Tamper-Evident PDF Verification: How SHA-256 Cryptographic Seals Work (2026)

// SHA-256 Non-linear functions (32-bit words)
Ch(x, y, z)  = (x & y) ^ (~x & z)
Maj(x, y, z) = (x & y) ^ (x & z) ^ (y & z)
Σ0(x)        = ROTR^2(x) ^ ROTR^13(x) ^ ROTR^22(x)
Σ1(x)        = ROTR^6(x) ^ ROTR^11(x) ^ ROTR^25(x)
σ0(x)        = ROTR^7(x) ^ ROTR^18(x) ^ SHR^3(x)
σ1(x)        = ROTR^17(x) ^ ROTR^19(x) ^ SHR^10(x)

// Working variables state update:
T1 = h + Σ1(e) + Ch(e, f, g) + K_t + W_t
T2 = Σ0(a) + Maj(a, b, c)
h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;

// Step 1: Initial document hash
H0 = SHA256(Raw_Original_PDF_Bytes)

// Step 2: First signer event (intent + network telemetry + OTP)
H1 = SHA256(H0 + Signer1_UUID + Signer1_IP + Signer1_UserAgent + OTP_Hash + Timestamp_UTC)

// Step 3: Second signer event
H2 = SHA256(H1 + Signer2_UUID + Signer2_IP + Signer2_UserAgent + OTP_Hash + Timestamp_UTC)

// Step 4: Final RFC 3161 Timestamp & System Seal
Final_Audit_Seal = SHA256(H2 + TSA_TimestampToken + X509_Certificate_Serial)

import fs from 'node:fs';
import crypto from 'node:crypto';

/**
 * Calculates SHA-256 checksum of a buffer or file
 * @param {Buffer} buffer 
 * @returns {string} Hexadecimal SHA-256 string
 */
function computeSha256(buffer) {
  return crypto.createHash('sha256').update(buffer).digest('hex');
}

/**
 * Verifies document integrity against Signbee Audit Certificate
 * @param {string} pdfPath - Path to signed PDF file
 * @param {string} auditJsonPath - Path to exported Certificate of Completion JSON
 */
function verifyPdfAuditTrail(pdfPath, auditJsonPath) {
  console.log(`=== Tamper-Evident Verification Tool (Node.js) ===`);
  console.log(`Analyzing: ${pdfPath}\n`);

  if (!fs.existsSync(pdfPath) || !fs.existsSync(auditJsonPath)) {
    console.error('Error: File path not found.');
    process.exit(1);
  }

  const pdfBuffer = fs.readFileSync(pdfPath);
  const auditData = JSON.parse(fs.readFileSync(auditJsonPath, 'utf8'));

  // 1. Recompute actual file SHA-256
  const actualHash = computeSha256(pdfBuffer);
  console.log(`[1] Computed PDF SHA-256 Digest: ${actualHash}`);
  console.log(`    Expected Audit Log Digest:   ${auditData.document_sha256}`);

  const isHashMatching = actualHash.toLowerCase() === auditData.document_sha256.toLowerCase();

  if (isHashMatching) {
    console.log(`    >>> STATUS: OK (Hash matches exactly, 0 bits altered)\n`);
  } else {
    console.error(`    >>> TAMPER ALERT: Hash mismatch! File has been altered.\n`);
    return { verified: false, reason: 'HASH_MISMATCH' };
  }

  // 2. Validate Signer Hash Chain
  console.log(`[2] Verifying Signer Hash Chain & Forensics:`);
  let runningHash = auditData.original_document_sha256;

  for (let i = 0; i < auditData.events.length; i++) {
    const event = auditData.events[i];
    const eventPayload = [
      runningHash,
      event.signer_email,
      event.ip_address,
      event.user_agent,
      event.timestamp_utc,
      event.otp_verified ? 'OTP_VERIFIED' : 'NO_OTP'
    ].join('|');

    const expectedEventHash = crypto.createHash('sha256').update(eventPayload).digest('hex');
    const isValidEvent = expectedEventHash === event.event_hash;

    console.log(`    Event ${i + 1} [${event.action} - ${event.signer_email}]: ${isValidEvent ? 'CHAIN INTACT' : 'CHAIN BROKEN'}`);
    console.log(`      - IP Address: ${event.ip_address}`);
    console.log(`      - Timestamp:  ${event.timestamp_utc}`);
    console.log(`      - RFC 3161:   ${event.timestamp_authority}`);

    if (!isValidEvent) {
      console.error(`    >>> TAMPER ALERT: Signer audit record compromised at event ${i + 1}!`);
      return { verified: false, reason: 'CHAIN_COMPROMISED' };
    }
    runningHash = expectedEventHash;
  }

  // 3. Output Final Verification Verdict
  console.log(`\n======================================================`);
  console.log(`VERIFICATION RESULT: PASSED (100% Cryptographically Intact)`);
  console.log(`Defensibility: Valid for Federal Rules of Evidence Rule 902`);
  console.log(`======================================================`);

  return { verified: true, computedHash: actualHash };
}

