ibe 0.3.0

Identity Based Encryption schemes on the BLS12-381 pairing-friendly elliptic curve
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

macro_rules! test_kem {
    ($name: ident) => {
        const ID1: &'static str = "email:w.geraedts@sarif.nl";

        #[allow(dead_code)]
        struct DefaultSubResults {
            kid: Identity,
            pk: PublicKey,
            sk: SecretKey,
            usk: UserSecretKey,
            c: CipherText,
            k: SharedSecret,
        }

        fn perform_default() -> DefaultSubResults {
            let mut rng = rand::thread_rng();
            let kid = <$name as IBKEM>::Id::derive_str(ID1);
            let (pk, sk) = $name::setup(&mut rng);
            let usk = $name::extract_usk(Some(&pk), &sk, &kid, &mut rng);
            let (c, k) = $name::encaps(&pk, &kid, &mut rng);

            DefaultSubResults {
                kid,
                pk,
                sk,
                usk,
                c,
                k,
            }
        }

        #[test]
        fn eq_encaps_decaps() {
            let results = perform_default();
            let k2 = <$name as IBKEM>::decaps(Some(&results.pk), &results.usk, &results.c).unwrap();

            assert_eq!(results.k, k2);
        }

        #[test]
        fn eq_serialize_deserialize() {
            let result = perform_default();

            assert!(result.pk == PublicKey::from_bytes(&result.pk.to_bytes()).unwrap());
            assert_eq!(
                result.sk,
                SecretKey::from_bytes(&result.sk.to_bytes()).unwrap()
            );
            assert_eq!(
                result.usk,
                UserSecretKey::from_bytes(&result.usk.to_bytes()).unwrap()
            );
            assert_eq!(
                result.c,
                CipherText::from_bytes(&result.c.to_bytes()).unwrap()
            );
        }
    };
}

macro_rules! test_multi_kem {
    ($name: ident) => {
        #[test]
        fn eq_multi_encaps_decaps() {
            use crate::kem::mkem::{Ciphertext, MultiRecipient};

            let mut rng = rand::thread_rng();

            let id1 = "email:w.geraedts@sarif.nl";
            let id2 = "email:l.botros@cs.ru.nl";

            let kid = [
                <$name as IBKEM>::Id::derive_str(id1),
                <$name as IBKEM>::Id::derive_str(id2),
            ];

            let (pk, sk) = $name::setup(&mut rng);

            let usk1 = $name::extract_usk(Some(&pk), &sk, &kid[0], &mut rng);
            let usk2 = $name::extract_usk(Some(&pk), &sk, &kid[1], &mut rng);

            let usks = [usk1, usk2];

            let (cts, k) = $name::multi_encaps(&pk, &kid, &mut rng);

            for (i, ct) in cts.enumerate() {
                let compressed = ct.to_bytes();
                let decompressed = Ciphertext::<$name>::from_bytes(&compressed).unwrap();

                let k_i = $name::multi_decaps(Some(&pk), &usks[i], &decompressed).unwrap();
                assert_eq!(k, k_i);
            }

            assert_ne!(k, SharedSecret([0u8; 32]));
        }
    };
}

macro_rules! test_ibe {
    ($name: ident) => {
        use super::*;
        use crate::Derive;

        const ID: &'static [u8] = b"email:w.geraedts@sarif.nl";

        #[allow(dead_code)]
        struct DefaultSubResults {
            pk: PublicKey,
            sk: SecretKey,
            usk: UserSecretKey,
            c: CipherText,
            m: Msg,
        }

        fn perform_default() -> DefaultSubResults {
            use group::Group;
            use rand::RngCore;

            let mut rng = rand::thread_rng();

            let kid = <$name as IBE>::Id::derive(ID);

            let (pk, sk) = $name::setup(&mut rng);
            let usk = $name::extract_usk(Some(&pk), &sk, &kid, &mut rng);

            let m = Msg::random(&mut rng);

            type Rng = <$name as IBE>::RngBytes;
            let mut rand_bytes: Rng = [0u8; core::mem::size_of::<Rng>()];
            rng.fill_bytes(&mut rand_bytes);

            let c = $name::encrypt(&pk, &kid, &m, &rand_bytes);

            DefaultSubResults { pk, sk, usk, c, m }
        }

        #[test]
        fn eq_encrypt_decrypt() {
            let results = perform_default();
            let m2 = $name::decrypt(&results.usk, &results.c);

            assert_eq!(results.m, m2);
        }

        #[test]
        fn eq_serialize_deserialize() {
            let result = perform_default();

            assert!(result.pk == PublicKey::from_bytes(&result.pk.to_bytes()).unwrap());
            assert_eq!(
                result.sk,
                SecretKey::from_bytes(&result.sk.to_bytes()).unwrap()
            );
            assert_eq!(
                result.usk,
                UserSecretKey::from_bytes(&result.usk.to_bytes()).unwrap()
            );
            assert_eq!(
                result.c,
                CipherText::from_bytes(&result.c.to_bytes()).unwrap()
            );
        }
    };
}