fix(env): PR #13 round4 gemini 指摘対応

- cipher.py: `@PATH` ファイルに複数行の鍵が含まれる場合は明示的に
  CipherError を投げる。team_keys.txt のような複数公開鍵列挙を
  暗黙に「最初の 1 人」だけ扱う挙動は、チーム運用で暗号化バンドル
  が壊れる原因になるため誤運用を防ぐ
- io_common.py: `resolve_identity_specs` で `~/.ssh/id_ed25519` と
  `~/.ssh/id_rsa` の両方が存在する場合、両方を返すように変更。
  `pyrage.decrypt` は複数 identity を受け付け、バンドルに合致する
  鍵だけが使われる。これにより RSA で暗号化されたバンドルを
  ed25519 鍵だけで開けず失敗する問題を解消
- resolve_recipient_specs は意図的に最初の 1 つを返す挙動を維持
  (どの鍵で暗号化するか一意に決める必要があるため)
- 複数鍵ファイル拒否と複数 identity 復号の回帰テストを追加

Author: takemi-ohama

lib/devbase/env/cipher.py

@@ -50,13 +50,22 @@ def _resolve_recipient(spec: str, _depth: int = 0):
                 f"recipient ファイルの読み込みに失敗しました ({path}): {e}"
             ) from e
         # ファイル中に複数行 / コメント / 空行が混在していても扱えるよう、
-        # 空行と '#' で始まるコメント行を除いた最初の有効行を採用する。
+        # 空行と '#' で始まるコメント行を除いた有効行のみを取り出す。
         valid = [
             line.strip() for line in content.splitlines()
             if line.strip() and not line.strip().startswith('#')
         ]
         if not valid:
             raise CipherError(f"recipient ファイルに有効な行がありません: {path}")
+        if len(valid) > 1:
+            # 複数公開鍵を 1 ファイルに列挙したケース (team_keys.txt 等)。
+            # 暗黙に「最初の 1 人」だけ採用するとチーム運用で暗号化が壊れるため、
+            # 明示的に複数 `--recipient` で指定するよう要求する (PR #13 gemini 指摘)。
+            raise CipherError(
+                f"recipient ファイルに複数行の鍵が含まれています ({path}, {len(valid)} 件)。"
+                "複数の公開鍵で暗号化したい場合は `--recipient @file_a.pub --recipient @file_b.pub` "
+                "のように 1 ファイルにつき 1 鍵で指定してください"
+            )
         return _resolve_recipient(valid[0], _depth + 1)
 
     if spec.startswith('age1'):

lib/devbase/env/io_common.py

@@ -70,16 +70,21 @@ def resolve_recipient_specs(specs: Sequence[str]) -> List[str]:
 def resolve_identity_specs(specs: Sequence[str]) -> List[str]:
     """identity 指定の解決。
 
-    明示指定があればそのまま返す。空なら ``~/.ssh/id_ed25519`` → ``id_rsa`` の
-    順で存在する秘密鍵を探し、最初に見つかったものを返す。
+    明示指定があればそのまま返す。空なら ``~/.ssh/id_ed25519`` / ``id_rsa`` の
+    うち **存在するものをすべて** 返す。``pyrage.decrypt`` は複数 identity を
+    受け付け、バンドル内の暗号化対象と一致した identity だけ復号に使われるため、
+    両方を渡しておけば「どの鍵で暗号化されたか分からない」状況でも復号できる
+    (PR #13 gemini 指摘)。一方 ``resolve_recipient_specs`` は明確に「どの鍵で
+    暗号化するか」を選ぶ必要があるため最初の 1 つだけを返す (非対称な仕様)。
     """
     if specs:
         return list(specs)
+    found: List[str] = []
     for path in _cipher.default_identity_paths():
         if path.exists():
             logger.info("identity 既定鍵を使用: %s", path)
-            return [str(path)]
-    return []
+            found.append(str(path))
+    return found
 
 
 def write_secure_bytes(path: Path, data: bytes, *, mode: int = 0o600) -> None:

tests/env/test_cipher.py

@@ -126,6 +126,25 @@ def test_resolve_recipient_at_path_rejects_only_comments(tmp_path):
         cipher.encrypt(b"x", recipients=[f"@{pub_path}"])
 
 
+def test_resolve_recipient_at_path_rejects_multiple_keys(tmp_path, x25519_keypair):
+    """@PATH ファイルに複数の鍵を列挙したら CipherError で明示的に拒否される。
+
+    暗黙に最初の 1 行だけ採用すると、`team_keys.txt` のような複数公開鍵ファイル
+    を渡したケースで「最初の 1 人」だけにしか暗号化されず、他メンバーの復号が
+    壊れる。誤運用を防ぐため明確にエラーを返す (PR #13 gemini 指摘)。
+    """
+    pub_a, _ = x25519_keypair
+    # 2 つ目の鍵を別途生成
+    pub_b = str(pyrage.x25519.Identity.generate().to_public())
+
+    team_keys = tmp_path / "team_keys.txt"
+    team_keys.write_text(
+        f"# alice\n{pub_a}\n# bob\n{pub_b}\n"
+    )
+    with pytest.raises(cipher.CipherError, match="複数行の鍵|1 鍵で指定"):
+        cipher.encrypt(b"x", recipients=[f"@{team_keys}"])
+
+
 def test_resolve_recipient_at_path_wraps_oserror(tmp_path, monkeypatch):
     """@PATH の read_text が OSError を投げた場合 CipherError に包んで送出"""
     rcpt_path = tmp_path / "rcpt.pub"

