Jan Kończak

W uniksopodobnych systemach istnieją użytkownicy i grupy.
Użytkownicy identyfikowani są po numerycznych identyfikatorach uid (user identifier), które są mapowane na nazwy użytkowników.
Podobnie grupy mają identyfikatory numeryczne o nazwie gid (group identifier), które też są mapowane na nazwy grup.

Każdy użytkownik jest w jednej podstawowej grupie (nazywanej jego grupą podstawową, primary group) i może należeć do dowolnie wielu grup (nazywanych jego grupami dodatkowymi, supplementary groups).

Lista dostępnych użytkowników i grup oraz powiązania uid/gid z nazwami zwykle są czytane z plików /etc/passwd i /etc/groups, ale po odpowiedniej konfiguracji może być pobierana też z innych źródeł.
Np. można wykorzystać serwer LDAP, czy kontroler domeny AD za pośrednictwem programu winbindd. Więcej informacji na tutaj.
Hasła lokalnych użytkowników i grup są przechowywane w /etc/shadow i /etc/gshadow

W systemie plików zapisane są uidy i gidy (a nie nazwy użytkowników), stąd np. podłączenie dysku z jednego komputera do drugiego przypisze pliki innym nazwom użytkowników i grup jeżeli mapowania uid/gid na nazwy nie są identyczne na obu systemach.
To dotyczy również kontenerów (sic!).

Użytkownik o uid równym 0 nazywany jest superużytkownikiem (superuser) i ma zwyczajowo nadaną nazwę root.

Żeby sprawdzić swoją nazwę użytkownika, można skorzystać z komendy whoami.
Do sprawdzenia listy grup służy komenda groups [użytkownik]. Bez argumentów wyświetla grupy bieżącego użytkownika.

Zadanie 1 Przetestuj działanie komendy whoami.

Zadanie 2 Sprawdź listę grup w której jesteś. Sprawdź listę grup w której jest użytkownik student.

Zmiana hasła użytkownika jest wykonywana przy pomocy komendy passwd.
Root może przy pomocy passwd user ustawić hasło każdego użytkownika, może też zmienić czas ważności hasła bądź zablokować konto.

Przykłady:

user@host ~ $ whoami
user
user@host ~ $ groups
wheel users android
user@host ~ $ groups john
android chromium
user@host ~ $ id
uid=1005(user) gid=100(users) grupy=100(users),10(wheel),968(android)
user@host ~ $ id john
uid=1234(john) gid=1001(chromium) grupy=1001(chromium),968(android)

Listę osób bieżąco używających systemu można wyświetlić komendą w -n oraz who.

Historię logowań można wyświetlić używając polecenia last [-n ile_ostatnich] [username].

Zadanie 4 Zaloguj się po ssh na polluksa. Sprawdź jacy inni użytkownicy są zalogowani.

Zadanie 5 Na polluksie sprawdź jacy trzej użytkownicy logowali się ostatnio.

Zadanie 6 Na polluksie sprawdź kiedy ostatnio logował się użytkownik root.

Komendą write użytkownik [terminal] można wysłać tekst do wybranego użytkownika (kończąc wpisany tekst przez EOF, zwykle Ctrl+d).
Spowoduje to wyświetlenie mu podanego testu poprzedzonego komunikatem "message from…" w terminalu.
Otrzymywanie takich wiadomości można zablokować (bądź odblokować) komendą mesg {n|y}.

Można też wysłać wiadomość do wszystkich użytkowników komendą wall.

Zadanie 8 Napisz do sąsiada wiadomość. Zobacz na własnym ekranie wiadomość wysłaną od kogoś.

Przykłady:

user@host ~ $ who
user     tty2         2025-01-04 10:04 (:0)
user     pts/0        2025-01-04 10:04 (:0)
user     pts/1        2025-01-04 10:06 (:0)
user     pts/2        2025-01-04 12:25 (:0)
user     pts/4        2025-01-04 12:27 (:0)
user     tty3         2025-01-04 14:54
user     pts/6        2025-01-04 18:36 (:0)
jane     pts/5        2025-01-04 13:43
john     pts/3        2025-01-04 23:43
user@host ~ $ w
 23:46:14 up 13:45,  9 users,  load average: 0.97, 0.66, 0.53
