[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


39. Utenza

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 38.2.2, 38.2.3 e 38.2.4.

La tabella 39.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.

Tabella 39.1: Riepilogo dei programmi e dei file per la gestione della registrazione degli utenti.

39.1 Password cifrate

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.

39.1.1 Funzione crypt()

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 DES, che accetta password con un massimo di otto 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 40).

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.

39.1.2 Trasferimento delle utenze

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.

39.1.3 Debolezza di questo sistema

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 otto caratteri è molto debole ai giorni nostri, perché tutte le combinazioni possibili possono essere trovate in breve tempo (forse qualche settimana) con un elaboratore di media potenza.

39.2 Utenti e gruppi

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.

39.2.1 # adduser, useradd

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.

39.2.2 /etc/skel/*

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.

39.2.3 $ passwd

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'.

39.2.4 $ chsh

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.

Alcune opzioni

-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'.

39.2.5 /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.

39.2.6 $ chfn

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.

Esempi

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.

39.2.7 $ groups

groups [<utente>...]

Visualizza i gruppi ai quali l'utente o gli utenti appartengono. Il risultato è equivalente al comando seguente:

id -Gn [<nome-utente>]

39.2.8 $ 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.

Opzioni

-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'.

39.3 Utenti e gruppi importanti

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 `nobody' ha il numero UID 99, come definito nella distribuzione Red Hat. In generale, questo utente potrebbe avere il numero -1, che applicandosi a un intero positivo rappresenta in pratica il numero più alto gestibile di UID, altre volte potrebbe essere il numero -2. Il numero massimo di UID dipende dalle caratteristiche del filesystem e dalle librerie utilizzate.

Segue la descrizione di alcuni di questi utenti e gruppi.

39.4 Eliminazione di un utente

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:

I file di un utente possono trovarsi ovunque gli sia stato consentito di scriverli. In particolare:

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"

#======================================================================
# 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).
        #--------------------------------------------------------------
        #rm `cat $ELENCO_FILE_UTENTE`
        echo
    fi

#======================================================================
# Fine.
#======================================================================

39.5 Trucchi

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.

39.5.1 Utente con funzione specifica

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.

39.5.2 Gruppo di utenti con lo stesso UID

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.

39.5.3 Uno stesso UID e GID per più nominativi-utente

Un utente reale potrebbe avere bisogno di gestire dei nominativi-utente differenti 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 (a partire da 44).

39.5.4 Un gruppo per ogni utente (gruppi privati)

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».

  1. 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.

  2. 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
    

  3. Si crea una sorta di directory home per i file del progetto, con eventuali ramificazioni.

    mkdir /home/progetti/alfa

    mkdir /home/progetti/alfa/...

  4. Si assegna l'appartenenza di questa directory (ed eventuali sottodirectory) al gruppo di lavoro.

    chown -R root.alfa /home/gruppi/alfa

  5. 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 2000.04.12 --- Copyright © 1997-2000 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 e anche nella distribuzione Debian.


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]