送信を押してから起きること

既読が
つくまで

「送信」を押すと相手の画面に吹き出しが出て、しばらくすると「既読」がつく。相手の端末に届くまでは 1 秒もかからない。その間に端末とサーバーを何が行き来しているのかを、フレーム単位で追っていく。

7 時に駅前でいい?

  1. SEND
  2. ACK seq=1042
  3. EVENT → B
  4. DELIVERED
  5. READ_RECEIPT
時間は一例。

第 0 章

登場人物

どのチャットアプリも、細部は違っても登場人物はだいたい同じになる。端末と常時接続を張るゲートウェイ、順序を決めて保存するメッセージサーバー、オフラインの端末を起こすためのOS のプッシュ通知サービス、それから大きいファイルを置くオブジェクトストレージ。

以下の図はすべて架空のプロトコルで描いている。フレームの名前やフィールドはアプリごとに違うが、解こうとしている問題は同じ。実在のアプリでの具体的な実装は実在のアプリにまとめた。

チャットアプリの構成端末 Aアプリ + ローカル DB端末 Bアプリ + ローカル DBゲートウェイ数百万本の接続メッセージサーバーseq を振る・配るストレージチャットログAPNs / FCMOS のプッシュ通知オブジェクトストレージ / CDN常時接続寝ている端末を起こすファイルは直接置く
太線は張りっぱなしの接続。点線は必要なときだけ使う経路。

第 1 章・12 ステップ

送信から既読まで

A と B がどちらもアプリを開いている、一番素直なケース。順番は誰かの時計ではなく、サーバーが振る seq で決まる。「配信済み」「既読」も 1 通ずつではなく、「ここまで」という位置で返す。

シーケンス図A の端末, ゲートウェイ, メッセージサーバー, ストレージ, B の端末SEND1SEND + userId2APPEND seq=10423OK4ACK seq=10425EVENT seq=10426保存して表示7DELIVERED upTo=10428DELIVERED9READ upTo=104210read_pos[B]=104211READ_RECEIPT12

  1. 1A の端末 → ゲートウェイSEND

    端末が ID を振ってから投げる

    送信ボタンを押した瞬間、端末は clientMsgId を自分で作り、ローカル DB に「送信中」で書いてから送る。乗せる先はアプリ起動時から張りっぱなしの接続で、ここで新しく TCP を張ることはない。

    流れるデータ
    {
      "op": "SEND",
      "chatId": "c_8f2a",
      "clientMsgId": "a-7d1c9e",
      "type": "text",
      "body": "<ciphertext, 128 bytes>"
    }
  2. 2ゲートウェイ → メッセージサーバーSEND + userId

    ゲートウェイは中身を見ない

    ゲートウェイの仕事は大量の接続を抱えておくこと。メッセージの中身は解釈せず、認証済みセッションのユーザー ID を付けて内部 RPC で後ろに渡す。

    流れるデータ
    rpc Send {
      userId: 31337
      deviceId: "ios-2"
      frame: <SEND ...>
    }
  3. 3メッセージサーバー → ストレージAPPEND seq=1042

    チャットごとに番号を振って追記

    サーバーはチャット単位で単調増加する seq を割り当てて保存する。並び順はこの seq で決まる。端末の時計はずれるので、順序の根拠には使わない。

    流れるデータ
    chat_id  | seq  | client_msg_id | sender | body
    c_8f2a   | 1042 | a-7d1c9e      | 31337  | ...
  4. 4ストレージ → メッセージサーバーOK

    永続化してから ACK

    書き込みが確定する前に送信者へ ACK を返すと、サーバーが落ちたときに「送れたはずのメッセージ」が消える。ACK は永続化のあと。

  5. 5メッセージサーバー → A の端末ACK seq=1042

    送信済みになる

    ここから先はゲートウェイの中継を図から省く。A の端末は clientMsgId で手元の行を見つけ、seq とサーバー時刻を書き込む。表示は「送信中」から「送信済み」に変わる。

    流れるデータ
    {
      "op": "ACK",
      "clientMsgId": "a-7d1c9e",
      "seq": 1042,
      "serverTime": 1795442112384
    }
  6. 6メッセージサーバー → B の端末EVENT seq=1042

    受信者の接続を探して押し込む

    B がどのゲートウェイにつながっているかはセッション表 (userId → ゲートウェイ) で引く。B がスマホと PC の両方でログインしていれば、両方に配る。

    流れるデータ
    {
      "op": "EVENT",
      "chatId": "c_8f2a",
      "seq": 1042,
      "from": 31337,
      "body": "<ciphertext>"
    }
  7. 7B の端末保存して表示

    受信側も先にローカル DB

    画面に出す前にローカル DB に保存する。手元の最新 seq (カーソル) も 1042 に進める。次に接続し直したとき、どこから取り直せばいいかはこのカーソルで決まる。

  8. 8B の端末 → メッセージサーバーDELIVERED upTo=1042

    「ここまで届いた」と返す

    1 通ずつではなく「ここまで受け取った」という形で返す。まとめて 50 通届いても ACK は 1 回で済む。

  9. 9メッセージサーバー → A の端末DELIVERED

    配信済み

    WhatsApp の灰色のチェック 2 つはこの段階。LINE はこの状態を画面に出さず、既読だけを見せる。

  10. 10B の端末 → メッセージサーバーREAD upTo=1042

    チャットを開いたら既読

    画面にチャットが表示された時点で送る。これも seq の位置で送るので、未読が何通あっても 1 フレーム。

    流れるデータ
    { "op": "READ", "chatId": "c_8f2a", "upTo": 1042 }
  11. 11メッセージサーバー → ストレージread_pos[B]=1042

    既読位置もサーバーに残す

    B の別の端末も同じ位置まで既読にするため、既読位置はユーザー単位でサーバーに持つ。

  12. 12メッセージサーバー → A の端末READ_RECEIPT

    既読がつく

    A の画面で、1042 以下の自分のメッセージに既読がつく。グループでの数え方は後の章で扱う。

