Add store passphrase policy

Author: 01rabbit

README.md

@@ -294,6 +294,7 @@ PHANTASM_STATE_DIR=/path/to/state python3 main.py init
 | `PHANTASM_RESTRICTED_SESSION_SECONDS` | Restricted confirmation lifetime |
 | `PHANTASM_FIELD_MODE=1` | Reduce normal WebUI operational detail |
 | `PHANTASM_PROFILE` | Select local capability mode: `standard`, `field`, or `maintenance` |
+| `PHANTASM_MIN_PASSPHRASE_LENGTH` | Minimum Store passphrase length |
 | `PHANTASM_AUDIT=1` | Enable audit logging |
 
 ## Local-Only Trust Boundary
@@ -304,6 +305,8 @@ Restricted local data-loss behavior should be understood primarily as key-materi
 
 For high-risk deployments, do not store all recovery conditions on the same physical medium. Phantasm is strongest when the encrypted container, local state, memorized password, physical-object cue, and optional external key material are separated.
 
+Store flows reject empty, obviously short, duplicate, or highly repetitive passphrases. This policy reduces accidental weak input, but it is not a substitute for secure operational procedure, key separation, or target-hardware validation.
+
 ## Test Command
 
 ```bash

docs/REVIEW_VALIDATION_RECORD.md

@@ -24,7 +24,7 @@ python3 -m unittest discover -s tests
 Result:
 
 ```text
