feat(read-integrity): verified read path — payload authenticity, sender-authenticated CEK envelopes, single-use mutation signatures

monas-content/Cargo.toml

@@ -30,10 +30,20 @@ base64 = "0.22"
 sled = "0.34"
 hpke-rs = { version = "0.4", features = ["hazmat"] }
 hpke-rs-rust-crypto = "0.3"
+# For verifying relay-read responses: recompute the crsl-lib Node CID from the
+# returned Node CBOR (docs/design/read-response-integrity.md §8). Versions must
+# match crsl-lib's (cid 0.11, multihash 0.19, serde_cbor 0.11) so the recomputed
+# CID string is byte-identical.
+serde_cbor = "0.11"
+cid = { version = "0.11", features = ["serde"] }
+multihash = "0.19"
 
 [features]
 default = ["filesync"]
 filesync = ["monas-filesync", "monas-filesync/cloud-connectivity"]
 
 [dev-dependencies]
 tempfile = "3.19.1"
+# Parity test only: build a real crsl-lib Node and confirm our from-CBOR CID
+# recompute matches Node::content_id() exactly. Same rev as monas-state-node.
+crsl-lib = { git = "https://github.com/Monas-project/crsl-lib", rev = "e13b86ce6d6a9c27ebd01a9b4fe82d6bc18f8a01" }

monas-content/src/application_service/content_service/service.rs

@@ -289,6 +289,66 @@ where
         Ok(plaintext)
     }
 
+    /// Verify and decrypt a relay-read response fetched from a state node.
+    ///
+    /// The state node returns the whole crsl-lib `Node` (CBOR). This:
+    /// 1. Recomputes the Node CID and confirms it equals `expected_version_cid`
+    ///    (tamper detection — a relay peer cannot fabricate the payload).
+    /// 2. Extracts the ciphertext from the Node payload.
+    /// 3. Loads the CEK for `local_content_id` and AES-GCM-decrypts.
+    ///
+    /// This is the client-side core of the verified read path
+    /// (`docs/design.md` §10「read応答の完全性検証」). It verifies **payload
+    /// authenticity only**: that these bytes are the ones named by
+    /// `expected_version_cid`. It does not establish that the version is the
+    /// canonical head, the latest, or the work of an authorized writer.
+    ///
+    /// There is **no monotonicity check anywhere** — neither here nor in the
+    /// SDK above. One existed and was removed: forged `parents` bypass it, and
+    /// it could not tell a legitimate sync lag from an attack, so it broke
+    /// honest reads without stopping dishonest ones. Version authenticity needs
+    /// an owner/writer-signed trust anchor, tracked in issue #59.
+    ///
+    /// Returns the plaintext and the verified node's parent CIDs. The parents
+    /// are returned for callers that want to inspect the DAG; nothing in the
+    /// SDK currently consumes them.
+    /// `cek` を渡した場合はそれを使い、`None` の場合だけローカルの CEK ストアを
+    /// 引く。呼び出し側が「どの CEK が正しいか」をより確実に知っている場合
+    /// (share 受信者は送信者ピンの権威レコードに CEK を持つ)、ストアより
+    /// そちらを優先させるための引数である。ストアは書き込み順が入れ替わると
+    /// 巻き戻り得るキャッシュに過ぎない。
+    pub fn verify_and_decrypt_relay_read(
+        &self,
+        node_bytes: &[u8],
+        expected_version_cid: &str,
+        local_content_id: ContentId,
+        cek: Option<ContentEncryptionKey>,
+    ) -> Result<VerifiedRead, VerifiedReadError> {
+        let verified = crate::infrastructure::node_verification::verify_and_extract(
+            node_bytes,
+            expected_version_cid,
+        )
+        .map_err(VerifiedReadError::NodeVerification)?;
+
+        let key = match cek {
+            Some(key) => key,
+            None => self
+                .cek_store
+                .load(&local_content_id)
+                .map_err(VerifiedReadError::KeyStore)?
+                .ok_or(VerifiedReadError::MissingKey)?,
+        };
+
+        let plaintext = self
+            .decrypt_with_cek(local_content_id, key, verified.ciphertext)
+            .map_err(VerifiedReadError::Decrypt)?;
+
+        Ok(VerifiedRead {
+            plaintext,
+            parents: verified.parents,
+        })
+    }
+
     /// コンテンツ削除ユースケース。
     ///
     /// - 物理削除ではなく、ドメインオブジェクト上で `is_deleted` フラグとバッファをクリアして保存する「論理削除」
