公開鍵暗号とTLS — 鍵は渡さずに秘密を共有する

公開鍵暗号とTLS。対になる鍵と保護された封筒、証明書とブラウザの南京錠。

※本記事はアフィリエイト広告(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回減る。 選べる暗号スイートも絞られている

この記事でやること

  1. openssl speed と Node.js で、共通鍵と公開鍵の速度差を実測する
  2. openssl genpkey で自分の鍵ペアを作り、中身をテキストで読み、権限を 600 にする
  3. 公開鍵で暗号化 → 秘密鍵で復号を実際にやり、逆ができないことと長さの上限をエラーで確かめる
  4. openssl dgst -sign / -verify で署名し、1バイト書き換えて検証を失敗させる
  5. Diffie-Hellman を小さい数で計算し、続けて Node.js の ECDH で同じことをやる
  6. 自己署名証明書と、自分だけのCAで署名した証明書を作り、openssl verify で違いを見る
  7. 自分で立てたHTTPSサーバーに openssl s_client で繋ぎ、プロトコルと暗号スイートを読む
  8. 守る側のチェックリストを作る(攻撃の例は書きません)

先に知る言葉

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

言葉意味
共通鍵暗号(対称暗号)暗号化と復号に同じ鍵を使う方式。AES が代表。速い
公開鍵暗号(非対称暗号)2つで1組の鍵を使う方式。片方で閉めたら、もう片方でしか開かない。遅い
秘密鍵絶対に外に出さないほうの鍵。 これが漏れたら全部終わる
公開鍵配ってよいほうの鍵。 秘密鍵から作れるが、逆はできない
ハイブリッド暗号公開鍵で共通鍵を渡し、本文は共通鍵で守るやり方。TLS はこれ
電子署名秘密鍵で作る短い印。中身は隠さない。 本人性と非改ざんだけを示す
ハッシュどんな長さのデータからも固定長の値を出す関数。SHA-256 なら常に32バイト
鍵交換(Diffie-Hellman)鍵そのものを送らずに、両者が同じ秘密に辿り着く手順
前方秘匿性(PFS)今の鍵が漏れても、過去の通信は守られるという性質
証明書(X.509)「この公開鍵は、この名前の持ち主のものです」と第三者が署名した紙
認証局(CA)その署名をする側。ルートCAはOSやブラウザに最初から入っている
暗号スイート鍵交換・暗号・ハッシュの組み合わせの名前。TLS_AES_256_GCM_SHA384 など

① なぜ2種類あるのか — 速度を測ってから話す

まず作業フォルダを作ります。

bash
$ mkdir -p ~/cslab/crypto
$ cd ~/cslab/crypto
$ pwd
/home/user/cslab/crypto

openssl が入っているか確認します。

bash
$ openssl version
OpenSSL 3.2.4 11 Feb 2025 (Library: OpenSSL 3.2.4 11 Feb 2025)

入っていなければ入れてください。 Ubuntu なら sudo apt install openssl です (sudo と apt の話は本線側にあります)。

共通鍵暗号は、もう十分に速い

先に速度を見ます。 ここを見ないと、この先の話が「なんとなく」で終わります。

bash
$ openssl speed -seconds 1 -elapsed -evp aes-256-gcm 2>/dev/null | tail -3
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 に向けます。

bash
$ openssl speed -seconds 1 -elapsed rsa2048 2>/dev/null | tail -6
                   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回あたり数百バイト」。 同じ土俵に載っていません。 使いどころがまったく違う道具です。

同じ量のデータで、正面から比べる

数字を並べただけだと実感しにくいので、同じデータを両方で暗号化して時間を測ります。

bash
$ nano speed.mjs
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 を読みます。 それは②で作るので、 ②を先にやってから戻ってきてください。 ここでは結果だけ先に出します。

bash
$ node speed.mjs
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でも

「遅いから使えない」ではなく、「遅いから最初の一瞬だけ使う」。 ここが設計の全部です。


② 鍵ペアを作って、中身を見る

話はここまでにして、実際に作ります。

bash
$ cd ~/cslab/crypto
$ openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private.pem
..+.........+..........+++++++++++++++++++++++++++++++++++++++*........+..+...+.+
...........+++++++++++++++++++++++++++++++++++++++*...+......+.........+........
....+........+.+...+..+.........+...............+.+......+..............++++++
....+...+.....+....+...+...+++++++++++++++++++++++++++++++++++++++*...+..+......
.+++++++++++++++++++++++++++++++++++++++*...+...+......+.....+....+...+....++++++

この点と + の羅列はエラーではありません。 素数を探している途中経過です。 . は「素数の候補を1つ作った」、+ は「素数判定を1回通った」、* は「素数が1つ見つかった」の目安です(細かな意味は OpenSSL の版や鍵の作り方によって異なります)。①で keygen 12.1回/秒 と出たのは、この作業です。

できたファイルを見ます。

bash
$ ls -l private.pem
$ head -3 private.pem
-rw-r--r-- 1 user user 1732 Oct  4 10:22 private.pem
-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC4DA2LjjdxG0Hj
3aCKl6MVUeypbdq46AtByOtrfnY1UDZfqu+/luU+YleI4uF0/JEJYbRCMV2eQU6t

これは暗号文ではありません。 Base64 で書かれたただのデータです。 このテキストを手に入れた人は、そのまま秘密鍵として使えます。

公開鍵は、秘密鍵から作る

bash
$ openssl pkey -in private.pem -pubout -out public.pem
$ cat public.pem
-----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 のままでは何も分かりません。 中を開きます。

bash
$ openssl pkey -in private.pem -text -noout | head -20
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つの素数) が並んでいます。

