Le informazioni sugli utenti registrati nel sistema sono raccolte principalmente all'interno di /etc/passwd. Anche se il nome suggerisce che debba contenere le password, in realtà il suo scopo è più ampio e la sua accessibilità in lettura è essenziale per tutti i programmi che hanno qualcosa a che fare con gli utenti. Per questo motivo, in molti sistemi si preferisce trasferire le password in un altro file con meno possibilità di accesso: /etc/shadow. Il file /etc/group permette di raccogliere le notizie sui gruppi e in particolare di stabilire la possibile appartenenza da parte di un utente a più gruppi.
Questi file sono già stati descritti nelle sezioni 35.2.2, 35.2.3 e 35.2.4.
La tabella 36.1 elenca i programmi e i file a cui si accenna in questo capitolo.
| Nome | Descrizione |
| adduser | Aggiunge un utente e tutto quello che serve perché possa accedere. |
| /etc/skel/ | Struttura tipica di una nuova directory personale. |
| passwd | Permette di modificare la password. |
| chsh | Cambia la shell abbinata all'utente. |
| /etc/shells | Elenco delle shell utilizzabili nel sistema. |
| chfn | Modifica i dati personali dell'utente. |
| groups | Elenca i gruppi a cui appartiene un utente. |
| id | Elenca i dati identificativi dell'utente. |
In questo documento si accenna più volte al fatto che le password utilizzate per accedere vengono annotate in forma cifrata, nel file /etc/passwd, oppure nel file /etc/shadow.
La cifratura genera una stringa che può essere usata per verificare la correttezza della password, mentre da sola, questa stringa non permette di determinare quale sia la password di origine. In pratica, data la password si può determinare la stringa cifrata, ma dalla stringa cifrata non si ottiene la password.
La verifica dell'identità avviene quindi attraverso la generazione della stringa cifrata corrispondente: se corrisponde a quanto annotato nel file /etc/passwd, oppure nel file /etc/shadow, la password è valida, altrimenti no.
L'algoritmo usato per generare la password cifrata non è uguale in tutti i sistemi. Per quanto riguarda GNU/Linux si distinguono due possibilità: l'algoritmo tradizionale, che accetta password con un massimo di 8 caratteri, e l'algoritmo MD5 che al contrario non pone limiti.
La gestione dell'algoritmo di cifratura delle password è a carico della funzione crypt() (descritta in crypt(3)). Nelle distribuzioni GNU/Linux in cui si può usare l'algoritmo MD5 dovrebbe essere possibile scegliere questo, o l'algoritmo precedente, attraverso un file di configurazione (/etc/login.defs, che verrà descritto nel capitolo
37).
Se la propria distribuzione non sembra predisposta per la cifratura MD5, è meglio non fare esperimenti: è importante che ogni componente del sistema di autenticazione e di gestione delle password sia aggiornato correttamente.
Il trasferimento, o la replicazione delle utenze si basa sulla riproduzione delle password cifrate, in modo tale da poter ignorare quale sia il loro valore di origine. Questa riproduzione può avvenire in modo manuale o automatico; cioè può essere l'amministratore del sistema che provvede a ricopiare le utenze, oppure può essere un servizio di rete, come il NIS (Network Information Service, noto anche come YP, Yellow Pages).
In tutti i casi di riproduzione delle utenze, occorre che i sistemi coinvolti concordino nel funzionamento della funzione crypt(), cioè generino le stesse stringhe cifrate a partire dalle password. Questo è il punto più delicato nella scelta di utilizzare o meno un algoritmo più sofisticato rispetto a quello tradizionale.
Questo sistema di autenticazione basato sulla conservazione di una password cifrata, ha una debolezza fondamentale: conoscendo l'algoritmo che genera la stringa cifrata, e conoscendo la stringa stessa, si può determinare la password originale per tentativi. *1*
Un sistema che consente l'utilizzo di password con un massimo di 8 caratteri è molto debole ai giorni nostri, perché tutte le combinazioni possibili possono essere trovate in breve tempo (forse qualche mese) con un elaboratore di media potenza.
I nuovi utenti possono essere aggiunti solo da parte dell'utente root, ma poi possono essere loro stessi a cambiare alcuni elementi della loro registrazione. Il più importante è naturalmente la password.
adduser |
useradd |
Il programma in questione può avere due nomi alternativi: adduser o useradd. Questo permette all'utente root di aggiungere un nuovo utente all'interno del file /etc/passwd, assegnandogli un UID, un GID, una password, una shell e creando la sua directory personale.
Per convenzione, il programma (o script che sia) inserisce automaticamente nella directory personale alcuni file di configurazione standard contenuti nella directory /etc/skel/. Di conseguenza, basta porre all'interno di questa directory i file e le directory che si vogliono riprodurre nella directory personale di ogni nuovo utente.
|
Per mantenere la compatibilità con alcuni vecchi programmi, il nome dell'utente non deve superare gli otto caratteri. Inoltre, è opportuno limitarsi all'uso di lettere non accentate e di numeri; qualunque altro simbolo, compresi i segni di punteggiatura, potrebbero creare problemi di vario tipo. |
La directory /etc/skel/ viene utilizzata normalmente come directory personale tipica per i nuovi utenti. In pratica, quando si aggiunge un nuovo utente e gli si prepara la sua directory personale, viene copiato all'interno di questa il contenuto di /etc/skel/.
Il nome skel sta per skeleton, cioè scheletro. In effetti rappresenta lo scheletro di una nuova directory personale.
È molto importante la preparazione di questa directory in modo che ogni nuovo utente trovi subito una serie di file di configurazione necessari a utilizzare le shell previste nel sistema, ed eventualmente altri programmi essenziali.
passwd [<utente>] |
Permette di cambiare la password registrata all'interno di /etc/passwd (oppure all'interno di /etc/shadow, come si vedrà in seguito). Solo l'utente root può cambiare la password di un altro utente. Gli utenti comuni (tutti escluso root) devono utilizzare una password non troppo breve composta sia da maiuscole che minuscole o simboli diversi. Alcune password simili al nome utilizzato per identificare l'utente, non sono valide.
*2*
*3*
Se non si dispone di un mezzo per l'inserimento di un nuovo utente, come quello fornito da adduser, è possibile aggiungere manualmente un record all'interno del file /etc/passwd senza l'indicazione della password che poi potrà essere specificata attraverso passwd.
chsh [<opzioni>] [<utente>] |
Permette di cambiare la shell predefinita all'interno del file /etc/passwd. È possibile indicare solo una shell esistente e possibilmente elencata all'interno di /etc/shells. Se la nuova shell non viene indicata tra gli argomenti, questa viene richiesta subito dopo l'avvio di chsh. Per conferma, viene richiesta anche la ripetizione della password.
|
Permette di specificare la shell.
|
Emette un elenco delle shell disponibili in base al contenuto di /etc/shells.
Il file /etc/shells contiene semplicemente un elenco di shell valide, cioè di quelle che sono esistenti e possono essere utilizzate. Segue un esempio di questo file.
/bin/sh /bin/bash /bin/tcsh /bin/csh /bin/ash /bin/zsh |
È molto importante che questo file sia preparato con cura, e contenga solo le shell per le quali il sistema è predisposto. Questo significa, quanto meno, che deve esistere una configurazione generalizzata per ognuna di queste, e che nella directory /etc/skel/ devono essere stati predisposti tutti i file di configurazione personalizzabili che sono necessari. Quindi, un file /etc/shells con un semplice elenco di tutte le shell disponibili non è sufficiente.
chfn [<opzioni>] [<utente>] |
Consente di modificare le informazioni personali registrate all'interno del file /etc/passwd. Si tratta in pratica del nome e cognome dell'utente, del numero dell'ufficio, del telefono dell'ufficio e del telefono di casa. Se non vengono specificate opzioni, i dati vengono inseriti in maniera interattiva, se non viene specificato l'utente, si intende quello che ha eseguito il comando. Solo l'utente root può cambiare le informazioni di un altro utente.
Le informazioni indicate nel quinto capo dei record del file /etc/passwd, sono strutturate solo in modo convenzione, senza che esista una necessità effettiva.
L'esempio seguente mostra le azioni compiute da un utente per definire le proprie informazioni personali.
tizio$ chfn[Invio]
Changing finger information for tizio |
Password: ********[Invio]
Name [tizio]: Tizio Tizi[Invio]
Office []: Riparazioni[Invio]
Office Phone[]: 123456[Invio]
Home Phone[]: 9876543[Invio]
Finger information changed. |
Volendo verificare il risultato all'interno del file /etc/passwd, si può trovare il record seguente:
tizio:724AD9dGbG25k:502:502:Tizio Tizi,Riparazioni,123456,987654:\ /home/tizio:/bin/bash |
Le informazioni personali possono essere delicate, specialmente quando si tratta di indicare il numero telefonico dell'abitazione di un utente. Per questo, quando si tratta di utenze presso elaboratori raggiungibili attraverso una rete estesa, come Internet, occorre prudenza.
groups [<utente>...] |
Visualizza i gruppi ai quali l'utente o gli utenti appartengono. Il risultato è equivalente al comando seguente:
id
|
id [<opzioni>] [<utente>] |
Visualizza il numero UID (User ID) e il numero GID (Group ID) reale ed efficace dell'utente selezionato o di quello corrente.
|
Emette solo il numero dell'utente (UID).
|
Emette solo il numero del gruppo (GID).
|
Emette solo i numeri dei gruppi supplementari.
|
Emette il nome dell'utente, del gruppo o dei gruppi, a seconda che sia usato insieme a -u-g-G
|
Emette i numeri UID o GID reali invece di quelli efficaci (ammesso che ci sia differenza). Si usa insieme a -u-g-G
Osservando il file /etc/passwd si possono notare diversi utenti fittizi standard che hanno degli scopi particolari. Si tratta di utenti di sistema, nel senso che servono al buon funzionamento del sistema operativo.
root:dxdFf9MvQ3s:0:0:root:/root:/bin/bash bin:*:1:1:bin:/bin: daemon:*:2:2:daemon:/sbin: adm:*:3:4:adm:/var/adm: lp:*:4:7:lp:/var/spool/lpd: sync:*:5:0:sync:/sbin:/bin/sync shutdown:*:6:0:shutdown:/sbin:/sbin/shutdown halt:*:7:0:halt:/sbin:/sbin/halt mail:*:8:12:mail:/var/mail: news:*:9:13:news:/var/spool/news: uucp:*:10:14:uucp:/var/spool/uucp: operator:*:11:0:operator:/root: games:*:12:100:games:/usr/games: gopher:*:13:30:gopher:/usr/lib/gopher-data: ftp:*:14:50:FTP User:/home/ftp: nobody:*:99:99:Nobody:/: |
Di conseguenza, anche /etc/group contiene l'indicazione di gruppi particolari (gruppi di sistema).
root::0:root bin::1:root,bin,daemon daemon::2:root,bin,daemon sys::3:root,bin,adm adm::4:root,adm,daemon tty::5: disk::6:root lp::7:daemon,lp mem::8: kmem::9: wheel::10:root mail::12:mail news::13:news uucp::14:uucp man::15: games::20: gopher::30: dip::40: ftp::50: nobody::99: users::100: |
I campi delle password di questi utenti speciali (tutti tranne root) hanno un asterisco che di fatto impedisce qualunque accesso.
|
Le varie distribuzioni GNU/Linux si distinguono spesso nella quantità e nell'organizzazione degli utenti e dei gruppi fittizi. In questo caso, in particolare, l'utente fittizio |
Segue la descrizione di alcuni di questi utenti e gruppi.
L'utente root è l'amministratore del sistema: ogni sistema Unix ha un utente root. L'utente root ha sempre il numero UID pari a zero.
L'utente bin non esiste nella realtà. Si tratta di un nome fittizio definito per assegnare ai file eseguibili (binary) un proprietario diverso dall'utente root. Di solito, con GNU/Linux, questi eseguibili appartengono al gruppo bin, mentre l'utente proprietario resta root.
Di solito, al gruppo tty appartengono i file di dispositivo utilizzabili come canali per la connessione di un terminale.
Di solito, al gruppo disk appartengono i file di dispositivo che si riferiscono a unità a dischi, compresi i CD-ROM.
Di solito, al gruppo floppy appartengono i file di dispositivo che si riferiscono alle unità a dischetti.
L'utente nobody corrisponde in linea di massima a un utente generico, non identificato, senza privilegi particolari. Viene usato in particolare per evitare che un utente root possa accedere a un filesystem di rete (NFS) mantenendo i suoi privilegi: quando ciò accade, l'elaboratore che offre il servizio NFS lo tratta come utente nobody.
In generale, nobody non deve essere utilizzabile per l'accesso umano.
L'eliminazione di un utente dal sistema non è gestibile attraverso un programma di utilità standard di uso generale: la particolare distribuzione GNU/Linux può fornire degli strumenti adatti, oppure si deve agire manualmente. In questa sezione si descrive come si può intervenire manualmente.
Fondamentalmente si tratta di agire su due punti:
l'eliminazione dell'utente dai file /etc/passwd e /etc/group (ed eventualmente anche da /etc/shadow);
l'eliminazione dei file appartenenti a quell'utente.
I file di un utente possono trovarsi ovunque gli sia stato consentito di scriverli. In particolare:
la directory personale;
la directory delle caselle postali (/var/mail/ o in certi casi /var/spool/mail/, a meno che questa non sia già inserita direttamente nelle directory personale);
la directory /var/spool/cron/ e /var/spool/at/ per eventuali applicazioni a esecuzione pianificata.
Per elencare tutti i file appartenenti a un certo utente, è possibile usare il programma find in uno dei modi seguenti.
find / |
find / |
Volendo, si potrebbe costruire uno script per l'eliminazione automatica di tutti i file appartenenti a un utente determinato. L'esempio seguente, prima di eliminare i file, crea una copia compressa.
#!/bin/bash
#======================================================================
# eliminautente
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#------------------------------------------------------------------
# Il nome dell'utente viene fornito come primo e unico argomento
# di questo script.
#------------------------------------------------------------------
NOME_UTENTE="$1"
#------------------------------------------------------------------
# Nome per un file temporaneo contenente l'elenco dei file
# appartenenti all'utente che si vuole eliminare.
#------------------------------------------------------------------
ELENCO_FILE_UTENTE="/tmp/elenco_file_utente"
#======================================================================
# Funzioni.
#======================================================================
#------------------------------------------------------------------
# Visualizza la sintassi corretta per l'utilizzo di questo script.
#------------------------------------------------------------------
function sintassi () {
echo ""
echo "eliminautente <nome-utente>"
echo ""
echo "Il nome può avere al massimo 8 caratteri."
}
#======================================================================
# Inizio.
#======================================================================
#------------------------------------------------------------------
# Verifica la quantità di argomenti.
#------------------------------------------------------------------
if [ $# != 1 ]
then
#--------------------------------------------------------------
# La quantità di argomenti è errata. Richiama la funzione
# «sintassi» e termina l'esecuzione dello script restituendo
# un valore corrispondente a «falso».
#--------------------------------------------------------------
sintassi
exit 1
fi
#------------------------------------------------------------------
# Verifica che l'utente sia root.
#------------------------------------------------------------------
if [ $UID != 0 ]
then
#--------------------------------------------------------------
# Dal momento che l'utente non è root, avvisa dell'errore
# e termina l'esecuzione restituendo un valore corrispondente
# a «falso».
#--------------------------------------------------------------
echo \
"Questo script può essere utilizzato solo dall'utente root."
exit 1
fi
#------------------------------------------------------------------
# Crea un elenco di tutti i file appartenenti all'utente
# specificato.
# Si deve evitare che find cerchi di entrare nella directory /dev/.
#------------------------------------------------------------------
find / -user $NOME_UTENTE -a \( -path "/dev" -prune -o -print \) \
> $ELENCO_FILE_UTENTE
#------------------------------------------------------------------
# Comprime i file generando un file compresso con lo stesso nome
# dell'utente da eliminare e con estensione «.tgz».
# Si utilizza «tar» e in particolare:
# «z» permette di comprimere automaticamente l'archivio
# attraverso «gzip»;
#------------------------------------------------------------------
if tar czvf ~/$NOME_UTENTE.tgz `cat $ELENCO_FILE_UTENTE`
then
#--------------------------------------------------------------
# Se è andato tutto bene, elimina i file
# (togliere il commento).
#--------------------------------------------------------------
#rm `cat $ELENCO_FILE_UTENTE`
echo
fi
#======================================================================
# Fine.
#======================================================================
|
Alcuni accorgimenti nella gestione degli utenti e dei gruppi possono essere utili in situazioni particolari, anche se a volte si tratta di scelte discutibili. Nelle sezioni seguenti se ne descrivono alcuni.
Un trucco che potrebbe rivelarsi comodo in certe situazioni è quello di creare un utente fittizio, con o senza password, al quale si associa un programma o uno script, al posto di una shell. La directory corrente nel momento in cui il programma o lo script viene eseguito è quella indicata come directory home (directory personale).
L'esempio seguente mostra un record del file /etc/passwd preparato in modo da permettere a chiunque di eseguire il programma (o lo script) /usr/local/bin/ciao partendo dalla posizione della directory /tmp/. Il numero UID 505 e GID 100 sono solo un esempio.
ciao::505:100:Ciao a tutti:/tmp:/usr/local/bin/ciao |
Naturalmente, il fatto di poter avere un utente (reale o fittizio) che possa accedere senza password, dipende dal sistema di autenticazione: il programma login, il quale potrebbe essere stato configurato (o predisposto all'atto della compilazione) per vietare un tale comportamento.
All'interno di un ambiente in cui esiste una certa fiducia nel comportamento reciproco, potrebbe essere conveniente creare un gruppo di utenti con lo stesso numero UID.
Ogni utente avrebbe un proprio nome e una password per accedere al sistema, ma poi, tutti i file apparterrebbero a un utente immaginario che rappresenta tutto il gruppo. Segue un esempio del file /etc/passwd.
tutti:*:1000:1000:Gruppo di lavoro:/home/tutti:/bin/sh alfa:34gdf6r123455:1000:1000:Gruppo di lavoro:/home/tutti:/bin/sh bravo:e445gsdfr2124:1000:1000:Gruppo di lavoro:/home/tutti:/bin/sh charlie:t654df7u72341:1000:1000:Gruppo di lavoro:/home/tutti:/bin/sh |
Se esiste la necessità o l'utilità si possono assegnare anche directory personali e shell differenti.
Si tratta di una strategia di gestione degli utenti e dei gruppi con cui, ogni volta che si crea un nuovo utente, si crea anche un gruppo con lo stesso nome e, possibilmente, lo stesso numero (UID = GID). Questa tecnica si combina con una maschera dei permessi 002. In pratica, i file vengono creati in modo predefinito con i permessi di lettura e scrittura, sia per l'utente proprietario che per il gruppo, mentre si esclude la scrittura per gli altri utenti.
Il motivo di tutto questo sta nella facilità con cui si può concedere a un altro utente di poter partecipare al proprio lavoro: basta aggiungere il suo nome nell'elenco degli utenti associati al proprio gruppo.
Volendo agire in maniera più elegante, si possono creare degli altri gruppi aggiuntivi, in base alle attività comuni e aggiungere a questi gruppi i nomi degli utenti che di volta in volta partecipano a quelle attività. Naturalmente, i file da condividere all'interno di questi gruppi devono appartenere a questi stessi gruppi. *4*
A titolo di esempio, si mostra cosa sia necessario fare per gestire un gruppo di lavoro per un ipotetico progetto «alfa».
Si fa in modo che la maschera dei permessi predefiniti (umask) degli utenti che faranno parte del progetto, sia pari a 002, in modo da consentire in modo normale ogni tipo di accesso agli utenti dei gruppi di cui si fa parte, ai file e alle directory che verranno create.
Si crea il gruppo alfa e a questo si abbinano tutti gli utenti che dovranno fare parte del progetto. Il record del file /etc/group potrebbe essere simile a quello seguente:
alfa::101:tizio,caio,semproni |
Si crea una sorta di directory home per i file del progetto, con eventuali ramificazioni.
# mkdir /home/progetti/alfa
# mkdir /home/progetti/alfa/...
Si assegna l'appartenenza di questa directory (ed eventuali sottodirectory) al gruppo di lavoro.
# chown -R root.alfa /home/gruppi/alfa
Si assegnano i permessi in modo che ciò che viene creato all'interno del gruppo di directory appartenga al gruppo delle directory stesse.
# chmod -R 2775 /home/progetti/alfa
In questo modo tutte le directory del progetto ottengono l'attivazione del bit SGID, attraverso il quale, in modo predefinito, i file creati al loro interno apparterranno allo stesso gruppo delle directory stesse, cioè quello del progetto per cui sono state predisposte.
---------------------------
Appunti Linux 1999.09.21 --- Copyright © 1997-1999 Daniele Giacomini -- daniele @ pluto.linux.it
1.) Naturalmente, questo vale finché nessuno riesce a trovare un algoritmo inverso che permetta di ricalcolare la password a partire dalla stessa stringa cifrata.
2.) Quando si inventa una nuova password bisogna essere sicuri di poterla introdurre in tutte le situazioni che si potranno presentare. Se si utilizzano lettere accentate (cosa sconsigliabile), potrebbe poi capitare di trovare un terminale che non permette il loro inserimento. In generale, conviene limitarsi a utilizzare i simboli che rientrano nella codifica ASCII a 7 bit.
3.) In generale, i sistemi pongono anche un limite superiore alla lunghezza delle password. In tali casi, può capitare che la parte eccedente tale dimensione venga semplicemente ignorata, rendendo vano lo sforzo dell'utente.
4.) Questo metodo di comportamento è quello predefinito della distribuzione Red Hat.