.\" -*- coding: UTF-8 -*- .\" Copyright (c) 2013, 2014 by Michael Kerrisk .\" and Copyright (c) 2012, 2014 by Eric W. Biederman .\" .\" SPDX-License-Identifier: Linux-man-pages-copyleft .\" .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH user_namespaces 7 "15 juni 2024" "Linux man\-pages 6.9.1" .SH NAMN user_namespaces — översikt över Linux användarnamnrymder .SH BESKRIVNING För en översikt över namnrymder, se \fBnamespaces\fP(7). .P .\" FIXME: This page says very little about the interaction .\" of user namespaces and keys. Add something on this topic. .\" .\" ============================================================ .\" Användarnamnrymder isolerar säkerhetsrelaterade identifierare och attribut, mer exakt, användar\-ID:n och grupp\-ID:n (se \fBcredentials\fP(7)), rotkatalogen, nycklar (se \fBkeyring\fP(7)) och förmågor (se \fBcapabilities\fP(7)). En process användar\- och grupp\-ID:n kan vara olika inuti och utanför en användarnamnrymd. I synnerhet kan en process ha ett normalt oprivilegierat användar\-ID utanför en användarnamnrymd medan den på samma gång har användar\-ID:t 0 inuti namnrymden; med andra ord, processen har fullständiga rättigheter vid åtgärder inuti användarnamnrymden, men är oprivilegierad vid åtgärder utanför namnrymden. .SS "Nästade namnrymder, medlemskap i namnrymder" Användarnamnrymder kan nästas; det vill säga, varje användarnamnrymd \[em] utom den initiala (”rot\-”)namnrymden \[em] har en föräldraanvändarnamnrymd, och kan ha noll eller flera barnanvändarnamnrymder. Föräldraanvändarnamnrymden är användarnamnrymden för processen som skapar användarnamnrymden via ett anrop av \fBunshare\fP(2) eller \fBclone\fP(2) med flaggan \fBCLONE_NEWUSER\fP. .P .\" commit 8742f229b635bf1c1c84a3dfe5e47c814c20b5c8 .\" FIXME Explain the rationale for this limit. (What is the rationale?) Kärnan lägger (från Linux 3.11) en gräns på 32 nästade nivåer med användarnamnrymder. Anrop av \fBunshare\fP(2) eller \fBclone\fP(2) som annars skulle orsaka att denna gräns överskrids misslyckas med felet \fBEUSERS\fP. .P Varje process är medlem i exakt en användarnamnrymd. En process som skapas via \fBfork\fP(2) eller \fBclone\fP(2) utan flaggan \fBCLONE_NEWUSER\fP är medlem av samma användarnamnrymd som sin förälder. En enkeltrådad process kan gå in i en annan användarnamnrymd med \fBsetns\fP(2) om den har \fBCAP_SYS_ADMIN\fP i den namnrymden; när den gör det får den en fullständig uppsättning av förmågor i den namnrymden. .P Ett anrop av \fBclone\fP(2) eller \fBunshare\fP(2) med flaggan \fBCLONE_NEWUSER\fP gör den nya barnprocessen (för \fBclone\fP(2)) eller anroparen (för \fBunshare\fP(2)) medlem av den nya användarnamnrymden som skapas av anropet. .P The \fBNS_GET_PARENT\fP \fBioctl\fP(2) operation can be used to discover the parental relationship between user namespaces; see \fBioctl_nsfs\fP(2). .P .\" .\" ============================================================ .\" En uppgift som ändrar ett av sina effektiva ID:n kommer ha sin dumpbarhet återställd till värdet i \fI/proc/sys/fs/suid_dumpable\fP. Detta kan påverka ägandet av proc\-filer för barnprocesser och kan alltså orsaka att föräldern kommer att sakna rättigheter att skriva till avbildningsfiler för barnprocesser som kör i en ny användarnamnrymd. I dessa fall kan man genom att göra processen dumpbar med \fBPR_SET_DUMPABLE\fP i ett anrop av \fBprctl\fP(2) före en barnprocess skapas i en ny användarnamnrymd åtgärda detta problem. Se \fBprctl\fP82) och \fBproc\fP(5) för detaljer om hur ägarskap påverkas. .SS Förmågor Barnprocesserna som skapas med \fBclone\fP(2) med flaggan \fBCLONE_NEWUSER\fP börjar med en fullständig uppsättning av förmågor i den nya användarnamnrymden. Likadant får en process som skapar en ny användarnamnrymd med \fBunshare\fP(2) eller går in i en befintlig användarnamnrymd med \fBsetns\fP(2) en fullständig uppsättning rättigheter i den namnrymden. Å andra sidan har den processen inga förmågor i förälderns (i fallet \fBclone\fP(2)) eller tidigare (i fallet \fBunshare\fP(2) och \fBsetns\fP(2)) användarnamnrymd, även om root\-anvädaren skapade eller gick in i den nya namnrymden (d.v.s., en process med användar\-ID 0 i rotnamnrymden). .P Observera att ett anrop av \fBexecve\fP(2) kommer göra att processens förmågor räknas om på det vanliga sättet (se \fBcapabilities\fP(7)). Alltså, om inte processen har användar\-ID 0 inom namnrymden, eller den körbara filen har en ärvbar förmågemask som inte är tom, kommer processen förlora alla förmågor. Se diskussionen om användar\- och grupp\-ID\-avbildningar nedan. .P Ett anrop av \fBclone\fP(2) eller \fBunshare\fP(2) med flaggan \fBCLONE_NEWUSER\fP eller ett anrop av \fBsetns\fP(2) som flyttar anroparen in i en annan användarnamnrymd sätter flaggorna ”securebits” (se \fBcapabilities\fP(7)) till sitt standardvärde (alla flaggor avslagna) i barnet (för \fBclone\fP(2)) eller anroparen (för \fBunshare\fP(2) eller \fBsetns\fP(2)). Observera att eftersom anroparen inte längre har förmågor i sin originalanvändarnamnrymd efter anropet av \fBsetns\fP(2) är det inte möjligt för en process att återställa sina flaggor ”securebits” medan den behåller sitt medlemskap i användarnamnrymden genom att använda ett par av anrop av \fBsetns\fP(2) för att flytta till en annan användarnamnrymd och sedan återvända till sin originalanvändarnamnrymd. .P Reglerna för att avgöra huruvida en process har en förmåga eller inte i en viss användarnamnrymd är som följer: .IP \[bu] 3 .\" In the 3.8 sources, see security/commoncap.c::cap_capable(): En process har en förmåga inuti en användarnamnrymd om den är medlem av den namnrymden och den har förmågan i sin effektiva förmågemängd. En process kan få förmågor i sin effektiva förmågemängd på olika sätt. Till exempel kan den köra ett sätt\-användar\-ID\-program eller en körbar fil associerad med filförmågor. Dessutom kan en process få förmågor via effekten av \fBclone\fP(2), \fBunshare\fP(2) eller \fBsetns\fP(2), som redan beskrivits. .IP \[bu] Om en process har en förmåga i en användarnamnrymd, då har den den förmågan i alla barn\- (och mer avlägsna avkomme\-)namnrymder också. .IP \[bu] .\" * The owner of the user namespace in the parent of the .\" * user namespace has all caps. .\" (and likewise associates the effective group ID of the creating process .\" with the namespace). .\" See kernel commit 520d9eabce18edfef76a60b7b839d54facafe1f9 for a fix .\" on this point .\" This includes the case where the process executes a set-user-ID .\" program that confers the effective UID of the creator of the namespace. .\" .\" ============================================================ .\" When a user namespace is created, the kernel records the effective user ID of the creating process as being the "owner" of the namespace. A process that resides in the parent of the user namespace and whose effective user ID matches the owner of the namespace has all capabilities in the namespace. By virtue of the previous rule, this means that the process has all capabilities in all further removed descendant user namespaces as well. The \fBNS_GET_OWNER_UID\fP \fBioctl\fP(2) operation can be used to discover the user ID of the owner of the namespace; see \fBioctl_nsfs\fP(2). .SS "Effekten av förmågor inom en användarnamnrymd" Att ha en förmåga inuti en användarnamnrymd tillåter en process att utföra åtgärder (som kräver privilegier) endast på resurser som styrs av den namnrymden. Med andra ord, att ha en förmåga i en användarnamnrymd tillåter en process att utföra privilegierade åtgärder på resurser som styrs av (icke användar\-)namnrymder som ägs av (är associerade med) användarnamnrymden (se nästa underavdelning). .P Däremot finns det många privilegierade åtgärder som påverkar resurser som inte är associerade med någon namnrymdstyp, till exempel, att ändra systemtiden (d.v.s., kalendertiden) (som styrs av \fBCAP_SYS_TIME\fP), att ladda kärnmoduler (som styrs av \fBCAP_SYS_MODULE\fP) och att skapa en enhet (som styrs av \fBCAP_MKNOD\fP). Endast en process med privilegier i den \fIinitiala\fP användarnamnrymden kan utföra sådana åtgärder. .P .\" fs_flags = FS_USERNS_MOUNT in kernel sources Att hålla \fBCAP_SYS_ADMIN\fP inom användarnamnrymden som äger en process monteringsnamnrymd gör att den processen kan skapa bindmonteringar och montera följande typer av filsystem: .P .RS 4 .PD 0 .IP \[bu] 3 \fI/proc\fP (från Linux 3.8) .IP \[bu] \fI/sys\fP (från Linux 3.8) .IP \[bu] \fIdevpts\fP (från Linux 3.9) .IP \[bu] \fBtmpfs\fP(5) (från Linux 3.9) .IP \[bu] \fIramfs\fP (från Linux 3.9) .IP \[bu] \fImqueue\fP (från Linux 3.9) .IP \[bu] .\" commit b2197755b2633e164a439682fb05a9b5ea48f706 \fIbpf\fP (från Linux 4.4) .IP \[bu] .\" commit 92dbc9dedccb9759c7f9f2f0ae6242396376988f .\" commit 4cb2c00c43b3fe88b32f29df4f76da1b92c33224 \fIoverlayfs\fP (från Linux 5.11) .PD .RE .P Att hålla \fBCAP_SYS_ADMIN\fP inom användarnamnrymden som äger en process cgroup\-namnrymd gör (från Linux 4.6) att den processen kan montera filsystemet cgroup version 2 och namngivna hierarkier av filsystemet cgroup verson 1 (d.v.s., cgroup\-filsystem monterade med flaggan \fI\[dq]none,name=\[dq]\fP). .P Att hålla \fBCAP_SYS_ADMIN\fP inom användarnamnrymden som äger en process PID\-namnrymd gör (från Linux 3.8) att den processen kan montera filsystemet \fI/proc\fP. .P .\" .\" ============================================================ .\" Observera dock att montering av blockbaserade filsystem endast kan göras av en process som håller \fBCAP_SYS_ADMIN\fP i den initiala användarnamnrymden. .SS "Interaktion mellan användarnamnrymder och andra typer av namnrymder" Med början från Linux 3.8 kan oprivilegierade processer skapa användarnamnrymder, och de andra typerna av namnrymder kan skapas med bara förmågan \fBCAP_SYS_ADMIN\fP i anroparens användarnamnrymd. .P När en annan namnrymd än en användarnamnrymd skapas ägs den av användarnamnrymden processen som skapade den var en medlem i vid tidpunkten då namnrymden skapades. Privilegierade åtgärder på resurser som styrs av en icke\-användarnamnrymd kräver att processen har de nödvändiga förmågorna i användarnamnrymden som äger den icke\-användarnamnrymden. .P Om \fBCLONE_NEWUSER\fP anges tillsammans med andra flaggor \fBCLONE_NEW*\fP i ett enskilt anrop av \fBclone\fP(2) eller \fBunshare\fP(2) garanteras det att användarnamnrymden skapas först vilket ger barnet (\fBclone\fP(2)) eller anroparen (\fBunshare\fP(2)) privilegier över de andra namnrymderna som skapas av anropet. Det är alltså möjligt för en oprivilegierad anropare att ange denna kombination av flaggor. .P När en ny namnrymd (annan än en användarnamnrymd) skapas via \fBclone\fP(2) eller \fBunshare\fP(2) registrerar kärnan användarnamnrymden för processen som skapar den som ägare till den nya namnrymden. (Denna koppling kan inte ändras.) När en process i den nya namnrymden senare utför privilegierade åtgärder som verkar på globala resurser isolerade av namnrymden utförs rättighetskontrollerna enligt processens förmågor i användarnamnrymden som kärnan associerade med den nya namnrymden. Till exempel, antag att en process försöker ändra värdnamnet (\fBsethostname\fP(2)), en resurs som styrs av UTS\-namnrymden. I detta fall kommer kärnan avgöra vilken användarnamnrymd som äger processens UTS\-namnrymd, och kontrollera huruvida processen har den nödvändiga förmågan (\fBCAP_SYS_ADMIN\fP) i den användarnamnrymden. .P .\" .\" ============================================================ .\" The \fBNS_GET_USERNS\fP \fBioctl\fP(2) operation can be used to discover the user namespace that owns a nonuser namespace; see \fBioctl_nsfs\fP(2). .SS "Användar\- och grupp\-ID\-avbildningar: uid_map och gid_map" .\" commit 22d917d80e842829d0ca0a561967d728eb1d6303 När en användarnamnrymd skapas börjar den utan någon avbildning av användar\-ID:n (grupp\-ID:n) till förälderns användarnamnrymd. Filerna \fI/proc/\fPpid\fI/uid_map\fP och \fI/proc/\fPpid\fI/gid_map\fP (tillgängliga från Linux 3.5) visar avbildningarna för användar\- och grupp\-ID:n inuti användarnamnrymden för processen \fIpid\fP. Dessa filer kan läsas för att visa avbildningarna i en användarnamnrymd och skrivas till (en gång) för att definiera avbildningarna. .P Beskrivningen i följande stycken förklarar detaljerna för \fIuid_map\fP; \fIgid_map\fP är exakt likadan, med varje förekomst av ”användar\-ID” ersatt med ”grupp\-ID”. .P Filen \fIuid_map\fP visar avbildningen av användar\-ID:n från användarnamnrymden för processen som öppnade \fIuid_map\fP (men se en avvikelse från denna punkt nedan). Med andra ord kan potentiellt processer som finns i olika användarnamnrymder se olika värden när de läser från en viss \fIuid_map\fP\-fil, beroende på användar\-ID\-avbildningarna för användarnamnrymderna för de läsande processerna. .P Varje rad i filen \fIuid_map\fP anger en 1\-till\-1\-avbildning av ett intervall av sammanhängande användar\-ID:n mellan två användarnamnrymder. (När en användarnamnrymd först skapas är denna fil tom.) Specifikationen på varje rad har formen tre tal avgränsade av mellanslag. De första två talen anger det första användar\-ID:t i vardera av de två användarnamnrymderna. Det tredje talet anger längden på det avbildade intervallet. Mer exakt tolkas fälten som följer: .IP (1) 5 Början av intervallet av användar\-ID:n i processen \fIpid\fPs användarnamnrymd. .IP (2) Början på intervallet av användar\-ID:n till vilka användar\-ID:n som anges av fält ett avbildas. Hur fält två tolkas beror på huruvida processen som öppnade \fIuid_map\fP och processen \fIpid\fP finns i samma användarnamnrymd, som följer: .RS .IP (a) 5 Om de två processerna finns i olika användarnamnrymder: fält två är början på ett intervall av användar\-ID:n i användarnamnrymden för processen som öppnade \fIuid_map\fP. .IP (b) Om de två processerna finns i samma användarnamnrymd: fält två är början på intervallet av användar\-ID:n i process \fIpid\fPs föräldraanvändarnamnrymd. Detta gör att den som öppnar \fIuid_map\fP (det vanliga fallet här är att öppna \fI/proc/self/uid_map\fP) kan se avbildningen av användar\-ID:n in i användarnamnrymden för processen som skapade denna användarnamnrymd. .RE .IP (3) Längden på intervallet av användar\-ID:n som avbildas mellan de två användarnamnrymderna. .P Systemanrop som returnerar användar\-ID:n (grupp\-ID:n) \[em] till exempel \fBgetuid\fP(2), \fBgetgid\fP(2), och kreditivfälten i posten som returneras av \fBstat\fP(2) \[em] returnerar användar\-ID:t (grupp\-ID:t) avbildat in i anroparens användarnamnrymd. .P När en process begär tillgång till en fil avbildas dess användar\- och grupp\-ID:n in i den initiala användarnamnrymden i syfte att kontrollera rättigheterna och tilldela ID:n när en fil skapas. När en process hämtar filens användar\- och grupp\-ID:n via \fBstat\fP(2) avbildas ID:erna i den andra riktningen, för att skapa värden relativt processens användar\- och grupp\-ID\-avbildningar. .P Den initiala användarnamnrymden har ingen föräldranamnrymd, men för konsistensens skull tillhandahåller kärnan tomfiler för användar\- och grupp\-ID\-avbildningar för den namnrymden. Tittar man på filen \fIuid_map\fP (\fIgid_map\fP är likadan) från ett skal i den initiala namnrymden ser man: .P .in +4n .EX $ \fBcat /proc/$$/uid_map\fP 0 0 4294967295 .EE .in .P .\" .\" ============================================================ .\" This mapping tells us that the range starting at user ID 0 in this namespace maps to a range starting at 0 in the (nonexistent) parent namespace, and the length of the range is the largest 32\-bit unsigned integer. This leaves 4294967295 (the 32\-bit signed \-1 value) unmapped. This is deliberate: \fI(uid_t)\ \-1\fP is used in several interfaces (e.g., \fBsetreuid\fP(2)) as a way to specify "no user ID". Leaving \fI(uid_t)\ \-1\fP unmapped and unusable guarantees that there will be no confusion when using these interfaces. .SS "Att definiera användar\- och grupp\-ID\-avbildningar: att skriva till uid_map och gid_map" Efter att en ny användarnamnrymd skapats kan filen \fIuid_map\fP för \fIen\fP av processerna i namnrymden skrivas till \fIen gång\fP för att definiera avbildningen av användar\-ID:n i den nya användarnamnrymden. Ett försök att skriva mer än en gång till en \fIuid_map\fP\-fil i en användarnamnrymd misslyckas med felet \fBEPERM\fP. Motsvarande regler gäller för \fIgid_map\fP\-filer. .P Raderna som skrivs till \fIuid_map\fP (\fIgid_map\fP) måste lyda följande giltighetsregler: .IP \[bu] 3 De tre fälten måste vara giltiga tal, och det sista fältet måste vara större än 0. .IP \[bu] Rader avslutas av nyradstecken. .IP \[bu] .\" 5*12-byte records could fit in a 64B cache line .\" commit 6397fac4915ab3002dc15aae751455da1a852f25 Det finns en gräns på antalet rader i filen. I Linux 4.14 och tidigare sattes denna gräns (godtyckligt) till 5 rader. Från Linux 4.15 är gränsen 340 rader. Dessutom måste antalet byte som skrivs till filen vara mindre än systemets sidstorlek, och skrivningen måste göras från början av filen (d.v.s., \fBlseek\fP(2) och \fBpwrite\fP(2) kan inte användas för att skriva till nollskilda avstånd in i filen). .IP \[bu] .\" commit 0bd14b4fd72afd5df41e9fd59f356740f22fceba Intervallet av användar\-ID:n (grupp\-ID:n) som anges på varje rad får inte överlappa med intervallerna på några andra rader. I den ursprungliga implementationen (Linux 3.8) uppfylldes detta krav av en enkel implementation som lade till det ytterligare kravet att värdena i både fält 1 och fält 2 av följande rader måste vara i stigande numerisk ordning, vilket förhindrade några eljest giltiga avbildningar från att skapas. Linux 3.9 och senare fixar denna begränsning, och tillåter alla giltiga uppsättningar av avbildningar som inte överlappar. .IP \[bu] Åtminstone en rad måste skrivas till filen. .P Skrivningar som bryter mot ovanstående regler misslyckas med felet \fBEINVAL\fP. .P För att en process skall kunna skriva till filen \fI/proc\fPpid\fI/uid_map\fP (\fI/proc\fPpid\fI/gid_map\fP) måste alla följande rättighetskrav vara uppfyllda: .IP \[bu] 3 Den skrivande processen måste ha förmågan \fBCAP_SETUID\fP (\fBCAP_SETGID\fP) i processen \fIpid\fPs användarnamnrymd. .IP \[bu] Den skrivande processen måste antingen finnas i namnrymden för process \fIpid\fP eller finnas i föräldraanvändarnamnrymden till process \fIpid\fP. .IP \[bu] De avbildade användar\-ID:na (grupp\-ID:na) måste i sin tur ha en avbildning i föräldraanvändarnamnrymden. .IP \[bu] Om man uppdaterar \fI/proc/\fPpid\fI/uid_map\fP för att skapa en avbildning som avbildar till UID 0 i föräldranamnrymden måste en av de följande vara sann: .RS .IP (a) 5 om den skrivande processen finns i föräldraanvändarnamnrymden, då måste den ha förmågan \fBCAP_SETFCAP\fP i den användarnamnrymden; eller .IP (b) om den skrivande processen finns i barnanvändarnamnrymden, då måste processen som skapade användarnamnrymden ha haft förmågan \fBCAP_SETFCAP\fP när namnrymden skapades. .RE .IP .\" commit db2e718a47984b9d71ed890eb2ea36ecf150de18 Denna regel har funnits från Linux 5.12. Den eliminerar en tidigare säkerhetsbrist varigenom en UID 0\-process som saknar förmågan \fBCAP_SETFCAP\fP vilken behövs för att skapa en binär med namnrymdsfilförmågor (så som det beskrivs i \fBcapabilities\fP(7)) ändå kunde skapa en sådan binär genom följande steg: .RS .IP (1) 5 Skapa en ny användarnamnrymd med identitetsavbildningen (d.v.s., AID 0 i den nya användarnamnrymden avbildas på AID 0 i föräldranamnrymden), så att AID 0 båda namnrymderna är ekvivalent med samma root\-användar\-ID. .IP (2) Eftersom barnprocessen har förmågan \fBCAP_SETFCAP\fP kunde den skapa en binär med namnrymdsfilförmågor som sedan skulle vara verkningsfulla i föräldranamnrymden (eftersom root\-användar\-ID:t är desamma i de två namnrymderna). .RE .IP \[bu] En av följande två fall gäller: .RS .IP (a) 5 \fIAntingen\fP har den skrivande processen förmågan \fBCAP_SETUID\fP (\fBCAP_SETGID\fP) i \fIföräldra\fPanvändarnamnrymden. .RS .IP \[bu] 3 Inga ytterligare begränsningar gäller: processen kan göra avbildningar till godtyckliga användar\-ID:n (grupp\-ID:n) i föräldraanvändarnamnrymden. .RE .IP (b) \fIEller\fP i annat fall gäller alla följande beskrivningar: .RS .IP \[bu] 3 Data som skrivs till \fIuid_map\fP (\fIgid_map\fP) måste bestå av en enda rad som avbildar den skrivande processens effektiva användar\-ID (grupp\-ID) i föräldraanvändarnamnrymden till ett användar\-ID (grupp\-ID) i användarnamnrymden. .IP \[bu] Den skrivande processen måste ha samma effektiva användar\-ID som processen som skapade användarnamnrymden. .IP \[bu] När det gäller \fIgid_map\fP måste först användning av systemanropet \fBsetgroups\fP(2) nekas genom att skriva \[dq]\fIdeny\fP\[dq] till filen \fI/proc/\fPpid\fI/setgroups\fP (se nedan) före någon skrivning till \fIgid_map\fP. .RE .RE .P .\" .\" ============================================================ .\" Skrivningar som strider mot ovanstående regler misslyckas med felet \fBEPERM\fP. .SS "Projekt\-ID\-avbildningar: projid_map" Liksom för användar\- och grupp\-ID\-avbildningar är det möjligt att skapa projekt\-ID\-avbildningar för användarnamnrymder. (Projekt\-ID:n används för diskkvoter; se \fBsetquota\fP(8) och \fBquotactl\fP(2).) .P .\" commit f76d207a66c3a53defea67e7d36c3eb1b7d6d61d Projekt\-ID\-avbildningar definieras genom att skriva till filen \fI/proc/\fPpid\fI/projid_map\fP (som finns från Linux 3.7). .P Giltighetsreglerna för att skriva till filen \fI/proc/\fPpid\fI/projid_map\fP är som för att skriva till filen \fIuid_map\fP; brott mot dessa regler får \fBwrite\fP(2) att misslyckas med felet \fBEINVAL\fP. .P Rättighetsreglerna för att skriva till filen \fI/proc/\fPpid\fI/projid_map\fP är som följer: .IP \[bu] 3 Den skrivande processen måste antingen finnas i namnrymden för process \fIpid\fP eller finnas i föräldraanvändarnamnrymden till process \fIpid\fP. .IP \[bu] De avbildade projekt\-ID:na måste i sin tur ha en avbildning i föräldraanvändarnamnrymden. .P .\" .\" ============================================================ .\" Brott mot dessa regler får \fBwrite\fP(2) att misslyckas med felet \fBEPERM\fP. .SS "Interaktion med systemanrop som ändrar process\-AID:n eller \-GID:n" I en användarnamnrymd där filen \fIuid_map\fP inte har skrivits kommer systemanrop som ändrar användar\-ID:n att misslyckas. På liknande sätt, om filen \fIgid_map\fP inte har skrivits kommer systemanrop som ändrar grupp\-ID:n att misslyckas. Efter att filerna \fIuid_map\fP och \fIgid_map\fP har skrivits kan endast de avbildade värdena användas i systemanrop som ändrar användar\- och grupp\-ID:n. .P För användar\-ID:n inkluderar de relevanta systemanropen \fBsetuid\fP(2), \fBsetfsuid\fP(2), \fBsetreuid\fP(2) och \fBsetresuid\fP(2). För grupp\-ID:n inkluderar de relevanta systemanropen \fBsetgid\fP(2), \fBsetfsgid\fP(2), \fBsetregid\fP(2), \fBsetresgid\fP(2) och \fBsetgroups\fP(2). .P .\" Things changed in Linux 3.19 .\" commit 9cc46516ddf497ea16e8d7cb986ae03a0f6b92f8 .\" commit 66d2f338ee4c449396b6f99f5e75cd18eb6df272 .\" http://lwn.net/Articles/626665/ .\" .\" ============================================================ .\" Att skriva \[dq]\fIdeny\fP\[dq] till filen \fI/proc/\fPpid\fI/setgroups\fP före man skriver till \fI/proc/\fPpid\fI/gid_map\fP kommer permanent avaktivera \fBsetgroups\fP(2) i en användarnamnrymd och tillåta att man skriver till \fI/proc/\fPpid\fI/gid_map\fP utan att ha förmågan \fBCAP_SETGID\fP i föräldraanvändarnamnrymden. .SS "Filen \fI/proc/\fPpid\fI/setgroups\fP" .\" .\" commit 9cc46516ddf497ea16e8d7cb986ae03a0f6b92f8 .\" commit 66d2f338ee4c449396b6f99f5e75cd18eb6df272 .\" http://lwn.net/Articles/626665/ .\" http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-8989 .\" Filen \fI/proc/\fPpid\fI/setgroups\fP visar strängen \[dq]\fIallow\fP\[dq] om processer i användarnamnrymden som innehåller process \fIpid\fP får lov att använda systemanropet \fBsetgroups\fP(2); den visar \[dq]\fIdeny\fP\[dq] om \fBsetgroups\fP(2) inte tillåts i den användarnamnrymden. Observera att oavsett värdet i filen \fI/proc/\fPpid\fI/setgroups\fP (och oavsett processens förmågor) är inte heller \fBsetgroups\fP(2) tillåtet om inte \fI/proc/\fPpid\fI/gid_map\fP har satts ännu. .P En privilegierad process (en med förmågan \fBCAP_SYS_ADMIN\fP i namnrymden) kan skriva endera av strängarna \[dq]\fIallow\fP\[dq] eller \[dq]\fIdeny\fP\[dq] till denna fil \fIföre\fP den skriver en grupp\-ID\-avbildning för denna användarnamnrymd till filen \fI/proc/\fPpid\fI/gid_map\fP. Att skriva strängen \[dq]\fIdeny\fP\[dq] förhindrar alla processer i användarnamnrymden från att använda \fBsetgroups\fP(2). .P Essensen av begränsningarna som beskrivs i föregående stycke är att det är tillåtet att skriva till \fI/proc/\fPpid\fI/setgroups\fP endast så länge som anrop av \fBsetgroups\fP(2) är otillåtet för att \fI/proc/\fPpid\fI/gid_map\fP inte har satts. Detta säkerställer att en process inte kan gå över från ett tillstånd där \fBsetgroups\fP(2) är tillåtet till ett tillstånd där \fBsetgroups\fP(2) nekas; en process kan gå över endast från att \fBsetgroups\fP(2) är otillåtet till att \fBsetgroups\fP(2) är tillåtet. .P Standardvärdet i denna fil i den initiala användarnamnrymden är \[dq]\fIallow\fP\[dq]. .P När \fI/proc/\fPpid\fI/gid_map\fP har skrivits till (vilket har effekten av att aktivera \fBsetgroups\fP(2) i användarnamnrymden), är det inte längre möjligt att göra \fBsetgroups\fP(2) otillåtet genom att skriva \[dq]\fIdeny\fP\[dq] till \fI/proc/\fPpid\fI/setgroups\fP (skrivningen misslyckas med felet \fBEPERM\fP). .P En barnnamnrymd ärver inställningen av \fI/proc/\fPpid\fI/setgroups\fP från sin förälder. .P Om filen \fIsetgroups\fP har värdet \[dq]\fIdeny\fP\[dq], då kan inte senare systemanropet \fBsetgroups\fP(2) återaktiveras (genom att skriva \[dq]\fIallow\fP\[dq] till filen) i den användarnamnrymden. (Försök att göra så misslyckas med felet \fBEPERM\fP.) Denna begränsning propagerar ner till alla barnanvändarnamnrymder till denna användarnamnrymd. .P .\" .\" /proc/PID/setgroups .\" [allow == setgroups() is allowed, "deny" == setgroups() is disallowed] .\" * Can write if have CAP_SYS_ADMIN in NS .\" * Must write BEFORE writing to /proc/PID/gid_map .\" .\" setgroups() .\" * Must already have written to gid_map .\" * /proc/PID/setgroups must be "allow" .\" .\" /proc/PID/gid_map -- writing .\" * Must already have written "deny" to /proc/PID/setgroups .\" .\" ============================================================ .\" Filen \fI/proc/\fPpid\fI/setgroups\fP lades till i Linux 3.19, men bakåtporterades till många tidigare stabila kärnserier, eftersom den åtgärdar ett säkerhetsproblem. Problemet rörde filer med rättigheter såsom ”rwx\-\-\-rwx”. Sådana filer ger färre rättigheter till ”gruppen” än de gör till ”övriga”. Detta betyder att genom att släppa grupper med \fBsetgroups\fP(2) kan en process tillåtas filåtkomst som den inte tidigare hade. Före det fanns användarnamnrymder var detta inte ett bekymmer, eftersom endast en privilegierad process (en med förmågan \fBCAP_SETGID\fP) kunde anropa \fBsetgroups\fP(2). Dock, med introduktionen av användarnamnrymder blev det möjligt för en oprivilegierad process att skapa en ny namnrymd i vilken användaren har alla privilegier. Detta tillät sedan tidigare oprivilegierade användare att släppa grupprivilegier och därmed få filåtkomst som de inte tidigare hade. Filen \fI/proc/\fPpid\fI/setgroups\fP lades till för att åtgärda detta säkerhetsproblem, genom att neka alla vägar för en oprivilegierad process att släppa grupper med \fBsetgroups\fP(2). .SS "Oavbildade användar\- och grupp\-ID:n" .\" from_kuid_munged(), from_kgid_munged() Det finns olika platser där ett oavbildat användar\-ID (grupp\-ID) kan exponeras för användarrymden. Till exempel kan den första processen i en ny användarnamnrymd anropa \fBgetuid\fP(2) innan en användar\-ID\-avbildning har definierats för namnrymden. I de flesta sådana fall konverteras ett oavbildat användar\-ID till spillanvändar\-ID:t (grupp\-ID:t); standardvärdet på spillanvändar\-ID:t (grupp\-ID:t) 65534). Se beskrivningarna av \fI/proc/sys/kernel/overflowuid\fP och \fI/proc/sys/kernel/overflowgid\fP i \fBproc\fP(5). .P .\" also SO_PEERCRED Fallen där oavbildade ID:n avbildas på detta sätt inkluderar systemanrop som returnerar användar\-ID:n (\fBgetuid\fP(2), \fBgetgid\fP(2) och liknande), kreditiv som skickas över ett UNIX\-domänsuttag, kreditiv som returneras av \fBstat\fP(2), \fBwaitid\fP(2) och System V IPC ”ctl”\-åtgärder \fBIPC_STAT\fP, kreditiv som exponeras av \fI/proc/\fPpid\fI/status\fP och filerna i \fI/proc/sysvipc/*\fP, kreditiv som returneras via fältet \fIsi_uid\fP i den \fIsiginfo_t\fP som tas emot med en signal (se \fBsigaction\fP(2)), kreditiv som skrivs till processbokföringsfilen (se \fBacct\fP(5)) och kreditiv som returneras via POSIX notifieringar i meddelandeköer (se \fBmq_notify\fP(3)). .P .\" from_kuid(), from_kgid() .\" Also F_GETOWNER_UIDS is an exception .\" .\" ============================================================ .\" Det finns ett nämnvärt fall där oavbildade användar\- och grupp\-ID:n \fIinte\fP konverteras till motsvarande spill\-ID\-värde. När man betraktar en fil \fIuid_map\fP eller \fIgid_map\fP i vilken det inte finns någon avbildning för det andra fältet visas det fältet som 4294967295 (\-1 som ett teckenlöst heltal). .SS "Åtkomst av filer" .\" .\" ============================================================ .\" För att avgöra rättigheterna när en oprivilegierad process söker tillgång till en fil avbildas processkreditiven (AID, GID) och de aktiva filkreditiven tillbaka till vad de skulle vara i den initiala användarnamnrymden och jämförs sedan för att avgöra rättigheterna som processen har till filen. Detsamma är också sant för andra objekt som använder åtkomstmodellen med kreditiv plus rättighetsmasker, såsom System V IPC\-objekt. .SS "Åtgärder med filrelaterade förmågor" Vissa förmågor tillåter en process att kringgå olika begränsningar som kärnan upprätthåller när den utför åtgärder på filer som ägs av andra användare eller grupper. Dessa förmågor är: \fBCAP_CHOWN\fP, \fBCAP_DAC_OVERRIDE\fP, \fBCAP_DAC_READ_SEARCH\fP, \fBCAP_FOWNER\fP och \fBCAP_FSETID\fP. .P Inom en användarnamnrymd tillåter dessa förmågor en process att kringgå reglerna om processen har den relevanta förmågan över filen, vilket betyder: .IP \[bu] 3 processen har den relevanta effektiva förmågan i sin användarnamnrymd; och .IP \[bu] filens användar\-ID och grupp\-ID båda har giltiga avbildningar i användarnamnrymden. .P .\" These are the checks performed by the kernel function .\" inode_owner_or_capable(). There is one exception to the exception: .\" overriding the directory sticky permission bit requires that .\" the file has a valid mapping for both its UID and GID. .\" .\" ============================================================ .\" Förmågan \fBCAP_FOWNER\fP behandlas något speciellt: den tillåter en process att kringgå motsvarande regler så länge som åtminstone filens användar\-ID har en avbildning i användarnamnrymden (d.v.s., filens grupp\-ID behöver inte ha en giltig avbildning). .SS "Sätt\-användar\-ID\- och sätt\-grupp\-ID\-program" .\" .\" ============================================================ .\" När en process inuti en användarnamnrymd kör ett program som är sätt\-användar\-ID (sätt\-grupp\-ID) ändras processens effektiva användar\- (grupp\-)ID inuti namnrymden till det värde som är avbildat för filens användar\- (grupp\-)ID. Dock, om antingen filens användar\- \fIeller\fP grupp\-ID inte har någon avbildning inuti namnrymden ignoreras tyst biten sätt\-användar\-ID (sätt\-grupp\-ID): det nya programmet körs, men processens effektiva användar\- (grupp\-)ID lämnas orört. (Detta avspeglar semantiken hos att köra ett program med sätt\-användar\-ID eller sätt\-grupp\-ID som bor på ett filsystem som monterades med flaggan \fBMS_NOSUID\fP, såsom beskrivs i \fBmount\fP(2).) .SS Diverse .\" När en process användar\- och grupp\-ID:n skickas över ett UNIX\-domänsuttag till en process i en annan användarnamnrymd (se beskrivningen av \fBSCM_CREDENTIALS\fP i \fBunix\fP(7)) översätts de till de motsvarande värdena i enlighet med den mottagande processens användar\- och grupp\-ID\-avbildningar. .SH STANDARDER .\" Linux. .SH NOTERINGAR .\" .\" ============================================================ .\" Under åren har det funnits många funktioner som har lagts till till Linuxkärnan som har gjorts tillgängliga endast till privilegierade användare på grund av deras potential att förvirra sätt\-användar\-ID\-root\-program. I allmänhet blir det säkert att tillåta root\-användaren i en användarnamnrymd att använda dessa funktioner eftersom det är omöjligt, så länge man finns i en användarnamnrymd, att få fler privilegier än de som en användarnamnrymds root\-användare har. .SS "Global root" .\" .\" ============================================================ .\" Termen ”global root” används ibland som en kortform för användar\-ID 0 i den initiala användarnamnrymden. .SS Tillgänglighet Användning av användarnamnrymder kräver en kärna som är konfigurerad med alternativet \fBCONFIG_USER_NS\fP. Användarnamnrymder kräver stöd i ett antal undersystem i hela kärnan. När ett undersystem som inte stödjs konfigureras i kärnan är det inte möjligt att konfigurera stöd för användarnamnrymder. .P .\" commit d6970d4b726cea6d7a9bc4120814f95c09571fc3 .\" Fram till Linux 3.8 stödde de mest relevanta subsystemen användarnamnrymder, men ett antal filsystem hade inte den nödvändiga infrastrukturen för att avbilda användar\- och grupp\-ID:n mellan användarnamnrymder. Linux 3.9 lade till det nödvändiga infrastrukturstödet till många av de återstående ej stödda filsystemen (Plan 9 (9P), Andrew File System (AFS), Ceph, CIFS, CODA, NFS och OCFS2). Linux 3.12 lade till stöd till det sista av de ej stödda större filsystemen, XFS. .SH EXEMPEL Nedanstående program är skapat för att möjliggöra experimenterande med användarnamnrymder, liksom även andra typer av namnrymder. Det skapar namnrymder enligt specifikationen från kommandoradsflaggor och kör sedan ett kommando inuti dessa namnrymder. Kommentarerna och funktionen \fIusage\fP() inuti programmet ger den fullständiga förklaringen av programmet. Följande skalsession demonstrerar dess användning. .P Först betraktar vi körtidsmiljön: .P .in +4n .EX $ \fBuname \-rs\fP # Förutsätter Linux 3.8 eller senare Linux 3.8.0 $ \fBid \-u\fP # Kör som en oprivilegierad användare 1000 $ \fBid \-g\fP 1000 .EE .in .P Starta nu ett skal i en ny användar\- (\fI\-U\fP), monterings\- (\fI\-m\fP) och PID\- (\fI\-p\fP) namnrymd, med användar\-ID (\fI\-M\fP) och grupp\-ID (\fI\-G\fP) 1000 avbildade på 0 inuti användarnamnrymden: .P .in +4n .EX $ \fB./userns_child_exec \-p \-m \-U \-M \[aq]0 1000 1\[aq] \-G \[aq]0 1000 1\[aq] bash\fP .EE .in .P Skalet har PID 1, för att det är den första processen i den nya PID\-namnrymden. .P .in +4n .EX bash$ \fBecho $$\fP 1 .EE .in .P Att montera ett nytt \fI/proc\fP\-filsystem och lista alla processerna som är synliga i den nya PID\-namnrymden visar att skalet inte kan se några processer utanför PID\-namnrymden: .P .in +4n .EX bash$ \fBmount \-t proc proc /proc\fP bash$ \fBps ax\fP PID TTY STAT TIME COMMAND 1 pts/3 S 0:00 bash 22 pts/3 R+ 0:00 ps ax .EE .in .P Inuti användarnamnrymden har skalet användar\- och grupp\-ID 0, och den kompletta uppsättningen av tillåtna och effektiva förmågor: .P .in +4n .EX bash$ \fBcat /proc/$$/status | egrep \[aq]\[ha][UG]id\[aq]\fP Uid: 0 0 0 0 Gid: 0 0 0 0 bash$ \fBcat /proc/$$/status | egrep \[aq]\[ha]Cap(Prm|Inh|Eff)\[aq]\fP CapInh: 0000000000000000 CapPrm: 0000001fffffffff CapEff: 0000001fffffffff .EE .in .SS Programkällkod \& .EX /* userns_child_exec.c \& Licensed under GNU General Public License v2 or later \& Create a child process that executes a shell command in new namespace(s); allow UID and GID mappings to be specified when creating a user namespace. */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include \& struct child_args { char **argv; /* Command to be executed by child, with args */ int pipe_fd[2]; /* Pipe used to synchronize parent and child */ }; \& static int verbose; \& static void usage(char *pname) { fprintf(stderr, "Usage: %s [options] cmd [arg...]\[rs]n\[rs]n", pname); fprintf(stderr, "Create a child process that executes a shell " "command in a new user namespace,\[rs]n" "and possibly also other new namespace(s).\[rs]n\[rs]n"); fprintf(stderr, "Options can be:\[rs]n\[rs]n"); #define fpe(str) fprintf(stderr, " %s", str); fpe("\-i New IPC namespace\[rs]n"); fpe("\-m New mount namespace\[rs]n"); fpe("\-n New network namespace\[rs]n"); fpe("\-p New PID namespace\[rs]n"); fpe("\-u New UTS namespace\[rs]n"); fpe("\-U New user namespace\[rs]n"); fpe("\-M uid_map Specify UID map for user namespace\[rs]n"); fpe("\-G gid_map Specify GID map for user namespace\[rs]n"); fpe("\-z Map user\[aq]s UID and GID to 0 in user namespace\[rs]n"); fpe(" (equivalent to: \-M \[aq]0 1\[aq] \-G \[aq]0 1\[aq])\[rs]n"); fpe("\-v Display verbose messages\[rs]n"); fpe("\[rs]n"); fpe("If \-z, \-M, or \-G is specified, \-U is required.\[rs]n"); fpe("It is not permitted to specify both \-z and either \-M or \-G.\[rs]n"); fpe("\[rs]n"); fpe("Map strings for \-M and \-G consist of records of the form:\[rs]n"); fpe("\[rs]n"); fpe(" ID\-inside\-ns ID\-outside\-ns len\[rs]n"); fpe("\[rs]n"); fpe("A map string can contain multiple records, separated" " by commas;\[rs]n"); fpe("the commas are replaced by newlines before writing" " to map files.\[rs]n"); \& exit(EXIT_FAILURE); } \& /* Update the mapping file \[aq]map_file\[aq], with the value provided in \[aq]mapping\[aq], a string that defines a UID or GID mapping. A UID or GID mapping consists of one or more newline\-delimited records of the form: \& ID_inside\-ns ID\-outside\-ns length \& Requiring the user to supply a string that contains newlines is of course inconvenient for command\-line use. Thus, we permit the use of commas to delimit records in this string, and replace them with newlines before writing the string to the file. */ \& static void update_map(char *mapping, char *map_file) { int fd; size_t map_len; /* Length of \[aq]mapping\[aq] */ \& /* Replace commas in mapping string with newlines. */ \& map_len = strlen(mapping); for (size_t j = 0; j < map_len; j++) if (mapping[j] == \[aq],\[aq]) mapping[j] = \[aq]\[rs]n\[aq]; \& fd = open(map_file, O_RDWR); if (fd == \-1) { fprintf(stderr, "ERROR: open %s: %s\[rs]n", map_file, strerror(errno)); exit(EXIT_FAILURE); } \& if (write(fd, mapping, map_len) != map_len) { fprintf(stderr, "ERROR: write %s: %s\[rs]n", map_file, strerror(errno)); exit(EXIT_FAILURE); } \& close(fd); } \& /* Linux 3.19 made a change in the handling of setgroups(2) and the \[aq]gid_map\[aq] file to address a security issue. The issue allowed *unprivileged* users to employ user namespaces in order to drop groups. The upshot of the 3.19 changes is that in order to update the \[aq]gid_maps\[aq] file, use of the setgroups() system call in this user namespace must first be disabled by writing "deny" to one of the /proc/PID/setgroups files for this namespace. That is the purpose of the following function. */ \& static void proc_setgroups_write(pid_t child_pid, char *str) { char setgroups_path[PATH_MAX]; int fd; \& snprintf(setgroups_path, PATH_MAX, "/proc/%jd/setgroups", (intmax_t) child_pid); \& fd = open(setgroups_path, O_RDWR); if (fd == \-1) { \& /* We may be on a system that doesn\[aq]t support /proc/PID/setgroups. In that case, the file won\[aq]t exist, and the system won\[aq]t impose the restrictions that Linux 3.19 added. That\[aq]s fine: we don\[aq]t need to do anything in order to permit \[aq]gid_map\[aq] to be updated. \& However, if the error from open() was something other than the ENOENT error that is expected for that case, let the user know. */ \& if (errno != ENOENT) fprintf(stderr, "ERROR: open %s: %s\[rs]n", setgroups_path, strerror(errno)); return; } \& if (write(fd, str, strlen(str)) == \-1) fprintf(stderr, "ERROR: write %s: %s\[rs]n", setgroups_path, strerror(errno)); \& close(fd); } \& static int /* Start function for cloned child */ childFunc(void *arg) { struct child_args *args = arg; char ch; \& /* Wait until the parent has updated the UID and GID mappings. See the comment in main(). We wait for end of file on a pipe that will be closed by the parent process once it has updated the mappings. */ \& close(args\->pipe_fd[1]); /* Close our descriptor for the write end of the pipe so that we see EOF when parent closes its descriptor. */ if (read(args\->pipe_fd[0], &ch, 1) != 0) { fprintf(stderr, "Failure in child: read from pipe returned != 0\[rs]n"); exit(EXIT_FAILURE); } \& close(args\->pipe_fd[0]); \& /* Execute a shell command. */ \& printf("About to exec %s\[rs]n", args\->argv[0]); execvp(args\->argv[0], args\->argv); err(EXIT_FAILURE, "execvp"); } \& #define STACK_SIZE (1024 * 1024) \& static char child_stack[STACK_SIZE]; /* Space for child\[aq]s stack */ \& int main(int argc, char *argv[]) { int flags, opt, map_zero; pid_t child_pid; struct child_args args; char *uid_map, *gid_map; const int MAP_BUF_SIZE = 100; char map_buf[MAP_BUF_SIZE]; char map_path[PATH_MAX]; \& /* Parse command\-line options. The initial \[aq]+\[aq] character in the final getopt() argument prevents GNU\-style permutation of command\-line options. That\[aq]s useful, since sometimes the \[aq]command\[aq] to be executed by this program itself has command\-line options. We don\[aq]t want getopt() to treat those as options to this program. */ \& flags = 0; verbose = 0; gid_map = NULL; uid_map = NULL; map_zero = 0; while ((opt = getopt(argc, argv, "+imnpuUM:G:zv")) != \-1) { switch (opt) { case \[aq]i\[aq]: flags |= CLONE_NEWIPC; break; case \[aq]m\[aq]: flags |= CLONE_NEWNS; break; case \[aq]n\[aq]: flags |= CLONE_NEWNET; break; case \[aq]p\[aq]: flags |= CLONE_NEWPID; break; case \[aq]u\[aq]: flags |= CLONE_NEWUTS; break; case \[aq]v\[aq]: verbose = 1; break; case \[aq]z\[aq]: map_zero = 1; break; case \[aq]M\[aq]: uid_map = optarg; break; case \[aq]G\[aq]: gid_map = optarg; break; case \[aq]U\[aq]: flags |= CLONE_NEWUSER; break; default: usage(argv[0]); } } \& /* \-M or \-G without \-U is nonsensical */ \& if (((uid_map != NULL || gid_map != NULL || map_zero) && !(flags & CLONE_NEWUSER)) || (map_zero && (uid_map != NULL || gid_map != NULL))) usage(argv[0]); \& args.argv = &argv[optind]; \& /* We use a pipe to synchronize the parent and child, in order to ensure that the parent sets the UID and GID maps before the child calls execve(). This ensures that the child maintains its capabilities during the execve() in the common case where we want to map the child\[aq]s effective user ID to 0 in the new user namespace. Without this synchronization, the child would lose its capabilities if it performed an execve() with nonzero user IDs (see the capabilities(7) man page for details of the transformation of a process\[aq]s capabilities during execve()). */ \& if (pipe(args.pipe_fd) == \-1) err(EXIT_FAILURE, "pipe"); \& /* Create the child in new namespace(s). */ \& child_pid = clone(childFunc, child_stack + STACK_SIZE, flags | SIGCHLD, &args); if (child_pid == \-1) err(EXIT_FAILURE, "clone"); \& /* Parent falls through to here. */ \& if (verbose) printf("%s: PID of child created by clone() is %jd\[rs]n", argv[0], (intmax_t) child_pid); \& /* Update the UID and GID maps in the child. */ \& if (uid_map != NULL || map_zero) { snprintf(map_path, PATH_MAX, "/proc/%jd/uid_map", (intmax_t) child_pid); if (map_zero) { snprintf(map_buf, MAP_BUF_SIZE, "0 %jd 1", (intmax_t) getuid()); uid_map = map_buf; } update_map(uid_map, map_path); } \& if (gid_map != NULL || map_zero) { proc_setgroups_write(child_pid, "deny"); \& snprintf(map_path, PATH_MAX, "/proc/%jd/gid_map", (intmax_t) child_pid); if (map_zero) { snprintf(map_buf, MAP_BUF_SIZE, "0 %ld 1", (intmax_t) getgid()); gid_map = map_buf; } update_map(gid_map, map_path); } \& /* Close the write end of the pipe, to signal to the child that we have updated the UID and GID maps. */ \& close(args.pipe_fd[1]); \& if (waitpid(child_pid, NULL, 0) == \-1) /* Wait for child */ err(EXIT_FAILURE, "waitpid"); \& if (verbose) printf("%s: terminating\[rs]n", argv[0]); \& exit(EXIT_SUCCESS); } .EE .SH "SE ÄVEN" .\" From the shadow package .\" From the shadow package .\" From the shadow package .\" From the shadow package \fBnewgidmap\fP(1), \fBnewuidmap\fP(1), \fBclone\fP(2), \fBptrace\fP(2), \fBsetns\fP(2), \fBunshare\fP(2), \fBproc\fP(5), \fBsubgid\fP(5), \fBsubuid\fP(5), \fBcapabilities\fP(7), \fBcgroup_namespaces\fP(7), \fBcredentials\fP(7), \fBnamespaces\fP(7), \fBpid_namespaces\fP(7) .P Kärnans källfil \fIDocumentation/admin\-guide/namespaces/resource\-control.rst\fP. .PP .SH ÖVERSÄTTNING Den svenska översättningen av denna manualsida skapades av Göran Uddeborg . .PP Denna översättning är fri dokumentation; läs .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License Version 3 .UE eller senare för upphovsrättsvillkor. Vi tar INGET ANSVAR. .PP Om du hittar fel i översättningen av denna manualsida, skicka ett mail till .MT Tp-sv@listor.tp-sv.se .ME .