公開鍵のほうも同じように開けます。

bash
$ openssl pkey -in public.pem -pubin -text -noout | tail -3
    2c:29
Exponent: 65537 (0x10001)

公開鍵には modulus と Exponent(65537)しか入っていません。 秘密鍵にあった prime1 / prime2 がありません。この2つの素数を知っているかどうかが、秘密鍵と公開鍵の差です。

秘密鍵の権限を 600 にする

ここは必ずやります。

bash
$ ls -l private.pem
$ chmod 600 private.pem
$ ls -l private.pem
-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------- に変わっているところ


③ 暗号化と復号を、自分でやる

では、公開鍵で閉めて、秘密鍵で開けます。

bash
$ echo "口座番号は 1234-5678 です" > secret.txt
$ cat secret.txt
口座番号は 1234-5678 です

公開鍵で暗号化します。

bash
$ openssl pkeyutl -encrypt -inkey public.pem -pubin -in secret.txt -out secret.enc
$ ls -l secret.txt secret.enc
-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バイト)です。

中を見ます。

bash
$ xxd secret.enc | head -4
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.

乱数と区別が付きません。 これが正しい状態です。

秘密鍵で開けます。

bash
$ openssl pkeyutl -decrypt -inkey private.pem -in secret.enc
口座番号は 1234-5678 です

戻りました。

同じ平文を2回暗号化すると、違う暗号文になる

ここは意外だったところです。

bash
$ openssl pkeyutl -encrypt -inkey public.pem -pubin -in secret.txt -out e1.bin
$ openssl pkeyutl -encrypt -inkey public.pem -pubin -in secret.txt -out e2.bin
$ xxd e1.bin | head -2
$ echo "---"
$ xxd e2.bin | head -2
$ echo "---"
$ cmp e1.bin e2.bin; echo "exit=$?"
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

同じ鍵、同じ平文なのに、まったく違うものが出ました。

これは正しい動作です。 暗号化するとき、平文の前に毎回違う乱数を混ぜてから計算しています(パディング)。 もし毎回同じ暗号文が出るなら、「同じ内容が送られた」ことが外から分かってしまいます。 中身は分からなくても、「昨日と同じ返事だ」が分かるだけで情報です。

