Qual è la regex per convalidare gli utenti Linux?

Ci scusiamo per il necrobumping di questa domanda vecchia di quasi 4 anni, ma appare piuttosto in alto nei risultati di ricerca su Internet e merita un po' più di attenzione.

Una regex più accurata è (sì, lo so, nonostante la pagina man):

^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\$)$

Spero che questo aiuti alcuni di coloro che cercano.

Per scomporlo:

1. Dovrebbe iniziare (^ ) con solo lettere minuscole o un trattino basso ([a-z_] ). Questo occupa esattamente 1 carattere.
2. Allora dovrebbe essere uno di uno (( ... ) ):
   1. Da 0 al 31 caratteri ({0,31} ) di lettere , numeri , trattini bassi e/o trattini ([a-z0-9_-] ), OPPURE (| )
   2. Da 0 a 30 caratteri del precedente più un simbolo USD (\$ ) alla fine, e poi
3. Niente più caratteri passati questo schema ($ ).

Per coloro che non hanno familiarità con i pattern regex, potresti chiederti perché il simbolo del dollaro aveva una barra rovesciata in 2.2. ma non in 3. Questo perché nella maggior parte (tutte?) delle varianti regex, il simbolo del dollaro indica la fine di una stringa (o riga, ecc.). A seconda del motore utilizzato, dovrà essere sfuggito se fa parte della stringa effettiva (non riesco a pensare in cima alla mia testa di un motore regex che non usa la barra rovesciata come fuga per una pura espressione) .

Nota che Debian e Ubuntu rimuovono alcune restrizioni per un nome utente completamente compatibile con POSIX/shadow upstream (ad esempio, e non so se questo è stato risolto, ma consentono al nome utente di iniziare con un numero - che in realtà è ciò che ha causato questo insetto). Se vuoi garantire la multipiattaforma, ti consiglio il modello regex sopra riportato piuttosto che quello che supera/fallisce il controllo in Debian, Ubuntu e altri.

Dalla pagina man di useradd (8):

Di solito si consiglia di utilizzare solo nomi utente che iniziano con una lettera minuscola o un trattino basso, seguiti da lettere minuscole, cifre, trattini bassi o trattini. Possono terminare con il simbolo del dollaro. In termini di espressioni regolari:[a-z_][a-z0-9_-]*[$]?

Su Debian, gli unici vincoli sono che i nomi utente non devono iniziare con un trattino ('-') né contenere due punti (':') o uno spazio bianco (spazio:' ', fine riga:'\n', tabulazione:' \t', ecc.). Tieni presente che l'utilizzo di una barra ('/') potrebbe interrompere l'algoritmo predefinito per la definizione della home directory dell'utente.

I nomi utente possono avere una lunghezza massima di 32 caratteri.

Quindi, c'è una raccomandazione generale. I vincoli effettivi dipendono dalle specifiche della tua implementazione/distribuzione. Sui sistemi basati su Debian, apparentemente non ci sono vincoli molto rigidi. Infatti, ho appena provato useradd '€' sulla mia macchina Ubuntu, e ha funzionato. Naturalmente, questo potrebbe interrompere alcune applicazioni che non si aspettano nomi utente così insoliti. Per evitare tali problemi, è meglio seguire la raccomandazione generale.

La regola generale per il nome utente è che la sua lunghezza deve essere inferiore a 32 caratteri. Dipende dalla tua distribuzione per creare un nome utente valido.

In Debian, shadow-utils 4.1 , c'è un is_valid_name funzione in chkname.c :

static bool is_valid_name (const char *name)
{
    /*
     * User/group names must match [a-z_][a-z0-9_-]*[$]
     */
    if (('\0' == *name) ||
        !((('a' <= *name) && ('z' >= *name)) || ('_' == *name))) {
        return false;
    }

    while ('\0' != *++name) {
        if (!(( ('a' <= *name) && ('z' >= *name) ) ||
              ( ('0' <= *name) && ('9' >= *name) ) ||
              ('_' == *name) ||
              ('-' == *name) ||
              ( ('$' == *name) && ('\0' == *(name + 1)) )
             )) {
            return false;
        }
    }

    return true;
}

E la lunghezza del nome utente è stata verificata prima:

bool is_valid_user_name (const char *name)
{
    /*
     * User names are limited by whatever utmp can
     * handle.
     */
    if (strlen (name) > USER_NAME_MAX_LENGTH) {
        return false;
    }

    return is_valid_name (name);
}