랜덤 문자열 생성기

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()는 한 번에 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
}

math/rand가 아니라 crypto/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을 쓰세요. 앞의 두 가지는 모두 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에서 운영체제 난수원을 읽지만, 표준은 결정적인 구현도 허용하며 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로 문자를 하나씩 고르세요. -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자가 아니라 더 짧고 길이도 일정하지 않은 문자열이 됩니다.