Como genero una contrasena aleatoria en PowerShell?

Usa la clase System.Web.Security.Membership: Add-Type -AssemblyName System.Web; [System.Web.Security.Membership]::GeneratePassword(16, 4). El primer argumento es la longitud total, el segundo es el numero minimo de caracteres especiales. Para un enfoque completamente personalizado, puedes construir contrasenas a partir de conjuntos de caracteres usando Get-Random.

Que hace que una contrasena sea criptograficamente segura?

Una contrasena criptograficamente segura debe generarse utilizando un generador de numeros aleatorios criptograficamente seguro (CSPRNG) como RandomNumberGenerator de .NET o /dev/urandom de Linux. Los generadores pseudoaleatorios estandar como System.Random son predecibles y nunca deben usarse para la generacion de contrasenas. La contrasena tambien debe ser lo suficientemente larga (mas de 14 caracteres) e incluir una combinacion de tipos de caracteres.

Como deben almacenarse las contrasenas generadas de forma segura?

Nunca almacenes contrasenas en texto plano. Usa un algoritmo de hash unidireccional con un salt unico por contrasena. Los algoritmos modernos recomendados son bcrypt, scrypt o Argon2. Para secretos de aplicaciones y claves API, usa un administrador de secretos como Azure Key Vault, AWS Secrets Manager o HashiCorp Vault en lugar de almacenarlos en archivos de configuracion o codigo fuente.

Como generar contrasenas aleatorias

Crear contrasenas fuertes y aleatorias es un desafio que todo administrador y desarrollador enfrenta regularmente, ya sea configurando cuentas de servicio, aprovisionando credenciales de usuario o generando claves API. Esta guia cubre multiples metodos para generar contrasenas aleatorias seguras en diferentes plataformas, junto con mejores practicas para la complejidad y el almacenamiento de contrasenas.

Requisitos de complejidad de contrasenas

Antes de generar contrasenas, es importante entender que hace que una contrasena sea fuerte:

Longitud — Minimo 14 caracteres para cuentas administrativas, 12 para usuarios estandar
Variedad de caracteres — Incluir letras mayusculas, letras minusculas, digitos y caracteres especiales
Aleatoriedad — Usar un generador de numeros aleatorios criptograficamente seguro, no un patron predecible
Unicidad — Cada cuenta debe tener una contrasena diferente

La mayoria de los marcos de cumplimiento (NIST, PCI-DSS, HIPAA) requieren que las contrasenas cumplan reglas de complejidad especificas. NIST SP 800-63B recomienda enfocarse en la longitud de la contrasena sobre los requisitos de complejidad, pero muchos sistemas aun exigen tipos de caracteres mixtos.

Metodos en PowerShell

Usando la clase Membership

El metodo mas simple en PowerShell usa la clase 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)
}

El primer parametro es la longitud total y el segundo es el numero minimo de caracteres no alfanumericos.

Generador de contrasenas personalizado en PowerShell

Para mayor control sobre los conjuntos de caracteres y el formato:

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 en PowerShell

Para la maxima seguridad, usa 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

Generacion de contrasenas criptograficas en .NET

Usando RandomNumberGenerator (Recomendado)

En .NET, RandomNumberGenerator (que reemplazo al antiguo RNGCryptoServiceProvider) es la forma correcta de generar datos 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 no usar System.Random?

Nunca uses System.Random para la generacion de contrasenas:

// 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 un generador de numeros pseudoaleatorios deterministico. Si un atacante puede adivinar o determinar la semilla (por ejemplo, la hora del sistema en la inicializacion), puede reproducir toda la secuencia. RandomNumberGenerator usa la fuente criptografica aleatoria del sistema operativo, que es adecuada para operaciones sensibles a la seguridad.

Metodos de linea de comandos en 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

La utilidad pwgen genera contrasenas pronunciables (o completamente 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)))"

El modulo secrets en Python 3.6+ esta disenado especificamente para generar tokens y contrasenas criptograficamente seguros.

Generacion masiva de contrasenas para aprovisionamiento de usuarios

Al aprovisionar multiples cuentas, puedes combinar la generacion de contrasenas con la salida CSV:

PowerShell: Generar contrasenas para una 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: Generar contrasenas desde una 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

Practicas de almacenamiento seguro de contrasenas

Generar contrasenas fuertes es solo la mitad de la batalla. Almacenarlas de forma segura es igualmente importante.

Para autenticacion de usuarios (Hashing)

Nunca almacenes contrasenas de usuario en texto plano. Usa un algoritmo de hash unidireccional con un salt unico:

bcrypt — El algoritmo mas ampliamente recomendado para el hash de contrasenas. Incluye salting integrado y un factor de trabajo configurable.
scrypt — Algoritmo con uso intensivo de memoria que resiste ataques basados en GPU.
Argon2 — Ganador de la Competencia de Hash de Contrasenas. Ofrece la mejor resistencia a ataques modernos.

Evita MD5 y SHA-1/SHA-256 para el hash de contrasenas — son demasiado rapidos, lo que hace que los ataques de fuerza bruta sean factibles.

Para secretos de aplicaciones (Gestion de secretos)

Para contrasenas utilizadas por aplicaciones (credenciales de base de datos, claves API, contrasenas de cuentas de servicio):

Azure Key Vault — Almacen de secretos administrado para entornos Azure
AWS Secrets Manager — Almacen de secretos administrado con soporte de rotacion automatica
HashiCorp Vault — Gestion de secretos de codigo abierto para cualquier entorno
Variables de entorno — Aceptable para desarrollo, pero usa un administrador de secretos en produccion

Nunca almacenes secretos en:

Repositorios de codigo fuente
Archivos de configuracion registrados en control de versiones
Archivos de texto sin cifrar en servidores
Documentos compartidos o wikis

Administrador de contrasenas para uso personal

Para gestionar contrasenas individuales, usa un administrador de contrasenas:

Bitwarden — Codigo abierto, multiplataforma
1Password — Rico en funciones, con planes para equipos y familias
KeePass — Sin conexion, codigo abierto

Resumen

Generar contrasenas aleatorias seguras requiere el uso de generadores de numeros aleatorios criptograficamente seguros, ya sea a traves de la clase Membership de PowerShell, RandomNumberGenerator de .NET o herramientas de Linux como openssl y pwgen. Evita fuentes predecibles como System.Random o patrones simples de teclado. Para el aprovisionamiento masivo, automatiza el proceso de generacion y exporta a un formato seguro. Siempre almacena contrasenas utilizando algoritmos de hash adecuados para autenticacion o un administrador de secretos para credenciales de aplicaciones.