[RFC][oprf][shuffle] OPRF Shuffle using a 2-round 4-message shuffle protocol

src/helpers/transport/query.rs → src/helpers/transport/query/mod.rs

@@ -1,3 +1,5 @@
+pub mod oprf_shuffle;
+
 use std::{
     fmt::{Debug, Display, Formatter},
     num::NonZeroU32,
@@ -206,6 +208,7 @@ pub enum QueryType {
     MaliciousIpa(IpaQueryConfig),
     SemiHonestSparseAggregate(SparseAggregateQueryConfig),
     MaliciousSparseAggregate(SparseAggregateQueryConfig),
+    OPRFShuffle(oprf_shuffle::QueryConfig),
 }
 
 impl QueryType {
@@ -214,6 +217,7 @@ impl QueryType {
     pub const MALICIOUS_IPA_STR: &'static str = "malicious-ipa";
     pub const SEMIHONEST_AGGREGATE_STR: &'static str = "semihonest-sparse-aggregate";
     pub const MALICIOUS_AGGREGATE_STR: &'static str = "malicious-sparse-aggregate";
+    pub const OPRF_SHUFFLE_STR: &'static str = "oprf-shuffle";
 }
 
 /// TODO: should this `AsRef` impl (used for `Substep`) take into account config of IPA?
@@ -226,6 +230,7 @@ impl AsRef<str> for QueryType {
             QueryType::MaliciousIpa(_) => Self::MALICIOUS_IPA_STR,
             QueryType::SemiHonestSparseAggregate(_) => Self::SEMIHONEST_AGGREGATE_STR,
             QueryType::MaliciousSparseAggregate(_) => Self::MALICIOUS_AGGREGATE_STR,
+            QueryType::OPRFShuffle(_) => Self::OPRF_SHUFFLE_STR,
         }
     }
 }

src/helpers/transport/query/oprf_shuffle.rs

@@ -0,0 +1,17 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct QueryConfig {
+    pub bk_size: u8, // breakdown key size bits
+    pub tv_size: u8, // trigger value size bits
+}
+
+impl Default for QueryConfig {
+    fn default() -> Self {
+        Self {
+            bk_size: 40,
+            tv_size: 40,
+        }
+    }
+}

src/net/http_serde.rs

@@ -139,6 +139,10 @@ pub mod query {
                     let Query(q) = req.extract().await?;
                     Ok(QueryType::MaliciousSparseAggregate(q))
                 }
+                QueryType::OPRF_SHUFFLE_STR => {
+                    let Query(q) = req.extract().await?;
+                    Ok(QueryType::OPRFShuffle(q))
+                }
                 other => Err(Error::bad_query_value("query_type", other)),
             }?;
             Ok(QueryConfigQueryParams(QueryConfig {
@@ -188,6 +192,10 @@ pub mod query {
 
                     Ok(())
                 }
+                QueryType::OPRFShuffle(config) => {
+                    write!(f, "&bk_size={}&tv_size={}", config.bk_size, config.tv_size)?;
+                    Ok(())
+                }
             }
         }
     }

src/protocol/context/mod.rs

@@ -1,4 +1,5 @@
 pub mod malicious;
+pub mod oprf;
 pub mod prss;
 pub mod semi_honest;
 pub mod upgrade;
@@ -8,6 +9,7 @@ use std::{num::NonZeroUsize, sync::Arc};
 
 use async_trait::async_trait;
 pub use malicious::{Context as MaliciousContext, Upgraded as UpgradedMaliciousContext};
+pub use oprf::Context as OPRFContext;
 use prss::{InstrumentedIndexedSharedRandomness, InstrumentedSequentialSharedRandomness};
 pub use semi_honest::{Context as SemiHonestContext, Upgraded as UpgradedSemiHonestContext};
 pub use upgrade::{UpgradeContext, UpgradeToMalicious};

src/protocol/context/oprf.rs

@@ -0,0 +1,88 @@
+use std::num::NonZeroUsize;
+
+use crate::{
+    helpers::{Gateway, Message, ReceivingEnd, Role, SendingEnd, TotalRecords},
+    protocol::{
+        context::{
+            Base, InstrumentedIndexedSharedRandomness, InstrumentedSequentialSharedRandomness,
+        },
+        prss::Endpoint as PrssEndpoint,
+        step::{Gate, Step, StepNarrow},
+    },
+    seq_join::SeqJoin,
+};
+
+#[derive(Clone)]
+pub struct Context<'a> {
+    inner: Base<'a>,
+}
+
+impl<'a> Context<'a> {
+    pub fn new(participant: &'a PrssEndpoint, gateway: &'a Gateway) -> Self {
+        Self {
+            inner: Base::new(participant, gateway),
+        }
+    }
+
+    #[cfg(test)]
+    #[must_use]
+    pub fn from_base(base: Base<'a>) -> Self {
+        Self { inner: base }
+    }
+}
+
+impl<'a> super::Context for Context<'a> {
+    fn role(&self) -> Role {
+        self.inner.role()
+    }
+
+    fn gate(&self) -> &Gate {
+        self.inner.gate()
+    }
+
+    fn narrow<S: Step + ?Sized>(&self, step: &S) -> Self
+    where
+        Gate: StepNarrow<S>,
+    {
+        Self {
+            inner: self.inner.narrow(step),
+        }
+    }
+
+    fn set_total_records<T: Into<TotalRecords>>(&self, total_records: T) -> Self {
+        Self {
+            inner: self.inner.set_total_records(total_records),
+        }
+    }
+
+    fn total_records(&self) -> TotalRecords {
+        self.inner.total_records()
+    }
+
+    fn prss(&self) -> InstrumentedIndexedSharedRandomness<'_> {
+        self.inner.prss()
+    }
+
+    fn prss_rng(
+        &self,
+    ) -> (
+        InstrumentedSequentialSharedRandomness,
+        InstrumentedSequentialSharedRandomness,
+    ) {
+        self.inner.prss_rng()
+    }
+
+    fn send_channel<M: Message>(&self, role: Role) -> SendingEnd<M> {
+        self.inner.send_channel(role)
+    }
+
+    fn recv_channel<M: Message>(&self, role: Role) -> ReceivingEnd<M> {
+        self.inner.recv_channel(role)
+    }
+}
+
+impl<'a> SeqJoin for Context<'a> {
+    fn active_work(&self) -> NonZeroUsize {
+        self.inner.active_work()
+    }
+}

src/protocol/mod.rs

@@ -6,6 +6,7 @@ pub mod context;
 pub mod dp;
 pub mod ipa;
 pub mod modulus_conversion;
+pub mod oprf;
 #[cfg(feature = "descriptive-gate")]
 pub mod prf_sharding;
 pub mod prss;