srp/src/server.rs

   1 //! SRP server implementation
   2 //!
   3 //! # Usage
   4 //! First receive user's username and public value `a_pub`, retrieve from a
   5 //! database `UserRecord` for a given username, generate `b` (e.g. 512 bits
   6 //! long) and initialize SRP server instance:
   7 //!
   8 //! ```ignore
   9 //! use srp::groups::G_2048;
  10 //!
  11 //! let (username, a_pub) = conn.receive_handshake();
  12 //! let user = db.retrieve_user_record(username);
  13 //! let b = rng.gen_iter::<u8>().take(64).collect::<Vec<u8>>();
  14 //! let server = SrpServer::<Sha256>::new(&user, &a_pub, &b, &G_2048)?;
  15 //! ```
  16 //!
  17 //! Next send to user `b_pub` and `salt` from user record:
  18 //!
  19 //! ```ignore
  20 //! let b_pub = server.get_b_pub();
  21 //! conn.reply_to_handshake(&user.salt, b_pub);
  22 //! ```
  23 //!
  24 //! And finally recieve user proof, verify it and send server proof in the
  25 //! reply:
  26 //!
  27 //! ```ignore
  28 //! let user_proof = conn.receive_proof();
  29 //! let server_proof = server.verify(user_proof)?;
  30 //! conn.send_proof(server_proof);
  31 //! ```
  32 //!
  33 //! To get the shared secret use `get_key` method. As alternative to using
  34 //! `verify` method it's also possible to use this key for authentificated
  35 //! encryption.
  36 use std::marker::PhantomData;
  37
  38 use num::{BigUint, Zero};
  39 use digest::Digest;
  40 use generic_array::GenericArray;
  41
  42 use tools::powm;
  43 use types::{SrpAuthError, SrpGroup};
  44
  45 /// Data provided by users upon registration, usually stored in the database.
  46 pub struct UserRecord<'a> {
  47     pub username: &'a [u8],
  48     pub salt: &'a [u8],
  49     /// Password verifier
  50     pub verifier: &'a [u8],
  51 }
  52
  53 /// SRP server state
  54 pub struct SrpServer<D: Digest> {
  55     b: BigUint,
  56     a_pub: BigUint,
  57     b_pub: BigUint,
  58
  59     key: GenericArray<u8, D::OutputSize>,
  60
  61     d: PhantomData<D>
  62 }
  63
  64 impl< D: Digest> SrpServer< D> {
  65     /// Create new server state.
  66     pub fn new(user: &UserRecord, a_pub: &[u8], b: &[u8], params: &SrpGroup)
  67         -> Result<Self, SrpAuthError>
  68     {
  69         let a_pub = BigUint::from_bytes_be(a_pub);
  70         // Safeguard against malicious A
  71         if &a_pub % &params.n == BigUint::zero() {
  72             return Err(SrpAuthError { description: "Malicious a_pub value" })
  73         }
  74         let v = BigUint::from_bytes_be(user.verifier);
  75         let b = BigUint::from_bytes_be(b)  % &params.n;
  76         let k = params.compute_k::<D>();
  77         // kv + g^b
  78         let interm = (k * &v) % &params.n;
  79         let b_pub = (interm + &params.powm(&b)) % &params.n;
  80         // H(A || B)
  81         let u = {
  82             let mut d = D::new();
  83             d.input(&a_pub.to_bytes_be());
  84             d.input(&b_pub.to_bytes_be());
  85             d.result()
  86         };
  87         let d = Default::default();
  88         //(Av^u) ^ b
  89         let key = {
  90             let u =  BigUint::from_bytes_be(&u);
  91             let t = (&a_pub * powm(&v, &u, &params.n)) % &params.n;
  92             let s = powm(&t, &b, &params.n);
  93             D::digest(&s.to_bytes_be())
  94         };
  95         Ok(Self { b, a_pub, b_pub, key, d})
  96     }
  97
  98     /// Get private `b` value. (see `new_with_b` documentation)
  99     pub fn get_b(&self) -> Vec<u8> {
 100         self.b.to_bytes_be()
 101     }
 102
 103     /// Get public `b_pub` value for sending to the user.
 104     pub fn get_b_pub(&self) -> Vec<u8> {
 105         self.b_pub.to_bytes_be()
 106     }
 107
 108     /// Get shared secret between user and the server. (do not forget to verify
 109     /// that keys are the same!)
 110     pub fn get_key(&self) -> GenericArray<u8, D::OutputSize> {
 111         self.key.clone()
 112     }
 113
 114     /// Process user proof of having the same shared secret and compute
 115     /// server proof for sending to the user.
 116     pub fn verify(&self, user_proof: &[u8])
 117         -> Result<GenericArray<u8, D::OutputSize>, SrpAuthError>
 118     {
 119         // M = H(A, B, K)
 120         let mut d = D::new();
 121         d.input(&self.a_pub.to_bytes_be());
 122         d.input(&self.b_pub.to_bytes_be());
 123         d.input(&self.key);
 124
 125         if user_proof == d.result().as_slice() {
 126             // H(A, M, K)
 127             let mut d = D::new();
 128             d.input(&self.a_pub.to_bytes_be());
 129             d.input(user_proof);
 130             d.input(&self.key);
 131             Ok(d.result())
 132         } else {
 133             Err(SrpAuthError { description: "Incorrect user proof" })
 134         }
 135     }
 136 }