Como gero uma senha aleatoria no PowerShell?

Use a classe System.Web.Security.Membership: Add-Type -AssemblyName System.Web; [System.Web.Security.Membership]::GeneratePassword(16, 4). O primeiro argumento e o comprimento total, o segundo e o numero minimo de caracteres especiais. Para uma abordagem totalmente personalizada, voce pode construir senhas a partir de conjuntos de caracteres usando Get-Random.

O que torna uma senha criptograficamente segura?

Uma senha criptograficamente segura deve ser gerada usando um gerador de numeros aleatorios criptograficamente seguro (CSPRNG), como o RandomNumberGenerator do .NET ou o /dev/urandom do Linux. Geradores pseudoaleatorios padrao como System.Random sao previsiveis e nunca devem ser usados para geracao de senhas. A senha tambem deve ser longa o suficiente (mais de 14 caracteres) e incluir uma combinacao de tipos de caracteres.

Como as senhas geradas devem ser armazenadas com seguranca?

Nunca armazene senhas em texto simples. Use um algoritmo de hash unidirecional com um salt unico por senha. Os algoritmos modernos recomendados sao bcrypt, scrypt ou Argon2. Para segredos de aplicativos e chaves de API, use um gerenciador de segredos como Azure Key Vault, AWS Secrets Manager ou HashiCorp Vault em vez de armazena-los em arquivos de configuracao ou codigo-fonte.

Como gerar senhas aleatorias | Knowledge eXchange

Criar senhas fortes e aleatorias e um desafio que todo administrador e desenvolvedor enfrenta regularmente — seja configurando contas de servico, provisionando credenciais de usuario ou gerando chaves de API. Este guia abrange varios metodos para gerar senhas aleatorias seguras em diferentes plataformas, junto com melhores praticas para complexidade e armazenamento de senhas.

Requisitos de complexidade de senhas

Antes de gerar senhas, entenda o que torna uma senha forte:

Comprimento — Minimo de 14 caracteres para contas administrativas, 12 para usuarios padrao
Variedade de caracteres — Inclua letras maiusculas, letras minusculas, digitos e caracteres especiais
Aleatoriedade — Use um gerador de numeros aleatorios criptograficamente seguro, nao um padrao previsivel
Unicidade — Cada conta deve ter uma senha diferente

A maioria dos frameworks de conformidade (NIST, PCI-DSS, HIPAA) exige que as senhas atendam a regras especificas de complexidade. O NIST SP 800-63B recomenda focar no comprimento da senha em vez de requisitos de complexidade, mas muitos sistemas ainda exigem tipos mistos de caracteres.

Metodos PowerShell

Usando a classe Membership

O metodo mais simples no PowerShell usa a classe System.Web.Security.Membership:

# Load the System.Web assembly
Add-Type -AssemblyName System.Web

# Generate a single password (16 characters, minimum 4 special characters)
[System.Web.Security.Membership]::GeneratePassword(16, 4)

# Generate multiple passwords
1..10 | ForEach-Object {
    [System.Web.Security.Membership]::GeneratePassword(20, 5)
}

O primeiro parametro e o comprimento total e o segundo e o numero minimo de caracteres nao alfanumericos.

Gerador de senhas personalizado no PowerShell

Para mais controle sobre conjuntos de caracteres e formatacao:

function New-RandomPassword {
    param(
        [int]$Length = 16,
        [int]$MinUpperCase = 2,
        [int]$MinLowerCase = 2,
        [int]$MinDigits = 2,
        [int]$MinSpecial = 2
    )

    $upper   = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    $lower   = 'abcdefghijklmnopqrstuvwxyz'
    $digits  = '0123456789'
    $special = '!@#$%^&*()-_=+[]{}|;:,.<>?'

    $password = @()

    # Ensure minimum requirements
    $password += ($upper.ToCharArray()   | Get-Random -Count $MinUpperCase)
    $password += ($lower.ToCharArray()   | Get-Random -Count $MinLowerCase)
    $password += ($digits.ToCharArray()  | Get-Random -Count $MinDigits)
    $password += ($special.ToCharArray() | Get-Random -Count $MinSpecial)

    # Fill remaining length with random characters from all sets
    $allChars = $upper + $lower + $digits + $special
    $remaining = $Length - $password.Count
    if ($remaining -gt 0) {
        $password += ($allChars.ToCharArray() | Get-Random -Count $remaining)
    }

    # Shuffle the result
    $password = $password | Get-Random -Count $password.Count

    return -join $password
}

# Generate a single password
New-RandomPassword -Length 20

# Generate a batch of passwords
1..25 | ForEach-Object { New-RandomPassword -Length 16 }

Metodo criptograficamente seguro no PowerShell

Para a maior seguranca, use System.Security.Cryptography.RandomNumberGenerator:

function New-SecurePassword {
    param([int]$Length = 20)

    $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*'
    $bytes = New-Object byte[] $Length
    $rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
    $rng.GetBytes($bytes)

    $password = New-Object char[] $Length
    for ($i = 0; $i -lt $Length; $i++) {
        $password[$i] = $charSet[$bytes[$i] % $charSet.Length]
    }

    return -join $password
}

New-SecurePassword -Length 24

Geracao de senhas criptograficas no .NET

Usando RandomNumberGenerator (Recomendado)

No .NET, RandomNumberGenerator (que substituiu o antigo RNGCryptoServiceProvider) e a maneira correta de gerar dados aleatorios criptograficamente seguros:

using System.Security.Cryptography;

