速いハッシュは使わない — パスワード保存とbcrypt

パスワード保存とbcrypt。伏せ字の入力欄と鍵、ハッシュ化する装置と保護されたデータベース。

認証の回で、bcrypt を使ってパスワードを保存しました。動いています。でも、なぜ bcrypt なのかは、ほとんど説明せずに通り過ぎました。

前回: パスワードは保存しない — セッションとJWT 作業場所はVMの中(Ubuntu)です。パスワードは保存しない — セッションとJWTで作った ~/server/ と appdb の users 表をそのまま使います。 この記事に出てくるパスワードは、すべてダミーです。 実際に使っているパスワードを、練習のコマンドに打ち込まないでください。

この回で、そこを埋めます。始める前に、立っている場所をはっきりさせます。

データベースは漏れます。

「漏らさないようにする」は当然やります。セキュリティ点検の回でやったことは全部それです。それでも漏れます。 設定を1つ間違える、バックアップの置き場所を間違える、使っているライブラリに穴がある、退職した人の権限が残っている。どれか1つで足ります。

だから、考える順番を逆にします。

漏れないようにするにはどうするか、ではなく、 漏れた瞬間に、どこまでが被害になるか。

users 表がそのまま外に出たとして、その日のうちに全員のアカウントが乗っ取られるのか、攻撃する側が何年かけても割に合わないのか。この差を作るのが、パスワードの置き方です。

対象レベル: 初級〜中級 / 区分: 必修

目次

この記事でわかること

  • ハッシュと暗号化は別物だということ。暗号化は鍵で戻せるので、パスワードには使わない
  • MD5 や SHA-256 が駄目な理由は「弱いから」ではなく「速いから」だということ
  • ソルトは秘密の値ではないこと。それでも同じパスワードが同じ値にならないという一点が効くこと
  • 平文のパスワードは一括でハッシュに変換できないこと。ログインのときに作り直すしかないこと
  • JWT はハッシュではなく署名だということ(混同すると設計を間違える)

この記事でやること

  1. node -e で SHA-256 を100万回回して、どれくらい速いかを実測する
  2. bcrypt で登録と照合を作り直す(前回より丁寧に、失敗の扱いまで)
  3. $2b$10$... という文字列を分解して読む。コストを上げて、遅くなることを実測する
  4. 平文パスワードが入った練習用の表を作り、ログイン時に作り直す移行を動かす
  5. やってはいけないことを4つ、理由つきで確認する

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
ハッシュ関数どんな長さの入力からも決まった長さの値を作る計算。同じ入力なら必ず同じ結果になる
一方向結果から元の入力を計算で戻せないという性質。ハッシュはこれを持つ
暗号化鍵を使って読めなくすること。鍵があれば元に戻せる(ハッシュとの決定的な違い)
ソルトハッシュを作るときに混ぜるランダムな文字列。1人1つ、保存もされる
コスト(ストレッチング)わざと計算を何度も繰り返すこと。回数を上げるほど遅くなる
オフライン攻撃盗んだデータを手元で好きなだけ試すこと。サーバー側では止められない
タイミング攻撃応答時間の差から、当たっている桁数などを推測すること

この記事は「守る側」の話だけをします。 攻撃するためのコードや、割るための道具の作り方は書きません。書かなくても、守り方の理由は全部説明できます。

① ハッシュは戻せない。暗号化は戻せる

まず、ここを混ぜないでください。 混ざったままだと、この先の判断が全部ずれます。

暗号化:  himitsu-dummy  --[鍵]-->  8f3a...  --[鍵]-->  himitsu-dummy
                                                        ↑ 戻る

ハッシュ: himitsu-dummy  ---------->  $2b$10$...
                                       ↑ 戻す方法が無い

暗号化は「後で読むため」の道具です。 だから鍵があれば戻ります。そして鍵は、どこかに置いてあります。 アプリのサーバーの中か、環境変数か、鍵の管理サービスか。