@@ -633,6 +693,26 @@ pub enum DecryptWithCekError {
     Domain(ContentError),
 }
 
+/// Result of a verified relay read: the plaintext plus the verified node's
+/// parent version CIDs (used by the caller for the monotonicity check).
+#[derive(Debug)]
+pub struct VerifiedRead {
+    pub plaintext: Vec<u8>,
+    pub parents: Vec<String>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum VerifiedReadError {
+    #[error("node verification failed: {0}")]
+    NodeVerification(crate::infrastructure::node_verification::NodeVerificationError),
+    #[error("key store error: {0:?}")]
+    KeyStore(ContentEncryptionKeyStoreError),
+    #[error("no content encryption key for this content")]
+    MissingKey,
+    #[error("decrypt failed: {0}")]
+    Decrypt(DecryptWithCekError),
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum ReencryptError {
     #[error("content not found")]
@@ -992,6 +1072,39 @@ mod tests {
         }
     }
 
+    /// crsl-lib `Node` と同じ CBOR 形状のバイト列を作る
+    /// (`node_verification` が受理する最小構成)。
+    fn make_test_node_bytes(ciphertext: &[u8]) -> Vec<u8> {
+        #[derive(serde::Serialize)]
+        struct Payload<'a> {
+            data: &'a [u8],
+            access_policy: Option<()>,
+        }
+        #[derive(serde::Serialize)]
+        struct Metadata {
+            policy_type: Option<()>,
+        }
+        #[derive(serde::Serialize)]
+        struct Node<'a> {
+            payload: Payload<'a>,
+            parents: Vec<()>,
+            genesis: Option<()>,
+            timestamp: u64,
+            metadata: Metadata,
+        }
+        serde_cbor::to_vec(&Node {
+            payload: Payload {
+                data: ciphertext,
+                access_policy: None,
+            },
+            parents: vec![],
+            genesis: None,
+            timestamp: 0,
+            metadata: Metadata { policy_type: None },
+        })
+        .unwrap()
+    }
+
     fn build_service<R, K, E, S>(
         repo: R,
         key_gen: K,
@@ -1498,6 +1611,82 @@ mod tests {
         assert_eq!(result, plaintext);
     }
 
+    /// `verify_and_decrypt_relay_read` は、明示的に渡された CEK を
+    /// ローカルの CEK ストアより優先する。
+    ///
+    /// ストアは権威レコード(送信者ピン)から導出されるキャッシュに過ぎず、
+    /// CAS の外で書かれるため書き込み順が入れ替わると古い世代へ巻き戻り得る
+    /// (世代 N の handler が CAS 後に停止し、その間に N+1 が権威レコードと
+    ///  キャッシュを進め、その後 N が再開してキャッシュだけを N へ戻す)。
+    /// read が権威レコード側の CEK を使えば、その巻き戻りは影響しない。
+    #[test]
+    fn verified_read_prefers_the_explicit_cek_over_the_store() {
+        /// 鍵を実際に見る暗号化器。鍵の 1 バイト目を XOR するだけだが、
+        /// 「どの CEK で復号したか」がテストから観測できるようになる。
+        struct KeySensitiveEncryptor;
+        impl ContentEncryption for KeySensitiveEncryptor {
+            fn encrypt(
+                &self,
+                key: &ContentEncryptionKey,
+                plaintext: &[u8],
+            ) -> Result<Vec<u8>, ContentError> {
+                Ok(plaintext.iter().map(|b| b ^ key.0[0]).collect())
+            }
+            fn decrypt(
+                &self,
+                key: &ContentEncryptionKey,
+                ciphertext: &[u8],
+            ) -> Result<Vec<u8>, ContentError> {
+                Ok(ciphertext.iter().map(|b| b ^ key.0[0]).collect())
+            }
+        }
+
+        let (repo, _storage) = TestContentRepository::new(false);
+        let (key_store, _key_storage) = TestKeyStore::new(false, false);
+        let service = build_service(repo, TestKeyGenerator, KeySensitiveEncryptor, key_store);
+
+        // 権威レコード側の(正しい)CEK と、巻き戻ったキャッシュ側の CEK
+        let authoritative = ContentEncryptionKey(vec![0x11]);
+        let stale_cache = ContentEncryptionKey(vec![0x22]);
+
+        let plaintext = b"authoritative-cek-wins".to_vec();
+        let ciphertext = service
+            .encryptor
+            .encrypt(&authoritative, &plaintext)
+            .expect("encrypt");
+        let content_id = service.content_id_generator.generate(&plaintext);
+
+        // キャッシュには古い世代の CEK が入っている
+        service
+            .cek_store
+            .save(&content_id, &stale_cache)
+            .expect("save stale cache");
+
+        let node_bytes = make_test_node_bytes(&ciphertext);
+        let version =
+            crate::infrastructure::node_verification::recompute_node_cid(&node_bytes).unwrap();
+
+        // 権威レコードの CEK を渡せば復号できる
+        let read = service
+            .verify_and_decrypt_relay_read(
+                &node_bytes,
+                &version,
+                content_id.clone(),
+                Some(authoritative),
+            )
+            .expect("the explicit CEK must be used");
+        assert_eq!(read.plaintext, plaintext);
+
+        // 渡さなければ巻き戻ったキャッシュが使われ、平文が一致しない
+        // (= この経路に依存していると read が壊れる)
+        let fallback =
+            service.verify_and_decrypt_relay_read(&node_bytes, &version, content_id, None);
+        assert!(
+            fallback.is_err() || fallback.unwrap().plaintext != plaintext,
+            "the stale cache must not yield the correct plaintext"
+        );
+    }
+
     #[test]
     fn decrypt_with_cek_returns_mismatch_error_when_content_id_differs() {
         let (repo, _storage) = TestContentRepository::new(false);

monas-content/src/application_service/share_service/command.rs

@@ -8,6 +8,9 @@ use crate::domain::share::{KeyEnvelope, KeyId, Permission};
 pub struct GrantShareCommand {
     pub content_id: ContentId,
     pub sender_key_id: KeyId,
+    /// 送信者の秘密鍵バイト列。HPKE Auth モードの wrap(送信者認証)に用いる。
+    /// 保存はされず、この呼び出しの間だけ使われる。
+    pub sender_private_key: Vec<u8>,
     pub recipient_public_key: Vec<u8>,
     pub permission: Permission,
 }
@@ -24,6 +27,9 @@ pub struct GrantShareResult {
 pub struct RevokeShareCommand {
     pub content_id: ContentId,
     pub sender_key_id: KeyId,
+    /// 送信者の秘密鍵バイト列。残存受信者向け KeyEnvelope 再発行の
+    /// HPKE Auth モード wrap(送信者認証)に用いる。
+    pub sender_private_key: Vec<u8>,
     pub recipient_key_id: KeyId,
 }
 

monas-content/src/application_service/share_service/mod.rs

@@ -1,7 +1,9 @@
 mod command;
 mod port;
+pub mod sender_key_pin_port;
 mod service;
 
 pub use command::*;
 pub use port::*;
+pub use sender_key_pin_port::{SenderKeyPin, SenderKeyPinStore, SenderKeyPinStoreError};
 pub use service::*;

monas-content/src/application_service/share_service/sender_key_pin_port.rs

@@ -0,0 +1,86 @@
+//! 受信者側の送信者公開鍵ピン(TOFU)ストア。
+//!
+//! share の KeyEnvelope は HPKE Auth モードでラップされており、受信者は
+//! 「期待する送信者の公開鍵」で unwrap する(成功 = その鍵の持ち主が作った証明)。
+//! このストアは content ごとに、最初に unwrap に成功した送信者公開鍵を
+//! ピン留めし(TOFU)、以後の envelope はピン済みの鍵でのみ検証する。
+//!
+//! 併せて CEK の鍵世代(key_epoch)と、**その世代の CEK 自体**を記録する。
+//! 記録済み世代より古い envelope は拒否する(rotation 後に旧 envelope を
+//! 再送して CEK を巻き戻す replay 攻撃の防止)。
+//!
+//! ## なぜ CEK をここに置くのか
+//!
+//! 守るべき不変条件は「送信者鍵・世代・CEK の3つ組が常に整合していること」で
+//! あって、世代番号だけではない。3つ組を別ストアに分けて別々に commit すると、
+//! 世代を CAS で守っても次の interleaving で壊れる:
+//!
+//! 1. epoch N の処理が pin(epoch N-1)を読む
+//! 2. epoch N+1 の処理が pin を N+1 へ進め、新しい CEK を保存する
+//! 3. epoch N の処理が「同一世代の再処理」等の経路で CEK だけを書き戻す
+//! 4. 結果は `pin = N+1, CEK = N` となり、以後の復号が失敗する
+//!
+//! 3つ組を1レコードに入れて単一の compare-and-swap で入れ替えれば、この
+//! interleaving は構造的に起こり得ない。CEK ストア側は、この権威レコードから
+//! 導出されるキャッシュとして扱う(書き損じても再処理で回復できる)。
+//!
+//! キーは受信者から見た(ローカルの) content id。
+
+#[derive(Debug, thiserror::Error)]
+pub enum SenderKeyPinStoreError {
+    #[error("sender key pin store error: {0}")]
+    Storage(String),
+}
+
+/// ピン留めされた送信者公開鍵と、その送信者から受理した最新の鍵世代・CEK。
+///
+/// この3つは常に同じ commit で入れ替わる。個別に更新してはならない
+/// (モジュール doc の interleaving を参照)。
+#[derive(Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct SenderKeyPin {
+    /// 送信者の公開鍵バイト列(P-256 uncompressed form)。
+    pub sender_public_key: Vec<u8>,
+    /// 最後に unwrap に成功した envelope の key_epoch。
+    pub key_epoch: u64,
+    /// `key_epoch` 世代の CEK。この端末のローカルにのみ存在し、ネットワークには出ない。
+    ///
+    /// 旧レコード(CEK を持たない形式)から読んだ場合は `None` になる。
+    /// その場合は次に受理した envelope で埋まる。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cek: Option<Vec<u8>>,
+}
+
+/// CEK を含むため、`Debug` は鍵素材を出さない。ログや panic メッセージに
+/// レコードが載っても CEK が漏れないようにする。
+impl std::fmt::Debug for SenderKeyPin {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SenderKeyPin")
+            .field("sender_public_key", &self.sender_public_key)
+            .field("key_epoch", &self.key_epoch)
+            .field(
+                "cek",
+                &self.cek.as_ref().map(|_| "<redacted>").unwrap_or("None"),
+            )
+            .finish()
+    }
+}
+
+/// `content_id -> (送信者公開鍵, 最終受理 key_epoch, その世代の CEK)` の永続化ポート。
+pub trait SenderKeyPinStore: Send + Sync {
+    fn load(&self, content_id: &str) -> Result<Option<SenderKeyPin>, SenderKeyPinStoreError>;
+    fn save(&self, content_id: &str, pin: &SenderKeyPin) -> Result<(), SenderKeyPinStoreError>;
+
+    /// compare-and-advance: 現在値が `expected` と一致する場合のみ `pin` へ進める。
+    /// 戻り値は「進めたかどうか」。
+    ///
+    /// envelope の並行処理(rotation 前後の epoch N / N+1 が同時に走る等)で、
+    /// 「load した時点の pin」を前提に無条件 save すると、後から完了した古い
+    /// epoch が新しいレコードを巻き戻せる。3つ組は1レコードなので、この CAS が
+    /// 成功した時点で送信者鍵・世代・CEK は一括で入れ替わっている。
+    fn compare_and_save(
+        &self,
+        content_id: &str,
+        expected: Option<&SenderKeyPin>,
+        pin: &SenderKeyPin,
+    ) -> Result<bool, SenderKeyPinStoreError>;
+}