diff --git a/.gitignore b/.gitignore index ba4cec2..fc91269 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ *.pem *.key .DS_Store +.mockups/ diff --git a/Cargo.lock b/Cargo.lock index 2433872..50fb81c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1496,22 +1496,28 @@ dependencies = [ [[package]] name = "kc-cli" -version = "0.2.0" +version = "0.3.0" dependencies = [ "base64 0.22.1", + "block2", "clap", "crossterm", "ctrlc", "directories", "fd-lock", "gethostname", + "hmac 0.12.1", "humantime", "inquire", "kc-proto", "kc-relay", "kc-store", + "kc-sync", "kc-wire", "libc", + "objc2", + "objc2-foundation", + "objc2-local-authentication", "postcard", "reqwest", "rustls", @@ -1523,12 +1529,13 @@ dependencies = [ "thiserror", "tokio", "toml", + "windows", "zeroize", ] [[package]] name = "kc-proto" -version = "0.2.0" +version = "0.3.0" dependencies = [ "base64 0.22.1", "chacha20poly1305", @@ -1551,7 +1558,7 @@ dependencies = [ [[package]] name = "kc-relay" -version = "0.2.0" +version = "0.3.0" dependencies = [ "anyhow", "axum", @@ -1579,7 +1586,7 @@ dependencies = [ [[package]] name = "kc-store" -version = "0.2.0" +version = "0.3.0" dependencies = [ "apple-native-keyring-store", "directories", @@ -1601,9 +1608,19 @@ dependencies = [ "zeroize", ] +[[package]] +name = "kc-sync" +version = "0.3.0" +dependencies = [ + "rand", + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "kc-wire" -version = "0.2.0" +version = "0.3.0" dependencies = [ "serde", "serde_json", @@ -1839,6 +1856,27 @@ version = "4.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags", + "objc2", +] + +[[package]] +name = "objc2-local-authentication" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e48e0b8b339e0d9d2ed4416b7f93f9d4daadff7d4dd797f89867cde11aeac607" +dependencies = [ + "block2", + "objc2", + "objc2-foundation", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -3120,6 +3158,51 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6" +dependencies = [ + "windows-core", + "windows-targets", +] + +[[package]] +name = "windows-core" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-result", + "windows-strings", + "windows-targets", +] + +[[package]] +name = "windows-implement" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-interface" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "windows-link" version = "0.2.1" @@ -3139,6 +3222,25 @@ dependencies = [ "zeroize", ] +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result", + "windows-targets", +] + [[package]] name = "windows-sys" version = "0.52.0" diff --git a/Cargo.toml b/Cargo.toml index 4800691..dabfd75 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,9 +1,9 @@ [workspace] resolver = "3" -members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli"] +members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli", "crates/kc-sync"] [workspace.package] -version = "0.2.0" +version = "0.3.0" edition = "2024" rust-version = "1.88" license = "MIT" @@ -15,9 +15,10 @@ authors = ["Dcode "] # `dep = { workspace = true, features = [...] }`. A lane that needs a crate that # isn't listed here may add it to its own Cargo.toml directly. [workspace.dependencies] -kc-wire = { path = "crates/kc-wire", version = "0.2.0" } -kc-proto = { path = "crates/kc-proto", version = "0.2.0" } -kc-store = { path = "crates/kc-store", version = "0.2.0" } +kc-wire = { path = "crates/kc-wire", version = "0.3.0" } +kc-proto = { path = "crates/kc-proto", version = "0.3.0" } +kc-store = { path = "crates/kc-store", version = "0.3.0" } +kc-sync = { path = "crates/kc-sync", version = "0.3.0" } anyhow = "1" thiserror = "2" diff --git a/README.de.md b/README.de.md index f9f86c8..4412fb8 100644 --- a/README.de.md +++ b/README.de.md @@ -130,6 +130,30 @@ desktop$ kc inbox # speichert, was angekommen ist (bi `kc peers rm LABEL` hebt die Kopplung eines Geräts auf; geht ein Rechner verloren, führe es auf deinen anderen Rechnern aus. Wann `kc device rotate` sinnvoll ist, steht in [docs/SECURITY.md](docs/SECURITY.md). +## Synchronisierung + +Synchronisiere ausgewählte Einträge zwischen gekoppelten Geräten. **Standardmäßig +wird nichts synchronisiert.** Ersetze `NAME` durch den Namen eines vorhandenen Eintrags: + +```console +$ kc sync add NAME # Eintrag aufnehmen und anderen Geräten vorschlagen +$ kc sync # auf beiden Geräten ausführen, um Änderungen auszutauschen +$ kc sync review # Vorschläge und zurückgehaltene Änderungen auf dem Empfänger prüfen +$ kc sync status # Status und lokale Fingerabdrücke anzeigen, niemals Werte +``` + +Diese Version hält jedes Überschreiben durch ein anderes Gerät zur Prüfung zurück. Jeder +Synchronisierungsschritt, der einen Wert übernimmt, verlangt eine lokale Bestätigung +per Touch ID (oder Systempasswort), Windows Hello oder polkit. Auch die Aufnahme eines +Eintrags verlangt diese Bestätigung. Normale lokale Schreibvorgänge können Änderungen +in die Warteschlange stellen, erlauben aber kein Überschreiben auf anderen Geräten. +Bei Konflikten bleiben die möglichen Werte erhalten. Wähle mit +`kc sync resolve NAME --keep mine` oder `kc sync resolve NAME --keep LABEL` einen Wert. +Die anderen Geräte müssen auch dieses Ergebnis prüfen. `kc sync freeze` stoppt die +Übernahme eingehender Änderungen ohne Bestätigung; `kc sync unfreeze` verlangt eine +Bestätigung des Betriebssystems. Exit-Code 8 bedeutet, dass noch Arbeit aussteht oder +blockiert ist. Siehe die [Sicherheitsgrenzen](docs/SECURITY.md). + ## Befehle | Befehl | Funktion | @@ -141,6 +165,7 @@ Wann `kc device rotate` sinnvoll ist, steht in [docs/SECURITY.md](docs/SECURITY. | `kc adopt --service S [--account A] [--as NAME]` | kopiert einen vorhandenen Schlüsselbundeintrag in kc | | `kc receive` / `kc send [NAMES…]` | überträgt Einträge mit einem Einmalcode | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | gemerkte Geräte | +| `kc sync` | ausgewählte Einträge mit gekoppelten Geräten synchronisieren | | `kc doctor` | prüft den Schlüsselbund, das Relay und die Konfiguration | ## Fehlerbehebung diff --git a/README.es.md b/README.es.md index 6c35ab1..e35c230 100644 --- a/README.es.md +++ b/README.es.md @@ -130,6 +130,29 @@ desktop$ kc inbox # guarda lo que llegó (se conserva `kc peers rm LABEL` desempareja un dispositivo; si pierdes una máquina, ejecútalo en las demás. Consulta [docs/SECURITY.md](docs/SECURITY.md) para saber cuándo usar `kc device rotate`. +## Sincronización + +Sincroniza los elementos que elijas entre dispositivos emparejados. **No se +sincroniza nada por defecto.** Sustituye `NAME` por el nombre de un elemento existente: + +```console +$ kc sync add NAME # incluye el elemento y lo propone a los otros dispositivos +$ kc sync # ejecútalo en ambos dispositivos para intercambiar cambios +$ kc sync review # revisa propuestas y cambios retenidos en el receptor +$ kc sync status # muestra el estado y las huellas locales, nunca los valores +``` + +En esta versión, toda sobrescritura remota queda pendiente de revisión. Cada paso de +sincronización que aplica un valor pide confirmación local mediante Touch ID +(o la contraseña del sistema), Windows Hello o polkit. Incluir un elemento también +requiere confirmación. Las escrituras locales normales pueden poner cambios en cola, +pero no autorizan sobrescrituras en otros dispositivos. Los conflictos conservan los +valores candidatos: elige con `kc sync resolve NAME --keep mine` o +`kc sync resolve NAME --keep LABEL`. Los demás dispositivos también revisan el resultado. +`kc sync freeze` detiene la aplicación de cambios entrantes sin pedir confirmación; +`kc sync unfreeze` requiere confirmación del sistema. El código de salida 8 indica +trabajo pendiente o bloqueado. Consulta los [límites de seguridad](docs/SECURITY.md). + ## Comandos | Comando | Qué hace | @@ -141,6 +164,7 @@ Consulta [docs/SECURITY.md](docs/SECURITY.md) para saber cuándo usar `kc device | `kc adopt --service S [--account A] [--as NAME]` | copia un elemento existente del llavero a kc | | `kc receive` / `kc send [NAMES…]` | mueve elementos con un código de un solo uso | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | dispositivos recordados | +| `kc sync` | sincroniza elementos seleccionados con dispositivos emparejados | | `kc doctor` | comprueba el llavero, el relé y la configuración | ## Solución de problemas diff --git a/README.fr.md b/README.fr.md index dc7c412..2b4b24d 100644 --- a/README.fr.md +++ b/README.fr.md @@ -130,6 +130,29 @@ desktop$ kc inbox # enregistre ce qui est arrivé (co `kc peers rm LABEL` supprime l'appairage d'un appareil ; si une machine est perdue, lancez-le sur vos autres machines. Consultez [docs/SECURITY.md](docs/SECURITY.md) pour savoir quand utiliser `kc device rotate`. +## Synchronisation + +Synchronisez les éléments choisis entre appareils appairés. **Rien n’est +synchronisé par défaut.** Remplacez `NAME` par le nom d’un élément existant : + +```console +$ kc sync add NAME # inscrit l’élément et le propose aux autres appareils +$ kc sync # à lancer sur les deux appareils pour échanger les modifications +$ kc sync review # examine les propositions et modifications en attente sur le destinataire +$ kc sync status # affiche l’état et les empreintes locales, jamais les valeurs +``` + +Dans cette version, tout écrasement distant attend une vérification humaine. Chaque étape de +synchronisation qui applique une valeur demande une confirmation locale via Touch ID +(ou le mot de passe du système), Windows Hello ou polkit. L’inscription d’un élément +exige aussi cette confirmation. Les écritures locales ordinaires peuvent mettre des +modifications en file d’attente, sans autoriser d’écrasement sur les autres appareils. +Les valeurs en conflit sont conservées : choisissez avec `kc sync resolve NAME --keep mine` +ou `kc sync resolve NAME --keep LABEL`. Les autres appareils doivent aussi examiner le +résultat. `kc sync freeze` suspend l’application des modifications entrantes sans +confirmation ; `kc sync unfreeze` exige une confirmation du système. Le code de sortie 8 +signale du travail en attente ou bloqué. Voir les [limites de sécurité](docs/SECURITY.md). + ## Commandes | Commande | Rôle | @@ -141,6 +164,7 @@ Consultez [docs/SECURITY.md](docs/SECURITY.md) pour savoir quand utiliser `kc de | `kc adopt --service S [--account A] [--as NAME]` | copie un élément existant du trousseau dans kc | | `kc receive` / `kc send [NAMES…]` | transfère des éléments avec un code à usage unique | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | appareils mémorisés | +| `kc sync` | synchronise les éléments choisis avec les appareils appairés | | `kc doctor` | vérifie le trousseau, le relais et la configuration | ## Dépannage diff --git a/README.ja.md b/README.ja.md index 9e7e82a..48de85a 100644 --- a/README.ja.md +++ b/README.ja.md @@ -130,6 +130,28 @@ desktop$ kc inbox # 届いたものを保存 (最大 `kc peers rm LABEL` はデバイスのペアリングを解除します。マシンを紛失したら、他のマシンでこれを実行してください。 `kc device rotate` を使う場面は [docs/SECURITY.md](docs/SECURITY.md) を参照してください。 +## 同期 + +選んだ項目をペアリング済みデバイス間で同期します。**初期状態では何も同期しません。** +`NAME` は既存の項目名に置き換えてください。 + +```console +$ kc sync add NAME # 同期対象に登録し、他のデバイスに提案 +$ kc sync # 両方のデバイスで実行して変更を交換 +$ kc sync review # 受信側で提案と保留中の変更を確認 +$ kc sync status # 値ではなく状態とこのデバイスの値の指紋を表示 +``` + +このバージョンでは、リモートからの上書きをすべて保留して人が確認します。同期で値を +適用するたびに、Touch ID(または OS のパスワード)、Windows Hello、polkit による +ローカル確認が必要です。同期対象の登録にも確認が必要です。通常のローカル書き込みは +変更を送信待ちにできますが、他のデバイスでの上書きを許可するものではありません。 +競合した候補の値は保存されます。`kc sync resolve NAME --keep mine` または +`kc sync resolve NAME --keep LABEL` で残す値を選びます。他のデバイスでは結果も +確認が必要です。`kc sync freeze` は確認なしで受信した変更の適用を止めます。 +`kc sync unfreeze` には OS の確認が必要です。終了コード 8 は保留中または処理できない +作業が残っていることを示します。[セキュリティ上の制限](docs/SECURITY.md)も参照してください。 + ## コマンド | コマンド | 内容 | @@ -141,6 +163,7 @@ desktop$ kc inbox # 届いたものを保存 (最大 | `kc adopt --service S [--account A] [--as NAME]` | 既存のキーチェーン項目を kc にコピー | | `kc receive` / `kc send [NAMES…]` | ワンタイムコードで項目を移動 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 記憶済みデバイス | +| `kc sync` | 選んだ項目をペアリング済みデバイスと同期 | | `kc doctor` | キーチェーン、リレー、設定を確認 | ## トラブルシューティング diff --git a/README.ko.md b/README.ko.md index 1ba990d..fcd9d52 100644 --- a/README.ko.md +++ b/README.ko.md @@ -132,6 +132,29 @@ desktop$ kc inbox # 도착한 항목을 저장(최대 실행하세요. `kc device rotate` 를 언제 쓰는지는 [docs/SECURITY.md](docs/SECURITY.md) 에 있습니다. +## 동기화 + +선택한 항목을 페어링한 기기끼리 동기화합니다. **처음에는 아무 항목도 +동기화하지 않습니다.** `NAME`에 기존 항목 이름을 넣으세요. + +```console +$ kc sync add NAME # 동기화 대상으로 등록하고 다른 기기에 제안 +$ kc sync # 양쪽 기기에서 실행해 변경 사항 교환 +$ kc sync review # 받는 기기에서 제안과 보류된 변경 검토 +$ kc sync status # 값 대신 상태와 이 기기의 값 지문 표시 +``` + +이 버전은 원격 덮어쓰기를 모두 보류하고 사람이 검토합니다. 동기화 과정에서 +값을 적용할 때마다 Touch ID(또는 OS 암호), Windows Hello, polkit으로 확인합니다. +동기화 대상 등록에도 이 확인이 필요합니다. 일반적인 로컬 쓰기는 변경을 전송 대기열에 +넣을 수 있지만, 다른 기기의 값을 덮어쓸 권한까지 부여하지는 않습니다. +충돌이 나면 후보 값을 보관합니다. `kc sync resolve NAME --keep mine`으로 +이 기기의 값을, `kc sync resolve NAME --keep LABEL`로 해당 기기의 후보 값을 +선택하세요. 다른 기기에서는 그 결과도 검토해야 합니다. `kc sync freeze`는 별도 +확인 없이 수신 변경의 적용을 중단하고, `kc sync unfreeze`는 OS 확인 후 다시 +허용합니다. 종료 코드 8은 대기 중이거나 막힌 작업이 남아 있다는 뜻입니다. +[보안상 한계](docs/SECURITY.md)도 참고하세요. + ## 명령 | 명령 | 하는 일 | @@ -143,6 +166,7 @@ desktop$ kc inbox # 도착한 항목을 저장(최대 | `kc adopt --service S [--account A] [--as NAME]` | 이미 있는 키체인 항목을 kc 로 복사 | | `kc receive` / `kc send [NAMES…]` | 일회용 코드로 항목 옮기기 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 기억된 기기 | +| `kc sync` | 선택한 항목을 페어링한 기기끼리 동기화 | | `kc doctor` | 키체인, 중계 서버, 설정 점검 | ## 문제 해결 diff --git a/README.md b/README.md index 69c854e..d12d549 100644 --- a/README.md +++ b/README.md @@ -130,6 +130,28 @@ desktop$ kc inbox # stores what arrived (kept up to 7 `kc peers rm LABEL` unpairs a device; run it on your other machines if one is lost. See [docs/SECURITY.md](docs/SECURITY.md) for when to use `kc device rotate`. +## Sync + +Sync keeps selected items shared between paired devices. **Nothing syncs by +default.** Replace `NAME` with an existing item name: + +```console +$ kc sync add NAME # enroll and offer to paired devices +$ kc sync # run on both devices to exchange changes +$ kc sync review # on the receiving device: review proposals and held changes +$ kc sync status # show state and local fingerprints, never values +``` + +This release holds every remote overwrite for review. Every sync step that applies +a value asks for local OS confirmation: Touch ID (or the OS password fallback), +Windows Hello, or polkit. Enrollment also requires this confirmation; ordinary +local writes can queue changes without authorizing an overwrite elsewhere. +Conflicts preserve candidate values: use `kc sync resolve NAME --keep mine` +or `kc sync resolve NAME --keep LABEL` to choose a version. Other devices still +review the result. `kc sync freeze` holds incoming changes without confirmation; +`kc sync unfreeze` requires OS confirmation. Exit 8 means pending or blocked +work remains. See [the security limits](docs/SECURITY.md). + ## Commands | Command | What it does | @@ -141,6 +163,7 @@ lost. See [docs/SECURITY.md](docs/SECURITY.md) for when to use `kc device rotate | `kc adopt --service S [--account A] [--as NAME]` | copy an existing keychain item into kc | | `kc receive` / `kc send [NAMES…]` | move items with a one-time code | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | remembered devices | +| `kc sync` | sync selected items with paired devices | | `kc doctor` | check the keychain, the relay and the configuration | ## Troubleshooting diff --git a/README.zh-Hans.md b/README.zh-Hans.md index acd86c6..8072d5f 100644 --- a/README.zh-Hans.md +++ b/README.zh-Hans.md @@ -129,6 +129,26 @@ desktop$ kc inbox # 保存收到的内容(最多保 `kc peers rm LABEL` 解除与某台设备的配对;如果有机器丢失,请在其他机器上运行此命令。 何时使用 `kc device rotate`,请参阅 [docs/SECURITY.md](docs/SECURITY.md)。 +## 同步 + +在已配对的设备之间同步选定的条目。**默认不同步任何条目。** +将 `NAME` 替换为已有条目的名称: + +```console +$ kc sync add NAME # 加入同步范围,并向其他设备发送提议 +$ kc sync # 在两台设备上运行,交换更改 +$ kc sync review # 在接收设备上审核提议和暂存的更改 +$ kc sync status # 显示状态和本机的值指纹,不显示值 +``` + +当前版本会暂存所有远程覆盖操作,等待人工审核。同步中每次应用值都需要通过 +Touch ID(或系统密码)、Windows Hello 或 polkit 在本机确认。加入同步范围也需要 +确认。普通的本地写入可以将更改加入发送队列,但不会授权覆盖其他设备上的值。 +发生冲突时会保留候选值;使用 `kc sync resolve NAME --keep mine` 或 +`kc sync resolve NAME --keep LABEL` 选择要保留的版本。其他设备仍需审核结果。 +`kc sync freeze` 无需确认即可暂停应用传入的更改;`kc sync unfreeze` 需要系统确认。 +退出码 8 表示仍有待处理或受阻的工作。另请参阅[安全限制](docs/SECURITY.md)。 + ## 命令 | 命令 | 作用 | @@ -140,6 +160,7 @@ desktop$ kc inbox # 保存收到的内容(最多保 | `kc adopt --service S [--account A] [--as NAME]` | 将现有钥匙串条目复制到 kc | | `kc receive` / `kc send [NAMES…]` | 用一次性代码转移条目 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 已记住的设备 | +| `kc sync` | 与已配对的设备同步选定条目 | | `kc doctor` | 检查钥匙串、中继服务器和配置 | ## 故障排除 diff --git a/README.zh-Hant.md b/README.zh-Hant.md index 67ef6ca..4ec4bde 100644 --- a/README.zh-Hant.md +++ b/README.zh-Hant.md @@ -129,6 +129,26 @@ desktop$ kc inbox # 儲存收到的內容(最多保 `kc peers rm LABEL` 解除與某台裝置的配對;若有電腦遺失,請在其他電腦上執行此指令。 何時使用 `kc device rotate`,請參閱 [docs/SECURITY.md](docs/SECURITY.md)。 +## 同步 + +在已配對的裝置之間同步選定的項目。**預設不會同步任何項目。** +將 `NAME` 換成現有項目的名稱: + +```console +$ kc sync add NAME # 加入同步範圍,並向其他裝置傳送提案 +$ kc sync # 在兩台裝置上執行,交換變更 +$ kc sync review # 在接收裝置上審核提案與暫存的變更 +$ kc sync status # 顯示狀態與本機的值指紋,不顯示值 +``` + +目前版本會暫存所有遠端覆寫操作,等待人工審核。同步中每次套用值都需要透過 +Touch ID(或系統密碼)、Windows Hello 或 polkit 在本機確認。加入同步範圍也需要 +確認。一般的本機寫入可以將變更加進傳送佇列,但不會授權覆寫其他裝置上的值。 +發生衝突時會保留候選值;使用 `kc sync resolve NAME --keep mine` 或 +`kc sync resolve NAME --keep LABEL` 選擇要保留的版本。其他裝置仍須審核結果。 +`kc sync freeze` 不需確認即可暫停套用傳入的變更;`kc sync unfreeze` 需要系統確認。 +結束代碼 8 表示仍有待處理或受阻的工作。另請參閱[安全限制](docs/SECURITY.md)。 + ## 指令 | 指令 | 作用 | @@ -140,6 +160,7 @@ desktop$ kc inbox # 儲存收到的內容(最多保 | `kc adopt --service S [--account A] [--as NAME]` | 將既有的鑰匙圈項目複製到 kc | | `kc receive` / `kc send [NAMES…]` | 用一次性代碼搬移項目 | | `kc pair`, `kc peers`, `kc inbox`, `kc device` | 已記住的裝置 | +| `kc sync` | 與已配對的裝置同步選定項目 | | `kc doctor` | 檢查鑰匙圈、中繼伺服器與設定 | ## 疑難排解 diff --git a/crates/kc-cli/Cargo.toml b/crates/kc-cli/Cargo.toml index b7aca97..4b863f3 100644 --- a/crates/kc-cli/Cargo.toml +++ b/crates/kc-cli/Cargo.toml @@ -21,6 +21,8 @@ path = "src/main.rs" kc-wire.workspace = true kc-proto.workspace = true kc-store.workspace = true +kc-sync.workspace = true +hmac = "0.12" thiserror.workspace = true serde.workspace = true serde_json.workspace = true @@ -50,10 +52,19 @@ sys-locale = "0.3" [target.'cfg(unix)'.dependencies] libc = "0.2" +[target.'cfg(target_os = "macos")'.dependencies] +block2 = "0.6.2" +objc2 = "0.6.5" +objc2-foundation = { version = "0.3.2", default-features = false, features = ["std", "NSError", "NSString"] } +objc2-local-authentication = { version = "0.3.2", default-features = false, features = ["std", "LAContext", "LAError", "block2"] } + +[target.'cfg(windows)'.dependencies] +windows = { version = "0.58.0", default-features = false, features = ["Security_Credentials_UI", "Foundation", "Win32_System_WinRT", "Win32_UI_WindowsAndMessaging", "Win32_System_Console", "Win32_Foundation"] } + [dev-dependencies] kc-proto = { workspace = true, features = ["test-util"] } kc-store = { workspace = true, features = ["test-util"] } -kc-relay = { path = "../kc-relay", version = "0.2.0", features = ["test-util"] } +kc-relay = { path = "../kc-relay", version = "0.3.0", features = ["test-util"] } tokio = { workspace = true, features = ["io-util"] } tempfile = "3" postcard = { version = "1.1", default-features = false, features = ["alloc"] } diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index cdbfd3f..be4ffdf 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} ist kein gültiges UTF-8" "{what} is too large for the relay" = "{what} ist zu groß für den Relay-Server" "↑↓ to move, enter to select, type to filter" = "↑↓ zum Bewegen, Enter zum Auswählen, tippen zum Filtern" +"Accept" = "Annehmen" +"Reject" = "Ablehnen" +"Leave for later" = "Später prüfen" +"this device" = "dieses Gerät" +"in sync" = "synchronisiert" +"held" = "zurückgehalten" +"conflict" = "Konflikt" +"proposal" = "Vorschlag" +"re-offer needed" = "erneuter Vorschlag erforderlich" +"frozen" = "eingefroren" +"awaiting review" = "wartet auf Prüfung" +"Synchronize selected items with paired devices" = "Ausgewählte Einträge mit gekoppelten Geräten synchronisieren" +"Show synchronization state without values" = "Synchronisierungsstatus ohne Werte anzeigen" +"Confirm the current value as the recovery checkpoint" = "Aktuellen Wert als Wiederherstellungspunkt bestätigen" +"Add items and offer them to paired devices" = "Einträge hinzufügen und gekoppelten Geräten anbieten" +"Offer selected sync items again" = "Ausgewählte Synchronisierungseinträge erneut anbieten" +"Remove items from this device's sync set, keeping their values" = "Einträge aus der Synchronisierung dieses Geräts entfernen und Werte behalten" +"Manage the paired devices used for sync" = "Gekoppelte Geräte für die Synchronisierung verwalten" +"Review proposals and held changes" = "Vorschläge und zurückgehaltene Änderungen prüfen" +"Resolve a conflict with a new version" = "Konflikt mit einer neuen Version lösen" +"Restore the recovery checkpoint" = "Wiederherstellungspunkt wiederherstellen" +"Hold all incoming sync changes" = "Alle eingehenden Synchronisierungsänderungen zurückhalten" +"Resume sync after local confirmation" = "Synchronisierung nach lokaler Bestätigung fortsetzen" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "Synchronisierungsstatus nicht verfügbar oder beschädigt; Schlüsselbund und Statusverzeichnis prüfen und erneut versuchen." +"Sync needs local confirmation." = "Die Synchronisierung erfordert eine lokale Bestätigung." +"Run this command at a terminal and confirm in the operating system." = "Diesen Befehl in einem Terminal ausführen und im Betriebssystem bestätigen." +"Sync items must contain between 1 byte and 200 KiB." = "Synchronisierungseinträge müssen zwischen 1 Byte und 200 KiB groß sein." +"Sync storage is full; review pending items before retrying." = "Synchronisierungsspeicher voll; ausstehende Einträge prüfen und erneut versuchen." +"Ignored a stale sync offer for {name}." = "Veralteten Synchronisierungsvorschlag für {name} ignoriert." +"Ignored signed approvals: Phase 1 requires local review." = "Signierte Freigaben ignoriert: Phase 1 erfordert lokale Prüfung." +"Sync delivery is queued; run `kc sync` to retry." = "Synchronisierungsübertragung wartet; mit `kc sync` erneut versuchen." +"Unknown sync peer: {label}." = "Unbekanntes Synchronisierungsgerät: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Nur das Gerät, das eine Änderung erstellt hat, sendet sie; geht es verloren, eine neue lokale Änderung aus einer verbleibenden Kopie veröffentlichen." +"Review sync changes." = "Synchronisierungsänderungen prüfen." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{name} von {peer} prüfen: aktuell {current}, vorgeschlagen {proposed}." +"Select sync items." = "Einträge für die Synchronisierung auswählen." +"Run `kc sync rm {name}` before deleting this item." = "Vor dem Löschen dieses Eintrags `kc sync rm {name}` ausführen." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} gesendet, {updated} aktualisiert, {conflict} Konflikte, {held} zurückgehalten" +"Sync {name}: {result}." = "Synchronisierung {name}: {result}." +"{names} and {n} more" = "{names} und {n} weitere" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{names} von {devices} annehmen; {rejected} ablehnen" +"Accept {names} from {devices}" = "{names} von {devices} annehmen" +"Reject {rejected}" = "{rejected} ablehnen" +"Replace {name} with the value from {device}" = "{name} durch den Wert von {device} ersetzen" +"Resolve {name}: keep {choice}" = "{name} auflösen: {choice} behalten" +"Restore {name} to its checkpoint" = "{name} auf seinen Kontrollpunkt zurücksetzen" +"Unfreeze sync" = "Synchronisierung fortsetzen" +"Confirm the current value of {name} as its checkpoint" = "Den aktuellen Wert von {name} als Kontrollpunkt bestätigen" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Synchronisierungsangebot vom deaktivierten oder blockierten Gerät {peer} ignoriert." +"Sync item held; run `kc sync review`." = "Synchronisierungselement zurückgehalten; `kc sync review` ausführen." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} steht im Konflikt; zuerst mit `kc sync resolve {name}` auflösen." diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index 90e7e9a..bf0acc6 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} no es UTF-8 válido" "{what} is too large for the relay" = "{what} es demasiado grande para el servidor de retransmisión" "↑↓ to move, enter to select, type to filter" = "↑↓ para moverte, intro para seleccionar, escribe para filtrar" +"Accept" = "Aceptar" +"Reject" = "Rechazar" +"Leave for later" = "Revisar más tarde" +"this device" = "este dispositivo" +"in sync" = "sincronizado" +"held" = "retenido" +"conflict" = "conflicto" +"proposal" = "propuesta" +"re-offer needed" = "es necesario volver a proponer" +"frozen" = "congelado" +"awaiting review" = "pendiente de revisión" +"Synchronize selected items with paired devices" = "Sincronizar los elementos seleccionados con dispositivos vinculados" +"Show synchronization state without values" = "Mostrar el estado de sincronización sin los valores" +"Confirm the current value as the recovery checkpoint" = "Confirmar el valor actual como punto de recuperación" +"Add items and offer them to paired devices" = "Añadir elementos y proponerlos a los dispositivos vinculados" +"Offer selected sync items again" = "Volver a proponer los elementos de sincronización seleccionados" +"Remove items from this device's sync set, keeping their values" = "Quitar elementos de la sincronización de este dispositivo y conservar sus valores" +"Manage the paired devices used for sync" = "Gestionar los dispositivos vinculados usados para sincronizar" +"Review proposals and held changes" = "Revisar propuestas y cambios retenidos" +"Resolve a conflict with a new version" = "Resolver un conflicto con una nueva versión" +"Restore the recovery checkpoint" = "Restaurar el punto de recuperación" +"Hold all incoming sync changes" = "Retener todos los cambios de sincronización entrantes" +"Resume sync after local confirmation" = "Reanudar la sincronización tras la confirmación local" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "El estado de sincronización no está disponible o está dañado; compruebe el llavero y el directorio de estado e inténtelo de nuevo." +"Sync needs local confirmation." = "La sincronización requiere confirmación local." +"Run this command at a terminal and confirm in the operating system." = "Ejecute este comando en un terminal y confirme en el sistema operativo." +"Sync items must contain between 1 byte and 200 KiB." = "Los elementos de sincronización deben contener entre 1 byte y 200 KiB." +"Sync storage is full; review pending items before retrying." = "El almacenamiento de sincronización está lleno; revise los elementos pendientes antes de volver a intentarlo." +"Ignored a stale sync offer for {name}." = "Se ignoró una propuesta de sincronización obsoleta para {name}." +"Ignored signed approvals: Phase 1 requires local review." = "Se ignoraron las aprobaciones firmadas: la fase 1 requiere revisión local." +"Sync delivery is queued; run `kc sync` to retry." = "El envío de sincronización está en cola; ejecute `kc sync` para reintentarlo." +"Unknown sync peer: {label}." = "Dispositivo de sincronización desconocido: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Solo el dispositivo que creó un cambio lo envía; si se pierde, publique un nuevo cambio local a partir de una copia restante." +"Review sync changes." = "Revisar los cambios de sincronización." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "Revisar {name} de {peer}: huella actual {current}, propuesta {proposed}." +"Select sync items." = "Seleccionar los elementos que se sincronizarán." +"Run `kc sync rm {name}` before deleting this item." = "Ejecute `kc sync rm {name}` antes de eliminar este elemento." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} enviados, {updated} actualizados, {conflict} conflictos, {held} retenidos" +"Sync {name}: {result}." = "Sincronización de {name}: {result}." +"{names} and {n} more" = "{names} y {n} más" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "Aceptar {names} de {devices}; rechazar {rejected}" +"Accept {names} from {devices}" = "Aceptar {names} de {devices}" +"Reject {rejected}" = "Rechazar {rejected}" +"Replace {name} with the value from {device}" = "Reemplazar {name} por el valor de {device}" +"Resolve {name}: keep {choice}" = "Resolver {name}: conservar {choice}" +"Restore {name} to its checkpoint" = "Restaurar {name} a su punto de control" +"Unfreeze sync" = "Reanudar la sincronización" +"Confirm the current value of {name} as its checkpoint" = "Confirmar el valor actual de {name} como su punto de control" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Se ignoró una oferta de sincronización del dispositivo desactivado o bloqueado {peer}." +"Sync item held; run `kc sync review`." = "Elemento de sincronización retenido; ejecuta `kc sync review`." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} está en conflicto; resuélvelo primero con `kc sync resolve {name}`." diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 4c94b92..d66f990 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} n'est pas en UTF-8 valide" "{what} is too large for the relay" = "{what} est trop volumineux pour le relais" "↑↓ to move, enter to select, type to filter" = "↑↓ pour se déplacer, entrée pour sélectionner, tapez pour filtrer" +"Accept" = "Accepter" +"Reject" = "Refuser" +"Leave for later" = "Examiner plus tard" +"this device" = "cet appareil" +"in sync" = "synchronisé" +"held" = "en attente" +"conflict" = "conflit" +"proposal" = "proposition" +"re-offer needed" = "nouvelle proposition nécessaire" +"frozen" = "gelé" +"awaiting review" = "en attente de vérification" +"Synchronize selected items with paired devices" = "Synchroniser les éléments sélectionnés avec les appareils associés" +"Show synchronization state without values" = "Afficher l’état de synchronisation sans les valeurs" +"Confirm the current value as the recovery checkpoint" = "Confirmer la valeur actuelle comme point de restauration" +"Add items and offer them to paired devices" = "Ajouter des éléments et les proposer aux appareils associés" +"Offer selected sync items again" = "Proposer à nouveau les éléments synchronisés sélectionnés" +"Remove items from this device's sync set, keeping their values" = "Retirer des éléments de la synchronisation de cet appareil en conservant leurs valeurs" +"Manage the paired devices used for sync" = "Gérer les appareils associés utilisés pour la synchronisation" +"Review proposals and held changes" = "Examiner les propositions et les modifications en attente" +"Resolve a conflict with a new version" = "Résoudre un conflit avec une nouvelle version" +"Restore the recovery checkpoint" = "Restaurer le point de récupération" +"Hold all incoming sync changes" = "Mettre en attente toutes les modifications de synchronisation entrantes" +"Resume sync after local confirmation" = "Reprendre la synchronisation après confirmation locale" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "L’état de synchronisation est indisponible ou endommagé ; vérifiez le trousseau et le dossier d’état, puis réessayez." +"Sync needs local confirmation." = "La synchronisation nécessite une confirmation locale." +"Run this command at a terminal and confirm in the operating system." = "Exécutez cette commande dans un terminal et confirmez dans le système d’exploitation." +"Sync items must contain between 1 byte and 200 KiB." = "Les éléments à synchroniser doivent contenir entre 1 octet et 200 KiB." +"Sync storage is full; review pending items before retrying." = "Le stockage de synchronisation est plein ; examinez les éléments en attente avant de réessayer." +"Ignored a stale sync offer for {name}." = "Proposition de synchronisation obsolète pour {name} ignorée." +"Ignored signed approvals: Phase 1 requires local review." = "Approbations signées ignorées : la phase 1 nécessite une vérification locale." +"Sync delivery is queued; run `kc sync` to retry." = "La transmission est en attente ; exécutez `kc sync` pour réessayer." +"Unknown sync peer: {label}." = "Appareil de synchronisation inconnu : {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "Seul l’appareil à l’origine d’une modification l’envoie ; s’il est perdu, publiez une nouvelle modification locale depuis une copie restante." +"Review sync changes." = "Examiner les modifications de synchronisation." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "Examiner {name} de {peer} : empreinte actuelle {current}, proposée {proposed}." +"Select sync items." = "Sélectionner les éléments à synchroniser." +"Run `kc sync rm {name}` before deleting this item." = "Exécutez `kc sync rm {name}` avant de supprimer cet élément." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "{sent} envoyés, {updated} mis à jour, {conflict} conflits, {held} en attente" +"Sync {name}: {result}." = "Synchronisation {name} : {result}." +"{names} and {n} more" = "{names} et {n} autres" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "Accepter {names} de {devices} ; refuser {rejected}" +"Accept {names} from {devices}" = "Accepter {names} de {devices}" +"Reject {rejected}" = "Refuser {rejected}" +"Replace {name} with the value from {device}" = "Remplacer {name} par la valeur de {device}" +"Resolve {name}: keep {choice}" = "Résoudre {name} : conserver {choice}" +"Restore {name} to its checkpoint" = "Restaurer {name} à son point de contrôle" +"Unfreeze sync" = "Reprendre la synchronisation" +"Confirm the current value of {name} as its checkpoint" = "Confirmer la valeur actuelle de {name} comme point de contrôle" +"Ignored a sync offer from disabled or blocked peer {peer}." = "Offre de synchronisation ignorée : appareil {peer} désactivé ou bloqué." +"Sync item held; run `kc sync review`." = "Élément de synchronisation en attente ; exécutez `kc sync review`." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} est en conflit ; résolvez-le d’abord avec `kc sync resolve {name}`." diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index 8b2a657..0878dd7 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} が有効な UTF-8 ではありません" "{what} is too large for the relay" = "{what} は中継サーバーには大きすぎます" "↑↓ to move, enter to select, type to filter" = "↑↓: 移動、Enter: 選択、入力で絞り込み" +"Accept" = "受け入れる" +"Reject" = "拒否する" +"Leave for later" = "後で確認" +"this device" = "このデバイス" +"in sync" = "同期済み" +"held" = "保留中" +"conflict" = "競合" +"proposal" = "提案" +"re-offer needed" = "再提案が必要" +"frozen" = "同期停止中" +"awaiting review" = "確認待ち" +"Synchronize selected items with paired devices" = "選択した項目をペア設定済みデバイスと同期" +"Show synchronization state without values" = "値を表示せずに同期状態を確認" +"Confirm the current value as the recovery checkpoint" = "現在の値を復元用チェックポイントとして確認" +"Add items and offer them to paired devices" = "項目を追加してペア設定済みデバイスに提案" +"Offer selected sync items again" = "選択した同期項目を再提案" +"Remove items from this device's sync set, keeping their values" = "値を残してこのデバイスの同期対象から外す" +"Manage the paired devices used for sync" = "同期に使うペア設定済みデバイスを管理" +"Review proposals and held changes" = "提案と保留中の変更を確認" +"Resolve a conflict with a new version" = "新しいバージョンで競合を解決" +"Restore the recovery checkpoint" = "復元用チェックポイントに戻す" +"Hold all incoming sync changes" = "受信した同期変更をすべて保留" +"Resume sync after local confirmation" = "このデバイスで確認して同期を再開" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同期状態を読み取れないか、破損しています。キーチェーンと状態ディレクトリを確認して再試行してください。" +"Sync needs local confirmation." = "同期にはこのデバイスでの本人確認が必要です。" +"Run this command at a terminal and confirm in the operating system." = "ターミナルでこのコマンドを実行し、OSの本人確認を完了してください。" +"Sync items must contain between 1 byte and 200 KiB." = "同期する値のサイズは1バイト以上200 KiB以下である必要があります。" +"Sync storage is full; review pending items before retrying." = "同期用の保存領域がいっぱいです。保留中の項目を確認してから再試行してください。" +"Ignored a stale sync offer for {name}." = "{name} の古い世代の同期提案を無視しました。" +"Ignored signed approvals: Phase 1 requires local review." = "署名付き承認を無視しました。フェーズ1ではこのデバイスでの確認が必要です。" +"Sync delivery is queued; run `kc sync` to retry." = "同期の送信が待機中です。`kc sync` で再試行してください。" +"Unknown sync peer: {label}." = "同期相手が見つかりません: {label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "変更は作成元のデバイスだけが送信します。そのデバイスを失った場合は、残っているコピーから新しいローカル変更を作成してください。" +"Review sync changes." = "同期の変更を確認してください。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer} からの {name} を確認: 現在 {current}、提案 {proposed}。" +"Select sync items." = "同期する項目を選択してください。" +"Run `kc sync rm {name}` before deleting this item." = "この項目を削除する前に `kc sync rm {name}` を実行してください。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "送信 {sent}件、更新 {updated}件、競合 {conflict}件、保留 {held}件" +"Sync {name}: {result}." = "同期 {name}: {result}。" +"{names} and {n} more" = "{names}、ほか{n}件" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{devices}からの{names}を承認し、{rejected}を拒否" +"Accept {names} from {devices}" = "{devices}からの{names}を承認" +"Reject {rejected}" = "{rejected}を拒否" +"Replace {name} with the value from {device}" = "{name}を{device}の値で置き換える" +"Resolve {name}: keep {choice}" = "{name}を解決:{choice}を保持" +"Restore {name} to its checkpoint" = "{name}をチェックポイントに戻す" +"Unfreeze sync" = "同期の凍結を解除" +"Confirm the current value of {name} as its checkpoint" = "{name}の現在の値をチェックポイントとして確認" +"Ignored a sync offer from disabled or blocked peer {peer}." = "無効またはブロックされたデバイス{peer}からの同期提案を無視しました。" +"Sync item held; run `kc sync review`." = "同期項目を保留しました。`kc sync review`を実行してください。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} は競合中です。先に `kc sync resolve {name}` で解決してください。" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index 03924ef..f6c24cc 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var}이(가) 올바른 UTF-8 이 아닙니다" "{what} is too large for the relay" = "{what}이(가) 중계 서버에 보내기에 너무 큽니다" "↑↓ to move, enter to select, type to filter" = "↑↓: 이동, 엔터: 선택, 입력해서 필터" +"Accept" = "받아들이기" +"Reject" = "거절하기" +"Leave for later" = "나중에 결정" +"this device" = "이 기기" +"in sync" = "동기화됨" +"held" = "보류 중" +"conflict" = "충돌" +"proposal" = "제안" +"re-offer needed" = "다시 제안해야 함" +"frozen" = "동기화 중지됨" +"awaiting review" = "검토 대기 중" +"Synchronize selected items with paired devices" = "선택한 항목을 페어링한 기기와 동기화" +"Show synchronization state without values" = "값을 표시하지 않고 동기화 상태 확인" +"Confirm the current value as the recovery checkpoint" = "현재 값을 복구 기준점으로 확인" +"Add items and offer them to paired devices" = "항목을 추가하고 페어링한 기기에 제안" +"Offer selected sync items again" = "선택한 동기화 항목을 다시 제안" +"Remove items from this device's sync set, keeping their values" = "값은 남기고 이 기기의 동기화 대상에서 제외" +"Manage the paired devices used for sync" = "동기화할 페어링 기기 관리" +"Review proposals and held changes" = "제안과 보류된 변경 검토" +"Resolve a conflict with a new version" = "새 버전을 만들어 충돌 해결" +"Restore the recovery checkpoint" = "복구 기준점으로 되돌리기" +"Hold all incoming sync changes" = "들어오는 동기화 변경을 모두 보류" +"Resume sync after local confirmation" = "기기에서 확인한 뒤 동기화 재개" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "동기화 상태를 읽을 수 없거나 상태가 손상됐습니다. 키체인과 상태 폴더를 확인한 뒤 다시 시도하세요." +"Sync needs local confirmation." = "동기화하려면 이 기기에서 본인 확인이 필요합니다." +"Run this command at a terminal and confirm in the operating system." = "터미널에서 이 명령을 실행한 뒤 운영체제의 본인 확인을 완료하세요." +"Sync items must contain between 1 byte and 200 KiB." = "동기화할 값의 크기는 1바이트 이상, 200 KiB 이하여야 합니다." +"Sync storage is full; review pending items before retrying." = "동기화 저장 공간이 가득 찼습니다. 대기 중인 항목을 검토한 뒤 다시 시도하세요." +"Ignored a stale sync offer for {name}." = "{name}의 이전 세대 제안을 무시했습니다." +"Ignored signed approvals: Phase 1 requires local review." = "서명 승인을 무시했습니다. 1단계에서는 이 기기에서 직접 검토해야 합니다." +"Sync delivery is queued; run `kc sync` to retry." = "동기화 전송이 대기 중입니다. `kc sync`로 다시 시도하세요." +"Unknown sync peer: {label}." = "동기화할 기기를 찾을 수 없습니다: {label}." +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "변경은 만든 기기에서만 전송합니다. 그 기기를 잃어버렸다면 남아 있는 사본으로 새 변경을 만들어 보내세요." +"Review sync changes." = "동기화 변경을 검토하세요." +"Review {name} from {peer}: current {current}, proposed {proposed}." = "{peer}에서 온 {name} 검토: 현재 지문 {current}, 제안 지문 {proposed}." +"Select sync items." = "동기화할 항목을 선택하세요." +"Run `kc sync rm {name}` before deleting this item." = "이 항목을 삭제하려면 먼저 `kc sync rm {name}`을 실행하세요." +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "전송 {sent}개, 갱신 {updated}개, 충돌 {conflict}개, 보류 {held}개" +"Sync {name}: {result}." = "동기화 {name}: {result}." +"{names} and {n} more" = "{names} 외 {n}개" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "{devices}의 {names} 수락; {rejected} 거절" +"Accept {names} from {devices}" = "{devices}의 {names} 수락" +"Reject {rejected}" = "{rejected} 거절" +"Replace {name} with the value from {device}" = "{name}을(를) {device}의 값으로 교체" +"Resolve {name}: keep {choice}" = "{name} 충돌 해결: {choice} 유지" +"Restore {name} to its checkpoint" = "{name}을(를) 복구 기준점으로 복원" +"Unfreeze sync" = "동기화 동결 해제" +"Confirm the current value of {name} as its checkpoint" = "{name}의 현재 값을 복구 기준점으로 확인" +"Ignored a sync offer from disabled or blocked peer {peer}." = "비활성화되거나 차단된 기기 {peer}의 동기화 제안을 무시했습니다." +"Sync item held; run `kc sync review`." = "동기화 항목을 보류했습니다. `kc sync review`를 실행하세요." +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 항목이 충돌 중입니다. 먼저 `kc sync resolve {name}`로 해결하세요." diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index 654c95b..1ed5632 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} 不是有效的 UTF-8" "{what} is too large for the relay" = "{what} 对中继服务器而言过大" "↑↓ to move, enter to select, type to filter" = "↑↓ 移动,回车选择,输入以筛选" +"Accept" = "接受" +"Reject" = "拒绝" +"Leave for later" = "稍后处理" +"this device" = "此设备" +"in sync" = "已同步" +"held" = "已暂存" +"conflict" = "冲突" +"proposal" = "提议" +"re-offer needed" = "需要重新提议" +"frozen" = "同步已冻结" +"awaiting review" = "等待审核" +"Synchronize selected items with paired devices" = "将所选项目与已配对设备同步" +"Show synchronization state without values" = "显示同步状态,不显示值" +"Confirm the current value as the recovery checkpoint" = "将当前值确认为恢复检查点" +"Add items and offer them to paired devices" = "添加项目并向已配对设备发出提议" +"Offer selected sync items again" = "重新提议所选同步项目" +"Remove items from this device's sync set, keeping their values" = "从此设备的同步集合中移除项目,保留其值" +"Manage the paired devices used for sync" = "管理用于同步的已配对设备" +"Review proposals and held changes" = "审核提议和暂存的更改" +"Resolve a conflict with a new version" = "使用新版本解决冲突" +"Restore the recovery checkpoint" = "恢复到检查点" +"Hold all incoming sync changes" = "暂存所有传入的同步更改" +"Resume sync after local confirmation" = "本地确认后恢复同步" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同步状态不可用或已损坏;请检查钥匙串和状态目录后重试。" +"Sync needs local confirmation." = "同步需要本地确认。" +"Run this command at a terminal and confirm in the operating system." = "请在终端运行此命令,并在操作系统中完成确认。" +"Sync items must contain between 1 byte and 200 KiB." = "同步项目的大小必须在 1 字节到 200 KiB 之间。" +"Sync storage is full; review pending items before retrying." = "同步存储已满;请审核待处理项目后重试。" +"Ignored a stale sync offer for {name}." = "已忽略 {name} 的过期同步提议。" +"Ignored signed approvals: Phase 1 requires local review." = "已忽略签名批准:第一阶段需要本地审核。" +"Sync delivery is queued; run `kc sync` to retry." = "同步传输已排队;请运行 `kc sync` 重试。" +"Unknown sync peer: {label}." = "未知的同步设备:{label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有创建更改的设备会发送它;若该设备丢失,请用剩余副本发布新的本地更改。" +"Review sync changes." = "请审核同步更改。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "审核来自 {peer} 的 {name}:当前指纹 {current},提议指纹 {proposed}。" +"Select sync items." = "请选择同步项目。" +"Run `kc sync rm {name}` before deleting this item." = "删除此项目之前,请先运行 `kc sync rm {name}`。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已发送 {sent} 项,已更新 {updated} 项,冲突 {conflict} 项,暂存 {held} 项" +"Sync {name}: {result}." = "同步 {name}:{result}。" +"{names} and {n} more" = "{names}及其他{n}项" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "接受来自{devices}的{names};拒绝{rejected}" +"Accept {names} from {devices}" = "接受来自{devices}的{names}" +"Reject {rejected}" = "拒绝{rejected}" +"Replace {name} with the value from {device}" = "用{device}的值替换{name}" +"Resolve {name}: keep {choice}" = "解决{name}:保留{choice}" +"Restore {name} to its checkpoint" = "将{name}恢复到检查点" +"Unfreeze sync" = "解除同步冻结" +"Confirm the current value of {name} as its checkpoint" = "确认{name}的当前值为检查点" +"Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已禁用或被阻止的设备{peer}的同步提议。" +"Sync item held; run `kc sync review`." = "同步项目已保留;请运行 `kc sync review`。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 存在冲突,请先用 `kc sync resolve {name}` 解决。" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index f714db9..e93c253 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -445,3 +445,58 @@ "{var} is not valid UTF-8" = "{var} 不是有效的 UTF-8" "{what} is too large for the relay" = "{what} 對中繼伺服器而言太大" "↑↓ to move, enter to select, type to filter" = "↑↓ 移動,Enter 選擇,輸入文字以篩選" +"Accept" = "接受" +"Reject" = "拒絕" +"Leave for later" = "稍後處理" +"this device" = "此裝置" +"in sync" = "已同步" +"held" = "已暫存" +"conflict" = "衝突" +"proposal" = "提議" +"re-offer needed" = "需要重新提議" +"frozen" = "同步已凍結" +"awaiting review" = "等待審核" +"Synchronize selected items with paired devices" = "將所選項目與已配對裝置同步" +"Show synchronization state without values" = "顯示同步狀態,不顯示值" +"Confirm the current value as the recovery checkpoint" = "將目前值確認為復原檢查點" +"Add items and offer them to paired devices" = "新增項目並向已配對裝置提出提議" +"Offer selected sync items again" = "重新提議所選同步項目" +"Remove items from this device's sync set, keeping their values" = "從此裝置的同步集合移除項目,保留其值" +"Manage the paired devices used for sync" = "管理用於同步的已配對裝置" +"Review proposals and held changes" = "審核提議及暫存的變更" +"Resolve a conflict with a new version" = "使用新版本解決衝突" +"Restore the recovery checkpoint" = "還原至復原檢查點" +"Hold all incoming sync changes" = "暫存所有傳入的同步變更" +"Resume sync after local confirmation" = "本機確認後恢復同步" +"Sync state is unavailable or damaged; retry after checking the keychain and state directory." = "同步狀態無法使用或已損壞;請檢查鑰匙圈與狀態目錄後重試。" +"Sync needs local confirmation." = "同步需要本機確認。" +"Run this command at a terminal and confirm in the operating system." = "請在終端機執行此命令,並在作業系統中完成確認。" +"Sync items must contain between 1 byte and 200 KiB." = "同步項目的大小必須介於 1 位元組與 200 KiB 之間。" +"Sync storage is full; review pending items before retrying." = "同步儲存空間已滿;請審核待處理項目後重試。" +"Ignored a stale sync offer for {name}." = "已忽略 {name} 的過期同步提議。" +"Ignored signed approvals: Phase 1 requires local review." = "已忽略簽署核准:第一階段需要本機審核。" +"Sync delivery is queued; run `kc sync` to retry." = "同步傳輸已排入佇列;請執行 `kc sync` 重試。" +"Unknown sync peer: {label}." = "未知的同步裝置:{label}。" +"Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." = "只有建立變更的裝置會傳送它;若該裝置遺失,請用剩餘副本發布新的本機變更。" +"Review sync changes." = "請審核同步變更。" +"Review {name} from {peer}: current {current}, proposed {proposed}." = "審核來自 {peer} 的 {name}:目前指紋 {current},提議指紋 {proposed}。" +"Select sync items." = "請選擇同步項目。" +"Run `kc sync rm {name}` before deleting this item." = "刪除此項目之前,請先執行 `kc sync rm {name}`。" +"{sent} sent, {updated} updated, {conflict} conflict, {held} held" = "已傳送 {sent} 項,已更新 {updated} 項,衝突 {conflict} 項,暫存 {held} 項" +"Sync {name}: {result}." = "同步 {name}:{result}。" +"{names} and {n} more" = "{names}及其他{n}項" +"kc sync add {names}" = "kc sync add {names}" +"kc sync rm {names}" = "kc sync rm {names}" +"kc sync peer add {label}" = "kc sync peer add {label}" +"kc sync peer rm {label}" = "kc sync peer rm {label}" +"Accept {names} from {devices}; reject {rejected}" = "接受來自{devices}的{names};拒絕{rejected}" +"Accept {names} from {devices}" = "接受來自{devices}的{names}" +"Reject {rejected}" = "拒絕{rejected}" +"Replace {name} with the value from {device}" = "以{device}的值取代{name}" +"Resolve {name}: keep {choice}" = "解決{name}:保留{choice}" +"Restore {name} to its checkpoint" = "將{name}還原至檢查點" +"Unfreeze sync" = "解除同步凍結" +"Confirm the current value of {name} as its checkpoint" = "確認{name}的目前值為檢查點" +"Ignored a sync offer from disabled or blocked peer {peer}." = "已忽略已停用或遭封鎖的裝置{peer}的同步提議。" +"Sync item held; run `kc sync review`." = "同步項目已保留;請執行 `kc sync review`。" +"{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 有衝突,請先用 `kc sync resolve {name}` 解決。" diff --git a/crates/kc-cli/src/cli.rs b/crates/kc-cli/src/cli.rs index 2bfcbbc..bb26450 100644 --- a/crates/kc-cli/src/cli.rs +++ b/crates/kc-cli/src/cli.rs @@ -60,6 +60,8 @@ pub enum Command { Device(DeviceArgs), /// Check the keychain, the relay and the configuration Doctor(DoctorArgs), + /// Synchronize selected items with paired devices + Sync(SyncArgs), } #[derive(Debug, Args)] @@ -362,3 +364,65 @@ mod tests { assert!(cli.allow_http); } } + +#[derive(Debug, Args)] +pub struct SyncArgs { + #[command(subcommand)] + pub command: Option, +} + +#[derive(Debug, Subcommand)] +pub enum SyncCommand { + /// Show synchronization state without values + Status { + /// Print JSON + #[arg(long)] + json: bool, + /// Confirm the current value as the recovery checkpoint + #[arg(long, value_name = "NAME")] + confirm_checkpoint: Option, + }, + /// Add items and offer them to paired devices + Add { + names: Vec, + #[arg(long, value_delimiter = ',')] + peers: Vec, + }, + /// Offer selected sync items again + Offer { + names: Vec, + #[arg(long, value_delimiter = ',')] + peers: Vec, + }, + /// Remove items from this device's sync set, keeping their values + Rm { + #[arg(required = true)] + names: Vec, + }, + /// Manage the paired devices used for sync + Peer { + #[command(subcommand)] + command: SyncPeerCommand, + }, + /// Review proposals and held changes + Review, + /// Resolve a conflict with a new version + Resolve { + name: String, + #[arg(long)] + keep: String, + }, + /// Restore the recovery checkpoint + RestoreCheckpoint { name: String }, + /// Hold all incoming sync changes + Freeze, + /// Resume sync after local confirmation + Unfreeze, +} + +#[derive(Debug, Subcommand)] +pub enum SyncPeerCommand { + Add { label: String }, + Rm { label: String }, + List, +} diff --git a/crates/kc-cli/src/commands/apply.rs b/crates/kc-cli/src/commands/apply.rs index 6a7a666..4e9e40e 100644 --- a/crates/kc-cli/src/commands/apply.rs +++ b/crates/kc-cli/src/commands/apply.rs @@ -57,6 +57,7 @@ impl Conflicts { #[derive(Debug, Default)] pub(crate) struct Applied { pub results: Vec, + pub confirmation_denied: bool, /// The first keychain error, to show once, with its exit code: 4 when the keychain is /// unavailable, 5 when it wants a person to confirm, 1 otherwise. pub keychain_error: Option<(String, i32)>, @@ -70,6 +71,9 @@ pub(crate) struct Applied { impl Applied { /// 0 if everything is here, the keychain error's code if the keychain failed, else 8. pub fn exit_code(&self) -> i32 { + if self.confirmation_denied { + return exit::INTERACTION_REQUIRED; + } match &self.keychain_error { Some((_, code)) => *code, None => local_exit_code(&self.results), @@ -130,6 +134,18 @@ pub(crate) fn declined(items: &[Item]) -> Vec { } pub(crate) fn apply_items( + ctx: &mut Ctx<'_, H>, + items: &[Item], + conflicts: Conflicts, + from_device: &str, + journal: Option<&mut dyn Journal>, +) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + apply_items_locked(ctx, items, conflicts, from_device, journal) +} + +pub(crate) fn apply_items_locked( ctx: &mut Ctx<'_, H>, items: &[Item], conflicts: Conflicts, @@ -171,6 +187,11 @@ pub(crate) fn apply_items( } status } + Err(Failure::SyncConfirmation(e)) => { + applied.confirmation_denied = true; + say!(ctx, "{e}"); + ItemStatus::SkippedConflict + } Err(Failure::Cli(e)) => return Err(e), }; let result = ItemResult { @@ -194,6 +215,7 @@ pub(crate) fn apply_items( } enum Failure { + SyncConfirmation(CliError), Store(StoreError), /// A prompt was cancelled, or a lock couldn't be taken. Cli(CliError), @@ -239,11 +261,25 @@ fn apply_one( if value.len() > MAX_VALUE_LEN { return Ok(ItemStatus::Rejected(REJECT_TOO_LARGE)); } + if let Some(status) = crate::sync::legacy( + ctx, + item, + from_device, + conflicts == Conflicts::Policy(ConflictPolicy::Overwrite), + ) + .map_err(|e| { + if e.code == exit::INTERACTION_REQUIRED { + Failure::SyncConfirmation(e) + } else { + Failure::Cli(e) + } + })? { + return Ok(status); + } let policy = match conflicts { Conflicts::Policy(policy) => policy, Conflicts::Ask { overwrite } => { { - let _items = ctx.state.lock_items(ctx.store.namespace())?; if let Some(status) = settle_without_conflict(ctx, item, from_device, mark)? { return Ok(status); } @@ -252,12 +288,12 @@ fn apply_one( ask(ctx, &item.name, overwrite)? } }; - let _items = ctx.state.lock_items(ctx.store.namespace())?; if let Some(status) = settle_without_conflict(ctx, item, from_device, mark)? { return Ok(status); } match policy { ConflictPolicy::Skip => Ok(ItemStatus::SkippedConflict), + ConflictPolicy::Overwrite if !ctx.interactive() => Ok(ItemStatus::SkippedConflict), ConflictPolicy::Overwrite => { mark(&ctx.state)?; store(ctx, item.name.as_str(), item, from_device)?; diff --git a/crates/kc-cli/src/commands/inbox.rs b/crates/kc-cli/src/commands/inbox.rs index 659101b..e4501ba 100644 --- a/crates/kc-cli/src/commands/inbox.rs +++ b/crates/kc-cli/src/commands/inbox.rs @@ -52,11 +52,13 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res Err(e) => return Err(CliError::from(e).context(tr!("reading this device's inbox"))), } } + let _items = ctx.state.lock_items(ctx.store.namespace())?; let _lock = ctx.state.lock()?; let listing = match relay.list_messages(&inbox_id, &owner, Duration::ZERO).await { Ok(listing) => listing, Err(e) if e.is(ErrorCode::Unauthorized) => { drop(_lock); + drop(_items); return lost_inbox(ctx, &relay, &inbox_id).await; } Err(e) => return Err(CliError::from(e).context(tr!("reading this device's inbox"))), @@ -85,11 +87,11 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res let opened = message_body(message) .map_err(|_| InboxError::Malformed) .and_then(|body| { - inbox::open( + inbox::open_any( &body, &key_refs, |fp| peers.by_fingerprint(fp).map(|p| p.device_pk), - |id| seen.contains(id), + |_| false, now, ) }); @@ -127,7 +129,31 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res let label = peers .by_fingerprint(&opened.sender_fp) .map_or_else(|| opened.sender_fp.short(), |p| p.label.to_string()); - let names: Vec<&str> = opened.items.iter().map(|i| i.name.as_str()).collect(); + let until = opened.keep_seen_until(); + if seen.contains(&opened.msg_id) { + say!( + ctx, + "{}", + tr!( + "A message was dropped: {error} (or one this device stored before but couldn't delete).", + error = InboxError::Replay + ) + ); + outcome.failed(InboxError::Replay.exit_code()); + delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; + continue; + } + let items = match &opened.body { + inbox::Body::Sync(message_body) => { + crate::sync::receive(ctx, &opened.sender_fp.to_hex(), message_body)?; + seen.insert(&opened.msg_id, until); + ctx.state.save_seen(&seen)?; + delete(ctx, &relay, &inbox_id, &owner, &message.msg_id).await; + continue; + } + inbox::Body::Items(items) => items, + }; + let names: Vec<&str> = items.iter().map(|i| i.name.as_str()).collect(); let (n, names) = (names.len(), names.join(", ")); let text = if n == 1 { tr!( @@ -163,7 +189,7 @@ pub(super) async fn inbox(ctx: &mut Ctx<'_, H>, args: InboxArgs) -> Res id: opened.msg_id, until, }; - apply::apply_items(ctx, &opened.items, conflicts, &label, Some(&mut journal))? + apply::apply_items_locked(ctx, items, conflicts, &label, Some(&mut journal))? }; apply::print_results(ctx, &applied.results, true); if applied.done_before > 0 { @@ -258,6 +284,13 @@ async fn lost_inbox(ctx: &mut Ctx<'_, H>, relay: &H::Relay, lost: &str) let (_, replaced) = pairing::replace_lost_inbox(ctx, relay, &lock, lost).await?; drop(lock); if replaced { + if ctx.state.root().join("sync.json").exists() { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut sync = crate::sync::State::load(&ctx.state)?; + sync.reconnect = true; + sync.save(&ctx.state)?; + } pairing::lost_inbox_notice(ctx); } else { say!( diff --git a/crates/kc-cli/src/commands/items.rs b/crates/kc-cli/src/commands/items.rs index ae9e0d1..db41104 100644 --- a/crates/kc-cli/src/commands/items.rs +++ b/crates/kc-cli/src/commands/items.rs @@ -67,10 +67,7 @@ pub(super) fn set(ctx: &mut Ctx<'_, H>, args: SetArgs) -> Result { "the value is empty; nothing was stored" ))); } - let outcome = { - let _items = ctx.state.lock_items(ctx.store.namespace())?; - ctx.store.set(name.as_str(), &value, kind, Origin::Local)? - }; + let outcome = crate::sync::local_set(ctx, name.as_str(), &value, kind, Origin::Local)?; match outcome.change { Change::Created => { let n = value.len(); @@ -331,6 +328,19 @@ fn format_table(items: &[ItemInfo]) -> String { pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { let name = item_name(&args.name)?; + { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + if crate::sync::State::load(&ctx.state)? + .items + .contains_key(name.as_str()) + { + return Err(CliError::interaction(tr!( + "Run `kc sync rm {name}` before deleting this item.", + name = name + ))); + } + } if ctx.interactive() && !args.yes { if !ctx.store.exists(name.as_str())? { return Err(not_found(&name)); @@ -345,6 +355,16 @@ pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { } let deleted = { let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + if crate::sync::State::load(&ctx.state)? + .items + .contains_key(name.as_str()) + { + return Err(CliError::interaction(tr!( + "Run `kc sync rm {name}` before deleting this item.", + name = name + ))); + } ctx.store.delete(name.as_str())? }; if deleted { @@ -357,10 +377,7 @@ pub(super) fn rm(ctx: &mut Ctx<'_, H>, args: RmArgs) -> Result { pub(super) fn restore(ctx: &mut Ctx<'_, H>, args: NameArgs) -> Result { let name = item_name(&args.name)?; - { - let _items = ctx.state.lock_items(ctx.store.namespace())?; - ctx.store.restore(name.as_str())?; - } + crate::sync::observed_write(ctx, name.as_str(), |store| store.restore(name.as_str()))?; say!( ctx, "{}", @@ -381,11 +398,9 @@ pub(super) fn adopt(ctx: &mut Ctx<'_, H>, args: AdoptArgs) -> Result say!( ctx, diff --git a/crates/kc-cli/src/commands/mod.rs b/crates/kc-cli/src/commands/mod.rs index ca94a8d..a959fa6 100644 --- a/crates/kc-cli/src/commands/mod.rs +++ b/crates/kc-cli/src/commands/mod.rs @@ -6,8 +6,9 @@ mod device; mod doctor; mod inbox; mod items; -mod pairing; +pub(crate) mod pairing; mod peers; +mod sync; mod transfer; use std::ffi::OsString; @@ -74,7 +75,8 @@ async fn execute(host: &mut H, cli: Cli) -> Result { } let settings = Settings::load(state.root())?; let policy = Policy::new(interactivity, settings.agent_code_send); - policy.check(&policy::gates(&cli.command, interactivity.stdin_terminal))?; + let gates = policy::gates(&cli.command, interactivity.stdin_terminal); + policy.check(&gates)?; let store = Keychain::new(host.open_store(policy.interactive())?); let mut ctx = Ctx { host, @@ -91,18 +93,39 @@ async fn execute(host: &mut H, cli: Cli) -> Result { async fn dispatch(ctx: &mut Ctx<'_, H>, command: Command) -> Result { pairing::expire_prev_key(ctx); match command { - Command::Set(args) => items::set(ctx, args), + Command::Set(args) => { + let code = items::set(ctx, args)?; + crate::sync::send_after_write(ctx).await; + Ok(code) + } Command::Get(args) => items::get(ctx, args), Command::Exec(args) => items::exec(ctx, args), Command::List(args) => items::list(ctx, args), Command::Rm(args) => items::rm(ctx, args), - Command::Restore(args) => items::restore(ctx, args), - Command::Adopt(args) => items::adopt(ctx, args), + Command::Restore(args) => { + let code = items::restore(ctx, args)?; + crate::sync::send_after_write(ctx).await; + Ok(code) + } + Command::Adopt(args) => { + let code = items::adopt(ctx, args)?; + crate::sync::send_after_write(ctx).await; + Ok(code) + } Command::Send(args) => transfer::send(ctx, args).await, Command::Receive(args) => transfer::receive(ctx, args).await, Command::Pair(args) => transfer::pair(ctx, args).await, Command::Peers(args) => peers::peers(ctx, args).await, - Command::Inbox(args) => inbox::inbox(ctx, args).await, + Command::Inbox(args) => { + let code = inbox::inbox(ctx, args).await?; + crate::sync::flush(ctx, false).await?; + Ok(if code != 0 && code != 8 { + code + } else { + code.max(crate::sync::pending_code(ctx)?) + }) + } + Command::Sync(args) => sync::run(ctx, args).await, Command::Device(args) => device::device(ctx, args).await, Command::Doctor(_) => unreachable!("handled before the store is opened"), } diff --git a/crates/kc-cli/src/commands/sync.rs b/crates/kc-cli/src/commands/sync.rs new file mode 100644 index 0000000..15545a5 --- /dev/null +++ b/crates/kc-cli/src/commands/sync.rs @@ -0,0 +1,73 @@ +use super::{Ctx, inbox, say}; +use crate::{ + cli::{InboxArgs, SyncArgs}, + error::Result, + host::Host, + i18n::tr, + sync::{self, State}, +}; + +pub(super) async fn run(ctx: &mut Ctx<'_, H>, args: SyncArgs) -> Result { + if let Some(command) = args.command { + let quiet = matches!( + command, + crate::cli::SyncCommand::Status { .. } + | crate::cli::SyncCommand::Freeze + | crate::cli::SyncCommand::Peer { + command: crate::cli::SyncPeerCommand::List + } + ); + let code = sync::actions::command(ctx, command)?; + if !quiet { + sync::flush(ctx, false).await?; + } + return Ok(code); + } + let before = { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + sync::scan(ctx, &mut s)?; + s.items + .iter() + .map(|(n, i)| (n.clone(), i.head)) + .collect::>() + }; + let received = inbox::inbox( + ctx, + InboxArgs { + on_conflict: None, + wait: None, + }, + ) + .await?; + let sent = sync::flush(ctx, true).await?; + let s = State::load(&ctx.state)?; + let updated = s + .items + .iter() + .filter(|(n, i)| before.get(*n) != Some(&i.head)) + .count(); + let conflict = s.items.values().filter(|i| i.conflict).count(); + let held = s + .candidates + .values() + .filter(|c| c.category != sync::CandidateKind::Conflict) + .count(); + say!( + ctx, + "{}", + tr!( + "{sent} sent, {updated} updated, {conflict} conflict, {held} held", + sent = sent, + updated = updated, + conflict = conflict, + held = held + ) + ); + Ok(if received != 0 && received != 8 { + received + } else { + sync::pending_code(ctx)?.max(received) + }) +} diff --git a/crates/kc-cli/src/host.rs b/crates/kc-cli/src/host.rs index 4db2db8..e69df55 100644 --- a/crates/kc-cli/src/host.rs +++ b/crates/kc-cli/src/host.rs @@ -17,6 +17,7 @@ use crate::console::{Console, TermConsole}; use crate::error::{CliError, Result}; use crate::http::HttpRelay; use crate::i18n::tr; +use crate::local_auth::{self, LocalAuthOutcome}; use crate::settings::RelayUrl; pub trait Host { @@ -24,6 +25,15 @@ pub trait Host { type Console: Console; fn console(&mut self) -> &mut Self::Console; + /// OS user presence outside the terminal (sync design §3.1). + fn local_confirm(&mut self, _reason: &str) -> LocalAuthOutcome { + LocalAuthOutcome::Unavailable("no local confirmation on this host".into()) + } + /// Test injection after a sync transaction's keychain write; production never interrupts. + #[doc(hidden)] + fn sync_interrupt_after_write(&mut self) -> bool { + false + } /// A process environment variable (`CI`, `CLAUDECODE`, `KC_RELAY`). fn env_var(&self, key: &str) -> Option; fn stdin_is_terminal(&self) -> bool; @@ -83,6 +93,10 @@ impl Host for RealHost { &mut self.console } + fn local_confirm(&mut self, reason: &str) -> LocalAuthOutcome { + local_auth::confirm(reason) + } + fn env_var(&self, key: &str) -> Option { std::env::var_os(key) } diff --git a/crates/kc-cli/src/lib.rs b/crates/kc-cli/src/lib.rs index cea8acb..0a16f8b 100644 --- a/crates/kc-cli/src/lib.rs +++ b/crates/kc-cli/src/lib.rs @@ -26,15 +26,18 @@ pub mod http; pub mod i18n; pub mod interrupt; mod keychain; +mod local_auth; pub mod policy; pub mod settings; pub mod state; +mod sync; mod values; pub use console::{Console, PromptError, TermConsole}; pub use error::CliError; pub use host::{Host, RealHost, spawn_and_wait}; pub use http::HttpRelay; +pub use local_auth::LocalAuthOutcome; pub use settings::{RelayUrl, Settings}; use std::ffi::OsString; diff --git a/crates/kc-cli/src/local_auth.rs b/crates/kc-cli/src/local_auth.rs new file mode 100644 index 0000000..0d54a73 --- /dev/null +++ b/crates/kc-cli/src/local_auth.rs @@ -0,0 +1,60 @@ +//! Local confirmation (sync design §3.1): the OS shows secure UI and reads biometrics +//! or credentials outside the terminal, so owning a PTY cannot type/script the answer. +//! There is no terminal fallback or cached confirmation in kc. + +#[cfg(target_os = "macos")] +#[allow(unsafe_code)] +mod macos; +#[cfg(windows)] +mod windows; +// Compile the pure Linux parser and result tests on the native test platform too. +#[cfg(any(target_os = "linux", test))] +mod linux; + +/// The result of an OS user-presence check. +#[derive(Debug, Clone, PartialEq)] +pub enum LocalAuthOutcome { + Confirmed, + Denied, + Unavailable(String), +} + +/// Blocks for a fresh OS confirmation, showing `reason` in the authentication UI. +pub fn confirm(reason: &str) -> LocalAuthOutcome { + // LocalAuthentication throws an Objective-C exception for an empty reason. + if reason.trim().is_empty() { + return LocalAuthOutcome::Unavailable("local confirmation needs a reason".into()); + } + #[cfg(target_os = "macos")] + { + macos::confirm(reason) + } + #[cfg(windows)] + { + windows::confirm(reason) + } + #[cfg(target_os = "linux")] + { + linux::confirm(reason) + } + #[cfg(not(any(target_os = "macos", windows, target_os = "linux")))] + { + LocalAuthOutcome::Unavailable("local confirmation is unsupported on this platform".into()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn empty_reason_does_not_prompt() { + assert!(matches!(confirm(" \t\n"), LocalAuthOutcome::Unavailable(_))); + } + + #[test] + #[ignore = "requires a human to answer the OS authentication prompt"] + fn manual_local_confirmation() { + eprintln!("{:?}", confirm("kc test")); + } +} diff --git a/crates/kc-cli/src/local_auth/linux.rs b/crates/kc-cli/src/local_auth/linux.rs new file mode 100644 index 0000000..8891251 --- /dev/null +++ b/crates/kc-cli/src/local_auth/linux.rs @@ -0,0 +1,144 @@ +use std::process::Command; + +use super::LocalAuthOutcome; + +#[cfg(target_os = "linux")] +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + let start_time = match std::fs::read_to_string("/proc/self/stat") { + Ok(stat) => match process_start_time(&stat) { + Ok(time) => time, + Err(error) => return LocalAuthOutcome::Unavailable(error.into()), + }, + Err(error) => { + return LocalAuthOutcome::Unavailable(format!("cannot read /proc/self/stat: {error}")); + } + }; + // Do not enable pkcheck's internal terminal agent. Authentication belongs to + // the session's OS agent, with no input inherited from kc's PTY. + // Polkit policy controls whether this check requires fresh authentication; + // kc itself never retains or reuses an authorization result. + match command(reason, std::process::id(), start_time).output() { + Ok(output) => outcome(output.status.code(), &output.stderr), + Err(error) => LocalAuthOutcome::Unavailable(format!("cannot run pkcheck: {error}")), + } +} + +fn command(reason: &str, pid: u32, start_time: u64) -> Command { + let mut command = Command::new("pkcheck"); + command.args([ + "--action-id", + "org.freedesktop.policykit.exec", + "--process", + &format!("{pid},{start_time}"), + "--allow-user-interaction", + "--detail", + "polkit.message", + reason, + ]); + command.stdin(std::process::Stdio::null()); + command +} + +/// Field 22 follows the state (field 3) by 19 fields. `comm` (field 2) can +/// contain whitespace and parentheses, so only the final ')' ends that field. +fn process_start_time(stat: &str) -> Result { + let (_, fields) = stat + .rsplit_once(')') + .ok_or("/proc/self/stat has no comm terminator")?; + fields + .split_whitespace() + .nth(19) + .ok_or("/proc/self/stat has no start time")? + .parse() + .map_err(|_| "/proc/self/stat has an invalid start time") +} + +fn outcome(code: Option, stderr: &[u8]) -> LocalAuthOutcome { + match code { + Some(0) => LocalAuthOutcome::Confirmed, + // pkcheck(1): 1 = not authorized, 3 = dialog dismissed. 2 means user interaction was + // needed but no authentication agent could ask, which falls to Unavailable below. + Some(1 | 3) => LocalAuthOutcome::Denied, + _ => LocalAuthOutcome::Unavailable(format!( + "pkcheck failed (exit {code:?}): {}", + String::from_utf8_lossy(stderr).trim() + )), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn stat(comm: &str, start: &str) -> String { + // Fields 4..21 intentionally differ from field 22 to catch off-by-one errors. + format!("42 ({comm}) S {}{start} 900 901\n", "7 ".repeat(18)) + } + + #[test] + fn reads_field_22() { + assert_eq!(process_start_time(&stat("kc", "123456")), Ok(123456)); + assert_eq!(process_start_time(&stat("kc", "0")), Ok(0)); + assert_eq!( + process_start_time(&stat("kc", "18446744073709551615")), + Ok(u64::MAX) + ); + } + + #[test] + fn comm_can_contain_spaces_and_parentheses() { + for comm in [ + "kc local confirm", + "kc (nested) name", + "kc)) (a) b)", + "kc\nname", + ] { + assert_eq!(process_start_time(&stat(comm, "123456")), Ok(123456)); + } + } + + #[test] + fn malformed_stat_is_unavailable() { + for text in ["", "42 kc S 1 2 3", "42 (kc) S 1 2 3"] { + assert!(process_start_time(text).is_err()); + } + for start in ["invalid", "-1", "18446744073709551616"] { + assert!(process_start_time(&stat("kc", start)).is_err()); + } + } + + #[test] + fn reason_is_one_argument_and_no_internal_agent_is_enabled() { + let command = command("kc: allow 'this' $(action)?", 42, 123456); + let args: Vec<_> = command + .get_args() + .map(|arg| arg.to_str().unwrap()) + .collect(); + assert_eq!( + args, + [ + "--action-id", + "org.freedesktop.policykit.exec", + "--process", + "42,123456", + "--allow-user-interaction", + "--detail", + "polkit.message", + "kc: allow 'this' $(action)?", + ] + ); + } + + #[test] + fn exit_status_fails_closed() { + assert_eq!(outcome(Some(0), b""), LocalAuthOutcome::Confirmed); + assert_eq!(outcome(Some(1), b""), LocalAuthOutcome::Denied); + assert_eq!(outcome(Some(3), b""), LocalAuthOutcome::Denied); + for code in [Some(2), Some(126), Some(127), Some(255), None] { + match outcome(code, b"no agent\n") { + LocalAuthOutcome::Unavailable(message) => assert!(message.contains("no agent")), + result => panic!("unexpected outcome: {result:?}"), + } + } + } +} diff --git a/crates/kc-cli/src/local_auth/macos.rs b/crates/kc-cli/src/local_auth/macos.rs new file mode 100644 index 0000000..1a9a45a --- /dev/null +++ b/crates/kc-cli/src/local_auth/macos.rs @@ -0,0 +1,93 @@ +use std::sync::mpsc; + +use block2::RcBlock; +use objc2::runtime::Bool; +use objc2_foundation::{NSError, NSString}; +use objc2_local_authentication::{LAContext, LAError, LAPolicy}; + +use super::LocalAuthOutcome; + +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + // SAFETY: LAContext has no thread affinity; this fresh, owned context stays + // alive until the asynchronous reply arrives. No prior context is reused. + let context = unsafe { LAContext::new() }; + // SAFETY: zero is a valid reuse duration and disables reuse of device unlocks. + unsafe { context.setTouchIDAuthenticationAllowableReuseDuration(0.0) }; + let policy = LAPolicy::DeviceOwnerAuthentication; + // SAFETY: policy is a supported constant, and this preflight is not inside + // an evaluation reply block (which could deadlock LocalAuthentication). + if let Err(error) = unsafe { context.canEvaluatePolicy_error(policy) } { + return LocalAuthOutcome::Unavailable(error.localizedDescription().to_string()); + } + + let reason = NSString::from_str(reason); + let (tx, rx) = mpsc::channel(); + let reply = RcBlock::new(move |success: Bool, error: *mut NSError| { + let outcome = if success.as_bool() { + LocalAuthOutcome::Confirmed + } else { + // SAFETY: LocalAuthentication supplies nil or a valid NSError for + // the duration of this callback. Only owned Rust data leaves it. + match unsafe { error.as_ref() } { + Some(error) => failure( + LAError(error.code()), + error.localizedDescription().to_string(), + ), + None => LocalAuthOutcome::Unavailable( + "LocalAuthentication returned no error details".into(), + ), + } + }; + // A dropped receiver must not unwind across the Objective-C callback. + let _ = tx.send(outcome); + }); + // SAFETY: the reason is nonempty (checked by the parent), the context and + // block remain alive during evaluation, and the callback captures only a + // thread-safe Sender. Apple invokes it on a private queue, so recv can block. + unsafe { context.evaluatePolicy_localizedReason_reply(policy, &reason, &reply) }; + rx.recv().unwrap_or_else(|error| { + LocalAuthOutcome::Unavailable(format!("LocalAuthentication reply unavailable: {error}")) + }) +} + +fn failure(code: LAError, message: String) -> LocalAuthOutcome { + match code { + LAError::AuthenticationFailed | LAError::UserCancel | LAError::UserFallback => { + LocalAuthOutcome::Denied + } + _ => LocalAuthOutcome::Unavailable(message), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn cancelled_or_failed_authentication_is_denied() { + for code in [ + LAError::UserCancel, + LAError::UserFallback, + LAError::AuthenticationFailed, + ] { + assert_eq!(failure(code, "denied".into()), LocalAuthOutcome::Denied); + } + } + + #[test] + fn unavailable_errors_preserve_the_message() { + for code in [ + LAError::BiometryNotAvailable, + LAError::BiometryNotEnrolled, + LAError::PasscodeNotSet, + LAError::SystemCancel, + LAError::InvalidContext, + LAError(-999), + ] { + assert_eq!( + failure(code, "OS error".into()), + LocalAuthOutcome::Unavailable("OS error".into()) + ); + } + } +} diff --git a/crates/kc-cli/src/local_auth/windows.rs b/crates/kc-cli/src/local_auth/windows.rs new file mode 100644 index 0000000..0c3a631 --- /dev/null +++ b/crates/kc-cli/src/local_auth/windows.rs @@ -0,0 +1,86 @@ +#![allow(unsafe_code)] // Window handles and WinRT interop require Win32 FFI. + +use windows::Foundation::IAsyncOperation; +use windows::Security::Credentials::UI::{UserConsentVerificationResult, UserConsentVerifier}; +use windows::Win32::System::Console::GetConsoleWindow; +use windows::Win32::System::WinRT::IUserConsentVerifierInterop; +use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow; +use windows::core::{HSTRING, factory}; + +use super::LocalAuthOutcome; + +pub(super) fn confirm(reason: &str) -> LocalAuthOutcome { + // Request a new verification every time; never retain a previous result. + match request_verification(reason) { + Ok(result) => outcome(result), + Err(error) => LocalAuthOutcome::Unavailable(format!("Windows Hello: {error}")), + } +} + +fn request_verification(reason: &str) -> windows::core::Result { + let verifier = factory::()?; + // SAFETY: These calls take no pointers; the returned handles are borrowed + // for the OS verification UI and are never freed or dereferenced here. + let hwnd = unsafe { + let console = GetConsoleWindow(); + if console.0.is_null() { + GetForegroundWindow() + } else { + console + } + }; + // SAFETY: The OS-provided window handle and owned HSTRING remain valid + // for the call; the requested interface is the documented result type. + let request: IAsyncOperation = + unsafe { verifier.RequestVerificationForWindowAsync(hwnd, &HSTRING::from(reason))? }; + request.get() +} + +fn outcome(result: UserConsentVerificationResult) -> LocalAuthOutcome { + match result { + UserConsentVerificationResult::Verified => LocalAuthOutcome::Confirmed, + UserConsentVerificationResult::Canceled + | UserConsentVerificationResult::RetriesExhausted => LocalAuthOutcome::Denied, + UserConsentVerificationResult::DeviceNotPresent => { + LocalAuthOutcome::Unavailable("Windows Hello device not present".into()) + } + UserConsentVerificationResult::NotConfiguredForUser => { + LocalAuthOutcome::Unavailable("Windows Hello is not configured for this user".into()) + } + UserConsentVerificationResult::DisabledByPolicy => { + LocalAuthOutcome::Unavailable("Windows Hello is disabled by policy".into()) + } + UserConsentVerificationResult::DeviceBusy => { + LocalAuthOutcome::Unavailable("Windows Hello device is busy".into()) + } + _ => LocalAuthOutcome::Unavailable(format!("Windows Hello returned {result:?}")), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn only_verified_confirms() { + assert_eq!( + outcome(UserConsentVerificationResult::Verified), + LocalAuthOutcome::Confirmed + ); + for result in [ + UserConsentVerificationResult::Canceled, + UserConsentVerificationResult::RetriesExhausted, + ] { + assert_eq!(outcome(result), LocalAuthOutcome::Denied); + } + for result in [ + UserConsentVerificationResult::DeviceNotPresent, + UserConsentVerificationResult::NotConfiguredForUser, + UserConsentVerificationResult::DisabledByPolicy, + UserConsentVerificationResult::DeviceBusy, + UserConsentVerificationResult(-1), + ] { + assert!(matches!(outcome(result), LocalAuthOutcome::Unavailable(_))); + } + } +} diff --git a/crates/kc-cli/src/settings.rs b/crates/kc-cli/src/settings.rs index fb9de34..63db42c 100644 --- a/crates/kc-cli/src/settings.rs +++ b/crates/kc-cli/src/settings.rs @@ -33,17 +33,20 @@ pub const ENV_RELAY: &str = "KC_RELAY"; const HEADER: &str = "# kc device settings (no secrets here). `kc doctor` checks this file.\n"; /// The fields kc knows; `kc doctor` reports any others. -const KNOWN_KEYS: [&str; 6] = [ +const KNOWN_KEYS: [&str; 7] = [ "label", "relay", "agent_code_send", "allow_http", "inbox_id", "device_key_prev_until", + "sync", ]; #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] pub struct Settings { + #[serde(default, skip_serializing_if = "SyncSettings::is_default")] + pub sync: SyncSettings, /// The label this device suggests when pairing. Default: the host name. #[serde(default, skip_serializing_if = "Option::is_none")] pub label: Option, @@ -64,6 +67,32 @@ pub struct Settings { pub device_key_prev_until: Option, } +/// Human-edited sync settings. Scheduling and signed-approval endpoints are reserved +/// for their later phases; Phase 1 always enforces the design's fixed breaker caps. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(default)] +pub struct SyncSettings { + pub interval: Option, + pub max_remote_overwrites: usize, + pub max_proposals_per_day: usize, + pub approver_url: Option, +} +impl Default for SyncSettings { + fn default() -> Self { + Self { + interval: None, + max_remote_overwrites: 1, + max_proposals_per_day: 32, + approver_url: None, + } + } +} +impl SyncSettings { + fn is_default(&self) -> bool { + self == &Self::default() + } +} + impl Settings { /// Reads `config.toml` from `dir`; a missing file gives the defaults. pub fn load(dir: &Path) -> Result { @@ -336,6 +365,7 @@ mod tests { allow_http: true, inbox_id: Some("AAAAAAAAAAAAAAAAAAAAAA".into()), device_key_prev_until: Some(1_760_000_000), + sync: SyncSettings::default(), }; s.save(dir.path()).unwrap(); assert_eq!(Settings::load(dir.path()).unwrap(), s); diff --git a/crates/kc-cli/src/state.rs b/crates/kc-cli/src/state.rs index 3890ad4..5033d52 100644 --- a/crates/kc-cli/src/state.rs +++ b/crates/kc-cli/src/state.rs @@ -269,8 +269,8 @@ impl StateDir { /// conflict check and the write it decides on can't interleave with another kc process /// writing to the same keychain namespace. The keychain is shared by every config /// directory of the user, so the lock file lives in a per-user directory (the runtime - /// or cache directory), not in the config directory. Taken after `state.lock` when - /// both are needed, never the other way round. + /// or cache directory), not in the config directory. Taken before `state.lock` when + /// both are needed; seen.json is written after sync state. pub fn lock_items(&self, namespace: &str) -> Result { let file = format!("{ITEMS_LOCK_PREFIX}{namespace}.lock"); let busy = || tr!("another kc process is writing items; try again"); diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs new file mode 100644 index 0000000..89409ae --- /dev/null +++ b/crates/kc-cli/src/sync/actions.rs @@ -0,0 +1,671 @@ +use super::*; +use crate::cli::{SyncCommand, SyncPeerCommand}; +use state::{CandidateKind, Control, Item, Offer, Peer}; +use transaction::{blob, put_blob, queue}; + +pub(crate) fn label(ctx: &Ctx<'_, H>, peer: &str) -> Result { + if peer == "mine" { + return Ok(tr!("this device")); + } + Ok(ctx + .state + .load_peers()? + .peers + .iter() + .find(|p| p.fingerprint.to_hex() == peer) + .map(|p| p.label.to_string()) + .unwrap_or_else(|| peer.to_string())) +} +fn selected_peers(ctx: &Ctx<'_, H>, s: &State, labels: &[String]) -> Result> { + let peers = ctx.state.load_peers()?; + if labels.is_empty() { + return Ok(peers + .peers + .iter() + .filter(|p| { + s.peers + .get(&p.fingerprint.to_hex()) + .is_none_or(|p| p.enabled) + }) + .map(|p| p.fingerprint.to_hex()) + .collect()); + } + labels + .iter() + .map(|label| { + peers + .find(label) + .map(|p| p.fingerprint.to_hex()) + .ok_or_else(|| { + CliError::not_found(tr!("Unknown sync peer: {label}.", label = label)) + }) + }) + .collect() +} +fn offer(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str, peers: &[String]) -> Result<()> { + let (value, kind, fp) = current(ctx, name)?.ok_or_else(state_error)?; + size(&value)?; + let item = s.items[name].clone(); + // Re-offering a received value is a new local publication, never forwarding its vid. + if item.conflict { + return Err(CliError::new(8, tr!("Sync needs local confirmation."))); + } + if !item.own { + transaction::publish_current(ctx, s, name)?; + } + let item = s.items[name].clone(); + let slot = snapshot_slot(item.head); + if !reserve(ctx, s, &slot, SlotKind::ConflictCandidate, true)? { + return Err(capacity()); + } + put_blob(ctx, &slot, kind, &value)?; + remember(ctx, name, item.head, fp, &item.parents)?; + s.latest_local.insert(name.into(), item.head); + s.versions.insert( + vid_key(item.head), + Version { + name: name.into(), + vid: item.head, + parents: item.parents.clone(), + lineage: item.lineage.clone(), + kind, + slot, + }, + ); + for peer in peers { + s.peers.entry(peer.clone()).or_insert_with(|| Peer { + enabled: true, + ..Peer::default() + }); + s.items.get_mut(name).unwrap().scope.insert(peer.clone()); + s.generations.accept(name, PeerId(peer.clone())); + s.offers.retain(|o| o.peer != *peer || o.name != name); + s.offers.push(Offer { + peer: peer.clone(), + name: name.into(), + vid: item.head, + }); + } + Ok(()) +} +pub(crate) fn remove(ctx: &Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { + let (registration, mut peers) = s.generations.rm(name).map_err(|_| state_error())?; + if let Some(item) = s.items.remove(name) { + peers.extend(item.scope.into_iter().map(PeerId)); + } + for peer in peers { + if peer.0 == "mine" { + continue; + } + queue( + s, + &peer.0, + Control::Leave { + name: name.into(), + generation: registration.generation, + }, + ); + } + let checkpoint = checkpoint_slot(name); + s.slots.remove(&checkpoint); + s.gc.insert(checkpoint); + s.offers.retain(|o| o.name != name); + transaction::clear_candidates(s, name); + for peer in s.peers.keys().cloned().collect::>() { + let ids = s + .outbox + .pending(&PeerId(peer.clone())) + .filter(|id| id.name == name) + .cloned() + .collect::>(); + for id in ids { + s.outbox + .ack(&PeerId(peer.clone()), &id, kc_sync::AckResult::Rejected); + } + } + super::transport::collect_snapshots(s); + s.cleanup(ctx) +} +pub(crate) fn status(ctx: &mut Ctx<'_, H>, json: bool) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + let mut rows = Vec::new(); + for (name, item) in &s.items { + let state = if s.frozen { + tr!("frozen") + } else if item.conflict { + tr!("conflict") + } else if item + .scope + .iter() + .any(|p| s.peers.get(p).is_some_and(|p| p.reoffer.contains(name))) + { + tr!("re-offer needed") + } else if s + .candidates + .values() + .any(|c| c.version.name == *name && c.category == CandidateKind::Held) + { + tr!("held") + } else if s.offers.iter().any(|o| o.name == *name) + || item.scope.iter().any(|p| { + s.outbox + .pending(&PeerId(p.clone())) + .any(|c| c.name == *name) + }) + { + tr!("awaiting review") + } else { + tr!("in sync") + }; + let fingerprint = ctx + .store + .get(name)? + .map(|v| crate::values::value_fingerprint(v.as_bytes())); + let peers = item + .scope + .iter() + .map(|p| label(ctx, p)) + .collect::>>()?; + rows.push(serde_json::json!({"name": name, "state": state, "head": item.head, "fingerprint": fingerprint, "peers": peers})); + } + let mut candidates = Vec::new(); + for c in s.candidates.values() { + let fp = if c.retire { + None + } else { + { + let value = blob(ctx, &c.version.slot)?; + Some(crate::values::value_fingerprint(value.value.expose())) + } + }; + let state = match c.category { + CandidateKind::Proposal => tr!("proposal"), + CandidateKind::Held => tr!("held"), + CandidateKind::Conflict => tr!("conflict"), + }; + candidates.push(serde_json::json!({"name": c.version.name, "state": state, "peer": label(ctx, &c.peer)?, "vid": c.version.vid, "fingerprint": fp})); + } + let mut peers = Vec::new(); + for (id, peer) in &s.peers { + peers.push(serde_json::json!({"label":label(ctx, id)?, "enabled":peer.enabled, "v2":peer.capable, + "breaker":s.limiter.is_tripped(&PeerId(id.clone())), "quarantine":peer.quarantine, "last_digest":peer.last_digest, "reoffer":peer.reoffer})); + } + let output = serde_json::json!({"items": rows, "candidates": candidates, "peers": peers, "frozen":s.frozen, + "capacity_blocked":s.capacity_blocked, "slots_used":s.slots.len(), "slot_capacity":SlotBudget::new(s.items.len()).capacity(), + "reconnect":s.reconnect, "delivery_failed":s.delivery_failed, "notice":tr!("Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy.")}); + if json { + ctx.emit( + format!( + "{}\n", + serde_json::to_string_pretty(&output).map_err(|_| state_error())? + ) + .as_bytes(), + )?; + } else { + for row in rows.iter().chain(&candidates) { + ctx.emit( + format!( + "{} {} {} {}\n", + row["name"].as_str().unwrap_or(""), + row["state"].as_str().unwrap_or(""), + row["fingerprint"].as_str().unwrap_or("-"), + row.get("peer") + .cloned() + .unwrap_or_else(|| row["peers"].clone()) + ) + .as_bytes(), + )?; + } + for peer in peers { + ctx.emit(format!("{}\n", peer).as_bytes())?; + } + if s.capacity_blocked { + crate::commands::say!( + ctx, + "{}", + tr!("Sync storage is full; review pending items before retrying.") + ); + } + if s.reconnect || s.delivery_failed { + crate::commands::say!( + ctx, + "{}", + tr!("Sync delivery is queued; run `kc sync` to retry.") + ); + } + crate::commands::say!( + ctx, + "{}", + tr!( + "Only the device that created a change sends it; if it is lost, publish a new local change from a remaining copy." + ) + ); + } + Ok(if pending(&s) { 8 } else { 0 }) +} +pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { + if !ctx.interactive() { + human(ctx, &tr!("Review sync changes."))?; + } + let candidates = { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let s = State::load(&ctx.state)?; + if s.frozen { + return Ok(8); + } + s.candidates + .values() + .filter(|c| c.category != CandidateKind::Conflict) + .cloned() + .collect::>() + }; + let mut accepts = Vec::new(); + let mut rejects = Vec::new(); + for c in candidates { + let fingerprint = if c.retire { + "-".into() + } else { + let value = blob(ctx, &c.version.slot)?; + crate::values::value_fingerprint(value.value.expose()) + }; + let existing = ctx + .store + .get(&c.version.name)? + .map(|v| crate::values::value_fingerprint(v.as_bytes())) + .unwrap_or_else(|| "-".into()); + let question = tr!( + "Review {name} from {peer}: current {current}, proposed {proposed}.", + name = c.version.name, + peer = label(ctx, &c.peer)?, + current = existing, + proposed = fingerprint + ); + match ctx.select( + &question, + &[tr!("Accept"), tr!("Reject"), tr!("Leave for later")], + 2, + )? { + 0 => accepts.push(c), + 1 => rejects.push(c), + _ => {} + } + } + if !accepts.is_empty() || !rejects.is_empty() { + let names = names_summary( + &accepts + .iter() + .map(|c| c.version.name.clone()) + .collect::>(), + ); + let devices = names_summary( + &accepts + .iter() + .map(|c| label(ctx, &c.peer)) + .collect::>>()?, + ); + let rejected = names_summary( + &rejects + .iter() + .map(|c| c.version.name.clone()) + .collect::>(), + ); + // The OS dialog shows only the clauses that apply. + let reason = match (accepts.is_empty(), rejects.is_empty()) { + (false, false) => tr!( + "Accept {names} from {devices}; reject {rejected}", + names = names, + devices = devices, + rejected = rejected + ), + (false, true) => tr!( + "Accept {names} from {devices}", + names = names, + devices = devices + ), + _ => tr!("Reject {rejected}", rejected = rejected), + }; + human(ctx, &reason)?; + } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + scan(ctx, &mut s)?; + for c in rejects { + if let Some(current) = s.candidates.remove(&c.version.slot) { + release(&mut s, ¤t.version.slot); + s.gc.insert(current.base_record); + let delivery = delivery_key(&c.peer, &c.version.name, c.generation, c.version.vid); + if c.category == CandidateKind::Proposal { + s.rejected_offers.insert(delivery); + forget_binding(&mut s, &c.version.name, c.version.vid); + } else { + s.receipts.insert( + delivery, + ( + kc_proto::sync::AckResult::Rejected, + ctx.host.now().saturating_add(3 * 86400), + ), + ); + } + if !c.legacy && c.category != CandidateKind::Proposal { + queue( + &mut s, + &c.peer, + Control::Ack { + id: kc_proto::sync::ChangeId { + name: crate::values::item_name(&c.version.name)?, + generation: c.generation, + new_vid: c.version.vid, + }, + result: kc_proto::sync::AckResult::Rejected, + }, + ); + } + } + } + for c in accepts { + if s.frozen { + break; + } + if let Some(current) = s.candidates.get(&c.version.slot).cloned() + && current.category != CandidateKind::Conflict + { + transaction::accept(ctx, &mut s, ¤t)?; + } + } + s.cleanup(ctx)?; + Ok(if pending(&s) { 8 } else { 0 }) +} +pub(crate) fn command(ctx: &mut Ctx<'_, H>, mut command: SyncCommand) -> Result { + if let SyncCommand::Status { + json, + confirm_checkpoint: None, + } = command + { + return status(ctx, json); + } + if matches!(command, SyncCommand::Review) { + return review(ctx); + } + if let SyncCommand::Add { names, .. } = &mut command + && names.is_empty() + { + let options = ctx + .store + .list()? + .into_iter() + .map(|i| i.name) + .collect::>(); + *names = ctx + .multi_select(&tr!("Select sync items."), &options)? + .into_iter() + .map(|i| options[i].clone()) + .collect(); + } + let reason = match &command { + SyncCommand::Add { names, .. } => { + Some(tr!("kc sync add {names}", names = names_summary(names))) + } + SyncCommand::Rm { names } => Some(tr!("kc sync rm {names}", names = names_summary(names))), + SyncCommand::Peer { + command: SyncPeerCommand::Add { label }, + } => Some(tr!("kc sync peer add {label}", label = label)), + SyncCommand::Peer { + command: SyncPeerCommand::Rm { label }, + } => Some(tr!("kc sync peer rm {label}", label = label)), + SyncCommand::Resolve { name, keep } => Some(tr!( + "Resolve {name}: keep {choice}", + name = name, + choice = keep + )), + SyncCommand::RestoreCheckpoint { name } => { + Some(tr!("Restore {name} to its checkpoint", name = name)) + } + SyncCommand::Unfreeze => Some(tr!("Unfreeze sync")), + SyncCommand::Status { + confirm_checkpoint: Some(name), + .. + } => Some(tr!( + "Confirm the current value of {name} as its checkpoint", + name = name + )), + _ => None, + }; + if let Some(reason) = reason { + human(ctx, &reason)?; + } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + match command { + SyncCommand::Add { names, peers } => { + let peers = selected_peers(ctx, &s, &peers)?; + for name in &names { + crate::values::item_name(name)?; + let (v, _, _) = current(ctx, name)?.ok_or_else(state_error)?; + size(&v)?; + } + for name in names { + let (value, kind, fp) = current(ctx, &name)?.ok_or_else(state_error)?; + if !s.items.contains_key(&name) { + let head = Vid::random(); + remember(ctx, &name, head, fp, &[])?; + s.items.insert( + name.clone(), + Item { + head, + lineage: vec![head], + parents: vec![], + known: vec![head], + scope: Default::default(), + own: true, + conflict: false, + }, + ); + // Allocate receiver generation even when there are no peers yet. + s.generations.accept(&name, PeerId("mine".into())); + } + let _ = (value, kind); + offer(ctx, &mut s, &name, &peers)?; + } + } + SyncCommand::Offer { names, peers } => { + let peers = selected_peers(ctx, &s, &peers)?; + for name in names { + if !s.items.contains_key(&name) { + return Err(state_error()); + } + // An agent may propose only to the already locally approved scope. + let allowed = peers + .iter() + .filter(|p| s.items[&name].scope.contains(*p)) + .cloned() + .collect::>(); + if allowed.len() != peers.len() { + return Err(CliError::interaction(tr!("Sync needs local confirmation."))); + } + // An explicit re-offer is a fresh proposal even if the previous vid + // was rejected. Transport retries keep the old vid and stay rejected. + if s.items[&name].conflict { + return Err(CliError::new(8, tr!("Sync needs local confirmation."))); + } + transaction::publish_current(ctx, &mut s, &name)?; + offer(ctx, &mut s, &name, &allowed)?; + } + } + SyncCommand::Rm { names } => { + for name in names { + crate::values::item_name(&name)?; + remove(ctx, &mut s, &name)?; + } + } + SyncCommand::Freeze => s.frozen = true, + SyncCommand::Unfreeze => { + s.frozen = false; + for peer in s.peers.keys() { + s.limiter.human_reset(&PeerId(peer.clone())); + } + } + SyncCommand::Status { + confirm_checkpoint: Some(name), + .. + } => { + if !s.items.contains_key(&name) { + return Err(state_error()); + } + let (value, kind, _) = current(ctx, &name)?.ok_or_else(state_error)?; + let slot = checkpoint_slot(&name); + if !reserve(ctx, &mut s, &slot, SlotKind::Checkpoint, false)? { + return Err(capacity()); + } + put_blob(ctx, &slot, kind, &value)?; + } + SyncCommand::RestoreCheckpoint { name } => { + scan(ctx, &mut s)?; + if !s.items.contains_key(&name) { + return Err(state_error()); + } + let value = blob(ctx, &checkpoint_slot(&name))?; + transaction::resolve_value(ctx, &mut s, &name, value.value.expose(), value.kind)?; + } + SyncCommand::Resolve { name, keep } => { + scan(ctx, &mut s)?; + let was_proposal = !s.items.contains_key(&name); + if was_proposal { + let scope = s + .candidates + .values() + .filter(|c| c.version.name == name && !c.legacy) + .map(|c| c.peer.clone()) + .collect::>(); + if scope.is_empty() { + return Err(state_error()); + } + let (_, _, fp) = current(ctx, &name)?.ok_or_else(state_error)?; + let head = Vid::random(); + remember(ctx, &name, head, fp, &[])?; + s.items.insert( + name.clone(), + Item { + head, + lineage: vec![head], + parents: vec![], + known: vec![head], + scope: scope.clone(), + own: true, + conflict: true, + }, + ); + for peer in scope { + let registration = s.generations.accept(&name, PeerId(peer.clone())); + queue( + &mut s, + &peer, + Control::Accept { + name: name.clone(), + generation: registration.generation, + }, + ); + } + } + let (value, kind) = if keep == "mine" { + let (v, k, _) = current(ctx, &name)?.ok_or_else(state_error)?; + (v, k) + } else { + let peer = selected_peers(ctx, &s, &[keep])?.remove(0); + let options = s + .candidates + .values() + .filter(|c| c.version.name == name && c.peer == peer && !c.retire) + .cloned() + .collect::>(); + let choice = if options.len() > 1 { + ctx.select( + &tr!("Select sync items."), + &options + .iter() + .map(|c| vid_key(c.version.vid)) + .collect::>(), + 0, + )? + } else { + 0 + }; + let c = options.get(choice).ok_or_else(state_error)?; + let value = blob(ctx, &c.version.slot)?; + (Zeroizing::new(value.value.expose().to_vec()), value.kind) + }; + transaction::resolve_value(ctx, &mut s, &name, &value, kind)?; + } + SyncCommand::Peer { command } => match command { + SyncPeerCommand::List => { + for (p, peer) in &s.peers { + ctx.emit(format!("{} {}\n", label(ctx, p)?, peer.enabled).as_bytes())?; + } + } + SyncPeerCommand::Add { label } => { + let id = selected_peers(ctx, &s, &[label])?.remove(0); + let peer = s.peers.entry(id.clone()).or_default(); + peer.enabled = true; + if !peer.capable { + peer.hello_sent = false; + } + for name in s.items.keys().cloned().collect::>() { + offer(ctx, &mut s, &name, std::slice::from_ref(&id))?; + } + } + SyncPeerCommand::Rm { label } => { + let id = selected_peers(ctx, &s, &[label])?.remove(0); + s.peers.entry(id.clone()).or_default().enabled = false; + let names = s + .items + .iter() + .filter(|(_, i)| i.scope.contains(&id)) + .map(|(n, _)| n.clone()) + .collect::>(); + for name in names { + let (registration, _) = s.generations.rm(&name).map_err(|_| state_error())?; + s.items.get_mut(&name).unwrap().scope.remove(&id); + queue( + &mut s, + &id, + Control::Leave { + name: name.clone(), + generation: registration.generation, + }, + ); + for p in s.items[&name].scope.clone() { + s.generations.accept(&name, PeerId(p.clone())); + queue( + &mut s, + &p, + Control::Accept { + name: name.clone(), + generation: registration.generation, + }, + ); + } + } + s.offers.retain(|o| o.peer != id); + for change in s + .outbox + .pending(&PeerId(id.clone())) + .cloned() + .collect::>() + { + s.outbox + .ack(&PeerId(id.clone()), &change, kc_sync::AckResult::Rejected); + } + super::transport::collect_snapshots(&mut s); + } + }, + _ => {} + } + s.cleanup(ctx)?; + Ok(if pending(&s) { 8 } else { 0 }) +} diff --git a/crates/kc-cli/src/sync/map.rs b/crates/kc-cli/src/sync/map.rs new file mode 100644 index 0000000..e73f334 --- /dev/null +++ b/crates/kc-cli/src/sync/map.rs @@ -0,0 +1,49 @@ +//! The only conversions between the transport and pure sync contracts. +use kc_proto::sync as wire; +use kc_sync as core; + +pub fn vid(v: wire::Vid) -> core::Vid { + core::Vid(v.0) +} +pub fn wire_vid(v: core::Vid) -> wire::Vid { + wire::Vid(v.0) +} +pub fn id(v: &wire::ChangeId) -> core::ChangeId { + core::ChangeId { + name: v.name.to_string(), + generation: v.generation, + new_vid: vid(v.new_vid), + } +} +pub fn ack(v: wire::AckResult) -> core::AckResult { + match v { + wire::AckResult::Applied => core::AckResult::Applied, + wire::AckResult::Held => core::AckResult::Held, + wire::AckResult::Conflict => core::AckResult::Conflict, + wire::AckResult::StaleGeneration => core::AckResult::StaleGeneration, + wire::AckResult::DeferredCapacity => core::AckResult::DeferredCapacity, + wire::AckResult::Rejected => core::AckResult::Rejected, + } +} +pub fn wire_ack(v: core::AckResult) -> wire::AckResult { + match v { + core::AckResult::Applied => wire::AckResult::Applied, + core::AckResult::Held => wire::AckResult::Held, + core::AckResult::Conflict => wire::AckResult::Conflict, + core::AckResult::StaleGeneration => wire::AckResult::StaleGeneration, + core::AckResult::DeferredCapacity => wire::AckResult::DeferredCapacity, + core::AckResult::Rejected => wire::AckResult::Rejected, + } +} +pub fn kind(v: wire::ItemKind) -> kc_store::ItemKind { + match v { + wire::ItemKind::Text => kc_store::ItemKind::Text, + wire::ItemKind::File => kc_store::ItemKind::File, + } +} +pub fn wire_kind(v: kc_store::ItemKind) -> wire::ItemKind { + match v { + kc_store::ItemKind::Text => wire::ItemKind::Text, + kc_store::ItemKind::File => wire::ItemKind::File, + } +} diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs new file mode 100644 index 0000000..d54b406 --- /dev/null +++ b/crates/kc-cli/src/sync/mod.rs @@ -0,0 +1,324 @@ +//! Phase 1 persistence adapter: all mutations require items -> state locks. The pure +//! crate owns decisions, lineage, delivery accounting, generations, limits and recovery. +pub(crate) mod actions; +mod map; +mod receive; +mod state; +mod transaction; +mod transport; +pub(crate) use receive::{legacy, receive}; +pub(crate) use state::{CandidateKind, State}; +pub(crate) use transaction::{local_set, observed_write, recover, scan}; +pub(crate) use transport::{flush, send_after_write}; + +use crate::{ + LocalAuthOutcome, + commands::Ctx, + error::{CliError, Result}, + host::Host, + i18n::tr, +}; +use hmac::{Hmac, Mac}; +use kc_proto::sync::{ItemKind, Vid}; +use kc_sync::{Fp, ItemState, PeerId, Reservation, SlotBudget, SlotKind, VidRecord}; +use serde::{Serialize, de::DeserializeOwned}; +use sha2::{Digest, Sha256}; +use state::{Item, Version}; +use zeroize::Zeroizing; + +pub(crate) fn state_error() -> CliError { + CliError::failure(tr!( + "Sync state is unavailable or damaged; retry after checking the keychain and state directory." + )) +} +pub(crate) fn human(ctx: &mut Ctx<'_, H>, reason: &str) -> Result<()> { + if !ctx.interactive() || ctx.host.local_confirm(reason) != LocalAuthOutcome::Confirmed { + return Err( + CliError::interaction(tr!("Sync needs local confirmation.")).with_hint(tr!( + "Run this command at a terminal and confirm in the operating system." + )), + ); + } + Ok(()) +} +pub(crate) fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +fn tag(name: &str) -> String { + hex(&Sha256::digest(name.as_bytes())) +} +fn delivery_key(peer: &str, name: &str, generation: u64, vid: Vid) -> String { + format!("{peer}/{name}/{generation}/{}", hex(&vid.0)) +} +fn vid_key(vid: Vid) -> String { + hex(&vid.0) +} +fn record_slot(name: &str, vid: Vid) -> String { + format!("sync/fp/{}/{}", tag(name), vid_key(vid)) +} +fn snapshot_slot(vid: Vid) -> String { + format!("sync/snapshot/{}", vid_key(vid)) +} +fn checkpoint_slot(name: &str) -> String { + format!("sync/kg/{}", tag(name)) +} +fn candidate_slot(peer: &str, vid: Vid) -> String { + format!("sync/candidate/{}/{}", tag(peer), vid_key(vid)) +} +fn private_put(ctx: &Ctx<'_, H>, slot: &str, value: &T) -> Result<()> { + let bytes = Zeroizing::new(serde_json::to_vec(value).map_err(|_| state_error())?); + ctx.store.set_internal(slot, &bytes)?; + Ok(()) +} +fn private_get(ctx: &Ctx<'_, H>, slot: &str) -> Result { + let bytes = ctx.store.get_internal(slot)?.ok_or_else(state_error)?; + serde_json::from_slice(bytes.as_bytes()).map_err(|_| state_error()) +} +fn fingerprint(ctx: &Ctx<'_, H>, name: &str, kind: ItemKind, value: &[u8]) -> Result { + if ctx.store.get_internal("sync-key")?.is_none() { + let mut key = Zeroizing::new(Vec::with_capacity(32)); + key.extend_from_slice(&Vid::random().0); + key.extend_from_slice(&Vid::random().0); + ctx.store.set_internal("sync-key", &key)?; + } + let key = ctx + .store + .get_internal("sync-key")? + .ok_or_else(state_error)?; + if key.as_bytes().len() != 32 { + return Err(state_error()); + } + let mut mac = Hmac::::new_from_slice(key.as_bytes()).map_err(|_| state_error())?; + mac.update(&(name.len() as u64).to_be_bytes()); + mac.update(name.as_bytes()); + mac.update(&[match kind { + ItemKind::Text => 0, + ItemKind::File => 1, + }]); + mac.update(&(value.len() as u64).to_be_bytes()); + mac.update(value); + Ok(Fp(mac.finalize().into_bytes().into())) +} +/// An item's current value, kind and fingerprint. +type Current = (Zeroizing>, ItemKind, Fp); + +fn current(ctx: &Ctx<'_, H>, name: &str) -> Result> { + let Some(value) = ctx.store.get(name)? else { + return Ok(None); + }; + let kind = map::wire_kind(ctx.store.info(name)?.ok_or_else(state_error)?.kind); + let fp = fingerprint(ctx, name, kind, value.as_bytes())?; + Ok(Some((value.into_zeroizing(), kind, fp))) +} +fn remember( + ctx: &Ctx<'_, H>, + name: &str, + vid: Vid, + fp: Fp, + parents: &[Vid], +) -> Result { + let slot = record_slot(name, vid); + let binding = VidRecord { + fp, + parents: parents.iter().copied().map(map::vid).collect(), + }; + if ctx.store.get_internal(&slot)?.is_some() { + return Ok(private_get::<_, VidRecord>(ctx, &slot)? == binding); + } + private_put(ctx, &slot, &binding)?; + Ok(true) +} +fn pure(ctx: &Ctx<'_, H>, s: &State, name: &str, item: &Item) -> Result { + let rec: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + let mut result = ItemState::new( + s.generations.generation(name), + map::vid(item.head), + rec.fp, + rec.parents, + ); + result.lineage = kc_sync::Lineage::new(item.lineage.iter().copied().map(map::vid)); + for v in &item.known { + result.remember(map::vid(*v), private_get(ctx, &record_slot(name, *v))?); + } + for c in s + .candidates + .values() + .filter(|c| c.version.name == name && !c.retire && !c.invalid_binding) + { + result.remember( + map::vid(c.version.vid), + private_get(ctx, &record_slot(name, c.version.vid))?, + ); + } + if item.conflict { + let mut set = kc_sync::ConflictSet::default(); + set.candidates.insert( + result.head, + private_get(ctx, &record_slot(name, item.head))?, + ); + for c in s + .candidates + .values() + .filter(|c| c.version.name == name && c.category == CandidateKind::Conflict) + { + set.candidates.insert( + map::vid(c.version.vid), + private_get(ctx, &record_slot(name, c.version.vid))?, + ); + } + result.conflict = Some(set); + } + Ok(result) +} +fn reserve( + ctx: &Ctx<'_, H>, + s: &mut State, + slot: &str, + kind: SlotKind, + snapshot: bool, +) -> Result { + if let Some(existing) = s.slots.get_mut(slot) { + if kind > *existing { + *existing = kind; + } + return Ok(true); + } + let mut budget = SlotBudget::new(s.items.len()); + // Never evict existing data merely because rm reduced the capacity. + if s.slots.len() > budget.capacity() { + s.capacity_blocked = true; + return Ok(false); + } + for (name, k) in &s.slots { + let result = if s.versions.values().any(|v| &v.slot == name) { + budget.reserve_snapshot(name) + } else { + budget.reserve(name, *k) + }; + if !matches!(result, Reservation::Reserved { evicted: None }) { + return Err(state_error()); + } + } + let result = if snapshot { + budget.reserve_snapshot(slot) + } else { + budget.reserve(slot, kind) + }; + match result { + Reservation::Refused => { + s.capacity_blocked = true; + Ok(false) + } + Reservation::Reserved { evicted } => { + if let Some(victim) = evicted { + let evicted = s + .candidates + .values() + .filter(|c| c.version.slot == victim) + .cloned() + .collect::>(); + s.candidates.retain(|_, c| c.version.slot != victim); + // Only the slots go: the vid binding stays, because the evicted candidate + // can be the one whose acceptance is reserving this slot. + for c in evicted { + s.gc.insert(c.base_record); + } + s.slots.remove(&victim); + s.gc.insert(victim); + } + s.slots.insert(slot.to_owned(), kind); + s.capacity_blocked = false; + // Persist reservations before writes, leaving failed slot creation retryable. + s.save(&ctx.state)?; + Ok(true) + } + } +} +/// Drops a dropped proposal's vid binding (`sync/fp/...` record, unbound entry, known vid) +/// unless the head, a version or another candidate still refers to it. +fn forget_binding(s: &mut State, name: &str, vid: Vid) { + let referenced = s.items.get(name).is_some_and(|i| i.head == vid) + || s.versions.values().any(|v| v.name == name && v.vid == vid) + || s.candidates + .values() + .any(|other| other.version.name == name && other.version.vid == vid); + if referenced { + return; + } + s.unbound.remove(&format!("{}:{}", name, vid_key(vid))); + if let Some(item) = s.items.get_mut(name) { + item.known.retain(|known| *known != vid); + } + s.gc.insert(record_slot(name, vid)); +} + +fn release(s: &mut State, slot: &str) { + if s.slots.get(slot) != Some(&SlotKind::Checkpoint) { + s.slots.remove(slot); + s.gc.insert(slot.to_owned()); + if s.slots.len() < SlotBudget::new(s.items.len()).capacity() { + s.capacity_blocked = false; + } + } +} +fn size(value: &[u8]) -> Result<()> { + if value.is_empty() || value.len() > 200 * 1024 { + return Err(CliError::usage(tr!( + "Sync items must contain between 1 byte and 200 KiB." + ))); + } + Ok(()) +} +fn capacity() -> CliError { + CliError::new( + 8, + tr!("Sync storage is full; review pending items before retrying."), + ) +} +pub(crate) fn pending_code(ctx: &Ctx<'_, H>) -> Result { + let s = State::load(&ctx.state)?; + Ok(if pending(&s) { 8 } else { 0 }) +} +fn pending(s: &State) -> bool { + s.frozen + || s.capacity_blocked + || s.reconnect + || s.delivery_failed + || !s.candidates.is_empty() + || !s.offers.is_empty() + || s.items.values().any(|i| i.conflict) + || s.peers.iter().any(|(p, state)| { + !state.reoffer.is_empty() + || !state.quarantine.is_empty() + || s.limiter.is_tripped(&PeerId(p.clone())) + || s.outbox.pending(&PeerId(p.clone())).next().is_some() + }) +} +fn log(ctx: &Ctx<'_, H>, text: String) -> Result<()> { + use std::io::Write; + let path = ctx.state.root().join("sync.log"); + if std::fs::metadata(&path).is_ok_and(|m| m.len() >= 1024 * 1024) { + std::fs::rename(&path, ctx.state.root().join("sync.log.1")).map_err(|_| state_error())?; + } + if !path.exists() { + crate::state::write_private_atomic(&path, b"").map_err(|_| state_error())?; + } + let mut file = std::fs::OpenOptions::new() + .append(true) + .open(&path) + .map_err(|_| state_error())?; + writeln!(file, "{text}").map_err(|_| state_error()) +} + +/// Keep local confirmation dialogs readable without hiding that more items are selected. +fn names_summary(names: &[String]) -> String { + if names.len() <= 3 { + names.join(", ") + } else { + tr!( + "{names} and {n} more", + names = names[..3].join(", "), + n = names.len() - 3 + ) + } +} diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs new file mode 100644 index 0000000..fdbaf22 --- /dev/null +++ b/crates/kc-cli/src/sync/receive.rs @@ -0,0 +1,775 @@ +use super::*; +use kc_proto::sync::{AckResult, Change, ChangeId, Op, SyncMsg}; +use kc_sync::{Incoming, LimitResult, RemoteOperation, Transition}; +use state::{Candidate, CandidateKind, Control, Peer}; +use transaction::{put_blob, queue}; + +pub(crate) fn receive(ctx: &mut Ctx<'_, H>, peer: &str, message: &SyncMsg) -> Result<()> { + // The shared inbox owns both locks before entering this adapter. + let mut s = State::load(&ctx.state)?; + scan(ctx, &mut s)?; + s.receipts.retain(|_, (_, until)| *until >= ctx.host.now()); + s.attempts.retain(|_, until| *until >= ctx.host.now()); + let p = s.peers.entry(peer.into()).or_insert_with(|| Peer { + enabled: true, + ..Peer::default() + }); + match message { + SyncMsg::Hello { is_reply, .. } => { + p.capable = true; + s.reconnect = false; + if !is_reply { + queue(&mut s, peer, Control::Hello { reply: true }); + } + } + SyncMsg::Offer { + name, + vid, + lineage, + kind, + value, + known_generation, + } => { + let name = name.as_str(); + if !p.enabled || s.limiter.is_tripped(&PeerId(peer.into())) { + log( + ctx, + tr!( + "Ignored a sync offer from disabled or blocked peer {peer}.", + peer = super::actions::label(ctx, peer)? + ), + )?; + } else if *known_generation < s.generations.generation(name) { + log( + ctx, + tr!("Ignored a stale sync offer for {name}.", name = name), + )?; + } else if s + .rejected_offers + .contains(&delivery_key(peer, name, *known_generation, *vid)) + { + // A rejected proposal is never resurrected by a transport retry. + } else if lineage.len() <= 64 + && value.expose().len() <= 200 * 1024 + && !value.expose().is_empty() + { + let mut version = Version { + name: name.into(), + vid: *vid, + parents: vec![], + lineage: lineage.clone(), + kind: *kind, + slot: candidate_slot(peer, *vid), + }; + let fp = fingerprint(ctx, name, *kind, value.expose())?; + // Offers carry no parent assertion; never replace an existing binding. + let existing = ctx.store.get_internal(&record_slot(name, *vid))?; + if existing.is_some() + && private_get::<_, VidRecord>(ctx, &record_slot(name, *vid))?.fp != fp + { + s.peers + .get_mut(peer) + .unwrap() + .quarantine + .insert(name.into()); + } else if s + .items + .get(name) + .is_some_and(|i| i.head == *vid && i.scope.contains(peer)) + { + let generation = s.generations.generation(name); + queue( + &mut s, + peer, + Control::Accept { + name: name.into(), + generation, + }, + ); + } else if !s.candidates.contains_key(&version.slot) { + let category = if s.items.get(name).is_some_and(|i| { + i.conflict + && i.scope.contains(peer) + && *known_generation == s.generations.generation(name) + }) { + CandidateKind::Conflict + } else { + CandidateKind::Proposal + }; + if existing.is_some() { + let record: VidRecord = private_get(ctx, &record_slot(name, *vid))?; + version.parents = record.parents.into_iter().map(map::wire_vid).collect(); + } + let times = s.proposals_today.entry(peer.into()).or_default(); + times.retain(|at| (ctx.host.now() as i128) - (*at as i128) < 86400); + let allowed = times.len() < ctx.settings.sync.max_proposals_per_day; + let stored = allowed + && store_candidate( + ctx, + &mut s, + peer, + version, + *known_generation, + category, + value.expose(), + false, + false, + )?; + if stored { + if existing.is_none() { + s.unbound.insert(format!("{}:{}", name, vid_key(*vid))); + } + s.proposals_today + .entry(peer.into()) + .or_default() + .push(ctx.host.now()); + } + if !stored { + s.capacity_blocked = true; + queue( + &mut s, + peer, + Control::Ack { + id: ChangeId { + name: crate::values::item_name(name)?, + generation: *known_generation, + new_vid: *vid, + }, + result: AckResult::DeferredCapacity, + }, + ); + } + } + } + } + SyncMsg::Accept { name, generation } => { + let name = name.as_str(); + // A peer may grant a generation only for an item explicitly offered to it, + // or the reciprocal half of a locally accepted proposal. + let wanted = s.offers.iter().any(|o| o.peer == peer && o.name == name) + || s.items.get(name).is_some_and(|i| i.scope.contains(peer)); + let previously_accepted = s + .generations + .outgoing_generation(&PeerId(peer.into()), name) + .is_some(); + if wanted + && *generation >= 1 + && s.generations.received_accept( + PeerId(peer.into()), + kc_sync::Registration { + name: name.into(), + generation: *generation, + }, + ) + { + let own = s.generations.accept(name, PeerId(peer.into())); + if let Some(item) = s.items.get_mut(name) { + item.scope.insert(peer.into()); + } + s.offers.retain(|o| o.peer != peer || o.name != name); + s.peers.get_mut(peer).unwrap().reoffer.remove(name); + s.outbox.accepted(&PeerId(peer.into()), name); + if !previously_accepted { + queue( + &mut s, + peer, + Control::Accept { + name: name.into(), + generation: own.generation, + }, + ); + } + if !previously_accepted && s.items.get(name).is_some_and(|i| i.own) { + super::transport::resend(ctx, &mut s, peer, name)?; + } + } + } + SyncMsg::Leave { name, generation } => { + let name = name.as_str(); + let expected = s.items.get(name).is_some_and(|i| i.scope.contains(peer)) + || s.generations.known_generation(&PeerId(peer.into()), name) != 0; + if expected + && s.generations.received_leave( + PeerId(peer.into()), + kc_sync::Registration { + name: name.into(), + generation: *generation, + }, + ) + { + s.peers.get_mut(peer).unwrap().reoffer.insert(name.into()); + let ids: Vec<_> = s + .outbox + .pending(&PeerId(peer.into())) + .filter(|id| id.name == name) + .cloned() + .collect(); + for id in ids { + s.outbox.ack( + &PeerId(peer.into()), + &id, + kc_sync::AckResult::StaleGeneration, + ); + } + s.offers.retain(|o| o.peer != peer || o.name != name); + } + } + SyncMsg::Changes { changes } => { + for change in changes { + change_received(ctx, &mut s, peer, change)?; + } + } + SyncMsg::Ack { results } => { + for (id, result) in results { + let expected = s + .outbox + .pending(&PeerId(peer.into())) + .any(|pending| *pending == map::id(id)) + || s.offers.iter().any(|o| { + o.peer == peer && o.name == id.name.as_str() && o.vid == id.new_vid + }); + if !expected { + continue; + } + let delivery = delivery_key(peer, id.name.as_str(), id.generation, id.new_vid); + if *result == AckResult::DeferredCapacity { + s.deferred.insert(delivery); + } else { + s.deferred.remove(&delivery); + } + s.outbox + .ack(&PeerId(peer.into()), &map::id(id), map::ack(*result)); + if *result == AckResult::StaleGeneration + && s.generations + .known_generation(&PeerId(peer.into()), id.name.as_str()) + <= id.generation + { + // The ACK carries the rejected (old) generation, not the receiver's + // new one. Invalidate only that still-current grant; a reordered ACK + // must not revoke a newer Accept. Re-offering learns the actual epoch. + if s.generations + .outgoing_generation(&PeerId(peer.into()), id.name.as_str()) + == Some(id.generation) + { + invalidate_generation(&mut s, peer, id.name.as_str())?; + } + s.peers + .get_mut(peer) + .unwrap() + .reoffer + .insert(id.name.to_string()); + } + } + } + SyncMsg::Digest { entries } => { + for entry in entries { + let name = entry.name.as_str(); + let generation = s.generations.generation(name); + if entry.generation < generation { + queue( + &mut s, + peer, + Control::Leave { + name: name.into(), + generation, + }, + ); + continue; + } + if let Some(item) = s.items.get(name).cloned() { + if item.own + && item.head != entry.head + && item.lineage.contains(&entry.head) + && item.scope.contains(peer) + { + super::transport::resend(ctx, &mut s, peer, name)?; + } else if item.head != entry.head && item.scope.contains(peer) { + s.peers.get_mut(peer).unwrap().reoffer.insert(name.into()); + } + } + } + } + SyncMsg::Approvals { .. } => log( + ctx, + tr!("Ignored signed approvals: Phase 1 requires local review."), + )?, + } + super::transport::collect_snapshots(&mut s); + s.cleanup(ctx) +} +// The Phase 1 core API cannot revoke an accepted grant at the same generation. +// Preserve the known receiver epoch while clearing its grant in the persisted adapter. +fn invalidate_generation(s: &mut State, peer: &str, name: &str) -> Result<()> { + let mut generations = serde_json::to_value(&s.generations).map_err(|_| state_error())?; + let accepted = generations + .get_mut("remote") + .and_then(|remote| remote.get_mut(peer)) + .and_then(|names| names.get_mut(name)) + .and_then(|grant| grant.get_mut("accepted")) + .ok_or_else(state_error)?; + *accepted = serde_json::Value::Bool(false); + s.generations = serde_json::from_value(generations).map_err(|_| state_error())?; + Ok(()) +} +fn ack(s: &mut State, peer: &str, c: &Change, result: AckResult) { + queue( + s, + peer, + Control::Ack { + id: ChangeId { + name: c.name.clone(), + generation: c.generation, + new_vid: c.new_vid, + }, + result, + }, + ); +} +fn change_received( + ctx: &mut Ctx<'_, H>, + s: &mut State, + peer: &str, + c: &Change, +) -> Result<()> { + let name = c.name.as_str(); + let Some(item) = s.items.get(name).cloned() else { + ack(s, peer, c, AckResult::StaleGeneration); + return Ok(()); + }; + if !item.scope.contains(peer) + || !s.generations.includes(name, &PeerId(peer.into())) + || c.generation != s.generations.generation(name) + { + ack(s, peer, c, AckResult::StaleGeneration); + return Ok(()); + } + let (value, kind, retire) = match &c.op { + Op::Put { kind, value } => (value.expose(), *kind, false), + Op::Retire => (&[][..], ItemKind::Text, true), + }; + if (!retire && size(value).is_err()) || c.parents.len() > 256 { + ack(s, peer, c, AckResult::Rejected); + return Ok(()); + } + if s.peers[peer].quarantine.contains(name) { + ack(s, peer, c, AckResult::Rejected); + return Ok(()); + } + let slot = candidate_slot(peer, c.new_vid); + let fp = if retire { + None + } else { + Some(fingerprint(ctx, name, kind, value)?) + }; + let delivery = delivery_key(peer, name, c.generation, c.new_vid); + if let Some((AckResult::Rejected, _)) = s.receipts.get(&delivery) { + ack(s, peer, c, AckResult::Rejected); + return Ok(()); + } + let current_fp = current(ctx, name)?.map_or(Fp([0; 32]), |v| v.2); + let mut state = pure(ctx, s, name, &item)?; + // An accepted Offer has no parent field. Bind its first explicit parent assertion + // only when the fingerprint still matches the immutable offered value. + let unbound = format!("{}:{}", name, vid_key(c.new_vid)); + if s.unbound.contains(&unbound) + && let Some(rec) = state.known.get_mut(&map::vid(c.new_vid)) + && Some(rec.fp) == fp + { + rec.parents = c.parents.iter().copied().map(map::vid).collect(); + private_put(ctx, &record_slot(name, c.new_vid), rec)?; + s.unbound.remove(&unbound); + } + let incoming = Incoming { + generation: c.generation, + new_vid: map::vid(c.new_vid), + parents: c.parents.iter().copied().map(map::vid).collect(), + lineage: kc_sync::Lineage::new(c.lineage.iter().copied().map(map::vid)), + value_fp: fp, + retire, + }; + let unseen = !s.attempts.contains_key(&delivery) + && !s.candidates.contains_key(&slot) + && !state.lineage.contains(&incoming.new_vid); + let overwrite = retire || fp != Some(current_fp); + let mut within = ctx.settings.sync.max_remote_overwrites != 0; + if unseen && overwrite { + let op = if retire { + RemoteOperation::Retire + } else { + RemoteOperation::Overwrite + }; + within &= s.limiter.check( + &PeerId(peer.into()), + name, + op, + ctx.host.now(), + s.items.len(), + false, + ) == LimitResult::Allowed; + // Phase 1 counts durably received overwrite attempts, although they are held. + s.limiter + .record(&PeerId(peer.into()), name, op, ctx.host.now(), false); + s.attempts + .insert(delivery.clone(), ctx.host.now().saturating_add(3 * 86400)); + } + let frozen = s.frozen || !s.peers[peer].enabled || s.limiter.is_tripped(&PeerId(peer.into())); + let decision = kc_sync::decide(&state, current_fp, &incoming, frozen, None, within); + if decision.quarantine { + s.peers + .get_mut(peer) + .unwrap() + .quarantine + .insert(name.into()); + } + let mut result = map::wire_ack(decision.ack); + match decision.transition { + Transition::Hold { .. } | Transition::Conflict { .. } => { + let category = if result == AckResult::Conflict { + CandidateKind::Conflict + } else { + CandidateKind::Held + }; + if category == CandidateKind::Conflict { + preserve_mine(ctx, s, name, &item)?; + } + let version = Version { + name: name.into(), + vid: c.new_vid, + parents: c.parents.clone(), + lineage: c.lineage.clone(), + kind, + slot: slot.clone(), + }; + if !store_candidate( + ctx, + s, + peer, + version, + c.generation, + category, + value, + retire, + false, + )? { + result = AckResult::DeferredCapacity; + } else if category == CandidateKind::Conflict { + s.items.get_mut(name).unwrap().conflict = true; + } + } + Transition::Advance { + head, + lineage, + write_value: false, + .. + } => { + if let Some(fp) = fp + && !matches!(remember(ctx, name, c.new_vid, fp, &c.parents), Ok(true)) + { + s.peers + .get_mut(peer) + .unwrap() + .quarantine + .insert(name.into()); + s.receipts.insert( + delivery, + ( + AckResult::Rejected, + ctx.host.now().saturating_add(3 * 86400), + ), + ); + ack(s, peer, c, AckResult::Rejected); + log( + ctx, + tr!( + "Sync {name}: {result}.", + name = name, + result = tr!("declined") + ), + )?; + return s.save(&ctx.state); + } + let item = s.items.get_mut(name).unwrap(); + item.head = map::wire_vid(head); + item.lineage = lineage.iter().copied().map(map::wire_vid).collect(); + if item.head == c.new_vid { + item.parents = c.parents.clone(); + item.own = false; + } + if !item.known.contains(&c.new_vid) { + item.known.push(c.new_vid); + } + } + Transition::Unchanged => {} + // No verified approval is ever constructed in Phase 1. + _ => return Err(state_error()), + } + if result != AckResult::DeferredCapacity { + s.receipts + .insert(delivery, (result, ctx.host.now().saturating_add(3 * 86400))); + } + ack(s, peer, c, result); + s.save(&ctx.state)?; + let result_text = match result { + AckResult::Applied => tr!("in sync"), + AckResult::Held => tr!("held"), + AckResult::Conflict => tr!("conflict"), + AckResult::Rejected => tr!("declined"), + AckResult::StaleGeneration => tr!("re-offer needed"), + AckResult::DeferredCapacity => { + tr!("Sync storage is full; review pending items before retrying.") + } + }; + log( + ctx, + tr!("Sync {name}: {result}.", name = name, result = result_text), + )?; + Ok(()) +} +pub(super) fn preserve_mine( + ctx: &Ctx<'_, H>, + s: &mut State, + name: &str, + item: &Item, +) -> Result<()> { + let slot = candidate_slot("mine", item.head); + if s.candidates.contains_key(&slot) { + return Ok(()); + } + if let Some((value, kind, _)) = current(ctx, name)? { + if size(&value).is_err() { + return Ok(()); + } + let version = Version { + name: name.into(), + vid: item.head, + parents: item.parents.clone(), + lineage: item.lineage.clone(), + kind, + slot, + }; + if !store_candidate( + ctx, + s, + "mine", + version, + s.generations.generation(name), + CandidateKind::Conflict, + &value, + false, + false, + )? { + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; + } + } + Ok(()) +} +#[allow(clippy::too_many_arguments)] +pub(super) fn store_candidate( + ctx: &Ctx<'_, H>, + s: &mut State, + peer: &str, + mut v: Version, + generation: u64, + category: CandidateKind, + value: &[u8], + retire: bool, + legacy: bool, +) -> Result { + let mut invalid_binding = false; + if !retire + && category != CandidateKind::Proposal + && ctx + .store + .get_internal(&record_slot(&v.name, v.vid))? + .is_some() + { + let record: VidRecord = private_get(ctx, &record_slot(&v.name, v.vid))?; + invalid_binding = record.fp != fingerprint(ctx, &v.name, v.kind, value)? + || record.parents != v.parents.iter().copied().map(map::vid).collect::>(); + } + if invalid_binding { + // Freeze precedes immutable-VID violations: retain the evidence without changing + // the immutable binding. Review must turn it into a conflict, never apply that vid. + for old in s.candidates.values().filter(|c| { + c.peer == peer + && c.version.vid == v.vid + && c.invalid_binding + && c.version.parents == v.parents + }) { + let stored = transaction::blob(ctx, &old.version.slot)?; + if stored.kind == v.kind && stored.value.expose() == value { + return Ok(true); + } + } + v.slot.push_str(&format!("/{}", hex(&Vid::random().0[..4]))); + } + if let Some(old) = s.candidates.get(&v.slot) { + let promote = old.category == CandidateKind::Proposal + && category != CandidateKind::Proposal + && !invalid_binding; + if (!promote && old.version.parents != v.parents) || old.retire != retire { + return Ok(false); + } + if !retire { + let old_value = transaction::blob(ctx, &v.slot)?; + if old_value.value.expose() != value || old_value.kind != v.kind { + return Ok(false); + } + } + if promote || category == CandidateKind::Conflict { + let old = s.candidates.get_mut(&v.slot).unwrap(); + old.category = category; + old.version.parents = v.parents; + old.version.lineage = v.lineage; + old.generation = generation; + s.slots.insert( + v.slot.clone(), + if category == CandidateKind::Conflict { + SlotKind::ConflictCandidate + } else { + SlotKind::Held + }, + ); + } + return Ok(true); + } + let kind = match category { + CandidateKind::Proposal => SlotKind::Proposal, + CandidateKind::Held => SlotKind::Held, + CandidateKind::Conflict => SlotKind::ConflictCandidate, + }; + if !reserve(ctx, s, &v.slot, kind, false)? { + return Ok(false); + } + let base = current(ctx, &v.name)?.map_or(Fp([0; 32]), |v| v.2); + let base_record = format!("sync/base/{}", vid_key(Vid::random())); + private_put(ctx, &base_record, &base)?; + if !retire { + put_blob(ctx, &v.slot, v.kind, value)?; + let fp = fingerprint(ctx, &v.name, v.kind, value)?; + if category == CandidateKind::Proposal { + if ctx + .store + .get_internal(&record_slot(&v.name, v.vid))? + .is_none() + { + remember(ctx, &v.name, v.vid, fp, &[])?; + s.unbound.insert(format!("{}:{}", v.name, vid_key(v.vid))); + } + } else if !invalid_binding && !remember(ctx, &v.name, v.vid, fp, &v.parents)? { + release(s, &v.slot); + s.gc.insert(base_record); + return Ok(false); + } + } + if !retire + && !invalid_binding + && let Some(item) = s.items.get_mut(&v.name) + { + if !item.known.contains(&v.vid) { + item.known.push(v.vid); + } + while item.known.len() > 256 { + let index = item.known.iter().position(|vid| *vid != item.head).unwrap(); + item.known.remove(index); + } + } + let key = v.slot.clone(); + s.candidates.insert( + key, + Candidate { + peer: peer.into(), + generation, + category, + base_head: s.items.get(&v.name).map(|i| i.head), + version: v, + base_record, + retire, + legacy, + invalid_binding, + }, + ); + Ok(true) +} +/// Existing v1/code imports enter the same review path. Caller already owns both locks. +/// A terminal may confirm the individual overwrite locally; noninteractive imports hold. +pub(crate) fn legacy( + ctx: &mut Ctx<'_, H>, + item: &kc_proto::payload::Item, + from: &str, + overwrite: bool, +) -> Result> { + let mut s = State::load(&ctx.state)?; + if !s.items.contains_key(item.name.as_str()) { + return Ok(None); + } + recover(ctx, &mut s)?; + scan(ctx, &mut s)?; + let name = item.name.as_str(); + let kind = if std::str::from_utf8(item.value.expose()).is_ok() { + ItemKind::Text + } else { + ItemKind::File + }; + if current(ctx, name)?.is_some_and(|v| v.0.as_slice() == item.value.expose()) { + return Ok(Some(kc_proto::ItemStatus::Unchanged)); + } + size(item.value.expose())?; + let peer = ctx + .state + .load_peers()? + .find(from) + .map(|p| p.fingerprint.to_hex()) + .unwrap_or_else(|| "legacy".into()); + let vid = Vid::random(); + let v = Version { + name: name.into(), + vid, + parents: vec![s.items[name].head], + lineage: s.items[name].lineage.clone(), + kind, + slot: candidate_slot(&peer, vid), + }; + let slot = v.slot.clone(); + let generation = s.generations.generation(name); + if !store_candidate( + ctx, + &mut s, + &peer, + v, + generation, + CandidateKind::Held, + item.value.expose(), + false, + true, + )? { + s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); + return Ok(Some(kc_proto::ItemStatus::SkippedConflict)); + } + s.save(&ctx.state)?; + if overwrite && ctx.interactive() && !s.frozen { + if let Err(error) = human( + ctx, + &tr!( + "Replace {name} with the value from {device}", + name = name, + device = from + ), + ) { + s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); + return Err(error); + } + let c = s.candidates[&slot].clone(); + if transaction::accept(ctx, &mut s, &c)? { + return Ok(Some(kc_proto::ItemStatus::Stored)); + } + } + s.cleanup(ctx)?; + crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); + Ok(Some(kc_proto::ItemStatus::SkippedConflict)) +} diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs new file mode 100644 index 0000000..e2f758f --- /dev/null +++ b/crates/kc-cli/src/sync/state.rs @@ -0,0 +1,157 @@ +//! Public metadata contains neither values nor HMAC fingerprints. Secret transaction +//! records live in immutable keychain slots, referenced by the durable journal pointer. +use crate::{commands::Ctx, error::Result, host::Host, state::StateDir}; +use kc_proto::sync::{AckResult, ChangeId, ItemKind, Vid}; +use kc_sync::{Generations, Limiter, Outbox, SlotKind}; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; + +#[derive(Clone, Serialize, Deserialize)] +pub struct Item { + pub head: Vid, + pub lineage: Vec, + pub parents: Vec, + pub known: Vec, + pub scope: BTreeSet, + pub own: bool, + pub conflict: bool, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Version { + pub name: String, + pub vid: Vid, + pub parents: Vec, + pub lineage: Vec, + pub kind: ItemKind, + pub slot: String, +} +#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CandidateKind { + Proposal, + Held, + Conflict, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Candidate { + pub peer: String, + pub version: Version, + pub generation: u64, + pub category: CandidateKind, + pub base_head: Option, + pub base_record: String, + pub retire: bool, + pub legacy: bool, + #[serde(default)] + pub invalid_binding: bool, +} +#[derive(Clone, Default, Serialize, Deserialize)] +pub struct Peer { + pub hello_sent: bool, + pub capable: bool, + pub enabled: bool, + pub last_digest: Option, + pub reoffer: BTreeSet, + pub quarantine: BTreeSet, +} +// These are intentionally NOT SyncMsg: that wire enum can contain secret values. +#[derive(Clone, Serialize, Deserialize)] +pub enum Control { + Hello { reply: bool }, + Accept { name: String, generation: u64 }, + Leave { name: String, generation: u64 }, + Ack { id: ChangeId, result: AckResult }, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Offer { + pub peer: String, + pub name: String, + pub vid: Vid, +} +#[derive(Clone, Serialize, Deserialize)] +pub struct Journal { + pub record: String, + pub name: String, +} +#[derive(Default, Serialize, Deserialize)] +pub struct State { + pub frozen: bool, + #[serde(default)] + pub proposals_today: BTreeMap>, + #[serde(default)] + pub receipts: BTreeMap, + #[serde(default)] + pub attempts: BTreeMap, + #[serde(default)] + pub deferred: BTreeSet, + #[serde(default)] + pub rejected_offers: BTreeSet, + #[serde(default)] + pub unbound: BTreeSet, + pub items: BTreeMap, + pub peers: BTreeMap, + pub generations: Generations, + pub outbox: Outbox, + pub limiter: Limiter, + pub versions: BTreeMap, + #[serde(default)] + pub latest_local: BTreeMap, + pub offers: Vec, + pub controls: Vec<(String, Control)>, + pub candidates: BTreeMap, + pub slots: BTreeMap, + pub journal: Option, + pub capacity_blocked: bool, + pub reconnect: bool, + /// The last delivery attempt failed; cleared by the next flush that reaches every peer. + #[serde(default)] + pub delivery_failed: bool, + pub gc: BTreeSet, +} +impl State { + pub fn load(dir: &StateDir) -> Result { + let path = dir.root().join("sync.json"); + match std::fs::read(path) { + Ok(bytes) => serde_json::from_slice(&bytes).map_err(|_| super::state_error()), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()), + Err(_) => Err(super::state_error()), + } + } + pub fn save(&self, dir: &StateDir) -> Result<()> { + crate::state::create_private_dir(dir.root())?; + let bytes = serde_json::to_vec_pretty(self).map_err(|_| super::state_error())?; + crate::state::write_private_atomic(&dir.root().join("sync.json"), &bytes) + .map_err(|_| super::state_error()) + } + pub fn cleanup(&mut self, ctx: &Ctx<'_, H>) -> Result<()> { + // A binding scheduled for deletion may have become live again in the same + // transaction (an accepted proposal evicted by its own checkpoint reservation). + let live: BTreeSet = self + .items + .iter() + .flat_map(|(name, i)| { + std::iter::once(i.head) + .chain(i.known.iter().copied()) + .map(move |vid| super::record_slot(name, vid)) + }) + .chain( + self.versions + .values() + .map(|v| super::record_slot(&v.name, v.vid)), + ) + .chain( + self.candidates + .values() + .map(|c| super::record_slot(&c.version.name, c.version.vid)), + ) + .collect(); + self.gc.retain(|slot| !live.contains(slot)); + // Metadata is durable before deletion. A restart repeats only harmless deletes. + self.save(&ctx.state)?; + for slot in &self.gc { + ctx.store.delete_internal(slot)?; + } + self.gc.clear(); + self.save(&ctx.state) + } +} diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs new file mode 100644 index 0000000..8d2f6ca --- /dev/null +++ b/crates/kc-cli/src/sync/transaction.rs @@ -0,0 +1,695 @@ +use super::*; +use kc_store::{Origin, SetOutcome}; +use kc_sync::{ + LocalJournalRecord, LocalRecovery, QueueTarget, RemoteJournalRecord, RemoteRecovery, +}; +use serde::{Deserialize, Serialize}; +use state::{Candidate, Control, Journal}; + +#[derive(Serialize, Deserialize)] +pub(super) struct Blob { + pub kind: ItemKind, + pub value: kc_proto::SecretBytes, +} +pub(super) fn put_blob( + ctx: &Ctx<'_, H>, + slot: &str, + kind: ItemKind, + value: &[u8], +) -> Result<()> { + private_put( + ctx, + slot, + &Blob { + kind, + value: kc_proto::SecretBytes::from_slice(value), + }, + ) +} +pub(super) fn blob(ctx: &Ctx<'_, H>, slot: &str) -> Result { + private_get(ctx, slot) +} +#[derive(Serialize, Deserialize)] +enum Intent { + Local { + record: LocalJournalRecord, + version: Version, + clear: bool, + }, + Remote { + record: RemoteJournalRecord, + candidate: Candidate, + }, + // Store's restore/adopt API does not expose the intended value before the mutation. + // This durable pre-intent makes an interrupted operation recoverable by observation. + Observe { + name: String, + previous: Fp, + vid: Vid, + parents: Vec, + snapshot: String, + }, +} +fn intent(ctx: &Ctx<'_, H>, s: &mut State, name: &str, record: &Intent) -> Result<()> { + let slot = format!("sync/journal/{}", vid_key(Vid::random())); + private_put(ctx, &slot, record)?; + if let Some(old) = s.journal.replace(Journal { + record: slot, + name: name.into(), + }) { + s.gc.insert(old.record); + } + s.save(&ctx.state) +} +fn clear_intent(ctx: &Ctx<'_, H>, s: &mut State) -> Result<()> { + if let Some(j) = s.journal.take() { + s.gc.insert(j.record); + } + s.cleanup(ctx) +} +fn interrupted(ctx: &mut Ctx<'_, H>) -> Result<()> { + if ctx.host.sync_interrupt_after_write() { + return Err(state_error()); + } + Ok(()) +} +#[allow(clippy::too_many_arguments)] +fn prepare_local( + ctx: &Ctx<'_, H>, + s: &mut State, + name: &str, + previous: Fp, + kind: ItemKind, + value: &[u8], + parents: Vec, + vid: Vid, + clear: bool, +) -> Result<(LocalJournalRecord, Version)> { + size(value)?; + let slot = snapshot_slot(vid); + if !reserve(ctx, s, &slot, SlotKind::ConflictCandidate, true)? { + return Err(capacity()); + } + let item = s.items.get(name).ok_or_else(state_error)?; + let new_fp = fingerprint(ctx, name, kind, value)?; + let record = LocalJournalRecord { + name: name.into(), + prev_fp: previous, + new_fp, + new_vid: map::vid(vid), + parents: parents.iter().copied().map(map::vid).collect(), + snapshot_slot: slot.clone(), + targets: item + .scope + .iter() + .filter_map(|p| { + s.generations + .outgoing_generation(&PeerId(p.clone()), name) + .map(|generation| QueueTarget { + peer: PeerId(p.clone()), + generation, + }) + }) + .collect(), + }; + let lineage = kc_sync::Lineage::new(item.lineage.iter().chain(&parents).copied().map(map::vid)) + .with_head(map::vid(vid)) + .iter() + .copied() + .map(map::wire_vid) + .collect(); + let version = Version { + name: name.into(), + vid, + parents, + lineage, + kind, + slot, + }; + intent( + ctx, + s, + name, + &Intent::Local { + record: record.clone(), + version: version.clone(), + clear, + }, + )?; + Ok((record, version)) +} +fn finish_local( + ctx: &Ctx<'_, H>, + s: &mut State, + r: &LocalJournalRecord, + v: &Version, + clear: bool, +) -> Result<()> { + if !remember(ctx, &r.name, v.vid, r.new_fp, &v.parents)? { + return Err(state_error()); + } + let item = s.items.get_mut(&r.name).ok_or_else(state_error)?; + item.head = v.vid; + item.lineage = v.lineage.clone(); + item.parents = v.parents.clone(); + item.own = true; + if !item.known.contains(&v.vid) { + item.known.push(v.vid); + } + if item.known.len() > 256 { + item.known.remove(0); + } + if clear { + item.conflict = false; + } + s.versions.insert(vid_key(v.vid), v.clone()); + s.latest_local.insert(r.name.clone(), v.vid); + for target in &r.targets { + s.outbox.enqueue( + target.peer.clone(), + kc_sync::ChangeId { + name: r.name.clone(), + generation: target.generation, + new_vid: r.new_vid, + }, + ); + } + for offer in &mut s.offers { + if offer.name == r.name { + offer.vid = v.vid; + } + } + if clear { + clear_candidates(s, &r.name); + } + s.save(&ctx.state) +} +pub(super) fn clear_candidates(s: &mut State, name: &str) { + let keys: Vec<_> = s + .candidates + .iter() + .filter(|(_, c)| c.version.name == name) + .map(|(k, _)| k.clone()) + .collect(); + for key in keys { + if let Some(c) = s.candidates.remove(&key) { + release(s, &c.version.slot); + s.gc.insert(c.base_record); + } + } +} +pub(crate) fn local_set( + ctx: &mut Ctx<'_, H>, + name: &str, + value: &[u8], + kind: kc_store::ItemKind, + origin: Origin, +) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + if !s.items.contains_key(name) { + return Ok(ctx.store.set(name, value, kind, origin)?); + } + scan_one(ctx, &mut s, name)?; + let item = s.items[name].clone(); + if item.conflict { + super::receive::preserve_mine(ctx, &mut s, name, &item)?; + } + let previous = current(ctx, name)?.map_or(Fp([0; 32]), |v| v.2); + let k = map::wire_kind(kind); + if fingerprint(ctx, name, k, value)? == previous { + return Ok(ctx.store.set(name, value, kind, origin)?); + } + let parents = vec![s.items[name].head]; + let (r, v) = prepare_local( + ctx, + &mut s, + name, + previous, + k, + value, + parents, + Vid::random(), + false, + )?; + let outcome = ctx.store.set(name, value, kind, origin)?; + interrupted(ctx)?; + put_blob(ctx, &v.slot, k, value)?; + finish_local(ctx, &mut s, &r, &v, false)?; + clear_intent(ctx, &mut s)?; + Ok(outcome) +} +pub(crate) fn observed_write( + ctx: &mut Ctx<'_, H>, + name: &str, + write: impl FnOnce(&crate::keychain::Keychain) -> std::result::Result, +) -> Result { + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + if !s.items.contains_key(name) { + return Ok(write(&ctx.store)?); + } + scan_one(ctx, &mut s, name)?; + let item = s.items[name].clone(); + if item.conflict { + super::receive::preserve_mine(ctx, &mut s, name, &item)?; + } + let previous = current(ctx, name)?.map_or(Fp([0; 32]), |v| v.2); + let vid = Vid::random(); + let snapshot = snapshot_slot(vid); + if !reserve(ctx, &mut s, &snapshot, SlotKind::ConflictCandidate, true)? { + return Err(capacity()); + } + let parents = vec![s.items[name].head]; + intent( + ctx, + &mut s, + name, + &Intent::Observe { + name: name.into(), + previous, + vid, + parents, + snapshot, + }, + )?; + let result = write(&ctx.store)?; + interrupted(ctx)?; + recover(ctx, &mut s)?; + Ok(result) +} +pub(crate) fn scan(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<()> { + recover(ctx, s)?; + for name in s.items.keys().cloned().collect::>() { + scan_one(ctx, s, &name)?; + let item = s.items[&name].clone(); + if item.conflict { + super::receive::preserve_mine(ctx, s, &name, &item)?; + } + } + s.cleanup(ctx) +} +fn scan_one(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { + let Some((value, kind, fp)) = current(ctx, name)? else { + s.items.get_mut(name).ok_or_else(state_error)?.conflict = true; + return s.save(&ctx.state); + }; + if size(&value).is_err() { + s.items.get_mut(name).unwrap().conflict = true; + return s.save(&ctx.state); + } + let item = &s.items[name]; + let binding: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + if fp == binding.fp { + return Ok(()); + } + let parents = vec![item.head]; + let prepared = prepare_local( + ctx, + s, + name, + binding.fp, + kind, + &value, + parents, + Vid::random(), + false, + ); + let (r, v) = match prepared { + Ok(value) => value, + Err(error) if error.code == 8 && s.capacity_blocked => { + s.items.get_mut(name).unwrap().conflict = true; + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; + return s.save(&ctx.state); + } + Err(error) => return Err(error), + }; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + clear_intent(ctx, s) +} +pub(super) fn publish_current( + ctx: &mut Ctx<'_, H>, + s: &mut State, + name: &str, +) -> Result<()> { + let (value, kind, fp) = current(ctx, name)?.ok_or_else(state_error)?; + let parents = vec![s.items[name].head]; + let (r, v) = prepare_local( + ctx, + s, + name, + fp, + kind, + &value, + parents, + Vid::random(), + false, + )?; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + clear_intent(ctx, s) +} +pub(super) fn resolve_value( + ctx: &mut Ctx<'_, H>, + s: &mut State, + name: &str, + value: &[u8], + kind: ItemKind, +) -> Result<()> { + let item = &s.items[name]; + if !item.conflict + && !s.candidates.values().any(|c| c.version.name == name) + && current(ctx, name)?.is_some_and(|v| v.1 == kind && v.0.as_slice() == value) + { + return Ok(()); + } + let mut parents = vec![item.head]; + parents.extend( + s.candidates + .values() + .filter(|c| c.version.name == name) + .map(|c| c.version.vid), + ); + parents.sort(); + parents.dedup(); + let fp = current(ctx, name)?.map_or(Fp([0; 32]), |v| v.2); + let (r, v) = match prepare_local(ctx, s, name, fp, kind, value, parents, Vid::random(), true) { + Ok(prepared) => prepared, + Err(error) if error.code == 8 && s.capacity_blocked => { + log( + ctx, + tr!("Sync storage is full; review pending items before retrying."), + )?; + return s.save(&ctx.state); + } + Err(error) => return Err(error), + }; + ctx.store.set(name, value, map::kind(kind), Origin::Local)?; + interrupted(ctx)?; + put_blob(ctx, &v.slot, kind, value)?; + finish_local(ctx, s, &r, &v, true)?; + clear_intent(ctx, s) +} +pub(super) fn accept(ctx: &mut Ctx<'_, H>, s: &mut State, c: &Candidate) -> Result { + let name = &c.version.name; + let now = current(ctx, name)?; + let actual = now.as_ref().map_or(Fp([0; 32]), |v| v.2); + let expected: Fp = private_get(ctx, &c.base_record)?; + let head = s.items.get(name).map(|i| i.head); + if actual != expected || head != c.base_head || c.invalid_binding { + if c.invalid_binding + && let Some(peer) = s.peers.get_mut(&c.peer) + { + peer.quarantine.insert(name.into()); + } + let key = c.version.slot.clone(); + if let Some(c) = s.candidates.get_mut(&key) { + c.category = CandidateKind::Conflict; + } + if let Some(item) = s.items.get_mut(name) { + item.conflict = true; + } + s.save(&ctx.state)?; + return Ok(false); + } + // While the item is in conflict, only `kc sync resolve` may settle it: accepting a + // proposal or held change here would drop the other candidates (§2.4). + // A held resolve whose parents name the current head and every open candidate is the + // way out of the conflict, so it stays acceptable (§2.4). + let settles_conflict = |s: &State| { + let Some(item) = s.items.get(name) else { + return false; + }; + c.version.parents.contains(&item.head) + && s.candidates + .values() + .filter(|o| o.version.name == *name && o.category == CandidateKind::Conflict) + .all(|o| c.version.parents.contains(&o.version.vid)) + }; + if c.category != CandidateKind::Conflict + && s.items.get(name).is_some_and(|i| i.conflict) + && !settles_conflict(s) + { + crate::commands::say!( + ctx, + "{}", + tr!( + "{name} is in conflict; settle it with `kc sync resolve {name}` first.", + name = name + ) + ); + return Ok(false); + } + if c.retire { + super::actions::remove(ctx, s, name)?; + return Ok(true); + } + let value = blob(ctx, &c.version.slot)?; + let fp = fingerprint(ctx, name, value.kind, value.value.expose())?; + let checkpoint = if now.is_some() { + Some(checkpoint_slot(name)) + } else { + None + }; + if let Some(slot) = &checkpoint + && !reserve(ctx, s, slot, SlotKind::Checkpoint, false)? + { + return Ok(false); + } + let lineage = + kc_sync::Lineage::new(c.version.lineage.iter().copied().chain(head).map(map::vid)) + .with_head(map::vid(c.version.vid)); + let r = RemoteJournalRecord { + change_id: kc_sync::ChangeId { + name: name.clone(), + generation: c.generation, + new_vid: map::vid(c.version.vid), + }, + sender: PeerId(c.peer.clone()), + prev_fp: actual, + new_fp: fp, + head: map::vid(c.version.vid), + lineage, + approval_key: None, + ack: kc_sync::AckResult::Applied, + checkpoint_slot: checkpoint.clone(), + candidate_slot: c.version.slot.clone(), + }; + intent( + ctx, + s, + name, + &Intent::Remote { + record: r.clone(), + candidate: c.clone(), + }, + )?; + if let (Some(slot), Some((old, old_kind, _))) = (&checkpoint, now) + && ctx.store.get_internal(slot)?.is_none() + { + put_blob(ctx, slot, old_kind, &old)?; + } + ctx.store.set( + name, + value.value.expose(), + map::kind(value.kind), + Origin::Received { + from_device: super::actions::label(ctx, &c.peer)?, + }, + )?; + interrupted(ctx)?; + finish_remote(ctx, s, &r, c)?; + clear_intent(ctx, s)?; + Ok(true) +} +fn finish_remote( + ctx: &Ctx<'_, H>, + s: &mut State, + r: &RemoteJournalRecord, + c: &Candidate, +) -> Result<()> { + let name = &r.change_id.name; + if !remember(ctx, name, c.version.vid, r.new_fp, &c.version.parents)? { + return Err(state_error()); + } + let proposal = c.category == CandidateKind::Proposal; + let mut scope = s + .items + .get(name) + .map(|i| i.scope.clone()) + .unwrap_or_default(); + if !c.legacy { + scope.insert(c.peer.clone()); + } + let mut known = s + .items + .get(name) + .map(|i| i.known.clone()) + .unwrap_or_default(); + if !known.contains(&c.version.vid) { + known.push(c.version.vid); + } + if known.len() > 256 { + known.remove(0); + } + s.items.insert( + name.clone(), + Item { + head: c.version.vid, + lineage: r.lineage.iter().copied().map(map::wire_vid).collect(), + parents: c.version.parents.clone(), + known, + scope, + own: false, + conflict: false, + }, + ); + if proposal { + let registration = s.generations.accept(name, PeerId(c.peer.clone())); + queue( + s, + &c.peer, + Control::Accept { + name: name.clone(), + generation: registration.generation, + }, + ); + // Both peers grant their own generations. The reciprocal Accept is sent once. + } else if !c.legacy { + queue( + s, + &c.peer, + Control::Ack { + id: kc_proto::sync::ChangeId { + name: crate::values::item_name(name)?, + generation: c.generation, + new_vid: c.version.vid, + }, + result: map::wire_ack(r.ack), + }, + ); + } + clear_candidates(s, name); + s.save(&ctx.state) +} +pub(super) fn queue(s: &mut State, peer: &str, message: Control) { + // Coalesce metadata-only controls; messages never contain values or fingerprints. + let encoded = serde_json::to_vec(&message).unwrap_or_default(); + if !s + .controls + .iter() + .any(|(p, c)| p == peer && serde_json::to_vec(c).unwrap_or_default() == encoded) + { + s.controls.push((peer.into(), message)); + } +} +pub(crate) fn recover(ctx: &mut Ctx<'_, H>, s: &mut State) -> Result<()> { + let Some(journal) = s.journal.clone() else { + return collect_orphan_snapshots(ctx, s); + }; + let record: Intent = private_get(ctx, &journal.record)?; + match record { + Intent::Local { + record: r, + version: v, + clear, + } => { + let cur = current(ctx, &r.name)?; + let fp = cur.as_ref().map_or(Fp([0; 32]), |v| v.2); + let committed = s + .items + .get(&r.name) + .is_some_and(|i| map::vid(i.head) == r.new_vid); + let exists = ctx.store.get_internal(&r.snapshot_slot)?.is_some(); + match kc_sync::recover_local(r.prev_fp, r.new_fp, fp, committed, exists) { + LocalRecovery::RebuildSnapshotAndCommit => { + let (value, kind, _) = cur.ok_or_else(state_error)?; + put_blob(ctx, &r.snapshot_slot, kind, &value)?; + finish_local(ctx, s, &r, &v, clear)?; + } + LocalRecovery::Commit => finish_local(ctx, s, &r, &v, clear)?, + LocalRecovery::CleanJournal | LocalRecovery::KeepSnapshotAndScan => {} + LocalRecovery::DiscardSnapshot | LocalRecovery::DiscardSnapshotAndScan => { + release(s, &r.snapshot_slot) + } + } + } + Intent::Remote { + record: r, + candidate: c, + } => { + let fp = current(ctx, &r.change_id.name)?.map_or(Fp([0; 32]), |v| v.2); + match kc_sync::recover_remote(&r, fp) { + RemoteRecovery::FinishFromStep4 => finish_remote(ctx, s, &r, &c)?, + RemoteRecovery::Retry => {} + RemoteRecovery::Conflict => { + if let Some(item) = s.items.get_mut(&r.change_id.name) { + item.conflict = true; + } + if let Some(candidate) = s.candidates.get_mut(&c.version.slot) { + candidate.category = CandidateKind::Conflict; + } + } + } + } + Intent::Observe { + name, + previous, + vid, + parents, + snapshot, + } => { + if let Some((value, kind, fp)) = current(ctx, &name)? { + if size(&value).is_err() { + s.items.get_mut(&name).ok_or_else(state_error)?.conflict = true; + release(s, &snapshot); + } else if fp != previous { + let (r, v) = + prepare_local(ctx, s, &name, previous, kind, &value, parents, vid, false)?; + put_blob(ctx, &v.slot, kind, &value)?; + finish_local(ctx, s, &r, &v, false)?; + } else { + release(s, &snapshot); + } + } else { + release(s, &snapshot); + } + } + } + clear_intent(ctx, s)?; + collect_orphan_snapshots(ctx, s) +} + +fn collect_orphan_snapshots(ctx: &Ctx<'_, H>, s: &mut State) -> Result<()> { + // Called after journal recovery: its in-flight snapshot must survive until then. + let orphaned = s + .slots + .keys() + .filter(|slot| { + slot.starts_with("sync/snapshot/") + && !s.versions.values().any(|v| &v.slot == *slot) + && !s.offers.iter().any(|o| snapshot_slot(o.vid) == **slot) + && !s.peers.keys().any(|peer| { + s.outbox + .pending(&PeerId(peer.clone())) + .any(|id| snapshot_slot(map::wire_vid(id.new_vid)) == **slot) + }) + }) + .cloned() + .collect::>(); + for slot in orphaned { + release(s, &slot); + } + if !s.gc.is_empty() { + s.cleanup(ctx)?; + } + Ok(()) +} diff --git a/crates/kc-cli/src/sync/transport.rs b/crates/kc-cli/src/sync/transport.rs new file mode 100644 index 0000000..1b2ac5d --- /dev/null +++ b/crates/kc-cli/src/sync/transport.rs @@ -0,0 +1,325 @@ +use super::*; +use kc_proto::inbox::{self, Body}; +use kc_proto::payload::WriterToken; +use kc_proto::relay::RelayApi; +use kc_proto::sync::{Change, DigestEntry, Op, SyncMsg}; +use state::Control; +use std::time::Duration; + +fn control(c: &Control) -> Result { + Ok(match c { + Control::Hello { reply } => SyncMsg::Hello { + features: vec!["sync-phase1".into()], + is_reply: *reply, + }, + Control::Accept { name, generation } => SyncMsg::Accept { + name: crate::values::item_name(name)?, + generation: *generation, + }, + Control::Leave { name, generation } => SyncMsg::Leave { + name: crate::values::item_name(name)?, + generation: *generation, + }, + Control::Ack { id, result } => SyncMsg::Ack { + results: vec![(id.clone(), *result)], + }, + }) +} +async fn post( + ctx: &Ctx<'_, H>, + peer: &crate::state::Peer, + message: SyncMsg, +) -> Result<()> { + let key = crate::commands::pairing::device_key(ctx)?.ok_or_else(state_error)?; + let stored = ctx + .store + .get_internal(&peer.token_key())? + .ok_or_else(state_error)?; + let raw = Zeroizing::new(<[u8; 32]>::try_from(stored.as_bytes()).map_err(|_| state_error())?); + let token = WriterToken::from_bytes(*raw); + let body = Body::Sync(message); + // seal_v2 checks the actual postcard plaintext/padded/envelope size against 256 KiB. + let sealed = inbox::seal_v2( + &key, + &peer.device_pk, + &body, + Duration::from_secs(kc_wire::limits::INBOX_MESSAGE_TTL_SECS), + ctx.host.now(), + )?; + ctx.connect()? + .post_message(&peer.inbox_id.to_b64url(), &token.bearer(), &sealed.body) + .await + .map_err(|error| { + let mut error = CliError::from(error); + error.code = 6; + error + })?; + Ok(()) +} +async fn deliver( + ctx: &Ctx<'_, H>, + s: &mut State, + peer: &crate::state::Peer, + message: SyncMsg, +) -> Result<()> { + if let Err(error) = post(ctx, peer, message).await { + s.delivery_failed = true; + s.save(&ctx.state)?; + return Err(error); + } + Ok(()) +} +pub(crate) async fn flush(ctx: &mut Ctx<'_, H>, digest: bool) -> Result { + if !ctx.state.root().join("sync.json").exists() { + return Ok(0); + } + let _items = ctx.state.lock_items(ctx.store.namespace())?; + let _state = ctx.state.lock()?; + let mut s = State::load(&ctx.state)?; + recover(ctx, &mut s)?; + let peers = ctx.state.load_peers()?; + let mut sent = 0; + for peer in &peers.peers { + let id = peer.fingerprint.to_hex(); + let Some(p) = s.peers.get(&id) else { continue }; + if !p.capable { + if !p.hello_sent { + s.peers.get_mut(&id).unwrap().hello_sent = true; + // Persist the attempt, but permit retry if delivery fails. + s.save(&ctx.state)?; + if let Err(error) = deliver( + ctx, + &mut s, + peer, + SyncMsg::Hello { + features: vec!["sync-phase1".into()], + is_reply: false, + }, + ) + .await + { + s.peers.get_mut(&id).unwrap().hello_sent = false; + s.save(&ctx.state)?; + return Err(error); + } + } + continue; + } + let controls = s + .controls + .iter() + .filter(|(p, _)| p == &id) + .cloned() + .collect::>(); + for entry in controls { + deliver(ctx, &mut s, peer, control(&entry.1)?).await?; + let bytes = serde_json::to_vec(&entry).map_err(|_| state_error())?; + if let Some(i) = s + .controls + .iter() + .position(|c| serde_json::to_vec(c).ok().as_ref() == Some(&bytes)) + { + s.controls.remove(i); + } + s.save(&ctx.state)?; + } + if !s.peers[&id].enabled { + continue; + } + let digest_due = digest + && s.peers[&id] + .last_digest + .is_none_or(|last| (ctx.host.now() as i128) - (last as i128) >= 86400); + let offers = s + .offers + .iter() + .filter(|o| o.peer == id) + .cloned() + .collect::>(); + for offer in offers { + let generation = s + .generations + .known_generation(&PeerId(id.clone()), &offer.name); + if s.deferred + .contains(&delivery_key(&id, &offer.name, generation, offer.vid)) + { + continue; + } + let Some(v) = s.versions.get(&vid_key(offer.vid)).cloned() else { + return Err(state_error()); + }; + let value = transaction::blob(ctx, &v.slot)?; + deliver( + ctx, + &mut s, + peer, + SyncMsg::Offer { + name: crate::values::item_name(&v.name)?, + vid: v.vid, + lineage: v.lineage.clone(), + kind: value.kind, + value: value.value, + known_generation: generation, + }, + ) + .await?; + sent += 1; + } + let ids: Vec<_> = s.outbox.pending(&PeerId(id.clone())).cloned().collect(); + for change in &ids { + if let Some(latest) = s.latest_local.get(&change.name) + && change.new_vid != map::vid(*latest) + && ids + .iter() + .any(|id| id.name == change.name && id.new_vid == map::vid(*latest)) + { + continue; + } + if s.deferred.contains(&delivery_key( + &id, + &change.name, + change.generation, + map::wire_vid(change.new_vid), + )) { + continue; + } + let v = s + .versions + .get(&vid_key(map::wire_vid(change.new_vid))) + .cloned() + .ok_or_else(state_error)?; + let value = transaction::blob(ctx, &v.slot)?; + deliver( + ctx, + &mut s, + peer, + SyncMsg::Changes { + changes: vec![Change { + name: crate::values::item_name(&v.name)?, + generation: change.generation, + new_vid: v.vid, + parents: v.parents.clone(), + lineage: v.lineage.clone(), + op: Op::Put { + kind: value.kind, + value: value.value, + }, + approval_ref: None, + }], + }, + ) + .await?; + sent += 1; + } + if digest_due { + let entries: Vec<_> = s + .items + .iter() + .filter(|(_, i)| i.scope.contains(&id)) + .map(|(name, i)| { + Ok(DigestEntry { + name: crate::values::item_name(name)?, + head: i.head, + generation: s.generations.known_generation(&PeerId(id.clone()), name), + }) + }) + .collect::>()?; + // A conservative count bound keeps each chunk small; sealing still enforces + // the actual serialized size instead of assuming byte lengths from item values. + for chunk in entries.chunks(256) { + deliver( + ctx, + &mut s, + peer, + SyncMsg::Digest { + entries: chunk.to_vec(), + }, + ) + .await?; + } + s.peers.get_mut(&id).unwrap().last_digest = Some(ctx.host.now()); + s.deferred.retain(|key| !key.starts_with(&format!("{id}/"))); + s.save(&ctx.state)?; + } + } + // Every peer was reached without an error, so nothing waits on a failed delivery. + s.delivery_failed = false; + collect_snapshots(&mut s); + s.cleanup(ctx)?; + Ok(sent) +} +pub(super) fn collect_snapshots(s: &mut State) { + let versions = s.versions.values().cloned().collect::>(); + for v in versions { + let waiting = s.offers.iter().any(|o| o.vid == v.vid) + || s.peers.keys().any(|p| { + s.outbox + .pending(&PeerId(p.clone())) + .any(|c| c.new_vid == map::vid(v.vid) && c.name == v.name) + }); + if !waiting { + s.outbox.release_snapshot(&v.name, map::vid(v.vid)); + release(s, &v.slot); + // Retain only the metadata for the latest locally authored head, for digest. + if s.items + .get(&v.name) + .is_none_or(|i| i.head != v.vid || !i.own) + { + s.versions.remove(&vid_key(v.vid)); + } + } + } +} +pub(super) fn resend( + ctx: &Ctx<'_, H>, + s: &mut State, + peer: &str, + name: &str, +) -> Result<()> { + let item = s.items[name].clone(); + if !item.own { + return Ok(()); + } + let Some(generation) = s + .generations + .outgoing_generation(&PeerId(peer.into()), name) + else { + return Ok(()); + }; + let v = s + .versions + .get(&vid_key(item.head)) + .cloned() + .ok_or_else(state_error)?; + if !s.slots.contains_key(&v.slot) { + let Some((value, kind, fp)) = current(ctx, name)? else { + return Ok(()); + }; + let record: VidRecord = private_get(ctx, &record_slot(name, item.head))?; + if fp != record.fp { + return Ok(()); + } + if !reserve(ctx, s, &v.slot, SlotKind::ConflictCandidate, true)? { + return Ok(()); + } + transaction::put_blob(ctx, &v.slot, kind, &value)?; + } + s.outbox.enqueue( + PeerId(peer.into()), + kc_sync::ChangeId { + name: name.into(), + generation, + new_vid: map::vid(v.vid), + }, + ); + Ok(()) +} +pub(crate) async fn send_after_write(ctx: &mut Ctx<'_, H>) { + if flush(ctx, false).await.is_err() { + crate::commands::say!( + ctx, + "{}", + tr!("Sync delivery is queued; run `kc sync` to retry.") + ); + } +} diff --git a/crates/kc-cli/tests/common/fault_relay.rs b/crates/kc-cli/tests/common/fault_relay.rs new file mode 100644 index 0000000..fc7932e --- /dev/null +++ b/crates/kc-cli/tests/common/fault_relay.rs @@ -0,0 +1,130 @@ +//! Relay delivery failure injection; all other calls use the authenticated memory relay. +use super::*; +use kc_wire::{ + ChannelAllocated, ChannelJoined, DeleteReason, InboxCreated, InboxMessages, MessageAccepted, + Phase, WriterRegister, WriterRegistered, +}; + +pub struct FaultRelay { + pub inner: MemoryRelay, + pub fail_post: std::sync::Arc, +} +impl Clone for FaultRelay { + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + fail_post: self.fail_post.clone(), + } + } +} +impl FaultRelay { + pub fn new(inner: MemoryRelay) -> Self { + Self { + inner, + fail_post: Default::default(), + } + } +} +impl Net for FaultRelay { + type Relay = Self; + fn connect(&self, _url: &RelayUrl) -> Result { + Ok(self.clone()) + } + async fn limits(&self, _url: &RelayUrl) -> Result { + Ok(Limits::current()) + } +} +impl RelayApi for FaultRelay { + async fn allocate(&self) -> Result { + self.inner.allocate().await + } + async fn join(&self, channel: u16) -> Result { + self.inner.join(channel).await + } + async fn put_phase( + &self, + channel: u16, + side_token: &str, + phase: Phase, + body: &[u8], + ) -> Result<(), RelayError> { + self.inner.put_phase(channel, side_token, phase, body).await + } + async fn get_phase( + &self, + channel: u16, + side_token: &str, + phase: Phase, + wait: Duration, + ) -> Result>, RelayError> { + self.inner.get_phase(channel, side_token, phase, wait).await + } + async fn delete_channel( + &self, + channel: u16, + side_token: &str, + reason: DeleteReason, + ) -> Result<(), RelayError> { + self.inner.delete_channel(channel, side_token, reason).await + } + async fn create_inbox(&self) -> Result { + self.inner.create_inbox().await + } + async fn register_writer( + &self, + inbox_id: &str, + owner_token: &str, + request: &WriterRegister, + ) -> Result { + self.inner + .register_writer(inbox_id, owner_token, request) + .await + } + async fn delete_writer( + &self, + inbox_id: &str, + owner_token: &str, + writer_id: &str, + ) -> Result<(), RelayError> { + self.inner + .delete_writer(inbox_id, owner_token, writer_id) + .await + } + async fn post_message( + &self, + inbox_id: &str, + writer_token: &str, + body: &[u8], + ) -> Result { + if self + .fail_post + .swap(false, std::sync::atomic::Ordering::SeqCst) + { + return Err(kc_proto::relay::RelayError::Transport( + "injected post failure".into(), + )); + } + self.inner.post_message(inbox_id, writer_token, body).await + } + async fn list_messages( + &self, + inbox_id: &str, + owner_token: &str, + wait: Duration, + ) -> Result { + self.inner.list_messages(inbox_id, owner_token, wait).await + } + async fn delete_message( + &self, + inbox_id: &str, + owner_token: &str, + msg_id: &str, + ) -> Result<(), RelayError> { + self.inner + .delete_message(inbox_id, owner_token, msg_id) + .await + } + async fn delete_inbox(&self, inbox_id: &str, owner_token: &str) -> Result<(), RelayError> { + self.inner.delete_inbox(inbox_id, owner_token).await + } +} diff --git a/crates/kc-cli/tests/common/mod.rs b/crates/kc-cli/tests/common/mod.rs index dd00cb7..f9526c7 100644 --- a/crates/kc-cli/tests/common/mod.rs +++ b/crates/kc-cli/tests/common/mod.rs @@ -14,7 +14,7 @@ use std::path::PathBuf; use std::process::Command; use std::time::Duration; -use kc_cli::{CliError, Console, Host, HttpRelay, PromptError, RelayUrl}; +use kc_cli::{CliError, Console, Host, HttpRelay, LocalAuthOutcome, PromptError, RelayUrl}; use kc_proto::memory_relay::MemoryRelay; use kc_proto::relay::{RelayApi, RelayError}; use kc_proto::session::SessionOptions; @@ -25,6 +25,8 @@ use tempfile::TempDir; use tokio::sync::oneshot; use zeroize::Zeroizing; +pub mod fault_relay; + pub const NAMESPACE: &str = "dev.1pass.kc.test-cli"; /// A scripted answer to the next prompt. @@ -186,6 +188,7 @@ pub struct Run { pub terminal: bool, pub stdout_terminal: bool, pub answers: Vec, + pub local_auth: VecDeque, pub env: Vec<(String, String)>, pub code_tx: Option>, } @@ -198,6 +201,7 @@ impl Run { terminal: false, stdout_terminal: false, answers: Vec::new(), + local_auth: VecDeque::new(), env: vec![("CLAUDECODE".into(), "1".into())], code_tx: None, } @@ -210,6 +214,7 @@ impl Run { terminal: true, stdout_terminal: false, answers, + local_auth: VecDeque::new(), env: Vec::new(), code_tx: None, } @@ -266,6 +271,7 @@ struct TestHost<'d, N: Net> { terminal: bool, stdout_terminal: bool, env: Vec<(String, String)>, + local_auth: VecDeque, } impl Host for TestHost<'_, N> { @@ -276,6 +282,24 @@ impl Host for TestHost<'_, N> { &mut self.console } + fn local_confirm(&mut self, reason: &str) -> LocalAuthOutcome { + self.console + .prompts + .push(format!("local confirmation: {reason}")); + self.local_auth.pop_front().unwrap_or_else(|| { + LocalAuthOutcome::Unavailable("no scripted local confirmation".into()) + }) + } + + fn sync_interrupt_after_write(&mut self) -> bool { + if let Some(index) = self.env.iter().position(|(k, _)| k == "TEST_SYNC_CRASH") { + self.env.remove(index); + true + } else { + false + } + } + fn env_var(&self, key: &str) -> Option { self.env .iter() @@ -367,8 +391,15 @@ impl Device { fn store_with(&self, interactive: bool) -> kc_store::Result { match &self.keychain { Keychain::Memory(mem) => { + // Sync tests isolate virtual keychain namespaces as real devices do; + // unrelated test cases must not contend on one OS-wide items lock. + let namespace = self + .env + .iter() + .find(|(key, _)| key == "TEST_NAMESPACE") + .map_or(NAMESPACE, |(_, value)| value.as_str()); let cfg = - StoreConfig::new(NAMESPACE, self.dir.path()).with_interactive(interactive); + StoreConfig::new(namespace, self.dir.path()).with_interactive(interactive); Store::open_with_memory_backend(cfg, mem) } Keychain::Os { namespace } => Store::open( @@ -393,6 +424,7 @@ impl Device { terminal: run.terminal, stdout_terminal: run.stdout_terminal, env, + local_auth: run.local_auth, }; let argv = std::iter::once("kc") .chain(args.iter().copied()) diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs new file mode 100644 index 0000000..b3da08e --- /dev/null +++ b/crates/kc-cli/tests/sync.rs @@ -0,0 +1,1651 @@ +//! Real CLI flows through two isolated memory keychains and the authenticated relay. +mod common; +use common::{Answer, Device, Run, transfer}; +use kc_cli::LocalAuthOutcome; +use kc_proto::memory_relay::MemoryRelay; +use kc_proto::relay::RelayApi; +use kc_proto::sync::{Change, Op, SyncMsg, Vid}; +use kc_proto::{ItemName, SecretBytes}; +use serde_json::Value; + +fn human(answers: Vec) -> Run { + let mut run = Run::human(answers); + run.local_auth.push_back(LocalAuthOutcome::Confirmed); + run +} +fn state(d: &Device) -> Value { + serde_json::from_slice(&std::fs::read(d.dir.path().join("sync.json")).unwrap()).unwrap() +} +fn head(d: &Device) -> Vid { + serde_json::from_value(state(d)["items"]["KEY"]["head"].clone()).unwrap() +} +async fn pair(a: &Device, b: &Device) { + let (rx, tx) = transfer( + b, + &["pair"], + Run::human(vec![Answer::Yes]), + a, + &["pair", "--join"], + |code| Run::human(vec![Answer::Text(code), Answer::Yes]), + ) + .await; + rx.expect(0); + tx.expect(0); +} +async fn devices() -> (Device, Device, MemoryRelay) { + let relay = MemoryRelay::new(); + let mut a = Device::new("alpha", relay.clone()); + let mut b = Device::new("bravo", relay.clone()); + for device in [&mut a, &mut b] { + device.env.push(( + "TEST_NAMESPACE".into(), + format!("dev.1pass.kc.sync-{}", u128::from_be_bytes(Vid::random().0)), + )); + } + pair(&a, &b).await; + (a, b, relay) +} +async fn pump(a: &Device, b: &Device) { + for _ in 0..3 { + for d in [a, b] { + let out = d.run(&["sync"], Run::agent()).await; + assert!([0, 8].contains(&out.code), "{}", out.stderr); + } + } +} +async fn enroll(a: &Device, b: &Device) { + a.set("KEY", b"fake-initial-secret").await; + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])) + .await + .expect(8); + pump(a, b).await; + assert!(b.value("KEY").is_none()); + assert_eq!(state(b)["candidates"].as_object().unwrap().len(), 1); + let out = b + .run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await; + assert!([0, 8].contains(&out.code), "{}", out.stderr); + assert_eq!( + out.prompts + .iter() + .filter(|p| p.starts_with("local confirmation:")) + .count(), + 1 + ); + pump(a, b).await; + assert_eq!(head(a), head(b)); +} +async fn post(a: &Device, b: &Device, relay: &MemoryRelay, msg: SyncMsg) { + let key = a.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let peer = a.peers().find("bravo").unwrap().clone(); + let sealed = kc_proto::inbox::seal_v2( + &key, + &peer.device_pk, + &kc_proto::inbox::Body::Sync(msg), + std::time::Duration::from_secs(86400), + kc_proto::inbox::unix_now(), + ) + .unwrap(); + relay + .post_message( + &b.inbox_credentials().0, + &a.writer_bearer("bravo"), + &sealed.body, + ) + .await + .unwrap(); +} +#[tokio::test] +async fn add_offer_review_local_confirmation_and_accept_on_both_sides() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + assert_eq!(a.value("KEY"), b.value("KEY")); + a.run(&["sync", "status", "--json"], Run::agent()) + .await + .expect(0); + b.run(&["sync", "status", "--json"], Run::agent()) + .await + .expect(0); + assert!( + state(&a)["slots"] + .as_object() + .unwrap() + .keys() + .all(|k| !k.contains("snapshot")) + ); +} +#[tokio::test] +async fn local_change_is_held_review_converges_and_ack_releases_snapshot() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-second-secret").await; + pump(&a, &b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert!( + state(&b)["candidates"] + .as_object() + .unwrap() + .values() + .any(|v| v["category"] == "held") + ); + assert!( + state(&a)["slots"] + .as_object() + .unwrap() + .keys() + .all(|k| !k.contains("snapshot")) + ); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + pump(&a, &b).await; + assert_eq!(head(&a), head(&b)); + assert_eq!(a.value("KEY"), b.value("KEY")); + b.run(&["sync", "restore-checkpoint", "KEY"], human(vec![])) + .await + .expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); +} +#[tokio::test] +async fn concurrent_changes_conflict_resolve_is_held_then_converges() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-alpha-change").await; + b.set("KEY", b"fake-bravo-change").await; + pump(&a, &b).await; + assert_eq!(state(&a)["items"]["KEY"]["conflict"], true); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); + a.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])) + .await + .expect(8); + pump(&a, &b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-bravo-change"); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + pump(&a, &b).await; + assert_eq!(head(&a), head(&b)); + assert_eq!(a.value("KEY"), b.value("KEY")); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} +#[tokio::test] +async fn remove_bumps_generation_late_change_is_stale_and_requires_reoffer() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let old = head(&a); + b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); + post( + &a, + &b, + &relay, + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: Vid::random(), + parents: vec![old], + lineage: vec![old], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"late-fake"), + }, + approval_ref: None, + }], + }, + ) + .await; + pump(&a, &b).await; + assert!(state(&b)["items"].as_object().unwrap().is_empty()); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert!( + a.run(&["sync", "status", "--json"], Run::agent()) + .await + .stdout_text() + .contains("re-offer needed") + ); + a.run(&["sync", "offer", "KEY", "--peers", "bravo"], Run::agent()) + .await + .expect(8); + pump(&a, &b).await; + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + pump(&a, &b).await; + assert_eq!(head(&a), head(&b)); +} +#[tokio::test] +async fn v1_imports_normal_items_but_holds_sync_overwrites_and_rm_refuses() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store() + .set( + "KEY", + b"fake-v1-overwrite", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.set("OTHER", b"fake-normal").await; + a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()) + .await + .expect(0); + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(b.value("OTHER").unwrap(), b"fake-normal"); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + b.run(&["rm", "KEY", "--yes"], Run::agent()).await.expect(5); +} +#[tokio::test] +async fn noninteractive_add_review_and_denied_local_confirmation_exit_five() { + let relay = MemoryRelay::new(); + let a = Device::new("alpha", relay); + a.set("KEY", b"fake").await; + for args in [ + vec!["sync", "add", "KEY"], + vec!["sync", "review"], + vec!["sync", "unfreeze"], + vec!["sync", "resolve", "KEY", "--keep", "mine"], + vec!["sync", "restore-checkpoint", "KEY"], + vec!["sync", "rm", "KEY"], + ] { + let before = std::fs::read(a.dir.path().join("sync.json")).ok(); + a.run(&args, Run::agent()).await.expect(5); + assert_eq!(std::fs::read(a.dir.path().join("sync.json")).ok(), before); + assert_eq!(a.value("KEY").unwrap(), b"fake"); + } + let mut denied = Run::human(vec![]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + a.run(&["sync", "add", "KEY"], denied).await.expect(5); + assert!(!a.dir.path().join("sync.json").exists()); + a.run(&["sync", "add", "KEY"], Run::human(vec![])) + .await + .expect(5); +} +#[tokio::test] +async fn crash_after_local_and_remote_keychain_writes_recovers_journal() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + let mut crash = Run::agent().stdin(b"fake-crash-local".to_vec()); + crash.env.push(("TEST_SYNC_CRASH".into(), "1".into())); + a.run(&["set", "KEY"], crash).await.expect(1); + assert!(!state(&a)["journal"].is_null()); + pump(&a, &b).await; + assert!(state(&a)["journal"].is_null()); + let mut crash = human(vec![Answer::Select(0)]); + crash.env.push(("TEST_SYNC_CRASH".into(), "1".into())); + b.run(&["sync", "review"], crash).await.expect(1); + assert!(!state(&b)["journal"].is_null()); + assert_eq!(b.value("KEY").unwrap(), b"fake-crash-local"); + pump(&a, &b).await; + assert!(state(&b)["journal"].is_null()); + assert_eq!(head(&a), head(&b)); +} +#[tokio::test] +async fn unknown_peer_gets_exactly_one_hello_and_no_offer_until_reply() { + let (a, b, relay) = devices().await; + a.set("KEY", b"fake").await; + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])) + .await + .expect(8); + for _ in 0..3 { + a.run(&["sync"], Run::agent()).await.expect(8); + } + let (id, owner) = b.inbox_credentials(); + let listing = relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap(); + assert_eq!(listing.messages.len(), 1); + let key = b.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let sender = b.peers().find("alpha").unwrap().device_pk; + let bytes = kc_proto::relay::message_body(&listing.messages[0]).unwrap(); + let opened = kc_proto::inbox::open_any( + &bytes, + &[&key], + |_| Some(sender), + |_| false, + kc_proto::inbox::unix_now(), + ) + .unwrap(); + assert!(matches!( + opened.body, + kc_proto::inbox::Body::Sync(SyncMsg::Hello { + is_reply: false, + .. + }) + )); +} +#[tokio::test] +async fn freeze_holds_changes_and_status_and_state_never_contain_values() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + b.run(&["sync", "freeze"], Run::agent()).await.expect(8); + a.set("KEY", b"fake-freeze-secret").await; + pump(&a, &b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + let status = b.run(&["sync", "status", "--json"], Run::agent()).await; + status.expect(8); + assert!(status.stdout_text().contains("frozen")); + for text in [ + status.stdout_text(), + std::fs::read_to_string(b.dir.path().join("sync.json")).unwrap(), + ] { + assert!(!text.contains("fake-")); + } + b.run(&["sync", "unfreeze"], human(vec![])).await.expect(8); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + pump(&a, &b).await; + assert_eq!(head(&a), head(&b)); +} + +#[tokio::test] +async fn stale_unseen_offer_is_ignored_and_digest_recovers_a_lost_leave() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); + // Lose every Leave already posted to A. + let (id, owner) = a.inbox_credentials(); + for msg in relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + { + relay + .delete_message(&id, &owner, &msg.msg_id) + .await + .unwrap(); + } + post( + &a, + &b, + &relay, + SyncMsg::Offer { + name: ItemName::new("KEY").unwrap(), + vid: Vid::random(), + lineage: vec![], + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"fake-stale-offer"), + known_generation: 1, + }, + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + post( + &a, + &b, + &relay, + SyncMsg::Digest { + entries: vec![kc_proto::sync::DigestEntry { + name: ItemName::new("KEY").unwrap(), + generation: 1, + head: head(&a), + }], + }, + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(0); + a.run(&["inbox"], Run::agent()).await.expect(8); + assert!( + a.run(&["sync", "status", "--json"], Run::agent()) + .await + .stdout_text() + .contains("re-offer needed") + ); +} +#[tokio::test] +async fn overwrite_attempts_trip_breaker_and_immutable_vid_is_quarantined() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let parent = head(&b); + let first = Vid::random(); + for n in 0..6 { + post( + &a, + &b, + &relay, + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: if n == 0 { first } else { Vid::random() }, + parents: vec![parent], + lineage: vec![parent], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(format!("fake-{n}").as_bytes()), + }, + approval_ref: None, + }], + }, + ) + .await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let status = b.run(&["sync", "status", "--json"], Run::agent()).await; + let json: Value = serde_json::from_slice(&status.stdout).unwrap(); + assert_eq!(json["peers"][0]["breaker"], true); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + b.run(&["sync", "unfreeze"], human(vec![])).await.expect(8); + post( + &a, + &b, + &relay, + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: first, + parents: vec![parent], + lineage: vec![parent], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"fake-mutated-vid"), + }, + approval_ref: None, + }], + }, + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| { + p["quarantine"] + .as_array() + .unwrap() + .contains(&Value::String("KEY".into())) + })); +} +#[tokio::test] +async fn capacity_defers_seventeenth_proposal_without_storing_its_value() { + let (a, b, relay) = devices().await; + for n in 0..17 { + post( + &a, + &b, + &relay, + SyncMsg::Offer { + name: ItemName::new(&format!("KEY{n}")).unwrap(), + vid: Vid::random(), + lineage: vec![], + known_generation: 0, + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"fake-capacity"), + }, + ) + .await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(), 16); + assert_eq!(s["slots"].as_object().unwrap().len(), 16); + assert_eq!(s["capacity_blocked"], true); + assert!(b.value("KEY16").is_none()); +} +#[tokio::test] +async fn recovery_never_overwrites_a_third_value_written_after_crash() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-remote-intent").await; + pump(&a, &b).await; + let mut crash = human(vec![Answer::Select(0)]); + crash.env.push(("TEST_SYNC_CRASH".into(), "1".into())); + b.run(&["sync", "review"], crash).await.expect(1); + b.store() + .set( + "KEY", + b"fake-third-value", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + b.run(&["sync"], Run::agent()).await.expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-third-value"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); + assert!(state(&b)["journal"].is_null()); +} +#[tokio::test] +async fn restore_and_adopt_publish_local_versions_and_checkpoint_confirmation_is_gated() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-next").await; + let before = head(&a); + a.run(&["restore", "KEY"], Run::agent()).await.expect(0); + assert_ne!(before, head(&a)); + assert_eq!(a.value("KEY").unwrap(), b"fake-initial-secret"); + a.memory() + .insert("foreign-service", "account", b"fake-adopted"); + let before = head(&a); + a.run( + &[ + "adopt", + "--service", + "foreign-service", + "--account", + "account", + "--as", + "KEY", + ], + Run::agent(), + ) + .await + .expect(0); + assert_ne!(before, head(&a)); + assert_eq!(a.value("KEY").unwrap(), b"fake-adopted"); + a.run( + &["sync", "status", "--confirm-checkpoint", "KEY"], + Run::agent(), + ) + .await + .expect(5); + a.run( + &["sync", "status", "--confirm-checkpoint", "KEY"], + human(vec![]), + ) + .await + .expect(8); + a.set("KEY", b"fake-later").await; + a.run(&["sync", "restore-checkpoint", "KEY"], human(vec![])) + .await + .expect(8); + assert_eq!(a.value("KEY").unwrap(), b"fake-adopted"); +} +#[tokio::test] +async fn rejected_held_change_is_not_recreated_by_retransmission() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let parent = head(&b); + let vid = Vid::random(); + let message = SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: vid, + parents: vec![parent], + lineage: vec![parent], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"fake-rejected"), + }, + approval_ref: None, + }], + }; + post(&a, &b, &relay, message.clone()).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + b.run(&["sync", "review"], human(vec![Answer::Select(1)])) + .await + .expect(0); + post(&a, &b, &relay, message).await; + b.run(&["inbox"], Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} + +#[tokio::test] +async fn legacy_overwrite_flag_and_code_receive_cannot_bypass_local_confirmation() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store() + .set( + "KEY", + b"fake-legacy-terminal", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.run(&["send", "KEY", "--to", "bravo"], Run::agent()) + .await + .expect(0); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + b.run(&["inbox", "--on-conflict", "overwrite"], Run::agent()) + .await + .expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + b.run(&["receive", "--on-conflict", "overwrite"], Run::agent()) + .await + .expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + b.run( + &["inbox", "--on-conflict", "overwrite"], + Run::human(vec![Answer::Yes]), + ) + .await + .expect(5); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + assert_eq!(b.value("KEY").unwrap(), b"fake-legacy-terminal"); + a.store() + .set( + "KEY", + b"fake-code-overwrite", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + let (rx, tx) = transfer( + &b, + &["receive", "--on-conflict", "overwrite"], + Run::human(vec![Answer::Yes]), + &a, + &["send", "KEY"], + |code| Run::human(vec![Answer::Text(code), Answer::Yes]), + ) + .await; + rx.expect(5); + tx.expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-legacy-terminal"); +} +#[tokio::test] +async fn local_change_between_receive_and_review_becomes_conflict() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-incoming").await; + pump(&a, &b).await; + b.set("KEY", b"fake-intervening-local").await; + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-intervening-local"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); +} +#[tokio::test] +async fn sync_peer_removal_is_locally_confirmed_and_stops_outgoing_updates() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.run(&["sync", "peer", "rm", "bravo"], Run::agent()) + .await + .expect(5); + a.run(&["sync", "peer", "rm", "bravo"], human(vec![])) + .await + .expect(0); + a.set("KEY", b"fake-out-of-scope").await; + pump(&a, &b).await; + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert!( + state(&a)["items"]["KEY"]["scope"] + .as_array() + .unwrap() + .is_empty() + ); +} + +#[tokio::test] +async fn freeze_retains_immutable_vid_violation_but_review_cannot_apply_it() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let vid = head(&b); + b.run(&["sync", "freeze"], Run::agent()).await.expect(8); + post( + &a, + &b, + &relay, + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: vid, + parents: vec![], + lineage: vec![vid], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(b"fake-mutation-while-frozen"), + }, + approval_ref: None, + }], + }, + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!( + state(&b)["candidates"] + .as_object() + .unwrap() + .values() + .any(|c| c["invalid_binding"] == true && c["category"] == "held") + ); + b.run(&["sync", "unfreeze"], human(vec![])).await.expect(8); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(8); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); +} + +#[tokio::test] +async fn rejecting_a_proposal_blocks_retries_but_an_explicit_reoffer_is_fresh() { + let (a, b, _) = devices().await; + a.set("KEY", b"fake-proposal").await; + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])) + .await + .expect(8); + pump(&a, &b).await; + b.run(&["sync", "review"], human(vec![Answer::Select(1)])) + .await + .expect(0); + pump(&a, &b).await; + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + let old = head(&a); + a.run(&["sync", "offer", "KEY", "--peers", "bravo"], Run::agent()) + .await + .expect(8); + assert_ne!(old, head(&a)); + pump(&a, &b).await; + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + pump(&a, &b).await; + assert_eq!(head(&a), head(&b)); +} + +fn save_state(d: &Device, s: &Value) { + std::fs::write( + d.dir.path().join("sync.json"), + serde_json::to_vec_pretty(s).unwrap(), + ) + .unwrap(); +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +fn fp_slot(name: &str, vid: Vid) -> String { + use sha2::{Digest, Sha256}; + format!( + "sync/fp/{}/{}", + hex(&Sha256::digest(name.as_bytes())), + hex(&vid.0) + ) +} +fn offer_message(name: &str, vid: Vid, value: &[u8], generation: u64) -> SyncMsg { + SyncMsg::Offer { + name: ItemName::new(name).unwrap(), + vid, + lineage: vec![], + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(value), + known_generation: generation, + } +} +fn change_message(name: &str, vid: Vid, parent: Vid, value: &[u8]) -> SyncMsg { + SyncMsg::Changes { + changes: vec![Change { + name: ItemName::new(name).unwrap(), + generation: 1, + new_vid: vid, + parents: vec![parent], + lineage: vec![parent], + op: Op::Put { + kind: kc_proto::sync::ItemKind::Text, + value: SecretBytes::from_slice(value), + }, + approval_ref: None, + }], + } +} +fn confirmations(out: &common::Output) -> Vec<&str> { + out.prompts + .iter() + .filter_map(|p| p.strip_prefix("local confirmation: ")) + .collect() +} + +#[tokio::test] +async fn failed_hello_delivery_is_retried_on_next_sync() { + let (a, b, relay) = devices().await; + let fault = common::fault_relay::FaultRelay::new(relay.clone()); + let a = Device { + name: a.name, + dir: a.dir, + keychain: a.keychain, + net: fault.clone(), + env: a.env, + }; + a.set("KEY", b"fake-hello").await; + fault + .fail_post + .store(true, std::sync::atomic::Ordering::SeqCst); + a.run(&["sync", "add", "KEY", "--peers", "bravo"], human(vec![])) + .await + .expect(6); + let peer = b.peers().find("alpha").unwrap().fingerprint.to_hex(); + let remote = a.peers().find("bravo").unwrap().fingerprint.to_hex(); + assert_eq!(state(&a)["peers"][&remote]["hello_sent"], false); + let (id, owner) = b.inbox_credentials(); + assert!( + relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .is_empty() + ); + a.run(&["sync"], Run::agent()).await.expect(8); + assert_eq!(state(&a)["peers"][&remote]["hello_sent"], true); + assert_eq!( + relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(), + 1 + ); + b.run(&["inbox"], Run::agent()).await.expect(0); + assert_eq!(state(&b)["peers"][peer]["capable"], true); +} + +#[tokio::test] +async fn corrupt_sync_state_does_not_break_get_or_exec() { + let a = Device::new("alpha", MemoryRelay::new()); + a.set("KEY", b"fake-independent").await; + std::fs::write(a.dir.path().join("sync.json"), b"broken json").unwrap(); + a.run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .expect(0); + a.run(&["exec", "--env", "KEY=KEY", "--", "true"], Run::agent()) + .await + .expect(0); + assert_eq!( + std::fs::read(a.dir.path().join("sync.json")).unwrap(), + b"broken json" + ); +} + +#[tokio::test] +async fn confirmation_reasons_name_actions_and_follow_selection() { + let a = Device::new("alpha", MemoryRelay::new()); + for name in ["a", "b", "c", "d", "e", "f", "g"] { + a.set(name, b"fake").await; + } + let mut denied = Run::human(vec![Answer::Multi(vec![0, 1, 2, 3, 4, 5, 6])]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + let out = a.run(&["sync", "add"], denied).await; + out.expect(5); + assert!(out.prompts[0].contains("Select sync items")); + assert_eq!(confirmations(&out), vec!["kc sync add a, b, c and 4 more"]); + assert!(!a.dir.path().join("sync.json").exists()); + let cases = [ + (vec!["sync", "rm", "a", "b"], "kc sync rm a, b"), + ( + vec!["sync", "peer", "add", "bravo"], + "kc sync peer add bravo", + ), + (vec!["sync", "peer", "rm", "bravo"], "kc sync peer rm bravo"), + ( + vec!["sync", "resolve", "a", "--keep", "mine"], + "Resolve a: keep mine", + ), + ( + vec!["sync", "restore-checkpoint", "a"], + "Restore a to its checkpoint", + ), + (vec!["sync", "unfreeze"], "Unfreeze sync"), + ( + vec!["sync", "status", "--confirm-checkpoint", "a"], + "Confirm the current value of a as its checkpoint", + ), + ]; + for (args, expected) in cases { + let out = a.run(&args, Run::human(vec![])).await; + out.expect(5); + assert_eq!(confirmations(&out), vec![expected]); + assert!(!a.dir.path().join("sync.json").exists()); + } +} + +#[tokio::test] +async fn review_accept_and_reject_share_one_confirmation_and_denial_changes_nothing() { + let (a, b, relay) = devices().await; + for name in ["A", "B"] { + post( + &a, + &b, + &relay, + offer_message(name, Vid::random(), b"fake-review", 0), + ) + .await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let mut denied = Run::human(vec![Answer::Select(0), Answer::Select(1)]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + let out = b.run(&["sync", "review"], denied).await; + out.expect(5); + assert_eq!(confirmations(&out).len(), 1); + assert!(confirmations(&out)[0].contains("from alpha; reject")); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + assert!(b.value("A").is_none() && b.value("B").is_none()); + assert!(state(&b)["items"].as_object().unwrap().is_empty()); + let out = b + .run( + &["sync", "review"], + human(vec![Answer::Select(0), Answer::Select(1)]), + ) + .await; + out.expect(0); + assert_eq!(confirmations(&out).len(), 1); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + assert_eq!(state(&b)["items"].as_object().unwrap().len(), 1); +} + +#[tokio::test] +async fn held_review_denied_and_agent_mutations_preserve_existing_state() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-denied").await; + pump(&a, &b).await; + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let mut denied = Run::human(vec![Answer::Select(0)]); + denied.local_auth.push_back(LocalAuthOutcome::Denied); + b.run(&["sync", "review"], denied).await.expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + for args in [ + vec!["sync", "resolve", "KEY", "--keep", "mine"], + vec!["sync", "restore-checkpoint", "KEY"], + vec!["sync", "rm", "KEY"], + ] { + b.run(&args, Run::agent()).await.expect(5); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + } + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); +} + +#[tokio::test] +async fn legacy_policies_hold_and_denial_continues_batch_then_one_l_replaces() { + for policy in [None, Some("skip"), Some("rename"), Some("overwrite")] { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store() + .set( + "KEY", + b"fake-legacy-batch", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.set("OTHER", b"fake-other").await; + a.run(&["send", "KEY", "OTHER", "--to", "bravo"], Run::agent()) + .await + .expect(0); + let mut args = vec!["inbox"]; + if let Some(p) = policy { + args.extend(["--on-conflict", p]); + } + let mut run = Run::human(vec![Answer::Yes]); + if policy == Some("overwrite") { + run.local_auth.push_back(LocalAuthOutcome::Denied); + } + let out = b.run(&args, run).await; + out.expect(if policy == Some("overwrite") { 5 } else { 8 }); + assert_eq!(b.value("OTHER").unwrap(), b"fake-other"); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + assert_eq!( + confirmations(&out).len(), + usize::from(policy == Some("overwrite")) + ); + assert!(b.value("KEY-2").is_none()); + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); + assert!(out.stderr.contains("run `kc sync review`")); + } + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store() + .set( + "KEY", + b"fake-inline", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.run(&["send", "KEY", "--to", "bravo"], Run::agent()) + .await + .expect(0); + let out = b + .run( + &["inbox", "--on-conflict", "overwrite"], + human(vec![Answer::Yes]), + ) + .await; + out.expect(0); + assert_eq!( + confirmations(&out), + vec!["Replace KEY with the value from alpha"] + ); + assert_eq!(b.value("KEY").unwrap(), b"fake-inline"); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); +} + +#[tokio::test] +async fn status_and_review_fingerprints_match_get_across_devices() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + let fp = a + .run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .stdout_text(); + for d in [&a, &b] { + let out = d.run(&["sync", "status", "--json"], Run::agent()).await; + let json: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(json["items"][0]["fingerprint"], fp.trim()); + } + a.set("KEY", b"fake-fingerprint-new").await; + pump(&a, &b).await; + let proposed = a + .run(&["get", "KEY", "--fingerprint"], Run::agent()) + .await + .stdout_text(); + let out = b.run(&["sync", "status", "--json"], Run::agent()).await; + let json: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(json["candidates"][0]["fingerprint"], proposed.trim()); + let out = b + .run(&["sync", "review"], Run::human(vec![Answer::Select(2)])) + .await; + assert!(out.prompts[0].contains(fp.trim())); + assert!(out.prompts[0].contains(proposed.trim())); +} + +#[tokio::test] +async fn offers_from_disabled_or_tripped_peers_are_logged_only() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + b.run(&["sync", "peer", "rm", "alpha"], human(vec![])) + .await + .expect(0); + post( + &a, + &b, + &relay, + offer_message("DISABLED", Vid::random(), b"fake-disabled", 0), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(0); + assert!(state(&b)["candidates"].as_object().unwrap().is_empty()); + b.run(&["sync", "peer", "add", "alpha"], human(vec![])) + .await + .expect(8); + // Peer rm removed KEY's scope. Restore it through the explicit add operation. + b.run(&["sync", "add", "KEY", "--peers", "alpha"], human(vec![])) + .await + .expect(8); + let parent = head(&b); + for _ in 0..6 { + let mut message = change_message("KEY", Vid::random(), parent, b"fake-trip"); + if let SyncMsg::Changes { changes } = &mut message { + changes[0].generation = 2; + } + post(&a, &b, &relay, message).await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let out = b.run(&["sync", "status", "--json"], Run::agent()).await; + let status: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(status["peers"][0]["breaker"], true); + let before = state(&b)["candidates"].clone(); + post( + &a, + &b, + &relay, + offer_message("BLOCKED", Vid::random(), b"fake-blocked", 0), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(state(&b)["candidates"], before); + assert!( + std::fs::read_to_string(b.dir.path().join("sync.log")) + .unwrap() + .contains("Ignored a sync offer") + ); +} + +#[tokio::test] +async fn offer_during_conflict_is_a_candidate_and_review_cannot_discard_it() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-conflict-a").await; + b.set("KEY", b"fake-conflict-b").await; + pump(&a, &b).await; + let before = state(&b)["candidates"].as_object().unwrap().len(); + let offered = Vid::random(); + post( + &a, + &b, + &relay, + offer_message("KEY", offered, b"fake-conflict-offer", 1), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(), before + 1); + assert!( + s["candidates"] + .as_object() + .unwrap() + .values() + .any( + |c| c["version"]["vid"] == serde_json::to_value(offered).unwrap() + && c["category"] == "conflict" + ) + ); + b.run(&["sync", "review"], Run::human(vec![])) + .await + .expect(8); + assert_eq!(state(&b)["candidates"], s["candidates"]); + assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); +} + +#[tokio::test] +async fn offer_during_conflict_at_another_generation_stays_a_proposal() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-conflict-a").await; + b.set("KEY", b"fake-conflict-b").await; + pump(&a, &b).await; + let offered = Vid::random(); + // Not stale (above the current generation) but not the registration in conflict either. + post( + &a, + &b, + &relay, + offer_message("KEY", offered, b"fake-conflict-offer", 2), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + let offer = s["candidates"] + .as_object() + .unwrap() + .values() + .find(|c| c["version"]["vid"] == serde_json::to_value(offered).unwrap()) + .expect("the offer is kept"); + assert_eq!(offer["category"], "proposal"); + // Accepting it would end the conflict and drop the other candidates; resolve must. + let candidates = s["candidates"].clone(); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(8); + let after = state(&b); + assert_eq!(after["candidates"], candidates); + assert_eq!(after["items"]["KEY"]["conflict"], true); + assert_eq!(b.value("KEY").unwrap(), b"fake-conflict-b"); +} + +#[tokio::test] +async fn sync_envelope_replay_is_skipped_by_seen_set() { + let (a, b, relay) = devices().await; + post( + &a, + &b, + &relay, + SyncMsg::Hello { + features: vec!["sync-phase1".into()], + is_reply: false, + }, + ) + .await; + let (id, owner) = b.inbox_credentials(); + let listed = relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap(); + let body = kc_proto::relay::message_body(&listed.messages[0]).unwrap(); + b.run(&["inbox"], Run::agent()).await.expect(0); + let (aid, aowner) = a.inbox_credentials(); + let replies = relay + .list_messages(&aid, &aowner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(); + relay + .post_message(&id, &a.writer_bearer("bravo"), &body) + .await + .unwrap(); + b.run(&["inbox"], Run::agent()).await.expect(7); + assert_eq!( + relay + .list_messages(&aid, &aowner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + .len(), + replies + ); +} + +#[tokio::test] +async fn convergence_binding_failure_quarantines_only_that_flow_and_rejects_ack() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let vid = Vid::random(); + // A valid stored record outside the bounded known list, with an incompatible fp. + b.store() + .set_internal( + &fp_slot("KEY", vid), + &serde_json::to_vec(&kc_sync::VidRecord { + fp: kc_sync::Fp([7; 32]), + parents: vec![], + }) + .unwrap(), + ) + .unwrap(); + let old_head = head(&b); + post( + &a, + &b, + &relay, + change_message("KEY", vid, old_head, b"fake-initial-secret"), + ) + .await; + post( + &a, + &b, + &relay, + offer_message("OTHER", Vid::random(), b"fake-next-message", 0), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!(head(&b), old_head); + assert!(state(&b)["peers"].as_object().unwrap().values().any(|p| { + p["quarantine"] + .as_array() + .unwrap() + .contains(&Value::String("KEY".into())) + })); + assert!( + state(&b)["candidates"] + .as_object() + .unwrap() + .values() + .any(|c| c["version"]["name"] == "OTHER") + ); + assert!( + state(&b)["receipts"] + .as_object() + .unwrap() + .values() + .any(|r| r[0] == "Rejected") + ); + let (id, owner) = a.inbox_credentials(); + let key = a.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let sender = a.peers().find("bravo").unwrap().device_pk; + let mut rejected = false; + for envelope in relay + .list_messages(&id, &owner, std::time::Duration::ZERO) + .await + .unwrap() + .messages + { + let bytes = kc_proto::relay::message_body(&envelope).unwrap(); + let opened = kc_proto::inbox::open_any( + &bytes, + &[&key], + |_| Some(sender), + |_| false, + kc_proto::inbox::unix_now(), + ) + .unwrap(); + if let kc_proto::inbox::Body::Sync(SyncMsg::Ack { results }) = opened.body { + rejected |= results.iter().any(|(id, result)| { + id.new_vid == vid && *result == kc_proto::sync::AckResult::Rejected + }); + } + } + assert!(rejected); +} + +#[tokio::test] +async fn offer_then_change_binds_parents_and_promotes_proposal_to_held() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let vid = Vid::random(); + post( + &a, + &b, + &relay, + offer_message("KEY", vid, b"fake-promoted", 1), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let parent = head(&b); + post( + &a, + &b, + &relay, + change_message("KEY", vid, parent, b"fake-promoted"), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let s = state(&b); + assert_eq!(s["candidates"].as_object().unwrap().len(), 1); + let c = s["candidates"] + .as_object() + .unwrap() + .values() + .next() + .unwrap(); + assert_eq!(c["category"], "held"); + assert_eq!( + c["version"]["parents"], + serde_json::to_value(vec![parent]).unwrap() + ); + assert_eq!(c["invalid_binding"], false); + assert!(s["unbound"].as_array().unwrap().is_empty()); + b.run(&["sync", "review"], human(vec![Answer::Select(0)])) + .await + .expect(0); + assert_eq!(b.value("KEY").unwrap(), b"fake-promoted"); +} + +#[tokio::test] +async fn stale_ack_revokes_grant_without_inventing_generation_or_revoking_newer_accept() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-stale-ack").await; + let vid = head(&a); + let stale = SyncMsg::Ack { + results: vec![( + kc_proto::sync::ChangeId { + name: ItemName::new("KEY").unwrap(), + generation: 1, + new_vid: vid, + }, + kc_proto::sync::AckResult::StaleGeneration, + )], + }; + // post helper sends A -> B, so construct the reverse envelope here. + let key = b.store().get_internal("device-key").unwrap().unwrap(); + let key = kc_proto::DeviceKeyPair::from_secret_bytes(key.as_bytes()).unwrap(); + let peer = b.peers().find("alpha").unwrap().clone(); + let sealed = kc_proto::inbox::seal_v2( + &key, + &peer.device_pk, + &kc_proto::inbox::Body::Sync(stale.clone()), + std::time::Duration::from_secs(86400), + kc_proto::inbox::unix_now(), + ) + .unwrap(); + relay + .post_message( + &a.inbox_credentials().0, + &b.writer_bearer("alpha"), + &sealed.body, + ) + .await + .unwrap(); + a.run(&["inbox"], Run::agent()).await.expect(8); + let peer_id = a.peers().find("bravo").unwrap().fingerprint.to_hex(); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], + false + ); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["generation"], + 1 + ); + a.set("KEY", b"fake-no-stale-send").await; + let s = state(&a); + let outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); + assert!( + outbox + .pending(&kc_sync::PeerId(peer_id.clone())) + .next() + .is_none() + ); + + // Recreate a pending old delivery with a newer accepted epoch to prove reordering safety. + let mut s = state(&a); + let mut outbox: kc_sync::Outbox = serde_json::from_value(s["outbox"].clone()).unwrap(); + outbox.enqueue( + kc_sync::PeerId(peer_id.clone()), + kc_sync::ChangeId { + name: "KEY".into(), + generation: 1, + new_vid: kc_sync::Vid(vid.0), + }, + ); + s["outbox"] = serde_json::to_value(outbox).unwrap(); + s["generations"]["remote"][&peer_id]["KEY"]["accepted"] = true.into(); + s["generations"]["remote"][&peer_id]["KEY"]["generation"] = 2.into(); + save_state(&a, &s); + let sealed = kc_proto::inbox::seal_v2( + &key, + &peer.device_pk, + &kc_proto::inbox::Body::Sync(stale), + std::time::Duration::from_secs(86400), + kc_proto::inbox::unix_now(), + ) + .unwrap(); + relay + .post_message( + &a.inbox_credentials().0, + &b.writer_bearer("alpha"), + &sealed.body, + ) + .await + .unwrap(); + a.run(&["inbox"], Run::agent()).await.expect(8); + assert_eq!( + state(&a)["generations"]["remote"][&peer_id]["KEY"]["accepted"], + true + ); +} + +#[tokio::test] +async fn candidate_eviction_collects_base_and_startup_collects_only_orphan_snapshots() { + let (a, b, relay) = devices().await; + for n in 0..16 { + post( + &a, + &b, + &relay, + offer_message(&format!("P{n}"), Vid::random(), b"fake-eviction", 0), + ) + .await; + } + b.run(&["inbox"], Run::agent()).await.expect(8); + let before = state(&b); + let base_slots = before["candidates"] + .as_object() + .unwrap() + .iter() + .map(|(slot, c)| (slot.clone(), c["base_record"].as_str().unwrap().to_owned())) + .collect::>(); + b.set("LOCAL", b"fake-local").await; + b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])) + .await + .expect(8); + let after = state(&b); + let evicted = base_slots + .iter() + .filter(|(slot, _)| after["candidates"].get(slot).is_none()) + .collect::>(); + assert_eq!(evicted.len(), 1); + for (slot, base) in evicted { + assert!(b.store().get_internal(slot).unwrap().is_none()); + assert!(b.store().get_internal(base).unwrap().is_none()); + } + let retained = after["slots"] + .as_object() + .unwrap() + .keys() + .find(|s| s.starts_with("sync/snapshot/")) + .unwrap() + .clone(); + let orphan = format!("sync/snapshot/{}", hex(&Vid::random().0)); + b.store().set_internal(&orphan, b"fake-orphan").unwrap(); + let mut injected = after; + injected["slots"][&orphan] = "ConflictCandidate".into(); + let queued_vid = Vid::random(); + let queued_slot = format!("sync/snapshot/{}", hex(&queued_vid.0)); + b.store() + .set_internal(&queued_slot, b"fake-queued") + .unwrap(); + injected["slots"][&queued_slot] = "ConflictCandidate".into(); + let mut outbox: kc_sync::Outbox = serde_json::from_value(injected["outbox"].clone()).unwrap(); + outbox.enqueue( + kc_sync::PeerId(b.peers().find("alpha").unwrap().fingerprint.to_hex()), + kc_sync::ChangeId { + name: "QUEUED".into(), + generation: 1, + new_vid: kc_sync::Vid(queued_vid.0), + }, + ); + injected["outbox"] = serde_json::to_value(outbox).unwrap(); + save_state(&b, &injected); + b.run(&["sync", "status", "--json"], Run::agent()) + .await + .expect(8); + assert!(b.store().get_internal(&orphan).unwrap().is_none()); + assert!(state(&b)["slots"].get(&orphan).is_none()); + assert!(b.store().get_internal(&retained).unwrap().is_some()); + assert!(state(&b)["slots"].get(&retained).is_some()); + assert!(b.store().get_internal(&queued_slot).unwrap().is_some()); + assert!(state(&b)["slots"].get(&queued_slot).is_some()); +} + +#[tokio::test] +async fn rejecting_proposal_deletes_binding_and_unbound_and_rm_releases_checkpoint() { + let (a, b, relay) = devices().await; + let vid = Vid::random(); + post( + &a, + &b, + &relay, + offer_message("PROPOSAL", vid, b"fake-proposal-gc", 0), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!( + b.store() + .get_internal(&fp_slot("PROPOSAL", vid)) + .unwrap() + .is_some() + ); + assert_eq!(state(&b)["unbound"].as_array().unwrap().len(), 1); + let before = std::fs::read(b.dir.path().join("sync.json")).unwrap(); + let out = b + .run(&["sync", "review"], Run::human(vec![Answer::Select(1)])) + .await; + out.expect(5); + assert_eq!(confirmations(&out).len(), 1); + assert_eq!( + std::fs::read(b.dir.path().join("sync.json")).unwrap(), + before + ); + let out = b + .run(&["sync", "review"], human(vec![Answer::Select(1)])) + .await; + out.expect(0); + assert_eq!(confirmations(&out).len(), 1); + assert!( + b.store() + .get_internal(&fp_slot("PROPOSAL", vid)) + .unwrap() + .is_none() + ); + assert!(state(&b)["unbound"].as_array().unwrap().is_empty()); + enroll(&a, &b).await; + b.run( + &["sync", "status", "--confirm-checkpoint", "KEY"], + human(vec![]), + ) + .await + .expect(0); + let checkpoint = state(&b)["slots"] + .as_object() + .unwrap() + .keys() + .find(|s| s.starts_with("sync/kg/")) + .unwrap() + .clone(); + assert!(b.store().get_internal(&checkpoint).unwrap().is_some()); + b.run(&["sync", "rm", "KEY"], human(vec![])).await.expect(0); + assert!(b.store().get_internal(&checkpoint).unwrap().is_none()); + assert!(state(&b)["slots"].get(&checkpoint).is_none()); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); +} + +#[tokio::test] +async fn full_capacity_scan_and_preserve_mine_leave_inbox_review_and_resolve_operational() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + // Pinned slots cannot be evicted. This isolates scan/preserve capacity failure + // from the lower-priority eviction path exercised above. + let mut s = state(&b); + for n in 0..16 { + let slot = format!("sync/kg/test-{n}"); + b.store().set_internal(&slot, b"fake-pinned").unwrap(); + s["slots"][slot] = "Checkpoint".into(); + } + save_state(&b, &s); + b.store() + .set( + "KEY", + b"fake-out-of-band", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + post( + &a, + &b, + &relay, + SyncMsg::Hello { + features: vec![], + is_reply: true, + }, + ) + .await; + let out = b.run(&["inbox"], Run::agent()).await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + let out = b.run(&["sync", "review"], Run::human(vec![])).await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + let status = b.run(&["sync", "status", "--json"], Run::agent()).await; + let status: Value = serde_json::from_slice(&status.stdout).unwrap(); + assert_eq!(status["capacity_blocked"], true); + assert!( + std::fs::read_to_string(b.dir.path().join("sync.log")) + .unwrap() + .contains("Sync storage is full") + ); + assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); + let out = b + .run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])) + .await; + out.expect(8); + assert!(!out.stderr.contains("Sync storage is full")); + assert_eq!(b.value("KEY").unwrap(), b"fake-out-of-band"); + // After capacity is freed, the same review/resolve path can recover normally. + let mut s = state(&b); + s["slots"] + .as_object_mut() + .unwrap() + .retain(|slot, _| !slot.starts_with("sync/kg/test-")); + save_state(&b, &s); + b.run(&["sync", "resolve", "KEY", "--keep", "mine"], human(vec![])) + .await + .expect(8); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], false); +} diff --git a/crates/kc-proto/src/inbox.rs b/crates/kc-proto/src/inbox.rs index 6d2ac71..987231f 100644 --- a/crates/kc-proto/src/inbox.rs +++ b/crates/kc-proto/src/inbox.rs @@ -26,9 +26,13 @@ use crate::device::{DeviceKem, DeviceKeyPair, DevicePublicKey, Fingerprint}; use crate::pad; use crate::payload::{self, Item, PayloadError}; use crate::rng; +use crate::sync::SyncMsg; /// `InboxEnvelope.v` and `InboxPlain.v`. pub const VERSION: u8 = 1; +/// The sync-capable inbox format. +pub const VERSION_V2: u8 = 2; +pub const INFO_PREFIX_V2: &[u8] = b"kc2 inbox"; /// `InboxEnvelope.suite`: DHKEM(X25519, HKDF-SHA256) + HKDF-SHA256 + ChaCha20-Poly1305. pub const SUITE: u16 = 1; pub const INFO_PREFIX: &[u8] = b"kc1 inbox"; @@ -190,8 +194,12 @@ fn header_aad(v: u8, suite: u16, sender_fp: &Fingerprint, recipient_fp: &Fingerp } fn info(sender_fp: &Fingerprint, recipient_fp: &Fingerprint) -> Vec { - let mut info = Vec::with_capacity(INFO_PREFIX.len() + 64); - info.extend_from_slice(INFO_PREFIX); + info_with_prefix(INFO_PREFIX, sender_fp, recipient_fp) +} + +fn info_with_prefix(prefix: &[u8], sender_fp: &Fingerprint, recipient_fp: &Fingerprint) -> Vec { + let mut info = Vec::with_capacity(prefix.len() + 64); + info.extend_from_slice(prefix); info.extend_from_slice(sender_fp.as_bytes()); info.extend_from_slice(recipient_fp.as_bytes()); info @@ -390,6 +398,232 @@ pub fn open( }) } +/// v2 content. Variant order is part of the wire contract. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Body { + Items(Vec), + Sync(SyncMsg), +} + +impl Body { + fn validate(&self) -> Result<(), InboxError> { + match self { + Self::Items(items) => { + payload::check_unique_names(items).map_err(InboxError::InvalidItems) + } + Self::Sync(msg) => msg.validate(), + } + } +} + +/// The encrypted v2 plaintext. Field order is the postcard wire order. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct InboxPlain2 { + pub v: u8, + pub msg_id: MessageId, + pub sender_fp: Fingerprint, + pub recipient_fp: Fingerprint, + pub created_at: i64, + pub expires_at: i64, + pub body: Body, +} + +#[derive(Serialize)] +struct InboxPlain2Ref<'a> { + v: u8, + msg_id: MessageId, + sender_fp: Fingerprint, + recipient_fp: Fingerprint, + created_at: i64, + expires_at: i64, + body: &'a Body, +} + +/// Seals a v2 body with the same TTL and time rules as [`seal`]. +pub fn seal_v2( + sender: &DeviceKeyPair, + recipient: &DevicePublicKey, + body: &Body, + ttl: Duration, + now: i64, +) -> Result { + seal_v2_with_rng( + sender, + recipient, + body, + ttl, + now, + MessageId(rng::array()), + &mut hpke::rand_core::UnwrapErr(getrandom::SysRng), + ) +} + +// The production path and golden vectors share this constructor. Only tests +// supply fixed message ids and ephemeral randomness; callers cannot do so. +fn seal_v2_with_rng( + sender: &DeviceKeyPair, + recipient: &DevicePublicKey, + body: &Body, + ttl: Duration, + now: i64, + msg_id: MessageId, + csprng: &mut impl hpke::rand_core::CryptoRng, +) -> Result { + let ttl = i64::try_from(ttl.as_secs()).map_err(|_| InboxError::InvalidTtl)?; + if !(1..=MAX_LIFETIME_SECS).contains(&ttl) { + return Err(InboxError::InvalidTtl); + } + let expires_at = now.checked_add(ttl).ok_or(InboxError::InvalidTtl)?; + body.validate()?; + let sender_fp = sender.fingerprint(); + let recipient_fp = recipient.fingerprint(); + let plain = InboxPlain2Ref { + v: VERSION_V2, + msg_id, + sender_fp, + recipient_fp, + created_at: now, + expires_at, + body, + }; + let mut buf = pad::encode(&plain, &[], TAG_LEN).map_err(|_| InboxError::Seal)?; + let mode = OpModeS::Auth((sender.kem_private().clone(), sender.public().kem_public())); + let (enc, tag) = hpke::single_shot_seal_inout_detached_with_rng::( + &mode, + &recipient.kem_public(), + &info_with_prefix(INFO_PREFIX_V2, &sender_fp, &recipient_fp), + (&mut buf[..]).into(), + &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), + csprng, + ) + .map_err(|_| InboxError::Seal)?; + buf.extend_from_slice(&tag.to_bytes()); + let envelope = InboxEnvelope { + v: VERSION_V2, + suite: SUITE, + sender_fp, + recipient_fp, + enc: enc.to_bytes().into(), + ct: std::mem::take(&mut *buf), + }; + let body = envelope.encode(); + if body.len() > MAX_MESSAGE_BYTES { + return Err(InboxError::TooLarge); + } + Ok(SealedMessage { + body, + msg_id, + created_at: now, + expires_at, + }) +} + +/// A v1 or v2 message that passed every check. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct OpenedAny { + pub msg_id: MessageId, + pub sender_fp: Fingerprint, + pub created_at: i64, + pub expires_at: i64, + pub body: Body, +} + +impl OpenedAny { + /// Keep `msg_id` in the seen-set at least until this time (Unix seconds). + pub fn keep_seen_until(&self) -> i64 { + self.expires_at.saturating_add(CLOCK_SKEW_SECS) + } +} + +/// Opens either inbox version; v1 items are returned as [`Body::Items`]. +/// Arguments have the same meaning as in [`open`]. +pub fn open_any( + body: &[u8], + own_keys: &[&DeviceKeyPair], + peer_key: impl Fn(&Fingerprint) -> Option, + seen: impl Fn(&MessageId) -> bool, + now: i64, +) -> Result { + if body.len() > MAX_MESSAGE_BYTES { + return Err(InboxError::TooLarge); + } + let envelope = InboxEnvelope::decode(body)?; + if envelope.v == VERSION { + let opened = open(body, own_keys, peer_key, seen, now)?; + return Ok(OpenedAny { + msg_id: opened.msg_id, + sender_fp: opened.sender_fp, + created_at: opened.created_at, + expires_at: opened.expires_at, + body: Body::Items(opened.items), + }); + } + if envelope.v != VERSION_V2 { + return Err(InboxError::UnsupportedVersion(envelope.v)); + } + if envelope.suite != SUITE { + return Err(InboxError::UnsupportedSuite(envelope.suite)); + } + let own = own_keys + .iter() + .find(|k| k.fingerprint() == envelope.recipient_fp) + .ok_or(InboxError::WrongRecipient)?; + let sender_pk = peer_key(&envelope.sender_fp) + .filter(|pk| pk.fingerprint() == envelope.sender_fp) + .ok_or(InboxError::UnknownSender)?; + let tag_at = envelope + .ct + .len() + .checked_sub(TAG_LEN) + .ok_or(InboxError::Malformed)?; + let (ciphertext, tag) = envelope.ct.split_at(tag_at); + let tag = AeadTag::::from_bytes(tag).map_err(|_| InboxError::Malformed)?; + let enc = EncappedKey::from_bytes(&envelope.enc).map_err(|_| InboxError::Malformed)?; + let mut buf = Zeroizing::new(ciphertext.to_vec()); + hpke::single_shot_open_inout_detached::( + &OpModeR::Auth(sender_pk.kem_public()), + own.kem_private(), + &enc, + &info_with_prefix(INFO_PREFIX_V2, &envelope.sender_fp, &envelope.recipient_fp), + (&mut buf[..]).into(), + &envelope.aad(), + &tag, + ) + .map_err(|_| InboxError::DecryptFailed)?; + let plain: InboxPlain2 = pad::decode(&buf).map_err(|_| InboxError::Malformed)?; + if plain.v != envelope.v { + return Err(InboxError::UnsupportedVersion(plain.v)); + } + if plain.sender_fp != envelope.sender_fp || plain.recipient_fp != envelope.recipient_fp { + return Err(InboxError::FingerprintMismatch); + } + let lifetime = plain.expires_at.checked_sub(plain.created_at); + if !lifetime.is_some_and(|l| (0..=MAX_LIFETIME_SECS).contains(&l)) { + return Err(InboxError::BadLifetime); + } + if now > plain.expires_at.saturating_add(CLOCK_SKEW_SECS) { + return Err(InboxError::Expired); + } + if plain.created_at > now.saturating_add(CLOCK_SKEW_SECS) { + return Err(InboxError::NotYetValid); + } + if seen(&plain.msg_id) { + return Err(InboxError::Replay); + } + plain.body.validate().map_err(|_| InboxError::Malformed)?; + Ok(OpenedAny { + msg_id: plain.msg_id, + sender_fp: plain.sender_fp, + created_at: plain.created_at, + expires_at: plain.expires_at, + body: plain.body, + }) +} + +#[cfg(test)] +#[path = "../tests/inbox_v2/mod.rs"] +mod v2_tests; + /// The current time in Unix seconds. pub fn unix_now() -> i64 { let secs = SystemTime::now() diff --git a/crates/kc-proto/src/lib.rs b/crates/kc-proto/src/lib.rs index bddf215..bf06a55 100644 --- a/crates/kc-proto/src/lib.rs +++ b/crates/kc-proto/src/lib.rs @@ -40,6 +40,7 @@ pub mod relay; mod rng; pub mod secret; pub mod session; +pub mod sync; pub mod words; #[cfg(any(test, feature = "test-util"))] diff --git a/crates/kc-proto/src/sync.rs b/crates/kc-proto/src/sync.rs new file mode 100644 index 0000000..c3cd188 --- /dev/null +++ b/crates/kc-proto/src/sync.rs @@ -0,0 +1,239 @@ +//! Sync messages carried by inbox v2 (design §5 and §12.1). +//! +//! Field and variant order is the postcard wire contract. Values use the +//! same zeroize-on-drop storage as `payload::Item`. + +use std::collections::HashSet; +use std::fmt; + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +use crate::inbox::{InboxError, MessageId}; +use crate::names::ItemName; +use crate::rng; +use crate::secret::SecretBytes; + +pub const MAX_LINEAGE: usize = 64; +pub const MAX_PARENTS: usize = 65; + +/// A random version identifier: raw 16 bytes in postcard, hex in JSON. +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Vid(pub [u8; 16]); + +impl Vid { + pub fn random() -> Self { + Self(rng::array()) + } +} + +impl fmt::Debug for Vid { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Vid({})", MessageId(self.0).to_hex()) + } +} + +impl Serialize for Vid { + fn serialize(&self, serializer: S) -> Result { + MessageId(self.0).serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for Vid { + fn deserialize>(deserializer: D) -> Result { + MessageId::deserialize(deserializer).map(|id| Self(id.0)) + } +} + +/// Value presentation, matching the store's Text/File meanings. v1 Item +/// has no kind field; sync carries it explicitly without changing v1. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ItemKind { + Text, + File, +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct ChangeId { + pub name: ItemName, + pub generation: u64, + pub new_vid: Vid, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Op { + Put { kind: ItemKind, value: SecretBytes }, + Retire, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Change { + pub name: ItemName, + pub generation: u64, + pub new_vid: Vid, + #[serde(deserialize_with = "deserialize_parents")] + pub parents: Vec, + #[serde(deserialize_with = "deserialize_lineage")] + pub lineage: Vec, + pub op: Op, + pub approval_ref: Option<[u8; 16]>, +} + +impl Change { + pub fn validate(&self) -> Result<(), InboxError> { + if self.lineage.len() > MAX_LINEAGE || self.parents.len() > MAX_PARENTS { + return Err(InboxError::Malformed); + } + Ok(()) + } +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum AckResult { + Applied, + Held, + Conflict, + StaleGeneration, + DeferredCapacity, + Rejected, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct DigestEntry { + pub name: ItemName, + pub generation: u64, + pub head: Vid, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum SyncMsg { + Hello { + features: Vec, + is_reply: bool, + }, + Offer { + name: ItemName, + /// The receiver's registration generation for `name` as the sender last learned it + /// from an `Accept` or `Leave` (0 = never). The receiver ignores an offer whose + /// value is below its current generation: it was sent before a `sync rm` (§2.1). + known_generation: u64, + vid: Vid, + #[serde(deserialize_with = "deserialize_lineage")] + lineage: Vec, + kind: ItemKind, + value: SecretBytes, + }, + Accept { + name: ItemName, + generation: u64, + }, + Leave { + name: ItemName, + generation: u64, + }, + Changes { + changes: Vec, + }, + Ack { + #[serde(deserialize_with = "deserialize_ack_results")] + results: Vec<(ChangeId, AckResult)>, + }, + Digest { + #[serde(deserialize_with = "deserialize_digest_entries")] + entries: Vec, + }, + Approvals { + docs: Vec>, + }, +} + +impl SyncMsg { + /// Checks in-memory messages too, before sealing or after opening. + pub fn validate(&self) -> Result<(), InboxError> { + match self { + Self::Offer { lineage, .. } if lineage.len() > MAX_LINEAGE => { + return Err(InboxError::Malformed); + } + Self::Changes { changes } => { + let mut names = HashSet::new(); + for change in changes { + change.validate()?; + if !names.insert(&change.name) { + return Err(InboxError::Malformed); + } + } + } + Self::Digest { entries } => { + let mut names = HashSet::new(); + if entries.iter().any(|entry| !names.insert(&entry.name)) { + return Err(InboxError::Malformed); + } + } + Self::Ack { results } => { + let mut ids = HashSet::new(); + if results.iter().any(|(id, _)| !ids.insert(id)) { + return Err(InboxError::Malformed); + } + } + _ => {} + } + Ok(()) + } +} + +fn deserialize_ack_results<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + let results = Vec::<(ChangeId, AckResult)>::deserialize(deserializer)?; + let mut ids = HashSet::new(); + if results.iter().any(|(id, _)| !ids.insert(id)) { + return Err(serde::de::Error::custom("duplicate ACK change_id")); + } + Ok(results) +} + +fn deserialize_digest_entries<'de, D: Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + let entries = Vec::::deserialize(deserializer)?; + let mut names = HashSet::new(); + if entries.iter().any(|entry| !names.insert(&entry.name)) { + return Err(serde::de::Error::custom("duplicate digest name")); + } + Ok(entries) +} + +// Bound allocation as well as the decoded number of version identifiers. +fn deserialize_lineage<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + deserialize_vids::(deserializer) +} + +fn deserialize_parents<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { + deserialize_vids::(deserializer) +} + +fn deserialize_vids<'de, D: Deserializer<'de>, const MAX: usize>( + deserializer: D, +) -> Result, D::Error> { + struct Vids; + impl<'de, const MAX: usize> serde::de::Visitor<'de> for Vids { + type Value = Vec; + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "at most {MAX} version identifiers") + } + fn visit_seq>(self, mut seq: A) -> Result, A::Error> { + if seq.size_hint().is_some_and(|n| n > MAX) { + return Err(serde::de::Error::custom("too many version identifiers")); + } + let mut out = Vec::with_capacity(seq.size_hint().unwrap_or(0).min(MAX)); + while let Some(vid) = seq.next_element()? { + if out.len() == MAX { + return Err(serde::de::Error::custom("too many version identifiers")); + } + out.push(vid); + } + Ok(out) + } + } + deserializer.deserialize_seq(Vids::) +} diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/README.md b/crates/kc-proto/tests/inbox_v2/fixtures/README.md new file mode 100644 index 0000000..9748a1d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/README.md @@ -0,0 +1,30 @@ +# Inbox v2 golden vectors + +Each `*.body.hex` file contains the postcard bytes of `Body`. Each matching +`*.envelope.hex` contains the complete postcard `InboxEnvelope`, including +HPKE ciphertext and tag. Hex is lowercase, with a trailing newline. + +Fixed inputs (synthetic, never production keys or secrets): + +- Sender X25519 private-key bytes: `11` repeated 32 times. +- Recipient X25519 private-key bytes: `22` repeated 32 times. +- HPKE ephemeral RNG output: `33` repeated 32 times (the IKM passed to + DHKEM's `DeriveKeyPair`, not a raw ephemeral private scalar). +- Message ID: `44` repeated 16 times. +- Created at: `1760000000`; TTL: `3600`; expires at: `1760003600`. +- Envelope and plaintext version: `2`; cipher suite: `1`. +- AAD: postcard `(2u8, 1u16, sender_fp, recipient_fp)`. +- Info: ASCII `kc2 inbox` followed by the two raw 32-byte fingerprints. +- Plaintext: 4-byte big-endian postcard length, postcard `InboxPlain2`, then + zeros to 4096 bytes; HPKE adds a 16-byte tag. + +The complete expected messages are declared in `../mod.rs::cases`. They cover +all eight SyncMsg discriminants, both Body and Op discriminants, both ItemKind +values, all six AckResult discriminants, and both approval_ref option cases. +`changes` contains both a Put and a Retire. The fixture files are read-only +inputs to tests; tests never rewrite them. + +`../mod.rs` is included as `inbox::v2_tests` by `src/inbox.rs` under `cfg(test)`. +This lets ordinary `cargo test -p kc-proto` exercise the production sealing +path with fixed randomness without exposing a deterministic production API +or requiring the test-util feature. diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex new file mode 100644 index 0000000..b93a2a8 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/accept.body.hex @@ -0,0 +1 @@ +010205746f6b656eac02 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex new file mode 100644 index 0000000..3850c2d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/accept.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex new file mode 100644 index 0000000..4cff008 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/ack.body.hex @@ -0,0 +1 @@ +01050605746f6b656e00000000000000000000000000000000000005746f6b656e01010101010101010101010101010101010105746f6b656e02020202020202020202020202020202020205746f6b656e03030303030303030303030303030303030305746f6b656e04040404040404040404040404040404040405746f6b656e050505050505050505050505050505050505 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex new file mode 100644 index 0000000..b2c3b3d --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/ack.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex new file mode 100644 index 0000000..1c07e1f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.body.hex @@ -0,0 +1 @@ +0107020301020300 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex new file mode 100644 index 0000000..b35b418 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/approvals.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex new file mode 100644 index 0000000..3805bd4 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/changes.body.hex @@ -0,0 +1 @@ +01040205746f6b656eac0255555555555555555555555555555555016666666666666666666666666666666602666666666666666666666666666666667777777777777777777777777777777700000b746573742d7365637265740188888888888888888888888888888888036f6c64029999999999999999999999999999999900000100 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex new file mode 100644 index 0000000..e894ad7 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/changes.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex new file mode 100644 index 0000000..effa48f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/digest.body.hex @@ -0,0 +1 @@ +01060105746f6b656eac0255555555555555555555555555555555 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex new file mode 100644 index 0000000..5312558 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/digest.envelope.hex @@ -0,0 +1 @@ +0201d19bf3f082782c87b783fe7134698aeff6e66d9f86afaf7cf9e9b8bf40bab3ff65cf5c9b1de5d41f758cb67f2d05f3e316a203fcb56351d9e3f158e02962c74da04588b74683334f6e7670db45cca1288fc2c1499d78715d9456f5d99261a82390206eecf82b6a1a2fd09db20629914f5b14eb406b70fcef91b1b16028a42f49a3cbb360c75aee5b45dffea9e6231478f1ab33e0772707caa5b7f633dc3efcb6b02323173c9104c8462248f097d28fe1c3b0ae09a956f7bfb67bd7893f8a2c80bac9d53119bf913fa06035faeb6101230a173694f6130283aa75265e08ccb41edaec46b17ebcb3adc2919589b60bb73def24a999cc0759adf4d9c775a456d9b5479587573b50a734211cd27150094fa09e7d537c3b812037a8ad6233032fa9e19f4e6684c7dad90ac0f1eab33ace6224bd90eda2a6750f81428d51f2357d20f43078ac988d98fd07969c4f2437796b42310efaab2732ccce851b8e8492208d265d561848aa51addac4782a0e5b8bba67ff00a68d2842267845891216e2261380ee761a6f7bdca8abd6bdad646ae6a49c9d25b4c5147137966b9ea7aa65da58ce08c3e30b5f531880dfb141d025bf0de2f09257b23ad7858414f4bf90cfe08ed4f35e806a1fad927cfd89887e98ef3dbfea5d485a391717b615ee155b3018f101a13c347115d9708c0f81ef7421303508839617f091b9d2727cf2029c86d495ef6b9d271af7d504bfbfa459c6d123cc2b2337c0ab850d0e240da5d1d71338dde1bcb446834b763b73243f65c2832d4ea1ffd8c8c7d8396afbe20def11b3e4ab7755545d16891b91e4a0f786d6364efe06d1adb18e8b4f69eb07d3d7ff03a288349703c98c758169c4933788e571b358dea214218e2e842a5f0113ef5fec867a874a50fbd9150bed757f21226067e3b27909b96dcc6c9c6aca1d8d275e1eee50380ab2a89ceabbedbfa02c1eedefc7bba061cd909108126bdff750b98096bda2d0fd2657f285d864acc8e0c79c34d75b5b179e051e64a843a6a57b3fac91e34cf257fa9398bf28680b788f0fd0f1d83b82c027391e6a3f71caccbfb43203e82884cbb3b6611dad627b407cfe60aa9594366662e9f8f7fd685b2dbe0f05f402b53c02651a21983576086df298bea12e2ea3fba81b495322c228effade35a026ddaf403d0fec95548125443b2d24504c3d2c5fcc40aedce0a8170aadd4a6f77c109aaf465f19f8e4f9e1a0ff3c60508cdce0e2f7a681b31deb96fccd93b3451832467fc1ce9fd57439a59d7821f0601d83edae298c0f1428daec95138e7fbc1670d1dd46288669061ebc8159b87dd12550cfd191f905054ec65e733fd26e1dbcfab16419134a5a001e98162134dbafaccf2bb0bc63d1aca8001e4d6894d8df96eb89da881532541800f21a05326ff5b712e9a2b02681988d4726b2b8124a1dcd1e3a03a2351f7211d837bea77c6fb4782231807445f6972e21d5a9bbdd3cbf45361faae3e1e906d94ca37f2e743b9a3d83ffbca7e8439ac7b7bcab0552a6bdfa68587ac3c16cbb8eb8b502321ab7d898c82e330e3b0220c920de62b409fd61bf70f3e3ae88f9d46d5e260c061488e7dbb7b068697f39052bfa9290d0cfe1e79e4aaa30bd6e8947bc1c8c07fc9ef245498cd84679a8517164f9c3a99ec8aefacdcc0f796566b22ad9cf71f8710a5c25d941f949c2e90499dcedc092f00987ab16af3d220f9e87282c3339d97469d57532fcafbc27988cab2601397d5eca6ba4178da5850def32a64a6e77322b32635f4a1a544756eefe12c827557870c3b8782a5813a0d3d250a9df1172e6b742ed93e9b3fadde0bf40806eec90e236f5ab02cfc71b4e1e3440a6ba5180e3ae30dc344fcf70151f41a8de9091c28fcedb1ef078c4430737efc2bd94ffc1a5258fe28567e27217491f4bea5302ccd1b5a59dd05507ed251b6149ed83a408100fc887cca389ebfeebde146884acc8ef336e513ecbce4aaa2e53476d58b8e98ba8d0508b20a954868d06c369abeb891c9f88e5bb95951fe1d47640bbb0e74e3df0e4d175c086a8abdd6ee95ea6ebc15836f0318653e91bc41f1785fc98aa746893302246d32c779b4237d4d28893280082f21759158a2a687eedcd25a18dc488ae663f8d488a5dd4f2e2b1cf30b28b31678fb16a5fda869de13311889d6bcb15988eff8e87e7f69af7125897f68444ab6cb42819c60904b3f9535b8676cf5011d97d054faac6d782bcc0d0253358c3ed1339aae657601c92a7e096f97efb864ce0d0fdd1194c28fb51bce44e58049f188751dd53038b1e6d1844c8c70e8b707d16627d20174cc1ba8ef7af4df56e098882989fbbd09d37138595b7936b1daee68f9f92048a05c955eeac6c4ecd09650345828c4fc84ff755ea9fc2220b328dcd499c6c8d204b836aa214019f437faf1aabe65fe358f01240122dc7dbdb5835a61779b83cd1c003d4cf6e765180345d1f87db40137baf6931f9aead057495b6cfe153fdc8ea4e7c961e136177349fdd5ae32137f220907791b41348a089040fcb2cd03216a9bc88b73eaae98e54ddcba8758f7ee495e82721ab205288a361045c9407b6d7479e9d1230e14d3111f0ee2b2353e02956f298a0d547b313e7ac945ec5125d63440b098d335c0e64b119f92e59ef61119058bb8cc270fd4fa04f1a756187a08bc129bfe24d9f9358f4fb7b3a6b3727b5caa0b68c049f4674954c894a59e2b13351cecf09903873320afb73314083d616db475fdba0a2b11c1bb6833056e73ee2faa00aedee502b1dd5f5b223a4ddb197f50c60d508f91291a0d97ddc6ed0fae1abc4f25b85ff8808ef872c7ded1987c4b9b5f840a9dcf971453bc5baacae18570146aa67e1e74b18e417884c810ff133c57dce6ea7524456e22ded3378df18c38e7705970d691c7ac8ad9d4d41a611c513aa1b09d3212c6fd99bb945b67ac3cd6ee45449a24bf6d87eaed19161e3c5ca0db9dc8d07bdb0e4f2aaa7ab3fda4ddece40b0a0bcc2ff78bf1fc8ef776a6e35751bfa8ba5ded3ba10d8827cec52dda82d5296f9df87833ee791b70826c1ce8e00f4d7ef13dedec30676757aa953efddf2d2d019654b1663d9b1d17a998a7c46365d7befd6bb3ab12bf9e7c5553211a429be7645bd04c9e77a12cd25df89c159636d3b3752421b30b55182a1ea5901f4dd48236729cfe5644a54e86ef1a9226facf74a8967d2d635ea789cfeb152d025e470bd15363222d859331fe9397de1e13c7e04b1c5c62a0956d3cd1333f32b3fc0adcb92c78f4306cb7d284ff3b7cd35b8517919958be8226f0ca4c63e349d8492ef8a418e453838937d58ef051f4752dd14d5ac71268f7f825de2c591d02c9bbb4b901b86f0425905d5d458ddad67d79bdac1692a0c4e403fbc8c36ac3ca46fd0bb5f69440b6ee139371d9be0ea1be3d87f86a4223f95489dd6c44f7d3815c010c071cc69df65f88a7b0edcfc7dc3296e56155dca8faed041506d00b46f6c4b91f5502046851e45ebccab4d064f8d94d3709881035698e0e281cb4b224d0887f6e4d4588a0f1ecf57fb9ae167b54c36e20863391c6c7e1b5de4f17fe53d5c926e78956d55601f1d0ae9f62ffa147c6566ebcbaf45ee1d0ab3926d62bfc4bd85a9b331b839610efadce593274353103de56caf9af947aaace8b14ae5042c147ddbadeea565f0ef1833dd996e40eae9d765c8f0b1bae8d60a5952c74bf9f269e875c8fba9e5ab662d893eb871fee0a2d60ca3fd839249869dac629487da9705c2623d64276a26fbebfbc28d603a0eee474fbbccd12f67d7e6a251af51227f17bcf8ab3a016cbfe43311baa588f8f0f711029aa62a4f1c7ca38b63e9e4045c5ef50fdd42216dd337611a6069da43513a773af58aca8e7cb3909a34c6cfd74802acc3e30a856f086638fb9e0c3418a842af45857595a9fd2296046dc4f9d65f9f1884de729de7ed1562c66fdc355492e7b8b5ab48a566c8fd1fab85b39056268e27282109f9dc85765224141e340824e7582118da5c949ba515bbdb9961b5b63e413d0616dbca7bf08a831e14dd9a1a31a8ac71d8ac96084eb644811c02cee855a4ac308dc86c968de21f1ba31682be521a5ff4898be7c5df750afe8ee0dc94286699e45ee5b59e35238ea0282a778ef1e16fe6ba37ff563bc2c47e7c67c66690667de188906d785159dae34dcba090376a862252498db3f432270c619fa317e0f7bccd6278644f80458771b334a2e98ad3cd53da99c0b3938a7fa1ef3a4a6dbcdd6a50aacdec1a6f78dfffe4b995f286f6b9563d3cca36ae2f1a77f21f4c452cdc060e930ab11c382eacd5bfbe97d4d7e5393506b0225dc65556a8d7bf5e88fb40677990e37dfd580309f457fb09f2845e811cb4337f4c2e787c63c50c0ddbf7a24e84a71daeb05d0317e402c06cfdc31033128fcbbc5d42f476e26e886d9e699c9cf7931986d82ed50d8b7919a1191a030de511f5cb8825e0aa02913729a594045e4ac4a9996dfb294c9d70062c574edc5086a05dd5105e47105721576ea8c8309f3a55c8e4f9d3e3e6b166e0336f16675d7674893f815d6a11845ef22300b12afcb6c6f066604ae2615c1f493a7967c4cbeb7af9744efd509c95b37ba23d9e0cc4e528557185509c88f7ba6ac2c7337aeb138251c3d2da24436ad1cdd8aa7ef9f9e2692c65ca3fd0db2679fd73a040213021150e5f0998fdedcd52ffbebb1b0d0d0ac8b3e85e8c158cd3102b292737d06b11e47fdbdced40d06ba48ddb89d2a0ededb3292e23211171275cee375159f7a2124527db04c89905764421cd52c8630132c1a0eab503e5ff9408bfa93be779cc0460464449362e2cc283114cc03dd77d000ced605a9c16b3ce1aa9984646471bfa777b6075855f782b90a2ea7dba5fbf131d95b005b9e847de06793b11670ea1c876ad3885056a9775ab3ae671c341e430a689681cab9a2a4cf1a6244382b667412c03d476d26787f932742579252684b8e7d87f67f9bd13400b0e208d8a400ee9e4684aa3c55aa25153b096ceedd595614b746c2586883aa6676b49a68d69389f726f69f348fdaee5190eed81a5ed35dc1f7b9f2cc8f111da38382eb33bdd5cf551c73b0306e81bbf36d532394359db5da7fbed9868ae497c90634832a6cb159dfdd8939c7b640fedf0f2cbe16101a6b820e636e366faf3d14ca47eac85aa7927f80227cb45ee3b37552acad66ca31b89de29faea2813ebad9a9138749aec2a2109426bcc40ca62c6df72cb01e7338d4e20550b09f3f77cc027253e74462519e9740c9f10b99d37bd78b07680b30753bc3a042edc54e99a58eb0c894558aeb6767c114d280cf4679a0284a02c12c905558573201c699b8d0c673ecee542e8b68c9c5349862db3076b325d7b3a5ebdc043cd47f06d3a5023c54358d5b40d13568aef034834b666becc58a148e7e928320ca28784e636d1158d528f808dcc32a88eca8f88498993086329183109fdcf3c0d3d88b17a5f67a09139a48ea6a58f45d4a1ed243cd5f52d796dc354d117ee1280e7cda6a0be7eea63d5cf4edf24da3fe6c2ef127aaee7d30e93d343975d57828f2f6055b15c37bbe0268ea7a756146d19074d1af0311e437d511af17ae59a3876b6d6cd0a5b6162d6455aa5cbc096e559cd1404990622237987f85d33ecded64d76493b382dcfc9c46a79862f2c9bfc04c5eb0fab092a5bfe944af524e55af838d1e43c6dad58681de611079f84e5f397811e335540bfb99329f8c33dbc4739971eb6e98f1b915234885754cae52b42addc5ed899f5d08a8f8c2caf9c6676d39d5e72efaadd61a762d6f20bd03237f82e11e62a70b716897283362a03eff71bee50107debeacdaa91c6d575d30a2b30ecf728e8a5454a3994f70206eb4786ad4e025ad209c9e379ea05af687b96fcf7be42213b21189d6e2708d60c827e90012126392f diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex new file mode 100644 index 0000000..2e5ff50 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/hello.body.hex @@ -0,0 +1 @@ +0100010773796e632d763100 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex new file mode 100644 index 0000000..6cb6c0f --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/hello.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex new file mode 100644 index 0000000..21aa8de --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/items.body.hex @@ -0,0 +1 @@ +000105746f6b656e0b746573742d736563726574ecdfbb8e0d diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex new file mode 100644 index 0000000..5156311 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/items.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex new file mode 100644 index 0000000..4d61241 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/leave.body.hex @@ -0,0 +1 @@ +010305746f6b656eac02 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex new file mode 100644 index 0000000..ce21799 --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/leave.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex new file mode 100644 index 0000000..934114b --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.body.hex @@ -0,0 +1 @@ +01010a636f6e6669672e656e76035555555555555555555555555555555501666666666666666666666666666666660107544553543d310a diff --git a/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex new file mode 100644 index 0000000..f224ddb --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/fixtures/offer.envelope.hex @@ -0,0 +1 @@ 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 diff --git a/crates/kc-proto/tests/inbox_v2/mod.rs b/crates/kc-proto/tests/inbox_v2/mod.rs new file mode 100644 index 0000000..d6910aa --- /dev/null +++ b/crates/kc-proto/tests/inbox_v2/mod.rs @@ -0,0 +1,657 @@ +//! Compiled as an inbox unit-test module so fixed HPKE randomness never +//! becomes a production API. All values below are synthetic test secrets. +use super::*; +use crate::names::ItemName; +use crate::secret::SecretBytes; +use crate::sync::{AckResult, Change, ChangeId, DigestEntry, ItemKind, Op, SyncMsg, Vid}; + +const NOW: i64 = 1_760_000_000; +const TTL: Duration = Duration::from_secs(3600); +const ID: MessageId = MessageId([0x44; 16]); + +struct FixedRng; +impl hpke::rand_core::TryRng for FixedRng { + type Error = std::convert::Infallible; + fn try_next_u32(&mut self) -> Result { + panic!("unexpected RNG call") + } + fn try_next_u64(&mut self) -> Result { + panic!("unexpected RNG call") + } + fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> { + assert_eq!(dst.len(), 32); + dst.fill(0x33); + Ok(()) + } +} +impl hpke::rand_core::TryCryptoRng for FixedRng {} + +fn keys() -> (DeviceKeyPair, DeviceKeyPair) { + ( + DeviceKeyPair::from_secret_bytes(&[0x11; 32]).unwrap(), + DeviceKeyPair::from_secret_bytes(&[0x22; 32]).unwrap(), + ) +} +fn name(s: &str) -> ItemName { + ItemName::new(s).unwrap() +} +fn item() -> Item { + Item { + name: name("token"), + value: SecretBytes::from_slice(b"test-secret"), + updated_at: NOW - 10, + } +} +fn hello() -> Body { + Body::Sync(SyncMsg::Hello { + features: vec!["sync-v1".into()], + is_reply: false, + }) +} +fn change() -> Change { + Change { + name: name("token"), + generation: 300, + new_vid: Vid([0x55; 16]), + parents: vec![Vid([0x66; 16])], + lineage: vec![Vid([0x66; 16]), Vid([0x77; 16])], + op: Op::Put { + kind: ItemKind::Text, + value: SecretBytes::from_slice(b"test-secret"), + }, + approval_ref: Some([0x88; 16]), + } +} +fn cases() -> Vec<(&'static str, Body)> { + vec![ + ("hello", hello()), + ( + "offer", + Body::Sync(SyncMsg::Offer { + name: name("config.env"), + known_generation: 3, + vid: Vid([0x55; 16]), + lineage: vec![Vid([0x66; 16])], + kind: ItemKind::File, + value: SecretBytes::from_slice(b"TEST=1\n"), + }), + ), + ( + "changes", + Body::Sync(SyncMsg::Changes { + changes: vec![ + change(), + Change { + name: name("old"), + generation: 2, + new_vid: Vid([0x99; 16]), + parents: vec![], + lineage: vec![], + op: Op::Retire, + approval_ref: None, + }, + ], + }), + ), + ( + "ack", + Body::Sync(SyncMsg::Ack { + results: [ + AckResult::Applied, + AckResult::Held, + AckResult::Conflict, + AckResult::StaleGeneration, + AckResult::DeferredCapacity, + AckResult::Rejected, + ] + .into_iter() + .enumerate() + .map(|(i, result)| { + ( + ChangeId { + name: name("token"), + generation: i as u64, + new_vid: Vid([i as u8; 16]), + }, + result, + ) + }) + .collect(), + }), + ), + ( + "digest", + Body::Sync(SyncMsg::Digest { + entries: vec![DigestEntry { + name: name("token"), + generation: 300, + head: Vid([0x55; 16]), + }], + }), + ), + ("items", Body::Items(vec![item()])), + ( + "accept", + Body::Sync(SyncMsg::Accept { + name: name("token"), + generation: 300, + }), + ), + ( + "leave", + Body::Sync(SyncMsg::Leave { + name: name("token"), + generation: 300, + }), + ), + ( + "approvals", + Body::Sync(SyncMsg::Approvals { + docs: vec![vec![1, 2, 3], vec![]], + }), + ), + ] +} +fn bob_opens(bytes: &[u8], now: i64) -> Result { + let (alice, bob) = keys(); + open_any( + bytes, + &[&bob], + |fp| (*fp == alice.fingerprint()).then_some(*alice.public()), + |_| false, + now, + ) +} +fn plain(body: Body) -> InboxPlain2 { + let (alice, bob) = keys(); + InboxPlain2 { + v: VERSION_V2, + msg_id: ID, + sender_fp: alice.fingerprint(), + recipient_fp: bob.fingerprint(), + created_at: NOW, + expires_at: NOW + 3600, + body, + } +} +// Intentionally bypass sender validation for adversarial authenticated messages. +fn seal_plain(p: &InboxPlain2, prefix: &[u8]) -> Vec { + let (alice, bob) = keys(); + let (sender_fp, recipient_fp) = (alice.fingerprint(), bob.fingerprint()); + let mut buf = pad::encode(p, &[], TAG_LEN).unwrap(); + let (enc, tag) = hpke::single_shot_seal_inout_detached_with_rng::( + &OpModeS::Auth((alice.kem_private().clone(), alice.public().kem_public())), + &bob.public().kem_public(), + &info_with_prefix(prefix, &sender_fp, &recipient_fp), + (&mut buf[..]).into(), + &header_aad(VERSION_V2, SUITE, &sender_fp, &recipient_fp), + &mut FixedRng, + ) + .unwrap(); + buf.extend_from_slice(&tag.to_bytes()); + InboxEnvelope { + v: VERSION_V2, + suite: SUITE, + sender_fp, + recipient_fp, + enc: enc.to_bytes().into(), + ct: std::mem::take(&mut *buf), + } + .encode() +} +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|b| format!("{b:02x}")).collect() +} +fn unhex(s: &str) -> Vec { + let s: String = s.split_whitespace().collect(); + assert_eq!(s.len() % 2, 0); + s.as_bytes() + .chunks(2) + .map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap(), 16).unwrap()) + .collect() +} +fn fixture(label: &str, suffix: &str) -> String { + std::fs::read_to_string(format!( + "{}/tests/inbox_v2/fixtures/{label}.{suffix}.hex", + env!("CARGO_MANIFEST_DIR") + )) + .unwrap() +} + +#[test] +fn golden_vectors_encode_and_open() { + let (alice, bob) = keys(); + for (label, body) in cases() { + let sealed = + seal_v2_with_rng(&alice, bob.public(), &body, TTL, NOW, ID, &mut FixedRng).unwrap(); + let encoded_body = postcard::to_allocvec(&body).unwrap(); + assert_eq!( + hex(&encoded_body), + fixture(label, "body").trim(), + "{label} body" + ); + let expected = unhex(&fixture(label, "envelope")); + assert_eq!(sealed.body, expected, "{label} envelope"); + assert_eq!( + sealed.body, + seal_plain(&plain(body.clone()), INFO_PREFIX_V2), + "borrowed encoding" + ); + let opened = bob_opens(&expected, NOW).unwrap(); + assert_eq!( + opened, + OpenedAny { + msg_id: ID, + sender_fp: alice.fingerprint(), + created_at: NOW, + expires_at: NOW + 3600, + body + } + ); + assert_eq!(opened.keep_seen_until(), NOW + 3600 + CLOCK_SKEW_SECS); + } +} + +#[test] +fn public_seal_v2_round_trips_all_bodies() { + let (alice, bob) = keys(); + for (label, body) in cases() { + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap(); + let opened = bob_opens(&sealed.body, NOW).unwrap(); + assert_eq!(opened.body, body, "{label}"); + assert_eq!(opened.msg_id, sealed.msg_id); + assert_eq!(opened.sender_fp, alice.fingerprint()); + assert_eq!((opened.created_at, opened.expires_at), (NOW, NOW + 3600)); + } +} + +#[test] +fn v1_open_rejects_v2_before_decryption() { + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &hello(), TTL, NOW).unwrap(); + let mut envelope = InboxEnvelope::decode(&sealed.body).unwrap(); + assert_eq!(envelope.v, 2); + for body in [sealed.body, { + envelope.ct.clear(); + envelope.encode() + }] { + assert_eq!( + open( + &body, + &[], + |_| panic!("peer lookup before version check"), + |_| panic!("seen lookup before version check"), + NOW + ) + .unwrap_err(), + InboxError::UnsupportedVersion(2) + ); + } +} + +#[test] +fn open_any_maps_v1_to_items() { + let (alice, bob) = keys(); + let sealed = seal(&alice, bob.public(), &[item()], TTL, NOW).unwrap(); + let opened = bob_opens(&sealed.body, NOW).unwrap(); + assert_eq!(opened.body, Body::Items(vec![item()])); + assert_eq!(opened.msg_id, sealed.msg_id); + assert_eq!(opened.sender_fp, alice.fingerprint()); + assert_eq!((opened.created_at, opened.expires_at), (NOW, NOW + 3600)); +} + +#[test] +fn v2_rejects_inner_v1() { + let mut p = plain(hello()); + p.v = 1; + assert_eq!( + bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::UnsupportedVersion(1) + ); +} + +#[test] +fn v2_rejects_v1_info() { + assert_eq!( + bob_opens(&seal_plain(&plain(hello()), INFO_PREFIX), NOW).unwrap_err(), + InboxError::DecryptFailed + ); +} + +#[test] +fn lineage_limit_on_decode_validate_and_open() { + for n in [0, 64, 65] { + let mut c = change(); + c.lineage = vec![Vid([7; 16]); n]; + let bytes = postcard::to_allocvec(&c).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 64); + let json = serde_json::to_string(&c).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 64); + assert_eq!(c.validate().is_ok(), n <= 64); + let body = Body::Sync(SyncMsg::Changes { changes: vec![c] }); + let result = bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW); + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW); + if n <= 64 { + assert!(result.is_ok()); + assert!(sealed.is_ok()); + } else { + assert_eq!(result.unwrap_err(), InboxError::Malformed); + assert_eq!(sealed.unwrap_err(), InboxError::Malformed); + } + } +} + +#[test] +fn duplicate_change_and_item_names_are_malformed() { + let mut other = change(); + other.generation += 1; + other.new_vid = Vid([0xaa; 16]); + for body in [ + Body::Sync(SyncMsg::Changes { + changes: vec![change(), other], + }), + Body::Items(vec![item(), item()]), + ] { + assert_eq!( + bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::Malformed + ); + let (alice, bob) = keys(); + assert!(seal_v2(&alice, bob.public(), &body, TTL, NOW).is_err()); + } +} + +#[test] +fn v2_lifetime_skew_and_replay_checks() { + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + assert!(bob_opens(&bytes, NOW - CLOCK_SKEW_SECS).is_ok()); + assert!(bob_opens(&bytes, NOW + 3600 + CLOCK_SKEW_SECS).is_ok()); + assert_eq!( + bob_opens(&bytes, NOW - CLOCK_SKEW_SECS - 1).unwrap_err(), + InboxError::NotYetValid + ); + assert_eq!( + bob_opens(&bytes, NOW + 3601 + CLOCK_SKEW_SECS).unwrap_err(), + InboxError::Expired + ); + for (created, expires, ok) in [ + (NOW, NOW, true), + (NOW, NOW + MAX_LIFETIME_SECS, true), + (NOW, NOW - 1, false), + (NOW, NOW + MAX_LIFETIME_SECS + 1, false), + (i64::MIN, i64::MAX, false), + ] { + let mut p = plain(hello()); + p.created_at = created; + p.expires_at = expires; + let result = bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW); + if ok { + assert!(result.is_ok()); + } else { + assert_eq!(result.unwrap_err(), InboxError::BadLifetime); + } + } + let (alice, bob) = keys(); + assert_eq!( + open_any( + &bytes, + &[&bob], + |_| Some(*alice.public()), + |id| { + assert_eq!(*id, ID); + true + }, + NOW + ) + .unwrap_err(), + InboxError::Replay + ); + for (ttl, now) in [ + (Duration::ZERO, NOW), + (Duration::from_secs(MAX_LIFETIME_SECS as u64 + 1), NOW), + (TTL, i64::MAX), + ] { + assert_eq!( + seal_v2(&alice, bob.public(), &hello(), ttl, now).unwrap_err(), + InboxError::InvalidTtl + ); + } +} + +#[test] +fn v2_fingerprint_and_authentication_checks() { + let (alice, bob) = keys(); + for sender in [true, false] { + let mut p = plain(hello()); + if sender { + p.sender_fp = bob.fingerprint(); + } else { + p.recipient_fp = alice.fingerprint(); + } + assert_eq!( + bob_opens(&seal_plain(&p, INFO_PREFIX_V2), NOW).unwrap_err(), + InboxError::FingerprintMismatch + ); + } + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + assert_eq!( + open_any(&bytes, &[&alice], |_| Some(*alice.public()), |_| false, NOW).unwrap_err(), + InboxError::WrongRecipient + ); + for pk in [None, Some(*bob.public())] { + assert_eq!( + open_any(&bytes, &[&bob], |_| pk, |_| false, NOW).unwrap_err(), + InboxError::UnknownSender + ); + } + assert!( + open_any( + &bytes, + &[&alice, &bob], + |_| Some(*alice.public()), + |_| false, + NOW + ) + .is_ok() + ); + for field in 0..3 { + let mut env = InboxEnvelope::decode(&bytes).unwrap(); + match field { + 0 => env.enc[0] ^= 1, + 1 => env.ct[0] ^= 1, + _ => *env.ct.last_mut().unwrap() ^= 1, + } + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::DecryptFailed + ); + } +} + +#[test] +fn v2_size_and_envelope_checks() { + let (alice, bob) = keys(); + let body = Body::Sync(SyncMsg::Offer { + name: name("large"), + known_generation: 0, + vid: Vid([1; 16]), + lineage: vec![], + kind: ItemKind::File, + value: SecretBytes::from_slice(&vec![0; MAX_MESSAGE_BYTES]), + }); + assert_eq!( + seal_v2(&alice, bob.public(), &body, TTL, NOW).unwrap_err(), + InboxError::TooLarge + ); + assert_eq!( + bob_opens(&vec![0; MAX_MESSAGE_BYTES + 1], NOW).unwrap_err(), + InboxError::TooLarge + ); + let bytes = seal_plain(&plain(hello()), INFO_PREFIX_V2); + let mut env = InboxEnvelope::decode(&bytes).unwrap(); + env.v = 3; + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::UnsupportedVersion(3) + ); + env.v = 2; + env.suite = 2; + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::UnsupportedSuite(2) + ); + env.suite = 1; + env.ct.truncate(15); + assert_eq!( + bob_opens(&env.encode(), NOW).unwrap_err(), + InboxError::Malformed + ); + let mut trailing = bytes.clone(); + trailing.push(0); + for bad in [vec![], bytes[..bytes.len() - 1].to_vec(), trailing] { + assert_eq!(bob_opens(&bad, NOW).unwrap_err(), InboxError::Malformed); + } +} + +#[test] +fn vid_serde_and_secret_debug() { + let vid = Vid([0xab; 16]); + assert_eq!(postcard::to_allocvec(&vid).unwrap(), vec![0xab; 16]); + let json = format!("\"{}\"", "ab".repeat(16)); + assert_eq!(serde_json::to_string(&vid).unwrap(), json); + assert_eq!(serde_json::from_str::(&json).unwrap(), vid); + assert_eq!( + serde_json::from_str::(&json.to_uppercase()).unwrap(), + vid + ); + for bad in ["\"00\"", "\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\"", "[]"] { + assert!(serde_json::from_str::(bad).is_err()); + } + let random = Vid::random(); + assert_eq!( + postcard::from_bytes::(&postcard::to_allocvec(&random).unwrap()).unwrap(), + random + ); + for (_, body) in cases() { + let debug = format!("{body:?}"); + assert!(!debug.contains("test-secret")); + assert!(!debug.contains("TEST=1")); + } +} + +fn assert_sync_validation(msg: SyncMsg, valid: bool) { + let bytes = postcard::to_allocvec(&msg).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), valid); + let json = serde_json::to_string(&msg).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), valid); + assert_eq!(msg.validate().is_ok(), valid); + if !valid { + assert_eq!(msg.validate().unwrap_err(), InboxError::Malformed); + } + let body = Body::Sync(msg); + let opened = bob_opens(&seal_plain(&plain(body.clone()), INFO_PREFIX_V2), NOW); + let (alice, bob) = keys(); + let sealed = seal_v2(&alice, bob.public(), &body, TTL, NOW); + if valid { + assert!(opened.is_ok()); + assert!(sealed.is_ok()); + } else { + assert_eq!(opened.unwrap_err(), InboxError::Malformed); + assert_eq!(sealed.unwrap_err(), InboxError::Malformed); + } +} + +#[test] +fn offer_lineage_limit_on_decode_validate_seal_and_open() { + for n in [0, 64, 65] { + let msg = SyncMsg::Offer { + name: name("token"), + known_generation: 0, + vid: Vid([1; 16]), + lineage: vec![Vid([7; 16]); n], + kind: ItemKind::Text, + value: SecretBytes::from_slice(b"test-secret"), + }; + let bytes = postcard::to_allocvec(&msg).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 64); + let json = serde_json::to_string(&msg).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 64); + assert_sync_validation(msg, n <= 64); + } +} + +#[test] +fn change_parents_limit_on_decode_validate_seal_and_open() { + for n in [0, 64, 65, 66] { + let mut c = change(); + c.parents = vec![Vid([7; 16]); n]; + let bytes = postcard::to_allocvec(&c).unwrap(); + assert_eq!(postcard::from_bytes::(&bytes).is_ok(), n <= 65); + let json = serde_json::to_string(&c).unwrap(); + assert_eq!(serde_json::from_str::(&json).is_ok(), n <= 65); + assert_eq!(c.validate().is_ok(), n <= 65); + assert_sync_validation(SyncMsg::Changes { changes: vec![c] }, n <= 65); + } +} + +#[test] +fn duplicate_digest_names_are_malformed() { + let entry = DigestEntry { + name: name("token"), + generation: 1, + head: Vid([1; 16]), + }; + for same_metadata in [true, false] { + let mut other = entry.clone(); + if !same_metadata { + other.generation += 1; + other.head = Vid([2; 16]); + } + assert_sync_validation( + SyncMsg::Digest { + entries: vec![entry.clone(), other], + }, + false, + ); + } + let mut other = entry.clone(); + other.name = name("other"); + assert_sync_validation( + SyncMsg::Digest { + entries: vec![entry, other], + }, + true, + ); +} + +#[test] +fn duplicate_ack_change_ids_are_malformed() { + let id = ChangeId { + name: name("token"), + generation: 1, + new_vid: Vid([1; 16]), + }; + for result in [AckResult::Applied, AckResult::Rejected] { + assert_sync_validation( + SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (id.clone(), result)], + }, + false, + ); + } + for field in 0..3 { + let mut other = id.clone(); + match field { + 0 => other.name = name("other"), + 1 => other.generation += 1, + _ => other.new_vid = Vid([2; 16]), + } + assert_sync_validation( + SyncMsg::Ack { + results: vec![(id.clone(), AckResult::Applied), (other, AckResult::Held)], + }, + true, + ); + } +} diff --git a/crates/kc-relay/Cargo.toml b/crates/kc-relay/Cargo.toml index 35799d3..f457375 100644 --- a/crates/kc-relay/Cargo.toml +++ b/crates/kc-relay/Cargo.toml @@ -45,6 +45,6 @@ ipnet = "2" humantime = "2" [dev-dependencies] -kc-relay = { path = ".", version = "0.2.0", features = ["test-util"] } +kc-relay = { path = ".", version = "0.3.0", features = ["test-util"] } tower = { version = "0.5", features = ["util"] } tokio = { workspace = true, features = ["test-util", "io-util"] } diff --git a/crates/kc-sync/Cargo.toml b/crates/kc-sync/Cargo.toml new file mode 100644 index 0000000..c34a878 --- /dev/null +++ b/crates/kc-sync/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "kc-sync" +description = "Pure sync decisions, retention, limits, and journal recovery" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +repository.workspace = true +homepage.workspace = true +authors.workspace = true +publish = false + +[dependencies] +serde.workspace = true +thiserror.workspace = true + +[dev-dependencies] +rand.workspace = true +serde_json.workspace = true diff --git a/crates/kc-sync/src/decision.rs b/crates/kc-sync/src/decision.rs new file mode 100644 index 0000000..18cdfaf --- /dev/null +++ b/crates/kc-sync/src/decision.rs @@ -0,0 +1,276 @@ +use crate::{ConflictSet, Fp, Incoming, ItemState, Lineage, Vid, VidRecord}; +use serde::{Deserialize, Serialize}; + +/// ACK discriminant order is the frozen sync contract (§12.3). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum AckResult { + /// Durable application, convergence, or already-seen version (§12.5). + Applied, + /// Durably retained for human review (§12.3). + Held, + /// Durably retained as a conflict (§2.4). + Conflict, + /// Receiver generation does not match (§12.2). + StaleGeneration, + /// Not retained; sender must retry and keep its snapshot (§12.3). + DeferredCapacity, + /// Rejected, including immutable-vid violations (§12.5). + Rejected, +} + +impl AckResult { + /// Only capacity deferral is non-final (§12.3). + pub fn is_final(self) -> bool { + self != Self::DeferredCapacity + } +} + +/// Evidence supplied only by an external approval verifier; Phase 1 always uses `None` (§12.5). +#[derive(Debug)] +pub struct VerifiedApproval { + _private: (), +} + +impl VerifiedApproval { + /// Test-only escape hatch; never call in production Phase 1 code (§12.5). + #[doc(hidden)] + pub fn for_tests() -> Self { + Self { _private: () } + } +} + +/// Human-review reason in decision precedence order (§12.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum HoldReason { + /// Receiver or peer is frozen (§4, §12.5). + Frozen, + /// No verified approval authorizes the operation (§12.5). + NoApproval, + /// Rate or checkpoint capacity prevents application (§4, §12.3). + OverLimit, + /// Complete Phase-1 resolve requires review (§2.4, §12.5). + Resolve, + /// Retire does not directly name the current head (§2.5). + RetireMismatch, +} + +/// Side-effect-free state intent; persistence and slot allocation precede ACK (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum Transition { + /// Preserve state for stale, rejected, duplicate, or capacity-deferred messages (§12.5). + Unchanged, + /// Preserve the incoming value in a held slot (§12.3). + Hold { + /// Why human review is required (§12.5). + reason: HoldReason, + }, + /// Retain the complete unresolved candidate set without overwriting (§2.4). + Conflict { + /// Includes the receiver's current head and the incoming Put, if any (§2.4). + candidates: ConflictSet, + }, + /// Update version metadata, optionally writing the incoming value (§2.2, §12.4). + Advance { + /// Deterministic resulting head (§2.2). + head: Vid, + /// Merged ancestry with the resulting head retained (§2.4). + lineage: Lineage, + /// False for same-value convergence (§2.2). + write_value: bool, + /// Clear all candidates only after a complete approved resolve (§2.4). + clear_conflict: bool, + }, + /// Remove registration only; caller retains the keychain value (§2.5, §12.2). + Retire, +} + +/// Ordered decision and required ACK; caller must commit before sending it (§12.4, §12.5). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Decision { + /// Result to ACK after durable handling (§12.3). + pub ack: AckResult, + /// Resulting state intent (§12.5). + pub transition: Transition, + /// Quarantine this peer's stream for this item on immutable-vid violation (§2.2). + pub quarantine: bool, +} + +impl Decision { + pub(crate) fn held(reason: HoldReason) -> Self { + Self { + ack: AckResult::Held, + transition: Transition::Hold { reason }, + quarantine: false, + } + } + + pub(crate) fn unchanged(ack: AckResult) -> Self { + Self { + ack, + transition: Transition::Unchanged, + quarantine: false, + } + } +} + +fn conflict(state: &ItemState, current_fp: Fp, incoming: &Incoming) -> Decision { + let mut candidates = state.conflict.clone().unwrap_or_default(); + candidates + .candidates + .entry(state.head) + .or_insert_with(|| VidRecord { + fp: current_fp, + parents: state + .record(&state.head) + .map(|r| r.parents.clone()) + .unwrap_or_default(), + }); + if let Some(fp) = incoming.value_fp { + candidates.candidates.insert( + incoming.new_vid, + VidRecord { + fp, + parents: incoming.parents.clone(), + }, + ); + } + Decision { + ack: AckResult::Conflict, + transition: Transition::Conflict { candidates }, + quarantine: false, + } +} + +fn advance(state: &ItemState, incoming: &Incoming, convergence: bool, resolve: bool) -> Decision { + if incoming.retire { + return Decision { + ack: AckResult::Applied, + transition: Transition::Retire, + quarantine: false, + }; + } + let head = if convergence { + state.head.max(incoming.new_vid) + } else { + incoming.new_vid + }; + // Equal values do not authenticate the sender's claimed ancestry. + let lineage = if convergence { + state.lineage.clone() + } else { + Lineage::merge(&state.lineage, &incoming.lineage) + }; + let mut lineage = Lineage::new( + lineage + .iter() + .copied() + .chain([state.head, incoming.new_vid]) + .chain(incoming.parents.iter().copied().filter(|_| resolve)), + ) + .with_head(head); + if convergence { + lineage = lineage.with_heads([state.head, incoming.new_vid]); + } + Decision { + ack: AckResult::Applied, + quarantine: false, + transition: Transition::Advance { + head, + lineage, + write_value: !convergence, + clear_conflict: resolve, + }, + } +} + +/// Implements the first-match table, rows 1–9, including resolve and non-deleting Retire (§12.5). +pub fn decide( + state: &ItemState, + current_fp: Fp, + incoming: &Incoming, + frozen: bool, + approval: Option<&VerifiedApproval>, + within_limits: bool, +) -> Decision { + // Rows 1 and 2 deliberately outrank all other conditions. + if incoming.generation != state.generation { + return Decision::unchanged(AckResult::StaleGeneration); + } + if frozen { + return Decision::held(HoldReason::Frozen); + } + // Row 3: consult all retained immutable bindings, not just the head. + let violation = state + .record(&incoming.new_vid) + .is_some_and(|r| incoming.value_fp != Some(r.fp) || incoming.parents != r.parents) + || (incoming.new_vid == state.head && incoming.value_fp != Some(current_fp)); + if violation { + return Decision { + ack: AckResult::Rejected, + transition: Transition::Unchanged, + quarantine: true, + }; + } + // Row 4: an already-known ancestor is acknowledged without another write. + if incoming.new_vid == state.head || state.lineage.contains(&incoming.new_vid) { + return Decision::unchanged(AckResult::Applied); + } + // Malformed operations cannot reach any value-writing transition. + if incoming.retire == incoming.value_fp.is_some() { + return Decision::unchanged(AckResult::Rejected); + } + // Retire has no candidate value; without approval it can only request review (§2.5). + if incoming.retire && approval.is_none() { + return Decision::held(HoldReason::NoApproval); + } + if incoming.retire && incoming.parents.as_slice() != [state.head] { + return Decision::held(HoldReason::RetireMismatch); + } + // Row 5: complete parent coverage is necessary even with a verified approval. + if let Some(candidates) = &state.conflict { + let complete = incoming.parents.contains(&state.head) + && candidates + .candidates + .keys() + .all(|vid| incoming.parents.contains(vid)); + if !complete { + if incoming.retire { + return Decision::held(HoldReason::Resolve); + } + return conflict(state, current_fp, incoming); + } + if approval.is_none() { + return Decision::held(HoldReason::Resolve); + } + if !within_limits { + return Decision::held(HoldReason::OverLimit); + } + return advance(state, incoming, false, true); + } + // A resolve can reach a peer which never saw the competing changes. Its only + // unresolved head is its current one; complete multi-parent coverage still requires + // review in Phase 1, including when the selected value already matches (§2.4). + if incoming.parents.len() > 1 && incoming.parents.contains(&state.head) && approval.is_none() { + return Decision::held(HoldReason::Resolve); + } + // Row 6 is metadata-only convergence; Retire has no value to converge. + if incoming.value_fp == Some(current_fp) { + return advance(state, incoming, true, false); + } + let direct = incoming.parents.as_slice() == [state.head]; + // Row 7: callers cannot substitute claimed lineage for signed direct parents. + if direct && approval.is_some() && within_limits { + return advance(state, incoming, false, false); + } + // Row 8. + if direct { + return Decision::held(if approval.is_none() { + HoldReason::NoApproval + } else { + HoldReason::OverLimit + }); + } + // Row 9. + conflict(state, current_fp, incoming) +} diff --git a/crates/kc-sync/src/generation.rs b/crates/kc-sync/src/generation.rs new file mode 100644 index 0000000..e158a34 --- /dev/null +++ b/crates/kc-sync/src/generation.rs @@ -0,0 +1,143 @@ +use crate::PeerId; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; + +/// Receiver-issued registration message, with explicit peer scoping (§12.2). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Registration { + /// Name being accepted or left (§12.2). + pub name: String, + /// Receiver-owned generation (§12.2). + pub generation: u64, +} + +/// Exhaustion must not wrap a receiver's generation and revive stale changes (§12.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)] +#[error("registration generation exhausted")] +pub struct GenerationExhausted; + +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +struct Owned { + generation: u64, + peers: BTreeSet, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Remote { + generation: u64, + accepted: bool, +} + +/// Receiver generations and sender-side Accept/Leave bookkeeping, never automatic enrollment (§12.2). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Generations { + owned: BTreeMap, + remote: BTreeMap>, +} + +impl Generations { + /// Returns the generation owned by this receiver, initially zero (§12.2). + pub fn generation(&self, name: &str) -> u64 { + self.owned.get(name).map_or(0, |o| o.generation) + } + + /// Human review accepts an offer for exactly the specified peer (§2.1, §12.2). + pub fn accept(&mut self, name: &str, peer: PeerId) -> Registration { + let owned = self.owned.entry(name.into()).or_default(); + owned.generation = owned.generation.max(1); + owned.peers.insert(peer); + Registration { + name: name.into(), + generation: owned.generation, + } + } + + /// Checks local registration membership for a peer/name (§2.1, §12.2). + pub fn includes(&self, name: &str, peer: &PeerId) -> bool { + self.owned.get(name).is_some_and(|o| o.peers.contains(peer)) + } + + /// Removes one scope member without changing generation; send Leave only to this peer (§12.2). + pub fn remove_peer(&mut self, name: &str, peer: &PeerId) -> Option<(Registration, PeerId)> { + let owned = self.owned.get_mut(name)?; + if !owned.peers.remove(peer) { + return None; + } + Some(( + Registration { + name: name.into(), + generation: owned.generation, + }, + peer.clone(), + )) + } + + /// Removes local membership and bumps its generation; send Leave to returned peers (§12.2). + pub fn rm( + &mut self, + name: &str, + ) -> Result<(Registration, BTreeSet), GenerationExhausted> { + let owned = self.owned.entry(name.into()).or_default(); + let next = owned.generation.checked_add(1).ok_or(GenerationExhausted)?; + owned.generation = next; + let peers = std::mem::take(&mut owned.peers); + Ok(( + Registration { + name: name.into(), + generation: next, + }, + peers, + )) + } + + /// Records a peer's Accept, ignoring generations older than a previously observed Leave (§12.2). + pub fn received_accept(&mut self, peer: PeerId, accept: Registration) -> bool { + let names = self.remote.entry(peer).or_default(); + if names + .get(&accept.name) + .is_some_and(|r| r.generation > accept.generation) + { + return false; + } + names.insert( + accept.name, + Remote { + generation: accept.generation, + accepted: true, + }, + ); + true + } + + /// Records a peer's Leave without permitting reordered older messages to roll it back (§12.2). + pub fn received_leave(&mut self, peer: PeerId, leave: Registration) -> bool { + let names = self.remote.entry(peer).or_default(); + if names.get(&leave.name).is_some_and(|r| { + r.generation > leave.generation || (r.generation == leave.generation && r.accepted) + }) { + return false; + } + names.insert( + leave.name, + Remote { + generation: leave.generation, + accepted: false, + }, + ); + true + } + + /// Last receiver generation learned from either Accept or Leave; zero means unknown. + pub fn known_generation(&self, peer: &PeerId, name: &str) -> u64 { + self.remote + .get(peer) + .and_then(|names| names.get(name)) + .map_or(0, |r| r.generation) + } + + /// Returns the receiver-issued generation only after Accept and before Leave (§12.2). + pub fn outgoing_generation(&self, peer: &PeerId, name: &str) -> Option { + let remote = self.remote.get(peer)?.get(name)?; + remote.accepted.then_some(remote.generation) + } +} diff --git a/crates/kc-sync/src/lib.rs b/crates/kc-sync/src/lib.rs new file mode 100644 index 0000000..28ee92a --- /dev/null +++ b/crates/kc-sync/src/lib.rs @@ -0,0 +1,21 @@ +//! Side-effect-free `kc sync` policy from docs/design/sync.md §§2, 4, 12.2–12.5. +//! Callers own authentication, durable storage, locks, fingerprints, and ACK delivery. +//! A returned transition is an intent: ACK only after its durable commit (§12.4). +#![forbid(unsafe_code)] +#![warn(missing_docs)] + +mod decision; +mod generation; +mod limiter; +mod outbox; +mod recovery; +mod slots; +mod state; + +pub use decision::*; +pub use generation::*; +pub use limiter::*; +pub use outbox::*; +pub use recovery::*; +pub use slots::*; +pub use state::*; diff --git a/crates/kc-sync/src/limiter.rs b/crates/kc-sync/src/limiter.rs new file mode 100644 index 0000000..0a8789f --- /dev/null +++ b/crates/kc-sync/src/limiter.rs @@ -0,0 +1,134 @@ +use crate::PeerId; +use serde::{Deserialize, Serialize}; +use std::collections::{BTreeMap, BTreeSet}; + +/// Rolling non-interactive overwrite and peer breaker window in seconds (§4). +pub const WINDOW_SECS: i64 = 24 * 60 * 60; + +/// Counted remote operation; retirement never deletes a value (§4, §2.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum RemoteOperation { + /// Value overwrite (§4). + Overwrite, + /// Registration removal (§4). + Retire, +} + +/// Limiter outcome that the caller feeds into `decide` (§4, §12.5). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LimitResult { + /// Within both item and peer limits (§4). + Allowed, + /// This item already had a non-interactive overwrite in the window (§4). + ItemLimited, + /// Peer is latched off until a human resets it; hold all its messages (§4). + PeerTripped, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Event { + at: i64, + name: String, + op: RemoteOperation, +} + +/// Serializable deterministic limiter; caller supplies time and records only committed operations (§4). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Limiter { + items: BTreeMap, + events: BTreeMap>, + tripped: BTreeSet, +} + +fn recent(at: i64, now: i64) -> bool { + // Future timestamps remain active under clock rollback, including i64 extremes. + (now as i128) - (at as i128) < WINDOW_SECS as i128 +} + +impl Limiter { + /// Checks the proposed operation and latches a breaker before crossing a threshold (§4). + pub fn check( + &mut self, + peer: &PeerId, + name: &str, + op: RemoteOperation, + now: i64, + sync_set_size: usize, + interactive: bool, + ) -> LimitResult { + if self.tripped.contains(peer) { + return LimitResult::PeerTripped; + } + self.prune(now); + let events = self.events.get(peer).map(Vec::as_slice).unwrap_or_default(); + let overwrites = events + .iter() + .filter(|e| e.op == RemoteOperation::Overwrite) + .count() + + usize::from(op == RemoteOperation::Overwrite); + let retires = events + .iter() + .filter(|e| e.op == RemoteOperation::Retire) + .count() + + usize::from(op == RemoteOperation::Retire); + let affected: BTreeSet<&str> = events + .iter() + .map(|e| e.name.as_str()) + .chain([name]) + .collect(); + if overwrites > 5 + || retires > 3 + || (sync_set_size >= 8 && affected.len() > sync_set_size / 4) + { + self.tripped.insert(peer.clone()); + return LimitResult::PeerTripped; + } + if op == RemoteOperation::Overwrite + && !interactive + && self.items.get(name).is_some_and(|at| recent(*at, now)) + { + return LimitResult::ItemLimited; + } + LimitResult::Allowed + } + + /// Records an actually committed operation; interactive writes bypass only the item cap (§4). + pub fn record( + &mut self, + peer: &PeerId, + name: &str, + op: RemoteOperation, + now: i64, + interactive: bool, + ) { + self.prune(now); + if op == RemoteOperation::Overwrite && !interactive { + self.items.insert(name.into(), now); + } + self.events.entry(peer.clone()).or_default().push(Event { + at: now, + name: name.into(), + op, + }); + } + + /// Tests the sticky peer breaker for any incoming message, including offers (§4). + pub fn is_tripped(&self, peer: &PeerId) -> bool { + self.tripped.contains(peer) + } + + /// Human reset clears this peer's breaker history but preserves per-item overwrite limits (§4). + pub fn human_reset(&mut self, peer: &PeerId) { + self.tripped.remove(peer); + self.events.remove(peer); + } + + /// Drops expired counters without clearing sticky breakers (§4). + pub fn prune(&mut self, now: i64) { + self.items.retain(|_, at| recent(*at, now)); + self.events.retain(|_, events| { + events.retain(|e| recent(e.at, now)); + !events.is_empty() + }); + } +} diff --git a/crates/kc-sync/src/outbox.rs b/crates/kc-sync/src/outbox.rs new file mode 100644 index 0000000..f935b8e --- /dev/null +++ b/crates/kc-sync/src/outbox.rs @@ -0,0 +1,176 @@ +use crate::{AckResult, PeerId, Vid}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use std::collections::{BTreeMap, BTreeSet}; + +/// Exact receiver-specific change identity; vids are random, not chronological (§12.3). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct ChangeId { + /// Item name (§12.3). + pub name: String, + /// Target receiver's accepted generation (§12.2). + pub generation: u64, + /// Immutable version being delivered (§12.3). + pub new_vid: Vid, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +struct Delivery { + order: u64, + final_ack: Option, +} + +/// Per-peer queues and all-target snapshot retention; contains no values (§2.8, §12.3). +#[derive(Debug, Clone, Default, Serialize, Deserialize)] +pub struct Outbox { + #[serde( + serialize_with = "serialize_deliveries", + deserialize_with = "deserialize_deliveries" + )] + deliveries: BTreeMap>, + reoffer: BTreeMap>, + next_order: u64, +} + +fn serialize_deliveries( + deliveries: &BTreeMap>, + s: S, +) -> Result { + deliveries + .iter() + .map(|(peer, queue)| (peer, queue.iter().collect::>())) + .collect::>() + .serialize(s) +} + +fn deserialize_deliveries<'de, D: Deserializer<'de>>( + d: D, +) -> Result>, D::Error> { + let peers = Vec::<(PeerId, Vec<(ChangeId, Delivery)>)>::deserialize(d)?; + let mut result = BTreeMap::new(); + for (peer, entries) in peers { + let count = entries.len(); + let queue: BTreeMap<_, _> = entries.into_iter().collect(); + if queue.len() != count || result.insert(peer, queue).is_some() { + return Err(serde::de::Error::custom("duplicate outbox identity")); + } + } + Ok(result) +} + +impl Outbox { + /// Adds an exact target delivery; repeated enqueue does not reset its ACK (§2.8, §12.3). + pub fn enqueue(&mut self, peer: PeerId, change: ChangeId) { + if self + .deliveries + .get(&peer) + .is_some_and(|q| q.contains_key(&change)) + { + return; + } + // Renumbering is unnecessary in practice, but exhaustion must never invert ordering. + if self.next_order == u64::MAX { + let mut orders: Vec<_> = self + .deliveries + .values() + .flat_map(|q| q.values().map(|d| d.order)) + .collect(); + orders.sort_unstable(); + orders.dedup(); + for queue in self.deliveries.values_mut() { + for entry in queue.values_mut() { + entry.order = orders.binary_search(&entry.order).unwrap() as u64; + } + } + self.next_order = orders.len() as u64; + } + self.deliveries.entry(peer).or_default().insert( + change, + Delivery { + order: self.next_order, + final_ack: None, + }, + ); + self.next_order += 1; + } + + /// Applies a final exact ACK and supersedes only earlier entries for this peer/name (§12.3). + pub fn ack(&mut self, peer: &PeerId, change: &ChangeId, result: AckResult) -> bool { + if !result.is_final() { + return false; + } + let Some(queue) = self.deliveries.get_mut(peer) else { + return false; + }; + let Some(delivery) = queue.get(change) else { + return false; + }; + if delivery.final_ack.is_some() { + return false; + } + let order = delivery.order; + for (id, delivery) in queue.iter_mut() { + if id.name == change.name && delivery.order <= order && delivery.final_ack.is_none() { + delivery.final_ack = Some(result); + } + } + if result == AckResult::StaleGeneration { + self.reoffer + .entry(peer.clone()) + .or_default() + .insert(change.name.clone()); + } + true + } + + /// Iterates only pending exact entries for a peer; finalized metadata is retained until release (§12.3). + pub fn pending<'a>(&'a self, peer: &PeerId) -> impl Iterator { + self.deliveries + .get(peer) + .into_iter() + .flat_map(|q| q.iter()) + .filter(|(_, d)| d.final_ack.is_none()) + .map(|(id, _)| id) + } + + /// True only for a known snapshot with a final ACK from every target peer/generation (§12.3). + pub fn snapshot_releasable(&self, name: &str, vid: Vid) -> bool { + let mut found = false; + for queue in self.deliveries.values() { + for (id, delivery) in queue { + if id.name == name && id.new_vid == vid { + found = true; + if delivery.final_ack.is_none() { + return false; + } + } + } + } + found + } + + /// Removes finalized bookkeeping only once the shared snapshot is releasable (§12.3). + pub fn release_snapshot(&mut self, name: &str, vid: Vid) -> bool { + if !self.snapshot_releasable(name, vid) { + return false; + } + for queue in self.deliveries.values_mut() { + queue.retain(|id, _| id.name != name || id.new_vid != vid); + } + self.deliveries.retain(|_, q| !q.is_empty()); + true + } + + /// Exposes the stale-generation status for a peer/name (§12.2). + pub fn needs_reoffer(&self, peer: &PeerId, name: &str) -> bool { + self.reoffer + .get(peer) + .is_some_and(|names| names.contains(name)) + } + + /// Clears the re-offer status after a new Accept (§12.2). + pub fn accepted(&mut self, peer: &PeerId, name: &str) { + if let Some(names) = self.reoffer.get_mut(peer) { + names.remove(name); + } + } +} diff --git a/crates/kc-sync/src/recovery.rs b/crates/kc-sync/src/recovery.rs new file mode 100644 index 0000000..511f1ab --- /dev/null +++ b/crates/kc-sync/src/recovery.rs @@ -0,0 +1,119 @@ +use crate::{AckResult, ChangeId, Fp, Lineage, PeerId, Vid}; +use serde::{Deserialize, Serialize}; + +/// Complete remote transaction intent, persisted before slots or keychain writes (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct RemoteJournalRecord { + /// Exact acknowledged change (§12.4). + pub change_id: ChangeId, + /// Authenticated source peer (§12.4). + pub sender: PeerId, + /// Fingerprint before the intended write (§12.4). + pub prev_fp: Fp, + /// Intended fingerprint after the write (§12.4). + pub new_fp: Fp, + /// Head installed at step 4 (§12.4). + pub head: Vid, + /// Lineage installed at step 4 (§12.4). + pub lineage: Lineage, + /// Verified approval consumption key, absent for human-reviewed Phase 1 changes (§12.4). + pub approval_key: Option, + /// ACK queued only after step 4 commits (§12.4). + pub ack: AckResult, + /// Recovery baseline slot reserved before writing (§12.4). + pub checkpoint_slot: Option, + /// Slot holding the intended incoming value (§12.4). + pub candidate_slot: String, +} + +/// Receiver-specific queued target captured by the local transaction (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct QueueTarget { + /// Destination peer (§12.4). + pub peer: PeerId, + /// Generation granted by this destination (§12.2, §12.4). + pub generation: u64, +} + +/// Complete local-change intent, including snapshot and target generations (§12.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct LocalJournalRecord { + /// Changed item name (§12.4). + pub name: String, + /// Previous keychain fingerprint (§12.4). + pub prev_fp: Fp, + /// Newly written or observed fingerprint (§12.4). + pub new_fp: Fp, + /// Caller-generated immutable version (§12.4). + pub new_vid: Vid, + /// Direct parents captured before writing (§12.4). + pub parents: Vec, + /// Outbound value snapshot retained while queues reference it (§12.4). + pub snapshot_slot: String, + /// Exact destination peers and their registration generations (§12.4). + pub targets: Vec, +} + +/// Recovery action for a remote transaction; never overwrites unrelated current values (§12.4). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum RemoteRecovery { + /// Write happened: finish metadata, approval consumption, and ACK queue (§12.4). + FinishFromStep4, + /// Write did not happen: clear intent and retry (§12.4). + Retry, + /// Another value is current: preserve it and record a conflict (§12.4). + Conflict, +} + +/// Classifies a remote journal by fingerprint, with intended-value equality taking precedence (§12.4). +pub fn recover_remote(record: &RemoteJournalRecord, current_fp: Fp) -> RemoteRecovery { + if current_fp == record.new_fp { + RemoteRecovery::FinishFromStep4 + } else if current_fp == record.prev_fp { + RemoteRecovery::Retry + } else { + RemoteRecovery::Conflict + } +} + +/// Exactly the six local-journal recovery rows, in design-table order (§12.4). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LocalRecovery { + /// Row 1: copy current value into the missing snapshot, then commit and clean journal (§12.4). + RebuildSnapshotAndCommit, + /// Row 2: existing snapshot is ready; commit metadata then clean journal (§12.4). + Commit, + /// Row 3: already committed and value matches; clean journal only (§12.4). + CleanJournal, + /// Row 4: retain queued snapshot, clean journal, and scan current value as a new version (§12.4). + KeepSnapshotAndScan, + /// Row 5: write never happened; delete any unreferenced snapshot and clean journal (§12.4). + DiscardSnapshot, + /// Row 6: discard uncommitted snapshot, clean journal, and scan current value (§12.4). + DiscardSnapshotAndScan, +} + +/// Classifies all six rows; `committed` means stored head equals the journal's new vid (§12.4). +pub fn recover_local( + prev_fp: Fp, + new_fp: Fp, + current_fp: Fp, + committed: bool, + snapshot_exists: bool, +) -> LocalRecovery { + if current_fp == new_fp { + if committed { + LocalRecovery::CleanJournal + } else if snapshot_exists { + LocalRecovery::Commit + } else { + LocalRecovery::RebuildSnapshotAndCommit + } + } else if committed { + LocalRecovery::KeepSnapshotAndScan + } else if current_fp == prev_fp { + LocalRecovery::DiscardSnapshot + } else { + LocalRecovery::DiscardSnapshotAndScan + } +} diff --git a/crates/kc-sync/src/slots.rs b/crates/kc-sync/src/slots.rs new file mode 100644 index 0000000..cfe9b90 --- /dev/null +++ b/crates/kc-sync/src/slots.rs @@ -0,0 +1,173 @@ +use crate::{AckResult, Decision, Fp, HoldReason}; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; + +/// Slot priority in increasing order; checkpoints are never evicted (§12.3). +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +pub enum SlotKind { + /// Lowest-priority unsolicited offer (§12.3). + Proposal, + /// Value waiting for human review (§12.3). + Held, + /// Unresolved candidate or outbound value snapshot (§2.6, §12.3). + ConflictCandidate, + /// Human-confirmed recovery baseline (§2.6). + Checkpoint, +} + +/// Reservation result; callers must durably remove evicted lower-priority slots (§12.3). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Reservation { + /// Reservation succeeded, possibly evicting a lower-priority slot (§12.3). + Reserved { + /// Evicted slot name, if any; never a checkpoint (§12.3). + evicted: Option, + }, + /// No space, or the name already belongs to a different slot kind (§12.3). + Refused, +} + +/// Serializable slot ledger with deterministic lower-priority eviction (§12.3). +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SlotBudget { + capacity: usize, + slots: BTreeMap, + pinned_snapshots: std::collections::BTreeSet, +} + +impl SlotBudget { + /// Creates a budget of max(16, items × 4), saturating arithmetic (§12.3). + pub fn new(items: usize) -> Self { + Self { + capacity: items.saturating_mul(4).max(16), + slots: BTreeMap::new(), + pinned_snapshots: Default::default(), + } + } + /// Returns the configured total capacity (§12.3). + pub fn capacity(&self) -> usize { + self.capacity + } + /// Updates the item count without evicting existing slots on shrink (§12.3). + pub fn set_items(&mut self, items: usize) { + self.capacity = items.saturating_mul(4).max(16); + } + /// Returns the count of reserved slots (§12.3). + pub fn used(&self) -> usize { + self.slots.len() + } + /// Looks up a reservation without touching its value (§12.3). + pub fn kind(&self, name: &str) -> Option { + self.slots.get(name).copied() + } + + /// Reserves a slot; new Held and Proposal slots never evict at capacity (§12.3). + pub fn reserve(&mut self, name: &str, kind: SlotKind) -> Reservation { + if let Some(existing) = self.slots.get(name) { + return if *existing == kind { + Reservation::Reserved { evicted: None } + } else { + Reservation::Refused + }; + } + let mut evicted = None; + // A reduced budget preserves all existing reservations until released. + if self.slots.len() > self.capacity { + return Reservation::Refused; + } + if self.slots.len() >= self.capacity { + if kind <= SlotKind::Held { + return Reservation::Refused; + } + evicted = self + .slots + .iter() + .filter(|(name, existing)| { + **existing < kind && !self.pinned_snapshots.contains(*name) + }) + .min_by_key(|(name, existing)| (**existing, *name)) + .map(|(name, _)| name.clone()); + let Some(victim) = &evicted else { + return Reservation::Refused; + }; + self.slots.remove(victim); + } + self.slots.insert(name.into(), kind); + Reservation::Reserved { evicted } + } + + /// Reserves an outbound snapshot pinned until all-target final ACK (§2.8, §12.3). + pub fn reserve_snapshot(&mut self, name: &str) -> Reservation { + let result = self.reserve(name, SlotKind::ConflictCandidate); + if matches!(result, Reservation::Reserved { .. }) { + self.pinned_snapshots.insert(name.into()); + } + result + } + + /// Releases resolved/rejected slots or finally acknowledged snapshots, never checkpoints (§12.3). + pub fn release(&mut self, name: &str) -> bool { + if self.slots.get(name) == Some(&SlotKind::Checkpoint) { + return false; + } + self.pinned_snapshots.remove(name); + self.slots.remove(name).is_some() + } + + /// Reserves durable review storage, or returns a non-final capacity deferral (§12.3). + pub fn prepare_hold(&mut self, held_slot: &str, reason: HoldReason) -> OverwriteCapacity { + match self.reserve(held_slot, SlotKind::Held) { + Reservation::Reserved { .. } => OverwriteCapacity::Held(Decision::held(reason)), + Reservation::Refused => { + OverwriteCapacity::Deferred(Decision::unchanged(AckResult::DeferredCapacity)) + } + } + } + + /// Ensures a checkpoint before overwrite; fallback is held, then capacity deferral (§2.6, §12.3). + pub fn prepare_overwrite( + &mut self, + checkpoint_slot: &str, + held_slot: &str, + ) -> OverwriteCapacity { + match self.reserve(checkpoint_slot, SlotKind::Checkpoint) { + Reservation::Reserved { evicted } => OverwriteCapacity::Ready { evicted }, + Reservation::Refused => self.prepare_hold(held_slot, HoldReason::OverLimit), + } + } +} + +/// First-overwrite capacity gate; only Ready permits a keychain write (§2.6, §12.3). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum OverwriteCapacity { + /// Checkpoint slot exists before the overwrite (§2.6). + Ready { + /// Lower-priority reservation displaced by the checkpoint (§12.3). + evicted: Option, + }, + /// Retain incoming value for review (§12.3). + Held(Decision), + /// Retain nothing and ask sender to retry (§12.3). + Deferred(Decision), +} + +/// Recovery baseline whose fingerprint cannot be replaced by remote overwrites (§2.6). +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct Checkpoint { + fp: Option, +} + +impl Checkpoint { + /// Captures the original value only on the first remote overwrite (§2.6). + pub fn before_remote_overwrite(&mut self, current: Fp) -> Fp { + *self.fp.get_or_insert(current) + } + /// Returns the retained fingerprint for caller-owned recovery storage (§2.6). + pub fn fingerprint(&self) -> Option { + self.fp + } + /// Explicit human confirmation is the only way to replace a baseline (§2.6). + pub fn human_confirm(&mut self, current: Fp) { + self.fp = Some(current); + } +} diff --git a/crates/kc-sync/src/state.rs b/crates/kc-sync/src/state.rs new file mode 100644 index 0000000..b86c76f --- /dev/null +++ b/crates/kc-sync/src/state.rs @@ -0,0 +1,211 @@ +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use std::collections::{BTreeMap, BTreeSet}; + +// Structured keys are encoded as pairs so state remains usable in sync.json as well as binary serde. +pub(crate) fn serialize_map( + map: &BTreeMap, + s: S, +) -> Result { + map.iter().collect::>().serialize(s) +} + +pub(crate) fn deserialize_map< + 'de, + D: Deserializer<'de>, + K: Deserialize<'de> + Ord, + V: Deserialize<'de>, +>( + d: D, +) -> Result, D::Error> { + let pairs = Vec::<(K, V)>::deserialize(d)?; + let count = pairs.len(); + let map: BTreeMap<_, _> = pairs.into_iter().collect(); + if map.len() != count { + return Err(serde::de::Error::custom("duplicate map key")); + } + Ok(map) +} + +/// Opaque, caller-generated version identifier (§2.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct Vid(pub [u8; 16]); + +/// Opaque, locally computed value fingerprint; never a wire value (§2.2). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct Fp(pub [u8; 32]); + +/// Opaque peer key, independent of transport or display labels (§12.2). +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)] +pub struct PeerId(pub String); + +/// Maximum retained lineage size (§2.4). +pub const MAX_LINEAGE: usize = 64; +/// Bounded immutable-VID cache; unresolved candidate records live separately (§2.2, §2.4). +pub const MAX_KNOWN: usize = 256; + +/// Sorted, bounded set of version identifiers (§2.4). +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)] +#[serde(transparent)] +pub struct Lineage(BTreeSet); + +impl<'de> Deserialize<'de> for Lineage { + fn deserialize>(d: D) -> Result { + let values = BTreeSet::::deserialize(d)?; + if values.len() > MAX_LINEAGE { + return Err(serde::de::Error::custom("lineage exceeds 64 vids")); + } + Ok(Self(values)) + } +} + +impl Lineage { + /// Retains the greatest 64 distinct vids, deterministically (§2.4). + pub fn new(vids: impl IntoIterator) -> Self { + let mut result = Self(vids.into_iter().collect()); + while result.0.len() > MAX_LINEAGE { + result.0.pop_first(); + } + result + } + + /// Unions two lineages, dropping smallest identifiers first (§2.4). + pub fn merge(a: &Self, b: &Self) -> Self { + Self::new(a.0.union(&b.0).copied()) + } + + /// Pins the resulting current head even when it is smaller than retained ancestors (§2.4). + pub fn with_head(mut self, head: Vid) -> Self { + self.0.insert(head); + if self.0.len() > MAX_LINEAGE { + let victim = self.0.iter().copied().find(|v| *v != head).unwrap(); + self.0.remove(&victim); + } + self + } + + pub(crate) fn with_heads(mut self, heads: [Vid; 2]) -> Self { + self.0.extend(heads); + while self.0.len() > MAX_LINEAGE { + let victim = self.0.iter().copied().find(|v| !heads.contains(v)).unwrap(); + self.0.remove(&victim); + } + self + } + + /// Tests ancestry membership without trusting remote ancestry for authorization (§2.2). + pub fn contains(&self, vid: &Vid) -> bool { + self.0.contains(vid) + } + /// Returns identifiers in deterministic ascending order (§2.4). + pub fn iter(&self) -> impl Iterator { + self.0.iter() + } + /// Returns the retained identifier count (§2.4). + pub fn len(&self) -> usize { + self.0.len() + } + /// Reports an empty ancestry set (§2.4). + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } +} + +/// Immutable value and direct-parent binding for a known version (§2.2, §2.4). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct VidRecord { + /// Locally computed value fingerprint (§2.2). + pub fp: Fp, + /// Exact ordered parent list bound to this vid (§2.4). + pub parents: Vec, +} + +/// Preserved unresolved heads and their immutable bindings (§2.4). +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct ConflictSet { + /// Candidate values must remain in caller-owned slots until resolve or rejection (§12.3). + #[serde(serialize_with = "serialize_map", deserialize_with = "deserialize_map")] + pub candidates: BTreeMap, +} + +/// Receiver-owned item state; construct/update its bounded cache with `remember` (§2.2, §12.2). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ItemState { + /// Receiver's registration generation (§12.2). + pub generation: u64, + /// Current value's immutable version (§2.2). + pub head: Vid, + /// Bounded ancestry, with the head pinned by transitions (§2.4). + pub lineage: Lineage, + /// All unresolved candidate values, including the current head (§2.4). + pub conflict: Option, + /// Bounded recent bindings; candidate bindings are additionally kept in `conflict` (§2.4). + #[serde( + serialize_with = "serialize_map", + deserialize_with = "deserialize_known" + )] + pub known: BTreeMap, +} + +fn deserialize_known<'de, D: Deserializer<'de>>( + d: D, +) -> Result, D::Error> { + let known: BTreeMap = deserialize_map(d)?; + if known.len() > MAX_KNOWN { + return Err(serde::de::Error::custom("known cache exceeds bound")); + } + Ok(known) +} + +impl ItemState { + /// Initializes a single local head using caller-supplied randomness (§2.2). + pub fn new(generation: u64, head: Vid, fp: Fp, parents: Vec) -> Self { + Self { + generation, + head, + lineage: Lineage::new([head]), + conflict: None, + known: BTreeMap::from([(head, VidRecord { fp, parents })]), + } + } + + /// Remembers a binding, rejects mutation, and deterministically bounds the cache (§2.2, §2.4). + pub fn remember(&mut self, vid: Vid, record: VidRecord) -> bool { + if self.record(&vid).is_some_and(|old| old != &record) { + return false; + } + self.known.insert(vid, record); + while self.known.len() > MAX_KNOWN { + let victim = self + .known + .keys() + .copied() + .find(|v| *v != self.head) + .unwrap(); + self.known.remove(&victim); + } + true + } + + pub(crate) fn record(&self, vid: &Vid) -> Option<&VidRecord> { + self.known + .get(vid) + .or_else(|| self.conflict.as_ref()?.candidates.get(vid)) + } +} + +/// Authenticated envelope data plus locally computed fingerprint for decision-making (§12.5). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Incoming { + /// Generation previously supplied by this receiver (§12.2). + pub generation: u64, + /// Immutable proposed version (§2.2). + pub new_vid: Vid, + /// Claimed direct parents; approval verification must bind this exact list (§12.5). + pub parents: Vec, + /// Claimed bounded ancestry, never sufficient to authorize overwrites (§2.2). + pub lineage: Lineage, + /// Local fingerprint of Put value; absent for Retire (§2.5). + pub value_fp: Option, + /// Unregister only; this operation must never delete a value (§2.5). + pub retire: bool, +} diff --git a/crates/kc-sync/tests/policy.rs b/crates/kc-sync/tests/policy.rs new file mode 100644 index 0000000..4fb9448 --- /dev/null +++ b/crates/kc-sync/tests/policy.rs @@ -0,0 +1,1190 @@ +use kc_sync::*; +use std::collections::BTreeMap; + +fn v(n: u16) -> Vid { + let mut b = [0; 16]; + b[14..].copy_from_slice(&n.to_be_bytes()); + Vid(b) +} +fn f(n: u8) -> Fp { + Fp([n; 32]) +} +fn peer(n: &str) -> PeerId { + PeerId(n.into()) +} +fn state() -> ItemState { + ItemState::new(7, v(1), f(1), vec![v(0)]) +} +fn incoming() -> Incoming { + Incoming { + generation: 7, + new_vid: v(2), + parents: vec![v(1)], + lineage: Lineage::new([v(1), v(2)]), + value_fp: Some(f(2)), + retire: false, + } +} +fn run(s: &ItemState, i: &Incoming) -> Decision { + decide(s, f(1), i, false, None, true) +} +fn held(d: &Decision, reason: HoldReason) { + assert_eq!(d.ack, AckResult::Held); + assert_eq!(d.transition, Transition::Hold { reason }); + assert!(!d.quarantine); +} +fn conflicted() -> ItemState { + let mut s = state(); + s.conflict = Some(ConflictSet { + candidates: BTreeMap::from([ + ( + v(1), + VidRecord { + fp: f(1), + parents: vec![v(0)], + }, + ), + ( + v(3), + VidRecord { + fp: f(3), + parents: vec![v(0)], + }, + ), + ( + v(4), + VidRecord { + fp: f(4), + parents: vec![v(0)], + }, + ), + ]), + }); + s +} + +#[test] +fn row1_stale_beats_freeze_violation_conflict_approval_and_limits() { + let mut i = incoming(); + i.generation = 6; + i.new_vid = v(1); + let d = decide( + &conflicted(), + f(1), + &i, + true, + Some(&VerifiedApproval::for_tests()), + false, + ); + assert_eq!(d.ack, AckResult::StaleGeneration); + assert_eq!(d.transition, Transition::Unchanged); + assert!(!d.quarantine); +} +#[test] +fn row2_frozen_beats_fast_forward() { + held( + &decide( + &state(), + f(1), + &incoming(), + true, + Some(&VerifiedApproval::for_tests()), + true, + ), + HoldReason::Frozen, + ); +} +#[test] +fn row2_frozen_beats_violation() { + let mut i = incoming(); + i.new_vid = v(1); + held( + &decide(&state(), f(1), &i, true, None, true), + HoldReason::Frozen, + ); +} +#[test] +fn row3_same_vid_different_fp_is_quarantined() { + let mut i = incoming(); + i.new_vid = v(1); + i.parents = vec![v(0)]; + let d = run(&state(), &i); + assert_eq!(d.ack, AckResult::Rejected); + assert!(d.quarantine); +} +#[test] +fn row3_same_vid_different_parents_is_quarantined() { + let mut i = incoming(); + i.new_vid = v(1); + i.value_fp = Some(f(1)); + let d = run(&state(), &i); + assert_eq!(d.ack, AckResult::Rejected); + assert!(d.quarantine); +} +#[test] +fn row3_checks_non_head_known_and_conflict_records() { + let mut s = state(); + s.remember( + v(9), + VidRecord { + fp: f(9), + parents: vec![v(0)], + }, + ); + let mut i = incoming(); + i.new_vid = v(9); + assert!(run(&s, &i).quarantine); + i.new_vid = v(3); + assert!(run(&conflicted(), &i).quarantine); +} +#[test] +fn row4_duplicate_head_applied_without_write() { + let mut i = incoming(); + i.new_vid = v(1); + i.value_fp = Some(f(1)); + i.parents = vec![v(0)]; + assert_eq!( + run(&state(), &i), + Decision { + ack: AckResult::Applied, + transition: Transition::Unchanged, + quarantine: false + } + ); +} +#[test] +fn row4_ancestor_beats_conflict_and_no_approval() { + let mut s = conflicted(); + s.lineage = Lineage::new([v(1), v(2)]); + assert_eq!(run(&s, &incoming()).transition, Transition::Unchanged); +} +#[test] +fn row5_adds_candidates_and_beats_same_value_and_fast_forward() { + let mut i = incoming(); + i.value_fp = Some(f(1)); + let d = decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Conflict { candidates } = d.transition else { + panic!("{d:?}"); + }; + assert_eq!(candidates.candidates.len(), 4); + assert!(candidates.candidates.contains_key(&v(2))); +} +#[test] +fn row5_complete_resolve_without_approval_requires_review() { + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; + held(&run(&conflicted(), &i), HoldReason::Resolve); +} +#[test] +fn row5_complete_approved_resolve_clears_conflict_atomically() { + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; + let d = decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + assert!( + matches!(d.transition, Transition::Advance { head, clear_conflict: true, write_value: true, .. } if head == v(2)) + ); +} +#[test] +fn row5_missing_any_candidate_including_own_head_stays_conflict() { + for missing in [v(1), v(3), v(4)] { + let mut i = incoming(); + i.parents = [v(1), v(3), v(4)] + .into_iter() + .filter(|v| *v != missing) + .collect(); + for approved in [false, true] { + let token = VerifiedApproval::for_tests(); + let d = decide( + &conflicted(), + f(1), + &i, + false, + approved.then_some(&token), + true, + ); + assert_eq!(d.ack, AckResult::Conflict); + } + } +} +#[test] +fn row5_resolve_obeys_limits() { + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4)]; + held( + &decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); +} +#[test] +fn row6_same_value_converges_before_approval_and_limits() { + let mut i = incoming(); + i.value_fp = Some(f(1)); + i.parents = vec![v(55)]; + let d = decide(&state(), f(1), &i, false, None, false); + assert!( + matches!(d.transition, Transition::Advance { head, write_value: false, .. } if head == v(2)) + ); +} +#[test] +fn convergence_is_symmetric_even_when_lineage_truncates() { + let mut a = ItemState::new(7, v(5), f(1), vec![]); + let mut b = ItemState::new(7, v(80), f(1), vec![]); + a.lineage = Lineage::new((0..64).map(v)).with_head(a.head); + b.lineage = Lineage::new((50..114).map(v)).with_head(b.head); + let from = |s: &ItemState| Incoming { + generation: 7, + new_vid: s.head, + parents: vec![], + lineage: s.lineage.clone(), + value_fp: Some(f(1)), + retire: false, + }; + let da = decide(&a, f(1), &from(&b), false, None, true); + let db = decide(&b, f(1), &from(&a), false, None, true); + for d in [da, db] { + let Transition::Advance { head, lineage, .. } = d.transition else { + panic!() + }; + assert_eq!(head, v(80)); + assert_eq!(lineage.len(), 64); + assert!(lineage.contains(&a.head)); + assert!(lineage.contains(&b.head)); + } +} +#[test] +fn row7_approved_direct_parent_fast_forwards() { + let d = decide( + &state(), + f(1), + &incoming(), + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + assert!( + matches!(d.transition, Transition::Advance { head, write_value: true, clear_conflict: false, .. } if head == v(2)) + ); +} +#[test] +fn row8_phase1_direct_parent_is_held() { + held(&run(&state(), &incoming()), HoldReason::NoApproval); +} +#[test] +fn row8_approved_over_limit_is_held() { + held( + &decide( + &state(), + f(1), + &incoming(), + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); +} +#[test] +fn row9_forged_lineage_cannot_replace_parent_binding() { + let mut i = incoming(); + i.parents = vec![v(99)]; + assert!(i.lineage.contains(&state().head)); + for approved in [false, true] { + let token = VerifiedApproval::for_tests(); + assert_eq!( + decide(&state(), f(1), &i, false, approved.then_some(&token), true).ack, + AckResult::Conflict + ); + } +} +#[test] +fn retire_requires_approval_and_never_requests_value_deletion() { + let mut i = incoming(); + i.retire = true; + i.value_fp = None; + held(&run(&state(), &i), HoldReason::NoApproval); + assert_eq!( + decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true + ) + .transition, + Transition::Retire + ); + held( + &decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + false, + ), + HoldReason::OverLimit, + ); + i.parents = vec![v(99)]; + held(&run(&conflicted(), &i), HoldReason::NoApproval); + for s in [state(), conflicted()] { + for parents in [vec![], vec![v(99)], vec![v(1), v(3), v(4)]] { + i.parents = parents; + held( + &decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ), + HoldReason::RetireMismatch, + ); + } + } + i.parents = vec![v(1)]; + held( + &decide( + &conflicted(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ), + HoldReason::Resolve, + ); +} +#[test] +fn malformed_put_or_retire_is_rejected() { + let mut i = incoming(); + i.value_fp = None; + assert_eq!(run(&state(), &i).ack, AckResult::Rejected); + i.value_fp = Some(f(2)); + i.retire = true; + assert_eq!(run(&state(), &i).ack, AckResult::Rejected); +} +#[test] +fn lineage_boundary_64_65_and_head_pinning() { + let a = Lineage::new((0..64).map(v)); + assert_eq!(a.len(), 64); + assert!(a.contains(&v(0))); + let b = Lineage::merge(&a, &Lineage::new([v(64)])); + assert_eq!(b.len(), 64); + assert!(!b.contains(&v(0))); + assert!(b.contains(&v(64))); + assert_eq!(b, Lineage::merge(&Lineage::new([v(64)]), &a)); + let pinned = b.with_head(v(0)); + assert!(pinned.contains(&v(0))); + assert!(!pinned.contains(&v(1))); + assert_eq!(pinned.len(), 64); +} +#[test] +fn fast_forward_retains_small_random_head_at_capacity() { + let mut s = state(); + s.lineage = Lineage::new((100..164).map(v)).with_head(v(1)); + let mut i = incoming(); + i.new_vid = v(0); + i.lineage = Lineage::new((200..264).map(v)); + let d = decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { head, lineage, .. } = d.transition else { + panic!() + }; + assert!(lineage.contains(&head)); + assert_eq!(head, v(0)); + assert_eq!(lineage.len(), 64); +} +#[test] +fn lineage_serde_rejects_oversized_sets() { + let json = serde_json::to_string(&(0..65).map(v).collect::>()).unwrap(); + assert!(serde_json::from_str::(&json).is_err()); + let a = Lineage::new((0..64).map(v)); + assert_eq!( + a, + serde_json::from_str(&serde_json::to_string(&a).unwrap()).unwrap() + ); +} +#[test] +fn known_cache_is_bounded_and_immutable() { + let mut s = state(); + for n in 2..400 { + assert!(s.remember( + v(n), + VidRecord { + fp: f(2), + parents: vec![] + } + )); + } + assert_eq!(s.known.len(), MAX_KNOWN); + assert!(s.known.contains_key(&s.head)); + assert!(!s.remember( + v(1), + VidRecord { + fp: f(9), + parents: vec![] + } + )); +} + +fn id(n: u16) -> ChangeId { + ChangeId { + name: "key".into(), + generation: 7, + new_vid: v(n), + } +} +#[test] +fn old_ack_never_deletes_newer_entry_even_with_lower_vid() { + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(99)); + o.enqueue(p.clone(), id(1)); + assert!(o.ack(&p, &id(99), AckResult::Applied)); + assert_eq!(o.pending(&p).cloned().collect::>(), vec![id(1)]); +} +#[test] +fn newer_ack_supersedes_older_entries_for_only_that_peer_and_name() { + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + for target in [&p, &q] { + o.enqueue(target.clone(), id(99)); + o.enqueue(target.clone(), id(1)); + } + let mut other = id(0); + other.name = "other".into(); + o.enqueue(p.clone(), other.clone()); + o.ack(&p, &id(1), AckResult::Held); + assert_eq!(o.pending(&p).cloned().collect::>(), vec![other]); + assert_eq!(o.pending(&q).count(), 2); + assert!(!o.snapshot_releasable("key", v(99))); + o.ack(&q, &id(1), AckResult::Conflict); + assert!(o.snapshot_releasable("key", v(99))); +} +#[test] +fn deferred_and_unknown_ack_preserve_queue_and_snapshot() { + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(1)); + assert!(!o.ack(&p, &id(1), AckResult::DeferredCapacity)); + assert!(!o.ack(&p, &id(2), AckResult::Applied)); + let mut wrong = id(1); + wrong.generation += 1; + assert!(!o.ack(&p, &wrong, AckResult::Applied)); + assert_eq!(o.pending(&p).count(), 1); + assert!(!o.snapshot_releasable("key", v(1))); +} +#[test] +fn stale_generation_marks_reoffer_and_accept_clears_it() { + let mut o = Outbox::default(); + let p = peer("a"); + o.enqueue(p.clone(), id(1)); + o.ack(&p, &id(1), AckResult::StaleGeneration); + assert_eq!(o.pending(&p).count(), 0); + assert!(o.needs_reoffer(&p, "key")); + o.accepted(&p, "key"); + assert!(!o.needs_reoffer(&p, "key")); +} +#[test] +fn snapshots_wait_for_all_targets_even_with_different_generations() { + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + let mut other = id(1); + other.generation = 22; + o.enqueue(p.clone(), id(1)); + o.enqueue(q.clone(), other.clone()); + o.ack(&p, &id(1), AckResult::Rejected); + assert!(!o.snapshot_releasable("key", v(1))); + o.ack(&q, &other, AckResult::Applied); + assert!(o.snapshot_releasable("key", v(1))); + assert!(o.release_snapshot("key", v(1))); + assert!(!o.snapshot_releasable("key", v(1))); +} +#[test] +fn ack_discriminant_order_and_finality() { + for (n, result) in [ + AckResult::Applied, + AckResult::Held, + AckResult::Conflict, + AckResult::StaleGeneration, + AckResult::DeferredCapacity, + AckResult::Rejected, + ] + .into_iter() + .enumerate() + { + assert_eq!(result as usize, n); + assert_eq!(result.is_final(), n != 4); + } +} + +fn journal() -> RemoteJournalRecord { + RemoteJournalRecord { + change_id: id(2), + sender: peer("a"), + prev_fp: f(1), + new_fp: f(2), + head: v(2), + lineage: Lineage::new([v(1), v(2)]), + approval_key: None, + ack: AckResult::Applied, + checkpoint_slot: Some("checkpoint".into()), + candidate_slot: "candidate".into(), + } +} +#[test] +fn remote_recovery_finish() { + assert_eq!( + recover_remote(&journal(), f(2)), + RemoteRecovery::FinishFromStep4 + ); +} +#[test] +fn remote_recovery_retry() { + assert_eq!(recover_remote(&journal(), f(1)), RemoteRecovery::Retry); +} +#[test] +fn remote_recovery_conflict() { + assert_eq!(recover_remote(&journal(), f(3)), RemoteRecovery::Conflict); +} +#[test] +fn local_row1_rebuild_snapshot() { + assert_eq!( + recover_local(f(1), f(2), f(2), false, false), + LocalRecovery::RebuildSnapshotAndCommit + ); +} +#[test] +fn local_row2_commit_existing_snapshot() { + assert_eq!( + recover_local(f(1), f(2), f(2), false, true), + LocalRecovery::Commit + ); +} +#[test] +fn local_row3_clean_committed_journal() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(2), true, snapshot), + LocalRecovery::CleanJournal + ); + } +} +#[test] +fn local_row4_keep_queued_snapshot_and_scan() { + for current in [f(1), f(3)] { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), current, true, snapshot), + LocalRecovery::KeepSnapshotAndScan + ); + } + } +} +#[test] +fn local_row5_discard_uncommitted_snapshot() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(1), false, snapshot), + LocalRecovery::DiscardSnapshot + ); + } +} +#[test] +fn local_row6_discard_and_scan_other_value() { + for snapshot in [false, true] { + assert_eq!( + recover_local(f(1), f(2), f(3), false, snapshot), + LocalRecovery::DiscardSnapshotAndScan + ); + } +} +#[test] +fn journal_records_round_trip_and_equal_fps_prefer_finished_write() { + let r = journal(); + assert_eq!( + r, + serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap() + ); + let l = LocalJournalRecord { + name: "key".into(), + prev_fp: f(1), + new_fp: f(2), + new_vid: v(2), + parents: vec![v(1)], + snapshot_slot: "snapshot".into(), + targets: vec![QueueTarget { + peer: peer("a"), + generation: 7, + }], + }; + assert_eq!( + l, + serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap() + ); + let mut r = r; + r.prev_fp = r.new_fp; + assert_eq!( + recover_remote(&r, r.new_fp), + RemoteRecovery::FinishFromStep4 + ); +} + +#[test] +fn limiter_one_noninteractive_overwrite_per_item_per_24h_across_peers() { + let mut l = Limiter::default(); + let p = peer("a"); + let q = peer("b"); + assert_eq!( + l.check(&p, "key", RemoteOperation::Overwrite, 0, 100, false), + LimitResult::Allowed + ); + l.record(&p, "key", RemoteOperation::Overwrite, 0, false); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, false), + LimitResult::ItemLimited + ); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86399, 100, true), + LimitResult::Allowed + ); + assert_eq!( + l.check(&q, "key", RemoteOperation::Overwrite, 86400, 100, false), + LimitResult::Allowed + ); +} +#[test] +fn limiter_overwrite_and_retire_thresholds_are_strict_and_latched() { + for (op, cap) in [ + (RemoteOperation::Overwrite, 5), + (RemoteOperation::Retire, 3), + ] { + let mut l = Limiter::default(); + let p = peer("a"); + for n in 0..cap { + let name = format!("key{n}"); + assert_eq!(l.check(&p, &name, op, 0, 100, false), LimitResult::Allowed); + l.record(&p, &name, op, 0, false); + } + assert_eq!( + l.check(&p, "extra", op, 0, 100, false), + LimitResult::PeerTripped + ); + assert_eq!( + l.check(&p, "other", op, 200000, 100, true), + LimitResult::PeerTripped + ); + l.human_reset(&p); + assert_eq!( + l.check(&p, "extra", op, 200000, 100, false), + LimitResult::Allowed + ); + } +} +#[test] +fn limiter_percentage_only_at_eight_and_counts_distinct_affected_names() { + for size in [7, 8, 9] { + let mut l = Limiter::default(); + let p = peer("a"); + for name in ["a", "b"] { + l.record(&p, name, RemoteOperation::Overwrite, 0, false); + } + assert_eq!( + l.check(&p, "c", RemoteOperation::Retire, 0, size, false), + if size < 8 { + LimitResult::Allowed + } else { + LimitResult::PeerTripped + } + ); + } + let mut l = Limiter::default(); + let p = peer("a"); + for _ in 0..3 { + l.record(&p, "same", RemoteOperation::Overwrite, 0, true); + } + assert_eq!( + l.check(&p, "same", RemoteOperation::Overwrite, 0, 8, true), + LimitResult::Allowed + ); +} +#[test] +fn limiter_clock_rollback_expiry_and_serde() { + let mut l = Limiter::default(); + let p = peer("a"); + l.record(&p, "key", RemoteOperation::Overwrite, i64::MAX, false); + let mut l: Limiter = serde_json::from_str(&serde_json::to_string(&l).unwrap()).unwrap(); + assert_eq!( + l.check(&p, "key", RemoteOperation::Overwrite, i64::MIN, 100, false), + LimitResult::ItemLimited + ); + let mut l = Limiter::default(); + l.record(&p, "key", RemoteOperation::Overwrite, 0, false); + l.prune(WINDOW_SECS); + assert_eq!( + l.check( + &p, + "key", + RemoteOperation::Overwrite, + WINDOW_SECS, + 100, + false + ), + LimitResult::Allowed + ); +} +#[test] +fn slot_capacity_floor_and_priority() { + assert_eq!(SlotBudget::new(0).capacity(), 16); + assert_eq!(SlotBudget::new(5).capacity(), 20); + assert!( + SlotKind::Checkpoint > SlotKind::ConflictCandidate + && SlotKind::ConflictCandidate > SlotKind::Held + && SlotKind::Held > SlotKind::Proposal + ); + let mut b = SlotBudget::new(0); + for n in 0..16 { + assert!(matches!( + b.reserve(&format!("p{n:02}"), SlotKind::Proposal), + Reservation::Reserved { .. } + )); + } + assert_eq!(b.reserve("p-new", SlotKind::Proposal), Reservation::Refused); + assert_eq!(b.reserve("h-new", SlotKind::Held), Reservation::Refused); + assert_eq!( + b.reserve("candidate", SlotKind::ConflictCandidate), + Reservation::Reserved { + evicted: Some("p00".into()) + } + ); + assert_eq!( + b.reserve("checkpoint", SlotKind::Checkpoint), + Reservation::Reserved { + evicted: Some("p01".into()) + } + ); + assert!(!b.release("checkpoint")); + assert!(b.release("candidate")); + assert_eq!(b.used(), 15); +} +#[test] +fn checkpoints_and_unacked_snapshots_are_never_evicted() { + let mut b = SlotBudget::new(0); + for n in 0..8 { + b.reserve(&format!("c{n}"), SlotKind::Checkpoint); + b.reserve_snapshot(&format!("s{n}")); + } + assert_eq!(b.reserve("new", SlotKind::Checkpoint), Reservation::Refused); + assert!(matches!( + b.prepare_overwrite("new", "held"), + OverwriteCapacity::Deferred(Decision { + ack: AckResult::DeferredCapacity, + .. + }) + )); + assert!(matches!( + b.prepare_overwrite("c0", "held"), + OverwriteCapacity::Ready { .. } + )); +} +#[test] +fn checkpoint_reservation_failure_holds_when_hold_can_be_retained() { + let mut b = SlotBudget::new(0); + b.reserve("occupied", SlotKind::Held); + let OverwriteCapacity::Held(d) = b.prepare_overwrite("occupied", "held") else { + panic!() + }; + held(&d, HoldReason::OverLimit); + assert_eq!(b.kind("held"), Some(SlotKind::Held)); +} +#[test] +fn checkpoint_changes_only_on_first_capture_or_human_confirmation() { + let mut cp = Checkpoint::default(); + assert_eq!(cp.before_remote_overwrite(f(1)), f(1)); + for n in 2..100 { + assert_eq!(cp.before_remote_overwrite(f(n)), f(1)); + } + cp.human_confirm(f(99)); + assert_eq!(cp.before_remote_overwrite(f(100)), f(99)); + let cp2: Checkpoint = serde_json::from_str(&serde_json::to_string(&cp).unwrap()).unwrap(); + assert_eq!(cp, cp2); +} +#[test] +fn generations_are_receiver_owned_scoped_and_bumped_on_rm() { + let mut g = Generations::default(); + let a = peer("a"); + let b = peer("b"); + assert_eq!(g.outgoing_generation(&a, "key"), None); + let accept = g.accept("key", a.clone()); + assert_eq!(accept.generation, 1); + assert!(g.includes("key", &a)); + assert!(!g.includes("key", &b)); + let (leave, peers) = g.rm("key").unwrap(); + assert_eq!(leave.generation, 2); + assert_eq!(peers.len(), 1); + assert!(!g.includes("key", &a)); + let accept = g.accept("key", b.clone()); + assert_eq!(accept.generation, 2); + assert!(g.includes("key", &b)); +} +#[test] +fn accept_leave_ignore_older_generations_and_require_reacceptance() { + let mut g = Generations::default(); + let p = peer("a"); + let msg = |generation| Registration { + name: "key".into(), + generation, + }; + g.received_accept(p.clone(), msg(2)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); + g.received_leave(p.clone(), msg(3)); + assert_eq!(g.outgoing_generation(&p, "key"), None); + assert!(!g.received_accept(p.clone(), msg(2))); + assert_eq!(g.outgoing_generation(&p, "key"), None); + g.received_accept(p.clone(), msg(3)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); + assert!(!g.received_leave(p.clone(), msg(2))); + let g: Generations = serde_json::from_str(&serde_json::to_string(&g).unwrap()).unwrap(); + assert_eq!(g.outgoing_generation(&p, "key"), Some(3)); +} + +#[test] +fn item_state_and_outbox_round_trip_through_sync_json() { + let s = conflicted(); + assert_eq!( + s, + serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap() + ); + let mut o = Outbox::default(); + let p = peer("a"); + let q = peer("b"); + o.enqueue(p.clone(), id(1)); + o.enqueue(q.clone(), id(1)); + o.ack(&p, &id(1), AckResult::Held); + let mut restored: Outbox = serde_json::from_str(&serde_json::to_string(&o).unwrap()).unwrap(); + assert_eq!(restored.pending(&p).count(), 0); + assert_eq!(restored.pending(&q).count(), 1); + assert!(!restored.snapshot_releasable("key", v(1))); + restored.ack(&q, &id(1), AckResult::Applied); + assert!(restored.snapshot_releasable("key", v(1))); +} +#[test] +fn known_cache_deserialization_rejects_unbounded_or_ambiguous_bindings() { + let mut s = state(); + for n in 2..260 { + s.known.insert( + v(n), + VidRecord { + fp: f(2), + parents: vec![], + }, + ); + } + assert!(serde_json::from_str::(&serde_json::to_string(&s).unwrap()).is_err()); + let mut json = serde_json::to_value(state()).unwrap(); + let known = json["known"].as_array_mut().unwrap(); + known.push(known[0].clone()); + assert!(serde_json::from_value::(json).is_err()); +} +#[test] +fn slot_budget_round_trip_retains_snapshot_pins() { + let mut b = SlotBudget::new(0); + for n in 0..16 { + b.reserve_snapshot(&format!("s{n}")); + } + let mut b: SlotBudget = serde_json::from_str(&serde_json::to_string(&b).unwrap()).unwrap(); + assert_eq!( + b.reserve("checkpoint", SlotKind::Checkpoint), + Reservation::Refused + ); +} + +#[test] +fn accepted_generation_starts_at_one_and_known_generation_survives_leave() { + let mut g = Generations::default(); + let p = peer("a"); + assert_eq!(g.generation("key"), 0); + assert_eq!(g.known_generation(&p, "key"), 0); + let accepted = g.accept("key", p.clone()); + assert_eq!(accepted.generation, 1); + g.received_accept(p.clone(), accepted); + assert_eq!(g.known_generation(&p, "key"), 1); + g.received_leave( + p.clone(), + Registration { + name: "key".into(), + generation: 2, + }, + ); + assert_eq!(g.known_generation(&p, "key"), 2); + assert_eq!(g.outgoing_generation(&p, "key"), None); +} + +#[test] +fn reordered_leave_cannot_undo_reacceptance_of_the_same_generation() { + let mut g = Generations::default(); + let p = peer("a"); + let r = Registration { + name: "key".into(), + generation: 2, + }; + assert!(g.received_accept(p.clone(), r.clone())); + assert!(!g.received_leave(p.clone(), r)); + assert_eq!(g.outgoing_generation(&p, "key"), Some(2)); +} + +#[test] +fn complete_unsigned_resolve_is_held_even_if_peer_missed_the_conflict() { + let s = state(); + let mut i = incoming(); + i.parents = vec![s.head, v(99)]; + i.value_fp = Some(f(1)); + let d = decide(&s, f(1), &i, false, None, true); + assert_eq!(d.ack, AckResult::Held); + assert!(matches!( + d.transition, + Transition::Hold { + reason: HoldReason::Resolve + } + )); +} + +#[test] +fn convergence_cannot_inject_another_peers_future_vid() { + let mut a = state(); + let mut from_b = incoming(); + from_b.value_fp = Some(f(1)); + from_b.lineage = Lineage::new([v(1), v(2), v(99)]); + let Transition::Advance { head, lineage, .. } = run(&a, &from_b).transition else { + panic!() + }; + assert!(!lineage.contains(&v(99))); + a.head = head; + a.lineage = lineage; + let mut from_c = incoming(); + from_c.new_vid = v(99); + from_c.parents = vec![v(0)]; + from_c.value_fp = Some(f(3)); + let d = run(&a, &from_c); + assert_eq!(d.ack, AckResult::Conflict); + assert!(matches!(d.transition, Transition::Conflict { .. })); +} + +#[test] +fn convergence_pins_both_heads_below_full_lineage() { + let mut s = state(); + s.lineage = Lineage::new((100..164).map(v)).with_head(s.head); + let mut i = incoming(); + i.value_fp = Some(f(1)); + for new_vid in [v(0), v(2)] { + i.new_vid = new_vid; + let Transition::Advance { head, lineage, .. } = run(&s, &i).transition else { + panic!() + }; + assert_eq!(head, s.head.max(new_vid)); + assert_eq!(lineage.len(), 64); + assert!(lineage.contains(&s.head)); + assert!(lineage.contains(&new_vid)); + } +} + +#[test] +fn approved_resolve_records_all_parents_and_late_candidates_are_stale() { + let mut s = conflicted(); + let mut i = incoming(); + i.parents = vec![v(1), v(3), v(4), v(99)]; + i.lineage = Lineage::new([v(77)]); + let d = decide( + &s, + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { + head, + lineage, + clear_conflict: true, + .. + } = d.transition + else { + panic!() + }; + assert!(lineage.contains(&v(77))); + for parent in &i.parents { + assert!(lineage.contains(parent)); + } + s.head = head; + s.lineage = lineage; + s.conflict = None; + for (vid, fp) in [(v(3), f(3)), (v(4), f(4)), (v(99), f(99))] { + let late = Incoming { + new_vid: vid, + parents: vec![v(0)], + value_fp: Some(fp), + ..incoming() + }; + let d = decide(&s, f(2), &late, false, None, true); + assert_eq!(d.ack, AckResult::Applied); + assert_eq!(d.transition, Transition::Unchanged); + } +} + +#[test] +fn approved_fast_forward_merges_sender_lineage() { + let mut i = incoming(); + i.lineage = Lineage::new([v(99)]); + let d = decide( + &state(), + f(1), + &i, + false, + Some(&VerifiedApproval::for_tests()), + true, + ); + let Transition::Advance { lineage, .. } = d.transition else { + panic!() + }; + assert!(lineage.contains(&v(99))); +} + +#[test] +fn slot_budget_shrink_preserves_slots_and_refuses_new_reservations() { + let mut b = SlotBudget::new(5); + for n in 0..20 { + b.reserve(&format!("p{n}"), SlotKind::Proposal); + } + b.set_items(0); + assert_eq!(b.capacity(), 16); + assert_eq!(b.used(), 20); + for n in 0..20 { + assert_eq!(b.kind(&format!("p{n}")), Some(SlotKind::Proposal)); + } + for kind in [ + SlotKind::Proposal, + SlotKind::Held, + SlotKind::ConflictCandidate, + SlotKind::Checkpoint, + ] { + assert_eq!(b.reserve("new", kind), Reservation::Refused); + } + assert_eq!( + b.reserve("p0", SlotKind::Proposal), + Reservation::Reserved { evicted: None } + ); + for n in 0..5 { + assert!(b.release(&format!("p{n}"))); + } + assert_eq!( + b.reserve("held", SlotKind::Held), + Reservation::Reserved { evicted: None } + ); + b.set_items(6); + assert_eq!(b.capacity(), 24); + assert_eq!( + b.reserve("new", SlotKind::Proposal), + Reservation::Reserved { evicted: None } + ); + b.set_items(usize::MAX); + assert_eq!(b.capacity(), usize::MAX); +} + +#[test] +fn prepare_hold_reserves_or_defers_without_eviction() { + let mut b = SlotBudget::new(0); + let OverwriteCapacity::Held(d) = b.prepare_hold("held", HoldReason::Frozen) else { + panic!() + }; + held(&d, HoldReason::Frozen); + for n in 0..15 { + b.reserve(&format!("p{n}"), SlotKind::Proposal); + } + let OverwriteCapacity::Deferred(d) = b.prepare_hold("new", HoldReason::NoApproval) else { + panic!() + }; + assert_eq!(d.ack, AckResult::DeferredCapacity); + assert_eq!(d.transition, Transition::Unchanged); + assert!(!d.ack.is_final()); + assert_eq!(b.used(), 16); + assert_eq!(b.kind("new"), None); + assert_eq!(b.kind("p0"), Some(SlotKind::Proposal)); + assert!(matches!( + b.prepare_hold("held", HoldReason::NoApproval), + OverwriteCapacity::Held(_) + )); +} + +#[test] +fn checkpoint_failure_reuses_existing_hold_at_capacity() { + let mut b = SlotBudget::new(0); + for n in 0..15 { + b.reserve_snapshot(&format!("s{n}")); + } + b.reserve("held", SlotKind::Held); + let OverwriteCapacity::Held(d) = b.prepare_overwrite("s0", "held") else { + panic!() + }; + held(&d, HoldReason::OverLimit); + assert!(matches!( + b.prepare_overwrite("s0", "new"), + OverwriteCapacity::Deferred(_) + )); + assert_eq!(b.used(), 16); +} + +#[test] +fn removing_one_scope_peer_preserves_generation_and_other_peers() { + let mut g = Generations::default(); + g.rm("key").unwrap(); + g.accept("key", peer("a")); + g.accept("key", peer("b")); + g.accept("other", peer("a")); + let (leave, target) = g.remove_peer("key", &peer("a")).unwrap(); + assert_eq!(target, peer("a")); + assert_eq!( + leave, + Registration { + name: "key".into(), + generation: 1 + } + ); + assert_eq!(g.generation("key"), 1); + assert!(!g.includes("key", &peer("a"))); + assert!(g.includes("key", &peer("b"))); + assert!(g.includes("other", &peer("a"))); + assert_eq!(g.remove_peer("key", &peer("a")), None); + assert_eq!(g.remove_peer("missing", &peer("a")), None); + assert_eq!(g.accept("key", peer("a")).generation, 1); +} diff --git a/crates/kc-sync/tests/simulation.rs b/crates/kc-sync/tests/simulation.rs new file mode 100644 index 0000000..e0afaad --- /dev/null +++ b/crates/kc-sync/tests/simulation.rs @@ -0,0 +1,574 @@ +//! Seeded in-memory transport and persistence adapter; production policy comes from kc-sync. +use kc_sync::*; +use rand::{Rng, SeedableRng, rngs::StdRng}; +use std::collections::BTreeMap; + +fn peer(n: usize) -> PeerId { + PeerId(format!("device-{n}")) +} +fn id(i: &Incoming) -> ChangeId { + ChangeId { + name: "key".into(), + generation: i.generation, + new_vid: i.new_vid, + } +} +fn fp(n: u64) -> Fp { + let mut bytes = [0; 32]; + bytes[..8].copy_from_slice(&n.to_be_bytes()); + Fp(bytes) +} +fn slot(v: Vid) -> String { + format!("{v:?}") +} + +struct Device { + state: ItemState, + value: Option, + checkpoint: Checkpoint, + slots: SlotBudget, + held: BTreeMap, + receipts: BTreeMap<(usize, Vid), AckResult>, + outbox: Outbox, + sent: BTreeMap, + generations: Generations, +} +impl Device { + fn new() -> Self { + Self { + state: ItemState::new(0, Vid([0; 16]), fp(0), vec![]), + value: Some(fp(0)), + checkpoint: Checkpoint::default(), + slots: SlotBudget::new(1024), + held: BTreeMap::new(), + receipts: BTreeMap::new(), + outbox: Outbox::default(), + sent: BTreeMap::new(), + generations: Generations::default(), + } + } + + // This adapter only executes Transition intents; it contains no independent sync decisions. + fn commit(&mut self, incoming: &Incoming, decision: Decision) { + let before = self.value; + let checkpoint_before = self.checkpoint.fingerprint(); + match decision.transition { + Transition::Unchanged => {} + Transition::Hold { .. } => { + assert!(matches!( + self.slots.reserve(&slot(incoming.new_vid), SlotKind::Held), + Reservation::Reserved { .. } + )); + self.held.insert(incoming.new_vid, incoming.clone()); + } + Transition::Conflict { candidates } => { + for vid in candidates.candidates.keys() { + // A previously held slot is promoted by releasing its reservation first. + if self.slots.kind(&slot(*vid)) == Some(SlotKind::Held) { + self.slots.release(&slot(*vid)); + } + assert!(matches!( + self.slots.reserve(&slot(*vid), SlotKind::ConflictCandidate), + Reservation::Reserved { .. } + )); + } + self.state.conflict = Some(candidates); + } + Transition::Advance { + head, + lineage, + write_value, + clear_conflict, + } => { + if write_value { + assert!(matches!( + self.slots.prepare_overwrite("checkpoint", "held-fallback"), + OverwriteCapacity::Ready { .. } + )); + self.checkpoint.before_remote_overwrite(self.value.unwrap()); + self.value = incoming.value_fp; + } + self.state.head = head; + self.state.lineage = lineage; + assert!(self.state.remember( + incoming.new_vid, + VidRecord { + fp: incoming.value_fp.unwrap(), + parents: incoming.parents.clone() + } + )); + if clear_conflict { + self.state.conflict = None; + } + } + Transition::Retire => { + // §2.5 only changes registration metadata. There is deliberately no value deletion. + self.state.generation += 1; + } + } + assert!( + before.is_some() && self.value.is_some(), + "remote event deleted a value" + ); + if checkpoint_before.is_some() { + assert_eq!( + self.checkpoint.fingerprint(), + checkpoint_before, + "remote event replaced a checkpoint" + ); + } + } + + fn receive(&mut self, from: usize, incoming: &Incoming) -> AckResult { + if let Some(ack) = self.receipts.get(&(from, incoming.new_vid)) { + return *ack; + } + let d = decide( + &self.state, + self.value.unwrap(), + incoming, + false, + None, + true, + ); + let ack = d.ack; + self.commit(incoming, d); + if ack.is_final() { + self.receipts.insert((from, incoming.new_vid), ack); + } + ack + } + + fn review(&mut self, rng: &mut StdRng, stats: &mut Stats) { + let Some(vid) = self + .held + .keys() + .nth(rng.random_range(0..self.held.len().max(1))) + .copied() + else { + return; + }; + let incoming = self.held.remove(&vid).unwrap(); + self.slots.release(&slot(vid)); + let old_checkpoint = self.checkpoint.fingerprint(); + if rng.random_bool(0.5) { + stats.accepted += 1; + // The simulated human is the only caller providing the test approval marker. + let approval = VerifiedApproval::for_tests(); + let d = decide( + &self.state, + self.value.unwrap(), + &incoming, + false, + Some(&approval), + true, + ); + self.commit(&incoming, d); + } else { + stats.rejected += 1; + } + // Human review does not implicitly confirm a new checkpoint baseline. + if old_checkpoint.is_some() { + assert_eq!(old_checkpoint, self.checkpoint.fingerprint()); + } + } +} + +#[derive(Clone)] +enum Message { + Change { + from: usize, + to: usize, + incoming: Incoming, + }, + Ack { + from: usize, + to: usize, + change: ChangeId, + result: AckResult, + }, +} +#[derive(Clone)] +struct Envelope { + due: u64, + message: Message, +} +#[derive(Default)] +struct Stats { + dropped: usize, + duplicated: usize, + reordered: usize, + delayed: usize, + accepted: usize, + rejected: usize, + retired: usize, +} +struct Created { + owner: usize, + vid: Vid, + fp: Fp, + sequence: u64, +} + +struct World { + rng: StdRng, + devices: Vec, + queue: Vec, + created: Vec, + tick: u64, + sequence: u64, + stats: Stats, +} +impl World { + fn new(seed: u64) -> Self { + let count = 3 + (seed as usize % 2); + let mut devices: Vec<_> = (0..count).map(|_| Device::new()).collect(); + for device in &mut devices { + for target in 0..count { + device.generations.received_accept( + peer(target), + Registration { + name: "key".into(), + generation: 0, + }, + ); + } + } + Self { + rng: StdRng::seed_from_u64(seed), + devices, + queue: vec![], + created: vec![], + tick: 0, + sequence: 0, + stats: Stats::default(), + } + } + fn schedule(&mut self, message: Message) { + let delay = self.rng.random_range(1..=12); + self.stats.delayed += usize::from(delay > 1); + self.queue.push(Envelope { + due: self.tick + delay, + message, + }); + } + fn edit(&mut self, owner: usize) { + self.sequence += 1; + let vid = Vid(self.rng.random()); + let value = fp(self.sequence); + assert!(!self.created.iter().any(|c| c.vid == vid)); + let targets = self.devices.len(); + let device = &mut self.devices[owner]; + let parents = vec![device.state.head]; + device.state.head = vid; + device.state.lineage = device.state.lineage.clone().with_head(vid); + device.state.remember( + vid, + VidRecord { + fp: value, + parents: parents.clone(), + }, + ); + // Local edits cannot silently resolve existing conflicts: retain their new head as a candidate. + if let Some(c) = &mut device.state.conflict { + c.candidates.insert( + vid, + VidRecord { + fp: value, + parents: parents.clone(), + }, + ); + } + device.value = Some(value); + let incoming = Incoming { + generation: 0, + new_vid: vid, + parents, + lineage: device.state.lineage.clone(), + value_fp: Some(value), + retire: false, + }; + device.sent.insert(vid, incoming.clone()); + assert!(matches!( + device + .slots + .reserve_snapshot(&format!("send-{}", slot(vid))), + Reservation::Reserved { .. } + )); + let mut messages = vec![]; + for target in 0..targets { + if target != owner { + let mut outgoing = incoming.clone(); + outgoing.generation = device + .generations + .outgoing_generation(&peer(target), "key") + .unwrap(); + device.outbox.enqueue(peer(target), id(&outgoing)); + messages.push(Message::Change { + from: owner, + to: target, + incoming: outgoing, + }); + } + } + self.created.push(Created { + owner, + vid, + fp: value, + sequence: self.sequence, + }); + for message in messages { + self.schedule(message); + } + } + fn retry_pending(&mut self) { + let mut retry = vec![]; + for (from, device) in self.devices.iter().enumerate() { + for to in 0..self.devices.len() { + for change in device.outbox.pending(&peer(to)) { + let mut incoming = device.sent[&change.new_vid].clone(); + incoming.generation = change.generation; + retry.push(Message::Change { from, to, incoming }); + } + } + } + for message in retry { + self.schedule(message); + } + } + fn deliver(&mut self, lossy: bool) -> bool { + let eligible: Vec<_> = self + .queue + .iter() + .enumerate() + .filter(|(_, e)| e.due <= self.tick) + .map(|(n, _)| n) + .collect(); + if eligible.is_empty() { + return false; + } + let index = eligible[self.rng.random_range(0..eligible.len())]; + self.stats.reordered += usize::from(index != 0); + let envelope = self.queue.remove(index); + if lossy && self.rng.random_bool(0.20) { + self.stats.dropped += 1; + return true; + } + if lossy && self.rng.random_bool(0.15) { + self.stats.duplicated += 1; + self.schedule(envelope.message.clone()); + } + match envelope.message { + Message::Change { from, to, incoming } => { + let result = self.devices[to].receive(from, &incoming); + self.schedule(Message::Ack { + from: to, + to: from, + change: id(&incoming), + result, + }); + } + Message::Ack { + from, + to, + change, + result, + } => { + let d = &mut self.devices[to]; + d.outbox.ack(&peer(from), &change, result); + let release: Vec<_> = d + .sent + .keys() + .copied() + .filter(|vid| d.outbox.snapshot_releasable("key", *vid)) + .collect(); + for vid in release { + assert!(d.outbox.release_snapshot("key", vid)); + d.slots.release(&format!("send-{}", slot(vid))); + } + } + } + true + } + fn assert_preserved(&self, seed: u64) { + for c in &self.created { + let superseded_locally = self + .created + .iter() + .any(|later| later.owner == c.owner && later.sequence > c.sequence); + let preserved = self.devices.iter().any(|d| { + d.value == Some(c.fp) + || d.held.values().any(|h| h.value_fp == Some(c.fp)) + || d.state + .conflict + .as_ref() + .is_some_and(|set| set.candidates.values().any(|r| r.fp == c.fp)) + }); + assert!( + superseded_locally || preserved, + "seed {seed}: lost local value {:?} from {}", + c.vid, + c.owner + ); + } + for d in &self.devices { + assert!(d.value.is_some()); + } + } + fn quiesce(&mut self) { + self.retry_pending(); + for _ in 0..20000 { + self.tick += 1; + while self.deliver(false) {} + for d in &mut self.devices { + d.review(&mut self.rng, &mut self.stats); + } + if self.queue.is_empty() { + let pending = self.devices.iter().any(|d| { + (0..self.devices.len()).any(|p| d.outbox.pending(&peer(p)).next().is_some()) + }); + if pending { + self.retry_pending(); + } else { + return; + } + } + } + panic!("transport did not quiesce"); + } +} + +#[test] +fn seeded_lossy_multi_device_simulation_256_seeds() { + let mut totals = Stats::default(); + for seed in 0..256 { + let mut w = World::new(seed); + // An initial causal edit exercises genuine Phase-1 holds and human accept/reject. + w.edit(0); + for _ in 0..30 { + w.tick += 1; + w.deliver(true); + for d in &mut w.devices { + d.review(&mut w.rng, &mut w.stats); + } + w.assert_preserved(seed); + } + w.quiesce(); + // Retire is delivered through the same decision path and changes registration, never value. + let d = &mut w.devices[1]; + let before = d.value; + let retire = Incoming { + generation: 0, + new_vid: Vid(w.rng.random()), + parents: vec![d.state.head], + lineage: d.state.lineage.clone(), + value_fp: None, + retire: true, + }; + assert_eq!(d.receive(0, &retire), AckResult::Held); + d.held.remove(&retire.new_vid); + d.slots.release(&slot(retire.new_vid)); + let token = VerifiedApproval::for_tests(); + let decision = decide( + &d.state, + d.value.unwrap(), + &retire, + false, + Some(&token), + true, + ); + assert_eq!(decision.transition, Transition::Retire); + d.commit(&retire, decision); + assert_eq!(before, d.value); + w.stats.retired += 1; + // A fresh human registration exchange reinstates the receiver-owned generation. + let mut generations = Generations::default(); + generations.rm("key").unwrap(); + let accept = generations.accept("key", peer(0)); + assert_eq!(accept.generation, d.state.generation); + // Every sender records the receiver's new Accept; generations never move backwards. + for device in &mut w.devices { + device.generations.received_accept(peer(1), accept.clone()); + } + // Every device makes independent local edits before network delivery; then edits interleave + // with transport. This creates true concurrent branches rather than serial overwrite tests. + for owner in 0..w.devices.len() { + for _ in 0..w.rng.random_range(1..=4) { + w.edit(owner); + } + } + for step in 0..120 { + w.tick += 1; + match w.rng.random_range(0..10) { + 0..=1 => { + let owner = w.rng.random_range(0..w.devices.len()); + w.edit(owner); + } + 2 => { + let owner = w.rng.random_range(0..w.devices.len()); + w.devices[owner].review(&mut w.rng, &mut w.stats); + } + 3 => { + let owner = w.rng.random_range(0..w.devices.len()); + let d = &mut w.devices[owner]; + d.checkpoint.human_confirm(d.value.unwrap()); + assert_eq!(d.checkpoint.fingerprint(), d.value); + } + _ => { + w.deliver(true); + } + } + if step % 23 == 0 { + w.retry_pending(); + } + w.assert_preserved(seed); + } + w.quiesce(); + w.assert_preserved(seed); + for (a_index, a) in w.devices.iter().enumerate() { + assert!(a.held.is_empty()); + for (b_index, b) in w.devices.iter().enumerate().skip(a_index + 1) { + let equal = a.state.head == b.state.head && a.value == b.value; + let conflict = a + .state + .conflict + .as_ref() + .is_some_and(|c| c.candidates.contains_key(&b.state.head)) + || b.state + .conflict + .as_ref() + .is_some_and(|c| c.candidates.contains_key(&a.state.head)); + assert!( + equal || conflict, + "seed {seed}: devices {a_index}/{b_index} silently diverged" + ); + } + for p in 0..w.devices.len() { + assert_eq!(a.outbox.pending(&peer(p)).count(), 0); + } + } + assert!(w.queue.is_empty()); + totals.dropped += w.stats.dropped; + totals.duplicated += w.stats.duplicated; + totals.reordered += w.stats.reordered; + totals.delayed += w.stats.delayed; + totals.accepted += w.stats.accepted; + totals.rejected += w.stats.rejected; + totals.retired += w.stats.retired; + } + assert!( + totals.dropped > 0 && totals.duplicated > 0 && totals.reordered > 0 && totals.delayed > 0 + ); + assert!(totals.accepted > 0 && totals.rejected > 0 && totals.retired == 256); + // Keep actual coverage visible when this test is run with --nocapture. + println!( + "256 seeds: dropped={}, duplicated={}, reordered={}, delayed={}, accepted={}, rejected={}, retired={}", + totals.dropped, + totals.duplicated, + totals.reordered, + totals.delayed, + totals.accepted, + totals.rejected, + totals.retired + ); +} diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index d2587f0..ac6439e 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -146,6 +146,71 @@ PairOffer { suggested_label: String, device_pk: [u8; 32], inbox_id: [u8; 16 - `kc device rotate` creates a new key and a new inbox, deletes the old inbox and asks you to re-pair. - The old private key is kept for 72 h to open messages already in flight. +### v2: sync-capable inbox messages + +The outer postcard `InboxEnvelope` has exactly the v1 fields and order above; +only `v` changes to `2`. `suite` remains `1`. A v1 reader decodes the envelope +and rejects version `2` **before decryption**. `seal` and `open` remain v1-only; +`seal_v2` writes v2 and `open_any` accepts both, mapping v1 items to `Body::Items`. + +```text +aad = postcard(v: 2, suite: 1, sender_fp, recipient_fp) +info = "kc2 inbox" || sender_fp || recipient_fp +plaintext = pad(postcard(InboxPlain2 { v: 2, msg_id: [u8;16], sender_fp, recipient_fp, + created_at: i64, expires_at: i64, body })) +Body = Items(Vec) | Sync(SyncMsg) +``` + +`enc` and `ct` are not part of AAD. HPKE auth mode and padding are unchanged. +The inner version must equal the outer version; a mismatch returns +`UnsupportedVersion(inner_v)`. Fingerprint, recipient, remembered-sender, +lifetime (0 through 72 hours on receive, 1 through 72 hours on send), 5-minute +clock skew, and replay checks are the same as v1. The encoded envelope must +fit the 256 KiB relay limit; `open_any` checks this before decoding. Duplicate +names in `Body::Items` reject the message as malformed. Values remain +zeroize-on-drop `SecretBytes`, including values in `Offer` and `Op::Put`. + +The following field and variant orders are fixed by golden vectors: + +```text +Vid = [u8;16] +ItemKind = Text | File +ChangeId { name: ItemName, generation: u64, new_vid: Vid } +Op = Put { kind: ItemKind, value: bytes } | Retire +Change { name: ItemName, generation: u64, new_vid: Vid, parents: Vec, + lineage: Vec, op: Op, approval_ref: Option<[u8;16]> } +AckResult = Applied | Held | Conflict | StaleGeneration | DeferredCapacity | Rejected +DigestEntry { name: ItemName, generation: u64, head: Vid } +SyncMsg = Hello { features: Vec, is_reply: bool } + | Offer { name: ItemName, known_generation: u64, vid: Vid, lineage: Vec, kind: ItemKind, value: bytes } + | Accept { name: ItemName, generation: u64 } + | Leave { name: ItemName, generation: u64 } + | Changes { changes: Vec } + | Ack { results: Vec<(ChangeId, AckResult)> } + | Digest { entries: Vec } + | Approvals { docs: Vec> } +``` + +- Postcard discriminants: `Body::Items = 0`, `Sync = 1`; `SyncMsg::Hello = 0` + through `Approvals = 7`; `Op::Put = 0`, `Retire = 1`; `AckResult::Applied = 0` + through `Rejected = 5`; `ItemKind::Text = 0`, `File = 1`. +- v1 `Item` has no kind field. v2 sync defines `ItemKind` separately, with the + store's text/file presentation meanings; the v1 `Item` layout is unchanged. +- `Vid` is 16 raw bytes in postcard and 32 hex characters in human-readable + formats (lowercase when written), just like `MessageId`. Fresh Vids use the + operating system CSPRNG. Generations use postcard's `u64` varint encoding. +- `Change.lineage` is limited to 64 entries on decode and validation. Names + must be unique within a `Changes` batch. Either violation rejects the entire + opened message as `Malformed`. `parents` are the sender's claimed direct + parents; approval and application policy are outside this wire layer. +- `Approvals` holds opaque reserved documents; this layer does not interpret them. +- Unknown peers' v2 capabilities are probed with one `Hello`; other sync messages + wait for its reply. Ordinary `send --to` stays v1. Sync changes must never be + downgraded to v1 items. This negotiation policy is implemented above the codec. + +Golden vectors in `crates/kc-proto/tests/inbox_v2/fixtures` freeze both body +postcard bytes and complete encrypted envelopes, including all enum variants. + ## 5. Relay rules - **Channels:** in memory. @@ -191,7 +256,28 @@ terminals and none of `CI`, `CLAUDECODE` or `--no-input` is set. | `pair`, `--remember`, `--all`, overwrite on receive or inbox | **always refused, exit 5** (`agent_code_send` doesn't change this) | allowed after showing names and peer label/SAS | | `receive` (shows a code) | allowed, conflicts skipped | allowed | -Without a TTY, kc never prompts. It exits 5 and names the missing flags. +For sync, **L** means confirmation by a human on the local device through +Touch ID (or the OS password fallback), Windows Hello, or polkit. A terminal +prompt alone is not L. Missing, denied or unavailable L returns exit 5. + +| Sync action | Non-interactive (agents, scripts) | Interactive | +|---|---|---| +| `sync`, `sync offer NAME` | allowed to queue/send changes and proposals within the already approved scope; no remote overwrite | same | +| `sync status`, `sync status --json`, `sync peer list` | allowed; no values displayed | allowed | +| `sync freeze` | allowed; holds incoming changes | allowed without L | +| `sync add NAME`, `sync rm NAME`, `sync peer add LABEL`, `sync peer rm LABEL` | refused, exit 5 | L required | +| `sync review` | refused, exit 5 | accepting proposals or held changes requires L; rejecting or leaving them for later does not | +| `sync resolve NAME --keep mine`, `sync resolve NAME --keep LABEL`, `sync restore-checkpoint NAME` | refused, exit 5 | L required | +| `sync status --confirm-checkpoint NAME`, `sync unfreeze` | refused, exit 5 | L required | + +Nothing syncs by default. Agents can create proposals and queue/send changes, +but cannot enroll items, expand sharing scope or accept remote values. Phase 1 +holds **every remote overwrite** for human review on the receiving device; +conflicts require explicit resolution. Even a resolution sent by another device +cannot bypass local review. Ordinary local writes such as `set` retain the +permissions above; their queued changes do not authorize a remote overwrite. + +Without a TTY, kc never prompts. Operations that require interaction exit 5. ## 7. Using values without leaking them @@ -217,10 +303,17 @@ Defined in `kc_wire::exit`. | 5 | interaction required | | 6 | relay unavailable or rate limited | | 7 | auth failed (bad code or MAC, tampering, replay) | -| 8 | partial | +| 8 | partial; for sync, work remains pending or blocked (proposals, held changes, conflicts, queued delivery, re-offer needed, frozen state, capacity, quarantine or a tripped limit) | | 9 | expired | -## 9. Reserved for phase 2 +## 9. Reserved for later phases + +Signed sync approvals (A/A+) and FIDO2 verification are planned for Phase 1b; +the 1pass.dev phone approver is planned for Phase 2b. None ships in this +release. Phase 1 ignores signed approval documents and never uses them to +authorize an automatic overwrite. + +The following approval lock is also reserved for phase 2: `/v1/locks/*`: an approval lock for selected items. A key share is held by the relay and released only after an authenticator code (TOTP) or a passkey diff --git a/docs/SECURITY.md b/docs/SECURITY.md index 559c231..d236758 100644 --- a/docs/SECURITY.md +++ b/docs/SECURITY.md @@ -12,11 +12,19 @@ that belong to one person, and while they sit in each device's OS keychain. | Your devices and OS keychains | the values | — | | The relay (`relay.1pass.dev`) | delivering bytes, keeping them only briefly | reading or changing values; it can drop or delay messages | | The network | nothing | everything (TLS plus end-to-end encryption) | +| A paired sync device | proposing items and sending changes within the approved scope | authorizing an overwrite on the receiving device | The relay sees client IPs, timing and message sizes. It stores no account, no long-term data, and only ciphertext: channel messages for at most 10 minutes, inbox envelopes for at most 72 hours. +Pairing does not enable sync: each item must be explicitly enrolled. A +compromised paired device can propose items and send changes, but cannot +overwrite a sync item's value without a human on the receiving device. Phase 1 +holds every remote overwrite for review or conflict resolution. Local OS +confirmation (L) uses Touch ID (or the OS password fallback), Windows Hello, +or polkit; agents cannot supply this confirmation. + ## Properties - **Code pairing:** SPAKE2 with explicit key confirmation. @@ -30,6 +38,13 @@ inbox envelopes for at most 72 hours. - kc never reads values from command-line arguments or its own environment. `kc exec --env` hands a value to a child process's environment on purpose. Only the same user (and root) can read a process environment, unlike argv, which every local user can read. - Buffers are zeroized. - `kc get` refuses to print to a terminal without `--reveal`. +- **Sync storage:** persisted values stay in OS keychain slots, including held + proposals, conflict candidates, outgoing snapshots and recovery checkpoints. + Values never go into `sync.json` or `sync.log`; they are read into zeroizing + memory for processing and end-to-end encrypted transport. Sync value + fingerprints use HMAC-SHA256 with a device-local key kept in the keychain. + They are not sent to peers or stored in public metadata; displayed sync + fingerprints compare values on one device, not across devices. - **Locked keychains:** kc reports an error instead of waiting on an OS unlock prompt, so unattended agents don't hang. ## Known limits @@ -46,6 +61,18 @@ inbox envelopes for at most 72 hours. permissions and disk encryption. - **macOS prompts:** macOS can ask "allow access" when the `kc` binary changes. Release builds are code-signed so updates keep the same identity. +- **Changes outside kc:** an external keychain change from A to B and back to A + between syncs cannot be detected. +- **Originating device lost:** devices send only changes they originate. If the + originating device disappears, a human must re-send unreceived changes as a + new local publication from a remaining copy. +- **Linux sync confirmation:** L currently uses polkit's + `org.freedesktop.policykit.exec` action, which may ask for an administrator + password. The OS policy controls authentication and caching. A kc-specific + policy is planned with the later sync installer; neither ships in Phase 1. +- **No signed sync approvals yet:** A/A+ and FIDO2 are Phase 1b work; the + 1pass.dev phone approver is Phase 2b work. They cannot authorize overwrites + in this release. - **Planned approval lock (phase 2):** selected items will need an authenticator code or a passkey before they can be read. diff --git a/docs/design/sync.md b/docs/design/sync.md new file mode 100644 index 0000000..c060779 --- /dev/null +++ b/docs/design/sync.md @@ -0,0 +1,329 @@ +# `kc sync` 설계 (초안 v0.4, 2026-10-13) + +상태: Phase 0·1 구현됨(v0.3.0). 1b 이후 미구현. +근거: Opus 설계안과 codex(gpt-6-astra) 설계안을 서로 보여 주지 않고 따로 받아 종합했다(v0.1). 이후 logi(1pass.dev) 레포 점검 결과와 codex 공격자 관점 리뷰(P1 9건·P2 6건)를 반영했다(v0.2). v0.2 재리뷰의 새 P1 4건과 부분 해결 항목을 반영했다(v0.3). v0.3 재리뷰(13건 중 10건 해결)에서 나온 착수 전 고정 계약 5개를 §12 로 정했다(v0.4). + +## 0. 확정된 사용자 결정 + +| 결정 | 내용 | +|---|---| +| D1 | kc 에 `sync` 기능을 만든다(일회성 이동이 아니라 상시 동기화) | +| D2 | 동기화 대상은 사람이 목록에서 고른다. 기본은 아무것도 동기화하지 않는다 | +| D3 | 중요한 작업은 사람 승인이 필요하다. 승인 창구는 1pass.dev(logi)다 | +| D4 | 1pass.dev 는 승인을 **전달만** 한다. 승인의 증거는 서명이고, 각 kc 기기가 직접 검증한다 | +| D5 | logi 가 보류해 둔 "기기 서명 영수증"(내용에 묶인 기기 서명)을 kc 를 계기로 시작한다 | +| D6 | logi 에는 kc 전용 승인 도메인을 새로 만든다(관례 D2). 부품은 에이전트 승인 게이트에서 가져온다 | +| D7 | TOTP 는 kc 승인 경로에 넣지 않는다. 1pass.dev 계정 로그인 2단계 인증으로만 남긴다(logi 소관) | +| D8 | 휴대폰이 없을 때는 FIDO2 보안 키(YubiKey 등)로 승인한다. 서버 없이 kc 가 직접 검증한다 | +| D9 | 휴대폰 승인 서명은 logi 패스키가 아니라 **logi 앱의 기기 고정 키**로 한다(§3.4, 2026-10-13 확정). logi 패스키는 여러 기기에 동기화되고 RP ID 를 웹과 공유해서, 장악된 1pass.dev 가 "로그인" 화면으로 위장해 승인 서명을 받아 낼 수 있다 | +| D10 | 구현은 v0.3 을 한 번 더 리뷰해 남은 부분 해결 항목을 닫은 뒤 시작한다 | + +## 1. 요약 + +- 기존 "기억된 기기" 인박스 위에 얹는다. **중계 서버(kc-relay)는 바꾸지 않는다.** +- 항목마다 직접 넣는(opt-in) 동기화다. 다른 기기가 보낸 새 항목도 **받는 기기에서 사람이 확인해야** 대상이 된다. +- 기존 값을 덮어쓰는 원격 변경은 **사람 승인 서명이 붙어 있고, 그 서명이 지금 내 값을 정확히 대체한다고 적고 있을 때만** 자동 적용한다. 그 밖에는 보류하거나 충돌로 둔다. +- 값 삭제는 다른 기기로 전파하지 않는다. 충돌은 자동으로 풀지 않고 모든 후보 값을 보존한다. +- 원격 덮어쓰기 전에 **복구 기준점**(사람이 마지막으로 확인한 값)을 따로 보존한다. 사람이 확인하기 전에는 지워지지 않는다. + +## 2. 동기화 모델 + +### 2.1 동기화 대상(sync set) +- 대상 목록은 기기마다 따로 둔다(`sync.json`). 목록 자체는 동기화하지 않는다. +- `kc sync add NAME`(L) 은 이 기기의 대상에 넣고, 다른 기기에는 **제안**을 보낸다. 받는 쪽은 값이 같든 다르든, 그 이름이 있든 없든 **제안함에만** 넣는다. `kc sync review`(L)에서 받아들여야 대상이 되고 값이 쓰인다. + - v0.1 은 "없으면 자동 생성·같으면 자동 가입"이었다. 공격 기기가 자기가 아는 값으로 등록시킨 뒤 피해 기기가 나중에 바꾼 비밀을 받아 가는 경로가 되어 없앴다(codex P1-1). +- 받아들일 때 그 이름을 **어느 기기들과** 동기화할지(기기별 범위)를 함께 정한다. 기본은 제안을 보낸 기기 하나다. +- `kc sync rm NAME` 뒤에는 그 이름의 **등록 세대**를 올린다. 이전 세대로 온 늦은 제안·변경은 무시한다(지연된 add 로 다시 등록되는 것을 막음). +- `kc sync add --from-keychain` 은 OS 키체인 항목 목록(서비스·계정 이름만, 값은 읽지 않음)을 체크리스트로 보여 주고, 고른 것만 `adopt` 해서 대상에 넣는다. 대화형으로만 한다. +- 200 KiB 를 넘는 항목은 대상에 넣지 않는다. 메시지는 **실제 직렬화 크기**로 묶어 256 KiB 를 넘지 않게 한다. 큰 항목 분할 전송은 나중 단계(§8 Phase 4). + +### 2.2 버전과 순서 +- 항목 상태 = `{head: vid(16바이트 무작위), lineage(최근 vid 64개), vid별 값 지문}`. 값 지문 = `HMAC(sys:sync-key, 이름‖종류‖값)` 이고 키는 이 기기 키체인에만 있다. 지문은 값이 같은지 비교하는 데만 쓰고 밖으로 보내지 않는다. +- **vid 는 불변이다.** 같은 vid 로 다른 값이 오면 프로토콜 위반으로 보고, 그 기기에서 온 해당 항목의 흐름을 격리한다(codex P2-10). +- 원격 변경 판정(순수 함수 `decide`): + 1. 받은 vid = 내 head → 무시(값 지문이 다르면 위반) + 2. 받은 vid 가 내 lineage 에 있음 → 낡은 변경, 무시 + 3. **승인 서명이 "parent = 내 head" 를 정확히 적고 있음** → 앞으로 감기. 한도 검사 뒤 적용 + 4. 값이 같음(지문 일치) → 수렴. 두 기기 모두 `head = max(vid_a, vid_b)` 로 맞추고, 각자 자기 lineage 에 두 head 만 더한다. 보낸 쪽 lineage 는 가져오지 않으며 쓰기는 없다 + 5. 그 밖 → 충돌 +- v0.1 은 보낸 쪽이 주장하는 lineage 만 보고 앞으로 감기를 허용했다. 뚫린 기기가 lineage 에 내 head 를 끼워 넣으면 충돌이 덮어쓰기로 바뀐다(codex P1-4). v0.2 에서는 **승인 서명에 묶인 parent 만** 믿고, lineage 는 낡은 변경을 거르는 데만 쓴다. 승인이 없거나 parent 가 내 head 와 다르면 충돌 또는 보류다. +- 기각한 방식: 시각 기준 마지막 쓰기 우선(시계 조작에 약함), 버전 벡터(codex v0.1 안; 빠진 이력을 원작자에게 받아 와야 해서 복잡함). + +### 2.3 로컬 쓰기와 원격 적용의 경쟁 +- 모든 쓰기(로컬 `kc set`·`restore`·`adopt`, 원격 적용, 충돌 해결)는 **같은 잠금(items)** 안에서 한다. 잠금 순서: `items` → `sync.json` → `seen.json`. +- 원격 적용 직전, 잠금 안에서 현재 값 지문과 head 를 **다시 확인**한다. 스캔 뒤 다른 프로세스가 `kc set` 을 했으면 원격 변경은 충돌로 바뀐다(codex P1-6). +- 쓰기 순서: ① 의도 기록(journal) → ② 키체인 쓰기 → ③ `sync.json`(head·lineage·큐·승인 소비) 갱신 → ④ journal 정리. 시작할 때 남은 journal 이 있으면 현재 값 지문으로 ②가 끝났는지 판정해 ③을 마저 하거나 되돌린다. 기존 인박스 journal(`crates/kc-cli/src/commands/inbox.rs:157`)을 확장한다. +- 한계(문서에 명시): kc 밖에서 키체인 값을 `A→B→A` 로 바꾸고 그 사이에 sync 가 돌지 않으면 감지하지 못한다. + +### 2.4 충돌 +- 모든 후보 값(2개 이상일 수 있음)을 내부 슬롯에 보존한다. 그 항목은 **일반 변경 적용만** 멈추고, 해결(resolve) 메시지와 다른 기기의 충돌 후보는 계속 받는다(codex P2-11). +- `kc sync status` 는 값 대신 지문과 기기 이름을 보여 준다. +- `kc sync resolve NAME --keep mine|LABEL`(L + A): 결과는 새 vid 이고 승인 서명의 parent 목록에 **알려진 모든 후보 head** 를 적는다. 받는 쪽은 **자기가 알고 있는 모든 미해결 후보 head(자기 head 포함)가 그 목록에 다 들어 있을 때만** 받아들인다. 하나라도 빠졌으면 충돌로 남긴다(v0.2 재리뷰 P1). 해결 메시지를 적용하는 일은 원자적이다. +- 보낸 쪽 lineage 는 **승인이 검증된 앞으로 감기·해결 경로에서만** 합친다. 수렴은 자기 lineage 에 두 head 만 더하고 보낸 쪽 lineage 는 가져오지 않는다. 합집합이 64개를 넘으면 현재 head(수렴은 두 head)를 남기고 **vid 값 오름차순**으로 자른다. +- 수렴 때 보낸 쪽 lineage 를 믿으면, 뚫린 기기가 같은 값과 다른 기기의 미래 vid 를 보내 그 실제 변경을 낡은 것으로 무시하게 만들 수 있다(`applied` ACK 뒤 영구 불일치). +- vid 의 parent 도 불변이다. 같은 vid 로 다른 parent 를 주장하면 위반이다. + +### 2.5 삭제 +- 동기화 대상에 `kc rm` 을 하면 거부한다("`kc sync rm NAME` 먼저"). +- `kc sync rm NAME` 은 이 기기의 대상에서만 빼고 등록 세대를 올린다. +- `kc sync rm NAME --everywhere`(A+) 는 다른 기기에서도 대상에서만 빼고 **값은 남긴다**. +- 값 삭제 전파는 지원하지 않는다. + +### 2.6 복구 기준점 +- v0.1 의 "`#prev` 에 항상 공격 전 값이 남는다"는 틀렸다. `#prev` 는 한 단계뿐이라 24시간 간격의 두 번 덮어쓰기면 원래 값이 사라진다(codex P1-9). +- 원격 덮어쓰기를 처음 적용하기 전에 그때 값을 **복구 기준점** 슬롯(`sync/kg/<이름 해시>`)에 복사한다. 이후 원격 덮어쓰기는 이 슬롯을 바꾸지 않는다. +- 사람이 `kc sync status` 나 `review` 에서 "현재 값 확인"(L)을 하면 그 값이 새 기준점이 된다. `kc sync restore-checkpoint NAME` 으로 되돌린다. +- 보류·충돌·기준점·보낼 값 스냅샷 슬롯의 총량에 상한을 둔다(기본 대상 항목 수 × 4). 기준점 슬롯은 **원격 쓰기 전에 먼저 확보**한다. 확보하지 못하면 원격 변경을 적용하지 않고 보류한다. 상한에 닿으면 새 제안·보류를 받지 않고 status 에 표시한다. + +### 2.7 실행 시점 +1. `kc sync`: 로컬 스캔 → 인박스 받기·적용 → 보낼 것 보내기 → 요약(digest) 교환 +2. `kc set`·`restore`·`adopt` 직후: 대상 항목이면 바로 보내기를 시도하고, 실패하면 큐에 남긴다. +3. `kc sync install [--every 15m]`: macOS LaunchAgent(서명된 릴리스 바이너리 경로 고정) / Linux systemd `--user` 타이머 / Windows 작업 스케줄러 "로그온한 경우에만"(로그온 없는 모드 금지). +- 상주 long-poll 은 하지 않는다(15분 주기 = 시간당 4회, 같은 IP 시간당 120회 한도에 여유). + +### 2.8 전달 확인과 재동기화 +- 받는 기기는 변경을 적용(또는 보류·충돌로 기록)하고 **저장이 끝난 뒤에만** 영수증(ACK)을 보낸 기기에 돌려준다. 이미 처리한 변경이 다시 오면 ACK 만 다시 보낸다(ACK 유실 대비). 보낸 기기는 그 기기의 ACK 를 받을 때까지 그 변경을 큐에 둔다(codex P2-12). +- 보낸 기기는 ACK 를 기다리는 동안 보낸 값 스냅샷을 키체인 내부 슬롯에 보관한다. 그 사이 새 로컬 변경이 생기면 새 변경이 이전 것을 대체하고, 받는 쪽이 중간 변경을 건너뛰어도 parent 가 맞지 않으면 충돌·digest 재요청으로 이어진다. +- 하루 한 번 digest 로 서로의 head 를 비교하고, 상대가 뒤처졌으면 최신 값을 **새 승인과 함께** 다시 보낸다(옛 승인은 만료됐을 수 있음). +- 인박스 메시지가 72시간 만료로 사라졌거나, 30일 미접속으로 인박스가 사라졌으면 다음 sync 에서 digest 로 감지해 다시 보낸다. 인박스 재연결이 필요하면 status 에 표시한다. +- 각 기기는 **자기 변경만** 보낸다(남의 변경을 중계하지 않음). 그래서 변경을 만든 기기가 영영 사라지면, 그 변경을 받지 못한 기기는 사람이 남은 사본을 새 변경으로 다시 보내야 한다. 이 한계를 status 에 표시한다. + +## 3. 사람 승인 + +### 3.1 두 층 +| 층 | 수단 | 막는 것 | +|---|---|---| +| L: 로컬 확인 | Touch ID · Windows Hello · Linux polkit | 같은 기기에서 kc 를 부르는 **에이전트**(터미널 판별은 PTY 로 우회되지만 지문은 우회 못 한다) | +| A: 서명 승인 | logi 앱 기기 고정 키 · FIDO2 보안 키 | **뚫린 기기 한 대**. 다른 기기들이 서명을 직접 검증한다 | +| A+: 강한 서명 승인 | **logi 앱 기기 고정 키만** (자체 화면에서 문서를 보여 주고 서명) | 신뢰 루트를 바꾸거나 여러 기기에 영향이 큰 작업 | + +- 일반 FIDO2 보안 키는 **A 등급까지만** 인정한다. 보안 키에는 자체 화면이 없어, 뚫린 컴퓨터가 다른 문서를 서명시켜도 사용자가 알 수 없다(v0.2 재리뷰 P1). A+ 작업은 휴대폰 승인을 기다린다. +- 기기 하드웨어 키(device-uv, v0.1 의 A 수단)는 **기본으로 쓰지 않는다**(codex P1-7). 어떤 키가 정말 하드웨어에 묶여 매번 생체 인증을 거치는지 받는 기기가 검증할 방법(키 증명)을 명세하기 전까지는, 소프트웨어 키를 등록한 뚫린 기기가 승인을 스스로 만들어 낼 수 있다. 나중 단계에서 키 증명과 함께 다시 검토한다. + +### 3.2 작업별 요구 수준 +| 작업 | 보내는 기기 | 받는 기기 | +|---|---|---| +| `sync add`·`rm`(이 기기만), `sync peer add`·`rm` | L | — | +| 받은 제안 받아들이기(`review`) | — | L | +| **기존 값 덮어쓰기**(set 뒤 sync, resolve) | A 요청 | **A**(parent 일치), 없으면 보류 | +| `sync rm --everywhere` | A+ 요청 | **A+**, 없으면 보류 | +| 보류분 직접 승인(`review`), `unfreeze`, 기준점 확인 | — | L | +| 새 기기 페어링 | L(양쪽) + 기존 코드·확인 단어 | — | +| `device rotate`, `sync install`, `approver enroll` | L | — | +| 승인자 추가 | L + 기존 승인자의 A+ | 각 기기에서 L 로 지문 확인 후 고정 | +| 승인자 제거 | L | — (마지막 승인자를 지우면 덮어쓰기는 전부 보류. 새 등록은 각 기기 L 확인 필요) | + +**기존 명령도 같은 규칙을 따른다**(codex P1-8). 동기화 대상 항목을 `kc inbox --on-conflict overwrite`·`kc receive`·v1 인박스 메시지로 덮어쓰려 하면 sync 정책으로 보낸다. 승인 서명이 없으면 L 이 필요하고, 비대화형이면 보류한다. + +에이전트는 L·A·A+ 어느 것도 통과하지 못한다. 할 수 있는 최대치는 승인 요청을 올리는 것과 제안을 보내는 것이다. + +### 3.3 승인 문서 +서명 대상은 `SHA-256("kc1 approval" ‖ 작업 종류 ‖ 문서)` 이다. **작업마다 구조체를 따로 둔다**(codex P1-3). +```text +ValueChange { v, origin_fp, doc_id(16바이트 무작위), created_at, expires_at(≤7일), agent_origin, + entries: [{ name, kind, new_vid, parents: [vid…], targets: [{ target_fp, generation, c }] }] } + c = HMAC(HKDF(X25519(origin_sk, target_pk), "kc1 commit"), name ‖ kind ‖ new_vid ‖ generation ‖ 값)[..16] +Retire { v, origin_fp, doc_id, created_at, expires_at, entries: [{ name, head_vid, generation }], + targets: [fp…] } +ApproverAdd { v, origin_fp, doc_id, created_at, expires_at, + new_approver: { kind, sign_public_key, enc_public_key?, key_id, platform }, + policy: { grade: A|A+, accept_for: [작업 종류…] }, approver_generation } +``` +- 받는 기기마다 **그 기기의 등록 세대(generation)** 까지 묶는다. 제거·재등록 뒤에는 아직 쓰지 않은 옛 승인이 새 세대로 둔갑하지 못한다(v0.2 재리뷰 P1). +- 값과 parent 까지 묶는다: 승인 뒤 보내는 기기가 값만 바꾸거나, 다른 head 를 대체하는 변경으로 쓰지 못한다. 커밋 키는 기존 기기 키로 기기 쌍마다 만든다. 1pass.dev 는 c 를 계산하거나 값을 맞춰 볼 수 없다. +- 짧은 코드: 문서 해시 앞 4바이트를 단어 4개로 바꿔 터미널과 휴대폰에 함께 보여 준다. +- 한 번의 sync 에서 대기 중인 변경을 문서 하나로 묶는다(승인 피로 감소). + +**받는 기기의 검증**: 보낸 기기와 `origin_fp` 일치 → 자기 몫 `c` 재계산 일치 → 항목·parent·종류 일치 → 유효 기간 확인 → 서명 검증 → 서명 수단이 작업 등급에 맞는지 확인. + +**문서 고정**: `doc_id` 는 처음 본 문서 해시에 고정된다. 같은 `doc_id` 로 다른 문서가 오면 위반이다. 한 문서 안에서 같은 이름이 두 번 나오면 문서 전체를 거부한다. + +**승인 소비**(codex P1-5): `(doc_id, 항목, 받는 기기)` 단위로 적용 기록을 남긴다. 한 문서의 항목 일부만 적용된 상태를 허용하고, 다시 시도할 때 남은 항목만 적용한다. 순서가 뒤바뀌어 도착한 승인도 받아들인다(최고 seq 하나만 기억하는 방식은 쓰지 않음). 거절·폐기한 문서는 만료 시각까지 기록해 둔다. + +### 3.4 휴대폰 승인: logi 앱의 기기 고정 키 +- **왜 패스키가 아닌가**(codex P1-2): logi 패스키는 RP ID `api.1pass.dev` 를 웹과 공유하고 여러 기기에 동기화된다(BE=1). 장악된 1pass.dev 는 웹 페이지나 앱의 로그인 응답에 kc 승인 해시를 challenge 로 넣어, 사용자가 "로그인"이라고 생각하고 생체 인증을 하게 만들 수 있다(로그인 경로는 서버 옵션을 그대로 서명 함수에 넘긴다, `toy/logi/Packages/LogiCore/Sources/LogiCore/Auth/SessionStore.swift:372`). 서명할 credential 을 고르는 `allowCredentials` 도 서버가 정한다. WebAuthn 생체 인증은 "사람이 있다"를 증명할 뿐 "이 내용을 봤다"를 증명하지 않는다. +- **대신**: logi 앱이 kc 승인 전용 키 쌍을 기기 안에서 만든다. + - iOS: Secure Enclave P-256, 접근 제어 `biometryCurrentSet`, 동기화·내보내기 불가. 이미 있는 `DpopSigner`(Secure Enclave 서명)를 본뜬다. + - Android: StrongBox(없으면 TEE) Keystore 키, 사용자 인증 필요. + - **서명할 때마다** 생체 인증을 요구한다(재사용 창 없음). 하드웨어 키를 만들 수 없는 기기에서는 등록을 거부한다(소프트웨어 키로 내려가지 않음). + - 기존 DPoP 서명 코드는 그대로 쓰지 않는다. iOS 는 생체 게이트 없이 소프트웨어 폴백을 허용하고(`toy/logi/Packages/LogiCore/Sources/LogiCore/Auth/DpopSigner.swift:143`), Android 는 사용자 인증을 끈다(`toy/logi/android/core/data/src/main/java/com/dcodelabs/logi/core/data/DpopSigner.kt:99`). 키 생성 방식만 참고한다. + - 이 키는 **앱의 kc 승인 화면에서만** 쓴다. 웹은 닿을 수 없고, 앱의 다른 화면(로그인 등)은 이 키를 쓰는 코드 경로가 없다. + - 앱이 승인 문서를 **직접 해석해서 화면에 그리고**, 그 문서의 해시에 서명한다. 서버가 보낸 표시 문구는 쓰지 않는다. +- **이름도 숨긴다**: 앱 키 쌍과 함께 암호화용 키(X25519)도 만든다. kc 는 승인 문서를 이 키로 암호화해 보내므로 1pass.dev 는 암호문과 짧은 코드만 본다(codex P2-15 의 이름 노출 문제 해결). `approval_display = "counts"` 설정은 필요 없어진다. +- **키 고정**: `kc approver enroll` 때 앱 공개키 두 개(서명·암호화)를 **함께** kc 가 받아 지문을 단어 4개로 보여 주고, 앱 화면에도 같은 단어를 띄운다. 각 kc 기기에서 사람이 대조해야 고정된다(L). +- **키 증명(선택)**: iOS App Attest·Android Key Attestation 으로 "정품 logi 앱의 하드웨어 키"임을 확인할 수 있다. 1단계에서는 지문 대조만 하고, 키 증명은 열린 문제로 둔다. +- 휴대폰 분실: 다른 기기에서 `kc approver rm`(L) 후 새 휴대폰으로 다시 등록한다. 키가 동기화되지 않으므로 새 휴대폰은 새 키다. + +### 3.5 FIDO2 보안 키(D8) +- libfido2(macOS·Linux)·`webauthn.dll`(Windows)로 kc 가 직접 서명을 받는다. 서버가 필요 없다. +- RP ID 는 **웹 도메인이 아닌 문자열**(`kc-approval`)을 쓴다. 브라우저는 자기 도메인이 아닌 RP ID 를 요청할 수 없으므로, 웹 페이지가 이 credential 로 서명을 받아 낼 수 없다. +- 받는 기기는 등록 때 고정한 공개키로 type·challenge·rpIdHash·UP·UV·알고리즘을 모두 검증한다. origin 은 kc 가 만든 고정 값과 비교한다. +- 한계: 꽂혀 있는 키를 악성 코드가 사용자를 속여 터치하게 만들 수 있다. 짧은 코드 대조가 완화책이다. + +### 3.6 1pass.dev(logi)에 새로 필요한 것 +logi 점검 결과(`scratchpad/logi-survey.md`)를 근거로, kc 전용 승인 도메인(D6)에 다음을 둔다. +1. kc 기기 연결: CLI 기기 코드 로그인을 그대로 쓴다. 이후 요청 인증은 **kc 가 직접 만든 Ed25519 키의 공개키만 등록**하는 새 API 로 한다. 기존 `AgentRegistration` 은 서버가 개인키를 만들어 내려주므로(`toy/logi/server/app/models/agent_registration.rb:234`) 그대로 쓰지 않는다(codex P2-14). 발급·교체·폐기 API 가 필요하다. +2. 승인자 등록: logi 앱이 기기 고정 키 쌍을 만들고 공개키를 kc 에 전달하는 흐름. 서버는 공개키를 **가공 없이** 중계한다. +3. 승인 요청: kc 가 올린 암호문·짧은 코드·만료 시각을 저장하고 앱에 푸시(기존 `PushNotifier`). 앱이 서명을 올리면 kc 가 long-poll 로 가져간다. 서버는 서명을 검증하지 않아도 되고, 검증해도 kc 는 그 결과를 쓰지 않는다. +4. 남용 방어: 에이전트 승인 게이트의 진행 중 요청 억제·거절 쿨다운·차단을 가져다 쓴다. 기기당 대기 요청 3건 상한. +5. 앱: kc 승인 화면(문서 복호화·해석·표시·서명), 키 생성·지문 표시, 승인자 재등록. +- **서버가 저장하는 것**: 계정↔kc 기기 연결(요청 서명 공개키 포함), 승인자 공개키, 승인 요청 암호문(처리 뒤 7일 안에 삭제), 푸시 구독. +- **서버가 볼 수 없는 것**: 값, 항목 이름, 값 지문, 기기 개인키, 인박스 토큰, 커밋 키. +- 패스키 관련 변경(무작위 challenge 대체, 공개키 노출)은 **필요 없어진다.** logi 의 "RP 에 패스키 공개키를 주지 않는다" 결정도 그대로 둔다. +- logi 보류 항목(R6 기기 서명 영수증)은 "패스키 challenge 유도" 대신 "앱 기기 고정 키 서명"으로 시작한다. logi 문서에 이 차이를 남긴다. + +### 3.7 백그라운드·에이전트 실행 +- 대화형 `kc set` 의 변경은 그 자리에서 승인을 요청한다. +- 비대화형 변경은 "승인 대기"로 두고 요청만 올린다. 7일 안에 승인이 없으면 요청만 만료되고 로컬 값은 남는다. +- 받는 기기는 승인이 없으면 보류하고, 승인이 나중에 오면 다시 평가한다. `kc sync review`(L)로 직접 승인할 수도 있다. + +### 3.8 승인 수단을 못 쓸 때 +- 휴대폰이 꺼져 있거나 1pass.dev 에 닿지 못하면 FIDO2 보안 키를 쓴다. 둘 다 없으면 큐에서 기다리고, 받는 기기에서 `review`(L)로 직접 승인할 수 있다. +- 승인자가 하나도 없으면 덮어쓰기는 모두 받는 기기의 `review` 대상이다. 제안·새 항목은 그대로 동작한다. + +## 4. 피해 범위 제한(승인이 있어도 유지) +- 항목별: 비대화형 원격 덮어쓰기는 24시간에 1회. 그 이상은 보류. +- 기기별 차단기: 24시간 안에 덮어쓰기 5건 초과, 또는 retire 3건 초과면 그 기기가 보낸 나머지를 모두 보류한다. "대상의 25% 초과" 조건은 대상이 8개 이상일 때만 쓴다(작은 집합에서 한 항목만 바뀌어도 걸리는 문제, codex P2-15). +- 재전송: 기존 메시지 id 기록과 72시간 만료, lineage 의 낡은 vid 무시, 승인 소비 기록. +- 뚫렸을 때: 다른 기기에서 `kc sync freeze`(비대화형 가능) → 기기마다 `kc peers rm LABEL` → `kc sync restore-checkpoint`. `peers rm` 은 전파하지 않는다. + +## 5. 프로토콜 +- 인박스 **바깥 봉투 버전을 2로** 올린다. v0.2 kc 는 바깥 봉투 버전을 복호화 전에 검사해(`crates/kc-proto/src/inbox.rs:329`) "지원하지 않는 버전"으로 인박스에 남겨 두고 72시간 뒤 만료된다(codex P2-13 확인). +```text +InboxPlain2 { v:2, msg_id, sender_fp, recipient_fp, created_at, expires_at, body } +body = Items(...) | Sync { kind: Hello | Offer | Accept | Leave | Changes | Ack | Digest | Approvals } +Change { name, generation, new_vid, parents: [vid…], lineage(≤64), op: Put{value,kind} | Retire, approval_ref? } +``` +- `Change.parents` 는 보낸 기기가 주장하는 직접 parent 목록이다(해결 메시지면 모든 후보 head). 승인이 붙은 변경은 `parents` 가 승인 문서의 parents 와 **정확히 같아야** 한다(다르면 거부). 승인이 없는 parents 는 보류와 충돌 중 어디로 보낼지만 정하고, 어느 쪽이든 사람이 본다. 그래서 위조해도 자동 적용으로 이어지지 않는다. +- 상대의 v2 지원 여부를 모르면 **Hello 한 통만** 보낸다. Hello 는 기능 목록만 담고 받는 쪽 상태를 바꾸지 않는 무해한 메시지다. v0.2 기기에서는 72시간 뒤 만료되는 낭비 1통으로 끝난다. Hello 응답을 받기 전에는 다른 sync 메시지를 보내지 않고 보류한다(v0.2 재리뷰 P1: 확인 전 금지 규칙이 Hello 까지 막아 교착되던 문제). **sync 변경을 v1 Items 로 낮춰 보내지 않는다.** 일반 `send --to` 는 지금처럼 v1 이다. +- `kc inbox` 와 `kc sync` 는 같은 인박스 처리 루프를 쓰고 내용 종류로 나눈다. +- `docs/PROTOCOL.md` §4(v2)·§6(sync·L/A/A+ 행)·§9(승인자로 일원화)와 `docs/SECURITY.md`(1pass.dev 신뢰 경계, 등록 시점 한계, 원작자 소실 한계)를 함께 고친다. + +## 6. 명령 +```text +kc sync 스캔→받기→보내기. "3 sent, 2 updated, 1 conflict, 1 awaiting approval" +kc sync status [--json] 항목별 상태와 기기별 마지막 요약 +kc sync add [NAMES…] [--peers a,b] [--from-keychain] +kc sync rm NAMES [--everywhere] +kc sync peer add|rm|list LABEL +kc sync review 받은 제안·보류분을 하나씩 받아들이기·거절 +kc sync resolve NAME --keep mine|LABEL +kc sync restore-checkpoint NAME +kc sync approve 대기 중인 승인 요청 상태 확인·재요청 +kc sync freeze | unfreeze +kc sync install [--every 15m] | uninstall +kc approver enroll [--fido2] | list | rm ID +``` +종료 코드: 0 = 완전히 맞음, 8 = 충돌·보류·승인 대기·제안, 4 = 키체인, 5 = 사람 필요, 6 = 중계 서버. + +## 7. 저장 위치 +- `config.toml [sync]`: 사람이 고치는 값만(`interval`, `max_remote_overwrites`, `max_proposals_per_day`, `approver_url`). +- `sync.json`: 기기 상태, 항목별 head·lineage·등록 세대·범위, 보낼 큐와 ACK 상태, 제안·보류·충돌 목록, 승인자 공개키, 승인 소비 기록, journal. **값과 값 지문은 넣지 않는다.** +- 키체인 내부 슬롯: 보류·충돌 후보 값, 복구 기준점, 보낼 값 스냅샷(보낼 때 값이 바뀌지 않게), vid별 값 지문, `sys:sync-key`(지문 HMAC 키), `sys:logi-token`, `sys:logi-request-key`(Ed25519). +- `sync.log`: 이름과 결과만, 값은 기록하지 않는다. 1 MiB 에서 교체. + +## 8. 단계 +| 단계 | 내용 | 다른 레포 | +|---|---|---| +| 0 | 인박스 v2(바깥 봉투 버전 2, **v1 과 같은 바깥 배치를 고정**하고 AAD·분기 규칙 명세), 골든 벡터, v0.2↔v2 호환 시험, 인박스 루프 공용화 | — | +| 1 | `sync.json`, add·제안·review·rm·peer·status·수동 sync, `decide`, 잠금·journal, 충돌·resolve, 복구 기준점, 한도·차단기·freeze, ACK·digest·세대 교환, 기존 명령의 sync 정책 적용, **로컬 확인(L)**. 원격 덮어쓰기는 전부 review 보류(§12.5) | — | +| 1b | 승인 문서 3종, FIDO2 검증기, 승인 소비 기록, 보류 재평가, 승인 붙은 덮어쓰기 자동 적용 켜기 | — | +| 2 | `install`(3 OS), `--from-keychain`, doctor 연동 | — | +| 2b | 1pass.dev 연동(기기 연결·요청 키, 앱 기기 고정 키 승인자, 암호화 승인 요청, 푸시, 앱 승인 화면) | **logi**(서버·iOS·Android) | +| 3 | 네이티브 위치 반영(기기별 선택, 기존 항목 갱신만, 대화형만) | — | +| 4 | 200 KiB 넘는 항목 분할 전송, device-uv 키 증명 재검토 | — | + +1·1b 만으로도 FIDO2 보안 키로 쓸 수 있다. 1pass.dev 연동(2b)은 logi 쪽 작업과 병행한다. + +## 9. 시험 +- `decide` 표 시험: 앞으로 감기(parent 일치만), 낡은 변경, 같은 vid 다른 값(위반), 수렴(양쪽 같은 head), 충돌, lineage 위조(parent 불일치 → 충돌), 잘림 경계. +- 경쟁 시험: 스캔 뒤 로컬 `kc set` 과 원격 적용이 겹칠 때 충돌로 바뀌는지, ②와 ③ 사이에서 죽은 뒤 복구. +- 결정적 시뮬레이션: 메모리 중계 위에 가상 기기 3~4대, 수정·전달·유실·순서 뒤바뀜·오프라인·72시간 만료를 무작위로 섞는다. 불변식: ACK 가 다 오면 모두 같은 값이거나 충돌 표시 / 동시 수정이 조용히 덮이는 경우 0 / 원격 메시지로 값이 지워지는 경우 0 / 복구 기준점이 사람 확인 없이 바뀌는 경우 0. +- 보안 시험: 원격 제안이 review 없이 대상이 되는 경우 0, 승인 없는 덮어쓰기 보류, `inbox --on-conflict overwrite`·`receive` 로 대상 항목 덮어쓰기 시 정책 적용, 승인 문서 종류 혼동(ValueChange 서명을 Retire 로) 거부, 부분 적용 뒤 재시도, 역순 승인 수용, 에이전트 실행에서 L·A·A+ 경로는 exit 5 또는 보류. +- 서버 단독 장악 시뮬레이션: 가짜 1pass.dev 가 임의 문서 서명 요청·서명 재사용·승인자 바꿔치기·로그인 위장을 해도 적용 0건. +- 실기기: logi 앱 Secure Enclave·StrongBox 키 생성과 서명, FIDO2 보안 키(USB) 3 OS. + +## 10. 열린 문제 +1. 키 증명(App Attest·Key Attestation)을 1단계부터 넣을지. +2. 로컬 스캔 비용(144개 전부 읽기) 실측. +3. 같은 이름이 기기마다 다른 의미일 때: 제안 review 화면에 양쪽 지문과 출처를 함께 보여 준다. +4. 네이티브 위치 반영(Phase 3)은 앱이 스스로 갱신하는 토큰을 덮어 세션을 깰 수 있어, 기존 항목 갱신만·대화형에서만 한다. +5. 승인자를 여러 명(휴대폰 + 보안 키) 둘 때 A 는 하나면 된다. A+ 는 휴대폰 승인이 필수다. 보안 키를 추가로 요구할지는 열려 있다. +6. 휴대폰 키 증명 없이 지문 대조만으로 "정품 logi 앱의 하드웨어 키"를 믿는 수준이 충분한지(열린 문제 1 과 연결). + +## 11. 화면 결정 (2026-10-13 시안 확정) +시안(검토 후 삭제)에서 받은 사용자 선택: + +| 화면 | 선택 | 내용 | +|---|---|---| +| logi 앱 승인 화면 | A · 바로 승인 | 짧은 코드 4단어를 보여 주고 바로 Face ID 승인 버튼. 코드 맞히기 단계는 두지 않는다 | +| kc 터미널 대기 | B · 항목·대안 함께 | 항목·대상 기기·코드를 함께 보여 주고, 휴대폰이 없을 때 보안 키(A 등급까지)·Ctrl-C 후 7일 유지를 안내 | +| 동기화 항목 고르기 | A · 묶음 목록 | 이름 앞부분으로 묶은 체크리스트(펼치기). 기본 선택 = 권장 분류 | + +- 승인 화면 A 를 고르면서 "사용자가 시작하지 않은 요청" 방어는 짧은 코드 **눈 대조**에 기댄다(B 의 맞히기 단계 없음). 2차 방어선(§4 한도·차단기·복구 기준점)은 그대로다. +- 초기 동기화 대상 목록은 개인 정보라 레포에 두지 않는다. 사용자 기기의 kc 설정 폴더 `sync-initial-set.toml` 에 있고, `kc sync add --from-keychain` 이 이 목록을 미리 체크해 보여 준다. + +## 12. 구현 착수 전 고정 계약 (v0.4) +v0.3 재리뷰가 "지금 정하지 않으면 다시 짜야 한다"고 꼽은 5개다. + +### 12.1 인박스 v2 형식 +- 바깥 봉투 필드와 순서는 v1 과 같다(`v, suite, sender_fp, recipient_fp, enc, ct`). `v = 2` 만 다르다. 지금 코드는 봉투 전체를 decode 한 뒤 버전을 보므로(`crates/kc-proto/src/inbox.rs:328`) **배치를 바꾸면 v0.2 가 Malformed 로 지운다.** 배치는 바꾸지 않는다. +- AAD 는 v1 과 똑같이 `postcard(v, suite, sender_fp, recipient_fp)` 다(`crates/kc-proto/src/inbox.rs:182`). `enc`·`ct` 는 넣지 않는다. HPKE info 는 `"kc2 inbox" ‖ sender_fp ‖ recipient_fp`. +- 안쪽 `InboxPlain2.v` 는 바깥 `v` 와 같아야 한다. 다르면 거부한다. +- 내용 종류는 `body` 열거형의 판별자로 나눈다. Phase 0 에서 골든 벡터로 고정한다. +- **변경 식별자** `change_id = (name, generation, new_vid)`. ACK 는 `[(change_id, 결과)]` 를 담는다. 결과 = `applied | held | conflict | stale_generation | deferred_capacity | rejected`. + +### 12.2 등록 세대 교환 +- 세대는 **받는 기기가** 정하고 보낸 기기에 알려 준다. +- `Offer{name}` → 받는 쪽이 review 에서 받아들이면 `Accept{name, generation}` 을 보낸다. 보낸 기기는 기기별로 그 세대를 기록하고, 그 뒤 변경에 이 세대를 넣는다. +- 받는 쪽에서 `sync rm` 하면 세대를 올리고 `Leave{name, generation}` 을 보낸다. 다시 넣으려면 새 Offer → 새 Accept 다. +- 세대가 맞지 않는 변경은 적용하지 않고 `stale_generation` ACK 를 돌려준다. 보낸 기기는 그 기기에 대한 큐 항목을 지우고 status 에 "다시 제안 필요"로 표시한다. +- 기기별 범위 변경(`--peers`)도 Offer·Leave 로 표현한다. + +### 12.3 ACK 와 보관·용량 +- 보낸 기기는 대상 기기 **전부**가 그 `change_id` 에 **확정 결과**(`applied | held | conflict | stale_generation | rejected`)를 ACK 하면 보낸 값 스냅샷을 지운다. `deferred_capacity` 는 확정 결과가 아니다. 스냅샷과 큐 항목을 그대로 두고 다음 digest 뒤 다시 보낸다. 같은 이름의 더 새 변경이 ACK 되면 이전 것도 지운다. ACK 는 `change_id` 가 정확히 같은 큐 항목만 지운다(옛 ACK 가 새 항목을 지우지 않음). +- 받는 기기의 보류·충돌 후보 슬롯은 해결·거절할 때 지운다. 복구 기준점은 사람이 확인할 때만 바뀐다. +- 슬롯 총량 상한 = `max(16, 대상 항목 수 × 4)`. 대상이 0개여도 첫 제안을 받을 수 있다. +- 보존 우선순위: 복구 기준점 > 충돌 후보 > 보류 값 > 제안. 상한에 닿으면 새 제안·보류를 받지 않고 `deferred_capacity` ACK 를 보낸다(보낸 쪽은 다음 digest 뒤 다시 보냄). 기준점은 절대 밀어내지 않는다. + +### 12.4 journal 복구 단위 +- 원격 적용 한 건 = 한 트랜잭션: ① journal 에 **적용 의도 레코드 전체**를 기록 — `change_id`, 보낸 기기, 이전 지문, 예정 지문, 적용 뒤 head·lineage, 소비할 승인 키, 보낼 ACK 결과, 확보할 기준점·후보 슬롯 이름. 예정 값 자체는 ② 에서 확보하는 후보 슬롯에 먼저 넣어 둔다 → ② 기준점·후보 슬롯 확보 → ③ 키체인 쓰기 → ④ `sync.json`(head·lineage·승인 소비·보낼 ACK) 갱신 → ⑤ journal 정리. +- 재시작 때 남은 journal 이 있으면 현재 값 지문으로 판정한다. + - 예정 지문과 같음 → 레코드대로 ④부터 마저 한다. + - 이전 지문과 같음 → 쓰기가 일어나지 않았으니 journal 만 지우고 다시 시도한다. + - **둘 다 아님** → 그 사이 다른 쓰기가 있었다. 덮어쓰지 않고 충돌로 남긴다. +- ACK 는 ④가 끝난 뒤에만 보낸다. +- **로컬 변경 한 건 = 한 트랜잭션**(`kc set`·`restore`·`adopt`·스캔으로 찾은 변경): ① journal 에 로컬 변경 레코드 기록 — 이름, 이전 지문, 새 지문, 새 vid, parents, 스냅샷 슬롯 이름, 만들 큐 항목(대상 기기·세대) → ② 보낼 값 스냅샷 슬롯에 값 복사 → ③ `sync.json`(head·lineage·큐) 갱신 → ④ journal 정리. `kc set` 은 키체인 쓰기를 ① 과 ② 사이에 한다. +- 재시작 때 로컬 변경 journal 이 남아 있으면, **③ 커밋 여부는 `sync.json` 의 head 가 레코드의 새 vid 인지로 판정**한다. + +| 현재 값 지문 | ③ 커밋됨? | 처리 | +|---|---|---| +| 새 지문 | 아니오, 스냅샷 없음 | 현재 값(=새 값)을 스냅샷에 다시 복사하고 ③ → ④ | +| 새 지문 | 아니오, 스냅샷 있음 | ③ → ④ | +| 새 지문 | 예 | ④ 만 | +| 새 지문이 아님(이전 지문이든 다른 값이든) | 예 | 큐가 스냅샷을 참조하므로 **스냅샷은 남긴다**(보낸 값). journal 만 정리. 다음 스캔이 지금 값을 새 vid 로 기록한다 | +| 이전 지문 | 아니오 | 키체인 쓰기가 안 일어났다. 스냅샷이 있으면 지우고 journal 정리 | +| 이전 지문도 새 지문도 아님 | 아니오 | 스냅샷을 지우고 journal 정리. 다음 스캔이 새 vid 를 만든다 | + +(행은 "현재 값 = 새 값 여부 × 커밋 여부"의 모든 조합을 덮는다.) + +- 스냅샷 슬롯은 큐 항목이 참조하는 동안 지우지 않는다. 지우는 것은 §12.3 의 확정 ACK 때뿐이다. + +### 12.5 단계 경계와 판정 순서 +- **로컬 확인(L)을 Phase 1 로 앞당긴다.** add·review·resolve 가 L 에 의존하기 때문이다. +- Phase 1 에는 서명 승인(A)이 없다. 판정은 `Change.parents` 로 한다. 판정표는 그대로 쓰되, **7번(자동 앞으로 감기)이 Phase 1 에서는 절대 걸리지 않는다**(검증된 승인이 없으므로). 그래서 parent 가 맞는 원격 덮어쓰기는 8번(review 보류), parent 가 다르면 9번(충돌)이다. 자동 적용은 Phase 1b 부터다. +- resolve: Phase 1 에서는 보내는 기기에서 L 만 요구한다. 받는 기기는 그 해결 메시지를 승인 없는 변경으로 보고 review 에 보류한다(§2.4 의 후보 포함 검사는 그대로). Phase 1b 부터 L + A 로 올리고, 승인이 붙은 해결은 자동 적용한다. +- `decide` 는 검증기가 통과시킨 승인만 받는다(`Option`). 서명 바이트를 직접 보지 않는다. +- 판정 순서(위에서 먼저 걸리는 것이 이긴다): + +| 순서 | 조건 | 결과 | +|---|---|---| +| 1 | 세대 불일치 | 거부, `stale_generation` ACK | +| 2 | freeze 상태 | 보류 | +| 3 | 같은 vid 다른 값·다른 parent | 위반, 그 기기의 해당 항목 흐름 격리 | +| 4 | 받은 vid = 내 head 또는 lineage 안 | 무시(낡은 변경), `applied` ACK | +| 5 | 이미 충돌 중 | 후보로 추가(해결 메시지면 §2.4 규칙으로 판정) | +| 6 | 값 같음 | 수렴 | +| 7 | 검증된 승인 + parent = 내 head + 한도 안 | 앞으로 감기 | +| 8 | 승인 없음·한도 초과 + parent = 내 head | 보류(review) | +| 9 | 그 밖 | 충돌 |