From 87b2a4bed460dcf17cc43f498af572170fc71377 Mon Sep 17 00:00:00 2001 From: raphaelrobert Date: Mon, 2 May 2022 16:13:07 +0200 Subject: [PATCH] Expand benchmarks & fix clippy warnings --- benches/benchmarks.rs | 182 ++++++++++++++++++++++++++++++++++-------- src/dleq.rs | 13 ++- src/oprf.rs | 8 +- 3 files changed, 159 insertions(+), 44 deletions(-) diff --git a/benches/benchmarks.rs b/benches/benchmarks.rs index 0f8fbe8..3e25cc4 100644 --- a/benches/benchmarks.rs +++ b/benches/benchmarks.rs @@ -14,36 +14,154 @@ use challenge_bypass_ristretto::errors::*; type HmacSha512 = Hmac; pub fn e2e_server_benchmarks(c: &mut Criterion) { - let mut rng = OsRng; - let signing_key = SigningKey::random(&mut rng); - let n_tokens = 30; - - let mut client = Client { - tokens: Vec::new(), - blinded_tokens: Vec::new(), - unblinded_tokens: Vec::new(), - }; - - let mut server = Server { - signing_key, - spent_tokens: Vec::new(), - }; - - let signing_req = client.create_tokens(n_tokens); - - c.bench_function("sing pre-tokens", |b| { - b.iter(|| { - let _signing_resp = server.sign_tokens(signing_req.clone()); - }); - }); - - let redeem_request = client.redeem_tokens(); - - c.bench_function("redeem tokens", |b| { - b.iter(|| { - server.redeem_tokens(&redeem_request); - }); - }); + for n_tokens in [1, 10, 100, 1000] { + c.bench_function( + &format!("client create tokens, batch size: {}", n_tokens), + |b| { + b.iter_batched( + || Client { + tokens: Vec::new(), + blinded_tokens: Vec::new(), + unblinded_tokens: Vec::new(), + }, + |mut client| { + client.create_tokens(n_tokens); + }, + criterion::BatchSize::SmallInput, + ); + }, + ); + + c.bench_function( + &format!("server sign pre-tokens, batch size: {}", n_tokens), + |b| { + b.iter_batched( + || { + let mut rng = OsRng; + let signing_key = SigningKey::random(&mut rng); + + let mut client = Client { + tokens: Vec::new(), + blinded_tokens: Vec::new(), + unblinded_tokens: Vec::new(), + }; + let server = Server { + signing_key, + spent_tokens: Vec::new(), + }; + + let signing_req = client.create_tokens(n_tokens); + (server, signing_req) + }, + |(server, signing_req)| { + server.sign_tokens(signing_req); + }, + criterion::BatchSize::SmallInput, + ); + }, + ); + + c.bench_function( + &format!("client unblind & verify tokens, batch size: {}", n_tokens), + |b| { + b.iter_batched( + || { + let mut rng = OsRng; + let signing_key = SigningKey::random(&mut rng); + + let mut client = Client { + tokens: Vec::new(), + blinded_tokens: Vec::new(), + unblinded_tokens: Vec::new(), + }; + let server = Server { + signing_key, + spent_tokens: Vec::new(), + }; + + let signing_req = client.create_tokens(n_tokens); + + let signing_res = server.sign_tokens(signing_req); + + (client, signing_res) + }, + |(mut client, signing_res)| { + client + .store_signed_tokens(signing_res) + .expect("Could not store tokens."); + }, + criterion::BatchSize::SmallInput, + ); + }, + ); + + c.bench_function( + &format!("client redeem tokens, batch size: {}", n_tokens), + |b| { + b.iter_batched( + || { + let mut rng = OsRng; + let signing_key = SigningKey::random(&mut rng); + + let mut client = Client { + tokens: Vec::new(), + blinded_tokens: Vec::new(), + unblinded_tokens: Vec::new(), + }; + let server = Server { + signing_key, + spent_tokens: Vec::new(), + }; + + let signing_req = client.create_tokens(n_tokens); + + let signing_resp = server.sign_tokens(signing_req); + client.store_signed_tokens(signing_resp).unwrap(); + + client + }, + |client| { + client.redeem_tokens(); + }, + criterion::BatchSize::SmallInput, + ); + }, + ); + + c.bench_function( + &format!("server redeem tokens, batch size: {}", n_tokens), + |b| { + b.iter_batched( + || { + let mut rng = OsRng; + let signing_key = SigningKey::random(&mut rng); + + let mut client = Client { + tokens: Vec::new(), + blinded_tokens: Vec::new(), + unblinded_tokens: Vec::new(), + }; + let server = Server { + signing_key, + spent_tokens: Vec::new(), + }; + + let signing_req = client.create_tokens(n_tokens); + + let signing_resp = server.sign_tokens(signing_req); + client.store_signed_tokens(signing_resp).unwrap(); + + let redeem_request = client.redeem_tokens(); + (server, redeem_request) + }, + |(mut server, redeem_request)| { + server.redeem_tokens(&redeem_request); + }, + criterion::BatchSize::SmallInput, + ); + }, + ); + } } #[cfg_attr(feature = "serde_base64", derive(Serialize, Deserialize))] @@ -74,10 +192,10 @@ struct Client { #[cfg(not(feature = "merlin"))] impl Client { - fn create_tokens(&mut self, n: u8) -> SigningRequest { + fn create_tokens(&mut self, n: usize) -> SigningRequest { let mut rng = OsRng; - for _i in 0..n { + for _ in 0..n { // client prepares a random token and blinding scalar let token = Token::random::(&mut rng); diff --git a/src/dleq.rs b/src/dleq.rs index 07b2752..6fe6b76 100644 --- a/src/dleq.rs +++ b/src/dleq.rs @@ -379,7 +379,7 @@ mod tests { let proof = DLEQProof::_new::(&mut rng, P, Q, &key1); - assert!(!proof._verify::(P, Q, &key1.public_key).is_ok()); + assert!(proof._verify::(P, Q, &key1.public_key).is_err()); } #[allow(non_snake_case)] @@ -393,8 +393,8 @@ mod tests { ("tviSLm/W8oFds67y9lMs990fjh08hQNV17/4V2bmOQY=", "5ufRlCvVKvXp1yuxxS7Jvw9LSwQUl6Q/MlT6HY2l1Hc=", "zOVEbK4KQ1GBW97YUVNguoN+NntwtGi1t+EeioMusXY=", "lH2gNbwqSC1nYYxT3I7fNQagTsD4OvSbzwrSCpanQkQ=", "NJF9U3TWiCWMd6Qh/vA90F/2N6udsXbTvifNxf0rzgbhInoEvYDi5jZAZUQEi7x7mmP8iFq7+ukoOroy6/8jCw=="), ("Ge3prZ2jJSoh1A3ZvrSfaSA1kDziGW2I+Gmh6jniaAs=", "2nNCd5YN9H5EYlOL9/kmLYNBMkaLwnG3wjyd7jw2QAY=", "YHdAzlpSTAMy3mB+F4mPwlyVl+V9Yt4f3cDPNJpWdns=", "gEnqgXg3FDaCQFayTXrIfpbZ2n0P6FD/95LuMsdIfFk=", "Fj2/YunbQs5XxSyLxl/fC4dAfRlErGurTtHHSfGKyQTzrLZrO7VghmGFQaMAXZ+jg+6v99YL6FWj1Y/5WFt2Aw=="), ]; - for i in 0..vectors.len() { - let (k, Y, P, Q_b64, dleq_b64) = vectors[i]; + for v in vectors { + let (k, Y, P, Q_b64, dleq_b64) = v; let server_key = SigningKey::decode_base64(k).unwrap(); @@ -430,15 +430,14 @@ mod tests { ("siv+BM3AvP8Jv1aL4MFhMs9Xa6jxUNhFXpTWDfGrZQQ=", "XgFOlHEz5zm5dtx6ptYIXNg1NsJ/3vAq+cf/9eBkbxI=", "dsaMl4/9FcOFtaW3l65y1Z9ETJR36aTcXPMp+w4HGUY=,aH2q1HiReMA/Ney2NNZCgl+5GKK9xrxVwdC+THq9pFY=,uGRqS51VD7DuK0gSpMb3owRld57W6DqOyZpygXJVpmI=,Bvv+lqtCg39SD1H218rPZdQTmYPe2HD3QScntqw1oFA=,9IHWUyv/SCwZ4WKEGi58+bQ5nHsaDBXCku2vOzGvgUY=", "4lPV/OyNjVy4VTUvaROxCuq4ryfegkt7jt5IhrX9THo=,4EAmV5Mv3a/IQFsfVlaFxErNc96Ns980FT4yLlCdoxA=,bgGM37uBMLdRRAd1cu/4Iq+FzFwzRFLVhqp2uGFnPQc=,rCn4OuWnV5tTsgcPJAYRSqfONZf9k/92fwzWHtUxxh8=,lHCDzazDlU0w735u7OQmJM96WGeaNFILanawmC9EwFE=", "jotItTWLW/kpDeh8KJQtNqM7ON0YibEJ7R8VnMHP7Cs=", "Pu49xb3Ixn+Dfg6s+wgjyoPy7ickB5lM7/MxQVdpaUI=", "N6vDmGbYZ0aa9S2JqWSYppiX1AV33QDXGc8FHaF0aQ9y6Hp68UEkI2x5AJQ3URqS+5/x1AuucMH0AOMcLNqODg=="), ("jTTf/D0gicaG++cQJ1X4qYaOqk4YPo0p6Mo2B95kJAg=", "LCtewONuYTXljy+oK73/m7CON/vr/e1r4aDaVE3xDnc=", "GsomH3aBo6qBHaNGzZZ/pNOviBTbZrUfpthgYU5jAmU=,wHvznjZDA9L8dgQGEj7wf1/QGxunE5/WYdxUpQX4Umc=,ZMxkDV7epUgmpix38jBfWv42VeMQefypY56dnysikWA=,aEy+/J0AFmjYGTjcv5y942fleEk/0rwqlD+kXSn0vCM=,QJMHfIYUraWdJKzenROtgLyjU9MrDtDDwFfDNIcjCHA=", "aGUXY5bBYoDmw4x1muwHzKp1w2sITQMeDfsyxv9EUDc=,qh0wfC/wAdclIJ79R+IIpPJLJM5aBe/i5i54dQOn3Vk=,zCi7XaHyO/b9SfN2AYuJcC60zqnIorkXMjjbixhEKxk=,XlBf7DyH5FtcUyr9Gfnj8i3cnKKPtWGHXm/LpIQX4gM=,wHtZg2i40wdxQvHehZEunTHiODSuEMv8suwFaqynmTQ=", "osUDqpps33Jw0k7vEHFCAk+iywlE7YrXrX5RfqC0olA=", "LnD9wlZrDo3v6dw56owm6NazoBLKwtqMPWdtxSRVWxc=", "KVEotBgIaz5Rymqpy4paroHGQyD/80FdvLCrONxDzQUWgNZxZ6aiCJ2VxIGP+6+86FZXS1sXGgs3dwft/VMCCw=="), ]; - for i in 0..vectors.len() { - let (k, Y, P, Q, M_b64, Z_b64, dleq_b64) = vectors[i]; + for v in vectors { + let (k, Y, P, Q, M_b64, Z_b64, dleq_b64) = v; let server_key = SigningKey::decode_base64(k).unwrap(); assert_eq!(server_key.public_key.encode_base64(), Y); let P: Vec<&str> = P.split(',').collect(); - let Q: Vec<&str> = Q.split(',').collect(); let P: Vec = P .iter() @@ -447,7 +446,7 @@ mod tests { let Q: Vec = P .iter() - .zip(Q.into_iter()) + .zip(Q.split(',')) .map(|(P_i, Q_i_b64)| { let Q_i = server_key.sign(P_i).unwrap(); assert_eq!(Q_i.encode_base64(), Q_i_b64); diff --git a/src/oprf.rs b/src/oprf.rs index 238fa53..414be1b 100644 --- a/src/oprf.rs +++ b/src/oprf.rs @@ -582,8 +582,6 @@ mod tests { use rand::rngs::OsRng; use sha2::Sha512; - use base64; - use super::*; type HmacSha512 = Hmac; @@ -603,8 +601,8 @@ mod tests { ("N8oRiMuSrYdp9TMKp++AP8ridXqdX6BoPOucx2eRCQE=", "mnikks9ySHzZGMgoPZ0SRA8/JJkMh5aA+m3eqeMfqTE=", "9sNH3G618rH0vy3TKBMNRQDKOb66LUKBo9jOtMsezeN4sgAp+2pMVDMS5BATkVxXAW5dpoGUTMJ3+cfnX0plSg==", "f44zH9r/YnCyaHZnKtEc/68diotEo1GjQ5MWepNEXAk=", "EEH0FTbmxN5XoXnAHmIH0y4VjcixJ5U9T8WqXgP2IAg=", "Km0KASMeIqj0s5vswz+WEYptTx2Y0fOb9cVjb+UKexw=", "lNDdKND+R/JmDrM08Q7w7ePoXT7/hgzGU6xVBU5RFig="), ("Nye8fMOQJv1HjCY6qxG0Br661wjd8OwNI1O0ZbkmGAc=", "5szoRS3/9jdVTmhswiS9yyaLeC2I0CfBAUzfe0zGjz8=", "OkOqxU+boJmNIhmzusoRGUDVJLfPlGd9bFV3UPpNueEHfu21um4zwQSuJUQ8hr8VgzU63fb93Rmk/0kRiOPUhw==", "ZBztTnJvQKmPkxfgzGzufhRa6o4oUPublpOIhODHKA4=", "lD1eLLmRw7ebLOd51OQSps51cZGTIg2DM+GL38bQQww=", "qA27hu9S60UX0jfnWJQgUBllQvfOPu+jQVkphi6Sv24=", "HhPZFQiNAYzG+niNmUiWut2g/YMhox86h1XyZypQfVk="), ]; - for i in 0..vectors.len() { - let (k, Y, seed, r, P, Q, W) = vectors[i]; + for v in vectors { + let (k, Y, seed, r, P, Q, W) = v; let server_key = SigningKey::decode_base64(k).unwrap(); let seed = base64::decode(seed).unwrap(); @@ -633,7 +631,7 @@ mod tests { W_bits.copy_from_slice(&W_bytes[..32]); let W = CompressedRistretto(W_bits); - let unblinded_token_expected = UnblindedToken { W: W, t: token.t }; + let unblinded_token_expected = UnblindedToken { W, t: token.t }; assert!(unblinded_token.encode_base64() == unblinded_token_expected.encode_base64()); } }