public static string GeneratePassword(int length = 20)
{
    const string chars =
        "abcdefghijklmnopqrstuvwxyz" +
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
        "0123456789" +
        "!@#$%^&*()-_=+[]{}|;:,.<>?";

    var password = new char[length];
    var randomBytes = new byte[length];

    using (var rng = RandomNumberGenerator.Create())
    {
        rng.GetBytes(randomBytes);
    }

    for (int i = 0; i < length; i++)
    {
        password[i] = chars[randomBytes[i] % chars.Length];
    }

    return new string(password);
}

Por que nao usar System.Random?

Nunca use System.Random para geracao de senhas:

// DO NOT use this for passwords -- it is predictable!
var random = new Random();
// An attacker who knows the seed can predict every output

System.Random usa um gerador de numeros pseudoaleatorios deterministico. Se um atacante puder adivinhar ou determinar a semente (por exemplo, a hora do sistema na inicializacao), ele pode reproduzir toda a sequencia. RandomNumberGenerator usa a fonte criptografica aleatoria do sistema operacional, que e adequada para operacoes sensiveis a seguranca.

Metodos de linha de comando do Linux

Usando openssl

# Generate a 24-character random password (base64 encoded)
openssl rand -base64 24

# Generate a hex-encoded password
openssl rand -hex 16

Usando pwgen

O utilitario pwgen gera senhas pronunciaveis (ou totalmente aleatorias):

# Install pwgen
sudo apt install pwgen    # Debian/Ubuntu
sudo yum install pwgen    # RHEL/CentOS

# Generate one 16-character secure password
pwgen -s 16 1

# Generate 20 passwords of 20 characters each, fully random
pwgen -s -y 20 20

# Options:
#   -s  Fully random (not pronounceable)
#   -y  Include special characters
#   -c  Include at least one capital letter (default)
#   -n  Include at least one number (default)

Usando /dev/urandom

# Generate a 20-character alphanumeric password
< /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*' | head -c 20; echo

# Generate multiple passwords
for i in $(seq 1 10); do
    < /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*()-_=+' | head -c 20
    echo
done

Usando Python

# One-liner for a 20-character password
python3 -c "import secrets, string; print(''.join(secrets.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(20)))"

O modulo secrets no Python 3.6+ e projetado especificamente para gerar tokens e senhas criptograficamente seguros.

Geracao de senhas em massa para provisionamento de usuarios

Ao provisionar varias contas, voce pode combinar a geracao de senhas com saida CSV:

PowerShell: Gerar senhas para uma lista de usuarios

# Read a list of usernames and generate passwords
$users = Import-Csv -Path "C:\users.csv"

$results = foreach ($user in $users) {
    [PSCustomObject]@{
        Username = $user.Username
        Password = [System.Web.Security.Membership]::GeneratePassword(16, 4)
    }
}

$results | Export-Csv -Path "C:\user-passwords.csv" -NoTypeInformation

Bash: Gerar senhas a partir de uma lista de usuarios

#!/bin/bash
while IFS= read -r username; do
    password=$(< /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*' | head -c 16)
    echo "$username,$password"
done < users.txt > user-passwords.csv

Praticas de armazenamento seguro de senhas

Gerar senhas fortes e apenas metade da batalha. Armazena-las com seguranca e igualmente importante.

Para autenticacao de usuarios (Hashing)

Nunca armazene senhas de usuarios em texto simples. Use um algoritmo de hash unidirecional com um salt unico:

bcrypt — O algoritmo mais amplamente recomendado para hashing de senhas. Inclui salting integrado e um fator de trabalho configuravel.
scrypt — Algoritmo intensivo em memoria que resiste a ataques baseados em GPU.
Argon2 — Vencedor da Password Hashing Competition. Oferece a melhor resistencia contra ataques modernos.

Evite MD5 e SHA-1/SHA-256 para hashing de senhas — eles sao rapidos demais, o que torna ataques de forca bruta viaveis.

Para segredos de aplicativos (Gerenciamento de segredos)

Para senhas usadas por aplicativos (credenciais de banco de dados, chaves de API, senhas de contas de servico):

Azure Key Vault — Armazenamento gerenciado de segredos para ambientes Azure
AWS Secrets Manager — Armazenamento gerenciado de segredos com suporte a rotacao automatica
HashiCorp Vault — Gerenciamento de segredos de codigo aberto para qualquer ambiente
Variaveis de ambiente — Aceitavel para desenvolvimento, mas use um gerenciador de segredos em producao

Nunca armazene segredos em:

Repositorios de codigo-fonte
Arquivos de configuracao versionados no controle de versao
Arquivos de texto nao criptografados em servidores
Documentos ou wikis compartilhados

Gerenciador de senhas para uso pessoal

Para gerenciar senhas individuais, use um gerenciador de senhas:

Bitwarden — Codigo aberto, multiplataforma
1Password — Rico em recursos, com planos para equipes e familias
KeePass — Offline, codigo aberto

Resumo

Gerar senhas aleatorias seguras requer o uso de geradores de numeros aleatorios criptograficamente seguros — seja atraves da classe Membership do PowerShell, do RandomNumberGenerator do .NET ou de ferramentas Linux como openssl e pwgen. Evite fontes previsiveis como System.Random ou simples digitacao aleatoria no teclado. Para provisionamento em massa, automatize o processo de geracao e exporte para um formato seguro. Sempre armazene senhas usando algoritmos de hashing adequados para autenticacao ou um gerenciador de segredos para credenciais de aplicativos.