fix(relay): close write-path id-oracle and complete Q2-Q16 review fixes

Add actor_can_reference_target helper to mask author-only event ids
on all five write-path target-resolution sites (reaction channel
derivation, NIP-10 thread parent, stream-edit, forum-vote, kind:5
e-tag deletion), preventing non-authors from distinguishing a real
draft/reminder id from a random id via differential error responses.

Q2: DbError::DraftChannelRequired + channel_id=None DB-layer rejection
Q3: participates_in_thread_metadata split; outer e-tag rejection on drafts
Q4: reader_can_receive_event canonical read gate in buzz-core/filter.rs;
     wire into req.rs / count.rs / bridge.rs / search path
Q5: CI step for buzz-search FTS integration tests (ignored suite now runs)
Q6: HTTP catchall kindless privacy e2e test_draft_not_returned_in_kindless_channel_http_query
Q7: draft_kind_is_excluded_from_workflow_dispatch_by_author_only_guard
Q8: a-tag defensive-guard comment rewrite in side_effects.rs
Q9: e2e smoke for outer-e-tag rejection (test_draft_rejected_outer_e_tag)
Q10: fan-out author-side positive control (test_draft_live_fanout_reaches_author_own_subscription)
Q11: mixed-kinds /count test (test_draft_attacker_mixed_kinds_count_excludes_drafts)
Q12: derive exclusion list from AUTHOR_ONLY_KINDS in thread.rs
Q13: DM privacy recipient-side test (test_dm_draft_not_readable_by_dm_recipient)
Q14: migration 0007 deploy-window note
Q15: actor_can_reference_target post-lookup helper applied at reaction channel
     derivation (all actors rejected), NIP-10 thread parent (all actors
     rejected), stream-edit / forum-vote (non-author masked, author falls
     through), kind:5 e-tag deletion (non-author masked before authz,
     false comment corrected); generalizes over AUTHOR_ONLY_KINDS so
     kind:30300 reminders are also protected; unit tests confirm membership
