Tools / OpenText Application Security (Fortify) Interview questions
Last updated
1. What is OpenText Application Security (Fortify)?
OpenText Application Security is the product family that used to be called Micro Focus Fortify. OpenText took it over when it acquired Micro Focus in 2023, and most developers still just say Fortify.
It helps teams find and fix security flaws in software across the development lifecycle. The portfolio covers SAST (Fortify Static Code Analyzer), DAST (WebInspect and ScanCentral DAST), open source and composition analysis, and a management layer (Software Security Center) for tracking issues and enforcing policy.
You can run it on-premises or consume it as a SaaS service through Fortify on Demand.
Take quiz
Synopsys
Checkmarx
OpenText
Veracode
Only manual penetration testing services
Only network port scanning
Only runtime web application firewalling
Static analysis, dynamic analysis, open source scanning and central issue management
2. What are the main components of the Fortify suite?
Fortify is not one tool but a set of products that work together. The core pieces are:
| Component | What it does |
| Static Code Analyzer (SCA) | SAST engine, run through the sourceanalyzer command line |
| Audit Workbench / IDE plugins | Review findings and fix code locally |
| Software Security Center (SSC) | Central server for results, policies and reports |
| ScanCentral SAST | Distributes scans to remote sensors |
| WebInspect / ScanCentral DAST | Dynamic scanning of running web apps and APIs |
| Fortify on Demand | Hosted SaaS version of the testing services |
| Fortify CLI (fcli) | Automation of SSC, ScanCentral and FoD from pipelines |
A typical flow is scan with SCA, upload the FPR to SSC, then audit and remediate.
Take quiz
Audit Workbench
WebInspect
sourceanalyzer
Software Security Center (SSC)
Fortify Static Code Analyzer
ScanCentral DAST
Fortify CLI (fcli)
Software Security Center
3. What is Fortify Static Code Analyzer (SCA)?
Fortify SCA is the static application security testing engine. It reads your source code (and some compiled artifacts) without running the application and looks for vulnerabilities such as SQL injection, cross-site scripting and path manipulation.
It works in two steps: it first translates the code into an intermediate model, then scans that model with its analyzers and rulepacks. The result is an .fpr file you can open in Audit Workbench or upload to SSC.
Because it never executes the app, it can run early in the pipeline, even before anything is deployed.
Take quiz
Statically, without running the application
By sending attack traffic to a deployed site
By monitoring production logs
By fuzzing network protocols
A WAR file
An FPR results file
A Docker image
A HAR capture
4. What is Fortify WebInspect?
WebInspect is Fortify's dynamic application security testing (DAST) tool. It attacks a running web application or API from the outside, the way an attacker would, and reports what it manages to exploit or observe.
It crawls the site to discover pages and parameters, then audits them using attack policies. It handles logins through recorded macros and can scan REST and SOAP APIs from definitions such as OpenAPI.
Use it alongside SCA: SCA finds code-level flaws early, while WebInspect finds runtime and configuration problems that only appear in a deployed environment.
Take quiz
Reading source code line by line
Crawling and attacking the running app over HTTP
Scanning only dependency manifests
Reviewing database schemas
Unused local variables
Code formatting violations
Runtime and deployment configuration issues
Missing code comments
5. What is Fortify Software Security Center (SSC)?
SSC is the central management server of the Fortify suite. Teams upload FPR files there, and it stores results per application and application version.
From SSC you can audit issues, assign them to developers, apply security policies, view trends and dashboards, generate reports and push findings to bug trackers such as Jira.
It also tracks the same issue across scans, so audit decisions are carried forward instead of being redone for every build.
Application versions matter because Fortify treats each release line as its own history. A team might keep Orders 1.0 and Orders 2.0 separately, with different issue templates and policies, while still reporting on the whole application.
Take quiz
Compiling Java projects
Recording web login macros
Centrally managing results, audits, policies and reports
Replacing the build server
Operating system users only
Git commit hashes only
Network subnets
Applications and application versions
6. What is Fortify on Demand?
Fortify on Demand (FoD) is the SaaS version of Fortify. You upload code or point it at a running app, and OpenText hosts the scanning infrastructure, with optional expert review of results. It is now marketed under the name OpenText Core Application Security.
It supports static, dynamic and mobile assessments, plus open source scanning, and you buy usage through entitlements.
Teams pick it when they don't want to install and maintain SCA, SSC and sensors themselves.
Scans in FoD are submitted through the portal, the API or CI plugins, and results appear under a release. Static scans take an uploaded zip of source, while dynamic scans need a reachable URL and often a test login.
Take quiz
It runs only on an air-gapped laptop
It replaces the need for any code review
It is a code editor
Hosted scanning without maintaining your own infrastructure
Entitlements
Per-commit billing only
Free open source licenses
Hardware appliances
7. What is Fortify Audit Workbench?
Audit Workbench is the desktop tool for reviewing FPR files. Auditors open a scan result, browse issues by folder or category, and read the trace that shows how tainted data travels from source to sink.
Each issue can be tagged (for example Exploitable or Not an Issue), commented on, and suppressed. Results can then be uploaded to SSC.
It also includes tools for building custom rules and generating reports.
In daily use, developers typically open it only when they want to dig into a specific trace, while auditors live in it longer. Edits made offline can be uploaded later, so audit work doesn't need a constant connection to SSC.
Take quiz
Open FPR files and audit the findings
Deploy applications to Kubernetes
Manage Git branches
Record load tests
The list of Maven plugins
The path from a tainted source to a vulnerable sink
Server CPU usage
Commit authors
8. What is an FPR file in Fortify?
An FPR (Fortify Project Results) file is a compressed archive that holds everything about one scan: the issues found, the source files, the audit data, and the rulepack and scan metadata.
Because the source snippets and traces are bundled in, anyone with Audit Workbench or SSC can review the results without access to the original repository.
You can inspect or combine FPRs with FPRUtility, for example to merge audit data from two scans.
One practical detail: FPR files can get large on big projects because they bundle source. If you only need issue data for a pipeline gate, query SSC instead of passing FPRs around between jobs.
Take quiz
Only a list of CVE numbers
Scan issues, source context and audit information
Only compiled bytecode
Only the SSC database backup
fortifyupdate
scancentral
FPRUtility
ReportGenerator
9. What is sourceanalyzer in Fortify?
sourceanalyzer is the command-line front end of Fortify SCA. Every CLI scan goes through it, usually in two calls that share a build ID given with -b.
sourceanalyzer -b myapp -clean sourceanalyzer -b myapp mvn clean package sourceanalyzer -b myapp -scan -f myapp.fpr
The first command clears older state, the second translates the code while the build runs, and the third analyzes and writes the FPR.
Besides scanning, it has handy diagnostic options. -show-files lists translated files, -show-build-warnings prints unresolved references, and -logfile writes details you can attach to a support case. It runs on Windows, Linux and macOS.
Take quiz
The branch name in Git
The memory limit
The build ID that ties translation and scan together
The output language
-translate-only
-upload
-compile
-scan
10. What are Fortify rulepacks?
Rulepacks are XML files of security rules that tell SCA what counts as a source, a sink, a sanitizer or a bad pattern. They are the knowledge base behind the analyzers.
OpenText's security research team updates the standard rulepacks regularly, and you pull them in with the fortifyupdate command. Teams can also add custom rulepacks for in-house frameworks or company coding standards.
Rulepacks are language-specific, so a Java rulepack does nothing for Python code.
Rule IDs inside a rulepack are what you see in a finding's details, which helps when you need to tune or disable one noisy rule. Custom rulepacks are loaded alongside the standard ones, not instead of them.
Take quiz
User roles in SSC
Scan scheduling windows
Report templates only
Security rules for sources, sinks, cleansers and patterns
fortifyupdate
sourceanalyzer -update
fprutility -refresh
scancentral sync
11. What are the Fortify issue folders?
Fortify groups findings into four priority folders: Critical, High, Medium and Low. The folder depends on two scores, impact and likelihood.
| Folder | Impact | Likelihood |
| Critical | High | High |
| High | High | Low |
| Medium | Low | High |
| Low | Low | Low |
Auditors usually start with Critical and High, since those are the issues most worth fixing first.
The folder is shown with every issue in SSC and Audit Workbench, and the numbers behind it are visible in the issue details. Filter sets let you hide folders you don't want to see, such as Low, without deleting anything.
Take quiz
Critical
High
Medium
Low
Age and file size
Impact and likelihood
Language and framework
Author and commit date
12. What is the Fortify priority order?
Priority order is the score Fortify uses to rank issues inside a folder so teams know what to fix first. It is based on impact (how bad exploitation would be) and likelihood (how probable the issue is real and exploitable).
Likelihood itself is derived from factors such as the accuracy of the rule, the confidence of the finding and the probability that an attacker can reach it. Remediation effort is shown separately, so it does not distort the risk ranking.
In practice, sort by priority order and tackle the top of the Critical folder first.
Take quiz
Encrypt FPR files
Rank issues so the riskiest are fixed first
Pick the scan sensor
Choose the Java version
Number of developers
Repository size
Rule accuracy and finding confidence
Build duration
13. List the languages supported by Fortify SCA?
Fortify SCA covers most mainstream enterprise languages. The commonly used ones include:
- JVM: Java, Kotlin, Scala
- .NET: C#, VB.NET, ASP.NET
- Native: C, C++, Objective-C, Swift, Go
- Web and scripting: JavaScript, TypeScript, Python, PHP, Ruby
- Enterprise and database: ABAP, COBOL, PL/SQL, T-SQL
It also understands configuration and markup such as XML, YAML and Dockerfiles. Exact support depends on the product version, so always check the release notes before committing to a language.
Frameworks matter as much as languages. Fortify has rules for Spring, Struts, ASP.NET, Django, Express, Angular and many others, and that framework knowledge is what lets it spot sources and sinks hidden behind annotations or routing configuration.
Take quiz
Excel formulas only
Photoshop scripts
Java
Gherkin only
The Git log
A browser cache
The SSC audit trail
The release notes of your Fortify version
14. What are the types of Fortify SCA analyzers?
SCA uses several analyzers, each looking for a different class of problem:
| Analyzer | Finds |
| Dataflow | Tainted input reaching a dangerous sink, such as SQL injection |
| Control Flow | Bad sequences of operations, such as use after free |
| Semantic | Dangerous use of specific functions or APIs |
| Structural | Unsafe code structure or design patterns |
| Configuration | Insecure settings in config files |
| Content | Problems in static content like HTML and JSP |
| Buffer | Buffer overflows in C and C++ |
Most real-world findings come from Dataflow, since injection flaws are the most common.
Take quiz
Buffer
Content
Configuration
Dataflow
Buffer
Structural
Semantic
Dataflow
15. What is Fortify ScanCentral SAST?
ScanCentral SAST lets you run SCA scans on remote machines instead of the build server or a laptop. A Controller receives scan jobs and hands them to Sensors that do the heavy work.
The developer or CI job uses the scancentral client to package the code and submit it. When the scan finishes, the Controller uploads the FPR to SSC automatically.
This keeps build agents free and makes it easy to add scan capacity by adding sensors.
For CI use, a job usually runs scancentral from the pipeline, which packages the code locally and sends it off. The sensor then builds and scans it remotely, so the CI agent doesn't need a full Fortify installation or large memory.
Take quiz
Sensor
Client
Report generator
Issue template
It removes the need for rulepacks
Offloads heavy scans to dedicated, scalable machines
It scans without any source code
It replaces SSC
16. Explain the execution flow of a Fortify SCA scan?
A Fortify scan has two phases: translation and analysis. Both use the same build ID, so SCA knows which translated files belong together.
flowchart LR A["Source code and build"] --> B["Translation: sourceanalyzer -b id"] B --> C["Intermediate NST model"] C --> D["Analysis: -scan"] D --> E["Dataflow, Control Flow, Semantic, Structural analyzers"] E --> F["FPR results file"] F --> G["Audit Workbench or SSC"]
- Clean any old session for the build ID.
- Translate every source file while the real build runs, so classpaths and dependencies are resolved.
- Scan the translated model with rulepacks loaded.
- Write the FPR and optionally upload it to SSC.
If translation misses files, the scan quietly covers less code, so always check build warnings.
Between those steps, SCA can also load custom rulepacks and a filter file, which is why the same translated build can be scanned twice with different settings. The result is deterministic for the same code, rules and settings.
Take quiz
Analysis
Translation
Upload
Reporting
The FPR file name
The SSC application name
The shared build ID
The rulepack version
17. How do you run a Fortify scan from the command line?
Use sourceanalyzer in three steps: clean, translate, scan. This example is for a Maven project:
sourceanalyzer -b orders -clean sourceanalyzer -b orders -Xmx8G mvn clean package -DskipTests sourceanalyzer -b orders -Xmx8G -scan -f orders.fpr
For plain source trees without a build tool, pass files and the classpath directly, for example -cp "lib/*.jar" src/**/*.java.
Afterwards you can upload the FPR with fortifyclient or fcli, or open it in Audit Workbench. Use -show-build-warnings to confirm everything translated.
Options worth knowing: -b sets the build ID, -f the output file, -logfile keeps a log, and -rules adds custom rulepacks. Run fortifyupdate first so the scan uses current security content.
Take quiz
sourceanalyzer -scan mvn package
fortifyupdate mvn clean
sourceanalyzer -b orders mvn clean package
scancentral -b orders mvn
It disables the rulepacks
It encrypts the FPR
It is required by Maven for Fortify
Tests are not needed for the scan, so the build is faster
18. Why does Fortify SCA translate source before scanning?
Translation turns different languages into one common intermediate model (NST). Analyzers then work on that model instead of raw text, so the same rules and dataflow logic apply across languages.
It also lets SCA run the real build, which resolves imports, classpaths, generated sources and dependencies. Without that, calls into libraries would be unresolved and taint could not be tracked through them.
The split also means you can translate once and scan multiple times with different rulepacks or filters, without redoing the expensive build step.
This is also why SCA wants the real build command rather than just a folder of files. For compiled languages, the build supplies compiler settings and dependency versions that the model needs to resolve method calls correctly.
Take quiz
To compress the FPR
To contact the SSC server
To encrypt the source
To build a common model and resolve dependencies from the real build
You can rescan with different rules without retranslating
It removes the need for a build ID
It makes scans non-deterministic
It avoids using rulepacks
19. What is the difference between SAST and DAST in Fortify?
SAST (SCA) analyzes code without running it, while DAST (WebInspect) attacks the running application.
| Aspect | SAST (SCA) | DAST (WebInspect) |
| Input | Source code or build | Running URL or API |
| When | Early, in the IDE or CI | After deployment to a test env |
| Finds | Code-level flaws with line numbers | Runtime and configuration issues |
| False positives | More likely | Fewer, since attacks are proven |
| Coverage | All code paths it can reach | Only what the crawler discovers |
Neither replaces the other. SAST tells developers exactly where to fix, and DAST confirms what is exploitable in the real deployment.
In a mature pipeline, SAST runs on every commit, and DAST runs against a staging environment. Findings from both can be uploaded to SSC, where a team can see that, for example, a SAST SQL injection and a DAST confirmation point at the same weakness.
Take quiz
SAST
DAST
Manual smoke testing
Load testing
SAST
DAST
Rulepack validation
FPR merging
20. How does Fortify taint analysis work?
Dataflow analysis follows untrusted input through the program. A source (like request.getParameter) marks data as tainted with flags such as webinput.
The taint then moves through assignments, method calls and returns. Passthrough rules describe library methods that carry taint, and cleanse rules describe methods that remove it.
If tainted data reaches a sink that is dangerous for that taint type, for example a SQL execute call, SCA reports an issue and records the full trace. Analysis is interprocedural, so it follows data across methods and files.
Hand-written wrappers are the usual trouble spot. If your code wraps a database call in a helper, Fortify follows the helper's body automatically, but for library code without source it relies on passthrough rules, which is why library coverage in rulepacks matters.
Take quiz
A cleanse rule
A source rule that marks input as tainted
The FPR file
An SSC policy
When a variable is declared
When a file is saved
When tainted data reaches a matching sink
When a class is imported
21. What are source, sink, passthrough and cleanse rules?
These are the four main dataflow rule types that describe how data moves:
| Rule type | Meaning | Example |
| Source | Where untrusted data enters | request.getParameter() |
| Sink | Dangerous place data should not reach unchecked | Statement.executeQuery() |
| Passthrough | Method that passes taint along | String.concat() |
| Cleanse | Method that removes taint | HTML encoder or parameter binder |
There are also entrypoint rules that treat a method's parameters as tainted, which is useful for framework handlers.
Rules also carry taint flags, such as webinput or xss, so a cleanse for one weakness doesn't wrongly hide another. HTML encoding removes XSS taint but not SQL injection taint, which is exactly how it should behave.
Take quiz
Source
Sink
Cleanse
Passthrough
Entrypoint only
Cleanse
Structural
Passthrough
22. How do you write a custom rule in Fortify?
Custom rules are XML files in a rulepack. Typical reasons: your company has its own sanitizer that Fortify doesn't recognize, or an internal API is a source or sink.
Here is a cleanse rule that tells Fortify an in-house encoder removes XSS taint:
<DataflowCleanseRule formatVersion="3.10" language="java"> <RuleID>MYORG-CLEANSE-XSS-01</RuleID> <TaintFlags>-xss</TaintFlags> <FunctionIdentifier> <NamespaceName><Pattern>com.myorg.security</Pattern></NamespaceName> <ClassName><Pattern>Sanitizer</Pattern></ClassName> <FunctionName><Pattern>encodeHtml</Pattern></FunctionName> </FunctionIdentifier> <OutArguments>return</OutArguments> </DataflowCleanseRule>
Wrap it in a RulePack element, then pass it with sourceanalyzer -scan -rules myrules.xml. Audit Workbench also has a wizard that generates simple rules for you.
Keep rule IDs unique and prefixed with your company name so they never collide with Fortify's own. Test each rule on a small sample project first, because a too-broad pattern can silently remove taint from real vulnerabilities.
Take quiz
Rename it to .fpr
Upload it to Git
Place it in the Maven pom
Pass it with the -rules option
Removes the XSS taint flag from the returned value
Adds an XSS flag
Disables the rule
Marks the method as a sink
23. How do you reduce false positives in Fortify?
Start by making sure the scan is complete and accurate: resolve translation warnings, since missing libraries can cause both missed issues and wrong ones.
- Update to the latest rulepacks with
fortifyupdate. - Add custom cleanse rules for your own validation and encoding methods.
- Audit findings and mark confirmed false ones as Not an Issue; SSC carries that forward to later scans.
- Use a filter set such as Quick View to focus on higher-confidence issues.
- Exclude test and generated code that isn't shipped.
Avoid blanket suppression of a whole category. Each suppression should have a comment explaining why.
Keep a record of why each rule or tag was changed. A year later, nobody remembers that a cleanse rule was added for a legacy sanitizer, and a review of those decisions is a healthy habit.
Take quiz
Write a custom cleanse rule
Delete the FPR
Increase JVM memory
Switch to DAST only
Scans become slower
Real issues of that type get hidden
The FPR becomes larger
SSC loses the application
24. What is the difference between Not an Issue and Exploitable in Fortify?
These are values of the Analysis audit tag that an auditor assigns after reviewing a finding.
| Value | Meaning |
| Exploitable | Real vulnerability that an attacker can use; must be fixed |
| Suspicious | Looks risky but needs more investigation |
| Bad Practice | Poor coding but not directly exploitable |
| Reliability Issue | Can cause crashes or instability rather than a security breach |
| Not an Issue | False positive or accepted as safe, with a justification |
Not an Issue hides the finding from most views, so always add a comment explaining why. Exploitable items go to developers, usually through a bug tracker.
Auditors should agree on the meaning of each value as a team. If one person uses Bad Practice for real but low-risk bugs and another uses it for stylistic problems, dashboards and policies built on those tags quickly become unreliable.
Take quiz
Not an Issue
Exploitable
Bad Practice
Reliability Issue
A new rulepack
A second FPR
A comment justifying the decision
A new application version
25. How do you merge FPR files with FPRUtility?
Merging combines the audit data from one FPR into the issues of another, so earlier decisions are not lost after a rescan.
FPRUtility -merge -project new_scan.fpr -source audited.fpr -f merged.fpr
Here -project is the new scan whose issues are kept, and -source is the older FPR whose audit tags and comments are copied onto matching issues.
SSC does the same automatically when you upload to an existing application version, so manual merging is mostly needed for offline workflows.
A related command is FPRUtility -information -analyzerIssueCounts -project scan.fpr, which prints issue counts per analyzer and is handy to sanity check a merge. Always keep a backup of the audited FPR before overwriting it.
Take quiz
The -project FPR only
Neither; audits are discarded
The -source FPR
The rulepack
WebInspect
Audit Workbench only
fortifyupdate
Software Security Center
26. How does ScanCentral SAST distribute scans?
The client packages the code and sends it to the Controller. The Controller queues the job and assigns it to a free Sensor that matches the job's requirements, such as OS or version.
sequenceDiagram participant C as CI or Developer (scancentral client) participant K as Controller participant S as Sensor participant U as SSC C->>K: Submit package and job K->>S: Assign queued job S->>S: Translate and scan S->>K: Return FPR K->>U: Upload results C->>K: Poll job status
Because sensors are interchangeable, you can scale throughput by adding more of them. Pools let you reserve sensors for specific teams or languages.
Failures are handled at the Controller too. If a sensor drops out mid-job, the job can be re-queued, and the client can poll with scancentral status and fetch the FPR when the scan is complete.
Take quiz
The SSC database
The IDE plugin
The rulepack
The Controller
Add more sensors
Increase the FPR size
Add more Git branches
Disable translation
27. How do you integrate Fortify into a Jenkins pipeline?
Install the Fortify Jenkins plugin and add its steps to your pipeline. The usual steps are fortifyClean, fortifyTranslate, fortifyScan and fortifyUpload. For remote scanning there are ScanCentral equivalents.
stage('Fortify') { steps { fortifyClean buildID: 'orders' fortifyTranslate buildID: 'orders', projectScanType: fortifyJava() fortifyScan buildID: 'orders' fortifyUpload appName: 'Orders', appVersion: '1.0', resultsFile: 'orders.fpr' } }
Store the SSC token as a Jenkins credential rather than in the Jenkinsfile. Step names and options can vary between plugin versions, so check yours.
Add a post-build check that fails the job when SSC reports new Critical issues. A common mistake is to run the scan but never act on it, which gives a green pipeline and no security value.
Take quiz
In Jenkins credentials
Hard-coded in the Jenkinsfile
In the source repository
In the FPR file
fortifyClean
fortifyUpload
fortifyTranslate
fortifyScan
28. How do you use Fortify with GitHub Actions?
Fortify provides GitHub Actions and the Fortify CLI (fcli) to run scans from workflows. A typical job checks out code, sets up the Fortify tools, packages the source, submits it to ScanCentral SAST or FoD, and waits for the result.
- Add the SSC URL and token (or FoD credentials) as repository secrets.
- Run the Fortify setup action to install fcli and tools.
- Package and start the scan with fcli or the Fortify actions.
- Optionally export results to GitHub code scanning in SARIF form.
Never echo tokens in logs. Use secrets and masked variables only.
Scans on pull requests should usually be quick scans or incremental, while the full scan runs on the default branch. Keep an eye on fork pull requests too, since GitHub doesn't pass secrets to them by default.
Take quiz
In the workflow YAML in plain text
Repository or organization secrets
In a README
In the commit message
fprutility only
Audit Workbench
fcli
WebInspect Agent
29. When should you use a quick scan versus a full scan?
Use quick scan when you want fast feedback, such as on pull requests or in a developer's workflow. It uses a reduced rule set and tuned limits, so it finishes sooner but reports fewer issues.
sourceanalyzer -b orders -quick -scan -f quick.fpr
Use a full scan for nightly builds, release gates and audits, where completeness matters more than time.
A common pattern is quick scans on every commit and a full scan on main each night.
Quick scan results are not a substitute for the full result. If a release gate relies on quick scan only, you will occasionally ship an issue that a full scan would have caught, so keep both in your process.
Take quiz
Full scan only
WebInspect crawl only
Quick scan
Manual audit
Higher memory use
Needs no translation
Finds more issues than a full scan
Faster results but fewer findings
30. How do you troubleshoot out of memory errors in Fortify SCA?
Out of memory (OutOfMemoryError) usually means the JVM heap is too small for the project. Raise it with -Xmx, for example sourceanalyzer -Xmx16G -b app -scan, but keep it well below physical RAM.
If you see StackOverflowError instead, increase the thread stack with -Xss.
- Check the scan log to see which phase failed.
- Exclude test, generated and third-party code.
- Split the project into modules and scan separately.
- Use ScanCentral SAST to run on a bigger sensor.
- Tune limiters only as a last resort, since they can reduce depth of analysis.
Memory problems on very large codebases are often better solved by partitioning than by endless heap increases.
Take quiz
-Xss only
-quick
-clean
-Xmx
The thread stack size with -Xss
The SSC license
The number of rulepacks
The FPR compression
31. How do you troubleshoot incomplete translation in Fortify?
If a scan finds surprisingly little, the translation probably missed code. Start by running with -show-build-warnings and -show-files to see what was processed and what was unresolved.
- Confirm the build command ran fully while wrapped by
sourceanalyzer. - Add missing dependencies with
-cpso imports resolve. - Check the source level, for example
-source 17for Java. - Review the log with
-debug -verbose -logfile. - Make sure incremental builds did not skip unchanged files; do a clean build.
Unresolved library calls are the most common cause of missed taint paths, so fixing classpaths often increases real findings.
A useful sanity check is to compare the file count and lines of code in the scan summary with what you expect from the repository. If the scan reports only a fraction of your files, translation is the problem, not the code.
Take quiz
-show-files
-clean
-quick
-merge
It deletes the rulepacks
Unchanged files may be skipped during translation
It disables the Dataflow analyzer
It changes the SSC URL
32. What is the difference between on-premises Fortify and Fortify on Demand?
On-premises Fortify means you install and run SCA, SSC, ScanCentral and WebInspect yourself. Fortify on Demand is the hosted version where OpenText runs the infrastructure.
| Aspect | On-premises | Fortify on Demand |
| Hosting | Your servers | OpenText SaaS |
| Maintenance | You patch and upgrade | Managed for you |
| Control | Full control of data and rules | Less customization |
| Cost model | Licenses | Entitlements |
| Typical fit | Regulated or air-gapped orgs | Teams wanting fast start |
Many companies mix them, for example SCA locally for developers and FoD for audits.
The upgrade story differs as well. On-premises teams plan version upgrades and content updates themselves, while FoD users get new engine versions automatically, which can occasionally change results between two scans of the same code.
Take quiz
Your own admins
OpenText
The developer on each commit
The SSC license server
Fortify on Demand
A public browser plugin
On-premises Fortify
Any SaaS-only tool
33. How do performance indicators and security policies work in SSC?
SSC measures each application version against performance indicators (PIs) such as the Fortify Security Rating, which runs from 1 to 5 stars, or the count of Critical issues. Teams use these to see risk at a glance.
A security policy turns these into pass or fail rules, for example no Critical issues and rating of at least 4 stars. Versions that break the policy are flagged in dashboards and can fail a pipeline gate.
Policies are configured by variables and thresholds in SSC, so different business units can apply different standards without changing the scan itself.
Define PIs around what your organisation actually acts on. A rating nobody understands gets ignored, while a clear rule such as zero open Critical issues older than 30 days gives teams a target they can meet.
Take quiz
The number of developers
The FPR size
A 1 to 5 star measure of an application version's security posture
The build time
Compiles the code
Creates rulepacks
Records macros
Turns metrics into pass or fail rules for a version
34. How do you set up a Fortify security gate in CI/CD?
A gate makes the pipeline fail when risk exceeds your threshold. The flow is: scan, upload to SSC, then query SSC for the result and fail the job if the policy is not met.
- Run the scan and upload the FPR to the right application version.
- Wait until SSC finishes processing the artifact.
- Check the version's policy status or issue counts with
fclior the SSC API. - Exit with a non-zero code if Critical or High issues exceed the limit.
Start in report-only mode for a few sprints, then enforce on new issues first. Gating on legacy backlog from day one usually just gets the gate disabled.
Take quiz
Delete the FPR
Skip the upload
Restart SSC
Fail the job with a non-zero exit code
To avoid blocking teams on legacy findings before they can adapt
Because SSC cannot fail builds
To disable rulepacks
To avoid needing tokens
35. How does WebInspect crawl and audit a web application?
WebInspect works in two stages. The crawl follows links, forms and scripts to build a map of pages and parameters. The audit then sends attack payloads to each discovered input and analyzes responses.
flowchart TD A["Start URL and settings"] --> B["Crawl: discover pages and parameters"] B --> C["Site tree"] C --> D["Audit with scan policy"] D --> E["Send attack requests"] E --> F["Analyze responses"] F --> G["Vulnerability report"]
Modes include Crawl Only, Crawl and Audit and Audit Only. The scan policy, such as Standard, Passive or OWASP Top 10, controls which attacks run.
Crawl quality decides audit quality. If the crawler can't reach a section, say behind a JavaScript-heavy navigation, that part is never attacked. WebInspect's traffic viewer and site tree show what was actually found.
Take quiz
Crawl
Audit
Report
Upload
The FPR name
The scan policy
The Git branch
The Jenkins plugin
36. How do you scan authenticated applications in WebInspect?
Record a login macro that replays the login steps, so WebInspect can sign in and keep a valid session during the scan.
- Record the login with the macro recorder in a browser session.
- Mark the logout condition so WebInspect detects when the session is lost and logs in again.
- Add a workflow macro for multi-step flows such as checkout.
- Exclude logout URLs from crawling so the scan doesn't kill its own session.
Use a dedicated test account with realistic roles. If the app uses MFA, a test bypass or token approach is usually required.
After recording, play the macro back and check that a protected page really loads. Many failed authenticated scans are just a stale macro, where the login form changed and the scanner was never actually logged in.
Take quiz
To speed up DNS
To stop the scanner ending its own session
To reduce FPR size
To disable the audit
A faster compiler
A list of rulepacks
Replayable login steps to keep an authenticated session
An SSC token
37. How do you scan REST APIs with WebInspect?
WebInspect needs an API definition because APIs have no pages to crawl. Depending on version it accepts OpenAPI (Swagger) files, Postman collections and GraphQL schemas.
- Choose the API scan option and import the definition.
- Supply authentication, such as a bearer token or API key.
- Provide realistic sample values for required parameters.
- Select a policy suited to APIs and run the scan.
Without valid samples and auth, most requests fail with 400 or 401 errors and the scan finds little. Check the traffic viewer to confirm requests reach the real logic.
Large APIs benefit from scanning one service at a time, using a scan policy suited to injection and authorization checks. For GraphQL, make sure introspection or the schema file gives the scanner every query and mutation.
Take quiz
A WAR file
A rulepack
An API definition such as OpenAPI
An FPR file
WebInspect ignores APIs
Auth makes scans slower
Only SAST can test APIs
Requests are rejected before reaching real logic
38. What is the difference between ScanCentral DAST and WebInspect?
Both use the same dynamic testing engine, but they are packaged differently. WebInspect is a Windows desktop application that a tester drives directly.
ScanCentral DAST is a scalable, API-driven service managed through SSC. Scans run on containerized sensors, so many scans can run in parallel and be triggered from pipelines.
| Aspect | WebInspect | ScanCentral DAST |
| Style | Desktop, interactive | Server-based, automated |
| Scale | One machine | Multiple sensors |
| Best for | Security testers | CI/CD and large portfolios |
ScanCentral DAST also adds scheduling, per-application configuration and central reporting. A tester who wants to explore interactively, step through a login or tune a crawl by hand, will still reach for WebInspect.
Take quiz
WebInspect desktop
Audit Workbench
FPRUtility
ScanCentral DAST
Through SSC
Through Notepad
Through the Git server
Through the IDE only
39. What is Fortify Aviator and how does it help auditors?
Fortify Aviator is OpenText's AI-assisted auditing capability for static analysis results. Instead of an auditor reading every finding, the AI reviews the code context and suggests whether an issue looks real, with an explanation.
The goal is to cut the noise: less time sorting false positives and more time on the issues that matter. It can also help explain a vulnerability in plain language.
Treat its output as advice, not a final verdict. A human should still review high-risk decisions. Availability depends on your edition and version, so confirm with OpenText.
A sensible rollout is to let it pre-sort a large backlog, then sample its decisions to measure how often auditors agree. That gives you evidence for how far to trust it on your own code base.
Take quiz
Manual effort and noise in triaging static findings
Compile times
Network latency
Database size
As automatically final
As advice reviewed by a human for high-risk items
As a replacement for SCA
As irrelevant
40. How does Fortify handle open source vulnerabilities?
Code you write is only part of the risk. Software composition analysis (SCA of dependencies) checks the third-party libraries you pull in against known vulnerability databases and reports CVEs, licenses and fix versions.
OpenText covers this in the Fortify portfolio through open source scanning in Fortify on Demand and through Debricked, which OpenText acquired in 2023. Older setups used Sonatype integrations.
Note the naming clash: Fortify SCA means Static Code Analyzer, not composition analysis. Results can sit beside SAST findings so teams see both code and dependency risk together.
When a dependency vulnerability is reported, check whether your code actually calls the vulnerable function. Prioritising reachable vulnerabilities over theoretical ones saves a lot of upgrade work.
Take quiz
Only your own source code
Third-party dependencies against known vulnerabilities
Server uptime
UI colors
Software Composition Analysis
Secure Cloud Access
Static Code Analyzer
Source Control Agent
41. How do you map Fortify findings to OWASP Top 10 and other standards?
Fortify categorizes each issue against several taxonomies, including OWASP Top 10, CWE, PCI DSS, NIST and DISA STIG. Each vulnerability category carries these mappings, so you don't tag them by hand.
- In Audit Workbench or SSC, switch to a filter set or grouping by the standard you need.
- Run a built-in report, such as OWASP Top 10 or PCI compliance.
- Export the report as PDF for auditors.
The mapping depends on the content version, so update rulepacks before generating compliance evidence.
Auditors often want one report per standard, such as PCI DSS requirement 6. Remember that the mapping tells you which category a finding belongs to, not whether you are compliant overall.
Take quiz
ISO paper sizes
TCP ports
OWASP Top 10
Unicode blocks
It deletes old issues
It speeds up SSC login
It disables reports
Standards mappings change with content versions
42. How does SSC track the same issue across scans?
Each finding gets an instance ID computed from stable properties such as the category, the sink or function involved and surrounding code context. It deliberately avoids using raw line numbers.
When a new FPR is uploaded to an existing application version, SSC compares instance IDs. Matching issues keep their audit tags, comments and history, even if the code moved a few lines.
Issues with no match are marked new, and ones that vanish are marked removed. If a fixed issue returns later, it is shown as reintroduced.
This is also why renaming or moving a method can occasionally make an old issue show up as new and a removed one at the same time. It is a known side effect, and auditors can use the issue history to reconnect them.
Take quiz
SCA doesn't record them
SSC can't read numbers
They are encrypted
Line numbers shift when code is edited
They carry forward to the new scan
They are deleted
They move to Git
They are emailed
43. How do you create a custom filter set and issue template in SSC?
An issue template defines the folders, filter sets and custom audit tags used by an application version. The default is the Prioritized High Risk Issue Template, with filter sets like Quick View, Security Auditor View and Critical Exposure.
- Export the default template from SSC or Audit Workbench.
- Edit it, for example to add a filter set that hides Low issues or a custom tag like Ticket ID.
- Import it into SSC as a new template.
- Assign it to the application versions that should use it.
Change templates carefully: altering folders affects how every dependent version is displayed.
Take quiz
Folders, filter sets and custom tags for a version
Server TLS settings
The Java classpath
Git hooks
Developer Slack View
Critical Exposure
Raw Logs
Nightly Backup
44. How do you audit a SQL injection finding step by step?
Open the issue in Audit Workbench and follow the data flow trace from source to sink.
- Identify the source: is the input really user-controlled?
- Walk the intermediate steps and look for validation or encoding.
- Inspect the sink: does it build a query by string concatenation?
- Decide: Exploitable if the input reaches the query unsanitized, Not an Issue if a safe cleanse exists, otherwise Suspicious.
- Add a comment with your evidence and file a bug.
A quick check is whether the code uses parameterized queries. Concatenated SQL with request data is nearly always exploitable.
Look for partial defences too. A length check or a blacklist of quote characters rarely stops injection, so don't mark a finding Not an Issue unless a real cleanse such as parameter binding or a whitelist is in the path.
Take quiz
The font of the code
Whether the source is truly user-controlled
The FPR size
The SSC version
Not an Issue
Reliability Issue
Exploitable
Bad Practice
45. How do you fix a SQL injection issue reported by Fortify in Java?
Replace string concatenation with a parameterized query so the database treats input as data, not code.
// Flagged by Fortify String sql = "SELECT * FROM users WHERE email = '" + email + "'"; ResultSet rs = stmt.executeQuery(sql); // Fixed PreparedStatement ps = conn.prepareStatement( "SELECT * FROM users WHERE email = ?"); ps.setString(1, email); ResultSet rs = ps.executeQuery();
Rescan afterwards to confirm the issue disappears. Input validation is a useful extra layer, but it is not a substitute for parameter binding.
In frameworks, prefer their safe APIs, such as JPA named parameters or Spring's JdbcTemplate with placeholders. For dynamic table or column names, which can't be bound as parameters, check them against a fixed allow-list in code.
Take quiz
Add more string concatenation
Escape quotes by hand only
Use PreparedStatement with bound parameters
Catch SQLException silently
Yes, always
Only in Python
Only with HTTPS
No, parameter binding is still needed
46. How do you remediate Cross-Site Scripting findings flagged by Fortify?
XSS happens when untrusted data is written into a page without context-aware output encoding. The fix belongs at the point of output.
// Flagged out.println("<p>Hello " + name + "</p>"); // Fixed (OWASP Java Encoder) out.println("<p>Hello " + Encode.forHtml(name) + "</p>");
Pick the encoder for the context: HTML body, attribute, JavaScript or URL. Frameworks that auto-escape, such as modern template engines, solve most cases.
If Fortify still reports the finding because it doesn't recognize your encoder, add a custom cleanse rule rather than suppressing the issue.
In frontend code, avoid sinks such as innerHTML and document.write and use textContent instead. Content Security Policy is a good defence in depth, but it does not remove the need to fix the flagged code.
Take quiz
Only in the database
Only in the firewall
Only in comments
At output, with context-aware encoding
Add a custom cleanse rule
Delete the encoder
Disable the analyzer
Ignore all XSS
47. How do you exclude test and generated code from a Fortify scan?
Excluding code that isn't shipped reduces noise and scan time. Do it at translation time with -exclude:
sourceanalyzer -b orders -exclude "**/src/test/**" -exclude "**/generated/**" \ mvn clean package
You can also hide issues later using a filter by file path, or in SSC with a filter set. Excluding at translation is more efficient because the files are never analyzed.
Be careful not to exclude shared utility code that production depends on.
Check that the scan summary afterwards shows the expected file count. If a pattern is too broad it can silently remove production code from the scan, and nobody notices until something is missed.
Take quiz
-exclude
-merge
-upload
-scan-only
It deletes the repository
Excluded files are never analyzed
It speeds up Git
It changes the language
48. How can you optimize Fortify scan performance on large codebases?
Scan time depends on code size, memory and analysis depth. Work through the options in this order:
- Exclude tests, generated and vendored code.
- Give SCA enough memory with
-Xmx, without starving the OS. - Use quick scan for fast feedback and full scans nightly.
- Partition a monolith into modules and scan them in parallel on ScanCentral sensors.
- Keep rulepacks current, as updated content can be faster and more accurate.
- Adjust limiters only if needed, understanding that they can cut analysis depth.
Measure first. Check the scan log to see whether translation or analysis is the bottleneck before tuning anything.
Scan time also grows with the number of rules, so removing languages you don't use from the scan configuration helps. Compare timing before and after each change so you know which step actually helped.
Take quiz
Compressing the FPR
Running scans on ScanCentral sensors
Renaming the build ID
Editing the pom
Delete all rulepacks
Add random flags
Check the log to find the bottleneck
Disable translation
49. How do you control access in Fortify Software Security Center?
SSC uses role-based access control. Built-in roles include Administrator, Security Lead, Manager, Developer and view-only users, and you can create custom roles with specific permissions.
Users can be managed locally or linked to LDAP or SSO, which lets group membership decide access. Access is granted per application version, so a developer sees only the projects they own.
For automation, use scoped authentication tokens, for example one that only uploads analysis results, so a leaked CI token can't reconfigure the server.
Review roles on a schedule. Developers who changed teams often keep access they no longer need, and SSC's audit log of user actions helps show who changed an audit tag or a policy.
Take quiz
It makes scans faster
It removes the need for SSC
A leaked token has limited permissions
It encrypts the FPR
Through FPR files
Through WebInspect macros
Through rulepacks
Through LDAP or SSO integration
50. How do you roll out Fortify across a development organization?
Treat it as a process change, not just a tool install. Rollouts that start by blocking every build usually fail.
- Pilot with one or two willing teams and tune rules for their stack.
- Set up SSC, ScanCentral and CI integration with templates that teams can copy.
- Run in report-only mode first and establish a baseline.
- Enforce gates on new Critical and High issues, then tighten gradually.
- Train developers using IDE plugins and short remediation guides.
- Track metrics such as time to fix and open Critical issues per application.
Appoint security champions in each team so audit and triage don't all land on one central group.