[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]
Le informazioni sugli utenti registrati nel sistema sono raccolte principalmente all'interno di /etc/passwd. Anche se il nome suggerisce che debba contenere le parole d'ordine, 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 parole d'ordine 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 53.2.2, 53.2.3 e 53.2.4.
La tabella 54.1 elenca i programmi e i file a cui si accenna in questo capitolo.
Tabella 54.1. Riepilogo dei programmi e dei file per la gestione della registrazione degli utenti.
In questo documento si accenna più volte al fatto che le parole d'ordine 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 parola d'ordine, mentre da sola, questa stringa non permette di determinare quale sia la parola d'ordine di origine. In pratica, data la parola d'ordine si può determinare la stringa cifrata, ma dalla stringa cifrata non si ottiene la parola d'ordine.
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 parola d'ordine è valida, altrimenti no.
L'algoritmo usato per generare la parola d'ordine cifrata non è uguale in tutti i sistemi. Per quanto riguarda GNU/Linux si distinguono due possibilità: l'algoritmo tradizionale DES, che accetta parole d'ordine con un massimo di otto caratteri, e l'algoritmo MD5 che al contrario non pone limiti.
La gestione dell'algoritmo di cifratura delle parole d'ordine è 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 55).
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 parole d'ordine sia aggiornato correttamente.
Il trasferimento, o la replicazione delle utenze si basa sulla riproduzione delle parole d'ordine 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 parole d'ordine. 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 parola d'ordine cifrata, ha una debolezza fondamentale: conoscendo la stringa cifrata e l'algoritmo che la genera, si può determinare la parola d'ordine originale per tentativi.(1)
Un sistema che consente l'utilizzo di parole d'ordine con un massimo di otto caratteri è molto debole ai giorni nostri, perché tutte le combinazioni possibili possono essere provate in tempi brevi, anche con un elaboratore di potenza media.
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 parola d'ordine.
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 parola d'ordine, una shell, creando anche 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 parola d'ordine registrata all'interno di /etc/passwd (oppure all'interno di /etc/shadow, come si vedrà in seguito). (2) Solo l'utente root può cambiare la parola d'ordine di un altro utente. Gli utenti comuni (tutti escluso root) devono utilizzare una parola d'ordine non troppo breve composta sia da maiuscole che minuscole o simboli diversi. Alcune parole d'ordine simili al nome utilizzato per identificare l'utente, non sono valide.(3)(4)
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 parola d'ordine che poi potrà essere specificata attraverso passwd.
chsh [opzioni] [utente]
Permette di cambiare la shell predefinita all'interno del file /etc/passwd. (5) È 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 parola d'ordine.
-s shell | --shell shell
Permette di specificare la shell.
-l | --list-shells
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. Ciò 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. (6) 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 convenzionale, 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, che appare suddiviso su due righe per la mancanza di spazio:
tizio:724AD9dGbG25k:502:502:Tizio Tizi,Riparazioni,123456,987654: (segue)
/home/tizio:/bin/bash
groups [utente...]
Visualizza i gruppi ai quali l'utente o gli utenti appartengono. Il risultato è equivalente al comando seguente: (7)
id -Gn [nome_utente]
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. (8)
-u | --user
Emette solo il numero dell'utente (UID).
-g | --group
Emette solo il numero del gruppo (GID).
-G | --groups
Emette solo i numeri dei gruppi supplementari.
-n | --name
Emette il nome dell'utente, del gruppo o dei gruppi, a seconda che sia usato insieme a -u, -g o -G.
-r | --real
Emette i numeri UID o GID reali invece di quelli efficaci (ammesso che ci sia differenza). Si usa insieme a -u, -g o -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 parole d'ordine di questi utenti speciali (tutti tranne root) hanno un asterisco che di fatto impedisce qualunque accesso.
Segue la descrizione di alcuni di questi utenti e gruppi.
root
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.
bin
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.
tty
Di solito, al gruppo tty appartengono i file di dispositivo utilizzabili come canali per la connessione di un terminale.
disk
Di solito, al gruppo disk appartengono i file di dispositivo che si riferiscono a unità a dischi, compresi i CD-ROM.
floppy
Di solito, al gruppo floppy appartengono i file di dispositivo che si riferiscono alle unità a dischetti.
nobody
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 file system 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.
|
A seconda della distribuzione GNU/Linux che si utilizza, il gruppo abbinato a questo utente potrebbe chiamarsi nobody, oppure anche nogroup. |
L'eliminazione di un utente dal sistema non è gestibile attraverso un programma di servizio 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 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/crontabs/ e /var/spool/cron/atjobs/ 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 / -uid numero_utente -print
find / -user utente -print
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"
ELENCO_FILE_UTENTE=`tempfile`
#======================================================================
# 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 otto 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 -n "Questo script può essere utilizzato "
echo -n "solo dall'utente root."
echo
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), quindi elimina l'elenco temporaneo.
#--------------------------------------------------------------
#rm `cat $ELENCO_FILE_UTENTE`
rm $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 parola d'ordine, 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 parola d'ordine, 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 parola d'ordine 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.
Un utente reale potrebbe avere bisogno di gestire diversi nominativi-utente per accedere allo stesso elaboratore e gestire attività differenti, pur mantenendo lo stesso numero UID e lo stesso numero GID. In questo modo, avrebbe a disposizione diverse directory personali, una per ogni progetto che conduce.
tizio:34gdf6r123455:1000:1000:Tizio Tizi:/home/tizio:/bin/sh alfa:34gdf6r123455:1000:1000:Tizio Tizi prog. Alfa:/home/alfa:/bin/sh bravo:34gdf6r123455:1000:1000:Tizio Tizi prog. Bravo:/home/bravo:/bin/sh charlie:34gdf6r123455:1000:1000:Tizio Tizi prog. Charlie:/home/charlie:/bin/sh
Eventualmente, per distinguere quale sia il nominativo-utente utilizzato effettivamente, si potrebbe modificare la stringa di definizione dell'invito della shell. Nel caso di Bash, si potrebbe utilizzare quella seguente:
PS1="$USER->\u@\h:\w\\$ " export PS1
Il significato di questo verrà approfondito nei capitoli dedicati a Bash (la parte xv).
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 0028. 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 dei gruppi devono appartenere a questi stessi gruppi.(9)
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 0028, per 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.
daniele @ swlibero.org1) Naturalmente, questo vale finché nessuno riesce a trovare un algoritmo inverso che permetta di ricalcolare la parola d'ordine a partire dalla stessa stringa cifrata.
2) Shadow utilities software libero con licenza speciale
3) Quando si inventa una nuova parola d'ordine 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.
4) In generale, i sistemi pongono anche un limite superiore alla lunghezza delle parole d'ordine. In tali casi, può capitare che la parte eccedente tale dimensione venga semplicemente ignorata, rendendo vano lo sforzo dell'utente.
5) Shadow utilities software libero con licenza speciale
6) Shadow utilities software libero con licenza speciale
7) GNU shell programming utilities GNU GPL
8) GNU shell programming utilities GNU GPL
9) Questo metodo di comportamento è quello predefinito della distribuzione Red Hat e anche nella distribuzione Debian.
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome utenza.html
[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]