Tools / Black Duck: application security testing Interview questions
Last updated
1. What is Black Duck in application security?
Black Duck is an application security vendor whose portfolio covers static analysis, software composition analysis, interactive testing, dynamic testing, fuzzing, and risk management. It became an independent company in 2024 when the Synopsys Software Integrity Group was spun out.
The products you will hear about in interviews are Coverity (SAST), Black Duck SCA (open source and license risk), Seeker (IAST), Continuous Dynamic (DAST), Defensics (protocol fuzzing), Polaris (SaaS platform) and Software Risk Manager (ASPM). Newer material also mentions Signal, aimed at AI-assisted development.
A simple way to answer: each tool targets a different risk. Coverity looks at your own code, SCA looks at the components you pull in, and Seeker, Continuous Dynamic and Defensics look at the running application.
Take quiz
Seeker
Defensics
Coverity
Black Duck SCA
Synopsys
Veracode
Micro Focus
2. What is application security testing?
Application security testing (AST) is the practice of finding security weaknesses in an application before an attacker does. It covers the code you write, the libraries you depend on, the running application, and the APIs it exposes.
No single technique sees all of that, so teams combine several: SAST for source code, SCA for third-party components, DAST and IAST for runtime behavior, and fuzzing for robustness against malformed input.
The business case is cost. A flaw caught in a pull request is a small fix, while the same flaw in production means an incident, a patch cycle and possibly disclosure.
Take quiz
Find and fix weaknesses before attackers exploit them
Replace code reviews entirely
Measure page response time under load
SAST
DAST
Load testing
Penetration testing of the live site
3. What are the main types of application security testing?
There are five techniques you should be able to name and place on the Black Duck map: SAST, SCA, DAST, IAST and fuzzing. They differ in what they look at and when they can run.
| Type | What it analyzes | Needs running app | Black Duck product |
| SAST | Source code or bytecode | No | Coverity |
| SCA | Open source and third-party components | No | Black Duck SCA |
| DAST | Running web app or API from outside | Yes | Continuous Dynamic |
| IAST | App behavior via an in-process agent | Yes | Seeker |
| Fuzzing | Protocols and parsers under malformed input | Yes | Defensics |
Take quiz
IAST
SAST
SCA
DAST
SAST
Fuzz testing
SCA
IAST
4. What is Software Composition Analysis (SCA)?
SCA identifies the open source and third-party components inside an application and maps each one to known vulnerabilities, license obligations and maintenance health. It does not look for flaws in the code your team wrote.
It matters because modern applications are mostly assembled from libraries. One vulnerable transitive dependency can expose an application that has perfectly clean first-party code.
A typical SCA run follows four steps:
- Discover components from manifests, files or binaries.
- Match them against a vulnerability and license database.
- Score security, license and operational risk.
- Apply policies that pass or fail the build.
The output is a bill of materials (BOM).
Take quiz
Custom business logic for injection flaws
Network latency between services
Open source and third-party components
A bill of materials with vulnerability and license data
A list of failed unit tests
A memory dump of the application
5. What is Black Duck SCA?
Black Duck SCA is Black Duck's software composition analysis product, formerly known as Black Duck Hub. It scans your code, builds and binaries, identifies the open source inside them, and reports security, license and operational risk.
The server is usually deployed on your own infrastructure and is backed by the Black Duck KnowledgeBase for component, license and vulnerability data. SCA is also available through the Polaris platform.
Results are stored per project version as a BOM. From there you can set policies, track remediation, generate reports and export an SBOM.
Take quiz
Black Duck Hub
Code Dx
Codenomicon Suite
A compiled build artifact
A BOM listing components with their risks
A firewall rule set
6. What is the Black Duck KnowledgeBase?
The Black Duck KnowledgeBase (KB) is a curated database of open source projects, versions, licenses, vulnerabilities and project activity data. Scans identify what is in your code, and the KB tells you what that means.
Vulnerability data comes from the NVD and from Black Duck Security Advisories (BDSA). License data includes the license text, family and obligations.
The KB is maintained by Black Duck, not by you. Your server keeps in sync with it, which is why vulnerabilities published after a scan can still show up on an existing BOM.
Take quiz
The local Maven repository cache
The Black Duck KnowledgeBase
The README of the scanned project
Stack Overflow answers
Package download counts
Black Duck Security Advisories
7. What is Black Duck Detect?
Detect is the main command-line scanner for Black Duck SCA. It is a Java application that works out which scan methods apply to a project, runs them, and uploads the results to the Black Duck server.
The methods it can run include package manager detectors, the signature scanner, binary analysis and Docker image scanning. Because it is a single command, it drops easily into Jenkins, GitHub Actions, GitLab and other CI systems.
java -jar detect.jar \ --blackduck.url=https://blackduck.example.com \ --blackduck.api.token=$BD_TOKEN \ --detect.project.name=shop-api \ --detect.project.version.name=1.4.0
The jar name changes between versions, and many teams call Detect through its wrapper script instead.
Take quiz
Compile the project and publish artifacts
Patch vulnerable libraries automatically
Run the applicable scan methods and upload results to Black Duck
detect.project.name
blackduck.url
detect.tools
detect.risk.report.pdf
8. What are the scan types supported by Black Duck SCA?
Black Duck SCA identifies components in five main ways. Each has a different strength, and most real projects use more than one.
| Scan type | How it identifies components | Best for |
| Package manager (detectors) | Reads manifests and lock files such as pom.xml or package-lock.json | Declared direct and transitive dependencies |
| Signature | Hashes files and folders and matches them to the KB | Vendored or copied open source |
| Snippet | Matches fragments of code to open source | Copy-pasted code |
| Binary (BDBA) | Unpacks and fingerprints compiled files | Firmware, installers, third-party binaries |
| Container | Inspects image layers and OS packages | Docker images |
Take quiz
Package manager detection
Binary analysis
Snippet matching
Signature scanning of source folders only
The project has no build files
A manifest or lock file describes the dependencies
All code is minified
9. What is a Bill of Materials (BOM) in Black Duck SCA?
The BOM is the list of every component Black Duck identified in a project version, together with its version, license, match type and risk. It is the central object you work with after a scan.
For each row you can see the vulnerabilities, license terms, usage (for example dynamically linked or source), and where the component was found. You can also mark components as reviewed, ignore them, or adjust a wrong identification.
Policies, reports and SBOM exports are all generated from the BOM, so its accuracy depends directly on scan coverage.
Take quiz
Only the developer names who committed code
Identified components with versions, licenses and risk
Only the build timestamps
Rebooting the Black Duck server
Changing the project phase
Editing or adjusting the component match
10. What are the three risk categories in a Black Duck BOM?
Black Duck rates each component on security risk, license risk and operational risk, and shows the counts as color-coded bars in the BOM.
| Category | Based on | Example finding |
| Security | Known vulnerabilities and their severity scores | A component version with a critical CVE |
| License | License family and its obligations | A strong copyleft license in a proprietary product |
| Operational | Project health and age of the version | A library with no commits for years |
Operational risk is the one people forget. A component can be clean today and still be a poor choice if nobody maintains it.
Take quiz
License risk
Security risk
Compliance risk
Operational risk
License risk
Security risk
Operational risk
11. What is a Black Duck Security Advisory (BDSA)?
A BDSA is a vulnerability record researched and published by the Black Duck Cybersecurity Research Center. It covers open source vulnerabilities and is delivered through the KnowledgeBase.
BDSA entries often appear earlier than the NVD entry and can include additional details such as affected versions, CVSS scoring, and remediation or workaround guidance. Some BDSA records have no CVE at all.
Access to BDSA data is typically a separate subscription from the base product, so check your license before relying on it.
Take quiz
The Black Duck Cybersecurity Research Center
The Linux Foundation
The component's original authors
It always has a lower severity score
It may be published earlier and include remediation guidance
It replaces the need for scanning
12. What is a policy in Black Duck SCA?
A policy is a set of rules evaluated against a BOM to decide whether a project version is acceptable. Each rule has conditions, such as vulnerability severity or license, and a severity that shows how serious a violation is.
Typical rules: block components with critical vulnerabilities, flag strong copyleft licenses, or restrict specific components by name. Violations are classified from Blocker down to Trivial.
A violation can be overridden with a comment when the risk is accepted, which leaves an audit trail instead of silently weakening the rule.
Take quiz
The CPU usage of the scan server
The BOM of a project version
The commit messages in the repository
Deleting the policy rule
Re-running the scan until it passes
Overriding the policy violation with a comment
13. What is Coverity in the Black Duck portfolio?
Coverity is Black Duck's static application security testing (SAST) engine. It analyzes source code without running it and reports both security vulnerabilities and quality defects such as null dereferences and resource leaks.
It supports many languages, including C and C++, Java, C#, JavaScript, Python and Go. Its strength is deep interprocedural, path-sensitive analysis that follows data across function and file boundaries, which keeps noise lower than simple pattern matching.
Findings are managed in Coverity Connect, where teams triage issues, assign owners and track trends.
Take quiz
An IAST tool
A DAST tool
A SAST tool
A fuzzer
Coverity Connect
Detect
The KnowledgeBase
14. What is Seeker IAST?
Seeker is Black Duck's interactive application security testing product. A lightweight agent runs inside the application and watches real requests, data flow and library use while the app is exercised.
Exercise can come from QA functional tests, automation or a DAST scan, so there is no separate attack phase. Seeker reports vulnerabilities with the request and the code path involved, and its active verification can confirm that an issue is really exploitable.
Agents exist for common runtimes such as Java, .NET and Node.js, and the data goes to a Seeker server for correlation.
Take quiz
Inside the application being tested
Only on the developer's IDE
On the network firewall
Scheduled database backups
QA functional tests or automation
Compiler warnings
15. What is Defensics in Black Duck?
Defensics is Black Duck's fuzz testing tool. It sends deliberately malformed, unexpected or boundary-case input to a target and watches for crashes, hangs, memory errors and other signs of weak input handling.
It works from test suites that model protocols and file formats such as HTTP, TLS, MQTT and Bluetooth. Because it needs no source code, you can fuzz third-party devices or services as a black box.
Typical users are teams building embedded devices, network equipment, automotive and medical products, where a parser crash is a safety or availability problem.
Take quiz
Only valid, well-formed requests
Malformed and unexpected input
Source code patches
It decompiles the firmware first
It replaces the device's operating system
It does not need access to the source code
16. What is Black Duck Polaris?
Polaris is Black Duck's SaaS application security platform. It brings static analysis and software composition analysis into one hosted service with central projects, issue views and policies.
Teams scan through the Polaris CLI, CI plugins or IDE integrations, and results appear in a shared dashboard without anyone running a Coverity Connect or Black Duck server.
The main trade-off against the self-hosted products is control. Hosting, upgrades and scaling are handled for you, but you work within the platform's configuration model.
Take quiz
As a USB hardware appliance
As a browser extension only
As a hosted SaaS platform
No server infrastructure to run and upgrade yourself
It scans without any configuration
It removes the need for a CI pipeline
17. What is Black Duck Software Risk Manager?
Software Risk Manager (SRM) is Black Duck's application security posture management (ASPM) product, formerly known as Code Dx. It collects findings from many scanners into one place.
It ingests results from Black Duck tools and from third-party SAST, DAST and SCA tools, then normalizes, de-duplicates and correlates them. Instead of ten tools reporting the same SQL injection, you see one finding with several confirmations.
From there you set risk-based priorities, route issues to ticketing systems and track remediation across the whole portfolio.
Take quiz
Code Dx
Seeker Server
Hub
Deletes them after thirty days
Normalizes and de-duplicates them into one view
Converts them into unit tests
18. What is an SBOM, and how does Black Duck produce one?
A software bill of materials (SBOM) is a formal, machine-readable inventory of the components in a piece of software, with versions, suppliers and dependency relationships.
Black Duck builds an SBOM from the BOM of a project version. You can export it from the UI or the REST API in standard formats such as SPDX and CycloneDX, and share it with customers or auditors.
An SBOM is only as complete as the scan behind it. If a binary or vendored library was never scanned, it will not appear.
Take quiz
JUnit XML and Cobertura
SPDX and CycloneDX
SARIF and Dockerfile
Developer chat history
The server's CPU logs
The BOM of a scanned project version
19. What is Continuous Dynamic in Black Duck's portfolio?
Continuous Dynamic is Black Duck's dynamic application security testing (DAST) service. It scans running web applications and APIs from the outside, the way an attacker would, and reports issues such as injection flaws and insecure configuration.
It is delivered as a service and designed for recurring scans rather than a one-off assessment, so new exposures are caught as the application changes.
DAST needs no source code and works regardless of language, but it can only report what it manages to reach, so unexercised paths remain untested.
Take quiz
Reading its source tree line by line
Counting its open source licenses
Probing the running app from the outside
It only finds issues in code paths it can reach
It requires access to source code
It only works for C programs
20. What is Black Duck Binary Analysis (BDBA)?
BDBA identifies open source components and vulnerabilities in compiled artifacts when you have no source: firmware images, installers, archives and disk images.
With Black Duck SCA, Detect uploads the binary to the BDBA scanner running alongside the server. BDBA unpacks it, fingerprints the contents, and returns results that merge into the BOM with the Binary match type. The uploaded file is deleted once scanning finishes.
It is most useful for supplier-delivered software, embedded firmware, and legacy builds where the source is gone.
Take quiz
When you need to analyze compiled artifacts without source
When you only have unit test reports
When you need to rewrite code in another language
With the Snippet match type
With the Binary match type
They stay in a separate PDF only
21. What are the match types in a Black Duck BOM?
A match type tells you how Black Duck decided a component is present. It is the first thing to check when you doubt a finding, because some match types are far more reliable than others.
| Match type | Meaning | Confidence |
| Direct Dependency | Declared in a manifest of your project | High |
| Transitive Dependency | Pulled in by one of your dependencies | High |
| Exact Directory / Exact File | Folder or file hashes identical to a known release | High |
| Partial File | File resembles a known file with changes | Medium |
| Snippet | Fragment of code resembles open source | Needs review |
| Binary | Identified inside a compiled artifact | Depends on method |
Snippet matches in particular should be reviewed by a person before you act on them.
Take quiz
Direct Dependency
Exact Directory
Snippet
Transitive Dependency
Snippet match
Binary match
Direct Dependency
22. How does snippet matching work and when should you enable it?
Snippet matching compares small fragments of your source files with a large index of open source code in the KnowledgeBase. It can find code that was copied and pasted into your project even though no dependency was ever declared.
Enable it when licensing exposure is the concern: proprietary products with outsourced code, acquisitions, or teams using code assistants that may reproduce open source. It adds scan time and produces matches that need review, so most teams run it on release branches rather than every commit.
In Detect it is switched on through the signature scanner setting:
--detect.blackduck.signature.scanner.snippet.matching=SNIPPET_MATCHING
Review results with Confirm or Ignore actions so the BOM reflects reality.
Take quiz
Unpatched operating system kernels
Weak TLS settings on the server
Copy-pasted open source code with no declared dependency
It adds scan time and its matches need human review
It only works on release tags
It deletes the previous BOM
23. How does the Black Duck signature scanner work without uploading source code?
The signature scanner walks a directory and computes hashes (signatures) of files and folders locally. It sends those signatures, not the source, to the Black Duck server, which compares them with the KnowledgeBase.
If a folder hash equals the hash of a known open source release, the result is an Exact Directory match. Individual files that match produce Exact File or Partial File matches.
Uploading source is a separate, optional mode used so reviewers can see matched code in the UI. Without it, your code never leaves the build machine. Use exclusion patterns to keep build output and test folders from adding noise.
Take quiz
Hashes of files and folders
The full source tree as a zip
The developer's Git credentials
Snippet
Exact Directory
Manual match
24. How do you fail a CI build on Black Duck policy violations?
Tell Detect which policy severities should break the build. When any BOM policy violation of those severities exists, Detect exits with a policy failure code, and the CI job fails.
java -jar detect.jar \ --blackduck.url=$BD_URL --blackduck.api.token=$BD_TOKEN \ --detect.project.name=shop-api --detect.project.version.name=$GIT_BRANCH \ --detect.policy.check.fail.on.severities=BLOCKER,CRITICAL
Detect then waits for the server to finish building the BOM and evaluating policies, and returns exit code 3 on violation. Most CI systems treat any non-zero code as a failed step.
Start with BLOCKER and CRITICAL only. Failing on everything from day one usually trains developers to ignore the gate.
Take quiz
detect.project.name
detect.policy.check.fail.on.severities
blackduck.trust.cert
detect.tools
0
1
3
25. What are Rapid, Intelligent and Stateless scan modes in Detect?
Detect's scan mode controls whether results are kept on the server and how fast you get feedback. It is set with detect.blackduck.scan.mode.
| Mode | Results stored | Typical use |
| INTELLIGENT | Yes, full BOM | Main branch and release scans |
| RAPID | No | Quick policy feedback on pull requests |
| STATELESS | No | Ephemeral checks with fuller results than Rapid |
Because only INTELLIGENT builds a persistent BOM, only INTELLIGENT scans benefit from later vulnerability updates and remediation tracking. Details of what each mode supports can vary by version, so confirm against your Detect release. In practice, pull requests use RAPID, while nightly and release builds use INTELLIGENT so the shipped version stays monitored.
Take quiz
RAPID
STATELESS
INTELLIGENT
RAPID
INTELLIGENT
Manual upload
26. How do you run Coverity analysis on a C/C++ project?
Coverity analysis for compiled languages has three phases: capture the build, analyze what was captured, and commit the results to Coverity Connect.
cov-configure --gcc cov-build --dir idir make cov-analyze --dir idir --enable-default cov-commit-defects --dir idir --url https://coverity.example.com:8443 \ --stream shop-core --auth-key-file ~/.coverity/authkey
cov-build wraps your normal build and records every compiler call, so Coverity sees exactly the files and flags you built. cov-analyze writes defects into the intermediate directory (idir). cov-commit-defects uploads them to a stream.
Add security checker options, such as --security or --webapp-security, when the goal is vulnerability findings rather than quality defects.
Take quiz
cov-analyze
cov-commit-defects
cov-configure
cov-build
Compiles the program
Uploads analysis results to a Coverity Connect stream
Deletes the intermediate directory
27. How do you triage defects in Coverity Connect?
Triage means deciding what each defect is and who fixes it. In Coverity Connect you set a few attributes on each issue, and those settings are shared by everyone viewing the same project.
- Open the issue and read the event trace to follow the data from source to the flagged line.
- Set Classification: Bug, False Positive or Intentional.
- Set Action, for example Fix Required or Ignore, plus a Severity.
- Assign an Owner and add a comment explaining the decision.
Triage decisions persist across snapshots, so a defect marked False Positive does not reappear next scan. Write the reason in the comment, because the next reviewer will not remember.
Take quiz
False Positive
Fix Required
Unclassified
Pending
Coverity refuses to save without one
It makes the analysis run faster
Later reviewers need to know why it was dismissed
28. What is the difference between SAST and IAST?
SAST reads code without running it. IAST watches the application while it runs. That single distinction drives most of the practical differences.
| Aspect | SAST (Coverity) | IAST (Seeker) |
| Needs running app | No | Yes, with an agent |
| Coverage | All code paths, including unexecuted | Only paths exercised by tests |
| Typical stage | IDE, pull request, build | QA and integration testing |
| Evidence | Static trace through code | Real request with runtime data flow |
| False positive tendency | Higher without tuning | Lower, issues are observed |
Teams usually run both. SAST gives early broad coverage, and IAST confirms what is really exploitable in a running build.
Take quiz
IAST
Runtime agent profiling
SAST
It observes real behavior at runtime
It ignores injection flaws
It only checks configuration files
29. How are projects, versions and code locations related in Black Duck SCA?
A project represents an application or product. Each project version represents a release or branch of it, with its own BOM, phase and distribution type. A code location is the record of one scan that feeds a project version.
One version can combine several code locations, for example a source scan, a binary scan and a container scan, and the BOM merges them. Rescanning the same code location replaces its earlier results rather than adding duplicates.
Naming matters. Stable project and version names in CI keep history clean, while generating a new name on every run floods the server with orphaned versions.
Take quiz
The result of one scan feeding a project version
A physical office of the company
A user's access role
A second duplicate BOM is always created
The earlier results of that scan are replaced
The project is deleted
30. How do you track vulnerability remediation status in a BOM?
Each vulnerability on each component has a remediation status that you update as work progresses. It starts as New and moves to a status that records the decision.
Common statuses are Remediation Required, Remediation Complete, Mitigated, Patched, Ignored and Duplicate. The exact list can vary by version.
Always add a comment, especially for Ignored and Mitigated, so an auditor can see the reasoning. Setting the status also affects how the vulnerability counts toward risk and can be used in policy rules, so triage before you gate builds on it.
Take quiz
New
Remediation Required
Duplicate
Mitigated
It lowers the CVSS score
It speeds up scanning
It leaves an audit trail for the decision
31. How does Black Duck assess license risk?
License risk comes from the license family of each component, which reflects how restrictive its obligations are.
| Family | Examples | Typical risk |
| Reciprocal (strong copyleft) | GPL, AGPL | High |
| Weak reciprocal | LGPL, MPL, EPL | Medium |
| Permissive | MIT, Apache 2.0, BSD | Low |
Components with an unknown or unrecognized license should be treated as high risk until someone identifies the real terms.
Weak copyleft licenses usually require sharing changes to the library itself, while strong copyleft can extend to the whole combined work, which is why the two are rated differently. The rating is a screening signal, not legal advice. How a component is linked or distributed changes the real obligations, so legal teams still decide on edge cases.
Take quiz
Reciprocal (strong copyleft)
Permissive
Weak reciprocal
Public domain dedication
Permissive
Reciprocal
Weak reciprocal
32. How does Black Duck assess operational risk?
Operational risk estimates how well maintained a component is. It looks at signals of project health, such as how recently the version was released, how many newer versions exist, and commit and contributor activity.
A component with an old release, few contributors and no recent commits scores higher than one with steady activity. The rating helps you spot dependencies that will be hard to patch when a vulnerability eventually appears.
It does not mean the component is currently vulnerable. Treat it as a planning input: replace or fork abandoned libraries before an incident forces the decision.
Take quiz
Commit and release activity of the project
The license family
The CVSS score of one CVE
Has a confirmed critical exploit
May be poorly maintained and hard to patch later
Uses a copyleft license
33. How does Seeker active verification work?
When Seeker spots untrusted input reaching a dangerous operation, it can send modified requests to the application to check whether the weakness is really exploitable, using its in-process agent to observe the result.
A successful check marks the finding as verified. That separates confirmed issues from theoretical ones, which saves triage time.
Run it against test or staging systems only. Verification traffic is crafted input, and you do not want it hitting production data. Verification also works best when the agent is attached to the same build that QA is testing.
Take quiz
The code is formatted correctly
The weakness was confirmed as exploitable
The finding came from a third-party scanner
Production only
On developer laptops without the app
Test or staging environments
34. How does generational fuzzing differ from mutation fuzzing in Defensics?
A generational fuzzer builds test cases from a model of the protocol or format, so it knows the structure and can break it deliberately. A mutation fuzzer starts from sample inputs and randomly changes them.
Defensics is best known for model-based test suites. Because the model understands message structure, it reaches deep protocol states that random mutation would rarely hit, such as inputs that pass an initial checksum or handshake.
| Approach | Starting point | Strength |
| Generational | Protocol or format specification | Deep, structured anomalies |
| Mutation | Captured sample inputs | Quick setup, little knowledge needed |
Take quiz
Random bytes with no structure
The application's source code
A model of the protocol or file format
It can reach deep protocol states past handshakes
It never produces crashes
It runs without a target
35. How do you scan Docker images with Black Duck?
Point Detect at the image by name or at an exported tar file. Detect extracts the layers, reads OS package databases and language manifests, and uploads the results as a BOM.
java -jar detect.jar \ --blackduck.url=$BD_URL --blackduck.api.token=$BD_TOKEN \ --detect.docker.image=registry.example.com/shop/api:1.4.0 \ --detect.project.name=shop-api --detect.project.version.name=1.4.0
Use --detect.docker.tar when the image is exported to disk. Container results include OS-level packages such as openssl and glibc, which are often where critical findings hide.
Scan the image you actually ship, not only the source repository. A clean application with an outdated base image is still a vulnerable deployment.
Take quiz
detect.docker.image
detect.docker.tar.only
detect.image.run
blackduck.docker.pull
Repositories never contain dependencies
Base image OS packages can carry vulnerabilities
Images contain no open source
36. How do you run a Polaris scan from a CI pipeline?
Install the Polaris CLI on the runner, provide the server URL and an access token as secrets, and run the analyze command. The CLI reads a configuration file (polaris.yml) that describes how to capture your code.
export POLARIS_SERVER_URL=https://example.polaris.blackduck.com export POLARIS_ACCESS_TOKEN=$POLARIS_TOKEN polaris analyze -w
The -w flag makes the command wait for the analysis to finish, so the pipeline step reflects the outcome. Without it the job returns right after upload.
Keep the token in your CI secret store, not in the repository. File names, flags and defaults can differ by CLI version, so check the current Polaris documentation.
Take quiz
Writes a log file only
Waits for the analysis to complete
Wipes the previous results
In polaris.yml committed to Git
In the README
In the pipeline's secret store
37. Explain the execution flow of a Black Duck Detect scan?
A Detect run is a sequence of stages, and knowing the order helps you decide where a failure came from. Detect first loads configuration and checks it can reach the server, then runs each enabled tool, uploads what they produce, and finally evaluates policy.
flowchart TD A["Start Detect and load properties"] --> B["Connect to Black Duck server"] B --> C["Run detectors on build files"] B --> D["Run signature scan on source folder"] B --> E["Optional binary or Docker scan"] C --> F["Upload dependency graph as BDIO"] D --> G["Upload signatures"] E --> G F --> H["Server builds BOM"] G --> H H --> I["Wait for results and check policy"] I --> J["Return exit code"]
- Detectors search for build files such as pom.xml, extract the dependency graph, and may need the build tool installed.
- The signature scanner hashes files and uploads signatures.
- Optional binary and Docker scans add their results.
- The server merges everything into one BOM per project version.
- Detect waits, evaluates policy, and exits with a code your CI understands.
A failure in stage 1 means a configuration or connectivity problem. A missing component usually points to stage 2 or 3.
Take quiz
Signature hashing
Exit code evaluation
Detector execution
Server connection check
The exit code it returns after the policy check
The size of the scan log
The number of detectors installed
38. How do you troubleshoot missing components in a Detect scan?
Missing components almost always mean a detector did not run or ran with incomplete input. Work from the cheapest check to the most expensive one.
- Search depth. Detectors only look a limited number of folders down by default. For multi-module repositories raise
--detect.detector.search.depth. - Build tooling. Many detectors call the real tool, so confirm Maven, Gradle or npm is on the PATH of the CI runner.
- Lock files. Without a lock file or resolved dependency tree, transitive dependencies may be missing.
- Private registries. A failed authentication to an internal repository can leave dependencies unresolved.
- Exclusions. Check the exclusion patterns are not hiding folders you care about.
- Diagnostics. Run with
--detect.diagnostic=trueand read the produced archive.
If dependencies are vendored rather than declared, no detector will find them. That is when the signature or snippet scan is the right tool.
Take quiz
detect.project.name
blackduck.url
detect.risk.report.pdf
detect.detector.search.depth
Raising Maven's heap size
Signature or snippet scanning
Disabling the detectors
39. How do you troubleshoot a Detect scan that cannot connect or times out?
Separate connection problems from waiting problems. Detect reports them with different exit codes, for example 1 for server connectivity and 2 for a timeout.
- Confirm the URL opens from the runner itself, not only from your laptop.
- Check TLS. A private CA needs to be in the Java trust store.
--blackduck.trust.cert=trueis acceptable only for testing. - If a proxy sits in the way, set the proxy host and credentials in Detect's proxy properties.
- Verify the API token is valid and its user has scanner roles such as Global Code Scanner.
- For timeouts, raise
--detect.timeoutwhen the BOM build is slow, then check the server's job queue for a backlog.
A common trap is blaming Detect when the server is busy. Large scans queue behind other jobs, and the real fix is capacity or scheduling on the server side.
Take quiz
Adding the CA to the Java trust store
blackduck.trust.cert=true
Using a longer API token name
The developer's IDE theme
The Git branch name
The job queue for a backlog
40. When should you choose Rapid scan over a full Intelligent scan?
Use Rapid when the question is "does this change break policy?" and you need the answer in a pull request. Use Intelligent when you need a durable BOM for reporting, remediation tracking and continuous monitoring.
| Need | Rapid | Intelligent |
| Fast PR feedback | Yes | Slower |
| Stored BOM and history | No | Yes |
| Vulnerability updates after the scan | No | Yes |
| Remediation workflow | No | Yes |
A sound setup uses both. Rapid scans guard pull requests, and an Intelligent scan runs on the main or release branch so the shipped version is tracked. Skipping the second step means a vulnerability published next month will never be raised against code you already released. Treat Rapid as a gate, not as your system of record.
Take quiz
Intelligent scan
Manual BOM export
Rapid scan
They store a BOM that can be monitored for new vulnerabilities
Rapid scans cannot detect any vulnerability
Intelligent scans skip policies
41. How would you design an application security pipeline using Black Duck tools?
Place each tool where its feedback is cheapest and most actionable, and keep fast checks early.
flowchart LR A["IDE plugin"] --> B["Pull request"] B --> C["CI build"] C --> D["QA tests"] D --> E["Staging"] E --> F["Release gate"] F --> G["Production monitoring"]
- IDE and pull request: incremental Coverity analysis and a Detect Rapid scan for fast feedback.
- CI build: full Coverity or Polaris analysis and an Intelligent Detect scan that stores the BOM.
- QA tests: Seeker agents observe functional tests and confirm exploitable issues.
- Staging: Continuous Dynamic scans the deployed app, and Defensics fuzzes protocol interfaces where relevant.
- Release gate: policy check passes and an SBOM is exported.
- Production: the stored BOM is monitored for newly published vulnerabilities.
Software Risk Manager can sit across all stages to de-duplicate findings and give security one prioritized backlog.
Take quiz
Coverity
Black Duck Binary Analysis
Seeker
Software Risk Manager
Rewrite source code automatically
Enforce policy and export an SBOM before shipping
Delete older project versions
42. How can you reduce false positives in Coverity?
Start by checking whether the finding is truly false, then fix the cause rather than only dismissing results. Most noise comes from four places.
- Incomplete build capture. If headers or compiler flags are missing, Coverity guesses and results suffer. Fix the capture first.
- Missing models. If your project has custom allocators, sanitizers or wrappers, add models so Coverity understands what they do.
- Over-broad checker sets. Disable checkers that do not apply to your code or standards.
- Triage hygiene. Mark real false positives with a classification and comment so they stay dismissed.
Also keep Coverity updated, since newer releases improve checker precision. Do not dismiss findings in bulk, because the same discipline that quiets noise also hides real defects.
Take quiz
Disable all security checkers
Add a model describing the sanitizer
Delete the intermediate directory every run
It makes cov-analyze skip every file
It changes the license of the code
Coverity analyzes with missing headers or flags and has to guess
43. How can you optimize Coverity analysis time for large codebases?
Analysis time grows with code size and the number of enabled checkers, so reduce both and use the available hardware.
- Parallelism: run
cov-analyzewith multiple jobs, for example--jobs auto. - Scope: exclude third-party and generated code that you will not fix anyway.
- Checkers: enable only the sets you act on instead of everything.
- Changed files: use desktop or incremental analysis on pull requests and keep the full analysis for scheduled builds.
- Splitting: separate very large products into components or streams that can be analyzed independently.
Measure before tuning. Check how long capture, analysis and commit each take, because a slow build capture needs a different fix than a slow analysis.
Take quiz
Run every checker over the full monorepo
Disable build capture
Analyze only the changed files
--jobs auto
--no-threads
--serial-mode
44. How does Black Duck help with open source license compliance?
Black Duck turns license compliance from a manual spreadsheet into a repeatable process built on the BOM.
- Define license policies, such as blocking AGPL in distributed products.
- Scan with detectors, signatures, snippets and binaries so undeclared code is also found.
- Review flagged components and record decisions, including whether license terms were fulfilled.
- Generate notices and license reports for the attributions your obligations require.
- Re-check on each release as dependencies change.
Policy catches known problems. Snippet and binary scanning catch the ones nobody declared, which is what matters most in acquisitions and outsourced development.
Assign a named reviewer per project, since unreviewed license flags tend to pile up until a release deadline forces rushed decisions.
Take quiz
Snippet and signature matching
Only reading the license file in the repo
Counting contributors
Rewrites AGPL code as MIT
Flags or fails builds that contain AGPL components
Hides AGPL components from the BOM
45. How do you prioritize vulnerabilities found by Black Duck SCA?
Do not sort by CVSS score alone. A critical score on a component that is never reached is less urgent than a high score on an internet-facing code path.
- Severity: start with the CVSS and BDSA scores.
- Exploitability: check whether a public exploit exists.
- Exposure: consider whether the component is in an externally reachable service and how it is used.
- Reachability: where supported, check whether the vulnerable function is actually called.
- Fix effort: use the upgrade guidance, which suggests short-term and long-term target versions.
Then record the decision with a remediation status and comment, so the reasoning is auditable. Policies can enforce the top tier automatically. Revisit the ranking regularly rather than once per release, because exploit information and scores change after publication.
Take quiz
CVSS scores are always wrong
Exposure and reachability change the real risk
Scores are hidden in the BOM
Which license to choose
Which scan mode to run
Which fixed version to move to
46. What happens when a new CVE affects a project that was already scanned?
If the project version has a stored BOM, Black Duck re-evaluates it against updated KnowledgeBase data and the new vulnerability appears on the existing component without a rescan.
Policies are then evaluated again, so a version that passed last month can now be in violation. Notifications and integrations can alert the owners.
This is the main reason to keep an Intelligent scan for each shipped release. Rapid and Stateless results are not stored, so there is nothing to update, and you only learn about the problem the next time someone scans. Subscribe owners of important projects to notifications so a new finding reaches a person without anyone opening the UI.
Take quiz
The scanner reinstalls itself nightly
The CVE is copied into the source code
The stored BOM is re-evaluated against updated KB data
Rapid scan results
Intelligent scan results
BOM with a stored version
47. Why do C and C++ projects need special handling in SCA?
C and C++ have no standard package manager, so there is usually no manifest listing dependencies. Libraries get vendored, copied into the tree, or installed with OS packages.
A plain signature scan of a build folder is noisy: it can pick up files that were never compiled, and miss files pulled in from outside the folder. Black Duck's C/C++ approach uses Coverity build capture to learn exactly which sources, headers and object files went into the build.
Those files are then identified in several ways: the Linux package manager for system libraries, signature matching for source, and binary analysis for linked objects. The result is a more accurate BOM with fewer false positives than scanning the directory alone.
Take quiz
There is no standard package manager or manifest
They cannot be compiled
They never use libraries
It encrypts the source tree
It records exactly which files were compiled and linked
It replaces the compiler
48. How does Black Duck support compliance with the EU Cyber Resilience Act?
The Cyber Resilience Act (CRA) requires makers of products with digital elements to manage vulnerabilities, ship security updates and document their components, including a machine-readable SBOM. Obligations are phased in, with vulnerability reporting duties starting before the full requirements, so confirm current dates with your legal team.
| CRA expectation | Where Black Duck helps |
| Know your components | SCA BOM across source, binary and container scans |
| Provide an SBOM | SPDX or CycloneDX export |
| Handle vulnerabilities | Continuous monitoring and remediation tracking |
| Find flaws in own code | Coverity, Seeker and fuzzing with Defensics |
Tooling produces evidence. It does not make a product compliant by itself, because the CRA also covers process, support periods and reporting.
Take quiz
Setting the product's price
Providing a machine-readable list of components
Choosing the company's legal address
Yes, automatically on installation
Yes, but only for C programs
No, it provides evidence but process obligations remain
49. Which is better and why: SAST or DAST?
Neither is better in general. They answer different questions, so the right choice depends on what you need to find and when.
| Factor | SAST | DAST |
| Needs running app | No | Yes |
| Finding location | Exact file and line | URL and parameter |
| Coverage | All code, including unexecuted | Only reachable behavior |
| Runtime and config issues | Mostly missed | Found |
| Best stage | Early, in the IDE and CI | Staging and ongoing |
SAST helps developers fix issues quickly because it points at the line. DAST proves what an outsider can actually reach, including misconfigurations that never appear in code.
For example, a hard-coded secret is a SAST finding, while an exposed admin endpoint is more likely found by DAST.
Use both, and add IAST where you want runtime confirmation with code-level detail.
Take quiz
DAST
Network port scanning
SAST
DAST
SAST
License scanning
50. How do you secure AI-generated code with Black Duck tools?
Treat AI-generated code like code from an unknown contributor: it can be insecure, it can reproduce open source, and it can suggest dependencies that are outdated or that do not exist.
- Run SAST on every pull request so insecure patterns are caught before merge.
- Run SCA on new dependencies, and verify that suggested packages are real and approved.
- Enable snippet matching to find generated code that matches open source and carries license duties.
- Gate merges with policies so findings block the build instead of piling up.
Black Duck also markets Signal as agentic application security for AI-powered development. Check its current documentation for what it covers before planning around it.