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

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

@@ -6,6 +6,38 @@ 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
+passed before can now redact, review or block, so re-check your policies before upgrading a gate.
+
+### Added
+
+- `ssn_pattern` detector for dashed US Social Security numbers (`pii.government_id`). They were
+  labelled `pii.phone`, so government-ID rules did not apply and a strict template can now block.
+
+### Fixed
+
+- `secret_pattern` no longer stops at `{` for nested values such as Actuator dumps, which left
+  the real value in the output.
+- `secret_pattern` now finds camelCase password names, `Cookie` and `Set-Cookie` headers, and
+  session and CSRF cookie values. `luhn_card` finds labelled CVV and CVC values.
+- Fewer false alarms: shell `PWD` paths, code such as `settings.X` or `request.Y` on the right of
+  an assignment, and an HTTP status followed by a byte count.
+
 ## [0.9.0] - 2026-10-30
 
 Detects more values. A run that passed before can now redact, review or block, so re-check your
@@ -296,7 +328,9 @@ 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.9.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
 [0.7.1]: https://github.com/aashishkumar-tech/ciphergate/compare/v0.7.0...v0.7.1

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ciphergate-cli
-Version: 0.9.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.9.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.9.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.9.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.9.0 → ciphergate_cli-0.11.0}/docs/detector-coverage.md

