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

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

Ou, para incluir uma gama maior de caracteres especiais:

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

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

<code bash>
openssl rand -base64 24 | tr -dc '[:alnum:][:punct:]' | head -c 20 ; echo
</code>

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

<code bash>
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
</code>

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

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

**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) =====

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

===== 6. Método com /dev/random =====

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

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

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

===== Função Bash Avançada para Gerar Senhas =====

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

<code bash>
# 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
</code>

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