open-standards/joule-code/joule-code-rs/crates/joule-moq-relay/tests/grant_proof.rs

//! Proof of possession of a room grant's key (WAI live-rooms §10.5.2), over each transport,
//! with the relay reading the client's SETUP before it sends its own
//! (`draft-ietf-moq-privacy-pass-auth-04` §3.5.1):
//!
//! - the relay sends nothing before the client's SETUP;
//! - at -22 over each transport, and at -23, -18 and -16 through the bridge, the same:
//!   a client that holds no challenge presents its grant unproved and is refused `pop_missing`,
//!   the relay's SETUP carrying `GRANT_REFUSED` and a challenge; its second session proves over
//!   that challenge and has the grant's rights; the SETUP that admits it carries the next
//!   challenge, which a third session proves over at once;
//! - planted, each refused with its reason and nothing served: the grant as a bare token, a
//!   proof by another key, one for another relay, one over a challenge already consumed
//!   (`pop_replayed`), one over a challenge the relay never issued, and one over a challenge
//!   past its time;
//! - a client that does not know `GRANT_REFUSED` stays, and the relay closes its session
//!   UNAUTHORIZED (§12.2) with the reason;
//! - a grant presented later in a request, never proved, is refused that request.

mod common;

use common::*;
use ed25519_dalek::SigningKey;
use joule_moq::draft22::{Parameter, Parameters, RequestErrorCode, SessionError, Token};
use joule_moq::grant_proof;
use joule_moq_relay::client::{Client, ClientOptions};
use joule_moq_relay::config::Grant;
use joule_moq_relay::transport::TransportError;
use joule_moq_relay::RelayServer;
use std::time::Duration;
use tokio::time::timeout;

/// A record shaped as a room grant (`WRG1`, version 1, a room, the principal), which is
/// all the relay reads of it: its rule names the record by its SHA-256.
fn grant_record(room: u8, principal: &SigningKey) -> Vec<u8> {
    let mut g = b"WRG1\x01".to_vec();
    g.extend_from_slice(&[room; 32]);
    g.extend_from_slice(&principal.verifying_key().to_bytes());
    g.extend_from_slice(&[0x5a; 160]);
    g.extend_from_slice(&[0x77; 64]);
    g
}

/// The `//authority/path` a test client addresses over `via`: the URL's over WebTransport
/// and the WebSocket binding; over native QUIC, with no AUTHORITY or PATH sent, `//`.
fn target_of(server: &RelayServer, via: Via) -> String {
    let path = server.relay().config().path.clone();
    match via {
        Via::Quic | Via::QuicDraft(_) => "//".into(),
        Via::WebTransport | Via::WtDraft(_) => format!("//127.0.0.1:{}{path}", server.quic_addr.unwrap().port()),
        Via::WebSocket | Via::WsDraft(_) => format!("//{}{path}", server.websocket_addr.unwrap()),
        #[cfg(feature = "webtransport-h2")]
        Via::WtH2 | Via::WtH2Draft(_) => format!("//127.0.0.1:{}{path}", server.webtransport_h2_addr.unwrap().port()),
    }
}