USER     TTY        LOGIN@   IDLE   JCPU   PCPU WHAT
user     tty2      10:04   12:45m  0.00s  0.17s /usr/bin/startplasma-x11
user     pts/0     10:04    2:21   0.95s  0.72s /bin/bash
user     pts/1     10:06    2:04m  0.26s  0.06s alsamixer -c0
user     pts/2     12:25    0.00s  0.23s  0.23s /bin/bash
user     pts/4     12:27   54:13  10.42s 10.33s ssh root@10.0.0.7
user     tty3      14:54    8:52m  2:07    ?    xinit /etc/X11/xinit/xinitrc -- /etc/X11/xinit/xserverrc :1 -auth /tmp/serverauth.w8runSyQCb
user     pts/6     18:36    3:26m  0.21s   ?    /usr/bin/less
jane     pts/5     13:43    2:22   0.80s  0.52s top
john     pts/3     23:43    2:27   0.23s  0.01s /usr/lib/python-exec/python3.12/python
user@host ~ $ last -n 3 user
user     tty3                          Sat Jan  4 14:54   still logged in
user     pts/9                         Sat Jan  4 20:05 - 09:13 (5+13:08)
user     pts/1        :0               Thu Jan  2 10:05 - 10:21  (00:15)
wtmp begins Mon Dec 31 23:59:59 2024
user@host ~ $ last -n 7
john     pts/3                         Sat Jan  4 23:43   still logged in
user     tty3                          Sat Jan  4 14:54   still logged in
jane     pts/3                         Sat Jan  4 13:43   still logged in
user     pts/9                         Sat Jan  4 20:05 - 09:13 (2+13:08)
user     pts/1        :0               Thu Jan  2 10:05 - 10:21  (00:15)
user     pts/17       :0               Wed Jan  1 22:10 - 22:37  (00:26)
reboot   system boot  6.8.8            Wed Jan  1 22:08   still running
user     pts/16       :0               Wed Jan  1 12:10 - 12:37  (00:26)
wtmp begins Mon Dec 31 23:59:59 2024

Posiadając odpowiednie uprawnienia i/lub znając odpowiednie hasło (w zależności od ustawień systemu) można przełączyć się na innego użytkownika bądź wykonać komendę jako inny użytkownik.

Komenda su [-] [użytkownik] po autoryzacji uruchamia domyślną powłokę dla podanego użytkownika (domyślnie roota).
Komenda su -c komenda [-] [użytkownik] po autoryzacji uruchamia w domyślnej powłoce dla podanego użytkownika (domyślnie roota) podaną komendę.
su jest dostępna w każdym uniksopodobnym systemie. W domyślnych ustawieniach Linuksa komenda su wymaga podania hasła użytkownika docelowego (i w niektórych dystrybucjach przynależności do odpowiedniej grupy, zwykle wheel).

Na wielu dystrybucjach instalowana jest też komenda sudo która ma na celu zezwolenie wybranym użytkownikom na wykonywanie wybranych komend z uprawnieniami wskazanych użytkowników. Do autoryzacji sudo wykorzystuje hasło bieżącego bądź docelowego użytkownika. W niektórych dystrybucjach komenda sudo jest nadużywana do zastąpienia komendy su.

Zadanie 9 Zaloguj się na podany przez prowadzącego serwer przez ssh (prawdopodobnie ssh userN@fe80::1%br0). Zmień użytkownika na root. Zmień użytkownika na innego userN.

Przykłady:

