oxy witness serve: a transparency-log witness anyone can run 51d4862a16d8

//! `oxy witness serve` (Oxygen spec §14.8, oxygenhub docs/transparency.md):

//! a small transparency-log witness anyone can run. It cosigns the

//! checkpoints of the logs it is told about (C2SP tlog-witness), each only

//! when it extends the last one this witness cosigned, with its own key

//! and clock, so a log cannot show two histories without the witness

//! seeing it.

//!

//! State is one file per log in the state directory: the size and root of

//! the last checkpoint cosigned, replaced atomically.

use axum::extract::State;

use axum::http::{header, StatusCode};

use axum::response::{IntoResponse, Response};

use axum::routing::post;

use axum::Router;

use oxy_core::identity::{Identity, SecretKey};

use oxy_core::tlog::{self, AddCheckpoint, Checkpoint, Note, WitnessError, WitnessKey, Witnessed};

use std::path::PathBuf;

use std::sync::{Arc, Mutex};

/// What a witness serves.

pub struct WitnessConfig {

    /// Its name in cosignatures (a host name, no spaces).

    pub name: String,

    pub identity: Identity,

    pub sk: SecretKey,

    /// The logs it witnesses: their origins and keys.

    pub logs: Vec<(String, Identity)>,

    /// Where it keeps what it cosigned.

    pub state: PathBuf,

    pub tls: Option<crate::TlsFiles>,

}

struct Witness {

    cfg: WitnessConfig,

    /// One add-checkpoint at a time: each reads and moves its log's state.

    lock: Mutex<()>,

}

fn state_file(w: &Witness, origin: &str) -> PathBuf {

    let safe: String = origin

        .chars()

        .map(|c| {

            if c.is_ascii_alphanumeric() || c == '.' || c == '-' {

                c

            } else {

                '_'

            }

        })

        .collect();

    w.cfg.state.join(safe)

}

fn read_state(w: &Witness, origin: &str) -> Option<(u64, tlog::Hash)> {

    let text = std::fs::read_to_string(state_file(w, origin)).ok()?;

    let (size, root) = text.trim().split_once(' ')?;

    let root = oxy_core::hash::ObjectRef::from_hex(root)?;

    Some((size.parse().ok()?, root.0))

}

fn plain(status: StatusCode, why: &str) -> Response {

    (

        status,

        [(header::CONTENT_TYPE, "text/plain; charset=utf-8")],

        format!("{why}\n"),

    )

        .into_response()

}

async fn add_checkpoint(State(w): State<Arc<Witness>>, body: String) -> Response {

    let Ok(req) = AddCheckpoint::parse(&body) else {

        return plain(StatusCode::BAD_REQUEST, "not an add-checkpoint request");

    };

    let Some(origin) = Note::parse(&req.note)

        .ok()

        .and_then(|n| Checkpoint::parse(&n.text).ok())

        .map(|c| c.origin)

    else {

        return plain(StatusCode::BAD_REQUEST, "the checkpoint does not parse");

    };

    let Some(key) = w

        .cfg

        .logs

        .iter()

        .find(|(o, _)| *o == origin)

        .map(|(_, k)| k.clone())

    else {

        return plain(

            StatusCode::NOT_FOUND,

            &format!("this witness does not witness {origin}"),

        );

    };

    let _held = w.lock.lock().unwrap_or_else(|p| p.into_inner());

    let latest = read_state(&w, &origin);

    let me = WitnessKey {

        name: &w.cfg.name,

        identity: &w.cfg.identity,

        sk: &w.cfg.sk,

    };

    let now = std::time::SystemTime::now()

        .duration_since(std::time::UNIX_EPOCH)

        .map(|d| d.as_secs())

        .unwrap_or(0);

    let conflict = |n: u64| {

        (

            StatusCode::CONFLICT,

            [(header::CONTENT_TYPE, "text/x.tlog.size")],

            format!("{n}\n"),

        )

            .into_response()

    };

    match tlog::witness(&req, &origin, &key, latest, &me, now) {

        Ok(Witnessed::Cosigned { checkpoint, lines }) => {

            let text = format!(

                "{} {}\n",

                checkpoint.size,

                oxy_core::hash::ObjectRef(checkpoint.root).to_hex()

            );

            if let Err(e) = std::fs::create_dir_all(&w.cfg.state).and_then(|_| {

                oxy_core::durable::write_atomic(&state_file(&w, &origin), text.as_bytes())

            }) {

                return plain(

                    StatusCode::INTERNAL_SERVER_ERROR,

                    &format!("keeping the witness's state: {e}"),

                );

            }

            let body = Note {

                text: String::new(),

                sigs: lines,

            }

            .encode();

            (

                [(header::CONTENT_TYPE, "text/plain; charset=utf-8")],

                body.trim_start_matches('\n').to_string(),

            )

                .into_response()

        }

        Ok(Witnessed::Conflict(n)) => conflict(n),

        Err(WitnessError::Unsigned(e)) => plain(StatusCode::FORBIDDEN, &e),

        Err(WitnessError::Inconsistent(e)) => plain(StatusCode::UNPROCESSABLE_ENTITY, &e),

        Err(WitnessError::Bad(e)) => plain(StatusCode::BAD_REQUEST, &e),

    }

}

