Web/A Tech & Verifiability

Two-week engineering deep dive: verification, security model, and form encryption.


Session Map

The Journey (60 minutes)

  • Part 1: Vision — Beyond the PDF/XML traps
  • Part 2: Core Architecture — 4-Layer Model & HMP
  • Part 3: L2 Security Deep Dive — Encryption, PRF, and WASM
  • Part 4: Data Sovereignty — Web/A Folio & LoA
  • Part 5: Trust & Governance — Lightweight Trust & DID-lite
  • Part 6: Engineering Details — Typography & Bimodal UX
  • Part 7: Status & Roadmap — Red Teaming & Standardization

Vision

What Is Sorane?

  • An open-source reference implementation for verifiable web documents
  • Focused on long-term readability and cryptographic trust
  • Designed for public-sector workflows where PDFs fall short

The Machine-Only Trap (XTX / Custom XML)

  • Structured data becomes unreadable to humans
  • Semantics drift across vendors and schemas
  • Human trust is weakened when layout is detached

XML + XSLT: The Connectivity Trap

  • Rendering depends on external stylesheets
  • Long-term survival is fragile without dependencies
  • Archival integrity becomes operationally expensive

Signature Verification Barrier

  • AATL and viewer lock-in create hidden trust anchors
  • Verification is expensive outside licensed tools
  • Web/A aims to remove viewer dependence
  • PDF is readable but hard to verify at scale

Comparison

Web/A vs PDF/A vs XML/XTX

Comparison Table A comparison of Web/A, PDF/A, and XML/XTX across portability, verifiability, and human readability. Dimension Web/A PDF/A XML/XTX Portability Single-file HTML File-based Depends on tooling Verifiability Built-in signatures Viewer-dependent Schema-dependent Human Readability First-class Strong Weak Summary Portable + Verifiable Portable, low semantics Structured, fragile

Why We Built SRN

  • Precision typography is a security problem: layout must be verifiable
  • Documents should be readable and provable for decades
  • Encryption must work without server lock-in

Core Architecture

4-Layer Trust Model

  • Layer 1: The Template — Definitions, questions, and schemas
  • Layer 2: The Data — Concrete evidence and user records
  • Layer 3: The Context — Metadata, transport tags, and binding
  • Layer 4: The Presentation — UI, fonts, and display logic
Web/A Document (.html) Layer 4: Presentation (View / UI) CSS, Fonts, minimal JS Layer 3: Context (Metadata / Routing) Transport Tag, Expiry, Nonce, Policy Ref Layer 2: Data (Evidence / Fact) Encrypted payload, signed fact record Layer 1: Template (Definition / Schema) Human Readable HTML / Template Bound Machine Readable JSON-LD / Logic Issuer Signature: Ed25519 + PQC

Verifiability

Human-Machine Parity (HMP)

  • Human-readable HTML + machine-readable JSON-LD are bound
  • Signatures guarantee both views describe the same artifact
  • Verification is built into every generated document

Conformance

Web/A Conformance Levels

Web/A Conformance Levels Three conformance tiers: 1s semantic, 1u universal, 1p provenance. Web/A-1s Semantic HTML + CSS JSON-LD embedded Basic signature Web/A-1u Universal All assets embedded Subsetted fonts CLS 0 target Web/A-1p Provenance C2PA manifest HMP claim High-trust archive

L2 Security

Web/A Form Security Highlights

  • Layer 1 template is signed and hash-bound
  • Layer 2 payload uses Ed25519 signature
  • Encryption binds AAD to layer1_ref (Anti-splicing)

L2 Encryption

Architecture Overview

flowchart TD
    User["User Input"] --> Plain["L2 Plaintext"]
    
    subgraph browser ["Browser Client"]
        Plain --> Sign["Signer (Ed25519)"]
        Sign --> Signed["L2 Signed Payload"]
        Signed --> Encrypt["Encrypter (HPKE / WASM)"]
    end
    
    Encrypt --> Envelope["L2 Encrypted Envelope"]
    
    Envelope --> Storage["Transport (Local / WebA Post)"]
    
    subgraph aggregator ["Aggregator Issuer"]
        Storage --> Decrypt["Decrypter (Strict Replay Check)"]
        Decrypt --> Verify["Signature Verifier"]
        Verify --> Data["Validated Data"]
    end

Ecosystem

The Web/A Five Components

