Skip to content

Commit e09f715

Browse files
authored
Verify ACP relay events before prompt routing (#7010)
## What changed Verify every Nostr EVENT received by buzz-acp immediately after deserialization. Events with an invalid NIP-01 ID or Schnorr signature are dropped before subscription routing, deduplication, replay-watermark updates, membership handling, or either harness queue. ## Safety Signature verification runs on the blocking pool so cryptographic work does not block the relay task. A verification failure drops only that event and keeps the connection available for subsequent valid traffic. The existing observer-control verification remains as defense in depth. Regression tests cover valid delivery; changed content, ID, signature, pubkey, tags, and timestamp; a forged owner shutdown command with a recomputed ID; forged membership notifications; and forged observer-control events. ## Testing cargo test -p buzz-acp cargo clippy -p buzz-acp --all-targets -- -D warnings just ci --------- Signed-off-by: Jordan Mecom <[email protected]>
1 parent b17c077 commit e09f715

3 files changed

Lines changed: 269 additions & 0 deletions

File tree

‎Justfile‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -369,6 +369,9 @@ test-unit:
369369
cargo test -p buzz-auth --doc
370370
cargo nextest run -p buzz-voice --lib
371371
cargo nextest run -p buzz-cli
372+
# buzz-acp owns the relay-to-agent trust boundary. Run its tests here so
373+
# forged relay events cannot regain a path into agent routing unnoticed.
374+
cargo nextest run -p buzz-acp
372375
# buzz-db migrator/lint tests: pure SQL-parsing unit tests (no infra).
373376
# They guard the embedded-migrator invariant (the complete checked-in
374377
# additive migration set; legacy cutover/backfill remains an operator

‎crates/buzz-acp/src/relay.rs‎

Lines changed: 261 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -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]),

‎scripts/run-tests.sh‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,11 @@ run_unit_tests() {
9090
run_test_step "buzz-cli tests" \
9191
cargo test -p buzz-cli -- --nocapture
9292

93+
# Keep the relay-to-agent trust-boundary regressions in the fallback path
94+
# when cargo-nextest is unavailable.
95+
run_test_step "buzz-acp tests" \
96+
cargo test -p buzz-acp -- --nocapture
97+
9398
# buzz-db migrator/lint unit tests (no infra): guard the embedded-migrator
9499
# invariant (exactly the consolidated 0001; cutover/backfill stays an operator
95100
# script, not startup state) and the tenant-scoping lints. The Postgres-backed

0 commit comments

Comments
 (0)