secret-scanner-cl 1.0.0__tar.gz

secret_scanner_cl-1.0.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: secret-scanner-cl
+Version: 1.0.0
+Summary: CLI tool that detects hardcoded secrets and credentials in source code.
+Author-email: Kiara <kiara@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Kiara1616/secret-scanner
+Project-URL: Repository, https://github.com/Kiara1616/secret-scanner
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: colorama>=0.4.6
+
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/MQUb8mG3)
+[![Open in Codespaces](https://classroom.github.com/assets/launch-codespace-2972f46106e565e64193e422d61a12cf1da4916b45550586e14ef0a7c637dd04.svg)](https://classroom.github.com/open-in-codespaces?assignment_repo_id=23328920)
+
+# SecretScanner — Analizador de Secretos
+
+
+Herramienta de código abierto desarrollada en **Python 3.10** que analiza proyectos de software y detecta **secretos y credenciales hardcodeadas** (API keys, tokens, contraseñas, claves privadas) mediante expresiones regulares.
+
+## Características
+
+- Soporte para cualquier directorio o archivo de texto.
+- Detección automática del tipo de secreto encontrado.
+- Recorrido recursivo de directorios con `os.walk`.
+- Análisis basado en **8 patrones regex** documentados: GitHub Token, AWS Access Key, API Key genérica, contraseña hardcodeada, JWT Token, Slack Token, clave privada RSA y URL con credenciales.
+- Salida en consola con colores diferenciados por severidad.
+- Exportación de reportes a **JSON** y **CSV** en la carpeta `output/`.
+- Interfaz de línea de comandos (CLI) con `--path`, `--output` y `--verbose`.
+
+## Requisitos
+
+- Python 3.10 o superior
+- pip
+
+## Instalación
+
+```bash
+git clone https://github.com/UPT-FAING-EPIS/proyecto-si784-2026-i-u1-analizador-de-secretos.git
+cd proyecto-si784-2026-i-u1-analizador-de-secretos
+pip install -r requirements.txt
+```
+
+## Uso de la CLI
+
+Una vez instaladas las dependencias, ejecuta la herramienta con:
+
+```bash
+python main.py --path <ruta-del-proyecto>
+```
+
+## Parámetros y opciones
+
+| Opción | Descripción |
+|--------|-------------|
+| `--path <ruta>` | **(Requerido)** Ruta al directorio o archivo a analizar |
+| `--output json` | Exporta el reporte a `output/report.json` |
+| `--output csv` | Exporta el reporte a `output/report.csv` |
+| `--verbose` | Muestra cada archivo procesado durante el escaneo |
+
+## Ejemplos
+
+```bash
+# Analizar el directorio actual
+python main.py --path .
+
+# Analizar una ruta específica y exportar JSON
+python main.py --path ./mi_proyecto --output json
+
+# Analizar y exportar CSV
+python main.py --path ./mi_proyecto --output csv
+
+# Modo verbose — muestra cada archivo procesado
+python main.py --path ./mi_proyecto --verbose
+
+# Verbose + exportar JSON
+python main.py --path ./mi_proyecto --verbose --output json
+```
+
+## Ejemplo de salida
+🔍 Analizando: ./mi_proyecto
+
+[ALERTA] GitHub Token encontrado
+Archivo : mi_proyecto/config.py
+Línea : 12
+Contenido: token = "ghp_1234...****"
+
+[ALERTA] Contraseña hardcodeada encontrada
+Archivo : mi_proyecto/db.py
+Línea : 8
+Contenido: password = "****"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Análisis completado
+Archivos analizados : 24
+Secretos encontrados : 2
+Reporte exportado : output/report.json
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+text
+
+## Tipos de secretos detectados
+
+| Tipo | Patrón detectado |
+|------|-----------------|
+| GitHub Token | `ghp_`, `gho_`, `ghu_`, `ghs_` |
+| AWS Access Key | `AKIA[0-9A-Z]{16}` |
+| API Key genérica | `api_key = "..."` |
+| Contraseña hardcodeada | `password = "..."` |
+| JWT Token | `eyJ...` (header base64) |
+| Slack Token | `xox[baprs]-...` |
+| Clave privada RSA | `-----BEGIN RSA PRIVATE KEY-----` |
+| URL con credenciales | `http://user:pass@host` |
+
+## Archivos ignorados
+
+El escáner omite automáticamente extensiones binarias (`.png`, `.jpg`, `.gif`, `.exe`, `.zip`, `.pdf`) y directorios no relevantes (`.git`, `__pycache__`, `node_modules`, `output`).
+
+## Desarrollo y tests
+
+```bash
+# Instalar dependencias de desarrollo
+pip install -r requirements-dev.txt
+
+# Ejecutar todos los tests
+pytest
+
+# Ver cobertura por módulo
+pytest --cov=scanner --cov-report=term-missing
+
+# Tests de un módulo específico
+pytest tests/test_patterns.py -v
+```
+
+La cobertura mínima requerida es **80%** sobre el paquete `scanner/`.
+
+## CI/CD
+
+El proyecto cuenta con un pipeline de **GitHub Actions** (`.github/workflows/ci.yml`) que se activa en cada `push` y `pull_request` hacia `main`, instala dependencias, ejecuta los tests con cobertura y falla el build si algún test no pasa.
+

secret_scanner_cl-1.0.0/README.md

@@ -0,0 +1,128 @@
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/MQUb8mG3)
+[![Open in Codespaces](https://classroom.github.com/assets/launch-codespace-2972f46106e565e64193e422d61a12cf1da4916b45550586e14ef0a7c637dd04.svg)](https://classroom.github.com/open-in-codespaces?assignment_repo_id=23328920)
+
+# SecretScanner — Analizador de Secretos
+
+
+Herramienta de código abierto desarrollada en **Python 3.10** que analiza proyectos de software y detecta **secretos y credenciales hardcodeadas** (API keys, tokens, contraseñas, claves privadas) mediante expresiones regulares.
+
+## Características
+
+- Soporte para cualquier directorio o archivo de texto.
+- Detección automática del tipo de secreto encontrado.
+- Recorrido recursivo de directorios con `os.walk`.
+- Análisis basado en **8 patrones regex** documentados: GitHub Token, AWS Access Key, API Key genérica, contraseña hardcodeada, JWT Token, Slack Token, clave privada RSA y URL con credenciales.
+- Salida en consola con colores diferenciados por severidad.
+- Exportación de reportes a **JSON** y **CSV** en la carpeta `output/`.
+- Interfaz de línea de comandos (CLI) con `--path`, `--output` y `--verbose`.
+
+## Requisitos
+
+- Python 3.10 o superior
+- pip
+
+## Instalación
+
+```bash
+git clone https://github.com/UPT-FAING-EPIS/proyecto-si784-2026-i-u1-analizador-de-secretos.git
+cd proyecto-si784-2026-i-u1-analizador-de-secretos
+pip install -r requirements.txt
+```
+
+## Uso de la CLI
+
+Una vez instaladas las dependencias, ejecuta la herramienta con:
+
+```bash
+python main.py --path <ruta-del-proyecto>
+```
+
+## Parámetros y opciones
+
+| Opción | Descripción |
+|--------|-------------|
+| `--path <ruta>` | **(Requerido)** Ruta al directorio o archivo a analizar |
+| `--output json` | Exporta el reporte a `output/report.json` |
+| `--output csv` | Exporta el reporte a `output/report.csv` |
+| `--verbose` | Muestra cada archivo procesado durante el escaneo |
+
+## Ejemplos
+
+```bash
+# Analizar el directorio actual
+python main.py --path .
+
+# Analizar una ruta específica y exportar JSON
+python main.py --path ./mi_proyecto --output json
+
+# Analizar y exportar CSV
+python main.py --path ./mi_proyecto --output csv
+
+# Modo verbose — muestra cada archivo procesado
+python main.py --path ./mi_proyecto --verbose
+
+# Verbose + exportar JSON
+python main.py --path ./mi_proyecto --verbose --output json
+```
+
+## Ejemplo de salida
+🔍 Analizando: ./mi_proyecto
+
+[ALERTA] GitHub Token encontrado
+Archivo : mi_proyecto/config.py
+Línea : 12
+Contenido: token = "ghp_1234...****"
+
+[ALERTA] Contraseña hardcodeada encontrada
+Archivo : mi_proyecto/db.py
+Línea : 8
+Contenido: password = "****"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Análisis completado
+Archivos analizados : 24
+Secretos encontrados : 2
+Reporte exportado : output/report.json
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+text
+
+## Tipos de secretos detectados
+
+| Tipo | Patrón detectado |
+|------|-----------------|
+| GitHub Token | `ghp_`, `gho_`, `ghu_`, `ghs_` |
+| AWS Access Key | `AKIA[0-9A-Z]{16}` |
+| API Key genérica | `api_key = "..."` |
+| Contraseña hardcodeada | `password = "..."` |
+| JWT Token | `eyJ...` (header base64) |
+| Slack Token | `xox[baprs]-...` |
+| Clave privada RSA | `-----BEGIN RSA PRIVATE KEY-----` |
+| URL con credenciales | `http://user:pass@host` |
+
+## Archivos ignorados
+
+El escáner omite automáticamente extensiones binarias (`.png`, `.jpg`, `.gif`, `.exe`, `.zip`, `.pdf`) y directorios no relevantes (`.git`, `__pycache__`, `node_modules`, `output`).
+
+## Desarrollo y tests
+
+```bash
+# Instalar dependencias de desarrollo
+pip install -r requirements-dev.txt
+
+# Ejecutar todos los tests
+pytest
+
+# Ver cobertura por módulo
+pytest --cov=scanner --cov-report=term-missing
+
+# Tests de un módulo específico
+pytest tests/test_patterns.py -v
+```
+
+La cobertura mínima requerida es **80%** sobre el paquete `scanner/`.
+
+## CI/CD
+
+El proyecto cuenta con un pipeline de **GitHub Actions** (`.github/workflows/ci.yml`) que se activa en cada `push` y `pull_request` hacia `main`, instala dependencias, ejecuta los tests con cobertura y falla el build si algún test no pasa.
+

secret_scanner_cl-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "secret-scanner-cl"
+version = "1.0.0"
+description = "CLI tool that detects hardcoded secrets and credentials in source code."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+  {name = "Kiara", email = "kiara@example.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "colorama>=0.4.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/Kiara1616/secret-scanner"
+Repository = "https://github.com/Kiara1616/secret-scanner"
+
+[project.scripts]
+secret-scanner = "secret_scanner.main:main"
+
+# ── pytest + coverage ──────────────────────────────────────────────────────
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = [
+    "--cov=src.secret_scanner",
+    "--cov-report=term-missing",
+    "--cov-fail-under=80",
+    "-v",
+]
+
+[tool.coverage.run]
+source = ["src/secret_scanner"]
+omit = ["tests/*"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 80

secret_scanner_cl-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

secret_scanner_cl-1.0.0/src/secret_scanner/main.py

@@ -0,0 +1,186 @@
+"""
+main.py – SecretScanner CLI entry-point.
+
+Usage examples
+--------------
+    python main.py --path .
+    python main.py --path ./myproject --output json --verbose
+    python main.py --path ./myproject --output csv
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+# Force UTF-8 output on Windows to avoid cp1252 UnicodeEncodeError
+if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+
+from colorama import Fore, Style, init as colorama_init
+
+from secret_scanner.scanner.file_scanner import scan_path
+from secret_scanner.scanner.reporter import export_json, export_csv
+
+# ── Colour helpers ─────────────────────────────────────────────────────────
+SEVERITY_COLOR = {
+    "HIGH": Fore.RED + Style.BRIGHT,
+    "MEDIUM": Fore.YELLOW + Style.BRIGHT,
+    "LOW": Fore.CYAN,
+}
+
+
+def _colored(text: str, color: str) -> str:
+    return f"{color}{text}{Style.RESET_ALL}"
+
+
+def _banner() -> None:
+    print(
+        _colored(
+            r"""
+  ____  ___   ____ ____  _____ _____ ____   ____    _    _   _ _   _ _____ ____
+ / ___||__ \ / ___| __ )| ____|_   _/ ___| / ___|  / \  | \ | | \ | | ____|  _ \
+ \___ \  / // |   |  _ \|  _|   | | \___ \| |     / _ \ |  \| |  \| |  _| | |_) |
+  ___) |/ /_| |___| |_) | |___  | |  ___) | |___ / ___ \| |\  | |\  | |___|  _ <
+ |____//_____\____|____/|_____| |_| |____/ \____/_/   \_\_| \_|_| \_|_____|_| \_\
+""",
+            Fore.CYAN + Style.BRIGHT,
+        )
+    )
+    print(_colored("  SecretScanner v1.0.0 - Hardcoded Secret Detector\n", Fore.WHITE))
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="secret-scanner",
+        description="Detect hardcoded secrets and credentials in source code.",
+    )
+    parser.add_argument(
+        "--path",
+        required=True,
+        metavar="PATH",
+        help="Directory or file to scan.",
+    )
+    parser.add_argument(
+        "--output",
+        choices=["json", "csv"],
+        default=None,
+        metavar="FORMAT",
+        help="Export format: 'json' or 'csv'. Saves to output/ directory.",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print each file as it is processed.",
+    )
+    return parser
+
+
+def _print_findings(findings: list) -> None:
+    if not findings:
+        return
+
+    print(_colored("\n" + "-" * 70, Fore.WHITE))
+    print(_colored("  FINDINGS", Fore.RED + Style.BRIGHT))
+    print(_colored("-" * 70 + "\n", Fore.WHITE))
+
+    for f in findings:
+        severity = f.get("severity", "MEDIUM")
+        color = SEVERITY_COLOR.get(severity, Fore.WHITE)
+        badge = _colored(f"[{severity}]", color)
+        type_label = _colored(f.get("type", "Unknown"), Fore.WHITE + Style.BRIGHT)
+        file_info = _colored(f"{f['file']}:{f['line']}", Fore.BLUE)
+        content = f.get("content", "")
+
+        print(f"  {badge} {type_label}")
+        print(f"    {_colored('File:', Fore.WHITE)} {file_info}")
+        print(f"    {_colored('Content:', Fore.WHITE)} {content}")
+        print()
+
+
+def _print_summary(
+    total_files: int,
+    findings: list,
+    report_path: str | None,
+) -> None:
+    count = len(findings)
+    separator = "-" * 70
+
+    print(_colored(separator, Fore.GREEN))
+
+    if count == 0:
+        print(_colored("  [OK] No secrets found. Your project looks clean!", Fore.GREEN + Style.BRIGHT))
+    else:
+        print(
+            _colored(
+                f"  [!] {count} secret(s) found - review them before committing!",
+                Fore.RED + Style.BRIGHT,
+            )
+        )
+
+    print(_colored(f"  Files analysed : {total_files}", Fore.GREEN))
+    print(_colored(f"  Secrets found  : {count}", Fore.GREEN))
+
+    if report_path:
+        print(_colored(f"  Report saved   : {report_path}", Fore.GREEN))
+
+    print(_colored(separator, Fore.GREEN))
+
+
+def _count_files(path: str) -> int:
+    """Count scannable files under *path* (mirrors the scanner logic)."""
+    root = Path(path).resolve()
+    if root.is_file():
+        return 1
+    total = 0
+    ignored_dirs = {".git", "__pycache__", "node_modules", "output",
+                    ".venv", "venv", ".tox", "dist", "build", ".mypy_cache"}
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in ignored_dirs]
+        total += len(filenames)
+    return total
+
+
+def main() -> int:
+    colorama_init(autoreset=True)
+    _banner()
+
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    target = Path(args.path)
+    if not target.exists():
+        print(_colored(f"  ERROR: Path not found: {args.path}", Fore.RED + Style.BRIGHT))
+        return 1
+
+    print(_colored(f"  Scanning: {target.resolve()}", Fore.CYAN))
+    if args.verbose:
+        print()
+
+    findings = scan_path(str(target), verbose=args.verbose)
+
+    total_files = _count_files(str(target))
+
+    _print_findings(findings)
+
+    report_path: str | None = None
+    if args.output and findings:
+        os.makedirs("output", exist_ok=True)
+        if args.output == "json":
+            report_path = os.path.join("output", "report.json")
+            export_json(findings, report_path)
+        elif args.output == "csv":
+            report_path = os.path.join("output", "report.csv")
+            export_csv(findings, report_path)
+
+    _print_summary(total_files, findings, report_path)
+
+    # Exit code 1 when secrets found (useful for CI pipelines)
+    return 1 if findings else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

secret_scanner_cl-1.0.0/src/secret_scanner/scanner/file_scanner.py

@@ -0,0 +1,127 @@
+"""
+file_scanner.py – Recursive file scanner that applies PATTERNS to every
+                  readable text file found under a given path.
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import List, Dict, Any
+
+from scanner.patterns import PATTERNS
+
+# ── Constants ──────────────────────────────────────────────────────────────
+BINARY_EXTENSIONS: set[str] = {
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".tiff",
+    ".exe", ".dll", ".so", ".dylib",
+    ".zip", ".tar", ".gz", ".bz2", ".rar", ".7z",
+    ".pdf", ".docx", ".xlsx", ".pptx",
+    ".pyc", ".pyo",
+}
+
+IGNORED_DIRS: set[str] = {
+    ".git", "__pycache__", "node_modules", "output",
+    ".venv", "venv", ".tox", "dist", "build", ".mypy_cache",
+}
+
+
+def _mask_secret(text: str) -> str:
+    """Return the line with the middle portion of each token replaced by ***."""
+    # Mask every word longer than 6 chars that looks like a secret value
+    def _replace(m: re.Match) -> str:
+        s = m.group(0)
+        if len(s) <= 6:
+            return s
+        keep = max(3, len(s) // 5)
+        return s[:keep] + "***" + s[-keep:]
+
+    return re.sub(r"[A-Za-z0-9\+/=_\-]{7,}", _replace, text)
+
+
+def _is_text_file(filepath: Path) -> bool:
+    """Return True if the file is likely a text file."""
+    if filepath.suffix.lower() in BINARY_EXTENSIONS:
+        return False
+    try:
+        with open(filepath, "rb") as fh:
+            chunk = fh.read(1024)
+        # If the chunk contains a null byte it is almost certainly binary
+        return b"\x00" not in chunk
+    except OSError:
+        return False
+
+
+def scan_path(path: str, verbose: bool = False) -> List[Dict[str, Any]]:
+    """
+    Recursively scan *path* for secrets.
+
+    Parameters
+    ----------
+    path : str
+        Directory or single file to scan.
+    verbose : bool
+        When True, print the name of each file as it is processed.
+
+    Returns
+    -------
+    list of dict
+        Each dict contains:
+            type     – pattern name (str)
+            severity – "HIGH" | "MEDIUM" | "LOW"
+            file     – relative (or absolute) path to the file (str)
+            line     – 1-based line number (int)
+            content  – masked line content (str)
+    """
+    findings: List[Dict[str, Any]] = []
+    root = Path(path).resolve()
+
+    # Build the list of files to inspect
+    if root.is_file():
+        files_to_scan = [root]
+    else:
+        files_to_scan = _walk_directory(root)
+
+    for filepath in files_to_scan:
+        if not _is_text_file(filepath):
+            continue
+
+        if verbose:
+            print(f"  [scanning] {filepath}")
+
+        _scan_file(filepath, findings)
+
+    return findings
+
+
+def _walk_directory(root: Path) -> List[Path]:
+    """Walk *root* skipping ignored directories and return all file paths."""
+    result: List[Path] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        # Prune ignored directories in-place so os.walk won't descend into them
+        dirnames[:] = [
+            d for d in dirnames if d not in IGNORED_DIRS
+        ]
+        for filename in filenames:
+            result.append(Path(dirpath) / filename)
+    return result
+
+
+def _scan_file(filepath: Path, findings: List[Dict[str, Any]]) -> None:
+    """Read *filepath* line-by-line and append any matches to *findings*."""
+    try:
+        with open(filepath, "r", encoding="utf-8", errors="replace") as fh:
+            for lineno, line in enumerate(fh, start=1):
+                for pat in PATTERNS:
+                    if pat["pattern"].search(line):
+                        findings.append(
+                            {
+                                "type": pat["name"],
+                                "severity": pat["severity"],
+                                "file": str(filepath),
+                                "line": lineno,
+                                "content": _mask_secret(line.rstrip()),
+                            }
+                        )
+    except OSError:
+        # Skip files we cannot open (permission errors, etc.)
+        pass