1. Linux / Administracja systemem
MC, 2023
Ilustracja do artykułu: chgrp i chown Linux - Jak zmienić właściciela pliku?

chgrp i chown Linux - Jak zmienić właściciela pliku?

Czy wiesz, że stawiając sobie pytanie, o to, jak zmienić właściciela pliku, ocierasz się o kwestię absolutnie fundamentalną dla systemów Unix i Unixopodobnych (Unix-like), takich jak Linux, z którym zapewne masz do czynienia, skoro tu trafiłeś?

Spis treści

Sięgnijmy do korzeni

Uruchommy wyobraźnię, bo zakładam, że dla większości czytelników, z racji wieku, nie mogą to być własne wspomnienia i przenieśmy się w myślach do lat siedemdziesiątych, a nawet sześćdziesiątych ubiegłego wieku. Szmat czasu, prawda? Zaszalejmy jeszcze bardziej i w tym wyobrażeniu o nieco matowym zabarwieniu usiądźmy w jednym z pomieszczeń uniwersytetu Massachusetts Institute of Technology (tak, tego słynnego „em aj ti”). A nie jesteśmy w nim sami! Są tam już pracownicy tegoż uniwersytetu, jak i AT&T Bell Labs oraz General Electric. Obok nas znajduje się między innymi, nie kto inny jak sam Dennis MacAlistair Ritchie. Reprezentuje AT&T Bell Labs, ale my znamy go dziś przede wszystkim jako autora języka C. Dalej siedzi jego nie mniej utalentowany kolega z Bell Labs - Kenneth Lane Thompson. Ten pan kojarzy się przede wszystkim z językiem programowania B, poprzednikiem języka C, zdefiniowaniem kodowania UTF-8 oraz implementacją praktyczną wyrażeń regularnych. Wymieńmy jeszcze tylko człowieka nazywającego się Malcolm Douglas McIlroy. Jemu zawdzięczamy znaną Ci pewnie koncepcję pipelines (w języku naszych ojców nazywanych potokami), czyli przekazywania rezultatów jednych programów, na wejście innych. Po dziś dzień używamy również narzędzi jego autorstwa takich jak dla przykładu polecenia diff, czy sort.

Nie wiem, jak Ty, ale ja w takim otoczeniu bałbym się otworzyć usta, dlatego tylko posłuchajmy, o czym ci ludzie o potężnych umysłach rozmawiają.

via GIPHY

Zdaje się, że dyskutują, o jakich problemach nastręcza złożoność tworzonego przez nich systemu Multics. W ich rozmowach często pojawia się pojęcie time-sharing system, czyli systemu mogącego obsługiwać jednocześnie wielu użytkowników. Ta potrzeba jest głównym motorem ich pracy, to ich podstawowy cel.

Czy to nas jakkolwiek dotyczy? Obecni na tym spotkaniu, nie mogli tego jeszcze wiedzieć, ale doświadczenie zdobyte podczas pracy nad systemem Multics jak również i napotkane problemy, które omawiali, staną się za kilka lat matką i ojcem systemu Unix.

Dlaczego pliki mają właścicieli?

Nie mam na to dowodu, ale zdrowy rozsądek podpowiada, że na jednym z takich spotkań, jakie sobie wyobrażaliśmy, musiała być omawiana sprawa tego, jak powinny być zarządzane pliki w systemie współdzielonym przez wielu użytkowników. Tak przynajmniej lubię o tym myśleć. Zdaje się, że to jedna z kwestii absolutnie kluczowych dla celu, jaki sobie postawiono. Jakoś przecież użytkownicy muszą tworzyć, edytować i usuwać pliki, nie wchodząc w kolizję z innymi użytkownikami o takich samych potrzebach. Z tego wprost nasuwa się wniosek, że możliwości poszczególnych użytkowników muszą zostać jakoś ograniczone, inaczej jedni drugim będą wchodzić w grządkę.

via GIPHY