だから、テストは「暗号文が期待値と一致するか」ではなく「復号して元に戻るか」で書きます。

逆はできない

公開鍵で復号しようとしてみます。

bash
$ openssl pkeyutl -decrypt -inkey public.pem -pubin -in secret.enc; echo "exit=$?"
A private key is needed for this operation
pkeyutl: Error initializing context
exit=1

きっぱり断られました。 公開鍵は「閉める専用」です。 だから、公開鍵をばらまいても、暗号文は読まれません。 これが「公開してよい鍵」の意味です。

長いデータは、そもそも暗号化できない

ここが今日いちばん大事なエラーです。 500バイトのファイルを作って、投げます。

bash
$ head -c 500 /dev/urandom > big.bin
$ ls -l big.bin
$ openssl pkeyutl -encrypt -inkey public.pem -pubin -in big.bin -out big.enc; echo "exit=$?"
-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. 「暗号化した本文」と「暗号化した鍵」を一緒に送る

やってみます。

bash
$ head -c 500 /dev/urandom | base64 > big.txt
$ wc -c big.txt
677 big.txt

① 使い捨ての共通鍵を作る

bash
$ openssl rand -out aes.key 32
$ ls -l aes.key
-rw-r--r-- 1 user user 32 Oct  4 10:25 aes.key

② 本文をその鍵で暗号化する

bash
$ openssl enc -aes-256-cbc -pbkdf2 -in big.txt -out big.enc -pass file:aes.key
$ ls -l big.txt big.enc
-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バイトが、平気で通りました。 共通鍵暗号には長さの上限がありません。

③ 共通鍵だけを、公開鍵で暗号化する

bash
$ openssl pkeyutl -encrypt -inkey public.pem -pubin -in aes.key -out aes.key.enc
$ ls -l aes.key.enc
-rw-r--r-- 1 user user 256 Oct  4 10:25 aes.key.enc

32バイトなので、余裕で入りました。

④ 受け取る側は、逆をやる

bash
$ openssl pkeyutl -decrypt -inkey private.pem -in aes.key.enc -out aes.key.dec
$ cmp aes.key aes.key.dec && echo "鍵が復元できた"
$ openssl enc -d -aes-256-cbc -pbkdf2 -in big.enc -out big.dec -pass file:aes.key.dec
$ cmp big.txt big.dec && echo "本文が復元できた"
鍵が復元できた
本文が復元できた

これがハイブリッド暗号です。 TLS も、SSH も、暗号化メールも、やっていることはこの4手順です。 公開鍵は「32バイトの鍵を渡すため」にしか使っていません。 ①で測った 1600倍の差は、この32バイトの分にしかかかりません。

ただし、これを自分で書いて本番に載せてはいけません。 上の4手順には、実は 「鍵をそのまま使わずに導出する」「本文が改ざんされていないことを確かめる」といった要素が抜けています。 本番では TLS を使ってください。 ここでやったのは中で何が起きているかを見るためです。


④ 署名は暗号化ではない

私が長いこと混ぜていたのがここです。

「秘密鍵で暗号化すると署名になる」と説明されることがあります。この言い方は、理解を壊します。

署名は、中身を隠しません。 署名しても、元のファイルは平文のままです。署名は別のファイルとして横に付きます。 保証するのは「本人が書いた」「1バイトも変わっていない」の2つだけです。

やってみます。

bash
$ printf 'transfer 1000 yen to alice\n' > pay.txt
$ cat pay.txt
transfer 1000 yen to alice

秘密鍵で署名します。

bash
$ openssl dgst -sha256 -sign private.pem -out pay.sig pay.txt
$ ls -l pay.txt pay.sig
-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バイトのままです。 中身を見ます。

bash
$ cat pay.txt
transfer 1000 yen to alice

平文のままです。 署名は pay.sig という別ファイルになりました。

公開鍵で検証します。

bash
$ openssl dgst -sha256 -verify public.pem -signature pay.sig pay.txt
Verified OK

