SESTRAV is a solo-maintained, academic research project developed at the University of Rhode Island. There is one active maintainer. Please keep this in mind when setting expectations around response timelines.
Only the latest major release of SESTRAV is actively supported with security updates.
| Version | Supported |
|---|---|
| 2.0.x | ✅ |
| < 2.0 | ❌ |
Please do NOT open a public GitHub Issue for security vulnerabilities. Public disclosure before a fix is available puts all users at risk.
Send a confidential report to the maintainer directly:
Email: gavinmborges1104@gmail.com
Please include the following in your report:
- Summary: A clear description of the vulnerability and its potential impact.
- Reproduction steps: Step-by-step instructions to reproduce the issue, including any sample inputs, scripts, or configuration needed.
- Environment: Python version, OS, relevant package versions.
- Proposed fix (optional): Any remediation ideas or patches you have.
GitHub's built-in private reporting is also available:
- Navigate to the SESTRAV Security tab.
- Click "Report a vulnerability".
- Fill in the advisory form. The report is private: it goes to the repository's maintainers rather than to a public issue, and GitHub adds you to it as a collaborator. GitHub does not describe it as encrypted end to end.
As a solo-maintained project, the maintainer commits to:
- Acknowledge receipt of your report within 3-5 business days.
- Provide an initial assessment (severity, scope, reproducibility) within 10 business days of acknowledgement.
- Coordinate a fix and disclosure timeline with you collaboratively.
- Credit reporters in the release notes (unless you prefer anonymity).
Responsible disclosure helps keep SESTRAV and its users safe. Thank you for taking the time to report vulnerabilities privately.
SESTRAV is led by a single active maintainer; the v1 collaborators credited in
CONTRIBUTORS.md are no longer active. There is no backup maintainer and no
succession arrangement, and none is planned - GOVERNANCE.md and BUS_FACTOR.md
record that honest status rather than a continuity plan.
The project therefore cannot survive the loss of the maintainer as a maintained project. What it does have is weaker but real: the source, full history and build procedure are public and MIT-licensed, so a third party may fork and continue the work independently. If you are assessing whether a security report will be actioned in the maintainer's absence, assume it will not be.
All accounts with write access to this repository MUST have Two-Factor Authentication (2FA) enabled on GitHub. In practice that is one account, the sole maintainer's.
Release artifacts are distributed via GitHub Releases over HTTPS with a
SHA-256 checksum manifest, SHA256SUMS.txt, written by the "Generate SHA-256
checksum manifest" step of .github/workflows/release.yml, which lets consumers
verify integrity:
sha256sum -c SHA256SUMS.txt # run in the directory holding the files it listsWhat it lists depends on the release. For the two shipped releases, v2.0.2 and
v2.0.3, it lists the wheel and the sdist, which with SHA256SUMS.txt itself are
their only uploaded assets (GitHub's auto-generated source archives are covered by
neither the checksums nor the attestation). The current workflow, which no tag has
run yet, writes it over dist/ (the sdist, the wheel and the .intoto.jsonl
attestation bundle) and also uploads a results-bundle ZIP and its
*.manifest.json, neither of which SHA256SUMS.txt lists. That JSON manifest is
written by src/release_bundle.py and records the SHA-256 of each results/ file
packed into the ZIP; it is not in sha256sum format, so sha256sum -c cannot
check it. The ZIP is covered by the provenance attestation below; the JSON
manifest is covered only through the copy packed inside the ZIP. SHA256SUMS.txt
itself carries no attestation, so the attestation below does not cover every
uploaded asset: gh attestation verify on it returns HTTP 404 for its digest,
while the wheel and the sdist each resolve one (read 2026-10-02, v2.0.3).
Release authenticity (signing) is automated by
.github/workflows/release.yml: pushing a version
tag builds the distribution and produces a keyless SLSA build-provenance
attestation (Sigstore, via GitHub OIDC - no maintainer-managed keys). From the
release at which signing is introduced onward:
-
Tags: v2.0.3 IS signed with an SSH key and carries a signature block; v2.0.2 and earlier are annotated but unsigned.
version_tags_signedis nevertheless still Unmet, for a different reason than "no signed tag exists": GitHub reports v2.0.3 as unverified with reasonunknown_key, because the SSH key that signed it is not the signing key registered on the account. A signing key IS registered, and GitHub reports commits signed with it as verified, so the next tag should be signed with that registered key. No tag has been signed with it yet, so a verified tag is expected, not measured. Seedocs/releasing.md. -
Artifacts carry a Sigstore provenance attestation, verifiable with:
gh attestation verify sestrav-<version>-py3-none-any.whl --repo Gavin-Borges/SESTRAV --signer-workflow Gavin-Borges/SESTRAV/.github/workflows/release.yml --source-ref refs/tags/v<version>
--repoalone accepts an attestation signed by any workflow in the repository, at any ref.--signer-workflowand--source-refrequire it to come fromrelease.ymlrunning on that version's tag. Checked 2026-10-19 on the v2.0.2 and v2.0.3 wheels and the v2.0.3 sdist: each verifies, and naming another workflow or another tag fails.
The full release procedure is documented in docs/releasing.md.
Maintainer note: artifact attestation is keyless, so there is no artifact-signing key to record. When tag signing is introduced, note the first signed version here and record the signing identity per
BUS_FACTOR.md.
SESTRAV is designed as a standalone, offline bioinformatics pipeline.
- Data Privacy by Design: All scoring and feature extraction processes execute strictly on the local machine or host environment. SESTRAV does not transmit, upload, or collect any sequence data, user parameters, or predictive outputs.
- No PII/PHI Requirement: The pipeline accepts standard FASTA, CSV, and YAML configurations. It does not require, accept, or process personally identifiable information (PII) or protected health information (PHI). Users are cautioned against introducing patient metadata or identifying fields into sequence inputs.
- Credential Safety: The pipeline does not connect to external patient databases and has no credential store or public telemetry APIs.
How findings from Dependabot, code scanning, and the CI security workflows are
prioritized and acted on. The policy is deliberately two-tiered, but "blocking"
here means one specific, verifiable thing: gating the merge button via the
Protect Main Branch ruleset (id 16846770) - its seven required status checks
(test (3.13), Require human review, check_dco, Cited commits resolve,
Cited lines still hold their content, Bandit Security Scan and
CodeQL Static Analysis) plus its code-scanning rule, which names CodeQL. A tool
that is not on either of those two lists cannot block a merge, even if it fails its
own CI job red.
One of those seven is satisfied automatically for the maintainer, and this list
alone would not tell you. Require human review is a genuine required context, but
.github/workflows/pr-review-check.yml returns success without any review when the
pull request author is the repository owner, and the ruleset's
required_approving_review_count is 0, so nothing else supplies one.
require_code_owner_review does not either: .github/CODEOWNERS is * @Gavin-Borges
and GitHub does not let an author approve their own pull request.
This is a declared accommodation, not a hole, and the workflow says so in its own
header: it enforces review for EXTERNAL contributors only, and records that it "does
NOT establish independent review for owner-authored changes, which are the large
majority of merges. SESTRAV is solo-maintained; the required CI checks, not a second
reviewer, are the real gate on those changes." BUS_FACTOR.md and
docs/security_compliance.md record the same position - OpenSSF Silver and Gold are
formally declined on bus_factor / two_person_review grounds as of 2026-08-17.
Noted here because a reader of the enumeration above, without this paragraph, would
conclude owner merges are human-reviewed. They are CI-reviewed.
It is satisfied automatically for one dependency bot as well. The same workflow
returns success, again before reading any review, when the pull request author's login
is exactly the one entry in its TRUSTED_BOTS list, dependabot[bot]. Its own comment
rests that bypass on the CI suite enforcing correctness, so a Dependabot pull request,
like an owner one, is CI-reviewed rather than human-reviewed. Until 2026-10-09 the list
also named Renovate's bot login, an author that has never opened a pull request here;
that entry was removed. For every
other author the check counts only each reviewer's latest non-comment review, and
passes only on an APPROVED one from an account whose author_association is OWNER,
MEMBER or COLLABORATOR and which is not the pull request author. A second required
check has a wider exemption: .github/workflows/dco.yml exits 0 before checking any
sign-off when the author's login ends in [bot], so check_dco passes for any bot
account, not only Dependabot.
Corrected 2026-09-13. The opening paragraph of this section read "its five required
status checks" and enumerated five, omitting Bandit Security Scan and
CodeQL Static Analysis. That understated enforcement, and it contradicted this
document's own CI gate map below, which was corrected on 2026-09-12 to record Bandit as
blocking. Both statements were true of different dates and neither said so. Do not
quote this enumeration as current - the count has already changed at least twice (five
as of 2026-08-24, seven as of 2026-09-13). Re-measure instead:
gh api repos/Gavin-Borges/SESTRAV/rulesets/16846770 \
--jq '[.rules[] | select(.type=="required_status_checks")
| .parameters.required_status_checks[].context] | sort'Note the classic branch-protection API is a confident false negative here:
gh api .../branches/main/protection returns 404 "Branch not protected", because
this repository uses a ruleset rather than legacy branch protection.
| Severity | Action | Target SLA | Gate |
|---|---|---|---|
| Critical | Patch or documented mitigation before the next merge to main |
48 hours | Blocking |
| High | Patch or mitigation within the current release cycle | 7 days | Blocking |
| Medium | Scheduled fix; risk-acceptable with written justification | 30 days | Advisory |
| Low | Best-effort; batched with routine dependency updates | Next cycle | Advisory |
Timelines follow the solo-maintainer cadence described under Response Commitment above. The Severity column states intent; the CI gate map below states what is mechanically enforced today, and the two are not yet the same for every row.
Every job in security.yml, dependency-review.yml, pii_scan.yml,
dependency-lockfile-check.yml, lock_manifest_coverage.yml, scorecard.yml and
dismissal_justifications_advisory.yml has a row below, named by its check context
(the job's name:, or its job id when it has none), followed by the two repository-level GitHub features that raise security
alerts. A row is Required only when its context is one of ruleset 16846770's
required status checks listed above, or when the ruleset's code-scanning rule names
its tool; every other row is advisory. Of the seven required contexts, only
Bandit Security Scan and CodeQL Static Analysis come from these seven workflows.
tests/test_security_gate_map_covers_security_jobs.py fails if a job in those seven
workflows has no row here.
| Check context (workflow, job id) | What it checks | Tier |
|---|---|---|
Bandit Security Scan (security.yml, bandit) |
Python SAST, -ll: MEDIUM+ severity |
Required - that exact context is among ruleset 16846770's required status checks, so a MEDIUM+ finding fails the job AND holds the merge button. Corrected 2026-09-12: this row read "Advisory - ... is not a required status check, so it does not gate the merge button", which the ruleset refutes; the error understated enforcement |
Custom Secret Pattern Scan (security.yml, secret-pattern-scan) |
scripts/check_secrets.py, whose comments define the patterns exactly: an = or : assignment to a name carrying a credential-class keyword (api_key, token, secret, password, passwd, pwd, credential or credentials, auth, private_key) after any prefix and before only _- or --separated suffixes, so accessToken, dbpassword and AWS_SECRET_ACCESS_KEY all qualify; the value must be quoted, except in .yml, .yaml, .sh, .md, .txt, .cfg, .ini, .def, .qmd and Dockerfile* files, dotenv files (.env and every .env.<variant>) and extensionless hooks under scripts/hooks/, where an unquoted value counts too, and in a file named Makefile, where an unquoted value counts only after one of Make's assignment operators (=, :=, ::=, ?=, +=, !=). Corrected 2026-10-08: this row said .env, .cfg and .ini sat in that bare-value list but were never opened, so tracked pytest.ini was not scanned. That stopped being true at 89112f3f, which added all three to the separate suffix set that decides what is opened at all; 1c244738 then made every .env.<variant> name scannable, and c59dab44 added .def and .qmd to the bare-value list. Measured 2026-10-08 by calling the script's own helpers: an unquoted high-entropy assignment in .env, .env.production, app.cfg, setup.cfg and pytest.ini is flagged by scan_file and reached by a tree walk, tracked pytest.ini is among the files a scan of this repository opens, and a .toml is opened but read for quoted values only. Beside that base pattern the script carries further shapes (type annotations, string prefixes, os.getenv defaults, Bearer headers, URL query strings and URL-embedded credentials among them), each described in its comments. A value one of those patterns captures is flagged when it has no whitespace, is longer than 8 characters and has Shannon entropy above 3.0; a known vendor token format (a PEM private-key header and GitHub, Slack and AWS key prefixes among them) is flagged on sight, whatever name it is assigned to. A file it cannot read, or a scan over fewer than 10 files, also fails |
Advisory - no continue-on-error, so a finding fails the job red, but it is not a required status check. scripts/hooks/pre-push runs the same script locally. Added 2026-09-23: until then this job had no row in the map |
CodeQL Static Analysis (security.yml, codeql) |
Deep SAST, security-extended query suite -> Security > Code scanning |
Required, twice - the context is a required status check, and the ruleset's code-scanning rule names the CodeQL tool (security_alerts_threshold: all, alerts_threshold: errors_and_warnings) |
Semgrep Custom Rules (blocking) (security.yml, semgrep-custom, semgrep-rules/) |
SESTRAV's own seven rules: the three ERROR rules in sestrav-custom.yml (unsafe pickle.load, raw joblib.load bypassing load_verified_joblib, subprocess(..., shell=True)) and the four recurring-defect rules in sestrav-recurring.yml |
Blocking at the job level - no continue-on-error, so any finding fails the run. It does NOT hold the merge button: Semgrep Custom Rules (blocking) is not among the required status checks on Protect Main Branch, re-measured 2026-09-23 against the live ruleset, and promoting it is a separate repo-settings change. The paragraph below this table lists it among the advisory jobs that turn their own run red |
Semgrep Security Scan (advisory) (security.yml, semgrep) |
Registry p/python ruleset plus semgrep-rules/ -> Security > Code scanning |
Advisory - the scan step is continue-on-error, so a finding leaves this job green. It still surfaces in two places: as a code-scanning alert, and, on a pull request, in the Semgrep OSS check run from the github-advanced-security app, which a finding can turn red, as PR #418's did. That check run is not required, but it shares one check suite with the CodeQL check run, so a red run makes the suite conclude failure, and OpenSSF Scorecard's SAST check, which reads check suites rather than runs, then counts the commit as not SAST-scanned; the semgrep-custom job's comments in security.yml record this cost (code-scanning alert #87). The job does go red on a TOOLING failure: a missing or unparseable SARIF, or one carrying 0 rules, fails its assertion step, so a scan that never ran cannot upload a zero-result analysis |
pip-audit Dependency Scan (advisory) (security.yml, pip-audit; push to main, pull request, weekly) |
CVEs in the installed environments/requirements.lock set, and in every tracked hash-pinned lock (tools/audit_all_locks.py), both audited against the OSV feed (-s osv) -> step log; plus a run-summary digest of the installed set from pip-audit's default PyPI feed |
Advisory - the audit step itself is continue-on-error, but the tools/check_lockfile_advisories.py step after it is not, so an advisory against a package pinned in environments/requirements.lock fails the job red unless environments/accepted_advisories.toml accepts that exact (advisory, package) PAIR for that lock - load_acceptances keys on both, and an entry covers only the lock its optional lock field names, environments/requirements.lock when it names none - so an ID accepted for one package still fails when the same ID surfaces on a different pinned package, as does a tooling failure. Findings on packages the lock does not pin, such as the runner's own pip, are reported but never fail. The all-locks step judges every other tracked lock the same way, against the entries naming that lock; by owner ruling of 2026-10-17 it is continue-on-error until it has run green for one week, so its findings do not fail the job yet. It is not a required status check |
Python SBOM (pip-licenses) (security.yml, python-sbom) |
Regenerates the dependency SBOM from the pinned lockfile and compares it with the committed docs/sbom.json and docs/DEPENDENCY_LICENSES.md |
Advisory - fails red when either committed file is stale, or when the generated SBOM lacks any of its production sentinels (numpy, pandas, scikit-learn); not a required status check |
dependency-review (dependency-review.yml, dependency-review; pull requests only) |
New deps introduced in a PR (fail-on-severity: moderate) |
Advisory - fails its own CI job on a finding, but is not a required status check, so it does not gate the merge button. The job declares no name:, so its check context is its job id |
Check lockfile freshness and hash pinning (dependency-lockfile-check.yml, lockfile-freshness) |
tools/check_lockfile_freshness.py --check: each requirements*.in pin is honoured by its compiled lockfile, and every compiled entry carries a --hash=sha256: pin; on a pull request authored by dependabot[bot], also refuses any edit to environments/requirements-ci-render.txt |
Advisory - red on a finding, but it runs only on pull requests that touch a file in its paths: filter, and it is not a required status check |
Locked packages are Dependabot-visible (lock_manifest_coverage.yml, check_lock_manifest_coverage) |
tools/check_lock_manifest_coverage.py: every distribution pinned in environments/requirements.lock is declared in a manifest GitHub's dependency graph parses, so none is invisible to Dependabot alerts by name. It matches distribution names only and does not compare versions |
Advisory - red on an uncovered distribution; not a required status check |
Check for Paths and Credentials and Content Scan of Published Refs (pii_scan.yml, scan-leaks and scan-published-refs) |
Workstation absolute paths in ADDED lines only (scan-leaks: a pull request's diff against its base, or a push's last commit against its first parent), plus a grep of the whole checkout, .git and the workflow itself excluded, for the unfilled email-placeholder token that step names (scan-leaks's placeholder step; the token is deliberately not spelled out here, since this file is inside the checkout it greps); and workstation paths plus AI-tooling filenames in the full content of the published refs the job fetches from the remote: main, release/* and every tag (scan-published-refs). Corrected 2026-10-08: this cell said both checks ran "over the tracked tree". Neither job scans a pull request's own tree for workstation paths or AI-tooling filenames: on a pull request scan-published-refs scans the published main, not the pull request's head (measured 2026-10-08 on a Dependabot pull request's run, which scanned refs/scan/main at the base commit and the two tags and nothing else), so in CI an AI-tooling filename a pull request adds is first flagged by the push to main that merges it |
Advisory, and split: pushes to main/release/** and pull requests are ENFORCED (hard exit 1), while tags are REPORTED only - the ref loop passes report, which downgrades a finding to a ::warning. That exemption is deliberate and commented in the workflow: a tag is immutable published provenance, so wiring it to exit 1 would wedge the job red on history no push can change. Note the workflow has no tag trigger at all, so a tag is first examined on the next main push, pull request or weekly sweep. Neither of its jobs is a required status check, so even the enforced half cannot hold the merge button |
Scorecard analysis (scorecard.yml, analysis) |
OpenSSF Scorecard supply-chain checks -> published score and Security > Code scanning | Advisory - it runs on push to main and weekly, never on a pull request, and the workflow sets no score threshold (its only action inputs are results_file, results_format and publish_results), so it cannot gate a merge |
Report undocumented alert dismissals (dismissal_justifications_advisory.yml, dismissal-justifications; weekly schedule only) |
tools/check_dismissal_justifications.py --branch main: reports dismissed code-scanning alerts on main whose dismissed_comment is absent or blank, and warns on dismissed repo-level alerts, which OpenSSF Scorecard raises once per check |
Advisory, and cannot turn red on a finding: its only trigger is a weekly schedule (cron 17 13 * * 1, Mondays), so it never runs on a pull request or a push, and its report step is continue-on-error: true, so neither a finding nor a failed alert fetch fails the job |
| Dependabot alerts (repository setting) | Known CVEs in dependencies -> Security > Dependabot | Advisory (triaged). Vulnerability alerts and Dependabot security updates were both enabled when re-measured 2026-09-23 |
| GitHub secret scanning and push protection (repository settings) | Secrets in GitHub's provider patterns -> Security > Secret scanning; push protection rejects a push carrying one | Not a status check, so it never holds the merge button; push protection acts at push time instead. Re-measured 2026-09-23 from the repository's security_and_analysis: secret_scanning and secret_scanning_push_protection are enabled, while secret_scanning_non_provider_patterns and secret_scanning_validity_checks are disabled, so this layer does not look for generic credentials that follow no provider format. In CI those are left to the advisory Custom Secret Pattern Scan |
Advisory findings never block a merge on their own - none of them is a required status
check or a code-scanning rule on Protect Main Branch. Advisory does not mean never
red. These advisory jobs fail their own run on a finding:
Custom Secret Pattern Scan, Semgrep Custom Rules (blocking),
pip-audit Dependency Scan (advisory) (on an unaccepted advisory against a package
pinned in environments/requirements.lock), Python SBOM (pip-licenses) (on a stale committed SBOM), dependency-review,
Check lockfile freshness and hash pinning, Locked packages are Dependabot-visible,
Check for Paths and Credentials and Content Scan of Published Refs (tag findings in
the latter are reported, not failed). The Semgrep Security Scan (advisory) job itself
goes red on a tooling failure only; its findings can instead turn the separate
Semgrep OSS check run red on a pull request, as its row describes. That failure is
visible in the run and in branch-status UI, but does not prevent the merge button from
going green. Corrected 2026-09-23: this paragraph said "Three of them (Dependency
Review, pip-audit and the Semgrep custom-rules job)", which the PII row above already
contradicted, and the table had no row for Custom Secret Pattern Scan, the SBOM job,
the two dependency-integrity jobs, Scorecard or secret scanning. The list above is
enumerated rather than counted so that it can be checked against the table. Findings
surface as (a) tracked, dismissable alerts in Security > Code scanning (CodeQL,
Semgrep and Scorecard SARIF), (b) a red or markdown-annotated job run (any workflow
row above), or a red Semgrep OSS code-scanning check run on a pull request, (c)
Dependabot alerts/PRs, and (d) secret-scanning alerts. They are reviewed on the
weekly cadence and logged in the register below whenever consciously deferred.
When a finding is intentionally left unfixed (no upstream patch, not reachable in SESTRAV's offline model, etc.):
- Add an entry to the Risk-Acceptance Register below: identifier, component, rationale, and a re-review trigger or date.
- If it is noisy in CI, suppress it at the source with the verified advisory ID
and a pointer back to this register entry:
- For a
pip-auditfinding onenvironments/requirements.lock(the production lockfile), add an entry toenvironments/accepted_advisories.toml-.github/workflows/security.yml'spip-auditjob fails closed on any finding not listed there (tools/check_lockfile_advisories.py). For a finding the all-locks step reports on another tracked lock, give the entrylock = "<that lock's repo-relative path>": an entry covers only the lock it names, and none at all meansenvironments/requirements.lock. Do not use pip-audit's--ignore-vulnflag for this: it is applied before pip-audit writes its own report, so a suppressed finding becomes invisible to every tool that reads that report, including the ones meant to notice when it gets fixed upstream. That gap is exactly how CVE-2025-3000 sat patched-but-unnoticed for four weeks; see the entry below. - For anything else (Semgrep/CodeQL SARIF, Dependabot), dismiss-with-reason in the Security tab, citing this register entry in the dismissal comment.
- Never suppress without a register entry.
- For a
- Note material changes in the
CHANGELOG.mdUnreleased / Securitysection as the audit trail.
As a standalone, offline scientific tool, SESTRAV occasionally relies on complex third-party libraries (e.g., PyTorch) that may contain upstream vulnerabilities with no available vendor patch. Each consciously-deferred advisory is logged here.
-
Pillow 12.3.0 in the demo image: RESOLVED 2026-10-22 (UTC) - no longer risk-accepted.
environments/requirements-demo.innow pinsstreamlit==1.66.1, which declarespillow<14,>=9.2.0, andenvironments/requirements-demo.txtpins Pillow 13.0.0. The entry is kept as the record of the acceptance, made on 2026-10-21 (UTC), and of the statements in it that are retracted below. Pillow 13.0.0's release notes, as tagged on 2026-10-16, list 38 security fixes (2 critical, 13 high, 20 medium, 3 low) and cite 42 GHSA ids; the default branch has since added GHSA-654x-cwwv-5j9c and reads 39 fixes and 43 ids. Every Pillow advisory that the GitHub advisory database (which Dependabot reads and OSV imports; pip-audit's default PyPI feed lags it) lists against 12.3.0 is first patched in 13.0.0. The database has been taking them in from Pillow's repository advisories onpython-pillow/Pillow: nine arrived on 2026-10-20 and nineteen more on 2026-10-21 between 19:58 and 21:29 UTC. As of 2026-10-22T01:11Z, 40 of the 42 tagged ids are published repository advisories and 28 of those are in the database, all listed against 12.3.0, which it grades 3 critical, 16 high and 9 medium; Pillow's notes grade the same 28 as 1 critical, 7 high, 17 medium and 3 low. The other 12 published ones may follow, so re-count before quoting these figures.requirements.txt,environments/requirements.lock,environments/requirements-api.txtandenvironments/requirements-demo.txtall pin 13.0.0.- Identifiers (the 28 in the advisory database as of 2026-10-22T01:11Z): critical,
CVE-2026-112393 / GHSA-332p-7hrc-92wf (heap buffer overflow when saving TIFF to an
in-memory buffer), CVE-2026-112403 / GHSA-8g5g-8vmr-9782 (heap buffer overflow in
ImagingJpegDecode) and CVE-2026-112900 / GHSA-w889-685w-c8fh (argument injection in the Ghostscript call); high, CVE-2026-112390, CVE-2026-112392, CVE-2026-112397, CVE-2026-112399, CVE-2026-112400, CVE-2026-112402, CVE-2026-112404, CVE-2026-112405, CVE-2026-112406, CVE-2026-112892, CVE-2026-112893, CVE-2026-112894, CVE-2026-112895, CVE-2026-112896, CVE-2026-112897 and CVE-2026-112902; medium, CVE-2026-112391, CVE-2026-112394, CVE-2026-112395, CVE-2026-112396, CVE-2026-112401, CVE-2026-112891, CVE-2026-112898, CVE-2026-112899 and CVE-2026-112901. These are the advisory-database severities; the release notes rank 15 of the same 28 differently. - Resolution: streamlit 1.66.1 was uploaded to PyPI at 2026-10-21T17:02Z. Its wheel
declares
pillow<14,>=9.2.0where 1.65.0 and 1.66.0 declarepillow<13, and streamlit's1.66.0...1.66.1comparison on GitHub carries the commit "[chore] Allow Pillow 13 (#17589)".environments/requirements-demo.inmoved its pin from 1.65.0 to 1.66.1, andpython tools/update_dependencies.py --target streamlitrecompiled the demo lock (the same command with--target pillowwrites a byte-identical file). In that lock Pillow moved from 12.3.0 to 13.0.0 and streamlit from 1.65.0 to 1.66.1, andhttptoolsandtomlleft it: streamlit 1.66 requires neither (httptoolsmoved to itsperformanceextra), and the lock recorded no other package requiring them. No other pin moved. The demo entry inIMAGE_LOCK_ALLOWED_DRIFT(tests/test_images_install_only_hashed_dependencies.py) and the demo sentence on thepillowfloor inenvironments/requirements-lock.inare deleted. - Retracted 2026-10-22 (UTC). From 2026-10-21T17:02Z, when streamlit 1.66.1 reached
PyPI, four statements this entry made were false or overstated:
- Its heading said the acceptance held "until streamlit admits Pillow 13". A streamlit release that admits it, 1.66.1, already existed.
- "as does 1.66.0, its newest release as of 2026-10-21 (UTC)". 1.66.0 does declare
pillow<13, but from 17:02Z that day streamlit's newest release was 1.66.1. - "A resolver that honours that metadata cannot select 13.0.0." That held only while the pin stayed at 1.65.0. It was given as the reason the demo lock could not move, and raising the pin to 1.66.1 is how the lock moved.
- That
pip install ".[demo]"(the routeUSAGE.mddocuments) resolves Pillow 12.x. The[demo]extra declaresstreamlit>=1.54.0with no upper bound, so a fresh resolve can select streamlit 1.66.1 and Pillow 13.0.0, anduv pip compile pyproject.toml --extra demodoes, for Python 3.11 and 3.13 on Linux and on Windows (measured 2026-10-22T20:38Z).
- Mitigation, while it was accepted: the nine that reached the database on
2026-10-20 each need Pillow to process image or PDF data that an attacker shapes: decode it, save it back, or run
morphology on it. The nineteen that followed were weighed for this entry by their
titles, which name decoders, encoders, file parsers (PDF, GIF, TIFF, XBM, MSP, MIC,
APNG, and EPS through Ghostscript) and image operations (quantize, merge, transform,
rank filters, font rendering), and the two new critical ones also by their
descriptions. The 12 published repository advisories not yet in the database were
weighed by their titles alone, which name BMP, FlashPix JPEG, WMF/EMF, PNG eXIf,
SPIDER, MPO, DCX and TarIO parsing, the bundled OpenJPEG library, JPEG comment
writing, PDF append, multi-frame loading and native integer operations. In
app/demo.pya user shapes nothing Pillow parses. The demo has no file or image input; its only data inputs are a text field, accepted only as 8 to 11 standard amino-acid letters, and a selection box over a fixed list of alleles. That peptide is drawn as text into the matplotlib figures the app renders, and those self-rendered figures are the only images Pillow handles. Streamlit's own server endpoints were not audited for this entry. - Fixed in 13.0.0, which the demo lock now pins: GHSA-654x-cwwv-5j9c
(medium, published 2026-10-19) is fixed in Pillow 13.0.0 by
python-pillow/Pillow@19f64946eb ("Reject exporting Arrow arrays from non-contiguous
images", upstream PR 10172), an ancestor of the
13.0.0tag. It did affect the 12.3.0 this entry accepted: measured 2026-10-21 (UTC) with the advisory's own reproducer, 12.3.0 exports stale heap bytes in every process layout tried (how many depends on the layout: 114 to 142 of 2440), while 13.0.0 refuses the export withValueError: Image rows are not contiguous in memory.It needsPILLOW_ALIGNMENTset above 1 and an image exported to Arrow; no tracked file setsPILLOW_ALIGNMENTor imports Pillow. Pillow's own repository advisory, which gained CVE-2026-114501 on 2026-10-21 (UTC), still records 11.2.1 to 13.0.0 as vulnerable with no patched version. The advisory database did not carry it as of 2026-10-22T01:11Z; if it is imported with that range, scanners that read the database will flag 13.0.0 until Pillow corrects it. Re-checked 2026-10-22T20:37Z: the repository advisory still records that range with no patched version, and the database still does not carry it. - Re-review trigger, now met: a streamlit release whose metadata admits Pillow 13;
the Resolution above carries out the steps this trigger named. While the entry was
live, it was also to be re-reviewed at once if the demo gained a file, image or camera
input, or if the advisory database listed a Pillow 12.x advisory that needs no
attacker-shaped data. Re-reviewed by the maintainer on 2026-10-21 (UTC), after the
database count rose from nine to 28 and from one critical to three, and re-confirmed.
The two new critical advisories need a TIFF saved to an in-memory target such as
io.BytesIO(GHSA-332p-7hrc-92wf) or an EPS file rendered through Ghostscript (GHSA-w889-685w-c8fh);app/demo.pysaves no TIFF and opens no EPS file. - Suppression: none was set. The fail-closed pip-audit gate audits the environment
that
environments/requirements.lockinstalls, which does not include the demo lock, so nothing in CI needed silencing. Scorecard's vulnerability check and Dependabot were left to keep reporting this until it was fixed.
- Identifiers (the 28 in the advisory database as of 2026-10-22T01:11Z): critical,
CVE-2026-112393 / GHSA-332p-7hrc-92wf (heap buffer overflow when saving TIFF to an
in-memory buffer), CVE-2026-112403 / GHSA-8g5g-8vmr-9782 (heap buffer overflow in
-
CVE-2025-3000 (PyTorch JIT script memory corruption): RESOLVED 2026-08-05 - no longer risk-accepted. PyTorch
<= 2.12.1contains a memory corruption flaw insidetorch.jit.script.- Identifiers:
CVE-2025-3000,GHSA-rrmf-rvhw-rf47,PYSEC-2025-194. - Resolution: upgraded to
torch==2.13.0, the first patched release (published 2026-07-08), acrossrequirements.in,requirements.txt,environments/requirements.lockandenvironments/requirements-ci-torch-cpu.txt, plus atorch>=2.13.0floor inpyproject.toml. The lockfiles only govern hash-pinned installs; thepyproject.tomlfloor is what stopspip install -e .or a downstream consumer from resolving back into the affected range (<= 2.12.1). - How this entry went stale, recorded deliberately: it asserted "No upstream patch
is available" and set a re-review trigger of "publication of a patched release." That
trigger fired on 2026-07-08 and went unnoticed for four weeks, because nothing
re-evaluates this register on a schedule - the suppression was set once and never
revisited. The advisory's own metadata (
firstPatchedVersion: 2.13.0) was the authoritative signal and was queryable the whole time. - Suppressions removed: the
--ignore-vuln PYSEC-2025-194/GHSA-rrmf-rvhw-rf47flags have been deleted from.github/workflows/security.yml, so pip-audit now reports this advisory again if it ever reappears. Any previously dismissed Dependabot alerts for it are superseded by the upgrade. - Side effect, intentional: torch 2.12.0 declared a
setuptools<82build-metadata cap that collided with this repo'ssetuptools>=83.0.0floor (GHSA-h35f-9h28-mq5c) and forced every lockfile recompile through auvoverride file. torch 2.13.0 declaressetuptools>=77.0.3, sooverrides.txthas been retired and both application lockfiles now resolve unaided. The setuptools floor itself is unchanged - it was the security constraint, not the workaround.
- Identifiers:
-
Standing lesson from the entry above: a risk acceptance with no scheduled re-review is a claim that decays silently. Every live entry in this register carries a re-review trigger; none of them fire on their own. (Writing this sentence exposed a counter-example: the
-W errorbypass below had no trigger at all. One was added rather than weakening the rule.) Re-check this register whenever dependencies are audited, and treat an advisory'sfirstPatchedVersionfield as the authoritative test of "is a patch available yet," not the prose in this file. -
Semgrep
dangerous-subprocess-use-tainted-env-args(external-tool wrappers): Risk-accepted false positive. The benchmark wrappers shell out to external binaries (PRIME, PredIG/Docker) viasubprocess.run.- Identifiers: Semgrep
python.lang.security.audit.dangerous-subprocess-use-tainted-env-args, BanditB603. - Scope:
scripts/run_prime_wrapper.py,scripts/run_predig_wrapper.py,scripts/run_predig_batched.py. - Severity: Error (Semgrep default); not exploitable in SESTRAV's model.
- Mitigation: All calls use the list/argv form (
shell=False), so no shell interpretation occurs. Command arguments are sourced from the operator's local CLI (argparse) and constant literals - never from untrusted or network input. - Suppression: An inline
# nosemgrepon all three call sites, and a CI step that makes GitHub honour it. Corrected 2026-08-17: this entry previously stated that an inline# nosemgrepdoes not clear the taint-mode finding, and that Security-tab dismissal was therefore the mechanism. The marker does clear it - the scanner's own verdict isRan 154 rules on 166 files: 0 findings.What did not happen was GitHub acting on it: semgrep still wrote each finding into the SARIF tagged"suppressions": [{"state": "accepted"}], and code scanning ingested it regardless, so the alerts were held closed only by manual dismissals that a single edit to the suppressed line could invalidate.security.ymlnow drops suppressed results before the SARIF upload, so the uploaded analysis matches the scan and no per-alert dismissal is required. Unsuppressed findings are untouched and still raise alerts. Seedocs/security_compliance.mdfor the measurement. - Re-review trigger: if any wrapper begins accepting subprocess arguments from
untrusted/remote input, or switches to
shell=True.
- Identifiers: Semgrep
-
MCP SDK transport vulnerabilities (session hijacking / origin validation): Risk-accepted. The
mcppackage is pulled in transitively as a dev/CI dependency ofsemgrep; it is not an application dependency and no MCP server transport is ever invoked by SESTRAV.- Identifiers:
GHSA-vj7q-gjh5-988w,GHSA-jpw9-pfvf-9f58,GHSA-hvrp-rf83-w775. - Scope:
mcp(transitive, viasemgrep) in the CI/dev dependency closure. - Severity: High (per GitHub advisory). All three are server-transport vulnerabilities (session-ID authentication bypass, WebSocket origin validation); SESTRAV never starts an MCP server, so the vulnerable code path is unreachable.
- Mitigation: Not used. SESTRAV imports
mcponly as a side effect of installingsemgrepfor CI static analysis; nomcp.server.*transport is constructed or run anywhere in the codebase or CI. - Suppression: Dependabot alerts dismissed as
not_used. This entry is the authoritative record; the dismissal comment on each alert points back here. - Re-review trigger: if
mcpever becomes a direct/runtime dependency, or an MCP server transport is added to the codebase.
- Identifiers:
-
Strict Warning Enforcement (
-W errorbypass) for PyTorch Ecosystem: Risk-accepted. OpenSSF Silver requires strict compiler/linter warnings to be enabled and addressed.- Scope:
pytesttest collection and runtime. - Rationale: Deep dependencies within
torch_geometricraise unpatchableDeprecationWarnings during import (e.g.,torch_geometric.distributeddeprecation since 2.7.0). Enforcing-W errorglobally breaks the CI pipeline. - Mitigation: A selected-rule static-analysis gate. Corrected 2026-09-02: this entry
previously said Ruff was "set to fail on any warning or error", which reads wider than the
gate that runs. What runs is
ruff check .in thelintjob of.github/workflows/ci.yml, with no--exit-zero, so any violation of the ENABLED rule set fails the job. The enabled set isE4,E7,E9,FandS([tool.ruff.lint]inpyproject.toml), with nine rules ignored repository-wide; Pycodestyle'sWwarning category is not selected at all. Measured 2026-09-02 against this repository's own config, with a control in each direction: trailing whitespace (W291) and an over-length line (E501) exit 0, while an unused import (F401) and an insecure hash (S324) exit 1 -S324fires althoughSis outside Ruff's default selection, andE402exits 0 althoughE4is selected, which is how the measurement is shown to be reading this config and not a default one. The Silver static-analysis judgement recorded above predates this correction and is not re-assessed here. Runtime PyTorch deprecation warnings continue to pass in test execution. - Re-review trigger: any
torchortorch-geometricmajor/minor upgrade (which may drop the import-timeDeprecationWarnings this bypass exists for), or any narrowing of the pytest warning filter. Added 2026-08-05: this entry previously carried no trigger, which the standing lesson above says is exactly how a risk acceptance decays silently.
- Scope:
-
environments/requirements.lockis outside Dependabot's dependency graph (a detection gap, not an exposure): Risk-accepted. GitHub's dependency graph for this repository (measured 2026-09-19 at21bbcac, re-measured 2026-09-28) parses 15 pip-ecosystem manifests:pyproject.toml, every trackedrequirements*.txt, andenvironments/requirements-lock.in.environments/requirements.lockis not among them, so the compiled production closure raises no Dependabot alert of its own.- Identifiers: none. This is a gap in the alerting surface rather than a vulnerability in a package, so no advisory id applies.
- Scope:
environments/requirements.lockalone. Measured first on 2026-09-19 at commit21bbcacby two instruments that share no input: GitHub's dependency graph reported 31 parsed manifests (34 on 2026-09-28; the 15 pip ones unchanged) and this file is absent from all of them, and none of the Dependabot alerts the API returned (108 on 2026-09-19, 106 on 2026-09-28) names it. Its compile inputenvironments/requirements-lock.inIS parsed and HAS raised two alerts, but that covers the constraint layer only partly: an exact pin there is checked at its own version, but a>=floor says nothing about the version the lock resolves to. Itspyjwt>=2.14.0floor raised no alert for GHSA-42vr-xj54-vc7v (published 2026-09-30), which covers the 2.14.0 the lock shipped. - Severity: Medium, and for DETECTION only. This is the file CI installs from in both
the
pip-auditandpython-sbomjobs of.github/workflows/security.yml(viapip install --require-hashes --no-deps), so an advisory affecting only the version pinned here, and not a version any parsed manifest declares, would not appear in the Security tab. - Mitigation: the closure is audited, just not alerted on. The
pip-auditjob's "Install the pinned lockfile (resolver-free) for auditing" step installs this lock and the "Audit installed dependency set" step that follows audits the resulting environment; the comment above them records why thepip-audit -r environments/requirements.lockform is deliberately not used.tools/check_lockfile_freshness.py, whoseLOCKFILE_PAIRSnames this exact.in-to-.lockpair, fails when a package the.inpins with==is missing from the lock or at another version, or when one it floors with>=sits below that floor in the lock;tools/check_hash_pins.pyseparately requires hash pins.tools/check_lock_manifest_coverage.py(CI jobLocked packages are Dependabot-visible) fails if any distribution pinned here is declared in no parsed manifest, judged by a filename rule calibrated against the live graph, so every locked package is Dependabot-visible by name; it does not compare versions. Stated precisely, because the direction matters: thatpip-auditjob is named "(advisory)" and is not a required status check, so this mitigation fails that job red on an unaccepted advisory against a locked package but does not gate a merge. - Suppression: none, and none is possible. Nothing is dismissed; the alerts are never generated in the first place.
- Re-review trigger: if the
pip-auditjob stops installing this lock or is removed; iftools/check_lockfile_freshness.pyis retired, since the.in-to-.lockpropagation is what makes the covered layer meaningful; or iftools/check_lock_manifest_coverage.pyis retired; or if GitHub's dependency graph starts parsing this file, at which point this entry should be RETIRED rather than re-reviewed. Renaming the file toenvironments/requirements-lock.txtwas considered; since every trackedrequirements*.txtis parsed, it would very likely close the gap directly. It is not done here because 29 tracked files name this path at26a36521, and every one that depends on the name would have to change in the same commit: among them theDockerfile,singularity.defand.dockerignore, thesecurity.yml,iedb_benchmark.ymlandlock_manifest_coverage.ymlworkflows, andtools/check_hash_pins.py,tools/check_lock_manifest_coverage.py,tools/check_lockfile_advisories.py,tools/check_lockfile_freshness.pyandtools/update_dependencies.py.scripts/check_doc_commit_refs.pyalso names its basename.