graph TD
    Maker[Web/A Maker] -->|1. Foundry| Form[Web/A Form]
    Maker -->|1. Foundry| Doc[Web/A Doc]
    
    Form -->|2. Input & Sign| Doc
    Doc -->|3. Ownership| Folio[Web/A Folio]
    
    Folio <-->|4. Transport| Post[Web/A Post]
    Post -->|5. Analytics| Aggregator[Aggregator]
  • Foundry (Maker/Aggregator): Forging trust and aggregating results
  • Interface (Form/Doc): Bimodal containers for humans and machines
  • Infrastructure (Folio/Post): Sovereign ownership and routing

L2 Encryption

Hierarchical Key Derivation

flowchart TD
    Instance["SRN Master Key"] -->|HKDF org-root| Root["Org Root Key"]
    Root -->|HKDF campaign+layer1| Campaign["Campaign/Form Key"]
    
    subgraph per_form ["Per Form"]
    Campaign --> Pub["Public Key (embedded in Form)"]
    Campaign --> Priv["Private Key (used by Aggregator)"]
    end
  • Zero-touch key rotation
  • Isolation between campaigns and forms
  • Aggregator escrow without master key exposure

L2 Encryption

WebAuthn PRF Unlock

sequenceDiagram
    participant User
    participant Browser
    participant Auth as WebAuthn/Authenticator
    
    User->>Browser: Click "Unlock with Passkey"
    Browser->>Auth: get() with PRF extension
    Auth-->>Browser: PRF Output (Seed)
    Browser->>Browser: HKDF(Seed) -> Wrap Key
    Browser->>Browser: AES-Decrypt(Wrapped Private Key)
    Browser->>Browser: Decrypt L2 Envelope
    Browser->>User: Show Plaintext Data

Encryption

L2 Envelope Lifecycle

sequenceDiagram
  participant User
  participant Browser
  participant Issuer
  User->>Browser: Fill form
  Browser->>Browser: Sign payload (Ed25519)
  Browser->>Browser: Encrypt (HPKE-like)
  Browser->>Issuer: Send envelope
  Issuer->>Issuer: Decrypt + verify

L2 Security

Replay Protection

  • Nonce is stored and strictly checked per envelope
  • Security Audit v3 Requirement: Mandatory replay guard for all L2 decryptions
  • CLI: JsonFileReplayStore / Browser: LocalStorageReplayStore
flowchart TB
  S[Envelope] --> N{Nonce seen?}
  N -- No --> A[Accept + Store]
  N -- Yes --> R[Reject]

Traffic Analysis Mitigation

  • Bucket padding (1KB / 4KB / 16KB / ...)
  • Obscures payload size class
  • Decoy traffic planned for high-sensitivity cases

WASM Crypto Core Completed

  • Ed25519 / X25519 / ML-KEM / ML-DSA / AES-GCM / SHA2 in Rust/WASM
  • Zero JS-dependent crypto: Improved performance and side-channel resistance
  • Validated as a standalone, side-loadable security module

Safety

Pilot Safety & Support Framework

  • Pilot Safety Guide: Published boundaries for risk and responsibility
  • Human Support Layer: Countermeasures for technical edge cases (backups, etc.)
  • Experimental Status: Incremental trust via verified HMP evidence

Forward Secrecy

Pre-Key Infrastructure Draft

  • One-time recipient keys via prekey_url
  • Offline submission preserved
  • Fallback to static keys with warnings

L3 Outlook

Layer 3: Web/A Folio

Web/A Folio Outlook A conceptual view of Web/A Folio enabling verifiable presentations and identity-bound proofs. Web/A Folio Identity-bound container History + proofs + claims Portable, offline-capable Verifiable Presentation Selective disclosure Authorization Flow Consent + delegation Relying Party Service verifier

Folio Design

Trust Levels & LoA

  • LoA 1 (Self-Asserted): Canonical = Human-Readable. JSON is derived.
  • LoA 2+ (Verified): Canonical = Machine-Readable. Human view is derived.
  • Validation: Editing LoA 2+ data invalidates verified status.

Folio Internals

The Submission Bundle

graph TD
    B[Submission Bundle] --> M[Manifest.json]
    B --> D[Docs/ HTML]
    B --> A[Attachments/ PDF]
    B --> V[VP/ Scoped Claims]
    B --> R[Verification Report]
    
    M -->|Signed| S[Manifest.sig]
    R -->|Covers| B

Folio CLI

Toolkit Architecture

graph TD
    MD[Form.markdown] -->|parse| Schema[Schema.json]
    Data[Data.json] -->|fill| Filled[Filled.html]
    MD -->|validate| Result[Validation Result]
    Key[Passkey] -->|sign| Signed[Signed.html]

Folio Conformance

Policy DSL (Draft)

profile: onboarding
requires:
  - manifest.bundle_id
  - subject.id
rules:
  - id: vp_required_for_l3
    when: claims.level == 3
    assert: vp.exists == true

