diff --git a/.gitea/workflows/signing-check.yml b/.gitea/workflows/signing-check.yml new file mode 100644 index 0000000..461c8ae --- /dev/null +++ b/.gitea/workflows/signing-check.yml @@ -0,0 +1,29 @@ +# Checks the release signing secrets without cutting a tag (docs/work/release.md 5절). Manual only: +# run it after the owner puts SIGNING_KEY or SIGNING_PASSWORD in, and before tagging. It prints shapes +# and verdicts, never the secrets (scripts/release/check-signing-key.sh). +name: signing-check + +on: + workflow_dispatch: + +permissions: + contents: read + +jobs: + signing-check: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: https://github.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + - uses: https://github.com/actions/setup-java@c5195efecf7bdfc987ee8bae7a71cb8b11521c00 # v4.7.1 + with: + distribution: temurin + java-version: "21.0.11+10.0.LTS" + - uses: https://github.com/gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6 + with: + build-scan-publish: false + cache-read-only: true + - run: ./gradlew verifySigningKey --stacktrace + env: + SIGNING_KEY: ${{ secrets.SIGNING_KEY }} + SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }} diff --git a/build-logic/src/main/java/dev/caskeleton/buildlogic/publishing/LibraryPublishingPlugin.java b/build-logic/src/main/java/dev/caskeleton/buildlogic/publishing/LibraryPublishingPlugin.java index 2f42a9e..5aac5a4 100644 --- a/build-logic/src/main/java/dev/caskeleton/buildlogic/publishing/LibraryPublishingPlugin.java +++ b/build-logic/src/main/java/dev/caskeleton/buildlogic/publishing/LibraryPublishingPlugin.java @@ -13,6 +13,7 @@ import org.gradle.api.publish.PublishingExtension; import org.gradle.api.publish.maven.MavenPublication; import org.gradle.api.publish.maven.tasks.PublishToMavenRepository; import org.gradle.authentication.http.HttpHeaderAuthentication; +import org.gradle.plugins.signing.Sign; import org.gradle.plugins.signing.SigningExtension; /** @@ -145,6 +146,9 @@ public final class LibraryPublishingPlugin implements Plugin { SigningExtension signing = project.getExtensions().getByType(SigningExtension.class); signing.useInMemoryPgpKeys(signingKey, signingPassword); signing.sign(publication); + // The root's verifySigningKey says what is wrong with a key before Gradle's signing reports + // it only as "Could not read PGP secret key". + project.getTasks().withType(Sign.class).configureEach(task -> task.mustRunAfter(":verifySigningKey")); } // Nothing leaves the machine before the release checks have passed, and nothing reaches Gitea diff --git a/build.gradle b/build.gradle index fd71d64..70020c3 100644 --- a/build.gradle +++ b/build.gradle @@ -191,6 +191,21 @@ publishing { } def signingKey = providers.environmentVariable('SIGNING_KEY').getOrElse('') + +// Before anything is signed: the secret's shape, that gpg imports it as the release key and that +// SIGNING_PASSWORD signs with it, printing no part of either. Gradle's signing reports every one of +// these as "Could not read PGP secret key" (v1.0.0 release run 9); this says which. A key other +// than the release key passes with -PsigningKeyFingerprint= (a rehearsal key). +tasks.register('verifySigningKey', Exec) { + group = 'verification' + description = 'Checks SIGNING_KEY and SIGNING_PASSWORD without printing them (scripts/release/check-signing-key.sh).' + outputs.upToDateWhen { false } + commandLine 'bash', file('scripts/release/check-signing-key.sh'), + providers.gradleProperty('signingKeyFingerprint').getOrElse('') +} +tasks.withType(Sign).configureEach { + mustRunAfter tasks.named('verifySigningKey') +} if (!signingKey.isBlank()) { signing { useInMemoryPgpKeys(signingKey, providers.environmentVariable('SIGNING_PASSWORD').getOrElse('')) @@ -220,6 +235,9 @@ tasks.register('releaseRehearsal') { group = 'release' description = 'releaseCheck, then publishes every module and the SBOM to build/staging-repository and checks the files.' dependsOn tasks.named('releaseCheck') + if (!signingKey.isBlank()) { + dependsOn tasks.named('verifySigningKey') + } dependsOn tasks.named('publishAllPublicationsToStagingRepository') dependsOn leafPaths.collect { "${it}:publishAllPublicationsToStagingRepository" } def staging = layout.buildDirectory.dir('staging-repository') @@ -244,6 +262,7 @@ tasks.register('release') { group = 'release' description = 'releaseCheck, publish to Gitea Packages, then verify the version is readable anonymously.' dependsOn tasks.named('releaseCheck') + dependsOn tasks.named('verifySigningKey') dependsOn tasks.named('publishAllPublicationsToGiteaRepository') dependsOn leafPaths.collect { "${it}:publishAllPublicationsToGiteaRepository" } def url = providers.gradleProperty('packagesUrl') diff --git a/gradle.properties b/gradle.properties index c391713..764f198 100644 --- a/gradle.properties +++ b/gradle.properties @@ -3,6 +3,8 @@ libraryGroup=dev.cakit.grpc packagesUrl=https://git.learn.hyeonworks.com/api/packages/donghyeon.kang/maven repositoryUrl=https://git.learn.hyeonworks.com/donghyeon.kang/grpc-library +# The release signing key (public fingerprint). verifySigningKey refuses any other key in SIGNING_KEY. +signingKeyFingerprint=92646CEAFE816CF8B9C249F0A1C936D7F791F8AB # Build defaults, copied from the backend template's src/gradle.properties. org.gradle.workers.max=4 diff --git a/scripts/release/check-signing-key.sh b/scripts/release/check-signing-key.sh new file mode 100755 index 0000000..03988d7 --- /dev/null +++ b/scripts/release/check-signing-key.sh @@ -0,0 +1,136 @@ +#!/usr/bin/env bash +# Checks the release signing secrets before anything is signed, without printing them. +# +# scripts/release/check-signing-key.sh [expected fingerprint] +# +# Reads SIGNING_KEY (an ASCII-armoured PGP secret key) and SIGNING_PASSWORD from the environment and +# prints only shapes and verdicts: line and character counts, whether the armour lines and the blank +# line after BEGIN are where OpenPGP puts them, whether the base64 body decodes and its CRC24 matches, +# the first packet's tag, whether gpg imports it, the imported key's fingerprint (public), and whether +# SIGNING_PASSWORD signs with it. No value, line or fragment of either secret is ever printed; do not +# add `set -x` here. +# +# Why it exists: Gradle's signing reports any of these problems as one "Could not read PGP secret +# key", and the cause sits in a secret nobody can look at in the job log (v1.0.0 release run 9). +# Exit codes: 0 = the key would sign, 1 = a check failed (the line says which), 2 = usage. +set -euo pipefail + +expected=${1:-} +fail=0 + +if [ -z "${SIGNING_KEY:-}" ]; then + echo "check-signing-key: SIGNING_KEY is empty or not set" + exit 1 +fi +[ -n "${SIGNING_PASSWORD:-}" ] || echo "check-signing-key: SIGNING_PASSWORD is empty (only right for a key without a passphrase)" + +python3 - <<'PY' || fail=1 +import base64, os, re, sys + +key = os.environ["SIGNING_KEY"] +BEGIN = "-----BEGIN PGP PRIVATE KEY BLOCK-----" +END = "-----END PGP PRIVATE KEY BLOCK-----" +problems = [] + +print(f"shape: {len(key)} characters, {key.count(chr(10)) + 1} lines," + f" CR {'present' if chr(13) in key else 'absent'}," + f" literal backslash-n sequences {key.count(chr(92) + 'n')}," + f" non-ASCII characters {sum(1 for c in key if ord(c) > 127)}," + f" leading whitespace {'yes' if key[:1].isspace() else 'no'}," + f" trailing whitespace {'yes' if key[-1:].isspace() else 'no'}") + +lines = key.replace("\r\n", "\n").replace("\r", "\n").split("\n") +while lines and lines[-1].strip() == "": + lines.pop() +if "\n" not in key.replace("\r", "\n"): + problems.append("the value is one line: the newlines were lost (paste the file as is, with its line breaks)") +first = lines[0].strip() if lines else "" +last = lines[-1].strip() if lines else "" +print(f"armour: first line is BEGIN {'yes' if first == BEGIN else 'no'}, last line is END {'yes' if last == END else 'no'}") +if first != BEGIN: + kind = "a PUBLIC key block" if "PUBLIC KEY BLOCK" in first else "something else" + problems.append(f"the value does not start with the BEGIN PGP PRIVATE KEY BLOCK line (it starts with {kind})") +if last != END: + problems.append("the value does not end with the END PGP PRIVATE KEY BLOCK line (cut short?)") + +body = lines[1:-1] if first == BEGIN and last == END else lines +headers = [] +while body and ":" in body[0] and body[0].strip(): + headers.append(body.pop(0)) +blank_after = bool(body) and body[0].strip() == "" +print(f"armour headers: {len(headers)}, blank line after them {'yes' if blank_after else 'no'}") +if not blank_after: + problems.append("no blank line between the BEGIN line (and its headers) and the base64 body") +data = [l.strip() for l in body if l.strip()] +checksum = data.pop() if data and data[-1].startswith("=") else None +lengths = [len(l) for l in data] +full = sum(1 for n in lengths[:-1] if n == lengths[0]) if lengths else 0 +print(f"body: {len(data)} base64 lines, first {lengths[0] if lengths else 0} characters wide," + f" {full + (1 if lengths else 0)} of {len(data)} lines that width or the last," + f" checksum line {'present' if checksum else 'absent'}") +if lengths and any(n != lengths[0] for n in lengths[:-1]): + problems.append("base64 lines of different widths before the last one (lines joined, split or cut)") +joined = "".join(data) +bad = sum(1 for c in joined if not re.match(r"[A-Za-z0-9+/=]", c)) +if bad: + problems.append(f"{bad} characters outside the base64 alphabet in the body") +try: + raw = base64.b64decode(joined, validate=False) +except Exception as error: + raw = b"" + problems.append(f"the body does not decode as base64 ({type(error).__name__})") +if raw: + def crc24(data): + crc = 0xB704CE + for byte in data: + crc ^= byte << 16 + for _ in range(8): + crc <<= 1 + if crc & 0x1000000: + crc ^= 0x1864CFB + return crc & 0xFFFFFF + if checksum: + try: + stated = int.from_bytes(base64.b64decode(checksum[1:]), "big") + match = stated == crc24(raw) + except Exception: + match = False + print(f"CRC24 of the decoded body matches the checksum line: {'yes' if match else 'no'}") + if not match: + problems.append("the CRC24 checksum does not match: the base64 body was changed (a line lost, added or edited)") + header = raw[0] + tag = (header & 0x3F) if header & 0x40 else ((header & 0x3C) >> 2) + names = {5: "secret key", 6: "public key", 7: "secret subkey"} + print(f"first packet: tag {tag} ({names.get(tag, 'not a key packet')}), {len(raw)} bytes decoded") + if not header & 0x80 or tag != 5: + problems.append("the first packet is not a secret key packet (tag 5)") + +for problem in problems: + print(f"PROBLEM: {problem}") +sys.exit(1 if problems else 0) +PY + +home=$(mktemp -d) +trap 'rm -rf "$home"' EXIT +chmod 700 "$home" +if printf '%s\n' "$SIGNING_KEY" | GNUPGHOME="$home" gpg --batch --quiet --import >/dev/null 2>&1; then + fingerprint=$(GNUPGHOME="$home" gpg --batch --with-colons --list-secret-keys 2>/dev/null | awk -F: '/^fpr/{print $10; exit}') + echo "gpg import: ok, secret key fingerprint ${fingerprint:-none}" + if [ -n "$expected" ] && [ "${fingerprint:-}" != "$expected" ]; then + echo "PROBLEM: the imported key is not the release key ${expected}" + fail=1 + fi + printf 'signing check\n' > "$home/message" + if printf '%s' "${SIGNING_PASSWORD:-}" | GNUPGHOME="$home" gpg --batch --pinentry-mode loopback \ + --passphrase-fd 0 --local-user "${fingerprint:-none}" --detach-sign --output "$home/message.sig" \ + "$home/message" >/dev/null 2>&1; then + echo "signing with SIGNING_PASSWORD: ok" + else + echo "PROBLEM: SIGNING_PASSWORD does not unlock the key for signing (wrong passphrase, or the key is not a signing key)" + fail=1 + fi +else + echo "PROBLEM: gpg cannot import SIGNING_KEY" + fail=1 +fi +exit "$fail"