feat: use axum for ohttp gateway middleware

Author: Harshdev098

Cargo-minimal.lock

@@ -2441,6 +2441,8 @@ dependencies = [
 name = "ohttp-relay"
 version = "0.0.11"
 dependencies = [
+ "bhttp",
+ "bitcoin-ohttp",
  "byteorder",
  "bytes",
  "futures",

Cargo-recent.lock

@@ -2441,6 +2441,8 @@ dependencies = [
 name = "ohttp-relay"
 version = "0.0.11"
 dependencies = [
+ "bhttp",
+ "bitcoin-ohttp",
  "byteorder",
  "bytes",
  "futures",

ohttp-relay/Cargo.toml

@@ -47,6 +47,8 @@ tokio-util = { version = "0.7.16", features = ["net", "codec"] }
 tower = "0.5"
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
+ohttp = { package = "bitcoin-ohttp", version = "0.6" }
+bhttp = { version = "0.6.1", features = ["http"] }
 
 [dev-dependencies]
 mockito = "1.7.0"

ohttp-relay/src/gateway_helpers.rs

@@ -0,0 +1,126 @@
+use http_body_util::combinators::BoxBody;
+use http_body_util::{BodyExt, Full};
+use hyper::body::Bytes;
+use hyper::{Request, Response, Uri};
+
+pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
+
+pub const CHACHA20_POLY1305_NONCE_LEN: usize = 32;
+pub const POLY1305_TAG_SIZE: usize = 16;
+pub const ENCAPSULATED_MESSAGE_BYTES: usize = 65536;
+pub const BHTTP_REQ_BYTES: usize =
+    ENCAPSULATED_MESSAGE_BYTES - (CHACHA20_POLY1305_NONCE_LEN + POLY1305_TAG_SIZE);
+
+#[derive(Debug)]
+pub enum GatewayError {
+    BadRequest(String),
+    OhttpKeyRejection(String),
+    InternalServerError(String),
+}
+
+impl std::fmt::Display for GatewayError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GatewayError::BadRequest(msg) => write!(f, "Bad request: {}", msg),
+            GatewayError::OhttpKeyRejection(msg) => write!(f, "OHTTP key rejection: {}", msg),
+            GatewayError::InternalServerError(msg) => write!(f, "Internal server error: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for GatewayError {}
+
+pub async fn decapsulate_ohttp_request<B>(
+    req: Request<B>,
+    ohttp_server: &ohttp::Server,
+) -> Result<(Request<BoxBody<Bytes, hyper::Error>>, ohttp::ServerResponse), GatewayError>
+where
+    B: hyper::body::Body<Data = Bytes> + Send + 'static,
+    B::Error: Into<BoxError>,
+{
+    // Collect OHTTP body
+    let ohttp_body = req
+        .into_body()
+        .collect()
+        .await
+        .map_err(|e| GatewayError::BadRequest(format!("Failed to read body: {}", e.into())))?
+        .to_bytes();
+
+    // Decapsulate using OHTTP server
+    let (bhttp_req, res_ctx) = ohttp_server.decapsulate(&ohttp_body).map_err(|e| {
+        GatewayError::OhttpKeyRejection(format!("OHTTP decapsulation failed: {}", e))
+    })?;
+
+    // Parse BHTTP message
+    let mut cursor = std::io::Cursor::new(bhttp_req);
+    let bhttp_msg = bhttp::Message::read_bhttp(&mut cursor)
+        .map_err(|e| GatewayError::BadRequest(format!("Invalid BHTTP: {}", e)))?;
+
+    let uri = Uri::builder()
+        .scheme(bhttp_msg.control().scheme().unwrap_or_default())
+        .authority(bhttp_msg.control().authority().unwrap_or_default())
+        .path_and_query(bhttp_msg.control().path().unwrap_or_default())
+        .build()
+        .map_err(|e| GatewayError::BadRequest(format!("Invalid URI: {}", e)))?;
+
+    let body = bhttp_msg.content().to_vec();
+    let mut http_req =
+        Request::builder().uri(uri).method(bhttp_msg.control().method().unwrap_or_default());
+
+    for header in bhttp_msg.header().fields() {
+        http_req = http_req.header(header.name(), header.value());
+    }
+
+    let request = http_req.body(full(body)).map_err(|e| {
+        GatewayError::InternalServerError(format!("Failed to build request: {}", e))
+    })?;
+
+    Ok((request, res_ctx))
+}
+
+pub async fn encapsulate_ohttp_response(
+    response: Response<BoxBody<Bytes, hyper::Error>>,
+    res_ctx: ohttp::ServerResponse,
+) -> Result<Response<BoxBody<Bytes, hyper::Error>>, GatewayError> {
+    let (parts, body) = response.into_parts();
+
+    let mut bhttp_res =
+        bhttp::Message::response(bhttp::StatusCode::try_from(parts.status.as_u16()).map_err(
+            |e| GatewayError::InternalServerError(format!("Invalid status code: {}", e)),
+        )?);
+
+    for (name, value) in parts.headers.iter() {
+        bhttp_res.put_header(name.as_str(), value.to_str().unwrap_or_default());
+    }
+
+    let full_body = body
+        .collect()
+        .await
+        .map_err(|e| GatewayError::InternalServerError(format!("Failed to collect body: {}", e)))?
+        .to_bytes();
+    bhttp_res.write_content(&full_body);
+
+    let mut bhttp_bytes = Vec::new();
+    bhttp_res.write_bhttp(bhttp::Mode::KnownLength, &mut bhttp_bytes).map_err(|e| {
+        GatewayError::InternalServerError(format!("BHTTP serialization failed: {}", e))
+    })?;
+
+    bhttp_bytes.resize(BHTTP_REQ_BYTES, 0);
+
+    let ohttp_res = res_ctx.encapsulate(&bhttp_bytes).map_err(|e| {
+        GatewayError::InternalServerError(format!("OHTTP encapsulation failed: {}", e))
+    })?;
+
+    assert!(
+        ohttp_res.len() == ENCAPSULATED_MESSAGE_BYTES,
+        "Unexpected OHTTP response size: {} != {}",
+        ohttp_res.len(),
+        ENCAPSULATED_MESSAGE_BYTES
+    );
+
+    Ok(Response::new(full(ohttp_res)))
+}
+
+fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
+    Full::new(chunk.into()).map_err(|never| match never {}).boxed()
+}

ohttp-relay/src/lib.rs

@@ -36,6 +36,12 @@ pub mod gateway_prober;
 mod gateway_uri;
 pub mod sentinel;
 pub use sentinel::SentinelTag;
+pub mod gateway_helpers;
+
+pub use gateway_helpers::{
+    decapsulate_ohttp_request, encapsulate_ohttp_response, BHTTP_REQ_BYTES,
+    ENCAPSULATED_MESSAGE_BYTES,
+};
 
 use crate::error::{BoxError, Error};