5.3 Lezione 1

Certificazione:

Linux Essentials

Versione:

1.6

Argomento:

5 Sicurezza e Permessi sui File

Obiettivo:

5.3 Gestione delle Autorizzazioni e delle Proprietà dei File

Lezione:

1 di 1

Introduzione

Essendo un sistema multiutente, Linux ha bisogno di un modo per tenere traccia di chi sia il proprietario di ciascun file e se un utente sia autorizzato o meno a eseguire azioni su quel file. Questo per garantire la privacy degli utenti che potrebbero voler mantenere riservato il contenuto dei propri file, nonché per garantire la collaborazione rendendo alcuni file accessibili a più utenti.

Ciò avviene attraverso un sistema di permessi a tre livelli: ogni file sul disco è di proprietà di un utente e di un gruppo di utenti e dispone di tre tipi di permessi: uno per il suo proprietario, uno per il gruppo che possiede il file e uno per tutti gli altri. In questa lezione imparerai come individuare i permessi di un file e come modificarli.

Ricercare Informazioni su File e Directory

Il comando ls viene utilizzato per ottenere un elenco dei contenuti di qualsiasi directory. In questa forma base, ciò che ottieni sono solo i nomi dei file:

$ ls
Another_Directory  picture.jpg  text.txt

Ma ci sono molte più informazioni disponibili per ogni file, inclusi il tipo, la dimensione, chi lo possiede (ownership) e altro. Per vedere queste informazioni devi chiedere a ls un elenco di “forma lunga” (long form), utilizzando il parametro -l:

$ ls -l
total 536
drwxrwxr-x 2 carol carol   4096 Dec 10 15:57 Another_Directory
-rw------- 1 carol carol 539663 Dec 10 10:43 picture.jpg
-rw-rw-r-- 1 carol carol   1881 Dec 10 15:57 text.txt

Ogni colonna dell’output sopra riportato ha un significato specifico:

La prima colonna dell’elenco mostra il tipo di file e i permessi.

Per esempio, in drwxrwxr-x:
- Il primo carattere, d, indica il tipo di file.
- I successivi tre caratteri, rwx, indicano i permessi del proprietario del file, indicato anche come utente (user) o u.
- I successivi tre caratteri, rwx, indicano i permessi del gruppo (group) che possiede il file, indicato anche come g.
- Gli ultimi tre caratteri, r-x, indicano i permessi per tutti gli altri, noti anche come others o o.
La seconda colonna indica il numero di hard link che puntano a quel file. Per una directory è il numero di sottodirectory, più un link a se stessa (.) e alla directory padre (..).
La terza e la quarta colonna mostrano informazioni di ownership: rispettivamente l’utente e il gruppo che possiede il file.
La quinta colonna mostra la dimensione del file, in byte.
La sesta colonna mostra la data e l’ora precise, o timestamp, dell’ultima modifica del file.
La settima e ultima colonna mostra il nome del file.

Se desideri vedere le dimensioni dei file in un formato “leggibile dall’uomo”, aggiungi il parametro -h a ls. I file di dimensioni inferiori a 1 kilobyte avranno la dimensione mostrata in byte. I file di dimensioni maggiori di 1 kilobyte e inferiori a 1 megabyte avranno una K dopo la dimensione, a indicare che la dimensione è in kilobyte. Lo stesso vale per le dimensioni dei file negli intervalli dei megabyte (M) e dei gigabyte (G):

$ ls -lh
total 1,2G
drwxrwxr-x 2 carol carol 4,0K Dec 10 17:59 Another_Directory
----r--r-- 1 carol carol    0 Dec 11 10:55 foo.bar
-rw-rw-r-- 1 carol carol 1,2G Dec 20 18:22 HugeFile.zip
-rw------- 1 carol carol 528K Dec 10 10:43 picture.jpg
---xr-xr-x 1 carol carol   33 Dec 11 10:36 test.sh
-rwxr--r-- 1 carol carol 1,9K Dec 20 18:13 text.txt
-rw-rw-r-- 1 carol carol 2,6M Dec 11 22:14 Zipped.zip

Per mostrare solo le informazioni su un insieme specifico di file, aggiungi i nomi di questi file a ls:

$ ls -lh HugeFile.zip test.sh
total 1,2G
-rw-rw-r-- 1 carol carol 1,2G Dec 20 18:22 HugeFile.zip
---xr-xr-x 1 carol carol   33 Dec 11 10:36 test.sh

E per le Directory?

Se provi a ricercare informazioni su una directory usando ls -l, il comando ti mostrerà invece un elenco dei contenuti della directory:

$ ls -l Another_Directory/
total 0
-rw-r--r-- 1 carol carol 0 Dec 10 17:59 another_file.txt

Per evitare questo comportamento e richiedere informazioni sulla directory stessa, aggiungi l’opzione -d a ls:

$ ls -l -d Another_Directory/
drwxrwxr-x 2 carol carol 4096 Dec 10 17:59 Another_Directory/

Visualizzare File Nascosti

L’elenco che abbiamo recuperato utilizzando ls -l visto in precedenza è incompleto:

