daphne 0.2.0

Implementation of the DAP specification
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

// Copyright (c) 2022 Cloudflare, Inc. All rights reserved.
// SPDX-License-Identifier: BSD-3-Clause

use crate::{
    vdaf::{
        prio3::{
            prio3_encode_prepare_message, prio3_helper_prepare_finish, prio3_leader_prepare_finish,
            prio3_prepare_init, prio3_shard, prio3_unshard,
        },
        VdafError,
    },
    DapAggregateResult, DapMeasurement, Prio3Config,
};
use prio::codec::Encode;
use rand::prelude::*;

#[test]
fn prepare_count() {
    test_prepare(
        &Prio3Config::Count,
        DapMeasurement::U64(0),
        DapAggregateResult::U64(0),
    )
    .unwrap();
}

#[test]
fn prepare_sum() {
    test_prepare(
        &Prio3Config::Sum { bits: 23 },
        DapMeasurement::U64(1337),
        DapAggregateResult::U128(1337),
    )
    .unwrap();
}

#[test]
fn prepare_histogram() {
    test_prepare(
        &Prio3Config::Histogram {
            buckets: vec![0, 23, 9999999],
        },
        DapMeasurement::U64(1337),
        DapAggregateResult::U128Vec(vec![0, 0, 1, 0]),
    )
    .unwrap();
}

fn test_prepare(
    config: &Prio3Config,
    measurement: DapMeasurement,
    expected_result: DapAggregateResult,
) -> Result<(), VdafError> {
    let mut rng = thread_rng();
    let verify_key = rng.gen();
    let nonce = b"this is a good nonce";

    // Shard
    let encoded_input_shares = prio3_shard(config, measurement).unwrap();
    assert_eq!(encoded_input_shares.len(), 2);

    // Prepare
    let (leader_state, leader_share) =
        prio3_prepare_init(&config, &verify_key, 0, nonce, &encoded_input_shares[0])?;

    let (helper_state, helper_share) =
        prio3_prepare_init(&config, &verify_key, 1, nonce, &encoded_input_shares[1])?;

    let helper_share_data = prio3_encode_prepare_message(&helper_share);

    let (leader_out_share, leader_message_data) =
        prio3_leader_prepare_finish(config, leader_state, leader_share, &helper_share_data)?;

    let helper_out_share = prio3_helper_prepare_finish(config, helper_state, &leader_message_data)?;

    // Unshard
    let agg_res = prio3_unshard(
        config,
        1,
        [
            leader_out_share.get_encoded(),
            helper_out_share.get_encoded(),
        ],
    )
    .unwrap();
    assert_eq!(agg_res, expected_result);

    Ok(())
}