DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Newsletter
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Related

  • SAST and SCA Complemented with Dynamic Observability for CVE Prioritization
  • How We Cut Our LLM Summarizer's Cost And Latency While Protecting Quality
  • Spring Security JWT Validation Best Practices
  • Why Your GPU Fleet Is Both Full and Idle: Building a Capacity Orchestration Layer

Trending

  • How to Format Articles for DZone
  • Member Spotlight: Raghava Dittakavi
  • Beyond the Wall of Charts: How Advanced Observability Displaced the Telemetry Dashboard
  • Kubernetes Rolling Updates Are Lying to You — and Your Users Are Paying for It

Draft This article hasn't been published, so readers can't see it.

In moderation This article is waiting for review, so readers can't see it yet.

Deleted This article has been deleted, so readers can't see it.

  1. DZone
  2. Culture and Methodologies
  3. Methodologies
  4. Static and Dynamic Application Security Testing With IBM Appscan

Static and Dynamic Application Security Testing With IBM Appscan

IBM AppScan is two distinct products (SAST and DAST) that share a name and find different things. Learn how to use them against a real application.

By 
Srivenkata Gantikota
·
Nov. 19, 26 · Tutorial
Post on X (opens in a new tab) Share on LinkedIn (opens in a new tab)
71 Views

Join the DZone community Save articles, join the discussion, and download Refcards and Trend Reports with a free account.

Join for free Already a member? Log in

I’ve used AppScan across two roles and three products. The first time, I treated the report as gospel and spent three weeks chasing findings that turned out to be artifacts of how the scanner authenticated. The second time, I knew what to throw out and what to keep, and the same scan generated about a third of the work. The difference wasn’t the tool. The difference was knowing what AppScan is good at, what it isn’t good at, and where the noise lives.

This article is the practical version of my experience: how you can configure SAST and DAST scans against a real application; how you can read the output without drowning; and how you can build a remediation cadence that the dev team will actually follow rather than passively resist.

What AppScan Is, and What To Use It For

IBM AppScan is two distinct products:

  • AppScan Source is the SAST product: it analyzes source code or compiled bytecode and finds taint paths, insecure API calls, hardcoded secrets, and similar static-discoverable patterns. 
  • AppScan Standard (and the cloud equivalent, HCL AppScan) is the DAST product: it crawls a running application, generates traffic, and finds vulnerabilities the application exposes at runtime.

You want both because they find different things. SAST catches issues that exist in code paths even if they’re not currently reachable. DAST catches issues that depend on runtime configuration, deployed environment, and the actual request the application receives. The Venn diagram has overlap, but neither replaces the other.

The version skew matters. AppScan Source 9.0.x is what most enterprises were on through the late 2010s, and a lot of the documentation you find online is for that version. Newer versions (10.x onward — as HCL AppScan, after the IBM-to-HCL transition) cleaned up the false-positive rate on a lot of Java framework patterns but introduced new ones around modern frontend toolchains. If you’re standing this up fresh, ask your tooling team what version is available before you read documentation.

Configuring a SAST Scan

The thing that took me the longest to get right with AppScan Source was the call graph configuration for our DAO layer. Out of the box, the scanner was reporting SQL injection on every database call because it didn’t recognize our wrapper class as a sanitizer. The taint was flowing from request through service through DAO, and the scanner saw the final executeQuerycall without seeing the parameter binding that happened two methods upstream.

The fix was a custom rule that taught the scanner that our DAO’s bindParametermethod was a sink terminator. After that, the false positive count on injection findings dropped by about 70%

The general workflow uses the AppScan Source CLI (appscansrcclion Linux/macOS, AppScanSrcCli.exe on Windows). The typical command sequence is to create an application configuration, add the source roots, run the scan, and produce a report — exact flags vary by version, so check appscansrcclihelp for the version you have installed.

What the documentation doesn’t always emphasize: the source configuration needs to include all dependencies that contribute to the call graph. If you only point at your application source, the scanner won’t see the framework code, won’t recognize Spring Security filters, won’t trace the authentication chain, and will report a forest of false positives on the assumption that nothing is sanitized.

For Maven projects, the right pattern is to copy dependency JARs into a directory and add that directory to the scan configuration:

Shell
 
mvn dependency:copy-dependencies -DoutputDirectory=./deps
# Then add ./deps to the AppScan Source configuration
# (via the CLI's add-jars option, or via the GUI Properties view)


The dependency JARs go into the analysis. The scanner doesn’t run rules against them, but it uses them to build the call graph correctly.

Configuring a DAST Scan