第 2 章・15 ステップ

張りっぱなしの接続

素の HTTP だとサーバーは聞かれたときにしか返事ができないので、B に向けてメッセージを押し込めない。そこでアプリは起動したらすぐ 1 本の接続を張り、閉じるまで維持する。張るのに往復を重ねるほど、アプリを開いてから最新のメッセージが出るまでが遅くなる。

Discord はこの仕組みをドキュメントで公開している。サーバーの最初のフレーム (Hello、opcode 10) がハートビートの間隔を指定し、切れた端末は resume すると取りこぼしたイベントを再送してもらえる。

シーケンス図B の端末, DNS, ゲートウェイ, 認証gw.example.com ?1203.0.113.172SYN3SYN-ACK4ACK + ClientHello5ServerHello … Finished6HELLO token=…7verify(token)8userId=313379セッション表に登録10READY11PING12PONG13PING14待ってから再接続15

  1. 1B の端末 → DNSgw.example.com ?

    接続先を引く

    アプリ起動時やネットワーク切り替え時に、ゲートウェイの名前を解決する。地域ごとに別のアドレスを返して近い拠点に寄せることが多い。

  2. 2DNS → B の端末203.0.113.17

    アドレスが返る

    TTL が短めに設定されていれば、拠点の切り替えもここで効く。

  3. 3B の端末 → ゲートウェイSYN

    TCP 3-way handshake

    モバイル回線だと往復 1 回で 50〜100ms かかることもある。ここから TLS 完了までの往復回数が、アプリを開いてからメッセージが流れ始めるまでの時間になる。

  4. 4ゲートウェイ → B の端末SYN-ACK

    TCP 3-way handshake

    サーバー側も接続用のバッファを確保する。

  5. 5B の端末 → ゲートウェイACK + ClientHello

    TLS 1.3 を始める

    ClientHello に鍵共有用の公開値 (key_share) を最初から入れておくので、TLS 1.3 は 1 往復で終わる。

    流れるデータ
    ClientHello
      supported_versions: TLS 1.3
      key_share: x25519 <32 bytes>
      alpn: h2
  6. 6ゲートウェイ → B の端末ServerHello … Finished

    暗号化された通信路ができる

    key_share から両側で同じ鍵を導く。ServerHello より後は証明書も含めて暗号化されていて、端末は証明書を検証してから通信路を信用する。

  7. 7B の端末 → ゲートウェイHELLO token=…

    誰なのかを名乗る

    ログイン時にもらったアクセストークンを送る。HTTP/2 のストリームに乗せるか、WebSocket か MQTT かはアプリによって違う。大事なのは、双方向にフレームを流せる 1 本の接続があること。

    流れるデータ
    {
      "op": "HELLO",
      "token": "eyJhbGciOi…",
      "device": "ios-2",
      "cursor": { "c_8f2a": 1038 }
    }
  8. 8ゲートウェイ → 認証verify(token)

    トークン検証

    署名と有効期限を確認する。失効リストを引くこともある。

  9. 9認証 → ゲートウェイuserId=31337

    ユーザーが確定

    以降、このコネクションから来るフレームはすべて userId=31337 のものとして扱う。

  10. 10ゲートウェイセッション表に登録

    配送のための住所録

    userId → (ゲートウェイ ID, 接続 ID) を共有ストアに書く。メッセージを配るときはこの表を見て、どのゲートウェイに投げればいいかを決める。

    流れるデータ
    SET session:31337:ios-2 = gw-17/conn-88412  EX 300
  11. 11ゲートウェイ → B の端末READY

    使える状態

    あとは双方向にフレームを流すだけ。

  12. 12B の端末 → ゲートウェイPING

    黙っていると忘れられる

    キャリアの NAT や途中の機器は、しばらく何も流れない TCP 接続を黙って捨てる。そこで数十秒〜数分おきに小さなフレームを流して、接続を生かしておく。短くすれば切れにくく、長くすれば電池が持つ。

  13. 13ゲートウェイ → B の端末PONG

    生きてる

    セッション表の TTL もここで延長する。

  14. 14B の端末 → ゲートウェイPING

    Wi-Fi から LTE に切り替わった

    IP アドレスが変わると古い TCP 接続は使えなくなる。ネットワークが変わったことは OS が教えてくれても、ソケットが死んだことまでは教えてくれない。PONG が返ってこないことで確かめる。

  15. 15B の端末待ってから再接続

    全員が同時に戻ってこないように

    1 秒、2 秒、4 秒…と間隔を伸ばし、さらにランダムなずれ (ジッタ) を足す。ゲートウェイが再起動したとき、数百万台が同じ瞬間に再接続してくるのを防ぐため。

    流れるデータ
    delay = min(cap, base * 2^attempt) * random(0.5, 1.0)

