WIP WASM demo

hacspec-scrambledb/oprf/src/coprf/coprf_setup.rs

@@ -26,7 +26,8 @@ pub type BlindingPrivateKey = elgamal::DecryptionKey;
 /// `Nsk` bytes of entropy is provided to the key derivation
 /// algorithm, where `Nsk` is the number of bytes to represent a valid
 /// private key, i.e. a P256 scalar in our case.
-pub type CoPRFMasterSecret = [u8; 32];
+pub type CoPRFMasterSecret = Vec<u8>;
+const COPRF_MSK_BYTES: usize = 32;
 
 /// A coPRF evaluation key is identified by a bytestring of arbitrary
 /// length.
@@ -78,8 +79,9 @@ impl CoPRFEvaluatorContext {
     /// ### E.1.2. Evaluator Setup
     /// The coPRF evaluator holds the master secret as well as any PRF
     /// evaluation keys derived from it.
-    pub fn new(msk: CoPRFMasterSecret) -> Self {
-        CoPRFEvaluatorContext { msk }
+    pub fn new(randomness: &mut Randomness) -> Result<Self, Error> {
+        let msk = randomness.bytes(COPRF_MSK_BYTES)?.to_vec();
+        Ok(CoPRFEvaluatorContext { msk })
     }
 }
 

hacspec-scrambledb/oprf/src/lib.rs

@@ -7,6 +7,7 @@ pub enum Error {
     CurveError,
     HashToCurveError,
     ElgamalError,
+    RandomnessError,
 }
 
 impl From<p256::Error> for Error {
@@ -27,6 +28,12 @@ impl From<elgamal::Error> for Error {
     }
 }
 
+impl From<hacspec_lib::Error> for Error {
+    fn from(_value: hacspec_lib::Error) -> Self {
+        Self::RandomnessError
+    }
+}
+
 // 3. Protocol
 pub mod protocol;
 

hacspec-scrambledb/scrambledb/Cargo.toml

@@ -5,9 +5,33 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+crate-type = ["rlib", "cdylib"]
+
 [dependencies]
 oprf.workspace = true
 elgamal.workspace = true
 prp.workspace = true
 p256.workspace = true
 hacspec_lib.workspace = true
+hash-to-curve.workspace = true
+
+wasm-bindgen = { version = "0.2.87", optional = true }
+rand = { version = "0.8.5", optional = true }
+getrandom = { version = "0.2.10", features = ["js"], optional = true }
+hex = { version = "0.4.3", optional = true }
+[dependencies.web-sys]
+version = "0.3.4"
+optional = true
+features = [
+    'Document',
+    'Element',
+    'HtmlElement',
+    'Node',
+    'Window',
+    'console',
+    'HtmlTableElement',
+    'HtmlTableRowElement',
+]
+[features]
+wasm = ["wasm-bindgen", "getrandom", "web-sys", "rand", "hex"]

hacspec-scrambledb/scrambledb/src/error.rs

@@ -12,6 +12,7 @@ impl From<oprf::Error> for Error {
             oprf::Error::CurveError => Self::CorruptedData,
             oprf::Error::HashToCurveError => Self::CorruptedData,
             oprf::Error::ElgamalError => Self::RandomnessError,
+            oprf::Error::RandomnessError => Self::RandomnessError,
         }
     }
 }

hacspec-scrambledb/scrambledb/src/finalize.rs

