Reachability
A dependency advisory says a package version is vulnerable. It does not say whether your program can reach the vulnerable code. Reachability answers that for Go, from the binaries you actually ship, and from your repository’s code for JavaScript and TypeScript (npm) and, at import level, Python (PyPI) and Java and Kotlin (Maven). It shows you why. For Go it also analyses your repository’s own code (source mode); see below.
What it checks
Go: the binaries you ship
When fremforge rescans the container images in your organisation’s registry, every Go binary that has a vulnerability finding is read by govulncheck in binary mode. govulncheck reads the binary’s module list and symbol table and compares them with the Go vulnerability database, which names the exact functions each advisory affects.
- Nothing in your image is built or run. The binary is read as a file.
- No service is called. The vulnerability database is fremforge’s own copy of the OSV Go records, refreshed daily.
- govulncheck (BSD-3-Clause) is pinned to a release and updated through Renovate.
Terraform and OpenTofu providers: the binaries your locks pin
A Terraform or OpenTofu provider finding is a Go module built into the provider binary your .terraform.lock.hcl pins. fremforge reads that binary with govulncheck in binary mode, as for a Go binary in an image, and the finding gets the verdict: reachable when an affected function is linked into the provider, not reachable when the module (or its package) is in the binary but none of the functions the advisory names are.
- Provider releases are built without a symbol table (
-ldflags=-s). The function table Go keeps at run time is still there; fremforge restores the one symbol govulncheck needs to read it, and the result is the same as for the same provider built with its symbols. If that symbol cannot be found, the verdict staysunknown(no_symbol_table). - Each provider version is analysed once, for every organisation that pins it, from the copy fremforge’s provider mirror keeps. Nothing about your repository is used.
- A provider binary over 512 MiB (for example
hashicorp/aws) keeps the verdictunknown(engine_failed).
Go: your repository’s code
When a dependency scan finds vulnerable Go modules, fremforge also runs govulncheck in source mode on the scanned commit. It type-checks your modules and builds a call graph from your main packages, so it can show the call path from a line in your repository to the affected function, even when no image was built from that commit.
This needs the go command, which a repository can try to steer. fremforge runs it so that nothing from your repository is executed and nothing is fetched except through your organisation’s dependency proxy. The design was reviewed before it shipped.
- Nothing in your repository runs. No
go generate, no tests, no build, no cgo (CGO_ENABLED=0), no-toolexec. Only the Go toolchain’s own type checker reads your code. - No other toolchain. A
toolchainline is ignored (GOTOOLCHAIN=local). Agoline newer than fremforge’s Go makes the moduleunknown(build_failed). fremforge keeps its Go current through Renovate. - No version control and no other network. Modules come only from your organisation’s dependency proxy, through a relay that adds fremforge’s scan credential, so your package policy applies. There is no fallback to a version-control host. If your organisation has turned its dependency proxy off, the scan reads modules from fremforge’s own scan cache on the same proxy instead. That cache holds only public modules from
proxy.golang.org, each checked againstsum.golang.org, and uses no credential of yours, so your package policy does not apply to those reads. An organisation whose proxy refuses a module by its policy getsunknownfor it; the scan never goes around your proxy. - Private modules are never requested. A module under
frem.sh, or matching aGOPRIVATE,GONOPROXYorGONOSUMDBpattern your repository declares (in its CI workflows,go.env,.envrc,.envorMakefile), is refused before any request leaves the scan. Its path is never sent to the dependency proxy, toproxy.golang.orgor tosum.golang.org, and anything that needs it isunknown(build_failed). The same rule applies to the Go licence, release-age and dependency-graph lookups. See what reaches Google for public modules. - Your settings files are not read. A checked-in
GOFLAGSfile,go.envor.config/go/env, avendor/directory and a.netrcare ignored. Symlinks are not followed. - Refused before the analysis, as
unknown(build_failed): a module governed by ago.work(it changes which code is built), areplaceto an absolute path or outside the repository, and a module path that names a version-control repository directly (….git). - Separated from fremforge’s credentials. The analysis runs in its own container that holds no credential and reaches nothing except the relay. It has its own memory and CPU limits.
- Limits: 20 modules, 20,000 files and 128 MiB of your repository per scan, 512 MiB of module downloads, and a time budget of 3 minutes per scan. Over a limit is
unknown. - Tests (
_test.go) are not analysed, as in binary mode. The standard library is judged only in binary mode: source mode would read it at fremforge’s Go version, not yours. - It never fails the scan and never changes the
fremforge/dep-scanstatus.
JavaScript and TypeScript: your repository’s code
When a dependency scan finds vulnerable npm packages, fremforge runs Jelly, a static call-graph analyser for JavaScript and TypeScript from Aarhus University, on the scanned commit. It checks whether your code loads the vulnerable package, directly or through other packages.
Jelly reads your code. It never runs it: nothing is installed, no package code runs and no install script runs.
The packages on the way to a vulnerable one are fetched by name and version and unpacked as data. Each one is checked against the integrity hash in your lockfile, and your repository’s
.npmrcis not used. They come through your organisation’s dependency proxy (see Where package files come from).Each tarball is read as a stream. It is checked against its integrity hash as it arrives, and only the files Jelly reads are written:
.js,.mjs,.cjs,.jsx,.ts,.mts,.cts,.tsxand.json. Native binaries and other large files are skipped without being kept, so a package such asonnxruntime-node(108 MiB) is analysed like any other. Files are kept only when the hash matches.Limits: a tarball of up to 512 MiB, 2 GiB once unpacked, 100,000 entries, 10,000 files written and 16 MiB per written file. All the packages laid out for one lockfile can take up to 96 MiB of written files. A package over a limit makes the findings that need it
unknown(build_failed). A file skipped for its size never lets a finding becomeunreachable.Supported lockfiles:
Lockfile Versions Integrity checked against package-lock.json,npm-shrinkwrap.jsonlockfile version 2 or 3 (npm 7 and later) the lockfile pnpm-lock.yaml5.x, 6 and 9 the lockfile yarn.lock, classicyarn 1 the lockfile ( integrity, or the SHA-1 in an olderresolvedURL)yarn.lock, berryyarn 2 and later ( __metadataversion 4 and later)the integrity your registry publishes for that version, because berry’s checksumcovers yarn’s own cache archive and not the npm tarball. A package whose published integrity cannot be read is not fetched.bun.locktext format (bun 1.2 and later) the lockfile For yarn classic, which records no workspaces, the
package.jsonbeside the lockfile and itsworkspacesare read too.bun.lockb, bun’s older binary format, is not read: it is an undocumented memory image that changed between bun versions. Its findings areunknown, and the evidence says why. Other lockfiles giveunknown.Jelly (BSD-3-Clause) runs inside fremforge’s scan job and calls no service. It is pinned to a release and updated through Renovate.
The analysis has a time budget of 2 minutes per scan. It never fails the scan. It changes the
fremforge/dep-scanstatus only if your organisation opts in to not blocking on not-reachable findings.
Python, Java and Kotlin: your repository’s imports
When a dependency scan finds vulnerable PyPI or Maven packages, fremforge checks whether your code imports them. This is import level only: it tells you a package is loaded, never that the vulnerable code runs, and it never gives unreachable.
Python. Your
.pyfiles are parsed with Python’s ownastmodule, which only parses. Nothing is imported or run. fremforge readsimportandfrom … importstatements, andimportlib.import_module(...)and__import__(...)calls with a literal name. A file that does not parse with current Python, such as Python 2 code, is read line by line for its import statements instead. Relative imports (from . import x) are your own modules and are skipped, as are virtual environments (.venv,venv,site-packages) and symlinks.Python, through other packages. When your code does not import a vulnerable package itself, fremforge follows the packages your code does import: it reads their code from their wheels the same way, starting at the modules your code imports and following only their own imports. If code reached that way imports the vulnerable package, the finding is Imported, and its evidence shows the path: your import, then the import inside each package, for example
idnathroughrequests. A module nothing loads (such as a package’shelp.py) and imports underif TYPE_CHECKING:are not followed. This walk goes at most three packages deep and reads at most 40 wheels of up to 16 MiB each per scan. It only adds Imported verdicts; a path it cannot follow leaves the findingunknown.Java, Kotlin, Groovy and Scala. fremforge reads
importstatements, fully qualified class names in code, andClass.forName("…")andloadClass("…")with a literal name. Comments and string literals are ignored, and so arebuild/andtarget/. Nothing is compiled.Java and Kotlin, through other packages. When your code does not import a vulnerable Maven package itself, fremforge follows the packages your code does import, in their compiled classes. It starts at the classes your code imports (every class of the package for a wildcard
import a.b.*). From there it follows the classes they use: every class a method calls, creates, casts to or reads a field of, and every superclass and interface. These are read from each class file’s constant pool. If a class reached that way uses a class of the vulnerable package, the finding is Imported. Its evidence shows the path: your import, then the source file and line inside each package where the next one is used. An example iscommons-textthroughcommons-configuration2. A class nothing reaches is not followed, and neither is a class loaded by name from a string. Class files are read as data: no class is loaded or run, and no JVM is involved. This walk goes at most three packages deep and reads at most 40 JARs of up to 32 MiB each per scan, one at a time. It only adds Imported verdicts; a path it cannot follow leaves the findingunknown.Which names a package provides comes from the file list of its published archive, read as data:
- PyPI: the wheel for that version. A namespace package resolves to its first real package, for example
google.protobufforprotobuf. - PyPI, a release with no wheel (sdist only): the source archive, read as data and never installed.
setup.pyis neither run nor read. The names come from the package lists insetup.cfgorpyproject.toml(setuptools, hatch, flit and poetry), or else from the directories holding an__init__.py, at the top, undersrc/or under a directory such aslib/. Sopysaml2providessaml2andpycryptoprovidesCrypto.PKG-INFOmust name the same project. Archives up to 16 MiB are read (.tar.gz,.tar,.zip). A release on no index, or an sdist that names nothing (for example a.tar.bz2), falls back to the project name, sorequestsstands forimport requests; the evidence’smappingsays so. - Maven: the JAR on Maven Central, and the Java packages its classes are in.
For a wheel or JAR, only the archive’s directory is fetched, with HTTP range requests, so a large one costs a few kilobytes. The walk through other packages reads the whole wheel or JAR of each package it follows, and an sdist is always read whole. Nothing is installed, built or run.
- PyPI: the wheel for that version. A namespace package resolves to its first real package, for example
Your repository is not built. Java reachability with call graphs, such as osv-scanner’s experimental JAR analysis or
jdeps, needs a built JAR. A pull request scan does not build your project, so those tools are not used.The analysis has a time budget of 1 minute per ecosystem per scan, running alongside the npm analysis. It never fails the scan and never changes the
fremforge/dep-scanstatus.
Where package files come from
npm tarballs, PyPI indexes and wheels, and Maven JARs are read through your organisation’s dependency proxy, on an internal route that only fremforge’s scan service can reach. So your organisation’s package policy, cache, storage cap and upstream rate apply to them as to any other pull, and what the scan fetches is cached for your builds.
- If your policy refuses a package (for example malware, a release too new, or a licence rule), the scan does not fetch it anywhere else. The findings that need it are
unknown(build_failed), and the evidence names the proxy’s decision. - If your organisation has the dependency proxy turned off, or the proxy cannot answer, the files are read from the public registries (npmjs, PyPI, Maven Central) instead, as before.
- Files the scan fetches count towards your organisation’s proxy storage like any other cached file.
The levels
A verdict has a level: how much the engine could see.
| Level | Meaning |
|---|---|
function | The advisory names the affected functions, and the engine looked for a path to them. This is what govulncheck gives for Go. |
import | The advisory names no affected functions. The engine can only say whether the vulnerable package is loaded. |
npm advisories almost never name affected functions. When this was measured on 2026-10-12, none of the 230,287 npm records in the OSV database did. So JavaScript and TypeScript verdicts are import level: they tell you that your code loads the vulnerable package, not that it calls the vulnerable code. If an npm advisory does name affected functions, Jelly checks them at function level.
Python and Maven verdicts are always import level. The same measurement found affected-function data in 2 of 26,221 PyPI records and in none of the 7,190 Maven records.
The three verdicts
Every dependency and image finding carries one of these:
| Verdict | Go (govulncheck) | JavaScript and TypeScript (Jelly) | Python, Java and Kotlin (import level) |
|---|---|---|---|
| Reachable | An affected function is linked into the binary. The Go linker drops code nothing can call, so a linked function is one your program can reach. The marker names the function, for example html.Renderer.renderLink. In source mode: a call path from your code reaches an affected function; the marker gives the file and line of the last call in your repository before the path enters the dependency, for example your handler rather than main. The whole path is in the evidence. | Import level, shown as Imported: your code loads the package at the vulnerable version, directly or through other packages. Function level, shown as Reachable: a call in your code may reach an affected function. The marker gives the file and line in your repository, for example src/session.ts:12. | Shown as Imported: your code imports a module or Java package that the vulnerable package provides. The marker gives the file and line of the import, for example app/main.py:2. |
Not reachable (unreachable) | The module is in the binary at an affected version, the advisory names the affected functions, govulncheck ran to completion, and none of those functions is in the binary. In source mode: the module is used at an affected version, govulncheck found no call path to any affected function, and nothing govulncheck cannot follow (reflection, files for other platforms, cgo, plugins) is in your code. | The advisory names the affected functions, Jelly ran to completion with every package on the way available, and no call in your code reaches one. Without that function data a package your code never loads is unknown, not unreachable. | Never. Imports inside other packages are followed only as far as they name a module or class literally, so a package your code does not seem to load may still be loaded. |
| Unknown | Everything else. This is the default, and it is never treated as safe. | The same. | The same, including every package your code does not import. |
unreachable needs all of its conditions. A missing input always gives unknown, with the reason:
| Reason | Why |
|---|---|
no_symbol_data | The advisory does not name the affected functions, so the absence of a path proves nothing. For npm this is the usual reason when your code does not load the package. For Python and Maven it is the reason whenever your code does not import the package. |
no_symbol_table | Go: the binary was built with -ldflags=-s. Its symbols cannot be read, so neither verdict is earned. Build without -s (keeping -w is fine) to get verdicts. Terraform providers: the symbol fremforge restores could not be found in this binary. |
build_failed | Go source mode: the module was refused before the analysis (see above), could not be loaded, or a module could not be fetched from your dependency proxy. npm: the lockfile is not one of the supported formats, or a package on the way could not be fetched, was over a limit, or did not match its integrity hash. Python and Maven: the wheel, sdist or JAR could not be read, for example a POM-only artifact or one not on Maven Central. |
dynamic_code | Your code loads modules or classes by computed names, so a missing call path or import proves nothing. npm: require(name) and import(name). Python: importlib.import_module(name) and __import__(name). Java: Class.forName(name) and loadClass(name). Go source mode: the plugin package or //go:linkname. |
reflection | Go source mode: your code calls methods through reflect (MethodByName, Method, Call), or uses text/template or html/template when the advisory names methods. govulncheck cannot follow those calls, so a missing call path proves nothing. |
build_constraints | Go source mode: a file the analysis did not load imports other packages. The analysis loads your code as for Linux on amd64 without cgo, so a _windows.go file, a file whose //go:build line excludes Linux, or a cgo file is not in the call graph, and a call made only there would be missed. A package that only builds with cgo (for example a desktop UI on a cgo-only toolkit) is left out of the analysis instead of failing it: the rest of the module is analysed, and every module that package imports gets this reason rather than unreachable. |
timeout | The analysis ran over its time budget (5 minutes per image for Go, 2 minutes per scan for npm, 1 minute per ecosystem per scan for Python and Maven). |
engine_no_match | Go: govulncheck did not report this module version as affected by the advisory, although the image scanner did. Neither is trusted over the other. |
oom_killed | Go source mode: the analysis ran out of memory and was stopped, so nothing was decided. |
engine_failed | The analysis could not run on this binary or repository. |
not_analysed | No verdict has been computed: the finding has not been scanned since reachability was added, or a Go finding has no image built from its commit. |
unsupported_ecosystem | A dependency finding outside Go, npm, PyPI, Maven and Terraform providers, for example NuGet or Cargo. |
Dependency findings
Go. A Go dependency finding gets its verdict in binary mode, from an image built from exactly that commit. Where source mode is on (fremforge’s internal organisations so far), it also gets one at every scan, with the call path in your repository. Label your images with the two standard OCI labels:
org.opencontainers.image.source=https://frem.sh/<org>/<repo>
org.opencontainers.image.revision=<full commit sha>docker/metadata-action sets both. The verdict applies only to the commit the image names and to the module versions the binaries were built with. If any Go binary in that image could not be read, the dependency finding stays unknown. If several binaries carry the module, the finding is reachable when any of them reaches it.
When both modes judge the same finding at the same commit, neither erases the other: an unknown from one never replaces a verdict from the other, and not reachable from one never replaces reachable from the other. Source-mode evidence carries "mode": "source".
npm, PyPI and Maven. Verdicts come with the dependency scan itself: every pull request scan, and the scan of your default branch after each push (at most once an hour). A verdict always belongs to the commit that was scanned. If the same package and advisory appear in several lockfiles, the finding is reachable when any of them reaches it.
How fremforge uses it
Ranking. The Dependencies and Container images findings lists are ordered reachable first, then unknown, then not reachable. Within each group they are ordered by severity, then known exploited before the rest, then by EPSS. A finding is known exploited when any of its CVE ids, its own or its advisory’s aliases, is listed as exploited by ENISA’s EU Vulnerability Database or by CISA’s Known Exploited Vulnerabilities catalogue. Both lists show a Known exploited badge whose tooltip names the source: EU (ENISA EUVD), US (CISA KEV), or both, and above each list Known exploited only shows just those findings (the findings API’s ?known_exploited=true). Both lists are refreshed daily. An Imported finding ranks with the reachable ones. The same order is used by:
- the Recommendations tab, where a card (one upgrade of one package in one repository) takes the most reachable verdict of the findings it fixes and is marked Reachable or No call path;
- the weekly digest’s Top fixable today, which shows each row’s verdict;
- the findings API with
?sort=risk.
Alerts. When an open dependency finding becomes reachable, or becomes known exploited, your SIEM gets an audit event at once and the organisation’s security contacts get an email, once per finding: see Finding alerts. Known exploited, and reachable at HIGH or CRITICAL severity, are mailed at once. Reachable at MEDIUM or LOW severity goes into each person’s daily alert summary, or at once for someone who has switched the summary off. The setup checklist on Security › Overview shows which of your images have Go binaries without symbols.
The probably unexploitable group. Findings that are not reachable move to a collapsed group at the bottom of the list, titled with their count. They stay visible, selectable and dismissable, and they are counted in every total.
Nothing is hidden or dismissed. A verdict never writes a dismissal. It changes a finding’s SLA only when your organisation opts in to the SLA multiplier. By default the commit status (fremforge/dep-scan, fremforge/image-scan) does not read verdicts: what blocks a merge or a pull is unchanged. The one exception is the opt-in policy not to block pull requests on not-reachable findings, which applies to fremforge/dep-scan only.
SLA multiplier (opt-in)
An organisation owner can stretch the severity SLA of findings that are not reachable, under Security › Prioritise › Fix-by SLA (/<org>/_admin/security/prioritise/sla), or with unreachable_sla_multiplier on PUT /orgs/{org}/security/sla-policy. The value is a whole number from 1 to 4. The default, 1, is off.
- Only
unreachablefindings are stretched. Reachable and unknown findings always keep the full SLA, and so does a finding that has not been analysed. - A known-exploited finding (listed by EU (ENISA EUVD) or US (CISA KEV), see Ranking above) is never stretched, at any severity and whatever its verdict.
- A critical finding whose EPSS score is in the top 10 % (percentile 0.90 or more) is never stretched, whatever its verdict.
- The deadline is always counted from when the finding was first seen. When a later scan finds a call path, or cannot decide, the full SLA applies again at once, so the finding can go straight to over SLA. The SLA pill then says why.
- With the multiplier on, a stretched SLA pill shows a small
×2(or×3,×4) and a tooltip with both deadlines. The weekly digest’s past-SLA count, the overview tile and thecode-security.sla.breachedSIEM event use the same stretched deadlines. - The multiplier changes deadlines only. It does not change what blocks a pull request, and it hides nothing.
Every change is audited as code-security.sla_policy.updated, with the previous value.
Do not block on findings that are not reachable (opt-in)
By default, every dependency finding at or above your block threshold blocks the pull request, whatever its verdict. An organisation owner can choose that a finding with not reachable does not block fremforge/dep-scan. It is off unless you turn it on.
Turn it on under Security › Prioritise › Pull request checks (/<org>/_admin/security/prioritise/pr-checks), or with PUT /orgs/{org}/security/dep-scan-unreachable-policy (see API). You can limit it to a list of repositories; an empty list means every repository in the organisation.
What it changes, and what it never changes:
- Only
unreachablewith evidence qualifies. The finding’s verdict for the pull request’s head commit must be not reachable, computed by an engine with its version and the advisory’s affected functions it checked. Today that means Go and JavaScript and TypeScript. For Go, govulncheck gives the verdict in binary mode once an image built from the pull request’s head commit has been scanned; a verdict that arrives after the scan applies from the pull request’s next scan. Where source mode is on (fremforge’s internal organisations so far), it also gives one at the pull request scan itself. For JavaScript and TypeScript, Jelly gives it when the advisory names affected functions. Python, Java and Kotlin verdicts are import level and are neverunreachable, so they always block. unknownalways blocks. There is no option not to block onunknown, and a finding that was not analysed isunknown.- Malware and known-exploited vulnerabilities always block, whatever the verdict: a
MAL-advisory or an advisory marked malicious, and a vulnerability any of whose CVE ids is listed as exploited by EU (ENISA EUVD) or US (CISA KEV). If fremforge cannot read these facts during a scan, nothing is let through on that scan. - Nothing is hidden. The finding is stored, listed, counted in every total and alerted like any other. It is not dismissed, and its SLA is unchanged (unless the SLA multiplier is also on).
- Pull requests only. The scan of your default branch is recorded exactly as before.
- Deny-list hits and the block threshold are unchanged. A finding below the threshold never blocked, and a denied component still blocks.
The block returns. When a later scan of the pull request finds a call path, or cannot decide, the finding blocks again. A verdict computed outside a scan (govulncheck on an image) and the policy being switched off or narrowed are picked up within the hour: fremforge re-checks every pull request that passed on the policy and recomputes its status, comment and audit event. The same happens when a finding becomes known exploited.
What the pull request shows. The fremforge/dep-scan status says how many findings did not block, for example 2 finding(s); 1 at or above critical with no call path, not blocking (org policy). The comment marks each such finding not blocking and lists them under Not blocking: no call path (org policy) with the engine, its version, the vulnerability database date and the functions it checked. A finding with no call path that blocks anyway is listed under Blocking although no call path was found, with the reason (malware or known exploited).
Audit. Every change to the policy is audited as code-security.deps.unreachable_policy.updated, with the new and the previous value, whether it changed, and whether it came from the console or the API. Every pull request scan while the policy applies records, in its code-security.dep_scan.ingest event, each finding that did not block (unreachable_not_blocking, with the engine, version and database date relied on) and each that blocked anyway (unreachable_blocked_anyway, with why). A re-check carries trigger: unreachable_policy_recheck and the reason. Both reach your SIEM endpoints.
When a verdict changes: reachability_changed
A dismissal or an exception can rest on a verdict. When you dismiss a dependency or image finding whose verdict is not reachable, or ask for an exception for it, fremforge records the verdict it relied on: the engine, its version, the database date and the commit or image it was computed on. The dismiss panel says so.
Every hour, fremforge checks those dismissals and exceptions. When a scan after the dismissal finds the same finding reachable, or cannot decide (unknown):
- an exception is revoked with the reason
reachability_changed; - a plain dismissal is revoked: the finding opens again, and a repo-wide dismissal it made stops applying to later scans;
- the finding alerts again through the same security alert as an expired dismissal;
- both are audit events (
code-security.exception.revoked, orcode-security.deps.dismissal_revokedandcode-security.images.dismissal_revoked) with the verdict relied on and the new one, and they reach your SIEM endpoints. The finding event says so too:security.finding.exception_revoked, or for a plain dismissalsecurity.finding.dismissal_revoked, both withtransition_reasonreachability_changed.
A finding that has not been analysed again keeps its dismissal: the absence of a new scan is not a new verdict. A dismissal made while the verdict was not unreachable records nothing and is never revoked by this check, and dismissals made before this was added are not checked. If you dismissed a finding for a reason that does not depend on reachability, dismiss it again after the revoke; the verdict is then no longer unreachable, so the new dismissal stays.
SAST triage signals
SAST findings have no call graph, so three deterministic signals rank them instead. No AI model is involved.
| Signal | What it is |
|---|---|
| Location | From the file path: test code (test/, __tests__/, *.test.ts, *_test.go, test_*.py, *Test.java and similar), examples and docs, third-party code (vendor/, third_party/, node_modules/) and generated code (*.pb.go, *.min.js, gen/, zz_generated* and similar). |
| Taint path | OpenGrep’s taint-mode rules trace data from a source, such as user input, to the sink. A match with a trace is marked Taint path and ranks above a pattern-only match. Only the fact is stored, never the trace. |
| Often dismissed here | People dismissed the same rule on at least 2 other findings in this repository, or 5 in the organisation, in the last 90 days. Bots, auto-resolve and other system actors do not count. |
A finding in test, example, third-party or generated code, or one marked often dismissed here, moves to a collapsed Lower confidence group at the bottom of the SAST list, titled with its count. A taint path does not move a finding out of that group: a taint match in a test file is still in a test file. Within each group, findings are ordered by severity, then taint path, then age, oldest first.
Like the probably unexploitable group, lower-confidence findings are never hidden or dismissed: they keep their full SLA, are counted everywhere, and can be selected, fixed and dismissed like any other. The SAST findings API returns the signals as a triage object on every finding, and ?sort=risk lists findings in this order across pages.
Pull request comment. The dependency scan comment orders findings the same way and marks each with its verdict when one exists for the pull request’s commit: reachable with the function or the file and line, imported with the file and line (npm, Python, Java and Kotlin), or no call path. With the policy not to block on not-reachable findings on, it also lists which findings did not block and why.
Measuring coverage
The share of your open dependency findings with a verdict, and the share that is not reachable, per ecosystem and over 30 or 90 days, are on the remediation metrics page.
What static analysis cannot see
A missing call path is strong evidence, not proof. Neither engine sees code reached through reflection, plugins, unsafe, eval, dependency injection or generated code, or code outside what was analysed: a separate CLI, a shared library, or for Go anything outside the binary. An advisory can also name the wrong functions.
For Go source mode the call graph covers your main packages and exported functions as built for Linux on amd64 without cgo. Calls through interface values and function values are followed. Calls through reflection, and calls only in files for other platforms or in cgo files, are not, which is why those findings are unknown (reflection, build_constraints) instead of not reachable.
For JavaScript and TypeScript the call graph is approximate. Jelly is a research-grade analyser, and a dynamic require or import() stops any unreachable verdict for the repository. An Imported verdict says the package is loaded. It does not say the vulnerable code runs.
For Python and for Java and Kotlin, imports through other packages are followed (see above). For Python this works only as far as their code names a module literally. For Java and Kotlin it works only as far as their compiled classes name a class. A package that loads modules or classes by computed names, ServiceLoader or reflection is not followed past that point. Frameworks that load classes from configuration, such as JDBC drivers and dependency injection, are not seen either. A Java or Kotlin package used only that way shows as unknown even though it is loaded.
That is why the group is called probably unexploitable and why every verdict shows the engine, its version and the database date: check the evidence before you dismiss a finding.
API
Every finding from GET /orgs/{org}/code-security/deps/findings and GET /orgs/{org}/code-security/images/findings carries a reachability object. For a Go binary:
"reachability": {
"verdict": "reachable",
"level": "function",
"reason_unknown": null,
"engine": "govulncheck",
"engine_version": "v1.8.0",
"db_version": "2026-10-10T11:47:18Z",
"advisory_id": "GO-2026-5320",
"evidence": {
"binary": "usr/local/bin/app",
"frames": [{ "module": "github.com/yuin/goldmark", "package": "github.com/yuin/goldmark/renderer/html", "receiver": "Renderer", "function": "renderLink" }]
},
"computed_at": "2026-10-12T05:40:00.000Z"
}For Go source mode, the frames run from your repository’s entry point to the affected function, through the standard library and your own handler (a planted test, 2026-10-13):
"reachability": {
"verdict": "reachable",
"level": "function",
"reason_unknown": null,
"engine": "govulncheck",
"engine_version": "v1.8.0 (source, go1.27.2)",
"db_version": "2026-10-10T11:47:18.507452919Z",
"advisory_id": "GO-2026-6278",
"evidence": {
"mode": "source",
"manifest": "reach-go/a/go.mod",
"module": "github.com/gorilla/websocket",
"version": "v1.5.0",
"symbols": ["github.com/gorilla/websocket.*Upgrader.Upgrade"],
"frames": [
{ "file": "reach-go/a/main.go", "line": 22, "go_package": "example.com/a", "function": "main" },
{ "file": "src/net/http/server.go", "line": 3604, "package": "stdlib@v1.27.2", "go_package": "net/http", "receiver": "*Server", "function": "Serve" },
{ "file": "src/net/http/server.go", "line": 2358, "package": "stdlib@v1.27.2", "go_package": "net/http", "receiver": "HandlerFunc", "function": "ServeHTTP" },
{ "file": "reach-go/a/main.go", "line": 13, "go_package": "example.com/a", "function": "handler" },
{ "file": "server.go", "line": 125, "package": "github.com/gorilla/websocket@v1.5.0", "go_package": "github.com/gorilla/websocket", "receiver": "*Upgrader", "function": "Upgrade" }
]
},
"computed_at": "2026-10-13T19:43:52.589Z"
}A frame without package is in your repository, with a repository-relative file. A frame with package is in a dependency or the standard library, and its file is relative to that module. At most 8 frames are kept: the entry point, then the last 7 down to the affected function (the example above leaves 3 standard-library frames out).
For an npm package your code loads through another package:
"reachability": {
"verdict": "reachable",
"level": "import",
"reason_unknown": null,
"engine": "jelly",
"engine_version": "0.13.0",
"db_version": "2026-10-12T02:00:00.000Z",
"advisory_id": "GHSA-pxg6-pf52-xh8x",
"evidence": {
"manifest": "package-lock.json",
"package": "cookie",
"version": "0.6.0",
"frames": [
{ "file": "src/server.ts", "line": 3 },
{ "file": "index.js", "line": 9, "package": "express@4.21.0" },
{ "file": "index.js", "line": 1, "package": "cookie@0.6.0" }
]
},
"computed_at": "2026-10-12T09:15:00.000Z"
}For a Python package your code imports:
"reachability": {
"verdict": "reachable",
"level": "import",
"reason_unknown": null,
"engine": "python-imports",
"engine_version": "1.1.0 (python 3.13.5)",
"db_version": "2026-10-12T02:00:00.000Z",
"advisory_id": "GHSA-9hjg-9r4m-mvj7",
"evidence": {
"manifest": "requirements.txt",
"package": "requests",
"version": "2.31.0",
"mapping": "wheel requests-2.31.0-py3-none-any.whl",
"provides": ["requests"],
"frames": [{ "file": "app/main.py", "line": 2 }]
},
"computed_at": "2026-10-12T15:00:00.000Z"
}For a Python package loaded only through another package, frames is the path, as for npm, and via names the packages on it:
"evidence": {
"manifest": "requirements.txt",
"package": "idna",
"version": "3.6",
"mapping": "wheel idna-3.6-py3-none-any.whl",
"provides": ["idna"],
"via": ["requests@2.32.3"],
"frames": [
{ "file": "app/main.py", "line": 2 },
{ "file": "requests/models.py", "line": 401, "package": "requests@2.32.3" }
]
}Maven verdicts have the same shape, with engine jvm-imports, mapping naming the JAR and provides listing its Java packages. Through another package, a frame inside a JAR names the source file from the class’s debug information and the line where the next package’s class is used. The line is 0 when no instruction uses it, as for an implemented interface:
"evidence": {
"manifest": "pom.xml",
"package": "org.apache.commons:commons-text",
"version": "1.9",
"mapping": "jar commons-text-1.9.jar",
"via": ["org.apache.commons:commons-configuration2@2.7"],
"frames": [
{ "file": "src/main/java/app/App.java", "line": 3 },
{ "file": "org/apache/commons/configuration2/PropertiesConfiguration.java", "line": 1663, "package": "org.apache.commons:commons-configuration2@2.7" }
]
}For an sdist-only Python release, mapping names the sdist and how the names were found, for example sdist pysaml2-4.4.0.tar.gz, package directories under src/.
The first npm frame is the line in your repository. The frames after it are files and lines inside the packages on the way, each named with its version.
A pull request finding also carries block_waived: "unreachable" when the policy not to block on not-reachable findings let it pass fremforge/dep-scan at its last scan, otherwise null. It is not a dismissal.
The policy itself is read in dep_scan_unreachable_policy on GET /orgs/{org}/security and set with PUT /orgs/{org}/security/dep-scan-unreachable-policy (scope policy:write):
{ "enabled": true, "repos": ["web", "acme/api"] }enabled is required. repos takes names of your organisation’s repositories, bare or as org/name; leave it out, or send [], for every repository. The answer has the stored policy, the previous one and whether it changed.
Add ?reachability=reachable, unreachable or unknown to list only those. The three values partition the list. Without the parameter every finding is returned. Evidence holds code locations only, never code content.
Add ?sort=risk to list findings in triage order: verdict (reachable, then unknown or not analysed, then not reachable), then severity, then known exploited (dependency and image findings), then EPSS for dependency findings, then the oldest first. Paging with offset is stable in this order. Without it, or with sort=created, findings are listed newest first, as before.
Each SAST finding from GET /orgs/{org}/code-security/sast/findings carries its triage signals:
"triage": {
"confidence": "lower",
"reasons": ["test"],
"location": "test",
"dataflow": true,
"dismissed_before": { "repo": 0, "org": 1, "days": 90 }
}dataflow is true for a taint match, false for a pattern-only match and null for a finding raised before the signal existed. The next scan of the repository fills it in.