第 3 章・8 ステップ

二重に届かない理由

モバイル回線では「送ったけど返事が来ない」がしょっちゅう起きる。ここで素直に再送すると、相手には同じメッセージが 2 通届いてしまう。端末が送る前に振った clientMsgId がこれを防ぐ。

シーケンス図A の端末, メッセージサーバー, ストレージSEND id=a-7d1c9e1INSERT seq=10422ACK seq=10423タイムアウト4SEND id=a-7d1c9e5SELECT by clientMsgId6seq=10427ACK seq=10428

  1. 1A の端末 → メッセージサーバーSEND id=a-7d1c9e

    普通に送る

    ここまでは最初の章と同じ。

  2. 2メッセージサーバー → ストレージINSERT seq=1042

    保存は成功している

    サーバー側では処理は完了している。

  3. 3メッセージサーバー → A の端末ACK seq=1042

    ACK だけが消える

    エレベーターに乗った、トンネルに入った。返事が届かないだけで、メッセージ自体は保存済み。A の端末からはこれが「届かなかった」のか「返事だけ消えた」のか区別できない。

  4. 4A の端末タイムアウト

    わからないので、もう一度送る

    送信待ちキューに残っている限り、つながり直したら再送する。ここで新しい ID を振ると、相手には同じメッセージが 2 通届く。

  5. 5A の端末 → メッセージサーバーSEND id=a-7d1c9e

    同じ clientMsgId で送り直す

    再送でも ID は最初に振ったものを使う。これで送信が冪等になる (何回送っても 1 回送ったのと同じ結果になる)。

  6. 6メッセージサーバー → ストレージSELECT by clientMsgId

    前に見たことがあるか

    (chatId, 送信者, clientMsgId) に一意制約をかけておくか、重複検知用のキャッシュを引く。clientMsgId は端末が勝手に振るので、送信者を含めないと別人の ID とぶつかる。

    流れるデータ
    SELECT seq FROM messages
     WHERE chat_id = 'c_8f2a'
       AND sender = 31337
       AND client_msg_id = 'a-7d1c9e';
  7. 7ストレージ → メッセージサーバーseq=1042

    あった

    すでに 1042 番として保存されている。

  8. 8メッセージサーバー → A の端末ACK seq=1042

    最初と同じ答えを返す

    保存も配送もやり直さず、前回と同じ ACK を返す。A から見れば「やっと返事が来た」だけで、B には 1 通しか届いていない。

