feat: Add secret detection workflows and comprehensive benchmarking (#15)

Add three production-ready secret detection workflows with full benchmarking infrastructure:

**New Workflows:**
- gitleaks_detection: Pattern-based secret scanning (13/32 benchmark secrets)
- trufflehog_detection: Entropy-based detection with verification (1/32 benchmark secrets)
- llm_secret_detection: AI-powered semantic analysis (32/32 benchmark secrets - 100% recall)

**Benchmarking Infrastructure:**
- Ground truth dataset with 32 documented secrets (12 Easy, 10 Medium, 10 Hard)
- Automated comparison tools for precision/recall testing
- SARIF output format for all workflows
- Performance metrics and tool comparison reports

**Fixes:**
- Set gitleaks default to no_git=True for uploaded directories
- Update documentation with correct secret counts and workflow names
- Temporarily deactivate AI agent command
- Clean up deprecated test files and GitGuardian workflow

**Testing:**
All workflows verified on secret_detection_benchmark and vulnerable_app test projects.
Workers healthy and system fully functional.
This commit is contained in:
tduhamel42
2025-10-16 11:21:24 +02:00
committed by GitHub
parent c3ce03e216
commit 2da986ebb0
28 changed files with 2505 additions and 648 deletions
@@ -0,0 +1,13 @@
"""
TruffleHog Detection Workflow
"""
# Copyright (c) 2025 FuzzingLabs
#
# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
# at the root of this repository for details.
from .workflow import TrufflehogDetectionWorkflow
from .activities import scan_with_trufflehog, trufflehog_generate_sarif
__all__ = ["TrufflehogDetectionWorkflow", "scan_with_trufflehog", "trufflehog_generate_sarif"]
@@ -0,0 +1,111 @@
"""TruffleHog Detection Workflow Activities"""
import logging
from pathlib import Path
from typing import Dict, Any
from temporalio import activity
try:
from toolbox.modules.secret_detection.trufflehog import TruffleHogModule
except ImportError:
from modules.secret_detection.trufflehog import TruffleHogModule
@activity.defn(name="scan_with_trufflehog")
async def scan_with_trufflehog(target_path: str, config: Dict[str, Any]) -> Dict[str, Any]:
"""Scan code using TruffleHog."""
activity.logger.info(f"Starting TruffleHog scan: {target_path}")
workspace = Path(target_path)
trufflehog = TruffleHogModule()
trufflehog.validate_config(config)
result = await trufflehog.execute(config, workspace)
if result.status == "failed":
raise RuntimeError(f"TruffleHog scan failed: {result.error}")
findings_dicts = [finding.model_dump() for finding in result.findings]
return {"findings": findings_dicts, "summary": result.summary}
@activity.defn(name="trufflehog_generate_sarif")
async def trufflehog_generate_sarif(findings: list, metadata: Dict[str, Any]) -> Dict[str, Any]:
"""
Generate SARIF report from TruffleHog findings.
Args:
findings: List of finding dictionaries
metadata: Metadata including tool_name, tool_version
Returns:
SARIF report dictionary
"""
activity.logger.info(f"Generating SARIF report from {len(findings)} findings")
# Basic SARIF 2.1.0 structure
sarif_report = {
"version": "2.1.0",
"$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
"runs": [
{
"tool": {
"driver": {
"name": metadata.get("tool_name", "trufflehog"),
"version": metadata.get("tool_version", "3.63.2"),
"informationUri": "https://github.com/trufflesecurity/trufflehog"
}
},
"results": []
}
]
}
# Convert findings to SARIF results
for finding in findings:
sarif_result = {
"ruleId": finding.get("metadata", {}).get("detector", "unknown"),
"level": _severity_to_sarif_level(finding.get("severity", "warning")),
"message": {
"text": finding.get("title", "Secret detected")
},
"locations": []
}
# Add description if present
if finding.get("description"):
sarif_result["message"]["markdown"] = finding["description"]
# Add location if file path is present
if finding.get("file_path"):
location = {
"physicalLocation": {
"artifactLocation": {
"uri": finding["file_path"]
}
}
}
# Add region if line number is present
if finding.get("line_start"):
location["physicalLocation"]["region"] = {
"startLine": finding["line_start"]
}
sarif_result["locations"].append(location)
sarif_report["runs"][0]["results"].append(sarif_result)
activity.logger.info(f"Generated SARIF report with {len(sarif_report['runs'][0]['results'])} results")
return sarif_report
def _severity_to_sarif_level(severity: str) -> str:
"""Convert severity to SARIF level"""
severity_map = {
"critical": "error",
"high": "error",
"medium": "warning",
"low": "note",
"info": "note"
}
return severity_map.get(severity.lower(), "warning")
@@ -0,0 +1,34 @@
name: trufflehog_detection
version: "1.0.0"
vertical: secrets
description: "Detect secrets with verification using TruffleHog"
author: "FuzzForge Team"
tags:
- "secrets"
- "trufflehog"
- "verification"
workspace_isolation: "shared"
parameters:
type: object
properties:
verify:
type: boolean
default: true
description: "Verify discovered secrets"
max_depth:
type: integer
default: 10
description: "Maximum directory depth to scan"
default_parameters:
verify: true
max_depth: 10
required_modules:
- "trufflehog"
supported_volume_modes:
- "ro"
@@ -0,0 +1,104 @@
"""TruffleHog Detection Workflow"""
from datetime import timedelta
from typing import Dict, Any
from temporalio import workflow
from temporalio.common import RetryPolicy
@workflow.defn
class TrufflehogDetectionWorkflow:
"""Scan code for secrets using TruffleHog."""
@workflow.run
async def run(self, target_id: str, verify: bool = False, concurrency: int = 10) -> Dict[str, Any]:
workflow_id = workflow.info().workflow_id
run_id = workflow.info().run_id
workflow.logger.info(
f"Starting TrufflehogDetectionWorkflow "
f"(workflow_id={workflow_id}, target_id={target_id}, verify={verify})"
)
results = {"workflow_id": workflow_id, "status": "running", "findings": []}
try:
# Step 1: Download target
workflow.logger.info("Step 1: Downloading target from MinIO")
target_path = await workflow.execute_activity(
"get_target", args=[target_id, run_id, "shared"],
start_to_close_timeout=timedelta(minutes=5),
retry_policy=RetryPolicy(
initial_interval=timedelta(seconds=1),
maximum_interval=timedelta(seconds=30),
maximum_attempts=3
)
)
workflow.logger.info(f"✓ Target downloaded to: {target_path}")
# Step 2: Scan with TruffleHog
workflow.logger.info("Step 2: Scanning with TruffleHog")
scan_results = await workflow.execute_activity(
"scan_with_trufflehog",
args=[target_path, {"verify": verify, "concurrency": concurrency}],
start_to_close_timeout=timedelta(minutes=15),
retry_policy=RetryPolicy(
initial_interval=timedelta(seconds=2),
maximum_interval=timedelta(seconds=60),
maximum_attempts=2
)
)
workflow.logger.info(
f"✓ TruffleHog scan completed: "
f"{scan_results.get('summary', {}).get('total_secrets', 0)} secrets found"
)
# Step 3: Generate SARIF report
workflow.logger.info("Step 3: Generating SARIF report")
sarif_report = await workflow.execute_activity(
"trufflehog_generate_sarif",
args=[scan_results.get("findings", []), {"tool_name": "trufflehog", "tool_version": "3.63.2"}],
start_to_close_timeout=timedelta(minutes=2)
)
# Step 4: Upload results to MinIO
workflow.logger.info("Step 4: Uploading results")
try:
results_url = await workflow.execute_activity(
"upload_results",
args=[workflow_id, scan_results, "json"],
start_to_close_timeout=timedelta(minutes=2)
)
results["results_url"] = results_url
workflow.logger.info(f"✓ Results uploaded to: {results_url}")
except Exception as e:
workflow.logger.warning(f"Failed to upload results: {e}")
results["results_url"] = None
# Step 5: Cleanup
workflow.logger.info("Step 5: Cleaning up cache")
try:
await workflow.execute_activity(
"cleanup_cache", args=[target_path, "shared"],
start_to_close_timeout=timedelta(minutes=1)
)
workflow.logger.info("✓ Cache cleaned up")
except Exception as e:
workflow.logger.warning(f"Cache cleanup failed: {e}")
# Mark workflow as successful
results["status"] = "success"
results["findings"] = scan_results.get("findings", [])
results["summary"] = scan_results.get("summary", {})
results["sarif"] = sarif_report or {}
workflow.logger.info(
f"✓ Workflow completed successfully: {workflow_id} "
f"({results['summary'].get('total_secrets', 0)} secrets found)"
)
return results
except Exception as e:
workflow.logger.error(f"Workflow failed: {e}")
results["status"] = "error"
results["error"] = str(e)
raise