@@ -14,7 +14,7 @@ use crate::{
 /// In addition the encrypted values need to be decrypted to be available
 /// for future conversions towards other data stores.
 pub fn finalize_conversion(
-    store_context: StoreContext,
+    store_context: &StoreContext,
     converted_tables: Vec<ConvertedTable>,
 ) -> Result<Vec<PseudonymizedTable>, Error> {
     let mut pseudonymized_tables = Vec::new();

hacspec-scrambledb/scrambledb/src/join.rs

@@ -60,7 +60,7 @@ use crate::{
 ///     return blind_tables
 /// ```
 pub fn prepare_join_conversion(
-    origin_context: StoreContext,
+    origin_context: &StoreContext,
     bpk_target: BlindingPublicKey,
     ek_target: EncryptionKey,
     pseudonymized_tables: Vec<PseudonymizedTable>,
@@ -102,7 +102,7 @@ pub fn join_identifier(identifier: String, attribute: String) -> String {
 /// evaluation key.
 ///
 pub fn join_conversion(
-    converter_context: ConverterContext,
+    converter_context: &ConverterContext,
     bpk_target: BlindingPublicKey,
     ek_target: EncryptionKey,
     tables: Vec<BlindTable>,

hacspec-scrambledb/scrambledb/src/lib.rs

@@ -207,3 +207,4 @@ pub mod join;
 pub mod finalize;
 
 pub mod error;
+pub mod wasm_demo;

hacspec-scrambledb/scrambledb/src/setup.rs

@@ -41,10 +41,10 @@ impl ConverterContext {
     /// fn setup_converter_context(msk) -> ConverterContext:
     ///     return coPRFEvaluatorContext::new(msk)
     /// ```
-    pub fn setup(msk: [u8; 32]) -> Self {
-        ConverterContext {
-            coprf_context: CoPRFEvaluatorContext::new(msk),
-        }
+    pub fn setup(randomness: &mut Randomness) -> Result<Self, Error> {
+        Ok(ConverterContext {
+            coprf_context: CoPRFEvaluatorContext::new(randomness)?,
+        })
     }
 }
 
@@ -76,10 +76,10 @@ impl StoreContext {
     ///       k_prp
     ///     }
     /// ```
-    pub fn setup(mut randomness: Randomness) -> Result<Self, Error> {
-        let receiver_context = CoPRFReceiverContext::new(&mut randomness);
+    pub fn setup(randomness: &mut Randomness) -> Result<Self, Error> {
+        let receiver_context = CoPRFReceiverContext::new(randomness);
 
-        let (dk, ek) = generate_keys(&mut randomness)?;
+        let (dk, ek) = generate_keys(randomness)?;
 
         let k_prp = randomness.bytes(32)?.try_into()?;
 

hacspec-scrambledb/scrambledb/src/split.rs

@@ -74,7 +74,7 @@ pub fn prepare_split_conversion(
 /// have been shuffled to prevent correlation of the incoming with the
 /// outgoing table data.
 pub fn split_conversion(
-    converter_context: ConverterContext,
+    converter_context: &ConverterContext,
     bpk_store: BlindingPublicKey,
     ek_store: EncryptionKey,
     table: BlindTable,

hacspec-scrambledb/scrambledb/src/table.rs

@@ -31,10 +31,32 @@ impl<K, V> Column<K, V> {
         Self { attribute, data }
     }
 
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
     pub fn attribute(&self) -> String {
         self.attribute.clone()
     }
 
+    pub fn keys(&self) -> Vec<K>
+    where
+        K: Clone,
+    {
+        self.data.iter().map(|(k, _v)| k.clone()).collect()
+    }
+
+    pub fn get(&self, key: &K) -> Option<V>
+    where
+        K: PartialEq,
+        V: Clone,
+    {
+        self.data
+            .iter()
+            .find(|(k, _v)| k == key)
+            .map(|(_k, v)| v.clone())
+    }
+
     pub fn data(&self) -> Vec<(K, V)>
     where
         K: Clone,
@@ -77,6 +99,14 @@ impl<K, V> SingleColumnTable<K, V> {
     {
         self.column.clone()
     }
+
+    pub fn len(&self) -> usize
+    where
+        K: Clone,
+        V: Clone,
+    {
+        self.column.data().len()
+    }
 }
 
 impl<K, V> MultiColumnTable<K, V> {
@@ -90,11 +120,40 @@ impl<K, V> MultiColumnTable<K, V> {
         self.identifier.clone()
     }
 
+    pub fn num_columns(&self) -> usize {
+        self.columns.len()
+    }
+
+    pub fn num_rows(&self) -> usize
+    where
+        K: Clone,
+        V: Clone,
+    {
+        self.columns()[0].len()
+    }
+
     pub fn columns(&self) -> Vec<Column<K, V>>
     where
         K: Clone,
         V: Clone,
     {
         self.columns.clone()
     }
+
+    pub fn rows(&self) -> Vec<Vec<(K, V)>>
+    where
+        K: Clone + PartialEq,
+        V: Clone,
+    {
+        let mut rows = Vec::new();
+        for i in 0..self.num_rows() {
+            let mut row = Vec::new();
+            for column in self.columns() {
+                row.push(column.data()[i].clone());
+            }
+            rows.push(row)
+        }
+
+        rows
+    }
 }