第 4 章・9 ステップ

閉じていても届く

スマホの OS は、バックグラウンドのアプリが勝手に通信し続けることを許さない。電池がもたないからだ。アプリを閉じている B に届けるには、Apple と Google がすでに張っている通知の経路を借りる。

シーケンス図A の端末, メッセージサーバー, APNs / FCM, B の端末SEND1セッション表に B なし2通知依頼3通知4拡張が起動5SYNC since=103861039 … 10427DELIVERED upTo=10428DELIVERED9

  1. 1A の端末 → メッセージサーバーSEND

    B はアプリを閉じている

    iOS も Android も、バックグラウンドのアプリが接続を張り続けることをほぼ許さない。B の端末とサーバーの間に接続はない。

  2. 2メッセージサーバーセッション表に B なし

    直接は届けられない

    メッセージは保存済みなので失われはしない。B が次に来たときに取りに来てもらえばいい。問題は「来てもらう」きっかけ。

  3. 3メッセージサーバー → APNs / FCM通知依頼

    OS のプッシュ通知サービスに頼む

    アプリは自前で端末を起こせないので、Apple (APNs) や Google (FCM) に頼む。OS は 1 本の接続を全アプリで共有していて、それ経由で届く。ペイロードは 4KB まで。E2EE のアプリは本文をサーバーが持っていないので、ここに本文は載らない。

    流れるデータ
    POST /3/device/<device-token>
    apns-push-type: alert
    {
      "aps": {
        "alert": { "title": "New message" },
        "mutable-content": 1
      },
      "chatId": "c_8f2a",
      "seq": 1042
    }
  4. 4APNs / FCM → B の端末通知

    OS が受け取る

    この時点でアプリ本体はまだ動いていない。

  5. 5B の端末拡張が起動

    通知を書き換える

    mutable-content が立っていると、iOS は通知を出す前にアプリの Notification Service Extension を短時間だけ動かす。ここで本文を取ってきて復号し、「新着メッセージ」をメッセージ本文に差し替えて表示できる。

  6. 6B の端末 → メッセージサーバーSYNC since=1038

    前回の続きから取り直す

    接続を張り直し (前の章の流れ)、手元のカーソルを渡す。サーバーは 1038 より後ろを返すだけでいい。「未読をすべて送る」より取りこぼしが起きにくい。

    流れるデータ
    { "op": "SYNC", "cursor": { "c_8f2a": 1038 } }
  7. 7メッセージサーバー → B の端末1039 … 1042

    差分がまとめて届く

    メッセージだけでなく、既読・取り消し・メンバー変更などのイベントも同じ列に並んでいる。端末はこれを先頭から順に適用すれば、サーバーと同じ状態になる。

  8. 8B の端末 → メッセージサーバーDELIVERED upTo=1042

    ここまで受け取った

    カーソルを 1042 に進める。

  9. 9メッセージサーバー → A の端末DELIVERED

    A にも伝わる

    A がオンラインならその場で。オフラインなら A の次の SYNC で拾われる。

第 5 章・10 ステップ

サーバーには読めない手紙

TLS で守られるのは端末とサーバーのあいだだけで、サーバーの中では平文になる。エンドツーエンド暗号化 (E2EE) では、本文を開けられる鍵を両端の端末だけが持ち、サーバーは封をされたまま運ぶ。