$ ls -l
total 544
drwxrwxr-x 2 carol carol   4096 Dec 10 17:59 Another_Directory
-rw------- 1 carol carol 539663 Dec 10 10:43 picture.jpg
-rw-rw-r-- 1 carol carol   1881 Dec 10 15:57 text.txt

Ci sono altri tre file in questa directory, ma sono nascosti. In Linux, i file il cui nome inizia con un punto (.) vengono automaticamente nascosti. Per vederli dobbiamo aggiungere l’opzione -a a ls:

$ ls -l -a
total 544
drwxrwxr-x 3 carol carol   4096 Dec 10 16:01 .
drwxrwxr-x 4 carol carol   4096 Dec 10 15:56 ..
drwxrwxr-x 2 carol carol   4096 Dec 10 17:59 Another_Directory
-rw------- 1 carol carol 539663 Dec 10 10:43 picture.jpg
-rw-rw-r-- 1 carol carol   1881 Dec 10 15:57 text.txt
-rw-r--r-- 1 carol carol      0 Dec 10 16:01 .thisIsHidden

Il file .thisIsHidden è semplicemente nascosto poiché il suo nome inizia con un ..

Le directory . e .. tuttavia sono directory speciali: . è un puntatore alla directory corrente, mentre .. è un puntatore alla directory padre (la directory che contiene la directory corrente). In Linux, ogni directory contiene almeno queste due directory speciali.

Tip	Puoi combinare più opzioni per `ls` (e molti altri comandi Linux). Per esempio, `ls -l -a` può essere scritto come `ls -la`.

Comprendere i Tipi di File

Abbiamo già detto che la prima lettera nell’output di ls -l descrive il tipo di file. I tre tipi di file più comuni sono:

- (file normale): Un file può contenere dati di qualsiasi tipo. I file possono essere modificati, spostati, copiati ed eliminati.
d (directory): Una directory contiene altri file o directory e aiuta a organizzare il file system. Tecnicamente, le directory sono un tipo speciale di file.
l (soft link): Questo “file” è un puntatore a un altro file o a una directory che si trova altrove nel filesystem.

Oltre a questi, ci sono almeno altri tre tipi di file che dovresti conoscere, ma che non rientrano nell’ambito di questa lezione:

b (dispositivo a blocchi): Questo file rappresenta un dispositivo virtuale o fisico, solitamente dei dischi o altri tipi di dispositivi di archiviazione. Per esempio, il primo disco rigido nel sistema potrebbe essere rappresentato da /dev/sda.
c (dispositivo a caratteri): Questo file rappresenta un dispositivo virtuale o fisico. I terminali (come il terminale principale su /dev/ttyS0) e le porte seriali sono esempi comuni di dispositivi a caratteri.
s (socket): I socket fungono da “condotti” per il passaggio di informazioni tra due programmi.

Warning

Non modificare nessun permesso su dispositivi a blocchi, dispositivi a caratteri o socket, a meno che tu non sappia cosa stai facendo. Questo potrebbe impedire al tuo sistema di funzionare!

Comprendere i Permessi

Nell’output di ls -l i permessi di un file sono mostrati subito dopo il tipo di file, come tre gruppi di tre caratteri ciascuno, secondo l’ordine r, w e x. Vedremo ora cosa significano. Tieni presente che un trattino - rappresenta la mancanza di un certo permesso.

Permessi sui File

r: Sta per read (lettura) e ha un valore ottale pari a 4 (non preoccuparti, discuteremo a breve di valori ottali). Ciò significa il permesso di aprire un file e leggerne il contenuto.
w: Sta per write (scrittura) e ha un valore ottale pari a 2. Ciò significa il permesso di modificare o eliminare un file.
x: Sta per execute (esecuzione) e ha un valore ottale pari a 1. Ciò significa che il file può essere eseguito come un eseguibile o uno script.

Quindi, per esempio, un file con permessi pari a rw- può essere letto e scritto, ma non può essere eseguito.

Permessi sulle Directory

r: Sta per read (lettura) e ha un valore ottale pari a 4. Ciò significa il permesso di leggere il contenuto della directory, come i nomi dei file, ma non implica il permesso di leggere i file stessi.
w: Sta per write (scrittura) e ha un valore ottale pari a 2. Ciò significa il permesso di creare o eliminare file in una directory o di modificarne i nomi, i permessi e i proprietari. Se un utente dispone dei permessi di scrittura su una directory, può modificare i permessi di qualsiasi file nella directory, anche se l’utente non ha permessi sul file o se il file è di proprietà di un altro utente.
x: Sta per execute e ha un valore ottale pari a 1. Ciò significa il permesso di entrare in una directory, ma non di elencare i suoi file (per questo, è necessario il permesso r).

L’ultimo bit per le directory può sembrare un po' confusionario. Immaginiamo, per esempio, di avere una directory chiamata Another_Directory con i seguenti permessi:

$ ls -ld Another_Directory/
d--xr-xr-x 2 carol carol 4,0K Dec 20 18:46 Another_Directory

Immagina anche che all’interno di questa directory tu abbia uno script di shell chiamato hello.sh con i seguenti permessi:

-rwxr-xr-x 1 carol carol 33 Dec 20 18:46 hello.sh

