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.

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

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.

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.

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.

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

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

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

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 ```

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.