Kto, kiedy i jak zaproponował koncepcję, którą za moment omówimy, niestety nie wiem (jeśli coś możesz na ten temat powiedzieć, zostaw, proszę komentarz u dołu strony – chętnie go przeczytam). Znamy za to jej finalny kształt, jaki został wprowadzony w systemie Unix i potem zaadoptowany w systemie Linux.

UNIX is basically a simple operating system, but you have to be a genius to understand the simplicity. / UNIX jest co do zasady prostym systemem operacyjnym, ale trzeba być geniuszem, aby zrozumieć tę prostotę.
Dennis MacAlistair Ritchie

Fakt pierwszy - pliki mają właścicieli. Kto jest właścicielem pliku? Jego autor, rzecz jasna! To, co mniej jasne, to to, że domyślnym właścicielem pliku jest również główna grupa jego autora, ale temat grup podejmiemy za moment.

Fakt drugi – nowo utworzony plik ma przypisane uprawnienia domyślne. Na przykład, na Ubuntu właściciel pliku oraz jego główna grupa mają domyślnie prawo do zapisu i odczytu plików. Pozostali, wyłącznie do odczytu. Nikt natomiast do jego wykonywania (co oczywiście można zmienić).

Innym częstym wariantem, jest ograniczenie uprawnień grupy właściciela wyłącznie do odczytu. Wtedy to na barkach autora pliku pozostaje nadanie prawa do zapisu grupie, jeśli jest wymagane.

Domyślne uprawnienia dla nowych plików definiowane są odpowiednią maską, którą można zarządzać poleceniem umask. Aktualne ustawienia swojego systemu możesz podejrzeć, wydając polecenie: `umask -S`.

Właściciel pliku może zarządzać jego uprawnieniami podzielonymi na trzy kategorie: uprawnienia użytkownika będącego właścicielem (czyli dla siebie samego), uprawnienia grupy będącej właścicielem (a ściślej dla innych użytkowników należących do tej grupy) oraz uprawnienia pozostałych użytkowników.

Czy wiesz, że właściciel pliku może pozbawić wszystkich użytkowników wszystkich praw? Wszystkich łącznie ze sobą! Co w takiej sytuacji? Wprawdzie nawet właściciel nie może pliku odczytać, edytować, czy usunąć, ale nadal pozostaje jego właścicielem, a tym samym nadal może tymi uprawnieniami zarządzać, więc sytuacja jest zupełnie odwracalna! Zainteresowanym polecam wykonać poniższą sekwencję poleceń.

$ echo "abc" > test       # tworzymy plik
$ ls -l test              # sprawdzamy uprawnienia
$ cat test                # odczytujemy plik
$ chmod u=,g=,o= test     # usuwamy uprawnienia
$ ls -l test              # sprawdzamy uprawnienia
$ cat test                # próbujemy odczytać plik
$ chmod u=rw,g=,o= test   # ponownie nadajemy uprawnienia samym sobie
$ ls -l test              # sprawdzamy uprawnienia
$ cat test                # odczytujemy plik
$ rm test                 # usuwamy plik

Co to jest grupa użytkowników Linux?

Nim przejdziemy dalej, musimy się teraz pochylić nad pojęciem grupy użytkowników w systemach z grupy Unix.

via GIPHY

Koncepcja grupy została oczywiście wprowadzona w celu ułatwienia zarządzania uprawnieniami. Zamiast przypisywać pewne uprawnienia każdemu użytkownikowi z osobna, definiujemy je na poziomie grupy gromadzącej wskazanych użytkowników. Taka struktura jest zdecydowanie prostsza do zarządzania, zarówno z punktu widzenia czasu potrzebnego na pewne modyfikacje, jak i ze względu na bezpieczeństwo. Znacznie trudniej o błąd, kiedy mamy grupę o ściśle określonych uprawnieniach i musimy tylko upewnić się, czy zawiera one odpowiednie osoby, niż sprawdzać każde konto, pod względem przypisanych uprawnień.

