Prev Next

Tools / Black Duck: application security testing Interview questions

Last updated

1. What is Black Duck in application security? 2. What is application security testing? 3. What are the main types of application security testing? 4. What is Software Composition Analysis (SCA)? 5. What is Black Duck SCA? 6. What is the Black Duck KnowledgeBase? 7. What is Black Duck Detect? 8. What are the scan types supported by Black Duck SCA? 9. What is a Bill of Materials (BOM) in Black Duck SCA? 10. What are the three risk categories in a Black Duck BOM? 11. What is a Black Duck Security Advisory (BDSA)? 12. What is a policy in Black Duck SCA? 13. What is Coverity in the Black Duck portfolio? 14. What is Seeker IAST? 15. What is Defensics in Black Duck? 16. What is Black Duck Polaris? 17. What is Black Duck Software Risk Manager? 18. What is an SBOM, and how does Black Duck produce one? 19. What is Continuous Dynamic in Black Duck's portfolio? 20. What is Black Duck Binary Analysis (BDBA)? 21. What are the match types in a Black Duck BOM? 22. How does snippet matching work and when should you enable it? 23. How does the Black Duck signature scanner work without uploading source code? 24. How do you fail a CI build on Black Duck policy violations? 25. What are Rapid, Intelligent and Stateless scan modes in Detect? 26. How do you run Coverity analysis on a C/C++ project? 27. How do you triage defects in Coverity Connect? 28. What is the difference between SAST and IAST? 29. How are projects, versions and code locations related in Black Duck SCA? 30. How do you track vulnerability remediation status in a BOM? 31. How does Black Duck assess license risk? 32. How does Black Duck assess operational risk? 33. How does Seeker active verification work? 34. How does generational fuzzing differ from mutation fuzzing in Defensics? 35. How do you scan Docker images with Black Duck? 36. How do you run a Polaris scan from a CI pipeline? 37. Explain the execution flow of a Black Duck Detect scan? 38. How do you troubleshoot missing components in a Detect scan? 39. How do you troubleshoot a Detect scan that cannot connect or times out? 40. When should you choose Rapid scan over a full Intelligent scan? 41. How would you design an application security pipeline using Black Duck tools? 42. How can you reduce false positives in Coverity? 43. How can you optimize Coverity analysis time for large codebases? 44. How does Black Duck help with open source license compliance? 45. How do you prioritize vulnerabilities found by Black Duck SCA? 46. What happens when a new CVE affects a project that was already scanned? 47. Why do C and C++ projects need special handling in SCA? 48. How does Black Duck support compliance with the EU Cyber Resilience Act? 49. Which is better and why: SAST or DAST? 50. How do you secure AI-generated code with Black Duck tools?

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
Which Black Duck product performs static analysis of first-party source code?
Seeker
Defensics
Coverity
Black Duck SCA
Black Duck Software became a standalone company after being separated from:
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
What is the main goal of application security testing?
Find and fix weaknesses before attackers exploit them
Replace code reviews entirely
Measure page response time under load
Which technique inspects source code without executing the application?
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
Which testing type relies on an agent running inside the application?
IAST
SAST
SCA
DAST
Defensics belongs to which category?
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:

  1. Discover components from manifests, files or binaries.
  2. Match them against a vulnerability and license database.
  3. Score security, license and operational risk.
  4. Apply policies that pass or fail the build.

The output is a bill of materials (BOM).