/// The witness's routes: `POST /add-checkpoint`.

pub fn router(cfg: WitnessConfig) -> Router {

    Router::new()

        .route("/add-checkpoint", post(add_checkpoint))

        .with_state(Arc::new(Witness {

            cfg,

            lock: Mutex::new(()),

        }))

}

/// Serve a witness on `listener` until stopped.

pub fn run_blocking(

    listener: std::net::TcpListener,

    mut cfg: WitnessConfig,

) -> std::io::Result<()> {

    let rt = tokio::runtime::Builder::new_multi_thread()

        .enable_all()

        .build()?;

    let tls = cfg.tls.take();

    rt.block_on(async move {

        listener.set_nonblocking(true)?;

        match tls {

            Some(tls) => {

                let _ = rustls::crypto::ring::default_provider().install_default();

                let rustls_cfg =

                    axum_server::tls_rustls::RustlsConfig::from_pem_file(&tls.cert, &tls.key)

                        .await

                        .map_err(|e| std::io::Error::other(format!("loading TLS files: {e}")))?;

                axum_server::from_tcp_rustls(listener, rustls_cfg)?

                    .serve(router(cfg).into_make_service())

                    .await

            }

            None => axum::serve(tokio::net::TcpListener::from_std(listener)?, router(cfg)).await,

        }

    })

}

#[cfg(test)]

mod tests {

    use super::*;

    use axum::body::Body;

    use axum::http::Request;

    use tower::ServiceExt;

    #[tokio::test]

    async fn the_witness_cosigns_and_keeps_what_it_cosigned() {

        let dir = tempfile::tempdir().unwrap();

        let log_sk = SecretKey::generate();

        let log = log_sk.identity("log", "[email protected]", 1);

        let w_sk = SecretKey::generate();

        let w = w_sk.identity("witness", "[email protected]", 1);

        let cfg = || WitnessConfig {

            name: "witness.example".into(),

            identity: w.clone(),

            sk: w_sk.clone(),

            logs: vec![("hub.example/log".into(), log.clone())],

            state: dir.path().join("state"),

            tls: None,

        };

        let mut stored: Vec<tlog::Hash> = Vec::new();

        for n in 0..9u64 {

            stored.extend(

                tlog::stored_hashes_for_leaf(n, tlog::leaf_hash(&[n as u8]), &stored).unwrap(),

            );

        }

        let note = |n: u64| {

            Checkpoint {

                origin: "hub.example/log".into(),

                size: n,

                root: tlog::tree_hash(n, &stored).unwrap(),

                extensions: vec![],

            }

            .sign(&log, &log_sk)

            .unwrap()

            .encode()

        };

        let post = |body: String| async {

            let res = router(cfg())

                .oneshot(

                    Request::post("/add-checkpoint")

                        .body(Body::from(body))

                        .unwrap(),

                )

                .await

                .unwrap();

            let st = res.status();

            let b = axum::body::to_bytes(res.into_body(), 1 << 20)

                .await

                .unwrap();

            (st, String::from_utf8(b.to_vec()).unwrap())

        };

        let (st, lines) = post(

            AddCheckpoint {

                old_size: 0,

                proof: vec![],

                note: note(4),

            }

            .encode(),

        )

        .await;

        assert_eq!(st, StatusCode::OK, "{lines}");

        let cosigned =

            Note::parse(&format!("{}\n{lines}", Note::parse(&note(4)).unwrap().text)).unwrap();

        assert!(cosigned.cosigned_by("witness.example", &w).is_ok());

        // Kept across a restart (a new router): a wrong old size is told.

        let (st, size) = post(

            AddCheckpoint {

                old_size: 0,

                proof: vec![],

                note: note(9),

            }

            .encode(),

        )

        .await;

        assert_eq!((st, size.trim()), (StatusCode::CONFLICT, "4"));

        let proof = tlog::prove_consistency(9, 4, &stored).unwrap();

        let (st, _) = post(

            AddCheckpoint {

                old_size: 4,

                proof,

                note: note(9),

            }

            .encode(),

        )

        .await;

        assert_eq!(st, StatusCode::OK);

    }

}

 "tower",