-2026-05-02, macOS Darwin arm64, python3 -m unittest discover -s tests, 133 tests passed.
+2026-05-02, macOS Darwin arm64, python3 -m unittest discover -s tests, 141 tests passed.
 ```
 
 Restricted-flow scenario matrix:

docs/SPECIFICATION.md

@@ -79,10 +79,11 @@ Store flow:
 
 1. Start the camera gate.
 2. Prompt for normal access and restricted recovery passwords.
-3. Register the physical object cue for the selected internal entry.
-4. Read the input file.
-5. Derive a key with Argon2id.
-6. Encrypt the payload with AES-GCM.
+3. Reject empty, duplicate, short, or highly repetitive passphrases.
+4. Register the physical object cue for the selected internal entry.
+5. Read the input file.
+6. Derive a key with Argon2id.
+7. Encrypt the payload with AES-GCM.
 
 ### Retrieve
 
@@ -314,6 +315,7 @@ The physical object is an operational cue, not a high-entropy cryptographic fact
 | `PHANTASM_RESTRICTED_SESSION_SECONDS` | Restricted confirmation lifetime | `120` |
 | `PHANTASM_FIELD_MODE` | Reduce normal WebUI operational detail | `0` |
 | `PHANTASM_PROFILE` | Select local capability mode: `standard`, `field`, or `maintenance` | `standard` |
+| `PHANTASM_MIN_PASSPHRASE_LENGTH` | Minimum Store passphrase length | `10` |
 | `PHANTASM_AUDIT` | Enable audit logging | `0` |
 | `PHANTASM_AUDIT_FILENAMES` | Record filename hashes | unset |
 

docs/THREAT_MODEL.md

@@ -36,6 +36,7 @@ It is not a substitute for audited full-disk encryption, hardware-backed key sto
 - New stores use GhostVault v3 records: random per-record Argon2id salt, random per-record AES-GCM nonce, no plaintext magic/header, and AEAD-authenticated encrypted metadata.
 - The local access key is mixed into Argon2id by default, so copying `vault.bin` alone is insufficient for recovery.
 - Protected entries can be stored with normal access and restricted recovery passwords that share the same object cue.
+- Store flows reject empty, duplicate, short, or highly repetitive passphrases to reduce accidental weak input.
 - `PHANTASM_HARDWARE_SECRET_FILE`, `PHANTASM_HARDWARE_SECRET`, or `PHANTASM_HARDWARE_SECRET_PROMPT=1` can add an external value to Argon2id derivation. Data stored with any of these values requires the same value for retrieval.
 - Default Argon2id parameters are tuned for Raspberry Pi Zero 2 W class hardware: `memory_cost=32768`, `iterations=2`, `lanes=1`.
 - Restricted recovery behavior and explicit restricted actions can update unmatched local state. These paths can cause irreversible data loss.
@@ -71,6 +72,7 @@ These surfaces should not reveal the internal disclosure model, internal trial o
 - UI face lock can be affected by lighting, camera angle, false rejects, false accepts, and presentation attacks using photos or screens.
 - The in-memory Web rate limiter and restricted confirmation state reset on process restart and are not substitutes for a full access-control layer.
 - UI tokens can be read from a compromised browser or host session.
+- Passphrase policy cannot compensate for observed input, reused passwords, coercion, compromised hosts, or poor operational separation.
 - Metadata checks and metadata reduction are best-effort. They can miss embedded identifiers, thumbnails, histories, and application-specific fields.
 - Optional audit logs can support local review, including tamper detection for versioned records, but they also create local metadata.
 - Browser history, cache, shell history, systemd logs, environment variables, and temporary files can leak operational context if the appliance is not configured carefully.

src/phantasm/cli.py

@@ -12,6 +12,7 @@
 from .face_lock import face_lock
 from .gv_core import GhostVault
 from .operations import doctor, export_redacted_log, verify_audit_log, verify_state
+from .passphrase_policy import check_store_passphrases
 
 CAMERA_WARMUP_TIMEOUT = 10
 REFERENCE_MATCH_TIMEOUT = 10
@@ -139,8 +140,11 @@ def _prompt_store_passwords():
         raise ValueError("access password must not be empty")
     if not restricted_recovery_password:
         raise ValueError("restricted recovery password must not be empty")
-    if open_password == restricted_recovery_password:
-        raise ValueError("access and restricted recovery passwords must be different")
+    passphrase_check = check_store_passphrases(
+        open_password, restricted_recovery_password
+    )
+    if not passphrase_check.ok:
+        raise ValueError(passphrase_check.message)
     return open_password, restricted_recovery_password
 
 

src/phantasm/config.py

@@ -42,3 +42,11 @@ def ui_face_enrollment_enabled():
 
 def field_mode_enabled():
     return env_flag("PHANTASM_FIELD_MODE", default=False)
+
+
+def passphrase_min_length():
+    value = os.environ.get("PHANTASM_MIN_PASSPHRASE_LENGTH", "10")
+    try:
+        return max(1, int(value))
+    except ValueError:
+        return 10

src/phantasm/passphrase_policy.py

@@ -0,0 +1,46 @@
+"""Local passphrase checks for Store flows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .config import passphrase_min_length
+
+
+@dataclass(frozen=True)
+class PassphraseCheck:
+    ok: bool
+    message: str = ""
+
+
+def check_passphrase(value: str, label: str = "Access password"):
+    if not value:
+        return PassphraseCheck(False, f"{label} must not be empty.")
+    minimum = passphrase_min_length()
+    if len(value) < minimum:
+        return PassphraseCheck(
+            False,
+            f"{label} must be at least {minimum} characters.",
+        )
+    if len(set(value)) <= 2:
+        return PassphraseCheck(False, f"{label} is too repetitive.")
+    return PassphraseCheck(True)
+
+
+def check_store_passphrases(access_value: str, restricted_value: str = ""):
+    access_check = check_passphrase(access_value, "Access password")
+    if not access_check.ok:
+        return access_check
+    if restricted_value:
+        if access_value == restricted_value:
+            return PassphraseCheck(
+                False,
+                "Access and restricted recovery passwords must be different.",
+            )
+        restricted_check = check_passphrase(
+            restricted_value,
+            "Restricted recovery password",
+        )
+        if not restricted_check.ok:
+            return restricted_check
+    return PassphraseCheck(True)

src/phantasm/web_server.py

@@ -38,6 +38,7 @@
 from .face_lock import face_lock
 from .gv_core import GhostVault
 from .metadata import metadata_risk_report, scrub_metadata
+from .passphrase_policy import check_store_passphrases
 from .restricted_actions import (
     RestrictedActionPolicy,
     RestrictedActionRejected,
@@ -715,8 +716,12 @@ async def store(
     try:
         if not password:
             return {"error": text.ACCESS_PASSWORD_REQUIRED}
-        if restricted_recovery_password and password == restricted_recovery_password:
-            return {"error": text.PASSWORDS_MUST_DIFFER}
+        passphrase_check = check_store_passphrases(
+            password,
+            restricted_recovery_password,
+        )
+        if not passphrase_check.ok:
+            return {"error": passphrase_check.message}
         if overwrite and overwrite_confirmation != OVERWRITE_CONFIRMATION_PHRASE:
             return {"error": text.REPLACEMENT_CONFIRMATION_REQUIRED}
         if overwrite and not _restricted_session_valid(request):

tests/test_cli.py

@@ -107,6 +107,17 @@ def format_container(self, rotate_access_key=False):
         self.assertEqual(enroll_message, "enrollment armed")
         arm.assert_called_once_with()
 
+    def test_store_password_prompt_rejects_short_values(self):
+        prompts = iter(["short", "another-short"])
+
+        with unittest.mock.patch(
+            "getpass.getpass", side_effect=lambda _: next(prompts)
+        ):
+            with self.assertRaises(ValueError) as ctx:
+                cli._prompt_store_passwords()
+
+        self.assertIn("at least", str(ctx.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_config.py

@@ -46,6 +46,18 @@ def test_field_mode_defaults_to_disabled(self):
         with mock.patch.dict(os.environ, {}, clear=True):
             self.assertFalse(config.field_mode_enabled())
 
+    def test_passphrase_min_length_defaults_and_handles_invalid_env(self):
+        with mock.patch.dict(os.environ, {}, clear=True):
+            self.assertEqual(config.passphrase_min_length(), 10)
+        with mock.patch.dict(
+            os.environ, {"PHANTASM_MIN_PASSPHRASE_LENGTH": "12"}, clear=True
+        ):
+            self.assertEqual(config.passphrase_min_length(), 12)
+        with mock.patch.dict(
+            os.environ, {"PHANTASM_MIN_PASSPHRASE_LENGTH": "bad"}, clear=True
+        ):
+            self.assertEqual(config.passphrase_min_length(), 10)
+
 
 if __name__ == "__main__":
     unittest.main()