Take quiz
SCA primarily analyzes:
Custom business logic for injection flaws
Network latency between services
Open source and third-party components
What is the typical output of an SCA scan?
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 SCA was previously known as:
Black Duck Hub
Code Dx
Codenomicon Suite
What does a Black Duck SCA scan produce for a project version?
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
Where does Black Duck look up component licenses and vulnerabilities?
The local Maven repository cache
The Black Duck KnowledgeBase
The README of the scanned project
Besides the NVD, which source feeds vulnerability data into the KnowledgeBase?
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
What is Detect's main job?
Compile the project and publish artifacts
Patch vulnerable libraries automatically
Run the applicable scan methods and upload results to Black Duck
Which property tells Detect which server to upload results to?
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
Which scan type fingerprints compiled files and firmware images?
Package manager detection
Binary analysis
Snippet matching
Signature scanning of source folders only
Package manager detection gives the best results when:
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
What does a Black Duck BOM list for a project version?
Only the developer names who committed code
Identified components with versions, licenses and risk
Only the build timestamps
Which feature of the BOM lets you correct a wrong component identification?
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
Which risk category reflects how actively a component is maintained?
License risk
Security risk
Compliance risk
Operational risk
A GPL component inside a closed-source product is mainly a:
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
Who researches and publishes BDSA records?
The Black Duck Cybersecurity Research Center
The Linux Foundation
The component's original authors
What advantage can a BDSA have over a plain NVD entry?
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
What does a Black Duck policy rule evaluate?
The CPU usage of the scan server
The BOM of a project version
The commit messages in the repository
Which action lets you accept a known violation while keeping an audit record?
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
Coverity is best classified as:
An IAST tool
A DAST tool
A SAST tool
A fuzzer
Where do teams triage and track Coverity findings?
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
Where does a Seeker agent run?
Inside the application being tested
Only on the developer's IDE
On the network firewall
Which activity usually provides the traffic that Seeker observes?
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
What does Defensics send to the target under test?
Only valid, well-formed requests
Malformed and unexpected input
Source code patches
Why can Defensics test a closed third-party device?
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
How is Polaris delivered?
As a USB hardware appliance
As a browser extension only
As a hosted SaaS platform
What is a main benefit of Polaris over self-hosted tools?
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
Software Risk Manager is formerly known as:
Code Dx
Seeker Server
Hub
What does SRM do with findings from different scanners?
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
Which two formats are commonly used for exported SBOMs?
JUnit XML and Cobertura
SPDX and CycloneDX
SARIF and Dockerfile
An SBOM generated by Black Duck is derived from:
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
Continuous Dynamic tests an application by:
Reading its source tree line by line
Counting its open source licenses
Probing the running app from the outside
What is a limitation of DAST compared to SAST?
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 is BDBA most useful?
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
How do BDBA results appear in the Black Duck BOM?
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
Which match type most often needs manual review before acceptance?
Direct Dependency
Exact Directory
Snippet
Transitive Dependency
A component declared in your pom.xml is reported as a:
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
What can snippet matching find that package manager detection cannot?
Unpatched operating system kernels
Weak TLS settings on the server
Copy-pasted open source code with no declared dependency
Why do many teams run snippet matching only on release builds?
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
What does the signature scanner send to the server by default?
Hashes of files and folders
The full source tree as a zip
The developer's Git credentials
A folder whose hash equals a known release produces which match type?
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
Which Detect property sets the policy severities that fail a build?
detect.project.name
detect.policy.check.fail.on.severities
blackduck.trust.cert
detect.tools
Which exit code does Detect return for a policy violation?
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
Which scan mode builds a stored BOM on the server?
RAPID
STATELESS
INTELLIGENT
Which mode is intended for fast pull request feedback?
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
Which command captures the compiler invocations of the build?
cov-analyze
cov-commit-defects
cov-configure
cov-build
What does cov-commit-defects do?
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.

  1. Open the issue and read the event trace to follow the data from source to the flagged line.
  2. Set Classification: Bug, False Positive or Intentional.
  3. Set Action, for example Fix Required or Ignore, plus a Severity.
  4. 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
Which Coverity classification marks a finding that is not a real defect?
False Positive
Fix Required
Unclassified
Pending
Why should you add a comment when marking a defect False Positive?
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
Which technique can analyze code paths that no test ever executes?
IAST
Runtime agent profiling
SAST
Why does IAST tend to produce fewer false positives?
It observes real behavior at runtime
It ignores injection flaws
It only checks configuration files

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.

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
Which status fits a vulnerability that cannot be fixed but has a compensating control?
New
Remediation Required
Duplicate
Mitigated
Why add a comment when you set a status to Ignored?
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
Which license family is normally rated as the highest license risk?
Reciprocal (strong copyleft)
Permissive
Weak reciprocal
Public domain dedication
MIT and Apache 2.0 licenses belong to which family?
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
Which signal feeds operational risk?
Commit and release activity of the project
The license family
The CVSS score of one CVE
A high operational risk rating means the component:
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
What does a verified Seeker finding indicate?
The code is formatted correctly
The weakness was confirmed as exploitable
The finding came from a third-party scanner
Where should active verification be run?
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
A generational fuzzer builds test cases from:
Random bytes with no structure
The application's source code
A model of the protocol or file format
What advantage does model-based fuzzing have?
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
Which Detect property scans a Docker image by name?
detect.docker.image
detect.docker.tar.only
detect.image.run
blackduck.docker.pull
Why scan the built image and not only the repository?
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
What does the -w flag do in polaris analyze -w?
Writes a log file only
Waits for the analysis to complete
Wipes the previous results
Where should the Polaris access token be stored in CI?
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"]

  1. Detectors search for build files such as pom.xml, extract the dependency graph, and may need the build tool installed.
  2. The signature scanner hashes files and uploads signatures.
  3. Optional binary and Docker scans add their results.
  4. The server merges everything into one BOM per project version.
  5. 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
In which stage does Detect extract the dependency graph from build files?
Signature hashing
Exit code evaluation
Detector execution
Server connection check
What determines whether Detect fails the pipeline after scanning?
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.

  1. Search depth. Detectors only look a limited number of folders down by default. For multi-module repositories raise --detect.detector.search.depth.
  2. Build tooling. Many detectors call the real tool, so confirm Maven, Gradle or npm is on the PATH of the CI runner.
  3. Lock files. Without a lock file or resolved dependency tree, transitive dependencies may be missing.
  4. Private registries. A failed authentication to an internal repository can leave dependencies unresolved.
  5. Exclusions. Check the exclusion patterns are not hiding folders you care about.
  6. Diagnostics. Run with --detect.diagnostic=true and 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
