I comandi e le utility di Linux: l'utente

Linux è un sistema multiutente. Per poter gestire la presenza contemporanea di più utenti, Linux deve identificare ciascun utente in modo univoco. Un utente, all'interno di un sistema Linux, viene identificato con un nome account e con un numero, lo User IDentifier ( UID ). Al contempo, Linux permette di creare gruppi di utenti. Ciascun gruppo sarà identificabile con un nome e con un numero univoco, il Group IDentifier ( GID ). Un utente, in un sistema Linux, può appartenere a più di un gruppo. A ciascun utente e a ciascun gruppo di utenti vengono assegnati determinati privilegi sui file e sulle risorse del sistema. Un file può essere creato, eliminato, modificato, sovrascritto, letto, eseguito. I privilegi determinano proprio chi può fare cosa su un file. Il comando ls ( list ), se seguito dall'opzione -l ( long ), stampa a video i permessi associati a ciascun file:

	ls -l missfont.log

-rw-r--r--  1 sara ufficio   312 2012-03-31 23:33 missfont.log

Il primo bit che apre ogni riga, nel nostro esempio:

	-

esprime il tipo di file ( file, come nel nostro esempio, oppure directory, d ). I 9 bit successivi, nel nostro esempio:

	rw-r--r--

esprimono i permessi: i primi tre bit sono riservati al proprietario, i secondi tre bit sono riservati al gruppo, gli ultimi tre bit sono riservati al resto del mondo ( other ). Il file missfont.log, in questo esempio, è stato creato dall'utente "sara" ed assegnato al gruppo "ufficio". Il proprietario "sara" detiene, sul file missfont.log i permessi di lettura e scrittura:

	rw-

mentre tutti gli utenti appartenenti al gruppo "ufficio" detengono, sul file missfont.log i soli permessi di lettura:

	r--

così come qualsiasi altro utente ( other ). Chi possiede i soli permessi di lettura su un file, non sarà mai in grado di modificare o eliminare quel file. Fortunatamente! In un sistema Linux, esiste un solo utente per il quale il sistema non eseguirà mai alcun controllo, in merito ai privilegi di accesso ai file ed alle risorse del sistema: il superuser ( root ). L'utente "root", in un sistema Linux, equivale all'amministratore Windows: a lui, tutto è concesso. A ciascun utente, in un sistema Linux, viene riservata una directory, la cosiddetta "home directory". Per l'utente "root", la "home directory" è la radice stessa dell'intero filesystem:

	/

mentre, per tutti gli altri utenti, la "home directory" viene creata, solitamente, all'interno della cartella:

	/home
	/home/user1
	/home/user2

Il nome utente e la directory HOME per l'utente corrente vengono memorizzati nelle variabili d'ambiente:

	USER
	HOME

Per leggere una variabile d'ambiente è sufficiente utilizzare il comando echo:

	echo $USER
	echo $HOME

In alternativa, per conoscere il nome utente corrente, eseguire uno dei seguenti comandi:

	whoami
	id -un

che stampano a video il cosiddetto " effective UserID ". Lo " effective UserID " si distingue dal " real UserID ". Il " real UserID " è l'identificativo dell'utente corrente, utilizzato per accedere al sistema: è quello che comunemente chiamiamo " user ". Lo " effective UserID ", invece, è l'identificativo utente del quale il " real UserID " ha acquisito, momentaneamente, i privilegi di accesso. Questo accade, per esempio, quando un utente, con un suo " real UserID ", si trova ad eseguire un file con il suid bit impostato. Quando un file ha impostato il suid bit, quel file verrà eseguito con i privilegi del proprietario del file ( effective user ID ) e non dell'utente che esegue il file ( real UserID ), il quale, in quel preciso istante, sta effettivamente agendo, nel sistema, con i privilegi associati al suo " effective user ID ". Per comprendere la differenza tra Real ed Effective UserID, creiamo il seguente file C:

#include <stdio.h>
#include <unistd.h>

int main()	{

 printf("My UID: %d, My EUID: %d\n", (int) getuid(), (int) geteuid());
 return 0;

 }

Per creare questo file .c, useremo un qualsiasi editor di testo ASCII o UTF-8, salvando il file con un nome qualsiasi, ma con estensione .c. Per esempio:

	mysuid.c

Questo semplice programma, composto, sostanzialmente, da una sola riga di comando, stampa a video il nostro ( real ) UID ed il nostro ( Effective ) UID ( EUID ). Compiliamo, ora, il file:

	gcc -Wall -o mysuid mysuid.c