tests/env/test_io_common.py

@@ -0,0 +1,122 @@
+"""io_common.py: resolve_recipient_specs / resolve_identity_specs の挙動"""
+
+from __future__ import annotations
+
+import pyrage
+import pytest
+
+from devbase.env import cipher
+from devbase.env import io_common
+
+
+@pytest.fixture
+def fake_home(tmp_path, monkeypatch):
+    """``Path.home()`` を ``tmp_path`` に差し替える"""
+    from pathlib import Path
+
+    monkeypatch.setattr(Path, "home", classmethod(lambda cls: tmp_path))
+    return tmp_path
+
+
+def test_resolve_recipient_specs_returns_first_existing_default(fake_home):
+    """recipient は「どの鍵で暗号化するか」を一意に決める必要があるため、
+    既定鍵が複数存在しても最初に見つかったものだけ返す (ed25519 を優先)。"""
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    (ssh / "id_ed25519.pub").write_text("ssh-ed25519 AAAA dummy\n")
+    (ssh / "id_rsa.pub").write_text("ssh-rsa AAAA dummy\n")
+
+    specs = io_common.resolve_recipient_specs([])
+    assert len(specs) == 1
+    assert specs[0].endswith("id_ed25519.pub")
+
+
+def test_resolve_recipient_specs_explicit_passthrough(fake_home):
+    """明示指定があれば既定鍵探索は行わない (そのまま返す)"""
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    (ssh / "id_ed25519.pub").write_text("ssh-ed25519 AAAA dummy\n")
+
+    specs = io_common.resolve_recipient_specs(["age1example"])
+    assert specs == ["age1example"]
+
+
+def test_resolve_recipient_specs_returns_empty_when_no_defaults(fake_home):
+    """既定鍵が見つからなければ空 list"""
+    assert io_common.resolve_recipient_specs([]) == []
+
+
+def test_resolve_identity_specs_returns_all_existing_defaults(fake_home):
+    """identity は「どの鍵で暗号化されたか」が事前に分からないため、
+    存在するすべての既定鍵を返す。``pyrage.decrypt`` は複数 identity を
+    受け取れる仕様なので、両方渡しておけばどちらの鍵で暗号化されたバンドル
+    でも復号できる (PR #13 gemini 指摘)。"""
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    (ssh / "id_ed25519").write_text("dummy ed25519 key\n")
+    (ssh / "id_rsa").write_text("dummy rsa key\n")
+
+    specs = io_common.resolve_identity_specs([])
+    assert len(specs) == 2
+    # ed25519 が先に来る (default_identity_paths の順序を維持)
+    assert specs[0].endswith("id_ed25519")
+    assert specs[1].endswith("id_rsa")
+
+
+def test_resolve_identity_specs_returns_only_existing(fake_home):
+    """片方しか存在しなければそれだけ返す"""
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    (ssh / "id_rsa").write_text("dummy\n")
+
+    specs = io_common.resolve_identity_specs([])
+    assert len(specs) == 1
+    assert specs[0].endswith("id_rsa")
+
+
+def test_resolve_identity_specs_explicit_passthrough(fake_home):
+    """明示指定があれば既定鍵探索は行わない"""
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    (ssh / "id_ed25519").write_text("dummy\n")
+
+    specs = io_common.resolve_identity_specs(["/path/to/explicit.key"])
+    assert specs == ["/path/to/explicit.key"]
+
+
+def test_resolve_identity_specs_returns_empty_when_no_defaults(fake_home):
+    """既定鍵が一切無ければ空"""
+    assert io_common.resolve_identity_specs([]) == []
+
+
+def test_decrypt_uses_correct_identity_from_multiple_defaults(tmp_path, fake_home):
+    """``resolve_identity_specs`` が返した複数 identity を ``cipher.decrypt`` に
+    渡すと、その中から正しい identity が選ばれて復号される。
+
+    シナリオ: 既定 ssh 鍵が 2 つ (id_ed25519 / id_rsa) 存在する状況を模した上で、
+    `id_rsa` (実体は age 鍵) で暗号化したバンドルを「両方の identity を試す」
+    `cipher.decrypt(identities=[both])` で復号できることを確認する。
+    `id_ed25519` 側は別 age 鍵で、こちらは復号に使われない。
+    """
+    # 異なる 2 つの age 鍵を用意し、ssh 既定パスに配置して
+    # resolve_identity_specs から両方が返るようにする
+    id1 = pyrage.x25519.Identity.generate()
+    id2 = pyrage.x25519.Identity.generate()
+
+    ssh = fake_home / ".ssh"
+    ssh.mkdir()
+    ed_path = ssh / "id_ed25519"
+    rsa_path = ssh / "id_rsa"
+    ed_path.write_text(str(id1))   # ed25519 スロットに id1
+    rsa_path.write_text(str(id2))  # rsa スロットに id2 (=暗号化に使う鍵)
+
+    # id2 の公開鍵だけで暗号化 → id1 では復号できないバンドル
+    blob = cipher.encrypt(b"team-secret", recipients=[str(id2.to_public())])
+
+    # resolve_identity_specs は両方返す
+    identities = io_common.resolve_identity_specs([])
+    assert len(identities) == 2
+
+    # 両 identity を渡して復号 → pyrage が正しい鍵 (id2) を選んで復号する
+    plain = cipher.decrypt(blob, identities=identities)
+    assert plain == b"team-secret"