Pre-Push Security for AI-Era Development

Your Team Writes Code With AI. Do You Know What's Actually In It?

"Your AI coding assistant has seen your database schema, your API keys, and your internal service URLs. Do you know who else has?"

38+ modules. Results in minutes. Code never leaves the machine. No CI/CD required - developer runs the plugin, AppSec sees findings in the dashboard.

Request a Demo Start Free Tier

Download CLI (.tar.gz)Download VSIX

DevGuard Demo

How to Use DevGuard

DevGuard - Business Logic

DevGuard - Credential Flow

Developer runs DevGuard locally

The CLI or IDE plugin starts a full local project security analysis.

Local secure telemetry collection

DevGuard collects only required security telemetry - no source code and no raw secrets are sent.

Pentesterra cloud analysis

Pentesterra correlates risks, analyzes dependencies and AI toolchains, and builds an actionable security score.

Results everywhere

Results are available across CLI, VS Code/Cursor/Windsurf plugins, and the Pentesterra Web Portal.

No source code uploadedNo secrets transmittedRead-only - never modifiesKeys masked locallyNo Anthropic / OpenAI keys neededRuns inside venvCredentials never verified or usedAuditable via --dry-run

Read-only - nothing is ever modified

DevGuard reads your project files and installed packages to surface risks. It never writes, patches, or modifies any file - not in your project, not in your environment, not in your installed packages.

Finds every signal across your project

Secrets, CVEs, misconfigurations, AI toolchain risks, business logic flaws, credential flows - every signal across your entire project in one scan. Not just the files you point it at.

Credentials are never verified or used

When DevGuard finds a key, password, or database URI, it does not verify it, does not connect anywhere, and does not use it in any way. It only tells you where the credential appears in your code and who could potentially reach it.

No Anthropic or OpenAI keys required

DevGuard does not require your own Anthropic or OpenAI API keys. All LLM-assisted analysis runs on Pentesterra infrastructure. Your AI credentials stay in your hands.

Runs inside your Python venv

Install and run the DevGuard CLI directly from within any Python virtual environment. No global installation, no dependency conflicts, no changes to your system Python or OS environment.

The client is fully transparent and can be reviewed by your security team. Use --dry-run to inspect the exact telemetry payload before anything is uploaded.

The Reality

AI-generated code ships with vulnerable dependencies
Hardcoded secrets reach remote repositories
Malicious packages enter supply chains through typosquats
MCP and AI IDE tools introduce novel attack vectors
Crypto misconfigurations bypass standard reviews
Peer dependency conflicts cause silent runtime crashes
Deprecated APIs in packages break on framework upgrades
LLM gateway keys exposed in agent configuration files
PHP and CMS platforms deployed with insecure defaults
Business logic flaws go undetected until exploitation
Malicious packages persist via .pth hooks, stealing cloud credentials on every Python start
GitHub projects silently exfiltrate your LLM API keys via custom SDK proxy (base_url redirect)
External services accumulate invisibly - forgotten Firebase without auth, n8n without encryption, unencrypted DB connections
A developer using SVN or Mercurial has no pre-commit protection - git hooks do nothing for them
A leaked token gets rotated, but nobody checks if it was already used or what it could access
Credentials typed into the terminal during debugging quietly persist in shell history and dotfiles repos

With DevGuard

Every dependency mapped to CVE/KEV before push
Secrets detected and masked - never transmitted
Known malicious packages blocked at development stage
AI toolchain configurations validated against threat intel
LLM-assisted crypto analysis with compliance mapping
Peer dependency conflicts flagged with semver analysis
Deprecated APIs detected across all npm dependencies
LLM gateway keys and insecure agentic patterns surfaced
Go, PHP, and CMS misconfigurations caught before deploy
Logic vulnerabilities detected from structural metadata alone
Python .pth execution hooks and credential harvesting in installed packages detected before push
Credential exfiltration via SDK proxy redirect, HTTP calls, and subprocess detected pre-push
Full service dependency map shows every external connection, protocol, TLS status, and risk
SVN, Mercurial, and any VCS protected - one shell hook covers every commit command on the machine
Leaked token? Know in seconds if it is still active and exactly what damage it can cause
Shell history and commit messages scanned - credentials found wherever they hide

