Quelle est la regex pour valider les utilisateurs Linux ?

Désolé d'avoir posé cette question vieille de presque 4 ans, mais elle arrive assez haut dans les résultats de recherche sur Internet et mérite un peu plus d'attention.

Une expression régulière plus précise est (oui, je sais, malgré la page de manuel) :

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

J'espère que cela aidera certains de ceux qui recherchent.

Pour le décomposer :

1. Ça devrait démarrer (^ ) avec uniquement des lettres minuscules ou un trait de soulignement ([a-z_] ). Cela occupe exactement 1 caractère.
2. Alors ça devrait être un de soit (( ... ) ):
   1. À partir de 0 au 31 caractères ({0,31} ) de lettres , chiffres , traits de soulignement , et/ou des traits d'union ([a-z0-9_-] ), OU (| )
   2. À partir de 0 à 30 caractères des plus ci-dessus un symbole USD (\$ ) à la fin, puis
3. Plus de caractères passés ce modèle ($ ).

Pour ceux qui ne connaissent pas les modèles regex, vous pouvez vous demander pourquoi le signe dollar avait une barre oblique inverse dans 2.2. mais pas dans 3. C'est parce que dans la plupart (toutes ?) des variantes de regex, le signe dollar indique la fin d'une chaîne (ou d'une ligne, etc.). Selon le moteur utilisé, il devra être échappé s'il fait partie de la chaîne réelle (je ne peux pas penser du haut de ma tête à un moteur regex qui n'utilise pas de barre oblique inverse comme échappement pour une expression pure) .

Notez que Debian et Ubuntu suppriment certaines restrictions pour un nom d'utilisateur entièrement conforme à POSIX/shadow en amont (par exemple, et je ne sais pas si cela a été corrigé, mais ils permettent au nom d'utilisateur de commencer par un nombre - qui est en fait ce qui a causé cela punaise). Si vous voulez garantir la multiplateforme, je recommanderais le modèle regex ci-dessus plutôt que ce qui réussit/échoue la vérification dans Debian, Ubuntu et autres.

À partir de la page de manuel de useradd (8) :

Il est généralement recommandé de n'utiliser que des noms d'utilisateur commençant par une lettre minuscule ou un trait de soulignement, suivis de lettres minuscules, de chiffres, de traits de soulignement ou de tirets. Ils peuvent se terminer par un signe dollar. En termes d'expressions régulières :[a-z_][a-z0-9_-]*[$] ?

Sur Debian, les seules contraintes sont que les noms d'utilisateur ne doivent ni commencer par un tiret ('-'), ni contenir deux-points (':') ou un espace (espace :' ', fin de ligne :'\n', tabulation :' \t', etc.). Notez que l'utilisation d'une barre oblique ('/') peut casser l'algorithme par défaut pour la définition du répertoire personnel de l'utilisateur.

Les noms d'utilisateur ne peuvent contenir que 32 caractères.

Donc, il y a une recommandation générale. Les contraintes réelles dépendent des spécificités de votre implémentation/distribution. Sur les systèmes basés sur Debian, il n'y a apparemment pas de contraintes très strictes. En fait, je viens d'essayer useradd '€' sur ma boîte Ubuntu, et cela a fonctionné. Bien sûr, cela peut casser certaines applications qui ne s'attendent pas à des noms d'utilisateur aussi inhabituels. Pour éviter de tels problèmes, il est préférable de suivre la recommandation générale.

La règle générale pour le nom d'utilisateur est que sa longueur doit être inférieure à 32 caractères. Cela dépend de votre distribution pour créer un nom d'utilisateur valide.

Dans Debian, shadow-utils 4.1 , il y a un is_valid_name fonction en 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;
}

Et la longueur du nom d'utilisateur a été vérifiée avant :

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);
}