@@ -2267,6 +2267,36 @@ async fn handle_ws_message(
22672267 subscription_id,
22682268 event,
22692269 } => {
2270+ // Relay and storage responses are untrusted. Verify before
2271+ // any event field can affect routing, replay state, or the
2272+ // harness queues.
2273+ let event_id = event. id . to_hex ( ) ;
2274+ let event = match tokio:: task:: spawn_blocking ( move || {
2275+ buzz_core:: verify_event ( & event) . map ( |( ) | event)
2276+ } )
2277+ . await
2278+ {
2279+ Ok ( Ok ( event) ) => event,
2280+ Ok ( Err ( error) ) => {
2281+ warn ! (
2282+ subscription_id,
2283+ event_id,
2284+ error = %error,
2285+ "relay event failed NIP-01 verification — dropping"
2286+ ) ;
2287+ return true ;
2288+ }
2289+ Err ( error) => {
2290+ warn ! (
2291+ subscription_id,
2292+ event_id,
2293+ error = %error,
2294+ "relay event verification task failed — dropping"
2295+ ) ;
2296+ return true ;
2297+ }
2298+ } ;
2299+
22702300 if subscription_id == OBSERVER_CONTROL_SUB_ID {
22712301 match observer_control_tx. try_send ( * event) {
22722302 Ok ( ( ) ) => { }
@@ -4774,6 +4804,237 @@ mod tests {
47744804 . expect ( "parse test websocket frame" )
47754805 }
47764806
4807+ fn make_signed_channel_event ( keys : & Keys , content : & str , created_at_secs : u64 ) -> Event {
4808+ EventBuilder :: new ( Kind :: Custom ( 9 ) , content)
4809+ . tags ( [ ] )
4810+ . custom_created_at ( nostr:: Timestamp :: from ( created_at_secs) )
4811+ . sign_with_keys ( keys)
4812+ . expect ( "sign channel event" )
4813+ }
4814+
4815+ fn replace_event_field ( event : & Event , field : & str , replacement : Value ) -> Event {
4816+ let mut value = serde_json:: to_value ( event) . expect ( "serialize event" ) ;
4817+ value[ field] = replacement;
4818+ serde_json:: from_value ( value) . expect ( "deserialize tampered event" )
4819+ }
4820+
4821+ fn recompute_event_id ( event : & Event ) -> Event {
4822+ let id = nostr:: EventId :: new (
4823+ & event. pubkey ,
4824+ & event. created_at ,
4825+ & event. kind ,
4826+ & event. tags ,
4827+ & event. content ,
4828+ ) ;
4829+ replace_event_field ( event, "id" , json ! ( id. to_hex( ) ) )
4830+ }
4831+
4832+ async fn handle_test_relay_event (
4833+ ws : & mut WsStream ,
4834+ event_tx : & mpsc:: Sender < Option < BuzzEvent > > ,
4835+ observer_control_tx : & mpsc:: Sender < Event > ,
4836+ state : & mut BgState ,
4837+ subscription_id : & str ,
4838+ event : & Event ,
4839+ ) -> bool {
4840+ let keys = Keys :: generate ( ) ;
4841+ let agent_pubkey_hex = keys. public_key ( ) . to_hex ( ) ;
4842+ let text = serde_json:: to_string ( & json ! ( [ "EVENT" , subscription_id, event] ) )
4843+ . expect ( "serialize relay frame" ) ;
4844+ handle_ws_message (
4845+ Message :: Text ( text. into ( ) ) ,
4846+ ws,
4847+ event_tx,
4848+ observer_control_tx,
4849+ state,
4850+ & keys,
4851+ "wss://relay.example.com" ,
4852+ & agent_pubkey_hex,
4853+ None ,
4854+ )
4855+ . await
4856+ }
4857+
4858+ #[ tokio:: test]
4859+ async fn verified_channel_event_is_recorded_and_forwarded ( ) {
4860+ let ( mut client, _server) = test_ws_pair ( ) . await ;
4861+ let ( event_tx, mut event_rx) = mpsc:: channel ( 4 ) ;
4862+ let ( observer_control_tx, mut observer_control_rx) = mpsc:: channel ( 4 ) ;
4863+ let mut state = BgState :: new ( ) ;
4864+ let channel_id = Uuid :: new_v4 ( ) ;
4865+ let event = make_signed_channel_event ( & Keys :: generate ( ) , "hello" , 2_000 ) ;
4866+
4867+ assert ! (
4868+ handle_test_relay_event(
4869+ & mut client,
4870+ & event_tx,
4871+ & observer_control_tx,
4872+ & mut state,
4873+ & channel_sub_id( channel_id) ,
4874+ & event,
4875+ )
4876+ . await
4877+ ) ;
4878+
4879+ let received = event_rx. try_recv ( ) . expect ( "verified event was forwarded" ) ;
4880+ let received = received. expect ( "event channel should not contain shutdown marker" ) ;
4881+ assert_eq ! ( received. channel_id, channel_id) ;
4882+ assert_eq ! ( received. event. id, event. id) ;
4883+ assert_eq ! ( state. last_seen. get( & channel_id) , Some ( & 2_000 ) ) ;
4884+ assert ! ( state. seen_ids. contains( & event. id. to_hex( ) ) ) ;
4885+ assert ! ( matches!(
4886+ observer_control_rx. try_recv( ) ,
4887+ Err ( mpsc:: error:: TryRecvError :: Empty )
4888+ ) ) ;
4889+ }
4890+
4891+ #[ tokio:: test]
4892+ async fn tampered_channel_events_are_dropped_before_state_or_queue_changes ( ) {
4893+ let ( mut client, _server) = test_ws_pair ( ) . await ;
4894+ let ( event_tx, mut event_rx) = mpsc:: channel ( 8 ) ;
4895+ let ( observer_control_tx, _observer_control_rx) = mpsc:: channel ( 4 ) ;
4896+ let mut state = BgState :: new ( ) ;
4897+ let channel_id = Uuid :: new_v4 ( ) ;
4898+ let owner_event = make_signed_channel_event ( & Keys :: generate ( ) , "status" , 2_000 ) ;
4899+ let other_event = make_signed_channel_event ( & Keys :: generate ( ) , "other" , 3_000 ) ;
4900+ let other = serde_json:: to_value ( & other_event) . expect ( "serialize other event" ) ;
4901+ let owner_command = recompute_event_id ( & replace_event_field (
4902+ & owner_event,
4903+ "content" ,
4904+ json ! ( "!shutdown" ) ,
4905+ ) ) ;
4906+
4907+ let cases = [
4908+ (
4909+ "changed content" ,
4910+ replace_event_field ( & owner_event, "content" , json ! ( "tampered" ) ) ,
4911+ ) ,
4912+ ( "forged owner command with a matching id" , owner_command) ,
4913+ (
4914+ "changed event id" ,
4915+ replace_event_field ( & owner_event, "id" , other[ "id" ] . clone ( ) ) ,
4916+ ) ,
4917+ (
4918+ "changed signature" ,
4919+ replace_event_field ( & owner_event, "sig" , other[ "sig" ] . clone ( ) ) ,
4920+ ) ,
4921+ (
4922+ "changed author pubkey" ,
4923+ replace_event_field ( & owner_event, "pubkey" , other[ "pubkey" ] . clone ( ) ) ,
4924+ ) ,
4925+ (
4926+ "changed tags" ,
4927+ replace_event_field (
4928+ & owner_event,
4929+ "tags" ,
4930+ json ! ( [ [ "h" , Uuid :: new_v4( ) . to_string( ) ] ] ) ,
4931+ ) ,
4932+ ) ,
4933+ (
4934+ "changed timestamp" ,
4935+ replace_event_field ( & owner_event, "created_at" , json ! ( 4_000 ) ) ,
4936+ ) ,
4937+ ] ;
4938+
4939+ for ( case, event) in cases {
4940+ assert ! (
4941+ handle_test_relay_event(
4942+ & mut client,
4943+ & event_tx,
4944+ & observer_control_tx,
4945+ & mut state,
4946+ & channel_sub_id( channel_id) ,
4947+ & event,
4948+ )
4949+ . await ,
4950+ "{case} should not close the connection"
4951+ ) ;
4952+ assert ! (
4953+ matches!( event_rx. try_recv( ) , Err ( mpsc:: error:: TryRecvError :: Empty ) ) ,
4954+ "{case} reached the harness event queue"
4955+ ) ;
4956+ }
4957+
4958+ assert ! ( state. last_seen. is_empty( ) ) ;
4959+ assert ! ( state. seen_ids. current. is_empty( ) ) ;
4960+ assert ! ( state. seen_ids. previous. is_empty( ) ) ;
4961+ }
4962+
4963+ #[ tokio:: test]
4964+ async fn forged_membership_notification_is_dropped_before_state_or_queue_changes ( ) {
4965+ let ( mut client, _server) = test_ws_pair ( ) . await ;
4966+ let ( event_tx, mut event_rx) = mpsc:: channel ( 4 ) ;
4967+ let ( observer_control_tx, _observer_control_rx) = mpsc:: channel ( 4 ) ;
4968+ let mut state = BgState :: new ( ) ;
4969+ let attacker_keys = Keys :: generate ( ) ;
4970+ let owner_keys = Keys :: generate ( ) ;
4971+ let channel_id = Uuid :: new_v4 ( ) ;
4972+ let event = EventBuilder :: new (
4973+ Kind :: Custom ( KIND_MEMBER_ADDED_NOTIFICATION as u16 ) ,
4974+ "membership changed" ,
4975+ )
4976+ . tags ( [ Tag :: parse ( [ "h" , & channel_id. to_string ( ) ] ) . expect ( "h tag" ) ] )
4977+ . custom_created_at ( nostr:: Timestamp :: from ( 2_000 ) )
4978+ . sign_with_keys ( & attacker_keys)
4979+ . expect ( "sign membership event" ) ;
4980+ let forged = recompute_event_id ( & replace_event_field (
4981+ & event,
4982+ "pubkey" ,
4983+ json ! ( owner_keys. public_key( ) . to_hex( ) ) ,
4984+ ) ) ;
4985+
4986+ assert ! (
4987+ handle_test_relay_event(
4988+ & mut client,
4989+ & event_tx,
4990+ & observer_control_tx,
4991+ & mut state,
4992+ MEMBERSHIP_NOTIF_SUB_ID ,
4993+ & forged,
4994+ )
4995+ . await
4996+ ) ;
4997+
4998+ assert ! ( matches!(
4999+ event_rx. try_recv( ) ,
5000+ Err ( mpsc:: error:: TryRecvError :: Empty )
5001+ ) ) ;
5002+ assert_eq ! ( state. membership_last_seen, None ) ;
5003+ assert ! ( state. seen_ids. current. is_empty( ) ) ;
5004+ assert ! ( state. seen_ids. previous. is_empty( ) ) ;
5005+ }
5006+
5007+ #[ tokio:: test]
5008+ async fn forged_observer_control_is_dropped_before_control_queue ( ) {
5009+ let ( mut client, _server) = test_ws_pair ( ) . await ;
5010+ let ( event_tx, _event_rx) = mpsc:: channel ( 4 ) ;
5011+ let ( observer_control_tx, mut observer_control_rx) = mpsc:: channel ( 4 ) ;
5012+ let mut state = BgState :: new ( ) ;
5013+ let event = make_signed_channel_event ( & Keys :: generate ( ) , "control" , 2_000 ) ;
5014+ let forged = recompute_event_id ( & replace_event_field (
5015+ & event,
5016+ "content" ,
5017+ json ! ( "tampered control" ) ,
5018+ ) ) ;
5019+
5020+ assert ! (
5021+ handle_test_relay_event(
5022+ & mut client,
5023+ & event_tx,
5024+ & observer_control_tx,
5025+ & mut state,
5026+ OBSERVER_CONTROL_SUB_ID ,
5027+ & forged,
5028+ )
5029+ . await
5030+ ) ;
5031+
5032+ assert ! ( matches!(
5033+ observer_control_rx. try_recv( ) ,
5034+ Err ( mpsc:: error:: TryRecvError :: Empty )
5035+ ) ) ;
5036+ }
5037+
47775038 fn test_channel_filter ( ) -> ChannelFilter {
47785039 ChannelFilter {
47795040 kinds : Some ( vec ! [ 9 ] ) ,
0 commit comments