update to base64 =0.21.1

- update base64 dependency
- replace deprecated functions with new equivalents

Author: mdtro

crates_io_index/repo.rs

@@ -1,5 +1,6 @@
 use crate::credentials::Credentials;
 use anyhow::{anyhow, Context};
+use base64::{engine::general_purpose, Engine};
 use secrecy::{ExposeSecret, SecretString};
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -30,7 +31,8 @@ impl RepositoryConfig {
                 let index_location =
                     Url::parse(&ssh_url).expect("failed to parse GIT_SSH_REPO_URL");
 
-                let key = base64::decode(encoded_key.expose_secret())
+                let key = general_purpose::STANDARD
+                    .decode(encoded_key.expose_secret())
                     .expect("failed to base64 decode the ssh key");
                 let key =
                     String::from_utf8(key).expect("failed to convert the ssh key to a string");

crates_io_s3/lib.rs

@@ -1,5 +1,6 @@
 #![warn(clippy::all, rust_2018_idioms)]
 
+use base64::{engine::general_purpose, Engine};
 use chrono::prelude::Utc;
 use hmac::{Hmac, Mac};
 use reqwest::{
@@ -103,7 +104,7 @@ impl Bucket {
             let mut h = Hmac::<Sha1>::new_from_slice(key).expect("HMAC can take key of any size");
             h.update(string.as_bytes());
             let res = h.finalize().into_bytes();
-            base64::encode(res)
+            general_purpose::STANDARD.encode(res)
         };
         format!("AWS {}:{}", self.access_key, signature)
     }

src/controllers/github/secret_scanning.rs

@@ -5,7 +5,7 @@ use crate::schema::api_tokens;
 use crate::util::token::SecureToken;
 use anyhow::{anyhow, Context};
 use axum::body::Bytes;
-use base64;
+use base64::{engine::general_purpose, Engine};
 use http::HeaderMap;
 use once_cell::sync::Lazy;
 use parking_lot::Mutex;
@@ -58,7 +58,8 @@ fn key_from_spki(key: &GitHubPublicKey) -> Result<Vec<u8>, std::io::Error> {
         .find(PEM_FOOTER)
         .ok_or(std::io::ErrorKind::InvalidData)?;
     let gh_key = gh_key[..end_idx].replace('\n', "");
-    let gh_key = base64::decode(gh_key)
+    let gh_key = general_purpose::STANDARD
+        .decode(gh_key)
         .map_err(|_| std::io::Error::from(std::io::ErrorKind::InvalidData))?;
     if gh_key.len() != 91 {
         return Err(std::io::Error::from(std::io::ErrorKind::InvalidData));
@@ -110,7 +111,8 @@ fn verify_github_signature(
     let sig = headers
         .get("GITHUB-PUBLIC-KEY-SIGNATURE")
         .ok_or_else(|| bad_request("missing HTTP header: GITHUB-PUBLIC-KEY-SIGNATURE"))?;
-    let sig = base64::decode(sig)
+    let sig = general_purpose::STANDARD
+        .decode(sig)
         .map_err(|e| bad_request(&format!("failed to decode signature as base64: {e:?}")))?;
     let public_keys = get_public_keys(state)
         .map_err(|e| bad_request(&format!("failed to fetch GitHub public keys: {e:?}")))?;

src/controllers/helpers/pagination.rs

@@ -6,6 +6,7 @@ use crate::models::helpers::with_count::*;
 use crate::util::errors::{bad_request, AppResult};
 use crate::util::HeaderMapExt;
 
+use base64::{engine::general_purpose, Engine};
 use diesel::pg::Pg;
 use diesel::query_builder::*;
 use diesel::query_dsl::LoadQuery;
@@ -290,18 +291,14 @@ fn is_useragent_or_ip_blocked(config: &Server, headers: &HeaderMap) -> bool {
 /// technical measure to prevent API consumers for manually creating or modifying them, but
 /// hopefully the base64 will be enough to convey that doing it is unsupported.
 pub(crate) fn encode_seek<S: Serialize>(params: S) -> AppResult<String> {
-    Ok(base64::encode_config(
-        serde_json::to_vec(&params)?,
-        base64::URL_SAFE_NO_PAD,
-    ))
+    let encoded = general_purpose::URL_SAFE_NO_PAD.encode(serde_json::to_vec(&params)?);
+    Ok(encoded)
 }
 
 /// Decode a list of params previously encoded with [`encode_seek`].
 pub(crate) fn decode_seek<D: for<'a> Deserialize<'a>>(seek: &str) -> AppResult<D> {
-    Ok(serde_json::from_slice(&base64::decode_config(
-        seek,
-        base64::URL_SAFE_NO_PAD,
-    )?)?)
+    let decoded = serde_json::from_slice(&general_purpose::URL_SAFE_NO_PAD.decode(seek)?)?;
+    Ok(decoded)
 }
 
 #[cfg(test)]

src/metrics/log_encoder.rs

@@ -1,4 +1,4 @@
-use base64::write::EncoderWriter;
+use base64::{engine::general_purpose::STANDARD, write::EncoderWriter};
 use indexmap::IndexMap;
 use prometheus::proto::{MetricFamily, MetricType};
 use prometheus::{Encoder, Error};
@@ -135,7 +135,7 @@ fn serialize_and_split_list<'a, S: Serialize + 'a>(
     while items.peek().is_some() {
         let mut writer = TrackedWriter::new();
         let written_count = writer.written_count.clone();
-        let mut serializer = Serializer::new(EncoderWriter::new(&mut writer, base64::STANDARD));
+        let mut serializer = Serializer::new(EncoderWriter::new(&mut writer, &STANDARD));
 
         let mut seq = serializer.serialize_seq(None)?;
         #[allow(clippy::while_let_on_iterator)]
@@ -215,6 +215,7 @@ enum VectorMetricData {
 mod tests {
     use super::*;
     use anyhow::Error;
+    use base64::{engine::general_purpose, Engine};
     use prometheus::{Histogram, HistogramOpts, IntCounter, IntGauge, IntGaugeVec, Opts, Registry};
 
     #[test]
@@ -391,7 +392,7 @@ mod tests {
         assert_eq!(chunks.len(), 1);
         assert!(chunks[0].len() <= 256);
         assert_eq!(
-            serde_json::from_slice::<Vec<usize>>(&base64::decode(&chunks[0])?)?,
+            serde_json::from_slice::<Vec<usize>>(&general_purpose::STANDARD.decode(&chunks[0])?)?,
             small,
         );
 
@@ -407,11 +408,11 @@ mod tests {
         assert!(chunks[0].len() >= 256);
         assert!(chunks[1].len() <= 256);
         assert_eq!(
-            serde_json::from_slice::<Vec<usize>>(&base64::decode(&chunks[0])?)?,
+            serde_json::from_slice::<Vec<usize>>(&general_purpose::STANDARD.decode(&chunks[0])?)?,
             (0..=67).collect::<Vec<_>>(),
         );
         assert_eq!(
-            serde_json::from_slice::<Vec<usize>>(&base64::decode(&chunks[1])?)?,
+            serde_json::from_slice::<Vec<usize>>(&general_purpose::STANDARD.decode(&chunks[1])?)?,
             (68..100).collect::<Vec<_>>(),
         );
 

src/middleware/session.rs

@@ -3,6 +3,7 @@ use axum::extract::{Extension, FromRequestParts};
 use axum::middleware::Next;
 use axum::response::{IntoResponse, Response};
 use axum_extra::extract::SignedCookieJar;
+use base64::{engine::general_purpose, Engine};
 use cookie::time::Duration;
 use cookie::{Cookie, SameSite};
 use http::Request;
@@ -110,7 +111,9 @@ impl<T: RequestPartsExt> RequestSession for T {
 
 pub fn decode(cookie: Cookie<'_>) -> HashMap<String, String> {
     let mut ret = HashMap::new();
-    let bytes = base64::decode(cookie.value().as_bytes()).unwrap_or_default();
+    let bytes = general_purpose::STANDARD
+        .decode(cookie.value().as_bytes())
+        .unwrap_or_default();
     let mut parts = bytes.split(|&a| a == 0xff);
     while let (Some(key), Some(value)) = (parts.next(), parts.next()) {
         if key.is_empty() {
@@ -136,5 +139,5 @@ pub fn encode(h: &HashMap<String, String>) -> String {
     while ret.len() * 8 % 6 != 0 {
         ret.push(0xff);
     }
-    base64::encode(&ret[..])
+    general_purpose::STANDARD.encode(&ret[..])
 }

src/tests/record.rs

@@ -11,6 +11,7 @@ use std::{
     thread,
 };
 
+use base64::{engine::general_purpose, Engine};
 use futures_channel::oneshot;
 use futures_util::future;
 use http::header::CONTENT_TYPE;
@@ -277,7 +278,7 @@ async fn record_http(req: Request<Body>, client: Client) -> Result<ResponseAndEx
             .filter(|h| !IGNORED_HEADERS.contains(&h.0.as_str()))
             .map(|h| (h.0.as_str().to_string(), h.1.to_str().unwrap().to_string()))
             .collect(),
-        body: base64::encode(&body),
+        body: general_purpose::STANDARD.encode(&body),
     };
 
     let (status, headers, body) = if let Ok("passthrough") = dotenvy::var("RECORD").as_deref() {
@@ -312,7 +313,7 @@ async fn record_http(req: Request<Body>, client: Client) -> Result<ResponseAndEx
             .iter()
             .map(|h| (h.0.as_str().to_string(), h.1.to_str().unwrap().to_string()))
             .collect(),
-        body: base64::encode(&body),
+        body: general_purpose::STANDARD.encode(&body),
     };
 
     // Construct an outgoing response
@@ -374,7 +375,7 @@ fn replay_http(
                 assert_eq!(body, exchange.request.body);
             }
             _ => {
-                let body = base64::encode(body);
+                let body = general_purpose::STANDARD.encode(body);
                 assert_eq!(body, exchange.request.body);
             }
         }
@@ -383,7 +384,9 @@ fn replay_http(
         for (key, value) in exchange.response.headers {
             builder = builder.header(key.as_str(), value.as_str());
         }
-        let body = base64::decode(exchange.response.body.as_bytes()).unwrap();
+        let body = general_purpose::STANDARD
+            .decode(exchange.response.body.as_bytes())
+            .unwrap();
         let status = StatusCode::from_u16(exchange.response.status).unwrap();
         let response = builder.status(status).body(body.into()).unwrap();