シーケンス図A の端末, 鍵サーバー, メッセージサーバー, B の端末鍵ペア生成1公開鍵を登録2B の公開鍵は?3pub_B, keyId=74ECDH → 共通鍵5AES-GCM で暗号化6SEND ct7EVENT ct8ECDH → 復号9鍵を進める10

  1. 1B の端末鍵ペア生成

    秘密鍵は端末から出ない

    インストール時に楕円曲線 (Curve25519 など) の鍵ペアを作る。秘密鍵は端末の安全な領域にしまい、サーバーには送らない。

  2. 2B の端末 → 鍵サーバー公開鍵を登録

    公開鍵だけを置いておく

    公開鍵は見られても困らない。誰かが B に送りたくなったときのために、サーバーに預けておく。

    流れるデータ
    { "userId": 42, "keyId": 7, "pub": "Kq3…x25519 32 bytes" }
  3. 3A の端末 → 鍵サーバーB の公開鍵は?

    初めて送るとき

    A は B の公開鍵を取りに行く。一度取ったら端末に保存しておく。

  4. 4鍵サーバー → A の端末pub_B, keyId=7

    公開鍵が届く

    サーバーがここで別の鍵にすり替えれば中間者になれる。だから「鍵の指紋を対面で照合する」機能や、鍵が変わったときの警告がある。

  5. 5A の端末ECDH → 共通鍵

    鍵を送らずに同じ鍵を作る

    自分の秘密鍵と相手の公開鍵を組み合わせる (ECDH) と、B が自分の秘密鍵と A の公開鍵で計算した値と一致する。この値を鍵導出関数に通してメッセージ用の鍵を作る。

    流れるデータ
    shared = X25519(priv_A, pub_B)
    key    = KDF(shared, salt, "message")
  6. 6A の端末AES-GCM で暗号化

    改ざん検知つきで暗号化

    AES-GCM は暗号化と同時に認証タグを作る。途中で 1bit でも書き換えられれば、復号の時点で失敗する。

    流れるデータ
    nonce = random(12)
    ct, tag = AES-256-GCM(key, nonce, plaintext, aad=header)
  7. 7A の端末 → メッセージサーバーSEND ct

    サーバーには読めない封筒

    サーバーに見えるのは、誰から誰へ・いつ・どのくらいのサイズかというメタデータだけ。本文は読めない。

    流れるデータ
    {
      "op": "SEND",
      "chatId": "c_8f2a",
      "keyIds": { "from": 3, "to": 7 },
      "nonce": "3tq…",
      "body": "9f1c…e0 (ciphertext + tag)"
    }
  8. 8メッセージサーバー → B の端末EVENT ct

    そのまま運ぶ

    サーバーは中身を解釈せずに配る。

  9. 9B の端末ECDH → 復号

    同じ鍵ができる

    B は X25519(priv_B, pub_A) を計算する。値は A が作ったものと一致するので、同じ鍵で復号できる。タグの検証に失敗したら表示しない。

  10. 10B の端末鍵を進める

    過去を守る

    同じ鍵を使い続けると、いつか端末から鍵が漏れたときに過去のメッセージも全部読まれる。Signal Protocol の Double Ratchet は 1 通ごとに鍵を更新して古い鍵を捨てるので、漏れても過去は読めない (前方秘匿性)。

第 6 章・9 ステップ

グループ

グループは宛先が多いだけの 1 対 1 に見えるが、人数が増えるとどこでコピーするかと既読をどう数えるかが効いてくる。

シーケンス図A の端末, メッセージサーバー, ストレージ, B の端末, C の端末, APNs / FCMSEND chat=g_room1APPEND seq=882ACK seq=883members(g_room)4EVENT seq=885EVENT seq=886通知依頼 → D7READ upTo=888既読 19

  1. 1A の端末 → メッセージサーバーSEND chat=g_room

    グループに送る

    A が送るのは 1 通だけ。誰に配るかはサーバーが決める。

  2. 2メッセージサーバー → ストレージAPPEND seq=88

    保存は 1 回

    グループのログに 1 回だけ書き、全員がそれを読む (fan-out on read)。メンバーごとの受信箱に 1 通ずつコピーする方式 (fan-out on write) もあり、こちらは読むのが速いが、500 人のグループだと 1 通で 500 回書くことになる。

  3. 3メッセージサーバー → A の端末ACK seq=88

    送信済み

    メンバーへの配送を待たずに返す。

  4. 4メッセージサーバー → ストレージmembers(g_room)

    誰に配るか

    メンバー一覧を引き、それぞれのセッションを探す。ここは非同期のキューに積んで別のワーカーが配ることが多い。

  5. 5メッセージサーバー → B の端末EVENT seq=88

    オンラインの人にはすぐ

    B の接続に押し込む。

  6. 6メッセージサーバー → C の端末EVENT seq=88

    オンラインの人にはすぐ

    C にも。

  7. 7メッセージサーバー → APNs / FCM通知依頼 → D

    オフラインの人には通知

    D の端末はつながっていないので、前の章と同じく OS のプッシュ通知で起こす。通知を何通ぶんまとめるか、ミュート中なら送らないか、もここで判断する。

  8. 8B の端末 → メッセージサーバーREAD upTo=88

    既読の人数を数える

    各メンバーの既読位置 (upTo) を持っておけば、seq=88 を既読にした人数は「upTo ≥ 88 の人数」で出せる。

  9. 9メッセージサーバー → A の端末既読 1

    既読の数が増えていく

    A の画面に「既読 1」が出て、開いた人が増えるたびに数字が上がる。E2EE ではもう 1 つ問題があって、本文をメンバーの人数ぶん暗号化し直すのは避けたい。WhatsApp は送信者ごとの「Sender Key」を 1 対 1 の暗号路で全員に配っておき、本文は 1 回だけ暗号化する。LINE はグループ共有鍵を作って配り、メンバーが出入りするたびに作り直す。

第 7 章・10 ステップ

画像と動画

20MB の動画をテキストと同じ経路に流すと、後ろに並んだ「了解」が全部待たされる。大きいものは別の道を通し、メッセージにはその置き場所だけを書く。

シーケンス図A の端末, メディア API, オブジェクトストレージ, メッセージサーバー, B の端末縮小・暗号化1アップロードしたい2署名付き URL3PUT blob4200 OK5SEND type=image6EVENT7GET objectId8blob9検証 → 復号10

  1. 1A の端末縮小・暗号化

    送る前に端末で加工

    画像を縮小してサムネイルを作り、ランダムな鍵で暗号化する。この鍵はファイルごとに使い捨て。

    流れるデータ
    fileKey = random(32)
    blob    = AES-256-GCM(fileKey, image)
    digest  = SHA-256(blob)
  2. 2A の端末 → メディア APIアップロードしたい

    置き場所をもらう

    サイズや種類を伝えて、アップロード先を発行してもらう。

  3. 3メディア API → A の端末署名付き URL

    ストレージに直接上げさせる

    数 MB のファイルをメッセージサーバーに通すと、チャットの配送が詰まる。期限付きの署名 URL を渡して、ストレージに直接 PUT させる。

    流れるデータ
    PUT https://blob.example.com/o/3f9a…
      ?X-Expires=600&X-Signature=…
  4. 4A の端末 → オブジェクトストレージPUT blob

    暗号化済みのまま置く

    ストレージ側は中身が画像だということすらわからない。

  5. 5オブジェクトストレージ → A の端末200 OK

    置けた

    ここで初めてメッセージを送れる。

  6. 6A の端末 → メッセージサーバーSEND type=image

    メッセージは「引換券」

    画像そのものではなく、どこにあるか・どう開けるかを送る。fileKey はメッセージ本文と一緒に E2EE で暗号化されている。

    流れるデータ
    {
      "type": "image",
      "objectId": "3f9a…",
      "fileKey": "<inside E2EE body>",
      "sha256": "b1e4…",
      "thumb": "<tiny JPEG>",
      "w": 1179, "h": 2556
    }
  7. 7メッセージサーバー → B の端末EVENT

    まずサムネイル

    B の画面にはまずぼやけたサムネイルが出る。本体はタップしたとき、または Wi-Fi なら自動で取りに行く。

  8. 8B の端末 → オブジェクトストレージGET objectId

    近くの CDN から取る

    同じ画像をグループの 100 人が開いても、メッセージサーバーには負荷がかからない。

  9. 9オブジェクトストレージ → B の端末blob

    暗号化されたバイト列

    CDN のキャッシュに残っていても、鍵がなければ読めない。

  10. 10B の端末検証 → 復号

    ハッシュを照合してから開く

    SHA-256 がメッセージに書かれた値と一致するか確かめ、fileKey で復号して表示する。一致しなければ途中ですり替えられている。

第 8 章

触ってみる

A と B を好きに操作できる。B をオフラインにして送ってから戻す。「次の ACK を落とす」を入れてから送って、再送する。下の通信ログに、サーバーとのやりとりがすべて流れる。

A
サーバー
seqclientMsgIdfrom本文

配信済み位置 A=0 B=0 ・ 既読位置 A=0 B=0

B
通信ログ
  1. まだ何も流れていない。何か送ってみて。

第 9 章

実在のアプリ

ここまでの図は複数のアプリをまぜた架空のもの。ここでは各アプリが自分で公開している情報をまとめる。「—」は一次資料が見つからなかったという意味で、その機能がないという意味ではない。

アプリ端末 ↔ サーバーエンドツーエンド暗号化グループ
LINE自社製ゲートウェイ LEGY。2012 年から SPDY、現在は HTTP/2 で TLS 1.2 / 1.3 へ移行中。既定で有効Letter Sealing: Curve25519 の ECDH、AES-256-GCM (v2)。グループ共有鍵。メンバーが変わると作り直す。
WhatsAppNoise Pipes (Curve25519、AES-GCM、SHA-256)。既定で有効Signal Protocol がベース。Sender Keys を 1 対 1 のセッションで配る。配送はサーバー側で fan-out。
Signal—既定で有効鍵合意は PQXDH (2023 年に、新規チャットでは X3DH を置き換えると発表)、その後は Double Ratchet。—
iMessageAPNs 経由で届き、配送後は APNs から消える。既定で有効PQ3 (iOS 17.4 から)。—
Messenger—既定で有効Signal protocol。2023 年 12 月から、個人間のチャットで既定化を順次展開。—
TelegramMTProto 2.0。手動で有効化E2EE は別途開く Secret Chat だけ。1 対 1 限定で、端末に紐づく。通常のチャットはクラウドチャット。グループはクラウドチャット。暗号化は端末–サーバー間のみで、Telegram のクラウドに保存。
DiscordGateway は secure WebSocket。サーバーの Hello (opcode 10) がハートビート間隔を指定し、切れた端末は resume で取りこぼしを再送してもらう。一部のみテキストは E2EE ではない。音声・ビデオ通話は 2026 年 3 月から、Stage チャンネルを除いてすべて MLS ベースの DAVE で E2EE。—

LINE

  • イベントはアカウントごとに「Operation」として積まれ、それぞれが revision 番号を持つ。端末は fetchOperations(clientRev, count) をロングポーリングで呼び、何もなければ 204 No Content が返る。
  • Letter Sealing v2 は対応クライアント同士なら 1 対 1 もグループも既定で有効。送信者 ID・受信者 ID は暗号化されない。
  • メッセージの保存先は、量の増加にあわせて Redis から HBase に移り、Redis はキャッシュとして残した。

出典:LINE Encryption Overview v2.2LINE Engineering: Adopting SPDY in LINELINE DEVDAY 2019: LINTLINE Engineering: LINE Storage

WhatsApp

  • リンクした端末はそれぞれ自分の identity key を持ち、メッセージは端末ごとに別々に暗号化される。
  • 添付ファイルは AES-256-CBC と HMAC-SHA256 で暗号化して blob store に上げる。
  • 相手の端末に届くと 2 つ目のチェックがつき、読まれると 2 つとも青になる。グループではどちらも全員分がそろうまで変わらない。1 対 1 のチャットでは、どちらかが既読通知をオフにすると青にならない。

出典:WhatsApp Encryption OverviewWhatsApp Help: How to check read receipts

第 10 章

参考資料