[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,5 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct QueryConfig {}

src/lib.rs

@@ -16,6 +16,8 @@ pub mod error;
 pub mod ff;
 pub mod helpers;
 pub mod hpke;
+pub mod one_off_fns;
+
 #[cfg(feature = "web-app")]
 pub mod net;
 pub mod protocol;

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, "")?;
+                    Ok(())
+                }
             }
         }
     }

src/one_off_fns.rs

@@ -0,0 +1,12 @@
+use futures::Stream;
+
+///
+/// Helps to convince the compiler that things are `Send`. Like `seq_join::assert_send`, but for
+/// streams.
+///
+/// <https://github.com/rust-lang/rust/issues/102211#issuecomment-1367900125>
+pub fn assert_stream_send<'a, T>(
+    st: impl Stream<Item = T> + Send + 'a,
+) -> impl Stream<Item = T> + Send + 'a {
+    st
+}

src/protocol/basics/mod.rs

@@ -1,3 +1,4 @@
+pub mod apply_permutation;
 pub mod check_zero;
 mod if_else;
 pub(crate) mod mul;

src/protocol/context/mod.rs

@@ -160,7 +160,7 @@ pub struct Base<'a> {
 }
 
 impl<'a> Base<'a> {
-    fn new(participant: &'a PrssEndpoint, gateway: &'a Gateway) -> Self {
+    pub fn new(participant: &'a PrssEndpoint, gateway: &'a Gateway) -> Self {
         Self::new_complete(
             participant,
             gateway,

src/protocol/mod.rs

@@ -6,6 +6,8 @@ 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;
 pub mod sort;

src/protocol/oprf/mod.rs

@@ -0,0 +1 @@
+pub mod shuffle;