Merge pull request #60 from brave-intl/bump-base64

bump base64 to 0.22

Author: bridiver

Cargo.toml

@@ -2,7 +2,7 @@
 authors = ["eV <[email protected]>"]
 edition = "2018"
 name = "challenge-bypass-ristretto"
-version = "2.0.1"
+version = "2.0.2"
 readme = "README.md"
 license = "MPL-2.0"
 repository = "https://github.com/brave-intl/challenge-bypass-ristretto"
@@ -25,7 +25,7 @@ zeroize = "1.3"
 
 [dependencies.base64]
 optional = true
-version = "0.13"
+version = "0.22"
 
 [dependencies.serde]
 optional = true
@@ -36,7 +36,7 @@ default-features = false
 serde_json = "=1.0.140"
 serde = { version = "=1.0.219", features = ["derive"] }
 sha2 = "=0.10.8"
-base64 = "=0.13.1"
+base64 = "0.22"
 rand = { version = "=0.8.5", default-features = true }
 criterion = { version = "=0.5.1", features = ["html_reports"] }
 
@@ -45,6 +45,7 @@ default = ["std"]
 std = ["alloc", "subtle/std"]
 alloc = ["curve25519-dalek/alloc"]
 serde_base64 = ["serde", "base64"]
+cbindgen = []
 
 [package.metadata.docs.rs]
 rustdoc-args = [
@@ -56,4 +57,3 @@ rustdoc-args = [
 [[bench]]
 name = "benchmarks"
 harness = false
-

src/dleq.rs

@@ -352,6 +352,7 @@ impl BatchDLEQProof {
 
 #[cfg(test)]
 mod tests {
+    use base64::{engine::Engine as _, prelude::BASE64_STANDARD};
     use curve25519_dalek::ristretto::CompressedRistretto;
     use rand::rngs::OsRng;
     use sha2::Sha512;
@@ -398,14 +399,14 @@ mod tests {
 
             assert_eq!(server_key.public_key.encode_base64(), Y);
 
-            let P_bytes = base64::decode(P).unwrap();
+            let P_bytes = BASE64_STANDARD.decode(P).unwrap();
             let mut P_bits: [u8; 32] = [0u8; 32];
             P_bits.copy_from_slice(&P_bytes[..32]);
             let P = CompressedRistretto(P_bits).decompress().unwrap();
 
             let Q = P * server_key.k;
 
-            assert_eq!(base64::encode(&Q.compress().to_bytes()[..]), Q_b64);
+            assert_eq!(BASE64_STANDARD.encode(&Q.compress().to_bytes()[..]), Q_b64);
 
             let seed: [u8; 32] = [0u8; 32];
             let mut prng: ChaChaRng = SeedableRng::from_seed(seed);
@@ -455,8 +456,8 @@ mod tests {
                 BatchDLEQProof::calculate_composites::<Sha512>(&P, &Q, &server_key.public_key)
                     .unwrap();
 
-            assert_eq!(base64::encode(&M.compress().to_bytes()[..]), M_b64);
-            assert_eq!(base64::encode(&Z.compress().to_bytes()[..]), Z_b64);
+            assert_eq!(BASE64_STANDARD.encode(&M.compress().to_bytes()[..]), M_b64);
+            assert_eq!(BASE64_STANDARD.encode(&Z.compress().to_bytes()[..]), Z_b64);
 
             let seed: [u8; 32] = [0u8; 32];
             let mut prng: ChaChaRng = SeedableRng::from_seed(seed);

src/macros.rs

@@ -7,19 +7,23 @@ macro_rules! impl_base64 {
             #[cfg(all(feature = "alloc", not(feature = "std")))]
             /// Encode to a base64 string
             pub fn encode_base64(&self) -> ::alloc::string::String {
-                ::base64::encode(&self.to_bytes()[..])
+                use base64::Engine;
+                base64::prelude::BASE64_STANDARD.encode(&self.to_bytes().to_vec())
             }
 
             #[cfg(all(feature = "std"))]
             /// Encode to a base64 string
             pub fn encode_base64(&self) -> ::std::string::String {
-                ::base64::encode(&self.to_bytes()[..])
+                use base64::Engine;
+                base64::prelude::BASE64_STANDARD.encode(&self.to_bytes().to_vec())
             }
 
             /// Decode from a base64 string
             pub fn decode_base64(s: &str) -> Result<Self, TokenError> {
-                let bytes =
-                    ::base64::decode(s).or(Err(TokenError(InternalError::DecodingError)))?;
+                use base64::Engine;
+                let bytes = base64::prelude::BASE64_STANDARD
+                    .decode(s)
+                    .or(Err(TokenError(InternalError::DecodingError)))?;
                 $t::from_bytes(&bytes)
             }
         }

src/oprf.rs

@@ -580,6 +580,7 @@ impl VerificationSignature {
 
 #[cfg(test)]
 mod tests {
+    use base64::{engine::Engine as _, prelude::BASE64_STANDARD};
     use hmac::Hmac;
     use rand::rngs::OsRng;
     use sha2::Sha512;
@@ -605,11 +606,11 @@ mod tests {
         ];
         for (k, Y, seed, r, P, Q, W) in vectors {
             let server_key = SigningKey::decode_base64(k).unwrap();
-            let seed = base64::decode(seed).unwrap();
+            let seed = BASE64_STANDARD.decode(seed).unwrap();
 
             assert!(server_key.public_key.encode_base64() == Y);
 
-            let r_bytes = base64::decode(r).unwrap();
+            let r_bytes = BASE64_STANDARD.decode(r).unwrap();
             let mut r_bits: [u8; 32] = [0u8; 32];
             r_bits.copy_from_slice(&r_bytes);
             let r = Scalar::from_canonical_bytes(r_bits).unwrap();
@@ -626,7 +627,7 @@ mod tests {
 
             let unblinded_token = token.unblind(&signed_token).unwrap();
 
-            let W_bytes = base64::decode(W).unwrap();
+            let W_bytes = BASE64_STANDARD.decode(W).unwrap();
             let mut W_bits: [u8; 32] = [0u8; 32];
             W_bits.copy_from_slice(&W_bytes[..32]);
             let W = CompressedRistretto(W_bits);