Technical Whitepaper

Executive Summary

Witness is a free iOS camera application that provides cryptographic proof of photo and video authenticity. In an era where AI can generate photorealistic images and video indistinguishable from real footage, Witness addresses a fundamental trust problem: how do you prove content is real, unedited, and captured at a specific time and place?

The Problem: Digital photos and videos carry no inherent proof of authenticity. Anyone can claim footage is fake, edited, or AI-generated — and increasingly, they're right to be skeptical.

Our Solution: Witness implements a five-layer verification stack that creates independent, cryptographic proofs at the moment of capture:

1. 1 SHA-256 Hash — Mathematical fingerprint of image/video data
2. 2 Apple App Attest — Hardware-backed device authenticity
3. 3 Secure Enclave Signature — Tamper-proof metadata signing
4. 4 C2PA Content Credentials — Industry-standard provenance metadata
5. 5 Bitcoin Timestamp — Blockchain-anchored temporal proof

Each layer addresses different trust requirements and failure modes. Together, they create verification that is mathematically provable, hardware-backed, industry-compatible, and permanently timestamped.

Beyond verification, Witness provides tools for collaborative documentation: organizations with shared verified feeds, a live map of verified content, direct social sharing with metadata intact, QR code verification, public profiles, and offline capture.

Witness is free, requires no account, and does not track users.

Problem Statement

The Trust Crisis in Digital Media

The proliferation of AI-generated content has fundamentally undermined trust in digital imagery. Modern generative models can create photorealistic images of events that never happened, people who don't exist, and documents that were never written. This creates three cascading problems:

1. Real content becomes dismissible. When AI can generate anything, authentic documentation of real events can be dismissed as fake. Footage of police misconduct, environmental violations, or human rights abuses faces automatic skepticism.

2. Verification burden falls on creators. The traditional assumption — that photos are real unless proven fake — has inverted. Now, photographers must prove their content is authentic, often without the tools to do so.

3. Existing solutions are inadequate. Current approaches suffer from critical limitations:

• Metadata is trivially editable. EXIF timestamps and GPS coordinates can be modified with free software.
• Cloud timestamps require trust. Services that timestamp photos require users to trust the service operator.
• AI detection is unreliable. Detectors produce false positives and negatives, and improve slower than generators.

Who Needs Verification

Witness is designed for anyone whose documentation must be trusted:

• Activists documenting protests, police actions, and government overreach with proof that can't be dismissed
• Citizen journalists building credibility with verified, timestamped footage
• Community organizers coordinating documentation across their entire team
• Professional journalists sourcing verified footage from the ground
• Legal observers collecting evidence with chain of custody for court proceedings
• News organizations establishing provenance for user-generated content

For these users, the stakes are high. A dismissible photo means a story that doesn't get published, evidence that doesn't hold up in court, or an injustice that goes unaddressed.

Verification Architecture

The Five-Layer Stack

Witness's architecture is built on a principle of defense in depth: multiple independent verification systems, each addressing different trust models and failure scenarios. If any single layer is compromised, the others remain valid.

┌────────────────────────────────────────────────────┐
│            Photo/Video Captured             │
└────────────────────────────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│  Layer 1: SHA-256 Hash                      │
│  Cryptographic fingerprint                  │
│  Trust: Mathematical certainty              │
└────────────────────────────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│  Layer 2: Apple App Attest                  │
│  Hardware attestation via Apple              │
│  Trust: Apple Secure Enclave + servers       │
└────────────────────────────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│  Layer 3: Secure Enclave Signature           │
│  P256 ECDSA in tamper-proof hardware         │
│  Trust: iPhone hardware security module      │
└────────────────────────────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│  Layer 4: C2PA Content Credentials           │
│  Industry-standard provenance metadata       │
│  Trust: Adobe/Microsoft/BBC coalition        │
└────────────────────────────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│  Layer 5: Bitcoin Timestamp                  │
│  OpenTimestamps on Bitcoin blockchain        │
│  Trust: Decentralized, trustless consensus   │
└────────────────────────────────────────────────────┘

Why Multiple Layers Matter

Each verification layer has different trust assumptions:

A single-layer system fails if that layer is compromised. Witness's multi-layer approach means an attacker would need to simultaneously compromise the SHA-256 algorithm, Apple's attestation infrastructure, the iPhone's Secure Enclave, the C2PA certificate chain, and the Bitcoin blockchain. This combination provides practical unforgability.

Technical Implementation