Tak się to przedstawia wysokopoziomowo. Zejdźmy jednak nieco niżej i przyjrzyjmy się pewnym pryncypiom systemowym dotyczącym grup użytkowników.

Po pierwsze, są dwa rodzaje grup użytkowników: grupy główne i pozostałe.

Po drugie, użytkownik musi być przypisany do jakiejś grupy głównej, która zostaje zastosowana podczas logowania. Informacja o grupach głównych użytkowników zapisana jest w pliku /etc/passwd i rekord z pustą grupą główną, jest traktowany jako niepoprawny. Obecnie najczęściej podczas tworzenia nowego użytkownika systemu, tworzona jest również grupa o takiej samej nazwie jak użytkownik i jest ona jego grupą główną. Spójrzmy na poniższe wywołania:

$ whoami                  # wypisze nazwę obecnego użytkownika
sapientisat
$ groups                  # pokaże grupy obecnego użytkownika
sapientisat adm cdrom sudo dip plugdev lpadmin

Widzimy, że użytkownik sapientisat jest przypisany do grupy o takiej samej nazwie. O wypisywaniu powiemy jeszcze kilka słów nieco niżej.

Po trzecie i ostatnie, użytkownik może być przypisany do wielu innych grup, ale nie jest to konieczne. Informacje o grupach dodatkowych użytkowników znajdują się w pliku /etc/group.

Na jeszcze niższym poziomie – systemowym – warto wiedzieć, że tak naprawdę nazwy użytkowników i grup w postaci tekstowej istnieją wyłącznie przez wzgląd na ludzką percepcję. System tak naprawdę operuje na identyfikatorach liczbowych. I my również możemy! O czym nieco dalej.

Jeśli przyjrzeć się wszystkim grupom znajdującym się w systemie możemy znaleźć dwie szczególnie interesujące: users oraz nogroup.
Zaczniemy od tej drugiej. Grupa o nazwie nogroup jest grupą główną użytkownika nobody, który jest zarezerwowany dla specjalnych procesów, które nie są właścicielami żadnych plików.
Wiedząc to, można przypuszczać, że grupa users zawiera wszystkich użytkowników, ale tak nie jest – jest ona traktowana jako grupa rezerwowa, mogąca być grupą główną dla użytkowników, niemających żadnej innej.

Jak wypisać wszystkie grupy?

Teraz zastanówmy się jak uzyskać listę grup użytkowników w systemie Linux. Zarówno tę, do których jest przypisany konkretny użytkownik, jak i po prostu listę wszystkich grup. Zaczniemy od tej drugiej opcji.

Wspomniałem wcześniej, że informacje o grupach zapisane są w pliku /etc/group, możemy je więc pozyskać, przeglądając jego treść:

$ cat /etc/group

Lub zawężając wyniki, wyłącznie do nazw grup:

$ cat /etc/group | awk -F: '{print $1}'

Możemy również osiągnąć te same rezultaty i otrzymać listę wszystkich grup w systemie Linux, używając polecenia getent, które odpytuje zasoby administracyjne. W naszym przypadku interesujący jest zbiór danych „group”, stąd polecenia wyglądają, jak następuje:

$ getent group

I podobnie jak poprzednim razem, dla uzyskania samych nazw grup:

$ getent group | awk -F: '{print $1}'

Wspominałem już, że system tak naprawdę operuje identyfikatorami numerycznymi grup i użytkowników, a nie ich nazwami, dlatego warto również wiedzieć, jak je pozyskać. Ponownie skorzystamy z pliku /etc/group, tylko tym razem skupimy się na 3 polu każdego wiersza, przyjmując za separator znak dwukropka.

$ cat /etc/group | awk -F: '{print $3}'
$ cat /etc/group | awk -F: '{print $1,$3}'
$ getent group | awk -F: '{print $3}'
$ getent group  | awk -F: '{print $1,$3}'

Jak wypisać, grupy do których należę?

Dobrze, wiemy już jak uzyskać listę wszystkich grup, użytkowników, ale jak sprawdzić, do jakich grup należy użytkownik, na którego konto jesteśmy obecnie zalogowani w systemie? Przedstawię dwa podejścia.

