Mon Dec 15 00:06:00 PST 2025

Author: 0x77dev

.cargo/config.toml

@@ -1,5 +1,5 @@
 [target.wasm32-unknown-unknown]
-# Disable hardening flags that don't work with WASM
+# Configure WASM target with appropriate stack size
 rustflags = [
     "-C", "link-arg=-zstack-size=4194304",
 ]

Cargo.toml

@@ -29,8 +29,8 @@ tracing = "0.1"
 # Serialization
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-bilrost = "0.1010"
-bilrost-derive = "0.1010"
+bilrost = "0.1010.2"
+bilrost-derive = "0.1010.2"
 
 # Hashing
 sha2 = "0.10"

README.md

@@ -1,6 +1,6 @@
 # pdf-sign
 
-A lightweight, modern PDF signing utility written in Rust that supports both **OpenPGP (GPG)** and **Sigstore (keyless OIDC)** signatures. It appends cryptographic signatures directly to PDFs, making it easy to sign and verify documents without heavyweight PDF signing stacks, making your PDFs authentic and tamper-proof.
+PDF signing utility written in Rust that supports both **OpenPGP (GPG)** and **Sigstore (keyless OIDC)** signatures, appending cryptographic signatures directly to PDFs, making it easy to sign and verify documents without heavyweight PDF signing stacks, making your PDFs authentic, tamper-proof, while being fully compatible with regular readers.
 
 [![asciicast](https://asciinema.org/a/JXR1crpqtcbMT1DIhD3dzXFB9.svg)](https://asciinema.org/a/JXR1crpqtcbMT1DIhD3dzXFB9)
 
@@ -280,11 +280,20 @@ Versioned bilrost-encoded blocks with digest binding:
 
 ## Environment Variables
 
+### General
+
 * `GNUPGHOME`: GPG keybox location (default: `~/.gnupg`)
 * `RUST_LOG`: Tracing verbosity (e.g., `RUST_LOG=debug`)
-* Output channels:
-  * `stderr`: Progress, status, errors
-  * `stdout`: Result paths (sign) or "OK" (verify) for pipelines
+
+### Sigstore-Specific
+
+* `SIGSTORE_IDENTITY_TOKEN`: Pre-obtained OIDC identity token (JWT) for CI workflows (bypasses interactive browser flow)
+* `OIDC_REDIRECT_PORT`: Local port for OIDC callback listener (default: OS-assigned dynamic port). Set to a fixed port (e.g., `8080`) if you need predictable port forwarding or firewall rules
+
+### Output Channels
+
+* `stderr`: Progress, status, errors
+* `stdout`: Result paths (sign) or "OK" (verify) for pipelines
 
 ## Examples
 

crates/cli/src/cli.rs

@@ -66,6 +66,7 @@ pub enum Commands {
     oidc_client_secret: Option<String>,
 
     /// Identity token (JWT) for non-interactive signing (Sigstore backend, CI mode)
+    /// Can also be set via SIGSTORE_IDENTITY_TOKEN environment variable
     #[arg(long)]
     identity_token: Option<String>,
 

crates/cli/src/commands.rs

@@ -120,12 +120,18 @@ pub fn verify_pdf(
     let cert_identity_matcher = match (certificate_identity, certificate_identity_regexp) {
       (Some(exact), None) => Some(CertificateIdentityMatcher::Exact(exact)),
       (None, Some(re)) => Some(CertificateIdentityMatcher::Regexp(re)),
+      (Some(_), Some(_)) => {
+        bail!("Cannot specify both --certificate-identity and --certificate-identity-regexp")
+      }
       _ => None,
     };
 
     let cert_issuer_matcher = match (certificate_oidc_issuer, certificate_oidc_issuer_regexp) {
       (Some(exact), None) => Some(OidcIssuerMatcher::Exact(exact)),
       (None, Some(re)) => Some(OidcIssuerMatcher::Regexp(re)),
+      (Some(_), Some(_)) => {
+        bail!("Cannot specify both --certificate-oidc-issuer and --certificate-oidc-issuer-regexp")
+      }
       _ => None,
     };
 

crates/cli/src/sign.rs

@@ -58,14 +58,6 @@ pub fn sign_gpg(
   let (clean_pdf, suffix) = split_pdf(&pdf_data)?;
   let existing_blocks = parse_suffix_blocks(suffix)?;
 
-  let existing_pgp_sigs: Vec<_> = existing_blocks
-    .iter()
-    .filter_map(|b| match b {
-      SuffixBlock::OpenPgpSig(data) => Some(data.clone()),
-      _ => None,
-    })
-    .collect();
-
   let cert = pdf_sign_gpg::load_cert(&key_spec)?;
 
   let fingerprint = cert.fingerprint();
@@ -132,11 +124,10 @@ pub fn sign_gpg(
   out.write_all(clean_pdf)?;
   out.write_all(b"\n")?;
 
-  for sig in &existing_pgp_sigs {
-    out.write_all(sig)?;
-    if !sig.ends_with(b"\n") {
-      out.write_all(b"\n")?;
-    }
+  // Preserve existing signature blocks (OpenPGP and Sigstore) when adding a new GPG signature.
+  for block in &existing_blocks {
+    let encoded = encode_suffix_block(block);
+    out.write_all(&encoded)?;
   }
   out.write_all(&sign_result.signature_data)?;
   out.flush()?;

crates/cli/src/util.rs

@@ -3,6 +3,9 @@
 pub fn format_bytes(bytes: usize) -> String {
   const KB: f64 = 1024.0;
   const MB: f64 = KB * 1024.0;
+  // Threshold chosen to avoid displaying "1024.0 KB" due to rounding.
+  // At 1_048_524 bytes (1023.99 KB), we still show KB.
+  // At 1_048_525 bytes and above, we switch to MB display.
   const KB_TO_MB_ROUNDING_THRESHOLD: usize = 1_048_525;
 
   if bytes < 1024 {

crates/core/src/digest.rs

@@ -101,6 +101,12 @@ mod tests {
     let data = b"hello";
     let digest = compute_digest(DigestAlgorithm::Sha512, data);
     assert_eq!(digest.len(), 64);
+    // Known SHA-512 of "hello"
+    let expected_hex = "9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043";
+    let expected: Vec<u8> = (0..64)
+      .map(|i| u8::from_str_radix(&expected_hex[i * 2..i * 2 + 2], 16).unwrap())
+      .collect();
+    assert_eq!(digest, expected);
   }
 
   #[test]

crates/core/src/pdf.rs

@@ -46,4 +46,10 @@ mod tests {
     assert_eq!(clean, b"%%PDF-1.4\ncontent%%EOF");
     assert_eq!(suffix, b"suffix");
   }
+
+  #[test]
+  fn errors_when_no_eof_marker() {
+    let invalid = b"%%PDF-1.4\n...content...";
+    assert!(find_eof_offset(invalid).is_err());
+  }
 }

crates/gpg/src/challenge.rs

@@ -117,7 +117,7 @@ pub fn apply_response(
   let signature_data = signature_armored.as_bytes().to_vec();
 
   // Validate signature cryptographically
-  validate_response(challenge, &signature_data)?;
+  validate_response(challenge, &signature_data, cert)?;
 
   let fingerprint = cert.fingerprint().to_string();
   let uids: Vec<String> = cert
@@ -143,7 +143,7 @@ pub fn apply_response(
 /// This function cryptographically verifies that the signature was
 /// created for the challenge's data.
 #[tracing::instrument(skip(challenge, signature))]
-pub fn validate_response(challenge: &Challenge, signature: &[u8]) -> Result<()> {
+pub fn validate_response(challenge: &Challenge, signature: &[u8], cert: &Cert) -> Result<()> {
   // Parse the signature
   let signature_reader = armor::Reader::from_bytes(
     signature,
@@ -154,22 +154,42 @@ pub fn validate_response(challenge: &Challenge, signature: &[u8]) -> Result<()>
   let policy = StandardPolicy::new();
 
   // Helper for verification
-  struct Helper;
-  impl VerificationHelper for Helper {
+  struct Helper<'a> {
+    cert: &'a Cert,
+  }
+
+  impl VerificationHelper for Helper<'_> {
     fn get_certs(&mut self, _ids: &[openpgp::KeyHandle]) -> openpgp::Result<Vec<Cert>> {
-      // We don't verify the cert here, just check signature structure
-      Ok(Vec::new())
+      Ok(vec![self.cert.clone()])
     }
 
-    fn check(&mut self, _structure: MessageStructure) -> openpgp::Result<()> {
-      // Basic structure check only
-      Ok(())
+    fn check(&mut self, structure: MessageStructure) -> openpgp::Result<()> {
+      let mut has_valid_signature = false;
+      for layer in structure {
+        if let MessageLayer::SignatureGroup { results } = layer {
+          for result in results {
+            if result.is_ok() {
+              has_valid_signature = true;
+              break;
+            }
+          }
+        }
+      }
+
+      if has_valid_signature {
+        Ok(())
+      } else {
+        Err(openpgp::Error::InvalidOperation("No valid signature".into()).into())
+      }
     }
   }
 
   // Try to parse as a detached signature
-  let mut verifier =
-    DetachedVerifierBuilder::from_reader(signature_reader)?.with_policy(&policy, None, Helper)?;
+  let mut verifier = DetachedVerifierBuilder::from_reader(signature_reader)?.with_policy(
+    &policy,
+    None,
+    Helper { cert },
+  )?;
 
   // Verify against challenge data
   verifier