Malicious vector installed - silently

VS Code extensionMCP servernpm / pip packagetyposquatted libraryAI SDK with proxy redirect

Developer installs from a marketplace, a GitHub repo, or a colleague's recommendation. No obvious red flags. The package has legitimate functionality - and a malicious payload bundled alongside it.

Reads the developer's environment

.envAPI keys, DB passwords, service tokens

~/.aws/credentialsCloud access keys with full account scope

~/.npmrc · ~/.netrcRegistry tokens, GitHub PATs

IDE settings · MCP configLLM API keys, workspace secrets

shell historyPasswords typed in terminal, curl tokens

postinstall scriptsRuns at npm install - before anyone reviews

Exfiltrates silently - no alert

HTTP POST to attacker serverSDK base_url redirectDNS exfiltrationsubprocess spawn.pth hook on Python start

Data leaves the machine in the background. Corporate VPN sees normal developer traffic. No AV alert. No EDR event. No SIEM log. The security team doesn't know this machine exists - it's a personal laptop on a home network.

Attacker owns what the developer had access to

AWS / GCP / Azure accountProduction databaseCI/CD pipelineGitHub / GitLab reposStripe / payment processorLLM API billing

DevGuard detects this chain

IDE extensions & MCP serversFilesystem access scope, unknown sources, permissions beyond stated purpose
npm / pip install hookspostinstall / preinstall scripts that read env vars or spawn network processes
Packages reading credentialsModules accessing .aws, .env, .netrc, credential stores, or shell history
Exfiltration patternsHTTP calls from install scripts, SDK proxy redirects (base_url), subprocess spawns, DNS encoding
Python .pth execution hooksPackages that persist credential harvesting across every Python interpreter start
Token liveness checkFound a leaked token? DevGuard tells you if it's still active and what it can access right now

Works on the developer's machine - before the secret leaves. Remote worker, startup laptop, contractor machine. No corporate perimeter required.

Install & Run - Your Way

Install the VS Code, Cursor, or Windsurf plugin, or run pentesterra-devguard scan from the terminal. No CI/CD required, no code changes, no mandatory pipeline steps. For teams that need centralized enforcement, an admin can deploy a server-side VCS hook that protects all committers without requiring individual installs.

Local Collection - Nothing Sensitive Leaves

A thin local collector inventories dependencies, secrets, configurations, IDE extensions, AI toolchains, and credential surfaces. Tokens are truncated before transmission. Source code is never uploaded. Only redacted metadata reaches the cloud.

Results Everywhere - Including AppSec Dashboard

Findings appear in CLI, IDE sidebar, and the Pentesterra web console. AppSec, compliance officers, and client contacts see full risk data and findings in the dashboard - without requiring access to source code or developer machines. 0-trust by design.

AI-Era Surface

Malicious MCP server configs. IDE extensions with excessive permissions. AI agent frameworks with unsafe tool exposure. LLM output piped to exec(). Packages routing your API calls through an attacker-controlled proxy. This surface didn't exist 3 years ago - no existing tool was designed to scan it.

Secret Liveness + Blast Radius

Found a token? DevGuard checks if it still responds - locally, value never leaves the machine. Blast radius mapped: which repos are accessible, whether CI pipelines can be triggered, what customer data is at risk. Most tools stop at "secret found." DevGuard tells you what to do about it.

Business Process Mapping

From package names, ORM models, route decorators, and env variable names - without transmitting source code - DevGuard identifies your app's business processes and regulatory scope. A leaked Stripe key becomes a PCI DSS incident in your payment flow, not a generic credential exposure.

0-Trust AppSec Visibility

Code stays on the developer's machine. AppSec, compliance, and clients see full findings in the Pentesterra dashboard - no code access, no repo permissions, no developer workflow changes required.

