By clicking “Accept All Cookies”, you agree to the storing of cookies on your device to enhance site navigation, analyze site usage, and assist in our marketing efforts. View our Privacy Policy for more information.
ToolAccuracy of FindingsDetects Non-Pattern-Based Issues?Coverage of SAST FindingsSpeed of ScanningUsability & Dev Experience
DryRun SecurityVery high – caught multiple critical issues missed by othersYes – context-based analysis, logic flaws & SSRFBroad coverage of standard vulns, logic flaws, and extendableNear real-time PR feedback
Snyk CodeHigh on well-known patterns (SQLi, XSS), but misses other categoriesLimited – AI-based, focuses on recognized vulnerabilitiesGood coverage of standard vulns; may miss SSRF or advanced auth logic issuesFast, often near PR speedDecent GitHub integration, but rules are a black box
GitHub Advanced Security (CodeQL)Very high precision for known queries, low false positivesPartial – strong dataflow for known issues, needs custom queriesGood for SQLi and XSS but logic flaws require advanced CodeQL experience.Moderate to slow (GitHub Action based)Requires CodeQL expertise for custom logic
SemgrepMedium, but there is a good community for adding rulesPrimarily pattern-based with limited dataflowDecent coverage with the right rules, can still miss advanced logic or SSRFFast scansHas custom rules, but dev teams must maintain them
SonarQubeLow – misses serious issues in our testingLimited – mostly pattern-based, code quality orientedBasic coverage for standard vulns, many hotspots require manual reviewModerate, usually in CIDashboard-based approach, can pass “quality gate” despite real vulns
Vulnerability ClassSnyk (partial)GitHub (CodeQL) (partial)SemgrepSonarQubeDryRun Security
SQL Injection
*
Cross-Site Scripting (XSS)
SSRF
Auth Flaw / IDOR
User Enumeration
Hardcoded Token
ToolAccuracy of FindingsDetects Non-Pattern-Based Issues?Coverage of C# VulnerabilitiesScan SpeedDeveloper Experience
DryRun Security
Very high – caught all critical flaws missed by others
Yes – context-based analysis finds logic errors, auth flaws, etc.
Broad coverage of OWASP Top 10 vulns plus business logic issuesNear real-time (PR comment within seconds)Clear single PR comment with detailed insights; no config or custom scripts needed
Snyk CodeHigh on known patterns (SQLi, XSS), but misses logic/flow bugsLimited – focuses on recognizable vulnerability patterns
Good for standard vulns; may miss SSRF or auth logic issues 
Fast (integrates into PR checks)Decent GitHub integration, but rules are a black box (no easy customization)
GitHub Advanced Security (CodeQL)Low - missed everything except SQL InjectionMostly pattern-basedLow – only discovered SQL InjectionSlowest of all but finished in 1 minuteConcise annotation with a suggested fix and optional auto-remedation
SemgrepMedium – finds common issues with community rules, some missesPrimarily pattern-based, limited data flow analysis
Decent coverage with the right rules; misses advanced logic flaws 
Very fast (runs as lightweight CI)Custom rules possible, but require maintenance and security expertise
SonarQube
Low – missed serious issues in our testing
Mostly pattern-based (code quality focus)Basic coverage for known vulns; many issues flagged as “hotspots” require manual review Moderate (runs in CI/CD pipeline)Results in dashboard; risk of false sense of security if quality gate passes despite vulnerabilities
Vulnerability ClassSnyk CodeGitHub Advanced Security (CodeQL)SemgrepSonarQubeDryRun Security
SQL Injection (SQLi)
Cross-Site Scripting (XSS)
Server-Side Request Forgery (SSRF)
Auth Logic/IDOR
User Enumeration
Hardcoded Credentials
VulnerabilityDryRun SecuritySemgrepGitHub CodeQLSonarQubeSnyk Code
1. Remote Code Execution via Unsafe Deserialization
2. Code Injection via eval() Usage
3. SQL Injection in a Raw Database Query
4. Weak Encryption (AES ECB Mode)
5. Broken Access Control / Logic Flaw in Authentication
Total Found5/53/51/51/50/5
VulnerabilityDryRun SecuritySnykCodeQLSonarQubeSemgrep
Server-Side Request Forgery (SSRF)
(Hotspot)
Cross-Site Scripting (XSS)
SQL Injection (SQLi)
IDOR / Broken Access Control
Invalid Token Validation Logic
Broken Email Verification Logic
DimensionWhy It Matters
Surface
Entry points & data sources highlight tainted flows early.
Language
Code idioms reveal hidden sinks and framework quirks.
Intent
What is the purpose of the code being changed/added?
Design
Robustness and resilience of changing code.
Environment
Libraries, build flags, and infra metadata flag, infrastructure (IaC) all give clues around the risks in changing code.
KPIPattern-Based SASTDryRun CSA
Mean Time to Regex
3–8 hrs per noisy finding set
Not required
Mean Time to Context
N/A
< 1 min
False-Positive Rate
50–85 %< 5 %
Logic-Flaw Detection
< 5 %
90%+
Severity
CriticalHigh
Location
utils/authorization.py :L118
utils/authorization.py :L49 & L82 & L164
Issue
JWT Algorithm Confusion Attack:
jwt.decode() selects the algorithm from unverified JWT headers.
Insecure OIDC Endpoint Communication:
urllib.request.urlopen called without explicit TLS/CA handling.
Impact
Complete auth bypass (switch RS256→HS256, forge tokens with public key as HMAC secret).
Susceptible to MITM if default SSL behavior is weakened or cert store compromised.
Remediation
Replace the dynamic algorithm selection with a fixed, expected algorithm list. Change line 118 from algorithms=[unverified_header.get('alg', 'RS256')] to algorithms=['RS256'] to only accept RS256 tokens. Add algorithm validation before token verification to ensure the header algorithm matches expected values.
Create a secure SSL context using ssl.create_default_context() with proper certificate verification. Configure explicit timeout values for all HTTP requests to prevent hanging connections. Add explicit SSL/TLS configuration by creating an HTTPSHandler with the secure SSL context. Implement proper error handling specifically for SSL certificate validation failures.
Key Insight
This vulnerability arises from trusting an unverified portion of the JWT to determine the verification method itself
This vulnerability stems from a lack of explicit secure communication practices, leaving the application reliant on potentially weak default behaviors.
DryRun Security News
February 5, 2026