Ecosystem Strategy: AI Agent-First

  • Agents can read, verify, and summarize Web/A
  • Structured data enables safe automation
  • Humans remain the final trust anchor

AI Integration

Bring Your Own AI Agent (BYOA)

  • MCP (Model Context Protocol): Agents access Folio records directly
  • Verified Context: AI reasons and interacts based on "Hard Evidence"
  • Agency & Liberty: Use your preferred AI without platform lock-in

Trust & Governance

The "Lightweight Trust" Model

  • Lower entry cost with strong verification
  • Designed for gradual migration from legacy PKI
  • Supports PQC transition without new infrastructure

Tiered Authority: Passkey-to-Build Delegation

  • Root authority delegates build-time signing
  • Passkeys provide hardware-backed trust
  • Enables automation without exposing root keys

Ephemeral Issuance

  • Fresh signing keys per build reduce blast radius
  • Encourages frequent rotation
  • Fits offline, file-first workflows

Identity via Transparency (DID-lite)

  • Trust derived from web publication and transparency
  • Lower friction than heavy certificate hierarchies
  • Fingerprint publication provides a "Known Good" list

Cryptographic Agility

  • Dynamic Root of Trust and continuity
  • Hybrid signatures (classical Ed25519 + PQC ML-DSA-44)
  • Safety-first migration for the quantum era

Legal Positioning

  • From "will" to "evidence"
  • Focus on provable intent and auditability
  • Pragmatic distance from rigid national act PKI

Deployment Safety

Client Safety: Draft State

  • Draft HTML embeds recovery state
  • Restore across devices without data loss
  • Draft files treated as sensitive artifacts

Engineering

Advanced Typography Requirements

  • Administrative glyph coverage (IVS/SVS)
  • Faithful reproduction of official layouts (Grid fidelity)
  • Zero layout shift as a security constraint

Challenges in Form Reproduction

  • Rendering engine variance vs millimeter precision
  • Layout-dependent semantics
  • Signed views must remain stable over time

Bimodal Presentation (Mobile + Desktop)

  • Archive View: Fixed layout for official verification
  • Wallet View: Responsive card view for quick reference
  • Switchable from single signed payload via CSS

Conservation Profiles

  • Define a safe subset of web tech (Evergreen)
  • Prevent browser drift from breaking archives
  • Long-term readability guaranteed by profile validation

Status

Web/A Evolution (Summary)

Web/A Evolution Timeline A concise timeline showing key milestones in Web/A development. 4-Layer Trust Forms supported Layer 2 Encryption Confidential payloads Audit Loop Remediation tracking

Timeline

Engineering Progress

flowchart LR
  A[L2 Feasibility] --> B[Encrypted Form]
  B --> C[ReplayGuard Hardening]
  C --> D[WASM Migration Complete]
  D --> E[Red Team Evaluation v8]
  E --> F[Safety Guide Release]
  F --> G[Infrastructure Scale-up]

Red Teaming

Iterative Feedback Loop

sequenceDiagram
  participant Dev as Web/A Team
  participant RT as Red Team
  participant Spec as Spec + Docs
  RT->>Dev: Findings (v2)
  Dev->>Spec: Remediation Plan
  Dev->>RT: Implementation Report
  RT->>Dev: Re-Assessment (v3)
  Dev->>Spec: Hardening Notes

Adoption

Phased Adoption Strategy

Phased Adoption Strategy Three-stage adoption plan across Layer 1, Layer 2, and Layer 3. Layer 1 Public Documents Certificates, notices Auditability first Current SRN scope Layer 2 + 3 Confidential Data & Tags L2 encryption Replay protection (L3) Selective access Layer 4 Identity & Presentation Verifiable presentation Holder binding Future scope

Roadmap

Document Typology

Document Typology Three document tiers mapped to Web/A layers and preservation requirements. Tier 1 Public Assets Gazettes, reports Universal access Public trust Tier 2 Individual Records Receipts, notices Confidentiality primary Direct delivery Tier 3 Identity Credentials Resident records, IDs Anti-personation required Holder binding

Challenges

Standardization Challenges

  • Cross-device and in-person transfer protocols
  • Practical holder binding in browser sandboxes
  • Native browser verification support
  • Long-term validation (LTV)


Next Steps

  • Pre-Key server PoC + test harness
  • Formal review of WASM bindings
  • Decoy traffic strategy
  • Publish CSP/SRI templates for deployments

Final Thoughts

Why This Matters

  • Web/A turns documents into verifiable artifacts, not just files
  • Trust is portable across time, devices, and institutions
  • The goal is interoperability with transparent security, not lock-in