Förstå funktioner i Linux-systemprogrammering

Funktioner tillåter utvärdering av några viktiga systemprivilegier i en separat tråd som skiljer sig från den nuvarande processen. På så sätt behöver du inte köra ett program som root för att det ska komma åt vissa delar av systemet.

Som en lösning som härrör från behov handlar avsnitt 25 i POSIX.1e om denna fråga. Utvecklingen av de privilegier som definieras i det avsnittet och mer har slutförts med lanseringen av Linux-kärnversion 2.6.26. Här är allt du behöver veta om funktioner i Linux-kärnan.

Förstå Capabilities API-logiken

Auktoriseringskontroll i Unix-baserade system består av två steg:

• Om den nuvarande ägaren (effektivt användar-ID, EUID) av det program som körs är noll, kontrollerar inte systemet efter auktorisering
• Om EUID-värdet skiljer sig från noll, utför systemet kontrollprocessen i linje med behörigheterna från den effektiva användaren och gruppen för den relevanta applikationen

Vissa applikationer måste ha bredare behörigheter (SUID, SGIT-bitar) när de körs. Som det mest typiska exemplet kan du tänka dig

passwd-applikationen. Med detta kan användare i ett system ändra sina lösenord. Men att skriva till /etc/shadow fil, där de krypterade lösenorden förvaras, är det nödvändigt att arbeta med root-användarrättigheter (dvs användar-ID = 0).

För att lösa detta problem har passwd-applikationen en SUID-bit. Oavsett vilken användare som kör den här applikationen kommer den aktiva ägaren (EUID) alltid att vara root:

ls -l /usr/bin/passwd
# Utgång
-rwsr-xr-x. 1 rotrot 32552 23 juli 2021 /usr/bin/passwd

Möjligheten att köra SUID-applikationer i den traditionella Unix-autentiseringsmodellen verkar ha löst problemet. Men kritiska fel i applikationer med SUID-bitar öppnar dörren till att köra oönskade koder för användare med full auktoritet i systemet. En idealisk applikation ska kunna köras utan att behöva rotanvändarrättigheter om möjligt.

Problemet slutar inte med bara SUID-biten. Du måste också ha root-användarrättigheter när du vill lyssna på en privilegierad TCP- eller UDP-port mindre än 1024 på Unix-baserade system. För att till exempel kunna lyssna på TCP 80-porten på en webbserver måste du köra programmet som root-användare.

Under årens lopp har man förstått hur förödande det är att köra programvara som tillhandahåller service till nätverksmiljön med ett fullt auktoriserat användarkonto. Som en interimslösning antogs att endast en viss och mindre del av programmet lyssnar på den privilegierade porten som root, och ändrar sedan det aktiva användar-ID till en annan användare för efterföljande processer (till exempel ingen användare med begränsade rättigheter).

Detta system, som har använts i flera år, har fungerat bra med sin enkelhet och används fortfarande effektivt. Men nuförtiden är det möjligt att få några ytterligare funktioner, specifika för applikationen, via Linux capabilities API, utan behov av root-rättigheter, förutom de ovan nämnda systemet.

Linux-kapacitetsmodellen, förklarad!

Du kan hitta den mest omfattande implementeringen av Capabilities API i Linux-kärnan. Moderna Linux-distributioner försöker också använda denna nya modell i hela systemet så mycket som möjligt.

Till exempel, för att ping-applikationen ska fungera måste den kunna öppna RAW-sockets, som i allmänhet endast är reserverade för root-användare. I gamla Linux-distributioner är problemet att ge SUID-biten till applikationen så att vanliga användare kan använda den. I dessa versioner, när du tar bort SUID-biten från applikationen och försöker köra applikationen som en normal användare, får du följande felmeddelande:

ping 8.8.8.8
# Utgång
ping: icmp open socket: Drift ej tillåten

Medan på moderna Linux-distributioner har pingapplikationen förmodligen inte SUID-biten:

