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