@@ -12,11 +12,12 @@ are engineering estimates mapped to bands (`low` < 0.5 <= `medium` < 0.8 <= `hig
 | `email_regex` | `pii.email` | `alice.test@example.com`, `alice.test%40example.com` | `a..b@example.com`, `user@localhost` | 0.9 | ASCII only; no IDN; obfuscated forms (`alice at example dot com`) missed; `%40` is the only percent-encoding recognised outside `accesslog` |
 | `phone_pattern` | `pii.phone` | `+1 202 555 0143` (high), `(202) 555-0143` (medium) | dates, IPs, card numbers, repeated digits, < 7 digits | 0.3 bare digits, 0.55–0.8 prefixed/formatted, +0.2 keyword | no numbering-plan validation; IDs can look like phones (low band) |
 | `ip_address` | `pii.ip_address` (global), `network.telemetry` (private/loopback/link-local) | `8.8.8.8`, `10.0.0.1`, `2606:4700::1111`, `fe80::1%eth0` | `256.1.1.1`, `std::vector`, `12:30:45` | 0.85 / 0.8 | version strings like `1.2.3.4` match; documentation ranges flagged with evidence |
-| `luhn_card` | `pii.payment_card` | `4111 1111 1111 1111` | Luhn-invalid, mixed separators, repeated digits | 0.4 Luhn-only, 0.8 issuer prefix, +0.15 keyword | random IDs pass Luhn ~10% (low band); cards split across fields missed |
+| `luhn_card` | `pii.payment_card` | `4111 1111 1111 1111` | Luhn-invalid, mixed separators, repeated digits | 0.4 Luhn-only, 0.8 issuer prefix, +0.15 keyword; labelled CVV/CVC values 0.85 | random IDs pass Luhn ~10% (low band); cards split across fields missed |
 | `mac_address` | `pii.device_identifier` | `00:1A:2B:3C:4D:5E`, `00-1a-2b-3c-4d-5e`, `001a.2b3c.4d5e` | all-zero, broadcast, mixed separators, `12:30:45` | 0.85, 0.6 when all digits | bare 12-hex values are missed; digit-only IDs in this shape are flagged |
 | `iban` | `pii.bank_account` | a mod-97-valid IBAN, compact or space-grouped | wrong check digits, lowercase | 0.9 | country length and national format are not checked; about 1 in 97 random strings of this shape pass; lowercase forms are missed |
+| `ssn_pattern` | `pii.government_id` | `219-09-9999` | never-issued areas (`000`, `666`, `9xx`), group `00`, serial `0000`, undashed | 0.8, 0.95 with a keyword | US only; undashed numbers are missed; other dashed IDs in this shape are flagged |
 | `date_pattern` | `pii.date_of_birth` with field/keyword evidence; `date.generic` if enabled | `dob: 1990-04-12`, field `birth_date` | `created 2026-01-05` (no DOB evidence), invalid dates | 0.85 / 0.6 | `DD/MM` vs `MM/DD` ambiguity flagged; free-text DOBs without keywords missed |
-| `secret_pattern` | `credential.secret` | PEM blocks, `Bearer ...`, `AKIA...`, `ghp_...`, `xox?-`, `sk_test_...`, `AIza...`, JWTs, `scheme://u:pw@`, `Password=...;`, `password=`, assignments to `PGPASSWORD` or `MYSQL_PWD`, `api_key:`, `token=` | `password=`, `password: null`, markers, `******` | 0.8–0.99 | base64/hex-wrapped, split, custom-format or high-entropy secrets without keywords are **missed**; prose like `password: required` is flagged |
+| `secret_pattern` | `credential.secret` | PEM blocks, `Bearer ...`, `AKIA...`, `ghp_...`, `xox?-`, `sk_test_...`, `AIza...`, JWTs, `scheme://u:pw@`, `Password=...;`, `password=`, assignments to `PGPASSWORD`, `MYSQL_PWD` or camelCase `...Password` names, `Cookie` and `Set-Cookie` headers, session and CSRF cookie values, `api_key:`, `token=` | `password=`, `password: null`, markers, `******` | 0.8–0.99 | base64/hex-wrapped, split, custom-format or high-entropy secrets without keywords are **missed**; prose like `password: required` is flagged |
 | `internal_host` | `network.telemetry` | `api-1.prod.internal`, `db.corp`, `localhost` | `example.com`, `a.internalx` | 0.75 | internal names without listed suffixes missed; configurable |
 | `custom:<id>` | configured | | | configured | regex-safety checks are heuristics |
 | `presidio_ner` (optional, off by default) | Presidio entities -> mapped categories (default `PERSON` -> `pii.person_name`, `LOCATION` -> `location.coarse`) | `ticket opened by <a person's name>` | numbers, single characters, CipherGate markers/pseudonyms | Presidio score, filtered by `min_score` | statistical model: misses and false positives, language/model dependent, slow; requires `ciphergate-cli[ner]` plus a locally installed spaCy model |

{ciphergate_cli-0.9.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.9.0 → ciphergate_cli-0.11.0}/docs/policy-schema.md

@@ -52,7 +52,7 @@ A pinned value combined with a different caller value fails with
 ## Detectors
 
 `disabled` (built-in IDs: `field_name`, `secret_pattern`, `luhn_card`, `ip_address`,
-`date_pattern`, `email_regex`, `internal_host`, `phone_pattern`, `mac_address`, `iban`),
+`date_pattern`, `email_regex`, `internal_host`, `phone_pattern`, `mac_address`, `iban`, `ssn_pattern`),
 `dates_emit_generic` (report
 non-DOB dates as `date.generic`), `internal_host_suffixes` (default `.internal .local .corp .lan
 .intranet .localdomain`), `custom` (list of `{id, category, pattern, confidence, ignore_case}`;
@@ -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.9.0 → ciphergate_cli-0.11.0}/pyproject.toml

@@ -110,6 +110,8 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["S101", "S105", "S106", "S108", "S311", "PLC0415", "S607"]
 "scripts/**" = ["S607", "T201"]
+# Reproducible synthetic data, and optional tools that may not be installed.
+"scripts/benchmark/**" = ["S311", "PLC0415", "S607", "T201"]
 
 [tool.mypy]
 python_version = "3.11"

ciphergate_cli-0.11.0/scripts/benchmark/README.md