Se sei l’utente carol e cerchi di elencare il contenuto di Another_Directory, riceverai un messaggio di errore, poiché il tuo utente non ha i permessi di lettura per quella directory:

$ ls -l Another_Directory/
ls: cannot open directory 'Another_Directory/': Permission denied

Tuttavia, l’utente carol dispone dei permessi di esecuzione, il che significa che può entrare nella directory. Pertanto, l’utente carol può accedere ai file all’interno della directory, purché abbia i permessi corretti per i rispettivi file. In questo esempio, l’utente ha i permessi completi per lo script hello.sh; quindi può eseguire lo script anche se non può leggere il contenuto della directory che lo contiene. Tutto ciò di cui ha bisogno è il nome del file completo.

$ sh Another_Directory/hello.sh
Hello LPI World!

Come detto in precedenza i permessi sono specificati in sequenza: prima per il proprietario del file, poi per il gruppo proprietario e infine per gli altri utenti. Ogni volta che qualcuno tenta di eseguire un’azione sul file, i permessi vengono verificati nello stesso ordine. Per prima cosa il sistema controlla se l’utente corrente possiede il file e, se questo è vero, applica solo la prima serie di permessi. In caso contrario, controlla se l’utente corrente appartiene al gruppo proprietario del file. In tal caso, applica solo la seconda serie di permessi. In ogni altro caso, il sistema applica la terza serie di permessi. Ciò significa che se l’utente corrente è il proprietario del file, sono applicati solo i permessi del proprietario, anche se i permessi di gruppo o degli altri fossero superiori a quelli del proprietario.

Modificare i Permessi dei File

Il comando chmod viene utilizzato per modificare i permessi di un file e necessita almeno di due parametri: il primo descrive quali permessi devono essere modificati, mentre il secondo punta al file o alla directory su cui verrà effettuata la modifica. Tuttavia, i permessi per la modifica possono essere indicati in due modi diversi, o “modalità”.

La prima, chiamata modalità simbolica, offre un controllo granulare, consentendo di aggiungere o revocare un singolo permesso senza modificare gli altri all’interno del set di permessi. L’altra, chiamata modalità numerica, è più facile da ricordare e più veloce da usare se desideri impostare tutti i valori dei permessi contemporaneamente.

Entrambe le modalità porteranno allo stesso risultato finale. Quindi, per esempio, i comandi:

$ chmod ug+rw-x,o-rwx text.txt

$ chmod 660 text.txt

produrranno esattamente lo stesso output, ovvero un file con impostati i seguenti permessi:

-rw-rw---- 1 carol carol  765 Dec 20 21:25 text.txt

Capiamo ora come funziona ciascuna modalità.

Modalità Simbolica

Quando si indicano quali permessi cambiare in modalità simbolica, il(i) primo(i) carattere(i) indica(no) quali permessi saranno oggetto della modifica: quelli per l’utente (u), per il gruppo (g), per gli altri (o), e/o per tutti e tre insieme (a).

A questo punto devi dire al comando che cosa fare: puoi concedere un permesso (+), revocare un permesso (-) o impostare un permesso a un valore specifico (=).

Infine, devi specificare quale permesso si desidera impostare: lettura (r), scrittura (w) o esecuzione (x).

Per esempio, immagina di avere un file chiamato text.txt con i seguenti permessi:

$ ls -l text.txt
-rw-r--r-- 1 carol carol 765 Dec 20 21:25 text.txt

Se desideri concedere i permessi di scrittura ai membri del gruppo che possiede il file, devi utilizzare il parametro g+w. È più facile se pensi in questo modo: “Per il gruppo (g), concedi (+) i permessi di scrittura (w)”. Quindi, il comando da usare è:

$ chmod g+w text.txt

Controlliamo il risultato con ls:

$ ls -l text.txt
-rw-rw-r-- 1 carol carol 765 Dec 20 21:25 text.txt

Se vuoi rimuovere i permessi di lettura per il proprietario dello stesso file, puoi pensare in questo modo: “Per l’utente (u) revoca (-) i permessi di lettura (r)”. Quindi il parametro è u-r come puoi vedere qui sotto:

$ chmod u-r text.txt
$ ls -l text.txt
--w-rw-r-- 1 carol carol 765 Dec 20 21:25 text.txt

E se volessimo impostare i permessi esattamente a rw- per tutti? Pensalo in questo modo: “Per tutti (a), imposta esattamente (=) i permessi di lettura (r), scrittura (w) ma non di esecuzione (-)”:

$ chmod a=rw- text.txt
$ ls -l text.txt
-rw-rw-rw- 1 carol carol 765 Dec 20 21:25 text.txt

Ovviamente è possibile modificare più permessi contemporaneamente. In questo caso, separali con una virgola (,):

$ chmod u+rwx,g-x text.txt
$ ls -lh text.txt
-rwxrw-rw- 1 carol carol 765 Dec 20 21:25 text.txt

L’esempio sopra riportato può essere letto come: “Per l’utente (u) concedi (+) i permessi di lettura, scrittura ed esecuzione (rwx), per il gruppo (g) revoca (-) i permessi di esecuzione (x)”.