ls -l /bin/ping 
# Utgång
-rwxr-xr-x. 1 rotrot 95232 25 juli 2021 /bin/ping

Ändå kan du köra programmet framgångsrikt som en vanlig användare. Mekanismen som gör detta möjligt är att pingapplikationen har den speciella förmågan CAP_NET_RAW.

Du kan lära dig de ytterligare funktionerna i applikationen med getcap kommando enligt följande:

sudo getcap /bin/ping
# Utgång
/bin/ping cap_net_raw=ep

Om getcap-kommandot returnerar ett tomt svar kan du ställa in detta värde manuellt med:

sudo setcap cap_net_raw+ep /bin/ping

Processkapacitetsmodellen

I Linux-implementering är funktionerna för varje process grupperade under tre rubriker:

Listan över tillåtna, effektiva och ärftliga funktioner för att köra processer när som helst visas som bitmask på raderna CapPrm, CapEff, och CapInh i filen /proc//status. Dessutom har CapBnd linje innehåller bitmasken som används i funktionsgränskontrolloperationen.

Försök till exempel att läsa värdena för din körande skalapplikation från /proc/self/status fil:

katt /proc/själv/status | grep Cap
# Utgång
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: 000001ffffffffff
CapAmb: 0000000000000000

Filkapacitetsmodellen i Linux

Funktionssystemet för filer beror på förutsättningen att dessa egenskaper kan lagras i det virtuella filsystemet (VFS) lagret. I likhet med processmodellen faller funktioner för filer under tre rubriker:

1. Tillåtet

Systemet bestämmer de tillåtna funktionerna för processen när motsvarande körbara körs i detta kluster.

2. Effektiv

Till skillnad från processkapacitetsmodellen lagrar denna rubrik endast en bit: aktiv eller inaktiv. Om biten är aktiv är de funktioner som definieras i den tillåtna listan för filen automatiskt överförs till den effektiva kapacitetslistan för den relevanta processen när denna fil körs och en process körs skapas. Om biten inte är aktiv utförs inte den automatiska överföringen av de tillåtna funktionerna på filen till den pågående processen.

Men om koden för den relevanta applikationen är integrerad med kapacitetssystemet, kan den aktivera behörigheterna i den tillåtna uppsättningen av filen med systemanrop. Huvudsyftet med detta beteende är att säkerställa att gamla applikationer som inte inkluderar kapacitet systemspecifika kod, kan utveckling på programvarukodnivå fungera med kapacitetssystemet utan behov av någon källkod ändringar.

Du kanske tror att bättre skrivna applikationer bara kommer att använda funktioner när det behövs. Om biten är aktiv blir alla funktioner i den tillåtna listan aktiva när applikationen startar.

3. Ärftlig

Liksom i processmodellen körs den aktuella filen och en process inträffar. Om en annan applikation körs inifrån processen efter det, ingår den i den tillåtna listan för den nya processen. Sammanfattningsvis indikerar det en lista över funktioner att ärva.

Funktionernas roll i ett Linux-system

När du kör en viss process som en vanlig användare har du inga privilegier. Som ett resultat kan du bara komma åt de partitioner som systemet tillåter för normala användare. Det främsta skälet bakom detta är att skärpa systemsäkerheten och genomföra sådana åtgärder.

Att tillåta alla användare att komma åt alla resurser kan skapa en allvarlig säkerhetsrisk. Det kommer att vara mycket lätt för människor som använder systemet i skadliga syften att utnyttja systemets sårbarheter. Linux-funktioner kommer väl till pass i sådana här frågor. Du kan enkelt stärka säkerheten för dina applikationer med funktioner API som drivs av kärnan.

Linux-funktioner är bara en av de frågor som måste övervägas för att göra mycket kraftfulla metoder som att dela root-användarens behörigheter, tilldela olika behörigheter till icke-privilegierade användare och vidta olika försiktighetsåtgärder om öppna portar i internettjänster med Linux-servrar.

Förbättra din Linux-serversäkerhet med dessa 7 härdningssteg

Läs Nästa