user@host ~ $ su
Password:
root@host /home/user # exit
user@host ~ $ su john
Password:
[host /home/user]$ exit
exit
user@host ~ $ id
uid=1005(user) gid=100(users) groups=100(users),10(wheel),968(android)
user@host ~ $ newgrp android
user@host ~ $ id
uid=1005(user) gid=968(android) groups=968(android),10(wheel),100(users)
user@host ~ $ exit
exit
user@host ~ $ su john
Password:
[host /home/user]$ sg android -c 'ps -H -o user,group,cmd -t `tty`'
USER     GROUP    CMD
user     users    -bash
root     users      su john
john     chromium     bash
root     chromium       sg android -c ps -H -o user,group,cmd -t `tty`
john     android          ps -H -o user,group,cmd -t /dev/pts/11
[host /home/user]$ exit
exit
user@host ~ $

W uniksopodobnych systemach dostęp do pliku określają trzy podstawowe uprawnienia: odczytu (read), zapisu (write) i wykonania (execute).
Każde z tych uprawnień jest przyznawane osobno właścicielowi pliku (user), grupie pliku (group) i pozostałym użytkownikom (others).
Dodatkowo można ustawić trzy uprawnienia specjalne: set-user-id (suid, s), set-group-id (sgid, s) i sticky (t).

Przy dostępie do pliku, jeżeli plik należy do bieżącego użytkownika, brane są pod uwagę tylko uprawnienia użytkownika.
Jeżeli plik nie należy do użytkownika, ale użytkownik należy do grupy pliku, brane są pod uwagę tylko uprawnienia grupy.
Jeżeli plik nie należy do użytkownika i użytkownik nie należy do grupy pliku, brane są pod uwagę tylko uprawnienia pozostałych.
Zauważ że jeśli plik ma ustawione prawo do odczytu dla grupy ale nie ma prawa odczytu dla użytkownika, to właściciel pliku nie może wyświetlić tego pliku nawet jeśli należy do grupy pliku.

Prawo do wykonania dla pliku oznacza możliwość uruchomienia go (jako skrypt, program etc.), dla katalogu – wejścia do niego.

Suid/sgid nadany zwykłym plikom oznacza, że po uruchomieniu proces będzie działać z efektywnym uid/gid właściciela pliku.
Zauważ że skrypt są interpretowane przez inny program, nie uruchamiane. Nadanie skryptowi suid/sgid nie ma wpływu na jego działanie.
Suid pozwala np. zwykłemu użytkownikowi zmienić hasło (czyli zmienić plik /etc/shadow do którego zwykły użytkownik nie ma dostępu).
Sgid pozwala np. zwykłemu użytkownikowi uruchamiać maszyny wirtualne w VirtualBoxie czy analizować pakiety sieciowe w Wiresharku.

Sticky bit nadany katalogowi D oznacza, że plik X z katalogu D może usunąć tylko właściciel pliku X bądź katalogu D.
Sticky bit ustawiany jest w katalogu /tmp i innych, gdzie każdy użytkownik może tworzyć pliki o to, by tylko właściciel (bądź root) mogli usunąć pliki.

Uprawnienia są przechowywane jako liczba, gdzie wartości kolejnych bitów oznaczają (od najstarszego bitu): prawa specjalne (w kolejności suid, sgid, sticky), i prawa dla użytkownika, grupy, innych (w kolejności odczyt, zapis, wykonanie).
Numerycznie uprawnienia zapisuje się w systemie ósemkowym, np: 4751 gdzie kolejne cyfry oznaczają uprawnienia specjalne (tutaj: suid), użytkownika (tutaj: wszystkie), grupy (tutaj: odczyt i wykonanie) i innych (tutaj: wykonanie).

Tekstowo uprawnienia zapisuje się jako: rwxrwxrwx, gdzie kolejne trójki to właśnie uprawnienia użytkownika, grupy i innych.
Brak danego uprawnienia zapisuje się przez -.
Zwykle przed tak zapisanymi uprawnieniami pojawia się dodatkowa litera określająca typ pliku.
Uprawnienia specjalne zapisuje się na pozycji uprawnień wykonania: suid i prawo do wykonanie to s, suid i brak prawa do wykonania to S na pozycji użytkownika. Analogicznie prezentowany jest sgid na pozycji grupy, i sticky bit z literami t i T na pozycji pozostałych.
Przykładowo: rw-r--r-- oznacza że użytkownik ma prawo zapisu i odczytu, a grupa i pozostali tylko do odczytu (równoważne 644),
a rwx--x--x pozwalają właścicielowi na odczyt, zapis i wykonanie pliku, a grupie i pozostałym tylko na wykonanie (711).