Quando viene eseguito su una directory, chmod modifica solo i permessi della directory. chmod ha una modalità ricorsiva, utile quando vuoi cambiare i permessi per “tutti i file all’interno di una directory e delle sue sottodirectory”. Per usarla, aggiungi l’opzione -R dopo il nome del comando e prima dei permessi da modificare, in questo modo:

$ chmod -R u+rwx Another_Directory/

Questo comando può essere letto nel seguente modo: “Ricorsivamente (-R), per l’utente (u) concedi (+) permessi di lettura, scrittura ed esecuzione (rwx)”.

Warning

Fai attenzione e pensaci due volte prima di utilizzare l’opzione -R, poiché è facile cambiare permessi su file e directory che in realtà non vuoi modificare, specialmente su directory con un gran numero di file e sottodirectory.

Modalità Numerica

In modalità numerica, i permessi sono specificati in modo diverso: come valore numerico a tre cifre in notazione ottale, un sistema numerico in base 8.

Ogni permesso ha un valore corrispondente e i permessi sono specificati nel seguente ordine: prima viene il permesso di lettura (r) che ha valore 4, poi il permesso di scrittura (w) che ha valore 2 e infine il permesso di esecuzione (x), rappresentato dal valore 1. Se non ci sono permessi, usa il valore zero (0). Quindi, un permesso pari a rwx ha valore 7 (4+2+1), mentre un permesso r-x ha valore 5 (4+0+1).

La prima delle tre cifre all’interno del set dei permessi rappresenta i permessi per l’utente (u), la seconda rappresenta i permessi per il gruppo (g) e la terza rappresenta i permessi per gli altri (o). Se vogliamo impostare i permessi di un file a rw-rw----, il valore ottale da usare è 660:

$ chmod 660 text.txt
$ ls -l text.txt
-rw-rw---- 1 carol carol 765 Dec 20 21:25 text.txt

Inoltre, la sintassi in modalità numerica è la stessa della modalità simbolica: il primo parametro rappresenta i permessi che si desidera impostare e il secondo punta al file o alla directory su cui verrà effettuata la modifica.

Tip	Se il permesso ha valore dispari, il file è sicuramente eseguibile!

Quale sintassi usare? La modalità numerica è consigliata se si desidera modificare i permessi a un valore specifico, per esempio 640 (rw- r-- ---).

La modalità simbolica è più utile se si desidera modificare solo un valore specifico, indipendentemente dai permessi correnti del file. Per esempio, è possibile aggiungere solo i permessi di esecuzione per l’utente usando chmod u+x script.sh senza preoccuparsi, o addirittura senza neanche toccare, i permessi correnti per il gruppo e per gli altri.

Modificare la Proprietà dei File

Il comando chown viene utilizzato per modificare la proprietà (ownership) di un file o di una directory. La sintassi è abbastanza semplice:

chown username:groupname filename

Per esempio, controlliamo un file chiamato text.txt:

$ ls -l text.txt
-rw-rw---- 1 carol carol 1881 Dec 10 15:57 text.txt

L’utente che possiede il file è carol e anche il gruppo è carol. Modifichiamo ora il gruppo che possiede il file in un altro gruppo, come per esempio students:

$ chown carol:students text.txt
$ ls -l text.txt
-rw-rw---- 1 carol students 1881 Dec 10 15:57 text.txt

Tieni presente che l’utente che possiede il file non deve appartenere al gruppo che possiede il file stesso. Nell’esempio sopra riportato, l’utente carol non ha bisogno di essere un membro del gruppo students. Tuttavia, deve essere membro del gruppo per potergli trasferire la proprietà di gruppo del file.

L’utente o il gruppo possono essere omessi se non si desidera modificarli. Quindi, per cambiare solo il gruppo proprietario di un file, puoi usare chown :students text.txt. Per cambiare solo l’utente, il comando è chown carol text.txt. In alternativa puoi usare il comando chgrp students text.txt per cambiare solo il gruppo.

A meno che tu non sia amministratore di sistema (root), non puoi cambiare la proprietà di un file posseduto da un altro utente o da un gruppo a cui non appartieni. Se provi a farlo, riceverai il messaggio di errore Operation not permitted (Operazione non consentita).

Ricercare i Gruppi

Prima di modificare la proprietà (ownership) di un file, potrebbe essere utile sapere quali gruppi esistono nel sistema, quali utenti sono membri di un gruppo e a quali gruppi appartiene un utente. Queste attività possono essere fatte con due comandi: groups e groupmems.

Per vedere quali gruppi esistono sul tuo sistema, digita semplicemente groups:

$ groups
carol students cdrom sudo dip plugdev lpadmin sambashare

E se vuoi sapere a quali gruppi appartiene un utente, aggiungi il nome utente come parametro:

$ groups carol
carol : carol students cdrom sudo dip plugdev lpadmin sambashare

Per fare il contrario, mostrando quali utenti appartengono a un gruppo, usa groupmems. L’opzione -g specifica il gruppo e l’opzione -l elenca tutti i suoi membri:

$ sudo groupmems -g cdrom -l
carol

Tip	`groupmems` può essere eseguito solo come root, l’amministratore di sistema. Se non sei attualmente loggato come root, aggiungi `sudo` prima del comando.