パスワードを暗号化で持つと、「鍵も一緒に漏れたら全部読める」という状態になります。 データベースが漏れる状況では、同じサーバーにある鍵も一緒に漏れることが多いです。

ハッシュにはそもそも鍵がありません。 戻す手段が用意されていない。だから、漏れても読めません。

戻せないのに、どうやってログインを確かめるのか

戻さないからです。

保存してあるもの:  $2b$10$...(ユーザーが登録したときの結果)
入力されたもの:    himitsu-dummy

  → 入力を「同じやり方」でもう一度変換して、
    保存してある結果と一致するかだけを見る

サーバーは、最後まで本物のパスワードを知りません。 「合っているかどうか」だけが分かります。これがパスワードを保存しないということの意味です。

ここまでは前回と同じ話です。 問題はこの先で、「ハッシュならどれでもいい」ではないというところです。

② 速いことが、そのまま弱点になる

SHA-256 は壊れていません。 2026年の今も、ファイルが改ざんされていないかの確認には普通に使われています。それでもパスワードには使いません。

理由は1つです。速すぎるからです。

実測する

VMの中で打ってください。 SHA-256 を100万回回して、時間を測ります。

bash
$ node -e "
  const c = require('crypto');
  const t = Date.now();
  for (let i = 0; i < 1000000; i++) {
    c.createHash('sha256').update('dummy-pass-' + i).digest('hex');
  }
  console.log('SHA-256 x 1,000,000:', (Date.now() - t) / 1000, 'sec');
  "

この記事の実機ではこう出ました。

SHA-256 x 1,000,000: 1.884 sec

[スクリーンショット: 01_sha256の実測.png] VMのターミナルで上の node -e を実行し、秒数が表示された画面を撮ってください。

1秒あたり約53万回です。しかもこれは、VMの上で、JavaScriptで、1コアだけで回した数字です。

この計算を専用のハードウェアでやると、桁が3つ4つ変わります。 ここではその具体的な数字は追いません。追わなくても結論は出ます。

users 表が漏れたあと、攻撃する側はサーバーに一切触りません。 盗んだファイルを手元に置いて、好きなだけ、何日でも試せます。 これがオフライン攻撃です。 ログイン試行回数の制限も、ufw も、fail2ban も、この状況では1ミリも効きません。

だから、守る側にできることは1つしかありません。

1回の照合を、わざと遅くする。

利用者にとっての0.1秒は、ログインのときに1回だけ払うコストです。気づきません。 手元で何億回も試したい側にとっては、0.1秒は致命的です。

「桁が違う」を数字で見る

bcrypt のほうも、あとで同じように測ります。先に結果だけ並べます。

この記事の実機での1回あたり1秒あたり
SHA-256約 0.0000019 秒約 53万回
bcrypt(コスト10)約 0.068 秒約 15回

約3万5千倍です。この差は「弱い / 強い」ではなく、「速い / 遅い」だけで作られています。

③ ソルトが防ぐもの

ソルトは、ハッシュを作るときに混ぜるランダムな文字列です。1人ずつ違う値を作って、ハッシュと一緒に保存します。

最初にひっかかるのはここです。

ソルトは秘密の値ではありません。 保存されているし、漏れたら一緒に漏れます。 隠すためのものではないからです。

では何のためか。ソルトが無い世界を見ると分かります。

ソルト無し(同じ関数を使うと、同じ入力は必ず同じ結果になる)

Aさん  dummy-pass-A  →  9b74c9...
Bさん  dummy-pass-A  →  9b74c9...    ← 同じ
Cさん  dummy-pass-A  →  9b74c9...    ← 同じ

漏れた表を眺めるだけで、「この3人は同じパスワードだ」と分かります。 そして、1人分が判明した瞬間、3人まとめて破れます。

さらに悪いことに、この計算は事前にやっておけます。 よく使われるパスワードの変換結果を先に用意しておけば、漏れた表と突き合わせるだけで済みます。「割る」作業が「探す」作業に変わります。

ソルトが1人1つ違うと、これが成立しません。

ソルトあり

