External Resources & References

External documentation and resources for C2PA content authenticity and Matrix/Synapse messaging integration.
Categories:

External Resources & References

This document provides comprehensive external resources for key technologies planned for integration with the Peregrine mobile application.

C2PA Content Authenticity

Overview

The Coalition for Content Provenance and Authenticity (C2PA) is developing technical standards for certifying the source and history (provenance) of media content. This addresses the prevalence of misleading information online through verifiable metadata attached to digital content.

Content Credentials function like a nutrition label for digital content, providing verifiable metadata about the content’s history, accessible to anyone at any time.

Why C2PA for Peregrine

The Phenom App requires content authenticity to:

  • Verify phenomenon reports are unaltered
  • Establish chain of custody for media
  • Prevent deepfakes and manipulated evidence
  • Build trust in the phenomenon documentation ecosystem
  • Enable scientific analysis of verified data

Official Resources

Technical Specifications

Organization Sites

Key Documentation

Implementation Status (January 2026)

  • Members: 6,000+ organizations
  • C2PA Trust List: Established in 2.0 specification (January 2024)
  • Adoption: Growing across media, journalism, and tech sectors

JavaScript/Web SDKs

Available Packages

@contentauth/react (NPM Package)

  • Version: 0.2.94 (latest as of 2 days ago)
  • Platform: React web applications
  • Usage: React components and hooks for C2PA
  • Link: npm: @contentauth/react

c2pa (Legacy - Deprecated)

  • Status: Deprecated
  • Migration: Use @contentauth/c2pa-web instead
  • Link: npm: c2pa

@contentauth/c2pa-web (Current Recommendation)

  • Platform: Web implementations
  • Status: Active development
  • Repository: GitHub: c2pa-js

React Native Considerations

⚠️ Important: No dedicated React Native SDK currently exists.

Implementation Options for Peregrine

Option 1: Native Module Wrapper (Recommended)

  • Create custom native module using native C2PA libraries
  • Platform-specific implementations (iOS/Android)
  • Full access to native camera and media APIs
  • Best performance and integration

Option 2: WebView Bridge

  • Use web-based SDK within WebView
  • JavaScript bridge for communication
  • Limited camera integration
  • Not ideal for real-time capture

Option 3: Wait for Official Support

  • Monitor c2pa-js repository for React Native support
  • Community contributions may add support
  • Not suitable for immediate implementation

  1. Create Native Modules:

    PhenomApp/
├── android/
│   └── app/src/main/java/com/phenomapp/c2pa/
│       └── C2PAModule.java
└── ios/
    └── PhenomApp/C2PA/
        └── C2PAModule.m

  2. Use Native C2PA Libraries:

    • iOS: Integrate C2PA SDK via CocoaPods/SPM
    • Android: Integrate C2PA library via Gradle

  3. Bridge to React Native:

    import { NativeModules } from 'react-native'
const { C2PAModule } = NativeModules

// Sign media with provenance data
const signedMedia = await C2PAModule.signMedia({
  uri: mediaUri,
  metadata: {
    author: user.name,
    location: coordinates,
    timestamp: Date.now(),
    sensors: sensorData
  }
})

Integration with Peregrine

Capture Flow with C2PA

sequenceDiagram
    participant User
    participant Camera
    participant C2PA
    participant Storage
    participant Backend

    User->>Camera: Start Recording
    Camera->>Camera: Capture Video + Sensor Data
    User->>Camera: Stop Recording
    Camera->>C2PA: Sign with Metadata
    Note over C2PA: Add timestamp, location,<br/>sensors, device info
    C2PA->>Storage: Save Signed Media
    Storage->>Backend: Upload with C2PA Manifest
    Backend->>Backend: Verify C2PA Signature
    Backend-->>User: Confirmed Authentic

Required Metadata

interface C2PAManifest {
  // Creator information
  creator: {
    name: string
    identifier: string  // User ID
  }

