fix(p2p/webrtc): avoid cors by doing GET request instead of POST for signaling

Author: binier

Cargo.lock

@@ -10,6 +10,7 @@ rand = "0.8"
 serde = "1.0.158"
 serde_json = "1.0.94"
 derive_more = "0.99.17"
+bs58 = { version = "0.4" }
 rayon = "1.5"
 tokio = { version = "1.26.0", features = ["process", "macros"] }
 reqwest = { version = "0.11.24", features = ["blocking", "json"] }

node/native/Cargo.toml

@@ -39,48 +39,64 @@ pub async fn run(port: u16, rpc_sender: RpcSender) {
 
         use super::rpc::RpcP2pConnectionIncomingResponse;
 
+        let handle = |sender: RpcSender, offer: Box<webrtc::Offer>| async move {
+            let mut rx = sender
+                .multishot_request(
+                    2,
+                    RpcRequest::P2pConnectionIncoming(P2pConnectionIncomingInitOpts {
+                        peer_id: PeerId::from_public_key(offer.identity_pub_key.clone()),
+                        signaling: IncomingSignalingMethod::Http,
+                        offer,
+                    }),
+                )
+                .await;
+
+            match rx.recv().await {
+                Some(RpcP2pConnectionIncomingResponse::Answer(answer)) => {
+                    let status = match &answer {
+                        P2pConnectionResponse::Accepted(_) => StatusCode::OK,
+                        P2pConnectionResponse::Rejected(reason) => match reason.is_bad() {
+                            false => StatusCode::OK,
+                            true => StatusCode::BAD_REQUEST,
+                        },
+                        P2pConnectionResponse::SignalDecryptionFailed => StatusCode::BAD_REQUEST,
+                        P2pConnectionResponse::InternalError => StatusCode::INTERNAL_SERVER_ERROR,
+                    };
+                    with_json_reply(&answer, status)
+                }
+                _ => {
+                    let resp = P2pConnectionResponse::internal_error_str();
+                    with_json_reply(&resp, StatusCode::INTERNAL_SERVER_ERROR)
+                }
+            }
+        };
+
         let rpc_sender_clone = rpc_sender.clone();
-        warp::path!("mina" / "webrtc" / "signal")
-            .and(warp::post())
-            .and(warp::filters::body::json())
-            .then(move |offer: Box<webrtc::Offer>| {
+        let get = warp::path!("mina" / "webrtc" / "signal" / String)
+            .and(warp::get())
+            .then(move |offer: String| {
                 let rpc_sender_clone = rpc_sender_clone.clone();
                 async move {
-                    let mut rx = rpc_sender_clone
-                        .multishot_request(
-                            2,
-                            RpcRequest::P2pConnectionIncoming(P2pConnectionIncomingInitOpts {
-                                peer_id: PeerId::from_public_key(offer.identity_pub_key.clone()),
-                                signaling: IncomingSignalingMethod::Http,
-                                offer,
-                            }),
-                        )
-                        .await;
-
-                    match rx.recv().await {
-                        Some(RpcP2pConnectionIncomingResponse::Answer(answer)) => {
-                            let status = match &answer {
-                                P2pConnectionResponse::Accepted(_) => StatusCode::OK,
-                                P2pConnectionResponse::Rejected(reason) => match reason.is_bad() {
-                                    false => StatusCode::OK,
-                                    true => StatusCode::BAD_REQUEST,
-                                },
-                                P2pConnectionResponse::SignalDecryptionFailed => {
-                                    StatusCode::BAD_REQUEST
-                                }
-                                P2pConnectionResponse::InternalError => {
-                                    StatusCode::INTERNAL_SERVER_ERROR
-                                }
-                            };
-                            with_json_reply(&answer, status)
-                        }
-                        _ => {
-                            let resp = P2pConnectionResponse::internal_error_str();
-                            with_json_reply(&resp, StatusCode::INTERNAL_SERVER_ERROR)
-                        }
+                    let decode_res = Err(()).or_else(move |_| {
+                        let json = bs58::decode(&offer).into_vec().or(Err(()))?;
+                        serde_json::from_slice(&json).or(Err(()))
+                    });
+                    match decode_res {
+                        Err(()) => with_json_reply(
+                            &P2pConnectionResponse::SignalDecryptionFailed,
+                            StatusCode::BAD_REQUEST,
+                        ),
+                        Ok(offer) => handle(rpc_sender_clone.clone(), offer).await,
                     }
                 }
-            })
+            });
+
+        let rpc_sender_clone = rpc_sender.clone();
+        let post = warp::path!("mina" / "webrtc" / "signal")
+            .and(warp::post())
+            .and(warp::filters::body::json())
+            .then(move |offer: Box<webrtc::Offer>| handle(rpc_sender_clone.clone(), offer));
+        get.or(post)
     };
 
     // TODO(binier): make endpoint only accessible locally.

node/native/src/http_server.rs

@@ -274,8 +274,7 @@ impl NodeBuilder {
 }
 
 fn default_peers() -> Vec<P2pConnectionOutgoingInitOpts> {
-    ["/2cBFzmUmkYgMUrxdv5S2Udyv8eiuhokAFS4WnYfHiAJLWoQ3yL9/http/webrtc3.webnode.openmina.com/3000",
-    "/2aevrztkwUrbPDP85ZZHkNYM6qha2GYT9sUwPhttKAKzqQdF4nV/http/localhost/3000"]
+    ["/2cBFzmUmkYgMUrxdv5S2Udyv8eiuhokAFS4WnYfHiAJLWoQ3yL9/https/webrtc3.webnode.openmina.com/443"]
         .into_iter()
         .map(|s| s.parse().unwrap())
         .collect()

node/web/src/node/builder.rs

@@ -234,12 +234,11 @@ pub async fn webrtc_signal_send(
     url: &str,
     offer: Offer,
 ) -> std::result::Result<P2pConnectionResponse, RTCSignalingError> {
-    use web_sys::{Request, RequestInit, Response};
+    use web_sys::{Request, Response};
 
-    let mut opts = RequestInit::new();
-    opts.method("POST");
-    opts.body(Some(&JsValue::from(serde_json::to_string(&offer)?)));
-    let request = Request::new_with_str_and_init(url, &opts)?;
+    let offer = bs58::encode(serde_json::to_string(&offer)?).into_string();
+    let url = format!("{url}/{offer}");
+    let request = Request::new_with_str(&url)?;
     request.headers().set("content-type", "application/json")?;
 
     let window = web_sys::window().unwrap();