@@ -0,0 +1,39 @@
+# Detection benchmark
+
+Measures what CipherGate catches and flags wrongly on generated, labelled log lines, next to other
+local tools. It is an engineering aid for finding gaps. It is not part of the package, CI or the
+test suite, and it never contacts a service.
+
+## Do not use the results as a public claim
+
+- The corpus is written by the people who wrote the detectors, so it leans toward CipherGate.
+- The data is synthetic. Real logs behave differently.
+- Other tools run on default settings, and their results depend on versions and models.
+- A high score here does not show that sensitive data is gone from any file.
+
+## Run it
+
+Use a separate virtual environment, because these tools are not project dependencies:
+
+```bash
+python -m venv /path/outside/repo/venv
+# Activate it, then:
+python -m pip install . detect-secrets scrubadub presidio-analyzer
+python -m pip install en_core_web_sm  # see the spaCy docs for the model install command
+python scripts/benchmark/compare_tools.py --out /path/outside/repo/results
+```
+
+Only CipherGate is required. Any other tool that is not installed is skipped and listed under
+`not run`. To include gitleaks, install it yourself and pass `--gitleaks PATH`.
+
+`--out` must be outside the repository, because `corpus.jsonl` holds format-shaped fake
+credentials that must not be committed. The tool refuses a path inside the repository. Results
+are repeatable for the same `--seed` and tool versions.
+
+## Reading the output
+
+Each row is a data class, and each cell is caught/total. A positive counts only if the finding
+overlaps the planted value; for CipherGate, the value must be gone from the output. `NEGATIVE`
+counts false alarms on clean lines. `presidio@0.5` is Presidio with a 0.5 score threshold.
+
+Random 16-digit IDs pass the card checksum about 10% of the time, so `NEGATIVE` varies by seed.