async fn closed_unauthorized(c: &Client, what: &str) {
    match timeout(STEP, c.conn.closed()).await.expect("closed in time") {
        TransportError::Closed { code, .. } => assert_eq!(code, SessionError::UNAUTHORIZED.0, "{what}"),
        other => panic!("{what}: {other:?}"),
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn a_grant_is_honoured_only_with_its_proof() {
    timeout(Duration::from_secs(180), run()).await.expect("the test finishes in time");
}

async fn run() {
    let host = SigningKey::from_bytes(&[0x41; 32]);
    let stranger = SigningKey::from_bytes(&[0x42; 32]);
    let record = grant_record(9, &host);
    let hash = hex::encode(joule_moq_relay::auth::sha256(&record));
    let rule = |hash: String| Grant { prefix: vec!["room".into()], token_sha256: hash, publish: true, subscribe: true, proof: true, unlimited: false, seek: false };
    let server = relay(|c| {
        c.auth.required = true;
        c.auth.grants = vec![rule(hash.clone())];
    })
    .await;
    let t = Tracks::new(ns(&["room", "host"]), "0", 10, 5, 128);
    let with = |key: &SigningKey, target: String| ClientOptions { grants: vec![(record.clone(), key.clone())], target, ..ClientOptions::default() };
    let ws = target_of(&server, Via::WebSocket);

    // The relay's SETUP never comes before the client's: a session that sends nothing is sent
    // nothing.
    let (silent, _ep) = dial(&server, Via::Quic, None).await;
    assert!(timeout(Duration::from_millis(400), silent.accept_uni()).await.is_err(), "the relay sent its SETUP before it read the client's");
    silent.close(0, b"done");

    // A client that holds no challenge is refused and given one; its second session proves over
    // it; the SETUP that admits it gives the next, and a third session proves over that at once.
    // Over each transport at -22, and at each other draft the relay speaks, through its bridge:
    // the order, the options and the second session are the same at every one.
    use joule_moq::draft::Draft;
    let vias = [Via::WebSocket, Via::WebTransport, Via::Quic, Via::QuicDraft(Draft::D23), Via::WsDraft(Draft::D23), Via::QuicDraft(Draft::D18), Via::QuicDraft(Draft::D16)];
    let mut challenges = Vec::new();
    for via in vias {
        let opts = with(&host, target_of(&server, via));
        let first = refused_at_setup(&server, via, opts.clone()).await;
        assert_eq!(first.reason, "pop_missing", "a grant presented with no proof");
        let given = first.challenge.expect("the refusing SETUP carries a challenge");
        let (conn, _ep) = dial(&server, via, None).await;
        let c = Client::connect(conn, ClientOptions { challenge: Some(given), ..opts.clone() }).await.expect("admitted on its second session");
        let _held = publish_tracks(&c, &t, None).await;
        let next = c.challenge().expect("the admitting SETUP carries the next challenge");
        c.close(0, "done");
        let (conn, _ep) = dial(&server, via, None).await;
        let c = Client::connect(conn, ClientOptions { challenge: Some(next), ..opts }).await.expect("admitted at once, over the challenge its last SETUP gave");
        let _held = publish_tracks(&c, &t, None).await;
        challenges.extend([given, next, c.challenge().expect("and gives another")]);
        c.close(0, "done");
    }
    let consumed = challenges[0];
    challenges.sort();
    challenges.dedup();
    assert_eq!(challenges.len(), 3 * vias.len(), "a relay never issues one challenge twice");

    // Planted, each refused with its reason.
    let mut caught = 0;
    let fresh = || async { challenge_from(&server, Via::WebSocket, &with(&host, ws.clone())).await.expect("a challenge") };
    let bare = ClientOptions { tokens: vec![Token::UseValue { token_type: 0, value: record.clone() }], ..ClientOptions::default() };
    assert_eq!(refused_at_setup(&server, Via::WebSocket, bare.clone()).await.reason, "pop_missing", "the grant as a bare token");
    caught += 1;
    let r = refused_at_setup(&server, Via::WebSocket, ClientOptions { challenge: Some(fresh().await), ..with(&stranger, ws.clone()) }).await;
    assert_eq!(r.reason, "pop_wrong_key", "a proof by another key");
    caught += 1;
    let r = refused_at_setup(&server, Via::WebSocket, ClientOptions { challenge: Some(fresh().await), ..with(&host, "//other-relay.example/moq".into()) }).await;
    assert_eq!(r.reason, "pop_wrong_context", "a proof for another relay");
    caught += 1;
    let r = refused_at_setup(&server, Via::WebSocket, ClientOptions { challenge: Some(consumed), ..with(&host, ws.clone()) }).await;
    assert_eq!(r.reason, "pop_replayed", "a proof over a challenge an admitted SETUP consumed");
    caught += 1;
    let r = refused_at_setup(&server, Via::WebSocket, ClientOptions { challenge: Some([0x5e; 32]), ..with(&host, ws.clone()) }).await;
    assert_eq!(r.reason, "pop_wrong_challenge", "a proof over a challenge the relay never issued");
    assert!(r.challenge.is_some(), "and a challenge to prove over is given with every refusal");
    caught += 1;
    // A challenge is good at the relay that issued it: another relay holds none of this one's.
    let brief = relay(|c| {
        c.auth.required = true;
        c.auth.grants = vec![rule(hash.clone())];
        c.limits.grant_challenge_ms = 150;
    })
    .await;
    let theirs = target_of(&brief, Via::WebSocket);
    let r = refused_at_setup(&brief, Via::WebSocket, ClientOptions { challenge: Some(fresh().await), ..with(&host, theirs.clone()) }).await;
    assert_eq!(r.reason, "pop_wrong_challenge", "a challenge of another relay's");
    caught += 1;
    // And for the time it states: past it, it is no challenge.
    let late = challenge_from(&brief, Via::WebSocket, &with(&host, theirs.clone())).await.expect("a challenge");
    tokio::time::sleep(Duration::from_millis(400)).await;
    let r = refused_at_setup(&brief, Via::WebSocket, ClientOptions { challenge: Some(late), ..with(&host, theirs.clone()) }).await;
    assert_eq!(r.reason, "pop_wrong_challenge", "a challenge past its time");
    caught += 1;
    // Within its time it is good: the same relay, the same grant.
    let (conn, _ep) = dial(&brief, Via::WebSocket, None).await;
    Client::connect(conn, ClientOptions { challenge: r.challenge, ..with(&host, theirs) }).await.expect("a proof over the challenge the refusal gave").close(0, "done");
    brief.shutdown().await;
    eprintln!("planted faults caught (grant proofs): {caught} of 7");

    // A client that does not know GRANT_REFUSED stays: the relay closes its session itself,
    // UNAUTHORIZED, with the reason. Nothing of it was served meanwhile.
    let (conn, _ep) = dial(&server, Via::WebSocket, None).await;
    let c = Client::connect(conn, ClientOptions { ignore_refusal: true, ..bare }).await.expect("the SETUPs are exchanged");
    assert_eq!(grant_proof::refusal_of(&c.peer_setup.options).as_deref(), Some("pop_missing"), "the relay's SETUP says it refuses");
    closed_unauthorized(&c, "a grant with no proof").await;

    // A grant presented only in a request, never proved in SETUP: refused that request.
    let (c, _) = connect(&server, Via::WebSocket, ClientOptions::default()).await;
    let late = Parameters::new().with(Parameter::AuthorizationToken(Token::UseValue { token_type: 0, value: record.clone() }));
    let refused = c.subscribe(t.ns.clone(), t.media.clone(), late).await.expect_err("a grant not proved");
    assert!(refused.contains(&RequestErrorCode::UNAUTHORIZED.to_string()), "{refused}");
    c.close(0, "done");
    server.shutdown().await;
}