Criação de Senhas no Linux

Criação de Senhas no Linux

Métodos eficientes para criar senhas seguras no terminal Linux utilizando Bash. As técnicas abaixo combinam diferentes ferramentas para gerar senhas contendo letras, números e caracteres especiais.

1. Usando /dev/urandom com tr

Este método é simples e amplamente utilizado por sua segurança e facilidade.

head /dev/urandom | tr -dc 'A-Za-z0-9!@#$%^&*()' | head -c 20 ; echo

Ou, para incluir uma gama maior de caracteres especiais:

head /dev/urandom | tr -dc '[:alnum:][:punct:]' | head -c 20 ; echo

Explicação:

head /dev/urandom: Lê uma quantidade de dados aleatórios.
tr -dc 'A-Za-z0-9!@#$%^&\*()': Filtra os caracteres para incluir letras, números e alguns símbolos.
tr -dc '[:alnum:][:punct:]': Filtra caracteres alfanuméricos e de pontuação para mais variedade.
head -c 20: Define o comprimento da senha para 20 caracteres (pode ser ajustado).

2. Usando openssl

O openssl também pode ser usado para gerar senhas seguras com dados criptograficamente fortes.

openssl rand -base64 24 | tr -dc '[:alnum:][:punct:]' | head -c 20 ; echo

Explicação:

openssl rand -base64 24: Gera 24 bytes de dados aleatórios codificados em Base64.
tr -dc '[:alnum:][:punct:]': Filtra para incluir apenas caracteres alfanuméricos e de pontuação.
head -c 20: Define o comprimento da senha.

3. Combinando Data e Aleatoriedade

Você pode gerar senhas únicas usando a data e hora atuais em conjunto com dados aleatórios.

parte1=$(date +%s%N)  # Segundos e nanossegundos desde 1970
parte2=$(openssl rand -base64 10 | tr -dc '[:alnum:][:punct:]')
senha="${parte1:0:10}$parte2"
echo $senha

Explicação:

date +%s%N: Gera um valor com a hora atual em segundos e nanossegundos.
openssl rand -base64 10: Gera dados aleatórios adicionais.
tr -dc '[:alnum:][:punct:]': Filtra para incluir os caracteres desejados.
A senha final combina parte da data e dados aleatórios para garantir unicidade.

4. Misturando Palavras com shuf

Este método cria senhas embaralhando palavras ou caracteres.

palavras=('Casa' 'Carro' 'Livro' 'Árvore' 'Sol')
senha=$(printf "%s" "${palavras[@]}" | fold -w1 | shuf | tr -d '\n' | head -c 20 ; echo)
echo $senha

Explicação:

printf “%s” “${palavras[@]}“: Imprime todas as palavras sem espaços entre elas.
fold -w1: Dobra a string para que cada caractere apareça em uma nova linha.
shuf: Embaralha os caracteres.
head -c 20: Define o tamanho da senha para 20 caracteres.

5. Usando pwgen (pacote externo)

# Instalação: sudo apt-get install pwgen (Debian/Ubuntu)
pwgen -s 20 1  # Gera uma senha segura de 20 caracteres

6. Método com /dev/random

head -c 32 /dev/random | base64 | tr -dc '[:alnum:][:punct:]' | head -c 20

7. Método Python (se disponível)

python3 -c "import secrets, string; print(''.join(secrets.choice(string.ascii_letters + string.digits + '!@#$%^&*') for i in range(20)))"

Função Bash Avançada para Gerar Senhas

Função completa para o arquivo `~/.bash_functions` ou `~/.bashrc`:

# Função gerar_senha 
# ~/.bash_functions
# Versão: 2.0
 