Supply Chain & Dependency Analysis

15 lockfile parsers across npm, PyPI, Go, Rust, Ruby, PHP, Java, .NET, Swift, and Dart. Every dependency mapped against CVE, KEV, and exploit availability databases.

Secrets & Credential Detection

Pattern-based detection for AWS keys, OAuth tokens, JWT secrets, private keys, database credentials, and more. Privacy-first: only metadata and masked fingerprints are transmitted.

AI Toolchain & MCP Risk

Detects malicious MCP server configurations, suspicious AI IDE plugin patterns, and known exfiltration vectors across Cursor, Windsurf, VS Code, JetBrains, and more.

Known Malicious Packages

Cross-referenced against a curated database of 50+ confirmed malicious packages - supply chain attacks, protestware, typosquats, and dependency confusion vectors.

Cloud & Credential Surface

Inspects AWS, GCP, Azure, Terraform, and Kubernetes configurations. Detects SSH key exposure, Docker registry auth tokens, and OS credential stores across platforms.

Crypto & TLS Weakness Analysis

Detects deprecated TLS/SSL versions, weak ciphers, broken hash algorithms, insecure key sizes, and deprecated crypto libraries. LLM-powered contextual analysis reduces false positives.

Peer Dependency Conflicts

Parses peerDependencies from every installed npm package and validates against actual versions. Catches React 19 incompatibilities, missing required peers, and major version mismatches before they cause runtime crashes.

Deprecated API Detection

Scans dependency entry points for removed React 19 lifecycle methods (UNSAFE_componentWillMount), legacy ReactDOM.render, deprecated Node.js Buffer constructors, and obsolete built-in modules - before they break in production.

NEW

Business Process Detection

Automatically identifies business processes from structural metadata - package names, directory paths, env vars, ORM class names, OpenAPI paths. No source code transmitted. Outputs BP-IDs (BP-PAY-001, BP-AUTH-001...) with regulatory scope mapping (PCI-DSS, GDPR, HIPAA, SOX).

NEW

Logic Risk Detection

Detects 7 classes of application logic vulnerabilities: Missing Authorization, IDOR, Bypassable Workflow, Unverified State Transitions, Privileged Op Exposed, Race Conditions, Mass Assignment. Composite risk scoring 0–10.

Endpoint & Auth Map

Extracts HTTP routes with authentication/authorization status from FastAPI, Flask, Django, Express, NestJS, Next.js, Rails, Spring. Identifies unprotected sensitive endpoints without transmitting source code.

Data Asset Classification

Field-level ORM model extraction across 10+ ORMs (SQLAlchemy, Django, Prisma, TypeORM, Sequelize, Mongoose, GORM, ActiveRecord). Classifies data assets: financial, identity, PII, health, credential. Maps regulatory scope automatically.

Business Impact Report

9-section structured report linking attack vectors to business processes. Executive summary, compliance impact (PCI-DSS/GDPR/HIPAA/SOX), prioritized remediation plan sorted by severity and effort. Integrates with Pentesterra attack chain analysis.

NEW

SAST Lite - Static Analysis

Regex-based static analysis across Python and JavaScript/TypeScript source files. Detects SQL injection, XSS, command injection, SSRF, insecure deserialization, prototype pollution, and prompt injection. Privacy-first: only file path, line number, and a short snippet hash are transmitted - no source code sent.

NEW

Automation Platform Risk

Detects insecure configurations in n8n, Zapier, Make, and IFTTT workflows. Identifies dangerous execution nodes (Execute Command, Code Node), missing authentication on webhook triggers, unencrypted workflow storage, and CVE-mapped versions of automation platforms.

NEW

AI Agent Configuration Risk

Scans agent frameworks for dangerous tool exposure (ShellTool, BashTool, PythonREPLTool), unsafe prompt construction patterns, persistent memory storage risks, and unvalidated input flows in Python, TypeScript, and YAML agent definitions.