{ciphergate_cli-0.9.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.9.0"
+__version__ = "0.11.0"
 
 from ciphergate.config import RuntimeSettings
 from ciphergate.constants import (

{ciphergate_cli-0.9.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.9.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.9.0 → ciphergate_cli-0.11.0}/src/ciphergate/detectors/payment_card.py

@@ -12,6 +12,9 @@ from ciphergate.detectors.base import make_finding, preceding_context
 from ciphergate.models.finding import Finding, ScanItem
 
 _CARD_RE = re.compile(r"(?<![0-9A-Za-z_])(\d(?:[ -]?\d){12,18})(?![0-9A-Za-z_])")
+_CVV_RE = re.compile(
+    r"(?i)(?<![a-z0-9])(?:cvv2?|cvc2?)(?:\\?[\"'])?\s{0,3}[:=]\s{0,3}(?:\\?[\"'])?(\d{3,4})(?!\d)"
+)
 _KEYWORDS = ("card", "visa", "mastercard", "amex", "pan", "cc", "credit", "debit", "payment")
 
 
@@ -45,9 +48,21 @@ class PaymentCardDetector:
 
     def detect(self, item: ScanItem) -> list[Finding]:
         text = item.text
-        if not text or sum(c.isdigit() for c in text) < 13:
+        if not text:
             return []
-        out: list[Finding] = []
+        out = [
+            make_finding(
+                item,
+                category="pii.payment_card",
+                detector=self.id,
+                confidence=0.85,
+                evidence=("pattern_match", "context_keyword"),
+                span=(m.start(1), m.end(1)),
+            )
+            for m in _CVV_RE.finditer(text)
+        ]
+        if sum(c.isdigit() for c in text) < 13:
+            return out
         for m in _CARD_RE.finditer(text):
             raw = m.group(1)
             digits = raw.replace(" ", "").replace("-", "")

{ciphergate_cli-0.9.0 → ciphergate_cli-0.11.0}/src/ciphergate/detectors/phone.py

@@ -21,6 +21,7 @@ _PHONE_RE = re.compile(
 )
 _DATE_LIKE = re.compile(r"^\d{4}[-./]\d{1,2}[-./]\d{1,2}$|^\d{1,2}[-./]\d{1,2}[-./]\d{2,4}$")
 _SEPARATED = re.compile(r"^\(?\d{2,4}\)?[ .-]\d{2,5}[ .-]\d{2,5}(?:[ .-]\d{2,5})?$")
+_HTTP_STATUS_BYTES = re.compile(r"^[1-5]\d{2} \d{1,12}$")
 _KEYWORDS = ("phone", "tel", "mobile", "cell", "call", "fax", "sms", "whatsapp", "contact")
 
 
@@ -40,6 +41,9 @@ class PhoneDetector:
                 continue
             if _DATE_LIKE.match(core.strip()):
                 continue
+            context = preceding_context(text, m.start(), _KEYWORDS)
+            if _HTTP_STATUS_BYTES.match(core.strip()) and not context:
+                continue
             evidence = ["pattern_match"]
             if core.startswith("+"):
                 confidence = 0.8 if len(digits) >= 8 else 0.55
@@ -49,7 +53,7 @@ class PhoneDetector:
                 evidence.append("separator_layout")
             else:
                 confidence = 0.3
-            if preceding_context(text, m.start(), _KEYWORDS):
+            if context:
                 confidence += 0.2
                 evidence.append("context_keyword")
             if "x" in candidate.lower() or "ext" in candidate.lower():

{ciphergate_cli-0.9.0 → ciphergate_cli-0.11.0}/src/ciphergate/detectors/registry.py

@@ -16,6 +16,7 @@ from ciphergate.detectors.network import InternalHostDetector
 from ciphergate.detectors.payment_card import PaymentCardDetector
 from ciphergate.detectors.phone import PhoneDetector
 from ciphergate.detectors.secrets import PEM_BEGIN_RE, PEM_END_RE, SecretDetector
+from ciphergate.detectors.ssn import SsnDetector
 from ciphergate.models.finding import Finding, ScanItem
 from ciphergate.models.policy import DetectorSettings, PolicyDocument
 
@@ -30,11 +31,20 @@ BUILTIN_DETECTOR_IDS: tuple[str, ...] = (
     "phone_pattern",
     "mac_address",
     "iban",
+    "ssn_pattern",
 )
 
 # Phone matching is the least specific pattern; drop phone spans that overlap these detectors.
 _PHONE_SUPPRESSORS = frozenset(
-    {"luhn_card", "ip_address", "date_pattern", "secret_pattern", "mac_address", "iban"}
+    {
+        "luhn_card",
+        "ip_address",
+        "date_pattern",
+        "secret_pattern",
+        "mac_address",
+        "iban",
+        "ssn_pattern",
+    }
 )
 
 
@@ -67,6 +77,7 @@ class DetectorSet:
             "phone_pattern": PhoneDetector(),
             "mac_address": MacAddressDetector(),
             "iban": IbanDetector(),
+            "ssn_pattern": SsnDetector(),
         }
         for detector_id in BUILTIN_DETECTOR_IDS:
             if detector_id not in disabled:
@@ -185,6 +196,8 @@ def unsafe_replacement_reason(value: str) -> str | None:
         return "looks like a real IBAN"
     if MacAddressDetector().detect(probe):
         return "looks like a real MAC address"
+    if SsnDetector().detect(probe):
+        return "looks like a real government identifier"
     for f in EmailDetector().detect(probe):
         if "reserved_domain" not in f.evidence:
             return "email replacements must use a reserved domain such as example.invalid"

{ciphergate_cli-0.9.0 → ciphergate_cli-0.11.0}/src/ciphergate/detectors/secrets.py

@@ -69,17 +69,68 @@ _PATTERNS: tuple[_Pattern, ...] = (
             r"api[_-]?key|apikey|access[_-]?token|"
             r"refresh[_-]?token|auth[_-]?token|client[_-]?secret|secret[_-]?key|private[_-]?key|"
             r"access[_-]?key|token|credentials?)"
+            r"(?:\\?[\"'])?\s{0,3}[:=]\s{0,3}"
+            # Spring Actuator and similar dumps nest the value in an object.
+            r"(?:\{\s{0,3}\\?[\"']value\\?[\"']\s{0,3}:\s{0,3})?(?:\\?[\"'])?"
+            r"([^\s\"'\\,;&}]{1,512})"
+        ),
+        1,
+        0.8,
+    ),
+    _Pattern(
+        "camel_case_password",
+        re.compile(
+            r"(?<![A-Za-z0-9])[a-z][A-Za-z0-9]{0,40}Password"
             r"(?:\\?[\"'])?\s{0,3}[:=]\s{0,3}(?:\\?[\"'])?"
             r"([^\s\"'\\,;&}]{1,512})"
         ),
         1,
         0.8,
     ),
