Update base64 to v0.21 (#851)

Cargo.toml

@@ -28,8 +28,8 @@ httpdate = { version = "1", optional = true }
 mime = { version = "0.3.4", optional = true }
 fastrand = { version = "1.4", optional = true }
 quoted_printable = { version = "0.4.6", optional = true }
-base64 = { version = "0.20", optional = true }
-email-encoding = { git = "https://github.com/lettre/email-encoding.git", rev = "e5db2da2ebb6e6255a22daa3374c053c15343527", optional = true }
+base64 = { version = "0.21", optional = true }
+email-encoding = { git = "https://github.com/lettre/email-encoding.git", rev = "1cb8db0612a266da5fb99ac9298a8baaea06cf54", optional = true }
 
 # file transport
 uuid = { version = "1", features = ["v4"], optional = true }

src/base64.rs

@@ -0,0 +1,12 @@
+use ::base64::{
+    engine::{general_purpose::STANDARD, Engine},
+    DecodeError,
+};
+
+pub(crate) fn encode<T: AsRef<[u8]>>(input: T) -> String {
+    STANDARD.encode(input)
+}
+
+pub(crate) fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
+    STANDARD.decode(input)
+}

src/lib.rs

@@ -203,6 +203,8 @@ Make sure to apply the same to any of your crate dependencies that use the `lett
 }
 
 pub mod address;
+#[cfg(any(feature = "smtp-transport", feature = "dkim"))]
+mod base64;
 pub mod error;
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod executor;

src/message/dkim.rs

@@ -121,14 +121,14 @@ impl DkimSigningKey {
                 RsaPrivateKey::from_pkcs1_pem(private_key)
                     .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Rsa(err)))?,
             ),
-            DkimSigningAlgorithm::Ed25519 => {
-                InnerDkimSigningKey::Ed25519(
-                    ed25519_dalek::Keypair::from_bytes(&base64::decode(private_key).map_err(
-                        |err| DkimSigningKeyError(InnerDkimSigningKeyError::Base64(err)),
-                    )?)
-                    .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Ed25519(err)))?,
+            DkimSigningAlgorithm::Ed25519 => InnerDkimSigningKey::Ed25519(
+                ed25519_dalek::Keypair::from_bytes(
+                    &crate::base64::decode(private_key).map_err(|err| {
+                        DkimSigningKeyError(InnerDkimSigningKeyError::Base64(err))
+                    })?,
                 )
-            }
+                .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Ed25519(err)))?,
+            ),
         }))
     }
     fn get_signing_algorithm(&self) -> DkimSigningAlgorithm {
@@ -358,7 +358,7 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
         &message.body_raw(),
         dkim_config.canonicalization.body,
     ));
-    let bh = base64::encode(body_hash);
+    let bh = crate::base64::encode(body_hash);
     let mut signed_headers_list =
         dkim_config
             .headers
@@ -390,7 +390,7 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
     hashed_headers.update(canonicalized_dkim_header.trim_end().as_bytes());
     let hashed_headers = hashed_headers.finalize();
     let signature = match &dkim_config.private_key.0 {
-        InnerDkimSigningKey::Rsa(private_key) => base64::encode(
+        InnerDkimSigningKey::Rsa(private_key) => crate::base64::encode(
             private_key
                 .sign(
                     PaddingScheme::new_pkcs1v15_sign::<Sha256>(),
@@ -399,7 +399,7 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
                 .unwrap(),
         ),
         InnerDkimSigningKey::Ed25519(private_key) => {
-            base64::encode(private_key.sign(&hashed_headers).to_bytes())
+            crate::base64::encode(private_key.sign(&hashed_headers).to_bytes())
         }
     };
     let dkim_header = dkim_header_format(

src/transport/smtp/commands.rs

@@ -220,7 +220,7 @@ pub struct Auth {
 
 impl Display for Auth {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let encoded_response = self.response.as_ref().map(base64::encode);
+        let encoded_response = self.response.as_ref().map(crate::base64::encode);
 
         if self.mechanism.supports_initial_response() {
             write!(f, "AUTH {} {}", self.mechanism, encoded_response.unwrap())?;
@@ -271,7 +271,7 @@ impl Auth {
         #[cfg(feature = "tracing")]
         tracing::debug!("auth encoded challenge: {}", encoded_challenge);
 
-        let decoded_base64 = base64::decode(encoded_challenge).map_err(error::response)?;
+        let decoded_base64 = crate::base64::decode(encoded_challenge).map_err(error::response)?;
         let decoded_challenge = String::from_utf8(decoded_base64).map_err(error::response)?;
         #[cfg(feature = "tracing")]
         tracing::debug!("auth decoded challenge: {}", decoded_challenge);