// Execution
const [pdfFile, certFile] = process.argv.slice(2);
if (pdfFile && certFile) {
  verifyPdfAuditTrail(pdfFile, certFile);
} else {
  console.log('Usage: node verify_tamper_evident.mjs <document.pdf> <certificate.json>');
}

#!/usr/bin/env python3
"""
Signbee Independent PDF & SHA-256 Audit Trail Verifier
Zero-dependency forensic verification script.
"""

import sys
import os
import json
import hashlib

def calculate_sha256(filepath: str) -> str:
    """Calculates SHA-256 over 64KB chunks to support arbitrarily large files."""
    sha256 = hashlib.sha256()
    with open(filepath, 'rb') as f:
        while chunk := f.read(65536):
            sha256.update(chunk)
    return sha256.hexdigest()

def verify_document(pdf_path: str, audit_path: str):
    print("=" * 60)
    print(" SIGNBEE INDEPENDENT SHA-256 PDF VERIFICATION ENGINE")
    print("=" * 60)
    print(f"Target Document: {pdf_path}")
    print(f"Audit Manifest:  {audit_path}\n")

    if not os.path.exists(pdf_path) or not os.path.exists(audit_path):
        print("[ERROR] Input files not found. Please verify file paths.")
        sys.exit(1)

    with open(audit_path, 'r', encoding='utf-8') as f:
        audit = json.load(f)

    # 1. Compute binary file hash
    computed_digest = calculate_sha256(pdf_path)
    expected_digest = audit.get("document_sha256", "").lower()

    print(f"[1] Computed File Digest:   {computed_digest}")
    print(f"    Certificate Seal Digest: {expected_digest}")

    if computed_digest.lower() != expected_digest:
        print("\n[!] CRITICAL INTEGRITY FAILURE: Hashes do not match!")
        print("    The PDF has been altered or damaged after signing.")
        sys.exit(2)
    else:
        print("    [+] Integrity Check: MATCH (0 bit deviations)\n")

    # 2. Inspect Audit Trail Forensics
    print("[2] Signer Audit Trail Forensics:")
    running_hash = audit.get("original_document_sha256")
    events = audit.get("events", [])

    for idx, ev in enumerate(events, 1):
        payload = f"{running_hash}|{ev['signer_email']}|{ev['ip_address']}|{ev['user_agent']}|{ev['timestamp_utc']}|{'OTP_VERIFIED' if ev.get('otp_verified') else 'NO_OTP'}"
        calc_event_hash = hashlib.sha256(payload.encode('utf-8')).hexdigest()
        
        is_intact = (calc_event_hash == ev.get("event_hash"))
        status_str = "VALID" if is_intact else "CORRUPTED"

        print(f"    Event {idx}: [{ev.get('action')}] by {ev.get('signer_email')}")
        print(f"      - Status:     {status_str}")
        print(f"      - Timestamp:  {ev.get('timestamp_utc')} (UTC)")
        print(f"      - IP Address: {ev.get('ip_address')}")
        print(f"      - User Agent: {ev.get('user_agent')[:45]}...")

        if not is_intact:
            print(f"\n[!] AUDIT CHAIN BROKEN at step {idx}. Record was modified.")
            sys.exit(3)

        running_hash = calc_event_hash

    print("\n" + "=" * 60)
    print("FINAL VERDICT: DOCUMENT IS AUTHENTIC AND UNMODIFIED")
    print("Complies with Federal Rules of Evidence FRE 902(13) / 902(14)")
    print("=" * 60)

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Usage: python verify_tamper_evident.py <contract.pdf> <certificate.json>")
        sys.exit(1)
    verify_document(sys.argv[1], sys.argv[2])