Linux commando: chown

1. De basis

De taak van chown is het veranderen van de eigenaar en, optioneel, de groep van een bestand of map. Waar chmod de rechten-bits bewerkt (de rwx-letters), bewerkt chown de twee namen waar die bits naar verwijzen.

Elk bestand heeft precies een eigenaar en een groep:

Het commando dat bepaalt van wie een bestand is. Achter een kort woord zit het hele idee van eigendom in een multi-user-systeem, de reden dat alleen root bestanden aan andere gebruikers mag geven, en een beveiligingsregel die stilletjes gevaarlijke programma's ontwapent.

Dit artikel begint met de eenvoudigste eigenaarswijziging en bouwt stap voor stap op naar groepen, recursieve wijzigingen over een hele mappenboom, symbolische links, en de verrassende regels die het systeem beschermen. Aan het eind lezen de derde en vierde kolom van ls -l als gewone taal.

Het juiste mentale model: rechten en eigendom zijn twee helften van een antwoord. De modus zegt "de eigenaar mag dit schrijven"; eigendom zegt "en jij bent de eigenaar". Geen van beide helften betekent iets zonder de ander.

1.1 Eerst het eigendom lezen

Voordat je eigendom wijzigt, moet je het kunnen zien. Draai ls -l en kijk naar de derde en vierde kolom:

$ ls -l report.txt
-rw-r--r--  1 peter staff  1234 May 28 17:02 report.txt
                |     |
              owner  group

Hier is de eigenaar peter en de groep staff. De rechtenreeks ervoor (-rw-r--r--) bepaalt wat elk van hen mag doen, maar het is chown dat de namen peter en staff in de eerste plaats bepaalt. Wil je de numerieke ID's achter die namen zien, voeg dan -n toe (kort voor numeric, numeriek):

$ ls -ln report.txt
-rw-r--r--  1 1000 1000  1234 May 28 17:02 report.txt

De namen zijn slechts een vriendelijk gezicht; de kernel bewaart een numeriek gebruikers-ID (UID) en een groeps-ID (GID). Dat detail wordt later belangrijk, wanneer je bestanden kopieert tussen machines die niet dezelfde lijst met gebruikers delen.

3. Een korte geschiedenis

Eigendom is een van de oudste ideeen in Unix. Het verscheen in Unix 1st Edition bij Bell Labs in 1971, samen met de bestandsmodi die chmod bewerkt. Het koppel van een eigenaar, een groep en een set rechten-bits heeft bijna elk besturingssysteem overleefd waar het mee concurreerde, en het draait vandaag nog op elke Linux-server.

Zoals bij de meeste kerncommando's zijn er twee versies in omloop. Linux-systemen draaien de GNU coreutils-versie; macOS en de BSD's leveren een BSD-versie. Ze zijn het eens over de belangrijke dingen, maar een paar opties verschillen (zo biedt GNU --from en --reference, die BSD mist, en spellen de twee de recursieve symlink-opties net iets anders). Dit artikel gebruikt de GNU-versie, gecontroleerd tegen coreutils 9.4, wat je op bijna elke Linux-server vindt.

5. Gemiddelde gebruiksgevallen

5.1 De login-groep-snelkoppeling

Er is een handige afkorting voor "maak deze gebruiker de eigenaar, en zet de groep op de eigen groep van die gebruiker". Je schrijft de eigenaar, een dubbele punt en dan niets:

$ sudo chown peter: report.txt

De afsluitende dubbele punt betekent "gebruik de login-groep van peter". Als de primaire groep van peter ook peter heet (de gebruikelijke standaard op modern Linux), belandt het bestand bij peter:peter. Het is een kleine besparing, maar een handige wanneer je de bestanden van een gebruiker terugzet naar hun normale staat.

5.2 Numerieke ID's gebruiken

Je hoeft geen namen te gebruiken. Overal waar een gebruikers- of groepsnaam is toegestaan, werkt ook een numeriek ID:

$ sudo chown 1000:1000 report.txt

Dit is essentieel wanneer een gebruiker geen naam heeft op het huidige systeem, wat voortdurend gebeurt binnen Docker-containers, op reddingssystemen, of bij het terugzetten van een back-up van een andere machine. Omdat de kernel echt getallen bewaart en geen namen, werken numerieke ID's altijd, zelfs wanneer het opzoeken van de naam mislukt. Als een naam en een getal verward kunnen worden, kun je numeriek lezen afdwingen met een voorloop-+, zoals in chown +1000 file.

