パスワード生成の推定エントロピーは正しいか 文字種必須で何ビット減るか

パスワード生成ツールの多くは、生成したパスワードの横に「推定エントロピー 101 ビット」のような数字を出す。計算は 長さ × log2(使える文字の数) で、16文字・80種類なら 16 × 6.32 = 101.15 ビットになる。

この式が正しいのは、各文字を全体から独立に一様に選んだときだけである。「英大文字・英小文字・数字・記号を最低1文字ずつ含める」という条件を付けると、作られうるパスワードの集合が小さくなり、出方にも偏りが出る。表示の数字はそのぶん大きすぎる。

この記事では、ハシトシステムの パスワード生成ツール の生成関数を使い、条件付きの生成で実際のエントロピーが何ビットになるかを正確に計算する。検証環境は Windows 11、Node.js v24.11.1 である。

ツールの生成手順

パスワード生成 は、長さ(4〜64文字)と文字の種類を選んでパスワードを作るツールである。2026-11-15 に本番の HTML から生成関数を取り出すと、処理は次の順になっていた。

  1. 選ばれた文字種を連結して全体の文字集合を作る。初期設定は英大文字26・英小文字26・数字10・記号18(!@#$%^&*()-_=+[]{})の計80文字
  2. 「選んだ各種類を最低1文字含める」がオン(初期値)なら、各文字種から1文字ずつ選ぶ
  3. 残りの文字を全体の80文字から選ぶ
  4. Fisher-Yates で並びをシャッフルする
  5. 推定エントロピーを 長さ × log2(80) で表示し、40・60・80 ビットを境に「弱い」「普通」「強い」「非常に強い」を付ける

乱数は crypto.getRandomValues で取った32ビット整数で、Math.floor(2**32 / max) * max 以上の値を捨ててから % max を取っている。範囲外を捨てているので剰余による偏りは出ない。1バイトを % で割ったときに先頭の文字が出やすくなる仕組みと、範囲外を捨てる方法は Nano ID の剰余バイアスの記事 に書いた。

この記事で問題にするのは乱数の偏りではなく、手順2と手順5の組み合わせである。

条件を付けると候補が減る

80文字から16文字を自由に選ぶと、候補は 80^16 通りで、log2 を取ると 101.15 ビットになる。ところがこの中には、数字を1つも含まない文字列や記号を含まない文字列も入っている。条件付きの生成ではそれらが出てこない。

どの文字種も1文字以上含む文字列の数は、包除原理で数えられる。文字種の集合 S を除いた文字数を N_S とすると、

1
条件を満たす数 = Σ (-1)^|S| × (N_S)^L    (S は4つの文字種の部分集合すべて)

である。80^L に対する割合を出すと、条件を満たさない文字列は思ったより多い。

長さ 条件を満たさない割合 うち数字が無い割合
8 50.8% 34.4%
12 25.9% 20.1%
16 13.8% 11.8%
20 7.6% 6.9%
32 1.4% 1.4%

数字は80文字中10文字しかないので、16文字の一様なパスワードでも約8本に1本は数字を含まない。「数字を必ず含めること」と決めているサイトで登録に失敗するのを防ぐのが、このオプションの役目である。

出方も一様にならない

ツールの方法では、各文字種から1文字ずつ選んだあとにシャッフルする。このとき、ある文字列 s が出る確率は、s に含まれる各文字種の文字数を m_c とすると次のようになる(k は文字種の数、n_c は各文字種の文字数、N は全体の文字数)。

1
P(s) = (Π m_c) × (L-k)! / L! × Π(1/n_c) × N^-(L-k)

確率が Π m_c に比例するので、文字種が均等に入った文字列ほど出やすい。16文字なら、4種が4文字ずつの文字列(積256)は、英大文字13文字と他が1文字ずつの文字列(積13)より約20倍出やすい。どちらも条件は満たしているが、出る確率が違う。

確率が偏ると、エントロピーの指標によって値が変わる。ここでは3つを並べる。

  • 条件を満たす数の log2: 条件を満たす文字列が全部同じ確率で出たときの値
  • シャノンエントロピー: -Σ P log2 P。実際の分布の平均的な情報量
  • 最小エントロピー: -log2(最も出やすい1本の確率)。攻撃者が一番出やすいものから試すときの目安

正確に計算した結果

初期設定(26/26/10/18 の80文字・各文字種を最低1文字)で計算した結果が次の表である。各文字種の文字数の組をすべて列挙し、確率の合計が1になることを確かめている。計算に使ったコードは後の「実際に試す」に載せた。

長さ 表示(L×log2 80) 条件を満たす数 シャノン 最小エントロピー 表示との差(シャノン)
4 25.29 21.48 21.48 21.48 3.81
6 37.93 36.16 36.14 36.03 1.79
8 50.58 49.55 49.51 48.89 1.07
12 75.86 75.43 75.35 74.66 0.51
16 101.15 100.94 100.84 100.17 0.31
20 126.44 126.32 126.23 125.58 0.21
64 404.60 404.60 404.57 404.07 0.04

4文字のときは、各文字種がちょうど1文字ずつになるので、候補は 4! × 26 × 26 × 10 × 18 = 2,920,320 通りしかない。log2 で 21.48 ビットで、表示の 25 ビットより 3.81 ビット小さい。攻撃者が試す回数に直すと約14分の1である。

長さが増えると、条件を満たさない文字列の割合が減るので差は小さくなる。初期値の16文字では差は 0.31 ビット、最小エントロピーで見ても約1ビットである。

紛らわしい文字を除外する設定(0 O o 1 l I を除いた 24/24/8/18 の74文字)では、4文字で 3.91 ビット、16文字で 0.37 ビットの差になった。数字が8文字に減るぶん、差はわずかに大きい。

強度の表示(40・60・80 ビットの境)は、初期設定のどの長さでも、表示の値とシャノンエントロピーで同じ区分になった。たとえば13文字は表示 82.19 ビット、シャノン 81.74 ビットで、どちらも「非常に強い」である。区分は変わらないが、数字そのものは短いほど大きく外れる。

直し方

表示を正しくするには、条件を満たす文字列の数を包除原理で数え、その log2 を出せばよい。ただしこれが正しいのは、条件を満たす文字列が全部同じ確率で出るときである。

そうするには、全体から一様に選んで、条件を満たさなければ最初から引き直す。Python の公式ドキュメントの secrets モジュールの「Recipes and best practices」に載っているパスワード生成の例も、条件を満たすまで while True で作り直す書き方になっている。

引き直す回数の平均は、条件を満たす割合の逆数である。16文字なら約1.16回、8文字なら約2回、4文字でも約14回で、ブラウザで1本作るぶんには負担にならない。

なお、NIST SP 800-63B-4 の 3.1.1.2 は、パスワードを検証する側に対して、文字種の混在を求める構成ルールを課してはならない(SHALL NOT)としている。一方で、単要素で使うパスワードの最小長は15文字としている。安全性を上げるのは文字種の条件ではなく長さで、条件は既存のサイトのルールに合わせるためのものと考えるのがよい。

ツールの表示が条件を考えずに計算している点は、修正対象として記録した。生成したパスワードはブラウザ内で作られ、サーバーには送られない。

実際に試す

前提: Node.js(確認は v24.11.1)。外部パッケージは不要である。

まず、ツールと同じ方法(各文字種から1文字ずつ選んでからシャッフル)で作ったときのエントロピーを計算する。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// pw-entropy.mjs(Node.js v24.11.1 で確認・外部パッケージ不要)
// 使い方: node pw-entropy.mjs [長さ...] 例: node pw-entropy.mjs 4 8 16
// 「各文字種を最低1文字」方式で作ったパスワードの実際のエントロピーを、表示値 L*log2(N) と比べる
const SETS = [26, 26, 10, 18]; // 英大文字・英小文字・数字・記号18種
const N = SETS.reduce((a, b) => a + b); // 80
const k = SETS.length;
const lf = [0];
for (let i = 1; i <= 128; i++) lf[i] = lf[i - 1] + Math.log2(i); // log2(i!)

// 各文字種の文字数 m(どれも1以上、合計 L)の組をすべて列挙する
function* counts(L, i = 0, rest = L, m = []) {
if (i === k - 1) { if (rest >= 1) yield [...m, rest]; return; }
for (let v = 1; v <= rest - (k - 1 - i); v++) yield* counts(L, i + 1, rest - v, [...m, v]);
}

function analyze(L) {
let H = 0, sum = 0, maxLogP = -Infinity;
const logCounts = [];
for (const m of counts(L)) {
// この組に当たる文字列の数 = 多項係数 × Π n_c^m_c
const logStrings = lf[L] - m.reduce((a, v) => a + lf[v], 0)
+ m.reduce((a, v, i) => a + v * Math.log2(SETS[i]), 0);
// 1本あたりの確率 = Π m_c × (L-k)!/L! × Π(1/n_c) × N^-(L-k)
const logP = m.reduce((a, v) => a + Math.log2(v), 0) + lf[L - k] - lf[L]
- SETS.reduce((a, v) => a + Math.log2(v), 0) - (L - k) * Math.log2(N);
const mass = 2 ** (logStrings + logP);
sum += mass; H -= mass * logP; maxLogP = Math.max(maxLogP, logP);
logCounts.push(logStrings);
}
const top = Math.max(...logCounts);
const valid = top + Math.log2(logCounts.reduce((a, t) => a + 2 ** (t - top), 0));
return { shown: L * Math.log2(N), valid, H, minH: -maxLogP, sum };
}

const lengths = process.argv.slice(2).map(Number);
console.log('L\t表示\t条件を満たす数\tシャノン\t最小エントロピー\t差');
for (const L of lengths.length ? lengths : [4, 6, 8, 12, 16, 20]) {
const r = analyze(L);
if (Math.abs(r.sum - 1) > 1e-9) throw new Error('確率の合計が1にならない');
console.log([L, r.shown, r.valid, r.H, r.minH, r.shown - r.H].map((x, i) => i ? x.toFixed(2) : x).join('\t'));
}
1
2
3
4
5
6
7
8
$ node pw-entropy.mjs
L 表示 条件を満たす数 シャノン 最小エントロピー 差
4 25.29 21.48 21.48 21.48 3.81
6 37.93 36.16 36.14 36.03 1.79
8 50.58 49.55 49.51 48.89 1.07
12 75.86 75.43 75.35 74.66 0.51
16 101.15 100.94 100.84 100.17 0.31
20 126.44 126.32 126.23 125.58 0.21

SETS を [24, 24, 8, 18] に変えると、紛らわしい文字を除外したときの値になる。確率の式が正しいことは、文字集合を AB・c・1 の4文字に縮め、ツールの生成関数をそのまま40万回動かして出現頻度と比べて確かめた(96通りすべてが出て、式との差は相対4%以内)。

次に、引き直す方式の生成関数と、正しい表示値を出す関数である。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// pw-retry.mjs(Node.js v24.11.1 で確認・外部パッケージ不要)
// 使い方: node pw-retry.mjs
// 全体から一様に引き、条件を満たさなければ引き直す。表示するエントロピーは条件を満たす文字列の数から出す
import { randomInt } from 'node:crypto';

const SETS = ['ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz',
'0123456789', '!@#$%^&*()-_=+[]{}'];
const POOL = SETS.join('');

export function generate(len) {
for (let tries = 1; ; tries++) {
let pw = '';
for (let i = 0; i < len; i++) pw += POOL[randomInt(POOL.length)]; // randomInt は偏りなし
if (SETS.every((s) => [...pw].some((c) => s.includes(c)))) return { pw, tries };
}
}

// 包除原理: どの文字種も1文字以上含む長さ len の文字列の数(BigInt で正確に)
export function validCount(len) {
let total = 0n;
for (let mask = 0; mask < 1 << SETS.length; mask++) {
let size = POOL.length, bits = 0;
SETS.forEach((s, i) => { if (mask >> i & 1) { size -= s.length; bits++; } });
total += (bits % 2 ? -1n : 1n) * BigInt(size) ** BigInt(len);
}
return total;
}

const log2big = (n) => { const s = n.toString(2); return s.length - 1 + Math.log2(Number('0b1' + s.slice(1, 53).padEnd(52, '0')) / 2 ** 52); };

for (const len of [4, 8, 16]) {
const all = BigInt(POOL.length) ** BigInt(len), valid = validCount(len);
let sumTries = 0; const runs = 20000;
for (let i = 0; i < runs; i++) sumTries += generate(len).tries;
console.log(`len=${len} 表示(L*log2 80)=${(len * Math.log2(POOL.length)).toFixed(2)} 正しい値=${log2big(valid).toFixed(2)} ` +
`条件を満たす割合=${(Number(valid * 10000n / all) / 100).toFixed(2)}% 平均試行=${(sumTries / runs).toFixed(2)}`);
}
console.log('例:', generate(16).pw.length, '文字');
1
2
3
4
5
$ node pw-retry.mjs
len=4 表示(L*log2 80)=25.29 正しい値=21.48 条件を満たす割合=7.12% 平均試行=14.03
len=8 表示(L*log2 80)=50.58 正しい値=49.55 条件を満たす割合=49.20% 平均試行=2.05
len=16 表示(L*log2 80)=101.15 正しい値=100.94 条件を満たす割合=86.24% 平均試行=1.15
例: 16 文字

平均試行回数は乱数で毎回少し変わる。条件を満たす割合の逆数(4文字で約14.0、8文字で約2.03、16文字で約1.16)に近い値になる。この方式では条件を満たす文字列がすべて同じ確率で出るので、シャノンエントロピーも最小エントロピーも「正しい値」の列と一致する。

まとめ

  • 長さ × log2(文字数) は、各文字を独立に一様に選んだときだけ正しい。
  • 「各文字種を最低1文字」を付けると候補が減る。80文字・4文字では 2,920,320 通りで 21.48 ビットになり、表示より 3.81 ビット小さい。16文字では差は 0.31 ビットである。
  • 各文字種から1文字ずつ選んでシャッフルする方法は、文字種が均等な文字列ほど出やすい。最小エントロピーは16文字で約1ビット下がる。
  • 正しく表示するなら、全体から一様に選んで条件を満たすまで引き直し、包除原理で数えた候補数の log2 を出す。
  • 強さを上げるのは文字種の条件より長さである。NIST SP 800-63B-4 は構成ルールを課さないこととし、単要素のパスワードには15文字以上を求めている。

結果は 2026-11-15 時点の上記の環境とツールの実装で得たものである。

参考

  • NIST SP 800-63B-4「Digital Identity Guidelines: Authentication and Authenticator Management」3.1.1.2 Password Verifiers(構成ルールを課さない・最小長15文字)
  • Python ドキュメント secrets — Recipes and best practices(条件を満たすまで作り直すパスワード生成の例)
  • Node.js ドキュメント crypto.randomInt、W3C Web Cryptography API Crypto.getRandomValues
  • ハシトシステム パスワード生成ツールの本番 HTML(2026-11-15 取得)

パスワード生成の推定エントロピーは正しいか 文字種必須で何ビット減るか
https://blog.hashito.biz/2026/11/15/password-generator-entropy-require-each-class-overestimate-min-entropy/
著者
hashito
作成日
2026年11月15日
著作権