Permessi Speciali

Oltre ai permessi di lettura, scrittura ed esecuzione per l’utente, il gruppo e gli altri, ogni file può avere altri tre permessi speciali che possono alterare il modo in cui funziona una directory o come viene eseguito un programma. Possono essere specificati o in modalità simbolica o numerica e sono i seguenti:

Sticky Bit

Lo sticky bit, chiamato anche flag di cancellazione limitata (restricted deletion flag), ha valore ottale pari a 1 e, in modalità simbolica, è rappresentato da una t all’interno del set dei permessi per gli altri. Si applica solo alle directory e su Linux impedisce agli utenti di rimuovere o rinominare un file in una directory a meno che non possiedano quel file o quella directory.

Le directory con impostato lo sticky bit mostrano una t che sostituisce la x nel set dei permessi per gli altri nell’output di ls -l:

$ ls -ld Sample_Directory/
drwxr-xr-t 2 carol carol 4096 Dec 20 18:46 Sample_Directory/

In modalità numerica, i permessi speciali vengono specificati utilizzando una “notazione a 4 cifre” con la prima cifra che rappresenta il permesso speciale su cui agire. Per esempio, per impostare lo sticky bit (valore 1) sulla directory Another_Directory in modalità numerica, con permessi 755, puoi usare il seguente comando:

$ chmod 1755 Another_Directory
$ ls -ld Another_Directory
drwxr-xr-t 2 carol carol 4,0K Dec 20 18:46 Another_Directory

Set GID

Set GID, noto anche come SGID o bit Set Group ID, ha valore ottale pari a 2 e, in modalità simbolica, è rappresentato da una s nel set di permessi del gruppo. Può essere impostato su file eseguibili o su directory. Sui file eseguibili concede al processo risultante dall’esecuzione del file l’accesso ai privilegi del gruppo proprietario del file. Se impostato su una directory fa in modo che ogni file o directory creata all’interno di essa erediti il gruppo dalla directory padre.

I file e le directory con impostato il bit SGID mostrano una s che sostituisce la x nel set dei permessi per il gruppo nell’output di ls -l:

$ ls -l test.sh
-rwxr-sr-x 1 carol carol 33 Dec 11 10:36 test.sh

Per aggiungere i permessi SGID a un file in modalità simbolica, puoi usare il seguente comando:

$ chmod g+s test.sh
$ ls -l test.sh
-rwxr-sr-x 1 carol root     33 Dec 11 10:36 test.sh

Il seguente esempio ti aiuterà a comprendere meglio gli effetti del bit SGID su una directory. Supponiamo di avere una directory chiamata Sample_Directory, di proprietà dell’utente carol e del gruppo users, con la seguente struttura di permessi:

$ ls -ldh Sample_Directory/
drwxr-xr-x 2 carol users 4,0K Jan 18 17:06 Sample_Directory/

Entriamo ora in questa directory e, usando il comando touch, creiamo un file vuoto al suo interno. Il risultato è il seguente:

$ cd Sample_Directory/
$ touch newfile
$ ls -lh newfile
-rw-r--r-- 1 carol carol 0 Jan 18 17:11 newfile

Come possiamo vedere il file è di proprietà dell’utente carol e del gruppo carol, ma se la directory avesse il set di permessi SGID, il risultato sarebbe diverso. Per prima cosa, aggiungiamo il bit SGID a Sample_Directory e controlliamo i risultati:

$ sudo chmod g+s Sample_Directory/
$ ls -ldh Sample_Directory/
drwxr-sr-x 2 carol users 4,0K Jan 18 17:17 Sample_Directory/

La s nei permessi del gruppo indica che è impostato il bit SGID. Entriamo ora in questa directory e, di nuovo, creiamo un file vuoto con il comando touch:

$ cd Sample_Directory/
$ touch emptyfile
$ ls -lh emptyfile
 -rw-r--r-- 1 carol users 0 Jan 18 17:20 emptyfile

Come possiamo vedere il gruppo che possiede il file è users. Questo perché il bit SGID ha fatto in modo che il file ereditasse il gruppo proprietario della sua directory padre, che è users.

Set UID

SUID, noto anche come Set User ID, ha valore ottale pari a 4 ed è rappresentato da una s nel set di permessi dell'utente in modalità simbolica. Si può impostare solo sui file e il suo comportamento è simile al bit SGID, ma il processo viene eseguito con i privilegi dell'utente che possiede il file. I file con il bit SUID mostrano una s che sostituisce la x nel set dei permessi per l’utente nell’output di ls -l:

$ ls -ld test.sh
-rwsr-xr-x 1 carol carol 33 Dec 11 10:36 test.sh

È possibile combinare più permessi speciali in un unico parametro sommandoli. Quindi, per impostare SGID (valore 2) e SUID (valore 4) in modalità numerica per lo script test.sh con permessi 755, puoi usare:

$ chmod 6755 test.sh

E il risultato è:

$ ls -lh test.sh
-rwsr-sr-x 1 carol carol 66 Jan 18 17:29 test.sh

Tip

