From 782eeb70900eaee3220f67b0f99967d60702b212 Mon Sep 17 00:00:00 2001 From: Kevin Lewi Date: Wed, 17 Feb 2021 02:47:00 -0800 Subject: [PATCH] Converting to_bytes and try_from to serialize() and deserialize() (#138) --- examples/digital_locker.rs | 6 +- examples/simple_login.rs | 5 +- src/envelope.rs | 5 -- src/lib.rs | 37 ++++------ src/messages.rs | 105 +-------------------------- src/opaque.rs | 121 ++++++++++++++----------------- src/serialization/tests.rs | 36 ++++----- src/tests/full_test.rs | 58 ++++++++------- src/tests/opaque_test_vectors.rs | 10 +-- 9 files changed, 132 insertions(+), 251 deletions(-) diff --git a/examples/digital_locker.rs b/examples/digital_locker.rs index 7ad85c8..8107238 100644 --- a/examples/digital_locker.rs +++ b/examples/digital_locker.rs @@ -28,7 +28,6 @@ use chacha20poly1305::aead::{Aead, NewAead}; use chacha20poly1305::{ChaCha20Poly1305, Key, Nonce}; use rustyline::error::ReadlineError; use rustyline::Editor; -use std::convert::TryFrom; use std::process::exit; use opaque_ke::{ @@ -129,7 +128,7 @@ fn register_locker( Locker { contents: ciphertext, - password_file: password_file.to_bytes(), + password_file: password_file.serialize(), } } @@ -150,7 +149,8 @@ fn open_locker( // Client sends credential_request_bytes to server - let password_file = ServerRegistration::::try_from(&locker.password_file[..]).unwrap(); + let password_file = + ServerRegistration::::deserialize(&locker.password_file[..]).unwrap(); let mut server_rng = OsRng; let server_login_start_result = ServerLogin::start( &mut server_rng, diff --git a/examples/simple_login.rs b/examples/simple_login.rs index 598701f..44f9572 100644 --- a/examples/simple_login.rs +++ b/examples/simple_login.rs @@ -23,7 +23,6 @@ use rustyline::error::ReadlineError; use rustyline::Editor; use std::collections::HashMap; -use std::convert::TryFrom; use std::process::exit; use opaque_ke::{ @@ -84,7 +83,7 @@ fn account_registration( .state .finish(RegistrationUpload::deserialize(&message_bytes[..]).unwrap()) .unwrap(); - password_file.to_bytes() + password_file.serialize() } // Password-based login between a client and server @@ -104,7 +103,7 @@ fn account_login( // Client sends credential_request_bytes to server - let password_file = ServerRegistration::::try_from(password_file_bytes).unwrap(); + let password_file = ServerRegistration::::deserialize(password_file_bytes).unwrap(); let mut server_rng = OsRng; let server_login_start_result = ServerLogin::start( &mut server_rng, diff --git a/src/envelope.rs b/src/envelope.rs index 380faf9..bb1b654 100644 --- a/src/envelope.rs +++ b/src/envelope.rs @@ -113,11 +113,6 @@ pub(crate) struct OpenedInnerEnvelope { } impl Envelope { - /// The additional number of bytes added to the plaintext - pub(crate) fn additional_size() -> usize { - NONCE_LEN + ::OutputSize::to_usize() - } - fn hmac_key_size() -> usize { ::OutputSize::to_usize() } diff --git a/src/lib.rs b/src/lib.rs index c53240c..81e3ca7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -169,7 +169,7 @@ //! a [ServerRegistration] from the second step. //! The server runs [ServerRegistration::finish] to produce a finalized [ServerRegistration]. //! At this point, the client can be considered as successfully registered, and the server can invoke -//! [ServerRegistration::to_bytes] to store the password file for use during the login protocol. +//! [ServerRegistration::serialize] to store the password file for use during the login protocol. //! ``` //! # use opaque_ke::{ //! # errors::ProtocolError, @@ -268,15 +268,14 @@ //! # let server_kp = Default::generate_random_keypair(&mut server_rng); //! # let server_registration_start_result = ServerRegistration::::start(&mut server_rng, client_registration_start_result.message, server_kp.public())?; //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::default())?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; //! use opaque_ke::{ServerLogin, ServerLoginStartParameters}; -//! use std::convert::TryFrom; -//! let password_file = ServerRegistration::::try_from(&password_file_bytes[..])?; +//! let password_file = ServerRegistration::::deserialize(&password_file_bytes[..])?; //! let mut server_rng = OsRng; //! let server_login_start_result = ServerLogin::start( //! &mut server_rng, @@ -317,15 +316,14 @@ //! # let server_kp = Default::generate_random_keypair(&mut server_rng); //! # let server_registration_start_result = ServerRegistration::::start(&mut server_rng, client_registration_start_result.message, server_kp.public())?; //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::default())?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; -//! # use std::convert::TryFrom; //! # let password_file = -//! # ServerRegistration::::try_from( +//! # ServerRegistration::::deserialize( //! # &password_file_bytes[..], //! # )?; //! # let server_login_start_result = @@ -364,15 +362,14 @@ //! # let server_kp = Default::generate_random_keypair(&mut server_rng); //! # let server_registration_start_result = ServerRegistration::::start(&mut server_rng, client_registration_start_result.message, server_kp.public())?; //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::default())?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; -//! # use std::convert::TryFrom; //! # let password_file = -//! # ServerRegistration::::try_from( +//! # ServerRegistration::::deserialize( //! # &password_file_bytes[..], //! # )?; //! # let server_login_start_result = @@ -444,15 +441,14 @@ //! // During setup or registration, the server transmits its static public key to the client //! let server_s_pk = server_kp.public(); // obtained from the server //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::default())?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; -//! # use std::convert::TryFrom; //! # let password_file = -//! # ServerRegistration::::try_from( +//! # ServerRegistration::::deserialize( //! # &password_file_bytes[..], //! # )?; //! # let server_login_start_result = @@ -522,15 +518,14 @@ //! server_registration_start_result.message, //! ClientRegistrationFinishParameters::default() //! )?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; -//! # use std::convert::TryFrom; //! # let password_file = -//! # ServerRegistration::::try_from( +//! # ServerRegistration::::deserialize( //! # &password_file_bytes[..], //! # )?; //! # let server_login_start_result = @@ -617,15 +612,14 @@ //! # let server_kp = Default::generate_random_keypair(&mut server_rng); //! # let server_registration_start_result = ServerRegistration::::start(&mut server_rng, client_registration_start_result.message, server_kp.public())?; //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::WithIdentifiers(b"username".to_vec(), b"facebook.com".to_vec()))?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; //! # use opaque_ke::{ServerLogin, ServerLoginStartParameters}; -//! # use std::convert::TryFrom; -//! # let password_file = ServerRegistration::::try_from(&password_file_bytes[..])?; +//! # let password_file = ServerRegistration::::deserialize(&password_file_bytes[..])?; //! # let mut server_rng = OsRng; //! let server_login_start_result = ServerLogin::start( //! &mut server_rng, @@ -665,15 +659,14 @@ //! # let server_kp = Default::generate_random_keypair(&mut server_rng); //! # let server_registration_start_result = ServerRegistration::::start(&mut server_rng, client_registration_start_result.message, server_kp.public())?; //! # let client_registration_finish_result = client_registration_start_result.state.finish(&mut client_rng, server_registration_start_result.message, ClientRegistrationFinishParameters::WithIdentifiers(b"username".to_vec(), b"facebook.com".to_vec()))?; -//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.to_bytes(); +//! # let password_file_bytes = server_registration_start_result.state.finish(client_registration_finish_result.message)?.serialize(); //! # let client_login_start_result = ClientLogin::::start( //! # &mut client_rng, //! # b"password", //! # ClientLoginStartParameters::default(), //! # )?; -//! # use std::convert::TryFrom; //! # let password_file = -//! # ServerRegistration::::try_from( +//! # ServerRegistration::::deserialize( //! # &password_file_bytes[..], //! # )?; //! # let server_login_start_result = diff --git a/src/messages.rs b/src/messages.rs index 090a3b3..17209c5 100644 --- a/src/messages.rs +++ b/src/messages.rs @@ -30,26 +30,7 @@ pub struct RegistrationRequest { pub(crate) alpha: CS::Group, } -impl TryFrom<&[u8]> for RegistrationRequest { - type Error = ProtocolError; - fn try_from(first_message_bytes: &[u8]) -> Result { - let elem_len = ::ElemLen::to_usize(); - let checked_slice = check_slice_size(first_message_bytes, elem_len, "first_message_bytes")?; - - // Check that the message is actually containing an element of the - // correct subgroup - let arr = GenericArray::from_slice(&checked_slice[checked_slice.len() - elem_len..]); - let alpha = CS::Group::from_element_slice(arr)?; - Ok(Self { alpha }) - } -} - impl RegistrationRequest { - /// Byte representation for the registration request - pub fn to_bytes(&self) -> Vec { - self.alpha.to_arr().to_vec() - } - /// Serialization into bytes pub fn serialize(&self) -> Vec { self.alpha.to_arr().to_vec() @@ -76,32 +57,7 @@ pub struct RegistrationResponse { pub(crate) server_s_pk: Vec, } -impl TryFrom<&[u8]> for RegistrationResponse { - type Error = ProtocolError; - - fn try_from(bytes: &[u8]) -> Result { - let elem_len = ::ElemLen::to_usize(); - let checked_slice = check_slice_size_atleast(bytes, elem_len, "second_message_bytes")?; - - // Check that the message is actually containing an element of the - // correct subgroup - let arr = GenericArray::from_slice(&checked_slice[..elem_len]); - let beta = CS::Group::from_element_slice(arr)?; - - // FIXME check public key bytes - let server_s_pk = checked_slice[elem_len..].to_vec(); - - Ok(Self { beta, server_s_pk }) - } -} - impl RegistrationResponse { - /// Byte representation for the registration response message. This does not - /// include the envelope credentials format - pub fn to_bytes(&self) -> Vec { - [&self.beta.to_arr().to_vec()[..], &self.server_s_pk[..]].concat() - } - /// Serialization into bytes pub fn serialize(&self) -> Vec { let mut registration_response: Vec = Vec::new(); @@ -139,27 +95,6 @@ pub struct RegistrationUpload { pub(crate) client_s_pk: Key, } -impl TryFrom<&[u8]> for RegistrationUpload { - type Error = ProtocolError; - - fn try_from(third_message_bytes: &[u8]) -> Result { - let key_len = ::Len::to_usize(); - let envelope_size = key_len + Envelope::::additional_size(); - let checked_bytes = check_slice_size( - third_message_bytes, - envelope_size + key_len, - "third_message", - )?; - let unchecked_client_s_pk = Key::from_bytes(&checked_bytes[envelope_size..])?; - let client_s_pk = KeyPair::::check_public_key(unchecked_client_s_pk)?; - - Ok(Self { - envelope: Envelope::::from_bytes(&checked_bytes[..envelope_size])?, - client_s_pk, - }) - } -} - impl RegistrationUpload { /// Serialization into bytes pub fn serialize(&self) -> Vec { @@ -192,19 +127,7 @@ pub struct CredentialRequest { pub(crate) ke1_message: >::KE1Message, } -impl TryFrom<&[u8]> for CredentialRequest { - type Error = ProtocolError; - fn try_from(first_message_bytes: &[u8]) -> Result { - Self::deserialize(first_message_bytes) - } -} - impl CredentialRequest { - /// byte representation for the login request - pub(crate) fn to_bytes(&self) -> Vec { - [&self.alpha.to_arr()[..], &self.ke1_message.to_bytes()].concat() - } - /// Serialization into bytes pub fn serialize(&self) -> Vec { let mut credential_request: Vec = Vec::new(); @@ -270,16 +193,9 @@ impl CredentialResponse { /// Deserialization from bytes pub fn deserialize(input: &[u8]) -> Result { - Self::try_from(input) - } -} - -impl TryFrom<&[u8]> for CredentialResponse { - type Error = ProtocolError; - fn try_from(second_message_bytes: &[u8]) -> Result { let elem_len = ::ElemLen::to_usize(); let checked_slice = - check_slice_size_atleast(second_message_bytes, elem_len, "login_second_message_bytes")?; + check_slice_size_atleast(input, elem_len, "login_second_message_bytes")?; // Check that the message is actually containing an element of the // correct subgroup @@ -321,16 +237,6 @@ pub struct CredentialFinalization { pub(crate) ke3_message: >::KE3Message, } -impl TryFrom<&[u8]> for CredentialFinalization { - type Error = ProtocolError; - - fn try_from(bytes: &[u8]) -> Result { - let ke3_message = - >::KE3Message::try_from(bytes)?; - Ok(Self { ke3_message }) - } -} - impl CredentialFinalization { /// Serialization into bytes pub fn serialize(&self) -> Vec { @@ -339,11 +245,8 @@ impl CredentialFinalization { /// Deserialization from bytes pub fn deserialize(input: &[u8]) -> Result { - Self::try_from(input) - } - - /// byte representation for the login finalization - pub fn to_bytes(&self) -> Vec { - self.ke3_message.to_bytes() + let ke3_message = + >::KE3Message::try_from(input)?; + Ok(Self { ke3_message }) } } diff --git a/src/opaque.rs b/src/opaque.rs index 9f41bd2..05077e2 100644 --- a/src/opaque.rs +++ b/src/opaque.rs @@ -38,9 +38,19 @@ pub struct ClientRegistration { pub(crate) token: oprf::Token, } -impl TryFrom<&[u8]> for ClientRegistration { - type Error = ProtocolError; - fn try_from(input: &[u8]) -> Result { +impl ClientRegistration { + /// Serialization into bytes + pub fn serialize(&self) -> Vec { + let output: Vec = [ + &CS::Group::scalar_as_bytes(&self.token.blind)[..], + &self.token.data, + ] + .concat(); + output + } + + /// Deserialization from bytes + pub fn deserialize(input: &[u8]) -> Result { let min_expected_len = ::ScalarLen::to_usize(); let checked_slice = (if input.len() <= min_expected_len { Err(InternalPakeError::SizeError { @@ -67,18 +77,6 @@ impl TryFrom<&[u8]> for ClientRegistration { } } -impl ClientRegistration { - /// byte representation for the client's registration state - pub fn to_bytes(&self) -> Vec { - let output: Vec = [ - &CS::Group::scalar_as_bytes(&self.token.blind)[..], - &self.token.data, - ] - .concat(); - output - } -} - /// Optional parameters for client registration finish pub enum ClientRegistrationFinishParameters { /// Specifying the identifiers idU and idS (corresponding to custom identifier mode) @@ -254,12 +252,21 @@ pub struct ServerRegistration { pub(crate) oprf_key: ::Scalar, } -impl TryFrom<&[u8]> for ServerRegistration { - type Error = ProtocolError; +impl ServerRegistration { + /// Serialization into bytes + pub fn serialize(&self) -> Vec { + let mut output: Vec = CS::Group::scalar_as_bytes(&self.oprf_key).to_vec(); + self.client_s_pk + .iter() + .for_each(|v| output.extend_from_slice(&v.to_arr())); + self.envelope + .iter() + .for_each(|v| output.extend_from_slice(&v.to_bytes())); + output + } - /// The format of a serialized ServerRegistration object: - /// oprf_key | client_s_pk | envelope - fn try_from(input: &[u8]) -> Result { + /// Deserialization from bytes + pub fn deserialize(input: &[u8]) -> Result { let scalar_len = ::ScalarLen::to_usize(); if input.len() == scalar_len { return Ok(Self { @@ -289,20 +296,6 @@ impl TryFrom<&[u8]> for ServerRegistration { oprf_key, }) } -} - -impl ServerRegistration { - /// byte representation for the server's registration state - pub fn to_bytes(&self) -> Vec { - let mut output: Vec = CS::Group::scalar_as_bytes(&self.oprf_key).to_vec(); - self.client_s_pk - .iter() - .for_each(|v| output.extend_from_slice(&v.to_arr())); - self.envelope - .iter() - .for_each(|v| output.extend_from_slice(&v.to_bytes())); - output - } /// From the client's "blinded" password, returns a response to be /// sent back to the client, as well as a ServerRegistration @@ -405,9 +398,21 @@ pub struct ClientLogin { serialized_credential_request: Vec, } -impl TryFrom<&[u8]> for ClientLogin { - type Error = ProtocolError; - fn try_from(input: &[u8]) -> Result { +impl ClientLogin { + /// Serialization into bytes + pub fn serialize(&self) -> Vec { + let output: Vec = [ + &CS::Group::scalar_as_bytes(&self.token.blind)[..], + &serialize(&self.serialized_credential_request, 2), + &serialize(&self.ke1_state.to_bytes(), 2), + &self.token.data, + ] + .concat(); + output + } + + /// Deserialization from bytes + pub fn deserialize(input: &[u8]) -> Result { let scalar_len = ::ScalarLen::to_usize(); let checked_slice = (if input.len() <= scalar_len { Err(InternalPakeError::SizeError { @@ -439,20 +444,6 @@ impl TryFrom<&[u8]> for ClientLogin { } } -impl ClientLogin { - /// byte representation for the client's login state - pub fn to_bytes(&self) -> Vec { - let output: Vec = [ - &CS::Group::scalar_as_bytes(&self.token.blind)[..], - &serialize(&self.serialized_credential_request, 2), - &serialize(&self.ke1_state.to_bytes(), 2), - &self.token.data, - ] - .concat(); - output - } -} - /// Optional parameters for client login start pub enum ClientLoginStartParameters { /// Specifying a plaintext info field that will be sent to the server @@ -652,18 +643,6 @@ pub struct ServerLogin { _cs: PhantomData, } -impl TryFrom<&[u8]> for ServerLogin { - type Error = ProtocolError; - fn try_from(bytes: &[u8]) -> Result { - Ok(Self { - _cs: PhantomData, - ke2_state: >::KE2State::try_from( - bytes, - )?, - }) - } -} - /// Optional parameters for server login start pub enum ServerLoginStartParameters { /// Specifying a confidential info field that will be sent to the client @@ -699,11 +678,21 @@ pub struct ServerLoginFinishResult { } impl ServerLogin { - /// byte representation for the server's login state - pub fn to_bytes(&self) -> Vec { + /// Serialization into bytes + pub fn serialize(&self) -> Vec { self.ke2_state.to_bytes() } + /// Deserialization from bytes + pub fn deserialize(bytes: &[u8]) -> Result { + Ok(Self { + _cs: PhantomData, + ke2_state: >::KE2State::try_from( + bytes, + )?, + }) + } + /// From the client's "blinded"" password, returns a challenge to be /// sent back to the client, as well as a ServerLogin /// @@ -773,7 +762,7 @@ impl ServerLogin { Some((id_u, id_s)) => (id_u, id_s), }; - let l1_bytes = &l1.to_bytes(); + let l1_bytes = &l1.serialize(); let beta = oprf::evaluate(l1.alpha, &password_file.oprf_key); let server_s_pk = KeyPair::::public_from_private(&server_s_sk); diff --git a/src/serialization/tests.rs b/src/serialization/tests.rs index 22bb3c9..4b9745d 100644 --- a/src/serialization/tests.rs +++ b/src/serialization/tests.rs @@ -58,8 +58,8 @@ fn client_registration_roundtrip() { // serialization order: scalar, password let bytes: Vec = [&sc.as_bytes()[..], &pw[..]].concat(); - let reg = ClientRegistration::::try_from(&bytes[..]).unwrap(); - let reg_bytes = reg.to_bytes(); + let reg = ClientRegistration::::deserialize(&bytes[..]).unwrap(); + let reg_bytes = reg.serialize(); assert_eq!(reg_bytes, bytes); } @@ -71,8 +71,8 @@ fn server_registration_roundtrip() { let oprf_key = ::random_scalar(&mut rng); let mut oprf_bytes: Vec = vec![]; oprf_bytes.extend_from_slice(oprf_key.as_bytes()); - let reg = ServerRegistration::::try_from(&oprf_bytes[..]).unwrap(); - let reg_bytes = reg.to_bytes(); + let reg = ServerRegistration::::deserialize(&oprf_bytes[..]).unwrap(); + let reg_bytes = reg.serialize(); assert_eq!(reg_bytes, oprf_bytes); // If we do have envelope and client pk, the server registration contains // the whole kit @@ -90,8 +90,8 @@ fn server_registration_roundtrip() { bytes.extend_from_slice(oprf_key.as_bytes()); bytes.extend_from_slice(&mock_client_kp.public().to_arr()); bytes.extend_from_slice(&mock_envelope_bytes); - let reg = ServerRegistration::::try_from(&bytes[..]).unwrap(); - let reg_bytes = reg.to_bytes(); + let reg = ServerRegistration::::deserialize(&bytes[..]).unwrap(); + let reg_bytes = reg.serialize(); assert_eq!(reg_bytes, bytes); } @@ -279,8 +279,8 @@ fn client_login_roundtrip() { &pw[..], ] .concat(); - let reg = ClientLogin::::try_from(&bytes[..]).unwrap(); - let reg_bytes = reg.to_bytes(); + let reg = ClientLogin::::deserialize(&bytes[..]).unwrap(); + let reg_bytes = reg.serialize(); assert_eq!(reg_bytes, bytes); } @@ -359,52 +359,52 @@ fn test_i2osp_os2ip(bytes in vec(any::(), 0..std::mem::size_of::())) #[test] fn test_nocrash_register_first_message(bytes in vec(any::(), 0..200)) { - RegistrationRequest::::try_from(&bytes[..]).map_or(true, |_| true); + RegistrationRequest::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_register_second_message(bytes in vec(any::(), 0..200)) { - RegistrationResponse::::try_from(&bytes[..]).map_or(true, |_| true); + RegistrationResponse::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_register_third_message(bytes in vec(any::(), 0..200)) { - RegistrationUpload::::try_from(&bytes[..]).map_or(true, |_| true); + RegistrationUpload::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_login_first_message(bytes in vec(any::(), 0..500)) { - CredentialRequest::::try_from(&bytes[..]).map_or(true, |_| true); + CredentialRequest::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_login_second_message(bytes in vec(any::(), 0..500)) { - CredentialResponse::::try_from(&bytes[..]).map_or(true, |_| true); + CredentialResponse::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_login_third_message(bytes in vec(any::(), 0..500)) { - CredentialFinalization::::try_from(&bytes[..]).map_or(true, |_| true); + CredentialFinalization::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_client_registration(bytes in vec(any::(), 0..700)) { - ClientRegistration::::try_from(&bytes[..]).map_or(true, |_| true); + ClientRegistration::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_server_registration(bytes in vec(any::(), 0..700)) { - ServerRegistration::::try_from(&bytes[..]).map_or(true, |_| true); + ServerRegistration::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_client_login(bytes in vec(any::(), 0..700)) { - ClientLogin::::try_from(&bytes[..]).map_or(true, |_| true); + ClientLogin::::deserialize(&bytes[..]).map_or(true, |_| true); } #[test] fn test_nocrash_server_login(bytes in vec(any::(), 0..700)) { - ServerLogin::::try_from(&bytes[..]).map_or(true, |_| true); + ServerLogin::::deserialize(&bytes[..]).map_or(true, |_| true); } } diff --git a/src/tests/full_test.rs b/src/tests/full_test.rs index 7a49e33..1c448f7 100644 --- a/src/tests/full_test.rs +++ b/src/tests/full_test.rs @@ -300,7 +300,7 @@ fn generate_parameters() -> TestVectorParameters { .message .serialize() .to_vec(); - let client_registration_state = client_registration_start_result.state.to_bytes().to_vec(); + let client_registration_state = client_registration_start_result.state.serialize().to_vec(); let mut oprf_key_rng = CycleRng::new(oprf_key_raw.to_vec()); let server_registration_start_result = ServerRegistration::::start( @@ -315,7 +315,7 @@ fn generate_parameters() -> TestVectorParameters { .to_vec(); let oprf_key_bytes = CS::Group::scalar_as_bytes(&server_registration_start_result.state.oprf_key).clone(); - let server_registration_state = server_registration_start_result.state.to_bytes().to_vec(); + let server_registration_state = server_registration_start_result.state.serialize().to_vec(); let mut client_s_sk_and_nonce: Vec = Vec::new(); client_s_sk_and_nonce.extend_from_slice(&client_s_kp.private().to_arr()); @@ -339,7 +339,7 @@ fn generate_parameters() -> TestVectorParameters { .state .finish(client_registration_finish_result.message) .unwrap(); - let password_file_bytes = password_file.to_bytes(); + let password_file_bytes = password_file.serialize(); let mut client_login_start: Vec = Vec::new(); client_login_start.extend_from_slice(&blinding_factor_bytes); @@ -354,7 +354,7 @@ fn generate_parameters() -> TestVectorParameters { ) .unwrap(); let credential_request_bytes = client_login_start_result.message.serialize().to_vec(); - let client_login_state = client_login_start_result.state.to_bytes().to_vec(); + let client_login_state = client_login_start_result.state.serialize().to_vec(); let mut server_e_sk_and_nonce_rng = CycleRng::new( [ @@ -376,7 +376,7 @@ fn generate_parameters() -> TestVectorParameters { ) .unwrap(); let credential_response_bytes = server_login_start_result.message.serialize().to_vec(); - let server_login_state = server_login_start_result.state.to_bytes().to_vec(); + let server_login_state = server_login_start_result.state.serialize().to_vec(); let client_login_finish_result = client_login_start_result .state @@ -385,7 +385,7 @@ fn generate_parameters() -> TestVectorParameters { ClientLoginFinishParameters::WithIdentifiers(id_u.to_vec(), id_s.to_vec()), ) .unwrap(); - let credential_finalization_bytes = client_login_finish_result.message.to_bytes().to_vec(); + let credential_finalization_bytes = client_login_finish_result.message.serialize(); TestVectorParameters { client_s_pk: client_s_kp.public().to_arr().to_vec(), @@ -440,7 +440,7 @@ fn test_registration_request() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.client_registration_state), - hex::encode(client_registration_start_result.state.to_bytes()) + hex::encode(client_registration_start_result.state.serialize()) ); Ok(()) } @@ -461,7 +461,7 @@ fn test_registration_response() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.server_registration_state), - hex::encode(server_registration_start_result.state.to_bytes()) + hex::encode(server_registration_start_result.state.serialize()) ); Ok(()) } @@ -473,7 +473,7 @@ fn test_registration_upload() -> Result<(), ProtocolError> { let client_s_sk_and_nonce: Vec = [parameters.client_s_sk, parameters.envelope_nonce].concat(); let mut finish_registration_rng = CycleRng::new(client_s_sk_and_nonce); - let result = ClientRegistration::::try_from( + let result = ClientRegistration::::deserialize( ¶meters.client_registration_state[..], )? .finish( @@ -498,7 +498,7 @@ fn test_registration_upload() -> Result<(), ProtocolError> { fn test_password_file() -> Result<(), ProtocolError> { let parameters = populate_test_vectors(&serde_json::from_str(TEST_VECTOR).unwrap()); - let server_registration = ServerRegistration::::try_from( + let server_registration = ServerRegistration::::deserialize( ¶meters.server_registration_state[..], )?; let password_file = server_registration.finish(RegistrationUpload::deserialize( @@ -507,7 +507,7 @@ fn test_password_file() -> Result<(), ProtocolError> { assert_eq!( hex::encode(parameters.password_file), - hex::encode(password_file.to_bytes()) + hex::encode(password_file.serialize()) ); Ok(()) } @@ -534,7 +534,7 @@ fn test_credential_request() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.client_login_state), - hex::encode(client_login_start_result.state.to_bytes()) + hex::encode(client_login_start_result.state.serialize()) ); Ok(()) } @@ -547,7 +547,7 @@ fn test_credential_response() -> Result<(), ProtocolError> { CycleRng::new([parameters.server_e_sk, parameters.server_nonce].concat()); let server_login_start_result = ServerLogin::::start( &mut server_e_sk_and_nonce_rng, - ServerRegistration::try_from(¶meters.password_file[..])?, + ServerRegistration::deserialize(¶meters.password_file[..])?, &Key::try_from(¶meters.server_s_sk[..])?, CredentialRequest::::deserialize( ¶meters.credential_request[..], @@ -568,7 +568,7 @@ fn test_credential_response() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.server_login_state), - hex::encode(server_login_start_result.state.to_bytes()) + hex::encode(server_login_start_result.state.serialize()) ); Ok(()) } @@ -577,14 +577,15 @@ fn test_credential_response() -> Result<(), ProtocolError> { fn test_credential_finalization() -> Result<(), ProtocolError> { let parameters = populate_test_vectors(&serde_json::from_str(TEST_VECTOR).unwrap()); - let client_login_finish_result = - ClientLogin::::try_from(¶meters.client_login_state[..])? - .finish( - CredentialResponse::::deserialize( - ¶meters.credential_response[..], - )?, - ClientLoginFinishParameters::WithIdentifiers(parameters.id_u, parameters.id_s), - )?; + let client_login_finish_result = ClientLogin::::deserialize( + ¶meters.client_login_state[..], + )? + .finish( + CredentialResponse::::deserialize( + ¶meters.credential_response[..], + )?, + ClientLoginFinishParameters::WithIdentifiers(parameters.id_u, parameters.id_s), + )?; assert_eq!( hex::encode(¶meters.einfo2), @@ -600,7 +601,7 @@ fn test_credential_finalization() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.credential_finalization), - hex::encode(client_login_finish_result.message.to_bytes()) + hex::encode(client_login_finish_result.message.serialize()) ); assert_eq!( hex::encode(¶meters.export_key), @@ -614,11 +615,12 @@ fn test_credential_finalization() -> Result<(), ProtocolError> { fn test_server_login_finish() -> Result<(), ProtocolError> { let parameters = populate_test_vectors(&serde_json::from_str(TEST_VECTOR).unwrap()); - let server_login_result = - ServerLogin::::try_from(¶meters.server_login_state[..])? - .finish(CredentialFinalization::try_from( - ¶meters.credential_finalization[..], - )?)?; + let server_login_result = ServerLogin::::deserialize( + ¶meters.server_login_state[..], + )? + .finish(CredentialFinalization::deserialize( + ¶meters.credential_finalization[..], + )?)?; assert_eq!( hex::encode(parameters.session_key), diff --git a/src/tests/opaque_test_vectors.rs b/src/tests/opaque_test_vectors.rs index 88cf8c0..7c1f741 100644 --- a/src/tests/opaque_test_vectors.rs +++ b/src/tests/opaque_test_vectors.rs @@ -354,7 +354,7 @@ fn get_password_file_bytes(parameters: &TestVectorParameters) -> Result, .state .finish(RegistrationUpload::deserialize(¶meters.registration_upload[..]).unwrap())?; - Ok(password_file.to_bytes()) + Ok(password_file.serialize()) } #[test] @@ -463,7 +463,7 @@ fn test_ke2() -> Result<(), ProtocolError> { CycleRng::new([parameters.server_private_keyshare, parameters.server_nonce].concat()); let server_login_start_result = ServerLogin::::start( &mut server_private_keyshare_and_nonce_rng, - ServerRegistration::try_from(&password_file_bytes[..]).unwrap(), + ServerRegistration::deserialize(&password_file_bytes[..]).unwrap(), &Key::try_from(¶meters.server_private_key[..]).unwrap(), CredentialRequest::::deserialize(¶meters.KE1[..]) .unwrap(), @@ -527,7 +527,7 @@ fn test_ke3() -> Result<(), ProtocolError> { ); assert_eq!( hex::encode(¶meters.KE3), - hex::encode(client_login_finish_result.message.to_bytes()) + hex::encode(client_login_finish_result.message.serialize()) ); assert_eq!( hex::encode(¶meters.export_key), @@ -546,7 +546,7 @@ fn test_server_login_finish() -> Result<(), ProtocolError> { CycleRng::new([parameters.server_private_keyshare, parameters.server_nonce].concat()); let server_login_start_result = ServerLogin::::start( &mut server_private_keyshare_and_nonce_rng, - ServerRegistration::try_from(&password_file_bytes[..]).unwrap(), + ServerRegistration::deserialize(&password_file_bytes[..]).unwrap(), &Key::try_from(¶meters.server_private_key[..]).unwrap(), CredentialRequest::::deserialize(¶meters.KE1[..]) .unwrap(), @@ -563,7 +563,7 @@ fn test_server_login_finish() -> Result<(), ProtocolError> { let server_login_result = server_login_start_result .state - .finish(CredentialFinalization::try_from(¶meters.KE3[..])?)?; + .finish(CredentialFinalization::deserialize(¶meters.KE3[..])?)?; assert_eq!( hex::encode(parameters.session_key),