Aさん  dummy-pass-A + ソルトA  →  $2b$10$QAr33ZAdR64iJDbCYI.Pyu...
Bさん  dummy-pass-A + ソルトB  →  $2b$10$/5N48B07EoQ4QgPWqtEXIO...
                                     ↑ 同じパスワードなのに別の値
  • 同じパスワードの人を見つけられない
  • 事前に用意した表が使えない(ソルトが分かってからでないと計算を始められない)
  • 1人割っても、その1人分にしかならない(全員分をやり直す必要がある)

ソルトは「時間を稼ぐ」道具ではなく、「まとめてやられる」のを止める道具です。 1回の計算を遅くするのがコスト、まとめ買いを禁止するのがソルト。 役割が違います。両方要ります。

そして bcrypt は、ソルトを自動で作って、自動で混ぜて、結果の文字列の中に一緒に入れてくれます。 自分で管理する場所はありません。これが「自作しない」の具体的な中身です。

④ bcrypt で登録と照合を作り直す

入れます。 VMの ~/server/ で打ってください。

bash
$ cd ~/server
$ npm install bcryptjs

なぜ bcrypt ではなく bcryptjs なのか

npm には名前の似た2つがあります。

パッケージ中身入れるとき
bcryptC++で書かれた部分がある(ネイティブ)合うビルド済みがあればそのまま入る。 無いとビルドが走り、node-gyp / make / g++ / Python が要る
bcryptjs全部JavaScriptどこでも同じように入る

素のUbuntu ServerのVMには、ビルドに要る道具が入っていません。 Linux(x64 / arm64)向けにはビルド済みが配布されているので、たいていはそのまま入ります。ただ、合うビルド済みが無い版・環境ではビルドに回り、npm install bcrypt は途中で止まります。

gyp ERR! find Python
gyp ERR! stack Error: Could not find any Python installation to use

直したければ sudo apt install -y build-essential python3 を入れれば通ります。 ただ、この記事では bcryptjs を使います。 計算方式は同じで、結果の文字列も互換です。JavaScriptのぶん少し遅いですが、パスワードのハッシュは「遅いほうが望ましい」ので、ここでは問題になりません。

本番で秒間のログインが多いなら、ネイティブ版のほうが有利です。 そのときは build-essential を入れて bcrypt に差し替えます。保存されている文字列はそのまま使えます。

登録(新しいパスワードを保存する)

app.js の該当箇所です。前回のものに、確認と失敗の扱いを足しています。

const bcrypt = require("bcryptjs");

const COST = 10;              // ← あとで上げます
const MAX_PASSWORD_BYTES = 72; // ← bcrypt の上限。理由は下

app.post("/api/users", async (req, res) => {
  const { email, password } = req.body;

  if (typeof email !== "string" || typeof password !== "string") {
    return res.status(400).json({ error: "email と password が要ります" });
  }
  if (password.length < 8) {
    return res.status(400).json({ error: "password は8文字以上にしてください" });
  }
  if (Buffer.byteLength(password, "utf8") > MAX_PASSWORD_BYTES) {
    return res.status(400).json({ error: "password が長すぎます" });
  }

  try {
    const hash = await bcrypt.hash(password, COST);
    const [r] = await pool.execute(
      "INSERT INTO users (email, password_hash) VALUES (?, ?)",
      [email, hash]
    );
    res.status(201).json({ id: r.insertId, email });
  } catch (e) {
    if (e.code === "ER_DUP_ENTRY") {
      return res.status(409).json({ error: "登録できませんでした" });
    }
    console.error(e.code);           // ← password は絶対に出さない
    res.status(500).json({ error: "サーバーエラー" });
  }
});

MAX_PASSWORD_BYTES の話をしておきます。

bcrypt は、72バイトを超えた部分を黙って捨てます。 エラーになりません。73バイト目以降は「何を入れても同じ」になります。

日本語はUTF-8で1文字3バイトなので、日本語のパスフレーズなら24文字あたりが上限です。長いものを受け付けているつもりで、実は切られているという状態を避けるために、入口で長さを見て、はっきり断ります。