Which Detect option widens how deep detectors search for build files?
detect.project.name
blackduck.url
detect.risk.report.pdf
detect.detector.search.depth
Vendored libraries with no manifest are best found by:
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.

  1. Confirm the URL opens from the runner itself, not only from your laptop.
  2. Check TLS. A private CA needs to be in the Java trust store. --blackduck.trust.cert=true is acceptable only for testing.
  3. If a proxy sits in the way, set the proxy host and credentials in Detect's proxy properties.
  4. Verify the API token is valid and its user has scanner roles such as Global Code Scanner.
  5. For timeouts, raise --detect.timeout when 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
Which setting is acceptable for quick testing but not production when a certificate is untrusted?
Adding the CA to the Java trust store
blackduck.trust.cert=true
Using a longer API token name
A scan hangs only at the final wait stage. What should you check on the server?
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
Which scan is better suited to quick pull request feedback?
Intelligent scan
Manual BOM export
Rapid scan
Why do you still need Intelligent scans on release branches?
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"]

  1. IDE and pull request: incremental Coverity analysis and a Detect Rapid scan for fast feedback.
  2. CI build: full Coverity or Polaris analysis and an Intelligent Detect scan that stores the BOM.
  3. QA tests: Seeker agents observe functional tests and confirm exploitable issues.
  4. Staging: Continuous Dynamic scans the deployed app, and Defensics fuzzes protocol interfaces where relevant.
  5. Release gate: policy check passes and an SBOM is exported.
  6. 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
Which tool fits best at the QA test stage because it observes running tests?
Coverity
Black Duck Binary Analysis
Seeker
Software Risk Manager
What is the purpose of the release gate in this pipeline?
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.

  1. Incomplete build capture. If headers or compiler flags are missing, Coverity guesses and results suffer. Fix the capture first.
  2. Missing models. If your project has custom allocators, sanitizers or wrappers, add models so Coverity understands what they do.
  3. Over-broad checker sets. Disable checkers that do not apply to your code or standards.
  4. 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
A custom input sanitizer causes repeated taint findings. What is the best fix?
Disable all security checkers
Add a model describing the sanitizer
Delete the intermediate directory every run
Why can incomplete build capture increase false positives?
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-analyze with 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
Which approach gives faster feedback on a pull request?
Run every checker over the full monorepo
Disable build capture
Analyze only the changed files
Which option runs cov-analyze using multiple CPU cores?
--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.

  1. Define license policies, such as blocking AGPL in distributed products.
  2. Scan with detectors, signatures, snippets and binaries so undeclared code is also found.
  3. Review flagged components and record decisions, including whether license terms were fulfilled.
  4. Generate notices and license reports for the attributions your obligations require.
  5. 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
Which scanning method helps find open source nobody declared in a manifest?
Snippet and signature matching
Only reading the license file in the repo
Counting contributors
What does a license policy such as 'block AGPL' do?
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.

  1. Severity: start with the CVSS and BDSA scores.
  2. Exploitability: check whether a public exploit exists.
  3. Exposure: consider whether the component is in an externally reachable service and how it is used.
  4. Reachability: where supported, check whether the vulnerable function is actually called.
  5. 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
Why should you not prioritize by CVSS score alone?
CVSS scores are always wrong
Exposure and reachability change the real risk
Scores are hidden in the BOM
What does upgrade guidance help you decide?
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
Why does a new CVE show up on an old project version without rescanning?
The scanner reinstalls itself nightly
The CVE is copied into the source code
The stored BOM is re-evaluated against updated KB data
Which result type cannot be monitored for new vulnerabilities later?
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
Why is accurate dependency detection hard for C and C++?
There is no standard package manager or manifest
They cannot be compiled
They never use libraries
What does Coverity build capture add to C/C++ SCA?
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
Which CRA expectation is directly supported by a Black Duck SBOM export?
Setting the product's price
Providing a machine-readable list of components
Choosing the company's legal address
Does installing Black Duck make a product CRA compliant?
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
Which technique points a developer to the exact line of vulnerable code?
DAST
Network port scanning
SAST
Which technique can detect a deployment misconfiguration that is not in source code?
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.

  1. Run SAST on every pull request so insecure patterns are caught before merge.
  2. Run SCA on new dependencies, and verify that suggested packages are real and approved.
  3. Enable snippet matching to find generated code that matches open source and carries license duties.
  4. 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.

Take quiz
Why run snippet matching on AI-generated code?
It may reproduce licensed open source fragments
It compresses the generated code
It encrypts prompts
What dependency risk is specific to AI code suggestions?
They always pin the newest release
Suggested packages may be outdated or not exist
They never use packages
«
»

Comments & Discussions