Pierwsze polega na użyciu polecenia groups bez dodatkowych argumentów.

$ groups
sapientisat adm cdrom sudo dip plugdev lpadmin

Zwraca ono dokładnie to, czego potrzebowaliśmy, czyli listę grup, których jesteśmy członkami. Drugie podejście wygląda bardzo podobnie. Tym razem wydajmy polecenie id.

$ id
uid=1000(sapientisat) gid=1000(sapientisat) grupy=1000(sapientisat),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin)

Wynik jest znacznie obszerniejszy. Widzimy bowiem nazwę naszego użytkownika wraz z jego identyfikatorem numerycznym (część „uid=1000(sapientisat)”), naszą grupę główną i jej identyfikator (część „gid=1000(sapientisat)”), a także pozostałe grupy i ich identyfikatory.

Jak wypisać grupy innego użytkownika?

Jeśli interesują nas grupy innego użytkownika systemu, wystarczy, że do poprzednich poleceń dołączymy jego nazwę i zamiast naszych własnych grup, otrzymamy grupy użytkownika Linux. Poniższy przykład ma na celu wypisanie grup dla użytkownika git.

$ groups git
git : git
$ id git
uid=129(git) gid=136(git) grupy=136(git)

Zwróćmy uwagę, że polecenie id może być również użyte z identyfikatorem użytkownika, zamiast jego nazwy:

$ id 129
uid=129(git) gid=136(git) grupy=136(git)

Jak wypisać wszystkich użytkowników należących do grupy?

Teraz odwróćmy problem i zamiast zastanawiać się jak wypisać grupy użytkownika, wypiszmy użytkowników w danej grupie!

Pewnie nikogo już nie zaskoczę, że zaczniemy od przetworzenia informacji z pliku /etc/group. Po prostu odfiltrujemy wiersz z nazwą interesującej nas grupy przy pomocy polecenia grep (w poniższym przykładzie szukamy użytkowników dla grupy sudo).

$ cat /etc/group | grep 'sudo'
sudo:x:27:sapientisat,admin

Widzimy, że w grupie sudo znajduje się dwóch użytkowników: sapientisat oraz admin.

Możemy również użyć polecenia members, choć może ono nie być domyślnie dostępne w systemie (co nie jest szczególnie problematyczne, bo z pewnością będzie czekać w repozytoriach).

$ members sudo
sapientisat admin

Rezultat jest dokładnie taki sam co do informacji, jaką niesie, ale forma jest nieco bardziej przejrzysta, już bez dodatkowego, ręcznego przetwarzania wierszy z /etc/group.

Jak wypisać wszystkich użytkowników Linux?

No dobrze, a jak uzyskać pełną listę użytkowników systemu Linux? W końcu musimy wiedzieć z kim mamy do czynienia, skoro chcemy szaleć ze zmienianiem właścicieli plików!

Pewnie się już domyślasz, że zajrzymy do plik /etc/passwd. Wykorzystamy nawet poprzednio omówione podejścia. Najpierw nieco bardziej surowo – wyciągniemy pierwszą kolumnę ze wspomnianego pliku.

$ cat /etc/passwd | awk -F: '{print $1}'

Możemy również użyć znanego nam już polecenia getent, jednak tym razem z argumentem... ta-dam, ta-dam, ta-dam… chwila napięcia trwa… - passwd!

$ getent passwd | awk -F: '{print $1}'

Jeśli stoisz przed potrzebą ograniczenia listy użytkowników systemowych, wyłącznie do zalogowanych, to zawsze możesz skorzystać z polecenia who:
$ who
sapientisat :1         2023-04-02 12:31 (:1)

Jak sprawdzić właściciela pliku Linux?