  // Capture details
  capture: {
    timestamp: number
    location: {
      latitude: number
      longitude: number
      altitude?: number
      accuracy: number
    }
    device: {
      make: string
      model: string
      os: string
    }
  }

  // Sensor data
  sensors: {
    accelerometer?: XYZData[]
    gyroscope?: XYZData[]
    magnetometer?: XYZData[]
    barometer?: number
  }

  // Media details
  media: {
    format: string
    resolution: string
    duration?: number
  }
}

Privacy Considerations

From World Privacy Forum Analysis:

  • Identity Management: C2PA includes identity and trust components
  • Metadata Exposure: Consider what metadata to include
  • User Control: Allow users to control provenance data
  • GDPR Compliance: Ensure metadata handling complies with regulations

Next Steps for Implementation

  1. Research native C2PA libraries for iOS/Android
  2. Prototype native module bridge
  3. Test signing flow with sample media
  4. Integrate with capture workflow
  5. Validate C2PA manifest format
  6. Document implementation guide

Additional Reading

Matrix/Synapse Messaging Server

Overview

Matrix is an open standard for decentralized, real-time communication. Synapse is the reference homeserver implementation written in Python/Twisted + Rust.

Why Matrix for Peregrine

The Phenom App could use Matrix for:

  • Real-time chat between investigators
  • Team coordination during phenomenon events
  • Encrypted private communications
  • Federation across organizations (MUFON, NUFORC, etc.)
  • Decentralized infrastructure (no single point of failure)

Official Resources

Synapse Documentation

⚠️ Important Maintenance Change:

  • Versions ≤1.98: Maintained by Matrix.org Foundation (Apache 2.0)
  • Versions ≥1.99: Maintained by Element (AGPL or commercial license)

Current Documentation (2026)

Legacy Documentation (Pre-1.99)

Package Repositories

Matrix Protocol Resources

Implementation in React Native

Matrix Client SDKs

matrix-js-sdk (Official JavaScript SDK)

Installation:

npm install matrix-js-sdk

React Native Compatibility:

  • Requires polyfills for Node.js built-ins
  • Use rn-nodeify or manual polyfills
  • WebRTC support via react-native-webrtc

Basic Integration

import * as sdk from "matrix-js-sdk"

// Create Matrix client
const client = sdk.createClient({
  baseUrl: "https://matrix.phenom.app",
  accessToken: userAccessToken,
  userId: "@user:phenom.app"
})

// Start syncing
await client.startClient({ initialSyncLimit: 10 })

// Join a room
await client.joinRoom("#phenomena:phenom.app")

// Send a message
await client.sendTextMessage(
  "!roomId:phenom.app",
  "New UAP sighting reported at coordinates [lat, lon]"
)

// Listen for messages
client.on("Room.timeline", (event, room) => {
  if (event.getType() === "m.room.message") {
    console.log(event.getContent().body)
  }
})

Deployment Architecture

graph TB
    Mobile[Mobile App<br/>React Native] --> Client[Matrix Client SDK]
    Client --> Synapse[Synapse Homeserver<br/>Python + Rust]

    Synapse --> PostgreSQL[(PostgreSQL<br/>Database)]
    Synapse --> Redis[(Redis<br/>Cache)]
    Synapse --> S3[S3<br/>Media Storage]

    Synapse <-.Federation.-> OtherServers[Other Matrix Servers<br/>MUFON, NUFORC, etc.]

    ALB[Load Balancer] --> Synapse
    Users[Other Users] --> ALB

    style Mobile fill:#e1f5fe
    style Client fill:#e1f5fe
    style Synapse fill:#f3e5f5
    style PostgreSQL fill:#c8e6c9
    style Redis fill:#fff9c4
    style S3 fill:#fff9c4

Self-Hosting Synapse

Installation Guide:

Docker Deployment:

