Merge pull request #6522 from mdtro/mdtro/base64-update

bump base64 to 0.21.1

Author: Turbo87

Cargo.lock

@@ -34,7 +34,7 @@ anyhow = "=1.0.71"
 aws-sigv4 = "=0.55.3"
 axum = { version = "=0.6.18", features = ["headers", "macros", "matched-path"] }
 axum-extra = { version = "=0.7.4", features = ["cookie-signed"] }
-base64 = "=0.13.1"
+base64 = "=0.21.2"
 crates_io_index = { path = "crates_io_index" }
 crates_io_markdown = { path = "crates_io_markdown" }
 crates_io_s3 = { path = "crates_io_s3" }

Cargo.toml

@@ -14,7 +14,7 @@ testing = []
 
 [dependencies]
 anyhow = "=1.0.71"
-base64 = "=0.13.1"
+base64 = "=0.21.2"
 dotenvy = "=0.15.7"
 git2 = "=0.17.2"
 secrecy = "=0.8.0"

crates_io_index/Cargo.toml

@@ -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_index/repo.rs

@@ -12,7 +12,7 @@ name = "s3"
 path = "lib.rs"
 
 [dependencies]
-base64 = "=0.13.1"
+base64 = "=0.21.2"
 chrono = { version = "=0.4.26", default-features = false }
 sha-1 = "=0.10.1"
 hmac = "=0.12.1"

crates_io_s3/Cargo.toml

@@ -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)
     }

crates_io_s3/lib.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/github/secret_scanning.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/controllers/helpers/pagination.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/metrics/log_encoder.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[..])
 }