deps: Bump toml and base64 (#1619)

Signed-off-by: Xuanwo <[email protected]>

Author: Xuanwo

Cargo.lock

@@ -27,7 +27,7 @@ anyhow = "1.0"
 ar = "0.9"
 async-trait = "0.1"
 atty = "0.2.6"
-base64 = "0.20"
+base64 = "0.21"
 bincode = "1"
 blake3 = "1"
 byteorder = "1.0"
@@ -70,7 +70,7 @@ tokio = { version = "1", features = ["rt-multi-thread", "io-util", "time", "net"
 tokio-serde = "0.8"
 tokio-util = { version = "0.7", features = ["codec", "io"] }
 tower = "0.4"
-toml = "0.5"
+toml = "0.7"
 url = { version = "2", optional = true }
 uuid = { version = "1.2", features = ["v4"] }
 walkdir = "2"

Cargo.toml

@@ -22,6 +22,7 @@ extern crate tar;
 extern crate void;
 
 use anyhow::{bail, Context, Error, Result};
+use base64::Engine;
 use rand::{rngs::OsRng, RngCore};
 use sccache::config::{
     scheduler as scheduler_config, server as server_config, INSECURE_DIST_CLIENT_TOKEN,
@@ -144,15 +145,15 @@ fn run(command: Command) -> Result<i32> {
             let mut bytes = vec![0; num_bytes];
             OsRng.fill_bytes(&mut bytes);
             // As long as it can be copied, it doesn't matter if this is base64 or hex etc
-            println!("{}", base64::encode_engine(&bytes, &BASE64_URL_SAFE_ENGINE));
+            println!("{}", BASE64_URL_SAFE_ENGINE.encode(bytes));
             Ok(0)
         }
         Command::Auth(AuthSubcommand::JwtHS256ServerToken {
             secret_key,
             server_id,
         }) => {
             let header = jwt::Header::new(jwt::Algorithm::HS256);
-            let secret_key = base64::decode_engine(&secret_key, &BASE64_URL_SAFE_ENGINE)?;
+            let secret_key = BASE64_URL_SAFE_ENGINE.decode(&secret_key)?;
             let token = create_jwt_server_token(server_id, &header, &secret_key)
                 .context("Failed to create server token")?;
             println!("{}", token);
@@ -197,7 +198,8 @@ fn run(command: Command) -> Result<i32> {
                     Box::new(move |server_token| check_server_token(server_token, &token))
                 }
                 scheduler_config::ServerAuth::JwtHS256 { secret_key } => {
-                    let secret_key = base64::decode_engine(&secret_key, &BASE64_URL_SAFE_ENGINE)
+                    let secret_key = BASE64_URL_SAFE_ENGINE
+                        .decode(&secret_key)
                         .context("Secret key base64 invalid")?;
                     if secret_key.len() != 256 / 8 {
                         bail!("Size of secret key incorrect")

src/bin/sccache-dist/main.rs

@@ -1,5 +1,6 @@
 use crate::jwt;
 use anyhow::{bail, Context, Result};
+use base64::Engine;
 use sccache::dist::http::{ClientAuthCheck, ClientVisibleMsg};
 use sccache::util::{new_reqwest_blocking_client, BASE64_URL_SAFE_ENGINE};
 use std::collections::HashMap;
@@ -29,9 +30,11 @@ impl Jwk {
         }
 
         // JWK is big-endian, openssl bignum from_slice is big-endian
-        let n = base64::decode_engine(&self.n, &BASE64_URL_SAFE_ENGINE)
+        let n = BASE64_URL_SAFE_ENGINE
+            .decode(&self.n)
             .context("Failed to base64 decode n")?;
-        let e = base64::decode_engine(&self.e, &BASE64_URL_SAFE_ENGINE)
+        let e = BASE64_URL_SAFE_ENGINE
+            .decode(&self.e)
             .context("Failed to base64 decode e")?;
         let n_bn = openssl::bn::BigNum::from_slice(&n)
             .context("Failed to create openssl bignum from n")?;

src/bin/sccache-dist/token_check.rs

@@ -848,7 +848,7 @@ impl CachedConfig {
     fn save_file_config(c: &CachedFileConfig) -> Result<()> {
         let file_conf_path = &*CACHED_CONFIG_PATH;
         let mut file = File::create(file_conf_path).context("Could not open config for writing")?;
-        file.write_all(&toml::to_vec(c).unwrap())
+        file.write_all(toml::to_string(c).unwrap().as_bytes())
             .map_err(Into::into)
     }
 }

src/config.rs

@@ -86,6 +86,7 @@ mod code_grant_pkce {
     };
     use crate::util::new_reqwest_blocking_client;
     use crate::util::BASE64_URL_SAFE_ENGINE;
+    use base64::Engine;
     use futures::channel::oneshot;
     use hyper::{Body, Method, Request, Response, StatusCode};
     use rand::{rngs::OsRng, RngCore};
@@ -146,10 +147,10 @@ mod code_grant_pkce {
     pub fn generate_verifier_and_challenge() -> Result<(String, String)> {
         let mut code_verifier_bytes = vec![0; NUM_CODE_VERIFIER_BYTES];
         OsRng.fill_bytes(&mut code_verifier_bytes);
-        let code_verifier = base64::encode_engine(&code_verifier_bytes, &BASE64_URL_SAFE_ENGINE);
+        let code_verifier = BASE64_URL_SAFE_ENGINE.encode(&code_verifier_bytes);
         let mut hasher = Sha256::new();
         hasher.update(&code_verifier);
-        let code_challenge = base64::encode_engine(hasher.finalize(), &BASE64_URL_SAFE_ENGINE);
+        let code_challenge = BASE64_URL_SAFE_ENGINE.encode(hasher.finalize());
         Ok((code_verifier, code_challenge))
     }
 

src/dist/client_auth.rs

@@ -31,11 +31,8 @@ use std::time::Duration;
 use crate::errors::*;
 
 /// The url safe engine for base64.
-pub const BASE64_URL_SAFE_ENGINE: base64::engine::fast_portable::FastPortable =
-    base64::engine::fast_portable::FastPortable::from(
-        &base64::alphabet::URL_SAFE,
-        base64::engine::fast_portable::NO_PAD,
-    );
+pub const BASE64_URL_SAFE_ENGINE: base64::engine::GeneralPurpose =
+    base64::engine::general_purpose::URL_SAFE_NO_PAD;
 
 #[derive(Clone)]
 pub struct Digest {

src/util.rs

@@ -261,13 +261,13 @@ fn test_auth_with_config(dist_auth: sccache::config::DistAuth) {
         }
     }
     println!("Validating cached config");
-    let mut cached_config_bytes = vec![];
+    let mut cached_config_string = String::new();
     fs::File::open(sccache_cached_config_path)
         .unwrap()
-        .read_to_end(&mut cached_config_bytes)
+        .read_to_string(&mut cached_config_string)
         .unwrap();
     let cached_config: sccache::config::CachedFileConfig =
-        toml::from_slice(&cached_config_bytes).unwrap();
+        toml::from_str(&cached_config_string).unwrap();
     assert_eq!(cached_config.dist.auth_tokens.len(), 1);
 }