Questo comando crea il file eseguibile mysuid, il cui utente proprietario sarà l'utente che lo ha creato ed il gruppo proprietario sarà il gruppo primario dell'utente che lo ha creato. Per esempio:

  -rwxrwxr-x 1 user user 8488 gen 29 10:41 mysuid

I permessi associati al file sono:

  read
  write
  execute

per il proprietario ( user ) e per il gruppo primario ( user );

  read
  execute

per chiunque altro. Se eseguiamo questo semplice programma da riga di comando:

	./mysuid

riceveremo un output del tipo:

  My UID: 1000, My EUID: 1000

Ora modifichiamo il nome utente proprietario del file ed impostiamo il cosiddetto suid bit:

	sudo chown root mysuid
	sudo chmod u+s mysuid

A questo punto, il nostro file apparirà come:

  -rwsrwxr-x 1 root user 8488 gen 29 10:41 mysuid

dove la " s " che appare come terzo permesso associato al proprietario ( al posto del permesso di esecuzione ) ci dice che questo file ha impostato il suid bit. Da questo momento in poi, chiunque abbia il permesso di esecuzione su questo file ( il gruppo proprietario e chiunque altro, nel nostro esempio ) potrà eseguirlo ereditando le credenziali del proprietario del file ( " root " nel nostro esempio ). Proviamo ad eseguire lo stesso programma, adesso:

	./mysuid

e riceveremo un output ben differente:

  My UID: 1000, My EUID: 0

Il nostro EUID ( Effective UID ) è diventato 0 ( zero: lo UID tipico di " root " ), mentre il nostro Real UID è rimasto inalterato ( 1000 ). Una avvertenza importante: non eseguite mai questo test, affidandovi al comando su o al comando sudo. Entrambi i comandi, infatti, hanno il suid bit impostato:

  -rwsr-xr-x 1 root root 71288 giu  1  2012 /usr/bin/sudo
  -rwsr-xr-x 1 root root 36832 set 13 00:29 /bin/su

ma il loro comportamento è diverso dal comportamento tenuto da tutti gli altri file che hanno il suid bit impostato: con i comandi su e sudo, infatti, il sistema operativo modifica sia il Real UID, sia lo Effective UID, equiparandoli a quelli del proprietario del file su o sudo. Eseguendo il nostro programma, dopo aver eseguito su o sudo, quindi, l'output sarà sempre:

	sudo ./mysuid

  My UID: 0, My EUID: 0