1バイト書き換えると、落ちる

10バイト目の 1 を 9 に変えます。 金額が 1000 円から 9000 円になります。

bash
$ cp pay.txt pay2.txt
$ printf '9' | dd of=pay2.txt bs=1 seek=9 conv=notrunc 2>/dev/null
$ cat pay.txt
$ cat pay2.txt
$ cmp -l pay.txt pay2.txt
transfer 1000 yen to alice
transfer 9000 yen to alice
10  61  71

cmp -l の出力は「10バイト目だけが違う」という意味です(8進数で 61 は 1、71 は 9)。 変えたのは1バイトだけです。

同じ署名で検証します。

bash
$ openssl dgst -sha256 -verify public.pem -signature pay.sig pay2.txt; echo "exit=$?"
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バイト変わっただけで、検証は通りません。

理由はハッシュを見れば分かります。

bash
$ sha256sum pay.txt pay2.txt
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 も試す

署名専用なら、もっと小さくて速い方式があります。

bash
$ openssl genpkey -algorithm ED25519 -out ed.key
$ openssl pkey -in ed.key -pubout -out ed.pub
$ cat ed.pub
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAZQIyb38RK3c6Rp+jcIt5mdubX10GqCCNzjJPoXzJOZU=
-----END PUBLIC KEY-----

RSA の公開鍵が7行あったのに対して、1行です。

bash
$ openssl pkey -in ed.key -text -noout
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です。

bash
$ openssl pkeyutl -sign -inkey ed.key -rawin -in pay.txt -out pay.ed.sig
$ ls -l pay.ed.sig pay.sig
$ openssl pkeyutl -verify -pubin -inkey ed.pub -rawin -in pay.txt -sigfile pay.ed.sig
-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 より速いです。

bash
$ openssl speed -seconds 1 -elapsed ed25519 ecdsap256 2>/dev/null | tail -4
                              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 は、相手が対応していないときの互換用と考えて構いません。


⑤ 鍵交換 — 鍵そのものを送らずに、同じ秘密に辿り着く

③のハイブリッドには、まだ弱いところがあります。

共通鍵を「公開鍵で包んで送る」やり方だと、秘密鍵が漏れた瞬間、過去の通信も全部読めます。 記録しておいた通信を、あとで開けられるからです。

それを断ち切るのが鍵交換です。

鍵を送りません。 両者が別々に計算して、同じ値に辿り着きます。 回線に流れるのは、そこから元の秘密を割り出せない値だけです。

小さい数で、紙の計算のようにやる

言葉だと信じられないので、実際に計算します。

bash
$ nano dh-small.mjs
// 小さい数で「鍵を送らずに同じ秘密に辿り着く」を確かめる
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つだけ');
bash
$ node dh-small.mjs
公開されている値      : 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 で

bash
$ nano dh-real.mjs
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'));
bash
$ node dh-real.mjs
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点を埋めるためだけに存在します。

自己署名証明書を作る

bash
$ openssl req -x509 -new -key private.pem -out server.crt -days 30 \
    -subj "/C=JP/ST=Tokyo/O=obmes-lab/CN=localhost" \
    -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"

(何も出なければ成功です)

中身を読みます。

bash
$ openssl x509 -in server.crt -text -noout | head -14
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 が同じです。 自分で自分を「これは自分です」と保証しています。 これが「自己署名」の意味です。 ブラウザが怒っているのは、まさにここです。

拡張領域も見ます。

bash
$ openssl x509 -in server.crt -text -noout | sed -n '/X509v3 extensions/,/Signature Algorithm/p'
        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 が同じ値なのも、自己署名だからです。

短くまとめて見たいときは、こちらのほうが実務的です。

bash
$ openssl x509 -in server.crt -noout -subject -issuer -dates -fingerprint -sha256
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用の鍵と証明書