Q16: channel-window cursor-boundary e2e (test_channel_window_cursor_boundary_excludes_draft)
Co-authored-by: Will Pfleger <pfleger.will@gmail.com>
Signed-off-by: Will Pfleger <pfleger.will@gmail.com>
This commit is contained in:
npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7
2026-07-14 00:21:25 -04:00
committed by Will Pfleger
co-authored by Will Pfleger
parent ed274bdc3c
commit 5c3ac62860
12 changed files with 965 additions and 130 deletions
+8
View File
@@ -629,6 +629,14 @@ jobs:
run: cargo test --profile ci -p buzz-db -- draft --ignored
env:
DATABASE_URL: postgres://buzz:buzz_dev@localhost:5432/buzz
- name: buzz-search FTS integration tests
# Storage-layer FTS guarantee tests, including the NIP-37 draft exclusion:
# kind:31234 rows must have NULL search_tsv so they never surface in
# NIP-50 results regardless of content. These tests are #[ignore]
# because they require a live Postgres; the CI job already provisions one.
run: cargo test --profile ci -p buzz-search --tests -- --include-ignored
env:
BUZZ_TEST_DATABASE_URL: postgres://buzz:buzz_dev@localhost:5432/buzz
- name: Upload relay log
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+30
View File
@@ -32,6 +32,36 @@ pub fn reader_authorized_for_event(event: &nostr::Event, reader_pubkey_hex: &str
.any(|t| t.content() == Some(reader_pubkey_hex))
}
/// Returns `true` if the event is an author-only kind and the requester is NOT
/// the author. Used as a per-event filter during historical delivery and fan-out
/// to silently omit unauthorized events from mixed-kind result sets.
pub fn is_author_only_event(event: &nostr::Event, requester_pubkey_bytes: &[u8]) -> bool {
let kind_u32 = crate::kind::event_kind_u32(event);
crate::kind::AUTHOR_ONLY_KINDS.contains(&kind_u32)
&& event.pubkey.to_bytes() != requester_pubkey_bytes
}
/// Canonical per-event read-authorization gate: combines `reader_authorized_for_event`
/// (p-gated/result-gated kinds) and `is_author_only_event` (author-private kinds)
/// into a single predicate.
///
/// Every delivery surface — WS historical pull, WS fan-out, HTTP bridge (all
/// branches: feed, thread, search, catchall, channel-window), and COUNT fallback
/// — must pass each event through this function before serializing it to the wire.
/// Using one canonical gate instead of composing the two predicates at each call
/// site prevents future read surfaces from accidentally omitting half the privacy
/// model.
///
/// Returns `true` if `reader` MAY receive the event.
pub fn reader_can_receive_event(
event: &nostr::Event,
reader_pubkey_hex: &str,
reader_pubkey_bytes: &[u8],
) -> bool {
reader_authorized_for_event(event, reader_pubkey_hex)
&& !is_author_only_event(event, reader_pubkey_bytes)
}
fn filter_match_one(f: &Filter, ev: &StoredEvent) -> bool {
if let Some(kinds) = &f.kinds {
if !kinds.contains(&ev.event.kind) {
+10
View File
@@ -57,6 +57,16 @@ pub enum DbError {
"draft-wrap channel binding is immutable — `h` tag must match the existing head's channel"
)]
DraftChannelMismatch,
/// A kind:31234 draft-wrap was submitted without a channel binding.
///
/// Every draft wrap requires a `channel_id` (resolved from the `h` tag
/// by ingest). A `None` channel_id at the DB layer means the caller
/// bypassed the ingest validator and must be rejected.
#[error(
"draft-wrap channel_id is required — draft wraps must be bound to a channel via `h` tag"
)]
DraftChannelRequired,
}
/// Convenience alias for `Result<T, DbError>`.
+60 -1
View File
@@ -2798,7 +2798,10 @@ impl Db {
/// kind:31234 draft wrap, the function checks — **inside the advisory lock,
/// before the stale-ordering step** — that the current head's `channel_id`
/// equals the incoming `channel_id`. If it differs the transaction is rolled
/// back and an `Err(DbError::DraftChannelMismatch)` is returned.
/// back and an `Err(DbError::DraftChannelMismatch)` is returned. An incoming
/// `channel_id` of `None` is also rejected with `Err(DbError::DraftChannelRequired)`
/// — every draft wrap must be bound to a channel via `h` tag, and a `None`
/// here means the caller bypassed the ingest validator.
///
/// The check is inferred from `event.kind` so no caller can supply a separate
/// "expected" value that differs from the "stored" value — the API is
@@ -2903,6 +2906,13 @@ impl Db {
// lock so the read-then-reject is atomic: no concurrent writer can slip a
// different-channel head between the SELECT and our rollback.
if buzz_core::kind::event_kind_u32(event) == buzz_core::kind::KIND_DRAFT {
// channel_id is required for all draft wraps. A None here means the
// caller bypassed the ingest validator (which enforces the `h` tag).
// Reject at the DB layer to keep the structural invariant self-contained.
if channel_id.is_none() {
tx.rollback().await?;
return Err(DbError::DraftChannelRequired);
}
if let Some((_, _, head_channel_id)) = &existing {
if *head_channel_id != channel_id {
tx.rollback().await?;
@@ -4484,4 +4494,53 @@ mod tests {
"live head must be bound to the winning channel"
);
}
/// Direct `replace_parameterized_event(channel_id = None)` for a kind:31234
/// draft must be rejected with `DraftChannelRequired`, regardless of whether
/// a head already exists. The DB-layer invariant must hold even when the
/// ingest pre-storage gate is bypassed.
#[tokio::test]
#[ignore = "requires Postgres"]
async fn draft_without_channel_id_is_rejected_at_db_layer() {
let db = setup_db().await;
let community = CommunityId::from_uuid(make_community(&db.pool).await);
let keys = nostr::Keys::generate();
let d_tag = Uuid::new_v4().to_string();
let ch = Uuid::new_v4();
let now = nostr::Timestamp::now().as_secs();
// First call: no existing head, channel_id = None.
let draft = build_test_draft_at(&keys, &d_tag, &ch, now);
let result = db
.replace_parameterized_event(community, &draft, &d_tag, None)
.await;
assert!(
matches!(result, Err(DbError::DraftChannelRequired)),
"first write with channel_id=None must return DraftChannelRequired; got: {result:?}"
);
// Verify no head was persisted.
let heads = query_draft_head(&db, community, &keys, &d_tag).await;
assert!(
heads.is_empty(),
"no head must be stored after DraftChannelRequired rejection"
);
// Second call: establish a real head first, then try channel_id = None
// update to confirm the None-reject fires before the mismatch check.
let (_, inserted) = db
.replace_parameterized_event(community, &draft, &d_tag, Some(ch))
.await
.expect("first write with channel_id = Some must succeed");
assert!(inserted, "first write must be a new insertion");
let update = build_test_draft_at(&keys, &d_tag, &ch, now + 1);
let result2 = db
.replace_parameterized_event(community, &update, &d_tag, None)
.await;
assert!(
matches!(result2, Err(DbError::DraftChannelRequired)),
"update with channel_id=None must return DraftChannelRequired even when head exists; got: {result2:?}"
);
}
}
+14 -8
View File
@@ -563,11 +563,11 @@ pub async fn get_thread_summary(
/// and never reaches the wire; callers must not re-derive exhaustion from row
/// counts (`rows < limit` proves nothing on an exact-multiple final page).
///
/// `author_pubkey`: when `Some`, author-only kinds (kind:31234 drafts,
/// kind:30300 reminders) are excluded for rows whose `pubkey` does not match.
/// Pass the authenticated requester's pubkey bytes on all bridge read paths.
/// `None` skips the filter (internal/test callers that don't need author-only
/// visibility control).
/// `author_pubkey`: when `Some`, author-only kinds (as listed in
/// `buzz_core::kind::AUTHOR_ONLY_KINDS`) are excluded for rows whose `pubkey`
/// does not match the requester. Pass the authenticated requester's pubkey bytes
/// on all bridge read paths. `None` skips the filter (internal/test callers
/// that don't need author-only visibility control).
pub async fn get_channel_window(
pool: &PgPool,
community_id: CommunityId,
@@ -638,10 +638,16 @@ pub async fn get_channel_window(
// leave those values pointing at or counting draft rows for non-authors.
if author_pubkey.is_some() {
let pk_idx = param_idx;
// KIND_AUTHOR_ONLY list kept in sync with buzz_core::kind::AUTHOR_ONLY_KINDS
// (30300 = KIND_EVENT_REMINDER, 31234 = KIND_DRAFT).
// Derive the exclusion list from AUTHOR_ONLY_KINDS (buzz_core) so that
// adding a new author-only kind in one place automatically extends this
// filter without a separate hardcoded list here.
let ao_list = buzz_core::kind::AUTHOR_ONLY_KINDS
.iter()
.map(|k| k.to_string())
.collect::<Vec<_>>()
.join(",");
sql.push_str(&format!(
" AND (e.kind NOT IN (30300, 31234) OR e.pubkey = ${pk_idx})"
" AND (e.kind NOT IN ({ao_list}) OR e.pubkey = ${pk_idx})"
));
param_idx += 1;
}
+47 -37
View File
@@ -846,10 +846,15 @@ pub async fn query_events(
if !event_in_accessible_channel(&se, &accessible_channels) {
continue;
}
// Defense-in-depth: never deliver a result-gated event (e.g. kind:44200
// or kind:30622) to a non-owner via the feed path, even though feed SQL
// kind allowlists already exclude these kinds.
if !buzz_core::filter::reader_authorized_for_event(&se.event, &authed_pubkey_hex) {
// Canonical per-event read gate: covers result-gated (p-owned) kinds
// and author-only kinds (e.g. kind:31234). Feed SQL kind allowlists
// exclude these kinds in practice, but this gate closes any future
// latent hole if the allowlist drifts.
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
if let Ok(v) = serde_json::to_value(&se.event) {
@@ -912,10 +917,15 @@ pub async fn query_events(
if !event_in_accessible_channel(&se, &accessible_channels) {
continue;
}
// Defense-in-depth: never deliver a result-gated event (e.g. kind:44200
// or kind:30622) to a non-owner via the thread path, even though
// requires_h_channel_scope already excludes these kinds from thread metadata.
if !buzz_core::filter::reader_authorized_for_event(&se.event, &authed_pubkey_hex) {
// Canonical per-event read gate: covers result-gated (p-owned) kinds
// and author-only kinds (e.g. kind:31234). Both guards are needed here
// even though requires_h_channel_scope already excludes these from thread
// metadata, because thread replies can reach this path through other routes.
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
if let Ok(v) = serde_json::to_value(&se.event) {
@@ -1006,17 +1016,15 @@ pub async fn query_events(
if !buzz_core::filter::filters_match(std::slice::from_ref(filter), &se) {
continue;
}
// Result-level read auth: never hand a viewer-private snapshot
// (kind:30622) to anyone but its owner, even via kindless `ids`.
if !buzz_core::filter::reader_authorized_for_event(
// Canonical per-event read gate: covers both result-gated (p-owned)
// and author-only kinds in a single call.
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes) {
continue;
}
if let Ok(v) = serde_json::to_value(&se.event) {
events.push(v);
}
@@ -1168,13 +1176,10 @@ pub async fn count_events(
{
continue;
}
if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes)
{
continue;
}
if !buzz_core::filter::reader_authorized_for_event(
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
@@ -1232,13 +1237,10 @@ pub async fn count_events(
{
continue;
}
if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes)
{
continue;
}
if !buzz_core::filter::reader_authorized_for_event(
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
@@ -1277,6 +1279,7 @@ fn search_hit_accepted(
stored: &buzz_core::StoredEvent,
accessible_channels: &[uuid::Uuid],
reader_pubkey_hex: &str,
reader_pubkey_bytes: &[u8],
) -> bool {
if !buzz_core::filter::filters_match(std::slice::from_ref(filter), stored) {
return false;
@@ -1286,7 +1289,11 @@ fn search_hit_accepted(
return false;
}
}
if !buzz_core::filter::reader_authorized_for_event(&stored.event, reader_pubkey_hex) {
if !buzz_core::filter::reader_can_receive_event(
&stored.event,
reader_pubkey_hex,
reader_pubkey_bytes,
) {
return false;
}
true
@@ -1410,10 +1417,13 @@ async fn handle_bridge_search(
Some(ev) => ev,
None => continue,
};
if !search_hit_accepted(filter, stored, accessible_channels, reader_pubkey_hex) {
continue;
}
if crate::handlers::req::is_author_only_event(&stored.event, pubkey_bytes) {
if !search_hit_accepted(
filter,
stored,
accessible_channels,
reader_pubkey_hex,
pubkey_bytes,
) {
continue;
}
// Dedup across filters.
@@ -2512,11 +2522,11 @@ mod tests {
// 30174 is not owner-gated, so any reader hex is fine here.
let reader = Keys::generate().public_key().to_hex();
assert!(
search_hit_accepted(&filter, &env_for_a, &[], &reader),
search_hit_accepted(&filter, &env_for_a, &[], &reader, &[]),
"envelope addressed to owner_a must be returned"
);
assert!(
!search_hit_accepted(&filter, &env_for_b, &[], &reader),
!search_hit_accepted(&filter, &env_for_b, &[], &reader, &[]),
"envelope addressed to owner_b must NOT be returned for a #p=[owner_a] search"
);
}
@@ -2539,9 +2549,9 @@ mod tests {
.author(agent_a.public_key());
let reader = Keys::generate().public_key().to_hex();
assert!(search_hit_accepted(&filter, &env_a, &[], &reader));
assert!(search_hit_accepted(&filter, &env_a, &[], &reader, &[]));
assert!(
!search_hit_accepted(&filter, &env_b, &[], &reader),
!search_hit_accepted(&filter, &env_b, &[], &reader, &[]),
"authors=[agent_a] search must not return events authored by agent_b"
);
}
@@ -2563,11 +2573,11 @@ mod tests {
let reader = Keys::generate().public_key().to_hex();
assert!(
!search_hit_accepted(&filter, &stored, &[], &reader),
!search_hit_accepted(&filter, &stored, &[], &reader, &[]),
"channel-scoped hit must be rejected when caller has no channel access"
);
assert!(
search_hit_accepted(&filter, &stored, &[scoped_channel], &reader),
search_hit_accepted(&filter, &stored, &[scoped_channel], &reader, &[]),
"channel-scoped hit must be accepted when caller has access to that channel"
);
}
@@ -2869,11 +2879,11 @@ mod tests {
let filter = nostr::Filter::new().id(ev.id);
assert!(
!search_hit_accepted(&filter, &stored, &[], &third_party),
!search_hit_accepted(&filter, &stored, &[], &third_party, &[]),
"third party must not receive a DM-visibility snapshot via kindless ids search"
);
assert!(
search_hit_accepted(&filter, &stored, &[], &viewer),
search_hit_accepted(&filter, &stored, &[], &viewer, &[]),
"owner must still receive their own snapshot"
);
}
+5 -9
View File
@@ -7,7 +7,7 @@ use tracing::warn;
use crate::connection::{AuthState, ConnectionState};
use crate::handlers::req::{
filter_can_match_result_gated_kinds, is_author_only_event, result_gated_count_safe_for_pushdown,
filter_can_match_result_gated_kinds, result_gated_count_safe_for_pushdown,
};
use crate::protocol::RelayMessage;
use crate::state::AppState;
@@ -187,12 +187,10 @@ pub async fn handle_count(
{
continue;
}
if is_author_only_event(&se.event, &pubkey_bytes) {
continue;
}
if !buzz_core::filter::reader_authorized_for_event(
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
@@ -257,12 +255,10 @@ pub async fn handle_count(
{
continue;
}
if is_author_only_event(&se.event, &pubkey_bytes) {
continue;
}
if !buzz_core::filter::reader_authorized_for_event(
if !buzz_core::filter::reader_can_receive_event(
&se.event,
&authed_pubkey_hex,
&pubkey_bytes,
) {
continue;
}
+242 -19
View File
@@ -12,14 +12,14 @@ use uuid::Uuid;
use buzz_auth::Scope;
use buzz_core::kind::{
event_kind_u32, is_identity_archive_request_kind, is_parameterized_replaceable,
is_relay_admin_kind, KIND_AGENT_ENGRAM, KIND_AGENT_PROFILE, KIND_AGENT_TURN_METRIC,
KIND_APPROVAL_DENY, KIND_APPROVAL_GRANT, KIND_AUTH, KIND_BOOKMARK_LIST, KIND_BOOKMARK_SET,
KIND_CANVAS, KIND_CONTACT_LIST, KIND_DELETION, KIND_DM_ADD_MEMBER, KIND_DM_HIDE, KIND_DM_OPEN,
KIND_DRAFT, KIND_EMOJI_LIST, KIND_EMOJI_SET, KIND_EVENT_REMINDER, KIND_FOLLOW_SET,
KIND_FORUM_COMMENT, KIND_FORUM_POST, KIND_FORUM_VOTE, KIND_GIFT_WRAP, KIND_GIT_ISSUE,
KIND_GIT_PATCH, KIND_GIT_PR_UPDATE, KIND_GIT_PULL_REQUEST, KIND_GIT_REPO_ANNOUNCEMENT,
KIND_GIT_REPO_STATE, KIND_GIT_STATUS_CLOSED, KIND_GIT_STATUS_DRAFT, KIND_GIT_STATUS_MERGED,
KIND_GIT_STATUS_OPEN, KIND_HUDDLE_ENDED, KIND_HUDDLE_GUIDELINES,
is_relay_admin_kind, AUTHOR_ONLY_KINDS, KIND_AGENT_ENGRAM, KIND_AGENT_PROFILE,
KIND_AGENT_TURN_METRIC, KIND_APPROVAL_DENY, KIND_APPROVAL_GRANT, KIND_AUTH, KIND_BOOKMARK_LIST,
KIND_BOOKMARK_SET, KIND_CANVAS, KIND_CONTACT_LIST, KIND_DELETION, KIND_DM_ADD_MEMBER,
KIND_DM_HIDE, KIND_DM_OPEN, KIND_DRAFT, KIND_EMOJI_LIST, KIND_EMOJI_SET, KIND_EVENT_REMINDER,
KIND_FOLLOW_SET, KIND_FORUM_COMMENT, KIND_FORUM_POST, KIND_FORUM_VOTE, KIND_GIFT_WRAP,
KIND_GIT_ISSUE, KIND_GIT_PATCH, KIND_GIT_PR_UPDATE, KIND_GIT_PULL_REQUEST,
KIND_GIT_REPO_ANNOUNCEMENT, KIND_GIT_REPO_STATE, KIND_GIT_STATUS_CLOSED, KIND_GIT_STATUS_DRAFT,
KIND_GIT_STATUS_MERGED, KIND_GIT_STATUS_OPEN, KIND_HUDDLE_ENDED, KIND_HUDDLE_GUIDELINES,
KIND_HUDDLE_PARTICIPANT_JOINED, KIND_HUDDLE_PARTICIPANT_LEFT, KIND_HUDDLE_STARTED,
KIND_IA_ARCHIVE_REQUEST, KIND_IA_UNARCHIVE_REQUEST, KIND_LONG_FORM, KIND_MANAGED_AGENT,
KIND_MEMBER_ADDED_NOTIFICATION, KIND_MEMBER_REMOVED_NOTIFICATION, KIND_MESH_LLM_RELAY_STATUS,
@@ -283,6 +283,13 @@ pub(crate) enum ReactionChannelResult {
}
/// Derive channel_id from the target event for NIP-25 reactions.
///
/// Author-only targets (kind:31234, kind:30300 — see `AUTHOR_ONLY_KINDS`) are
/// rejected for ALL actors, including the author themselves: a reaction writes
/// the draft id into a public kind:7 row, creating durable public state that
/// leaks the draft's existence. The caller receives `NotFound` regardless of
/// whether the actor authored the target, making the response byte-identical
/// to the missing-target branch — no oracle.
pub(crate) async fn derive_reaction_channel(
community_id: CommunityId,
db: &buzz_db::Db,
@@ -311,10 +318,19 @@ pub(crate) async fn derive_reaction_channel(
};
match db.get_event_by_id(community_id, &id_bytes).await {
Ok(Some(target)) => match target.channel_id {
Some(ch_id) => ReactionChannelResult::Channel(ch_id),
None => ReactionChannelResult::NoChannel,
},
Ok(Some(target)) => {
// Author-only targets (drafts, reminders) are rejected for everyone
// — including the author — because a successful reaction writes the
// draft id into a public kind:7 row (durable public state, id oracle).
// Return NotFound so the response is byte-identical to a random id.
if AUTHOR_ONLY_KINDS.contains(&event_kind_u32(&target.event)) {
return ReactionChannelResult::NotFound;
}
match target.channel_id {
Some(ch_id) => ReactionChannelResult::Channel(ch_id),
None => ReactionChannelResult::NoChannel,
}
}
Ok(None) => ReactionChannelResult::NotFound,
Err(e) => ReactionChannelResult::DbError(e.to_string()),
}
@@ -445,6 +461,20 @@ pub(crate) fn requires_h_channel_scope(kind: u32) -> bool {
)
}
/// Kinds that participate in NIP-10 thread metadata (reply chains, depth,
/// thread summaries, live-summary fan-out).
///
/// This is a strict subset of `requires_h_channel_scope`: all threaded kinds
/// must be channel-scoped, but NOT all channel-scoped kinds are threaded.
/// Kind:31234 draft wraps are channel-bound but are author-private and must
/// NOT participate in thread metadata — an outer thread reference would
/// expose the fact that a draft is a reply to a specific event, and the
/// live thread-summary side effect (`emit_live_thread_summary`) would
/// broadcast that information to channel subscribers.
pub(crate) fn participates_in_thread_metadata(kind: u32) -> bool {
requires_h_channel_scope(kind) && kind != KIND_DRAFT
}
/// Check channel membership: member OR open-visibility channel.
///
/// `channel` is the request's already-fetched channel row, when the caller has
@@ -571,6 +601,15 @@ pub(crate) async fn resolve_nip10_thread_meta(
.map_err(|e| format!("db error looking up parent: {e}"))?
.ok_or_else(|| "reply parent not found".to_string())?;
// Author-only targets (drafts, reminders) are rejected as thread parents
// for EVERYONE, including the author themselves: the NIP-10 thread metadata
// row (and the live thread-summary fan-out) would write the draft id into
// public state. Return the same not-found string so the response is
// byte-identical to the missing-parent branch — no oracle.
if AUTHOR_ONLY_KINDS.contains(&event_kind_u32(&parent_event.event)) {
return Err("reply parent not found".to_string());
}
match parent_event.channel_id {
Some(parent_ch) if parent_ch != channel_id => {
return Err("parent event belongs to a different channel".to_string());
@@ -718,6 +757,56 @@ pub(crate) fn effective_message_author(event: &Event, relay_pubkey: &nostr::Publ
event.pubkey.to_bytes().to_vec()
}
/// Post-lookup visibility predicate for e-tag target resolution on write paths.
///
/// Returns `Ok(true)` if `actor_bytes` may use `target_event` as an e-tag
/// reference target. Returns `Ok(false)` if the reference must be rejected
/// (caller uses its own site-specific not-found string for the error, so the
/// response is byte-identical to the missing-target branch).
///
/// **Public-reference paths** (reaction target, NIP-10 thread parent): caller
/// must reject for EVERYONE — pass `allow_author_reference: false`. An author-
/// only event written into a public row (kind:7, thread metadata) leaks the
/// draft id as durable public state; the author has no legitimate use case for
/// threading or reacting to their own draft either.
///
/// **Owner-mutation paths** (kind:5 e-tag deletion, stream-edit, forum-vote):
/// pass `allow_author_reference: true`. Non-authors/non-agent-owners receive
/// the byte-identical not-found mask; the author falls through to the site's
/// natural validation errors (tombstone-guidance for kind:5, etc.).
///
/// Generalizes over all `AUTHOR_ONLY_KINDS` (currently kind:31234 draft wraps
/// and kind:30300 reminders) so adding a new author-only kind in one place
/// automatically extends the mask here.
pub(crate) async fn actor_can_reference_target(
target_event: &buzz_core::StoredEvent,
actor_bytes: &[u8],
allow_author_reference: bool,
community_id: CommunityId,
state: &AppState,
) -> Result<bool, String> {
let target_kind = event_kind_u32(&target_event.event);
if !AUTHOR_ONLY_KINDS.contains(&target_kind) {
return Ok(true);
}
if allow_author_reference {
let target_author =
effective_message_author(&target_event.event, &state.relay_keypair.public_key());
if target_author == actor_bytes {
return Ok(true);
}
if state
.db
.is_agent_owner(community_id, &target_author, actor_bytes)
.await
.map_err(|e| format!("db error checking agent ownership: {e}"))?
{
return Ok(true);
}
}
Ok(false)
}
/// Validate kind:40003 edit ownership — event.pubkey must match target's effective author,
/// or the actor must be the owning human of the agent that authored the target message.
async fn validate_edit_ownership(
@@ -752,6 +841,14 @@ async fn validate_edit_ownership(
.map_err(|e| format!("db error: {e}"))?
.ok_or_else(|| "edit target event not found".to_string())?;
// Author-only targets (drafts, reminders): non-author/non-agent-owner receives
// "edit target event not found" (byte-identical to the missing-target branch —
// no oracle). The author falls through to the natural validation errors below.
let actor_bytes = event.pubkey.to_bytes().to_vec();
if !actor_can_reference_target(&target_event, &actor_bytes, true, community_id, state).await? {
return Err("edit target event not found".to_string());
}
// Verify target belongs to the same channel as the edit event.
let edit_channel_id = extract_channel_id(event);
match (edit_channel_id, target_event.channel_id) {
@@ -765,13 +862,12 @@ async fn validate_edit_ownership(
}
let author = effective_message_author(&target_event.event, &state.relay_keypair.public_key());
let actor = event.pubkey.to_bytes().to_vec();
if author == actor {
if author == actor_bytes {
// Author editing their own message: re-gate on membership/open visibility so that
// a removed private-channel member cannot mutate old messages after access is revoked.
if let Some(ch_id) = target_event.channel_id {
let is_member = state
.is_member_cached(community_id, ch_id, &actor)
.is_member_cached(community_id, ch_id, &actor_bytes)
.await
.map_err(|e| format!("db error checking membership: {e}"))?;
if !is_member {
@@ -790,7 +886,7 @@ async fn validate_edit_ownership(
// Allow the owning human to edit messages authored by their agent.
let is_owner = state
.db
.is_agent_owner(community_id, &author, &actor)
.is_agent_owner(community_id, &author, &actor_bytes)
.await
.map_err(|e| format!("db error checking agent ownership: {e}"))?;
if !is_owner {
@@ -833,6 +929,15 @@ async fn validate_forum_vote_target(
.map_err(|e| format!("db error: {e}"))?
.ok_or_else(|| "vote target event not found".to_string())?;
// Author-only targets (drafts, reminders): non-author/non-agent-owner receives
// "vote target event not found" (byte-identical to missing-target — no oracle).
// The author falls through; their draft fails the forum-post/comment kind check
// below with a natural validation error.
let actor_bytes = event.pubkey.to_bytes().to_vec();
if !actor_can_reference_target(&target_event, &actor_bytes, true, community_id, state).await? {
return Err("vote target event not found".to_string());
}
let target_kind = event_kind_u32(&target_event.event);
if target_kind != KIND_FORUM_POST && target_kind != KIND_FORUM_COMMENT {
return Err("vote target must be a forum post or comment".to_string());
@@ -1215,10 +1320,14 @@ fn validate_not_before(tag_value: &str) -> Result<u64, &'static str> {
/// this check only validates the tag's syntactic shape.
/// 4. No outer `p` tag — prevents this event from entering the mention/feed index.
/// Recipient/reply/edit details remain encrypted inside the payload.
/// 5. Non-empty content must be a syntactically plausible NIP-44 v2 ciphertext
/// 5. No outer `e` tag — thread-reference context (reply-to, root) belongs inside
/// the NIP-44 encrypted payload, not as plain outer metadata. An outer `e` tag
/// would be visible to anyone with relay access, leaking the fact that this draft
/// is a reply or edit of a specific event.
/// 6. Non-empty content must be a syntactically plausible NIP-44 v2 ciphertext
/// (reuses `validate_engram_nip44_content`). Empty content is the NIP-37
/// deletion tombstone and is explicitly valid.
/// 6. At most one `expiration` tag, whose value must be canonical ASCII decimal,
/// 7. At most one `expiration` tag, whose value must be canonical ASCII decimal,
/// strictly greater than both `event.created_at` and the relay's current time.
/// If present, it must be in the safe-integer range for JSON interoperability.
fn validate_draft_wrap_envelope(event: &Event) -> Result<(), String> {
@@ -1258,6 +1367,11 @@ fn validate_draft_wrap_envelope(event: &Event) -> Result<(), String> {
.to_string(),
);
}
"e" => {
return Err("draft-wrap event must not have an outer `e` tag \
(thread-reference context belongs inside the encrypted payload)"
.to_string());
}
"expiration" => {
expiration_count += 1;
expiration_value = Some(&parts[1]);
@@ -2256,7 +2370,7 @@ async fn ingest_event_inner(
.map_err(|e| IngestError::Rejected(format!("invalid: {e}")))?;
}
let thread_meta = if requires_h_channel_scope(kind_u32) {
let thread_meta = if participates_in_thread_metadata(kind_u32) {
if let Some(ch_id) = channel_id {
resolve_nip10_thread_meta(tenant.community(), &event, ch_id, state)
.await
@@ -3885,6 +3999,23 @@ mod tests {
);
}
#[test]
fn draft_wrap_does_not_participate_in_thread_metadata() {
// Draft wraps must NOT participate in NIP-10 thread metadata.
// An outer reply/root `e` tag on a draft would expose that the draft is
// a reply to a specific event; the live-summary fan-out would broadcast
// that information to channel subscribers, breaking author-privacy.
assert!(
!participates_in_thread_metadata(KIND_DRAFT),
"KIND_DRAFT must be excluded from thread-metadata processing"
);
// Sanity: a plain channel message DOES participate.
assert!(
participates_in_thread_metadata(KIND_STREAM_MESSAGE),
"KIND_STREAM_MESSAGE must participate in thread metadata (positive control)"
);
}
#[test]
fn draft_wrap_is_not_global_only() {
// Draft wraps have a required `h` tag — they are channel-scoped, not global.
@@ -4001,4 +4132,96 @@ mod tests {
"expected canonical/lowercase/UUID rejection, got: {err}"
);
}
/// Outer `e` tags on a draft wrap must be rejected: thread-reference context
/// (reply-to, root-event) belongs inside the NIP-44 encrypted payload, not as
/// plain outer metadata visible to any relay reader.
#[test]
fn draft_wrap_rejects_outer_e_tag() {
let d = uuid::Uuid::new_v4().to_string();
let ch = uuid::Uuid::new_v4().to_string();
let target_id = hex::encode([0u8; 32]);
let ev = make_draft(
&[&["d", &d], &["k", "9"], &["h", &ch], &["e", &target_id]],
&fake_nip44_v2(),
);
let err = validate_draft_wrap_envelope(&ev).unwrap_err();
assert!(
err.contains("`e` tag") || err.contains("e tag"),
"expected outer-e-tag rejection, got: {err}"
);
}
// ── actor_can_reference_target: author-only mask ───────────────────────────
// These unit tests verify that `actor_can_reference_target` masks kind:31234
// (draft wraps) and kind:30300 (reminders) — all `AUTHOR_ONLY_KINDS` — without
// requiring a live Postgres. The helper is the single seam that closes the
// write-path id-oracle on reaction, thread-parent, stream-edit, forum-vote,
// and kind:5 e-tag deletion paths.
#[test]
fn author_only_kinds_covers_draft_and_reminder() {
// AUTHOR_ONLY_KINDS must contain both KIND_DRAFT and KIND_EVENT_REMINDER.
// actor_can_reference_target derives its mask from this constant, so any
// author-only kind not in the list escapes the guard.
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&buzz_core::kind::KIND_DRAFT),
"AUTHOR_ONLY_KINDS must contain KIND_DRAFT (31234)"
);
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&buzz_core::kind::KIND_EVENT_REMINDER),
"AUTHOR_ONLY_KINDS must contain KIND_EVENT_REMINDER (30300)"
);
// Positive control: a non-author-only kind must NOT be in the list.
let kind_channel_msg: u32 = 9;
assert!(
!buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&kind_channel_msg),
"kind:9 must NOT be in AUTHOR_ONLY_KINDS (positive control)"
);
}
#[test]
fn derive_reaction_channel_masks_draft_target() {
// derive_reaction_channel returns NotFound for a stored draft target —
// it must never return Channel/NoChannel and allow the reaction to proceed.
//
// We test via participates_in_thread_metadata / AUTHOR_ONLY_KINDS membership
// since derive_reaction_channel is async and uses the DB. The logic is:
// `if AUTHOR_ONLY_KINDS.contains(&event_kind_u32(&target.event)) => NotFound`
// so this test verifies the constant + kind function used by the guard.
let kind_val = buzz_core::kind::KIND_DRAFT;
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&kind_val),
"KIND_DRAFT must be in AUTHOR_ONLY_KINDS — derive_reaction_channel \
relies on this to return NotFound for draft targets"
);
let reminder_kind = buzz_core::kind::KIND_EVENT_REMINDER;
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&reminder_kind),
"KIND_EVENT_REMINDER must be in AUTHOR_ONLY_KINDS — derive_reaction_channel \
also masks reminders (Q15 generalizes over all AUTHOR_ONLY_KINDS)"
);
}
#[test]
fn resolve_nip10_thread_meta_masks_draft_parent() {
// participates_in_thread_metadata(KIND_DRAFT) must be false — draft kinds
// are excluded from NIP-10 thread metadata processing. The Q15 guard
// in resolve_nip10_thread_meta uses AUTHOR_ONLY_KINDS; this test verifies
// the membership that drives it.
assert!(
!participates_in_thread_metadata(KIND_DRAFT),
"KIND_DRAFT must not participate in thread metadata"
);
// The AUTHOR_ONLY_KINDS membership check gates the explicit not-found
// masking added in Q15. Verify both draft and reminder are covered.
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&KIND_DRAFT),
"KIND_DRAFT must be in AUTHOR_ONLY_KINDS for the Q15 not-found mask"
);
assert!(
buzz_core::kind::AUTHOR_ONLY_KINDS.contains(&buzz_core::kind::KIND_EVENT_REMINDER),
"KIND_EVENT_REMINDER must be in AUTHOR_ONLY_KINDS for the Q15 not-found mask"
);
}
}
+12 -24
View File
@@ -368,16 +368,14 @@ pub async fn handle_req(
}
}
// Result-level read auth: a viewer-private snapshot (kind:30622) is
// delivered only to its owner, even if reached via a kindless
// `ids:[…]` subscription that skips the filter-level `#p` gate.
if !buzz_core::filter::reader_authorized_for_event(&stored.event, &viewer_hex) {
continue;
}
// Author-only kinds: only the event author may see these events.
// Mixed-kind filters still serve other kinds normally.
if is_author_only_event(&stored.event, &pubkey_bytes) {
// Canonical per-event read gate: covers result-gated (p-owned) kinds
// and author-only kinds in a single call so no delivery surface can
// accidentally omit half the privacy model.
if !buzz_core::filter::reader_can_receive_event(
&stored.event,
&viewer_hex,
&pubkey_bytes,
) {
continue;
}
@@ -693,15 +691,13 @@ async fn handle_search_req(
continue;
}
}
if !buzz_core::filter::reader_authorized_for_event(
if !buzz_core::filter::reader_can_receive_event(
&stored.event,
reader_pubkey_hex,
reader_pubkey_bytes,
) {
continue;
}
if is_author_only_event(&stored.event, reader_pubkey_bytes) {
continue;
}
// Dedup AFTER acceptance — an event that fails filter A's constraints
// must remain eligible for filter B (NIP-01 OR semantics).
if !seen_ids.insert(stored.event.id) {
@@ -1132,7 +1128,7 @@ pub(crate) fn filter_can_match_result_gated_kinds(filter: &Filter) -> bool {
/// `{kinds:[44200], #p:[self]}`.
///
/// When this returns `false`, the COUNT handler MUST use the per-event fallback
/// and apply `reader_authorized_for_event` on each row.
/// and apply `reader_can_receive_event` on each row.
pub(crate) fn result_gated_count_safe_for_pushdown(
filter: &Filter,
authed_pubkey_hex: &str,
@@ -1144,14 +1140,6 @@ pub(crate) fn result_gated_count_safe_for_pushdown(
.is_some_and(|values| !values.is_empty() && values.iter().all(|v| v == authed_pubkey_hex))
}
/// Returns `true` if the event is an author-only kind and the requester is NOT
/// the author. Used as a per-event filter during historical delivery and fan-out
/// to silently omit unauthorized events from mixed-kind result sets.
pub(crate) fn is_author_only_event(event: &nostr::Event, requester_pubkey_bytes: &[u8]) -> bool {
let kind_u32 = event.kind.as_u16() as u32;
AUTHOR_ONLY_KINDS.contains(&kind_u32) && event.pubkey.to_bytes() != requester_pubkey_bytes
}
/// Pre-filter authorization for filters that exclusively target author-only kinds.
///
/// If a filter targets ONLY author-only kinds (e.g. `{kinds:[30300]}`), the
@@ -1438,7 +1426,7 @@ mod tests {
// Case 2: kindless {ids:[...]} — the existing ids exemption applies
// at this filter-authorization gate (consistent with other p-gated kinds).
// The kindless path is closed at the result level by
// `reader_authorized_for_event` (buzz-core/src/filter.rs), which gates
// `reader_can_receive_event` (buzz-core/src/filter.rs), which gates
// kind:44200 delivery to the #p owner across all pull paths (WS historical,
// HTTP bridge) and live fan-out. Pass-through here is correct; the
// result-level gate is the enforcement point for this path.
+45 -20
View File
@@ -216,6 +216,36 @@ pub async fn validate_standard_deletion_event(
.await?
.ok_or_else(|| anyhow::anyhow!("target event not found"))?;
// Author-only kinds (drafts, reminders): mask existence for non-authors.
// The authz check below produces "must be event author" for a real event
// vs "target event not found" for a random id — that differential IS an
// oracle. Placing the author-only check before authz ensures that a
// non-author/non-agent-owner receives "target event not found" regardless,
// collapsing the oracle. The author falls through to the informative
// tombstone-guidance error below.
if buzz_core::kind::AUTHOR_ONLY_KINDS
.contains(&buzz_core::kind::event_kind_u32(&target_event.event))
{
let draft_author =
effective_message_author(&target_event.event, &state.relay_keypair.public_key());
let is_owner = state
.db
.is_agent_owner(tenant.community(), &draft_author, &actor_bytes)
.await
.unwrap_or(false);
if draft_author != actor_bytes && !is_owner {
// Non-author: respond byte-identical to the missing-target branch.
return Err(anyhow::anyhow!("target event not found"));
}
// Author or agent-owner: informative tombstone-guidance error.
return Err(anyhow::anyhow!(
"NIP-09 e-tag deletion of kind:{} events is not supported; \
use an empty-content tombstone (kind:{} with empty content) instead",
buzz_core::kind::event_kind_u32(&target_event.event),
buzz_core::kind::event_kind_u32(&target_event.event),
));
}
let target_author =
effective_message_author(&target_event.event, &state.relay_keypair.public_key());
if target_author != actor_bytes
@@ -226,20 +256,6 @@ pub async fn validate_standard_deletion_event(
{
return Err(anyhow::anyhow!("must be event author"));
}
// NIP-37: kind:5 e-tag deletion of kind:31234 draft wraps is not
// supported. Accepting it would erase the live head row, enabling a
// subsequent write to rebind the immutable (community, author, kind, d)
// address to a different channel. The correct deletion mechanism is an
// empty-content tombstone (kind:31234 with "" content).
// Check is placed after authz so the relay does not reveal draft
// existence to callers who do not own the target event.
if event_kind_u32(&target_event.event) == KIND_DRAFT {
return Err(anyhow::anyhow!(
"NIP-09 e-tag deletion of kind:31234 draft wraps is not supported; \
use an empty-content tombstone (kind:31234 with empty content) instead"
));
}
}
Ok(())
@@ -2030,12 +2046,21 @@ async fn handle_a_tag_deletion(
let actor_bytes = effective_message_author(event, &state.relay_keypair.public_key());
match kind_num {
// NIP-37 draft wraps use an empty-content tombstone (kind:31234 with ""
// content) for deletion — they do NOT use NIP-09 a-tag soft-deletion.
// Accepting a NIP-09 a-tag soft-delete would erase the head row, after
// which a different-channel write would see no existing head and bypass
// the immutable-binding invariant. Reject with an error so the
// caller can surface it as a validation failure.
// Defensive guard: draft wraps (kind:31234) do NOT use NIP-09 a-tag
// soft-deletion — they use an empty-content tombstone (a replacement
// write with empty content) instead. Accepting an a-tag soft-delete
// would erase the head row and allow a different-channel write to
// rebind the (author, d_tag) address, breaking the immutable-binding
// invariant.
//
// This branch is unreachable via normal ingest: the pre-storage gate at
// `ingest.rs` rejects any NIP-09 kind:5 event whose a-tag targets
// kind:31234 before it is ever stored. This guard is a second-line
// defensive check in case side_effects is called from a future path
// that bypasses the pre-storage gate. It does NOT surface as a
// client-facing validation error — errors returned by side-effect
// handlers after storage are logged only (callers do not propagate
// them to the client).
buzz_core::kind::KIND_DRAFT => {
return Err(anyhow::anyhow!(
"NIP-09 a-tag deletion of kind:31234 draft wraps is not supported; \
+486 -12
View File
@@ -754,6 +754,35 @@ async fn test_draft_rejected_p_tag() {
assert!(msg.contains("p` tag"), "unexpected message: {msg}");
}
#[tokio::test]
#[ignore]
async fn test_draft_rejected_outer_e_tag() {
// Smoke test: outer `e` tag on a kind:31234 event must be rejected.
// Thread-reference context (reply-to, root) belongs inside the NIP-44
// encrypted payload — plain outer `e` tags would expose the fact that
// this draft is a reply/edit of a specific event to any relay reader.
let client = http_client();
let owner = Keys::generate();
let ch_id = create_open_channel(&owner).await;
let d = uuid::Uuid::new_v4().to_string();
let target_id = "0".repeat(64); // 64-char hex string representing a nonexistent event id
let event = nostr::EventBuilder::new(nostr::Kind::Custom(KIND_DRAFT), fake_nip44_v2())
.tags([
nostr::Tag::parse(["d", &d]).unwrap(),
nostr::Tag::parse(["k", "9"]).unwrap(),
nostr::Tag::parse(["h", &ch_id]).unwrap(),
nostr::Tag::parse(["e", &target_id]).unwrap(),
])
.sign_with_keys(&owner)
.unwrap();
let (accepted, msg) = submit_event_http(&client, &owner, &event).await;
assert!(!accepted, "outer `e` tag on draft should be rejected");
assert!(
msg.contains("e` tag") || msg.contains("e tag"),
"unexpected rejection message: {msg}"
);
}
#[tokio::test]
#[ignore]
async fn test_draft_rejected_malformed_ciphertext() {
@@ -1521,6 +1550,66 @@ async fn test_draft_author_can_count_own_drafts_http() {
assert!(count >= 1, "author must count at least 1 own draft");
}
#[tokio::test]
#[ignore]
async fn test_draft_attacker_mixed_kinds_count_excludes_drafts() {
// A mixed-kinds COUNT filter (e.g. kinds=[9,31234]) from a non-author must
// count only the public events — the kind:31234 draft must not be included.
// This exercises the per-event fallback path in handle_count where the
// reader_can_receive_event gate runs for each row in a mixed-kinds result.
let client = http_client();
let victim = Keys::generate();
let attacker = Keys::generate();
let ch_id = create_open_channel(&victim).await;
let d = uuid::Uuid::new_v4().to_string();
// Victim submits one kind:9 channel message and one kind:31234 draft.
let msg = EventBuilder::new(Kind::Custom(9), "hello")
.tags([Tag::parse(["h", &ch_id]).unwrap()])
.sign_with_keys(&victim)
.unwrap();
let (ok_m, err_m) = submit_event_http(&client, &victim, &msg).await;
assert!(ok_m, "kind:9 message must be accepted: {err_m}");
let draft = build_draft(&victim, &d, "9", &ch_id, &fake_nip44_v2());
let (ok_d, err_d) = submit_event_http(&client, &victim, &draft).await;
assert!(ok_d, "draft must be accepted: {err_d}");
// Attacker COUNTs with a mixed kinds=[9,31234] filter via HTTP /count.
// Should be allowed (kindless-mixed filter is not exclusively author-only)
// but the kind:31234 must be excluded from the count.
let url = relay_url();
let filter = serde_json::json!({
"kinds": [9, KIND_DRAFT],
"authors": [victim.public_key().to_hex()],
});
let resp = client
.post(format!(
"{}/count",
url.replace("ws://", "http://")
.replace("wss://", "https://")
))
.header("X-Pubkey", &attacker.public_key().to_hex())
.header("Content-Type", "application/json")
.json(&vec![filter])
.send()
.await
.expect("count request");
assert!(
resp.status().is_success(),
"mixed-kinds /count must succeed for attacker, got: {}",
resp.status()
);
let body: Value = resp.json().await.expect("parse count response");
let count = body["count"].as_u64().unwrap_or(0);
// The attacker sees at most 1 (the kind:9 message). The kind:31234 draft
// must NOT be included.
assert!(
count <= 1,
"mixed-kinds count for non-author must not include kind:31234 drafts; got count={count}"
);
}
// ─── HTTP /query exclusive-author privacy ────────────────────────────────────
#[tokio::test]
@@ -1627,6 +1716,53 @@ async fn test_draft_live_fanout_only_reaches_author() {
ac.disconnect().await.expect("disconnect");
}
#[tokio::test]
#[ignore]
async fn test_draft_live_fanout_reaches_author_own_subscription() {
// Positive-control companion to test_draft_live_fanout_only_reaches_author:
// the AUTHOR themselves MUST receive their own draft via live fan-out when
// they have an active subscription for it. This proves the author-only
// gate is a filter (not a kill-switch) and doesn't silently break delivery
// to the author.
let url = relay_url();
let client = http_client();
let author = Keys::generate();
let ch_id = create_open_channel(&author).await;
let d = uuid::Uuid::new_v4().to_string();
// Author opens a subscription with limit:0 (skip historical, live only).
let mut ac = BuzzTestClient::connect(&url, &author)
.await
.expect("connect author");
let sid = sub_id("fanout-author-self");
let filter = Filter::new()
.kind(Kind::Custom(KIND_DRAFT))
.author(author.public_key())
.limit(0);
ac.subscribe(&sid, vec![filter])
.await
.expect("subscribe author draft filter");
let _ = ac.collect_until_eose(&sid, Duration::from_secs(3)).await;
// Author submits their own draft.
let draft = build_draft(&author, &d, "9", &ch_id, &fake_nip44_v2());
let draft_id = draft.id;
let (ok, msg) = submit_event_http(&client, &author, &draft).await;
assert!(ok, "author's draft must be accepted: {msg}");
// Author's own subscription must deliver the draft via fan-out.
let received = ac
.recv_event(Duration::from_secs(5))
.await
.expect("author must receive their own draft via fan-out");
let got_draft = matches!(&received, RelayMessage::Event { event, .. } if event.id == draft_id);
assert!(
got_draft,
"author's own subscription must receive their draft via live fan-out; got: {received:?}"
);
ac.disconnect().await.expect("disconnect");
}
// ─── Nonexistent / alien channel rejection ────────────────────────────────────
// NOTE: test_draft_rejected_nonexistent_channel_h_tag (at the top of this file)
@@ -1697,14 +1833,76 @@ async fn test_draft_not_returned_in_kindless_channel_query_by_attacker() {
#[tokio::test]
#[ignore]
async fn test_draft_not_indexed_in_fts_search() {
// A kind:31234 has NULL search_tsv at the storage layer, so NIP-50 search
// must never surface it — even when the requester is the author.
async fn test_draft_not_returned_in_kindless_channel_http_query() {
// HTTP bridge catchall /query mirror of the WS kindless h-tag test above.
// Exercises bridge.rs catchall path (distinct from req.rs), proving the
// reader_can_receive_event gate is live there.
//
// The test explicitly uses kinds=[1,31234] in the search filter so the query
// cannot be satisfied by the read-gate alone: if kind:31234 had a non-NULL
// tsvector matching the token, the relay would return it to the authorized
// author. NULL tsvector is the only thing that hides it.
// Non-author queries the channel with a kindless h-tag filter via HTTP
// /query. Kind:9 message must appear (positive control); kind:31234 draft
// must be absent.
let client = http_client();
let owner = Keys::generate();
let attacker = Keys::generate();
let ch_id = create_open_channel(&owner).await;
let d = uuid::Uuid::new_v4().to_string();
let draft = build_draft(&owner, &d, "9", &ch_id, &fake_nip44_v2());
let draft_id = draft.id;
let (ok, msg) = submit_event_http(&client, &owner, &draft).await;
assert!(ok, "draft must be accepted: {msg}");
// Publish a public channel message for use as a positive control.
let msg_event = EventBuilder::new(Kind::Custom(9), "hello http channel")
.tags([Tag::parse(["h", &ch_id]).unwrap()])
.sign_with_keys(&owner)
.unwrap();
let msg_id = msg_event.id;
let (ok_m, msg_m) = submit_event_http(&client, &owner, &msg_event).await;
assert!(ok_m, "channel message must be accepted: {msg_m}");
// Kindless h-tag filter over HTTP /query as non-author.
let kindless_filter = Filter::new().custom_tag(
nostr::SingleLetterTag::lowercase(nostr::Alphabet::H),
ch_id.as_str(),
);
let results = query_events_http(
&client,
&attacker.public_key().to_hex(),
vec![kindless_filter],
)
.await;
// Kind:9 message must appear — proves the subscription is live.
assert!(
results
.iter()
.any(|e| e["id"].as_str() == Some(&msg_id.to_hex())),
"kind:9 channel message must appear in HTTP kindless query (positive control)"
);
// Draft must be absent — bridge.rs catchall author-only gate must suppress it.
assert!(
!results
.iter()
.any(|e| e["id"].as_str() == Some(&draft_id.to_hex())),
"kind:31234 draft must not appear in non-author HTTP kindless channel query"
);
}
#[tokio::test]
#[ignore]
async fn test_draft_not_indexed_in_fts_search() {
// Proves the search surface returns no drafts: the HTTP /query search path
// is exercised with a mixed kinds=[1,31234] filter, and the kind:31234 is
// absent from results.
//
// This test CANNOT prove the NULL-tsvector storage guarantee by itself:
// draft content is a NIP-44 ciphertext, so the search token could never
// appear in stored content regardless of the tsvector column. The
// storage-layer guarantee (search_tsv = NULL for all kind:31234 rows) is
// owned by `crates/buzz-search/tests/fts_integration.rs`. This e2e test
// only proves the search read-path returns no draft rows — a necessary
// complement that exercises the HTTP bridge search branch end-to-end.
let client = http_client();
let victim = Keys::generate();
let attacker = Keys::generate();
@@ -1723,16 +1921,17 @@ async fn test_draft_not_indexed_in_fts_search() {
let (ok_note, msg_note) = submit_event_http(&client, &victim, &note).await;
assert!(ok_note, "control note must be accepted: {msg_note}");
// Kind:31234 draft — NIP-44 v2 content (relay validates). Storage migration
// sets search_tsv = NULL for all kind:31234 rows, so even a theoretically
// searchable payload must not surface in FTS results.
// Kind:31234 draft — NIP-44 v2 content (relay validates). The draft
// content is a ciphertext and cannot contain the plaintext token; the
// search_tsv is also NULL at the storage layer (fts_integration.rs owns
// that guarantee). Either property would prevent this draft from surfacing.
let draft = build_draft(&victim, &d, "9", &ch_id, &fake_nip44_v2());
let draft_id = draft.id;
let (ok_d, msg_d) = submit_event_http(&client, &victim, &draft).await;
assert!(ok_d, "draft must be accepted: {msg_d}");
// Search as the author with explicit kinds=[1,31234]. The kind:31234 draft
// is excluded by NULL search_tsv; the kind:1 note IS found.
// Search as the author with explicit kinds=[1,31234]. The kind:1 note IS
// found (positive control); the kind:31234 draft is absent.
let search_filter = Filter::new()
.kinds(vec![Kind::TextNote, Kind::Custom(KIND_DRAFT)])
.search(&token)
@@ -2259,6 +2458,101 @@ async fn test_draft_accepted_and_replaced_in_dm_channel() {
);
}
#[tokio::test]
#[ignore]
async fn test_dm_draft_not_readable_by_dm_recipient() {
// Regression guard (Q13): Alice opens a DM with Bob and writes a draft to
// that DM channel. Bob (the DM recipient and channel member) must NOT be
// able to read Alice's draft — drafts are author-only regardless of
// channel membership. The test queries from Bob's perspective to prove
// the author-only guard fires on the recipient-side, not just on arbitrary
// third parties.
let client = http_client();
let alice = Keys::generate();
let bob = Keys::generate();
// Alice opens a DM with Bob — relay creates the DM channel UUID.
let dm_event = EventBuilder::new(Kind::Custom(41010), "")
.tags([Tag::parse(["p", &bob.public_key().to_hex()]).unwrap()])
.sign_with_keys(&alice)
.unwrap();
let resp = client
.post(format!("{}/events", relay_http_url()))
.header("X-Pubkey", &alice.public_key().to_hex())
.header("Content-Type", "application/json")
.body(serde_json::to_string(&dm_event).unwrap())
.send()
.await
.expect("open DM");
let body: Value = resp.json().await.expect("parse DM response");
assert!(
body["accepted"].as_bool().unwrap_or(false),
"DM open must be accepted: {body}"
);
let msg = body["message"].as_str().unwrap_or("");
let dm_channel_id = if let Some(stripped) = msg.strip_prefix("response:") {
let parsed: Value = serde_json::from_str(stripped).expect("response JSON");
parsed["channel_id"]
.as_str()
.expect("channel_id in DM response")
.to_string()
} else {
panic!("DM open response must contain channel_id; got: {msg:?}");
};
// Alice writes a draft to the DM channel.
let d = uuid::Uuid::new_v4().to_string();
let draft = build_draft(&alice, &d, "9", &dm_channel_id, &fake_nip44_v2());
let draft_id = draft.id;
let (ok, err) = submit_event_http(&client, &alice, &draft).await;
assert!(ok, "Alice's draft must be accepted: {err}");
// Bob queries the DM channel as a member (recipient-side query).
// He should NOT see Alice's draft — drafts are author-only.
let filter = Filter::new()
.kind(Kind::Custom(KIND_DRAFT))
.author(alice.public_key())
.custom_tag(
nostr::SingleLetterTag::lowercase(nostr::Alphabet::D),
d.as_str(),
);
let resp2 = client
.post(format!("{}/query", relay_http_url()))
.header("X-Pubkey", &bob.public_key().to_hex())
.header("Content-Type", "application/json")
.json(&vec![filter])
.send()
.await
.expect("Bob query");
assert_eq!(
resp2.status().as_u16(),
403,
"Bob (DM recipient) must get 403 querying Alice's draft; got: {}",
resp2.status()
);
// Verify Alice herself can still read it (positive control).
let filter2 = Filter::new()
.kind(Kind::Custom(KIND_DRAFT))
.author(alice.public_key())
.custom_tag(
nostr::SingleLetterTag::lowercase(nostr::Alphabet::D),
d.as_str(),
);
let alice_results =
query_events_http(&client, &alice.public_key().to_hex(), vec![filter2]).await;
assert_eq!(
alice_results.len(),
1,
"Alice must be able to read her own DM draft (positive control)"
);
assert_eq!(
alice_results[0]["id"].as_str().unwrap(),
draft_id.to_hex(),
"Alice's query must return her draft"
);
}
// ─── Removed-member read denial ──────────────────────────────────────────────
#[tokio::test]
@@ -2579,3 +2873,183 @@ async fn test_channel_window_draft_visible_to_author() {
"exactly one 39006 bounds overlay required: {events:?}"
);
}
/// Q16: channel-window cursor-boundary variant.
///
/// Posts more messages than the `limit` so the window response includes a
/// `next_cursor`, then verifies:
/// 1. `next_cursor` ids never contain a draft id (draft-excluded row set).
/// 2. Paginating with the cursor returns only public messages and remains gapless.
/// 3. Drafts are excluded from both pages and from every id in the overlay.
///
/// This is the exact mutate-bite scenario the whole review run hunted:
/// a future regression that moves the author-only filter after pagination
/// would either leak a draft id in `next_cursor` or create a gap on page 2.
#[tokio::test]
#[ignore]
async fn test_channel_window_cursor_boundary_excludes_draft() {
let client = http_client();
let author = Keys::generate();
let attacker = Keys::generate();
let ch_id = create_open_channel(&author).await;
add_member_http(&client, &author, &ch_id, &attacker).await;
// Post 3 public kind:9 messages with strictly increasing timestamps.
// Then post a draft between message 1 and 2 (same second as msg-1 so it
// sits in the middle of the window) to make it straddle the cursor
// boundary when limit=2.
let base_ts = nostr::Timestamp::now().as_secs() - 10;
let mut msg_ids = Vec::new();
for i in 0..3u64 {
let ts = nostr::Timestamp::from(base_ts + i * 2); // spread 0, 2, 4 seconds
let msg = nostr::EventBuilder::new(nostr::Kind::Custom(9), format!("msg-{i}"))
.tags([nostr::Tag::parse(["h", &ch_id]).unwrap()])
.custom_created_at(ts)
.sign_with_keys(&author)
.unwrap();
msg_ids.push(msg.id.to_hex());
let (ok, err) = submit_event_http(&client, &author, &msg).await;
assert!(ok, "kind:9 message {i} must be accepted: {err}");
}
// Post a draft with a timestamp between msg-0 and msg-1 so it lands in
// the middle of the window (created_at = base_ts + 1).
let d = uuid::Uuid::new_v4().to_string();
let draft_ts = nostr::Timestamp::from(base_ts + 1);
let draft = nostr::EventBuilder::new(nostr::Kind::Custom(KIND_DRAFT), fake_nip44_v2())
.tags([
nostr::Tag::parse(["d", &d]).unwrap(),
nostr::Tag::parse(["k", "9"]).unwrap(),
nostr::Tag::parse(["h", &ch_id]).unwrap(),
])
.custom_created_at(draft_ts)
.sign_with_keys(&author)
.unwrap();
let draft_id = draft.id.to_hex();
let (ok_d, err_d) = submit_event_http(&client, &author, &draft).await;
assert!(ok_d, "draft must be accepted: {err_d}");
// Page 1: limit=2 as the attacker. Response must have has_more=true and a
// next_cursor. No draft id must appear anywhere (rows, overlay, aux).
let page1_filter = serde_json::json!({
"kinds": [9, KIND_DRAFT],
"#h": [ch_id],
"top_level": true,
"limit": 2,
"include_aux": true,
"include_summaries": false,
});
let resp1 = client
.post(format!("{}/query", relay_http_url()))
.header("X-Pubkey", &attacker.public_key().to_hex())
.header("Content-Type", "application/json")
.body(serde_json::to_string(&serde_json::json!([page1_filter])).unwrap())
.send()
.await
.expect("page 1 window query");
assert!(resp1.status().is_success(), "page 1 must succeed");
let page1_events: Vec<Value> = resp1.json().await.expect("page 1 parse");
// Collect all ids present in page 1 (rows + overlays + aux).
let page1_ids: Vec<String> = page1_events
.iter()
.flat_map(|e| {
let mut ids = vec![];
if let Some(id) = e["id"].as_str() {
ids.push(id.to_string());
}
// 39006 overlay content may embed next_cursor.id — check content too.
if e["kind"].as_u64() == Some(39006) {
if let Some(content_str) = e["content"].as_str() {
if let Ok(content) = serde_json::from_str::<Value>(content_str) {
if let Some(cursor_id) = content
.get("next_cursor")
.and_then(|c| c.get("id"))
.and_then(|v| v.as_str())
{
ids.push(cursor_id.to_string());
}
}
}
}
ids
})
.collect();
assert!(
!page1_ids.iter().any(|id| id == &draft_id),
"draft id must not appear anywhere in page 1: draft_id={draft_id}, page1={page1_events:?}"
);
// Extract next_cursor from the 39006 overlay.
let overlay1 = page1_events
.iter()
.find(|e| e["kind"].as_u64() == Some(39006));
let cursor = overlay1.and_then(|o| {
let content: Value = serde_json::from_str(o["content"].as_str()?).ok()?;
let has_more = content["has_more"].as_bool().unwrap_or(false);
if !has_more {
return None;
}
let cursor_ts = content["next_cursor"]["created_at"].as_i64()?;
let cursor_id = content["next_cursor"]["id"].as_str()?.to_string();
Some((cursor_ts, cursor_id))
});
// If the relay returned has_more=true and a cursor, paginate to page 2
// and verify the second page also contains no draft id.
if let Some((cursor_ts, cursor_id)) = cursor {
// The cursor must not be the draft id.
assert_ne!(
cursor_id, draft_id,
"next_cursor.id must not be the draft id — cursor must be computed on the \
draft-excluded row set"
);
let page2_filter = serde_json::json!({
"kinds": [9, KIND_DRAFT],
"#h": [ch_id],
"top_level": true,
"limit": 2,
"until": cursor_ts,
"before_id": cursor_id,
"include_aux": true,
"include_summaries": false,
});
let resp2 = client
.post(format!("{}/query", relay_http_url()))
.header("X-Pubkey", &attacker.public_key().to_hex())
.header("Content-Type", "application/json")
.body(serde_json::to_string(&serde_json::json!([page2_filter])).unwrap())
.send()
.await
.expect("page 2 window query");
assert!(resp2.status().is_success(), "page 2 must succeed");
let page2_events: Vec<Value> = resp2.json().await.expect("page 2 parse");
let page2_ids: Vec<String> = page2_events
.iter()
.filter_map(|e| e["id"].as_str().map(|s| s.to_string()))
.collect();
assert!(
!page2_ids.iter().any(|id| id == &draft_id),
"draft id must not appear in page 2: draft_id={draft_id}, page2={page2_events:?}"
);
// Gapless invariant: the two pages together cover all 3 public messages.
let all_msg_ids: std::collections::HashSet<String> = page1_ids
.iter()
.chain(page2_ids.iter())
.filter(|id| msg_ids.contains(id))
.cloned()
.collect();
assert_eq!(
all_msg_ids.len(),
3,
"all 3 public messages must appear across both pages with no gaps; \
got: page1={page1_ids:?}, page2={page2_ids:?}"
);
}
// If has_more=false, all 3 messages fit in one page — cursor test skipped,
// but the no-draft assertion above already passed.
}
+6
View File
@@ -10,6 +10,12 @@
-- We must DROP the generated column and re-ADD it with the extended exclusion
-- list; ALTER COLUMN cannot change a GENERATED expression in Postgres.
--
-- DEPLOY NOTE: the DROP + re-ADD below acquires ACCESS EXCLUSIVE on `events`
-- for the duration of the migration, blocking all reads and writes to the
-- table. The GIN index rebuild that follows is a full table scan. On large
-- deployments this migration should run during a scheduled maintenance window.
-- This is the same shape as migration 0005 and was accepted as precedent.
--
-- Final kind exclusion list after this migration:
-- 1059 = KIND_GIFT_WRAP (NIP-17 ciphertext)
-- 30300 = KIND_EVENT_REMINDER (AUTHOR_ONLY_KINDS — defense in depth)