Un'altra avvertenza: molti sistemi operativi Linux ignorano il suid bit applicato a script di shell, riconoscendolo solo nei file binari eseguibili. Questo per ragioni di sicurezza. Infatti, quando il kernel deve eseguire uno script di shell, esegue, prima, una copia SUID della shell stessa, affidando a quest'ultima l'esecuzione dello script. Un malintenzionato, quindi, potrebbe interrompere il kernel, non appena quest'ultimo avesse eseguito la copia SUID della shell, e sottoporre, alla nuova shell, uno script diverso da eseguire. Il suid bit ed lo sgid bit sono da usare sempre con la massima cautela, poichè permettono ad un utente qualsiasi di acquisire i privilegi di un altro utente ( spesso, dell'amministratore stesso, " root " ). La gran parte delle informazioni relative ad un utente sono raccolte in pochi, essenziali file di configurazione:

	/etc/passwd
	/etc/shadow
	/etc/group
	/etc/gshadow

Si tratta di file testuali, in tutti e quattro i casi. I file " shadow " sono file destinati alla conservazione delle password.

Il file: /etc/passwd

Il file di password contiene la maggior parte delle informazioni relative agli utenti del sistema. A ciascun utente è riservata una riga ( record ). Ciascun record è composto da sette campi, ciascuno dei quali separato dall'altro dai due punti:

  username:password:UID:GID:GECOS:HOME:shell

    root:x:0:1:0000-Admin(0000):/:/sbin/sh
    daemon:x:1:1:0000-Admin(0000):/:
    bin:x:2:2:0000-Admin(0000):/usr/bin:
    sys:x:3:3:0000-Admin(0000):/:

Un carattere x nel campo password denota l'uso del file " shadow ", contenente le password cifrate. Nel caso in cui non si utilizzasse il sistema " shadow ", per le password, il campo password conterrebbe la password cifrata. Il campo GECOS è un campo riservato ai commenti, o ai dettagli, relativi all'utente. Non sono ammesse righe vuote. Una riga vuota verrebbe interpretata come un record riservato all'utente " root " che non abbia impostato alcuna password.

passwd

Il comando passwd serve per modificare la password di un utente. Naturalmente, se l'utente che invoca il comando è diverso da " root ", l'utente potrà modificare solo la propria password, mentre l'utente " root " sarà in grado di modificare la password di qualsiasi altro utente:

	passwd [opzioni] [Utente]
	passwd
	passwd fred

Il comando passwd modifica i campi dei file:

  /etc/passwd
  /etc/shadow

Prima di modificare una password, è possibile chiedere a passwd di stampare a video le informazioni relative al proprio account:

	passwd -S
	passwd --status

oppure, possedendone le credenziali, le informazioni dell'account di un altro utente:

	passwd -S fred
	passwd --status fred

oppure, in qualità di utente " root ", di tutti gli utenti:

	passwd -S -a
	passwd --status --all

Le informazioni restituite sono le informazioni contenute in 7 campi:

  fred P 03/04/96 0 60 0 0

• nome utente

• tipo di password assegnata al'utente. Questa informazione è reperibile nel file di configurazione /etc/shadow:

  • locked password ( L ), vale a dire una password bloccata. Nel file /etc/shadow, il campo password contiene un punto esclamativo ( ! ), oppure un asterisco ( * ).

  • no password ( NP ): l'utente, per accedere al sistema, non ha bisogno di inserire alcuna credenziale particolare. Nel file /etc/shadow, il campo password è vuoto.

  • usable password ( P ), vale a dire una password utilizzabile.

• data dell'ultima modifica. Campo 3 del file /etc/shadow.

• minimum age. Campo 4 del file /etc/shadow.

• maximum age. Campo 5 del file /etc/shadow.

• warning period. Campo 6 del file /etc/shadow.

• inactivity period. Campo 7 del file /etc/shadow.

Per bloccare una password:

	passwd -l fred
	passwd --lock fred

Il LOCK disabilita la password, ma non l'account. L'utente, infatti, sarà in grado di accedere al sistema, usando una password di un servizio differente, quale SSH. Il LOCK viene eseguito modificando la password, nel file /etc/passwd, oppure nel file /etc/shadow, facendola precedere da un punto esclamativo, rendendo, così, la stringa testuale non valida. Un utente con la password in LOCK non sarà in grado di modificare la propria password. Per togliere il LOCK da e sbloccare una password:

	passwd -u fred
	passwd --unlock fred

L'opzione -u rimuove il punto esclamativo dal campo della password. Se il punto esclamativo, nel file /etc/shadow, è seguito dalla vecchia password, quest'ultima verrà ripristinata. In caso contrario, cioè, se il punto esclamativo non è seguito da alcuna password, il sistema rifiuterà il tentativo di sblocco, a meno che si utilizzi l'ulteriore opzione -f ( force ). Per eliminare la password di un utente, che potrà, quindi, accedere al sistema senza alcuna verifica:

	passwd -d fred
	passwd --delete fred

Per modificare i giorni di validità di una password ( maximum password age ):

	passwd -x20 fred
	passwd --maxdays 20 fred

Per impostare il " minimum password age " ( il valore zero indica che l'utente potrà modificare la password in qualsiasi momento ):

	passwd -n4 fred
	passwd --mindays 4 fred

Per modificare il numero dei giorni, prima della prossima scadenza di una password, nei quali il sistema invierà un messaggio di avviso all'utente:

	passwd -w14 fred
	passwd --warndays 14 fred

Per modificare il numero dei giorni da attendere, prima di disabilitare un account, una volta scaduta la password:

	passwd -i24 fred
	passwd --inactive 24 fred

Il file: /etc/shadow

Il file:

	/etc/passwd

deve essere aperto, in lettura, a chiunque:

  -rw-r--r-- 1 root root 1660 nov 2 13:18 /etc/passwd

Troppi sono i programmi, i comandi e le applicazioni che devono poter leggere le informazioni in esso contenute. Nel file, chiunque potrebbe leggere, quindi, le password cifrate di tutti gli utenti presenti nel sistema. Anche se cifrate, le password, invece, dovrebbero sempre essere inaccessibili al resto del mondo. Ecco perchè si è pensato di conservare tutte le password in un file dedicato, consultabile solo dall'amministratore del sistema ( root ):

	/etc/shadow

  -rw-r----- 1 root shadow 1042 nov 2 13:18 /etc/shadow

Come per il file passwd, nel file shadow, a ciascun utente è riservata una riga ( record ):

	root:!:14964:0:99999:7:::
	daemon:*:14889:0:99999:7:::
	pippo:mmtWGc4ncckXo:14889:0:99999:7:::

Ciascun record è composto da nove campi, ciascuno dei quali separato dall'altro dai due punti:

1. username

2. password criptata. La funzione utilizzata per la cifratura è crypt(), che utilizza l'algoritmo, modificato, DES ( Data Encryption Standard ). Il campo password può essere lasciato vuoto, a significare che non è richiesta alcuna password per l'autenticazione dell'utente. Se nel campo password si trova un asterisco o un punto esclamativo, l'account utente è bloccato ( l'utente non può accedere al sistema operativo ).

3. ultima modifica apportata, espressa in numero di giorni, con inizio dal 1 gennaio 1970. Se il valore è 0 ( zero ), l'utente dovrà modificare la sua password in occasione del prossimo accesso al sistema. Se il campo è vuoto, il sistema non supporta la gestione dei tempi delle password ( password aging ).

4. il numero di giorni minimo in cui la password non potrà essere modificata ( minimum password age ). Un campo vuoto o il valore 0 ( zero ) significano: nessun limite minimo previsto.

5. il numero di giorni massimo dopo i quali la password dovrà essere modificata ( maximum password age ). Se questo valore è inferiore al valore del Minimum Password Age, l'utente non sarà in grado di modificare la propria password.

6. il numero di giorni, prima del Maximum Password Age ( data di scadenza ), durante i quali il sistema invierà un messaggio di avvertimento all'utente.

7. il numero di giorni, dopo la scadenza ( Maximum Password Age ), durante i quali la vecchia password verrà ancora accettata e dopo i quali l'utente non sarà più in grado di accedere al sistema con la vecchia password e dovrà contattare l'amministratore.

8. la data di scadenza dell'account ( non della password ), espressa in numero di giorni, con inizio dal 1 gennaio 1970. La scadenza dell'account è differente dalla scadenza della password: quando un account è scaduto, l'utente non è più in grado di accedere al sistema. Quando una password è scaduta, l'utente non è più in grado di accedere al sistema, con la sua password scaduta. Quando questo campo viene lasciato vuoto, l'account non ha scadenza. La data 1969-12-31 corrisponde ad un valore espresso da tutti i bit a zero, che esprime una password senza scadenza.

9. campo riservato ad usi futuri.

La funzione C crypt() è la funzione che esegue la cifratura delle password. L'implementazione tradizionale della funzione crypt() utilizza una forma modificata dell'algoritmo DES ( Data Encryption Standard ), dove la password dell'utente viene troncata all'ottavo carattere e dove i primi 7 bit di ciascuno degli otto caratteri vengono usati per creare una chiave a 56 bit: la chiave DES a 56-bit. Questa chiave a 56 bit viene, quindi, usata per cifrare, ripetutamente ( per un totale di 25 cifrature DES ), una stringa di bit costante ( spesso costituita da una sequenza di zero ). La stringa di testo finale, risultato di tutti questi processi, è il cosiddetto valore di hash della stringa originale ( password ), una serie di 13 caratteri ASCII. E' praticamente impossibile risalire, dal valore di hash, alla stringa testuale originale. Una stringa testuale, sottoposta ripetutamente alla funzione crypt(), originerà sempre lo stesso valore di hash. Questi due presupposti hanno come conseguenza che la stringa criptata ( valore di hash ) non verrà mai decriptata, ma verrà confrontata con i valori di hash di altre stringhe: quando il valore di hash della stringa A è identico al valore di hash della stringa B, i due valori di hash sono stati originati dalla stessa stringa testuale originale. Quindi, le stringhe A e B sono identiche. Questo è il fondamento della verifica della password utente, nel momento dell'accesso al sistema. In realtà, è possibile, anche se altamente improbabile, ipotizzare che due stringhe testuali differenti possano generare lo stesso valore di hash. Inoltre, per evitare che due stringhe testuali ( password ) identiche generino lo stesso valore di hash, la funzione crypt accetta un altro parametro, oltre alla password, chiamato " salt ": una stringa di due caratteri, di cui crypt userà i primi 6 bit, per un totale di dodici bit, che verrà utilizzata per modificare ( perturbare ) l'algoritmo di codifica. Due password identiche, passate alla funzione crypt con due " salt " differenti, genereranno due valori di hash completamente differenti:

#define _XOPEN_SOURCE
#include <stdio.h>
#include <unistd.h>

int main()
        {

        printf("Password: => %s\n", crypt("password", "mm"));
	printf("Password: => %s\n", crypt("password", "tt"));

        return 0;

        }
	

Nel primo caso, avremo, come valore di hash finale:

	mmtWGc4ncckXo

mentre, nel secondo caso, avremo:

	ttHVu3FSDqUDk

E' evidente che le prime due lettere del valore di hash, restituito dalla funzione crypt(), contengono proprio il " salt " utilizzato. L'utilizzo del " salt " mette a disposizione 4096 percorsi addizionali per la generazione del valore di hash, dove 4096 è la dodicesima potenza di due ( il " salt " utilizzato è composto da 12 bit ). Questo significa che una tabella di conversione, che utilizzasse un dizionario per generare tutti i valori di hash possibili ( per poi confrontarli con il valore di hash letto nel file shadow di un utente ), sarebbe più grande di ben 4096 volte, rispetto ad una tabella di conversione che non prevedesse un " salt ". Naturalmente, una password data in pasto a crypt() con lo stesso " salt " darà sempre lo stesso valore di hash finale. Durante la prima cifratura di una password, sarebbe sempre buona cosa generare i due caratteri di " salt " in modo casuale. I caratteri ammessi, per la generazione del " salt " sono compresi nella classe di caratteri seguente:

	./0-9A-Za-z

Per quanto riguarda il programma che utilizza la funzione C crypt(), è bene ricordare che va sempre compilato richiamando proprio la libreria che contiene la funzione:

	gcc -Wall crypto.c -l crypt -o crypto

Nel nostro esempio, gcc compilerà il file " crypto.c " e la libreria " libcrypt.a ", generando un file eseguibile di output, chiamato " crypto ". Come abbiamo già visto, l'algoritmo DES trattiene solo i primi otto caratteri della password e, di ciascuno di questi otto caratteri, solo i primi 7 bit. Quindi, la stringa di partenza, o chiave, con l'algoritmo DES, è composta da 56 bit. Questo significa che l'algoritmo DES mette a disposizione un numero di possibili sequenze pari a:

	256 = 7.2e16	

Questo rende possibili ricerche intensive, eseguite da più computer in parallelo, sull'intero spazio delle chiavi. Per estendere lo spazio delle chiavi, crypt(), oggi, supporta algoritmi di crittografia diversi da DES, quali MD5, SHA-256, SHA-512. Con gli algoritmi MD5 e SHA viene utilizzata l'intera stringa originale ( chiave ) e non i soli primi otto caratteri, come in DES. Per utilizzare un algoritmo diverso da DES, occorre specificare un " salt " composto dalla sequenza:

	$id$salt$

dove id è un numero identificativo dell'algoritmo da usare, mentre salt può contenere fino a 8 caratteri. Gli identificativi degli algoritmi sono:

              ID  | Method
              ──────────────────
              1   | MD5
              2a  | Blowfish 
              5   | SHA-256
              6   | SHA-512

Quindi, per codificare la password "miapassword", utilizzando l'algoritmo MD5 ed un salt "miosalt", occorrerà eseguire:

	crypt("miapassword", "$1$miosalt$");

che restituirà, come hash finale:

	$1$miosalt$zm75Q4Hf7mM/S6slmbNou.

La parte riservata alla password criptata, è composta da un numero fisso di caratteri, differente a seconda dell'algoritmo utilizzato:

       MD5     | 22 caratteri
       SHA-256 | 43 caratteri
       SHA-512 | 86 caratteri

Per una corretta gestione del file shadow, Linux mette a disposizione una serie di strumenti ( comandi ):

• chage ( change age ): cambia le informazioni sulla scadenza della password.

• pwconv ( password conversion ): questo comando attiva il sistema shadow, creando il file

  
         /etc/shadow
  
  

  a partire dal file:

  
         /etc/passwd
  
  

• pwunconv ( password unconverted ): ripristina l'uso del solo file:

  
         /etc/passwd
  
  

  eliminando il file:

  
         /etc/shadow
  
  

pwconv / pwunconv

	pwconv
	pwunconv

Il comando pwconv attiva il sistema shadow, creando il file:

       /etc/shadow

a partire dal file:

       /etc/passwd

Alcune variabili, configurabili nel file:

       /etc/login.defs

possono modificare il comportamento di pwconv:

	PASS_MAX_DAYS (number)
	PASS_MIN_DAYS (number)
	PASS_WARN_AGE (number)

PASS_MAX_DAYS	99999
PASS_MIN_DAYS	0
PASS_WARN_AGE	7

La variabile PASS_MAX_DAYS esprime il numero dei giorni di validità di una password. Se la password è più vecchia, il sistema obbliga l'utente a modificarla. Se non viene specificato alcun valore, la restrizione decade ( si assume il valore -1 ). La variabile PASS_MIN_DAYS esprime il numero minimo di giorni che dovranno trascorrere tra una modifica della password e l'altra. Se non viene specificato alcun valore, la restrizione decade ( si assume il valore -1 ). La variabile PASS_WARN_AGE esprime il numero di giorni in cui dovrà essere emesso un Warning ( un messaggio di avviso ), relativamente alla scadenza di una password. Il valore zero significa: avvisa solo nel giorno della scadenza. Un valore negativo equivale a non impostare alcun valore e significa: non avvisare mai. Il comando pwunconv rimuove il sistema shadow, ripristinando l'uso del solo file:

       /etc/passwd

ed eliminando il file:

       /etc/shadow

chage

Il comando chage ( change age ) cambia le informazioni sulle scadenze delle password degli utenti, informazioni conservate nel file shadow.

	chage [opzioni] [LOGIN]

	sudo chage -l pippo
	sudo chage -d 15630 pippo
	sudo chage -E 2020-03-21 pippo
	sudo chage -I 9 pippo
	sudo chage -m 9 pippo
	sudo chage -M 9 pippo
	sudo chage -W 3 pippo

	[opzioni]

	-l
	--list

Mostra le informazioni sull'account specificato ( " pippo ", nel nostro esempio ).

	-d LAST_DAY
	--lastday LAST_DAY

Imposta la data dell'ultima modifica di password effettuata, espressa come il numero di giorni trascorsi dal 1 gennaio 1970. La data può anche essere specificata nel formato AAAA-MM-GG.

	-E EXPIRE_DATE 
	--expiredate  EXPIRE_DATE

Imposta la data di scadenza dell'account ( campo 8 del file shadow ). E' espressa o in numero di giorni trascorsi dal 1 gennaio 1970 ( Epoch ), oppure nel formato AAAA-MM-GG. Il valore -1 elimina la data di scadenza dell'account ( la data di scadenza viene impostata a 1969-12-31: un giorno prima di Epoch ). Una volta scaduto un account utente, l'utente dovrà rivolgersi all'amministratore, per poter accedere nuovamente al sistema.

	-I INACTIVE 
	--inactive INACTIVE

Imposta il numero di giorni ammessi di mancata attività, dopo la scadenza della password, prima che l'account venga bloccato ( campo 7 del file shadow ). Una volta bloccato o scaduto un account utente, l'utente dovrà rivolgersi all'amministratore, per poter accedere nuovamente al sistema.

	-m MIN_DAYS 
	--mindays MIN_DAYS

	-M MAX_DAYS
	--maxdays MAX_DAYS

	-W WARN_DAYS
	--warndays WARN_DAYS

Impostano i campi 4, 5 e 6 del file shadow: minimum password age, maximum password age, password warning period. Se eseguito senza alcuna opzione, il comando chage viene eseguito in modalità interattiva, presentando, all'utente, i valori attuali di ciascuna variabile: per mantenere il valore attuale, lasciare il campo in bianco, per modificare il valore attuale, scrivere il nuovo valore:

	sudo chage pippo

sudo

	su = superuser
	do = fai, esegui

Il comando sudo permette ad un utente ordinario ( senza particolari privilegi di azione all'interno del filesystem ) di eseguire comandi, acquisendo i privilegi di un altro utente, anche dotato di privilegi superiori, compreso l'utente " root " ( amministratore ). Quando l'utente di cui si desidera acquisire i privilegi è diverso da " root ", è necessario specificarne il nome, usando l'opzione -u:

	sudo -u utente comando
	sudo -u user cat README
	sudo -u root cat README

Dell'utente di destinazione è possibile indicare lo UserID:

	sudo -u#UID comando
	sudo -u#1000 cat README
	sudo -u#0 cat README

Quando l'utente di destinazione è " root ", invece, l'opzione -u può essere omessa:

	sudo comando
	sudo cat README

Diversamente dal comando su, quando il file di configurazione /etc/sudoers richiede l'autenticazione dell'utente, sudo convalida le credenziali ( login e password ) dell'utente che invoca sudo, non dell'utente di destinazione. E' possibile indicare a sudo di eseguire una nuova shell, più precisamente quella contenuta nella variabile d'ambiente SHELL, se impostata, oppure quella specificata nel file passwd:

	sudo -s
	sudo -s comando
	sudo -s cat README

Nel primo caso, si aprirà una shell di root interattiva, mentre nel terzo caso, verrà eseguito il comando specificato ( cat ). Per uscire dalla shell interattiva di root, eseguire:

	exit

Se l'utente che esegue il comando sudo è " root ", oppure lo stesso utente di destinazione, non verrà richiesta alcuna password. Altrimenti, sudo chiede all'utente di qualificarsi, inserendo, normalmente, la propria password ( non la password di root ). Una volta autenticato, l'utente potrà usare sudo, senza inserire alcuna password, per un certo periodo di tempo ( solitamente, i successivi 5 minuti ), rinnovabile con l'opzione:

	sudo -v

Se eseguite il comando ls ( list ) per il file eseguibile sudo:

	ls -l /usr/bin/sudo

scoprirete che il file ha il bit di setUID impostato:

  -rwsr-xr-x 1 root root 71288 giu  1  2012 /usr/bin/sudo

Questo significa che chiunque esegua questo programma, acquisirà i privilegi del proprietario del file, per eseguirlo. E il proprietario del file è " root ", l'utente per il quale il sistema operativo non effettua alcuna verifica, prima di eseguire un qualsiasi programma o comando: l'utente " root ", se vuole, può eliminare qualsiasi file dal disco fisso. Il comando sudo, inoltre, va ben al di la delle competenze di un qualsiasi file con il bit di setUID impostato. Il comando sudo, infatti, modifica sia il realUID, sia lo effectiveUID, sia il realGID, sia lo effectiveGID dell'utente e permette di decidere chi potrà eseguire il comando stesso e con quali privilegi. Per sapere quali privilegi può acquisire l'utente corrente, eseguire:

	sudo -l

Per sapere quali privilegi può acquisire un altro utente, eseguire:

	sudo -lU nomeUtente

Naturalmente, questa opzione ( U ) può essere usata solo da " root ", oppure da un utente che usi sudo, con tutti i privilegi ( ALL ) attivi. Il file di configurazione per il comando sudo è:

	/etc/sudo.conf

Quando non presente, sudo legge il file:

	/etc/sudoers

che dovrebbe, sempre, essere manipolato indirettamente, utilizzando il comando:

	visudo

che previene l'eventualità che due utenti modifichino il file nello stesso istante, oltre a mettere a disposizione dell'utente una sintassi ristretta. Per file di configurazione personalizzati, è a disposizione la directory:

	/etc/sudoers.d

Se nel file di configurazione /etc/sudoers è presente ed attiva la direttiva:

  #includedir /etc/sudoers.d

il comando sudo leggerà e caricherà anche tutti i file presenti in:

	/etc/sudoers.d

il cui nome non finisca in " ~ ", oppure non contenga un punto ( . ). Il file di configurazione sudoers contiene una serie di direttive per gli utenti: una direttiva per gli utenti determina quali comandi un utente, od un gruppo di utenti, potrà eseguire, su quale host e con i privilegi di quale altro utente. Una direttiva è composta da quattro campi:

  who where = (as_whom) what

dove:

• who è la lista di utenti ai quali si applicano le regole seguenti, oppure una variabile User_Alias.

  
    root ALL = (ALL) ALL
  
  

• where è una lista di host, sui quali si applicano le regole seguenti, per gli utenti specificati in who, oppure una variabile Host_Alias.

  
    root ALL = (ALL) ALL
  
  

• as_whom è la lista di utenti con i cui privilegi who eseguirà i comandi, oppure una variabile Runas_Alias.

  
    root ALL = (ALL) ALL
  
  

• what è una lista di comandi che who potrà eseguire, oppure una variabile Cmnd_Alias.

  
    root ALL = (ALL) ALL
  
  

In questo primo esempio, l'utente root può eseguire qualsiasi comando, su qualsiasi computer della rete, ereditando i privilegi di tutti gli altri utenti. E' possibile dichiarare quattro tipi di variabili:

  User_Alias
  Runas_Alias
  Host_Alias
  Cmnd_Alias

e a ciascuna di esse vanno assegnati un nome ed un valore, oppure una lista di valori. In questo secondo esempio:

  Host_Alias WORKSTATIONS=localhost, station1, station2
  User_Alias SHUTDOWNUSERS=bob, mary, jane
  Cmnd_Alias REBOOT=halt, reboot, sync
  Runas_Alias REBOOTUSER=admin
  SHUTDOWNUSERS WORKSTATIONS=(REBOOTUSER) REBOOT

diamo agli utenti bob, mary e jane, espressi dalla variabile SHUTDOWNUSERS ( User_Alias = who ), le credenziali dell'utente admin, alias REBOOTUSER ( Runas_Alias = as_whom ), al fine di eseguire ( Cmnd_Alias = what ) i soli comandi halt, reboot, sync ( REBOOT ), sulle macchine ( WORKSTATIONS ) localhost, station1 e station2 ( Host_Alias = where ). Un segno percentuale, %, preposto al nome utente, indica il nome di un gruppo di utenti. In questo terzo esempio:

  User_Alias ADMINS = %admin
  Host_Alias SERVERS = 192.168.0.1, 192.168.0.2, server1
  Cmnd_Alias ADMIN_CMDS = /usr/sbin/passwd,
			/usr/sbin/useradd,
			/usr/sbin/userdel,
			/usr/sbin/usermod,
			/usr/sbin/visudo

  ADMINS SERVERS= ADMIN_CMDS

tutti i membri del gruppo admin potranno eseguire, sui server contenuti nella variabile SERVERS, tutti i comandi, e solo quelli, contenuti in ADMIN_CMDS.

#
# This file MUST be edited with the 'visudo' command as root.
#
# Please consider adding local content in /etc/sudoers.d/ instead of
# directly modifying this file.
#
# See the man page for details on how to write a sudoers file.
#
Defaults	env_reset
Defaults	mail_badpass
Defaults
secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

# Host alias specification

# User alias specification

# Cmnd alias specification

# User privilege specification# Allow members of group sudo to execute
any command
%sudo	ALL=(ALL:ALL) ALL

root	ALL=(ALL:ALL) ALL

# Allow members of group sudo to execute any command
%sudo	ALL=(ALL:ALL) ALL

# See sudoers(5) for more information on "#include" directives:

#includedir /etc/sudoers.d

visudo

Il comando visudo è un editor di testo che permette di modificare il file di configurazione:

	/etc/sudoers

Il comando visudo blocca il file sudoers, in modo da impedire accessi multipli al file: nel caso il file fosse già aperto da un altro utente, il nuovo utente riceverà un messaggio di invito a riprovare più tardi. Inoltre, il comando visudo verifica che le modifiche apportate siano correttamente scritte: nel caso ci fossero degli errori di sintassi, le modifiche non verranno salvate automaticamente, ma visudo offrirà all'utente tre opzioni:

• e ( re-edit ): ripartire dall'inizio.

• x ( exit ): uscire senza salvare le modifiche.

• Q ( Quit ): uscire salvando, comunque, le modifiche. Da usare con estrema cautela.

E' possibile chiedere a visudo di effettuare solo la verifica di sudoers:

	sudo visudo -c

E' possibile chiedere a visudo di operare su un file diverso dal file sudoers di default:

	sudo visudo -f nuovo_sudoers

Una volta aperto il file da editare, quali comandi usare? Dipende dall'editor di testo usato da visudo. Normalmente, visudo utilizza l'editor vi. Una lista di editor è compresa nel codice sorgente di visudo. E' possibile impostare un editor particolare, utilizzando le variabili di sudo:

	Defaults editor=/usr/bin/nano

Questa riga, che indica a visudo di utilizzare l'editor di testo nano, deve essere aggiunta al file sudoers di default, oppure in uno dei file contenuti nella directory:

	/etc/sudoers.d

Per esempio, nel file:

	/etc/sudoers.d/my_sudoers

Normalmente, visudo non utilizza le variabili d'ambiente:

	$VISUAL
	$EDITOR

a meno che non contengano un editor di testo presente nella lista di editor compresa nel codice sorgente di visudo.

su

Il comando su permette di agire nel sistema, con i privilegi di un altro utente. A differenza del comando sudo, il comando su assegna i privilegi del'utente richiesto, fino alla chiusura della sessione:

	exit

Normalmente, l'ambiente corrente ( variabili d'ambiente ) viene trasferito alla nuova shell. Per caricare, invece, l'ambiente associato all'utente target, utilizzate l'opzione:

	su -l root
	su --login root

A differenza del comando sudo, il comando su richiede, per l'accesso, i dati ( password ) dell'utente target. Questo significa che, se il sistema operativo tiene bloccata la password di root, come avviene, per esempio, con Ubuntu, per poter utilizzare il comando su, dovrete, prima, sbloccare la password di root.