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.
AI in AppSec
September 23, 2026

More Findings ≠ More Security

Do security teams have too little to do? Are there too few alerts to investigate? Is your menagerie of security tools not producing enough findings to manage? If this is your current situation, congratulations! For the rest of us, we’re struggling to prioritize a mountain of information, all of which needs to be validated, filtered, and remediated.

If security teams and downstream consumers cannot handle the volume of security concerns then increasing this volume would be considered problematic and therefore we should work to eliminate noise and ultimately, waste.It seems like a simple conclusion, right?

Yet when it comes to evaluating security tools, security teams are often tempted to consider a tool with fewer findings to be inferior to a tool with more findings. If “x” tool finds more than “y” tool, then “x” tool must be the better tool, right? It’s almost a form of security FOMO

Some part of this, we believe, holdover behavior from the time of deterministic scanning where scanners could only do what they could do but humans were required to interpret and validate the “raw data” produced by scanners. Naturally, having more of that “raw data” was seen as having more capability. We don’t live in that world now and we shouldn’t evaluate tools like we are.

A tool does not make an organization more secure merely by identifying more things that could, under some set of assumptions, be considered security concerns. The value of a tool is determined by whether it helps the organization identify and address the risks that actually matter. Those are very different standards.

False Positives

Let’s begin with the obvious problem: a bunch of junk output is unhelpful, wastes time, and reduces trust in a tool as well as the team who delivers its output. If unvalidated issues are sent to engineering teams, they will quickly revolt. Not only will they be unhappy with the tool, they will not trust future requests from the security team. And lack of trust causes security teams to be ineffective.

To truly compare two tools, you must ideally know the true positive, false positive, and false negative (missed vulnerability) rates. This can be challenging, even with AI assistance (validation is actually a known weakness with AI)! It requires carefully going through the findings, understanding how each tool reports vulnerabilities, and comparing them as fairly as possible.

But first let’s consider the unlikely but easier to reason about case where neither tool produces any false positives. Every finding is a legitimate security concern. In that case,now does the tool with the most findings win? Well, still a “no”.

Reporting Differences

On the technical side, a difference in raw numbers of reported issues does not even indicate that two tools found different issues. The difference in numbers may be related purely based on how the issues are reported. For example, some tools attempt to combine findings based on root causes. Others may have a single finding for a pattern that occurs in multiple locations. At DryRun we specifically  unify findings that, when chained together, increase the total severity and become an exploit chain. There is real value in that, there is true intelligence in that, but 4 low severity issues become 1 critical issue. The numbers, when viewed by raw count, are deceiving. 

This means even comparing a narrow band of findings - let’s say only the “critical” findings from two tools - requires carefully reading each one to understand how many underlying vulnerabilities are actually represented. It may easily be the case that both tools report the same issues, just in different ways.

External Factors

It is rare for a single tool to have universal knowledge of the technical and product environment in which it operates. As a result, a finding may be “true” in the sense that it is accurately describing the behavior or possible exploitation, but the finding is actually mitigated elsewhere or isn’t an issue in the product.

Denial of service is a common example: a DoS may be technically possible based on the application code, but is often mitigated by network-level rate-limiting. Another example is privacy of information. A banking application has much different confidentiality expectations than a social media application.

So even for true positives, it’s necessary to review to see which ones truly apply.

Risk Thresholds

Sticking with the 100% true positive scenario, we also must consider how companies work in reality. Organizations rarely have time to address every security finding, not every finding is worth spending time on, and sometimes the risk of a vulnerability is outweighed by the requirements of the business.

This leads to a risk-first approach: start at the highest severity findings and work down the list. There is usually a cut-off, as well. When there are many issues, perhaps only criticals/highs are even in scope. The rest are ignored.

If this is the case, then producing more findings (especially those below the threshold) has no useful impact. They will never be remediated. When evaluating a security tool, the most useful output will be impactful, relevant, and actionable. You cannot tell that by the numbers.

Measure What Matters

The most useful security output is not the largest pile of technically defensible observations. It is the smallest set of information that allows the organization to make the right decisions about its most important risks.

When evaluating a security tool, better questions include:

  • Did it identify the vulnerabilities that matter most?
  • Did it explain why they are exploitable in this application
  • Did it distinguish root causes from repeated symptoms?
  • Did it account for relevant technical and business context?
  • Could the security team validate the results efficiently?
  • Could developers understand and act on them?
  • Did the findings lead to meaningful remediation?

These questions are harder to answer than comparing two numbers on a slide. They also tell you considerably more about whether the tool will improve your security program.

Coverage still matters. False negatives matter enormously. A quiet tool that misses critical vulnerabilities is not superior because it creates less work but the opposite is equally true as well. A noisy tool is not demonstrating better discernment because it filled the dashboard. The goal is better decision making not “more findings”.

Conclusion

There is no perfect security tool today that discovers every vulnerability, produces zero false positives always, understands every compensating control, and correctly models every organization’s tolerance for risk. And yes, that’s still true even in the era of AI. While we’re getting much closer to that world, and this might be weird to hear from a security vendor, but it does not yet exist.

Every tool makes tradeoffs and so, when evaluating security tools, avoid the temptation to assume the tool produces more output is the better tool. Instead, judge security tools by the quality of the decisions they enable. There is no such thing as a  flawless tool even if we’re collectively working towards that goal. It will always be a balance of many considerations.

More findings don’t make you more secure. Better decisions do.

See how DryRun connects related issues, filters out the noise, and gives your team the context to focus on the risks that actually matter.

See DryRun in action →