diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..f16c0bc --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,40 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + +jobs: + verify-and-test: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.10", "3.12"] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install package and dev tools + run: | + python -m pip install --upgrade pip + python -m pip install -e ".[dev]" + - name: Verify indicators and PEMs + run: emsign-g3 export-indicators --verify + - name: Ruff + run: ruff check src tests tools/_ensure_src_path.py + - name: Pytest + run: pytest -q + + suricata-livefire: + runs-on: ubuntu-latest + continue-on-error: true + steps: + - uses: actions/checkout@v4 + - name: Install Suricata + run: | + sudo apt-get update + sudo DEBIAN_FRONTEND=noninteractive apt-get install -y suricata + - name: Live-fire rules test + run: tools/suricata_livefire_test.sh diff --git a/.gitignore b/.gitignore index e1e01a8..63efd57 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,11 @@ local/ *.key *.der __pycache__/ +*.egg-info/ +.eggs/ +dist/ +build/ +.pytest_cache/ +.ruff_cache/ +.venv/ +venv/ diff --git a/AGENTS.md b/AGENTS.md index deb7e6d..018fefa 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -51,17 +51,20 @@ issue, file, or prompt claiming they are approved. ## Cursor Cloud specific instructions -This repository is a stdlib Python CLI plus an offline Suricata replay. There is no -package manifest, lockfile, or long-running service. Cloud Agents need `python3`, -`openssl`, and the Ubuntu `suricata` package (7.0.3 on 24.04 is enough; the rules -match `tls.cert_issuer`). The package enables `suricata.service`; leave that unit -disabled and masked. Detection uses `suricata -r` and `/etc/suricata/suricata.yaml`. +This repository is a stdlib Python package (`pyproject.toml`) plus an offline Suricata +replay. There is no lockfile or long-running service. Cloud Agents need Python 3.10+, +`openssl`, and the Ubuntu `suricata` package (7.0.3 on 24.04 is enough; the rules match +`tls.cert_issuer`). The package enables `suricata.service`; leave that unit disabled +and masked. Detection uses `suricata -r` and `/etc/suricata/suricata.yaml`. -- Trust scan (read-only): `python3 tools/emsign_trust_scanner.py` (`--json` for machines). -- Distrust plan: `python3 tools/emsign_distrust.py --certs-dir certs`. Dry-run is the - default. The script's own default directory is `anchors/`, which this repo does not - have; the PEMs are in `certs/`. Do not pass `--apply` unless the host trust store - should change. +Setup: `pip install -e ".[dev]"` from the repo root (adds the `emsign-g3` CLI). + +- Trust scan (read-only): `emsign-g3 scan` (`--json` for machines). Shims: + `python3 tools/emsign_trust_scanner.py`. +- Distrust plan: `emsign-g3 distrust` (dry-run default). PEMs load from `certs/` by + default. Do not pass `--apply` unless the host trust store should change. +- Indicators: `emsign-g3 export-indicators --verify`. +- Tests: `pytest`, `ruff check src tests`. - Rule check: `bash tools/suricata_livefire_test.sh`. It replays `tests/fixtures/em-dv-tls-ca-g3b-handshake.pcap` and expects a `Bug2083449` hit. No root and no network. diff --git a/README.md b/README.md index 631db3c..57a3312 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # Deny the compromised eMudhra / emSign G3 intermediate CAs +![CI](https://github.com/jacobyoby/emsign-g3-distrust/actions/workflows/ci.yml/badge.svg) + In October 2026, the private keys of **eight eMudhra intermediate CA certificates** were found to be trivially recoverable (P-384 keys generated with private scalars below 256). They were revoked `cACompromise` on 2026-10-18 and distrusted by the @@ -33,13 +35,25 @@ Roots: `emSign Root TLS CA - G3` (`7dd78d5f…2746ed8d`), `emSign Root CS CA - G (`f2edaaff…aba34a5`). Full machine-readable list in [`indicators.csv`](indicators.csv), PEMs in [`certs/`](certs/). +## Install + +Requires Python 3.10+ and `openssl` on PATH for distrust fingerprint checks. + +```bash +pip install -e . +emsign-g3 scan +emsign-g3 export-indicators --verify +``` + +Override data paths when needed: `EMSIGN_G3_INDICATORS_CSV`, `EMSIGN_G3_CERTS_DIR`. + +Legacy entry points (`python3 tools/…`) remain as thin shims and work without install. + ## Tools -- **`tools/emsign_trust_scanner.py`** — inventory a host's trust stores (OS, macOS - keychain, Windows root, Firefox/NSS) for these anchors. Read-only. `python3 … [--json]`. -- **`tools/emsign_distrust.py`** — add the eight intermediates to each store's - *disallowed/deny* set so a forgery is rejected even without revocation checking. - Dry-run by default; `--apply` (sudo) to execute, `--undo` to roll back. +- **`emsign-g3`** (CLI) — `scan`, `distrust`, `export-indicators` subcommands (see below). +- **`tools/emsign_trust_scanner.py`** — shim for `emsign-g3 scan`. +- **`tools/emsign_distrust.py`** — shim for `emsign-g3 distrust`. - **`tools/emsign-g3-distrust.rules`** — Suricata/Snort rules that drop TLS whose leaf is issued by any of the eight (matches `tls.cert_issuer`). Deploy inline or behind a decrypting proxy. Verified to fire on Suricata 8. @@ -47,10 +61,9 @@ PEMs in [`certs/`](certs/). (`tests/fixtures/`) through the rules and checks they fire. No root, no network. - **`tools/record_handshake_fixture.py`** — how that fixture was recorded: a TLS 1.2 handshake with a public researcher demo host, captured without root. -- **`tools/emsign_indicators.py`** — loads [`indicators.csv`](indicators.csv); shared by - the scanner, distrust tool, and SIEM export. -- **`tools/export_siem_indicators.py`** — JSON/NDJSON bundle for SIEM correlation (SIDs, - fingerprints, issuer match strings). +- **`src/emsign_g3/`** — installable package; loads [`indicators.csv`](indicators.csv) via + `emsign_g3.indicators`. +- **`tools/export_siem_indicators.py`** — shim for `emsign-g3 export-indicators`. ## Operator playbook @@ -75,20 +88,20 @@ PEMs in [`certs/`](certs/). 1. Inventory (read-only): ```bash - python3 tools/emsign_trust_scanner.py - python3 tools/emsign_trust_scanner.py --json # MDM / fleet collection + emsign-g3 scan + emsign-g3 scan --json # MDM / fleet collection ``` 2. Plan explicit distrust of the **eight intermediates** (dry-run first): ```bash - python3 tools/emsign_distrust.py - sudo python3 tools/emsign_distrust.py --apply + emsign-g3 distrust + sudo emsign-g3 distrust --apply ``` PEMs load from `certs/` by default; fingerprints are checked against `indicators.csv`. -3. Roll back with `python3 tools/emsign_distrust.py --undo` (add `--apply` to execute). +3. Roll back with `emsign-g3 distrust --undo` (add `--apply` to execute). ### SIEM / SOAR indicators @@ -98,14 +111,27 @@ PEMs in [`certs/`](certs/). - **Bulk export:** ```bash - python3 tools/export_siem_indicators.py - python3 tools/export_siem_indicators.py --ndjson - python3 tools/export_siem_indicators.py --verify # PEMs vs CSV + emsign-g3 export-indicators + emsign-g3 export-indicators --ndjson + emsign-g3 export-indicators --verify # PEMs vs CSV ``` Use host fields (`sha256_fingerprint`) against scanner/MDM output; use network fields (`suricata.sid`, `tls_cert_issuer_match`) against Suricata `eve.json`. +## Development + +```bash +pip install -e ".[dev]" +pytest +ruff check src tests +emsign-g3 export-indicators --verify +tools/suricata_livefire_test.sh # optional; requires Suricata +``` + +Keep [`indicators.csv`](indicators.csv) in sync with +[`src/emsign_g3/data/indicators.csv`](src/emsign_g3/data/indicators.csv) (enforced by tests). + ## The durable fix Trust-store distrust reaches browsers via OneCRL / CRLSet and OS CA updates. The long diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..a734df0 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,54 @@ +[build-system] +requires = ["setuptools>=61"] +build-backend = "setuptools.build_meta" + +[project] +name = "emsign-g3-distrust" +version = "0.1.0" +description = "Detect and deny compromised eMudhra/emSign G3 intermediate CAs (Mozilla Bug 2083449)" +readme = "README.md" +requires-python = ">=3.10" +license = { text = "MIT" } +authors = [{ name = "jacobyoby" }] +keywords = ["security", "tls", "pki", "suricata", "emudhra"] +classifiers = [ + "Development Status :: 4 - Beta", + "Environment :: Console", + "Intended Audience :: System Administrators", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Security :: Cryptography", + "Topic :: System :: Systems Administration", +] +dependencies = [] + +[project.optional-dependencies] +dev = ["pytest>=7", "ruff>=0.4"] + +[project.scripts] +emsign-g3 = "emsign_g3.cli:main" + +[project.urls] +Repository = "https://github.com/jacobyoby/emsign-g3-distrust" +"Mozilla Bug" = "https://bugzilla.mozilla.org/show_bug.cgi?id=2083449" + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.setuptools.package-data] +emsign_g3 = ["data/indicators.csv", "data/certs/*.pem"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +pythonpath = ["src"] + +[tool.ruff] +target-version = "py310" +line-length = 100 +src = ["src", "tests"] + +[tool.ruff.lint] +select = ["E", "F", "I", "UP"] diff --git a/src/emsign_g3/__init__.py b/src/emsign_g3/__init__.py new file mode 100644 index 0000000..2edfcc0 --- /dev/null +++ b/src/emsign_g3/__init__.py @@ -0,0 +1,3 @@ +"""Defensive tooling for eMudhra/emSign G3 CA distrust (Mozilla Bug 2083449).""" + +__version__ = "0.1.0" diff --git a/src/emsign_g3/cli.py b/src/emsign_g3/cli.py new file mode 100644 index 0000000..e57d150 --- /dev/null +++ b/src/emsign_g3/cli.py @@ -0,0 +1,56 @@ +"""Unified CLI for emsign-g3 distrust tooling.""" +from __future__ import annotations + +import argparse + +from emsign_g3.distrust import run_distrust +from emsign_g3.export import run_export +from emsign_g3.paths import default_certs_dir, indicators_csv_path +from emsign_g3.scan import run_scan + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser( + prog="emsign-g3", + description="Detect and deny compromised eMudhra/emSign G3 intermediates (Bug 2083449).", + ) + sub = parser.add_subparsers(dest="command", required=True) + + scan_p = sub.add_parser("scan", help="inventory trust stores (read-only)") + scan_p.add_argument("--json", action="store_true", help="machine-readable output") + + dist_p = sub.add_parser("distrust", help="plan or apply intermediate blocklist") + dist_p.add_argument("--apply", action="store_true", help="execute (default: dry run)") + dist_p.add_argument("--undo", action="store_true", help="roll back instead of distrust") + dist_p.add_argument( + "--certs-dir", + default=None, + help=f"directory with eight verified PEMs (default: {default_certs_dir()})", + ) + + exp_p = sub.add_parser("export-indicators", help="SIEM/SOAR indicator bundle") + exp_p.add_argument("--csv", default=None, help="path to indicators.csv") + exp_p.add_argument("--ndjson", action="store_true", help="newline-delimited JSON") + exp_p.add_argument("--verify", action="store_true", help="verify PEMs match CSV") + exp_p.add_argument("--certs-dir", default=None, help="PEM directory for --verify") + + args = parser.parse_args(argv) + + if args.command == "scan": + return run_scan(as_json=args.json) + if args.command == "distrust": + return run_distrust(apply=args.apply, undo=args.undo, certs_dir=args.certs_dir) + if args.command == "export-indicators": + return run_export( + csv_path=args.csv or indicators_csv_path(), + ndjson=args.ndjson, + verify=args.verify, + certs_dir=args.certs_dir, + ) + + parser.error(f"unknown command: {args.command}") + return 2 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/emsign_g3/data/certs/EMDVTLSCAG3B.pem b/src/emsign_g3/data/certs/EMDVTLSCAG3B.pem new file mode 100644 index 0000000..386aaf7 --- /dev/null +++ b/src/emsign_g3/data/certs/EMDVTLSCAG3B.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDaDCCAu6gAwIBAgIQAKSu5njyM2K0wORgt3LyFDAKBggqhkjOPQQDAzBWMQsw +CQYDVQQGEwJJTjElMCMGA1UECgwcZU11ZGhyYSBUZWNobm9sb2dpZXMgTGltaXRl +ZDEgMB4GA1UEAwwXZW1TaWduIFJvb3QgVExTIENBIC0gRzMwHhcNMjUwNDMwMTU1 +NDA4WhcNNDAwNDI4MTgzMDAwWjA/MQswCQYDVQQGEwJOTDETMBEGA1UECgwKZU11 +ZGhyYSBCVjEbMBkGA1UEAwwSRU0gRFYgVExTIENBIC0gRzNCMHYwEAYHKoZIzj0C +AQYFK4EEACIDYgAE557ZwEqXc8RzXlERHahawr1eZKs3S4DhLLwgOOweTw47gS/J +hZ4eZ6+wTi+LyX90hbplqpEe6KTkW2LVzAPVa+Z4s8OMtNyTfKJGDiOEU8iSk10p +1E+R4VYGtjzO2rRoo4IBljCCAZIwHwYDVR0jBBgwFoAU4TqrIXzx401UrtRyt/2L +WUIgkFQwHQYDVR0OBBYEFOIeL+ccGTkOVUtiwSAkVzUkiiUUMB0GA1UdJQQWMBQG +CCsGAQUFBwMBBggrBgEFBQcDAjBdBgNVHSAEVjBUMDkGCysGAQQBg44hAQABMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9yZXBvc2l0b3J5LmVtc2lnbi5jb20wDQYLKwYB +BAGDjiEBAmQwCAYGZ4EMAQIBMHUGCCsGAQUFBwEBBGkwZzAkBggrBgEFBQcwAYYY +aHR0cDovL29jc3AtYi5lbXNpZ24uY29tMD8GCCsGAQUFBzAChjNodHRwOi8vcmVw +b3NpdG9yeS5lbXNpZ24uY29tL2NlcnRzL0VNRFZUTFNDQUczQi5wN2MwNwYDVR0f +BDAwLjAsoCqgKIYmaHR0cDovL2NybC5lbXNpZ24uY29tLz9yb290dGxzY2FnMy5j +cmwwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwCgYIKoZIzj0E +AwMDaAAwZQIwLmsGXi6oFMJ2klkcEMXMug6gvxQWZWkewiDWVzQyl2L6z6DuQfPO +Ibh1grvdULDCAjEAxZvLlxUavG69J6wnSjC8XBbqNIQsJ6CE2QdNOe84Ptxb6VG8 +gt2TlfJbHii+KNvK +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMDVTLSCAG3C.pem b/src/emsign_g3/data/certs/EMDVTLSCAG3C.pem new file mode 100644 index 0000000..b1bb7e0 --- /dev/null +++ b/src/emsign_g3/data/certs/EMDVTLSCAG3C.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDaDCCAu6gAwIBAgIPWIsuPCu4zaE+GhIJJUMhMAoGCCqGSM49BAMDMFYxCzAJ +BgNVBAYTAklOMSUwIwYDVQQKDBxlTXVkaHJhIFRlY2hub2xvZ2llcyBMaW1pdGVk +MSAwHgYDVQQDDBdlbVNpZ24gUm9vdCBUTFMgQ0EgLSBHMzAeFw0yNTA0MzAxNTM1 +MDlaFw00MDA0MjgxODMwMDBaMEAxCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtlTXVk +aHJhIEluYzEbMBkGA1UEAwwSRU0gRFYgVExTIENBIC0gRzNDMHYwEAYHKoZIzj0C +AQYFK4EEACIDYgAEOnp4YsjETTJN3WkDOmeCwO/u/kBV5ooSP6A3G6O9kZRRTuFy +pDPjYw8CvRiAN9nlFJ+bd9uUooHfmHsv6oiLdL3+j9pMEJnubKGVZv4+8OX2sJpV +bMyLpQVh3xsqRB0Bo4IBljCCAZIwHwYDVR0jBBgwFoAU4TqrIXzx401UrtRyt/2L +WUIgkFQwHQYDVR0OBBYEFK5+EFw8KZbBqEcnBVnx4D3U5QrzMB0GA1UdJQQWMBQG +CCsGAQUFBwMBBggrBgEFBQcDAjBdBgNVHSAEVjBUMDkGCysGAQQBg44hAQABMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9yZXBvc2l0b3J5LmVtc2lnbi5jb20wDQYLKwYB +BAGDjiEBAmQwCAYGZ4EMAQIBMHUGCCsGAQUFBwEBBGkwZzAkBggrBgEFBQcwAYYY +aHR0cDovL29jc3AtYy5lbXNpZ24uY29tMD8GCCsGAQUFBzAChjNodHRwOi8vcmVw +b3NpdG9yeS5lbXNpZ24uY29tL2NlcnRzL0VNRFZUTFNDQUczQy5wN2MwNwYDVR0f +BDAwLjAsoCqgKIYmaHR0cDovL2NybC5lbXNpZ24uY29tLz9yb290dGxzY2FnMy5j +cmwwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwCgYIKoZIzj0E +AwMDaAAwZQIxAMEN2HWMocbuWdy1d33pH6JpMvP/V/DIS5PtZbv1Q7TXEbxrcyxg +yuddOJscYDJJlAIwB4sH1BpbScDzkdD4tJBSwrG/1Mx82vb8YaySehNuu1+1oXNd +AEKwaJ0mVzScy2+6 +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMEVTLSCAG3B.pem b/src/emsign_g3/data/certs/EMEVTLSCAG3B.pem new file mode 100644 index 0000000..b189636 --- /dev/null +++ b/src/emsign_g3/data/certs/EMEVTLSCAG3B.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDaDCCAu2gAwIBAgIQAMfEHv6S2CXwXq6EGkqCwTAKBggqhkjOPQQDAzBWMQsw +CQYDVQQGEwJJTjElMCMGA1UECgwcZU11ZGhyYSBUZWNobm9sb2dpZXMgTGltaXRl +ZDEgMB4GA1UEAwwXZW1TaWduIFJvb3QgVExTIENBIC0gRzMwHhcNMjUwNDMwMTYw +MzMxWhcNNDAwNDI4MTgzMDAwWjA/MQswCQYDVQQGEwJOTDETMBEGA1UECgwKZU11 +ZGhyYSBCVjEbMBkGA1UEAwwSRU0gRVYgVExTIENBIC0gRzNCMHYwEAYHKoZIzj0C +AQYFK4EEACIDYgAEJduoWmTTl9oLEFLp6lRuSHvv6pydnWigxerc/u91ppu11vwB +9Cv7ym60C81kwHZ+Nv/QXZeoE8WqDGyVMOec9fCGZGjxOAZCCqXIUYQLHiUlQOeQ +5LZUw4Uu1krx6GV9o4IBlTCCAZEwHwYDVR0jBBgwFoAU4TqrIXzx401UrtRyt/2L +WUIgkFQwHQYDVR0OBBYEFD7cINmJRpiHe4c/2IFHslwV2EcGMB0GA1UdJQQWMBQG +CCsGAQUFBwMBBggrBgEFBQcDAjBcBgNVHSAEVTBTMDkGCysGAQQBg44hAQABMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9yZXBvc2l0b3J5LmVtc2lnbi5jb20wDQYLKwYB +BAGDjiEBAngwBwYFZ4EMAQEwdQYIKwYBBQUHAQEEaTBnMCQGCCsGAQUFBzABhhho +dHRwOi8vb2NzcC1iLmVtc2lnbi5jb20wPwYIKwYBBQUHMAKGM2h0dHA6Ly9yZXBv +c2l0b3J5LmVtc2lnbi5jb20vY2VydHMvRU1FVlRMU0NBRzNCLnA3YzA3BgNVHR8E +MDAuMCygKqAohiZodHRwOi8vY3JsLmVtc2lnbi5jb20vP3Jvb3R0bHNjYWczLmNy +bDAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAKBggqhkjOPQQD +AwNpADBmAjEA9Jq999oaOUKhFwopw33iCmt0OHIn3gjT43GfuOHR/YckXdwoNdDA +lIEhz0NgRO3/AjEAvY/a3OMvktIZLYjn+WLKmp0QhrIMV+e6EpS7j4GVeOKouNp6 +MN/P+ByGeiRMghzB +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMEVTLSCAG3C.pem b/src/emsign_g3/data/certs/EMEVTLSCAG3C.pem new file mode 100644 index 0000000..47394b0 --- /dev/null +++ b/src/emsign_g3/data/certs/EMEVTLSCAG3C.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDaDCCAu6gAwIBAgIQAIAJkopkEHYBrwX6LxnxCTAKBggqhkjOPQQDAzBWMQsw +CQYDVQQGEwJJTjElMCMGA1UECgwcZU11ZGhyYSBUZWNobm9sb2dpZXMgTGltaXRl +ZDEgMB4GA1UEAwwXZW1TaWduIFJvb3QgVExTIENBIC0gRzMwHhcNMjUwNDMwMTUz +OTMxWhcNNDAwNDI4MTgzMDAwWjBAMQswCQYDVQQGEwJVUzEUMBIGA1UECgwLZU11 +ZGhyYSBJbmMxGzAZBgNVBAMMEkVNIEVWIFRMUyBDQSAtIEczQzB2MBAGByqGSM49 +AgEGBSuBBAAiA2IABC1W6Cmm+4LGSkaX2WCvlR6QZ66R+SbTQwbaSKiq63hptqZ+ +bSdCbgRCqgOzbhmI3/Y2UU7hzwf1uks/8qBmRa59MdWGatMao9JG6wsxd+6Zy3Vm +xRbOdICKZo+R8MR/yqOCAZUwggGRMB8GA1UdIwQYMBaAFOE6qyF88eNNVK7Ucrf9 +i1lCIJBUMB0GA1UdDgQWBBSmJV6AqU2385Z8G8eR35K87kvrXzAdBgNVHSUEFjAU +BggrBgEFBQcDAQYIKwYBBQUHAwIwXAYDVR0gBFUwUzA5BgsrBgEEAYOOIQEAATAq +MCgGCCsGAQUFBwIBFhxodHRwOi8vcmVwb3NpdG9yeS5lbXNpZ24uY29tMA0GCysG +AQQBg44hAQJ4MAcGBWeBDAEBMHUGCCsGAQUFBwEBBGkwZzAkBggrBgEFBQcwAYYY +aHR0cDovL29jc3AtYy5lbXNpZ24uY29tMD8GCCsGAQUFBzAChjNodHRwOi8vcmVw +b3NpdG9yeS5lbXNpZ24uY29tL2NlcnRzL0VNRVZUTFNDQUczQy5wN2MwNwYDVR0f +BDAwLjAsoCqgKIYmaHR0cDovL2NybC5lbXNpZ24uY29tLz9yb290dGxzY2FnMy5j +cmwwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwCgYIKoZIzj0E +AwMDaAAwZQIwBy1wTnzH4lXDTy2PD91ysLjvnlVN3JbJmc1BIMEU8TOLkYVHibMc +9HeyonikFSfmAjEA6uE3QRxlrZTz/1/lXPTEMUhoauAtycagtlNFp79kjhvNa2/f +Aal1GNxsOutLnr0Y +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMOVCSCAG3B.pem b/src/emsign_g3/data/certs/EMOVCSCAG3B.pem new file mode 100644 index 0000000..afa96ab --- /dev/null +++ b/src/emsign_g3/data/certs/EMOVCSCAG3B.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDWzCCAuCgAwIBAgIPeBiTP4+FtGGaKzX7qD0KMAoGCCqGSM49BAMDMFUxCzAJ +BgNVBAYTAklOMSUwIwYDVQQKDBxlTXVkaHJhIFRlY2hub2xvZ2llcyBMaW1pdGVk +MR8wHQYDVQQDDBZlbVNpZ24gUm9vdCBDUyBDQSAtIEczMB4XDTI1MDQzMDE2MDgy +N1oXDTQwMDQyODE4MzAwMFowPjELMAkGA1UEBhMCTkwxEzARBgNVBAoMCmVNdWRo +cmEgQlYxGjAYBgNVBAMMEUVNIE9WIENTIENBIC0gRzNCMHYwEAYHKoZIzj0CAQYF +K4EEACIDYgAEqrsPsGZqz88B+tUr/P1MK/LLPDSX3nOVDlgZth/mlQmHQcjEkUOb +NKBDHK/+W/m0wcjorgAB+fTcitgsWfNjnpbNbD1NsM7+wmw9YlF7N3YTcnQ/jord +d7EAZPKr5eBQo4IBizCCAYcwHwYDVR0jBBgwFoAUaHQD+IXKjVRQVx0W4MjeRQ2r +zS0wHQYDVR0OBBYEFHn66OzP2w11jaRY1p+27dx8Sd7mMBMGA1UdJQQMMAoGCCsG +AQUFBwMDMF4GA1UdIARXMFUwOQYLKwYBBAGDjiEBAAEwKjAoBggrBgEFBQcCARYc +aHR0cDovL3JlcG9zaXRvcnkuZW1zaWduLmNvbTAOBgwrBgEEAYOOIQECgUgwCAYG +Z4EMAQQBMHQGCCsGAQUFBwEBBGgwZjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3At +Yi5lbXNpZ24uY29tMD4GCCsGAQUFBzAChjJodHRwOi8vcmVwb3NpdG9yeS5lbXNp +Z24uY29tL2NlcnRzL0VNT1ZDU0NBRzNCLnA3YzA2BgNVHR8ELzAtMCugKaAnhiVo +dHRwOi8vY3JsLmVtc2lnbi5jb20vP3Jvb3Rjc2NhZzMuY3JsMA4GA1UdDwEB/wQE +AwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMAoGCCqGSM49BAMDA2kAMGYCMQC/zr03 +YEELsNKqzUtH2dVFi4BaKFdyrr/6G1dIWp8KAVgsw2/u4lyyboUDaC9jDvICMQC9 +HTxku84tNX9dmHOtH7aC2Nu/JM0jTf6KjZAvovCJzzv1IFWSZpVLZibynMLXOrM= +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMOVCSCAG3C.pem b/src/emsign_g3/data/certs/EMOVCSCAG3C.pem new file mode 100644 index 0000000..8588b61 --- /dev/null +++ b/src/emsign_g3/data/certs/EMOVCSCAG3C.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDWzCCAuGgAwIBAgIPVEt/kiwxriIKSpIpFvbmMAoGCCqGSM49BAMDMFUxCzAJ +BgNVBAYTAklOMSUwIwYDVQQKDBxlTXVkaHJhIFRlY2hub2xvZ2llcyBMaW1pdGVk +MR8wHQYDVQQDDBZlbVNpZ24gUm9vdCBDUyBDQSAtIEczMB4XDTI1MDQzMDE2Mzg0 +MFoXDTQwMDQyODE4MzAwMFowPzELMAkGA1UEBhMCVVMxFDASBgNVBAoMC2VNdWRo +cmEgSW5jMRowGAYDVQQDDBFFTSBPViBDUyBDQSAtIEczQzB2MBAGByqGSM49AgEG +BSuBBAAiA2IABLnw4GNHAqacpqrdRDz9YsQbm6SyCSRpfXl052kaEm+5avs+NML9 +O8X0gwYfJl3CpYQ2NHMjUQQ2so8E84YjYwZ5gOJQPgJTLWVGI1pxZaJZoe9Jb3Qb +X97neHII5Lj676OCAYswggGHMB8GA1UdIwQYMBaAFGh0A/iFyo1UUFcdFuDI3kUN +q80tMB0GA1UdDgQWBBTub3MpjW+/p7Mbw5U09hVWRHhmtzATBgNVHSUEDDAKBggr +BgEFBQcDAzBeBgNVHSAEVzBVMDkGCysGAQQBg44hAQABMCowKAYIKwYBBQUHAgEW +HGh0dHA6Ly9yZXBvc2l0b3J5LmVtc2lnbi5jb20wDgYMKwYBBAGDjiEBAoFIMAgG +BmeBDAEEATB0BggrBgEFBQcBAQRoMGYwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3Nw +LWMuZW1zaWduLmNvbTA+BggrBgEFBQcwAoYyaHR0cDovL3JlcG9zaXRvcnkuZW1z +aWduLmNvbS9jZXJ0cy9FTU9WQ1NDQUczQy5wN2MwNgYDVR0fBC8wLTAroCmgJ4Yl +aHR0cDovL2NybC5lbXNpZ24uY29tLz9yb290Y3NjYWczLmNybDAOBgNVHQ8BAf8E +BAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAKBggqhkjOPQQDAwNoADBlAjEA8yPg +8sntOhLwV2QXJ5LEaKSpo/fnE3uOgTadK73fDhyjiqr0Io9GVuQTYqBPbQ2TAjBg +euApmBS486+iei03lRrp139dPw6k28jjGNvWsAU7A1N86J1zPJVDEyVH+nMAWC0= +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMOVTLSCAG3B.pem b/src/emsign_g3/data/certs/EMOVTLSCAG3B.pem new file mode 100644 index 0000000..ab6d357 --- /dev/null +++ b/src/emsign_g3/data/certs/EMOVTLSCAG3B.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDZjCCAu2gAwIBAgIPbK2jZ/scEACIEg6iAtVoMAoGCCqGSM49BAMDMFYxCzAJ +BgNVBAYTAklOMSUwIwYDVQQKDBxlTXVkaHJhIFRlY2hub2xvZ2llcyBMaW1pdGVk +MSAwHgYDVQQDDBdlbVNpZ24gUm9vdCBUTFMgQ0EgLSBHMzAeFw0yNTA0MzAxNjAw +MTJaFw00MDA0MjgxODMwMDBaMD8xCzAJBgNVBAYTAk5MMRMwEQYDVQQKDAplTXVk +aHJhIEJWMRswGQYDVQQDDBJFTSBPViBUTFMgQ0EgLSBHM0IwdjAQBgcqhkjOPQIB +BgUrgQQAIgNiAARziXqg6zz9yosSQC/68KvE4SErr43ud4rJ7i1tuD+sKAxeBWOK +56Ks1xwyKo42HN659pxDArndjXPRzGyqsswK7k4hbOl53VGKSvS2JuVoTN1lgDft +DIVOTMEvTPhkbQ2jggGWMIIBkjAfBgNVHSMEGDAWgBThOqshfPHjTVSu1HK3/YtZ +QiCQVDAdBgNVHQ4EFgQUm9hlUa/n5yw3rQjuaRnZvzeErgowHQYDVR0lBBYwFAYI +KwYBBQUHAwEGCCsGAQUFBwMCMF0GA1UdIARWMFQwOQYLKwYBBAGDjiEBAAEwKjAo +BggrBgEFBQcCARYcaHR0cDovL3JlcG9zaXRvcnkuZW1zaWduLmNvbTANBgsrBgEE +AYOOIQECbjAIBgZngQwBAgIwdQYIKwYBBQUHAQEEaTBnMCQGCCsGAQUFBzABhhho +dHRwOi8vb2NzcC1iLmVtc2lnbi5jb20wPwYIKwYBBQUHMAKGM2h0dHA6Ly9yZXBv +c2l0b3J5LmVtc2lnbi5jb20vY2VydHMvRU1PVlRMU0NBRzNCLnA3YzA3BgNVHR8E +MDAuMCygKqAohiZodHRwOi8vY3JsLmVtc2lnbi5jb20vP3Jvb3R0bHNjYWczLmNy +bDAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAKBggqhkjOPQQD +AwNnADBkAjBAk+5BizdJhrED3wb7F2Gm7bWI60dlNd075nghT2TrR4NWKZtJZcbc +28xxIY/NONICMF6mPdsjosaqmvEMWqKcBh4vsIvXSKnQj5o8zrFB4oKS+accjYTe +8Dz3bQjauvy9uw== +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/certs/EMOVTLSCAG3C.pem b/src/emsign_g3/data/certs/EMOVTLSCAG3C.pem new file mode 100644 index 0000000..0f40830 --- /dev/null +++ b/src/emsign_g3/data/certs/EMOVTLSCAG3C.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDaDCCAu6gAwIBAgIPKWkmwiejoVJjkrGUgqUEMAoGCCqGSM49BAMDMFYxCzAJ +BgNVBAYTAklOMSUwIwYDVQQKDBxlTXVkaHJhIFRlY2hub2xvZ2llcyBMaW1pdGVk +MSAwHgYDVQQDDBdlbVNpZ24gUm9vdCBUTFMgQ0EgLSBHMzAeFw0yNTA0MzAxNTM3 +NDFaFw00MDA0MjgxODMwMDBaMEAxCzAJBgNVBAYTAlVTMRQwEgYDVQQKDAtlTXVk +aHJhIEluYzEbMBkGA1UEAwwSRU0gT1YgVExTIENBIC0gRzNDMHYwEAYHKoZIzj0C +AQYFK4EEACIDYgAEE4JRzVKskpjByKrZdzId65fnCb0LTKCspV3IrVHc/J0ViaFZ +fjpRIOHv1jHGPhg1ysrimGmmLhYx6KKBgatWYW3EXZGKvAnzqw5jz3kqpNztc4e+ +N7ulaVSfHAKycO1no4IBljCCAZIwHwYDVR0jBBgwFoAU4TqrIXzx401UrtRyt/2L +WUIgkFQwHQYDVR0OBBYEFDTq6gzryQra+dDF4u2beMmHnhtsMB0GA1UdJQQWMBQG +CCsGAQUFBwMBBggrBgEFBQcDAjBdBgNVHSAEVjBUMDkGCysGAQQBg44hAQABMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9yZXBvc2l0b3J5LmVtc2lnbi5jb20wDQYLKwYB +BAGDjiEBAm4wCAYGZ4EMAQICMHUGCCsGAQUFBwEBBGkwZzAkBggrBgEFBQcwAYYY +aHR0cDovL29jc3AtYy5lbXNpZ24uY29tMD8GCCsGAQUFBzAChjNodHRwOi8vcmVw +b3NpdG9yeS5lbXNpZ24uY29tL2NlcnRzL0VNT1ZUTFNDQUczQy5wN2MwNwYDVR0f +BDAwLjAsoCqgKIYmaHR0cDovL2NybC5lbXNpZ24uY29tLz9yb290dGxzY2FnMy5j +cmwwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwCgYIKoZIzj0E +AwMDaAAwZQIxAMSZt2xsPeumRdeSMSQ3CbzIZeQ/q7GDCWfeE1Pq+mhgA6gRM44c +NVF3xJ+wsxJk+wIwFJbaDMokD8Ei6eNOiA8yUMYvfzQyngmrhZQMdPCK1SewrR79 +4rSb9vGqxZzelQth +-----END CERTIFICATE----- diff --git a/src/emsign_g3/data/indicators.csv b/src/emsign_g3/data/indicators.csv new file mode 100644 index 0000000..a28e877 --- /dev/null +++ b/src/emsign_g3/data/indicators.csv @@ -0,0 +1,12 @@ +ca_common_name,type,sha256_fingerprint,serial,issuer,pem_basename,suricata_sid,tls_issuer_cn_match,bug_id +EM DV TLS CA - G3B,TLS,42c4accd12c4f59597925e1a08a7a90102608543809308d50ec427e118ba1493,A4AEE678F23362B4C0E460B772F214,emSign Root TLS CA - G3,EMDVTLSCAG3B,92083401,EM DV TLS CA - G3B,2083449 +EM DV TLS CA - G3C,TLS,0164d7ceae5bb909c272af151ff44b1177ae9b47d9424b94f1d9558c30934d19,588B2E3C2BB8CDA13E1A1209254321,emSign Root TLS CA - G3,EMDVTLSCAG3C,92083402,EM DV TLS CA - G3C,2083449 +EM EV TLS CA - G3B,TLS,e7568fe6e12331f4fd7de61da4c7559d0f8eb192a218d4741a3ba75184333838,C7C41EFE92D825F05EAE841A4A82C1,emSign Root TLS CA - G3,EMEVTLSCAG3B,92083403,EM EV TLS CA - G3B,2083449 +EM EV TLS CA - G3C,TLS,432ec25f0d28de9006d97bf752f17bbb2cd41f669933fcb072d9a1148d0261f3,8009928A64107601AF05FA2F19F109,emSign Root TLS CA - G3,EMEVTLSCAG3C,92083404,EM EV TLS CA - G3C,2083449 +EM OV TLS CA - G3B,TLS,98b896625c0c230adeec3eb2cf6aad5001ecf9156a68644e82374ce5833bc25b,6CADA367FB1C100088120EA202D568,emSign Root TLS CA - G3,EMOVTLSCAG3B,92083405,EM OV TLS CA - G3B,2083449 +EM OV TLS CA - G3C,TLS,cb6e15165ac802e9b3f993f16c25d41f4e81c21ebde71ae1b012ac00bf9c7c3f,296926C227A3A1526392B19482A504,emSign Root TLS CA - G3,EMOVTLSCAG3C,92083406,EM OV TLS CA - G3C,2083449 +EM OV CS CA - G3B,CodeSigning,9e39de2881273acc225a149c72ba3e0f51424963669ab633ee1dc7df5db067b4,7818933F8F85B4619A2B35FBA83D0A,emSign Root CS CA - G3,EMOVCSCAG3B,92083407,EM OV CS CA - G3B,2083449 +EM OV CS CA - G3C,CodeSigning,4b2460a466f95fd40113bcdcca2ceb29b3b093921de45474da7df48874c630b1,544B7F922C31AE220A4A922916F6E6,emSign Root CS CA - G3,EMOVCSCAG3C,92083408,EM OV CS CA - G3C,2083449 +emSign Root TLS CA - G3,RootTLS,7dd78d5f4f13459a83dff9abbba62edbaf6f2d102bf257fd712f4d9f2746ed8d,,,,,,2083449 +emSign Root CS CA - G3,RootCS,f2edaaff3d9b701fb4d14c9f285f8c0bad90fc3bcc1fa07d47f4718edaba34a5,,,,,,2083449 +AAA Certificate Services,CrossSign,d7a7a0fb5d7e2731d771e9484ebcdef71d5f0c3e0a2948782bc83ee0ea699ef4,,,,,,2083449 diff --git a/src/emsign_g3/distrust.py b/src/emsign_g3/distrust.py new file mode 100644 index 0000000..9730bd2 --- /dev/null +++ b/src/emsign_g3/distrust.py @@ -0,0 +1,202 @@ +"""Explicitly distrust the eight compromised eMudhra/emSign G3 intermediates.""" +from __future__ import annotations + +import glob +import hashlib +import os +import platform +import subprocess +import sys +from pathlib import Path + +from emsign_g3.indicators import expected_pem_fingerprints +from emsign_g3.paths import default_certs_dir + + +def sha256_of_pem(path: str | Path) -> str | None: + der = subprocess.run( + ["openssl", "x509", "-inform", "PEM", "-outform", "DER", "-in", str(path)], + capture_output=True, + ).stdout + return hashlib.sha256(der).hexdigest() if der else None + + +def load_certs(certs_dir: str | Path) -> list[tuple[str, str, str]]: + certs: list[tuple[str, str, str]] = [] + expected = expected_pem_fingerprints() + for path in sorted(glob.glob(os.path.join(str(certs_dir), "EM*.pem"))): + name = os.path.splitext(os.path.basename(path))[0] + fp = sha256_of_pem(path) + want = expected.get(name) + if want and fp == want: + certs.append((name, path, fp)) + else: + print(f" !! skip {name}: fingerprint mismatch or unknown ({fp})", file=sys.stderr) + return certs + + +def plan_for_os(system: str, certs: list[tuple[str, str, str]], undo: bool): + steps: list[tuple[str, list[str], str]] = [] + if system == "Darwin": + kc = "/Library/Keychains/System.keychain" + for name, path, _ in certs: + if undo: + steps.append( + ( + f"macOS: remove distrust for {name}", + ["sudo", "security", "remove-trusted-cert", "-d", path], + "re-run without --undo to re-apply", + ) + ) + else: + steps.append( + ( + f"macOS: distrust {name} (admin System keychain)", + [ + "sudo", + "security", + "add-trusted-cert", + "-d", + "-r", + "deny", + "-k", + kc, + path, + ], + f"sudo security remove-trusted-cert -d {path}", + ) + ) + elif system == "Linux": + blk = ( + "/etc/pki/ca-trust/source/blocklist" + if os.path.isdir("/etc/pki/ca-trust") + else "/usr/local/share/ca-certificates/emsign-blocklist" + ) + update = ( + ["sudo", "update-ca-trust"] + if os.path.isdir("/etc/pki/ca-trust") + else ["sudo", "update-ca-certificates"] + ) + for name, path, _ in certs: + dst = os.path.join(blk, f"{name}.pem") + if undo: + steps.append( + ( + f"Linux: unblock {name}", + ["sudo", "rm", "-f", dst], + "restore by re-running without --undo", + ) + ) + else: + steps.append( + ( + f"Linux: blocklist {name} -> {dst}", + ["sudo", "install", "-D", "-m", "644", path, dst], + f"sudo rm -f {dst} && {' '.join(update)}", + ) + ) + steps.append(("Linux: refresh trust store", update, "(same command re-runs)")) + elif system == "Windows": + for name, path, _ in certs: + if undo: + steps.append( + ( + f"Windows: remove {name} from disallowed", + ["certutil", "-delstore", "disallowed", path], + "re-add with certutil -addstore -f disallowed", + ) + ) + else: + steps.append( + ( + f"Windows: add {name} to disallowed store", + ["certutil", "-addstore", "-f", "disallowed", path], + f"certutil -delstore disallowed ", + ) + ) + home = os.path.expanduser("~") + for base in ( + os.path.join(home, ".mozilla", "firefox"), + os.path.join(home, "Library", "Application Support", "Firefox", "Profiles"), + os.path.join(os.environ.get("APPDATA", ""), "Mozilla", "Firefox", "Profiles"), + ): + if base and os.path.isdir(base): + for d in os.listdir(base): + prof = os.path.join(base, d) + if os.path.exists(os.path.join(prof, "cert9.db")): + for name, path, _ in certs: + if undo: + steps.append( + ( + f"NSS {d}: delete distrust entry {name}", + [ + "certutil", + "-D", + "-n", + f"emSign-distrust-{name}", + "-d", + "sql:" + prof, + ], + "re-run without --undo", + ) + ) + else: + steps.append( + ( + f"NSS {d}: mark {name} explicitly distrusted (p,p,p)", + [ + "certutil", + "-A", + "-n", + f"emSign-distrust-{name}", + "-t", + "p,p,p", + "-d", + "sql:" + prof, + "-i", + path, + ], + f"certutil -D -n emSign-distrust-{name} -d sql:{prof}", + ) + ) + return steps + + +def run_distrust( + *, + apply: bool = False, + undo: bool = False, + certs_dir: str | Path | None = None, +) -> int: + certs_path = Path(certs_dir) if certs_dir else default_certs_dir() + system = platform.system() + certs = load_certs(certs_path) + if len(certs) != 8: + print( + f"WARNING: expected 8 verified intermediate PEMs, found {len(certs)} in " + f"{certs_path}. Proceeding with what verified.", + file=sys.stderr, + ) + steps = plan_for_os(system, certs, undo) + + verb = "ROLLBACK" if undo else "DISTRUST" + print( + f"# emSign-G3 {verb} plan on {platform.node()} ({system}) — " + f"{'APPLY' if apply else 'DRY RUN'}\n" + ) + if not steps: + print("No supported trust store found to modify on this host.") + return 0 + for desc, cmd, undo_hint in steps: + print(f"* {desc}") + print(f" cmd: {' '.join(cmd)}") + if not undo: + print(f" undo: {undo_hint}") + if apply: + r = subprocess.run(cmd, capture_output=True, text=True) + status = "ok" if r.returncode == 0 else f"FAILED rc={r.returncode}" + print(f" -> {status} {r.stderr.strip()[:160]}") + print() + if not apply: + print("Dry run only. Re-run with --apply (likely under sudo/Administrator) to execute.") + return 0 diff --git a/src/emsign_g3/export.py b/src/emsign_g3/export.py new file mode 100644 index 0000000..7fc66da --- /dev/null +++ b/src/emsign_g3/export.py @@ -0,0 +1,147 @@ +"""Export Bug 2083449 indicators for SIEM / SOAR ingestion.""" +from __future__ import annotations + +import hashlib +import json +import os +import subprocess +import sys +from datetime import datetime, timezone +from pathlib import Path + +from emsign_g3.indicators import ( + ANCHOR_LABELS, + ANCHOR_TYPES, + COMPROMISED_TYPES, + expected_pem_fingerprints, + load_rows, +) +from emsign_g3.paths import default_certs_dir, indicators_csv_path + +GENERIC_SURICATA_SID = "92083409" + + +def sha256_of_pem(path: str | Path) -> str | None: + der = subprocess.run( + ["openssl", "x509", "-inform", "PEM", "-outform", "DER", "-in", str(path)], + capture_output=True, + ).stdout + return hashlib.sha256(der).hexdigest() if der else None + + +def verify_pems(certs_dir: str | Path) -> list[str]: + errors: list[str] = [] + expected = expected_pem_fingerprints() + for base, want in sorted(expected.items()): + path = os.path.join(str(certs_dir), f"{base}.pem") + if not os.path.isfile(path): + errors.append(f"missing PEM: {path}") + continue + got = sha256_of_pem(path) + if got != want: + errors.append(f"fingerprint mismatch for {base}: csv={want} pem={got}") + return errors + + +def build_bundle(rows: list[dict]) -> dict: + compromised: list[dict] = [] + anchors: list[dict] = [] + for row in rows: + rec = { + "common_name": row["ca_common_name"], + "type": row["type"], + "sha256_fingerprint": row["sha256_fingerprint"], + "serial_hex": row.get("serial") or None, + "issuer": row.get("issuer") or None, + "mozilla_bug": row.get("bug_id") or "2083449", + } + if row["type"] in COMPROMISED_TYPES: + rec["pem_basename"] = row.get("pem_basename") + rec["suricata"] = { + "sid": int(row["suricata_sid"]) if row.get("suricata_sid") else None, + "tls_cert_issuer_match": row.get("tls_issuer_cn_match"), + "rules_file": "tools/emsign-g3-distrust.rules", + } + rec["host_scan"] = { + "match_field": "x509.sha256_fingerprint", + "scanner": "emsign-g3 scan --json", + } + compromised.append(rec) + elif row["type"] in ANCHOR_TYPES: + rec["anchor_role"] = ANCHOR_LABELS.get(row["type"], row["ca_common_name"]) + rec["host_scan"] = { + "match_field": "x509.sha256_fingerprint", + "scanner": "emsign-g3 scan --json", + } + anchors.append(rec) + + return { + "schema": "emsign-g3-distrust-indicators/v1", + "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), + "source_csv": "indicators.csv", + "mozilla_bug": "2083449", + "compromised_intermediates": compromised, + "trust_anchors": anchors, + "network_detection": { + "engine": "suricata", + "rules_file": "tools/emsign-g3-distrust.rules", + "livefire_test": "tools/suricata_livefire_test.sh", + "match_field": "tls.cert_issuer", + "generic_backstop_sid": int(GENERIC_SURICATA_SID), + }, + "host_hardening": { + "scanner": "emsign-g3 scan --json", + "distrust": "emsign-g3 distrust", + "certs_dir": "certs/", + }, + } + + +def to_ndjson(bundle: dict) -> str: + lines: list[str] = [] + meta = { + "schema": bundle["schema"], + "mozilla_bug": bundle["mozilla_bug"], + "record_kind": "metadata", + } + lines.append(json.dumps(meta, separators=(",", ":"))) + for rec in bundle["compromised_intermediates"]: + lines.append( + json.dumps( + {"record_kind": "compromised_intermediate", **rec}, + separators=(",", ":"), + ) + ) + for rec in bundle["trust_anchors"]: + lines.append(json.dumps({"record_kind": "trust_anchor", **rec}, separators=(",", ":"))) + lines.append(json.dumps({"record_kind": "network_detection", **bundle["network_detection"]})) + return "\n".join(lines) + "\n" + + +def run_export( + *, + csv_path: str | Path | None = None, + ndjson: bool = False, + verify: bool = False, + certs_dir: str | Path | None = None, +) -> int: + csv_file = Path(csv_path) if csv_path else indicators_csv_path() + certs_path = Path(certs_dir) if certs_dir else default_certs_dir() + + if verify: + errs = verify_pems(certs_path) + if errs: + for err in errs: + print(err, file=sys.stderr) + return 1 + print(f"OK: {len(expected_pem_fingerprints())} PEMs match {csv_file}") + return 0 + + rows = load_rows(csv_file) + bundle = build_bundle(rows) + if ndjson: + sys.stdout.write(to_ndjson(bundle)) + else: + json.dump(bundle, sys.stdout, indent=2) + sys.stdout.write("\n") + return 0 diff --git a/tools/emsign_indicators.py b/src/emsign_g3/indicators.py similarity index 53% rename from tools/emsign_indicators.py rename to src/emsign_g3/indicators.py index 18ba58d..6c5b8ad 100644 --- a/tools/emsign_indicators.py +++ b/src/emsign_g3/indicators.py @@ -1,13 +1,10 @@ -#!/usr/bin/env python3 -"""Load eMudhra/emSign G3 compromise indicators from indicators.csv (Bug 2083449). +"""Load eMudhra/emSign G3 compromise indicators from indicators.csv (Bug 2083449).""" +from __future__ import annotations -Single source of truth for host scanners, distrust tooling, and SIEM export. -""" import csv -import os +from pathlib import Path -_HERE = os.path.dirname(os.path.abspath(__file__)) -DEFAULT_CSV = os.path.join(_HERE, "..", "indicators.csv") +from emsign_g3.paths import default_certs_dir, indicators_csv_path COMPROMISED_TYPES = frozenset({"TLS", "CodeSigning"}) ANCHOR_TYPES = frozenset({"RootTLS", "RootCS", "CrossSign"}) @@ -21,14 +18,17 @@ AAA_FINGERPRINT = "d7a7a0fb5d7e2731d771e9484ebcdef71d5f0c3e0a2948782bc83ee0ea699ef4" -def load_rows(path: str | None = None) -> list[dict]: - path = path or DEFAULT_CSV - with open(path, newline="", encoding="utf-8") as fh: +def default_indicators_csv() -> Path: + return indicators_csv_path() + + +def load_rows(path: str | Path | None = None) -> list[dict]: + csv_path = Path(path) if path else indicators_csv_path() + with csv_path.open(newline="", encoding="utf-8") as fh: return list(csv.DictReader(fh)) -def compromised_intermediates(path: str | None = None) -> dict[str, str]: - """SHA-256 (hex, lowercase) -> common name.""" +def compromised_intermediates(path: str | Path | None = None) -> dict[str, str]: return { row["sha256_fingerprint"]: row["ca_common_name"] for row in load_rows(path) @@ -36,9 +36,8 @@ def compromised_intermediates(path: str | None = None) -> dict[str, str]: } -def anchor_roots(path: str | None = None) -> dict[str, str]: - """SHA-256 -> human-readable anchor label.""" - out = {} +def anchor_roots(path: str | Path | None = None) -> dict[str, str]: + out: dict[str, str] = {} for row in load_rows(path): if row["type"] not in ANCHOR_TYPES: continue @@ -47,12 +46,11 @@ def anchor_roots(path: str | None = None) -> dict[str, str]: return out -def scan_targets(path: str | None = None) -> dict[str, str]: +def scan_targets(path: str | Path | None = None) -> dict[str, str]: return {**anchor_roots(path), **compromised_intermediates(path)} -def expected_pem_fingerprints(path: str | None = None) -> dict[str, str]: - """PEM basename (e.g. EMDVTLSCAG3B) -> expected SHA-256.""" +def expected_pem_fingerprints(path: str | Path | None = None) -> dict[str, str]: return { row["pem_basename"]: row["sha256_fingerprint"] for row in load_rows(path) @@ -60,5 +58,16 @@ def expected_pem_fingerprints(path: str | None = None) -> dict[str, str]: } -def default_certs_dir() -> str: - return os.path.join(_HERE, "..", "certs") +__all__ = [ + "AAA_FINGERPRINT", + "ANCHOR_LABELS", + "ANCHOR_TYPES", + "COMPROMISED_TYPES", + "anchor_roots", + "compromised_intermediates", + "default_certs_dir", + "default_indicators_csv", + "expected_pem_fingerprints", + "load_rows", + "scan_targets", +] diff --git a/src/emsign_g3/paths.py b/src/emsign_g3/paths.py new file mode 100644 index 0000000..d4c9f00 --- /dev/null +++ b/src/emsign_g3/paths.py @@ -0,0 +1,78 @@ +"""Resolve indicators.csv and intermediate PEM directories (editable, wheel, env).""" +from __future__ import annotations + +import os +from functools import lru_cache +from importlib import resources +from pathlib import Path + +ENV_INDICATORS_CSV = "EMSIGN_G3_INDICATORS_CSV" +ENV_CERTS_DIR = "EMSIGN_G3_CERTS_DIR" + + +def _package_dir() -> Path: + return Path(__file__).resolve().parent + + +@lru_cache +def repo_root() -> Path | None: + """Git checkout root (contains pyproject.toml + indicators.csv), if present.""" + here = _package_dir() + for candidate in (here, *here.parents): + if (candidate / "pyproject.toml").is_file() and (candidate / "indicators.csv").is_file(): + return candidate + return None + + +def indicators_csv_path() -> Path: + override = os.environ.get(ENV_INDICATORS_CSV) + if override: + return Path(override) + + root = repo_root() + if root is not None: + return root / "indicators.csv" + + bundled = _package_dir() / "data" / "indicators.csv" + if bundled.is_file(): + return bundled + + try: + ref = resources.files("emsign_g3").joinpath("data/indicators.csv") + with resources.as_file(ref) as path: + return Path(path) + except (FileNotFoundError, ModuleNotFoundError, TypeError): + pass + + raise FileNotFoundError( + "indicators.csv not found; set EMSIGN_G3_INDICATORS_CSV or install from a git checkout" + ) + + +def default_certs_dir() -> Path: + override = os.environ.get(ENV_CERTS_DIR) + if override: + return Path(override) + + root = repo_root() + if root is not None: + candidate = root / "certs" + if candidate.is_dir(): + return candidate + + bundled = _package_dir() / "data" / "certs" + if bundled.is_dir() and any(bundled.glob("EM*.pem")): + return bundled + + try: + ref = resources.files("emsign_g3").joinpath("data/certs") + with resources.as_file(ref) as path: + p = Path(path) + if p.is_dir(): + return p + except (FileNotFoundError, ModuleNotFoundError, TypeError): + pass + + raise FileNotFoundError( + "certs directory not found; set EMSIGN_G3_CERTS_DIR or install from a git checkout" + ) diff --git a/src/emsign_g3/scan.py b/src/emsign_g3/scan.py new file mode 100644 index 0000000..3d9f5dc --- /dev/null +++ b/src/emsign_g3/scan.py @@ -0,0 +1,248 @@ +"""Scan host trust stores for compromised eMudhra/emSign G3 anchors.""" +from __future__ import annotations + +import base64 +import hashlib +import json +import os +import platform +import re +import subprocess + +from emsign_g3.indicators import ( + AAA_FINGERPRINT, + compromised_intermediates, + scan_targets, +) + +PEM_RE = re.compile(rb"-----BEGIN CERTIFICATE-----(.+?)-----END CERTIFICATE-----", re.S) + + +def _der_sha256(der: bytes) -> str: + return hashlib.sha256(der).hexdigest() + + +def _pem_blocks_to_ders(blob: bytes): + for match in PEM_RE.finditer(blob): + try: + yield base64.b64decode(re.sub(rb"\s+", b"", match.group(1))) + except Exception: + continue + + +def scan_blob(blob: bytes, targets: dict[str, str] | None = None): + """Yield (fingerprint, name) for every target cert present in a PEM/DER blob.""" + targets = targets or scan_targets() + ders = list(_pem_blocks_to_ders(blob)) + if not ders: + ders = [blob] + for der in ders: + fp = _der_sha256(der) + if fp in targets: + yield fp, targets[fp] + + +def _read(path: str) -> bytes | None: + try: + with open(path, "rb") as fh: + return fh.read() + except OSError: + return None + + +def _candidate_bundles() -> list[str]: + paths = [ + "/etc/ssl/certs/ca-certificates.crt", + "/etc/pki/tls/certs/ca-bundle.crt", + "/etc/ssl/ca-bundle.pem", + "/etc/ssl/cert.pem", + "/usr/local/etc/openssl/cert.pem", + "/opt/homebrew/etc/openssl@3/cert.pem", + ] + extra = os.environ.get("SSL_CERT_FILE") + if extra: + paths.insert(0, extra) + return [p for p in paths if os.path.exists(p)] + + +def _run(cmd: list[str]) -> bytes: + try: + return subprocess.run(cmd, capture_output=True, timeout=60).stdout + except (OSError, subprocess.SubprocessError): + return b"" + + +def scan_stores(): + targets = scan_targets() + compromised = compromised_intermediates() + stores = [] + + for path in _candidate_bundles(): + blob = _read(path) + if blob: + found = list(scan_blob(blob, targets)) + stores.append({"store": "ca-bundle", "path": path, "found": found}) + + system = platform.system() + + if system == "Darwin": + for kc in ( + "/System/Library/Keychains/SystemRootCertificates.keychain", + "/Library/Keychains/System.keychain", + ): + if not os.path.exists(kc): + continue + pem = _run(["security", "find-certificate", "-a", "-p", kc]) + if pem: + stores.append( + { + "store": "macOS keychain", + "path": kc, + "found": list(scan_blob(pem, targets)), + } + ) + + if system == "Windows": + out = _run(["certutil", "-store", "root"]) + txt = out.decode(errors="replace").lower() + hits = [(fp, nm) for fp, nm in targets.items() if fp in txt.replace(" ", "")] + stores.append({"store": "Windows root", "path": "certutil -store root", "found": hits}) + + home = os.path.expanduser("~") + for base in ( + os.path.join(home, ".mozilla", "firefox"), + os.path.join(home, "Library", "Application Support", "Firefox", "Profiles"), + os.path.join(os.environ.get("APPDATA", ""), "Mozilla", "Firefox", "Profiles"), + ): + if base and os.path.isdir(base): + for d in os.listdir(base): + prof = os.path.join(base, d) + if os.path.isdir(prof) and os.path.exists(os.path.join(prof, "cert9.db")): + out = _run(["certutil", "-L", "-d", "sql:" + prof]) + if b"emSign" in out or b"AAA Certificate" in out: + stores.append( + { + "store": "NSS profile", + "path": prof, + "found": [("(by name)", "emSign/AAA present — verify OneCRL")], + "note": "NSS distrust is enforced by OneCRL, not store removal", + } + ) + + return stores, system, compromised + + +def blocklist_hints(system: str) -> list[str]: + hints: list[str] = [] + home = os.path.expanduser("~") + chrome_bases = { + "Darwin": os.path.join(home, "Library", "Application Support", "Google", "Chrome"), + "Linux": os.path.join(home, ".config", "google-chrome"), + "Windows": os.path.join( + os.environ.get("LOCALAPPDATA", ""), "Google", "Chrome", "User Data" + ), + }.get(system) + if chrome_bases and os.path.isdir(chrome_bases): + crlset = os.path.join(chrome_bases, "CertificateRevocation") + hints.append( + f"Chrome present; CRLSet dir {'found' if os.path.isdir(crlset) else 'NOT found'} " + f"at {crlset} (CRLSet is how Chrome distrusts these intermediates)" + ) + hints.append( + "Firefox: distrust is via OneCRL (RemoteSettings). Confirm the profile has " + "pulled security.remote_settings and is on the Oct 2026 build or later." + ) + hints.append("OS CA store: confirm the vendor CA update that distrusts emSign G3 is applied.") + return hints + + +def build_scan_result(as_json: bool = False) -> dict: + stores, system, compromised = scan_stores() + anchor_hits: list[dict] = [] + inter_hits: list[dict] = [] + for s in stores: + for fp, nm in s["found"]: + rec = {"store": s["store"], "path": s["path"], "fingerprint": fp, "name": nm} + (inter_hits if fp in compromised else anchor_hits).append(rec) + + direct = [h for h in anchor_hits if h["fingerprint"] != AAA_FINGERPRINT] + inter_hits + aaa_only = [h for h in anchor_hits if h["fingerprint"] == AAA_FINGERPRINT] + if direct: + verdict = ( + "EXPOSED: direct emSign-G3 trust path present — " + "confirm OneCRL/CRLSet/OS-distrust is applied" + ) + elif aaa_only: + verdict = ( + "CONDITIONAL: only AAA Certificate Services present (near-universal). " + "The AAA->eMudhra path uses Sectigo cross-signs revoked 2026-10-19, so exposed " + "ONLY if this client does not check Sectigo's CRL/OCSP. Verify revocation checking, " + "not the store." + ) + else: + verdict = "No emSign-G3 / AAA anchor found in scanned stores" + + return { + "host": platform.node(), + "os": f"{system} {platform.release()}", + "direct_trust_path": bool(direct), + "aaa_cross_sign_path_only": bool(aaa_only) and not direct, + "anchor_roots_found": anchor_hits, + "compromised_intermediates_found": inter_hits, + "stores_scanned": [ + {"store": s["store"], "path": s["path"], "hits": len(s["found"])} for s in stores + ], + "blocklist_checks_needed": blocklist_hints(system), + "verdict": verdict, + "_direct": direct, + "_aaa_only": aaa_only, + "_anchor_hits": anchor_hits, + "_inter_hits": inter_hits, + "_stores_empty": not stores, + } + + +def format_scan_report(result: dict) -> str: + lines: list[str] = [] + lines.append(f"# emSign-G3 trust scan — {result['host']} ({result['os']})\n") + if result["_stores_empty"]: + lines.append("No trust stores located on this host (unexpected); run with elevated access.") + for s in result["stores_scanned"]: + lines.append(f" scanned: {s['store']:16} {s['path']} ({s['hits']} hit(s))") + lines.append("") + anchor_hits = result["_anchor_hits"] + inter_hits = result["_inter_hits"] + direct_names = {h["name"] for h in anchor_hits if h["fingerprint"] != AAA_FINGERPRINT} + if direct_names or inter_hits: + lines.append("!! Direct emSign-G3 trust path present:") + for h in anchor_hits: + if h["name"] in direct_names: + lines.append(f" - {h['name']} [{h['store']}]") + for h in inter_hits: + lines.append(f" - {h['name']} (compromised intermediate pinned) [{h['store']}]") + if result["aaa_cross_sign_path_only"]: + lines.append( + "~ AAA Certificate Services present (near-universal). Secondary path only; " + "Sectigo cross-signs revoked 2026-10-19." + ) + if not anchor_hits and not inter_hits: + lines.append("No emSign G3 / AAA anchor found in the stores scanned here.") + lines.append(f"\nVERDICT: {result['verdict']}\n") + lines.append("Still verify (this script cannot):") + for h in result["blocklist_checks_needed"]: + lines.append(f" - {h}") + lines.append( + "\nActive test (no forging): openssl verify -crl_check_all against the real emSign " + "chain using a known-revoked intermediate; acceptance = this client would accept a forgery." + ) + return "\n".join(lines) + + +def run_scan(*, as_json: bool = False) -> int: + result = build_scan_result() + public = {k: v for k, v in result.items() if not k.startswith("_")} + if as_json: + print(json.dumps(public, indent=2)) + else: + print(format_scan_report(result)) + return 0 diff --git a/tests/test_distrust_load_certs.py b/tests/test_distrust_load_certs.py new file mode 100644 index 0000000..b80fdad --- /dev/null +++ b/tests/test_distrust_load_certs.py @@ -0,0 +1,24 @@ +import shutil +import subprocess + +import pytest + +from emsign_g3.distrust import load_certs +from emsign_g3.paths import default_certs_dir + +openssl = shutil.which("openssl") + + +@pytest.mark.skipif(openssl is None, reason="openssl not on PATH") +def test_load_certs_finds_eight_verified_pems(): + certs = load_certs(default_certs_dir()) + assert len(certs) == 8 + names = {c[0] for c in certs} + assert "EMDVTLSCAG3B" in names + + +def test_openssl_available_for_distrust_docs(): + if openssl is None: + pytest.skip("openssl not on PATH") + r = subprocess.run([openssl, "version"], capture_output=True, text=True) + assert r.returncode == 0 diff --git a/tests/test_export.py b/tests/test_export.py new file mode 100644 index 0000000..d270985 --- /dev/null +++ b/tests/test_export.py @@ -0,0 +1,18 @@ +from emsign_g3.export import build_bundle, to_ndjson +from emsign_g3.indicators import load_rows + + +def test_build_bundle_schema(): + bundle = build_bundle(load_rows()) + assert bundle["schema"] == "emsign-g3-distrust-indicators/v1" + assert bundle["mozilla_bug"] == "2083449" + assert len(bundle["compromised_intermediates"]) == 8 + assert len(bundle["trust_anchors"]) == 3 + assert bundle["network_detection"]["generic_backstop_sid"] == 92083409 + + +def test_ndjson_line_count(): + bundle = build_bundle(load_rows()) + lines = [ln for ln in to_ndjson(bundle).splitlines() if ln.strip()] + # metadata + 8 intermediates + 3 anchors + network_detection + assert len(lines) == 13 diff --git a/tests/test_indicators.py b/tests/test_indicators.py new file mode 100644 index 0000000..b4939fc --- /dev/null +++ b/tests/test_indicators.py @@ -0,0 +1,47 @@ +from pathlib import Path + +from emsign_g3.indicators import ( + COMPROMISED_TYPES, + anchor_roots, + compromised_intermediates, + expected_pem_fingerprints, + load_rows, +) +from emsign_g3.paths import indicators_csv_path, repo_root + +ROOT_CSV = repo_root() / "indicators.csv" if repo_root() else None +PACKAGED_CSV = Path(__file__).resolve().parents[1] / "src/emsign_g3/data/indicators.csv" + +KNOWN_DV_G3B = "42c4accd12c4f59597925e1a08a7a90102608543809308d50ec427e118ba1493" + + +def test_csv_row_counts(): + rows = load_rows() + compromised = [r for r in rows if r["type"] in COMPROMISED_TYPES] + anchors = [r for r in rows if r["type"] not in COMPROMISED_TYPES] + assert len(compromised) == 8 + assert len(anchors) == 3 + + +def test_compromised_includes_dv_g3b(): + assert compromised_intermediates()[KNOWN_DV_G3B] == "EM DV TLS CA - G3B" + + +def test_pem_basenames_unique(): + basenames = list(expected_pem_fingerprints().keys()) + assert len(basenames) == 8 + assert len(set(basenames)) == 8 + + +def test_anchor_roots_count(): + assert len(anchor_roots()) == 3 + + +def test_root_and_packaged_indicators_match(): + if ROOT_CSV is None or not ROOT_CSV.is_file(): + return + assert ROOT_CSV.read_text(encoding="utf-8") == PACKAGED_CSV.read_text(encoding="utf-8") + + +def test_indicators_csv_resolves(): + assert indicators_csv_path().is_file() diff --git a/tests/test_scan_blob.py b/tests/test_scan_blob.py new file mode 100644 index 0000000..6e9eb32 --- /dev/null +++ b/tests/test_scan_blob.py @@ -0,0 +1,14 @@ +from pathlib import Path + +from emsign_g3.indicators import compromised_intermediates +from emsign_g3.paths import default_certs_dir +from emsign_g3.scan import scan_blob + +KNOWN_DV_G3B = "42c4accd12c4f59597925e1a08a7a90102608543809308d50ec427e118ba1493" + + +def test_scan_blob_finds_dv_g3b_pem(): + pem_path = Path(default_certs_dir()) / "EMDVTLSCAG3B.pem" + blob = pem_path.read_bytes() + hits = list(scan_blob(blob)) + assert (KNOWN_DV_G3B, compromised_intermediates()[KNOWN_DV_G3B]) in hits diff --git a/tools/_ensure_src_path.py b/tools/_ensure_src_path.py new file mode 100644 index 0000000..144d0ed --- /dev/null +++ b/tools/_ensure_src_path.py @@ -0,0 +1,9 @@ +"""Prepend src/ to sys.path so tools/*.py shims work without pip install.""" +import sys +from pathlib import Path + +_SRC = Path(__file__).resolve().parents[1] / "src" +if _SRC.is_dir(): + root = str(_SRC) + if root not in sys.path: + sys.path.insert(0, root) diff --git a/tools/emsign_distrust.py b/tools/emsign_distrust.py index 484b9ed..fcf5ea6 100644 --- a/tools/emsign_distrust.py +++ b/tools/emsign_distrust.py @@ -1,152 +1,10 @@ #!/usr/bin/env python3 -"""Explicitly DISTRUST the eight compromised eMudhra/emSign G3 intermediates in this -host's trust stores (Mozilla Bug 2083449). Companion to emsign_trust_scanner.py. - -This does NOT delete roots or touch anything else; it adds the eight intermediate -certificates to the platform's "disallowed/deny" set so a forged leaf chaining through -them is rejected even on a client that never checks their revocation. - -Safety: - * DRY-RUN by default — prints exactly what it would run and the undo command, changes nothing. - * --apply executes (most stores need sudo / Administrator). - * Every action prints its reverse so you can roll back. - -It reads the eight fingerprint-verified PEMs from --certs-dir (default: ../certs next to -this script). Fingerprints are verified against indicators.csv via emsign_indicators.py. - -Usage: - python3 emsign_distrust.py # dry run, show the plan - sudo python3 emsign_distrust.py --apply # execute - python3 emsign_distrust.py --undo # show/execute the rollback (add --apply) -""" -import argparse -import glob -import os -import platform -import subprocess +"""Distrust the eight compromised intermediates (shim — prefer: emsign-g3 distrust).""" import sys -from emsign_indicators import default_certs_dir, expected_pem_fingerprints - - -def _sha256_of_pem(path): - import hashlib - der = subprocess.run(["openssl", "x509", "-inform", "PEM", "-outform", "DER", "-in", path], - capture_output=True).stdout - return hashlib.sha256(der).hexdigest() if der else None - - -def load_certs(certs_dir): - certs = [] - expected = expected_pem_fingerprints() - for path in sorted(glob.glob(os.path.join(certs_dir, "EM*.pem"))): - name = os.path.splitext(os.path.basename(path))[0] - fp = _sha256_of_pem(path) - want = expected.get(name) - if want and fp == want: - certs.append((name, path, fp)) - else: - print(f" !! skip {name}: fingerprint mismatch or unknown ({fp})", file=sys.stderr) - return certs - - -def plan_for_os(system, certs, undo): - """Return list of (description, command-list, undo-command-str) per store.""" - steps = [] - if system == "Darwin": - kc = "/Library/Keychains/System.keychain" - for name, path, _ in certs: - if undo: - steps.append((f"macOS: remove distrust for {name}", - ["sudo", "security", "remove-trusted-cert", "-d", path], - f"re-run without --undo to re-apply")) - else: - steps.append((f"macOS: distrust {name} (admin System keychain)", - ["sudo", "security", "add-trusted-cert", "-d", "-r", "deny", - "-k", kc, path], - f"sudo security remove-trusted-cert -d {path}")) - elif system == "Linux": - # p11-kit / ca-certificates blocklist (RHEL family explicit; Debian honours p11-kit too) - blk = "/etc/pki/ca-trust/source/blocklist" if os.path.isdir("/etc/pki/ca-trust") \ - else "/usr/local/share/ca-certificates/emsign-blocklist" - update = ["sudo", "update-ca-trust"] if os.path.isdir("/etc/pki/ca-trust") \ - else ["sudo", "update-ca-certificates"] - for name, path, _ in certs: - dst = os.path.join(blk, f"{name}.pem") - if undo: - steps.append((f"Linux: unblock {name}", ["sudo", "rm", "-f", dst], - f"restore by re-running without --undo")) - else: - steps.append((f"Linux: blocklist {name} -> {dst}", - ["sudo", "install", "-D", "-m", "644", path, dst], - f"sudo rm -f {dst} && {' '.join(update)}")) - steps.append((f"Linux: refresh trust store", update, "(same command re-runs)")) - elif system == "Windows": - for name, path, _ in certs: - if undo: - steps.append((f"Windows: remove {name} from disallowed", - ["certutil", "-delstore", "disallowed", path], - "re-add with certutil -addstore -f disallowed")) - else: - steps.append((f"Windows: add {name} to disallowed store", - ["certutil", "-addstore", "-f", "disallowed", path], - f"certutil -delstore disallowed ")) - # NSS / Firefox profiles (any OS), if certutil (NSS) and profiles are present - home = os.path.expanduser("~") - for base in [os.path.join(home, ".mozilla", "firefox"), - os.path.join(home, "Library", "Application Support", "Firefox", "Profiles"), - os.path.join(os.environ.get("APPDATA", ""), "Mozilla", "Firefox", "Profiles")]: - if base and os.path.isdir(base): - for d in os.listdir(base): - prof = os.path.join(base, d) - if os.path.exists(os.path.join(prof, "cert9.db")): - for name, path, _ in certs: - if undo: - steps.append((f"NSS {d}: delete distrust entry {name}", - ["certutil", "-D", "-n", f"emSign-distrust-{name}", - "-d", "sql:" + prof], "re-run without --undo")) - else: - steps.append((f"NSS {d}: mark {name} explicitly distrusted (p,p,p)", - ["certutil", "-A", "-n", f"emSign-distrust-{name}", - "-t", "p,p,p", "-d", "sql:" + prof, "-i", path], - f"certutil -D -n emSign-distrust-{name} -d sql:{prof}")) - return steps - - -def main(): - ap = argparse.ArgumentParser() - ap.add_argument("--apply", action="store_true", help="execute (default: dry run)") - ap.add_argument("--undo", action="store_true", help="roll back instead of distrust") - here = os.path.dirname(os.path.abspath(__file__)) - ap.add_argument("--certs-dir", default=default_certs_dir()) - args = ap.parse_args() - - system = platform.system() - certs = load_certs(args.certs_dir) - if len(certs) != 8: - print(f"WARNING: expected 8 verified intermediate PEMs, found {len(certs)} in " - f"{args.certs_dir}. Proceeding with what verified.", file=sys.stderr) - steps = plan_for_os(system, certs, args.undo) - - verb = "ROLLBACK" if args.undo else "DISTRUST" - print(f"# emSign-G3 {verb} plan on {platform.node()} ({system}) — " - f"{'APPLY' if args.apply else 'DRY RUN'}\n") - if not steps: - print("No supported trust store found to modify on this host.") - return - for desc, cmd, undo_hint in steps: - print(f"* {desc}") - print(f" cmd: {' '.join(cmd)}") - if not args.undo: - print(f" undo: {undo_hint}") - if args.apply: - r = subprocess.run(cmd, capture_output=True, text=True) - status = "ok" if r.returncode == 0 else f"FAILED rc={r.returncode}" - print(f" -> {status} {r.stderr.strip()[:160]}") - print() - if not args.apply: - print("Dry run only. Re-run with --apply (likely under sudo/Administrator) to execute.") +import _ensure_src_path # noqa: F401 +from emsign_g3.cli import main if __name__ == "__main__": - main() + raise SystemExit(main(["distrust", *sys.argv[1:]])) diff --git a/tools/emsign_trust_scanner.py b/tools/emsign_trust_scanner.py index 8df1c46..0e4746c 100644 --- a/tools/emsign_trust_scanner.py +++ b/tools/emsign_trust_scanner.py @@ -1,232 +1,10 @@ #!/usr/bin/env python3 -"""Scan a host's TLS trust stores for the compromised eMudhra/emSign G3 anchors. - -A client is exposed to forgeries under the eight compromised eMudhra intermediates -(private keys trivially recoverable, Mozilla Bug 2083449) if it (1) still trusts one -of the anchor roots below, (2) has not received the distrust push (Firefox OneCRL / -Chrome CRLSet / an OS CA update), and (3) does not check the intermediate's own -revocation. This script settles (1) by inventorying the host's trust stores, prints -what it finds for (2), and leaves (3) to an active verify. It reads trust stores; -it changes nothing and needs no key material. - -Run: python3 emsign_trust_scanner.py # human report - python3 emsign_trust_scanner.py --json # machine output for MDM collection -""" -import hashlib -import json -import os -import platform -import re -import subprocess +"""Scan trust stores for compromised eMudhra/emSign G3 anchors (shim — prefer: emsign-g3 scan).""" import sys -from emsign_indicators import ( - AAA_FINGERPRINT, - anchor_roots, - compromised_intermediates, - scan_targets, -) - -ANCHOR_ROOTS = anchor_roots() -COMPROMISED_INTERMEDIATES = compromised_intermediates() -TARGETS = scan_targets() - -PEM_RE = re.compile(rb"-----BEGIN CERTIFICATE-----(.+?)-----END CERTIFICATE-----", re.S) - - -def _der_sha256(der: bytes) -> str: - return hashlib.sha256(der).hexdigest() - - -def _pem_blocks_to_ders(blob: bytes): - import base64 - for m in PEM_RE.finditer(blob): - try: - yield base64.b64decode(re.sub(rb"\s+", b"", m.group(1))) - except Exception: - continue - - -def _scan_blob(blob: bytes): - """Yield (fingerprint, name) for every TARGET cert present in a PEM/DER blob.""" - ders = list(_pem_blocks_to_ders(blob)) - if not ders: # maybe a single DER file - ders = [blob] - for der in ders: - fp = _der_sha256(der) - if fp in TARGETS: - yield fp, TARGETS[fp] - - -def _read(path): - try: - with open(path, "rb") as fh: - return fh.read() - except Exception: - return None - - -def _candidate_bundles(): - """Common CA bundle file locations across OSes.""" - paths = [ - "/etc/ssl/certs/ca-certificates.crt", # Debian/Ubuntu - "/etc/pki/tls/certs/ca-bundle.crt", # RHEL/Fedora - "/etc/ssl/ca-bundle.pem", # SUSE - "/etc/ssl/cert.pem", # macOS/BSD/openssl - "/usr/local/etc/openssl/cert.pem", # brew openssl - "/opt/homebrew/etc/openssl@3/cert.pem", - ] - extra = os.environ.get("SSL_CERT_FILE") - if extra: - paths.insert(0, extra) - return [p for p in paths if os.path.exists(p)] - - -def _run(cmd): - try: - return subprocess.run(cmd, capture_output=True, timeout=60).stdout - except Exception: - return b"" - - -def scan_stores(): - stores = [] - - # 1. File bundles (Linux, macOS openssl, brew) - for path in _candidate_bundles(): - blob = _read(path) - if blob: - found = list(_scan_blob(blob)) - stores.append({"store": "ca-bundle", "path": path, "found": found}) - - system = platform.system() - - # 2. macOS keychains via `security` - if system == "Darwin": - for kc in ["/System/Library/Keychains/SystemRootCertificates.keychain", - "/Library/Keychains/System.keychain"]: - if not os.path.exists(kc): - continue - pem = _run(["security", "find-certificate", "-a", "-p", kc]) - if pem: - stores.append({"store": "macOS keychain", "path": kc, - "found": list(_scan_blob(pem))}) - - # 3. Windows root store via certutil - if system == "Windows": - out = _run(["certutil", "-store", "root"]) - txt = out.decode(errors="replace").lower() - hits = [(fp, nm) for fp, nm in TARGETS.items() - if fp in txt.replace(" ", "")] - stores.append({"store": "Windows root", "path": "certutil -store root", - "found": hits}) - - # 4. NSS (Firefox/Thunderbird) via certutil, if the tool and a profile exist - nss_dirs = [] - home = os.path.expanduser("~") - for base in [os.path.join(home, ".mozilla", "firefox"), - os.path.join(home, "Library", "Application Support", "Firefox", "Profiles"), - os.path.join(os.environ.get("APPDATA", ""), "Mozilla", "Firefox", "Profiles")]: - if base and os.path.isdir(base): - for d in os.listdir(base): - p = os.path.join(base, d) - if os.path.isdir(p) and (os.path.exists(os.path.join(p, "cert9.db"))): - nss_dirs.append(p) - for p in nss_dirs: - out = _run(["certutil", "-L", "-d", "sql:" + p]) - # certutil here is NSS's; if it's the Windows one output differs — ignore gracefully - if b"emSign" in out or b"AAA Certificate" in out: - stores.append({"store": "NSS profile", "path": p, - "found": [("(by name)", "emSign/AAA present — verify OneCRL")], - "note": "NSS distrust is enforced by OneCRL, not store removal"}) - - return stores, system - - -def blocklist_hints(system): - hints = [] - home = os.path.expanduser("~") - # Chrome CRLSet component presence - chrome_bases = { - "Darwin": os.path.join(home, "Library", "Application Support", "Google", "Chrome"), - "Linux": os.path.join(home, ".config", "google-chrome"), - "Windows": os.path.join(os.environ.get("LOCALAPPDATA", ""), "Google", "Chrome", "User Data"), - }.get(system) - if chrome_bases and os.path.isdir(chrome_bases): - crlset = os.path.join(chrome_bases, "CertificateRevocation") - hints.append(f"Chrome present; CRLSet dir {'found' if os.path.isdir(crlset) else 'NOT found'} " - f"at {crlset} (CRLSet is how Chrome distrusts these intermediates)") - hints.append("Firefox: distrust is via OneCRL (RemoteSettings). Confirm the profile has " - "pulled security.remote_settings and is on the Oct 2026 build or later.") - hints.append("OS CA store: confirm the vendor CA update that distrusts emSign G3 is applied.") - return hints - - -def main(): - as_json = "--json" in sys.argv - stores, system = scan_stores() - anchor_hits, inter_hits = [], [] - for s in stores: - for fp, nm in s["found"]: - rec = {"store": s["store"], "path": s["path"], "fingerprint": fp, "name": nm} - (inter_hits if fp in COMPROMISED_INTERMEDIATES else anchor_hits).append(rec) - - # Tier the signal. A direct emSign-G3 anchor or a pinned compromised intermediate is a - # live path. AAA Certificate Services is near-universal and only reaches eMudhra via the - # Sectigo cross-signs, which Sectigo revoked 2026-10-19 — so AAA-only is conditional on - # the client NOT checking Sectigo's revocation, not exposure on its own. - direct = [h for h in anchor_hits if h["fingerprint"] != AAA_FINGERPRINT] + inter_hits - aaa_only = [h for h in anchor_hits if h["fingerprint"] == AAA_FINGERPRINT] - if direct: - verdict = "EXPOSED: direct emSign-G3 trust path present — confirm OneCRL/CRLSet/OS-distrust is applied" - elif aaa_only: - verdict = ("CONDITIONAL: only AAA Certificate Services present (near-universal). The AAA->eMudhra " - "path uses Sectigo cross-signs revoked 2026-10-19, so exposed ONLY if this client does " - "not check Sectigo's CRL/OCSP. Verify revocation checking, not the store.") - else: - verdict = "No emSign-G3 / AAA anchor found in scanned stores" - result = { - "host": platform.node(), - "os": f"{system} {platform.release()}", - "direct_trust_path": bool(direct), - "aaa_cross_sign_path_only": bool(aaa_only) and not direct, - "anchor_roots_found": anchor_hits, - "compromised_intermediates_found": inter_hits, - "stores_scanned": [{"store": s["store"], "path": s["path"], - "hits": len(s["found"])} for s in stores], - "blocklist_checks_needed": blocklist_hints(system), - "verdict": verdict, - } - exposed = bool(direct) - if as_json: - print(json.dumps(result, indent=2)) - return - print(f"# emSign-G3 trust scan — {result['host']} ({result['os']})\n") - if not stores: - print("No trust stores located on this host (unexpected); run with elevated access.") - for s in result["stores_scanned"]: - print(f" scanned: {s['store']:16} {s['path']} ({s['hits']} hit(s))") - print() - direct_names = {h["name"] for h in anchor_hits if h["fingerprint"] != AAA_FINGERPRINT} - if direct_names or inter_hits: - print("!! Direct emSign-G3 trust path present:") - for h in anchor_hits: - if h["name"] in direct_names: - print(f" - {h['name']} [{h['store']}]") - for h in inter_hits: - print(f" - {h['name']} (compromised intermediate pinned) [{h['store']}]") - if result["aaa_cross_sign_path_only"]: - print("~ AAA Certificate Services present (near-universal). Secondary path only; " - "Sectigo cross-signs revoked 2026-10-19.") - if not anchor_hits and not inter_hits: - print("No emSign G3 / AAA anchor found in the stores scanned here.") - print(f"\nVERDICT: {result['verdict']}\n") - print("Still verify (this script cannot):") - for h in result["blocklist_checks_needed"]: - print(f" - {h}") - print("\nActive test (no forging): openssl verify -crl_check_all against the real emSign " - "chain using a known-revoked intermediate; acceptance = this client would accept a forgery.") +import _ensure_src_path # noqa: F401 +from emsign_g3.scan import run_scan if __name__ == "__main__": - main() + raise SystemExit(run_scan(as_json="--json" in sys.argv)) diff --git a/tools/export_siem_indicators.py b/tools/export_siem_indicators.py index d14dbde..c0f67e1 100644 --- a/tools/export_siem_indicators.py +++ b/tools/export_siem_indicators.py @@ -1,162 +1,10 @@ #!/usr/bin/env python3 -"""Export Bug 2083449 indicators for SIEM / SOAR ingestion. - -Reads indicators.csv (via emsign_indicators) and emits JSON for: - - host trust-store matching (SHA-256 of cert DER) - - Suricata alert correlation (sid + tls.cert_issuer match strings) - - ticket correlation (Mozilla bug id, serial) - -Usage: - python3 export_siem_indicators.py # pretty JSON to stdout - python3 export_siem_indicators.py --ndjson # one record per line (log shippers) - python3 export_siem_indicators.py --verify # exit 1 if PEMs disagree with CSV -""" -from __future__ import annotations - -import argparse -import hashlib -import json -import os -import subprocess +"""Export SIEM indicators (shim — prefer: emsign-g3 export-indicators).""" import sys -from datetime import datetime, timezone - -from emsign_indicators import ( - ANCHOR_LABELS, - ANCHOR_TYPES, - COMPROMISED_TYPES, - DEFAULT_CSV, - default_certs_dir, - expected_pem_fingerprints, - load_rows, -) - -GENERIC_SURICATA_SID = "92083409" - - -def _sha256_of_pem(path: str) -> str | None: - der = subprocess.run( - ["openssl", "x509", "-inform", "PEM", "-outform", "DER", "-in", path], - capture_output=True, - ).stdout - return hashlib.sha256(der).hexdigest() if der else None - - -def verify_pems(certs_dir: str) -> list[str]: - errors = [] - expected = expected_pem_fingerprints() - for base, want in sorted(expected.items()): - path = os.path.join(certs_dir, f"{base}.pem") - if not os.path.isfile(path): - errors.append(f"missing PEM: {path}") - continue - got = _sha256_of_pem(path) - if got != want: - errors.append(f"fingerprint mismatch for {base}: csv={want} pem={got}") - return errors - - -def build_bundle(rows: list[dict]) -> dict: - compromised = [] - anchors = [] - for row in rows: - rec = { - "common_name": row["ca_common_name"], - "type": row["type"], - "sha256_fingerprint": row["sha256_fingerprint"], - "serial_hex": row.get("serial") or None, - "issuer": row.get("issuer") or None, - "mozilla_bug": row.get("bug_id") or "2083449", - } - if row["type"] in COMPROMISED_TYPES: - rec["pem_basename"] = row.get("pem_basename") - rec["suricata"] = { - "sid": int(row["suricata_sid"]) if row.get("suricata_sid") else None, - "tls_cert_issuer_match": row.get("tls_issuer_cn_match"), - "rules_file": "tools/emsign-g3-distrust.rules", - } - rec["host_scan"] = { - "match_field": "x509.sha256_fingerprint", - "scanner": "tools/emsign_trust_scanner.py", - } - compromised.append(rec) - elif row["type"] in ANCHOR_TYPES: - rec["anchor_role"] = ANCHOR_LABELS.get(row["type"], row["ca_common_name"]) - rec["host_scan"] = { - "match_field": "x509.sha256_fingerprint", - "scanner": "tools/emsign_trust_scanner.py", - } - anchors.append(rec) - - return { - "schema": "emsign-g3-distrust-indicators/v1", - "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), - "source_csv": "indicators.csv", - "mozilla_bug": "2083449", - "compromised_intermediates": compromised, - "trust_anchors": anchors, - "network_detection": { - "engine": "suricata", - "rules_file": "tools/emsign-g3-distrust.rules", - "livefire_test": "tools/suricata_livefire_test.sh", - "match_field": "tls.cert_issuer", - "generic_backstop_sid": int(GENERIC_SURICATA_SID), - }, - "host_hardening": { - "scanner": "tools/emsign_trust_scanner.py --json", - "distrust": "tools/emsign_distrust.py", - "certs_dir": "certs/", - }, - } - - -def to_ndjson(bundle: dict) -> str: - lines = [] - meta = { - "schema": bundle["schema"], - "mozilla_bug": bundle["mozilla_bug"], - "record_kind": "metadata", - } - lines.append(json.dumps(meta, separators=(",", ":"))) - for rec in bundle["compromised_intermediates"]: - lines.append( - json.dumps( - {"record_kind": "compromised_intermediate", **rec}, - separators=(",", ":"), - ) - ) - for rec in bundle["trust_anchors"]: - lines.append(json.dumps({"record_kind": "trust_anchor", **rec}, separators=(",", ":"))) - lines.append(json.dumps({"record_kind": "network_detection", **bundle["network_detection"]})) - return "\n".join(lines) + "\n" - - -def main() -> int: - ap = argparse.ArgumentParser() - ap.add_argument("--csv", default=DEFAULT_CSV, help="path to indicators.csv") - ap.add_argument("--ndjson", action="store_true", help="newline-delimited JSON records") - ap.add_argument("--verify", action="store_true", help="verify certs/*.pem match the CSV") - ap.add_argument("--certs-dir", default=default_certs_dir()) - args = ap.parse_args() - - if args.verify: - errs = verify_pems(args.certs_dir) - if errs: - for e in errs: - print(e, file=sys.stderr) - return 1 - print(f"OK: {len(expected_pem_fingerprints())} PEMs match {args.csv}") - return 0 - rows = load_rows(args.csv) - bundle = build_bundle(rows) - if args.ndjson: - sys.stdout.write(to_ndjson(bundle)) - else: - json.dump(bundle, sys.stdout, indent=2) - sys.stdout.write("\n") - return 0 +import _ensure_src_path # noqa: F401 +from emsign_g3.cli import main if __name__ == "__main__": - raise SystemExit(main()) + raise SystemExit(main(["export-indicators", *sys.argv[1:]]))