DAST is where the noise really starts. AppScan Standard sends real HTTP traffic to the application. It’s going to find things the SAST scanner can’t (broken access control between roles, session fixation, or certain XSS variants that depend on response headers), and it’s also going to find things that aren’t real because the test environment behaves differently from production.

The first thing to configure is authentication. If AppScan is scanning unauthenticated, it’s only seeing a fraction of the surface. There are three patterns:

  1. Recorded login. Use the AppScan browser extension to record a login flow. The scanner replays it before each scan iteration. This works for most form-based logins but breaks on SSO with redirects to external identity providers.
  2. Token authentication. Configure a custom HTTP header with a static token. Easy and useful for API-only scans. The token will eventually expire, so build that into your pipeline.
  3. OAuth flow. Configure the scanner to perform the OAuth handshake and use the resulting access token. AppScan supports this in 10.x natively; in 9.x it requires scripting.

The failure that ate three weeks wasn’t a scan misconfiguration; it was the application doing exactly what it was designed to do. For security reasons, the app rotated the session cookie on every state-changing request. AppScan's recorded-login replay held on to the cookie it captured at login time and kept presenting it on every subsequent request. Once the app rotated the cookie out, the scanner got redirected to the login page and treated that redirect as a new, undiscovered part of the application. It re-ran the recorded login, grabbed a fresh cookie, made a handful of requests, hit another rotation, and looped again. Crawl time ballooned, and the report came back full of what looked like broken-access-control findings that were just repeated login-page captures mislabeled as app content.

The fix was a custom cookie-refresh script AppScan could invoke mid-scan, rather than relying on the one-time recorded replay.

The crawl configuration matters more than people think. By default, the scanner will follow every link, fill every form, and submit every action. If your application has destructive operations (delete user, cancel order), the scanner will exercise them. You should configure the exclusions before the first run.

Reading the Output Without Drowning

This is the part that most teams get wrong. AppScan SAST reports for a moderately-sized Java application typically generate between 200 and 2,000 findings on the first scan. If you assign all of them to the development team, the program dies before week two.

The triage I run has three phases:

  • Phase one: trust filter. Group the findings by rule. Look at the top five rules by count. For each one, sample five findings. Are they real? If the rule has more than fifty findings and they’re all the same false positive pattern, write a custom suppression rule before assigning anything. This is the most useful hour you’ll spend in the entire program.
  • Phase two: severity by data sensitivity, not by CVSS. AppScan assigns severity. The severity is based on the technical category (high for SQL injection, medium for information disclosure, etc.). What it doesn’t know is what data your application handles. A SQL injection in your read-only marketing site is a different problem from a SQL injection in the patient record service. Re-rank findings against your application’s data classification before you assign them.

I categorized one endpoint's findings as lower priority because no individual field in the response was sensitive on its own. Name, zip code, and date of birth each looked harmless in isolation, and with AppScan's severity scoring, like most scanners, it rates fields independently rather than in combination. The privacy officer flagged it during review. Together, those three fields formed a re-identifiable record — which under HIPAA counted as PHI — even though nothing in the response was a “sensitive field” by any scanner's definition. The endpoint got re-ranked from informational to a real finding, and it reset how I triaged everything after. Technical severity tells you how easy something is to exploit, not what happens once someone does. The second question is a data classification exercise, not a scanner output.

Phase three: assignment with context. Each finding that survives the first two phases gets assigned to a specific developer with the file, line, rule explanation, and a suggested fix. Generic “assigned to the team” tickets get ignored. Specific “assigned to you, line 47, here’s what to change” tickets get fixed.

Building the Remediation Cadence

Here’s where the program lives or dies. This is the schedule I used:

  • Weekly security triage meeting. Thirty minutes, with one engineer from each team and the security lead. Walk through the new findings from the prior week’s scans. Triage as a group. Anything tagged for assignment gets a ticket created in the meeting.
  • Monthly remediation review. Look at the open findings. What’s been fixed, what’s been suppressed with justification, what’s been pushed past the SLA. The pushed-past-the-SLA findings are the ones that need attention. Either the fix is genuinely hard, the assigned developer is overloaded, or the finding turned out to be invalid, and nobody updated the status.
  • Quarterly trend review. Meet with engineering leadership. Show the burndown, the new findings rate, and the mean time to remediation. Three numbers. Don’t show them ten metrics. They’ll pick the wrong one, and the program will reorient around the wrong incentive.

The mistake I’ve seen kill more security programs than any other: trying to enforce a fix-everything-now policy on the existing backlog. This doesn’t work. The team revolts. What works is enforcing zero-new-findings on critical-severity issues going forward, while the existing backlog drains at a sustainable rate.

