O que é o regex para validar usuários do Linux?

Question

Ao adicionar um novo usuário, como a string é validada?

Suponho que exista uma expressão regular. O que é essa expressão regular?

    

Answer 1

A regra geral para o nome de usuário é seu comprimento deve ter menos de 32 caracteres. Depende da sua distribuição para criar o nome de usuário válido.

No Debian, shadow-utils 4.1 , há uma função is_valid_name em chkname.c :

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

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

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

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

    return true;
}

E a duração do nome de usuário foi verificada antes:

%pre%     

Answer 2

Na página man do useradd (8) :

It is usually recommended to only use usernames that begin with a lower case letter or an underscore, followed by lower case letters, digits, underscores, or dashes. They can end with a dollar sign. In regular expression terms: [a-z_][a-z0-9_-]*[$]?

On Debian, the only constraints are that usernames must neither start with a dash ('-') nor contain a colon (':') or a whitespace (space: ' ', end of line: '\n', tabulation: '\t', etc.). Note that using a slash ('/') may break the default algorithm for the definition of the user's home directory.

Usernames may only be up to 32 characters long.

Então, há uma recomendação geral. As restrições reais dependem das especificidades de sua implementação / distribuição. Em sistemas baseados em Debian, aparentemente não há restrições muito difíceis. Na verdade, eu apenas tentei useradd '€' na minha caixa Ubuntu, e funcionou. Claro, isso pode quebrar alguns aplicativos que não esperam nomes de usuário tão incomuns. Para evitar tais problemas, é melhor seguir a recomendação geral.

    

Answer 3

Desculpe por necrobumping esta pergunta de quase 4 anos de idade, mas ela aparece bem alta nos resultados de busca na Internet e merece um pouco mais de atenção.

Um regex mais preciso é (sim, eu sei, apesar da página man):

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

Espero que ajude alguns deles a pesquisar.

Para dividir:

1. Deve começar ( ^ ) com apenas letras minúsculas ou um sublinhado ( [a-z_] ). Isso ocupa exatamente o 1 caractere.
2. Em seguida, deve ser um de ou ( ( ... ) ):
   1. De 0 a 31 caracteres ( {0,31} ) de letras , números , sublinhados e / ou hífens ( [a-z0-9_-] ), OU ( | )
   2. De 0 a 30 caracteres do mais acima, um símbolo do USD ( \$ ) no final e, em seguida,
3. Não há mais caracteres passado nesse padrão ( $ ).

Para aqueles que não estão familiarizados com padrões de regex, você pode perguntar por que o cifrão tinha uma barra invertida no 2.2. mas não em 3. Isso acontece porque na maioria das variantes de regex (todas?), o sinal de cifrão indica o fim de uma string (ou linha, etc.). Dependendo do mecanismo que está sendo usado, ele precisará ser escapado se for parte da cadeia real (não consigo pensar no topo da minha cabeça de um mecanismo de regex que não use a barra invertida como um escape para uma expressão pura) .

Note que Debian e Ubuntu removem algumas restrições para um nome de usuário compatível com o POSIX / shadow upstream (por exemplo, e eu não sei se isso foi corrigido, mas eles permitem que o nome de usuário comece com um número - que é o que causou este bug ). Se você quer garantir uma plataforma cruzada, eu recomendo o padrão regex acima, em vez do que passa / falha na verificação no Debian, Ubuntu e outros.