umbral-rs 0.0.4

A pure-Rust implementation of the Umbral threshold Proxy Re-encryption scheme
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use openssl::bn::BigNumRef;
use umbral_rs::internal::keyredistrib::*;
// use umbral_rs::pre::*;

fn main() {
    let params = new_standard_params();
    let alice = KeyPair::new(&params);
    let signer = Signer::new(&params);
    let bob = KeyPair::new(&params);

    let plaintext = b"Hello, umbral!".to_vec();
    let (ciphertext, mut capsule) = encrypt(&alice.public_key(), &plaintext).unwrap();

    capsule.set_correctness_keys(&alice.public_key(), &bob.public_key(), &signer.public_key());

    let threshold = 3;
    let nodes_number = 5;

    let kfrag_raw = generate_kfrags(
        &alice,
        &bob.public_key(),
        threshold,
        nodes_number,
        &signer,
        KFragMode::DelegatingAndReceiving,
    );
    let kfrags = kfrag_raw.0.unwrap();
    let dh_point = kfrag_raw.1;

    let mut cfrags: Vec<CFrag> = vec![];
    for kfrag in kfrags.iter() {
        let cfrag = reencrypt(&kfrag, &capsule, false, None, false).unwrap();

        cfrags.push(cfrag);
        // capsule.attach_cfrag(&cfrag).unwrap();
    }

    let mut cfrags_iter = cfrags.iter();

    let len_kfrags = nodes_number.clone();
    println!("kfrags len: {:?}", len_kfrags);

    let mut secret_vec: Vec<CurveBN> = vec![];
    let mut ids: Vec<&BigNumRef> = vec![];
    let precursor = kfrags[0].precursor();
    for kfrag in kfrags.iter() {
        secret_vec.push(kfrag.re_key_share().clone());
        ids.push(kfrag.id());
    }

    println!("dh_point: {:?}", dh_point.to_bytes());
    println!("\nprecursor: {:?}", precursor.to_bytes());
    println!("\nbob public key: {:?}", bob.public_key().to_bytes());
    println!("\nthreshold: {:?}", threshold);

    let mut count = 0;
    for priv_key in secret_vec.iter_mut() {
        println!("{}th priv_key: {:?}", count, priv_key.to_bytes());
        count += 1;
    }
    let mut count = 0;
    for id in ids.iter() {
        println!("{}th id: {:?}", count, id.to_hex_str());
        count += 1;
    }

    let res = key_refresh(
        &secret_vec,
        ids,
        dh_point,
        bob.public_key(),
        precursor,
        threshold as u32,
        &params,
    );
    println!("Result: {:?}", res);
    let u = CurvePoint::from_ec_point(params.u_point(), &params);
    // let mut new_share_for_secret: Vec<(CurveBN, CurveBN)> = vec![];

    let mut new_kfrags: Vec<KFrag> = vec![];
    let mut new_cfrags: Vec<CFrag> = vec![];
    let mut kfrag_iter = kfrags.iter();

    for share in res.iter() {
        // let share_num = share.0.clone() - 1;
        // let share_num_bignum = BigNum::from_u32(share.0.clone() as u32).unwrap();
        let curr_id = share.0.bn();

        let share_bn = share.1.clone();
        let curr_kfrag = kfrag_iter.next().unwrap();
        // let curr_kfrag = &kfrags[share_num as usize];
        // let id = curr_kfrag.id();
        let re_key_share = share_bn.clone();
        let commitment = &u * &re_key_share;
        let new_curr_kfrag = KFrag::new(
            curr_id,
            &re_key_share,
            &commitment,
            curr_kfrag.precursor(),
            curr_kfrag.signature_for_proxy(),
            curr_kfrag.signature_for_receiver(),
            curr_kfrag.keys_mode_in_signature(),
        );

        let new_curr_cfrag = refresh_cfrag(
            cfrags_iter.next().unwrap().clone(),
            curr_id,
            kfrag_get_rk(&curr_kfrag),
            &re_key_share,
        );

        // println!("new_curr_cfrag: {:?}", new_curr_cfrag);

        // let new_curr_cfrag2 = reencrypt(&new_curr_kfrag, &capsule, false, None, false).unwrap();

        // println!("new_curr_cfrag2:{:?}", new_curr_cfrag2);

        // assert!(new_curr_cfrag.eq(&new_curr_cfrag2));
        new_kfrags.push(new_curr_kfrag);
        new_cfrags.push(new_curr_cfrag);
    }

    for cfrag in new_cfrags.iter() {
        capsule.attach_cfrag(&cfrag).unwrap();
    }

    let plaintext_bob = decrypt(ciphertext, &capsule, &bob, false).unwrap();
    assert_eq!(plaintext, plaintext_bob);
    println!("{:?}", String::from_utf8(plaintext_bob.to_owned()).unwrap());
}