tower = { version = "0.5", features = ["util"] }

pub mod witness;

Anyone can **witness** a hub's log: a witness cosigns each checkpoint that extends the last one it cosigned, with its own key and clock, so a hub cannot show two histories without the witness noticing. The hub lists its witnesses in `hub.toml` (`[tlog] witnesses`), and its served checkpoint carries their cosignatures.

```

curl -fsSL https://oxygenhub.io/.well-known/oxyhub-key -o oxygenhub.identity

oxy witness serve --name witness.example.org --log oxygenhub.io/log=oxygenhub.identity \

    --bind 0.0.0.0:8891 --tls-cert cert.pem --tls-key key.pem

```

It signs with your oxy home's key and keeps what it cosigned in `--state` (default `witness-state`).

    /// Witness hubs' transparency logs: cosign each checkpoint that extends

    /// the last one cosigned (spec §14.8)

    Witness {

        #[command(subcommand)]

        cmd: WitnessCmd,

    },

    },

}

#[derive(Subcommand)]

enum WitnessCmd {

    /// Serve a witness (C2SP tlog-witness: POST /add-checkpoint), signing

    /// with this oxy home's key (author.key)

    Serve {

        /// The witness's name in cosignatures: a host name

        #[arg(long)]

        name: String,

        /// A log to witness, as ORIGIN=FILE: its origin (HOST/log) and its

        /// key's identity file (a hub's /.well-known/oxyhub-key); repeatable

        #[arg(long = "log", required = true)]

        logs: Vec<String>,

        /// Where to keep what it cosigned

        #[arg(long, default_value = "witness-state")]

        state: PathBuf,

        /// Address and port to listen on

        #[arg(long, default_value = "127.0.0.1:8891")]

        bind: String,

        /// PEM certificate chain; enables HTTPS together with --tls-key

        #[arg(long, requires = "tls_key")]

        tls_cert: Option<PathBuf>,

        /// PEM private key for --tls-cert

        #[arg(long, requires = "tls_cert")]

        tls_key: Option<PathBuf>,

        Cmd::Witness {

            cmd:

                WitnessCmd::Serve {

                    name,

                    logs,

                    state,

                    bind,

                    tls_cert,

                    tls_key,

                },

        } => tlog::witness_serve(&name, &logs, state, &bind, tls_cert.zip(tls_key)),

use std::path::{Path, PathBuf};

/// `oxy witness serve`: cosign the named logs' checkpoints.

pub fn witness_serve(

    name: &str,

    logs: &[String],

    state: PathBuf,

    bind: &str,

    tls: Option<(PathBuf, PathBuf)>,

) -> Result<i32> {

    let home = oxy_core::repo::default_home();

    let (identity, sk) = oxy_core::repo::home_key(&home)

        .map_err(|e| anyhow!("{e}"))?

        .ok_or_else(|| anyhow!("{} names no key (author.key) with its secret: a witness signs with it; oxy identity create", home.display()))?;

    let mut parsed = Vec::new();

    for l in logs {

        let (origin, file) = l

            .split_once('=')

            .ok_or_else(|| anyhow!("--log takes ORIGIN=FILE, as oxygenhub.io/log=hub.identity"))?;

        let bytes = std::fs::read(file).map_err(|e| anyhow!("{file}: {e}"))?;

        let key =

            oxy_core::identity::Identity::decode(&bytes).map_err(|e| anyhow!("{file}: {e}"))?;

        parsed.push((origin.to_string(), key));

    }

    let listener = std::net::TcpListener::bind(bind).map_err(|e| anyhow!("binding {bind}: {e}"))?;

    println!(

        "{} {} logs as {} with key {} on {}://{bind}/add-checkpoint",

        ui::done("Witnessing"),

        parsed.len(),

        ui::path(name),

        identity.hash().short(12),

        if tls.is_some() { "https" } else { "http" }

    );

    for (o, k) in &parsed {

        println!(

            "  {} {} {}",

            ui::note(),

            o,

            ui::dim(format!("signed by {}", k.hash().short(12)))

        );

    }

    oxy_server::witness::run_blocking(

        listener,

        oxy_server::witness::WitnessConfig {

            name: name.to_string(),

            identity,

            sk,

            logs: parsed,

            state,

            tls: tls.map(|(cert, key)| oxy_server::TlsFiles { cert, key }),

        },

    )?;

    Ok(0)

}