Refactor SignedAnnounce

Author: rklaehn

content-discovery/Cargo.lock

@@ -11,7 +11,7 @@ use clap::Parser;
 use futures::StreamExt;
 use iroh_mainline_content_discovery::{
     create_quinn_client,
-    protocol::{AbsoluteTime, Announce, AnnounceKind, Query, QueryFlags, ALPN},
+    protocol::{AbsoluteTime, Announce, AnnounceKind, Query, QueryFlags, SignedAnnounce, ALPN},
     to_infohash,
 };
 use iroh_net::{
@@ -78,7 +78,8 @@ async fn announce(args: AnnounceArgs) -> anyhow::Result<()> {
         content,
         timestamp,
     };
-    iroh_mainline_content_discovery::announce(connection, announce, &key).await?;
+    let signed_announce = SignedAnnounce::new(announce, &key)?;
+    iroh_mainline_content_discovery::announce(connection, signed_announce).await?;
     println!("done");
     Ok(())
 }
@@ -101,9 +102,9 @@ async fn query(args: QueryArgs) -> anyhow::Result<()> {
         "querying tracker {} for content {}",
         args.tracker, args.content
     );
-    for peer in res.hosts {
-        if let Ok(announce) = peer.verify() {
-            println!("{}: {:?}", announce.host, announce.kind);
+    for sa in res.hosts {
+        if sa.verify().is_ok() {
+            println!("{}: {:?}", sa.announce.host, sa.announce.kind);
         } else {
             println!("invalid announce");
         }
@@ -134,8 +135,8 @@ async fn query_dht(args: QueryDhtArgs) -> anyhow::Result<()> {
     );
     while let Some(item) = stream.next().await {
         match item {
-            Ok(signed_announce) => {
-                if let Ok(announce) = signed_announce.verify() {
+            Ok(announce) => {
+                if announce.verify().is_ok() {
                     println!("found verified provider {}", announce.host);
                 } else {
                     println!("found unverified provider");

content-discovery/iroh-mainline-content-discovery-cli/src/main.rs

@@ -26,6 +26,7 @@ futures = { version = "0.3.25", optional = true }
 rcgen = { version = "0.12.0", optional = true }
 rustls = { version = "0.21", optional = true }
 genawaiter = { version = "0.99.1", features = ["futures03"], optional = true }
+serde-big-array = "0.5.1"
 
 [features]
 client = ["iroh-pkarr-node-discovery", "mainline", "quinn", "tracing", "anyhow", "rcgen", "genawaiter", "rustls", "futures", "postcard"]

content-discovery/iroh-mainline-content-discovery/Cargo.toml

@@ -8,12 +8,12 @@ use std::{
 
 use futures::{future::BoxFuture, FutureExt, Stream, StreamExt};
 use iroh_bytes::HashAndFormat;
-use iroh_net::{key::SecretKey, MagicEndpoint, NodeId};
+use iroh_net::{MagicEndpoint, NodeId};
 use iroh_pkarr_node_discovery::PkarrNodeDiscovery;
 use mainline::common::{GetPeerResponse, StoreQueryMetdata};
 
 use crate::protocol::{
-    Announce, Query, QueryResponse, Request, Response, SignedAnnounce, ALPN, REQUEST_SIZE_LIMIT,
+    Query, QueryResponse, Request, Response, SignedAnnounce, ALPN, REQUEST_SIZE_LIMIT,
 };
 
 /// Announce to a tracker.
@@ -26,12 +26,10 @@ use crate::protocol::{
 /// `kind` is the kind of the announcement. We can claim to have the complete data or only some of it.
 pub async fn announce(
     connection: quinn::Connection,
-    args: Announce,
-    secret_key: &SecretKey,
+    signed_announce: SignedAnnounce,
 ) -> anyhow::Result<()> {
     let (mut send, mut recv) = connection.open_bi().await?;
     tracing::debug!("opened bi stream");
-    let signed_announce = SignedAnnounce::new(args, secret_key)?;
     let request = Request::Announce(signed_announce);
     let request = postcard::to_stdvec(&request)?;
     tracing::debug!("sending announce");

content-discovery/iroh-mainline-content-discovery/src/client.rs

@@ -1,12 +1,13 @@
 //! The protocol for communicating with the tracker.
 use std::{
-    ops::Sub,
+    ops::{Deref, Sub},
     time::{Duration, SystemTime},
 };
 
 use iroh_bytes::HashAndFormat;
 use iroh_net::NodeId;
 use serde::{Deserialize, Serialize};
+use serde_big_array::BigArray;
 
 /// The ALPN string for this protocol
 pub const ALPN: &[u8] = b"n0/tracker/1";
@@ -74,7 +75,7 @@ impl Into<SystemTime> for AbsoluteTime {
 ///
 /// A peer can announce having some data, but it should also be able to announce
 /// that another peer has the data. This is why the peer is included.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct Announce {
     /// The peer that supposedly has the data.
     pub host: NodeId,
@@ -87,35 +88,42 @@ pub struct Announce {
 }
 
 /// A signed announce.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct SignedAnnounce {
-    /// Postcard-encoded announce
-    pub announce_bytes: Vec<u8>,
+    /// Announce.
+    pub announce: Announce,
     /// Signature of the announce, signed by the host of the announce.
-    pub signature: Vec<u8>,
+    ///
+    /// The signature is over the announce, serialized with postcard.
+    #[serde(with = "BigArray")]
+    pub signature: [u8; 64],
+}
+
+impl Deref for SignedAnnounce {
+    type Target = Announce;
+
+    fn deref(&self) -> &Self::Target {
+        &self.announce
+    }
 }
 
 impl SignedAnnounce {
     /// Create a new signed announce.
     pub fn new(announce: Announce, secret_key: &iroh_net::key::SecretKey) -> anyhow::Result<Self> {
-        let announce = postcard::to_allocvec(&announce)?;
-        let signature = secret_key.sign(&announce).to_vec();
+        let announce_bytes = postcard::to_allocvec(&announce)?;
+        let signature = secret_key.sign(&announce_bytes).to_bytes();
         Ok(Self {
-            announce_bytes: announce,
+            announce,
             signature,
         })
     }
 
-    pub fn announce(&self) -> anyhow::Result<Announce> {
-        Ok(postcard::from_bytes(&self.announce_bytes)?)
-    }
-
     /// Verify the announce, and return the announce if it's valid.
-    pub fn verify(&self) -> anyhow::Result<Announce> {
-        let announce = self.announce()?;
-        let signature = iroh_net::key::Signature::from_slice(&self.signature)?;
-        announce.host.verify(&self.announce_bytes, &signature)?;
-        Ok(announce)
+    pub fn verify(&self) -> anyhow::Result<()> {
+        let announce_bytes = postcard::to_allocvec(&self.announce)?;
+        let signature = iroh_net::key::Signature::from_bytes(&self.signature);
+        self.announce.host.verify(&announce_bytes, &signature)?;
+        Ok(())
     }
 }
 

content-discovery/iroh-mainline-content-discovery/src/protocol.rs

@@ -121,11 +121,7 @@ impl From<SignedAnnounce> for PeerInfo {
 
 impl PeerInfo {
     fn last_announced(&self) -> AbsoluteTime {
-        self.signed_announce
-            .announce()
-            .ok()
-            .map(|x| x.timestamp)
-            .unwrap_or_default()
+        self.signed_announce.timestamp
     }
 }
 
@@ -402,15 +398,15 @@ impl Tracker {
 
     fn handle_announce(&self, signed_announce: SignedAnnounce) -> anyhow::Result<()> {
         tracing::info!("got announce");
-        let announce = signed_announce.verify()?;
-        tracing::info!("verified announce: {:?}", announce);
+        signed_announce.verify()?;
+        tracing::info!("verified announce: {:?}", signed_announce);
         let mut state = self.0.state.write().unwrap();
-        let content = announce.content;
+        let content = signed_announce.content;
         let entry = state.announce_data.entry(content).or_default();
         let peer_info = entry
-            .entry(announce.kind)
+            .entry(signed_announce.kind)
             .or_default()
-            .entry(announce.host)
+            .entry(signed_announce.host)
             .or_insert(PeerInfo::from(signed_announce.clone()));
         peer_info.signed_announce = signed_announce.clone();
         if let Some(path) = &self.0.options.announce_data_path {