Aby zobaczyć szczegółowe informacje o pliku, w tym uprawnienia, można wykonać stat plik.
Uprawnienia są też wyświetlane w wynikach ls -l i tree -p.
Wszystkie powyższe polecenia dodają na początek uprawnień literę określającą rodzaj pliku.

Zadanie 10 Sprawdź jakie uprawienia mają (na twoim komputerze):

• twój katalog domowy
• podkatalog .ssh w twoim katalogu domowym
• plik .bash_history w twoim katalogu domowym
• plik /etc/passwd i /etc/shadow
• katalog /tmp
• plik /usr/bin/passwd i /usr/bin/write

Zadanie 11 Sprawdź jakie mają uprawnienia i jakim są rodzajem plików:

• /var/run
• /dev/sda lub /dev/nvme0n1
• /dev/null
• /run/initctl
• /run/rpcbind.sock

Domyślnie uprawnienia nadawane plikom i katalogom określa maska którą można odczytać poleceniem umask (i zmienić dla bieżącej powłoki poleceniem umask oktalnie).

Do zmiany uprawnień służy komenda chmod uprawnienia plik.
chmod przyjmuje uprawnienia w postaci ósemkowej, np. chmod 644 plik lub w postaci symbolicznej.
Postać symboliczna to oddzielone przecinkami wyrażenia na które składa się:

• litera u, g, o lub a (user, group, others lub all - wszyscy)
• operacja +, - lub = (dodaj, usuń lub ustaw te prawa)
• uprawnienia r, w, x, s lub t.

Np. chmod u+x,o= plik doda użytkownikowi prawo do zapisu i ustawi brak praw dla innych (a prawa grupy zostaną bez zmian).
Pominięcie litery [ugoa] przed operacją ma specjalne znaczenie, szczegóły w podręczniku systemowym.

Uprawnienia dostępu może zmieniać tylko właściciel pliku (i root).

Właściciel pliku będący w kliku grupach może użyć komendy chgrp grupa plik do zmiany grupy do której należy plik.

Tylko root może zmienić właściciela (i grupę) pliku poleceniem chown [właściciel][:[grupa]] plik.

Zarówno chmod, chgrp i chown przyjmują przełączniki -R (--recursive) dla rekursywnej zmiany i --reference=plik dla ustawienia uprawnień/grupy/właściciela identycznego jak we wskazanym pliku.

Ćwiczenia wykonuj na podanym przez prowadzącego serwerze.
Do tworzenia plików możesz wykorzystać np. komendę fortune > plik.

Zadanie 12 Stwórz plik. Ustaw takie prawa dostępu, żeby tylko właściciel mógł odczytać plik.
Sprawdź poprawność nadanych praw przełączając się na innych użytkowników.

Zadanie 13 Stwórz plik. Ustaw korzystając z ósemkowego zapisu takie prawa dostępu, żeby właściciel mógł zmodyfikować i odczytać plik, a grupa mogła tylko odczytać plik. Sprawdź poprawność nadanych praw.

Zadanie 14 Stwórz plik. Ustaw korzystając z symbolicznego zapisu takie prawa dostępu, żeby właściciel mógł zmodyfikować i odczytać plik, a grupa mogła tylko odczytać plik.

Zadanie 15 Zmień grupę pliku z poprzedniego zadania.

Zadanie 16 Stwórz plik. Ustaw takie prawa dostępu, żeby tylko właściciel i pozostali mogli odczytać plik. Sprawdź czy osoba należąca do grupy pliku może go odczytać.