bash
$ openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out ca.key 2>/dev/null
$ chmod 600 ca.key
$ openssl req -x509 -new -key ca.key -days 365 -out ca.crt \
    -subj "/C=JP/O=obmes-lab/CN=obmes-lab Root CA" \
    -addext "basicConstraints=critical,CA:TRUE" \
    -addext "keyUsage=critical,keyCertSign,cRLSign"

② サーバー用の鍵と、署名依頼書(CSR)

bash
$ openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out site.key 2>/dev/null
$ chmod 600 site.key
$ openssl req -new -key site.key -out site.csr -subj "/C=JP/O=obmes-lab/CN=localhost"
$ openssl req -in site.csr -text -noout | head -6
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が署名する

bash
$ printf 'subjectAltName=DNS:localhost,IP:127.0.0.1\nbasicConstraints=CA:FALSE\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth\n' > site.ext
$ openssl x509 -req -in site.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
    -days 90 -sha256 -extfile site.ext -out site.crt
Certificate request self-signature ok
subject=C=JP, O=obmes-lab, CN=localhost

④ 鎖が繋がったか確かめる

bash
$ openssl x509 -in site.crt -noout -subject -issuer -dates
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 が違います。 自己署名ではなくなりました。

bash
$ openssl verify -CAfile ca.crt site.crt
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サーバーを立てる

bash
$ nano server.mjs
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の外からも繋がります。 実験用のサーバーは自分の中だけに閉じます。

別のターミナルで起動します。

bash
$ cd ~/cslab/crypto
$ node server.mjs
https://127.0.0.1:8443 で待機中

まず、素直に繋いでみる

元のターミナルに戻って、curl を打ちます。

bash
$ curl https://localhost:8443/
curl: (60) SSL certificate problem: unable to get local issuer certificate
More details here: https://curl.se/docs/sslcerts.html

拒否されました。 ⑥で作った ca.crt は、curl の信頼リストに入っていないからです。

CAを渡すと、通ります。

bash
$ curl --cacert ca.crt https://localhost:8443/
protocol: TLSv1.3
cipher: TLS_AES_256_GCM_SHA384

-k で警告を潰すのではなく、--cacert で「このCAは信頼する」と明示しました。 やっていることが違います。 -k は検証そのものを止めます。 本番のスクリプトに -k を書かないでください。 検証が要らないなら HTTPS にする意味がありません。

ハンドシェイクを、s_client で覗く

bash
$ echo | openssl s_client -connect 127.0.0.1:8443 -servername localhost -CAfile ca.crt 2>&1 | head -20
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を渡さないと、こうなります。

bash
$ echo | openssl s_client -connect 127.0.0.1:8443 -servername localhost 2>&1 | head -6
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証明書をサーバーに置き忘れていることがほとんどです。 ブラウザでは繋がるのにスマホアプリでは繋がらない、という形で出ます。

結果の要点だけを見る

bash
$ echo | openssl s_client -connect 127.0.0.1:8443 -servername localhost -CAfile ca.crt 2>&1 \
    | grep -E "Protocol|Cipher   |Temp Key|Verify return code|handshake has read"
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 を指定して繋ぎます。

bash
$ echo | openssl s_client -connect 127.0.0.1:8443 -tls1_2 2>&1 \
    | grep -E "Protocol|Cipher   |handshake has read"
SSL handshake has read 1564 bytes and written 287 bytes
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES128-GCM-SHA256

暗号スイートの名前の形が違います。

TLS 1.2TLS 1.3
名前ECDHE-RSA-AES128-GCM-SHA256TLS_AES_256_GCM_SHA384
何が書いてあるか鍵交換 + 署名 + 暗号 + ハッシュの4つ暗号 + ハッシュの2つだけ
鍵交換の選択スイートごとに決まる別枠。前方秘匿性のあるものしか無い
ハンドシェイクの往復2往復1往復
使えるスイートの数数十種類(古いものも混ざる)5種類だけ

