user_namespaces(7) Miscellaneous Information Manual user_namespaces(7) NAMN user_namespaces -- oversikt over Linux anvandarnamnrymder BESKRIVNING For en oversikt over namnrymder, se namespaces(7). Anvandarnamnrymder isolerar sakerhetsrelaterade identifierare och attribut, mer exakt, anvandar-ID:n och grupp-ID:n (se credentials(7)), rotkatalogen, nycklar (se keyring(7)) och formagor (se capabilities(7)). En process anvandar- och grupp-ID:n kan vara olika inuti och utanfor en anvandarnamnrymd. I synnerhet kan en process ha ett normalt oprivilegierat anvandar-ID utanfor en anvandarnamnrymd medan den pa samma gang har anvandar-ID:t 0 inuti namnrymden; med andra ord, processen har fullstandiga rattigheter vid atgarder inuti anvandarnamnrymden, men ar oprivilegierad vid atgarder utanfor namnrymden. Nastade namnrymder, medlemskap i namnrymder Anvandarnamnrymder kan nastas; det vill saga, varje anvandarnamnrymd -- utom den initiala ("rot-")namnrymden -- har en foraldraanvandarnamnrymd, och kan ha noll eller flera barnanvandarnamnrymder. Foraldraanvandarnamnrymden ar anvandarnamnrymden for processen som skapar anvandarnamnrymden via ett anrop av unshare(2) eller clone(2) med flaggan CLONE_NEWUSER. Karnan lagger (fran Linux 3.11) en grans pa 32 nastade nivaer med anvandarnamnrymder. Anrop av unshare(2) eller clone(2) som annars skulle orsaka att denna grans overskrids misslyckas med felet EUSERS. Varje process ar medlem i exakt en anvandarnamnrymd. En process som skapas via fork(2) eller clone(2) utan flaggan CLONE_NEWUSER ar medlem av samma anvandarnamnrymd som sin foralder. En enkeltradad process kan ga in i en annan anvandarnamnrymd med setns(2) om den har CAP_SYS_ADMIN i den namnrymden; nar den gor det far den en fullstandig uppsattning av formagor i den namnrymden. Ett anrop av clone(2) eller unshare(2) med flaggan CLONE_NEWUSER gor den nya barnprocessen (for clone(2)) eller anroparen (for unshare(2)) medlem av den nya anvandarnamnrymden som skapas av anropet. Atgarden NS_GET_PARENT till ioctl(2) kan anvandas for att upptacka foraldrarelationen mellan anvandarnamnrymder; se ioctl_ns(2). En uppgift som andrar ett av sina effektiva ID:n kommer ha sin dumpbarhet aterstalld till vardet i /proc/sys/fs/suid_dumpable. Detta kan paverka agandet av proc-filer for barnprocesser och kan alltsa orsaka att foraldern kommer att sakna rattigheter att skriva till avbildningsfiler for barnprocesser som kor i en ny anvandarnamnrymd. I dessa fall kan man genom att gora processen dumpbar med PR_SET_DUMPABLE i ett anrop av prctl(2) fore en barnprocess skapas i en ny anvandarnamnrymd atgarda detta problem. Se prctl82) och proc(5) for detaljer om hur agarskap paverkas. Formagor Barnprocesserna som skapas med clone(2) med flaggan CLONE_NEWUSER borjar med en fullstandig uppsattning av formagor i den nya anvandarnamnrymden. Likadant far en process som skapar en ny anvandarnamnrymd med unshare(2) eller gar in i en befintlig anvandarnamnrymd med setns(2) en fullstandig uppsattning rattigheter i den namnrymden. A andra sidan har den processen inga formagor i foralderns (i fallet clone(2)) eller tidigare (i fallet unshare(2) och setns(2)) anvandarnamnrymd, aven om root-anvadaren skapade eller gick in i den nya namnrymden (d.v.s., en process med anvandar-ID 0 i rotnamnrymden). Observera att ett anrop av execve(2) kommer gora att processens formagor raknas om pa det vanliga sattet (se capabilities(7)). Alltsa, om inte processen har anvandar-ID 0 inom namnrymden, eller den korbara filen har en arvbar formagemask som inte ar tom, kommer processen forlora alla formagor. Se diskussionen om anvandar- och grupp-ID-avbildningar nedan. Ett anrop av clone(2) eller unshare(2) med flaggan CLONE_NEWUSER eller ett anrop av setns(2) som flyttar anroparen in i en annan anvandarnamnrymd satter flaggorna "securebits" (se capabilities(7)) till sitt standardvarde (alla flaggor avslagna) i barnet (for clone(2)) eller anroparen (for unshare(2) eller setns(2)). Observera att eftersom anroparen inte langre har formagor i sin originalanvandarnamnrymd efter anropet av setns(2) ar det inte mojligt for en process att aterstalla sina flaggor "securebits" medan den behaller sitt medlemskap i anvandarnamnrymden genom att anvanda ett par av anrop av setns(2) for att flytta till en annan anvandarnamnrymd och sedan atervanda till sin originalanvandarnamnrymd. Reglerna for att avgora huruvida en process har en formaga eller inte i en viss anvandarnamnrymd ar som foljer: o En process har en formaga inuti en anvandarnamnrymd om den ar medlem av den namnrymden och den har formagan i sin effektiva formagemangd. En process kan fa formagor i sin effektiva formagemangd pa olika satt. Till exempel kan den kora ett satt-anvandar-ID-program eller en korbar fil associerad med filformagor. Dessutom kan en process fa formagor via effekten av clone(2), unshare(2) eller setns(2), som redan beskrivits. o Om en process har en formaga i en anvandarnamnrymd, da har den den formagan i alla barn- (och mer avlagsna avkomme-)namnrymder ocksa. o Nar en anvandarnamnrymd skapas sparar karnan det effektiva anvandar-ID:t for processen som skapar den som varandes "agaren" till namnrymden. En process som bor i foraldern till anvandarnamnrymden och vars effektiva anvandar-ID stammer med agaren till namnrymden har alla formagor i namnrymden. Tack vare foregaende regel har processen alla formagor i alla mer avlagsna avkommeanvandarnamnrymder ocksa. Atgarden NS_GET_OWNER_UID till ioctl(2) kan anvandas for att upptacka anvandar-ID for namnrymdens agare; se ioctl_ns(2). Effekten av formagor inom en anvandarnamnrymd Att ha en formaga inuti en anvandarnamnrymd tillater en process att utfora atgarder (som kraver privilegier) endast pa resurser som styrs av den namnrymden. Med andra ord, att ha en formaga i en anvandarnamnrymd tillater en process att utfora privilegierade atgarder pa resurser som styrs av (icke anvandar-)namnrymder som ags av (ar associerade med) anvandarnamnrymden (se nasta underavdelning). Daremot finns det manga privilegierade atgarder som paverkar resurser som inte ar associerade med nagon namnrymdstyp, till exempel, att andra systemtiden (d.v.s., kalendertiden) (som styrs av CAP_SYS_TIME), att ladda karnmoduler (som styrs av CAP_SYS_MODULE) och att skapa en enhet (som styrs av CAP_MKNOD). Endast en process med privilegier i den initiala anvandarnamnrymden kan utfora sadana atgarder. Att halla CAP_SYS_ADMIN inom anvandarnamnrymden som ager en process monteringsnamnrymd gor att den processen kan skapa bindmonteringar och montera foljande typer av filsystem: o /proc (fran Linux 3.8) o /sys (fran Linux 3.8) o devpts (fran Linux 3.9) o tmpfs(5) (fran Linux 3.9) o ramfs (fran Linux 3.9) o mqueue (fran Linux 3.9) o bpf (fran Linux 4.4) o overlayfs (fran Linux 5.11) Att halla CAP_SYS_ADMIN inom anvandarnamnrymden som ager en process cgroup-namnrymd gor (fran 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 "none,name="). Att halla CAP_SYS_ADMIN inom anvandarnamnrymden som ager en process PID-namnrymd gor (fran Linux 3.8) att den processen kan montera filsystemet /proc. Observera dock att montering av blockbaserade filsystem endast kan goras av en process som haller CAP_SYS_ADMIN i den initiala anvandarnamnrymden. Interaktion mellan anvandarnamnrymder och andra typer av namnrymder Med borjan fran Linux 3.8 kan oprivilegierade processer skapa anvandarnamnrymder, och de andra typerna av namnrymder kan skapas med bara formagan CAP_SYS_ADMIN i anroparens anvandarnamnrymd. Nar en annan namnrymd an en anvandarnamnrymd skapas ags den av anvandarnamnrymden processen som skapade den var en medlem i vid tidpunkten da namnrymden skapades. Privilegierade atgarder pa resurser som styrs av en icke-anvandarnamnrymd kraver att processen har de nodvandiga formagorna i anvandarnamnrymden som ager den icke-anvandarnamnrymden. Om CLONE_NEWUSER anges tillsammans med andra flaggor CLONE_NEW* i ett enskilt anrop av clone(2) eller unshare(2) garanteras det att anvandarnamnrymden skapas forst vilket ger barnet (clone(2)) eller anroparen (unshare(2)) privilegier over de andra namnrymderna som skapas av anropet. Det ar alltsa mojligt for en oprivilegierad anropare att ange denna kombination av flaggor. Nar en ny namnrymd (annan an en anvandarnamnrymd) skapas via clone(2) eller unshare(2) registrerar karnan anvandarnamnrymden for processen som skapar den som agare till den nya namnrymden. (Denna koppling kan inte andras.) Nar en process i den nya namnrymden senare utfor privilegierade atgarder som verkar pa globala resurser isolerade av namnrymden utfors rattighetskontrollerna enligt processens formagor i anvandarnamnrymden som karnan associerade med den nya namnrymden. Till exempel, antag att en process forsoker andra vardnamnet (sethostname(2)), en resurs som styrs av UTS-namnrymden. I detta fall kommer karnan avgora vilken anvandarnamnrymd som ager processens UTS-namnrymd, och kontrollera huruvida processen har den nodvandiga formagan (CAP_SYS_ADMIN) i den anvandarnamnrymden. ioctl(2)-atgarden NS_GET_USERNS kan anvandas for att hitta anvandarnamnrymden som ager en icke-anvandarnamnrymd; se ioctl_ns(2). Anvandar- och grupp-ID-avbildningar: uid_map och gid_map Nar en anvandarnamnrymd skapas borjar den utan nagon avbildning av anvandar-ID:n (grupp-ID:n) till foralderns anvandarnamnrymd. Filerna /proc/pid/uid_map och /proc/pid/gid_map (tillgangliga fran Linux 3.5) visar avbildningarna for anvandar- och grupp-ID:n inuti anvandarnamnrymden for processen pid. Dessa filer kan lasas for att visa avbildningarna i en anvandarnamnrymd och skrivas till (en gang) for att definiera avbildningarna. Beskrivningen i foljande stycken forklarar detaljerna for uid_map; gid_map ar exakt likadan, med varje forekomst av "anvandar-ID" ersatt med "grupp-ID". Filen uid_map visar avbildningen av anvandar-ID:n fran anvandarnamnrymden for processen som oppnade uid_map (men se en avvikelse fran denna punkt nedan). Med andra ord kan potentiellt processer som finns i olika anvandarnamnrymder se olika varden nar de laser fran en viss uid_map-fil, beroende pa anvandar-ID-avbildningarna for anvandarnamnrymderna for de lasande processerna. Varje rad i filen uid_map anger en 1-till-1-avbildning av ett intervall av sammanhangande anvandar-ID:n mellan tva anvandarnamnrymder. (Nar en anvandarnamnrymd forst skapas ar denna fil tom.) Specifikationen pa varje rad har formen tre tal avgransade av mellanslag. De forsta tva talen anger det forsta anvandar-ID:t i vardera av de tva anvandarnamnrymderna. Det tredje talet anger langden pa det avbildade intervallet. Mer exakt tolkas falten som foljer: (1) Borjan av intervallet av anvandar-ID:n i processen pids anvandarnamnrymd. (2) Borjan pa intervallet av anvandar-ID:n till vilka anvandar-ID:n som anges av falt ett avbildas. Hur falt tva tolkas beror pa huruvida processen som oppnade uid_map och processen pid finns i samma anvandarnamnrymd, som foljer: (a) Om de tva processerna finns i olika anvandarnamnrymder: falt tva ar borjan pa ett intervall av anvandar-ID:n i anvandarnamnrymden for processen som oppnade uid_map. (b) Om de tva processerna finns i samma anvandarnamnrymd: falt tva ar borjan pa intervallet av anvandar-ID:n i process pids foraldraanvandarnamnrymd. Detta gor att den som oppnar uid_map (det vanliga fallet har ar att oppna /proc/self/uid_map) kan se avbildningen av anvandar-ID:n in i anvandarnamnrymden for processen som skapade denna anvandarnamnrymd. (3) Langden pa intervallet av anvandar-ID:n som avbildas mellan de tva anvandarnamnrymderna. Systemanrop som returnerar anvandar-ID:n (grupp-ID:n) -- till exempel getuid(2), getgid(2), och kreditivfalten i posten som returneras av stat(2) -- returnerar anvandar-ID:t (grupp-ID:t) avbildat in i anroparens anvandarnamnrymd. Nar en process begar tillgang till en fil avbildas dess anvandar- och grupp-ID:n in i den initiala anvandarnamnrymden i syfte att kontrollera rattigheterna och tilldela ID:n nar en fil skapas. Nar en process hamtar filens anvandar- och grupp-ID:n via stat(2) avbildas ID:erna i den andra riktningen, for att skapa varden relativt processens anvandar- och grupp-ID-avbildningar. Den initiala anvandarnamnrymden har ingen foraldranamnrymd, men for konsistensens skull tillhandahaller karnan tomfiler for anvandar- och grupp-ID-avbildningar for den namnrymden. Tittar man pa filen uid_map (gid_map ar likadan) fran ett skal i den initiala namnrymden ser man: $ cat /proc/$$/uid_map 0 0 4294967295 Denna avbildning sager oss att intervallet som startar med anvandar-ID 0 i denna namnrymd oversatts till ett intervall som startar med 0 i den (obefintliga) foraldranamnrymden, och att langden pa intervallet ar det storsta 32-bitars teckenlosa heltalet. Detta lamnar 4294967295 (32-bitsvardet -1) oavbildat. Detta ar avsiktligt: (uid_t) -1 anvands i flera granssnitt (t.ex., setreuid(2)) som ett satt att ange "inget anvandar-ID". Genom att lata (uid_t) -1 vara oavbildat och oanvandbart garanteras att det inte kommer uppsta nagon forvirring vid anvandning av dessa granssnitt. Att definiera anvandar- och grupp-ID-avbildningar: att skriva till uid_map och gid_map Efter att en ny anvandarnamnrymd skapats kan filen uid_map for en av processerna i namnrymden skrivas till en gang for att definiera avbildningen av anvandar-ID:n i den nya anvandarnamnrymden. Ett forsok att skriva mer an en gang till en uid_map-fil i en anvandarnamnrymd misslyckas med felet EPERM. Motsvarande regler galler for gid_map-filer. Raderna som skrivs till uid_map (gid_map) maste lyda foljande giltighetsregler: o De tre falten maste vara giltiga tal, och det sista faltet maste vara storre an 0. o Rader avslutas av nyradstecken. o Det finns en grans pa antalet rader i filen. I Linux 4.14 och tidigare sattes denna grans (godtyckligt) till 5 rader. Fran Linux 4.15 ar gransen 340 rader. Dessutom maste antalet byte som skrivs till filen vara mindre an systemets sidstorlek, och skrivningen maste goras fran borjan av filen (d.v.s., lseek(2) och pwrite(2) kan inte anvandas for att skriva till nollskilda avstand in i filen). o Intervallet av anvandar-ID:n (grupp-ID:n) som anges pa varje rad far inte overlappa med intervallerna pa nagra andra rader. I den ursprungliga implementationen (Linux 3.8) uppfylldes detta krav av en enkel implementation som lade till det ytterligare kravet att vardena i bade falt 1 och falt 2 av foljande rader maste vara i stigande numerisk ordning, vilket forhindrade nagra eljest giltiga avbildningar fran att skapas. Linux 3.9 och senare fixar denna begransning, och tillater alla giltiga uppsattningar av avbildningar som inte overlappar. o Atminstone en rad maste skrivas till filen. Skrivningar som bryter mot ovanstaende regler misslyckas med felet EINVAL. For att en process skall kunna skriva till filen /procpid/uid_map (/procpid/gid_map) maste alla foljande rattighetskrav vara uppfyllda: o Den skrivande processen maste ha formagan CAP_SETUID (CAP_SETGID) i processen pids anvandarnamnrymd. o Den skrivande processen maste antingen finnas i namnrymden for process pid eller finnas i foraldraanvandarnamnrymden till process pid. o De avbildade anvandar-ID:na (grupp-ID:na) maste i sin tur ha en avbildning i foraldraanvandarnamnrymden. o Om man uppdaterar /proc/pid/uid_map for att skapa en avbildning som avbildar till UID 0 i foraldranamnrymden maste en av de foljande vara sann: (a) om den skrivande processen finns i foraldraanvandarnamnrymden, da maste den ha formagan CAP_SETFCAP i den anvandarnamnrymden; eller (b) om den skrivande processen finns i barnanvandarnamnrymden, da maste processen som skapade anvandarnamnrymden ha haft formagan CAP_SETFCAP nar namnrymden skapades. Denna regel har funnits fran Linux 5.12. Den eliminerar en tidigare sakerhetsbrist varigenom en UID 0-process som saknar formagan CAP_SETFCAP vilken behovs for att skapa en binar med namnrymdsfilformagor (sa som det beskrivs i capabilities(7)) anda kunde skapa en sadan binar genom foljande steg: (1) Skapa en ny anvandarnamnrymd med identitetsavbildningen (d.v.s., AID 0 i den nya anvandarnamnrymden avbildas pa AID 0 i foraldranamnrymden), sa att AID 0 bada namnrymderna ar ekvivalent med samma root-anvandar-ID. (2) Eftersom barnprocessen har formagan CAP_SETFCAP kunde den skapa en binar med namnrymdsfilformagor som sedan skulle vara verkningsfulla i foraldranamnrymden (eftersom root-anvandar-ID:t ar desamma i de tva namnrymderna). o En av foljande tva fall galler: (a) Antingen har den skrivande processen formagan CAP_SETUID (CAP_SETGID) i foraldraanvandarnamnrymden. o Inga ytterligare begransningar galler: processen kan gora avbildningar till godtyckliga anvandar-ID:n (grupp-ID:n) i foraldraanvandarnamnrymden. (b) Eller i annat fall galler alla foljande beskrivningar: o Data som skrivs till uid_map (gid_map) maste besta av en enda rad som avbildar den skrivande processens effektiva anvandar-ID (grupp-ID) i foraldraanvandarnamnrymden till ett anvandar-ID (grupp-ID) i anvandarnamnrymden. o Den skrivande processen maste ha samma effektiva anvandar-ID som processen som skapade anvandarnamnrymden. o Nar det galler gid_map maste forst anvandning av systemanropet setgroups(2) nekas genom att skriva "deny" till filen /proc/pid/setgroups (se nedan) fore nagon skrivning till gid_map. Skrivningar som strider mot ovanstaende regler misslyckas med felet EPERM. Projekt-ID-avbildningar: projid_map Liksom for anvandar- och grupp-ID-avbildningar ar det mojligt att skapa projekt-ID-avbildningar for anvandarnamnrymder. (Projekt-ID:n anvands for diskkvoter; se setquota(8) och quotactl(2).) Projekt-ID-avbildningar definieras genom att skriva till filen /proc/pid/projid_map (som finns fran Linux 3.7). Giltighetsreglerna for att skriva till filen /proc/pid/projid_map ar som for att skriva till filen uid_map; brott mot dessa regler far write(2) att misslyckas med felet EINVAL. Rattighetsreglerna for att skriva till filen /proc/pid/projid_map ar som foljer: o Den skrivande processen maste antingen finnas i namnrymden for process pid eller finnas i foraldraanvandarnamnrymden till process pid. o De avbildade projekt-ID:na maste i sin tur ha en avbildning i foraldraanvandarnamnrymden. Brott mot dessa regler far write(2) att misslyckas med felet EPERM. Interaktion med systemanrop som andrar process-AID:n eller -GID:n I en anvandarnamnrymd dar filen uid_map inte har skrivits kommer systemanrop som andrar anvandar-ID:n att misslyckas. Pa liknande satt, om filen gid_map inte har skrivits kommer systemanrop som andrar grupp-ID:n att misslyckas. Efter att filerna uid_map och gid_map har skrivits kan endast de avbildade vardena anvandas i systemanrop som andrar anvandar- och grupp-ID:n. For anvandar-ID:n inkluderar de relevanta systemanropen setuid(2), setfsuid(2), setreuid(2) och setresuid(2). For grupp-ID:n inkluderar de relevanta systemanropen setgid(2), setfsgid(2), setregid(2), setresgid(2) och setgroups(2). Att skriva "deny" till filen /proc/pid/setgroups fore man skriver till /proc/pid/gid_map kommer permanent avaktivera setgroups(2) i en anvandarnamnrymd och tillata att man skriver till /proc/pid/gid_map utan att ha formagan CAP_SETGID i foraldraanvandarnamnrymden. Filen /proc/pid/setgroups Filen /proc/pid/setgroups visar strangen "allow" om processer i anvandarnamnrymden som innehaller process pid far lov att anvanda systemanropet setgroups(2); den visar "deny" om setgroups(2) inte tillats i den anvandarnamnrymden. Observera att oavsett vardet i filen /proc/pid/setgroups (och oavsett processens formagor) ar inte heller setgroups(2) tillatet om inte /proc/pid/gid_map har satts annu. En privilegierad process (en med formagan CAP_SYS_ADMIN i namnrymden) kan skriva endera av strangarna "allow" eller "deny" till denna fil fore den skriver en grupp-ID-avbildning for denna anvandarnamnrymd till filen /proc/pid/gid_map. Att skriva strangen "deny" forhindrar alla processer i anvandarnamnrymden fran att anvanda setgroups(2). Essensen av begransningarna som beskrivs i foregaende stycke ar att det ar tillatet att skriva till /proc/pid/setgroups endast sa lange som anrop av setgroups(2) ar otillatet for att /proc/pid/gid_map inte har satts. Detta sakerstaller att en process inte kan ga over fran ett tillstand dar setgroups(2) ar tillatet till ett tillstand dar setgroups(2) nekas; en process kan ga over endast fran att setgroups(2) ar otillatet till att setgroups(2) ar tillatet. Standardvardet i denna fil i den initiala anvandarnamnrymden ar "allow". Nar /proc/pid/gid_map har skrivits till (vilket har effekten av att aktivera setgroups(2) i anvandarnamnrymden), ar det inte langre mojligt att gora setgroups(2) otillatet genom att skriva "deny" till /proc/pid/setgroups (skrivningen misslyckas med felet EPERM). En barnnamnrymd arver installningen av /proc/pid/setgroups fran sin foralder. Om filen setgroups har vardet "deny", da kan inte senare systemanropet setgroups(2) ateraktiveras (genom att skriva "allow" till filen) i den anvandarnamnrymden. (Forsok att gora sa misslyckas med felet EPERM.) Denna begransning propagerar ner till alla barnanvandarnamnrymder till denna anvandarnamnrymd. Filen /proc/pid/setgroups lades till i Linux 3.19, men bakatporterades till manga tidigare stabila karnserier, eftersom den atgardar ett sakerhetsproblem. Problemet rorde filer med rattigheter sasom "rwx---rwx". Sadana filer ger farre rattigheter till "gruppen" an de gor till "ovriga". Detta betyder att genom att slappa grupper med setgroups(2) kan en process tillatas filatkomst som den inte tidigare hade. Fore det fanns anvandarnamnrymder var detta inte ett bekymmer, eftersom endast en privilegierad process (en med formagan CAP_SETGID) kunde anropa setgroups(2). Dock, med introduktionen av anvandarnamnrymder blev det mojligt for en oprivilegierad process att skapa en ny namnrymd i vilken anvandaren har alla privilegier. Detta tillat sedan tidigare oprivilegierade anvandare att slappa grupprivilegier och darmed fa filatkomst som de inte tidigare hade. Filen /proc/pid/setgroups lades till for att atgarda detta sakerhetsproblem, genom att neka alla vagar for en oprivilegierad process att slappa grupper med setgroups(2). Oavbildade anvandar- och grupp-ID:n Det finns olika platser dar ett oavbildat anvandar-ID (grupp-ID) kan exponeras for anvandarrymden. Till exempel kan den forsta processen i en ny anvandarnamnrymd anropa getuid(2) innan en anvandar-ID-avbildning har definierats for namnrymden. I de flesta sadana fall konverteras ett oavbildat anvandar-ID till spillanvandar-ID:t (grupp-ID:t); standardvardet pa spillanvandar-ID:t (grupp-ID:t) 65534). Se beskrivningarna av /proc/sys/kernel/overflowuid och /proc/sys/kernel/overflowgid i proc(5). Fallen dar oavbildade ID:n avbildas pa detta satt inkluderar systemanrop som returnerar anvandar-ID:n (getuid(2), getgid(2) och liknande), kreditiv som skickas over ett UNIX-domansuttag, kreditiv som returneras av stat(2), waitid(2) och System V IPC "ctl"-atgarder IPC_STAT, kreditiv som exponeras av /proc/pid/status och filerna i /proc/sysvipc/*, kreditiv som returneras via faltet si_uid i den siginfo_t som tas emot med en signal (se sigaction(2)), kreditiv som skrivs till processbokforingsfilen (se acct(5)) och kreditiv som returneras via POSIX notifieringar i meddelandekoer (se mq_notify(3)). Det finns ett namnvart fall dar oavbildade anvandar- och grupp-ID:n inte konverteras till motsvarande spill-ID-varde. Nar man betraktar en fil uid_map eller gid_map i vilken det inte finns nagon avbildning for det andra faltet visas det faltet som 4294967295 (-1 som ett teckenlost heltal). Atkomst av filer For att avgora rattigheterna nar en oprivilegierad process soker tillgang till en fil avbildas processkreditiven (AID, GID) och de aktiva filkreditiven tillbaka till vad de skulle vara i den initiala anvandarnamnrymden och jamfors sedan for att avgora rattigheterna som processen har till filen. Detsamma ar ocksa sant for andra objekt som anvander atkomstmodellen med kreditiv plus rattighetsmasker, sasom System V IPC-objekt. Atgarder med filrelaterade formagor Vissa formagor tillater en process att kringga olika begransningar som karnan uppratthaller nar den utfor atgarder pa filer som ags av andra anvandare eller grupper. Dessa formagor ar: CAP_CHOWN, CAP_DAC_OVERRIDE, CAP_DAC_READ_SEARCH, CAP_FOWNER och CAP_FSETID. Inom en anvandarnamnrymd tillater dessa formagor en process att kringga reglerna om processen har den relevanta formagan over filen, vilket betyder: o processen har den relevanta effektiva formagan i sin anvandarnamnrymd; och o filens anvandar-ID och grupp-ID bada har giltiga avbildningar i anvandarnamnrymden. Formagan CAP_FOWNER behandlas nagot speciellt: den tillater en process att kringga motsvarande regler sa lange som atminstone filens anvandar-ID har en avbildning i anvandarnamnrymden (d.v.s., filens grupp-ID behover inte ha en giltig avbildning). Satt-anvandar-ID- och satt-grupp-ID-program Nar en process inuti en anvandarnamnrymd kor ett program som ar satt-anvandar-ID (satt-grupp-ID) andras processens effektiva anvandar- (grupp-)ID inuti namnrymden till det varde som ar avbildat for filens anvandar- (grupp-)ID. Dock, om antingen filens anvandar- eller grupp-ID inte har nagon avbildning inuti namnrymden ignoreras tyst biten satt-anvandar-ID (satt-grupp-ID): det nya programmet kors, men processens effektiva anvandar- (grupp-)ID lamnas orort. (Detta avspeglar semantiken hos att kora ett program med satt-anvandar-ID eller satt-grupp-ID som bor pa ett filsystem som monterades med flaggan MS_NOSUID, sasom beskrivs i mount(2).) Diverse Nar en process anvandar- och grupp-ID:n skickas over ett UNIX-domansuttag till en process i en annan anvandarnamnrymd (se beskrivningen av SCM_CREDENTIALS i unix(7)) oversatts de till de motsvarande vardena i enlighet med den mottagande processens anvandar- och grupp-ID-avbildningar. STANDARDER Linux. NOTERINGAR Under aren har det funnits manga funktioner som har lagts till till Linuxkarnan som har gjorts tillgangliga endast till privilegierade anvandare pa grund av deras potential att forvirra satt-anvandar-ID-root-program. I allmanhet blir det sakert att tillata root-anvandaren i en anvandarnamnrymd att anvanda dessa funktioner eftersom det ar omojligt, sa lange man finns i en anvandarnamnrymd, att fa fler privilegier an de som en anvandarnamnrymds root-anvandare har. Global root Termen "global root" anvands ibland som en kortform for anvandar-ID 0 i den initiala anvandarnamnrymden. Tillganglighet Anvandning av anvandarnamnrymder kraver en karna som ar konfigurerad med alternativet CONFIG_USER_NS. Anvandarnamnrymder kraver stod i ett antal undersystem i hela karnan. Nar ett undersystem som inte stodjs konfigureras i karnan ar det inte mojligt att konfigurera stod for anvandarnamnrymder. Fram till Linux 3.8 stodde de mest relevanta subsystemen anvandarnamnrymder, men ett antal filsystem hade inte den nodvandiga infrastrukturen for att avbilda anvandar- och grupp-ID:n mellan anvandarnamnrymder. Linux 3.9 lade till det nodvandiga infrastrukturstodet till manga av de aterstaende ej stodda filsystemen (Plan 9 (9P), Andrew File System (AFS), Ceph, CIFS, CODA, NFS och OCFS2). Linux 3.12 lade till stod till det sista av de ej stodda storre filsystemen, XFS. EXEMPEL Nedanstaende program ar skapat for att mojliggora experimenterande med anvandarnamnrymder, liksom aven andra typer av namnrymder. Det skapar namnrymder enligt specifikationen fran kommandoradsflaggor och kor sedan ett kommando inuti dessa namnrymder. Kommentarerna och funktionen usage() inuti programmet ger den fullstandiga forklaringen av programmet. Foljande skalsession demonstrerar dess anvandning. Forst betraktar vi kortidsmiljon: $ uname -rs # Forutsatter Linux 3.8 eller senare Linux 3.8.0 $ id -u # Kor som en oprivilegierad anvandare 1000 $ id -g 1000 Starta nu ett skal i en ny anvandar- (-U), monterings- (-m) och PID- (-p) namnrymd, med anvandar-ID (-M) och grupp-ID (-G) 1000 avbildade pa 0 inuti anvandarnamnrymden: $ ./userns_child_exec -p -m -U -M '0 1000 1' -G '0 1000 1' bash Skalet har PID 1, for att det ar den forsta processen i den nya PID-namnrymden. bash$ echo $$ 1 Att montera ett nytt /proc-filsystem och lista alla processerna som ar synliga i den nya PID-namnrymden visar att skalet inte kan se nagra processer utanfor PID-namnrymden: bash$ mount -t proc proc /proc bash$ ps ax PID TTY STAT TIME COMMAND 1 pts/3 S 0:00 bash 22 pts/3 R+ 0:00 ps ax Inuti anvandarnamnrymden har skalet anvandar- och grupp-ID 0, och den kompletta uppsattningen av tillatna och effektiva formagor: bash$ cat /proc/$$/status | egrep '^[UG]id' Uid: 0 0 0 0 Gid: 0 0 0 0 bash$ cat /proc/$$/status | egrep '^Cap(Prm|Inh|Eff)' CapInh: 0000000000000000 CapPrm: 0000001fffffffff CapEff: 0000001fffffffff Programkallkod /* userns_child_exec.c Licensed under GNU General Public License v2 or later Skapa en barnprocess som kor ett skalkommando i nya namnrymder; lat UID- och GID-avbildningar anges nar en anvandarnamnrymd skapas. */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include struct child_args { char **argv; /* Kommando att koras av barnet, med argument */ int pipe_fd[2]; /* Ror anvant for att synkronisera foralder och barn */ }; static int verbose; static void usage(char *pname) { fprintf(stderr, "Anvandning: %s [flaggor] kmd [arg]\n\n", pname); fprintf(stderr, "Skapa en barnprocess som kor ett skalkommando i " "en ny anvandarnamnrymd,\n" "och eventuellt aven andra nya namnrymder.\n\n"); fprintf(stderr, "Flaggor kan vara:\n\n"); #define fpe(str) fprintf(stderr, " %s", str); fpe("-i Ny IPC-namnrymd\n"); fpe("-m Ny monteringsnamnrymd\n"); fpe("-n Ny natverksnamnrymd\n"); fpe("-p Ny PID-namnrymd\n"); fpe("-u Ny UTS-namnrymd\n"); fpe("-U Ny anvandarnamnrymd\n"); fpe("-M uid_map Ange AID-avbildning for anvandarnamnrymden\n"); fpe("-G gid_map Ange GID-avbildning for anvandarnamnrymden\n"); fpe("-z Avbilda anvandar-AID och -GID till 0 i anvandarnamnrymden\n"); fpe(" (ekvivalent med: -M '0 1' -G '0 1')\n"); fpe("-v Visa utforliga meddelanden\n"); fpe("\n"); fpe("Om -z, -M eller -G anges ar -U nodvandigt.\n"); fpe("Det ar inte tillatet att ange bade -z och nagon av -M eller -G.\n"); fpe("\n"); fpe("Avbildningsstrangar for -M och -G bestar av poster pa formen:\n"); fpe("\n"); fpe(" ID-inuti-nr ID-utanfor-nr langd\n"); fpe("\n"); fpe("En avbildningsstrang kan innehalla flera poster, separerade" " av komman;\n"); fpe("kommatecknen ersatts med nyrader fore skrivning" " till avbildningsfiler.\n"); exit(EXIT_FAILURE); } /* Uppdatera avbildningsfilen 'map_fil', med vardena som ges i 'avbildning', en strang som definierar en AID- eller GID-avbildning. En AID- eller GID-avbildning bestar av en eller flera nyradsavgransade poster pa formen: ID_inuti-nr ID-utanfor-nr langd Att begara att anvandaren skall ge en strang som innehaller nyrader ar naturligtvis opraktiskt for kommandoradsanvandning. Darfor tillater vi anvandningen av komman for att avgransa poster i denna strang, och ersatter dem med nyrader fore vi skriver strangen till filen. */" static void update_map(char *mapping, char *map_file) { int fd; size_t map_len; /* Langden pa \[aq]avbildning\[aq] */ /* Ersatt kommatecken i avbildningsstrangar med nyrader. */ map_len = strlen(mapping); for (size_t j = 0; j < map_len; j++) if (mapping[j] == ',') mapping[j] = '\n'; fd = open(map_file, O_RDWR); if (fd == -1) { fprintf(stderr, "FEL: open %s: %s\n", map_file, strerror(errno)); exit(EXIT_FAILURE); } if (write(fd, mapping, map_len) != map_len) { fprintf(stderr, "FEL: write %s: %s\n", map_file, strerror(errno)); exit(EXIT_FAILURE); } close(fd); } /* Linux 3.19 gjorde en andring av hanteringen av setgroups(2) och filen 'gid_map' for att atgarda ett sakerhetsproblem. Problemet tillat *oprivilegierade* anvandare att nyttja anvandarnamnrymder for att slappa grupper. Foljden av andringarna i 3.19 ar att for att uppdatera filen 'gid_maps' maste forst anvandning av systemanropet setgroups() i denna anvandarnamnrymd avaktiveras genom att skriva "deny" till en av filerna /proc/PID/setgroups for denna namnrymd. Det ar syftet med foljande funktion. */ 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) { /* Vi kan vara pa ett system som inte stodjer /proc/PID/setgroups. I det fallet kommer filen inte att finnas, och systemet kommer inte att patvinga begransningarna som Linux 3.19 lade till. Det ar bra sa: vi behover inte gora nagot for att tillata att 'gid_map' uppdateras. Dock, om felet fran open() var nagot annat an felet ENOENT som forvantas i det fallet, tala om det for anvandaren. */ if (errno != ENOENT) fprintf(stderr, "FEL: open %s: %s\n", setgroups_path, strerror(errno)); return; } if (write(fd, str, strlen(str)) == -1) fprintf(stderr, "FEL: write %s: %s\n", setgroups_path, strerror(errno)); close(fd); } static int /* Startfunktion for klonat barn */ childFunc(void *arg) { struct child_args *args = arg; char ch; /* Vanta tills foraldern har uppdaterat AID- och GID-avbildningarna. Se kommentaren i main(). Vi vantar pa filslut fran ett ror som kommer stangas av foraldraprocessen nar den har uppdaterat avbildningarna. */ close(args->pipe_fd[1]); /* Stang var beskrivare for skrivanden av roret sa att vi ser EOF nar foraldern stanger sin beskrivare. */ if (read(args->pipe_fd[0], &ch, 1) != 0) { fprintf(stderr, "Fel i barnet: lasning fran roret returnerade != 0\n"); exit(EXIT_FAILURE); } close(args->pipe_fd[0]); /* Kor ett skalkommando. */ printf("I begrepp att gora exec %s\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]; /* Utrymme for barnets 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]; /* Tolka kommandoradsflaggor. Det inledande tecknet '+' i det sista argumentet till getopt() forhindrar permutationer av kommandoradsflaggor enligt GNU-stil. Det ar anvandbart, eftersom ibland 'kommandot' som skall koras av detta program sjalvt har kommandoradsflaggor. Vi vill inte att getopt() skall hantera dessa som flaggor till detta 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 'i': flags |= CLONE_NEWIPC; break; case 'm': flags |= CLONE_NEWNS; break; case 'n': flags |= CLONE_NEWNET; break; case 'p': flags |= CLONE_NEWPID; break; case 'u': flags |= CLONE_NEWUTS; break; case 'v': verbose = 1; break; case 'z': map_zero = 1; break; case 'M': uid_map = optarg; break; case 'G': gid_map = optarg; break; case 'U': flags |= CLONE_NEWUSER; break; default: usage(argv[0]); } } /* -M eller -G utan -U ar meningslost */ 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]; /* Vi anvander ett ror for att synkronisera foralder och barn, for att sakerstalla att foraldern staller in UID- och GID-avbildningarna fore barnet anropar execve(). Detta ser till att barnet behaller sina formagor under execve() i det vanliga fallet da vi vill avbilda barnets effektiva anvandar-ID pa 0 i den nya anvandarnamnrymden. Utan denna synkronisering skulle barnet tappa sina formagor om det utforde en execve() med anvandar-ID:n skilda fran noll (se manualsidan capabilities(7) for detaljer om transformationen av en process formagor under execve()). */ if (pipe(args.pipe_fd) == -1) err(EXIT_FAILURE, "pipe"); /* Skapa barnet i nya namnrymder. */ child_pid = clone(childFunc, child_stack + STACK_SIZE, flags | SIGCHLD, &args); if (child_pid == -1) err(EXIT_FAILURE, "clone"); /* Foraldern faller igenom hit. */ if (verbose) printf("%s: PID for barnet som skapades av clone() ar %jd\n", argv[0], (intmax_t) child_pid); /* Uppdatera UID- och GID-avbildningarna i barnet. */ 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); } /* Stang skrivanden av roret for att signalera till barnet att vi har uppdaterat UID- och GID-avbildningarna. */ close(args.pipe_fd[1]); if (waitpid(child_pid, NULL, 0) == -1) /* Wait for child */ err(EXIT_FAILURE, "waitpid"); if (verbose) printf("%s: avslutar\n", argv[0]); exit(EXIT_SUCCESS); } SE AVEN newgidmap(1), newuidmap(1), clone(2), ptrace(2), setns(2), unshare(2), proc(5), subgid(5), subuid(5), capabilities(7), cgroup_namespaces(7), credentials(7), namespaces(7), pid_namespaces(7) Karnans kallfil Documentation/admin-guide/namespaces/resource-control.rst. OVERSATTNING Den svenska oversattningen av denna manualsida skapades av Goran Uddeborg Denna oversattning ar fri dokumentation; las GNU General Public License Version 3 eller senare for upphovsrattsvillkor. Vi tar INGET ANSVAR. Om du hittar fel i oversattningen av denna manualsida, skicka ett mail till . Linux man-pages 6.06 31 oktober 2023 user_namespaces(7)