Insecure Random Number Generation for Cryptographic Use

// JavaScript - SECURE: Using crypto.getRandomValues()
class SecureTokenGenerator {
    generateSessionId() {
        // Use crypto.getRandomValues() for cryptographic randomness
        const array = new Uint8Array(16);
        crypto.getRandomValues(array);
        
        // Convert to hex string
        return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
    }
    
    generateApiKey(length = 32) {
        const array = new Uint8Array(length);
        crypto.getRandomValues(array);
        
        // Convert to base64url for API key format
        return btoa(String.fromCharCode(...array))
            .replace(/\+/g, '-')
            .replace(/\//g, '_')
            .replace(/=/g, '');
    }
    
    generateCsrfToken() {
        // Strong CSRF token
        const array = new Uint8Array(32);
        crypto.getRandomValues(array);
        return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
    }
    
    generateNonce(length = 12) {
        // Cryptographically secure nonce for AES-GCM
        const nonce = new Uint8Array(length);
        crypto.getRandomValues(nonce);
        return nonce;
    }
    
    generateSecurePassword(length = 16) {
        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
        const array = new Uint8Array(length);
        crypto.getRandomValues(array);
        
        return Array.from(array, byte => charset[byte % charset.length]).join('');
    }
}

# Python - SECURE: Using os.urandom() and secrets module
import secrets
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
import base64

class SecureRandomGenerator:
    def __init__(self):
        # No seeding required - let OS handle entropy
        pass
    
    def generate_password_reset_token(self):
        # Use secrets module for cryptographic randomness
        return secrets.token_urlsafe(32)  # 256 bits of entropy
    
    def generate_encryption_iv(self, algorithm='AES'):
        if algorithm == 'AES':
            # 128-bit IV for AES
            return os.urandom(16)
        elif algorithm == 'ChaCha20':
            # 96-bit nonce for ChaCha20
            return os.urandom(12)
        else:
            raise ValueError(f"Unknown algorithm: {algorithm}")
    
    def generate_encryption_key(self, key_size=256):
        # Generate cryptographically secure key
        key_bytes = key_size // 8
        return os.urandom(key_bytes)
    
    def generate_session_key(self):
        # Strong session key generation
        return secrets.token_bytes(32)  # 256-bit session key
    
    def generate_otp(self, digits=6):
        # Secure OTP generation
        max_value = 10 ** digits
        # Use rejection sampling to avoid modulo bias
        while True:
            value = secrets.randbits(32)
            if value < max_value:
                return str(value).zfill(digits)
    
    def generate_salt(self, length=32):
        # Random salt for password hashing
        return os.urandom(length)
    
    def generate_csrf_token(self):
        # CSRF token with timestamp and random component
        random_part = secrets.token_bytes(24)
        return base64.urlsafe_b64encode(random_part).decode('ascii').rstrip('=')
    
    def generate_api_key(self):
        # Secure API key generation
        prefix = 'sk_'  # API key prefix
        random_part = secrets.token_urlsafe(40)  # ~320 bits
        return prefix + random_part
    
    def generate_jwt_secret(self):
        # JWT signing secret (should be stored securely)
        return secrets.token_bytes(64)  # 512-bit secret

// C# - SECURE: Using RNGCryptoServiceProvider and RandomNumberGenerator
using System;
using System.Security.Cryptography;
using System.Text;

public class SecureRandomCrypto
{
    private readonly RandomNumberGenerator rng;
    
    public SecureRandomCrypto()
    {
        // Use cryptographically secure RNG
        rng = RandomNumberGenerator.Create();
    }
    
    public string GenerateJwtSecret()
    {
        // Generate 512-bit JWT secret
        byte[] secretBytes = new byte[64];
        rng.GetBytes(secretBytes);
        return Convert.ToBase64String(secretBytes);
    }
    
    public byte[] GenerateEncryptionKey(int keySize)
    {
        // Generate secure encryption key
        byte[] key = new byte[keySize / 8];
        rng.GetBytes(key);
        return key;
    }
    
    public string GeneratePasswordSalt()
    {
        // Generate 256-bit salt
        byte[] saltBytes = new byte[32];
        rng.GetBytes(saltBytes);
        return Convert.ToBase64String(saltBytes);
    }
    
    public string GenerateTwoFactorCode()
    {
        // Secure 6-digit 2FA code generation
        byte[] randomBytes = new byte[4];
        rng.GetBytes(randomBytes);
        
        // Convert to int and use modulo with proper bias handling
        uint randomInt = BitConverter.ToUInt32(randomBytes, 0);
        int code = (int)(randomInt % 1000000);
        
        return code.ToString("D6");
    }
    
    public byte[] GenerateNonce(int length)
    {
        // Generate cryptographic nonce
        byte[] nonce = new byte[length];
        rng.GetBytes(nonce);
        return nonce;
    }
    