TLS 1.3 の名前が短いのは、選べるものを減らしたからです。 1.2 には「選べてしまうけれど選んではいけない組み合わせ」がありました。 1.3 はそれを仕様から消しました。 設定ミスの余地を潰すのが、いちばん確実な守り方です。

往復が1回減ると、遅い回線ほど効きます。 地球の裏側との往復が200msなら、接続が200ms速くなります。

古い版を、ちゃんと断れているか確かめる

minVersion: 'TLSv1.2' が効いているかを見ます。

bash
$ echo | openssl s_client -connect 127.0.0.1:8443 -tls1_1 2>&1 | head -4
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; です。

bash
$ # 自分のサーバーが古い版を断れているか
$ echo | openssl s_client -connect 127.0.0.1:8443 -tls1_1 -cipher 'DEFAULT@SECLEVEL=0' 2>&1 | head -3

確認は必ず自分のホストに対してだけ。 他人のサーバーに向けてはいけません。

2. 証明書の期限を、機械に見張らせる

bash
$ openssl x509 -in site.crt -noout -enddate
notAfter=Dec  3 01:25:09 2026 GMT

人間は必ず忘れます。 Let’s Encrypt なら自動更新の仕組みが標準で付いてきます。 自動更新にした上で、更新が動いているかを監視してください。「自動化したから安心」で止まると、失敗しても気付けません。

3. 秘密鍵の権限を確かめる

bash
$ ls -l ~/cslab/crypto/*.key ~/cslab/crypto/private.pem
-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 に入れない

bash
$ cat > .gitignore <<'EOF'
  *.key
  *.pem
  .env
  EOF
$ cat .gitignore
*.key
*.pem
.env

.gitignore は「まだコミットしていないもの」にしか効きません。 一度コミットしたら、履歴に残ります。 消しても git log から取り出せます。

入れてしまった鍵は、消すのではなく「作り直して差し替える」のが正解です。 暗号化して置く方法は .envは暗号化してGitに置ける — SOPSとage にあります。

5. 依存パッケージを上げ続ける

bash
$ npm audit --omit=dev

「動いているから触らない」がいちばん危ない状態です。 上げ方を決めておくほうが、何年か経ってからまとめて上げるより安全です。

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 を押します。残っていないか確認します。

bash
$ ps -ef | grep "[n]ode server.mjs"
(何も出なければOK)

残っていたら止めます。

bash
$ pkill -f "node server.mjs" 2>/dev/null; echo "終了コード: $?"
終了コード: 1

1 は「該当なし」です。 すでに止まっていたということなので、正常です。

繋がらなくなったことを確かめます。

bash
$ curl -s --max-time 3 --cacert ~/cslab/crypto/ca.crt https://localhost:8443/ ; echo "exit=$?"
exit=7

7 は「接続できない」です。 止まっています。

作業フォルダの中身を確認します。

bash
$ ls ~/cslab/crypto
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 が入っています。中身は本物の秘密鍵です。 実験用なので消して構いませんが、他のフォルダに紛れていないか先に確かめてください。

bash
$ cd ~
$ rm -rf ~/cslab/crypto
$ ls ~/cslab
(空、または他の記事のフォルダ)

rm -rf は戻せません。 パスを打つ前に ls ~/cslab/crypto で中身を確認してください。

最後に、この記事で作った鍵をどこかに残していないか確認します。

bash
$ find ~ -name "*.key" -o -name "private.pem" 2>/dev/null | head
(何も出なければ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を明示すること
  • 暗号は自作しない。 標準の実装を使い、確かめるのは自分の管理下のホストだけにする

参考リンク


次に読む

この記事は 【深掘り】コンピュータ科学 の 23 / 25 本目です。

記事
← 前の記事SSEとWebSocket — 1秒ごとに聞きに行くのをやめる
→ 次の記事スケールとアムダールの法則 — 状態を持つと台を増やせない

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

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

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

›CS — Cryptography
  • 署名は暗号化ではない
  • 証明書がやるのは身元の保証だけ

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

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

コメント

コメントする

目次