Skoro chcemy opanować zmienianie właściciela plików na systemach Linux, to w pierwszej kolejności musimy się upewnić, że w ogóle potrafimy sprawdzić, kto jest obecnym właścicielem. Szczęśliwie, sprawa jest najzupełniej banalna. Najprościej jest użyć polecenia ls, służącego, rzecz jasna, do wypisywania plików i informacji o nich, wraz z przełącznikiem -l, który zapewni nam podanie nieco obszerniejszych informacji o pliku, w tym tych, których szukamy, czyli kto jest właścicielem.

Stwórzmy nowy plik o nazwie „tmp” i sprawdźmy, jak wygląda dla niego rezultat polecenia ls.

Polecenie ls zwróciło nam kolejno: uprawnienia, liczbę twardych dowiązań, właściciela pliku, grupę będącą właścicielem, rozmiar pliku, datę i czas utworzenia pliku, jego nazwę.

Mamy więc to, czego potrzebowaliśmy, a nawet ciut więcej.

Po co zmieniać właściciela pliku?

Nim przejdziemy do właściwego zagadnienia, odpowiedzmy sobie jeszcze na pytanie, po co właściwie zmieniać właściciela plików na systemie Linux? Jeśli trafiłeś tu, szukając praktycznej wskazówki, pewnie masz swój własny powód, więc zachęcam do podzielenia się nim w sekcji komentarzy, szczególnie jeśli jest inny, niż te, które za moment opiszę.

Zmiana właściciela pliku jest zadaniem czysto administracyjnym i taki charakter mają potrzeby z nim związane. Najczęściej jest to jakaś forma udostępniania pewnych zasobów systemowych, katalogów, skryptów itp., określonym użytkownikom. Albo dokładnie odwrotnie – możemy chcieć zmienić właściciela, aby pewne dostępy odebrać. Dobry powodem może być pojawienie się w organizacji nowego pracownika, bądź odejść odejście starego.

A teraz czas zabrać się za właściwą praktykę!

via GIPHY

Jak zmienić właściciela pliku Linux? - Polecenie chown

Wytoczyliśmy na pole bitwy wszystkie niezbędne działa teoretyczne i pomocnicze w postaci dostępu do list użytkowników i grup, czas więc oddać pierwsze strzały z działa głównego – zacznijmy zmieniać właściciela plików.

Użytkownika będącego właścicielem pliku może zmieniać wyłącznie administrator – root. Takie ograniczenie wydaje się być bardzo logiczne. Z jednej strony uniemożliwia to „podrzucanie” plików innym użytkownikom, a właściwie rezerwuje to taką możliwość wyłącznie adminom, z drugiej zaś, zapobiega pomyłkom nieodwracalnym bez ingerencji administracyjnej z zewnątrz. Zmieniając właściciela swojego pliku, mógłbyś stracić do niego dostęp i możliwość cofnięcia tej zmiany!

Do zmiany właściciela posłuży nam polecenie chown, którego nazwa jest skrótem od change owner, czyi „zmień właściciela”. W swojej najprostszej postaci komenda ta przybiera następującą składnię:

# chown nazwa_nowego_właściciela_lub_uid ścieżka_do_pliku

Aby więc ustanowić użytkownika „jan” właścicielem pliku „/tmp/file”, wydamy następujące polecenie (tu i wszędzie dalej dodaję polecenie sudo przed właściwą komendę, na oznaczenie wymagań uprawnień administracyjnych):

sudo chown jan /tmp/file

Prawa, że proste? Kilkukrotnie wspominałem, że możemy również użyć identyfikatorów numerycznych zamiast nazw użytkowników i grup. Zakładając, że użytkownik „jan” ma identyfikator 1001, poniższe polecenie będzie odpowiednikiem poprzedniego przykładu:

sudo chown 1001 /tmp/file

Jak zmienić właściciela i grupę pliku? - Polecenie chown

Teraz spróbujemy zmienić zarówno użytkownika będącego właścicielem jak i grupę. Przez wzgląd na zmianę właściciela, nadal jest to operacja zarezerwowana wyłącznie dla roota!

