mirror of
https://github.com/block/buzz.git
synced 2026-08-18 06:50:31 +02:00
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:
co-authored by
Will Pfleger
parent
ed274bdc3c
commit
5c3ac62860
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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>`.
|
||||
|
||||
@@ -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:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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"
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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; \
|
||||
|
||||
@@ -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, ¬e).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.
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user