version: '3.8'
services:
  synapse:
    image: matrixdotorg/synapse:latest
    ports:
      - "8008:8008"
    volumes:
      - ./data:/data
    environment:
      - SYNAPSE_SERVER_NAME=phenom.app
      - SYNAPSE_REPORT_STATS=no

  postgres:
    image: postgres:14
    environment:
      POSTGRES_PASSWORD: secure_password
      POSTGRES_DB: synapse
    volumes:
      - ./postgres:/var/lib/postgresql/data

Configuration (homeserver.yaml):

server_name: "phenom.app"
pid_file: /data/homeserver.pid
web_client_location: https://app.element.io/

listeners:
  - port: 8008
    tls: false
    type: http
    x_forwarded: true
    resources:
      - names: [client, federation]
        compress: false

database:
  name: psycopg2
  args:
    user: synapse
    password: secure_password
    database: synapse
    host: postgres
    cp_min: 5
    cp_max: 10

media_store_path: "/data/media_store"
uploads_path: "/data/uploads"
max_upload_size: "500M"

registration_shared_secret: "generate_with_pwgen"
enable_registration: false

Integration with Peregrine

Use Cases

Investigator Chat Rooms:

#general:phenom.app          - General discussion
#uap-reports:phenom.app       - UAP-specific channel
#cryptid-sightings:phenom.app - Cryptid reports
#analysis:phenom.app          - Technical analysis

Direct Messages:

  • Private researcher communication
  • Expert consultations
  • Report verification discussions

Team Coordination:

  • Planned observation events
  • Multi-witness phenomenon reports
  • Investigation teams

Features for Phenom App

Real-time Updates:

// Subscribe to new phenomenon reports
client.on("Room.timeline", (event, room) => {
  if (event.getType() === "com.phenom.report") {
    const report = event.getContent()
    showNotification({
      title: "New Phenomenon Report",
      body: `${report.category} reported at ${report.location}`
    })
  }
})

Custom Event Types:

// Send custom phenom event
await client.sendEvent("!roomId:phenom.app", "com.phenom.report", {
  type: "uap",
  location: { lat: 40.7484, lon: -73.9857 },
  timestamp: Date.now(),
  reportId: "phenom-123",
  description: "Unexplained aerial phenomenon observed"
})

End-to-End Encryption:

  • Matrix supports E2EE via Olm/Megolm
  • Secure sensitive discussions
  • Encrypted media sharing

Federation Benefits

Connect with External Organizations:

@mufon-investigator:mufon.com
@nuforc-analyst:nuforc.org
@researcher:university.edu

All can communicate via federated Matrix protocol without central server dependency.

Cost Considerations

Self-Hosted Synapse:

  • Server: $20-100/month (depending on scale)
  • PostgreSQL: Included or $10-50/month managed
  • Storage (media): $0.023/GB/month (S3)
  • Bandwidth: $0.09/GB (outbound)

Managed Hosting:

  • Element Matrix Services: Contact for pricing
  • Third-party hosts: $5-50/user/month

Next Steps for Implementation

  1. Deploy test Synapse server
  2. Integrate matrix-js-sdk in mobile app
  3. Create custom event types for phenomena
  4. Implement chat UI components
  5. Test federation with external servers
  6. Plan moderation and admin tools

Additional Resources

Summary

Both C2PA and Matrix/Synapse provide critical infrastructure for the Peregrine mobile application:

C2PA ensures content authenticity and builds trust in phenomenon reports through cryptographic verification.

Matrix/Synapse enables secure, decentralized real-time communication for investigators and research teams.

Implementation Priority:

  1. C2PA integration (HIGH) - Core to app mission
  2. Matrix integration (MEDIUM) - Valuable for collaboration

Timeline:

  • C2PA native module: 4-6 weeks
  • Matrix client integration: 2-3 weeks
  • Full feature deployment: 8-10 weeks total

Sources

C2PA Resources

Matrix/Synapse Resources