Nadal pozostajemy przy poleceniu chown. Różnica będzie taka, że po nazwie użytkownika mającego się stać nowym właścicielem, po dwukropku podamy również nazwę grupy, której chcemy przypisać posiadanie pliku. 

# chown nazwa_nowego_właściciela_lub_uid:nazwa_grupy_lub_gid ścieżka_do_pliku

W naszych przykładach nadal nowym właścicielem pozostaje użytkownik „jan”, za docelową grupę przyjmiemy zaś grupę „pracownicy”:

sudo chown jan:pracownicy /tmp/file

Zamiast dwukropka oddzielającego nazwę użytkownika od nazwy grupy, dopuszczalne jest również użycie kropki jako separatora, jednak zdecydowanie częściej w przykładowych użyciach można się spotkać z notacją dwukropkową, dlatego my również będziemy się jej trzymać.

W tym wypadku również możemy użyć identyfikatorów numerycznych! Zakładamy, że UID użytkownika „jan” to 1001, a GID grupy „pracownicy” to 2002:

sudo chown 1001:2002 /tmp/file

Jak zmienić grupę posiadającą plik? Polecenie chown

W tej chwili na celownik bierzemy zmianę grupy, która ma być właścicielem pliku. Nie zmieniamy tym razem właściciela-użytkownika, więc wkraczamy w obszar możliwości zwykłego konta, nieposiadającego uprawnień administracyjnych. Musimy się nad tym na moment zatrzymać.

O ile do tej pory używaliśmy polecenia chown, o tyle, jeśli interesuje nas wyłącznie zmiana grupy, możemy również użyć polecenia chgrp (change group). Dlaczego warto znać obydwa polecenia? Otóż zwyczajowo utarło się, że zwykli użytkownicy, mogący zmienić tylko grupę, używają komendy chgrp, natomiast administratorzy, mający możliwość zmiany również użytkownika, korzystają z polecenia chown.

Komenda chown może w kontekście zmiany wyłącznie grupy, jawić się jako nieco kłopotliwa, ponieważ nazwa grupy docelowej występuje po separatorze – dwukropku. Co zrobić z użytkownikiem? Pominąć! Nadal używamy przykładowej grupy „pracownicy”:

sudo chown :pracownicy /tmp/file

I ponownie wersja z identyfikatorem numerycznym:

sudo chown :2002 /tmp/file

Jak zmienić grupę poleceniem chgrp?

Przyszedł czas na wspomniane polecenie chgrp. Jest ono bardzo podobne w użyciu do komendy chown, z tą różnicą, że nie ma możliwości podania właściciela-użytkownika, zatem znika też separator – podajemy tylko nazwę, bądź identyfikator grupy. 

chgrp nazwa_grupy_lub_gid ścieżka_do_pliku

Zwróć uwagę, że polecenie chgrp nie jest poprzedzone komendą sudo – uprawnienia administracyjne nie są wymagane!

Czyli dla naszej przykładowej grupy „pracownicy” będzie to:

chgrp pracownicy /tmp/file

Dla wersji z identyfikatorem numerycznym otrzymamy:

chgrp 2002 /tmp/file

Rekurencyjna zmiana właściciela

Dotychczas posługiwałem się wyłącznie przykładem zmiany właściciela jednego pliku. Możemy oczywiście wykonać te same operacje w sposób rekurencyjny, dla całej zawartości wskazanego katalogu. Wystarczy do wywołań dodać przełącznik -R, który zazwyczaj łączony jest z jeszcze innym przełącznikiem - -h. Otóż ta druga flaga definiuje sposób obchodzenia się z dowiązaniami symbolicznymi (o których jeszcze dwa zdania w kolejnej sekcji), mianowicie nie pozwala na zmianę właściciela plików wskazywanych przez dowiązania, a modyfikuje samo dowiązanie. Oto zmodyfikowane wcześniejsze przykłady, rekurencyjnie zmieniające właściciela w katalogu /tmp.

Rekurencyjne chown – zmiana użytkownika:

