What does PGP signature verification in Gradle's dependency verification feature actually verify, and how does it differ from a checksum?

## What problem this solves When Gradle resolves a dependency it downloads a binary (a JAR, POM, etc.) from a repository. **Dependency verification** lets you assert, ahead of time, that every artifact you consume is exactly what you expect — defending against a compromised mirror, a hijacked account, or a man-in-the-middle swapping bytes. Gradle records these expectations in a file at `gradle/verification-metadata.xml`. There are two complementary mechanisms: ### Checksums A checksum is a cryptographic hash (e.g. `sha256`) of the artifact's bytes. You record the expected value; Gradle recomputes the hash on download and fails if it differs. This proves **integrity** (the bytes were not altered) but not **authenticity** — a hash carries no notion of an author. If an attacker can alter the artifact *and* the recorded hash (e.g. by compromising the same supply chain), the check passes. ### PGP signatures PGP (Pretty Good Privacy) uses asymmetric cryptography. A publisher signs the artifact with their **private key**, producing a small detached signature file published alongside the artifact with a `.asc` extension (e.g. `foo-1.0.jar.asc`). Anyone can verify that signature using the publisher's **public key**: a valid signature could only have been produced by the private-key holder, so it proves **both integrity and authenticity**. In `verification-metadata.xml` you express trust in keys: ```xml <configuration> <verify-metadata>true</verify-metadata> <verify-signatures>true</verify-signatures> </configuration> <trusted-keys> <trusted-key id="ABCDEF0123456789ABCDEF0123456789ABCDEF01" group="com.example"/> </trusted-keys> ``` When `verify-signatures` is true, for each artifact Gradle: 1. Downloads the artifact's `.asc` detached signature (if the repository publishes one). 2. Obtains the signing public key — from a configured **key server** (e.g. `keyserver.ubuntu.com`) or a **local keyring** file (`gradle/verification-keyring.keys` / `.gpg`). 3. Validates the signature; if it's made by a `<trusted-key>` (matched by fingerprint, optionally scoped to a `group`/`module`), the artifact passes. Artifacts that have **no** `.asc` published can't be PGP-verified, so Gradle falls back to the recorded checksum for those. This is why real-world metadata files contain a mix of `<pgp>` and `<sha256>` entries. ### Key identifiers Keys are referenced by their **fingerprint** (40 hex chars) or **long key ID** (last 16 hex). Always prefer the full fingerprint: short key IDs are vulnerable to collision attacks where an attacker crafts a different key with the same short ID. ### Bottom line Use PGP where publishers sign (most Maven Central artifacts do), and checksums everywhere else. PGP raises the bar from "these bytes match what I saw" to "these bytes were signed by a party I chose to trust."