ciphergate-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/CHANGELOG.md

@@ -6,6 +6,19 @@ versioning: [PEP 440](https://peps.python.org/pep-0440/) with SemVer meaning (pr
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-10-31
+
+Makes a clean rescan harder to mistake for proof of safety. Scripts that read `PASSED` from the
+`rescan` terminal output need updating; exit codes and the JSON report do not change.
+
+### Changed
+
+- The `rescan` terminal summary no longer prints `PASSED`. It says `NO GATING FINDINGS`, or
+  `NOT ENFORCED` when gating findings remain with strict off, and states what rescan cannot see.
+  Exit codes and the JSON report's `status` are unchanged.
+- `validate-policy` warns when a rule or default handles `credential.secret` with anything other
+  than `block` or `review` toward a possibly untrusted destination.
+
 ## [0.10.0] - 2026-10-30
 
 Fixes a password leak in nested values and detects more credentials and identifiers. A run that
@@ -315,7 +328,8 @@ Pre-release (alpha). Licensed under Apache-2.0. Not a final release: the securit
 See `docs/limitations.md`. Deferred: optional NER/Presidio detectors, stdin/stdout streaming,
 directory processing, structured log parsers, key files, reversible token vault, lossy decoding.
 
-[Unreleased]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.10.0...HEAD
+[Unreleased]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.11.0...HEAD
+[0.11.0]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.7.1...v0.8.0

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ciphergate-cli
-Version: 0.10.0
+Version: 0.11.0
 Summary: Local-first, environment- and destination-aware inspection and sanitization of logs and test datasets.
 Project-URL: Homepage, https://github.com/aashishkumar-tech/ciphergate
 Project-URL: Source, https://github.com/aashishkumar-tech/ciphergate
@@ -50,7 +50,7 @@ vendor ticket. CipherGate replaces that with a local, explainable, scriptable ga
 inspect  ->  plan  ->  sanitize --apply  ->  rescan
 ```
 
-> **Status: 0.10.0 (alpha).** No detector finds every sensitive value. A passing run means the
+> **Status: 0.11.0 (alpha).** No detector finds every sensitive value. A passing run means the
 > configured processing completed under the selected policy; it is **not** proof that the output
 > contains no sensitive information, and it is not a compliance (GDPR, HIPAA, PCI DSS, ...) or
 > anonymization guarantee. Policy templates must be reviewed before use.
@@ -154,6 +154,7 @@ ciphergate sanitize examples/sample.csv --policy policies/prd_external_ai.yml \
   --output build/sample.sanitized.csv --report build/sample.report.json --apply
 
 # 5. Rescan the output (read-only). Exit 7 if gating residual findings remain.
+# A clean result only means no gating findings. It does not show the output is safe.
 ciphergate rescan build/sample.sanitized.csv --policy policies/prd_external_ai.yml
 ```
 

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/README.md

@@ -11,7 +11,7 @@ vendor ticket. CipherGate replaces that with a local, explainable, scriptable ga
 inspect  ->  plan  ->  sanitize --apply  ->  rescan
 ```
 
-> **Status: 0.10.0 (alpha).** No detector finds every sensitive value. A passing run means the
+> **Status: 0.11.0 (alpha).** No detector finds every sensitive value. A passing run means the
 > configured processing completed under the selected policy; it is **not** proof that the output
 > contains no sensitive information, and it is not a compliance (GDPR, HIPAA, PCI DSS, ...) or
 > anonymization guarantee. Policy templates must be reviewed before use.
@@ -115,6 +115,7 @@ ciphergate sanitize examples/sample.csv --policy policies/prd_external_ai.yml \
   --output build/sample.sanitized.csv --report build/sample.report.json --apply
 
 # 5. Rescan the output (read-only). Exit 7 if gating residual findings remain.
+# A clean result only means no gating findings. It does not show the output is safe.
 ciphergate rescan build/sample.sanitized.csv --policy policies/prd_external_ai.yml
 ```
 

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/docs/limitations.md

@@ -5,7 +5,9 @@
 - Detection is incomplete. Names, addresses, government IDs and bank accounts are not detected by
   value in free text; secrets in custom formats or encoded forms are missed. See
   [detector-coverage.md](detector-coverage.md).
-- A clean rescan is a quality gate, not proof of safety. Rescan cannot verify date-shifted values
+- A clean rescan is a quality gate, not proof of safety. The terminal summary says "no gating
+  findings" for this reason, while the JSON report keeps `status: passed` for CI. Names and
+  addresses in free text are often missed. Rescan cannot verify date-shifted values
   (reported as `unverifiable`) and recognises CipherGate's own markers/pseudonyms/replacement
   constants as transformed output.
 - Confidence values are uncalibrated engineering estimates.

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/docs/policy-schema.md

@@ -122,6 +122,12 @@ A context selector never matches missing context.
 | `review` | — | run needs human decision, nothing written |
 | `tokenize` | — | **rejected**: no token vault in this release |
 
+A rule or default that applies `redact`, `replace`, or any other non-`block`, non-`review` action
+to `credential.secret` toward a possibly untrusted destination validates with a warning, because
+a detector can match only part of a secret. A destination that is not pinned counts as possibly
+untrusted. A `hard: true` block that covers every untrusted destination, with no selectors other
+than `categories` and `destinations`, removes the warning.
+
 ## Precedence (deterministic)
 
 1. Engine hard constraints: missing/invalid context gates; credential never allowed (forced

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/src/ciphergate/__init__.py

@@ -24,7 +24,7 @@ Supported public API (everything else is internal and may change without notice)
     rescan_directory(root, policy, context=None, *, recursive=False, strict=None) -> BatchReport
 """
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"
 
 from ciphergate.config import RuntimeSettings
 from ciphergate.constants import (

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/src/ciphergate/cli.py

@@ -749,7 +749,10 @@ def rescan_command(
     no_color: NoColorOpt = False,
     debug: DebugOpt = False,
 ) -> None:
-    """Report residual findings in an existing output. Read-only; never alters the file."""
+    """Report residual findings in an existing output. Read-only; never alters the file.
+
+    No gating findings does not mean the output is safe: rescan only sees what detectors match.
+    """
     _configure_logging(verbose, debug)
     _guard(
         debug,

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/src/ciphergate/constants.py

@@ -272,3 +272,7 @@ DISCLAIMER = (
     "It does not prove that the output contains no sensitive information; "
     "detectors can miss values."
 )
+RESCAN_LIMIT = (
+    "rescan only sees what the enabled detectors match. No gating findings does not mean the "
+    "output is safe; names and addresses in free text are often missed."
+)

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/src/ciphergate/policy/validator.py

@@ -225,6 +225,34 @@ def _effective_destinations(doc: PolicyDocument, rule_dests: list[Destination] |
     return {str(d) for d in Destination}
 
 
+def _hard_blocked_destinations(doc: PolicyDocument, categories: frozenset[str]) -> set[str]:
+    """Destinations where a hard rule blocks every credential finding, whatever its field."""
+    blocked: set[str] = set()
+    for rule in doc.rules:
+        m = rule.match
+        if (
+            rule.hard
+            and rule.action == Action.BLOCK
+            and m.categories is not None
+            and CREDENTIAL_CATEGORY in _selector_can_cover(m.categories, categories)
+            and set(m.model_dump(exclude_none=True)) <= {"categories", "destinations"}
+        ):
+            blocked |= _effective_destinations(doc, m.destinations)
+    return blocked
+
+
+def _relaxes_credentials(
+    doc: PolicyDocument,
+    action: Action,
+    rule_dests: list[Destination] | None,
+    hard_blocked: set[str],
+) -> bool:
+    if action in (Action.BLOCK, Action.REVIEW):
+        return False
+    reachable = _effective_destinations(doc, rule_dests) - hard_blocked
+    return bool(reachable & {str(d) for d in UNTRUSTED_DESTINATIONS})
+
+
 def _selector_can_cover(selectors: list[str] | None, categories: frozenset[str]) -> set[str]:
     if selectors is None:
         return set(categories)
@@ -335,6 +363,7 @@ def compile_policy(raw: dict[str, Any], *, digest: str, source_name: str | None
     required_keys: set[str] = set()
     replacement_values: set[str] = set()
     seen_rules: set[str] = set()
+    hard_blocked = _hard_blocked_destinations(doc, categories)
     for i, rule in enumerate(doc.rules):
         where = f"rules[{i}]"
         if rule.id in seen_rules:
@@ -394,6 +423,15 @@ def compile_policy(raw: dict[str, Any], *, digest: str, source_name: str | None
                     "credential_unsafe_action",
                 )
             )
+        if (
+            CREDENTIAL_CATEGORY in covered
+            and m.categories is not None
+            and _relaxes_credentials(doc, rule.action, m.destinations, hard_blocked)
+        ):
+            warnings.append(
+                f"rule '{rule.id}' applies '{rule.action}' to credential.secret toward a possibly "
+                "untrusted destination instead of blocking; detection can miss part of a secret"
+            )
         if rule.action == Action.ALLOW:
             dests = _effective_destinations(doc, m.destinations)
             untrusted = dests & {str(d) for d in UNTRUSTED_DESTINATIONS}
@@ -492,6 +530,13 @@ def compile_policy(raw: dict[str, Any], *, digest: str, source_name: str | None
                     "credential_unsafe_action",
                 )
             )
+        if CREDENTIAL_CATEGORY in covered and _relaxes_credentials(
+            doc, spec.action, None, hard_blocked
+        ):
+            warnings.append(
+                f"default '{sel}' applies '{spec.action}' to credential.secret toward a possibly "
+                "untrusted destination instead of blocking; detection can miss part of a secret"
+            )
         if isinstance(params, PseudonymizeParams | DateShiftParams):
             required_keys.add(params.key_env)
         if isinstance(params, ReplaceParams) and params.value is not None:

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/src/ciphergate/reporting/terminal.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from ciphergate.constants import DISCLAIMER
+from ciphergate.constants import DISCLAIMER, RESCAN_LIMIT
 from ciphergate.models.report import RunReport
 from ciphergate.pipeline.batch import BatchReport
 from ciphergate.reporting.safe_text import escape_control
@@ -31,9 +31,24 @@ def _location(loc: dict[str, Any]) -> str:
     return ", ".join(parts)
 
 
+def _rescan_verdict(rescan: dict[str, Any]) -> str:
+    if rescan["failed"]:
+        return "FAILED, gating findings remain"
+    if rescan["gating_by_category"]:
+        return "NOT ENFORCED, gating findings remain but strict is off"
+    return "no gating findings"
+
+
+def _headline(d: dict[str, Any]) -> str:
+    # Never print a bare PASSED for rescan: it reads as "this output is safe".
+    if d["command"] == "rescan" and d["rescan"] and not d["rescan"]["failed"]:
+        return _rescan_verdict(d["rescan"]).split(",")[0].upper()
+    return str(d["status"]).upper()
+
+
 def render_summary(report: RunReport, *, verbose: bool = False) -> str:
     d = report.to_dict()
-    lines = [f"CipherGate {d['command']}: {d['status'].upper()} (exit {d['exit_code']})"]
+    lines = [f"CipherGate {d['command']}: {_headline(d)} (exit {d['exit_code']})"]
     inp = d["input"]
     lines.append(
         f"  input:   {escape_control(str(inp['path']))} [{inp['format']}, "
@@ -89,12 +104,13 @@ def render_summary(report: RunReport, *, verbose: bool = False) -> str:
         )
     if d["rescan"]:
         r = d["rescan"]
-        verdict = "FAILED" if r["failed"] else "passed"
         lines.append(
-            f"  rescan: {verdict} (strict={r['strict']}) residuals: {_counts(r['counts'])}"
+            f"  rescan: {_rescan_verdict(r)} (strict={r['strict']}) "
+            f"residuals: {_counts(r['counts'])}"
         )
         if r["gating_by_category"]:
             lines.append(f"    gating residuals: {_counts(r['gating_by_category'])}")
+        lines.append(f"  rescan limit: {RESCAN_LIMIT}")
     out = d["output"]
     if out:
         if out.get("written"):

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/tests/integration/test_cli_e2e.py

@@ -197,6 +197,28 @@ def test_sanitize_missing_key_exit_6(tmp_path: Path, no_key_env: None) -> None:
     assert r.exit_code == 6 and not out.exists() and "missing" in r.stdout
 
 
+def test_rescan_summary_never_says_a_bare_pass(tmp_path: Path) -> None:
+    policy = POLICIES / "prd_external_ai.yml"
+    clean = tmp_path / "clean.log"
+    clean.write_text("service started\n", encoding="utf-8")
+    r = invoke("rescan", clean, "--policy", policy)
+    assert r.exit_code == 0
+    assert "NO GATING FINDINGS" in r.stdout and "does not mean the output is safe" in r.stdout
+    assert "PASSED" not in r.stdout and "passed" not in r.stdout.replace("--", "")
+
+    report = tmp_path / "report.json"
+    assert invoke("rescan", clean, "--policy", policy, "--report", report).exit_code == 0
+    assert json.loads(report.read_text(encoding="utf-8"))["status"] == "passed"
+
+
+def test_rescan_summary_says_when_gating_findings_are_not_enforced(tmp_path: Path) -> None:
+    src = tmp_path / "raw.csv"
+    shutil.copy(EXAMPLES / "sample.csv", src)
+    r = invoke("rescan", src, "--policy", POLICIES / "prd_external_ai.yml", "--no-strict")
+    assert r.exit_code == 0
+    assert "NOT ENFORCED" in r.stdout and "PASSED" not in r.stdout
+
+
 def test_rescan_exit_7_and_read_only(tmp_path: Path) -> None:
     src = tmp_path / "raw.csv"
     shutil.copy(EXAMPLES / "sample.csv", src)

{ciphergate_cli-0.10.0 → ciphergate_cli-0.11.0}/tests/unit/test_policy_validation.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 import pytest
 
+from ciphergate import load_policy
 from ciphergate.errors import PolicyValidationError
 from ciphergate.policy.validator import Policy, validate_policy
 from tests.conftest import MINIMAL_POLICY, POLICIES
@@ -138,6 +139,71 @@ def test_credential_generalize_rejected(policy_text: Callable[[str], Policy]) ->
     assert "credential_unsafe_action" in codes(e)
 
 
+CREDENTIAL_RULE = "rules:\n  - id: r\n    match: {categories: [credential.secret]}\n"
+
+
+@pytest.mark.parametrize(
+    ("action", "extra", "warns"),
+    [
+        ("redact", "", True),
+        ("block", "", False),
+        ("review", "", False),
+        (
+            "redact",
+            "    match: {categories: [credential.secret], destinations: [local_dev]}\n",
+            False,
+        ),
+        (
+            "redact",
+            "    match: {categories: [credential.secret], destinations: [external_ai]}\n",
+            True,
+        ),
+    ],
+)
+def test_credential_rule_short_of_block_warns(
+    policy_text: Callable[[str], Policy], action: str, extra: str, warns: bool
+) -> None:
+    head = "rules:\n  - id: r\n" + extra if extra else CREDENTIAL_RULE
+    p = policy_text(HEAD + head + f"    action: {action}\n")
+    assert any("instead of blocking" in w for w in p.warnings) is warns
+
+
+def test_credential_default_short_of_block_warns(policy_text: Callable[[str], Policy]) -> None:
+    p = policy_text(HEAD + "defaults:\n  credential.*: {action: redact}\n")
+    assert any("instead of blocking" in w for w in p.warnings)
+
+
+HARD_BLOCK = (
+    "  - id: b\n    priority: 1000\n    hard: true\n"
+    "    match:\n      categories: [credential.secret]\n{scope}"
+    "    action: block\n"
+)
+EVERY_UNTRUSTED = "      destinations: [external_vendor, external_ai, public_repository, unknown]\n"
+
+
+def test_hard_block_on_every_untrusted_destination_silences_the_warning(
+    policy_text: Callable[[str], Policy],
+) -> None:
+    rule = CREDENTIAL_RULE + "    action: redact\n"
+    covered = policy_text(HEAD + rule + HARD_BLOCK.format(scope=EVERY_UNTRUSTED))
+    assert not any("instead of blocking" in w for w in covered.warnings)
+
+
+def test_partial_hard_block_keeps_the_warning(policy_text: Callable[[str], Policy]) -> None:
+    rule = CREDENTIAL_RULE + "    action: redact\n"
+    scope = "      destinations: [external_ai]\n"
+    partial = policy_text(HEAD + rule + HARD_BLOCK.format(scope=scope))
+    assert any("instead of blocking" in w for w in partial.warnings)
+    fields = "      field_names: [password]\n"
+    narrow = policy_text(HEAD + rule + HARD_BLOCK.format(scope=fields))
+    assert any("instead of blocking" in w for w in narrow.warnings)
+
+
+@pytest.mark.parametrize("path", sorted(POLICIES.glob("*.yml")), ids=lambda p: p.stem)
+def test_shipped_policies_do_not_relax_credentials(path: Path) -> None:
+    assert not any("instead of blocking" in w for w in load_policy(path).warnings)
+
+
 def test_high_risk_allow_needs_acknowledgement(policy_text: Callable[[str], Policy]) -> None:
     rule = "rules:\n  - id: r\n    match: {categories: [pii.email]}\n    action: allow\n"
     e = rejects(policy_text, HEAD + rule)