Se il tuo terminale supporta i colori, e oggigiorno la maggior parte dei terminali lo fa, puoi rapidamente vedere se sono impostati questi permessi speciali, dando uno sguardo all’output di ls -l. Per lo sticky bit, il nome della directory potrebbe essere visualizzato in nero con uno sfondo blu. Lo stesso vale per i file con i bit SGID (sfondo giallo) e SUID (sfondo rosso). I colori possono essere diversi a seconda della distribuzione Linux e delle impostazioni del terminale che utilizzi.

Esercizi Guidati

Crea una directory chiamata emptydir usando il comando mkdir emptydir. Ora, con ls elenca i permessi della directory emptydir.
Crea un file vuoto chiamato emptyfile con il comando touch emptyfile. Ora, usando chmod con la notazione simbolica, aggiungi i permessi di esecuzione per il proprietario del file emptyfile, e rimuovi i permessi di scrittura ed esecuzione per tutti gli altri. Fallo usando un solo comando chmod.
Quali sono i permessi di un file chiamato text.txt dopo aver usato il comando chmod 754 text.txt?
Supponiamo che un file chiamato test.sh sia uno script di shell con i seguenti permessi e ownership:
```
-rwxr-sr-x 1 carol root     33 Dec 11 10:36 test.sh
```
- Quali sono i permessi per il proprietario del file?
- Se l’utente john esegue questo script, con quali privilegi utente verrà eseguito?
- Usando la notazione numerica, qual è la sintassi di chmod per “annullare” il permesso speciale concesso a questo file?

Considera questo file:

$ ls -l /dev/sdb1
brw-rw---- 1 root disk 8, 17 Dec 21 18:51 /dev/sdb1

Che tipo di file è sdb1? E chi può scriverci?

Considera i 4 file di seguito riportati:

drwxr-xr-t 2 carol carol 4,0K Dec 20 18:46 Another_Directory
----r--r-- 1 carol carol    0 Dec 11 10:55 foo.bar
-rw-rw-r-- 1 carol carol 1,2G Dec 20 18:22 HugeFile.zip
drwxr-sr-x 2 carol users 4,0K Jan 18 17:26 Sample_Directory

Indica i corrispondenti permessi per ogni file e directory utilizzando la notazione numerica a 4 cifre.

Another_Directory

foo.bar

HugeFile.zip

Sample_Directory

Esercizi Esplorativi

Crea un file vuoto chiamato emptyfile con il comando touch emptyfile. Ora “azzera” i permessi del file con chmod 000 emptyfile. Cosa succede se modifichi i permessi per emptyfile passando solo un valore per chmod, in notazione numerica, come per esempio chmod 4 emptyfile? E se ne usassimo due, come chmod 44 emptyfile? Cosa possiamo imparare sul modo in cui chmod legge il valore numerico?
Puoi eseguire un file per il quale hai i permessi di esecuzione, ma non quelli di lettura (--x)? Per quale motivo?
Considera i permessi per la directory temporanea su un sistema Linux: /tmp:
```
$ ls -l /tmp
drwxrwxrwt  19 root root  16K Dec 21 18:58 tmp
```
L’utente, il gruppo e gli altri hanno permessi completi. Ma può un utente ordinario eliminare qualsiasi file all’interno di questa directory? Per quale motivo?
Un file chiamato test.sh ha i seguenti permessi: -rwsr-xr-x, il che significa che è impostato il bit SUID. Ora esegui i seguenti comandi:
```
$ chmod u-x test.sh
$ ls -l test.sh
-rwSr-xr-x 1 carol carol 33 Dec 11 10:36 test.sh
```
Che cosa abbiamo fatto? Cosa significa la S maiuscola?
Come puoi creare una directory chiamata Box in cui tutti i file sono automaticamente di proprietà del gruppo users e possono essere eliminati solo dall’utente che li ha creati?

Sommario

Essendo un sistema multiutente, Linux ha bisogno di un modo per tenere traccia di chi possiede e di chi può accedere a ogni file. Questo viene realizzato attraverso un sistema di permessi a tre livelli e in questa lezione abbiamo imparato tutto su come funziona questo sistema.

In questa lezione hai imparato come usare ls per ottenere informazioni sui permessi dei file, come controllare o cambiare chi può creare, eliminare o modificare un file con chmod, sia usando la notazione numerica sia usando la notazione simbolica e come cambiare la proprietà (ownership) dei file con chown e chgrp.

In questa lezione sono stati discussi i seguenti comandi:

ls: Elenca i file, eventualmente includendo dettagli come, per esempio, i permessi.
chmod: Modifica i permessi di un file o di una directory.
chown: Modifica l’utente e/o il gruppo proprietario di un file o di una directory.
chgrp: Modifica il gruppo proprietario di un file o di una directory.

Risposte agli Esercizi Guidati

Crea una directory chiamata emptydir usando il comando mkdir emptydir. Ora, con ls elenca i permessi della directory emptydir.

Aggiungi l’opzione -d a ls per vedere gli attributi di file di una directory, invece di elencarne il contenuto. Quindi la risposta è:
```
ls -l -d emptydir
```
Ottieni punti bonus se hai unito le due opzioni in una sola, come in ls -ld emptydir.
Crea un file vuoto chiamato emptyfile con il comando touch emptyfile. Ora, usando chmod con la notazione simbolica, aggiungi i permessi di esecuzione per il proprietario del file emptyfile, e rimuovi i permessi di scrittura ed esecuzione per tutti gli altri. Fallo usando un solo comando chmod.

