Abseil Code Review · 47/79

Abseil Random Seeding·Entropy

2026년 6월 11일 · Hawk · 3분 읽기

#기본은 OS entropy

absl::BitGen bg;는 OS의 entropy source(/dev/urandom, Windows BCryptGenRandom)에서 시드를 받는다. 사용자가 시드 코드를 쓰지 않는 것이 권장 방식이다.

1
#include "absl/random/random.h"
2

3
absl::BitGen bg;   // 자동 시드 — 매 프로세스, 매 객체 다른 시퀀스

OS entropy는 cryptographically strong하므로 시드 자체는 예측 불가 다. 다만 BitGen 자체가 cryptographic이 아니라는 점은 별개다(시드만 안전).

#결정적 재현 — SeedSeq

테스트 또는 재현 가능한 시뮬레이션에는 명시 시드를 쓴다.

1
absl::SeedSeq seed{1, 2, 3, 4};
2
absl::BitGen bg(seed);
3

4
absl::SeedSeq same{1, 2, 3, 4};
5
absl::BitGen bg2(same);
6
// bg와 bg2는 동일 시퀀스

absl::SeedSeq는 std::seed_seq 호환 컨셉이다. 정수 시퀀스로 초기화하고, 엔진이 내부적으로 큰 entropy pool을 채울 만큼 stretch한다.

#SeedGen — sequence 헬퍼

여러 BitGen을 같은 base seed에서 파생할 때.

1
absl::SeedSeq seed{42};
2
absl::BitGen bg1(seed);
3
absl::BitGen bg2(seed);   // bg1과 동일 시퀀스 ❌ 보통 원하지 않음

각 BitGen이 독립 이어야 하면 base seed를 stretch 한 뒤 나눠 쓴다.

1
absl::SeedSeq base{42};
2
std::vector<std::uint32_t> spread(8);
3
base.generate(spread.begin(), spread.end());
4

5
absl::BitGen bg1(absl::SeedSeq(spread.begin(), spread.begin() + 4));
6
absl::BitGen bg2(absl::SeedSeq(spread.begin() + 4, spread.end()));
7
// bg1, bg2 독립

#시드 누출 — 회피

시드 값을 로그에 남기는 것은 예측 가능성 을 만든다.

1
// 회피 — 시드 노출
2
absl::SeedSeq seed{absl::ToUnixNanos(absl::Now())};   // 현재 시각 — 추측 가능
3
LOG(INFO) << "seed = " << seed_value;
4

5
// Good — OS entropy 그대로
6
absl::BitGen bg;

시뮬레이션 재현성을 위해 시드를 저장해야 하면 별도 채널(설정 파일, 안전 저장소)로 관리하고 로그에는 hash나 ID만 남긴다.

#비-cryptographic 한계

BitGen의 시드가 안전하더라도, 출력으로부터 상태를 역추적할 수 있다. 충분한 출력을 본 공격자는 다음 출력을 예측한다.

용도	BitGen 사용 가능?
게임 로직 random	✓
캐시 키 무작위화	✓
A/B 테스트 분기	✓
부하 시뮬레이션	✓
토큰 생성	✗ — 예측 가능
세션 ID	✗ — 예측 가능
암호 키	✗ — 예측 가능
Nonce	✗ — 예측 가능

암호학적 random이 필요하면 boringssl::RAND_bytes 또는 getrandom(2)을 직접 호출한다.

1
// 토큰 생성 — BitGen 절대 안 됨
2
unsigned char token[32];
3
ABSL_CHECK_EQ(RAND_bytes(token, sizeof(token)), 1);

#thread별 BitGen

thread_local은 자동 시드 BitGen과 잘 맞는다.

1
thread_local absl::BitGen tls_bg;
2

3
int RandomShard(int n) {
4
    return absl::Uniform(tls_bg, 0, n);
5
}

각 스레드가 독립 entropy로 시드된 BitGen을 가진다. 락 없음, 시퀀스 충돌 없음.

#분산 시뮬레이션의 재현성

여러 worker가 같은 시뮬레이션을 재현하려면 worker ID + base seed로 결정.

1
absl::BitGen MakeWorkerGen(int64_t base_seed, int worker_id) {
2
    absl::SeedSeq seed{
3
        static_cast<std::uint32_t>(base_seed >> 32),
4
        static_cast<std::uint32_t>(base_seed & 0xffffffff),
5
        static_cast<std::uint32_t>(worker_id),
6
    };
7
    return absl::BitGen(seed);
8
}

같은 base_seed로 시뮬레이션을 두 번 돌리면 모든 worker가 동일 시퀀스를 본다.

#seed 자료형 호환

absl::SeedSeq는 표준의 std::seed_seq와 동등하게 동작하므로 std 엔진에도 쓸 수 있다.

1
absl::SeedSeq seed{1, 2, 3};
2
std::mt19937 mt(seed);     // OK
3
absl::BitGen bg(seed);     // OK

반대로 std::seed_seq도 absl::BitGen에 넣을 수 있다. 두 시스템이 호환된다.

#작은 예시 — 재현 가능한 부하 테스트

1
ABSL_FLAG(int64_t, sim_seed, 0, "0 → OS entropy; non-zero → reproducible");
2

3
absl::BitGen MakeSimGen() {
4
    int64_t s = absl::GetFlag(FLAGS_sim_seed);
5
    if (s == 0) {
6
        return absl::BitGen{};   // 자동 entropy
7
    }
8
    return absl::BitGen(absl::SeedSeq{
9
        static_cast<std::uint32_t>(s >> 32),
10
        static_cast<std::uint32_t>(s & 0xffffffff),
11
    });
12
}
13

14
int main(int argc, char** argv) {
15
    absl::ParseCommandLine(argc, argv);
16
    absl::BitGen bg = MakeSimGen();
17

18
    LOG(INFO) << "sim_seed = "
19
              << (absl::GetFlag(FLAGS_sim_seed) == 0
20
                  ? "ENTROPY"
21
                  : absl::StrCat(absl::GetFlag(FLAGS_sim_seed)));
22

23
    RunSimulation(bg);
24
}

Flag 하나로 production-스타일과 재현 가능 모드를 토글한다.

#코드 리뷰 체크리스트

1
// 회피 — 약한 시드
2
std::mt19937 bg(static_cast<unsigned>(std::time(nullptr)));
3

4
// Good — OS entropy
5
absl::BitGen bg;

1
// 회피 — 매 호출 새 BitGen
2
int Pick() {
3
    absl::BitGen bg;   // ❌ 매번 시드 갱신 = 비싸고 thread 충돌 가능
4
    return absl::Uniform(bg, 0, 100);
5
}
6

7
// Good — thread_local
8
thread_local absl::BitGen bg;
9
int Pick() { return absl::Uniform(bg, 0, 100); }

1
// 회피 — 토큰 생성에 BitGen
2
std::string Token() {
3
    absl::BitGen bg;
4
    return absl::StrCat(absl::Uniform<uint64_t>(bg, 0, ~0ull));   // ❌ 예측 가능
5
}
6

7
// Good — 암호학적 random
8
std::string Token() {
9
    unsigned char b[16];
10
    RAND_bytes(b, sizeof(b));
11
    return absl::BytesToHexString({reinterpret_cast<char*>(b), sizeof(b)});
12
}