Zadanie 17 Stwórz katalog ze zwykłym plikiem w środku. Odbierz prawo do wykonywania katalogu. Spróbuj wylistować katalog, wejść do katalogu i wyświetlić plik bez wchodzenia do katalogu.

Zadanie 18 Zmień prawa dostępu katalogu na u=rwx,go=rx. Stwórz w tym katalogu zwykły plik. Wyświetl plik jako inny użytkownik. Wyświetl zawartość katalogu jako inny użytkownik.
Następnie zmień prawa do katalogu u=rwx,go=x. Spróbuj ponownie wyświetlić plik i zawartość katalogu jako inny użytkownik.

Zadanie 19 Stwórz katalog z prawami dostępu 777 i stwórz w nim dwa pliki. Jednemu z nich ustaw prawa 600. Z innego użytkownika spróbuj usunąć oba pliki.

Zadanie 20 W katalogu użytkownika A z prawami dostępu 777 stwórz jako użytkownik B dwa katalogi: jeden pusty, jeden z plikiem w środku. Spróbuj usunąć te katalogi jako użytkownik A.

Zadanie 21 Czy możesz zmienić nazwę katalogu K który nie dał się usunąć w poprzednim zadaniu? Czy możesz przenieść katalog K do innego? Czy możesz przenieść katalog zawierający K do innego?

Zadanie 22 Stwórz plik i katalog z plikiem w środku i odbierz wszystkim trzem wszystkie uprawnienia. Zmień użytkownika na root i spróbuj wyświetlić oba pliki.

Zadanie 23 Z roota zmień właściciela wybranego pliku. Następnie zmień grupę innego pliku na www-data.

user@host ~ $ umask
0022
user@host ~ $ mkdir d_zero-two-two
user@host ~ $ touch f_zero-two-two
user@host ~ $ umask 027
user@host ~ $ mkdir d_zero-two-seven
user@host ~ $ touch f_zero-two-seven
user@host ~ $ umask 421
user@host ~ $ mkdir d_four-two-one
user@host ~ $ touch f_four-two-one
user@host ~ $ ls -ltr
drwxr-xr-x 2 user users  4096 Jan 04 00:01 d_zero-two-two
-rw-r--r-- 1 user users     0 Jan 04 00:02 f_zero-two-two
drwxr-x--- 2 user users  4096 Jan 04 00:03 d_zero-two-seven
-rw-r----- 1 user users     0 Jan 04 00:04 f_zero-two-seven
d-wxr-xrw- 2 user users  4096 Jan 04 00:05 d_four-two-one
--w-r--rw- 1 user users     0 Jan 04 00:06 f_four-two-one

user@host ~/perms $ ls -l butterflies.txt
-rw-r--r-- 1 user users 55 Jan 04 12:00 butterflies.txt
user@host ~/perms $ stat butterflies.txt
  File: butterflies.txt
  Size: 55              Blocks: 8          IO Block: 4096   regular file
Device: 254,3   Inode: 15466579    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
Access: 2025-01-04 12:00:00.000000000 +0100
Modify: 2025-01-04 12:00:00.000000000 +0100
Change: 2025-01-04 12:00:00.000000000 +0100
 Birth: 2025-01-04 12:00:00.000000000 +0100