NEW

Vector DB Exposure

Identifies exposed vector database credentials and unauthenticated endpoints. Detects API keys for Pinecone, Weaviate, Qdrant, and OpenSearch in source files and environment configs. Flags Docker Compose services exposing ChromaDB, Qdrant, and Weaviate without authentication.

NEW

IDE Plugin Threat Intelligence

Cross-references your installed VS Code, Cursor, Windsurf, JetBrains, and Zed extensions against a threat intelligence database of malicious and typosquatted extensions. Detects AI agent plugins with excessive permissions and extensions reported in security advisories.

NEW

Go Security

Detects Go-specific security issues: InsecureSkipVerify in TLS configs, pprof profiler endpoints exposed without auth, math/rand used for security operations, SQL injection via fmt.Sprintf, HTTP servers without TLS. Full route enumeration for Gin, Echo, Chi, Fiber, and net/http.

NEW

PHP & CMS Security

Analyzes PHP.ini settings, Laravel .env files, and dangerous function usage (eval, exec, shell_exec, unserialize with user input). CMS coverage: WordPress plugin inventory, debug mode, xmlrpc.php exposure; Drupal, Joomla, Magento 2, and PrestaShop configuration risks.

NEW

LLM Integration & Prompt Injection Risk

Detects LLM gateway API key exposure (LiteLLM, OpenRouter, Portkey, Helicone), insecure agentic loops (while-true + LLM call without guards), LLM output piped to exec/subprocess (RCE chain), missing guardrails library, and multi-agent trust boundary violations where agent output is used as trusted tool input.

NEW

Python Runtime Execution Hook Detection

Detects supply-chain persistence and credential harvesting in installed Python packages - the class of attack used in litellm 1.82.8. Three layers: (1) .pth files with executable code in site-packages auto-executed at every Python startup; (2) installed packages reading cloud credential env vars (AWS, GCP, Azure, GitHub, OpenAI) combined with outbound network calls in the same file; (3) subprocess/os.system at module level in __init__.py. Cross-references with .env to confirm active attack surface.

NEW

Service Dependency Map

Maps every external service your project connects to: databases, LLMs, queues, object storage, auth providers, monitoring, and automation platforms. Extracted from connection strings, SDK imports, Docker Compose, and config files. Surfaces unencrypted connections, hardcoded credentials in URIs, unauthenticated endpoints, and forgotten services - like Firebase without auth or n8n without an encryption key left from the MVP phase. Available on the free tier in CLI output, IDE plugin sidebar, and web console.

NEW

Credential Flow Analysis

Traces how detected API keys and secrets are actually used in code - and whether they are being exfiltrated. Catches the most dangerous supply-chain attack: a GitHub project that works correctly but routes all LLM SDK calls through an attacker-controlled proxy via a custom base_url, silently collecting your key and every prompt. Also detects credential variables near HTTP calls to unexpected domains, subprocess curl exfiltration, credentials forwarded via webhooks, MCP servers configured with credential env vars, base64-encoded exfiltration, credentials in log statements, and secrets passed to unverified GitHub Actions.

NEW

API Route Security Analysis