Namen zijn een gemakslaag. Het bestand onthoudt een UID en een GID; de koppeling naar peter en staff staat in /etc/passwd en /etc/group (of in LDAP of Active Directory, via de Name Service Switch). Kopieer een bestand naar een machine met een andere koppeling en dezelfde getallen kunnen een andere naam tonen, of helemaal geen naam. Containers maken dit zichtbaar: een user namespace kan ID's omzetten, zodat UID 1000 binnen een Docker-container bij een totaal andere gebruiker op de host kan horen.

5.3 Eigendom kopieren: --reference

In plaats van een eigenaar en groep te noemen, kun je chown vragen ze van een ander bestand te kopieren met --reference:

$ sudo chown --reference=working.conf broken.conf

Nu heeft broken.conf precies dezelfde eigenaar en groep als working.conf. Dit is de natuurlijke oplossing wanneer het ene bestand in een map werkt en het andere niet, en je ze wilt laten overeenkomen zonder de namen met de hand te lezen en te typen.

5.4 Melden wat er veranderde

Standaard is chown stil. Twee vlaggen laten het praten. Gebruik -v (kort voor verbose, uitgebreid) om elk bestand te melden dat het aanraakt, of -c (kort voor changes, wijzigingen) om alleen de bestanden te melden die echt veranderden:

$ sudo chown -c peter:staff *.txt
changed ownership of 'notes.txt' from root:root to peter:staff
changed ownership of 'todo.txt' from root:root to peter:staff
# report.txt is not listed: it already belonged to peter:staff

Bij een grote batch is -c de betere keuze: het toont alleen het echte werk en blijft stil over bestanden die al klopten.

7. Iets wat de meeste gebruikers niet weten

7.1 Je kunt je eigen bestanden niet weggeven

Hier is de regel die bijna iedereen verrast. Op Linux kan een gewone gebruiker de eigenaar van een bestand niet naar iemand anders wijzigen, zelfs niet voor bestanden die ze bezitten. Alleen root mag eigendom wijzigen. Probeer het als gewone gebruiker en je krijgt:

$ chown alice report.txt
chown: changing ownership of 'report.txt': Operation not permitted

Dit is de POSIX-regel "restricted chown", en die bestaat om goede redenen. Als gebruikers bestanden konden weggeven, konden ze schijfquota ontwijken door bestanden op andermans account te dumpen, of een bestand op naam van een andere gebruiker plaatsen om die erin te luizen of langs een controle te glippen. Dus de macht om een eigenaar te wijzigen is voorbehouden aan de supergebruiker. De groep wijzigen is losser: je mag de groep van een bestand op elke groep zetten waarvan je lid bent, zonder root.

Eigendom stroomt voor gewone gebruikers een kant op: root kan je een bestand geven, maar jij kunt het aan niemand geven. Om een bestand naar een andere gebruiker te verplaatsen, word je root, of maak je een kopie die de andere gebruiker dan zelf bezit.

7.2 chown ontwapent stilletjes setuid-programma's

Deze is een echte beveiligingsfunctie die verborgen in het volle zicht zit. Wanneer je de eigenaar van een bestand wijzigt, wist de kernel meestal de setuid- en setgid-bits op hetzelfde moment. Denk terug aan chmod: een setuid-programma draait met de identiteit van zijn eigenaar. Als het wijzigen van de eigenaar die bit zou laten staan, kon je een gewoon programma nemen, het setuid maken, en het dan naar root chown-en, en ineens een programma hebben dat als root draait. Die bit wissen bij elke eigenaarswijziging gooit die deur dicht:

$ ls -l tool
-rwsr-xr-x  1 peter staff  ... tool     # setuid bit is set (the 's')

$ sudo chown root tool
$ ls -l tool
-rwxr-xr-x  1 root  staff  ... tool     # the 's' is gone; now a plain program

De praktische les: als je bewust een setuid-root-programma nodig hebt, zet dan eerst de eigenaar en daarna de setuid-bit. Doe je het andersom, dan wordt je chmod u+s stilletjes ongedaan gemaakt door de volgende chown.

7.3 De oude puntscheiding

Je kunt een oud script tegenkomen dat eigendom met een punt schrijft in plaats van een dubbele punt:

$ sudo chown peter.staff report.txt    # legacy syntax

