ランダム文字列生成ツール

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() は 1 回の要求が 65,536 バイトを超えると拒否するため、大量に生成する場合は分割する必要があります。

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 は Python 3.6 から標準ライブラリに含まれています。random モジュールを使うものは、シークレットには適していません。

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 を使い、math/rand は使わないでください。Go 1.20 以降、math/rand のグローバル生成器には自動でランダムなシードが設定されますが、予測可能性は何も改善されません。

// 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()
}

rand 0.8 ではパスが異なります。rand::distr の代わりに rand::distributions、SampleString の代わりに DistString、random_range の代わりに gen_range、rand::rng() の代わりに rand::thread_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();
    }
}

java.util.Random や Math.random() ではなく SecureRandom を使ってください。前者2つはどちらも 48 ビットの線形合同法による生成器です。

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 は libstdc++、libc++、MSVC では OS の乱数源を読みますが、標準規格は決定的な実装も認めており、GCC 9.2 より前の MinGW ビルドは実際にそうでした。保証が必要な場合は libsodium の randombytes_uniform() を使ってください。シークレットに std::rand() や std::mt19937 は決して使わないでください。

$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 は GetInt32 のない .NET Framework 上で動作します。5.1 では Get-Random -Maximum $chars.Length で1文字ずつ選んでください。-SetSeed を指定しない限り、システムの CSPRNG が使われます。同じ文字を繰り返さない Get-Random -Count は避けてください。

# 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 は集合に含まれないバイトを集合内に折り返さずに捨てるため、このパイプラインに偏りはありません。`head -c 24` を `tr` の前に置くと、生の 24 バイトのうち英数字だけが残り、24 文字ではなく、より短く長さも一定しない文字列になります。