「切られるなら先にSHA-256で縮めてから渡せばいい」という書き方をネットで見かけます。 考え方としては使われている手ですが、組み合わせ方を間違えると別の穴になります。 自分で組み立てないでください。 長いパスフレーズを受けたいなら、あとで出てくる Argon2id を選ぶほうが素直です。

照合(ログイン)

// ユーザーが見つからなかったときに使う、形だけのハッシュ(ダミー)
const DUMMY_HASH = bcrypt.hashSync("dummy-not-a-real-password", COST);

app.post("/api/login", async (req, res) => {
  const { email, password } = req.body;

  const [rows] = await pool.execute(
    "SELECT id, email, password_hash FROM users WHERE email = ?",
    [String(email || "")]
  );
  const user = rows[0];

  // ユーザーが居なくても、必ず1回は照合を走らせる(理由は下)
  const ok = await bcrypt.compare(
    String(password || ""),
    user ? user.password_hash : DUMMY_HASH
  );

  if (!user || !ok) {
    return res.status(401).json({ error: "メールアドレスかパスワードが違います" });
  }

  req.session.userId = user.id;
  res.json({ id: user.id, email: user.email });
});

DUMMY_HASH を挟んでいる理由です。

ユーザーが居ないときにすぐ 401 を返すと、その応答だけ明らかに速くなります。 bcrypt は0.07秒かかるのに、そこを通らない応答は0.001秒で返ります。測れば分かります。 「このメールアドレスは登録されている / されていない」が、応答時間だけで判別できてしまいます。

居ても居なくても同じ仕事をさせる。 これがタイミングの穴を塞ぐということです。

動かして確かめます。

bash
$ curl -s -X POST http://localhost:3000/api/users \
    -H "Content-Type: application/json" \
    -d '{"email":"dummy1@example.com","password":"dummy-pass-1234"}'
bash
$ sudo mysql -e "SELECT id, email, password_hash FROM appdb.users;"

[スクリーンショット: 02_usersテーブルの中身.png] password_hash の列に $2b$10$... という文字列が入っていることが分かる画面を撮ってください。

登録したパスワードが、どこにも残っていないことを目で確認してください。 ここが確認できたら、この節は終わりです。

⑤ $2b$10$... を読む

保存されているのは、ハッシュ「だけ」ではありません。

$2b$10$QAr33ZAdR64iJDbCYI.PyuaOxfEFo3/GBnORrxIdpkVVV6sPGKUdW
└┬┘ └┬┘ └───────────┬──────────┘└──────────┬─────────────┘
 │   │              │                       │
 │   │              │                       └─ ハッシュ(31文字)
 │   │              └───────────────────────── ソルト(22文字)
 │   └──────────────────────────────────────── コスト(10)
 └──────────────────────────────────────────── アルゴリズムの版

全部で60文字です。 前回 VARCHAR(255) を取ったのは、60文字に合わせて切り詰めると、方式を変えたときに入らなくなるからです。

部分中身なぜ一緒に入っているか
$2b$bcrypt の版。$2a$ $2y$ も同じ仲間昔の版で作られたものも照合できるように
10コスト。2^10 = 1024 回繰り返す後からコストを上げたとき、古い行も照合できるように
22文字ソルトソルトを別の列で管理しなくていい
31文字ハッシュ本体—

これが「自分で組み立てるな」の答えです。 ソルト用の列を足す、コストをどこかに書いておく、方式を変えたら全部作り直す。そういう管理が全部要りません。 照合するときは、保存してある文字列を渡すだけ。 中に書いてある条件で、勝手に同じ計算をやり直してくれます。

コストを上げて、遅くなることを実測する

コストは1増えると計算量が2倍になります。 打って確かめてください。

bash
$ cd ~/server
$ node -e "
  const b = require('bcryptjs');
  for (const cost of [8, 10, 11, 12]) {
    const t = Date.now();
    b.hashSync('dummy-pass-1234', cost);
    console.log('cost', cost, ':', (Date.now() - t) / 1000, 'sec');
  }
  "

