Skip to content

Commit dbe973d

Browse files
tlongwell-blocknpub1qyvc0c5kl4gqv2fd97fsk46tu378sqgy35vc83rvgfwne90sel7s0ed67d
andauthored
fix(relay): accept mesh signaling kinds (24620/24621) via POST /events (#946)
Signed-off-by: npub1qyvc0c5kl4gqv2fd97fsk46tu378sqgy35vc83rvgfwne90sel7s0ed67d <011987e296fd5006292d2f930b574be47c7801048d1983c46c425d3c95f0cffd@sprout-oss.stage.blox.sqprod.co> Co-authored-by: npub1qyvc0c5kl4gqv2fd97fsk46tu378sqgy35vc83rvgfwne90sel7s0ed67d <011987e296fd5006292d2f930b574be47c7801048d1983c46c425d3c95f0cffd@sprout-oss.stage.blox.sqprod.co>
1 parent f49cdcd commit dbe973d

3 files changed

Lines changed: 210 additions & 27 deletions

File tree

‎crates/sprout-relay/src/api/bridge.rs‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,31 @@ pub async fn submit_event(
188188
let event: nostr::Event = serde_json::from_slice(&body)
189189
.map_err(|e| api_error(StatusCode::BAD_REQUEST, &format!("invalid event JSON: {e}")))?;
190190

191+
// Mesh signaling kinds (24620 status report, 24621 connect request) are
192+
// ephemeral and deliberately absent from ingest_event's per-kind allowlist.
193+
// The desktop's Rust coordinator publishes them via this bridge, so route
194+
// them to the mesh handlers — the HTTP twin of the WS door's special-casing
195+
// in handlers::event. Membership was enforced above; the handlers re-check
196+
// it fail-closed.
197+
let kind_u32 = sprout_core::kind::event_kind_u32(&event);
198+
if kind_u32 == sprout_core::kind::KIND_MESH_STATUS_REPORT
199+
|| kind_u32 == sprout_core::kind::KIND_MESH_CONNECT_REQUEST
200+
{
201+
let event_id = event.id.to_hex();
202+
return match crate::handlers::mesh_signaling::handle_mesh_event_http(
203+
&state, &pubkey, &event,
204+
)
205+
.await
206+
{
207+
Ok(()) => Ok(Json(serde_json::json!({
208+
"event_id": event_id,
209+
"accepted": true,
210+
"message": "",
211+
}))),
212+
Err(msg) => Err(api_error(StatusCode::BAD_REQUEST, &msg)),
213+
};
214+
}
215+
191216
let auth = IngestAuth::Http {
192217
pubkey,
193218
scopes: sprout_auth::Scope::all_known(), // Pure Nostr: full scopes, channel access via membership

‎crates/sprout-relay/src/handlers/event.rs‎

Lines changed: 9 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -497,32 +497,15 @@ async fn handle_ephemeral_event(
497497
// in the v1 direct-iroh mesh — validate membership + pair + fan out. It
498498
// never carries iroh traffic and stores no endpoint state.
499499
if event_kind_u32(&event) == KIND_MESH_CONNECT_REQUEST {
500-
// Generous per-requester rate limit: each accepted 24621 makes the relay
501-
// sign + fan TWO 24622s, so bound the amplification. 20/sec is far above
502-
// any real interactive use; a buggy desktop loop can't storm the relay.
503-
{
504-
let key: [u8; 32] = auth_pubkey.to_bytes();
505-
let now = std::time::Instant::now();
506-
let mut entry = state
507-
.mesh_connect_rate_limiter
508-
.entry(key)
509-
.or_insert((0, now));
510-
let (count, window_start) = entry.value_mut();
511-
if now.duration_since(*window_start).as_secs() >= 1 {
512-
*count = 1;
513-
*window_start = now;
514-
} else {
515-
*count += 1;
516-
if *count > 20 {
517-
drop(entry);
518-
conn.send(RelayMessage::ok(
519-
event_id_hex,
520-
false,
521-
"rate-limited: mesh connect request rate exceeded (20/sec)",
522-
));
523-
return;
524-
}
525-
}
500+
// Per-requester rate limit shared with the HTTP door — see
501+
// `mesh_signaling::connect_request_rate_limited` for rationale.
502+
if super::mesh_signaling::connect_request_rate_limited(&state, &auth_pubkey) {
503+
conn.send(RelayMessage::ok(
504+
event_id_hex,
505+
false,
506+
"rate-limited: mesh connect request rate exceeded (20/sec)",
507+
));
508+
return;
526509
}
527510
let requester_hex = auth_pubkey.to_hex();
528511
match super::mesh_signaling::handle_connect_request(&state, &requester_hex, &event).await {

‎crates/sprout-relay/src/handlers/mesh_signaling.rs‎

Lines changed: 176 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,11 +24,80 @@ use std::sync::Arc;
2424

2525
use nostr::{EventBuilder, Kind, Tag};
2626
use 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

2931
use crate::api::relay_members::{check_relay_membership, MembershipDecision};
3032
use 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)]
34103
pub 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

Comments
 (0)