Browse Source

Remove commented-out old code

Ian Goldberg 1 year ago
parent
commit
7495aac88a
1 changed files with 0 additions and 116 deletions
  1. 0 116
      src/main.rs

+ 0 - 116
src/main.rs

@@ -104,120 +104,4 @@ fn main() {
         println!("Query client finish: {} µs", query_finish_us);
         println!("idx = {}; entry = {}", idx, entry);
     }
-
-    /*
-        let spiral_params = params::get_spiral_params(r);
-        let mut rng = rand::thread_rng();
-        print_params_summary(&spiral_params);
-        println!("OT one-time setup: {} µs", otsetup_us);
-
-        // One-time setup for the Spiral client
-        let spc_otsetup_start = Instant::now();
-        let mut clientrng = rand::thread_rng();
-        let mut client = Client::init(&spiral_params, &mut clientrng);
-        let pub_params = client.generate_keys();
-        let pub_params_buf = pub_params.serialize();
-        let spc_otsetup_us = spc_otsetup_start.elapsed().as_micros();
-        let spiral_blocking_factor = spiral_params.db_item_size / mem::size_of::<DbEntry>();
-        println!(
-            "Spiral client one-time setup: {} µs, {} bytes",
-            spc_otsetup_us,
-            pub_params_buf.len()
-        );
-
-        println!("\n===== PREPROCESSING =====\n");
-
-        // Spiral preprocessing: create a PIR lookup for an element at a
-        // random location
-        let spc_query_start = Instant::now();
-        let rand_idx = (rng.next_u64() as usize) % num_records;
-        let rand_pir_idx = rand_idx / spiral_blocking_factor;
-        println!("rand_idx = {} rand_pir_idx = {}", rand_idx, rand_pir_idx);
-        let spc_query = client.generate_query(rand_pir_idx);
-        let spc_query_buf = spc_query.serialize();
-        let spc_query_us = spc_query_start.elapsed().as_micros();
-        println!(
-            "Spiral query: {} µs, {} bytes",
-            spc_query_us,
-            spc_query_buf.len()
-        );
-
-        // Create the database encryption keys and do the OT to fetch the
-        // right one, but don't actually encrypt the database yet
-        let dbkeys = gen_db_enc_keys(r);
-        let otkeyreq_start = Instant::now();
-        let (keystate, keyquery) = otkey_request(rand_idx, r);
-        let keyquerysize = keyquery.len() * keyquery[0].len();
-        let otkeyreq_us = otkeyreq_start.elapsed().as_micros();
-        let otkeysrv_start = Instant::now();
-        let keyresponse = otkey_serve(keyquery, &dbkeys);
-        let keyrespsize = keyresponse.len() * keyresponse[0].len();
-        let otkeysrv_us = otkeysrv_start.elapsed().as_micros();
-        let otkeyrcv_start = Instant::now();
-        let otkey = otkey_receive(keystate, &keyresponse);
-        let otkeyrcv_us = otkeyrcv_start.elapsed().as_micros();
-        println!("key OT query in {} µs, {} bytes", otkeyreq_us, keyquerysize);
-        println!("key OT serve in {} µs, {} bytes", otkeysrv_us, keyrespsize);
-        println!("key OT receive in {} µs", otkeyrcv_us);
-
-        // Create a database with recognizable contents
-        let db: Vec<DbEntry> = ((0 as DbEntry)..(num_records as DbEntry))
-            .map(|x| 10000001 * x)
-            .collect();
-
-        println!("\n===== RUNTIME =====\n");
-
-        // Pick the record we actually want to query
-        let q = (rng.next_u64() as usize) % num_records;
-
-        // Compute the offset from the record index we're actually looking
-        // for to the random one we picked earlier.  Tell it to the server,
-        // who will rotate right the database by that amount before
-        // encrypting it.
-        let idx_offset = (num_records + rand_idx - q) % num_records;
-
-        println!("Send to server {} bytes", 8 /* sizeof(idx_offset) */);
-
-        // The server rotates, blinds, and encrypts the database
-        let blind: DbEntry = 20;
-        let encdb_start = Instant::now();
-        let encdb = encdb_xor_keys(&db, &dbkeys, r, idx_offset, blind, num_threads);
-        let encdb_us = encdb_start.elapsed().as_micros();
-        println!("Server encrypt database {} µs", encdb_us);
-
-        // Load the encrypted database into Spiral
-        let sps_loaddb_start = Instant::now();
-        let sps_db = load_db_from_slice_mt(&spiral_params, &encdb, num_threads);
-        let sps_loaddb_us = sps_loaddb_start.elapsed().as_micros();
-        println!("Server load database {} µs", sps_loaddb_us);
-
-        // Do the PIR query
-        let sps_query_start = Instant::now();
-        let sps_query = Query::deserialize(&spiral_params, &spc_query_buf);
-        let sps_response = process_query(&spiral_params, &pub_params, &sps_query, sps_db.as_slice());
-        let sps_query_us = sps_query_start.elapsed().as_micros();
-        println!(
-            "Server compute response {} µs, {} bytes (*including* the above expansion time)",
-            sps_query_us,
-            sps_response.len()
-        );
-
-        // Decode the response to yield the whole Spiral block
-        let spc_recv_start = Instant::now();
-        let encdbblock = client.decode_response(sps_response.as_slice());
-        // Extract the one encrypted DbEntry we were looking for (and the
-        // only one we are able to decrypt)
-        let entry_in_block = rand_idx % spiral_blocking_factor;
-        let loc_in_block = entry_in_block * mem::size_of::<DbEntry>();
-        let loc_in_block_end = (entry_in_block + 1) * mem::size_of::<DbEntry>();
-        let encdbentry = DbEntry::from_le_bytes(
-            encdbblock[loc_in_block..loc_in_block_end]
-                .try_into()
-                .unwrap(),
-        );
-        let decdbentry = otkey_decrypt(&otkey, rand_idx, encdbentry);
-        let spc_recv_us = spc_recv_start.elapsed().as_micros();
-        println!("Client decode response {} µs", spc_recv_us);
-        println!("index = {}, Response = {}", q, decdbentry);
-    */
 }