Pensa in questo modo:
- “Per l’utente che possiede il file (u) aggiungi (+) i permessi di esecuzione (x)”, quindi u+x.
- “Per il gruppo (g) e per gli altri utenti (o), rimuovi (-) i permessi di scrittura (w) ed esecuzione (x)”, quindi go-wx.
  
  Per combinare questi due set di permessi, aggiungiamo una virgola tra di loro. Quindi il risultato finale è:
  chmod u+x,go-wx emptyfile
Quali sono i permessi di un file chiamato text.txt dopo aver usato il comando chmod 754 text.txt?

Ricorda che nella notazione numerica ogni cifra rappresenta un insieme di tre permessi, ognuno con un rispettivo valore: per la lettura il valore è 4, per la scrittura il valore è 2, per l'esecuzione il valore è 1, mentre nessun permesso ha valore 0. Possiamo ottenere il valore di una cifra sommando i corrispondenti valori per ogni permesso: 7 è 4+2+1 o rwx, 5 è 4+0+1 o r-x e 4 indica permessi di sola lettura o r--. Quindi i permessi per text.txt sono:
```
rwxr-xr--
```
Supponiamo che un file chiamato test.sh sia uno script di shell con i seguenti permessi e ownership:
```
-rwxr-sr-x 1 carol root     33 Dec 11 10:36 test.sh
```
- Quali sono i permessi per il proprietario del file?
  
  I permessi per il proprietario (dal secondo al quarto carattere nell’output di ls -l) sono rwx; quindi la risposta è: “leggere, scrivere ed eseguire il file”.
- Se l’utente john esegue questo script, con quali privilegi utente verrà eseguito?
  
  Presta attenzione ai permessi per il gruppo. Questi sono r-s, il che significa che è impostato il bit SGID. Il gruppo che possiede questo file è root; quindi lo script, anche quando viene avviato da un utente ordinario, verrà eseguito con i privilegi di quell’utente.
- Usando la notazione numerica, qual è la sintassi di chmod per “annullare” il permesso speciale concesso a questo file?
  
  Possiamo “annullare” i permessi speciali passando una quarta cifra, 0, a chmod. I permessi correnti sono 755; quindi il comando è chmod 0755.
Considera questo file:
```
$ ls -l /dev/sdb1
brw-rw---- 1 root disk 8, 17 Dec 21 18:51 /dev/sdb1
```
Che tipo di file è sdb1? E chi può scriverci?

Il primo carattere dell’output di ls -l mostra il tipo di file. b indica un dispositivo a blocchi, solitamente un disco (interno o esterno), connesso alla macchina. Il proprietario (root) e qualsiasi utente del gruppo disk possono scrivere su di esso.
Considera i 4 file di seguito riportati:
```
drwxr-xr-t 2 carol carol 4,0K Dec 20 18:46 Another_Directory
----r--r-- 1 carol carol    0 Dec 11 10:55 foo.bar
-rw-rw-r-- 1 carol carol 1,2G Dec 20 18:22 HugeFile.zip
drwxr-sr-x 2 carol users 4,0K Jan 18 17:26 Sample_Directory
```
Indica i corrispondenti permessi per ogni file e directory utilizzando la notazione numerica a 4 cifre.

I corrispondenti permessi, in notazione numerica, sono i seguenti:

Another_Directory

Soluzione: 1755

1 per lo sticky bit, 755 per i normali permessi (rwx per l’utente, r-x per il gruppo e per gli altri).

foo.bar

Soluzione: 0044

Nessun permesso speciale (quindi la prima cifra è 0), nessun permesso per l’utente (---) e permessi di sola lettura (r—r--) per il gruppo e per gli altri.

HugeFile.zip

Soluzione: 0664

Nessun permesso speciale, quindi la prima cifra è 0. 6 (rw-) per l’utente e il gruppo, 4 (r--) per gli altri.

Sample_Directory

Soluzione: 2755

2 per il bit SGID, 7 (rwx) per l’utente, 5 (r-x) per il gruppo e per gli altri.

Risposte agli Esercizi Esplorativi

Crea un file vuoto chiamato emptyfile con il comando touch emptyfile. Ora “azzera” i permessi del file con chmod 000 emptyfile. Cosa succede se modifichi i permessi per emptyfile passando solo un valore per chmod, in notazione numerica, come per esempio chmod 4 emptyfile? E se ne usassimo due, come chmod 44 emptyfile? Cosa possiamo imparare sul modo in cui chmod legge il valore numerico?