Layer 1: SHA-256 Hashing

Implementation: Apple CryptoKit framework

At capture, Witness computes a SHA-256 hash of the raw image or video data. This creates a 256-bit fingerprint that is deterministic (same input always produces same hash), collision-resistant (finding two inputs with the same hash is computationally infeasible), and sensitive (changing a single pixel produces a completely different hash).

import CryptoKit

func computeHash(imageData: Data) -> String {
    let digest = SHA256.hash(data: imageData)
    return digest.compactMap { String(format: "%02x", $0) }.joined()
}

The hash is stored alongside the content and displayed in the verification overlay. Recipients can recompute the hash to verify the content hasn't been modified.

Layer 2: Apple App Attest

Implementation: DeviceCheck framework with App Attest API

App Attest provides hardware-backed proof that the app is the genuine Witness application (not modified or repackaged), running on a genuine Apple device (not emulated or jailbroken), and that the attestation was generated at a specific time.

Process:

1. At first launch, Witness generates a key pair in the Secure Enclave
2. The public key is sent to Apple's attestation servers
3. Apple returns a signed attestation linking the key to the device and app
4. At capture, Witness signs metadata with the attested key
5. Verifiers can validate the signature against Apple's root certificate

import DeviceCheck

func generateAttestation(challenge: Data) async throws -> Data {
    let service = DCAppAttestService.shared
    let keyId = try await service.generateKey()
    return try await service.attestKey(keyId, clientDataHash: challenge)
}

Layer 3: Secure Enclave Signature

Implementation: Security framework with kSecAttrTokenIDSecureEnclave

The Secure Enclave is a hardware security module built into Apple's chips. It stores cryptographic keys in isolated, tamper-resistant hardware, performs cryptographic operations without exposing keys to the main processor, and cannot be accessed even if iOS is compromised.

Witness creates a P256 ECDSA key pair in the Secure Enclave and uses it to sign metadata:

func createSecureEnclaveKey() throws -> SecKey {
    let attributes: [String: Any] = [
        kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
        kSecAttrKeySizeInBits as String: 256,
        kSecAttrTokenID as String: kSecAttrTokenIDSecureEnclave,
        kSecPrivateKeyAttrs as String: [
            kSecAttrIsPermanent as String: true,
            kSecAttrApplicationTag as String: "com.witness.signing"
        ]
    ]

    var error: Unmanaged<CFError>?
    guard let key = SecKeyCreateRandomKey(
        attributes as CFDictionary, &error
    ) else {
        throw error!.takeRetainedValue()
    }
    return key
}

Layer 4: C2PA Content Credentials

Implementation: C2PA Swift SDK

C2PA (Coalition for Content Provenance and Authenticity) is an industry standard developed by Adobe, Microsoft, BBC, Intel, and others. It embeds cryptographically signed metadata directly into image and video files.

Witness embeds C2PA Content Credentials that include capture device information, timestamp, GPS coordinates, software identification, and a cryptographic signature.

import C2PA

func embedCredentials(image: Data, metadata: CaptureMetadata) throws -> Data {
    let manifest = C2PAManifest()
    manifest.addAssertion(.captureInfo(
        device: metadata.device,
        timestamp: metadata.timestamp,
        location: metadata.coordinates
    ))
    return try manifest.embed(in: image, signingKey: witnessSigningKey)
}

Interoperability: C2PA credentials can be verified by Adobe Photoshop and Lightroom, Microsoft products, news organization verification tools, any C2PA-compatible software, and the Witness web verification page at witnesshq.com/verify.

Layer 5: Bitcoin Timestamp (OpenTimestamps)

Implementation: OpenTimestamps protocol over HTTP

OpenTimestamps anchors data hashes to the Bitcoin blockchain, creating permanent, decentralized proof that the data existed at a specific time.

Process:

1. At capture, Witness submits the content hash to multiple OpenTimestamps calendar servers
2. Calendar servers batch hashes and create a Merkle tree
3. The Merkle root is embedded in a Bitcoin transaction
4. Once confirmed (~10 minutes to 2 hours), the timestamp is permanent

Content Hash ──┐
               ├── Merkle Tree ── Merkle Root ── Bitcoin Transaction
Other Hashes ──┘

Platform Features

Security Model & Threat Analysis

Threats Witness Addresses

Threats Witness Does Not Address

Witness cannot prove that a photo or video depicts reality. It proves the content hasn't been modified since capture, it was captured on a genuine device running Witness, and it was captured at a specific time and location.