この記事の実機ではこう出ました。

cost 8 : 0.017 sec
cost 10 : 0.068 sec
cost 11 : 0.136 sec
cost 12 : 0.279 sec

[スクリーンショット: 03_コスト別の所要時間.png] コスト 8 / 10 / 11 / 12 の秒数が並んで表示された画面を撮ってください。

きれいに倍になっています。 数字はマシンによって変わるので、あなたの環境の数字が違っても正常です。

同じパスワードを2回ハッシュ化すると、違う結果になることも見ておきます。

bash
$ node -e "
  const b = require('bcryptjs');
  const h1 = b.hashSync('dummy-pass-1234', 10);
  const h2 = b.hashSync('dummy-pass-1234', 10);
  console.log(h1);
  console.log(h2);
  console.log('同じ文字列か:', h1 === h2);
  console.log('h1で照合:', b.compareSync('dummy-pass-1234', h1));
  console.log('h2で照合:', b.compareSync('dummy-pass-1234', h2));
  "

2行は違うのに、どちらでも照合は通ります。 ソルトが毎回作られていて、そのソルトが文字列の中に入っているからです。③ の話が、目の前で起きています。

どのコストにするか

「安全な数字」は決まっていません。 決め方は決まっています。

自分のサーバーで測って、1回あたり 0.1〜0.5秒 くらいに収まる一番大きい値を選ぶ。

  • 利用者が待つのはログインのときの1回だけなので、0.2秒は体感されません
  • マシンが速くなれば、同じコストでも速くなります。 だから数年ごとに測り直して上げます
  • 上げすぎると、ログインが集中したときに自分のサーバーが詰まります。 相手より先に自分が倒れます

上げるときは、COST の値を変えるだけです。

const COST = 12;

既に保存してある行は、コスト10のままです。それでも照合は通ります。(文字列の中に 10 と書いてあるからです)次にその人がログインしたときに作り直す、というのが次の節です。

⑥ 平文のパスワードを、どう移行するか

この記事の users 表は、最初からハッシュです。 移行の話は、他所から引き継いだシステムを触るときに必ず来ます。

平文で入っている表を、一括でハッシュに変換することはできません。

「できない」の意味を正確に書きます。技術的には、UPDATE を1回打てば全行をハッシュにできます。 問題はそこではありません。

  • ハッシュは戻せません。 一度変換したら、元の平文はもう手に入りません
  • 変換した時点では、まだ「そのパスワードが正しいか」を誰も確かめていません
  • 文字コードや前後の空白の扱いを1つ間違えると、全員がログインできなくなります。 そして戻せません

だから、実務ではこうします。

本人がログインしてきた、その瞬間に作り直す。

そのときだけ、正しい平文が手元にあります。 一度きりのチャンスです。

練習用に、平文の表を作って再現する

本物の users は触りません。 別の表を作ります。入れるのは全部ダミーです。

bash
$ sudo mysql
USE appdb;

