Random text generator

const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

function randomString(length) {
  const n = ALPHABET.length;
  // Largest multiple of n that fits in a uint32. Values at or above this
  // are discarded, which is what removes the modulo bias.
  const limit = Math.floor(2 ** 32 / n) * n;
  const out = new Array(length);
  const buf = new Uint32Array(length);
  crypto.getRandomValues(buf);

  for (let i = 0, j = 0; i < length; i++) {
    let v = buf[j++];
    while (v >= limit) {
      // Refill one word at a time on the rare rejection.
      const extra = new Uint32Array(1);
      crypto.getRandomValues(extra);
      v = extra[0];
    }
    out[i] = ALPHABET[v % n];
  }
  return out.join("");
}

randomString(24);

crypto.getRandomValues() refuses a single request over 65536 bytes, so a large batch has to be chunked.

import secrets
import string

ALPHABET = string.ascii_letters + string.digits

def random_string(length: int) -> str:
    # secrets.choice() is unbiased: it uses randbelow(), which is itself
    # rejection sampling over os.urandom. Do not use random.choice() here,
    # which is a Mersenne Twister and is not cryptographically secure.
    return "".join(secrets.choice(ALPHABET) for _ in range(length))

random_string(24)

secrets has been in the standard library since 3.6. Anything using the random module is the wrong tool for a secret.

package main

import (
	"crypto/rand"
	"math/big"
)

const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

func randomString(length int) (string, error) {
	out := make([]byte, length)
	max := big.NewInt(int64(len(alphabet)))
	for i := range out {
		// rand.Int is unbiased; it rejects internally.
		n, err := rand.Int(rand.Reader, max)
		if err != nil {
			return "", err
		}
		out[i] = alphabet[n.Int64()]
	}
	return string(out), nil
}

crypto/rand, never math/rand. Go 1.20 seeds the math/rand global generator randomly on its own, which improves nothing about its predictability.

// rand = "0.9"
use rand::Rng;
use rand::distr::{Alphanumeric, SampleString};

fn random_string(length: usize) -> String {
    // rand::rng() is a thread-local ChaCha12 CSPRNG, seeded from the
    // operating system and reseeded periodically.
    // Alphanumeric samples uniformly over A-Z a-z 0-9.
    Alphanumeric.sample_string(&mut rand::rng(), length)
}

// With an arbitrary alphabet, random_range rejection-samples:
fn random_from(alphabet: &[u8], length: usize) -> String {
    let mut rng = rand::rng();
    (0..length)
        .map(|_| alphabet[rng.random_range(0..alphabet.len())] as char)
        .collect()
}

On rand 0.8 the paths differ: rand::distributions instead of rand::distr, DistString instead of SampleString, gen_range instead of random_range, and rand::thread_rng() instead of rand::rng().

<?php
function randomString(int $length): string {
    $alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $n = strlen($alphabet);
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        // random_int() is unbiased and cryptographically secure.
        // rand() and mt_rand() are neither.
        $out .= $alphabet[random_int(0, $n - 1)];
    }
    return $out;
}

echo randomString(24);

import java.security.SecureRandom;

public final class RandomString {
    private static final String ALPHABET =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    private static final SecureRandom RANDOM = new SecureRandom();

    public static String generate(int length) {
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            // nextInt(bound) rejects internally, so it is unbiased.
            sb.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
        }
        return sb.toString();
    }
}

SecureRandom, not java.util.Random and not Math.random(), both of which are 48-bit linear congruential generators.

using System.Security.Cryptography;

public static class RandomStringGenerator
{
    private const string Alphabet =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    public static string Generate(int length)
    {
        // GetString was added in .NET 8 and is unbiased.
        return RandomNumberGenerator.GetString(Alphabet, length);
    }

    // On .NET 6 and 7, GetInt32 is the unbiased primitive:
    public static string GenerateLegacy(int length)
    {
        var chars = new char[length];
        for (int i = 0; i < length; i++)
            chars[i] = Alphabet[RandomNumberGenerator.GetInt32(Alphabet.Length)];
        return new string(chars);
    }
}

#include <random>
#include <string>

std::string random_string(std::size_t length) {
    static const std::string alphabet =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    // uniform_int_distribution is specified to give every value in the range
    // equal probability, so there is no modulo bias to remove by hand.
    std::random_device rd;
    std::uniform_int_distribution<std::size_t> pick(0, alphabet.size() - 1);

    std::string out;
    out.reserve(length);
    for (std::size_t i = 0; i < length; ++i) {
        out += alphabet[pick(rd)];
    }
    return out;
}

std::random_device reads the operating system source on libstdc++, libc++ and MSVC, but the standard allows it to be deterministic, and MinGW builds before GCC 9.2 were. Where a guarantee matters, use libsodium randombytes_uniform() instead. Never std::rand() or std::mt19937 for a secret.

$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'

# GetInt32 draws from the OS CSPRNG and rejection samples internally.
-join (1..24 | ForEach-Object {
  $chars[[System.Security.Cryptography.RandomNumberGenerator]::GetInt32($chars.Length)]
})

Windows PowerShell 5.1 runs on .NET Framework, which has no GetInt32. There, pick each character with Get-Random -Maximum $chars.Length, which draws from the system CSPRNG unless -SetSeed is given. Avoid Get-Random -Count, which never repeats a character.

# 24 alphanumeric characters from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24; echo

# Base64, URL-safe, from 32 bytes of entropy.
openssl rand -base64 32 | tr '+/' '-_' | tr -d '='

tr discards bytes outside the set rather than folding them into it, so this pipeline is unbiased. Putting `head -c 24` before `tr` instead gives you the alphanumeric subset of 24 raw bytes, which is a shorter and variable-length string, not 24 characters.