SLA Structure That Works

This is the SLA structure I used:

  • Blocker/critical findings: 14 days to resolution or risk acceptance
  • High findings: 30 days
  • Medium findings: 90 days
  • Low/informational: best-effort, tracked but not SLA’d

The risk acceptance path matters. Some findings genuinely don’t need to be fixed (the affected code path is unreachable, the data is already public, or the threat model excludes the actor). Risk acceptance with sign-off from the engineering manager is the alternative to rushed fixes that introduce new bugs.

What doesn’t work: an across-the-board “all findings within 30 days” policy which treats unequal things equally. This policy generates resentment when the team has to fix a low-severity issue while a Blocker sits open.

False-Positive Rate as Leading Indicator

If your false-positive rate on AppScan SAST is over 40%, your custom rules are insufficient. The fix is investing in custom rule development through the Pattern Rule Library and Custom Rules wizard. It’s an investment with real payoff: every false-positive class you suppress with a custom rule reduces noise on every future scan.

If your false-positive rate on AppScan DAST is over 20%, your scan configuration is the issue. Usually, it’s the authentication state going stale mid-scan, or a test environment that behaves differently from production, which the scanner interprets as vulnerabilities.

The false-positive class that ate the most cycles was hardcoded credentials in test fixtures and mock objects — code that never shipped to production but sat inside the same source tree AppScan was scanning. The first suppression attempt excluded the entire test directory by path, which worked until a developer added a mock config file one level up, outside the excluded path, and the findings came back. The second attempt tried to match on file naming convention instead (anything with “Mock” or “Fixture” in the name), but that missed a batch of test helpers that didn’t follow the convention and let real findings slip past unflagged in the other direction. A suppression rule that's too loose is worse than no rule, because it hides things silently. The third rule combined both signals: path pattern and a check that the file wasn’t referenced from any non-test source root in the call graph. That’s the version that held.

What AppScan Doesn’t Do

These are what AppScan SAST and DAST do not catch:

  • Authentication and authorization logic flaws beyond the simple cases. If your authorization is “any authenticated user can access this endpoint” when it should be “only the owning user,” neither tool will find it. This is a code review and threat modeling responsibility.
  • Business logic vulnerabilities. The scanner doesn’t know what your application is supposed to do.
  • Race conditions in security-critical code. Mostly invisible to static analysis, partially visible to DAST if you’re lucky, and the timing happens to land.
  • Vulnerabilities in client-side JavaScript that depends on dynamic configuration loaded at runtime.

This is the right way to think about AppScan: it’s the broad coverage layer. It catches the patterns that scanner-detectable rules can describe. Above it, you need code review for logic flaws, threat modeling for design issues, dependency scanning for third-party CVEs, and penetration testing for the things only humans find.

Getting Started

If you’re trying this for the first time, here's my suggested order:

  1. Run an unauthenticated SAST scan against your largest service. Don’t act on the findings yet. Just look at the false positive rate by rule.
  2. Write the top three custom suppression rules. Re-run the scan.
  3. Configure DAST against a non-production environment. Get authentication working. Run a full crawl.
  4. Compare findings between SAST and DAST. The overlap shows you what’s reachable and exploitable. The gaps show you what each tool is finding that the other isn’t.
  5. After two cycles, integrate into the CI/CD pipeline. Use SAST on every PR, DAST on every release branch.

The pipeline integration is what makes the program sustainable. Manual scans get skipped. Automated scans run regardless. The findings flow into the same triage process either way.

What I’d avoid in the first six months: trying to make AppScan the only security tool in the program. It’s part of a stack. The stack works. The single tool doesn’t.

Decentralized autonomous organization Requirements engineering Security testing

Opinions expressed by DZone contributors are their own.

Related

  • SAST and SCA Complemented with Dynamic Observability for CVE Prioritization
  • How We Cut Our LLM Summarizer's Cost And Latency While Protecting Quality
  • Spring Security JWT Validation Best Practices
  • Why Your GPU Fleet Is Both Full and Idle: Building a Capacity Orchestration Layer

Partner Resources

×

Comments

Loading comments

The comments didn't load

Please try again in a moment.

Likes

Loading

The next likes didn't load. Please try again.

The likes didn't load

Please try again in a moment.

See who liked this

Log in or join DZone for free to see who liked this article.

Log in Join for free
  • RSS
  • X
  • Facebook

ABOUT US

  • About DZone
  • Support and feedback
  • Community research

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 215
  • Nashville, TN 37211
  • [email protected]

Let's be friends:

  • RSS
  • X
  • Facebook