CREATE TABLE legacy_users (
  id            INT AUTO_INCREMENT PRIMARY KEY,
  email         VARCHAR(255) NOT NULL UNIQUE,
  password      VARCHAR(255) NULL,      -- 平文(引き継いだ悪い状態)
  password_hash VARCHAR(255) NULL,      -- これから入れる列
  created_at    TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO legacy_users (email, password) VALUES
  ('old1@example.com', 'dummy-old-pass-1'),
  ('old2@example.com', 'dummy-old-pass-2');

やっていることを言葉にします。

  1. 新しい列 password_hash を足す(既存の password はまだ消さない)
  2. ログインの処理を、両方に対応させる
  3. 平文で照合が通ったら、その場でハッシュを作って書き込み、平文を NULL にする
  4. 平文が残っている行が0になったら、password 列を落とす

ログイン処理(移行つき)

app.post("/api/legacy-login", async (req, res) => {
  const email = String(req.body.email || "");
  const password = String(req.body.password || "");

  const [rows] = await pool.execute(
    "SELECT id, email, password, password_hash FROM legacy_users WHERE email = ?",
    [email]
  );
  const user = rows[0];
  if (!user) {
    await bcrypt.compare(password, DUMMY_HASH);   // 時間差を作らない
    return res.status(401).json({ error: "メールアドレスかパスワードが違います" });
  }

  let ok = false;

  if (user.password_hash) {
    // すでに移行済み
    ok = await bcrypt.compare(password, user.password_hash);
  } else if (user.password !== null) {
    // まだ平文。ここで一度だけ照合して、その場で作り直す
    ok = timingSafeEqualString(password, user.password);
    if (ok) {
      const hash = await bcrypt.hash(password, COST);
      await pool.execute(
        "UPDATE legacy_users SET password_hash = ?, password = NULL WHERE id = ?",
        [hash, user.id]
      );
      console.log("migrated user id:", user.id);   // パスワードは出さない
    }
  }

  if (!ok) return res.status(401).json({ error: "メールアドレスかパスワードが違います" });
  res.json({ id: user.id, email: user.email });
});

timingSafeEqualString は、長さの違いで漏れないように包んだ比較です。

const crypto = require("crypto");

function timingSafeEqualString(a, b) {
  const ba = Buffer.from(String(a), "utf8");
  const bb = Buffer.from(String(b), "utf8");
  if (ba.length !== bb.length) return false;
  return crypto.timingSafeEqual(ba, bb);
}

動かします。

bash
$ curl -s -X POST http://localhost:3000/api/legacy-login \
    -H "Content-Type: application/json" \
    -d '{"email":"old1@example.com","password":"dummy-old-pass-1"}'
bash
$ sudo mysql -e "SELECT id, email, password, password_hash FROM appdb.legacy_users;"

ログインした行だけ、password が NULL になって password_hash が埋まっているはずです。

[スクリーンショット: 04_移行後のlegacy_users.png] 1行目だけ password が NULL になり、password_hash に $2b$ から始まる文字列が入っている画面を撮ってください。

移行しきれない人が、必ず残る

ここが現実の話です。

何ヶ月経ってもログインしてこない利用者が、必ず残ります。

その人たちの平文は、放っておくと永久に残ります。 実務では、期限を決めてこうします。

  1. 締切を決めて告知する
  2. 締切を過ぎたら、残っている行の password を消す(ハッシュは作れないので、そのアカウントはログイン不能になる)
  3. その人たちはパスワード再設定の導線で入り直してもらう

「ログインできなくなる人を出さない」と「平文を残さない」は両立しません。 どこかで選びます。選んだことを記録に残してください。

⑦ やってはいけないこと

ハッシュの仕組みを自分で作らない

SHA-256 を1000回繰り返す、ソルトを自分で作って前後に足す、社内の秘密の文字列を混ぜる。どれも駄目です。

思いつく組み合わせは、だいたい過去に誰かが試して、穴が見つかっています。 そして自分では確かめようがありません。

使うのは、公開されていて、長く検証されていて、実装が広く使われているものだけ。

ハッシュ同士を === で比べない

照合には、必ずライブラリの compare を使ってください。

// 駄目
if (myHash === user.password_hash) { /* ... */ }

// 正しい
const ok = await bcrypt.compare(password, user.password_hash);

=== は、先頭から1文字ずつ比べて、違ったところで止まります。 つまり一致している文字数が多いほど時間がかかります。 その差は極めて小さいですが、何万回も測れば見えます。

bcrypt.compare は、最後まで比べてから結果を返すように作られています。セッションIDやAPIキーを比べるときも同じで、そこは Node.js の crypto.timingSafeEqual を使います。

これは「セッションのIDを推測されない」話と地続きです。認証の回で扱った Cookie の属性と、同じ層の守りです。

パスワードをログに出さない

一番よくある事故です。 攻撃されたわけでもなく、自分で書き出します。

// 全部駄目
console.log(req.body);                       // password が入っている
app.use(morgan("combined"));                 // 設定次第でボディが載る
console.error("login failed:", email, password);
catch (e) { console.error(e); }              // 例外に値が載ることがある

ログは、データベースより雑に扱われます。 別のサーバーに集められて(ログ集約の回でやりました)、バックアップされて、権限も緩い。そこに平文が流れたら、ハッシュにした意味がありません。

エラーを出すときは e.code だけにする、リクエストのボディを丸ごと出さない。 これで大半は防げます。

使い回しを検知しようとしない

「他のサービスと同じパスワードを使っていたら警告したい」という発想が出てきます。

やめてください。 それをやるには、他所のパスワードを手元で扱う必要があります。ハッシュにした意味が消えます。

同じことが「登録済みのパスワードと似ているか」の判定にも言えます。 似ているかを判定するには、元のパスワードを持っていないとできません。

やっていいのは、入力されたその場でできることだけです。

  • 長さの下限を決める(上限も。72バイトの話)
  • よく使われるパスワードの一覧と突き合わせて、その場で断る(一覧は公開されているものを使う。保存はしない)
  • 定期的な変更を強制しない(強制すると単純なものに変えられる。いまの公的な指針は「強制しない」側です)

⑧ JWT はハッシュではない

ここを分けておきます。 認証の回でJWTを扱ったので、混ざりやすいからです。

ハッシュ:  入力  →  戻せない値          (目的: 元を隠す)
署名:     データ + 鍵  →  署名          (目的: 改ざんを検出する)

JWT は、中身が読めます。 隠していません。

eyJhbGciOiJIUzI1NiJ9.eyJ1c2VySWQiOjF9.dBjftJeZ4CVP...
└─── ヘッダ ───┘└─── ペイロード ───┘└─── 署名 ───┘
      ↑ どちらも Base64URL。誰でもデコードして読める

JWT のペイロードに、秘密の値を入れてはいけません。 メールアドレスも、権限の詳細も、当然パスワードも。Base64 は暗号化ではありません。 変換しているだけです。

署名が守るのは「書き換えられていないこと」だけです。「読まれないこと」ではありません。

何を守るか鍵戻せるか
ハッシュ(bcrypt)元の値を隠す無い戻せない
署名(JWTのHS256)改ざんを検出するサーバーの秘密鍵中身はそのまま読める
暗号化読まれないようにする鍵鍵があれば戻る

JWT の署名にも HMAC-SHA256 というハッシュの仲間が使われています。 それでも役割が違います。

署名は「速いこと」が望ましい(リクエストごとに毎回検証するので) パスワードのハッシュは「遅いこと」が望ましい(ログインのときだけなので)

同じ SHA-256 が、片方では正解で、片方では不正解。 理由は強度ではなく、何回、誰が計算するかの違いです。ここが分かれば、この記事の話は繋がっています。

OAuthの回で扱った ID トークンも、実体はJWTです。 あれも署名を検証するのであって、復号するのではありません。

⑨ いま何を選ぶか

2026年時点で、名前が挙がるのは3つです。

特徴どういうときに
Argon2idメモリも大量に使わせる方式。専用ハードウェアで並列に回すのが難しくなる新しく作るなら、まずこれを検討する
bcrypt長く使われていて、実装が多く、資料も多い。72バイト上限がある既にあるもの。学習用。実装の選択肢を優先したいとき
scryptArgon2 の前からある、メモリを使う方式。Node.js に標準で入っている(crypto.scrypt)依存を増やしたくないとき

Node.js で Argon2 を使うなら argon2 パッケージです。 ただしネイティブの部品を含みます(bcrypt と同じ事情で、合うビルド済みが無い環境ではビルドが要ります)。

bash
$ sudo apt install -y build-essential python3
$ npm install argon2

この記事では入れ替えません。 理由は2つです。

  • bcrypt で保存したものは、そのまま使い続けても現時点で問題になりません
  • 入れ替えるなら、⑥ と同じ「ログイン時に作り直す」手順になります。やり方は既に手が動きます

そして、一番大事な注意を書きます。

この表を鵜呑みにしないでください。

推奨は変わります。 パラメータの推奨値(メモリ量、繰り返し回数)は、マシンが速くなるたびに更新されます。 この記事の数字も、数年で古くなります。

見に行く先を1つだけ覚えてください。

OWASP — Password Storage Cheat Sheet

実装する直前に、ここを開いて、そのときの推奨値を見る。 これが正しいやり方です。「記事に書いてあった値をコピーする」ではありません。

つまずいたところ

症状原因と直し方
npm install bcrypt が gyp ERR! find Python で止まるビルドの道具が無い。 bcryptjs に変えるか、sudo apt install -y build-essential python3
node -e の中の ' でシェルが混乱するnode -e "..." の外側は二重引用符、中は一重引用符に統一する
コスト12にしたらログインが体感で重い正常です。 実測して 0.1〜0.5秒に収まる値まで下げる
長いパスワードで、途中まで合っていればログインできる72バイトで切られている。 入口で長さを断る
移行の UPDATE を打ったのに password が NULL にならないWHERE id = ? を忘れて条件が効いていないか、照合が通っていない。ok の値を確かめる
存在しないメールアドレスだけ応答が明らかに速いDUMMY_HASH を通していない。 ユーザーが居なくても照合を1回走らせる
crypto.timingSafeEqual が Input buffers must have the same byte length で落ちる長さを先に比べていない。 上の timingSafeEqualString のように、長さが違う時点で false を返す
ハッシュがDBで途中で切れている列が VARCHAR(60) より短い。VARCHAR(255) にする

後片づけ

練習用の表だけ落とします。

bash
$ sudo mysql
USE appdb;
DROP TABLE legacy_users;

~/server/ と users 表は残してください。 この先の回でも使います。

app.js に足した /api/legacy-login も、消して構いません。 移行が要る場面が来たときに、この記事に戻ってきてください。

まとめ

  • データベースは漏れる前提で考える。 目標は「漏らさない」ではなく、漏れた瞬間に被害がどこで止まるか
  • ハッシュは戻せない。暗号化は鍵で戻せる。 鍵はだいたいデータと一緒に漏れるので、パスワードに暗号化は使わない
  • SHA-256 が駄目な理由は「弱いから」ではなく「速いから」。 実測で1秒に約53万回。盗まれたあとは手元で無制限に試せる(オフライン攻撃)ので、回数制限もファイアウォールも効かない
  • 守る側にできるのは、1回の照合をわざと遅くすることだけ。0.1〜0.5秒に収まる一番大きいコストを、自分のサーバーで測って決める
  • ソルトは秘密の値ではない。 役割は「まとめてやられる」のを止めること。同じパスワードが同じ値にならないので、1人割っても1人分にしかならない
  • $2b$10$... の中には、アルゴリズム・コスト・ソルト・ハッシュが全部入っている。 だからコストを上げても古い行が照合できる
  • bcrypt は72バイトを超えた部分を黙って捨てる。 入口で長さを断る
  • 平文は一括変換できない。 ハッシュは戻せないので、本人がログインした瞬間にしか作り直せない。ログインしてこない人は必ず残るので、締切を決めて選ぶ
  • 自作しない / === で比べない / ログに出さない / 使い回しを検知しようとしない
  • JWT はハッシュではなく署名。 中身は誰でも読めるので、ペイロードに秘密を入れない
  • 推奨は変わる。 実装する直前に OWASP の Cheat Sheet を開く

参考リンク


次に読む

この記事は 【第5段階】バックエンドとデータベース の 10 / 29 本目です。

記事
← 前の記事パスワードは保存しない — セッションとJWT
→ 次の記事ALTER TABLE を手で打たない — ORMとマイグレーション

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

Backend›Hashing Algorithms
  • ハッシュ(bcrypt / scrypt / MD5 / SHA の使い分け)
  • パスワードの保存と、漏れたあとの被害の止め方

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次