sudo chown -hR jan /tmp
sudo chown -hR 1001 /tmp

Rekurencyjne chown – zmiana użytkownika i grupy:

sudo chown -hR jan:pracownicy /tmp
sudo chown -hR 1001:2002 /tmp

Rekurencyjne chown – zmiana grupy:

sudo chown -hR :pracownicy /tmp
sudo chown -hR :2002 /tmp

Rekurencyjne chgrp – zmiana grupy:

chgrp -hR pracownicy /tmp
chgrp -hR 2002 /tmp

Komenda chown i dowiązania symboliczne (symlinks)

W poprzedniej sekcji wspomniałem, że jeśli chcemy, aby podczas rekurencyjnej zmianie właściciela modyfikować pliki dowiązań symbolicznych, ale nie ich celów, należy dodać flagę -h. Należy powiedzieć o tym problemie coś więcej.

Domyślnie na systemach Linux, wykonywanie operacji zmiany właściciela na dowiązaniu symbolicznym będzie modyfikowało plik docelowy, nie samo dowiązanie (a przynajmniej zostanie podjęta taka próba, o czym za momencik). Dopiero wspomniana flaga zmienia tę sytuację. Przeanalizuj proszę poniższe outputy.

Najpierw bez flagi -h:

$ touch /tmp/symlinksource
$ ln -s /tmp/symlinksource /tmp/symlink 
$ ls -l /tmp/symlink*
lrwxrwxrwx 1 sapientisat sapientisat 18 kwi 4 00:01 /tmp/symlink -> /tmp/symlinksource
-rw-rw-r-- 1 sapientisat sapientisat 0 kwi 4 00:00 /tmp/symlinksource
$
$ sudo chown root /tmp/symlink
$ ls -l /tmp/symlink*
lrwxrwxrwx 1 sapientisat sapientisat 18 kwi 4 00:01 /tmp/symlink -> /tmp/symlinksource
-rw-rw-r-- 1 root sapientisat 0 kwi 4 00:00 /tmp/symlinksource

Widzimy, że zmodyfikowany został właściciel pliki docelowego, a nie samo dowiązanie. A następnie po dołączeniu przełącznika -h:

$ touch /tmp/symlinksource
$ ln -s /tmp/symlinksource /tmp/symlink 
$ ls -l /tmp/symlink*
lrwxrwxrwx 1 sapientisat sapientisat 18 kwi 4 00:01 /tmp/symlink -> /tmp/symlinksource
-rw-rw-r-- 1 sapientisat sapientisat 0 kwi 4 00:00 /tmp/symlinksource
$
$ sudo chown -h root /tmp/symlink 
$ ls -l /tmp/symlink*
lrwxrwxrwx 1 root sapientisat 18 kwi 4 00:01 /tmp/symlink -> /tmp/symlinksource
-rw-rw-r-- 1 sapientisat sapientisat 0 kwi 4 00:00 /tmp/symlinksource

Teraz mamy sytuację odwrotną – to plik dowiązania symbolicznego ma zmienionego właściciela, a nie plik, na który dowiązanie wskazuje!

Warto wiedzieć o jeszcze jednej rzeczy, umykającej w powyższych przykładach, w których używamy uprawnień administracyjnych.

Na większości dystrybucji Linuksa możliwość modyfikowania uprawnień plików docelowych za pośrednictwem ich dowiązania, jest wyłączona. To, czy cele dowiązań symbolicznych są chronione, czy nie, zdefiniowane jest w pliku /proc/sys/fs/protected_symlinks (wartość 1 oznacza, że ochrona jest włączona, 0 – że nie). Dlaczego więc w poprzednich przykładach mogliśmy zmieniać cele dowiązań symbolicznych? Wymuszaliśmy to poleceniem sudo! Zwróć jednak uwagę na poniższe wywołanie wykonane na prawach zwykłego użytkownika.

$ sudo cat  /proc/sys/fs/protected_symlinks
1
$ chgrp root /tmp/symlink
chgrp: nie można zmienić grupy '/tmp/symlink': Operacja niedozwolona

