@@ -24,11 +24,80 @@ use std::sync::Arc;
2424
2525use nostr:: { EventBuilder , Kind , Tag } ;
2626use sprout_core:: event:: StoredEvent ;
27- use sprout_core:: kind:: KIND_MESH_CALL_ME_NOW ;
27+ use sprout_core:: kind:: {
28+ event_kind_u32, KIND_MESH_CALL_ME_NOW , KIND_MESH_CONNECT_REQUEST , KIND_MESH_STATUS_REPORT ,
29+ } ;
2830
2931use crate :: api:: relay_members:: { check_relay_membership, MembershipDecision } ;
3032use crate :: state:: AppState ;
3133
34+ /// Check + bump the per-requester 24621 rate limit (20/sec window).
35+ ///
36+ /// Each accepted connect request makes the relay sign + fan TWO 24622s, so we
37+ /// bound the amplification. 20/sec is far above any real interactive use; a
38+ /// buggy desktop loop can't storm the relay. Shared by the WS door
39+ /// (`handlers::event`) and the HTTP door (`handle_mesh_event_http`) — one
40+ /// limiter, two transports.
41+ pub ( crate ) fn connect_request_rate_limited ( state : & AppState , pubkey : & nostr:: PublicKey ) -> bool {
42+ let key: [ u8 ; 32 ] = pubkey. to_bytes ( ) ;
43+ let now = std:: time:: Instant :: now ( ) ;
44+ let mut entry = state
45+ . mesh_connect_rate_limiter
46+ . entry ( key)
47+ . or_insert ( ( 0 , now) ) ;
48+ let ( count, window_start) = entry. value_mut ( ) ;
49+ if now. duration_since ( * window_start) . as_secs ( ) >= 1 {
50+ * count = 1 ;
51+ * window_start = now;
52+ false
53+ } else {
54+ * count += 1 ;
55+ * count > 20
56+ }
57+ }
58+
59+ /// HTTP-door entry point for the two desktop-published mesh signaling kinds
60+ /// (24620 status report, 24621 connect request).
61+ ///
62+ /// These kinds are ephemeral, so `ingest_event`'s per-kind allowlist
63+ /// (deliberately) rejects them — historically they arrived only over the WS
64+ /// path in `handlers::event`. Since the desktop's Rust coordinator publishes
65+ /// them via `POST /events` (NIP-98), the bridge routes them here instead.
66+ /// Mirrors the WS door's checks in the same order: signature, pubkey-match
67+ /// (strict — mesh kinds are never proxy-submittable), rate limit, then the
68+ /// shared handlers. Membership is enforced both at the bridge and inside the
69+ /// handlers (fail-closed `require_mesh_member`).
70+ ///
71+ /// Returns the same message the WS door would put in its OK frame; the bridge
72+ /// maps `Err` to HTTP 400.
73+ pub async fn handle_mesh_event_http (
74+ state : & Arc < AppState > ,
75+ auth_pubkey : & nostr:: PublicKey ,
76+ event : & nostr:: Event ,
77+ ) -> Result < ( ) , String > {
78+ let event_clone = event. clone ( ) ;
79+ tokio:: task:: spawn_blocking ( move || sprout_core:: verification:: verify_event ( & event_clone) )
80+ . await
81+ . map_err ( |_| "error: internal verification error" . to_string ( ) ) ?
82+ . map_err ( |e| format ! ( "invalid: {e}" ) ) ?;
83+
84+ if event. pubkey != * auth_pubkey {
85+ return Err ( "invalid: event pubkey does not match authenticated identity" . to_string ( ) ) ;
86+ }
87+
88+ let pubkey_hex = auth_pubkey. to_hex ( ) ;
89+ match event_kind_u32 ( event) {
90+ k if k == KIND_MESH_STATUS_REPORT => handle_status_report ( state, & pubkey_hex, event) . await ,
91+ k if k == KIND_MESH_CONNECT_REQUEST => {
92+ if connect_request_rate_limited ( state, auth_pubkey) {
93+ return Err ( "rate-limited: mesh connect request rate exceeded (20/sec)" . to_string ( ) ) ;
94+ }
95+ handle_connect_request ( state, & pubkey_hex, event) . await
96+ }
97+ k => Err ( format ! ( "invalid: kind {k} is not a mesh signaling kind" ) ) ,
98+ }
99+ }
100+
32101/// Parsed `KIND_MESH_CONNECT_REQUEST` (24621) content.
33102#[ derive( Debug , Clone , PartialEq , Eq ) ]
34103pub struct ConnectRequest {
@@ -609,4 +678,110 @@ mod tests {
609678 ) ;
610679 assert ! ( target_rx. try_recv( ) . is_err( ) , "target receives no event" ) ;
611680 }
681+
682+ // ── HTTP door (handle_mesh_event_http) ──────────────────────────────────
683+ // Regression coverage for the post-#879 transport: the desktop's Rust
684+ // coordinator publishes 24620/24621 via POST /events, which used to fall
685+ // into ingest_event's allowlist and 400 with "unknown event kind".
686+
687+ fn signed_connect_request ( keys : & nostr:: Keys , target_hex : & str ) -> nostr:: Event {
688+ let content = serde_json:: json!( {
689+ "self_endpoint_addr" : "SELF_ADDR" ,
690+ "peer_endpoint_addr" : "PEER_ADDR" ,
691+ "attempt_id" : "attempt-http-1"
692+ } )
693+ . to_string ( ) ;
694+ nostr:: EventBuilder :: new ( nostr:: Kind :: Custom ( 24621 ) , content)
695+ . tags ( [ nostr:: Tag :: parse ( [ "p" , target_hex] ) . unwrap ( ) ] )
696+ . sign_with_keys ( keys)
697+ . unwrap ( )
698+ }
699+
700+ #[ tokio:: test]
701+ async fn http_door_accepts_connect_request_and_emits_pair ( ) {
702+ let state = test_state ( ) . await ;
703+ let requester = nostr:: Keys :: generate ( ) ;
704+ let requester_hex = requester. public_key ( ) . to_hex ( ) ;
705+ let target_hex = nostr:: Keys :: generate ( ) . public_key ( ) . to_hex ( ) ;
706+ let ( _rc, mut requester_rx) =
707+ register_call_me_now_sub ( & state, & requester_hex, "http_requester" ) ;
708+ let ( _tc, mut target_rx) = register_call_me_now_sub ( & state, & target_hex, "http_target" ) ;
709+
710+ handle_mesh_event_http (
711+ & state,
712+ & requester. public_key ( ) ,
713+ & signed_connect_request ( & requester, & target_hex) ,
714+ )
715+ . await
716+ . expect ( "HTTP door accepts a valid connect request" ) ;
717+
718+ event_from_ws_message ( requester_rx. try_recv ( ) . expect ( "requester call-me-now" ) ) ;
719+ event_from_ws_message ( target_rx. try_recv ( ) . expect ( "target call-me-now" ) ) ;
720+ }
721+
722+ #[ tokio:: test]
723+ async fn http_door_rejects_pubkey_mismatch ( ) {
724+ let state = test_state ( ) . await ;
725+ let signer = nostr:: Keys :: generate ( ) ;
726+ let other = nostr:: Keys :: generate ( ) ;
727+ let target_hex = nostr:: Keys :: generate ( ) . public_key ( ) . to_hex ( ) ;
728+
729+ let err = handle_mesh_event_http (
730+ & state,
731+ & other. public_key ( ) ,
732+ & signed_connect_request ( & signer, & target_hex) ,
733+ )
734+ . await
735+ . expect_err ( "signer != authenticated identity must be rejected" ) ;
736+ assert ! ( err. contains( "does not match" ) , "unexpected error: {err}" ) ;
737+ }
738+
739+ #[ tokio:: test]
740+ async fn http_door_rejects_bad_signature ( ) {
741+ let state = test_state ( ) . await ;
742+ let keys = nostr:: Keys :: generate ( ) ;
743+ let target_hex = nostr:: Keys :: generate ( ) . public_key ( ) . to_hex ( ) ;
744+ let mut event = signed_connect_request ( & keys, & target_hex) ;
745+ // Tamper after signing.
746+ event. content = "{}" . to_string ( ) ;
747+
748+ let err = handle_mesh_event_http ( & state, & keys. public_key ( ) , & event)
749+ . await
750+ . expect_err ( "tampered event must be rejected" ) ;
751+ assert ! ( err. starts_with( "invalid:" ) , "unexpected error: {err}" ) ;
752+ }
753+
754+ #[ tokio:: test]
755+ async fn http_door_rejects_non_mesh_kind ( ) {
756+ let state = test_state ( ) . await ;
757+ let keys = nostr:: Keys :: generate ( ) ;
758+ let event = nostr:: EventBuilder :: new ( nostr:: Kind :: Custom ( 20001 ) , "online" )
759+ . sign_with_keys ( & keys)
760+ . unwrap ( ) ;
761+
762+ let err = handle_mesh_event_http ( & state, & keys. public_key ( ) , & event)
763+ . await
764+ . expect_err ( "only 24620/24621 route through the mesh HTTP door" ) ;
765+ assert ! (
766+ err. contains( "not a mesh signaling kind" ) ,
767+ "unexpected error: {err}"
768+ ) ;
769+ }
770+
771+ #[ tokio:: test]
772+ async fn connect_request_rate_limiter_trips_on_21st_in_window ( ) {
773+ let state = test_state ( ) . await ;
774+ let pubkey = nostr:: Keys :: generate ( ) . public_key ( ) ;
775+ for i in 0 ..20 {
776+ assert ! (
777+ !connect_request_rate_limited( & state, & pubkey) ,
778+ "request {} should pass" ,
779+ i + 1
780+ ) ;
781+ }
782+ assert ! (
783+ connect_request_rate_limited( & state, & pubkey) ,
784+ "21st request in the same window must be limited"
785+ ) ;
786+ }
612787}
0 commit comments