Heel vroeg Unix gebruikte een punt als scheiding tussen eigenaar en groep. GNU chown accepteert het nog voor achterwaartse compatibiliteit, maar het drukt nu een waarschuwing af, en de ondersteuning kan ooit verdwijnen. De punt is ook dubbelzinnig: als een echte gebruikersnaam een punt bevat (zeg first.last), kan chown niet zien waar de naam eindigt en de groep begint. Schrijf in alles wat nieuw is altijd de moderne dubbele-puntvorm, peter:staff.

7.4 Niet elk bestandssysteem bewaart eigendom

Eigendom is een eigenschap van het bestandssysteem, niet van het bestand. De native Linux-bestandssystemen leggen allemaal een UID en een GID in elke inode vast:

$ stat -c '%U %G' report.txt
peter staff

Maar sommige bestandssystemen hebben geen plek om die informatie te bewaren. FAT32 en exFAT, de formaten op de meeste USB-sticks en camerakaarten, bewaren helemaal geen Unix-eigenaar. NTFS (het Windows-bestandssysteem) ook niet, tenminste niet in een vorm die Linux standaard gebruikt. Wanneer je zo'n schijf aankoppelt, verzint de kernel een eigenaar voor elk bestand uit de aankoppelopties, en chown mislukt gewoon of wordt genegeerd:

$ sudo chown peter /mnt/usb/photo.jpg
chown: changing ownership of '/mnt/usb/photo.jpg': Operation not supported

De oplossing is niet chown; het is de aankoppeling. Je stelt eigendom voor de hele schijf in bij het aankoppelen met de opties uid= en gid=, bijvoorbeeld mount -o uid=1000,gid=1000 /dev/sdb1 /mnt/usb. Als chown ooit "Operation not supported" antwoordt, is het bestandssysteem de reden, niet je rechten.

7.5 Eigendom is niet de enige poort

Een deel van vakmanschap is weten wanneer een tool ophoudt. Je kunt de eigenaar en groep perfect instellen en toch geweigerd worden, omdat eigendom slechts de eerste van meerdere toegangslagen is:

• POSIX-ACL's geven extra gebruikers of groepen hun eigen rechten bovenop het owner/group/others-model. Een afsluitende + in ls -l (zoals in -rw-rwxr--+) is je aanwijzing; lees ze met getfacl.
• SELinux en AppArmor voegen een hele aparte beleidslaag toe. Een proces kan een bestand bezitten en toch geblokkeerd worden door zijn beveiligingscontext of profiel, wat chown en chmod ook zeggen.

Wanneer het eigendom klopt maar de toegang toch mislukt, vertelt een kleine gereedschapskist je waarom. Gebruik ze voordat je naar weer een chown grijpt:

$ id                       # who am I, and which groups am I in?
$ stat report.txt          # exact owner, group, and mode of one file
$ namei -l /srv/data/file  # ownership and mode of every step in the path
$ find /srv -user root     # every file still owned by root
$ find /srv -group www-data # every file in a given group

De meest onderbenutte hiervan is namei -l. Toegang tot een bestand hangt af van elke map erboven, en namei loopt het hele pad af en drukt de eigenaar en modus bij elke stap af, zodat het precies laat zien waar een keten breekt.

9. Veelgemaakte fouten

9.1 Mythe versus werkelijkheid

9.2 Andere valkuilen om te vermijden

• Rechten repareren met chown terwijl je chmod bedoelt, of andersom. Als de juiste gebruiker een bestand nog steeds niet kan lezen na een moduswijziging, hoort het bestand misschien gewoon bij de verkeerde eigenaar. Hoort het bij de juiste gebruiker maar mislukt het toch, controleer dan de modus. De twee commando's lossen verschillende helften van het probleem op.
• De -R op een map vergeten. Een kaal chown user dir wijzigt alleen de map-node, niet de bestanden erin. Voeg -R toe om de hele boom te bereiken.
• Een recursieve chown vanaf de verkeerde plek draaien. chown -R volgt het pad dat je geeft precies. Bevestig dat je in, of gericht op, de map bent die je denkt.
• De puntscheiding in nieuwe scripts gebruiken. peter.staff is verouderd, waarschuwt, en breekt op namen die een punt bevatten. Schrijf peter:staff.
• Een webapplicatie breken met te breed eigendom. Elk bestand aan www-data geven kan de webserver zijn eigen code laten herschrijven. Geef de server alleen eigendom van de mappen die het echt moet schrijven, zoals cache en uploads.