gerar_senha() {
    # Definir cores para output
    local RED='\033[0;31m'
    local GREEN='\033[0;32m'
    local YELLOW='\033[1;33m'
    local BLUE='\033[0;34m'
    local CYAN='\033[0;36m'
    local NC='\033[0m' # No Color
 
    # Funções de log usando variáveis de cores
    _info() { echo -e "${BLUE}[INFO]${NC} $*"; }
    _warn() { echo -e "${YELLOW}[WARN]${NC} $*"; }
    _error() { echo -e "${RED}[ERRO]${NC} $*" >&2; }
    _success() { echo -e "${GREEN}[SUCESSO]${NC} $*"; }
 
    # Valores padrão
    local comprimento=20
    local usar_simbolos=true
    local quantidade=1
    local apenas_hex=false
    local metodo="random"
    local mostrar_senha=false
    local copiar_clipboard=false
    local arquivo_saida=""
 
    # Limites de segurança
    local COMPRIMENTO_MAX=256
    local QUANTIDADE_MAX=100
 
    # Função auxiliar para gerar conjunto de caracteres
    # Evita duplicação de código (melhoria de qualidade)
    _gerar_caracteres() {
        if [ "$apenas_hex" = true ]; then
            echo '0-9A-F'
        elif [ "$usar_simbolos" = true ]; then
            echo 'A-Za-z0-9!@#$%^&*()_+-=[]{}|;:,.<>?'
        else
            echo 'A-Za-z0-9'
        fi
    }
 
    # Função para limpeza de variáveis sensíveis
    # Melhoria crítica de segurança
    _limpar_variaveis_sensíveis() {
        unset senha senha_gerada caracteres
    }
 
    # Trap para garantir limpeza mesmo em caso de erro
    trap '_limpar_variaveis_sensíveis' RETURN
 
    # Mostrar ajuda
    mostrar_ajuda() {
        cat << EOF
Uso: gerar_senha [OPÇÕES]
 
Opções:
  -c, --comprimento N    Define o comprimento da senha (padrão: 20, máx: 256)
  -q, --quantidade N     Gera N senhas (padrão: 1, máx: 100)
  -s, --sem-simbolos     Gera senha apenas com letras e números
  -x, --hexadecimal      Gera senha hexadecimal (0-9, A-F)
  -m, --metodo METODO    Método de geração: random, mkpasswd, openssl, openssl-rand (padrão: random)
  -S, --mostrar-senha    Mostra a senha em claro quando usando mkpasswd ou openssl
  -C, --clipboard        Copia a última senha gerada para clipboard (requer xclip)
  -f, --arquivo ARQUIVO  Salva as senhas em arquivo (com permissões 600)
  -h, --help             Mostra esta ajuda
 
Exemplos:
  gerar_senha                            # Gera uma senha de 20 caracteres com símbolos
  gerar_senha -c 16 -q 3                 # Gera 3 senhas de 16 caracteres
  gerar_senha --sem-simbolos             # Gera senha apenas com letras e números
  gerar_senha --hexadecimal              # Gera senha hexadecimal
  gerar_senha --metodo mkpasswd          # Gera o hash de uma senha aleatória usando mkpasswd
  gerar_senha --metodo openssl -S        # Gera o hash e mostra a senha em claro
  gerar_senha -c 32 -C                   # Gera senha de 32 caracteres e copia para clipboard
  gerar_senha -q 5 -f senhas.txt         # Gera 5 senhas e salva em arquivo
 
Métodos disponíveis:
  random       - Geração aleatória pura (mais rápido, ideal para uso geral)
  mkpasswd     - Hash SHA-512 (ideal para /etc/shadow)
  openssl      - Hash SHA-512 via openssl (alternativa a mkpasswd)
  openssl-rand - Geração via openssl rand -base64 (compatível com base64)
EOF
    }
 
    # Processar argumentos
    while [[ $# -gt 0 ]]; do
        case $1 in
            -c|--comprimento)
                # Validação de argumento faltante (melhoria de robustez)
                if [ -z "$2" ]; then
                    _error "Opção $1 requer um valor"
                    return 1
                fi
                if [[ $2 =~ ^[0-9]+$ ]] && [ "$2" -gt 0 ]; then
                    comprimento="$2"
                    shift 2
                else
                    _error "Comprimento deve ser um número positivo"
                    return 1
                fi
                ;;
            -q|--quantidade)
                # Validação de argumento faltante (melhoria de robustez)
                if [ -z "$2" ]; then
                    _error "Opção $1 requer um valor"
                    return 1
                fi
                if [[ $2 =~ ^[0-9]+$ ]] && [ "$2" -gt 0 ]; then
                    quantidade="$2"
                    shift 2
                else
                    _error "Quantidade deve ser um número positivo"
                    return 1
                fi
                ;;
            -s|--sem-simbolos)
                usar_simbolos=false
                shift
                ;;
            -x|--hexadecimal)
                apenas_hex=true
                shift
                ;;
            -m|--metodo)
                # Validação de argumento faltante (melhoria de robustez)
                if [ -z "$2" ]; then
                    _error "Opção $1 requer um valor"
                    return 1
                fi
                case "$2" in
                    random|mkpasswd|openssl|openssl-rand)
                        metodo="$2"
                        shift 2
                        ;;
                    *)
                        _error "Método deve ser: random, mkpasswd, openssl ou openssl-rand"
                        return 1
                        ;;
                esac
                ;;
            -S|--mostrar-senha)
                mostrar_senha=true
                shift
                ;;
            -C|--clipboard)
                copiar_clipboard=true
                shift
                ;;
            -f|--arquivo)
                # Validação de argumento faltante (melhoria de robustez)
                if [ -z "$2" ]; then
                    _error "Opção $1 requer um valor"
                    return 1
                fi
                arquivo_saida="$2"
                shift 2
                ;;
            -h|--help)
                mostrar_ajuda
                return 0
                ;;
            *)
                _error "Opção desconhecida: $1"
                mostrar_ajuda
                return 1
                ;;
        esac
    done
 
    # Validação de limites de segurança (melhoria crítica)
    if [ "$comprimento" -gt "$COMPRIMENTO_MAX" ]; then
        _error "Comprimento máximo permitido: $COMPRIMENTO_MAX caracteres"
        return 1
    fi
 
    if [ "$quantidade" -gt "$QUANTIDADE_MAX" ]; then
        _error "Quantidade máxima permitida: $QUANTIDADE_MAX senhas"
        return 1
    fi
 
    # Verificar dependências para os métodos
    if [ "$metodo" = "mkpasswd" ] && ! command -v mkpasswd >/dev/null 2>&1; then
        _error "O comando 'mkpasswd' não está instalado. Instale com: sudo apt install whois"
        return 1
    fi
 
    if [[ "$metodo" = "openssl" || "$metodo" = "openssl-rand" ]] && ! command -v openssl >/dev/null 2>&1; then
        _error "O comando 'openssl' não está instalado."
        return 1
    fi
 
    # Verificar dependência para clipboard
    if [ "$copiar_clipboard" = true ] && ! command -v xclip >/dev/null 2>&1; then
        _warn "O comando 'xclip' não está instalado. Clipboard será desativado."
        copiar_clipboard=false
    fi
 
    # Validar arquivo de saída
    if [ -n "$arquivo_saida" ]; then
        if ! touch "$arquivo_saida" 2>/dev/null; then
            _error "Não foi possível criar/acessar o arquivo: $arquivo_saida"
            return 1
        fi
        chmod 600 "$arquivo_saida"
    fi
 
    # Mensagem informativa sobre o método
    case "$metodo" in
        random) _info "Gerando senha com método aleatório..." ;;
        mkpasswd) _info "Gerando hash com mkpasswd (SHA-512)..." ;;
        openssl) _info "Gerando hash com openssl (SHA-512)..." ;;
        openssl-rand) _info "Gerando senha com openssl rand..." ;;
    esac
 
    # Gerar senhas
    local ultima_senha=""
    for ((i=1; i<=quantidade; i++)); do
        if [ "$quantidade" -gt 1 ]; then
            echo -e "${CYAN}--- Senha $i ---${NC}"
        fi
 
        # Gerar a senha baseada no método selecionado
        local senha
        local senha_gerada
        case "$metodo" in
            random)
                # Otimização de performance: limitar leitura de /dev/urandom (melhoria de performance)
                local caracteres
                caracteres=$(_gerar_caracteres)
 
                if ! senha=$(head -c 1024 /dev/urandom | tr -dc "$caracteres" | head -c "$comprimento"); then
                    _error "Falha ao gerar senha"
                    return 1
                fi
                ;;
            openssl-rand)
                # Gera exatamente o comprimento solicitado
                local bytes_necessarios=$((comprimento * 3 / 4 + 1))
                if ! senha=$(openssl rand -base64 "$bytes_necessarios" 2>/dev/null | tr -d '\n/+=' | head -c "$comprimento"); then
                    _error "Falha ao gerar senha com openssl rand"
                    return 1
                fi
                ;;
            mkpasswd|openssl)
                # Para métodos de hash, primeiro gerar uma senha aleatória
                local caracteres
                caracteres=$(_gerar_caracteres)
 
                if ! senha_gerada=$(head -c 1024 /dev/urandom | tr -dc "$caracteres" | head -c "$comprimento"); then
                    _error "Falha ao gerar senha"
                    return 1
                fi
 
                if [ -z "$senha_gerada" ]; then
                    _error "Falha ao gerar senha"
                    return 1
                fi
 
                case "$metodo" in
                    mkpasswd)
                        if ! senha=$(mkpasswd -m SHA-512 "$senha_gerada" 2>/dev/null); then
                            _error "Falha ao gerar hash com mkpasswd"
                            return 1
                        fi
                        ;;
                    openssl)
                        if ! senha=$(openssl passwd -6 "$senha_gerada" 2>/dev/null); then
                            _error "Falha ao gerar hash com openssl"
                            return 1
                        fi
                        ;;
                esac
 
                # Mostrar senha em claro se solicitado
                if [ "$mostrar_senha" = true ]; then
                    echo -e "${GREEN}Senha: ${senha_gerada}${NC}"
                fi
                ;;
        esac
 
        if [ -z "$senha" ]; then
            _error "Falha ao gerar senha"
            return 1
        fi
 
        # Exibir resultado
        echo -e "${GREEN}${senha}${NC}"
 
        # Salvar em arquivo se solicitado
        if [ -n "$arquivo_saida" ]; then
            echo "$senha" >> "$arquivo_saida"
        fi
 
        # Guardar última senha para clipboard
        ultima_senha="$senha"
 
        # Espaço entre múltiplas senhas
        if [ "$quantidade" -gt 1 ] && [ "$i" -lt "$quantidade" ]; then
            echo
        fi
    done
 
    # Copiar para clipboard se solicitado (melhoria de funcionalidade)
    if [ "$copiar_clipboard" = true ] && [ -n "$ultima_senha" ]; then
        if echo -n "$ultima_senha" | xclip -selection clipboard 2>/dev/null; then
            _success "Última senha copiada para clipboard"
        else
            _warn "Falha ao copiar para clipboard"
        fi
    fi
 
    # Informações finais
    if [ -n "$arquivo_saida" ]; then
        _success "Senhas salvas em: $arquivo_saida (permissões: 600)"
    fi
 
    # Dicas de segurança
    if [ "$comprimento" -lt 12 ]; then
        _warn "Recomendação: Use senhas com pelo menos 12 caracteres para melhor segurança"
    fi
 
    # Informação adicional para métodos de hash
    if [[ "$metodo" == "mkpasswd" || "$metodo" == "openssl" ]]; then
        _info "Use este hash em arquivos de configuração como /etc/shadow"
    fi
 
    # Limpeza de variáveis sensíveis (melhoria crítica de segurança)
    # Nota: O trap já cuidará disso, mas fazemos explicitamente também
    _limpar_variaveis_sensíveis
}
 
