spake2/src/lib.rs

   1 #![forbid(unsafe_code)]
   2 #![cfg_attr(test, deny(warnings))]
   3
   4 extern crate curve25519_dalek;
   5 extern crate hex;
   6 extern crate hkdf;
   7 extern crate num_bigint;
   8 extern crate rand;
   9 extern crate sha2;
  10
  11 mod spake2;
  12 pub use spake2::*;
  13
  14 #[cfg(test)]
  15 mod tests {
  16     use spake2::{Ed25519Group, ErrorType, Identity, Password, SPAKEErr, SPAKE2};
  17
  18     #[test]
  19     fn test_basic() {
  20         let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
  21             &Password::new(b"password"),
  22             &Identity::new(b"idA"),
  23             &Identity::new(b"idB"),
  24         );
  25         let (s2, msg2) = SPAKE2::<Ed25519Group>::start_b(
  26             &Password::new(b"password"),
  27             &Identity::new(b"idA"),
  28             &Identity::new(b"idB"),
  29         );
  30         let key1 = s1.finish(msg2.as_slice()).unwrap();
  31         let key2 = s2.finish(msg1.as_slice()).unwrap();
  32         assert_eq!(key1, key2);
  33     }
  34
  35     #[test]
  36     fn test_mismatch() {
  37         let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
  38             &Password::new(b"password"),
  39             &Identity::new(b"idA"),
  40             &Identity::new(b"idB"),
  41         );
  42         let (s2, msg2) = SPAKE2::<Ed25519Group>::start_b(
  43             &Password::new(b"password2"),
  44             &Identity::new(b"idA"),
  45             &Identity::new(b"idB"),
  46         );
  47         let key1 = s1.finish(msg2.as_slice()).unwrap();
  48         let key2 = s2.finish(msg1.as_slice()).unwrap();
  49         assert_ne!(key1, key2);
  50     }
  51
  52     #[test]
  53     fn test_reflected_message() {
  54         let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
  55             &Password::new(b"password"),
  56             &Identity::new(b"idA"),
  57             &Identity::new(b"idB"),
  58         );
  59         let r = s1.finish(msg1.as_slice());
  60         assert_eq!(
  61             r.unwrap_err(),
  62             SPAKEErr {
  63                 kind: ErrorType::BadSide,
  64             }
  65         );
  66     }
  67
  68     #[test]
  69     fn test_bad_length() {
  70         let (s1, msg1) = SPAKE2::<Ed25519Group>::start_a(
  71             &Password::new(b"password"),
  72             &Identity::new(b"idA"),
  73             &Identity::new(b"idB"),
  74         );
  75         let mut msg2 = Vec::<u8>::with_capacity(msg1.len() + 1);
  76         msg2.resize(msg1.len() + 1, 0u8);
  77         let r = s1.finish(&msg2);
  78         assert_eq!(
  79             r.unwrap_err(),
  80             SPAKEErr {
  81                 kind: ErrorType::WrongLength,
  82             }
  83         );
  84     }
  85
  86     #[test]
  87     fn test_basic_symmetric() {
  88         let (s1, msg1) = SPAKE2::<Ed25519Group>::start_symmetric(
  89             &Password::new(b"password"),
  90             &Identity::new(b"idS"),
  91         );
  92         let (s2, msg2) = SPAKE2::<Ed25519Group>::start_symmetric(
  93             &Password::new(b"password"),
  94             &Identity::new(b"idS"),
  95         );
  96         let key1 = s1.finish(msg2.as_slice()).unwrap();
  97         let key2 = s2.finish(msg1.as_slice()).unwrap();
  98         assert_eq!(key1, key2);
  99     }
 100
 101     #[test]
 102     fn it_works() {}
 103
 104     #[test]
 105     #[should_panic(expected = "nope")]
 106     fn it_panics() {
 107         assert!(false, "nope");
 108     }
 109 }