Introducing Risk Register

Your One Place to See and Act on Risk Across the Organization

Most orgs don’t lack findings. They lack a single, reliable place to decide what to fix next.

AI-powered engineering teams ship across dozens, sometimes hundreds, of repositories. Findings show up in Code Review Agent results, DeepScan Agent reports, tickets, and spreadsheets. The results are predictable as triage becomes fragmented and it gets harder to answer the questions leaders actually need to prioritize security work.

This is why we built the Risk Register.

Risk Register is a new tool in the DryRun Security dashboard that centralizes findings from the Code Review Agent and the DeepScan Agent into one organization-wide view. It gives AppSec, DevSecOps, and engineering leaders a clear starting point to understand where risk lives, prioritize Critical and High issues, and drive the next right actions.

A clear starting point for AppSec, DevSecOps, and engineering leaders

A clear starting point for AppSec, DevSecOps, and engineering leaders

DryRun Security agents help teams reduce risk in two key moments:

Code Review Agent in your pull requests: AI-native PR security that understands your code and intent, flags risky changes before they merge, and keeps developers moving with low-noise feedback powered by Contextual Security Analysis.

DeepScan Agent across your code repos: A deep, repository-wide assessment that surfaces the highest-risk issues beyond a single PR by reasoning across the codebase and filtering out junk findings.

Risk Register brings those worlds together. Instead of hopping between PRs and separate scan views, you get one place to track, understand, and prioritize risk across the entire organization.

With Risk Register, you can:

  • See priority findings from the Code Review Agent and DeepScan Agent in one unified table
  • Understand where risk concentrates by repository, type, and severity
  • Move from org-level insight to an actionable list in seconds with filters and search
  • Start with Critical and High, then drill down to the exact repo, file, and finding

Security work cannot live only in PRs

Working PR by PR can feel productive, but it leaves gaps. It is hard to maintain a true organization-wide picture of risk when your workflow is bound to whatever PR happens to be open.

Risk Register is built for the bigger, recurring needs of security and engineering leadership:

  • Identifying which repositories carry the most high-severity risk
  • Tracking whether Critical and High issues are trending in the right direction
  • Spotting patterns emerging across the organization, not just in one repo or one PR
  • Keeping triage focused on the work that reduces risk fastest
Criticality summary

Criticality summary

Risk Register exposes your overall risk posture at a glance, including how many issues you have at each severity across Code Review Agent findings and DeepScan Agent findings.

Risk Register includes:

  • Unified findings table across all repositories for the Code Review Agent and DeepScan Agent results
  • Search to instantly locate findings by file, repo, or keyword
  • Sortable Risk column
  • Industry-standard severities: Critical, High, Medium, Low
  • Severity model
  • Filters to focus the view:
    • Date ranges
    • Risk level (Critical, High, Medium, Low)
    • Agent (DeepScan Agent, Code Review Agent)
    • Status (Merged, Open, Closed)

DryRun Security normalizes findings to industry-standard severities so teams can prioritize consistently across agents and repositories.

  • Code Review Agent: mapping aligns closely to Fail → Critical, Risky → High, Info → Low
  • DeepScan Agent and other analyzers: normalized to the same four-level model
  • Configuration-aware: final severity reflects your analyzer setup in Default or Custom Configs
Filters to quickly find the most relevant risk

Filters to quickly find the most relevant risk

Filters to quickly find the most relevant risk

Filters to quickly find the most relevant risk

Designed for action, not just detection

Most security tools stop at detection. They generate findings and leave teams to figure out where risk is concentrated, what to fix first, and how it all adds up across the organization.

DryRun Security is built around action. That means context-rich findings, a consistent severity model, and a clear path from detection to decision.

Risk Register extends that philosophy beyond individual pull requests. It gives security and engineering leaders a shared, organization-wide view of risk, without forcing them to stitch together PRs, scans, and spreadsheets. By normalizing findings and reducing noise, it keeps attention focused on the work that actually reduces risk.

Instead of asking “what did we find,” teams can answer the more important question: “what should we fix next?”

Ready to see Risk Register in action?

Open it now: DryRun Security Dashboard → Risk Register

Want a walkthrough of how teams use it to prioritize risk across the organization? Request a demo.