proofmode 0.9.0

Capture, share, and preserve verifiable photos and videos
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use serde::{Deserialize, Serialize};

use super::error::SignError;

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Platform {
    Ios,
    Android,
}

impl Platform {
    pub fn as_str(&self) -> &str {
        match self {
            Platform::Ios => "ios",
            Platform::Android => "android",
        }
    }
}

impl std::str::FromStr for Platform {
    type Err = SignError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "ios" => Ok(Platform::Ios),
            "android" => Ok(Platform::Android),
            _ => Err(SignError::InvalidPlatform(format!(
                "Invalid platform: {}. Must be 'ios' or 'android'",
                s
            ))),
        }
    }
}

impl std::fmt::Display for Platform {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

// Certificate Signing Models

#[derive(Debug, Deserialize)]
pub struct CertificateSigningRequest {
    pub csr: String,
    pub metadata: Option<CSRMetadata>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct CSRMetadata {
    pub device_id: Option<String>,
    pub app_version: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct SignedCertificateResponse {
    pub certificate_id: String,
    pub certificate_chain: String,
    pub expires_at: chrono::DateTime<chrono::Utc>,
    pub serial_number: String,
}

// C2PA Signing Models

#[derive(Debug, Deserialize)]
pub struct C2PASigningRequest {
    pub claim: String,
    #[serde(default)]
    pub platform: String,
    pub client_data_hash: Option<String>,
    pub client_data_json: Option<String>,

    // iOS App Attest fields
    pub key_id: Option<String>,
    pub assertion: Option<String>,

    // Android Play Integrity fields
    #[serde(alias = "token")]
    pub device_id: Option<String>,
    pub integrity_token: Option<String>,
    pub nonce: Option<String>,
    pub package_name: Option<String>,

    // Android cryptographic request signing (for verified devices)
    pub counter: Option<i64>,
    pub timestamp: Option<i64>,
    pub request_signature: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct C2PASigningResponse {
    pub signature: String,
}

#[derive(Debug, Serialize)]
pub struct IntegrityChallengeResponse {
    pub challenge: String,
    pub message: String,
}

// C2PA Configuration Models

#[derive(Debug, Serialize)]
pub struct C2PAConfiguration {
    pub algorithm: String,
    pub timestamp_url: String,
    pub signing_url: String,
    pub certificate_chain: String,
}