siglog 0.1.0

A minimal Tessera-compatible transparency log server
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
110
111
112
113
114
115
116
117
118
119

//! HTTP handlers for the witness server.

use crate::witness::{AddCheckpointRequest, Witness, WitnessError};
use axum::{
    body::Bytes,
    extract::State,
    http::{header, StatusCode},
    response::{IntoResponse, Response},
};
use std::sync::Arc;

/// Content type for tlog size responses (on 409 Conflict).
const CONTENT_TYPE_TLOG_SIZE: &str = "text/x.tlog.size";

/// POST /add-checkpoint - Submit a checkpoint for witnessing.
///
/// Request body format:
/// ```text
/// old <size>
/// <base64-proof-hash-1>
/// <base64-proof-hash-2>
/// ...
/// <empty line>
/// <checkpoint text>
/// ```
///
/// Response on success (200 OK):
/// ```text
/// — <witness_name> <base64(key_id + signature)>
/// ```
///
/// Response on conflict (409 Conflict):
/// ```text
/// <witnessed_size>
/// ```
/// with Content-Type: text/x.tlog.size
pub async fn add_checkpoint(State(witness): State<Arc<Witness>>, body: Bytes) -> Response {
    // Parse body as UTF-8
    let body_str = match std::str::from_utf8(&body) {
        Ok(s) => s,
        Err(e) => {
            return (StatusCode::BAD_REQUEST, format!("invalid UTF-8: {}", e)).into_response();
        }
    };

    // Parse the request
    let request = match AddCheckpointRequest::from_ascii(body_str) {
        Ok(r) => r,
        Err(e) => {
            return (StatusCode::BAD_REQUEST, format!("parse error: {}", e)).into_response();
        }
    };

    // Process the request
    match witness.add_checkpoint(request).await {
        Ok(cosig) => {
            // Return the cosignature line
            let sig_line = cosig.to_line();
            (StatusCode::OK, sig_line).into_response()
        }
        Err(e) => witness_error_to_response(e),
    }
}

/// Convert a WitnessError to an HTTP response.
fn witness_error_to_response(err: WitnessError) -> Response {
    match err {
        WitnessError::Conflict(size) => {
            // 409 Conflict with the actual size
            (
                StatusCode::CONFLICT,
                [(header::CONTENT_TYPE, CONTENT_TYPE_TLOG_SIZE)],
                format!("{}\n", size),
            )
                .into_response()
        }
        WitnessError::UnknownLog(origin) => {
            (StatusCode::NOT_FOUND, format!("unknown log: {}", origin)).into_response()
        }
        WitnessError::InvalidSignature(msg) => {
            (StatusCode::FORBIDDEN, format!("invalid signature: {}", msg)).into_response()
        }
        WitnessError::InvalidProof(msg) => (
            StatusCode::UNPROCESSABLE_ENTITY,
            format!("invalid proof: {}", msg),
        )
            .into_response(),
        WitnessError::BadRequest(msg) => {
            (StatusCode::BAD_REQUEST, format!("bad request: {}", msg)).into_response()
        }
        WitnessError::Internal(msg) => {
            tracing::error!("Internal witness error: {}", msg);
            (StatusCode::INTERNAL_SERVER_ERROR, "internal error").into_response()
        }
    }
}

/// GET /checkpoint/{origin} - Get the latest witnessed checkpoint for a log.
pub async fn get_witnessed_checkpoint(
    State(witness): State<Arc<Witness>>,
    axum::extract::Path(origin): axum::extract::Path<String>,
) -> Response {
    match witness.get_state(&origin).await {
        Ok(Some(_state)) => {
            // TODO: Return the full checkpoint from state
            (StatusCode::OK, "checkpoint found").into_response()
        }
        Ok(None) => (StatusCode::NOT_FOUND, "no witnessed checkpoint").into_response(),
        Err(e) => {
            tracing::error!("Error getting state: {}", e);
            (StatusCode::INTERNAL_SERVER_ERROR, "internal error").into_response()
        }
    }
}

/// GET /health - Health check.
pub async fn health() -> &'static str {
    "ok"
}