From acd8e2eb18adec64064263a68654f30e82e5dbe2 Mon Sep 17 00:00:00 2001 From: Felipe Fumero Date: Tue, 17 Nov 2026 15:19:29 -0600 Subject: [PATCH 1/3] ci: gate releases and pin deployment actions --- .changes/unreleased/release-workflows.yaml | 3 + .github/dependabot.yml | 4 + .github/signing-maintainers | 4 + .github/workflows/changelog.yml | 1 - .github/workflows/ci_cd.yml | 79 +++++++++----- .github/workflows/deploy.yml | 91 ++++++++++++---- RELEASE.md | 50 +++++++++ scripts/release.py | 111 +++++++++++++++++++ scripts/tests/test_release_gates.py | 110 +++++++++++++++++++ scripts/tests/test_signed_tags.py | 120 +++++++++++++++++++++ scripts/tests/test_workflows.py | 54 ++++++++++ scripts/verify-release-tag.sh | 55 ++++++++++ 12 files changed, 633 insertions(+), 49 deletions(-) create mode 100644 .changes/unreleased/release-workflows.yaml create mode 100644 .github/signing-maintainers create mode 100644 scripts/tests/test_release_gates.py create mode 100644 scripts/tests/test_signed_tags.py create mode 100644 scripts/tests/test_workflows.py create mode 100644 scripts/verify-release-tag.sh diff --git a/.changes/unreleased/release-workflows.yaml b/.changes/unreleased/release-workflows.yaml new file mode 100644 index 000000000..57f29d6a7 --- /dev/null +++ b/.changes/unreleased/release-workflows.yaml @@ -0,0 +1,3 @@ +kind: Changed +body: Verify release metadata and milestones, check security findings, support phased signed-tag enforcement, and use pinned workflow actions and changelog-derived release notes. +time: 2026-11-17T00:00:01Z diff --git a/.github/dependabot.yml b/.github/dependabot.yml index e2922be11..8c8403581 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -3,6 +3,10 @@ version: 2 updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" - package-ecosystem: "gradle" directory: "/" schedule: diff --git a/.github/signing-maintainers b/.github/signing-maintainers new file mode 100644 index 000000000..36f20bf45 --- /dev/null +++ b/.github/signing-maintainers @@ -0,0 +1,4 @@ +# Intended release-tag signers. Public keys are resolved from each GitHub profile at check time. +goanpeca +ffumero2003 +sophiecarreras diff --git a/.github/workflows/changelog.yml b/.github/workflows/changelog.yml index 18a039614..b252150df 100644 --- a/.github/workflows/changelog.yml +++ b/.github/workflows/changelog.yml @@ -5,7 +5,6 @@ name: Changelog on: pull_request: - branches: [master, api-v2, 7.x] push: branches: [master] diff --git a/.github/workflows/ci_cd.yml b/.github/workflows/ci_cd.yml index a092aa6cb..189555c95 100644 --- a/.github/workflows/ci_cd.yml +++ b/.github/workflows/ci_cd.yml @@ -11,9 +11,12 @@ on: - api-v2 - 7.x # TODO: This is temporary and will be removed once we merge this branch to master branch +permissions: + contents: read + env: - OUTPUT_DIR: $GITHUB_WORKSPACE/build/outputs - OUTPUT_ZIP: b2-sdk-build-${GITHUB_RUN_NUMBER}.zip + OUTPUT_DIR: ${{ github.workspace }}/build/outputs + OUTPUT_ZIP: b2-sdk-build-${{ github.run_number }}.zip BUILD_NUMBER: ${{ github.run_number }} # These are stored in Bitwarden B2_ACCOUNT_ID: ${{ secrets.B2_ACCOUNT_ID }} @@ -25,22 +28,23 @@ jobs: runs-on: ${{ github.repository == 'Backblaze/b2-sdk-java-private' && 'self-hosted'|| 'ubuntu-latest' }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 with: fetch-depth: 0 + persist-credentials: false - - uses: actions/setup-java@v4 + - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3 # v4 with: distribution: temurin java-version: '11' - - uses: gradle/actions/wrapper-validation@v4 + - uses: gradle/actions/wrapper-validation@ed408507eac070d1f99cc633dbcf757c94c7933a # v4 - name: Setup Gradle - uses: gradle/actions/setup-gradle@v4 + uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4 # --- uv + Python 3.13, then create a venv in $RUNNER_TEMP --- - name: Set up uv - uses: astral-sh/setup-uv@v5 + uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5 with: enable-cache: false @@ -64,15 +68,15 @@ jobs: - name: Build the distribution run: | - $GITHUB_WORKSPACE/gradlew build - mkdir -p ${{ env.OUTPUT_DIR }} - cp -v */build/libs/b2-sdk-*.{jar,pom,module} ${{ env.OUTPUT_DIR }} - cd ${{ env.OUTPUT_DIR }} - zip -r $GITHUB_WORKSPACE/build/${{ env.OUTPUT_ZIP }} * + "$GITHUB_WORKSPACE/gradlew" build + mkdir -p "$OUTPUT_DIR" + cp -v ./*/build/libs/b2-sdk-*.{jar,pom,module} "$OUTPUT_DIR" + cd "$OUTPUT_DIR" + zip -r "$GITHUB_WORKSPACE/build/$OUTPUT_ZIP" ./* - name: Deploy to internal Maven repo if: (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/api-v2' || github.ref == 'refs/heads/7.x') && github.repository == 'Backblaze/b2-sdk-java-private' - run: $GITHUB_WORKSPACE/gradlew publishMavenPublicationToRemoteRepository + run: '"$GITHUB_WORKSPACE/gradlew" publishMavenPublicationToRemoteRepository' env: ORG_GRADLE_PROJECT_remoteUsername: ${{ secrets.ARTIFACTORY_USERNAME }} ORG_GRADLE_PROJECT_remotePassword: ${{ secrets.ARTIFACTORY_TOKEN }} @@ -80,7 +84,7 @@ jobs: - name: Deploy to GH packages if: (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/api-v2' || github.ref == 'refs/heads/7.x') && github.repository == 'Backblaze/b2-sdk-java-private' - run: $GITHUB_WORKSPACE/gradlew publishMavenPublicationToRemoteRepository + run: '"$GITHUB_WORKSPACE/gradlew" publishMavenPublicationToRemoteRepository' env: ORG_GRADLE_PROJECT_remoteUsername: ${{ secrets.PACKAGES_USERNAME }} ORG_GRADLE_PROJECT_remotePassword: ${{ secrets.PACKAGES_TOKEN }} @@ -92,17 +96,40 @@ jobs: export PATH="$UV_VENV/bin:$PATH" "$GITHUB_WORKSPACE/maybe_upload_build_results" "${{ env.OUTPUT_ZIP }}" - - name: Check GitHub Pages status - if: github.ref == 'refs/heads/master' - uses: crazy-max/ghaction-github-status@v4 + - name: Upload Javadoc artifact + if: >- + github.event_name == 'push' && github.repository == 'Backblaze/b2-sdk-java' && + contains(fromJSON('["refs/heads/master", "refs/heads/api-v2", "refs/heads/7.x"]'), github.ref) + uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3 with: - pages_threshold: major_outage - - - name: Deploy Javadoc - if: (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/api-v2' || github.ref == 'refs/heads/7.x') && success() - uses: crazy-max/ghaction-github-pages@v3 + path: core/build/docs/javadoc + + deploy-pages: + needs: build + if: >- + github.event_name == 'push' && github.repository == 'Backblaze/b2-sdk-java' && + contains(fromJSON('["refs/heads/master", "refs/heads/api-v2", "refs/heads/7.x"]'), github.ref) + runs-on: ubuntu-latest + permissions: + contents: read + pages: write + id-token: write + concurrency: + group: github-pages + cancel-in-progress: false + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 with: - target_branch: gh-pages - build_dir: core/build/docs/javadoc - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + persist-credentials: false + - name: Check GitHub Pages status + shell: bash + run: | + set -euo pipefail + curl --fail --show-error --silent --location --max-time 30 \ + https://www.githubstatus.com/api/v2/components.json | python3 scripts/release.py pages-status + - name: Deploy Javadoc + id: deployment + uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4 diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index b064cf61e..2939b9426 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -6,24 +6,79 @@ on: push: tags: ['v*'] +permissions: + contents: read + +concurrency: + group: maven-central-${{ github.ref }} + cancel-in-progress: false + jobs: + release-checks: + if: github.repository == 'Backblaze/b2-sdk-java' + runs-on: ubuntu-latest + permissions: + contents: read + security-events: read + issues: read + env: + RELEASE_TAG: ${{ github.ref_name }} + steps: + # Read the key registry and gate implementation from the reviewed default branch. + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 + with: + ref: master + fetch-depth: 0 + persist-credentials: false + - name: Verify release tag + env: + ENFORCE_SIGNED_TAGS: ${{ vars.ENFORCE_SIGNED_TAGS }} + GH_TOKEN: ${{ github.token }} + run: | + git merge-base --is-ancestor "$RELEASE_TAG^{commit}" origin/master + bash scripts/verify-release-tag.sh "$RELEASE_TAG" + - name: Check tag, version, and changelog agreement + run: | + git worktree add --detach "$RUNNER_TEMP/release-metadata" "$RELEASE_TAG" + python3 scripts/release.py --root "$RUNNER_TEMP/release-metadata" notes "$RELEASE_TAG" > /dev/null + - name: Require complete version milestone + env: + GH_TOKEN: ${{ github.token }} + run: python3 scripts/release.py milestone "$RELEASE_TAG" + - name: Require security clearance + env: + GH_TOKEN: ${{ secrets.RELEASE_READ_TOKEN }} + run: python3 scripts/release.py security + deploy: name: Deploy + needs: release-checks if: github.repository == 'Backblaze/b2-sdk-java' runs-on: ubuntu-latest + permissions: + contents: write + env: + RELEASE_TAG: ${{ github.ref_name }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 with: fetch-depth: 0 + persist-credentials: false - - uses: actions/setup-java@v4 + - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3 # v4 with: distribution: 'temurin' java-version: '11' - - uses: gradle/actions/wrapper-validation@v4 + - uses: gradle/actions/wrapper-validation@ed408507eac070d1f99cc633dbcf757c94c7933a # v4 - name: Setup Gradle - uses: gradle/actions/setup-gradle@v4 + uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4 + + - name: Build and test the release + run: ./gradlew build --no-daemon + + - name: Extract release notes + run: python3 scripts/release.py notes "$RELEASE_TAG" > "$RUNNER_TEMP/release-notes.md" - name: Deploy to Maven Central run: ./gradlew publishToSonatype closeAndReleaseSonatypeStagingRepository createBundle --no-daemon --stacktrace @@ -34,23 +89,15 @@ jobs: ORG_GRADLE_PROJECT_sonatypeUsername: ${{ secrets.SONATYPE_TOKEN_USERNAME }} ORG_GRADLE_PROJECT_sonatypePassword: ${{ secrets.SONATYPE_TOKEN_PASSWORD }} - - name: Get tag name - id: get_tag - shell: bash - run: | - tag_name="$(echo $GITHUB_REF | cut -d / -f 3)" - echo ::set-output name=tag::$tag_name - - name: Create GitHub Release - uses: softprops/action-gh-release@v2 env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - with: - tag_name: ${{ steps.get_tag.outputs.tag }} - name: ${{ steps.get_tag.outputs.tag }} - prerelease: false - draft: false - files: | - core/build/libs/bundle-*.jar - httpclient/build/libs/bundle-*.jar - samples/build/libs/bundle-*.jar + GH_TOKEN: ${{ github.token }} + shell: bash + run: | + shopt -s nullglob + assets=(core/build/libs/bundle-*.jar httpclient/build/libs/bundle-*.jar samples/build/libs/bundle-*.jar) + [ "${#assets[@]}" -eq 3 ] || { echo 'Expected one release bundle for each module' >&2; exit 1; } + flags=(--latest) + if [[ "$RELEASE_TAG" == *-* ]]; then flags=(--prerelease); fi + gh release create "$RELEASE_TAG" --verify-tag --title "$RELEASE_TAG" \ + --notes-file "$RUNNER_TEMP/release-notes.md" "${flags[@]}" "${assets[@]}" diff --git a/RELEASE.md b/RELEASE.md index 375e02543..d231acb37 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -18,6 +18,36 @@ approach in [Blazer's release guide](https://github.com/Backblaze/blazer/blob/ma Do not run a publishing task locally as a verification step. A tag push starts the production deployment, including closing and releasing the Sonatype staging repository. +## Repository setup and signed-tag rollout + +The intended release maintainers are `goanpeca`, `ffumero2003`, and `sophiecarreras`, listed in +`.github/signing-maintainers`. The verifier resolves their public keys from +`https://github.com/.gpg`, `https://github.com/.keys`, and the paginated public +`users//ssh_signing_keys` API at check time and runs +`git verify-tag` with an isolated keyring and SSH allowed-signers file. GitHub profile key changes +therefore affect the next verification; review the username list through a PR. + +Tag verification is **warn-only by default**. Before enabling it, each intended signer must create a +GPG or SSH signing key and register the public key on their GitHub account. Confirm that their signed +tag passes verification, then run `gh variable set ENFORCE_SIGNED_TAGS --body true` for this repository. +Once enabled, an +unsigned, lightweight, unrecognized, or unverifiable tag blocks publication. In warn-only mode those +conditions produce a workflow warning; the security, milestone, and metadata gates still enforce. + +An administrator must complete the following before the workflow changes are used for a release: + +- Supply `RELEASE_READ_TOKEN`, a read-only token authorized for this repository's code-scanning, + Dependabot, secret-scanning alerts, repository security advisories (including drafts), and issues. + Enable these sources and grant access: a disabled or unreadable source holds publication. + The ordinary workflow token is used only for milestone reads and release creation, with explicit + job permissions; Maven signing/publishing secrets are exposed only to the publish step. +- Change Settings → Pages → Build and deployment → Source from **Deploy from a branch** to + **GitHub Actions**. Configure the `github-pages` environment to allow the documentation branches + `master`, `api-v2`, and `7.x`. The official Pages deployment uses GitHub OIDC with `pages: write` + and `id-token: write`; this does not change Maven Central authentication. +- Make `changelog-check` a required PR check and protect `.github/signing-maintainers` and the + release workflows through maintainer review. Keep Dependabot's GitHub Actions updates enabled. + ## Changelog and versioning Use semantic versioning: fixes use a patch release, compatible features a minor release, and @@ -64,6 +94,19 @@ workflow files and human-authored changes still need a fragment. including findings without a patched dependency. Failures to read findings are unverified, not clean. A maintainer must resolve or dismiss findings with a written reason before release. + ```bash + GH_TOKEN="$RELEASE_READ_TOKEN" python3 scripts/release.py security + # After the release-prep PR has merged, the milestone must contain no open issues or PRs: + python3 scripts/release.py milestone "$TAG" + ``` + + The gate reads all pages of GitHub code-scanning alerts on `master`, Dependabot alerts, + draft/triage repository advisories, secret-scanning alerts, and severity-labeled open issues. + Medium/high/critical findings block even without a patched version; all open secret alerts + and unscored active advisories block. Low findings do not block. The gate prints counts, + never unpublished advisory text or secret values. Do not put private advisory details in + a public issue. API failures are not a waiver; restore access and rerun the gate. + 3. Batch the changelog and update the version in one operation: ```bash @@ -131,6 +174,13 @@ The tag-triggered deploy workflow publishes using the existing Gradle command: Maven Central, GPG artifact signing, the Sonatype staging endpoint, and the release/close tasks are unchanged by the changelog tooling. Never run this production command as a dry-run substitute. +Before publishing, `release-checks` reads its gate implementation and maintainer list from `master`, +checks tag ancestry and version/changelog agreement, verifies the tag in the configured mode, and +requires security clearance and a complete `vX.Y.Z` milestone. `deploy` depends on those checks and +runs the Gradle build before publishing. After successful publication it runs `gh release create` +with the exact `.changes/vX.Y.Z.md` section as `--notes-file` and the three existing module bundles. +No default or automatically generated release body is used. + ## Verify the published release 1. Inspect the deployment run for the tag and confirm the Sonatype close/release step succeeded: diff --git a/scripts/release.py b/scripts/release.py index df0fad218..cbf6df39b 100644 --- a/scripts/release.py +++ b/scripts/release.py @@ -2,6 +2,7 @@ """Release metadata checks. Uses the standard library and the pinned Changie binary.""" import argparse +import json import os import pathlib import re @@ -74,6 +75,104 @@ def changelog_check(root, base, dependabot=False): print("changelog-check: generated changelog, fragments, and version agree") +def api_list(repo, resource): + if not re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", repo): + raise ValueError("invalid repository name") + result = subprocess.run(["gh", "api", "--paginate", "--slurp", + "repos/" + repo + "/" + resource], capture_output=True, text=True) + if result.returncode: + raise ValueError("cannot verify " + resource.split("?")[0] + "; check security-read access") + try: + pages = json.loads(result.stdout) + if not isinstance(pages, list) or not all(isinstance(page, list) for page in pages): + raise ValueError() + items = [item for page in pages for item in page] + if not all(isinstance(item, dict) for item in items): + raise ValueError() + return items + except (ValueError, TypeError): + raise ValueError("cannot verify " + resource.split("?")[0] + ": invalid API response") from None + + +def blocks_release(severity): + if severity is None: + return True # An untriaged advisory cannot establish a clear release gate. + if severity not in ("low", "medium", "high", "critical"): + raise ValueError("cannot verify an unknown severity") + return severity != "low" + + +def security_gate(repo): + sources = ( + ("Code scanning", "code-scanning/alerts?state=open&ref=refs/heads/master&per_page=100"), + ("Dependabot", "dependabot/alerts?state=open&per_page=100"), + ("Secret scanning", "secret-scanning/alerts?state=open&per_page=100"), + ("Repository advisories", "security-advisories?per_page=100"), + ("Issues", "issues?state=open&per_page=100"), + ) + blocked = False + allowed_states = { + "Code scanning": ("open", "fixed", "dismissed"), + "Dependabot": ("open", "fixed", "dismissed", "auto_dismissed"), + "Secret scanning": ("open", "resolved"), + "Repository advisories": ("draft", "triage", "published", "closed", "withdrawn"), + "Issues": ("open", "closed"), + } + for name, endpoint in sources: + count = 0 + try: + for item in api_list(repo, endpoint): + state = item["state"] + if state not in allowed_states[name]: + raise ValueError("cannot verify " + name + ": unknown finding state") + if name == "Repository advisories": + count += state in ("draft", "triage") and blocks_release(item["severity"]) + elif state == "open": + if name == "Code scanning": + severity = item["rule"].get("security_severity_level") + count += severity is not None and blocks_release(severity) + elif name == "Dependabot": + count += blocks_release(item["security_advisory"]["severity"]) + elif name == "Secret scanning": + count += 1 + elif name == "Issues": + labels = [re.sub(r"[\s:/_-]+", "", label["name"].lower()) for label in item["labels"]] + count += any(label in ("medium", "high", "critical", "severitymedium", + "severityhigh", "severitycritical") for label in labels) + except (KeyError, TypeError, AttributeError): + raise ValueError("cannot verify " + name + ": incomplete API response") from None + print(name + (": HOLD (" + str(count) + " blocking finding(s))" if count else ": clear")) + blocked |= count > 0 + if blocked: + raise ValueError("security gate holds this release") + print("security gate: clear") + + +def milestone_gate(repo, tag): + if not re.fullmatch("v" + VERSION, tag): + raise ValueError("expected a version tag") + matches = [item for item in api_list(repo, "milestones?state=all&per_page=100") if item.get("title") == tag] + if len(matches) != 1 or matches[0].get("open_issues") != 0: + raise ValueError("milestone " + tag + " must exist and have no open issues or pull requests") + print("milestone gate: clear (" + tag + ")") + + +def pages_status(): + try: + components = json.load(sys.stdin)["components"] + pages = [item for item in components if item["name"] in ("Pages", "GitHub Pages")] + if len(pages) != 1: + raise ValueError() + status = pages[0]["status"] + except (ValueError, KeyError, TypeError): + raise ValueError("cannot verify GitHub Pages status") from None + if status == "major_outage": + raise ValueError("GitHub Pages has a major outage; hold Javadoc deployment") + if status not in ("operational", "degraded_performance", "partial_outage", "under_maintenance"): + raise ValueError("cannot verify GitHub Pages status") + print("GitHub Pages status: " + status) + + def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--root", type=pathlib.Path, default=pathlib.Path(__file__).resolve().parents[1]) @@ -83,12 +182,24 @@ def main(): changelog = commands.add_parser("changelog-check") changelog.add_argument("--base") changelog.add_argument("--dependabot", action="store_true") + security = commands.add_parser("security") + security.add_argument("--repo", default="Backblaze/b2-sdk-java") + milestone = commands.add_parser("milestone") + milestone.add_argument("tag") + milestone.add_argument("--repo", default="Backblaze/b2-sdk-java") + commands.add_parser("pages-status") args = parser.parse_args() try: if args.command == "notes": print(release_notes(args.root, args.tag), end="") elif args.command == "changelog-check": changelog_check(args.root, args.base, args.dependabot) + elif args.command == "security": + security_gate(args.repo) + elif args.command == "milestone": + milestone_gate(args.repo, args.tag) + elif args.command == "pages-status": + pages_status() except (ValueError, OSError, subprocess.CalledProcessError) as error: print("HOLD: " + str(error), file=sys.stderr) return 1 diff --git a/scripts/tests/test_release_gates.py b/scripts/tests/test_release_gates.py new file mode 100644 index 000000000..1ec328828 --- /dev/null +++ b/scripts/tests/test_release_gates.py @@ -0,0 +1,110 @@ +"""Exercise API decisions using paginated fixtures; never contact GitHub.""" + +import json +import os +import pathlib +import subprocess +import sys +import tempfile +import unittest + + +SCRIPT = pathlib.Path(__file__).resolve().parents[1] / "release.py" +SOURCES = ("code-scanning/alerts", "dependabot/alerts", "secret-scanning/alerts", "security-advisories", "issues") + + +class ReleaseGateTest(unittest.TestCase): + def setUp(self): + self.temporary = tempfile.TemporaryDirectory() + self.addCleanup(self.temporary.cleanup) + self.root = pathlib.Path(self.temporary.name) + fake = self.root / "gh" + fake.write_text("""#!/usr/bin/env python3 +import json, os, sys +if '--paginate' not in sys.argv or '--slurp' not in sys.argv: + sys.exit(90) +endpoint = next(arg for arg in sys.argv if arg.startswith('repos/')).split('?')[0].split('repos/example/sdk/')[1] +fixture = json.loads(os.environ['RELEASE_GATE_FIXTURE']) +value = fixture.get(endpoint, 'unreadable') +if value == 'unreadable': + sys.exit(1) +print(json.dumps(value)) +""") + fake.chmod(0o755) + self.data = {source: [[]] for source in SOURCES} + self.data["milestones"] = [[{"title": "v1.2.3", "number": 4, "open_issues": 0}]] + + def run_gate(self, command="security", *arguments): + environment = dict(os.environ, PATH=str(self.root) + os.pathsep + os.environ["PATH"], + RELEASE_GATE_FIXTURE=json.dumps(self.data), GH_TOKEN="test-only") + return subprocess.run([sys.executable, str(SCRIPT), command, *arguments, "--repo", "example/sdk"], + env=environment, text=True, capture_output=True) + + def test_all_readable_empty_sources_pass(self): + result = self.run_gate() + self.assertEqual(0, result.returncode, result.stderr) + self.assertIn("security gate: clear", result.stdout) + + def test_medium_high_and_critical_dependencies_block_even_without_patch(self): + for severity in ("medium", "high", "critical"): + with self.subTest(severity=severity): + self.data["dependabot/alerts"] = [[], [{"state": "open", "security_advisory": {"severity": severity}}]] + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertIn("Dependabot", result.stdout) + + def test_open_code_scanning_and_severity_labeled_issues_block(self): + self.data["code-scanning/alerts"] = [[{"state": "open", "rule": {"security_severity_level": "high"}}]] + self.data["issues"] = [[{"state": "open", "labels": [{"name": "severity: medium"}]}]] + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertIn("Code scanning: HOLD", result.stdout) + self.assertIn("Issues: HOLD", result.stdout) + + def test_low_or_closed_findings_do_not_block(self): + self.data["dependabot/alerts"] = [[ + {"state": "open", "security_advisory": {"severity": "low"}}, + {"state": "dismissed", "security_advisory": {"severity": "critical"}}, + ]] + result = self.run_gate() + self.assertEqual(0, result.returncode, result.stderr) + + def test_unreadable_or_malformed_security_response_blocks(self): + for value in ("unreadable", {"message": "not an alerts list"}): + with self.subTest(value=value): + self.data["code-scanning/alerts"] = value + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertIn("cannot verify", result.stderr) + + def test_draft_advisory_and_secret_alerts_block_without_disclosing_contents(self): + self.data["security-advisories"] = [[{"state": "draft", "severity": "medium", "summary": "PRIVATE"}]] + self.data["secret-scanning/alerts"] = [[{"state": "open", "secret": "PRIVATE"}]] + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertNotIn("PRIVATE", result.stdout + result.stderr) + + def test_unscored_active_advisory_blocks(self): + self.data["security-advisories"] = [[{"state": "triage", "severity": None}]] + self.assertNotEqual(0, self.run_gate().returncode) + + def test_unknown_finding_state_is_not_clean(self): + self.data["dependabot/alerts"] = [[{"state": "unexpected", "security_advisory": {"severity": "high"}}]] + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertIn("cannot verify", result.stderr) + + def test_complete_version_milestone_passes(self): + result = self.run_gate("milestone", "v1.2.3") + self.assertEqual(0, result.returncode, result.stderr) + self.assertIn("milestone gate: clear", result.stdout) + + def test_missing_milestone_or_open_work_blocks(self): + self.data["milestones"] = [[]] + self.assertNotEqual(0, self.run_gate("milestone", "v1.2.3").returncode) + self.data["milestones"] = [[{"title": "v1.2.3", "number": 4, "open_issues": 1}]] + self.assertNotEqual(0, self.run_gate("milestone", "v1.2.3").returncode) + + +if __name__ == "__main__": + unittest.main() diff --git a/scripts/tests/test_signed_tags.py b/scripts/tests/test_signed_tags.py new file mode 100644 index 000000000..56b6789a0 --- /dev/null +++ b/scripts/tests/test_signed_tags.py @@ -0,0 +1,120 @@ +"""Verify real disposable Git/GPG/SSH signatures; mock only the key-download boundary.""" + +import os +import pathlib +import subprocess +import tempfile +import unittest + + +SCRIPT = pathlib.Path(__file__).resolve().parents[1] / "verify-release-tag.sh" + + +class SignedTagTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temporary = tempfile.TemporaryDirectory(prefix="b2-tag-", dir="/tmp") + cls.root = pathlib.Path(cls.temporary.name) + cls.home = cls.root / "gnupg" + cls.home.mkdir(mode=0o700) + cls.environment = dict(os.environ, GNUPGHOME=str(cls.home), GIT_CONFIG_GLOBAL=os.devnull, + GIT_CONFIG_NOSYSTEM="1") + cls.repo = cls.root / "repo" + cls.repo.mkdir() + cls.call(["git", "init", "-q"]) + cls.call(["git", "config", "user.name", "Release Fixture"]) + cls.call(["git", "config", "user.email", "fixture@example.invalid"]) + cls.call(["git", "-c", "commit.gpgSign=false", "commit", "--allow-empty", "-qm", "Fixture"]) + cls.call(["gpg", "--batch", "--pinentry-mode", "loopback", "--passphrase", "", + "--quick-generate-key", "Release Fixture ", "ed25519", "sign", "0"]) + keys = cls.call(["gpg", "--with-colons", "--list-secret-keys"]).stdout + fingerprint = next(line.split(":")[9] for line in keys.splitlines() if line.startswith("fpr:")) + cls.public_gpg = cls.root / "fixture.gpg" + cls.public_gpg.write_text(cls.call(["gpg", "--armor", "--export", fingerprint]).stdout) + cls.call(["git", "-c", "gpg.format=openpgp", "-c", "user.signingkey=" + fingerprint, + "tag", "-s", "v1.2.3", "-m", "v1.2.3"]) + cls.call(["git", "tag", "v1.2.4"]) + cls.ssh_key = cls.root / "ssh-key" + cls.call(["ssh-keygen", "-q", "-t", "ed25519", "-N", "", "-f", str(cls.ssh_key)]) + cls.call(["git", "-c", "gpg.format=ssh", "-c", "user.signingkey=" + str(cls.ssh_key), + "tag", "-s", "v1.2.5", "-m", "v1.2.5"]) + cls.maintainers = cls.root / "maintainers" + cls.maintainers.write_text("fixture-maintainer\n") + cls.bin = cls.root / "bin" + cls.bin.mkdir() + curl = cls.bin / "curl" + curl.write_text("""#!/usr/bin/env python3 +import os, pathlib, sys +path = os.environ.get('FIXTURE_GPG' if sys.argv[-1].endswith('.gpg') else 'FIXTURE_SSH') +if path: + print(pathlib.Path(path).read_text(), end='') +""") + curl.chmod(0o755) + gh = cls.bin / "gh" + gh.write_text("""#!/usr/bin/env python3 +import os, pathlib +path = os.environ.get('FIXTURE_SSH_SIGNING') +if path: + print(pathlib.Path(path).read_text(), end='') +""") + gh.chmod(0o755) + + @classmethod + def call(cls, command): + result = subprocess.run(command, cwd=cls.repo, env=cls.environment, text=True, capture_output=True) + if result.returncode: + raise RuntimeError(str(command) + ": " + result.stderr) + return result + + @classmethod + def tearDownClass(cls): + subprocess.run(["gpgconf", "--kill", "all"], env=cls.environment, capture_output=True) + cls.temporary.cleanup() + + def verify(self, tag="v1.2.3", enforce="true", registered=True, signing_only=False): + environment = dict(self.environment, PATH=str(self.bin) + os.pathsep + self.environment["PATH"], + ENFORCE_SIGNED_TAGS=enforce, + FIXTURE_GPG=str(self.public_gpg) if registered else "", + FIXTURE_SSH=str(self.ssh_key) + ".pub" if registered else "", + FIXTURE_SSH_SIGNING=str(self.ssh_key) + ".pub" if signing_only else "") + return subprocess.run(["bash", str(SCRIPT), tag, str(self.maintainers)], + cwd=self.repo, env=environment, text=True, capture_output=True) + + def test_registered_gpg_signature_passes_enforcing_gate(self): + result = self.verify() + self.assertEqual(0, result.returncode, result.stdout + result.stderr) + self.assertIn("verified", result.stdout) + + def test_registered_ssh_signature_passes_enforcing_gate(self): + result = self.verify("v1.2.5") + self.assertEqual(0, result.returncode, result.stdout + result.stderr) + self.assertIn("verified", result.stdout) + + def test_ssh_key_registered_only_for_signing_passes(self): + result = self.verify("v1.2.5", registered=False, signing_only=True) + self.assertEqual(0, result.returncode, result.stdout + result.stderr) + self.assertIn("verified", result.stdout) + + def test_unsigned_tag_blocks_when_enforced(self): + result = self.verify("v1.2.4") + self.assertNotEqual(0, result.returncode) + self.assertIn("annotated", result.stdout + result.stderr) + + def test_unregistered_signature_blocks_when_enforced(self): + result = self.verify(registered=False) + self.assertNotEqual(0, result.returncode) + self.assertIn("not verified", result.stdout + result.stderr) + + def test_default_mode_warns_without_blocking(self): + result = self.verify("v1.2.4", enforce="") + self.assertEqual(0, result.returncode, result.stderr) + self.assertIn("::warning::", result.stdout) + + def test_missing_registered_keys_warns_without_blocking(self): + result = self.verify(enforce="false", registered=False) + self.assertEqual(0, result.returncode, result.stderr) + self.assertIn("::warning::", result.stdout) + + +if __name__ == "__main__": + unittest.main() diff --git a/scripts/tests/test_workflows.py b/scripts/tests/test_workflows.py new file mode 100644 index 000000000..a611aa634 --- /dev/null +++ b/scripts/tests/test_workflows.py @@ -0,0 +1,54 @@ +"""Release workflow policy and GitHub Pages status contract checks.""" + +import json +import pathlib +import re +import subprocess +import sys +import unittest + + +ROOT = pathlib.Path(__file__).resolve().parents[2] + + +class WorkflowTest(unittest.TestCase): + def test_every_external_action_is_pinned_to_commit(self): + for workflow in (ROOT / ".github/workflows").glob("*.yml"): + for action in re.findall(r"uses:\s*([^\s#]+)", workflow.read_text()): + with self.subTest(workflow=workflow.name, action=action): + self.assertRegex(action, r"^[A-Za-z0-9_./-]+@[0-9a-f]{40}$") + + def test_replaced_community_actions_are_absent(self): + workflows = "\n".join(path.read_text() for path in (ROOT / ".github/workflows").glob("*.yml")) + for action in ("crazy-max/ghaction-github-pages", "crazy-max/ghaction-github-status", "softprops/action-gh-release"): + self.assertNotIn(action, workflows) + + def test_publish_command_and_signing_secrets_are_preserved(self): + workflow = (ROOT / ".github/workflows/deploy.yml").read_text() + self.assertIn("./gradlew publishToSonatype closeAndReleaseSonatypeStagingRepository createBundle --no-daemon --stacktrace", workflow) + for secret in ("GPG_SIGNING_KEY", "GPG_PASSPHRASE", "SONATYPE_TOKEN_USERNAME", "SONATYPE_TOKEN_PASSWORD"): + self.assertIn("secrets." + secret, workflow) + + +class PagesStatusTest(unittest.TestCase): + def run_status(self, payload): + return subprocess.run([sys.executable, str(ROOT / "scripts/release.py"), "pages-status"], + input=json.dumps(payload), text=True, capture_output=True) + + def test_operational_pages_passes(self): + result = self.run_status({"components": [{"name": "Pages", "status": "operational"}]}) + self.assertEqual(0, result.returncode, result.stderr) + + def test_major_outage_blocks_deployment(self): + result = self.run_status({"components": [{"name": "Pages", "status": "major_outage"}]}) + self.assertNotEqual(0, result.returncode) + self.assertIn("major outage", result.stderr) + + def test_unreadable_status_is_not_treated_as_operational(self): + result = self.run_status({"components": []}) + self.assertNotEqual(0, result.returncode) + self.assertIn("Pages status", result.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/scripts/verify-release-tag.sh b/scripts/verify-release-tag.sh new file mode 100644 index 000000000..73166a82e --- /dev/null +++ b/scripts/verify-release-tag.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +# Verify against the named maintainers' registered keys, isolated from the runner's own keyring. +set -euo pipefail + +tag=${1:?usage: verify-release-tag.sh TAG [MAINTAINERS_FILE]} +maintainers=${2:-.github/signing-maintainers} +enforce=${ENFORCE_SIGNED_TAGS:-false} + +reject() { + if [ "$enforce" = true ]; then + printf 'HOLD: %s\n' "$1" >&2 + exit 1 + fi + printf '::warning::%s (ENFORCE_SIGNED_TAGS is off)\n' "$1" + exit 0 +} + +git check-ref-format "refs/tags/$tag" >/dev/null 2>&1 || reject 'Invalid release tag' +[ "$(git cat-file -t "refs/tags/$tag" 2>/dev/null || true)" = tag ] || reject 'Release tag must be annotated and signed' +[ -r "$maintainers" ] || reject 'Maintainer key registry is unavailable' + +temporary=$(mktemp -d) +cleanup() { + gpgconf --homedir "$temporary/gnupg" --kill all >/dev/null 2>&1 || true + rm -rf "$temporary" +} +trap cleanup EXIT +mkdir -m 700 "$temporary/gnupg" +printf 'no-auto-key-retrieve\nauto-key-locate clear\n' > "$temporary/gnupg/gpg.conf" +export GNUPGHOME="$temporary/gnupg" +touch "$temporary/allowed_signers" + +while IFS= read -r username || [ -n "$username" ]; do + case "$username" in ''|'#'*) continue ;; esac + [[ "$username" =~ ^[a-zA-Z0-9][a-zA-Z0-9-]*$ ]] || reject 'Invalid maintainer username' + if curl --fail --silent --show-error --location --max-time 20 "https://github.com/$username.gpg" > "$temporary/key.gpg" 2>/dev/null; then + if [ -s "$temporary/key.gpg" ] && command -v gpg >/dev/null; then + gpg --batch --import "$temporary/key.gpg" >/dev/null 2>&1 || true + fi + fi + curl --fail --silent --show-error --location --max-time 20 "https://github.com/$username.keys" > "$temporary/key.ssh" 2>/dev/null || true + # Signing-only SSH keys are distinct from the authentication keys served by .keys. + gh api --paginate "users/$username/ssh_signing_keys?per_page=100" --jq '.[].key' >> "$temporary/key.ssh" 2>/dev/null || true + while IFS= read -r key; do + case "$key" in + ssh-*|ecdsa-*) printf '%s namespaces="git" %s\n' "$username" "$key" >> "$temporary/allowed_signers" ;; + esac + done < "$temporary/key.ssh" +done < "$maintainers" + +if git -c gpg.ssh.allowedSignersFile="$temporary/allowed_signers" verify-tag -- "$tag" > "$temporary/verification" 2>&1; then + printf 'release tag: verified against a registered maintainer key\n' +else + reject 'Release tag signature not verified against registered maintainer keys; enroll keys before enforcement' +fi From ee8011c68939102373cd108d081be20675213296 Mon Sep 17 00:00:00 2001 From: Felipe Fumero Date: Tue, 17 Nov 2026 15:27:40 -0600 Subject: [PATCH 2/3] ci: bind release validation to the event commit --- .github/workflows/deploy.yml | 5 +++-- RELEASE.md | 8 +++++--- scripts/release.py | 19 +++++++++++++++++++ scripts/tests/test_signed_tags.py | 24 ++++++++++++++++++++++++ scripts/tests/test_workflows.py | 6 ++++++ 5 files changed, 57 insertions(+), 5 deletions(-) diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index 2939b9426..19fb015ed 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -35,11 +35,11 @@ jobs: ENFORCE_SIGNED_TAGS: ${{ vars.ENFORCE_SIGNED_TAGS }} GH_TOKEN: ${{ github.token }} run: | - git merge-base --is-ancestor "$RELEASE_TAG^{commit}" origin/master + python3 scripts/release.py verify-commit "$RELEASE_TAG" "$GITHUB_SHA" bash scripts/verify-release-tag.sh "$RELEASE_TAG" - name: Check tag, version, and changelog agreement run: | - git worktree add --detach "$RUNNER_TEMP/release-metadata" "$RELEASE_TAG" + git worktree add --detach "$RUNNER_TEMP/release-metadata" "$GITHUB_SHA" python3 scripts/release.py --root "$RUNNER_TEMP/release-metadata" notes "$RELEASE_TAG" > /dev/null - name: Require complete version milestone env: @@ -62,6 +62,7 @@ jobs: steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 with: + ref: ${{ github.sha }} fetch-depth: 0 persist-credentials: false diff --git a/RELEASE.md b/RELEASE.md index d231acb37..45161fca4 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -175,9 +175,11 @@ Maven Central, GPG artifact signing, the Sonatype staging endpoint, and the rele are unchanged by the changelog tooling. Never run this production command as a dry-run substitute. Before publishing, `release-checks` reads its gate implementation and maintainer list from `master`, -checks tag ancestry and version/changelog agreement, verifies the tag in the configured mode, and -requires security clearance and a complete `vX.Y.Z` milestone. `deploy` depends on those checks and -runs the Gradle build before publishing. After successful publication it runs `gh release create` +requires the tag to resolve to the workflow's immutable event commit on `master`, checks +version/changelog agreement, verifies the tag in the configured mode, and requires security clearance +and a complete `vX.Y.Z` milestone. Metadata validation and the `deploy` checkout use that same event +commit. `deploy` depends on those checks and runs the Gradle build before publishing. After successful +publication it runs `gh release create` with the exact `.changes/vX.Y.Z.md` section as `--notes-file` and the three existing module bundles. No default or automatically generated release body is used. diff --git a/scripts/release.py b/scripts/release.py index cbf6df39b..86f6d9083 100644 --- a/scripts/release.py +++ b/scripts/release.py @@ -157,6 +157,20 @@ def milestone_gate(repo, tag): print("milestone gate: clear (" + tag + ")") +def verify_commit(root, tag, expected): + if not re.fullmatch("v" + VERSION, tag) or not re.fullmatch(r"[0-9a-f]{40}|[0-9a-f]{64}", expected): + raise ValueError("expected a version tag and immutable event commit") + actual = subprocess.check_output( + ["git", "rev-parse", "--verify", "refs/tags/" + tag + "^{commit}"], cwd=root, text=True + ).strip() + if actual != expected: + raise ValueError("release tag no longer matches the event commit") + result = subprocess.run(["git", "merge-base", "--is-ancestor", expected, "origin/master"], cwd=root) + if result.returncode: + raise ValueError("release event commit is not on origin/master") + print("release commit: matches event and origin/master") + + def pages_status(): try: components = json.load(sys.stdin)["components"] @@ -188,6 +202,9 @@ def main(): milestone.add_argument("tag") milestone.add_argument("--repo", default="Backblaze/b2-sdk-java") commands.add_parser("pages-status") + commit = commands.add_parser("verify-commit") + commit.add_argument("tag") + commit.add_argument("sha") args = parser.parse_args() try: if args.command == "notes": @@ -200,6 +217,8 @@ def main(): milestone_gate(args.repo, args.tag) elif args.command == "pages-status": pages_status() + elif args.command == "verify-commit": + verify_commit(args.root, args.tag, args.sha) except (ValueError, OSError, subprocess.CalledProcessError) as error: print("HOLD: " + str(error), file=sys.stderr) return 1 diff --git a/scripts/tests/test_signed_tags.py b/scripts/tests/test_signed_tags.py index 56b6789a0..1bb912c24 100644 --- a/scripts/tests/test_signed_tags.py +++ b/scripts/tests/test_signed_tags.py @@ -25,6 +25,8 @@ def setUpClass(cls): cls.call(["git", "config", "user.name", "Release Fixture"]) cls.call(["git", "config", "user.email", "fixture@example.invalid"]) cls.call(["git", "-c", "commit.gpgSign=false", "commit", "--allow-empty", "-qm", "Fixture"]) + cls.reviewed = cls.call(["git", "rev-parse", "HEAD"]).stdout.strip() + cls.call(["git", "update-ref", "refs/remotes/origin/master", cls.reviewed]) cls.call(["gpg", "--batch", "--pinentry-mode", "loopback", "--passphrase", "", "--quick-generate-key", "Release Fixture ", "ed25519", "sign", "0"]) keys = cls.call(["gpg", "--with-colons", "--list-secret-keys"]).stdout @@ -38,6 +40,9 @@ def setUpClass(cls): cls.call(["ssh-keygen", "-q", "-t", "ed25519", "-N", "", "-f", str(cls.ssh_key)]) cls.call(["git", "-c", "gpg.format=ssh", "-c", "user.signingkey=" + str(cls.ssh_key), "tag", "-s", "v1.2.5", "-m", "v1.2.5"]) + cls.call(["git", "-c", "commit.gpgSign=false", "commit", "--allow-empty", "-qm", "Unreviewed fixture"]) + cls.unreviewed = cls.call(["git", "rev-parse", "HEAD"]).stdout.strip() + cls.call(["git", "tag", "v1.2.8"]) cls.maintainers = cls.root / "maintainers" cls.maintainers.write_text("fixture-maintainer\n") cls.bin = cls.root / "bin" @@ -115,6 +120,25 @@ def test_missing_registered_keys_warns_without_blocking(self): self.assertEqual(0, result.returncode, result.stderr) self.assertIn("::warning::", result.stdout) + def check_commit(self, tag, commit): + return subprocess.run(["python3", str(SCRIPT.with_name("release.py")), "--root", str(self.repo), + "verify-commit", tag, commit], cwd=self.repo, env=self.environment, + text=True, capture_output=True) + + def test_tag_moved_away_from_event_commit_is_rejected(self): + result = self.check_commit("v1.2.3", self.unreviewed) + self.assertNotEqual(0, result.returncode) + self.assertIn("event commit", result.stderr) + + def test_matching_event_commit_on_master_passes(self): + result = self.check_commit("v1.2.3", self.reviewed) + self.assertEqual(0, result.returncode, result.stderr) + + def test_matching_tag_outside_master_is_rejected(self): + result = self.check_commit("v1.2.8", self.unreviewed) + self.assertNotEqual(0, result.returncode) + self.assertIn("origin/master", result.stderr) + if __name__ == "__main__": unittest.main() diff --git a/scripts/tests/test_workflows.py b/scripts/tests/test_workflows.py index a611aa634..dcab238a5 100644 --- a/scripts/tests/test_workflows.py +++ b/scripts/tests/test_workflows.py @@ -29,6 +29,12 @@ def test_publish_command_and_signing_secrets_are_preserved(self): for secret in ("GPG_SIGNING_KEY", "GPG_PASSPHRASE", "SONATYPE_TOKEN_USERNAME", "SONATYPE_TOKEN_PASSWORD"): self.assertIn("secrets." + secret, workflow) + def test_release_checks_and_deploy_use_the_same_event_commit(self): + workflow = (ROOT / ".github/workflows/deploy.yml").read_text() + self.assertIn('verify-commit "$RELEASE_TAG" "$GITHUB_SHA"', workflow) + deploy = workflow.split("\n deploy:\n", 1)[1] + self.assertIn("ref: ${{ github.sha }}", deploy) + class PagesStatusTest(unittest.TestCase): def run_status(self, payload): From 154633c91d1510f8b6c276caff258f3646d875e1 Mon Sep 17 00:00:00 2001 From: Felipe Fumero Date: Tue, 17 Nov 2026 15:35:14 -0600 Subject: [PATCH 3/3] ci: hold releases for unscored code scanning alerts --- RELEASE.md | 2 +- scripts/release.py | 2 +- scripts/tests/test_release_gates.py | 6 ++++++ scripts/tests/test_signed_tags.py | 2 ++ 4 files changed, 10 insertions(+), 2 deletions(-) diff --git a/RELEASE.md b/RELEASE.md index 45161fca4..40086e747 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -103,7 +103,7 @@ workflow files and human-authored changes still need a fragment. The gate reads all pages of GitHub code-scanning alerts on `master`, Dependabot alerts, draft/triage repository advisories, secret-scanning alerts, and severity-labeled open issues. Medium/high/critical findings block even without a patched version; all open secret alerts - and unscored active advisories block. Low findings do not block. The gate prints counts, + and unscored active advisories or code-scanning alerts block. Low findings do not block. The gate prints counts, never unpublished advisory text or secret values. Do not put private advisory details in a public issue. API failures are not a waiver; restore access and rerun the gate. diff --git a/scripts/release.py b/scripts/release.py index 86f6d9083..d0741d1e0 100644 --- a/scripts/release.py +++ b/scripts/release.py @@ -130,7 +130,7 @@ def security_gate(repo): elif state == "open": if name == "Code scanning": severity = item["rule"].get("security_severity_level") - count += severity is not None and blocks_release(severity) + count += blocks_release(severity) elif name == "Dependabot": count += blocks_release(item["security_advisory"]["severity"]) elif name == "Secret scanning": diff --git a/scripts/tests/test_release_gates.py b/scripts/tests/test_release_gates.py index 1ec328828..7f3394e9b 100644 --- a/scripts/tests/test_release_gates.py +++ b/scripts/tests/test_release_gates.py @@ -88,6 +88,12 @@ def test_unscored_active_advisory_blocks(self): self.data["security-advisories"] = [[{"state": "triage", "severity": None}]] self.assertNotEqual(0, self.run_gate().returncode) + def test_unscored_code_scanning_alert_blocks(self): + self.data["code-scanning/alerts"] = [[{"state": "open", "rule": {"id": "unscored-fixture"}}]] + result = self.run_gate() + self.assertNotEqual(0, result.returncode) + self.assertIn("Code scanning: HOLD", result.stdout) + def test_unknown_finding_state_is_not_clean(self): self.data["dependabot/alerts"] = [[{"state": "unexpected", "security_advisory": {"severity": "high"}}]] result = self.run_gate() diff --git a/scripts/tests/test_signed_tags.py b/scripts/tests/test_signed_tags.py index 1bb912c24..e4e3f4e1c 100644 --- a/scripts/tests/test_signed_tags.py +++ b/scripts/tests/test_signed_tags.py @@ -91,6 +91,8 @@ def test_registered_gpg_signature_passes_enforcing_gate(self): self.assertIn("verified", result.stdout) def test_registered_ssh_signature_passes_enforcing_gate(self): + tag = self.call(["git", "cat-file", "tag", "v1.2.5"]).stdout + self.assertIn("tagger Release Fixture ", tag) result = self.verify("v1.2.5") self.assertEqual(0, result.returncode, result.stdout + result.stderr) self.assertIn("verified", result.stdout)