Full API endpoint inventory with authentication coverage analysis across Flask, FastAPI, Django, Express, NestJS, Gin, Echo, and Chi. Detects unprotected routes, auth regressions, and missing authorization. Includes BOLA/IDOR surface detection (OWASP API Top 10 #1) - identifies authenticated endpoints that accept resource IDs without apparent ownership verification. Pre-push route diff blocks commits that introduce unprotected critical endpoints or remove authentication from existing routes.

NEW

GraphQL Security Analysis

Detects GraphQL APIs across SDL schema files, Graphene, Strawberry, Apollo, and Nexus codebases. Identifies unauthenticated mutations and sensitive queries, missing authorization decorators on resolvers, and introspection endpoints left open in production. Tracks auth coverage per operation type (query / mutation / subscription) without transmitting any source code.

NEW

Multi-VCS Secrets Protection

DevGuard now protects every developer, not just those using git. Install once and secrets are blocked before any commit - whether you use SVN, Mercurial, Perforce, or any other version control system. A single shell-level hook intercepts all VCS commit commands. Server administrators can generate a ready-to-install SVN server hook that protects all committers without requiring them to install anything.

NEW

Token Liveness & Blast Radius

When DevGuard finds a leaked secret, you now get two answers that matter most: is it still active, and what can an attacker do with it? A local check against the provider's API tells you if the token works right now - the value never leaves your machine. If it's still active, blast radius analysis shows the exact damage: which repositories are exposed, whether CI pipelines can be triggered, whether webhooks can be modified, and what customer data is at risk. Supported for GitHub, GitLab, Stripe, OpenAI, Anthropic, HuggingFace, and SendGrid.

NEW

Shell History & Commit Message Scanning

Credentials do not only appear in source files. DevGuard now scans terminal history files - the places where API keys often end up after a debugging session and can be silently synced via dotfiles repositories. Commit messages are scanned too: tokens typed directly into SVN or git commit commands are caught before they reach the server. Use scan-string to check any text for secrets, including clipboard content or piped command output.

NEW

SVN History Scan & Exposure Window

Rotating a token removes it from your working copy - it does not remove it from SVN revision history. Anyone with read access can check out any past revision and read the key. DevGuard scans all revisions and reports: which revision a secret first appeared in, whether it was ever deleted, and exactly how many hours it was exposed. No other tool on the market does this for SVN.

NEW

SVN → Git Migration Pre-Check

When you import an SVN repository into GitHub, the full commit history comes with it - including every secret in every old revision. GitHub Code Search indexes that history within hours. Run devguard migration-check before you push and get a full remediation list of which files and revisions need to be cleaned so the migration does not become a public credential leak.

NEW

Entropy-Based False Positive Filter

Regex patterns alone generate noise. DevGuard now runs Shannon entropy analysis on every candidate match as a second filter: short passwords, test values, and placeholder strings are silently skipped. Only high-entropy, high-confidence matches produce a finding. Result: roughly 60% fewer false alarms in typical codebases - teams that disabled secrets scanning because of noise can turn it back on.

38 Scan Modules

15 lockfile parsers (npm, pip, Go, Rust, Ruby, PHP, Maven, NuGet, Swift, Dart), SAST Lite, Go & PHP & CMS security, LLM integration risk, AI agent configs, vector DB exposure, automation platform risk, service dependency map, credential flow analysis, crypto weakness analysis, multi-VCS protection, token liveness checks, and shell history scanning - all in one unified scan.

9 IDE Families

VS Code, Cursor, Windsurf, JetBrains family, Zed, Neovim, Claude Code, Continue.dev, Cline - extension inventory with version tracking and advisory matching.

40+ Framework Signatures

WordPress, Django, Laravel, Next.js, Rails, Angular, React, Vue, Express, Flask, Spring - automatic detection with version CVE correlation.

Advisory Intelligence

Continuous feed from GitHub Advisory Database, OSV.dev, and VS Code Marketplace - enriched with LLM-classified security news from 6 industry sources.

Thin Agent. Powerful Cloud Engine.

DevGuard follows a strict thin-agent philosophy. The local CLI performs only data collection and privacy redaction. All intelligence - CVE mapping, advisory correlation, LLM analysis, risk scoring - runs in Pentesterra's controlled cloud infrastructure.

No intellectual property leaves your machine unredacted
Secret values are never transmitted - only type, path, and masked fingerprint
Payload inspection available via --dry-run before any data is sent
3-pass analysis engine: CPE lookup, advisory matching, LLM contextual fallback
Re-analysis on new CVE data without rescanning
API key authentication with bcrypt hashing and prefix-based resolution

Privacy-First

No source code upload. Only metadata and redacted findings leave the developer machine.

IDE-Native

VS Code, Cursor, Windsurf extensions. Zero-setup: auto-installs CLI on first use, auto-updates, sidebar integration, scan-on-push hooks, and inline results.

Re-Analysis

When new CVEs are published, previously scanned projects are automatically re-evaluated - no rescan needed.

Pre-Push Gate

Git hook blocks push on critical findings. Configurable thresholds. CI/CD mode with exit codes.

Any VCS

Works with SVN, Mercurial, Perforce, and any other version control system - not only git. A single shell hook covers every commit command on the machine.

Liveness Check

When a secret is found, DevGuard tells you whether it is still active and what an attacker can do with it - all checked locally, the value never leaves your machine.

Capability	Pentesterra DevGuard	GitHub Advanced Security	Snyk / SCA Tools	IDE Security Plugins
Pre-push local project analysis	✓	✕	✕	partial
Dependency vulnerability detection	✓	✓	✓	partial
Malicious package detection	✓	✕	partial	✕
Secrets detection before commit	✓	partial	partial	partial
Source code sent to cloud	✕	partial	partial	partial
IDE extensions security audit	✓	✕	✕	✕
AI / MCP toolchain analysis	✓	✕	✕	✕
Development environment security checks	✓	✕	partial	✕
Automatic risk re-analysis for new CVEs	✓	partial	partial	✕
Independent of Git hosting platform	✓	✕	partial	✓
SAST without source code upload	✓	✕	✕	partial
Go / PHP / CMS platform security checks	✓	✕	partial	✕
LLM integration & prompt injection risks	✓	✕	✕	✕
Business logic vulnerability detection	✓	✕	✕	✕
Python .pth execution hook & installed package credential harvesting	✓	✕	✕	✕
Credential flow analysis - proxy redirect, exfiltration, MCP exposure	✓	✕	✕	✕
Service dependency map - all external connections with TLS & protocol risk	✓	✕	partial	✕
SVN, Mercurial, and non-git VCS secrets protection	✓	✕	✕	✕
Token liveness check - is the leaked key still active?	✓	✕	✕	✕
Blast radius analysis - what can an attacker access with this key?	✓	✕	✕	✕
Shell history scanning for accidentally typed credentials	✓	✕	✕	✕
Commit message scanning for embedded secrets	✓	partial	✕	✕
SVN repository history scan - secrets that survived rotation	✓	✕	✕	✕
SVN → Git migration pre-check before public indexing	✓	✕	✕	✕
Entropy scoring to eliminate false positives (~60% reduction)	✓	✕	partial	partial

CLI vs IDE Extension: What's the Difference?

The CLI is the core tool. It performs all security analysis and runs standalone in any terminal or CI/CD pipeline.

The IDE extension is zero-setup. On first use it automatically downloads and installs the CLI - no separate pip install required. It adds visual sidebar panels, scan-on-push file watchers, and inline results, and auto-updates itself (from Marketplace or our site). Choose CLI for terminal and CI/CD workflows; choose the extension for IDE integration with automatic updates.

CLI

Command Line

pip install, single-command scan. Supports --ci mode with configurable exit codes for pipeline integration. Local reports, dry-run inspection, and branch-aware scanning.

IDE

VS Code / Cursor / Windsurf

Native extension with sidebar panels. Auto-installs CLI on first use. Auto-updates from Marketplace or our site. Scan-on-push watcher and one-click pre-push hook installation.

WEB

Web Console

Full dashboard with project overview, scan history, findings grouped by risk category, severity trends, and API key management. Part of the Pentesterra platform.

Pre-Push Security Gate

DevGuard installs a git pre-push hook that runs a full security scan before code leaves your machine. Configurable severity thresholds - block on critical, high, or medium findings. CI/CD mode returns structured exit codes for pipeline enforcement. Bypass available with git push --no-verify when needed.

Block on critical findingsConfigurable thresholdsCI/CD exit codesBranch-aware scanning

AI-Era Developers

Cursor · Windsurf · Copilot · Cloud IDE

AI generates code fast - DevGuard validates its security posture before commit. MCP configurations, AI extensions, and generated dependencies all covered.

Startups & Small Teams

Developers without dedicated security

Free tier available. Zero infrastructure overhead. pip install and scan - enterprise-grade security intelligence without enterprise complexity.

DevSecOps & Security Teams

Security Engineers · AppSec · Platform Teams

Enforce pre-push policies, track supply chain risk across projects, and feed findings into the full Pentesterra vulnerability management pipeline.

DevGuard

Pre-push security audit. Supply chain, secrets, AI toolchain, and crypto risk - caught before code leaves the developer machine.

Web & API Pentest

Authenticated and unauthenticated testing of deployed applications. Evidence-based exploit validation with verification workflows.

Full-Cycle Platform

Network assessment, attack chain analysis, compliance mapping, and continuous verification - one platform covering the entire security lifecycle.

Tier 2 · Vibe Coding Pro - Extended Dev Security

Attack Chain Analysis

DevGuard findings feed directly into Pentesterra's Attack Chain engine. The platform correlates supply chain risks, exposed secrets, misconfigured containers, and vulnerable runtimes with network and web pentest data to compute realistic multi-step attack paths - showing exactly how an attacker could pivot from a compromised dependency to full infrastructure access.

Works with DevGuard data onlyChains across web + network + supply chainScored & prioritized attack pathsBusiness impact & compliance mapping

The output is a ranked list of attack chains with severity scores, affected assets, compliance gaps, and an AI-generated executive narrative - giving security teams and management a clear picture of exploitability before a real attacker finds it.

AI-Driven Development

Projects built with Cursor, Copilot, or other AI tools need fast security feedback before deployment.

Startup Teams

Fast-moving teams can run security checks without maintaining a full DevSecOps pipeline.

Internal Development Environments

DevGuard helps secure internal services and development infrastructure.

Real customer case

The Stripe key that was hiding in the logs

A payment service integration had been logging raw HTTP request objects for debugging. Inside those objects: a live Stripe secret key - sk_live_… - quietly written to application logs on every checkout request.

The logs were forwarded to a third-party monitoring platform. Over months, the key had been indexed, stored in retention, and was accessible to anyone with read access to the monitoring dashboard - including contractors and vendor support accounts.

No scanner found it. No SAST rule flagged it. No one in the team knew it was there.

DevGuard detected the pattern during a pre-push scan - not from the log file itself, but from the logging call in source code: logger.info(request) on an object that included payment provider credentials in its serialised form. The finding was marked Secret Exposure via logging path and surfaced before the next deployment.

DevGuard · Finding

CRITICALSecret Exposure via logging path

src/payments/checkout.py · line 84

# Triggered finding:
logger.info("Checkout request: %s", request)

# request object includes:
{
  "stripe_key": "sk_live_4xR...",
  "amount": 4900,
  "customer_id": "cus_..."
}

DestinationApplication log → monitoring platform

Key typeStripe live secret key (sk_live_…)

ExposureLog retention + 3rd-party read access

Detected byDevGuard · logging path analysis

Revoke key · sanitize logging · rotate credentials

AWS credentials pushed to git - silent S3 exfiltration for weeks

What happens

Developer hard-codes AWS Access Key and Secret Key in a .env or config file and pushes to GitHub - even to a private repo. Attackers scan GitHub continuously for high-entropy strings. Key is found within minutes. S3 buckets enumerated, data exfiltrated silently. Confirmed pattern in Toyota (2023), Samsung, and dozens of smaller incidents every month.

Why it's too late after push

Deleting the file from git doesn't remove it from history. Secret scanners on GitHub catch it after the push - but git history is permanent. Rotating the key is the only fix. If the breach started before rotation, you may never know what was accessed.

How DevGuard catches it

DevGuard runs before the push, at the developer's machine. High-entropy string detection + AWS key pattern matching flags the credential in the file. The push is blocked. The key never reaches git history. No rotation needed, no breach.

Next.js middleware auth bypass - all protected routes exposed

What happens

Next.js versions before 15.2.3 allow an attacker to bypass authentication middleware entirely by sending x-middleware-subrequest: middleware in the request header (CVSS 9.1, disclosed March 2025). Any route protected only by Next.js middleware - admin panels, user dashboards, API routes - becomes accessible without authentication.

Why teams ship with vulnerable versions

Developers don't check CVEs manually with every npm install. The project runs fine. No test fails. The application behaves correctly until an attacker sends one crafted request. By then, the vulnerable version has been in production for days or weeks.

How DevGuard catches it

DevGuard reads package-lock.json and matches the installed Next.js version against the CVE database. Before push: "next@14.2.1 is vulnerable to CVE-2025-29927 (auth bypass, CVSS 9.1). Upgrade to 15.2.3." Fix takes 30 seconds. The vulnerable version never ships.

Compromised GitHub Action silently printed secrets of 23,000 repos

What happens

tj-actions/changed-files - used by over 23,000 GitHub repositories - was compromised in March 2025. The attacker modified the action to print all workflow secrets to logs: GITHUB_TOKEN, AWS credentials, deployment keys. Any repo using the action in CI had its secrets exposed in the workflow run output.

Why developers can't catch this manually

The action appeared legitimate and had a long trusted track record. No code review catches a compromised action that was safe yesterday. The malicious code was injected into the release without changing the version tag developers pinned to.

How DevGuard catches it

DevGuard scans .github/workflows/ files and cross-references GitHub Action names and versions against a continuously updated compromised actions database. Developer is alerted before the workflow runs with the malicious version. The database is updated as incidents are disclosed - not after the next model retrain.

JWT decoded without signature verification - anyone can forge admin tokens

What happens

Developer writes jwt.decode(token) in Python (PyJWT) - which decodes the payload without verifying the signature. The correct call is jwt.decode(token, secret, algorithms=["HS256"]). With the insecure version, any attacker can craft a token with "role":"admin" and it will be accepted. No CVE will ever be filed - this is a code logic error.

Why code review and DAST miss it

Code review misses it because the function call looks correct at a glance. DAST sends test requests but doesn't inspect the server-side validation logic. The authentication returns 200 OK for valid tokens - nobody tests with a forged one in regular QA.

How DevGuard catches it

DevGuard SAST Lite detects the jwt.decode() pattern without the verification arguments across Python files. Logic Risk Detection flags "Missing Authorization" in the auth flow. Before push: exact file, line number, and the specific fix. Source code is never transmitted - only the pattern hash and line reference.

Does DevGuard upload my source code?

No. DevGuard follows a privacy-first architecture. Only metadata is transmitted: dependency names and versions, masked secret fingerprints (no actual values), misconfiguration patterns, and tech stack hints. Use --dry-run to inspect the exact payload before uploading.

How does DevGuard detect AI toolchain and MCP risks?

DevGuard scans IDE configuration files for malicious MCP server configs, suspicious AI plugin patterns, and known exfiltration vectors across Cursor, Windsurf, VS Code, and JetBrains. It also detects LLM gateway key exposure, insecure agentic loops, and prompt injection risk patterns.

What is Business Process Detection?

DevGuard identifies business processes from structural metadata - package names, directory paths, env vars, ORM class names, and API paths. No source code is transmitted. It outputs BP-IDs (e.g. BP-PAY-001, BP-AUTH-001) with regulatory scope mapping to PCI-DSS, GDPR, HIPAA, and SOX.

What happens when new CVEs are published after my last scan?

DevGuard includes automatic re-analysis. When new CVEs are published that match your previously scanned dependencies, your project is re-evaluated against the updated knowledge base - without requiring a new scan.

How does DevGuard integrate with CI/CD pipelines?

DevGuard CLI runs in any terminal environment and supports --json output for machine-readable results. Use the pre-push Git hook for local blocking, or integrate the CLI into GitHub Actions, GitLab CI, or any pipeline with configurable exit codes and fail thresholds.