Base de Conhecimento

User Tools

Site Tools

Trace: • make_password_bash
wiki:linux:bash:make_password_bash

This is an old revision of the document!

Table of Contents

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 - Função gerar_senha final
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
 
    # Mostrar ajuda
    mostrar_ajuda() {
        cat << EOF
Uso: gerar_senha [OPÇÕES]
 
Opções:
  -c, --comprimento N    Define o comprimento da senha (padrão: 20)
  -q, --quantidade N     Gera N senhas (padrão: 1)
  -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
  -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 --metodo openssl-rand      # Gera senha usando openssl rand -base64
EOF
    }
 
    # Processar argumentos
    while [[ $# -gt 0 ]]; do
        case $1 in
            -c|--comprimento)
                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)
                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)
                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
                ;;
            -h|--help)
                mostrar_ajuda
                return 0
                ;;
            *)
                _error "Opção desconhecida: $1"
                mostrar_ajuda
                return 1
                ;;
        esac
    done
 
    # 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
 
    # 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
    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)
                # Definir conjunto de caracteres base
                local caracteres
                if [ "$apenas_hex" = true ]; then
                    caracteres='0-9A-F'
                elif [ "$usar_simbolos" = true ]; then
                    caracteres='A-Za-z0-9!@#$%^&*()_+-=[]{}|;:,.<>?'
                else
                    caracteres='A-Za-z0-9'
                fi
 
                senha=$(head /dev/urandom | tr -dc "$caracteres" | head -c "$comprimento" ; echo)
                ;;
            openssl-rand)
                # Gera exatamente o comprimento solicitado
                local bytes_necessarios=$((comprimento * 3 / 4 + 1))
                senha=$(openssl rand -base64 "$bytes_necessarios" | tr -d '\n/+=' | head -c "$comprimento" ; echo)
                ;;
            mkpasswd|openssl)
                # Para métodos de hash, primeiro gerar uma senha aleatória
                local caracteres
                if [ "$apenas_hex" = true ]; then
                    caracteres='0-9A-F'
                elif [ "$usar_simbolos" = true ]; then
                    caracteres='A-Za-z0-9!@#$%^&*()_+-=[]{}|;:,.<>?'
                else
                    caracteres='A-Za-z0-9'
                fi
 
                senha_gerada=$(head /dev/urandom | tr -dc "$caracteres" | head -c "$comprimento" ; echo)
 
                if [ -z "$senha_gerada" ]; then
                    _error "Falha ao gerar senha"
                    return 1
                fi
 
                case "$metodo" in
                    mkpasswd)
                        senha=$(mkpasswd -m SHA-512 "$senha_gerada" 2>/dev/null)
                        if [ $? -ne 0 ]; then
                            _error "Falha ao gerar hash com mkpasswd"
                            return 1
                        fi
                        ;;
                    openssl)
                        senha=$(openssl passwd -6 "$senha_gerada" 2>/dev/null)
                        if [ $? -ne 0 ]; 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}"
 
        # Espaço entre múltiplas senhas
        if [ "$quantidade" -gt 1 ] && [ "$i" -lt "$quantidade" ]; then
            echo
        fi
    done
 
    # 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
}

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.
wiki/linux/bash/make_password_bash.1768922381.txt.gz · Last modified: by Wiki Administrator