Ricorda che abbiamo “azzerato” i permessi di emptyfile. Quindi, il suo stato iniziale è:
```
---------- 1 carol carol    0 Dec 11 10:55 emptyfile
```
Ora proviamo il primo comando: chmod 4 emptyfile:
```
$ chmod 4 emptyfile
$ ls -l emptyfile
-------r-- 1 carol carol 0 Dec 11 10:55 emptyfile
```
I permessi per gli altri sono stati modificati. E se provassimo due cifre, come chmod 44 emptyfile?
```
$ chmod 44 emptyfile
$ ls -l emptyfile
----r--r-- 1 carol carol 0 Dec 11 10:55 emptyfile
```
Ora i permessi per il gruppo e per gli altri sono stati alterati. Da questo possiamo dedurre che in notazione numerica chmod legge il valore “al contrario”, dalla cifra meno significativa (gli altri) a quella più significativa (l’utente). Se passi una cifra, modifichi i permessi per gli altri. Con due cifre modifichi i permessi per il gruppo e per gli altri, con tre modifichi i permessi per l'utente, il gruppo e gli altri, e con quattro cifre modifichi i permessi per l'utente, il gruppo, gli altri e i permessi speciali.
Puoi eseguire un file per il quale hai i permessi di esecuzione, ma non quelli di lettura (--x)? Per quale motivo?

Di primo acchito la risposta sembra ovvia: se hai il permesso di esecuzione, il file dovrebbe essere eseguito. Tuttavia, senza il permesso di lettura, il sistema non può aprire il file e leggerne il contenuto per l’esecuzione. Pertanto, senza il permesso di lettura non puoi eseguire un file, anche se hai il permesso di esecuzione.
Considera i permessi per la directory temporanea su un sistema Linux: /tmp:
```
$ ls -l /tmp
drwxrwxrwt  19 root root  16K Dec 21 18:58 tmp
```
L’utente, il gruppo e gli altri hanno permessi completi. Ma può un utente ordinario eliminare qualsiasi file all’interno di questa directory? Per quale motivo?

/tmp è ciò che chiamiamo una directory scrivibile da chiunque (world writeable), il che significa che qualsiasi utente può scriverci. Ma non vogliamo che un utente modifichi i file creati da altri, quindi è impostato lo sticky bit (come indicato dalla t nei permessi per gli altri). Ciò significa che un utente può eliminare i file in /tmp, ma solo se ha creato quei file.
Un file chiamato test.sh ha i seguenti permessi: -rwsr-xr-x, il che significa che è impostato il bit SUID. Ora esegui i seguenti comandi:
```
$ chmod u-x test.sh
$ ls -l test.sh
-rwSr-xr-x 1 carol carol 33 Dec 11 10:36 test.sh
```
Che cosa abbiamo fatto? Cosa significa la S maiuscola?

Abbiamo rimosso i permessi di esecuzione per l’utente proprietario del file. La s (o la t) prende il posto della x nell’output di ls -l; quindi il sistema ha bisogno di un modo per mostrare se l’utente ha i permessi di esecuzione o meno. Lo fa mettendo il carattere speciale in maiuscolo o minuscolo.

Una s minuscola nel primo gruppo di permessi significa che l’utente che possiede il file ha i permessi di esecuzione e che è impostato il bit SUID. Una S maiuscola significa che l’utente che possiede il file non ha (-) i permessi di esecuzione e che è impostato il bit SUID.

Lo stesso si può dire per SGID. Una s minuscola nel secondo gruppo di permessi significa che il gruppo che possiede il file ha i permessi di esecuzione e che è impostato il bit SGID. Una S maiuscola significa che il gruppo che possiede il file non ha (-) i permessi di esecuzione e che è impostato il bit SGID.

Questo vale anche per lo sticky bit, rappresentato da una t nel terzo gruppo di permessi. Una t minuscola significa che è impostato lo sticky bit e che gli altri hanno i permessi di esecuzione. Una T maiuscola significa che è impostato lo sticky bit e che gli altri non hanno i permessi di esecuzione.
Come puoi creare una directory chiamata Box in cui tutti i file sono automaticamente di proprietà del gruppo users e possono essere eliminati solo dall’utente che li ha creati?

Questo è un processo a più fasi. Il primo passo consiste nel creare la directory:
```
$ mkdir Box
```
Vogliamo che ogni file creato all’interno di questa directory venga automaticamente assegnato al gruppo users. Possiamo farlo impostando questo gruppo come proprietario della directory e poi impostando il bit SGID sulla directory stessa. Dobbiamo anche assicurarci che qualsiasi membro del gruppo possa scrivere in questa directory.

Dato che non abbiamo bisogno di preoccuparci degli altri permessi e vogliamo solo “attivare” i bit speciali, ha senso usare la modalità simbolica:
```
$ chown :users Box/
$ chmod g+wxs Box/
```
Nota che se l’utente corrente non appartiene al gruppo users, dovrai usare il comando sudo prima dei comandi sopra riportati per apportare la modifica come root.

Ora per la parte finale, assicuriamoci che solo l’utente che ha creato un file sia autorizzato a eliminarlo. Questo viene fatto impostando lo sticky bit (rappresentato da una t) sulla directory. Ricorda che è impostato sul set dei permessi per gli altri (o).
```
$ chmod o+t Box/
```
I permessi sulla directory Box dovrebbero apparire nel seguente modo:
```
drwxrwsr-t 2 carol users  4,0K Jan 18 19:09 Box
```
Ovviamente, puoi specificare SGID e sticky bit usando un solo comando chmod:
```
$ chmod g+wxs,o+t Box/
```
Ottieni dei punti bonus se ci hai pensato.