# Exportar função se for sourced
export -f gerar_senha

Como usar a função:

1. Adicionar ao seu ambiente:

``` # Adicione a função ao ~/.bashrc ou ~/.bash_functions echo “source ~/.bash_functions” » ~/.bashrc ```

2. Exemplos de uso:

``` gerar_senha # Senha padrão (20 chars com símbolos) gerar_senha -c 16 -q 3 # 3 senhas de 16 caracteres gerar_senha –sem-simbolos -c 32 # Senha de 32 chars sem símbolos gerar_senha –metodo mkpasswd # Hash SHA-512 para /etc/shadow ```

Considerações Finais

Esses métodos cobrem uma ampla gama de abordagens para gerar senhas seguras diretamente no terminal Linux, usando ferramentas padrão como Bash. Escolha o método que melhor se adapta à sua necessidade de segurança e ajuste conforme necessário:

Segurança: Para sistemas críticos, prefira fontes de entropia mais fortes como `/dev/random`.
Tamanho da Senha: Ajuste o comprimento da senha conforme necessário, idealmente com 20 caracteres ou mais.
Personalização: Modifique a lista de caracteres especiais ou a seleção de palavras para atender aos seus requisitos de segurança.
Função Bash: A função avançada oferece flexibilidade máxima com opções para diferentes casos de uso.

Table of Contents

Criação de Senhas no Linux

1. Usando /dev/urandom com tr

2. Usando openssl

3. Combinando Data e Aleatoriedade

4. Misturando Palavras com shuf

5. Usando pwgen (pacote externo)

6. Método com /dev/random

7. Método Python (se disponível)

Função Bash Avançada para Gerar Senhas

Considerações Finais