+    _Pattern(
+        "cookie_header",
+        re.compile(
+            r"(?i)(?<![a-z0-9_-])(?:set-)?cookie(?:\\?[\"'])?\s{0,3}:\s{0,3}(?:\\?[\"'])?"
+            r"([^\s=;\"']{1,128}=[^\r\n\"']{1,2048})"
+        ),
+        1,
+        0.85,
+    ),
+    _Pattern(
+        "session_cookie",
+        re.compile(
+            r"(?i)(?<![a-z0-9_-])(?:(?:sessionid|jsessionid|phpsessid|connect\.sid|csrftoken|"
+            r"csrfmiddlewaretoken|xsrf-token)(?:\\?[\"'])?\s{0,3}[:=]\s{0,3}|session=)"
+            r"(?:\\?[\"'])?([^\s\"'\\,;&}]{8,512})"
+        ),
+        1,
+        0.8,
+    ),
 )
 
 _PLACEHOLDER_VALUES = frozenset(
-    {"", "null", "none", "nil", "undefined", "true", "false", "redacted", "***", "******", "xxx"}
+    {
+        "",
+        "null",
+        "none",
+        "nil",
+        "undefined",
+        "true",
+        "false",
+        "redacted",
+        "***",
+        "******",
+        "xxx",
+        "{",
+        "[",
+    }
 )
+# Code that reads a secret, not the secret. Only well-known names, because a dotted value can
+# itself be a password.
+_CODE_REFERENCE_RE = re.compile(
+    r"(?:settings|config|request|self|this|args|params|env|os\.environ|process\.env)[.\[]"
+)
+_PATH_VALUE_RE = re.compile(r"(?:/|~/|[A-Za-z]:\\)")
 
 
 def _is_placeholder(value: str) -> bool:
@@ -110,7 +161,7 @@ class SecretDetector:
             for m in pattern.regex.finditer(text):
                 start, end = m.start(pattern.group), m.end(pattern.group)
                 value = m.group(pattern.group)
-                if _is_placeholder(value):
+                if _is_placeholder(value) or self._is_reference(pattern.name, m, value):
                     continue
                 if any(s <= start and end <= e for s, e in covered):
                     continue
@@ -118,6 +169,15 @@ class SecretDetector:
                 out.append(self._finding(item, (start, end), pattern.name, pattern.confidence))
         return out
 
+    @staticmethod
+    def _is_reference(family: str, match: re.Match[str], value: str) -> bool:
+        if family not in ("assignment", "connection_string_password"):
+            return False
+        if _CODE_REFERENCE_RE.match(value):
+            return True
+        # PWD is also the shell's working directory.
+        return match.group(0)[:3].lower() == "pwd" and bool(_PATH_VALUE_RE.match(value))
+
     def _finding(
         self, item: ScanItem, span: tuple[int, int], family: str, confidence: float
     ) -> Finding:

ciphergate_cli-0.11.0/src/ciphergate/detectors/ssn.py

@@ -0,0 +1,45 @@
+"""US Social Security number detector: dashed form, with the never-issued ranges excluded.
+
+Bare nine-digit runs are not matched because they are indistinguishable from other identifiers.
+Other countries' identifiers are not covered.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ciphergate.detectors.base import make_finding, preceding_context
+from ciphergate.models.finding import Finding, ScanItem
+
+_SSN_RE = re.compile(r"(?<![\d-])(\d{3})-(\d{2})-(\d{4})(?![\d-])")
+_KEYWORDS = ("ssn", "social", "tax", "tin")
+
+
+class SsnDetector:
+    id = "ssn_pattern"
+
+    def detect(self, item: ScanItem) -> list[Finding]:
+        text = item.text
+        if not text or len(text) < 11:
+            return []
+        out: list[Finding] = []
+        for m in _SSN_RE.finditer(text):
+            area, group, serial = m.groups()
+            if area in ("000", "666") or area[0] == "9" or group == "00" or serial == "0000":
+                continue
+            evidence = ["pattern_match"]
+            confidence = 0.8
+            if preceding_context(text, m.start(), _KEYWORDS):
+                confidence = 0.95
+                evidence.append("context_keyword")
+            out.append(
+                make_finding(
+                    item,
+                    category="pii.government_id",
+                    detector=self.id,
+                    confidence=confidence,
+                    evidence=tuple(evidence),
+                    span=(m.start(), m.end()),
+                )
+            )
+        return out

{ciphergate_cli-0.9.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.9.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.9.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)