Warunkowa zmiana własności – tylko z określonego właściciela, lub grupy

Polecenie chown ma jeszcze dwie, bardzo przydatne możliwości, które teraz omówimy. Pierwsza z nich pozwala na zmianę własności plików, tylko jeśli obecnym właścicielem jest wskazany użytkownik lub grupa. Ma to charakter dodatkowego zabezpieczenia z jednej strony, z drugiej zaś ułatwia pracę administracyjną, ponieważ nie musimy kontrolować, czy na pewno dobrych plików własności modyfikujemy. Stosuję się do tego celu flagę --from.

Ustanawiamy właścicielem użytkownika „jan”, jeśli obecnym właścicielem jest użytkownik „sapientisat”:

$ sudo chown --from=sapientisat jan /tmp/file

Zmiana grupy z „sapientisat” na „pracownicy”:

$ sudo chown --from=:sapientisat :pracownicy /tmp/file

Zmieniamy użytkownika i grupę z „sapientisat:sapientisat” na „jan:pracownicy”:

$ sudo chown --from=sapientisat:sapientisat jan:pracownicy /tmp/file

Ustanawiamy właścicielem użytkownika „jan”, wyłącznie jeśli obecnie plik należy do użytkownika i grupy „sapientisat:sapientisat”:

$ sudo chown --from=sapientisat:sapientisat jan /tmp/file

Podobnie jak wyżej, jeśli właścicielem jest „sapientisat:sapientisat”, zmieniamy grupę na „pracownicy”:

$ sudo chown --from=sapientisat:sapientisat :pracownicy /tmp/file

Wszystkie powyższe przykłady można użyć razem z identyfikatorami numerycznymi, zamiast nazw użytkownika i grupy:

$ sudo chown --from=1001:1001 2002:2002 /tmp/file

Kopiowanie ustawień własności z innego pliku

Drugą bardzo przydatną opcją dostępną poleceniu chown jest możliwość skopiowania własności z jednego pliku na drugi. Do tego celu wystarczy wskazać plik stanowiący odniesienie przy pomocy przełącznika --reference.

Dla przykładu przenieśmy ustawienia własności z pliku fileref na plik file:

$ sudo chown --reference=/tmp/fileref /tmp/file

Zwróć uwagę, że w takim wypadku nie podajemy już docelowego właściciela ani grupy – cechy te zostaną skopiowane z pliku referencyjnego! Poniżej przedstawiam bardziej obrazowy output:

$ ls -l /tmp/file*
-rw-rw-r-- 1 sapientisat sapientisat 0 kwi 4 10:48 /tmp/file
-rw-rw-r-- 1 jan jan 0 kwi 4 10:48 /tmp/fileref
$ sudo chown --reference=/tmp/fileref /tmp/file
$ ls -l /tmp/file*
-rw-rw-r-- 1 jan jan 0 kwi 4 10:48 /tmp/file
-rw-rw-r-- 1 jan jan 0 kwi 4 10:48 /tmp/fileref

Zakończenie

Na tym kończymy artykuł dotyczący zmiany własności plików na systemach Linux. Był on dość długi, ale mam nadzieję, że i pomocny w pogłębieniu spojrzenia na sprawy systemowe, do których tak łatwo przywykamy i często traktujemy ja jako coś oczywistego. Warto pamiętać, że jeśli coś staje się tak proste w użyciu, znaczy to, że jest bardzo dobrze zrobione i czasem wypada się nad takimi sprawami pochylić z zachwytem i wdzięcznością.

Jeśli udało Ci się przeczytać ten artykuł od początku do końca, to bardzo proszę o zostawienia śladu po sobie w sekcji komentarzy – będzie mi to przydatne do oceny, jak taka forma sprawdza się w odbiorze. Na ten moment dziękuję za wspólny czas!

via GIPHY

Komentarze (0) - Nikt jeszcze nie komentował - bądź pierwszy!

Imię:
Treść: