# Bluetoothチャットアプリの作り方｜Web Bluetooth API・ESP32・BLE GATTの実装と本番設計

> ブラウザ同士はBluetoothで直接つながらないため、ESP32をGATTの中継役にしたチャットを作ります。Web Bluetoothでの接続、UTF-8メッセージの分割と再組み立て、確認応答と再送、重複排除、同時接続数の上限、ペアリングと暗号化、脅威モデルまで、テスト済みのコードつきで解説します。

- 公開日: 2026-11-17
- 著者: 友田 陽大
- タグ: Bluetooth, IoT, TypeScript, アーキテクチャ設計, 信頼性, セキュリティ
- URL: https://tomodahinata.com/blog/web-bluetooth-esp32-ble-chat-app-implementation
- カテゴリ: Bluetooth・BLE・IoT連携
- 総合ガイド: https://tomodahinata.com/blog/bluetooth-vs-wifi-osi-tcp-ip-http-ftp-guide

## 要点

- Web Bluetooth はGATTクライアント（Central）側の機能しか持たないため、ブラウザ同士はBluetoothで直接つながらない。ESP32をGATTサーバーの中継役にして、PC A → ESP32 → PC B と運ぶ
- 既定の ATT_MTU 23 では1回の書き込み・通知に載る値は20バイト。9バイトのヘッダを引くと本文は11バイトで、「こんにちは、BLE」（21バイト）は「ち」の途中で切れて2フレームになる。組み立て直してからUTF-8として解釈する
- 書き込みの成功は中継が受け取ったことしか示さない。受信側が組み立て後にACKを返し、送信側はACKを既定で3秒待ち、最大3回まで送信を試みる。受信側はメッセージIDで重複を見分け、2回目は表示せずACKだけ返す
- 送信者IDは中継が接続ハンドルから刻むが、接続ハンドルは本人確認ではない。サンプルは既定で暗号化なし。本番ではペアリング、接続を許す端末の制限、アプリ層の暗号化と署名が要る
- TypeScriptはフェイクを使ったユニットテスト、ESP32のスケッチはarduino-cliでのコンパイルまで確認済み。実ブラウザと実機での通信は未検証

---

「2台のノートPCのブラウザで、Bluetoothだけを使ってチャットしたい」。素直に考えると、片方のブラウザがもう片方に Bluetooth でつなげばよさそうです。しかし、これは今のブラウザではできません。この記事は、その「できない理由」から設計を始め、ESP32 を中継に置いたチャットを、ユニットテストとコンパイルで確かめたコードで組み立てます。

**この記事で分かること**

- ブラウザ同士が Bluetooth で直接つながらない理由と、ESP32 を中継にする構成
- GATT の設計、ATT_MTU とペイロード、UTF-8 の分割と再組み立て
- メッセージID・送信者ID、重複排除、アプリ層の確認応答と再送、切断からの復旧
- 同時接続数とバッファの上限、ペアリングと暗号化、脅威モデル
- WebRTC などとの比較と、本番採用の判断基準

**短い結論**: ブラウザは BLE の Central（GATT クライアント）にしかなれません。そこで2台のブラウザを、どちらも Central として ESP32 という Peripheral（GATT サーバー）につなぎ、ESP32 が片方の書き込みをもう片方へ通知で転送します。BLE の書き込み成功は「中継に届いた」ことしか意味しないので、受信側のアプリが ACK を返し、送信側が再送する仕組みをアプリ層に作ります。

> **検証の範囲**: TypeScript のコードは vitest のユニットテストで検証しています（Web Bluetooth はフェイクに置き換えています）。ESP32 のスケッチは arduino-cli でのコンパイルまで確認しました。**実ブラウザと実機の ESP32 での通信は未検証です。** サンプル一式は [GitHub の examples/bluetooth](https://github.com/tomodahinata/portfolio/tree/main/examples/bluetooth) にあります。

---

## 1. 前提：ブラウザ同士はBluetoothで直接つながらない

### 1-1. なぜブラウザはBLEのペリフェラルになれないのか

BLE では、自分の存在を知らせる（アドバタイズする）側が Peripheral、それを見つけて接続しにいく側が Central です。2台を直接つなぐには、片方が Peripheral として待ち受ける必要があります。

ところが Web Bluetooth の仕様は、対象を「Central の役割で動く UA（ブラウザ）が GATT サーバーに接続すること」と定めており、IDL にはアドバタイズを始める API も GATT サーバーを公開する API もありません。**ブラウザは待ち受ける側になれない**ので、2台のブラウザは互いにつなげません。ネイティブアプリなら Peripheral になれる場合がありますが、Web ページからは使えません。そこで待ち受け役を別の機器に任せます。

### 1-2. Web Bluetooth の役割

Web Bluetooth は、ブラウザから BLE 機器の GATT サーバーに接続し、キャラクタリスティック（値の入れ物）を読み書きし、通知を購読する API です。2026-11-17 時点の仕様は W3C Community Group のドラフト（最終更新 2026-06-03）で、W3C 勧告ではありません。Chrome では Android・ChromeOS・macOS・Windows でフラグなしで使え、Linux はフラグが必要です。Firefox と Safari は対応しておらず、Mozilla と WebKit は標準化に否定的な立場を表明しています。

接続の基本（`requestDevice()` のフィルタ、GATT 操作の直列化、切断後の再接続）は[Web Bluetooth API の実装ガイド](/blog/web-bluetooth-api-javascript-typescript-ble-guide)で扱いました。この記事はそこで作った接続管理クラス `BleConnection` をそのまま使い、その上に載せるチャットの層に集中します。

### 1-3. 構成：PC A → ESP32 → PC B

PC A と PC B のブラウザは、どちらも Central として ESP32 に接続します。ESP32 は Peripheral で、チャット用の GATT サービスを公開します。PC A が書き込んだフレームを、ESP32 が PC B へ通知（Notification）で送ります。逆向きも同じで、PC A と PC B の間に直接の無線のつながりはありません。

```text
 PC A (Chrome)          ESP32            PC B (Chrome)
  Central  ── write ──▶ Peripheral ── notify ──▶ Central
           ◀─ notify ── (GATT中継) ◀── write ──

  PC A ✕ PC B : Bluetooth で直接はつながらない
```

ESP32 はただの転送役ではなく、送信者の番号を付け直し、壊れたフレームを捨て、相手が受け取れない大きさのフレームを送らない、という最低限の検査をします。Bluetooth のどの層が何を担うか、BLE で HTTP や TCP が使えるかといった前提は、シリーズの[Bluetooth と Wi-Fi の違い](/blog/bluetooth-vs-wifi-osi-tcp-ip-http-ftp-guide)にまとめています。

### 1-4. 「HTMLの届け方」と「メッセージの通り道」を分ける

「Bluetooth チャットならインターネット不要」とは、無条件には言えません。2つの経路を分けて考えます。

1つ目は、**チャット画面（HTML と JavaScript）がブラウザに届く経路**です。Web Bluetooth は安全なコンテキストでしか使えず、`http://` のページには `navigator.bluetooth` がありません。安全なコンテキストは、おおまかには `https://` のページか、`localhost` のように自分の端末を指すオリジンのページです（Secure Contexts 仕様は `127.0.0.0/8` と `::1` を「潜在的に信頼できる」とし、`localhost` という名前は条件つきで同様に扱います）。https で配るなら初回の読み込みにネットワークが要り、`localhost` で配るならその準備が要ります。

2つ目は、**チャットのメッセージが通る経路**です。ページが開いたあと、メッセージは BLE だけを通り、サーバーを経由しません。

ESP32 用のコアとライブラリの導入にも、通常ネットワークを使います。ページをオフラインで開く仕組み（Service Worker など）はサンプルになく、検証もしていません。正確に言うと「**準備とページの読み込みが済めば、メッセージのやり取りにインターネットは使わない**」です。

---

## 2. ESP32を中継ペリフェラルにする

### 2-1. バージョンと、内蔵のBLEライブラリを同じスケッチで使わない理由

| 項目 | このサンプル | 確認した事実 |
|---|---|---|
| Arduino コア | esp32:esp32 3.3.12 | 2026-09-18 公開の最新の安定版。4.0.0-RC1 はプレリリース |
| BLE ライブラリ | NimBLE-Arduino 2.5.2 | 2026-10-25 公開。Arduino Library Manager の索引に登録あり |
| ボード | ESP32 Dev Module（`esp32:esp32:esp32`） | — |

コア同梱の `BLE` ライブラリは、README によれば 3.3 系の無印 ESP32 では Bluedroid を使い、4.0.0 で NimBLE に一本化される予定です。NimBLE-Arduino は自前の NimBLE ホストを持つ別のライブラリで、ヘッダ名は衝突しませんが、NimBLE を組み込んだコアとの組み合わせで起きたビルドエラーやクラッシュの修正記録が複数あります。そこで筆者の判断で、**同じスケッチで2つを混ぜず、版を固定**しています。

### 2-2. 複数のCentralを受ける：既定3台と、広告の再開

NimBLE-Arduino の設定ファイル `nimconfig.h` では、同時接続数 `CONFIG_BT_NIMBLE_MAX_CONNECTIONS` の既定は3で、コメントに「ESP32 のコントローラーの上限は9」とあります。サンプルは既定の3台を前提にしています。

もう1つの落とし穴が広告です。Core Specification の Link Layer の章では、接続要求を受けた Peripheral は広告の状態を抜けます（「shall exit the Advertising state」）。NimBLE-Arduino は接続に成功しても広告を再開せず、2.x では切断後も自動では再開しません（移行ガイド）。2台目以降を受けるには、自分で再開する必要があります。

```cpp
class ServerCallbacks : public NimBLEServerCallbacks {
  void onConnect(NimBLEServer* s, NimBLEConnInfo& info) override {
    Serial.printf("connect handle=%u peers=%u\n", info.getConnHandle(), s->getConnectedCount());
    // Central が接続すると広告が止まる。ほかの端末も参加できるよう再開する。
    if (s->getConnectedCount() < kMaxCentrals) NimBLEDevice::startAdvertising();
    if (kRequireEncryption) NimBLEDevice::startSecurity(info.getConnHandle());
  }

  void onDisconnect(NimBLEServer* s, NimBLEConnInfo& info, int reason) override {
    removeSubscriber(info.getConnHandle());
    Serial.printf("disconnect handle=%u reason=0x%x\n", info.getConnHandle(), reason);
  }
```

3台目が接続すると広告は再開せず、誰かが切断すれば `advertiseOnDisconnect(true)` で再開します。最後の行は暗号化を必須にしたときのペアリング要求です（10章）。ブラウザ側では、端末を選ぶ画面（チューザー）がページを開くたびに出ます。前に選んだ端末を受け取る `getDevices()` が、まだフラグの裏にあるためです。

---

## 3. GATTの設計：サービス1つ、RXとTX

### 3-1. UUIDは小文字のランダムな128ビット

GATT では、サービスとキャラクタリスティックを UUID で識別します。サンプルは次の3つを使います。

| 名前 | UUID | 向き | 性質 |
|---|---|---|---|
| チャットサービス | `cb777dd5-3ca7-4b0d-a487-252e8aa82b34` | — | プライマリサービス |
| RX | `97b860da-5ced-41b3-be51-d4684a734d26` | ブラウザ → ESP32 | Write（応答あり） |
| TX | `c242c325-07bb-4a81-aa61-d9e644f1dd5b` | ESP32 → ブラウザ | Notify |

RX と TX は ESP32 から見た向きです（Nordic UART Service と同じ慣習）。UUID は**小文字**で書きます。Web Bluetooth の仕様では、小文字の128ビット表記でない文字列は `TypeError` になります。また、Nordic UART Service の UUID を流用すると本物の NUS 機器と見分けがつかないので、**自分で生成したランダムな値**を使います。製品ではこのサンプルの値も生成し直してください。

ブラウザ側の入口は次のとおりです。`BleConnection` が通知の購読、書き込みの直列化、切断時の再接続を受け持ちます。

```ts
// ...
// クリックのハンドラから呼ぶこと。requestDevice() にはユーザー操作が要る。
export async function startChat(callbacks: ChatCallbacks): Promise<ChatHandle> {
  const bluetooth = getBluetooth();
  if (!bluetooth) throw new Error("Web Bluetooth is not available in this browser");

  const device = await bluetooth.requestDevice({
    filters: [{ services: [CHAT_SERVICE_UUID] }],
  });

  const session = new ChatSession({
    write: (frame) => connection.write(frame),
    onMessage: callbacks.onMessage,
    onStatus: callbacks.onStatus,
    onDiagnostic: callbacks.onDiagnostic,
  });

  const connection = new BleConnection(device, {
    service: CHAT_SERVICE_UUID,
    notifyCharacteristic: CHAT_TX_UUID,
    writeCharacteristic: CHAT_RX_UUID,
    onNotification: (value) =>
      session.receive(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)),
    onStateChange: callbacks.onConnectionState,
  });

  await connection.connect();
  return {
    session,
    close: async () => {
      session.dispose();
      await connection.disconnect();
    },
  };
}
```

`session` が参照する `connection` は次の行で作られますが、`write` が呼ばれるのは接続後なので問題ありません。

### 3-2. Write（応答あり）とNotificationの違い

ATT（Attribute Protocol）で値を運ぶ操作のうち、このサンプルに関係するのは次の4つです。

| 操作 | 向き | 応答 | このサンプルでの使い方 |
|---|---|---|---|
| Write Request（`writeValueWithResponse`） | クライアント → サーバー | Write Response が返る | RX への書き込み |
| Write Command（`writeValueWithoutResponse`） | クライアント → サーバー | なし | 使わない |
| Notification | サーバー → クライアント | なし | TX からの配信 |
| Indication | サーバー → クライアント | Confirmation が返る | 使わない |

Core Specification の ATT の章は、Write Response を「属性が正しく書き込まれたことを確認する」ものと定めています。RX に応答ありの書き込みを使うのは、ブラウザ側の Promise が「ESP32 が受け取った」ことを表すようにするためです。応答なしの書き込みは速い反面、`ATT_MTU − 3` を超える大きさを渡したときの扱いが出荷済みの API では決まっておらず、筆者は挙動を確認できていません。

TX には Notification を使います。Indication は、相手が Confirmation を返すまでその相手へ次の Indication を送れない決まりなので、相手ごとに1往復ずつ待つことになります。しかも Confirmation は相手の Bluetooth スタックが返すもので、ページがメッセージを組み立て終えたことは示しません。そこで配信は Notification にし、「相手のアプリが受け取ったか」は7章のアプリ層の ACK で確かめます。

---

## 4. ATT_MTUとペイロード、UTF-8

### 4-1. 23 − 3 = 20、ヘッダ9バイトを引いて本文11バイト

1回の書き込みや通知に載せられる値の大きさは、ATT_MTU で決まります。GATT の仕様では、LE の既定の ATT_MTU は23バイトです。ATT の書き込みと通知は、そのうち3バイトをオペコード（1バイト）と属性ハンドル（2バイト）に使い、値に使えるのは `ATT_MTU − 3` バイトです。

```text
既定       ATT_MTU 23  → 値 20  → 本文 20 − 9 = 11
交渉後の例 ATT_MTU 247 → 値 244 → 本文 244 − 9 = 235
（単位はバイト。値 = ATT_MTU − 3、本文 = 値 − ヘッダ 9）
```

「BLE は20バイトまで」は誤解です。20バイトは、MTU を交渉していない相手でも必ず通る大きさにすぎません。MTU は接続後に交渉でき、両者の受信可能な値の小さいほうになります。属性値は最大512バイトで、247 は交渉後によく見る値の一例です。

### 4-2. Web BluetoothはMTUを教えてくれない

仕様では、ブラウザは接続時に MTU を交渉しますが、その結果をページに知らせる API は 2026-11-17 時点で出荷されていません。MTU を取得する API を求める issue #383 は2018年から開いたままで、`maxWriteWithoutResponseSize` を追加する PR #672 も提案の段階です。

そのためサンプルは、**必ず通る20バイトを既定のフレームサイズ**にしています。ESP32 側は `NimBLEDevice::setMTU(247)` で大きめの MTU を希望しますが、ブラウザから結果が見えないので、速度より確実さを取りました。

```ts
export const PROTOCOL_VERSION = 1;
export const HEADER_BYTES = 9;

// ATT_MTU は最低 23 バイトで、ATT の書き込みと通知はそのうち 3 バイトを
// オペコードとハンドルに使う。したがって 20 バイトは、どの相手でも必ず
// 受け付けられる大きさであって、BLE が運べる最大値ではない。
export const MIN_ATT_MTU = 23;
export const ATT_HEADER_BYTES = 3;
export const SAFE_FRAME_BYTES = MIN_ATT_MTU - ATT_HEADER_BYTES;
```

### 4-3. 中継は切り詰めない

ATT の仕様は、属性値が `ATT_MTU − 3` より長い場合、通知では先頭の `ATT_MTU − 3` バイトしか送れないと定めています。中継が大きなフレームをそのまま通知すると、後ろが欠けたフレームが届きかねません。

そこで中継は、**受信側の MTU − 3 より大きいフレームを、切り詰めずに送らない**ことにしています。送信側は ACK が来ないのでタイムアウトで「失敗」と判断します。壊れたデータが黙って届くより扱いやすいからです。既定の20バイトで送る限り、この分岐には入りません。

---

## 5. フレーム形式とUTF-8の分割

### 5-1. バイトレイアウト

1つのフレームは、9バイトのヘッダと本文からできています。下の表は各バイトの役割です。数値はビッグエンディアンです。

| バイト | フィールド | 大きさ | 内容 |
|---|---|---|---|
| 0 | version | 1 | プロトコルの版。今は 1 |
| 1 | type | 1 | `0x01` が DATA、`0x02` が ACK |
| 2 | sender | 1 | クライアントは 0 を書き、中継が接続のラベルで上書きする |
| 3〜6 | messageId | 4 | メッセージごとの32ビットの乱数 |
| 7 | index | 1 | 0 から始まる分割番号 |
| 8 | total | 1 | 分割数（1〜255） |
| 9〜 | payload | 可変 | UTF-8 のバイト列の一部。ACK では空 |

メッセージIDを乱数にしたのは、ページを開き直しても前回のIDと衝突しにくくするためです。中継が書くラベル自体が 0 になることもあるので、画面は sender の 0 を「自分」や「不明」の意味に使ってはいけません。分割数は1バイトなので、1メッセージは最大255フレームです。

### 5-2. 分割の実例：「こんにちは、BLE」は「ち」の途中で切れる

UTF-8 では、ひらがなや読点「、」は1文字3バイト、英字は1バイトです。「こんにちは、BLE」は、ひらがな5文字と読点で18バイト、`BLE` で3バイト、合計21バイトです。1フレームの本文は11バイトなので、2フレームに分かれます。

下の図は、サンプルのテスト（`frame.test.ts`）が確かめているバイト列です。メッセージIDは `0x0a0b0c0d` に固定しています。1フレーム目は、ヘッダ9バイトのあとに「こ」「ん」「に」の9バイトと「ち」の最初の2バイト（`e3 81`）が入って20バイトです。2フレーム目は「ち」の残り1バイト（`a1`）から始まり、「は」「、」「BLE」が続いて19バイトです。縦棒はヘッダと本文の境目を示す説明用で、データには含まれません。

```text
「こんにちは、BLE」 = UTF-8 で 21 バイト
こ e3 81 93   ん e3 82 93   に e3 81 ab   ち e3 81 a1
は e3 81 af   、 e3 80 81   B 42  L 4c  E 45

フレーム1（20 バイト = ヘッダ 9 + 本文 11）
01 01 00 0a 0b 0c 0d 00 02 | e3 81 93 e3 82 93 e3 81 ab e3 81
フレーム2（19 バイト = ヘッダ 9 + 本文 10）
01 01 00 0a 0b 0c 0d 01 02 | a1 e3 81 af e3 80 81 42 4c 45
```

受信側は全フレームをそろえてから UTF-8 として解釈するので、文字の途中で切っても問題ありません。フレームごとに文字列へ変換すると、`e3 81` だけを解釈して文字化けします。

```ts
// 文字ではなくバイトの境界で分ける。3 バイトの UTF-8 文字が 2 つのフレームに
// またがることがある。受信側は再組み立てのあとで初めてデコードするので、
// この分け方で問題は起きない。
export function splitMessage(
  text: string,
  messageId: number,
  maxFrameBytes: number,
  maxMessageBytes: number,
): Uint8Array<ArrayBuffer>[] {
  const chunkBytes = maxFrameBytes - HEADER_BYTES;
  if (chunkBytes < 1) throw new RangeError(`maxFrameBytes ${maxFrameBytes} leaves no payload`);
  const utf8 = new TextEncoder().encode(text);
  if (utf8.byteLength === 0) throw new RangeError("empty message");
  if (utf8.byteLength > maxMessageBytes) {
    throw new RangeError(`message is ${utf8.byteLength} bytes, limit ${maxMessageBytes}`);
  }
  const total = Math.ceil(utf8.byteLength / chunkBytes);
  if (total > 255) throw new RangeError(`message needs ${total} frames, limit 255`);

  const frames: Uint8Array<ArrayBuffer>[] = [];
  for (let index = 0; index < total; index++) {
    const payload = utf8.subarray(index * chunkBytes, (index + 1) * chunkBytes);
    frames.push(encodeFrame({ type: FrameType.Data, sender: 0, messageId, index, total, payload }));
  }
  return frames;
}
```

受信側の `decodeFrame()` は届いたバイト列を信用できない入力として扱い、ヘッダより短い、版が違う、種類が不明、分割番号が分割数以上、本文つきの ACK、のいずれかで例外を投げます。

### 5-3. 送信者IDは中継が刻む

ヘッダ2バイト目の送信者IDは、クライアントが書いた値を信用しません。ESP32 が、書き込みを受けた接続のハンドル（接続ごとに BLE スタックが振る番号）で上書きします。

```cpp
static void relay(QueuedFrame& frame) {
  // 送信者のバイトはクライアントではなく接続から決める。ここに別の番号を
  // 書いても、ほかの参加者を名乗ることはできない。
  frame.data[2] = static_cast<uint8_t>(frame.from & 0xFF);

  uint16_t peers[kPeerSlots];
  size_t count;
  portENTER_CRITICAL(&peersLock);
  count = subscriberCount;
  memcpy(peers, subscribers, count * sizeof(uint16_t));
  portEXIT_CRITICAL(&peersLock);

  for (size_t i = 0; i < count; i++) {
    if (peers[i] == frame.from) continue;
    NimBLEConnInfo peer = server->getPeerInfoByHandle(peers[i]);
    // 表を写し取ったあとで、相手が切断しているかもしれない。
    if (peer.getConnHandle() != peers[i]) continue;
    if (kRequireEncryption && !peer.isEncrypted()) {
      skippedUnencrypted++;
      continue;
    }
    uint16_t mtu = peer.getMTU();
    // 切り詰めたフレームは決して送らない。送信側の ACK タイムアウトが気づく。
    if (mtu < 23 || frame.length > mtu - 3) {
      droppedOversize++;
      continue;
    }
    if (!txChar->notify(frame.data, frame.length, peers[i])) notifyFailures++;
  }
}
```

`notify()` には相手の接続ハンドルを必ず渡します。NimBLE-Arduino 2.5.2 のソースでは、値を渡す `notify(data, len)` はハンドルを省くと、購読の有無に関係なく接続中の全員に送ります（コメントの「購読者全員」とは違います）。そこで `onSubscribe` で購読したハンドルを表に持ち、送信者と、表を写したあとに切断した相手を除いて1台ずつ送ります。

防げるのは「接続中のほかの参加者の番号を名乗る」ことだけです。**接続ハンドルは本人確認ではありません。** 範囲内で接続できれば誰でも参加でき、ハンドルは再接続で変わることも、別の端末に再利用されることもあります。送信者のバイトは「どのリンクから来たか」のラベルで、名前の代わりにすると、再接続後に同じ人が別人に見えることがあります。

---

## 6. 再組み立て、重複排除、資源の上限

受信側の `Reassembler` は、組み立て途中のフレームを `送信者:メッセージID` のキーで集め、全部そろったら UTF-8 として解釈します。キーに送信者を含めるのは、2人がたまたま同じIDを選んでも断片が混ざらないようにするためです。

再送があるプロトコルでは、同じメッセージが2回届くことを前提にします。そこで、組み立て終えたメッセージのIDを小さな LRU（古いものから忘れる集合）に覚え、同じIDが届いたら「重複」と判定します。チャット側は重複を画面に出さず、ACK だけを返します（7章）。

重複の判定で**メッセージIDだけ**を見るのは意図した設計です。再接続すると再送が別の送信者のバイトで届くことがあり、送信者まで含めると2回表示してしまいます。その代償として、別々の参加者が直近64件の範囲で偶然同じ32ビットの乱数を選ぶと、後のほうを表示しません。確率は無視できると判断しました。

ただし、これは偶然の衝突の話です。メッセージIDは全員に平文で配られるので、悪意のある参加者は、分割の途中にあるメッセージと同じIDで短いメッセージを先に送り込めます。受信側は本物の残りのフレームを重複とみなして表示せず、ACK まで返すので、送信者には「届いた」と表示されます。参加者を信用できない環境では、重複の判定を署名つきの（送信者の鍵, 連番）で行う必要があります。

もう1つ大事なのが、**どのバッファにも上限がある**ことです。上限がなければ、分割数だけ大きく宣言して残りを送らないフレームを大量に送られるだけで、メモリを使い果たします。既定の上限は次のとおりです。

- 1メッセージ1024バイト、分割数128
- 組み立て途中のメッセージは全体で16件、同じ送信者からは4件まで
- 組み立て途中のメッセージは、**最後のフレームが届いてから**10秒で捨てる
- 重複排除の記憶は64件

1024バイトを本文11バイトずつ送ると94フレームで、分割数の上限128に収まります。保持時間を最後のフレームから数えるのは、遅いリンクで長いメッセージを途中で切らないためです。94フレームを送り切る時間は接続間隔などで決まり、筆者は計測していません。

```ts
  accept(frame: Frame): ReassemblyResult {
    // 重複は messageId だけで判定する。中継は送信者を接続ハンドルから刻むが、
    // ハンドルは相手が再接続すると変わりうるので、再接続後の再送は別の
    // 送信者のバイトで届く。32 ビットの乱数なので記憶の範囲内での偶然の衝突は
    // 無視できるが、ほかの参加者が意図的に同じ ID を使うことは防げない（本文参照）。
    if (this.completed.has(frame.messageId)) {
      return { kind: "duplicate", sender: frame.sender, messageId: frame.messageId };
    }
    if (frame.total > this.limits.maxChunks) {
      return { kind: "rejected", reason: `too many chunks: ${frame.total}` };
    }
    if (frame.payload.byteLength > this.limits.maxMessageBytes) {
      return { kind: "rejected", reason: `message exceeds ${this.limits.maxMessageBytes} bytes` };
    }
    // 1 フレームのメッセージは組み立て途中の枠を使わない。枠を埋める相手が
    // いても、ほかの参加者の短いメッセージは止められない。
    if (frame.total === 1) return this.finish(frame, [frame.payload]);

    this.sweep();
    const key = `${frame.sender}:${frame.messageId}`;
    let entry = this.pending.get(key);
    if (!entry) {
      const rejected = this.checkQuota(frame.sender);
      if (rejected) return rejected;
      entry = {
        sender: frame.sender,
        total: frame.total,
        chunks: new Array<Uint8Array | undefined>(frame.total),
        received: 0,
        bytes: 0,
        lastSeenAt: this.now(),
      };
      this.pending.set(key, entry);
    }
    // ...
    entry.chunks[frame.index] = frame.payload;
    entry.received += 1;
    entry.lastSeenAt = this.now();
    if (entry.received < entry.total) return { kind: "incomplete" };

    this.pending.delete(key);
    return this.finish(frame, entry.chunks);
  }
```

デコーダーは `fatal: true` で作っており、不正な UTF-8 を拒否します。順序が入れ替わっても組み立てられます。期限切れで捨てた件数は、チャット側が診断イベント `expired` で知らせます。重複排除の記憶は64件なので、それより古いメッセージの再送はもう一度表示されます。

---

## 7. 確認応答（ACK）・再送・タイムアウト

### 7-1. リンク層の再送があってもACKが要る理由

Core Specification の Link Layer の章は、すべての ACL 接続でリンク層の確認応答とフロー制御を使い、確認されていない PDU は再送すると定めています。それでもアプリ層の ACK は要ります。リンク層の確認は、**1本の無線リンクの両端の間**の話だからです。この構成には PC A → ESP32 と ESP32 → PC B の2本のリンクがあり、間に ESP32 のキューとソフトウェアが挟まります。

PC A の書き込みが成功しても、分かるのは ESP32 が受け取ったことだけです。キューが満杯なら捨てられ、PC B の MTU が小さければ送られません。Web Bluetooth の仕様自身も、切断から購読し直すまでの間に「一部の通知を取りこぼす避けられない危険がある」と書いています。相手のチャット画面が組み立てられたかを知るには、相手のアプリに返事をしてもらうしかありません。TCP が信頼できない IP の上に到達確認を作るのと同じ考え方です（[TCP と UDP の違い](/blog/tcp-vs-udp-quic-http3-difference-when-to-use-guide)）。[WebSocket と SSE の設計判断ガイド](/blog/websocket-sse-realtime-architecture-decision-guide)で書いた冪等性・ACK・再接続の考え方も、そのまま当てはまります。

既定値は、ACK を待つ時間 `ackTimeoutMs` が3000ミリ秒、送信の試行回数 `maxAttempts` が3回、同時に送信中にできるメッセージ数 `maxInFlight` が4件です。

### 7-2. 送信メッセージの状態遷移

送信メッセージは4つの状態をとります。`send()` で `sending`、全フレームを書き込むと `awaiting-ack`、ACK を受けると `delivered` です。ACK が書き込み完了より先に届けば `sending` から直接 `delivered` になります。ACK が来ないまま `ackTimeoutMs` が過ぎたら、試行回数が上限未満なら `sending` に戻って全フレームを送り直し、上限なら `failed` です。書き込みの失敗も同じ扱いです。

```text
 send()
   │
   ▼
 sending ─────── ACK ───────▶ delivered
   │                              ▲
   │ 書き込み完了                 │
   ▼                              │
 awaiting-ack ── ACK ─────────────┘
   │
   │ ackTimeoutMs 経過
   │（書き込み失敗のときは sending から）
   ▼
 試行 < maxAttempts ?
   │ はい：sending に戻り、全フレームを再送
   │ いいえ
   ▼
 failed
```

### 7-3. 送信とACKのシーケンス

PC A が1フレーム目を応答ありで書き込むと、ESP32 の `onWrite` はキューに入れて戻り、その時点で PC A に Write Response が返ります。番号を刻んで PC B へ通知するのは、あとで `loop()` が取り出したときです。2フレーム目も同じです。PC B はそろったら組み立てて表示し、ACK を書き込みます。ESP32 がそれを PC A へ通知し、PC A は `delivered` にします。

```text
 PC A           ESP32               PC B
  │ write F1       │                   │
  │───────────────▶│ キューに入れる    │
  │◀─ Write Resp ──│                   │
  │                │ notify F1         │
  │                │──────────────────▶│
  │ write F2       │                   │
  │───────────────▶│ キューに入れる    │
  │◀─ Write Resp ──│                   │
  │                │ notify F2         │
  │                │──────────────────▶│
  │ awaiting-ack   │      組み立て・表示
  │                │◀──── write ACK ───│
  │                │── Write Resp ────▶│
  │                │ notify ACK        │
  │◀───────────────│                   │
  │ delivered      │                   │
```

ACK が失われると、PC A はタイムアウト後に F1 と F2 を送り直します。PC B では再送のフレームがすべて重複になるので、画面には出さず、**最後のフレームを受けたときに1回だけ** ACK を返します。ACK を返さなければ、PC A は再送を繰り返して `failed` と表示してしまいます。

```ts
    const result = this.reassembler.accept(frame);
    const expired = this.reassembler.takeExpiredCount();
    if (expired > 0) this.options.onDiagnostic?.({ type: "expired", count: expired });
    switch (result.kind) {
      case "complete":
        this.options.onMessage({
          sender: result.sender,
          messageId: result.messageId,
          text: result.text,
        });
        this.sendAck(result.messageId);
        break;
      case "duplicate":
        // 先に返した ACK が失われ、送信側が再送してきた。もう一度 ACK を返すが、
        // メッセージを 2 回表示はしない。再送のフレームはすべて重複になるので、
        // フレームごとではなく最後のフレームで 1 回だけ ACK を返す。
        if (frame.index === frame.total - 1) this.sendAck(result.messageId);
        break;
      case "rejected":
        this.options.onDiagnostic?.({ type: "frame-rejected", reason: result.reason });
        break;
      case "incomplete":
        break;
    }
```

ACK の書き込みは、データの送信待ちの列を通しません。長いメッセージの送信中に ACK が相手のタイムアウトに遅れるのを避けるためです。GATT 操作の直列化は `BleConnection` が受け持ちます。

```ts
  // ACK はデータの送信待ちの列を通さないので、長い送信メッセージがあっても
  // 相手のタイムアウトを過ぎるほど遅れることはない。通信路（BleConnection の
  // GattQueue）は、それでも GATT 操作を 1 つずつ実行する。
  private sendAck(messageId: number): void {
    if (this.disposed) return;
    this.options.write(encodeAck(messageId)).catch(() =>
      this.options.onDiagnostic?.({ type: "write-failed", messageId, attempt: 0 }),
    );
  }
```

再送のタイマーは、試行ごとに書き込みが終わったとき（成功でも失敗でも）に仕掛けます。

```ts
  private transmit(messageId: number): void {
    const entry = this.outgoing.get(messageId);
    if (!entry) return;
    entry.attempt += 1;
    const attempt = entry.attempt;
    this.options.onStatus?.(messageId, "sending");

    this.enqueueWrite(async () => {
      for (const frame of entry.frames) {
        if (this.disposed) return;
        await this.options.write(frame);
      }
    })
      .then(
        () => {
          if (this.outgoing.has(messageId)) this.options.onStatus?.(messageId, "awaiting-ack");
        },
        () => this.options.onDiagnostic?.({ type: "write-failed", messageId, attempt }),
      )
      .finally(() => this.armAckTimer(messageId));
  }

  // 書き込みの失敗は ACK が失われたのと同じに扱う。待ってから再送する。
  // これで、BleConnection が再接続している間の短い切断も吸収できる。
  private armAckTimer(messageId: number): void {
    const entry = this.outgoing.get(messageId);
    if (!entry) return;
    entry.timer = setTimeout(() => {
      if (entry.attempt >= this.maxAttempts) {
        this.settle(messageId, "failed");
        return;
      }
      this.options.onDiagnostic?.({ type: "retry", messageId, attempt: entry.attempt + 1 });
      this.transmit(messageId);
    }, this.ackTimeoutMs);
  }
```

### 7-4. 「delivered」が意味すること

ACK の設計には、本番で必ず問われる限界があります。

- **3人以上なら「誰か1人が受け取った」の意味になる。** ACK にはメッセージIDしかなく、送信側は最初の ACK で `delivered` にします。全員への到達を示すには、ACK に受信者を入れて参加者ごとに管理する必要があります。
- **ACK は偽造できる。** DATA フレームは全員に配られるので、参加者は他人のメッセージIDの ACK を送れます。
- **相手がいなければ必ず失敗する。** 接続しているのが自分だけなら、ACK は来ません。

---

## 8. 切断からの復旧

BLE の接続は、距離や電波の状況、スリープで簡単に切れます。復旧は2つの層で分担しています。

- **接続の層（`BleConnection`）**: 意図しない切断を検知すると、指数バックオフで再接続します。既定は最大5回、遅延は `[0, min(8000, 500 × 2^試行)]` ミリ秒の乱数（フルジッター）です。1回の試行は `connectTimeoutMs`（既定10000ミリ秒）で `gatt.disconnect()` により打ち切るので、`reconnecting` のまま止まりません。接続に失敗したときや再接続を諦めるときは、リンクを閉じてから `failed` にし、半端な接続を残しません。詳しくは[Web Bluetooth API の実装ガイド](/blog/web-bluetooth-api-javascript-typescript-ble-guide)で扱っています。
- **メッセージの層（`ChatSession`）**: 再接続中の書き込みはすぐに失敗します。それを1回の試行として数え、タイムアウトを待って再送します。再接続が間に合えば、再送で届きます。

接続の状態は、`connect()` で `connecting`、成功で `connected`、失敗で `failed` です。意図しない切断で `reconnecting` になり、成功すれば `connected` に戻り、5回失敗すれば `failed` です。`disconnect()` はどの状態からでも `disconnected` にし、自動の再接続をしません。

```text
 connect()
   │
   ▼
 connecting ── 失敗 ──────▶ failed
   │ 成功                     ▲
   ▼                          │ 5回失敗
 connected ◀─ 成功 ──────── reconnecting
   │                          ▲
   └── 意図しない切断 ────────┘

 disconnect() → どの状態からでも disconnected
```

2つの層の時間の兼ね合いに注意が要ります。メッセージ側は、試行の書き込みが終わるか失敗するたびに3000ミリ秒のタイマーを仕掛けるので、再接続中（書き込みがすぐ失敗する）は約9秒で `failed` になります。再接続側は、待ち時間の上限の合計 500 + 1000 + 2000 + 4000 + 8000 = 15500ミリ秒に、打ち切りまでの 5 × 10000 = 50000ミリ秒が加わりうるので、`failed` まで最大約65.5秒です。つまり、**再接続が6秒ほどより長くかかると、その間に送ったメッセージは失敗扱いになります**。いずれも計算上の目安で、計測値ではありません。「再送」ボタンを出すか、`maxAttempts` と `ackTimeoutMs` を延ばすかは要件で決めます。

再接続をまたいだ再送は、メッセージIDで重複を判定するので2回表示しません。ただし「誰の発言か」は別人に見えることがあり、本番では再接続で変わらない識別子（ボンディング済み端末の識別アドレスや参加者ID）を使うべきです。`close()` が呼ぶ `session.dispose()` は、再送を止め、以後のフレームを無視し、`send()` を例外にします。

---

## 9. バッファの上限とバックプレッシャー

サンプルは各所に上限を置き、超えたら「ためる」のではなく「断る」ようにしています。

| 場所 | 上限 | 超えたときの動き |
|---|---|---|
| ブラウザの送信（`maxInFlight`） | 4件 | `send()` が `BackpressureError` を投げる |
| ブラウザの GATT 操作 | 直列に1つずつ | 次の操作は前の完了を待つ |
| ESP32 の受信キュー | 16フレーム | 捨てて `droppedQueueFull` を数える |
| ESP32 の同時接続 | 3台 | 広告を再開せず、新しい接続を受けない |
| 受信側の組み立て途中 | 全体16件・送信者ごと4件、最後のフレームから10秒 | 新しいメッセージを拒否し、期限切れを捨てる |

送信中が4件に達すると例外を投げるので、画面は送信ボタンを無効にして結果を待ちます。

```ts
  // 際限なくためる代わりに BackpressureError を投げる。UI はメッセージの
  // 結果が出るまで送信ボタンを無効にすること。
  send(text: string): number {
    if (this.disposed) throw new Error("ChatSession is disposed");
    if (this.outgoing.size >= this.maxInFlight) {
      throw new BackpressureError(`${this.maxInFlight} messages are still in flight`);
    }
    let messageId = this.newMessageId();
    while (this.outgoing.has(messageId)) messageId = this.newMessageId();
    const frames = splitMessage(text, messageId, this.maxFrameBytes, this.limits.maxMessageBytes);
    this.outgoing.set(messageId, { frames, attempt: 0 });
    this.transmit(messageId);
    return messageId;
  }
```

ESP32 の書き込みのコールバックは NimBLE のホストタスク（FreeRTOS のタスク）で動くので、ここで配信まで済ませると、ほかの接続の BLE イベントが待たされます。そこでキューに入れてすぐ戻り、配信は `loop()` で行います。満杯なら捨てます。これは NimBLE-Arduino の規則ではなく筆者の設計判断です。

```cpp
class RxCallbacks : public NimBLECharacteristicCallbacks {
  // NimBLE のホストタスクの上で動く。バイト列をキューにコピーしてすぐ戻る。
  void onWrite(NimBLECharacteristic* chr, NimBLEConnInfo& info) override {
    NimBLEAttValue value = chr->getValue();
    if (value.size() < kHeaderBytes || value.size() > kMaxFrameBytes) {
      droppedMalformed++;
      return;
    }
    QueuedFrame frame;
    frame.from = info.getConnHandle();
    frame.length = value.size();
    memcpy(frame.data, value.data(), value.size());
    if (xQueueSend(frameQueue, &frame, 0) != pdTRUE) droppedQueueFull++;
  }
};
```

キューが満杯で捨てても、Write Response は返るのでブラウザ側は成功に見えます。書き込み成功を「届いた」とみなせない理由の1つです。

---

## 10. 認証・認可・暗号化

### 10-1. サンプルの既定は暗号化なし

NimBLE-Arduino 2.5.2 の初期化処理は、ボンディング（鍵の保存）なし、MITM（中間者攻撃）対策なし、LE Secure Connections なし（レガシーペアリング）、入出力の能力は NoInputNoOutput、という既定値を設定します。サンプルは `kRequireEncryption = false` が既定です。**この状態では、チャットの内容は暗号化されずに電波で飛びます。**

### 10-2. kRequireEncryptionを有効にしたとき

`kRequireEncryption` を `true` にすると、スケッチは次のことをします。

1. `setSecurityAuth(true, false, true)` で、ボンディングを有効にし LE Secure Connections を希望する（MITM 対策は無効）。
2. 接続のたびに `startSecurity()` でペアリングを求める（2章）。
3. RX に `WRITE_ENC` を付ける。移行ガイドの説明では「ペアリング済み（暗号化済み）でないと書き込めない」属性で、暗号化されていない書き込みは BLE スタックで拒否されます。
4. 配信のたびに、暗号化されていない相手を飛ばす。購読はペアリングより先に起きることが多いので、1フレームごとに確かめます。

```cpp
  NimBLEService* service = server->createService(kServiceUuid);
  uint32_t rxProperties = NIMBLE_PROPERTY::WRITE;
  if (kRequireEncryption) rxProperties |= NIMBLE_PROPERTY::WRITE_ENC;
  NimBLECharacteristic* rx = service->createCharacteristic(kRxUuid, rxProperties);
  rx->setCallbacks(new RxCallbacks());
  txChar = service->createCharacteristic(kTxUuid, NIMBLE_PROPERTY::NOTIFY);
  txChar->setCallbacks(new TxCallbacks());
```

この設定でもコンパイルできることは確認しました（12章）。ただし、**実機での動作は未検証**で、守れる範囲も限られます。

- **LE Secure Connections は強制されない。** この設定は「相手も対応していれば SC を使う」もので、相手が対応していなければレガシーペアリングに落ちます。SC 以外を拒む設定はサンプルにありません（未検証）。NIST SP 800-121 Rev. 2 は、128ビットの一時鍵による OOB を除き、LE のレガシーペアリングは「破られているとみなすべき」としています。ペアリングのやり取りを傍受できれば、得られた長期鍵を割り出せるからです。
- **MITM は防げない。** この ESP32 には数字を表示する画面も入力する手段もありません（NoInputNoOutput のまま）。NIST は、入出力の制約でほかの方式が使えないときは Just Works になり、Just Works は MITM 対策がなく LE で最も弱い方式だとしています。
- **ブラウザがペアリングを完了するとは限らない。** 仕様はボンディングを試みてもよい（MAY）としか書かず、Chrome の実装状況で必要時のペアリングに印があるのは Android と Mac だけです。ほかの OS では事前のペアリングが要る可能性があります（未確認）。
- **認可にはならず、中継は平文を見る。** ペアリングできれば誰でも暗号化されたリンクを持てます。リンクの暗号化は区間ごとで、ESP32 の中ではメッセージは平文です。

### 10-3. 接続ハンドルは本人確認ではない

接続ハンドルは「今どの接続から来たか」を区別する番号で、「誰か」を示すものではありません。認可（誰が参加してよいか）を決めるには、ボンディング済みの端末の識別アドレスを許可リストと照らすか、アプリ層で参加者ごとの鍵を使う必要があります。

ボンディングに基づく許可リストは、登録の時間以外はペアリングを受け付けないようにして初めて意味を持ちます。NimBLE-Arduino が保存できるボンディングの既定数は3（`CONFIG_BT_NIMBLE_MAX_BONDS`）で、既定のコールバック（`ble_store_util_status_rr`）はあふれると最も古い相手の情報を消すコードです。新しいペアリングが登録済みの端末を押し出す可能性があります（ソースで確認、実機では未確認）。

---

## 11. なりすましと信頼境界：脅威モデル

限界を脅威ごとに整理します。「すること」「しないこと」はコードから読み取れる事実、「本番での対策」は筆者の推奨で、組み合わせて使うものです。

| 脅威 | 具体例 | サンプルがすること | しないこと | 本番での対策 |
|---|---|---|---|---|
| なりすまし | 別の参加者の番号を名乗る | 送信者IDを中継が接続ハンドルから刻む | 参加者の本人確認。ハンドルの変化と再利用への対応 | ボンディング済み端末の許可リスト、参加者ごとの鍵によるアプリ層の署名 |
| ACK の偽造 | 他人のメッセージIDで ACK を送る | なし | ACK の宛先と送り主の検証 | ACK に受信者を入れて署名する |
| 重複判定の汚染 | 他人のメッセージIDで先に送り、本物を重複扱いさせる | なし | ID の持ち主の確認 | 署名の対象に送信者ごとの連番を含め、（鍵, 連番）で重複を判定する |
| 改ざん | 中継や途中で本文を書き換える | 形式の検査（版・種類・分割番号） | 本文の完全性の検証 | 認証付き暗号（AEAD）か署名をアプリ層で付ける |
| リプレイ | 記録したフレームをあとで流し直す | 直近64件の重複排除 | それより古いフレームの拒否 | 署名の対象に送信者ごとの連番か時刻を含め、連番を永続化する |
| 資源の枯渇 | 大量のフレーム、組み立ての枠や接続枠の占有 | 組み立て（全体16件・送信者ごと4件、1フレームは枠を使わない）・キュー・送信数・接続数の上限 | 再接続で送信者のバイトを変えながら送る相手への対策（全体の16件は埋まりうる）、居座る接続の切断 | 許可リスト外の接続を切る、端末ごとの流量制限 |
| 盗聴 | 電波を傍受して本文を読む | 既定ではなし（暗号化は任意） | 既定での暗号化、SC の強制、MITM 対策 | SC のみを許可、表示や入力のある機器ならパスキーなどの方式、アプリ層のエンドツーエンド暗号化 |
| 偽の中継 | 同じサービス UUID で広告する偽の ESP32 | なし（UUID で探すだけ） | 中継の真正性の確認 | 中継に鍵を持たせてチャレンジ・レスポンスで確かめる、中継を信用しない E2E 暗号化 |

信頼境界は2本あります。誰でも傍受・接続を試みられる無線の区間と、すべてを平文で見て送信者IDと配信先を決める ESP32 そのものです。サンプルは「中継は正直」という前提の作例で、中継を信用しないなら、暗号化と署名をブラウザの中で完結させます。

---

## 12. 動かす手順とテスト

### 12-1. 動かすまでの手順

ESP32 側は、筆者が実行したコマンドで導入とコンパイルまでを示します。

```bash
arduino-cli config init
arduino-cli config add board_manager.additional_urls https://espressif.github.io/arduino-esp32/package_esp32_index.json
arduino-cli core update-index
arduino-cli core install esp32:esp32@3.3.12
arduino-cli lib install "NimBLE-Arduino@2.5.2"
arduino-cli compile --fqbn esp32:esp32:esp32 --warnings all ble_chat_relay
```

ボードへの書き込み（Arduino IDE や arduino-cli の upload）は、筆者は実行していません（未検証）。

ブラウザ側は TypeScript のモジュールで、画面は含みません。任意のバンドラーでまとめ、クリック処理から `startChat()` を呼ぶページを作り、`localhost` か https で配信します。ページの配信と Chrome からの接続も未検証です。

### 12-2. vitestとFakeRelay

vitest のテストは、Web Bluetooth と ESP32 の代わりをするフェイクの上で動きます。`FakeRelay` が写すスケッチの規則は3つだけ（送信者の番号を刻む、送信者以外に配る、MTU − 3 を超えるフレームは送らない）で、購読の表、暗号化の確認、キューの上限は再現していません。主に次のことを確かめています。

- 5章のバイト列。文字の途中で切れても、順序が逆でも組み立てられる
- ACK を失うと再送し、受信側は1回だけ表示して ACK を1回だけ返す。送信者のバイトが変わった再送も同じ
- ACK が来なければ `failed`、短いリンク断のあとは再送で届く、MTU を超えるフレームは届かない
- 各種の上限、1フレームのメッセージが枠を使わないこと、保持時間、期限切れの件数、`dispose()`

実行結果は次のとおりです（2026-11-17 に筆者の環境で実行）。

```bash
npx vitest run examples/bluetooth/ble-chat
```

```text
 ✓ examples/bluetooth/ble-chat/web/chat-session.test.ts (11 tests) 10ms
 ✓ examples/bluetooth/ble-chat/web/reassembler.test.ts (14 tests) 3ms
 ✓ examples/bluetooth/ble-chat/web/frame.test.ts (13 tests) 3ms

 Test Files  3 passed (3)
      Tests  38 passed (38)
```

テストが通っても、実際のブラウザと ESP32 がつながる証明にはなりません。Chrome の挙動、MTU の交渉、電波は再現していません。

### 12-3. ESP32のコンパイルとシリアルログ

スケッチは arduino-cli 1.6.0、esp32:esp32 3.3.12、NimBLE-Arduino 2.5.2 で、警告をすべて有効にしてコンパイルしました。`kRequireEncryption` が `false`（コミットされている設定）と `true` の両方で、終了コード0、スケッチ由来の警告なしです。

```text
kRequireEncryption = false（コミットされている設定）
Sketch uses 587784 bytes (44%) of program storage space. Maximum is 1310720 bytes.
Global variables use 36012 bytes (10%) of dynamic memory, leaving 291668 bytes for local variables. Maximum is 327680 bytes.

kRequireEncryption = true（一時的に書き換えたコピー）
Sketch uses 587888 bytes (44%) of program storage space. Maximum is 1310720 bytes.
Global variables use 36012 bytes (10%) of dynamic memory, leaving 291668 bytes for local variables. Maximum is 327680 bytes.
```

確認できたのはコンパイルまでで、**書き込み、広告、Chrome との接続、MTU の交渉、複数台の中継はどれも未検証**です。

実機での手がかりはシリアルログ（115200bps）です。接続・切断・MTU の変更と、10秒ごとに接続数と捨てたフレームの数（`queue`・`malformed`・`oversize`・`notifyFail`・`unencrypted`）を表示します。**メッセージの本文はログに出しません。** ブラウザの診断イベントも ID・理由・件数だけです。GATT サーバーの見え方は、nRF Connect のような汎用の BLE スキャナーアプリで、ブラウザを介さずに切り分けられます。

### 12-4. 教材のサンプルと本番の違い

このサンプルは教材です。本番には、参加者の認証と認可、アプリ層の暗号化と署名、再接続で変わらない送信者ID、宛先つきの ACK、履歴と再同期、iPhone を含むブラウザの対応、実機での試験（距離、混雑した電波、長時間の運転、電池）が足りません。

サンプルはメッセージを保存しません。履歴を残すなら IndexedDB を使い、保持期間と削除の手段を決め、鍵やパスワードを平文で保存しないことです。保存すると再接続後の再同期が新たな論点になります。

---

## 13. WebRTC・Wi-Fi Direct・ネイティブBLEアプリとの比較

サーバーなしでメッセージを送るほかの方法と、確認できた範囲で比べます。

| 観点 | Web Bluetooth + ESP32 中継（この記事） | WebRTC データチャネル | ネイティブ BLE アプリ |
|---|---|---|---|
| 通り道 | BLE（GATT） | IP ネットワーク（SCTP over DTLS over UDP） | BLE |
| 追加の機器 | ESP32 が必要 | 不要 | 端末が Peripheral になれるなら不要 |
| 接続の準備 | ユーザーが端末を選ぶ | シグナリング（接続情報の交換）を別の経路で行う | アプリの導入と OS の権限 |
| Web ページからの利用 | Chrome 系のみ。Firefox・Safari は非対応 | Chrome・Firefox・Safari が対応（MDN の互換性データ） | 該当しない（アプリ） |
| 1フレームの大きさ | 既定では20バイト（本文11バイト） | BLE の ATT_MTU の制約は受けない | BLE と同じ制約 |

RFC 8825 によれば、WebRTC のシグナリングはアプリ固有の方法で、通常は TLS で保護された Web の技術で行います。データチャネルは RFC 8831 で SCTP over DTLS over UDP と定められています。Wi-Fi Direct は、Web ページから扱う標準 API を 2026-11-17 時点で筆者は確認できておらず、表に入れていません。

筆者の整理では、**機器がもともと BLE で、ブラウザから扱いたい**場合に Web Bluetooth が有力です。大きなデータや iPhone の Safari が必要なら、WebRTC やネイティブを先に検討します。

---

## 14. 本番採用の判断基準

製品に使うかを判断する確認項目です。外部に頼む場合も同じ項目で確認できます。

**利用環境**

- [ ] 利用者のブラウザは Chrome 系に限定できるか。iPhone の Safari は対象外でよいか
- [ ] Windows・ChromeOS・Linux で、OS での事前のペアリングを利用者に求められるか
- [ ] ページの配信方法（https か、端末ごとの localhost か）と、初回の読み込みにネットワークを使えるかを決めたか

**通信と信頼性**

- [ ] 同時に何台つながるか。既定の3台で足りるか、増やすなら実機で試験したか
- [ ] 「届いた」の定義は「誰か1人」か「全員」か。ACK をどう設計するか
- [ ] 再接続にかかる時間と、再送をあきらめるまでの時間の関係を決めたか
- [ ] MTU を前提にできない Web Bluetooth で、必要なデータ量を運べるか

**セキュリティ**

- [ ] 誰が参加してよいか（認可）をどう決めるか。接続ハンドルに頼っていないか
- [ ] Just Works を避けられるか。NIST SP 800-121 Rev. 2 は、LE で Just Works を使うべきでないとしている。避けるなら中継に表示や入力の手段を持たせるか
- [ ] 常に接続可能な状態を避けられるか。NIST は、発見可能・接続可能な状態は攻撃を受けやすく最小限にとどめるべきとしている（この中継は3台未満なら広告を続ける）
- [ ] 中継を信用するか。しないなら、アプリ層の暗号化と署名の鍵をどう配るか
- [ ] ログや端末内の保存に、会話の内容や秘密の情報を残さないか

**検証**

- [ ] 実機で、距離・電波の混雑・長時間の運転・切断と再接続を試験する計画があるか
- [ ] ファームウェアとライブラリの版を固定し、コアの更新（4.0 での NimBLE への移行など）で試し直す手順があるか
- [ ] 外部に頼む場合、相手が検証済みと未検証の範囲を分けて説明できるか

---

## 15. まとめ

- ブラウザは Central にしかなれないので、ESP32 を Peripheral の中継にして PC A → ESP32 → PC B と運びます。「インターネット不要」は、準備とページの読み込みのあとのメッセージについてだけ成り立ちます。
- 既定の ATT_MTU 23 では1回20バイト。11バイトずつ UTF-8 のバイト列を分け、そろってから文字列に戻します。
- 書き込みの成功は「中継に届いた」だけなので、ACK・再送・メッセージIDによる重複排除をアプリ層に作ります。
- バッファには上限を置きます。送信者IDは本人確認ではなく、暗号化は既定で無効で、有効にしても SC は強制されず、Just Works には MITM 対策がありません。
- TypeScript はフェイクでのテスト、ESP32 はコンパイルまで確認済みで、実機での通信は未検証です。
