1 //! This compares results against the python compatibility tests:
2 //! spake2.test.test_compat.SPAKE2.test_asymmetric . The python test passes a
3 //! deterministic RNG (used only for tests, of course) into the per-Group
4 //! "random_scalar()" function, which results in some particular scalar.
6 use curve25519_dalek::constants::ED25519_BASEPOINT_POINT;
8 use num_bigint::BigUint;
10 // the python tests show the long-integer form of scalars. the rust code
11 // wants an array of bytes (little-endian). Make sure the way we convert
12 // things works correctly.
13 fn decimal_to_scalar(d: &[u8]) -> c2_Scalar {
14 let bytes = BigUint::parse_bytes(d, 10).unwrap().to_bytes_le();
15 assert_eq!(bytes.len(), 32);
16 let mut b2 = [0u8; 32];
17 b2.copy_from_slice(&bytes);
18 c2_Scalar::from_bytes_mod_order(b2)
24 b"2238329342913194256032495932344128051776374960164957527413114840482143558222";
25 let t1_scalar = decimal_to_scalar(t1_decimal);
26 let t1_bytes = t1_scalar.to_bytes();
28 0x4e, 0x5a, 0xb4, 0x34, 0x5d, 0x47, 0x08, 0x84, 0x59, 0x13, 0xb4, 0x64, 0x1b, 0xc2, 0x7d,
29 0x52, 0x52, 0xa5, 0x85, 0x10, 0x1b, 0xcc, 0x42, 0x44, 0xd4, 0x49, 0xf4, 0xa8, 0x79, 0xd9,
32 assert_eq!(t1_bytes, expected);
33 //println!("t1_scalar is {:?}", t1_scalar);
37 fn test_serialize_basepoint() {
38 // make sure elements are serialized same as the python library
39 let exp = "5866666666666666666666666666666666666666666666666666666666666666";
40 let base_vec = ED25519_BASEPOINT_POINT.compress().as_bytes().to_vec();
41 let base_hex = hex::encode(base_vec);
42 println!("exp: {:?}", exp);
43 println!("got: {:?}", base_hex);
44 assert_eq!(exp, base_hex);
48 fn test_password_to_scalar() {
49 let password = Password::new(b"password");
50 let expected_pw_scalar = decimal_to_scalar(
51 b"3515301705789368674385125653994241092664323519848410154015274772661223168839",
53 let pw_scalar = Ed25519Group::hash_to_scalar(&password);
54 println!("exp: {:?}", hex::encode(expected_pw_scalar.as_bytes()));
55 println!("got: {:?}", hex::encode(pw_scalar.as_bytes()));
56 assert_eq!(&pw_scalar, &expected_pw_scalar);
61 let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
62 &Password::new(b"password"),
63 &Identity::new(b"idA"),
64 &Identity::new(b"idB"),
66 assert_eq!(msg1.len(), 1 + 32);
67 let (s2, msg2) = SPAKE2::<Ed25519Group>::start_b(
68 &Password::new(b"password"),
69 &Identity::new(b"idA"),
70 &Identity::new(b"idB"),
72 assert_eq!(msg2.len(), 1 + 32);
73 let key1 = s1.finish(&msg2).unwrap();
74 let key2 = s2.finish(&msg1).unwrap();
75 assert_eq!(key1.len(), 32);
76 assert_eq!(key2.len(), 32);
78 let (s1, msg1) = SPAKE2::<Ed25519Group>::start_symmetric(
79 &Password::new(b"password"),
80 &Identity::new(b"idS"),
82 assert_eq!(msg1.len(), 1 + 32);
83 let (s2, msg2) = SPAKE2::<Ed25519Group>::start_symmetric(
84 &Password::new(b"password"),
85 &Identity::new(b"idS"),
87 assert_eq!(msg2.len(), 1 + 32);
88 let key1 = s1.finish(&msg2).unwrap();
89 let key2 = s2.finish(&msg1).unwrap();
90 assert_eq!(key1.len(), 32);
91 assert_eq!(key2.len(), 32);
96 let key = ed25519_hash_ab(
100 b"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", // len=32
101 b"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY",
102 b"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK",
104 let expected_key = "d59d9ba920f7092565cec747b08d5b2e981d553ac32fde0f25e5b4a4cfca3efd";
105 assert_eq!(hex::encode(key), expected_key);
109 fn test_hash_symmetric() {
110 let key = ed25519_hash_symmetric(
113 b"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
114 b"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY",
115 b"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK",
117 let expected_key = "b0b31e4401aae37d91a9a8bf6fbb1298cafc005ff9142e3ffc5b9799fb11128b";
118 assert_eq!(hex::encode(key), expected_key);
122 fn test_asymmetric() {
123 let scalar_a = decimal_to_scalar(
124 b"2611694063369306139794446498317402240796898290761098242657700742213257926693",
126 let scalar_b = decimal_to_scalar(
127 b"7002393159576182977806091886122272758628412261510164356026361256515836884383",
129 let expected_pw_scalar = decimal_to_scalar(
130 b"3515301705789368674385125653994241092664323519848410154015274772661223168839",
133 println!("scalar_a is {}", hex::encode(scalar_a.as_bytes()));
135 let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a_internal(
136 &Password::new(b"password"),
137 &Identity::new(b"idA"),
138 &Identity::new(b"idB"),
141 let expected_msg1 = "416fc960df73c9cf8ed7198b0c9534e2e96a5984bfc5edc023fd24dacf371f2af9";
144 println!("xys1: {:?}", hex::encode(s1.xy_scalar.as_bytes()));
146 println!("pws1: {:?}", hex::encode(s1.password_scalar.as_bytes()));
147 println!("exp : {:?}", hex::encode(expected_pw_scalar.as_bytes()));
149 println!("msg1: {:?}", hex::encode(&msg1));
150 println!("exp : {:?}", expected_msg1);
154 hex::encode(expected_pw_scalar.as_bytes()),
155 hex::encode(s1.password_scalar.as_bytes())
157 assert_eq!(hex::encode(&msg1), expected_msg1);
159 let (s2, msg2) = SPAKE2::<Ed25519Group>::start_b_internal(
160 &Password::new(b"password"),
161 &Identity::new(b"idA"),
162 &Identity::new(b"idB"),
165 assert_eq!(expected_pw_scalar, s2.password_scalar);
168 "42354e97b88406922b1df4bea1d7870f17aed3dba7c720b313edae315b00959309"
171 let key1 = s1.finish(&msg2).unwrap();
172 let key2 = s2.finish(&msg1).unwrap();
173 assert_eq!(key1, key2);
176 "712295de7219c675ddd31942184aa26e0a957cf216bc230d165b215047b520c1"
182 let (s1, _msg1) = SPAKE2::<Ed25519Group>::start_a(
183 &Password::new(b"password"),
184 &Identity::new(b"idA"),
185 &Identity::new(b"idB"),
187 println!("s1: {:?}", s1);
190 "SPAKE2 { group: \"Ed25519\", side: A, idA: (s=idA), idB: (s=idB), idS: (s=) }"
193 let (s2, _msg1) = SPAKE2::<Ed25519Group>::start_symmetric(
194 &Password::new(b"password"),
195 &Identity::new(b"idS"),
197 println!("s2: {:?}", s2);
200 "SPAKE2 { group: \"Ed25519\", side: Symmetric, idA: (s=), idB: (s=), idS: (s=idS) }"