user@host ~/perms $ stat butterflies.txt | sed -n '4p'
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod g+w butterflies.txt
user@host ~/perms $ stat butterflies.txt | sed -n '4p'
Access: (0664/-rw-rw-r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod ug+x butterflies.txt
user@host ~/perms $ stat butterflies.txt | sed -n '4p'
Access: (0774/-rwxrwxr--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod o-r butterflies.txt
user@host ~/perms $ stat butterflies.txt | sed -n '4p'
Access: (0770/-rwxrwx---)  Uid: ( 1005/    user)   Gid: (  100/   users)

user@host ~/perms $ stat field.txt | sed -n '4p'
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod ug+x,g+w,o-r field.txt
user@host ~/perms $ stat field.txt | sed -n '4p'
Access: (0770/-rwxrwx---)  Uid: ( 1005/    user)   Gid: (  100/   users)

user@host ~/perms $ stat pause.txt | sed -n '4p'
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod 770 pause.txt
user@host ~/perms $ stat pause.txt | sed -n '4p'
Access: (0770/-rwxrwx---)  Uid: ( 1005/    user)   Gid: (  100/   users)

user@host ~/perms $ chmod 0 rain.txt
user@host ~/perms $ stat rain.txt | sed -n '4p'
Access: (0000/----------)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ umask
0022
user@host ~/perms $ chmod +rw rain.txt
user@host ~/perms $ stat rain.txt | sed -n '4p'
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)

user@host ~/perms $ stat smell.txt | sed -n '4p'
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod g+s,o= smell.txt
user@host ~/perms $ stat smell.txt | sed -n '4p'
Access: (2640/-rw-r-S---)  Uid: ( 1005/    user)   Gid: (  100/   users)
user@host ~/perms $ chmod g+x smell.txt
user@host ~/perms $ stat smell.txt | sed -n '4p'
Access: (2650/-rw-r-s---)  Uid: ( 1005/    user)   Gid: (  100/   users)

user@host ~/perms $ chmod 077 butterflies.txt
user@host ~/perms $ chmod 707 field.txt
user@host ~/perms $ chmod 770 pause.txt
user@host ~/perms $ chgrp android field.txt
user@host ~/perms $ ls -l
total 24
----rwxrwx 1 user users     55 Jan 04 12:00 butterflies.txt
-rwx---rwx 1 user android   82 Jan 04 12:00 field.txt
-rwxrwx--- 1 user users     85 Jan 04 12:00 pause.txt
user@host ~/perms $ cat butterflies.txt
cat: butterflies.txt: Permission denied
user@host ~/perms $ su john
Password:
[host /home/user/perms]$ groups
android chromium
[host /home/user/perms]$ cat field.txt
cat: field.txt: Permission denied
[host /home/user/perms]$ cat pause.txt
cat: pause.txt: Permission denied

user@host ~ $ touch incoming
user@host ~ $ chmod 422 incoming
user@host ~ $ cat incoming
user@host ~ $ echo "hello" >  incoming
-bash: incoming: Permission denied
user@host ~ $ su jane
Password:
jane@host /home/user $ cat incoming
cat: incoming: Permission denied
jane@host /home/user $ echo "hello" >  incoming
jane@host /home/user $ echo "user!" >> incoming
jane@host /home/user $ exit
exit
user@host ~ $ cat incoming
hello
user!

user@host ~ $ chgrp android ffa
user@host ~ $ chmod g+w ffa
user@host ~ $ cd ffa
user@host ~/ffa $ touch user_file
user@host ~/ffa $ su john
Password:
[host /home/user/ffa]$ id
uid=1234(john) gid=1001(chromium) groups=1001(chromium),968(android)
[host /home/user/ffa]$ mkdir john_empty_dir john_dir
[host /home/user/ffa]$ touch john_file1 john_file2 john_file3 john_dir/file
[host /home/user/ffa]$ exit
exit
user@host ~/ffa $ su jane
Password:
jane@host /home/user/ffa $ touch jane_file
jane@host /home/user/ffa $ tree -pug
[drwxrwxr-x user     android ]  .
├── [-rw-r--r-- jane     android ]  jane_file
├── [drwxr-xr-x john     chromium]  john_dir
│   └── [-rw-r--r-- john     chromium]  file
├── [drwxr-xr-x john     chromium]  john_empty_dir
├── [-rw-r--r-- john     chromium]  john_file1
├── [-rw-r--r-- john     chromium]  john_file2
├── [-rw-r--r-- john     chromium]  john_file3
└── [-rw-r--r-- user     users   ]  user_file
3 directories, 6 files
jane@host /home/user/ffa $ rm -f user_file
jane@host /home/user/ffa $ rm -f john_file1
jane@host /home/user/ffa $ rm -rf john_empty_dir
jane@host /home/user/ffa $ rm -rf john_dir
rm: cannot remove 'john_dir/file': Permission denied
jane@host /home/user/ffa $ tree -pug
[drwxrwxr-x user     android ]  .
├── [-rw-r--r-- jane     android ]  jane_file
├── [drwxr-xr-x john     chromium]  john_dir
│   └── [-rw-r--r-- john     chromium]  file
├── [-rw-r--r-- john     chromium]  john_file2
└── [-rw-r--r-- john     chromium]  john_file3
2 directories, 4 files
jane@host /home/user/ffa $ exit
exit
user@host ~/ffa $ chmod o+t .
user@host ~/ffa $ su jane
Password:
jane@host /home/user/ffa $ rm -f jane_file
jane@host /home/user/ffa $ rm -f john_file2
rm: cannot remove 'john_file2': Operation not permitted
jane@host /home/user/ffa $ exit
exit
user@host ~/ffa $ rm -f john_file2
user@host ~/ffa $ chmod go=rx .
user@host ~/ffa $ su john
Password:
[host /home/user/ffa]$ tree -pug
[drwxr-xr-x user     android ]  .
├── [drwxr-xr-x john     chromium]  john_dir
│   └── [-rw-r--r-- john     chromium]  file
└── [-rw-r--r-- john     chromium]  john_file3
2 directories, 2 files
[host /home/user/ffa]$ rm john_file3
rm: cannot remove 'john_file3': Permission denied

suid i sgid

user@host ~ $ pygmentize prog.c
int main(int, char **a) {
  char *name;
  asprintf(&name, "%s.txt", a[0]);
  int file = creat(name, 0644);
  free(name);
  write(file, "Hello\n", 6);
  close(file);
  execlp("id", "id", 0);
  return 1;
}
user@host ~ $ gcc -w -ansi ./prog.c -o prog
user@host ~ $ su
Password:
root@host /home/user # cp prog prog-suid
root@host /home/user # cp prog prog-sgid
root@host /home/user # cp prog prog-none
root@host /home/user # chown daemon:man prog-*
root@host /home/user # chmod u+s prog-suid
root@host /home/user # chmod g+s prog-sgid
root@host /home/user # exit
user@host ~ $ stat prog-* | awk '/F/{f=$0}/)/{print f "\t" $0}'
  File: prog-none       Access: (0755/-rwxr-xr-x)  Uid: (    2/  daemon)   Gid: (   15/     man)
  File: prog-sgid       Access: (2755/-rwxr-sr-x)  Uid: (    2/  daemon)   Gid: (   15/     man)
  File: prog-suid       Access: (4755/-rwsr-xr-x)  Uid: (    2/  daemon)   Gid: (   15/     man)
user@host ~ $ chmod go+w .
user@host ~ $ ./prog-none
uid=1005(user) gid=100(users) groups=100(users),10(wheel),968(android)
user@host ~ $ ./prog-suid
uid=1005(user) gid=100(users) euid=2(daemon) groups=100(users),10(wheel),968(android)
user@host ~ $ ./prog-sgid
uid=1005(user) gid=100(users) egid=15(man) groups=15(man),10(wheel),100(users),968(android)
user@host ~ $ stat prog-*.txt | awk '/F/{f=$0}/)/{print f "\t" $0}'
  File: prog-none.txt   Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
  File: prog-sgid.txt   Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (   15/     man)
  File: prog-suid.txt   Access: (0644/-rw-r--r--)  Uid: (    2/  daemon)   Gid: (  100/   users)
user@host ~ $ ls -ltr prog-*
-rwsr-xr-x 1 daemon man   15680 Jan 04 12:01 prog-suid
-rwxr-sr-x 1 daemon man   15680 Jan 04 12:02 prog-sgid
-rwxr-xr-x 1 daemon man   15680 Jan 04 12:03 prog-none
-rw-r--r-- 1 user   users     6 Jan 04 12:04 prog-none.txt
-rw-r--r-- 1 user   man       6 Jan 04 12:05 prog-sgid.txt
-rw-r--r-- 1 daemon users     6 Jan 04 12:06 prog-suid.txt

Linuksowe system plików zwykle przechowują datę zmiany metadanych (change, ctime), zmiany treści (modify, mtime) i ostatniego dostępu (access, atime) dla każdego pliku. Niektóre systemy plików dodatkowo przechowują też czas utworzenia pliku.
Montując system plików często wyłącza się rejestrowanie czasu ostatniego dostępu podając opcję noatime lub ustawia zmianę tego czasu tylko w szczególnych przypadkach podając opcję relatime. Komenda mnt i findmnt wyświetlają z jakimi opcjami zamontowano system plików.

Polecenie stat plik pokazuje te czasy.

Komenda touch plik ustawia czas dostępu i modyfikacji pliku, domyślnie na teraz.
Podając -d data lub --reference=plik można wybrać inną datę, a -a, -c i -m wybierają który czas zmodyfikować.
Jeśli plik docelowy nie istnieje, domyślnie komenda touch go stworzy. Jest to często używane do tworzenia pustych plików.

Zadanie 24 Sprawdź daty dla pliku /var/log/wtmp

Zadanie 25 Zmień daty do swojego katalogu domowego.

Przykłady:

user@host ~ $ stat essay.odt
  File: essay.odt
  Size: 73414           Blocks: 144        IO Block: 4096   regular file
Device: 254,3   Inode: 15466607    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
Access: 2025-01-02 12:00:00.000000000 +0100
Modify: 2025-01-01 12:00:00.000000000 +0100
Change: 2025-01-02 12:00:00.000000000 +0100
 Birth: 2025-01-01 12:00:00.000000000 +0100
user@host ~ $ ls -l essay.odt
-rw-r--r-- 1 user users 73414 Jan  1 12:00 essay.odt
user@host ~ $ touch -d '2025-01-03 12:34' essay.odt
user@host ~ $ stat essay.odt
  File: essay.odt
  Size: 73414           Blocks: 144        IO Block: 4096   regular file
Device: 254,3   Inode: 15466607    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
Access: 2025-01-03 12:34:00.000000000 +0100
Modify: 2025-01-03 12:34:00.000000000 +0100
Change: 2025-01-05 12:00:00.000000000 +0100
 Birth: 2025-01-01 12:00:00.000000000 +0100
user@host ~ $ ls -l essay.odt
-rw-r--r-- 1 user users 73414 Jan  3 12:34 essay.odt
user@host ~ $ touch -a -d 'yesterday 6pm' essay.odt
user@host ~ $ stat essay.odt
  File: essay.odt
  Size: 73414           Blocks: 144        IO Block: 4096   regular file
Device: 254,3   Inode: 15466607    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
Access: 2025-01-04 18:00:00.000000000 +0100
Modify: 2025-01-03 12:34:00.000000000 +0100
Change: 2025-01-05 12:00:00.000000000 +0100
 Birth: 2025-01-01 12:00:00.000000000 +0100
user@host ~ $ ls -l essay.odt
-rw-r--r-- 1 user users 73414 Jan  3 12:34 essay.odt
user@host ~ $ date
Sun Jan  5 12:00:00 CET 2025
user@host ~ $ touch essay.odt
user@host ~ $ stat essay.odt
  File: essay.odt
  Size: 73414           Blocks: 144        IO Block: 4096   regular file
Device: 254,3   Inode: 15466607    Links: 1
Access: (0644/-rw-r--r--)  Uid: ( 1005/    user)   Gid: (  100/   users)
Access: 2025-01-05 12:00:00.000000000 +0100
Modify: 2025-01-05 12:00:00.000000000 +0100
Change: 2025-01-05 12:00:00.000000000 +0100
 Birth: 2025-01-01 12:00:00.000000000 +0100
user@host ~ $ ls -l essay.odt
-rw-r--r-- 1 user users 73414 Jan  5 12:01 essay.odt