    public string GenerateSessionId()
    {
        // Generate 256-bit session ID
        byte[] sessionBytes = new byte[32];
        rng.GetBytes(sessionBytes);
        
        // Convert to hex string
        StringBuilder sb = new StringBuilder();
        foreach (byte b in sessionBytes)
        {
            sb.Append(b.ToString("x2"));
        }
        
        return sb.ToString();
    }
    
    public string GenerateApiToken()
    {
        // Generate secure API token
        byte[] tokenBytes = new byte[40]; // 320 bits
        rng.GetBytes(tokenBytes);
        
        return Convert.ToBase64String(tokenBytes)
            .Replace('+', '-')
            .Replace('/', '_')
            .TrimEnd('=');
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            rng?.Dispose();
        }
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

// Java - SECURE: Comprehensive secure random implementation
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.nio.ByteBuffer;
import java.time.Instant;

public class EnterpriseSecureRandom {
    private final SecureRandom secureRandom;
    private final String algorithm;
    
    public EnterpriseSecureRandom() throws NoSuchAlgorithmException {
        // Use strongest available algorithm
        try {
            // Try to use NativePRNG on Unix systems
            secureRandom = SecureRandom.getInstance("NativePRNG");
            algorithm = "NativePRNG";
        } catch (NoSuchAlgorithmException e) {
            try {
                // Fallback to SHA1PRNG
                secureRandom = SecureRandom.getInstance("SHA1PRNG");
                algorithm = "SHA1PRNG";
            } catch (NoSuchAlgorithmException e2) {
                // Use default implementation
                secureRandom = new SecureRandom();
                algorithm = "Default";
            }
        }
        
        // Let SecureRandom self-seed - NEVER manually seed!
        // secureRandom.setSeed() should NEVER be called
    }
    
    public byte[] generateSecureKey(int keySize) throws SecurityException {
        if (keySize <= 0 || keySize % 8 != 0) {
            throw new IllegalArgumentException("Key size must be positive and divisible by 8");
        }
        
        byte[] key = new byte[keySize / 8];
        
        try {
            secureRandom.nextBytes(key);
            
            // Verify we got non-zero bytes (extremely rare but possible)
            if (isAllZeros(key)) {
                throw new SecurityException("Generated all-zero key - entropy may be exhausted");
            }
            
            return key;
        } catch (Exception e) {
            throw new SecurityException("Failed to generate secure key: " + e.getMessage(), e);
        }
    }
    
    public String generateSessionId() throws SecurityException {
        byte[] sessionBytes = generateSecureKey(256); // 32 bytes
        
        // Use URL-safe base64 encoding
        return Base64.getUrlEncoder().withoutPadding().encodeToString(sessionBytes);
    }
    
    public byte[] generateNonce(int length) throws SecurityException {
        if (length <= 0) {
            throw new IllegalArgumentException("Nonce length must be positive");
        }
        
        byte[] nonce = new byte[length];
        secureRandom.nextBytes(nonce);
        
        return nonce;
    }
    
    public String generateApiToken(String prefix) throws SecurityException {
        if (prefix == null) {
            prefix = "sk_";
        }
        
        // Generate 40 bytes (320 bits) of randomness
        byte[] tokenBytes = generateSecureKey(320);
        String randomPart = Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);
        
        return prefix + randomPart;
    }
    
    public int generateSecureOTP(int digits) throws SecurityException {
        if (digits < 4 || digits > 10) {
            throw new IllegalArgumentException("OTP digits must be between 4 and 10");
        }
        
        int maxValue = (int) Math.pow(10, digits);
        
        // Use rejection sampling to avoid modulo bias
        int attempts = 0;
        while (attempts < 100) { // Prevent infinite loops
            int randomInt = secureRandom.nextInt();
            
            // Ensure positive value
            randomInt = Math.abs(randomInt);
            
            if (randomInt < maxValue) {
                return randomInt;
            }
            attempts++;
        }
        
        throw new SecurityException("Failed to generate OTP after 100 attempts");
    }
    
    public void testRandomness() {
        // Basic randomness test - check for obvious patterns
        byte[] test1 = new byte[32];
        byte[] test2 = new byte[32];
        
        secureRandom.nextBytes(test1);
        secureRandom.nextBytes(test2);
        
        if (java.util.Arrays.equals(test1, test2)) {
            throw new SecurityException("Random number generator produced identical sequences");
        }
        
        if (isAllZeros(test1) || isAllZeros(test2)) {
            throw new SecurityException("Random number generator produced all-zero sequence");
        }
    }
    
    private boolean isAllZeros(byte[] array) {
        for (byte b : array) {
            if (b != 0) {
                return false;
            }
        }
        return true;
    }
    
    public String getAlgorithmInfo() {
        return String.format("Algorithm: %s, Provider: %s", 
                           algorithm, 
                           secureRandom.getProvider().getName());
    }
}