chalamet_pir 0.4.0

Simple, Stateful, Single-Server Private Information Retrieval for Key-Value Databases
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

#![cfg(test)]

use crate::ChalametPIRError;
use crate::pir_internals::matrix::test::generate_random_kv_database;
use crate::{client::Client, server::Server};
use rand::prelude::*;
use rand_chacha::ChaCha8Rng;
use std::collections::HashMap;
use test_case::test_case;

#[test_case(2usize.pow(12); "A key-value database with power of 2 many entries")]
#[test_case(2usize.pow(12) + 1; "A key-value database with non-power of 2 many entries")]
fn test_keyword_pir_with_3_wise_xor_filter(num_kv_pairs_in_db: usize) {
    const ARITY: u32 = 3;

    let kv_db = generate_random_kv_database(num_kv_pairs_in_db);
    let kv_db_as_ref = kv_db.iter().map(|(k, v)| (k.as_slice(), v.as_slice())).collect::<HashMap<&[u8], &[u8]>>();

    let mut rng = ChaCha8Rng::from_os_rng();

    let mut seed_μ = [0u8; 32];
    rng.fill_bytes(&mut seed_μ);

    let (server, hint_bytes, filter_param_bytes) = Server::setup::<ARITY>(&seed_μ, kv_db_as_ref.clone()).expect("Server setup failed");
    let mut client = Client::setup(&seed_μ, &hint_bytes, &filter_param_bytes).expect("Client setup failed");

    let mut kv_iter = kv_db_as_ref.iter();
    let (&(mut key), &(mut value)) = kv_iter.next().unwrap();
    let mut is_current_kv_pair_processed = false;

    loop {
        if is_current_kv_pair_processed {
            match kv_iter.next() {
                Some((&k, &v)) => {
                    key = k;
                    value = v;
                }
                None => {
                    // No more KV pairs to test
                    break;
                }
            };
        }

        match client.query(key) {
            Ok(query_bytes) => {
                let response_bytes = server.respond(&query_bytes).expect("Server can't respond");
                let received_value = client.process_response(key, &response_bytes).expect("Client can't extract value from response");

                assert_eq!(value, received_value);
                is_current_kv_pair_processed = true;
            }
            Err(e) => {
                assert_eq!(e, ChalametPIRError::ArithmeticOverflowAddingQueryIndicator);
                is_current_kv_pair_processed = false;
                continue;
            }
        }
    }
}

#[test_case(2usize.pow(12); "A key-value database with power of 2 many entries")]
#[test_case(2usize.pow(12) + 1; "A key-value database with non-power of 2 many entries")]
fn test_keyword_pir_with_4_wise_xor_filter(num_kv_pairs_in_db: usize) {
    const ARITY: u32 = 4;

    let kv_db = generate_random_kv_database(num_kv_pairs_in_db);
    let kv_db_as_ref = kv_db.iter().map(|(k, v)| (k.as_slice(), v.as_slice())).collect::<HashMap<&[u8], &[u8]>>();

    let mut rng = ChaCha8Rng::from_os_rng();

    let mut seed_μ = [0u8; 32];
    rng.fill_bytes(&mut seed_μ);

    let (server, hint_bytes, filter_param_bytes) = Server::setup::<ARITY>(&seed_μ, kv_db_as_ref.clone()).expect("Server setup failed");
    let mut client = Client::setup(&seed_μ, &hint_bytes, &filter_param_bytes).expect("Client setup failed");

    let mut kv_iter = kv_db_as_ref.iter();
    let (&(mut key), &(mut value)) = kv_iter.next().unwrap();
    let mut is_current_kv_pair_processed = false;

    loop {
        if is_current_kv_pair_processed {
            match kv_iter.next() {
                Some((&k, &v)) => {
                    key = k;
                    value = v;
                }
                None => {
                    // No more KV pairs to test
                    break;
                }
            };
        }

        match client.query(key) {
            Ok(query_bytes) => {
                let response_bytes = server.respond(&query_bytes).expect("Server can't respond");
                let received_value = client.process_response(key, &response_bytes).expect("Client can't extract value from response");

                assert_eq!(value, received_value);
                is_current_kv_pair_processed = true;
            }
            Err(e) => {
                assert_eq!(e, ChalametPIRError::ArithmeticOverflowAddingQueryIndicator);
                is_current_kv_pair_processed = false;
                continue;
            }
        }
    }
}