spake2/src/tests.rs

   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.
   5 use super::*;
   6 use curve25519_dalek::constants::ED25519_BASEPOINT_POINT;
   7 use hex;
   8 use num_bigint::BigUint;
   9
  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)
  19 }
  20
  21 #[test]
  22 fn test_convert() {
  23     let t1_decimal =
  24         b"2238329342913194256032495932344128051776374960164957527413114840482143558222";
  25     let t1_scalar = decimal_to_scalar(t1_decimal);
  26     let t1_bytes = t1_scalar.to_bytes();
  27     let expected = [
  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,
  30         0xf2, 0x04,
  31     ];
  32     assert_eq!(t1_bytes, expected);
  33     //println!("t1_scalar is {:?}", t1_scalar);
  34 }
  35
  36 #[test]
  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);
  45 }
  46
  47 #[test]
  48 fn test_password_to_scalar() {
  49     let password = Password::new(b"password");
  50     let expected_pw_scalar = decimal_to_scalar(
  51         b"3515301705789368674385125653994241092664323519848410154015274772661223168839",
  52     );
  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);
  57 }
  58
  59 #[test]
  60 fn test_sizes() {
  61     let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
  62         &Password::new(b"password"),
  63         &Identity::new(b"idA"),
  64         &Identity::new(b"idB"),
  65     );
  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"),
  71     );
  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);
  77
  78     let (s1, msg1) = SPAKE2::<Ed25519Group>::start_symmetric(
  79         &Password::new(b"password"),
  80         &Identity::new(b"idS"),
  81     );
  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"),
  86     );
  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);
  92 }
  93
  94 #[test]
  95 fn test_hash_ab() {
  96     let key = ed25519_hash_ab(
  97         b"pw",
  98         b"idA",
  99         b"idB",
 100         b"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", // len=32
 101         b"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY",
 102         b"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK",
 103     );
 104     let expected_key = "d59d9ba920f7092565cec747b08d5b2e981d553ac32fde0f25e5b4a4cfca3efd";
 105     assert_eq!(hex::encode(key), expected_key);
 106 }
 107
 108 #[test]
 109 fn test_hash_symmetric() {
 110     let key = ed25519_hash_symmetric(
 111         b"pw",
 112         b"idSymmetric",
 113         b"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 114         b"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY",
 115         b"KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK",
 116     );
 117     let expected_key = "b0b31e4401aae37d91a9a8bf6fbb1298cafc005ff9142e3ffc5b9799fb11128b";
 118     assert_eq!(hex::encode(key), expected_key);
 119 }
 120
 121 #[test]
 122 fn test_asymmetric() {
 123     let scalar_a = decimal_to_scalar(
 124         b"2611694063369306139794446498317402240796898290761098242657700742213257926693",
 125     );
 126     let scalar_b = decimal_to_scalar(
 127         b"7002393159576182977806091886122272758628412261510164356026361256515836884383",
 128     );
 129     let expected_pw_scalar = decimal_to_scalar(
 130         b"3515301705789368674385125653994241092664323519848410154015274772661223168839",
 131     );
 132
 133     println!("scalar_a is {}", hex::encode(scalar_a.as_bytes()));
 134
 135     let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a_internal(
 136         &Password::new(b"password"),
 137         &Identity::new(b"idA"),
 138         &Identity::new(b"idB"),
 139         scalar_a,
 140     );
 141     let expected_msg1 = "416fc960df73c9cf8ed7198b0c9534e2e96a5984bfc5edc023fd24dacf371f2af9";
 142
 143     println!();
 144     println!("xys1: {:?}", hex::encode(s1.xy_scalar.as_bytes()));
 145     println!();
 146     println!("pws1: {:?}", hex::encode(s1.password_scalar.as_bytes()));
 147     println!("exp : {:?}", hex::encode(expected_pw_scalar.as_bytes()));
 148     println!();
 149     println!("msg1: {:?}", hex::encode(&msg1));
 150     println!("exp : {:?}", expected_msg1);
 151     println!();
 152
 153     assert_eq!(
 154         hex::encode(expected_pw_scalar.as_bytes()),
 155         hex::encode(s1.password_scalar.as_bytes())
 156     );
 157     assert_eq!(hex::encode(&msg1), expected_msg1);
 158
 159     let (s2, msg2) = SPAKE2::<Ed25519Group>::start_b_internal(
 160         &Password::new(b"password"),
 161         &Identity::new(b"idA"),
 162         &Identity::new(b"idB"),
 163         scalar_b,
 164     );
 165     assert_eq!(expected_pw_scalar, s2.password_scalar);
 166     assert_eq!(
 167         hex::encode(&msg2),
 168         "42354e97b88406922b1df4bea1d7870f17aed3dba7c720b313edae315b00959309"
 169     );
 170
 171     let key1 = s1.finish(&msg2).unwrap();
 172     let key2 = s2.finish(&msg1).unwrap();
 173     assert_eq!(key1, key2);
 174     assert_eq!(
 175         hex::encode(key1),
 176         "712295de7219c675ddd31942184aa26e0a957cf216bc230d165b215047b520c1"
 177     );
 178 }
 179
 180 #[test]
 181 fn test_debug() {
 182     let (s1, _msg1) = SPAKE2::<Ed25519Group>::start_a(
 183         &Password::new(b"password"),
 184         &Identity::new(b"idA"),
 185         &Identity::new(b"idB"),
 186     );
 187     println!("s1: {:?}", s1);
 188     let (s2, _msg1) = SPAKE2::<Ed25519Group>::start_symmetric(
 189         &Password::new(b"password"),
 190         &Identity::new(b"idS"),
 191     );
 192     println!("s2: {:?}", s2);
 193 }