It does not prove:

• The scene wasn't staged
• The camera wasn't pointed at a screen showing AI-generated content
• The content wasn't taken of a forgery

These limitations are inherent to any camera-based verification system. Witness provides the strongest possible guarantee that the digital file is authentic — what the camera saw is a separate question.

Attack Scenarios

Scenario 1: Sophisticated device compromise

An attacker with hardware-level access to the iPhone could potentially extract Secure Enclave keys.

Mitigation: App Attest provides server-side verification through Apple's infrastructure. Even with device compromise, the attacker cannot forge Apple's attestation.

Scenario 2: Compromised OpenTimestamps calendar

A malicious calendar server could refuse to timestamp or provide false proofs.

Mitigation: Witness submits to multiple independent calendar servers. Timestamps are also verifiable against the Bitcoin blockchain directly.

Scenario 3: Future SHA-256 weakness

Theoretical advances in cryptanalysis could weaken SHA-256.

Mitigation: The multi-layer stack means other proofs remain valid. C2PA and OpenTimestamps can migrate to stronger algorithms if needed.

Privacy Design

"Allow While Using" Location Model

Witness requests location access with the "Allow While Using" permission level. This means location is only accessed when the app is open and in use. There is no background location tracking, no location history stored on servers, and users can revoke permission at any time.

Local-First Architecture

Content is stored locally on the device. Witness does not upload photos or videos to Witness servers, require accounts or user registration, track user behavior or analytics, or store personal information.

What Data Leaves the Device

The only data transmitted externally:

• To Apple: App Attest requests (device attestation, no content data)
• To OpenTimestamps: Content hashes only (not photos/videos, not metadata)
• User-initiated sharing: When users explicitly share content or post to the Live Map

The content itself, GPS coordinates, and other metadata remain on-device unless the user chooses to share.

Standards Compliance

C2PA Conformance

Witness implements the C2PA 1.4 specification, including manifest structure and signing, required assertions for capture devices, certificate chain validation, and embedding in JPEG, PNG, and video formats.

C2PA credentials created by Witness can be verified by Adobe Content Authenticity Initiative tools, Microsoft products with C2PA support, news organization verification workflows, any C2PA-compliant verification software, and the Witness web verification page (witnesshq.com/verify).

OpenTimestamps Protocol

Witness implements the OpenTimestamps protocol as specified at opentimestamps.org: HTTP calendar server submission, Merkle tree proof verification, Bitcoin transaction validation, and pending-to-confirmed status tracking.

Berkeley Protocol Alignment

Witness is aligned with the Berkeley Protocol on Digital Open Source Investigations, which provides a framework for using digital information in international criminal and human rights investigations.

For News Outlets

News organizations can embed the Witness Live Map in their coverage, allowing readers to explore verified footage from any event, browse the timeline, and see exactly where each piece of content was captured.

• Embeddable map widget
• Filtering by location, time, or organization
• Every piece of content C2PA-certified and cryptographically verified
• Timeline scrubbing to watch events unfold
• Court-ready evidence export with chain of custody documentation

Future Roadmap

Planned Enhancements

Android Version (2026) — Native Android implementation with equivalent verification stack using Android hardware security features.

Third-Party Security Audit (2026) — Independent security audit of cryptographic implementation and threat model.

Chain of Custody Documentation — Export format for legal proceedings including transfer events and custody metadata.

Location Fuzzing — Optional precision reduction for sensitive documentation where exact coordinates create risk.

Legal Export Format — Structured export (ZIP with image/video, JSON metadata, HTML verification report) optimized for court admissibility.

Research Areas

• Integration with additional blockchain timestamp services
• Hardware camera module attestation (beyond software-level verification)
• Zero-knowledge proofs for privacy-preserving verification

Technical Specifications

Conclusion

Witness addresses the trust crisis in digital media through defense in depth: five independent verification layers, each with different trust models, working together to create mathematically provable, hardware-backed, industry-compatible, and permanently timestamped proof of authenticity.

For citizen journalists, activists, legal observers, community organizers, and anyone whose documentation must be trusted, Witness provides the strongest possible guarantee that their content is real, unedited, and captured exactly when and where they claim.

The combination of local-first privacy, open standards (C2PA), and decentralized timestamping (Bitcoin) ensures that verification remains valid and accessible even if Witness as a company ceases to exist. Your proof exists on a decentralized network. No single company, government, or server can alter or delete it.