envleak-cli 0.1.0__tar.gz

envleak_cli-0.1.0/.github/workflows/scan.yml

@@ -0,0 +1,10 @@
+name: envleak
+on: [push, pull_request]
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.12" }
+      - run: pipx run envleak --fail-on critical

envleak_cli-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+dist/
+build/
+*.egg-info/
+.venv/
+venv/
+.env

envleak_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Diego
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

envleak_cli-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.5
+Name: envleak-cli
+Version: 0.1.0
+Summary: Find exposed API keys and secrets before someone else does. 100% local.
+Project-URL: Homepage, https://github.com/novasdiego1/envleak
+Project-URL: Issues, https://github.com/novasdiego1/envleak/issues
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,api-keys,devsecops,llm,secrets,security
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# envleak
+
+**Find your exposed API keys before someone else does.**
+
+One command. No config. Nothing ever leaves your machine.
+
+```bash
+pipx run envleak
+```
+
+```
+  ┌────────────────────────────────────────────┐
+  │            E N V L E A K   S C A N         │
+  └────────────────────────────────────────────┘
+
+   F   █░░░░   Crítico
+
+   5 hallazgo(s) en 128 archivos
+   5 critical
+
+   ⚡ 2 en la superficie de agentes/LLM
+
+   ✗ ARCHIVOS DE ENTORNO RASTREADOS POR GIT:
+     .env
+
+   CRIT  Anthropic API key
+         .env:2
+         ANTHROPIC_API_KEY=sk-a********o9Pq
+
+   CRIT  GitHub token
+         .config/mcp.json:1
+         {"mcpServers":{"gh":{"env":{"GITHUB_TOKEN":"ghp_********3zA5"}}}}
+```
+
+---
+
+## Why another secret scanner?
+
+There are good ones already — `gitleaks` and `trufflehog` scan git history
+and belong in your CI pipeline. `envleak` is for a different moment: **right
+now, on your laptop, in ten seconds, with a grade you can screenshot.**
+
+Two things it does that the others don't:
+
+**1. It scans the agent surface.** Everyone is shipping AI agents in 2026,
+and the credentials moved with them — MCP server configs, `claude_desktop_config.json`,
+n8n and LangGraph workflows, notebooks, LLM provider keys pasted into JSON.
+`envleak` knows what an OpenAI, Anthropic, Groq, LangSmith or Hugging Face key
+looks like and where agent tooling hides them.
+
+**2. It gives you a grade, not a JSON dump.** A 400-line report gets closed.
+An `F` gets fixed.
+
+## Install
+
+```bash
+pipx run envleak          # no install, just run it
+pip install envleak       # or keep it around
+```
+
+Python 3.8+. Zero dependencies.
+
+## Use
+
+```bash
+envleak                   # scan current directory
+envleak ~/code/myproject  # scan somewhere else
+envleak --markdown        # scorecard ready to paste in an issue or PR
+envleak --json            # machine-readable, for pipelines
+```
+
+### In CI
+
+Exits `1` when it finds anything `high` or worse:
+
+```yaml
+- run: pipx run envleak --fail-on critical
+```
+
+```bash
+envleak --fail-on none    # report only, never fail
+```
+
+## What it looks for
+
+| Surface | Examples |
+|---|---|
+| **AI / agents** | OpenAI, Anthropic, Google AI, Groq, Mistral, Hugging Face, Replicate, LangSmith, Perplexity, MCP configs |
+| **Cloud / infra** | AWS access keys, GCP service accounts, private key blocks, Docker registry auth |
+| **Classic** | GitHub, GitLab, Stripe, Slack, Telegram, SendGrid, Twilio, JWTs, database URLs with passwords |
+| **Generic** | High-entropy values assigned to `*_KEY`, `*_TOKEN`, `*_SECRET`, `*_PASSWORD` — in config files only |
+
+It also flags the thing that actually causes breaches: **`.env` files tracked
+by git.**
+
+## Privacy
+
+This is a security tool, so the guarantee matters more than the feature list:
+
+- **It makes no network calls.** None. Read the source — it's a few hundred
+  lines with zero dependencies.
+- **Secrets are redacted in output.** You see `sk-a********o9Pq`, never the
+  full key, so a screenshot is safe to post.
+- Nothing is written anywhere except stdout.
+
+## False positives
+
+The generic entropy check runs **only in config files** (`.env`, `.json`,
+`.yaml`, `.toml`, `.ini`). In source code it fires on ordinary expressions
+like `key = key.upper()` and buries the real findings, so it doesn't run there.
+
+Template files (`.env.example`, `*.sample`, `*.template`) are downgraded, and
+documentation credentials (`user:password@localhost`) are ignored.
+
+Found a false positive? [Open an issue](https://github.com/novasdiego1/envleak/issues)
+with the pattern — that feedback is the whole roadmap.
+
+## What it is not
+
+`envleak` scans your **working tree**, not git history. If a key was committed
+and later deleted, it's still in your history and still compromised — use
+`trufflehog` for that, and rotate the key regardless.
+
+Finding a key is step one. **Rotate it.** A key that appeared in this scan
+should be considered burned.
+
+## License
+
+MIT

envleak_cli-0.1.0/README.md

@@ -0,0 +1,129 @@
+# envleak
+
+**Find your exposed API keys before someone else does.**
+
+One command. No config. Nothing ever leaves your machine.
+
+```bash
+pipx run envleak
+```
+
+```
+  ┌────────────────────────────────────────────┐
+  │            E N V L E A K   S C A N         │
+  └────────────────────────────────────────────┘
+
+   F   █░░░░   Crítico
+
+   5 hallazgo(s) en 128 archivos
+   5 critical
+
+   ⚡ 2 en la superficie de agentes/LLM
+
+   ✗ ARCHIVOS DE ENTORNO RASTREADOS POR GIT:
+     .env
+
+   CRIT  Anthropic API key
+         .env:2
+         ANTHROPIC_API_KEY=sk-a********o9Pq
+
+   CRIT  GitHub token
+         .config/mcp.json:1
+         {"mcpServers":{"gh":{"env":{"GITHUB_TOKEN":"ghp_********3zA5"}}}}
+```
+
+---
+
+## Why another secret scanner?
+
+There are good ones already — `gitleaks` and `trufflehog` scan git history
+and belong in your CI pipeline. `envleak` is for a different moment: **right
+now, on your laptop, in ten seconds, with a grade you can screenshot.**
+
+Two things it does that the others don't:
+
+**1. It scans the agent surface.** Everyone is shipping AI agents in 2026,
+and the credentials moved with them — MCP server configs, `claude_desktop_config.json`,
+n8n and LangGraph workflows, notebooks, LLM provider keys pasted into JSON.
+`envleak` knows what an OpenAI, Anthropic, Groq, LangSmith or Hugging Face key
+looks like and where agent tooling hides them.
+
+**2. It gives you a grade, not a JSON dump.** A 400-line report gets closed.
+An `F` gets fixed.
+
+## Install
+
+```bash
+pipx run envleak          # no install, just run it
+pip install envleak       # or keep it around
+```
+
+Python 3.8+. Zero dependencies.
+
+## Use
+
+```bash
+envleak                   # scan current directory
+envleak ~/code/myproject  # scan somewhere else
+envleak --markdown        # scorecard ready to paste in an issue or PR
+envleak --json            # machine-readable, for pipelines
+```
+
+### In CI
+
+Exits `1` when it finds anything `high` or worse:
+
+```yaml
+- run: pipx run envleak --fail-on critical
+```
+
+```bash
+envleak --fail-on none    # report only, never fail
+```
+
+## What it looks for
+
+| Surface | Examples |
+|---|---|
+| **AI / agents** | OpenAI, Anthropic, Google AI, Groq, Mistral, Hugging Face, Replicate, LangSmith, Perplexity, MCP configs |
+| **Cloud / infra** | AWS access keys, GCP service accounts, private key blocks, Docker registry auth |
+| **Classic** | GitHub, GitLab, Stripe, Slack, Telegram, SendGrid, Twilio, JWTs, database URLs with passwords |
+| **Generic** | High-entropy values assigned to `*_KEY`, `*_TOKEN`, `*_SECRET`, `*_PASSWORD` — in config files only |
+
+It also flags the thing that actually causes breaches: **`.env` files tracked
+by git.**
+
+## Privacy
+
+This is a security tool, so the guarantee matters more than the feature list:
+
+- **It makes no network calls.** None. Read the source — it's a few hundred
+  lines with zero dependencies.
+- **Secrets are redacted in output.** You see `sk-a********o9Pq`, never the
+  full key, so a screenshot is safe to post.
+- Nothing is written anywhere except stdout.
+
+## False positives
+
+The generic entropy check runs **only in config files** (`.env`, `.json`,
+`.yaml`, `.toml`, `.ini`). In source code it fires on ordinary expressions
+like `key = key.upper()` and buries the real findings, so it doesn't run there.
+
+Template files (`.env.example`, `*.sample`, `*.template`) are downgraded, and
+documentation credentials (`user:password@localhost`) are ignored.
+
+Found a false positive? [Open an issue](https://github.com/novasdiego1/envleak/issues)
+with the pattern — that feedback is the whole roadmap.
+
+## What it is not
+
+`envleak` scans your **working tree**, not git history. If a key was committed
+and later deleted, it's still in your history and still compromised — use
+`trufflehog` for that, and rotate the key regardless.
+
+Finding a key is step one. **Rotate it.** A key that appeared in this scan
+should be considered burned.
+
+## License
+
+MIT

envleak_cli-0.1.0/envleak/__init__.py

@@ -0,0 +1,3 @@
+"""envleak — find exposed credentials before someone else does."""
+
+__version__ = "0.1.0"

envleak_cli-0.1.0/envleak/__main__.py

@@ -0,0 +1,4 @@
+import sys
+from .cli import _entry
+
+sys.exit(_entry())

envleak_cli-0.1.0/envleak/cli.py

@@ -0,0 +1,72 @@
+"""envleak — find exposed credentials before someone else does.
+
+Runs entirely on your machine. Nothing is uploaded, ever.
+"""
+
+import argparse
+import sys
+
+from . import __version__
+from .report import compute_score, render_json, render_markdown, render_terminal
+from .scanner import scan
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(
+        prog="envleak",
+        description="Escanea credenciales expuestas. 100%% local, no sube nada.",
+    )
+    p.add_argument("path", nargs="?", default=".", help="directorio a escanear (default: .)")
+    p.add_argument("--json", action="store_true", help="salida JSON")
+    p.add_argument("--markdown", "--md", action="store_true", dest="markdown",
+                   help="scorecard en markdown, listo para pegar")
+    p.add_argument("--no-color", action="store_true", help="sin colores ANSI")
+    p.add_argument("--fail-on", choices=["none", "medium", "high", "critical"],
+                   default="high",
+                   help="código de salida 1 si hay hallazgos de este nivel o peor "
+                        "(default: high). Útil en CI.")
+    p.add_argument("--max-files", type=int, default=20000)
+    p.add_argument("--version", action="version", version=f"envleak {__version__}")
+    args = p.parse_args(argv)
+
+    try:
+        result = scan(args.path, max_files=args.max_files)
+    except FileNotFoundError:
+        print(f"envleak: no existe la ruta {args.path}", file=sys.stderr)
+        return 2
+    except PermissionError:
+        print(f"envleak: sin permiso para leer {args.path}", file=sys.stderr)
+        return 2
+
+    if args.json:
+        print(render_json(result))
+    elif args.markdown:
+        print(render_markdown(result))
+    else:
+        color = not args.no_color and sys.stdout.isatty()
+        print(render_terminal(result, color=color))
+
+    if args.fail_on == "none":
+        return 0
+    order = {"medium": 0, "high": 1, "critical": 2}
+    threshold = order[args.fail_on]
+    worst = max((order[f.severity] for f in result.findings), default=-1)
+    return 1 if worst >= threshold else 0
+
+
+def _entry() -> int:
+    """Console entry point that survives `| head` without a traceback."""
+    try:
+        return main()
+    except BrokenPipeError:
+        try:
+            sys.stdout.close()
+        except Exception:
+            pass
+        return 0
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(_entry())

envleak_cli-0.1.0/envleak/report.py

@@ -0,0 +1,165 @@
+"""Scoring and the shareable scorecard."""
+
+import json
+from collections import Counter
+
+WEIGHTS = {"critical": 25, "high": 10, "medium": 3}
+HOT_FILE_MULTIPLIER = 1.5   # a secret sitting in .env / config is worse
+GIT_TRACKED_PENALTY = 20    # .env committed to git
+
+GRADES = [
+    (0, "A", "Limpio"),
+    (1, "B", "Menor"),
+    (25, "C", "Atención"),
+    (60, "D", "Riesgo alto"),
+    (100, "F", "Crítico"),
+]
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+COLORS = {
+    "A": "\033[92m", "B": "\033[92m", "C": "\033[93m",
+    "D": "\033[91m", "F": "\033[91m",
+}
+SEV_COLOR = {"critical": "\033[91m", "high": "\033[93m", "medium": "\033[94m"}
+
+
+def compute_score(result) -> tuple:
+    """Return (penalty_points, grade_letter, label)."""
+    points = 0.0
+    for f in result.findings:
+        w = WEIGHTS.get(f.severity, 3)
+        if f.in_hot_file:
+            w *= HOT_FILE_MULTIPLIER
+        if f.gitignored:
+            w *= 0.5  # ignored by git = less likely to leak outward
+        points += w
+    points += GIT_TRACKED_PENALTY * len(result.env_in_git)
+
+    grade, label = "A", "Limpio"
+    for threshold, letter, text in GRADES:
+        if points >= threshold:
+            grade, label = letter, text
+    return round(points), grade, label
+
+
+def _bar(grade: str) -> str:
+    filled = {"A": 5, "B": 4, "C": 3, "D": 2, "F": 1}[grade]
+    return "█" * filled + "░" * (5 - filled)
+
+
+def render_terminal(result, color: bool = True) -> str:
+    points, grade, label = compute_score(result)
+    c = (lambda s, code: f"{code}{s}{RESET}") if color else (lambda s, code: s)
+    gcol = COLORS[grade]
+
+    sev = Counter(f.severity for f in result.findings)
+    groups = Counter(f.group for f in result.findings)
+
+    out = []
+    out.append("")
+    out.append(c("  ┌────────────────────────────────────────────┐", DIM))
+    out.append(c("  │", DIM) + c("            E N V L E A K   S C A N         ", BOLD)
+               + c(" │", DIM))
+    out.append(c("  └────────────────────────────────────────────┘", DIM))
+    out.append("")
+    out.append(f"   {c(grade, gcol + BOLD)}   {c(_bar(grade), gcol)}   {c(label, BOLD)}")
+    out.append("")
+    out.append(f"   {len(result.findings)} hallazgo(s) en {result.files_scanned} archivos")
+    if result.findings:
+        parts = []
+        for s in ("critical", "high", "medium"):
+            if sev[s]:
+                parts.append(c(f"{sev[s]} {s}", SEV_COLOR[s]))
+        out.append("   " + "  ·  ".join(parts))
+    out.append("")
+
+    if groups.get("agent"):
+        out.append(c(f"   ⚡ {groups['agent']} en la superficie de agentes/LLM", "\033[95m"))
+        out.append("")
+
+    if result.env_in_git:
+        out.append(c("   ✗ ARCHIVOS DE ENTORNO RASTREADOS POR GIT:", "\033[91m" + BOLD))
+        for p in result.env_in_git[:5]:
+            out.append(c(f"     {p}", "\033[91m"))
+        out.append("")
+
+    if result.findings:
+        out.append(c("   Hallazgos", BOLD))
+        out.append("")
+        shown = sorted(
+            result.findings,
+            key=lambda f: (
+                {"critical": 0, "high": 1, "medium": 2}[f.severity],
+                not f.in_hot_file,
+            ),
+        )
+        for f in shown[:15]:
+            tag = c(f.severity.upper()[:4], SEV_COLOR[f.severity])
+            out.append(f"   {tag}  {c(f.rule_name, BOLD)}")
+            out.append(c(f"         {f.path}:{f.line_no}", DIM))
+            out.append(c(f"         {f.snippet}", DIM))
+            out.append("")
+        if len(shown) > 15:
+            out.append(c(f"   … y {len(shown) - 15} más\n", DIM))
+    else:
+        out.append(c("   Sin credenciales expuestas. Bien ahí.\n", "\033[92m"))
+
+    if not result.has_gitignore and result.env_files_found:
+        out.append(c("   ! No hay .gitignore y existen archivos .env\n", "\033[93m"))
+
+    out.append(c("   Nada de esto salió de tu máquina.", DIM))
+    out.append("")
+    return "\n".join(out)
+
+
+def render_markdown(result) -> str:
+    points, grade, label = compute_score(result)
+    sev = Counter(f.severity for f in result.findings)
+    groups = Counter(f.group for f in result.findings)
+
+    lines = [
+        "```",
+        "  E N V L E A K   S C A N",
+        "",
+        f"   {grade}   {_bar(grade)}   {label}",
+        "",
+        f"   {len(result.findings)} hallazgo(s) · {result.files_scanned} archivos",
+    ]
+    if result.findings:
+        parts = [f"{sev[s]} {s}" for s in ("critical", "high", "medium") if sev[s]]
+        lines.append("   " + "  ·  ".join(parts))
+    if groups.get("agent"):
+        lines.append(f"   {groups['agent']} en la superficie de agentes/LLM")
+    if result.env_in_git:
+        lines.append(f"   {len(result.env_in_git)} archivo(s) .env rastreados por git")
+    lines += ["```", "", "_Escaneado localmente con `pipx run envleak`. "
+              "Ningún dato salió de la máquina._"]
+    return "\n".join(lines)
+
+
+def render_json(result) -> str:
+    points, grade, label = compute_score(result)
+    return json.dumps({
+        "grade": grade,
+        "label": label,
+        "penalty_points": points,
+        "files_scanned": result.files_scanned,
+        "env_files_tracked_by_git": result.env_in_git,
+        "agent_config_files": result.agent_files_found,
+        "findings": [
+            {
+                "rule": f.rule_id,
+                "name": f.rule_name,
+                "severity": f.severity,
+                "group": f.group,
+                "path": f.path,
+                "line": f.line_no,
+                "snippet": f.snippet,
+                "in_env_or_config_file": f.in_hot_file,
+                "gitignored": f.gitignored,
+            }
+            for f in result.findings
+        ],
+    }, indent=2, ensure_ascii=False)

envleak_cli-0.1.0/envleak/rules.py

@@ -0,0 +1,162 @@
+"""Detection rules for envleak.
+
+Each rule finds one kind of credential. Rules are ordered: the agent/LLM
+surface comes first because that's the surface nobody else scans.
+"""
+
+import math
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Rule:
+    id: str
+    name: str
+    pattern: re.Pattern
+    severity: str  # critical | high | medium
+    group: str     # "agent" | "cloud" | "classic"
+
+
+def _c(p: str) -> re.Pattern:
+    return re.compile(p)
+
+
+# --- The agent / LLM surface (the differentiator) -------------------------
+AGENT_RULES = [
+    Rule("openai-key", "OpenAI API key",
+         _c(r"\bsk-(?!ant-)(?:proj-)?[A-Za-z0-9_-]{20,}\b"), "critical", "agent"),
+    Rule("anthropic-key", "Anthropic API key",
+         _c(r"\bsk-ant-[A-Za-z0-9_-]{20,}\b"), "critical", "agent"),
+    Rule("google-ai-key", "Google AI / Gemini key",
+         _c(r"\bAIza[0-9A-Za-z_-]{35}\b"), "critical", "agent"),
+    Rule("groq-key", "Groq API key",
+         _c(r"\bgsk_[A-Za-z0-9]{40,}\b"), "critical", "agent"),
+    Rule("hf-token", "Hugging Face token",
+         _c(r"\bhf_[A-Za-z0-9]{30,}\b"), "high", "agent"),
+    Rule("replicate-token", "Replicate token",
+         _c(r"\br8_[A-Za-z0-9]{30,}\b"), "high", "agent"),
+    Rule("langsmith-key", "LangSmith API key",
+         _c(r"\blsv2_(?:pt|sk)_[A-Za-z0-9]{20,}"), "high", "agent"),
+    Rule("perplexity-key", "Perplexity API key",
+         _c(r"\bpplx-[A-Za-z0-9]{32,}\b"), "high", "agent"),
+    Rule("mistral-key", "Mistral API key",
+         _c(r"(?i)\bmistral[_-]?api[_-]?key\b\s*[:=]\s*['\"]?([A-Za-z0-9]{24,})"),
+         "high", "agent"),
+    Rule("generic-llm-key", "LLM provider key in config",
+         _c(r"(?i)\b(?:llm|openai|anthropic|together|fireworks|deepseek|xai)"
+            r"[_-]?(?:api[_-]?)?key\b\s*[:=]\s*['\"]?([A-Za-z0-9_\-]{20,})"),
+         "high", "agent"),
+]
+
+# --- Cloud / infra --------------------------------------------------------
+CLOUD_RULES = [
+    Rule("aws-access-key", "AWS access key ID",
+         _c(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"), "critical", "cloud"),
+    Rule("aws-secret", "AWS secret access key",
+         _c(r"(?i)aws[_-]?secret[_-]?access[_-]?key\b\s*[:=]\s*['\"]?([A-Za-z0-9/+=]{40})"),
+         "critical", "cloud"),
+    Rule("gcp-sa", "GCP service-account private key",
+         _c(r'"type"\s*:\s*"service_account"'), "critical", "cloud"),
+    Rule("private-key", "Private key block",
+         _c(r"-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----"),
+         "critical", "cloud"),
+    Rule("docker-auth", "Docker registry auth",
+         _c(r'"auths"\s*:\s*\{[^}]*"auth"\s*:\s*"[A-Za-z0-9+/=]{16,}"'),
+         "high", "cloud"),
+]
+
+# --- Classic third-party --------------------------------------------------
+CLASSIC_RULES = [
+    Rule("github-token", "GitHub token",
+         _c(r"\bgh[pousr]_[A-Za-z0-9]{36,}\b"), "critical", "classic"),
+    Rule("gitlab-token", "GitLab token",
+         _c(r"\bglpat-[A-Za-z0-9_-]{20,}\b"), "critical", "classic"),
+    Rule("stripe-key", "Stripe secret key",
+         _c(r"\b(?:sk|rk)_live_[A-Za-z0-9]{20,}\b"), "critical", "classic"),
+    Rule("slack-token", "Slack token",
+         _c(r"\bxox[abprs]-[A-Za-z0-9-]{10,}\b"), "high", "classic"),
+    Rule("telegram-bot", "Telegram bot token",
+         _c(r"\b\d{8,10}:AA[A-Za-z0-9_-]{32,}\b"), "high", "classic"),
+    Rule("sendgrid-key", "SendGrid API key",
+         _c(r"\bSG\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b"), "high", "classic"),
+    Rule("twilio-sid", "Twilio account SID",
+         _c(r"\bAC[0-9a-fA-F]{32}\b"), "medium", "classic"),
+    Rule("jwt", "JSON Web Token",
+         _c(r"\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b"),
+         "medium", "classic"),
+    Rule("db-url", "Database URL with password",
+         _c(r"\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp)://"
+            r"[^\s:'\"]+:[^\s@'\"]{3,}@[^\s/'\"]+"), "critical", "classic"),
+    Rule("crypto-priv", "Crypto private key / seed",
+         _c(r"(?i)\b(?:private[_-]?key|mnemonic|seed[_-]?phrase)\b\s*[:=]\s*"
+            r"['\"]?(0x[a-fA-F0-9]{64}|(?:[a-z]+\s+){11,23}[a-z]+)"),
+         "critical", "classic"),
+]
+
+ALL_RULES = AGENT_RULES + CLOUD_RULES + CLASSIC_RULES
+
+# Generic high-entropy assignment (catches what the rules above miss)
+ASSIGNMENT = re.compile(
+    r"(?i)\b([A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|CREDENTIAL)[A-Z0-9_]*)"
+    r"\s*[:=]\s*['\"]?([^\s'\"#,;]{16,})"
+)
+
+PLACEHOLDERS = {
+    "changeme", "your_key_here", "xxx", "todo", "placeholder", "example",
+    "null", "none", "true", "false", "undefined", "secret", "password",
+    "username", "user", "admin", "root", "test", "localhost",
+}
+
+# Credential pairs that only ever appear in docs and templates.
+DOC_CREDENTIALS = (
+    "user:password@", "username:password@", "admin:admin@", "root:root@",
+    "user:pass@", "foo:bar@", "test:test@", ":password@", ":changeme@",
+)
+
+LOCAL_HOSTS = ("@localhost", "@127.0.0.1", "@0.0.0.0", "@db:", "@host.docker")
+
+# A value that is really an expression, not a literal secret.
+CODE_CHARS = set("()[]{}<>+*/\\ ")
+
+
+def shannon_entropy(s: str) -> float:
+    if not s:
+        return 0.0
+    freq = {}
+    for ch in s:
+        freq[ch] = freq.get(ch, 0) + 1
+    n = len(s)
+    return -sum((c / n) * math.log2(c / n) for c in freq.values())
+
+
+def looks_like_code(value: str) -> bool:
+    """True when the "secret" is actually a code expression."""
+    v = value.strip().strip("'\"")
+    if any(ch in CODE_CHARS for ch in v):
+        return True
+    if v.endswith((".upper", ".lower", ".strip", ".format", ".get")):
+        return True
+    if v.count(".") >= 1 and "_" not in v and not any(c.isdigit() for c in v):
+        return True  # attribute access like key.upper
+    return False
+
+
+def looks_like_placeholder(value: str) -> bool:
+    v = value.strip().strip("'\"").lower()
+    if any(d in v for d in DOC_CREDENTIALS):
+        return True
+    if any(h in v for h in LOCAL_HOSTS):
+        return True
+    if len(v) < 16:
+        return True
+    if v in PLACEHOLDERS:
+        return True
+    if v.startswith(("${", "{{", "<", "$(")):  # templated
+        return True
+    if any(p in v for p in ("your-", "your_", "example", "placeholder",
+                            "changeme", "dummy", "fake", "sample", "xxxx")):
+        return True
+    if len(set(v)) <= 3:  # aaaaaaaa, 00000000
+        return True
+    return False

envleak_cli-0.1.0/envleak/scanner.py

@@ -0,0 +1,268 @@
+"""Filesystem scanner. Everything here runs locally; nothing leaves the machine."""
+
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .rules import (
+    ALL_RULES, ASSIGNMENT, looks_like_code, looks_like_placeholder,
+    shannon_entropy,
+)
+
+MAX_FILE_BYTES = 2 * 1024 * 1024  # skip anything bigger than 2 MB
+MAX_LINE_LEN = 4000
+
+SKIP_DIRS = {
+    ".git", "node_modules", "__pycache__", ".venv", "venv", "env",
+    "dist", "build", ".next", ".nuxt", "target", "vendor", ".tox",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache", "site-packages",
+    ".terraform", "coverage", ".idea", ".gradle",
+}
+
+SKIP_EXT = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".ico", ".pdf",
+    ".zip", ".gz", ".tar", ".bz2", ".xz", ".7z", ".rar", ".jar",
+    ".mp3", ".mp4", ".mov", ".avi", ".woff", ".woff2", ".ttf", ".otf",
+    ".so", ".dylib", ".dll", ".exe", ".bin", ".pyc", ".pyo", ".class",
+    ".lock", ".min.js", ".map",
+}
+
+# Config-shaped files. The generic entropy pass runs ONLY here: in source
+# code it fires on ordinary expressions (key = key.upper()) and destroys
+# the signal-to-noise ratio.
+CONFIG_EXT = {".env", ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg",
+              ".conf", ".properties", ".tfvars"}
+
+# Template files ship fake credentials on purpose.
+EXAMPLE_MARKERS = (".example", ".sample", ".template", ".dist", "sample.",
+                   "example.", "template.")
+
+
+def is_example_file(name: str) -> bool:
+    n = name.lower()
+    return any(m in n for m in EXAMPLE_MARKERS)
+
+
+# Files that are, by their nature, credential-bearing. Finding a live secret
+# in one of these is worse because they're the ones that get committed or
+# copied into images by accident.
+HOT_FILES = {
+    ".env", ".env.local", ".env.production", ".env.prod", ".env.dev",
+    ".env.development", ".env.staging", ".envrc",
+    "credentials", "config.json", "secrets.json", "settings.json",
+    "docker-compose.yml", "docker-compose.yaml",
+}
+
+# The agent surface: MCP servers, orchestration configs, notebooks.
+AGENT_FILE_HINTS = (
+    "mcp.json", "mcp_config", "claude_desktop_config.json",
+    "langgraph.json", "crew", "agents.yaml", "agent.yaml",
+    ".n8n", "workflows", "flowise", "dify",
+)
+
+TEXT_HINT_EXT = {
+    ".env", ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf",
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".sh", ".bash", ".zsh", ".fish",
+    ".rb", ".go", ".rs", ".java", ".php", ".cs", ".txt", ".md", ".properties",
+    ".tf", ".tfvars", ".xml", ".sql", ".ipynb", ".example", ".sample", "",
+}
+
+
+@dataclass
+class Finding:
+    rule_id: str
+    rule_name: str
+    severity: str
+    group: str
+    path: str
+    line_no: int
+    snippet: str
+    in_hot_file: bool = False
+    gitignored: bool = False
+
+
+@dataclass
+class ScanResult:
+    root: str
+    findings: list = field(default_factory=list)
+    files_scanned: int = 0
+    env_files_found: list = field(default_factory=list)
+    agent_files_found: list = field(default_factory=list)
+    env_in_git: list = field(default_factory=list)
+    has_gitignore: bool = False
+
+
+def _redact(value: str) -> str:
+    """Show enough to identify the key, never enough to use it."""
+    v = value.strip().strip("'\"")
+    if len(v) <= 10:
+        return v[:2] + "*" * max(len(v) - 2, 0)
+    return f"{v[:4]}{'*' * 8}{v[-4:]}"
+
+
+def _redact_line(line: str, match_text: str) -> str:
+    line = line.strip()[:MAX_LINE_LEN]
+    return line.replace(match_text, _redact(match_text))[:200]
+
+
+def _is_probably_text(path: Path) -> bool:
+    if path.suffix.lower() in SKIP_EXT:
+        return False
+    if path.suffix.lower() in TEXT_HINT_EXT or path.name.startswith("."):
+        return True
+    return path.suffix == ""
+
+
+def _read_gitignore(root: Path) -> set:
+    patterns = set()
+    gi = root / ".gitignore"
+    if gi.exists():
+        try:
+            for line in gi.read_text(errors="ignore").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    patterns.add(line.rstrip("/"))
+        except OSError:
+            pass
+    return patterns
+
+
+def _matches_gitignore(rel: str, patterns: set) -> bool:
+    name = os.path.basename(rel)
+    for p in patterns:
+        if p in (name, rel):
+            return True
+        if p.startswith("*") and name.endswith(p[1:]):
+            return True
+        if p.endswith("*") and name.startswith(p[:-1]):
+            return True
+        if rel.startswith(p + "/"):
+            return True
+    return False
+
+
+def scan(root: str, max_files: int = 20000) -> ScanResult:
+    root_path = Path(root).resolve()
+    result = ScanResult(root=str(root_path))
+    gitignore = _read_gitignore(root_path)
+    result.has_gitignore = bool(gitignore)
+    tracked = _git_tracked_files(root_path)
+
+    for dirpath, dirnames, filenames in os.walk(root_path):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+        for fname in filenames:
+            if result.files_scanned >= max_files:
+                return result
+            fpath = Path(dirpath) / fname
+            try:
+                if fpath.is_symlink() or fpath.stat().st_size > MAX_FILE_BYTES:
+                    continue
+            except OSError:
+                continue
+            if not _is_probably_text(fpath):
+                continue
+
+            rel = str(fpath.relative_to(root_path))
+            lower = rel.lower()
+
+            is_example = is_example_file(fname)
+            is_hot = (fname in HOT_FILES or fname.startswith(".env")) \
+                and not is_example
+            if is_hot:
+                result.env_files_found.append(rel)
+                if tracked is not None and rel in tracked:
+                    result.env_in_git.append(rel)
+
+            if any(h in lower for h in AGENT_FILE_HINTS):
+                result.agent_files_found.append(rel)
+
+            try:
+                text = fpath.read_text(errors="ignore")
+            except (OSError, UnicodeDecodeError):
+                continue
+            result.files_scanned += 1
+
+            ignored = _matches_gitignore(rel, gitignore)
+            is_config = (fpath.suffix.lower() in CONFIG_EXT
+                         or fname.startswith(".env"))
+            _scan_text(text, rel, is_hot, ignored, result,
+                       is_config=is_config, is_example=is_example)
+
+    return result
+
+
+def _git_tracked_files(root: Path):
+    """Return set of git-tracked paths, or None if not a repo / git missing."""
+    if not (root / ".git").exists():
+        return None
+    try:
+        import subprocess
+        out = subprocess.run(
+            ["git", "-C", str(root), "ls-files"],
+            capture_output=True, text=True, timeout=20,
+        )
+        if out.returncode != 0:
+            return None
+        return set(out.stdout.splitlines())
+    except Exception:
+        return None
+
+
+def _scan_text(text: str, rel: str, is_hot: bool, ignored: bool,
+               result: ScanResult, is_config: bool = False,
+               is_example: bool = False) -> None:
+    seen = set()
+    claimed = set()
+    lines = text.splitlines()
+
+    for i, line in enumerate(lines, 1):
+        if len(line) > MAX_LINE_LEN:
+            continue
+        stripped = line.strip()
+        if stripped.startswith(("#", "//", "*", "<!--")) and "=" not in stripped:
+            continue
+
+        for rule in ALL_RULES:
+            for m in rule.pattern.finditer(line):
+                hit = m.group(1) if m.groups() else m.group(0)
+                # One credential, one finding: the first (most specific) rule
+                # to claim a value wins. ALL_RULES is ordered specific-first.
+                claim = hit.strip().strip("'\"")[:60]
+                if claim in claimed:
+                    continue
+                if looks_like_placeholder(hit):
+                    continue
+                claimed.add(claim)
+                sev = "medium" if is_example else rule.severity
+                result.findings.append(Finding(
+                    rule_id=rule.id, rule_name=rule.name,
+                    severity=sev, group=rule.group,
+                    path=rel, line_no=i,
+                    snippet=_redact_line(line, hit),
+                    in_hot_file=is_hot, gitignored=ignored,
+                ))
+
+        # Generic entropy pass — config files only. In source code this
+        # fires on ordinary expressions and buries the real findings.
+        if not is_config:
+            continue
+        for m in ASSIGNMENT.finditer(line):
+            varname, value = m.group(1), m.group(2)
+            if looks_like_placeholder(value) or looks_like_code(value):
+                continue
+            if shannon_entropy(value) < 3.5:
+                continue
+            claim = value.strip().strip("'\"")[:60]
+            if claim in claimed:
+                continue
+            if any(claim in c or c in claim for c in claimed):
+                continue
+            claimed.add(claim)
+            result.findings.append(Finding(
+                rule_id="high-entropy", rule_name=f"High-entropy value in {varname}",
+                severity="medium", group="classic",
+                path=rel, line_no=i,
+                snippet=_redact_line(line, value),
+                in_hot_file=is_hot, gitignored=ignored,
+            ))

envleak_cli-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "envleak-cli"
+version = "0.1.0"
+description = "Find exposed API keys and secrets before someone else does. 100% local."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["security", "secrets", "api-keys", "ai-agents", "llm", "devsecops"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Security",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/novasdiego1/envleak"
+Issues = "https://github.com/novasdiego1/envleak/issues"
+
+[project.scripts]
+envleak = "envleak.cli:_entry"
+
+[tool.hatch.build.targets.wheel]
+packages = ["envleak"]