※本記事はアフィリエイト広告(PR)を含みます。
鍵を渡さずに秘密を共有できます。公開鍵暗号とTLSの手順を実際に打って、証明書が何を保証しているのかを確かめます。
前回: SSEとWebSocket — 1秒ごとに聞きに行くのをやめる
これは【深掘り】の記事です。本線の順路ではありません。 このシリーズは言葉を覚える回にしません。 全部、手元で打って、出力を見て、確かめます。 飛ばしても本線は進めます。 本線側の入口は 安全にはできない、被害を小さくする — セキュリティ点検 にあります。
この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。
この記事は「守る側」だけを書きます。攻撃の手順は書きません。 暗号を破る方法、鍵を推測する方法、他人の通信を覗く方法、証明書を偽装する方法は一切書きません。 出てくるのは 自分で作った鍵 と 自分の localhost だけです。 他人のサーバーに対しては、この記事の内容を含め、何も試さないでください。 自分の管理下にないホストへ確認行為を行うことは、それ自体が問題になります。
「HTTPSは、通信を暗号化するもの」。私はずっとそう覚えていました。
それで困りませんでした。証明書を入れたら鍵マークが付いて、それで終わりだったからです。
困ったのは、社内向けの小さなAPIを立てたときでした。自己署名の証明書を入れました。 通信は暗号化されています。それは間違いありません。なのにブラウザは真っ赤な警告を出しました。
「暗号化はできているのに、なぜ怒られるのか」が、そのときの私には本当に分かりませんでした。 -k を付けて curl を通し、ブラウザでは「詳細設定 → アクセスする」を押して、警告を無視して進みました。
暗号化と、身元の確認は、別の仕事です。 自己署名証明書でも通信は暗号化されています。 ブラウザが怒っているのは暗号の話ではありません。 「この公開鍵が、本当に localhost のものだと、誰が保証したのか」を怒っています。 保証したのが自分だけだったから、警告が出ていました。
そしてもう1つ、私が長いこと勘違いしていたことがあります。
公開鍵暗号は「速い暗号」ではありません。むしろ遅いです。 公開鍵暗号がやっているのは、「鍵をどうやって相手に渡すか」という、たった1点です。 本文を暗号化しているのは、今も昔も共通鍵のほうです。
この記事では、それを全部、手を動かして確かめます。 RSA で長いファイルを暗号化しようとしてわざとエラーを出します。 Diffie-Hellman を小さい数で紙の計算のように書いて、両者が同じ値に辿り着くところを出力で見ます。 自分だけのCAを作って証明書に署名し、ブラウザが怒る理由が消える瞬間を openssl verify で確かめます。
対象レベル: 中級〜上級 / 区分: 発展
この記事でわかること
- 共通鍵暗号は十分に速い。残る問題は「その鍵をどうやって相手に渡すか」の1点だけ。公開鍵暗号はそこだけを解く
- 公開鍵暗号は遅い。 実測で、同じ1MBを守るのに 1600倍の差が出た。だからハイブリッドになる
- RSAは鍵長より短いデータしか暗号化できない。 2048ビット鍵なら実質245バイトまで。これが構造的な理由
- 署名は暗号化ではない。中身は隠れない。 保証するのは「本人が書いた」「改ざんされていない」の2つだけ
- 鍵交換は「鍵を送らない」。 回線に流れるのは公開値だけで、共有する秘密は両者が別々に計算して一致する
- 証明書は暗号の道具ではなく、身元の保証書。暗号化は証明書が無くてもできる
- ブラウザの警告は「暗号が弱い」ではなく「保証した人が信頼リストに居ない」。信頼の連鎖の話
- TLS 1.3 はハンドシェイクの往復が1回減る。 選べる暗号スイートも絞られている
この記事でやること
openssl speedと Node.js で、共通鍵と公開鍵の速度差を実測するopenssl genpkeyで自分の鍵ペアを作り、中身をテキストで読み、権限を 600 にする- 公開鍵で暗号化 → 秘密鍵で復号を実際にやり、逆ができないことと長さの上限をエラーで確かめる
openssl dgst -sign/-verifyで署名し、1バイト書き換えて検証を失敗させる- Diffie-Hellman を小さい数で計算し、続けて Node.js の ECDH で同じことをやる
- 自己署名証明書と、自分だけのCAで署名した証明書を作り、
openssl verifyで違いを見る - 自分で立てたHTTPSサーバーに
openssl s_clientで繋ぎ、プロトコルと暗号スイートを読む - 守る側のチェックリストを作る(攻撃の例は書きません)
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| 共通鍵暗号(対称暗号) | 暗号化と復号に同じ鍵を使う方式。AES が代表。速い |
| 公開鍵暗号(非対称暗号) | 2つで1組の鍵を使う方式。片方で閉めたら、もう片方でしか開かない。遅い |
| 秘密鍵 | 絶対に外に出さないほうの鍵。 これが漏れたら全部終わる |
| 公開鍵 | 配ってよいほうの鍵。 秘密鍵から作れるが、逆はできない |
| ハイブリッド暗号 | 公開鍵で共通鍵を渡し、本文は共通鍵で守るやり方。TLS はこれ |
| 電子署名 | 秘密鍵で作る短い印。中身は隠さない。 本人性と非改ざんだけを示す |
| ハッシュ | どんな長さのデータからも固定長の値を出す関数。SHA-256 なら常に32バイト |
| 鍵交換(Diffie-Hellman) | 鍵そのものを送らずに、両者が同じ秘密に辿り着く手順 |
| 前方秘匿性(PFS) | 今の鍵が漏れても、過去の通信は守られるという性質 |
| 証明書(X.509) | 「この公開鍵は、この名前の持ち主のものです」と第三者が署名した紙 |
| 認証局(CA) | その署名をする側。ルートCAはOSやブラウザに最初から入っている |
| 暗号スイート | 鍵交換・暗号・ハッシュの組み合わせの名前。TLS_AES_256_GCM_SHA384 など |
① なぜ2種類あるのか — 速度を測ってから話す
まず作業フォルダを作ります。
/home/user/cslab/crypto
openssl が入っているか確認します。
OpenSSL 3.2.4 11 Feb 2025 (Library: OpenSSL 3.2.4 11 Feb 2025)
入っていなければ入れてください。 Ubuntu なら sudo apt install openssl です (sudo と apt の話は本線側にあります)。
共通鍵暗号は、もう十分に速い
先に速度を見ます。 ここを見ないと、この先の話が「なんとなく」で終わります。
The 'numbers' are in 1000s of bytes per second processed.
type 16 bytes 64 bytes 256 bytes 1024 bytes 8192 bytes 16384 bytes
AES-256-GCM 50059.73k 202918.63k 427376.62k 1090889.40k 2571913.04k 2659100.44k
一番右を読みます。 2659100.44k バイト毎秒 = 約 2.6 GB/秒です。
1秒で2.6GBを暗号化できます。 手元のVMの、1コアで、です。 「暗号化すると遅くなる」は、共通鍵に関しては、もう成り立ちません。
公開鍵暗号は、けた違いに遅い
同じコマンドを RSA-2048 に向けます。
sign verify encrypt decrypt sign/s verify/s encr./s decr./s
rsa 2048 bits 0.000798s 0.000033s 0.000037s 0.001086s 1253.0 30560.0 27116.7 921.2
keygen encaps decaps keygens/s encaps/s decaps/s
rsa2048 0.082615s 0.000037s 0.000815s 12.1 27378.2 1227.0
単位が違います。 バイト毎秒ではなく、回数毎秒です。
- 復号は 921 回/秒。1回あたり 1.086 ミリ秒
- 署名は 1253 回/秒。1回あたり 0.798 ミリ秒
- 鍵の生成は 12.1 回/秒。1回に 80ミリ秒もかかっています
そして、RSA の1回で扱えるのは、数百バイトです。
AES は「1秒に2.6GB」、RSA は「1秒に921回、1回あたり数百バイト」。 同じ土俵に載っていません。 使いどころがまったく違う道具です。
同じ量のデータで、正面から比べる
数字を並べただけだと実感しにくいので、同じデータを両方で暗号化して時間を測ります。
import crypto from 'node:crypto';
import { readFileSync } from 'node:fs';
const pub = readFileSync('public.pem', 'utf8');
const priv = readFileSync('private.pem', 'utf8');
// --- ① 同じ 200 バイトを 1000 回、両方で暗号化 ---
const block = Buffer.alloc(200, 'A');
const N = 1000;
let t0 = performance.now();
const boxes = [];
for (let i = 0; i < N; i++) boxes.push(crypto.publicEncrypt(pub, block));
const rsaEnc = performance.now() - t0;
t0 = performance.now();
for (const b of boxes) crypto.privateDecrypt(priv, b);
const rsaDec = performance.now() - t0;
const key = crypto.randomBytes(32);
t0 = performance.now();
for (let i = 0; i < N; i++) {
const iv = crypto.randomBytes(12);
const c = crypto.createCipheriv('aes-256-gcm', key, iv);
Buffer.concat([c.update(block), c.final()]);
}
const aesEnc = performance.now() - t0;
console.log(`RSA-2048 暗号化 ${N}回 : ${rsaEnc.toFixed(0)} ms`);
console.log(`RSA-2048 復号 ${N}回 : ${rsaDec.toFixed(0)} ms`);
console.log(`AES-256 暗号化 ${N}回 : ${aesEnc.toFixed(0)} ms`);
// --- ② 1MB を AES で暗号化 ---
const big = crypto.randomBytes(1024 * 1024);
t0 = performance.now();
const iv = crypto.randomBytes(12);
const c = crypto.createCipheriv('aes-256-gcm', key, iv);
Buffer.concat([c.update(big), c.final()]);
const aesBig = performance.now() - t0;
console.log(`AES-256 で 1MB : ${aesBig.toFixed(1)} ms`);
// --- ③ 同じ 1MB を RSA だけでやったら何秒かかるか ---
const chunks = Math.ceil(1024 * 1024 / 200);
const rsaBig = (rsaEnc / N) * chunks;
console.log(`RSA だけで 1MB : ${(rsaBig / 1000).toFixed(1)} 秒 (200バイト x ${chunks}回)`);
console.log(`差 : ${(rsaBig / aesBig).toFixed(0)} 倍`);
このスクリプトは public.pem と private.pem を読みます。 それは②で作るので、 ②を先にやってから戻ってきてください。 ここでは結果だけ先に出します。
RSA-2048 暗号化 1000回 : 299 ms
RSA-2048 復号 1000回 : 2229 ms
AES-256 暗号化 1000回 : 17 ms
AES-256 で 1MB : 1.0 ms
RSA だけで 1MB : 1.6 秒 (200バイト x 5243回)
差 : 1606 倍
1MBを守るのに、AES なら 1.0ミリ秒、RSA だけでやると 1.6秒。
1600倍です。 公開鍵暗号で本文を暗号化する設計は、この時点で成立しません。 1MBの画像を1枚送るたびに1.6秒かかるサイトを、誰も使いません。
では、公開鍵は何のためにあるのか
共通鍵は速い。ならそれだけでいいはずです。 ところが、1つだけどうしても解けない問題が残ります。
その共通鍵を、どうやって相手に渡すのか。
初めて繋ぐ相手です。事前に会って鍵を手渡していません。渡す道は、これから守ろうとしている、その回線しかありません。 鍵をそのまま流したら、暗号化する意味がありません。
公開鍵暗号は、この1点だけを解く道具です。
| 共通鍵暗号(AES) | 公開鍵暗号(RSA / EC) | |
|---|---|---|
| 鍵 | 1つを両者が持つ | 2つで1組。片方は公開してよい |
| 速度 | 2.6 GB/秒 | 921 回/秒(1回数百バイト) |
| 扱えるデータ量 | いくらでも | 鍵長より短いものだけ |
| 解ける問題 | 本文を隠す | 鍵の受け渡しと、身元の証明 |
| 実際の役割 | 通信の中身を全部これで守る | 最初の一瞬だけ使う |
この組み合わせをハイブリッド暗号と言います。 TLS も、SSH も、暗号化メールも、全部この形です。
[最初の一瞬] 公開鍵の仕組みで、共通鍵を安全に決める ← 遅いが、1回だけ
↓
[あとは全部] 決まった共通鍵で、本文を暗号化する ← 速い、何GBでも
「遅いから使えない」ではなく、「遅いから最初の一瞬だけ使う」。 ここが設計の全部です。
② 鍵ペアを作って、中身を見る
話はここまでにして、実際に作ります。
..+.........+..........+++++++++++++++++++++++++++++++++++++++*........+..+...+.+
...........+++++++++++++++++++++++++++++++++++++++*...+......+.........+........
....+........+.+...+..+.........+...............+.+......+..............++++++
....+...+.....+....+...+...+++++++++++++++++++++++++++++++++++++++*...+..+......
.+++++++++++++++++++++++++++++++++++++++*...+...+......+.....+....+...+....++++++
この点と + の羅列はエラーではありません。 素数を探している途中経過です。 . は「素数の候補を1つ作った」、+ は「素数判定を1回通った」、* は「素数が1つ見つかった」の目安です(細かな意味は OpenSSL の版や鍵の作り方によって異なります)。①で keygen 12.1回/秒 と出たのは、この作業です。
できたファイルを見ます。
-rw-r--r-- 1 user user 1732 Oct 4 10:22 private.pem
-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC4DA2LjjdxG0Hj
3aCKl6MVUeypbdq46AtByOtrfnY1UDZfqu+/luU+YleI4uF0/JEJYbRCMV2eQU6t
これは暗号文ではありません。 Base64 で書かれたただのデータです。 このテキストを手に入れた人は、そのまま秘密鍵として使えます。
公開鍵は、秘密鍵から作る
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuAwNi443cRtB492gipej
FVHsqW3auOgLQcjra352NVA2X6rvv5blPmJXiOLhdPyRCWG0QjFdnkFOrfaPS+gl
eRumkETpB+mLDDSrwIanWaQSZEkUvPsjoScjZW2I//yFtVCa9sIiyYIZ+CvcOSSf
P2MDx6cyhsX2KwfYLAf9upOTQWbggCSD/Nqf7oXjeaL/vaLYMk2oiPU/5MXimyJf
vsedKJzg1Ayv5mX2+IsrV7Dv62XA4ouWLfVvF8PMbUEPTeWJqbxAMFiVWW/MHGQA
2OxBA4h8kX1SMulfwcvacVKO0KHBYx7fp6nF4wHgeVpfhfKHCaeaebLPj5o3urMs
KQIDAQAB
-----END PUBLIC KEY-----
公開鍵は秘密鍵から作れます。逆はできません。 ここが公開鍵暗号の非対称性です。 だから公開鍵はどこに貼っても構いません。 GitHub にも置けます(SSH鍵がまさにそれです)。
中身をテキストで見る
Base64 のままでは何も分かりません。 中を開きます。
Private-Key: (2048 bit, 2 primes)
modulus:
00:b8:0c:0d:8b:8e:37:71:1b:41:e3:dd:a0:8a:97:
a3:15:51:ec:a9:6d:da:b8:e8:0b:41:c8:eb:6b:7e:
76:35:50:36:5f:aa:ef:bf:96:e5:3e:62:57:88:e2:
e1:74:fc:91:09:61:b4:42:31:5d:9e:41:4e:ad:f6:
8f:4b:e8:25:79:1b:a6:90:44:e9:07:e9:8b:0c:34:
ab:c0:86:a7:59:a4:12:64:49:14:bc:fb:23:a1:27:
23:65:6d:88:ff:fc:85:b5:50:9a:f6:c2:22:c9:82:
19:f8:2b:dc:39:24:9f:3f:63:03:c7:a7:32:86:c5:
f6:2b:07:d8:2c:07:fd:ba:93:93:41:66:e0:80:24:
83:fc:da:9f:ee:85:e3:79:a2:ff:bd:a2:d8:32:4d:
a8:88:f5:3f:e4:c5:e2:9b:22:5f:be:c7:9d:28:9c:
e0:d4:0c:af:e6:65:f6:f8:8b:2b:57:b0:ef:eb:65:
c0:e2:8b:96:2d:f5:6f:17:c3:cc:6d:41:0f:4d:e5:
89:a9:bc:40:30:58:95:59:6f:cc:1c:64:00:d8:ec:
41:03:88:7c:91:7d:52:32:e9:5f:c1:cb:da:71:52:
8e:d0:a1:c1:63:1e:df:a7:a9:c5:e3:01:e0:79:5a:
5f:85:f2:87:09:a7:9a:79:b2:cf:8f:9a:37:ba:b3:
2c:29
modulus の行数を数えると 17行 × 15バイト前後 = 256バイト。 256バイト = 2048ビットです。
「RSA 2048ビット」の 2048 は、この数の長さです。 秘密鍵ファイルの大きさ(1732バイト)ではありません。 ここでは head -20 で切りましたが、続きには privateExponent(秘密の指数)や prime1 / prime2(元の2つの素数) が並んでいます。
公開鍵のほうも同じように開けます。
2c:29
Exponent: 65537 (0x10001)
公開鍵には modulus と Exponent(65537)しか入っていません。 秘密鍵にあった prime1 / prime2 がありません。この2つの素数を知っているかどうかが、秘密鍵と公開鍵の差です。
秘密鍵の権限を 600 にする
ここは必ずやります。
-rw-r--r-- 1 user user 1732 Oct 4 10:22 private.pem
-rw------- 1 user user 1732 Oct 4 10:22 private.pem
-rw-r--r--(644)は「同じサーバーの他のユーザーが読める」という意味です。 1台のサーバーに複数のアプリを載せていたら、隣のアプリから秘密鍵が読めます。
rwx と数字の読み方は Permission denied の正体 — rwxと755を読めるようにする にあります。
公開鍵は 644 のままで構いません。 むしろ読めないと配れません。
| ファイル | 権限 | 理由 |
|---|---|---|
private.pem(秘密鍵) | 600 | 自分だけが読める。 漏れたら全部終わる |
public.pem(公開鍵) | 644 | 配るためのもの。 読めてよい |
*.crt(証明書) | 644 | 証明書は公開鍵が入った公開情報。 隠す意味がない |
📸 スクリーンショット1:
openssl pkey -in private.pem -text -noout | head -20の出力と、chmod 600の前後でls -lが-rw-r--r--から-rw-------に変わっているところ
③ 暗号化と復号を、自分でやる
では、公開鍵で閉めて、秘密鍵で開けます。
口座番号は 1234-5678 です
公開鍵で暗号化します。
-rw-r--r-- 1 user user 256 Oct 4 10:22 secret.enc
-rw-r--r-- 1 user user 33 Oct 4 10:22 secret.txt
33バイトの平文が、256バイトになりました。 これは偶然ではありません。 RSA の出力は、常に鍵長ちょうど(2048ビット = 256バイト)です。
中を見ます。
00000000: aa44 8d59 9e30 9c3b 32bd f2f8 55f7 0939 .D.Y.0.;2...U..9
00000010: 4e12 c160 93f3 8f40 eaff d206 a9ce b48c N..`...@........
00000020: 7c5e e9e7 831b f572 0564 571e b770 6132 |^.....r.dW..pa2
00000030: 7c9f fb66 a7ba 0022 a75f c98d ed18 61ec |..f..."._....a.
乱数と区別が付きません。 これが正しい状態です。
秘密鍵で開けます。
口座番号は 1234-5678 です
戻りました。
同じ平文を2回暗号化すると、違う暗号文になる
ここは意外だったところです。
00000000: 9acf 0bc7 3e57 8536 f6fd 3016 13e4 348c ....>W.6..0...4.
00000010: 57ab 8b26 9ea6 a95a a2b6 0cb8 b60a 3a73 W..&...Z......:s
---
00000000: 2337 685c c601 577a 8a6c ceda cfdb cc6e #7h\..Wz.l.....n
00000010: 7a87 e512 db9d 428e f63d dc63 5978 d15a z.....B..=.cYx.Z
---
e1.bin e2.bin differ: char 1, line 1
exit=1
同じ鍵、同じ平文なのに、まったく違うものが出ました。
これは正しい動作です。 暗号化するとき、平文の前に毎回違う乱数を混ぜてから計算しています(パディング)。 もし毎回同じ暗号文が出るなら、「同じ内容が送られた」ことが外から分かってしまいます。 中身は分からなくても、「昨日と同じ返事だ」が分かるだけで情報です。
だから、テストは「暗号文が期待値と一致するか」ではなく「復号して元に戻るか」で書きます。
逆はできない
公開鍵で復号しようとしてみます。
A private key is needed for this operation
pkeyutl: Error initializing context
exit=1
きっぱり断られました。 公開鍵は「閉める専用」です。 だから、公開鍵をばらまいても、暗号文は読まれません。 これが「公開してよい鍵」の意味です。
長いデータは、そもそも暗号化できない
ここが今日いちばん大事なエラーです。 500バイトのファイルを作って、投げます。
-rw-r--r-- 1 user user 500 Oct 4 10:22 big.bin
Public Key operation error
806D0000:error:0200006E:rsa routines:ossl_rsa_padding_add_PKCS1_type_2_ex:data too large for key size:../crypto/rsa/rsa_pk1.c:133:
exit=1
data too large for key size— データが鍵の大きさに対して大きすぎる。
500バイトが入りませんでした。 2048ビット鍵の入れ物は256バイトで、 そこからパディング(乱数)11バイト以上を引くので、実際に入るのは245バイトまでです。
これは実装の都合ではなく、RSA という仕組みそのものの制約です。 「大きい数を、決まった大きさの数で割った余りを計算する」演算なので、元の数が大きいと入りません。
鍵長を4096ビットに上げても、入るのは500バイト程度です。 根本的に足りません。
だから、封筒に入れる(ハイブリッド)
やり方は単純です。
1. 使い捨ての共通鍵(AES 256ビット = 32バイト)を、乱数で作る
2. 本文は、その共通鍵で暗号化する ← 何MBでもよい、速い
3. その共通鍵「だけ」を、相手の公開鍵で暗号化する ← 32バイトなので RSA に入る
4. 「暗号化した本文」と「暗号化した鍵」を一緒に送る
やってみます。
677 big.txt
① 使い捨ての共通鍵を作る
-rw-r--r-- 1 user user 32 Oct 4 10:25 aes.key
② 本文をその鍵で暗号化する
-rw-r--r-- 1 user user 704 Oct 4 10:25 big.enc
-rw-r--r-- 1 user user 677 Oct 4 10:25 big.txt
677バイトが704バイトになっただけです。 少し前に RSA が拒否した500バイトが、平気で通りました。 共通鍵暗号には長さの上限がありません。
③ 共通鍵だけを、公開鍵で暗号化する
-rw-r--r-- 1 user user 256 Oct 4 10:25 aes.key.enc
32バイトなので、余裕で入りました。
④ 受け取る側は、逆をやる
鍵が復元できた
本文が復元できた
これがハイブリッド暗号です。 TLS も、SSH も、暗号化メールも、やっていることはこの4手順です。 公開鍵は「32バイトの鍵を渡すため」にしか使っていません。 ①で測った 1600倍の差は、この32バイトの分にしかかかりません。
ただし、これを自分で書いて本番に載せてはいけません。 上の4手順には、実は 「鍵をそのまま使わずに導出する」「本文が改ざんされていないことを確かめる」といった要素が抜けています。 本番では TLS を使ってください。 ここでやったのは中で何が起きているかを見るためです。
④ 署名は暗号化ではない
私が長いこと混ぜていたのがここです。
「秘密鍵で暗号化すると署名になる」と説明されることがあります。この言い方は、理解を壊します。
署名は、中身を隠しません。 署名しても、元のファイルは平文のままです。署名は別のファイルとして横に付きます。 保証するのは「本人が書いた」「1バイトも変わっていない」の2つだけです。
やってみます。
transfer 1000 yen to alice
秘密鍵で署名します。
-rw-r--r-- 1 user user 256 Oct 4 10:22 pay.sig
-rw-r--r-- 1 user user 27 Oct 4 10:22 pay.txt
pay.txt は27バイトのままです。 中身を見ます。
transfer 1000 yen to alice
平文のままです。 署名は pay.sig という別ファイルになりました。
公開鍵で検証します。
Verified OK
1バイト書き換えると、落ちる
10バイト目の 1 を 9 に変えます。 金額が 1000 円から 9000 円になります。
transfer 1000 yen to alice
transfer 9000 yen to alice
10 61 71
cmp -l の出力は「10バイト目だけが違う」という意味です(8進数で 61 は 1、71 は 9)。 変えたのは1バイトだけです。
同じ署名で検証します。
Verification failure
280E0000:error:02000068:rsa routines:ossl_rsa_verify:bad signature:../crypto/rsa/rsa_sign.c:426:
280E0000:error:1C880004:Provider routines:rsa_verify:RSA lib:../providers/implementations/signature/rsa_sig.c:801:
exit=1
落ちました。 1バイト変わっただけで、検証は通りません。
理由はハッシュを見れば分かります。
93cc57c16e3b591835995dcf1367fddb9e430316d378f0f39b6c18c1227ac7d9 pay.txt
603fdd0aef559383a44abbf578c44c2c6cced7b58a94489ecee71f7aec832a5d pay2.txt
1バイト違うだけで、まったく別の値になりました。 似てすらいません。
署名がやっていることは、こうです。
[署名する側]
本文 → SHA-256 でハッシュ(32バイト)→ 秘密鍵で処理 → 署名ファイル
[検証する側]
本文 → SHA-256 でハッシュ(32バイト)→ ┐
署名ファイル → 公開鍵で処理 → ハッシュ → 一致するか比べる
署名しているのは本文ではなく、本文のハッシュ(32バイト)です。 だから ③で見た245バイト制限に引っかかりません。 どんなに大きいファイルでも署名できます。
そして、ハッシュが1ビットでも変われば、署名は合いません。
署名と暗号化を、表で分ける
| 暗号化 | 署名 | |
|---|---|---|
| 使う鍵(作る側) | 相手の公開鍵 | 自分の秘密鍵 |
| 使う鍵(受ける側) | 自分の秘密鍵 | 相手の公開鍵 |
| 中身は隠れるか | 隠れる | 隠れない。平文のまま |
| 何を保証するか | 第三者に読まれない | 本人が書いた + 改ざんされていない |
| 誰でもできるか | 公開鍵があれば誰でも暗号化できる | 秘密鍵を持つ本人しか作れない |
| 扱えるデータ量 | 245バイトまで | いくらでも(ハッシュに潰すから) |
これ、毎日使っています
署名は、特別な場面の技術ではありません。 開発をしていると毎日通っています。
| 場面 | 誰が署名し、誰が検証しているか |
|---|---|
apt install | 配布元がパッケージに署名し、apt が検証している。 だから改ざんに気付ける |
| Git のコミット署名 | 書いた人が秘密鍵で署名し、GitHub が公開鍵で検証して Verified を出す |
npm のパッケージ | レジストリが署名し、インストール時に整合性を確かめる |
| JWT | 発行したサーバーが署名し、受け取ったサーバーが検証する。 中身は隠れていない |
| TLS のハンドシェイク | サーバーが「この鍵交換は自分がやった」ことを署名で示す |
| OSのアップデート | 配布元が署名し、OSが検証してから適用する |
JWT のところは大事です。 JWT のペイロードは Base64 で書いてあるだけで、誰でも読めます。 署名は「改ざんされていない」ことしか言っていません。JWT にパスワードや機微な情報を入れてはいけません。
RSA だけではない — Ed25519 も試す
署名専用なら、もっと小さくて速い方式があります。
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAZQIyb38RK3c6Rp+jcIt5mdubX10GqCCNzjJPoXzJOZU=
-----END PUBLIC KEY-----
RSA の公開鍵が7行あったのに対して、1行です。
ED25519 Private-Key:
priv:
c4:d8:72:aa:d3:1d:06:cb:67:de:ff:e1:da:06:6c:
cf:28:38:f9:9c:0d:17:73:fc:91:d2:b0:e8:35:94:
b6:19
pub:
65:02:32:6f:7f:11:2b:77:3a:46:9f:a3:70:8b:79:
99:db:9b:5f:5d:06:a8:20:8d:ce:32:4f:a1:7c:c9:
39:95
秘密鍵32バイト、公開鍵32バイト。 RSA の 256バイトに対して8分の1です。
-rw-r--r-- 1 user user 256 Oct 4 10:22 pay.sig
-rw-r--r-- 1 user user 64 Oct 4 10:25 pay.ed.sig
Signature Verified Successfully
署名も 256バイト → 64バイト。 しかも生成は RSA より速いです。
sign verify sign/s verify/s
256 bits ecdsa (nistp256) 0.0000s 0.0001s 29482.1 10796.1
sign verify sign/s verify/s
253 bits EdDSA (Ed25519) 0.0001s 0.0002s 18797.4 4048.5
RSA-2048 の署名が 1253回/秒だったのに対して、ECDSA は 29482回/秒。 23倍です。
これから新しく鍵を作るなら、Ed25519 か ECDSA(P-256) を選んでください。 短く、速く、強度も足ります。RSA は、相手が対応していないときの互換用と考えて構いません。
⑤ 鍵交換 — 鍵そのものを送らずに、同じ秘密に辿り着く
③のハイブリッドには、まだ弱いところがあります。
共通鍵を「公開鍵で包んで送る」やり方だと、秘密鍵が漏れた瞬間、過去の通信も全部読めます。 記録しておいた通信を、あとで開けられるからです。
それを断ち切るのが鍵交換です。
鍵を送りません。 両者が別々に計算して、同じ値に辿り着きます。 回線に流れるのは、そこから元の秘密を割り出せない値だけです。
小さい数で、紙の計算のようにやる
言葉だと信じられないので、実際に計算します。
// 小さい数で「鍵を送らずに同じ秘密に辿り着く」を確かめる
const p = 23; // みんなに公開されている素数
const g = 5; // みんなに公開されている数
const powMod = (b, e, m) => {
let r = 1n; b = BigInt(b); e = BigInt(e); m = BigInt(m);
while (e > 0n) { if (e & 1n) r = r * b % m; b = b * b % m; e >>= 1n; }
return Number(r);
};
const a = 6; // Aliceだけが知っている(外に出ない)
const b = 15; // Bobだけが知っている(外に出ない)
const A = powMod(g, a, p); // Alice が回線に流す値
const B = powMod(g, b, p); // Bob が回線に流す値
console.log('公開されている値 : p =', p, ', g =', g);
console.log('Alice の秘密 a :', a, '(送らない)');
console.log('Bob の秘密 b :', b, '(送らない)');
console.log('Alice が送る A = g^a mod p :', A);
console.log('Bob が送る B = g^b mod p :', B);
const sAlice = powMod(B, a, p);
const sBob = powMod(A, b, p);
console.log('Alice の計算 B^a mod p :', sAlice);
console.log('Bob の計算 A^b mod p :', sBob);
console.log('一致したか :', sAlice === sBob);
console.log('回線に流れたのは : p, g, A, B の4つだけ');
公開されている値 : p = 23 , g = 5
Alice の秘密 a : 6 (送らない)
Bob の秘密 b : 15 (送らない)
Alice が送る A = g^a mod p : 8
Bob が送る B = g^b mod p : 19
Alice の計算 B^a mod p : 2
Bob の計算 A^b mod p : 2
一致したか : true
回線に流れたのは : p, g, A, B の4つだけ
両方とも 2 に辿り着きました。
2 は回線に一度も流れていません。 流れたのは 23, 5, 8, 19 の4つだけです。
なぜ一致するのかは、式を並べると1行です。
Alice の計算: B^a mod p = (g^b)^a mod p = g^(b*a) mod p
Bob の計算: A^b mod p = (g^a)^b mod p = g^(a*b) mod p
⚠️ 指数の掛け算は順番を入れ替えられる → 同じ値
そして、A = 8 から a = 6 を求める作業は、数が大きくなると現実的な時間で終わりません。 これが安全性の根拠です。「絶対にできない」ではなく「現実的な時間では終わらない」です。
p = 23 は説明用です。 本物は2048ビット以上か、楕円曲線を使います。この数字を実運用に使ってはいけません。
本物の鍵交換を、Node.js で
import crypto from 'node:crypto';
const alice = crypto.createECDH('prime256v1'); const A = alice.generateKeys();
const bob = crypto.createECDH('prime256v1'); const B = bob.generateKeys();
const sA = alice.computeSecret(B);
const sB = bob.computeSecret(A);
console.log('Alice が送る公開値 :', A.toString('hex').slice(0, 32), '... (' + A.length + ' バイト)');
console.log('Bob が送る公開値 :', B.toString('hex').slice(0, 32), '... (' + B.length + ' バイト)');
console.log('Alice の共有秘密 :', sA.toString('hex'));
console.log('Bob の共有秘密 :', sB.toString('hex'));
console.log('一致したか :', sA.equals(sB));
// ⚠️ 共有秘密をそのまま鍵に使わず、鍵導出関数に通す
const k = crypto.hkdfSync('sha256', sA, Buffer.alloc(0), Buffer.from('tls session'), 32);
console.log('導出したセッション鍵:', Buffer.from(k).toString('hex'));
Alice が送る公開値 : 04bdc96dbde4b8c8ab6a277aa85a41ff ... (65 バイト)
Bob が送る公開値 : 045cd952f9242d9fcbb3e5ef95beeaec ... (65 バイト)
Alice の共有秘密 : 4d23c1285ad355cb3a1113eee623800ce10de7877bc3dd66129d9d582d906025
Bob の共有秘密 : 4d23c1285ad355cb3a1113eee623800ce10de7877bc3dd66129d9d582d906025
一致したか : true
導出したセッション鍵: d1f46fbe57a7acea53bfd72502d94c4aeefed9ae4d10c7dea2049503ff64c04f
65バイトずつ交換しただけで、32バイトの共通鍵ができました。
最後の hkdfSync は飛ばしてはいけない工程です。 共有秘密をそのまま AES の鍵にすると、 数学的な偏りがそのまま鍵に乗ります。ハッシュを通して均すのが鍵導出関数(HKDF)です。
前方秘匿性 — これが得られる最大の利点
接続のたびにこの鍵交換をやり直すと、こうなります。
| やり方 | サーバーの秘密鍵が漏れたら |
|---|---|
| ③のように公開鍵で共通鍵を包んで送る | 記録されていた過去の通信が、すべて開けられる |
| 接続のたびに鍵交換する(ECDHE) | 過去の通信は開けられない。 使い捨ての秘密は誰も保存していない |
前方秘匿性(Forward Secrecy) は、今の鍵が漏れても、過去は守られるという性質です。
ECDHEの最後のEは ephemeral(使い捨て) の E です。ここが付いているかどうかが分かれ目です。
TLS 1.3 では、前方秘匿性のない方式が仕様から消えました。 「選べるようにしておくと、いつか間違って選ぶ」からです。選択肢を削るのも設計です。
⑥ 証明書は「暗号」ではなく「身元の保証」
ここまで、証明書は一度も出てきていません。 それでも暗号化も署名も鍵交換もできました。
暗号化は、証明書が無くてもできます。 証明書がやるのは 「この公開鍵は、本当にその名前の相手のものか」 の保証だけです。
それが無いと何が困るか。 ⑤の鍵交換で、Bob だと思って公開値を交換した相手が、本当に Bob なのか、 鍵交換の手順そのものには、それを確かめる仕組みがありません。
証明書は、その1点を埋めるためだけに存在します。
自己署名証明書を作る
(何も出なければ成功です)
中身を読みます。
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
66:7e:a4:df:8e:ad:f0:dd:49:84:f2:87:62:e4:87:49:5f:63:3f:bb
Signature Algorithm: sha256WithRSAEncryption
Issuer: C=JP, ST=Tokyo, O=obmes-lab, CN=localhost
Validity
Not Before: Sep 4 01:24:11 2026 GMT
Not After : Oct 4 01:24:11 2026 GMT
Subject: C=JP, ST=Tokyo, O=obmes-lab, CN=localhost
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
読むべきところは4つです。
| 項目 | 意味 |
|---|---|
| Issuer(発行者) | この証明書に署名した人 |
| Subject(主体者) | この証明書が「この人のものだ」と言っている相手 |
| Validity | 有効期間。 Not Before から Not After まで |
| Subject Public Key Info | 中身は結局、②で作った公開鍵 |
IssuerとSubjectが同じです。 自分で自分を「これは自分です」と保証しています。 これが「自己署名」の意味です。 ブラウザが怒っているのは、まさにここです。
拡張領域も見ます。
X509v3 extensions:
X509v3 Subject Key Identifier:
54:87:BB:A8:7E:64:85:26:C1:23:80:53:0C:56:95:43:21:AF:00:2C
X509v3 Authority Key Identifier:
54:87:BB:A8:7E:64:85:26:C1:23:80:53:0C:56:95:43:21:AF:00:2C
X509v3 Basic Constraints: critical
CA:TRUE
X509v3 Subject Alternative Name:
DNS:localhost, IP Address:127.0.0.1
Signature Algorithm: sha256WithRSAEncryption
Subject Alternative Name(SAN)が、いま名前の照合に使われている場所です。 昔は CN=localhost が使われましたが、今のブラウザは CN を見ません。 SAN に書いていないホスト名は、証明書があっても一致しません。
Subject Key Identifier と Authority Key Identifier が同じ値なのも、自己署名だからです。
短くまとめて見たいときは、こちらのほうが実務的です。
subject=C=JP, ST=Tokyo, O=obmes-lab, CN=localhost
issuer=C=JP, ST=Tokyo, O=obmes-lab, CN=localhost
notBefore=Sep 4 01:24:11 2026 GMT
notAfter=Oct 4 01:24:11 2026 GMT
sha256 Fingerprint=FA:01:4E:E6:CF:D2:03:72:83:7C:A6:B4:BC:C6:99:8B:A0:77:69:6D:23:16:D6:69:3B:E5:52:BF:34:8E:30:54
notAfter を見る癖を付けてください。 障害の原因として、証明書の期限切れは今も上位です。
信頼の連鎖 — なぜ他人の証明書は警告が出ないのか
私がずっと分からなかったのはここです。
[ルートCA証明書] ← ⚠️ OS・ブラウザに最初から入っている。ここが出発点
↓ 署名する
[中間CA証明書] ← 実際に発行の仕事をする
↓ 署名する
[サーバー証明書] ← あなたのサイトの証明書
ブラウザは「サーバー証明書」を直接は信頼していません。 「自分が最初から知っているルートCAまで、署名の鎖が繋がるか」を辿ります。
- 繋がった → 鍵マーク
- 繋がらなかった(=出発点が自分の知らない人) → 警告
自己署名証明書は、鎖が1段しかなく、その1段が「知らない人」です。 だから警告が出ます。
警告は「暗号が弱い」と言っていません。 「誰が保証したのか分からない」と言っています。通信は暗号化されています。
自分だけのCAを作って、鎖を繋いでみる
言葉で終わらせず、実際に鎖を作ります。
① ルートCA用の鍵と証明書
② サーバー用の鍵と、署名依頼書(CSR)
Certificate Request:
Data:
Version: 1 (0x0)
Subject: C=JP, O=obmes-lab, CN=localhost
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
CSR には公開鍵しか入っていません。 秘密鍵はサーバーから一歩も出ません。 Let’s Encrypt などに送るのも、この CSR です。秘密鍵を送るのではありません。
③ CAが署名する
Certificate request self-signature ok
subject=C=JP, O=obmes-lab, CN=localhost
④ 鎖が繋がったか確かめる
subject=C=JP, O=obmes-lab, CN=localhost
issuer=C=JP, O=obmes-lab, CN=obmes-lab Root CA
notBefore=Sep 4 01:25:09 2026 GMT
notAfter=Dec 3 01:25:09 2026 GMT
Issuer と Subject が違います。 自己署名ではなくなりました。
site.crt: OK
OK が出ました。 これは「ca.crt を信頼するなら、site.crt も信頼できる」という意味です。
ここが本物のCAとの唯一の差です。 本物のルートCAはOSに最初から入っています。 いま作った ca.crt は、この機械にしか無いので、他の人のブラウザでは繋がりません。
社内やVM内の検証環境なら、これで十分です。 インターネットに出すサイトでは、Let’s Encrypt のような無料の公的CAを使ってください。 自己署名を配って「警告を無視して」と案内するのは、「警告を無視する習慣」を教えることになります。
📸 スクリーンショット2:
openssl x509 -in server.crt -noout -subject -issuerで Issuer と Subject が同じなのと、site.crtで違うのを並べたところ。 その下にopenssl verify -CAfile ca.crt site.crtのOK
手元で立てたHTTPSサーバーと違い、公開するサイトには認証局が署名した証明書が要ります。XServer SSL
は無料のLet’s Encryptから、クラウドSSL(880円〜1,100円/年、2026-11時点、税込)、企業認証(OV)・EVまでを扱っており、ドメイン認証SSLは最短即時発行とされています。多くのレンタルサーバーは無料SSLを標準で付けているので、個人サイトなら有料の証明書が要らない場合もあります。
⑦ TLS のハンドシェイクを、自分のサーバーで見る
ここまで作った部品が、全部一度に動くところを見ます。
自分でHTTPSサーバーを立てる
import https from 'node:https';
import { readFileSync } from 'node:fs';
const server = https.createServer({
key: readFileSync('site.key'),
cert: readFileSync('site.crt'),
minVersion: 'TLSv1.2', // ⚠️ TLS 1.1 以下は受け付けない
}, (req, res) => {
const s = req.socket;
res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
res.end(`protocol: ${s.getProtocol()}\ncipher: ${s.getCipher().name}\n`);
});
server.on('secureConnection', (s) => {
console.log('接続:', s.getProtocol(), s.getCipher().name);
});
// ⚠️ 127.0.0.1 に縛る。外からは繋がらない
server.listen(8443, '127.0.0.1', () => console.log('https://127.0.0.1:8443 で待機中'));
server.listen(8443, '127.0.0.1', ...) の第2引数を必ず書いてください。 省くとVMの外からも繋がります。 実験用のサーバーは自分の中だけに閉じます。
別のターミナルで起動します。
https://127.0.0.1:8443 で待機中
まず、素直に繋いでみる
元のターミナルに戻って、curl を打ちます。
curl: (60) SSL certificate problem: unable to get local issuer certificate
More details here: https://curl.se/docs/sslcerts.html
拒否されました。 ⑥で作った ca.crt は、curl の信頼リストに入っていないからです。
CAを渡すと、通ります。
protocol: TLSv1.3
cipher: TLS_AES_256_GCM_SHA384
-kで警告を潰すのではなく、--cacertで「このCAは信頼する」と明示しました。 やっていることが違います。-kは検証そのものを止めます。 本番のスクリプトに-kを書かないでください。 検証が要らないなら HTTPS にする意味がありません。
ハンドシェイクを、s_client で覗く
Connecting to 127.0.0.1
CONNECTED(00000170)
depth=1 C=JP, O=obmes-lab, CN=obmes-lab Root CA
verify return:1
depth=0 C=JP, O=obmes-lab, CN=localhost
verify return:1
---
Certificate chain
0 s:C=JP, O=obmes-lab, CN=localhost
i:C=JP, O=obmes-lab, CN=obmes-lab Root CA
a:PKEY: rsaEncryption, 2048 (bit); sigalg: RSA-SHA256
v:NotBefore: Sep 4 01:25:09 2026 GMT; NotAfter: Dec 3 01:25:09 2026 GMT
---
Server certificate
-----BEGIN CERTIFICATE-----
MIIDhzCCAm+gAwIBAgIUZn6k346t8N1JhPKHYuSHSV9jP7swDQYJKoZIhvcNAQEL
BQAwRTELMAkGA1UEBhMCSlAxDjAMBgNVBAgMBVRva3lvMRIwEAYDVQQKDAlvYm1l
cy1sYWIxEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yNjA5MDQwMTI0MTFaFw0yNjEw
読み方は3行だけです。
s:は subject(この証明書の持ち主)i:は issuer(署名した人)depth=1→depth=0は ルートから順に鎖を辿っているということ
CAを渡さないと、こうなります。
Connecting to 127.0.0.1
CONNECTED(00000170)
depth=0 C=JP, O=obmes-lab, CN=localhost
verify error:num=20:unable to get local issuer certificate
verify return:1
depth=0 C=JP, O=obmes-lab, CN=localhost
unable to get local issuer certificate は「署名した人の証明書が手元に無い」という意味です。 本番でこのエラーが出たら、中間CA証明書をサーバーに置き忘れていることがほとんどです。 ブラウザでは繋がるのにスマホアプリでは繋がらない、という形で出ます。
結果の要点だけを見る
Server Temp Key: X25519, 253 bits
SSL handshake has read 1463 bytes and written 404 bytes
Protocol : TLSv1.3
Cipher : TLS_AES_256_GCM_SHA384
Verify return code: 0 (ok)
この5行に、今日の全部が入っています。
| 行 | 対応する節 |
|---|---|
Server Temp Key: X25519 | ⑤の鍵交換。 Temp(使い捨て)なので前方秘匿性がある |
Protocol : TLSv1.3 | 使われたプロトコル版 |
Cipher : TLS_AES_256_GCM_SHA384 | ①の共通鍵暗号(AES-256)。本文はこれで守られている |
Verify return code: 0 (ok) | ⑥の証明書の検証が通った |
Cipher に AES と書いてあります。RSA ではありません。 RSA が使われたのは、サーバーが「この鍵交換は自分がやった」と署名した一瞬だけです。
TLS 1.2 と 1.3 を比べる
同じサーバーに、1.2 を指定して繋ぎます。
SSL handshake has read 1564 bytes and written 287 bytes
Protocol : TLSv1.2
Cipher : ECDHE-RSA-AES128-GCM-SHA256
暗号スイートの名前の形が違います。
| TLS 1.2 | TLS 1.3 | |
|---|---|---|
| 名前 | ECDHE-RSA-AES128-GCM-SHA256 | TLS_AES_256_GCM_SHA384 |
| 何が書いてあるか | 鍵交換 + 署名 + 暗号 + ハッシュの4つ | 暗号 + ハッシュの2つだけ |
| 鍵交換の選択 | スイートごとに決まる | 別枠。前方秘匿性のあるものしか無い |
| ハンドシェイクの往復 | 2往復 | 1往復 |
| 使えるスイートの数 | 数十種類(古いものも混ざる) | 5種類だけ |
TLS 1.3 の名前が短いのは、選べるものを減らしたからです。 1.2 には「選べてしまうけれど選んではいけない組み合わせ」がありました。 1.3 はそれを仕様から消しました。 設定ミスの余地を潰すのが、いちばん確実な守り方です。
往復が1回減ると、遅い回線ほど効きます。 地球の裏側との往復が200msなら、接続が200ms速くなります。
古い版を、ちゃんと断れているか確かめる
minVersion: 'TLSv1.2' が効いているかを見ます。
Connecting to 127.0.0.1
CONNECTED(00000178)
60630000:error:0A0000BF:SSL routines:tls_setup_handshake:no protocols available
---
繋がりませんでした。 no protocols available は「共通で使える版が無い」という意味ですが、手元の OpenSSL 3 が TLS 1.1 を使えないだけでも出るので、断れている証拠にはなりません。-cipher 'DEFAULT@SECLEVEL=0' を付けて、サーバーから tlsv1 alert protocol version が返ることで確かめます。
サーバー側のターミナルのログも見ます。
https://127.0.0.1:8443 で待機中
接続: TLSv1.3 TLS_AES_256_GCM_SHA384
接続: TLSv1.3 TLS_AES_256_GCM_SHA384
接続: TLSv1.2 ECDHE-RSA-AES128-GCM-SHA256
TLS 1.1 の試行はログに1行も出ていません。 このログは secureConnection(ハンドシェイクが成立した接続)でしか出さないので、失敗した試行はどれも出ません。no protocols available のときは、手元の OpenSSL が ClientHello を送る前に止まっていて、サーバーには TCP の接続しか届いていません。-cipher 'DEFAULT@SECLEVEL=0' を付ければサーバーまで届いて断られますが、それもこのログには出ません。
本線側の HTTPS の話は DNSとHTTPSを自分のドメインで確かめる — 未経験の1歩目 にあります。
📸 スクリーンショット3:
openssl s_clientの出力から、Server Temp Key: X25519/Protocol : TLSv1.3/Cipher : TLS_AES_256_GCM_SHA384/Verify return code: 0 (ok)の4行が並んでいるところ
⑧ 守る側のチェックリスト
ここから先は「防ぐ側」だけを書きます。 攻撃の例も、手順も、道具の名前も書きません。
OWASP Top 10 を「何を守るか」の一覧として使う
OWASP Top 10 は、Webアプリで起きやすい問題を10個に整理した公開資料です。 下の表は2025年版(OWASP Top 10:2025)の番号です。年版が変わると番号も項目も入れ替わるので、番号で話すときは年版も添えます。
この記事では「守るべき対象の一覧」としてだけ使います。 各項目について、防ぐ側の対策だけを書きます。
| # | 守るべき対象 | 防ぐ側がやること |
|---|---|---|
| A01 | アクセス制御 | 拒否をデフォルトにする。 「明示的に許可したものだけ通す」。サーバー側で毎回、本人のものか確かめる(画面を隠すのは対策ではない)。利用者が指定したURLをサーバーから取りに行かない(SSRF。2025年版ではここに含まれる)。どうしても要るなら許可リストで宛先を限定する |
| A02 | 設定 | 初期パスワード・サンプルデータ・管理画面を消す。 エラーの詳細を利用者に返さない。不要な機能は入れない |
| A03 | 依存パッケージ(サプライチェーン) | バージョンを固定し、定期的に上げる。 npm audit を CI に入れる。使っていない依存を消す |
| A04 | 暗号まわり | TLS 1.2 以上のみ。 保存時も暗号化。パスワードは遅いハッシュ。方式を自分で発明せず標準のものを使う |
| A05 | 入力の扱い(インジェクション) | 文字列を組み立てず、プレースホルダを使う。 出力側で必ずエスケープ。入力は許可リストで検証する |
| A06 | 設計そのもの | 作る前に「何を守るか」を1枚書く。 上限(回数・容量・金額)を仕様として先に決める |
| A07 | 認証 | 多要素認証を用意する。 試行回数に上限。セッションは期限切れさせる。既知の流出パスワードを弾く |
| A08 | 成果物の完全性 | 署名を検証してから使う(④の話)。CI で信用できない外部スクリプトを取り込まない。ロックファイルをコミットする |
| A09 | 記録と監視 | ログイン・権限変更・失敗を必ず記録する。 ログに秘密情報を書かない。 アラートを鳴らす条件を決める |
| A10 | 例外的な状況の扱い | エラーは起きた場所で捕まえ、失敗したら「拒否」側に倒す。 途中で失敗した処理は中途半端に残さず、全部元に戻す。例外を握りつぶさない |
この表は「気を付ける」で終わらせないための一覧です。 1行ずつ、自分のアプリでどうなっているかを確認してください。
Web 側の防御ヘッダについては 自分のページをCSPで壊す — Webの防御ヘッダ に別に書きました。
今日、自分のサイトでできること
全部、自分の管理下のものに対してだけやります。
1. TLS 1.2 以上だけにする
⑦でやったとおりです。Node.js なら minVersion: 'TLSv1.2'、nginx なら ssl_protocols TLSv1.2 TLSv1.3; です。
確認は必ず自分のホストに対してだけ。 他人のサーバーに向けてはいけません。
2. 証明書の期限を、機械に見張らせる
notAfter=Dec 3 01:25:09 2026 GMT
人間は必ず忘れます。 Let’s Encrypt なら自動更新の仕組みが標準で付いてきます。 自動更新にした上で、更新が動いているかを監視してください。「自動化したから安心」で止まると、失敗しても気付けません。
3. 秘密鍵の権限を確かめる
-rw------- 1 user user 1704 Oct 4 10:25 ca.key
-rw------- 1 user user 1732 Oct 4 10:22 private.pem
-rw------- 1 user user 1704 Oct 4 10:25 site.key
-rw-------(600)以外があったら直します。 見方は Permission denied の正体 — rwxと755を読めるようにする にあります。
4. 秘密情報を Git に入れない
*.key
*.pem
.env
.gitignore は「まだコミットしていないもの」にしか効きません。 一度コミットしたら、履歴に残ります。 消しても git log から取り出せます。
入れてしまった鍵は、消すのではなく「作り直して差し替える」のが正解です。 暗号化して置く方法は .envは暗号化してGitに置ける — SOPSとage にあります。
5. 依存パッケージを上げ続ける
「動いているから触らない」がいちばん危ない状態です。 上げ方を決めておくほうが、何年か経ってからまとめて上げるより安全です。
6. パスワードは、遅いハッシュで保存する
④で SHA-256 を使いましたが、パスワードにこれを使ってはいけません。 SHA-256 は速いことが取り柄の関数で、パスワード保存にはわざと遅い関数(bcrypt / Argon2 / scrypt)を使います。
理由と実装は 速いハッシュは使わない — パスワード保存とbcrypt にあります。
判断表 — 迷ったときに見る
| 状況 | やること | 理由 |
|---|---|---|
| 新しく鍵を作る | Ed25519 か ECDSA(P-256) | ④で見たとおり、短く速い。RSA は互換用 |
| RSA を使う必要がある | 2048ビット以上。3072が望ましい | 1024ビットはもう使わない |
| 通信を守りたい | TLS を使う。自分でハイブリッドを書かない | ③の4手順には抜けがある |
| 公開サイトの証明書 | Let’s Encrypt などの公的CA + 自動更新 | 自己署名は「警告を無視する習慣」を作る |
| 社内・VM内の検証環境 | ⑥の自分だけのCAでよい | 外に出ないなら十分 |
| 大きなファイルを暗号化 | 共通鍵(AES-GCM)。公開鍵で直接やらない | ③で data too large が出る |
| 「本人が書いた」を示したい | 署名。暗号化ではない | 中身は隠れない。それでよい場面 |
| JWT に情報を入れる | 誰でも読める前提で入れる | 署名は改ざん防止であって秘匿ではない |
| パスワードを保存する | bcrypt / Argon2。SHA-256 は使わない | 速い関数は保存に向かない |
curl が証明書で落ちた | --cacert で足す。-k で潰さない | -k は検証そのものを止める |
| 暗号アルゴリズムを自作したい | やらない。標準の実装を使う | 自作の暗号は、弱くても弱いと気付けない |
| 他人のサーバーを確かめたい | 確かめない | 自分の管理下のホストにだけ行う |
つまずいたところ
1. 「秘密鍵で暗号化すると署名になる」で覚えて、混乱した
署名は暗号化ではありません。 ④で見たとおり、署名しても本文は平文のままです。 この言い方で覚えると、「署名すれば秘密が守られる」と勘違いします。JWT にそのまま機微な情報を入れかけました。 署名は本人性と非改ざん。秘匿はゼロ、と分けて覚え直しました。
2. RSA で普通のファイルを暗号化しようとして、エラーの意味が分からなかった
data too large for key size
「鍵が小さいから鍵長を上げよう」と思いました。違います。 4096ビットにしても入るのは500バイト程度で、根本的に足りません。 RSA は本文を暗号化する道具ではないと分かるまで、ここで30分溶かしました。
3. 同じ平文を2回暗号化したら違う結果が出て、「壊れた」と思った
正常です。 毎回違う乱数を混ぜているからです。 むしろ毎回同じ暗号文が出るほうが危ないと、逆でした。 テストで「暗号文が期待値と一致するか」を書こうとして、そこで気付きました。テストは「復号して戻るか」で書きます。
4. curl -k を、スクリプトに残したまま本番に出しかけた
-k は警告を消すのではなく、検証を止めます。 相手が誰でも通ります。 ⑦でやったとおり、正しいのは --cacert で「このCAを信頼する」と明示することです。 手元で -k を打ったら、その場で消すルールにしました。
5. 自己署名証明書を配って「警告は無視してください」と案内しかけた
これは、利用者に「警告を無視する習慣」を教えることです。 1回無視できた人は、次も無視します。本物の警告のときも無視します。 外に出すものは公的CA、内側だけなら自分のCA、と線を引きました。
6. 証明書の期限を、カレンダーに書いて管理しようとした
忘れます。 実際に一度切らしました。しかも気付いたのは利用者からの連絡でした。 自動更新を入れ、その上で「更新が動いているか」を監視する必要があります。 自動化しただけでは、失敗したことに気付けません。
7. Verify return code: 0 (ok) が出たので「安全になった」と思った
それは「証明書の鎖が繋がった」だけです。 アプリの認可も、入力の扱いも、依存パッケージも、何ひとつ確認していません。 TLS は入口の1枚で、⑧の表の A04(暗号まわり)の一部にしか対応していません。
8. 中間CA証明書を置き忘れて、「ブラウザでは繋がるのにアプリでは繋がらない」になった
ブラウザは、足りない中間CAを補完してくれることがあります。 openssl s_client や、多くのプログラムからのアクセスは補完しません。 ⑦の unable to get local issuer certificate が、まさにこの症状です。 確認は必ず openssl s_client でやります。 ブラウザで見えたことは、証拠になりません。
後片づけ
まず、実験用のHTTPSサーバーを止めます。
サーバーを起動したターミナルで Ctrl+C を押します。残っていないか確認します。
(何も出なければOK)
残っていたら止めます。
終了コード: 1
1 は「該当なし」です。 すでに止まっていたということなので、正常です。
繋がらなくなったことを確かめます。
exit=7
7 は「接続できない」です。 止まっています。
作業フォルダの中身を確認します。
aes.key big.enc ca.crt ca.srl dh-small.mjs e2.bin ed.pub pay.sig pay2.txt secret.enc server.mjs site.csr site.key
aes.key.enc big.txt ca.key dh-real.mjs e1.bin ed.key pay.ed.sig pay.txt private.pem secret.txt server.crt site.ext speed.mjs
public.pem
.key と private.pem が入っています。中身は本物の秘密鍵です。 実験用なので消して構いませんが、他のフォルダに紛れていないか先に確かめてください。
(空、または他の記事のフォルダ)
rm -rf は戻せません。 パスを打つ前に ls ~/cslab/crypto で中身を確認してください。
最後に、この記事で作った鍵をどこかに残していないか確認します。
(何も出なければOK)
実験用の鍵は、実験が終わったら消します。 残しておいて、あとで本番に使い回すことがいちばん危険です。
まとめ — 理解できたこと
- 共通鍵暗号は 2.6 GB/秒で動く。 「暗号化すると遅い」はもう成り立たない
- 公開鍵暗号は 921回/秒、1回あたり数百バイト。 同じ1MBで1600倍の差が出た
- 公開鍵暗号が解いているのは「鍵をどう渡すか」の1点だけ。 本文は今も共通鍵が守っている
- 秘密鍵から公開鍵は作れる。逆はできない。 だから公開鍵はどこに貼ってもよい
- 秘密鍵の権限は 600。 644 は「同じサーバーの他のユーザーが読める」という意味
- RSA は鍵長より短いデータしか暗号化できない。 2048ビットで245バイトまで。
data too large for key size - だからハイブリッド。 32バイトの共通鍵だけを公開鍵で包み、本文は共通鍵で守る。TLS も SSH も同じ形
- 同じ平文を2回暗号化すると、違う暗号文が出るのが正しい。 毎回乱数を混ぜている
- 署名は暗号化ではない。中身は隠れない。 保証するのは本人性と非改ざんの2つだけ
- 1バイト書き換えるだけで
Verification failure。 署名しているのは本文ではなく本文のハッシュ - 署名は毎日使っている。
apt、Git、npm、JWT、TLS のハンドシェイク。JWT の中身は誰でも読める - 新しく鍵を作るなら Ed25519 か ECDSA。 公開鍵32バイト、署名64バイト、RSA の23倍速い
- 鍵交換は鍵を送らない。
p=23, g=5で計算しても、共有した2は回線に一度も出ない - 前方秘匿性は
ECDHEのE(使い捨て)。 だから今の鍵が漏れても過去は守られる - 暗号化は証明書が無くてもできる。 証明書は「この公開鍵はこの相手のものか」の保証だけ
- ブラウザの警告は「暗号が弱い」ではなく「保証した人を知らない」。 Issuer と Subject が同じなら自己署名
- 信頼の連鎖は、ルートCAから辿れるかどうか。 中間CAを置き忘れると、ブラウザだけ繋がる状態になる
Server Temp Key/Protocol/Cipher/Verify return codeの4行に全部が出る。Cipherは AES であって RSA ではない- TLS 1.3 は往復が1回減り、選べるスイートが5種類だけ。 設定ミスの余地を仕様から消した
Verify return code: 0 (ok)は「安全」ではない。 証明書の鎖が繋がっただけcurl -kは検証を止める。 正しいのは--cacertで信頼するCAを明示すること- 暗号は自作しない。 標準の実装を使い、確かめるのは自分の管理下のホストだけにする
参考リンク
- OpenSSL 公式: openssl-genpkey — 鍵の作り方
- OpenSSL 公式: openssl-pkeyutl — 暗号化・復号・署名
- OpenSSL 公式: openssl-x509 — 証明書を読む・署名する
- OpenSSL 公式: openssl-s_client — 接続してハンドシェイクを見る
- RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3
- RFC 5280: X.509 証明書と失効リストの仕様
- Node.js 公式: Crypto
- Node.js 公式: TLS (SSL)
- MDN: Transport Layer Security
- OWASP: Top 10 — 守るべき対象の一覧
- OWASP: Cheat Sheet Series — 防ぐ側の実装指針
- Let’s Encrypt: ドキュメント
- Mozilla SSL Configuration Generator — 設定を生成する
- roadmap.sh: Computer Science
次に読む
この記事は 【深掘り】コンピュータ科学 の 23 / 25 本目です。
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- 署名は暗号化ではない
- 証明書がやるのは身元の保証だけ
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント