Fix clippy lints

dacut · dacut · commit 3fcdcfcf78af · 2024-07-15T10:45:37.000-07:00
diff --git a/src/auth.rs b/src/auth.rs
@@ -250,7 +250,7 @@ impl SigV4Authenticator {
 
         // Remove the access key from the credential to get the credential scope. This requires that prevalidate() has
         // been called.
-        let cscope = self.credential.splitn(2, '/').nth(1).expect("prevalidate should have been called first");
+        let cscope = self.credential.split_once('/').map(|x| x.1).expect("prevalidate should have been called first");
 
         result.extend(AWS4_HMAC_SHA256.as_bytes());
         result.push(b'\n');
@@ -295,7 +295,7 @@ impl SigV4Authenticator {
 impl Debug for SigV4Authenticator {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         f.debug_struct("SigV4Authenticator")
-            .field("canonical_request_sha256", &hex::encode(&self.canonical_request_sha256))
+            .field("canonical_request_sha256", &hex::encode(self.canonical_request_sha256))
             .field("session_token", &self.session_token)
             .field("signature", &self.signature)
             .field("request_timestamp", &self.request_timestamp)
@@ -385,7 +385,7 @@ mod tests {
         ring::digest::SHA256_OUTPUT_LEN,
         scratchstack_aws_principal::{Principal, User},
         scratchstack_errors::ServiceError,
-        std::{error::Error, fs::File},
+        std::{error::Error, fs::File, str::FromStr},
         tower::BoxError,
     };
 
@@ -470,7 +470,7 @@ mod tests {
         match request.access_key() {
             "AKIDEXAMPLE" => {
                 let principal = Principal::from(vec![User::new("aws", "123456789012", "/", "test").unwrap().into()]);
-                let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
+                let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap();
                 let k_signing = k_secret.to_ksigning(request.request_date(), request.region(), request.service());
 
                 let response =
diff --git a/src/aws4.rs b/src/aws4.rs
@@ -19,7 +19,7 @@ use {
         fs::File,
         io::{BufRead, BufReader, Read, Seek},
         path::PathBuf,
-        str::from_utf8,
+        str::{from_utf8, FromStr},
     },
     tower::BoxError,
 };
@@ -289,7 +289,7 @@ async fn run(basename: &str) {
 
 async fn get_signing_key(request: GetSigningKeyRequest) -> Result<GetSigningKeyResponse, BoxError> {
     let principal = Principal::from(User::new("aws", "123456789012", "/", "test").unwrap());
-    let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
+    let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap();
     let k_signing = k_secret.to_ksigning(request.request_date(), request.region(), request.service());
 
     let response = GetSigningKeyResponse::builder().principal(principal).signing_key(k_signing).build().unwrap();
diff --git a/src/canonical.rs b/src/canonical.rs
@@ -174,9 +174,9 @@ impl CanonicalRequest {
         mut body: Bytes,
         options: SignatureOptions,
     ) -> Result<(Self, Parts, Bytes), SignatureError> {
-        let canonical_path = canonicalize_uri_path(&parts.uri.path(), options.s3)?;
+        let canonical_path = canonicalize_uri_path(parts.uri.path(), options.s3)?;
         let content_type = get_content_type_and_charset(&parts.headers);
-        let mut query_parameters = query_string_to_normalized_map(&parts.uri.query().unwrap_or(""))?;
+        let mut query_parameters = query_string_to_normalized_map(parts.uri.query().unwrap_or(""))?;
 
         if options.url_encode_form {
             // Treat requests with application/x-www-form-urlencoded bodies as if they were passed into the query string.
@@ -210,7 +210,7 @@ impl CanonicalRequest {
                         }
                     };
 
-                    query_parameters.extend(query_string_to_normalized_map(body_query.as_str())?.into_iter());
+                    query_parameters.extend(query_string_to_normalized_map(body_query.as_str())?);
                     // Rebuild the parts URI with the new query string.
                     let qs = canonicalize_query_to_string(&query_parameters);
                     trace!("Rebuilding URI with new query string: {}", qs);
@@ -320,12 +320,12 @@ impl CanonicalRequest {
 
     /// Get the SHA-256 hash of the [canonical request](https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html).
     pub fn canonical_request_sha256(&self, signed_headers: &Vec<String>) -> [u8; SHA256_OUTPUT_LEN] {
-        let canonical_request = self.canonical_request(&signed_headers);
+        let canonical_request = self.canonical_request(signed_headers);
         let result_digest = digest(&SHA256, canonical_request.as_ref());
         let result_slice = result_digest.as_ref();
         assert!(result_slice.len() == SHA256_OUTPUT_LEN);
         let mut result: [u8; SHA256_OUTPUT_LEN] = [0; SHA256_OUTPUT_LEN];
-        result.as_mut_slice().clone_from_slice(&result_slice);
+        result.as_mut_slice().clone_from_slice(result_slice);
         result
     }
 
@@ -497,7 +497,7 @@ impl CanonicalRequest {
         }
 
         let mut signed_headers = if let Some(signed_headers) = parameter_map.get(SIGNED_HEADERS) {
-            signed_headers.split(|c| *c == b';').map(|s| latin1_to_string(s)).collect()
+            signed_headers.split(|c| *c == b';').map(latin1_to_string).collect()
         } else {
             missing_messages.push(MSG_AUTH_HEADER_REQ_SIGNED_HEADERS);
             Vec::new()
@@ -824,7 +824,7 @@ pub fn get_content_type_and_charset(headers: &HeaderMap<HeaderValue>) -> Option<
         None => return None,
     };
 
-    let mut parts = content_type_opts.split(|c| *c == b';').map(|s| trim_ascii(s));
+    let mut parts = content_type_opts.split(|c| *c == b';').map(trim_ascii);
     let content_type = latin1_to_string(parts.next().expect("split always returns at least one element"));
 
     for option in parts {
@@ -870,7 +870,7 @@ pub fn normalize_headers(headers: &HeaderMap<HeaderValue>) -> HashMap<String, Ve
     for (key, value) in headers.iter() {
         let key = key.as_str().to_lowercase();
         let value = normalize_header_value(value.as_bytes());
-        result.entry(key).or_insert_with(Vec::new).push(value);
+        result.entry(key).or_default().push(value);
     }
 
     result
@@ -886,7 +886,7 @@ fn normalize_header_value(value: &[u8]) -> Vec<u8> {
     for c in value {
         if *c == b' ' {
             if !last_was_space {
-                result.push(' ' as u8);
+                result.push(b' ');
                 last_was_space = true;
             }
         } else {
@@ -897,7 +897,7 @@ fn normalize_header_value(value: &[u8]) -> Vec<u8> {
 
     if last_was_space {
         // Remove trailing spaces.
-        while result.last() == Some(&(' ' as u8)) {
+        while result.last() == Some(&b' ') {
             result.pop();
         }
     }
@@ -1100,8 +1100,8 @@ fn unescape_uri_encoding(s: &str) -> String {
     while let Some(c) = chars.next() {
         if c == b'%' {
             let mut hex_digits = [0u8; 2];
-            hex_digits[0] = chars.next().expect(MSG_INCOMPLETE_TRAILING_ESCAPE) as u8;
-            hex_digits[1] = chars.next().expect(MSG_INCOMPLETE_TRAILING_ESCAPE) as u8;
+            hex_digits[0] = chars.next().expect(MSG_INCOMPLETE_TRAILING_ESCAPE);
+            hex_digits[1] = chars.next().expect(MSG_INCOMPLETE_TRAILING_ESCAPE);
             match u8::from_str_radix(from_utf8(&hex_digits).unwrap(), 16) {
                 Ok(c) => result.push(c as char),
                 Err(_) => panic!("{}{}{}", MSG_ILLEGAL_HEX_CHAR, hex_digits[0] as char, hex_digits[1] as char),
@@ -1132,7 +1132,7 @@ mod tests {
             uri::{PathAndQuery, Uri},
         },
         scratchstack_errors::ServiceError,
-        std::{collections::HashMap, mem::transmute},
+        std::collections::HashMap,
     };
 
     macro_rules! expect_err {
@@ -1252,7 +1252,7 @@ mod tests {
         assert_eq!(foo.len(), 1);
         assert_eq!(foo[0], "bar");
 
-        assert!(v.get("").is_none());
+        assert!(!v.contains_key(""));
     }
 
     #[test_log::test]
@@ -1273,22 +1273,23 @@ mod tests {
     #[test_log::test]
     fn normalize_invalid_hex_path_cr() {
         // The HTTP crate does its own validation; we need to hack into it to force invalid URI elements in there.
-        for (path, error_message) in vec![
+        for (path, error_message) in [
             ("/abcd%yy", "Illegal hex character in escape % pattern: %yy"),
             ("/abcd%0", "Incomplete trailing escape % sequence"),
             ("/abcd%", "Incomplete trailing escape % sequence"),
         ] {
             let mut fake_path = "/".to_string();
             while fake_path.len() < path.len() {
-                fake_path.push_str("a");
+                fake_path.push('a');
             }
 
             let mut pq = PathAndQuery::from_maybe_shared(fake_path.clone()).unwrap();
             let pq_path = Bytes::from_static(path.as_bytes());
 
             unsafe {
-                // Rewrite the path to be invalid.
-                let pq_ptr: *mut PathAndQuerySimulate = transmute(&mut pq);
+                // Rewrite the path to be invalid. This can't be done with the normal PathAndQuery
+                // API.
+                let pq_ptr: *mut PathAndQuerySimulate = &mut pq as *mut PathAndQuery as *mut PathAndQuerySimulate;
                 (*pq_ptr).data = pq_path;
             }
 
@@ -1313,22 +1314,22 @@ mod tests {
     #[test_log::test]
     fn normalize_invalid_hex_query_cr() {
         // The HTTP crate does its own validation; we need to hack into it to force invalid URI elements in there.
-        for (path, error_message) in vec![
+        for (path, error_message) in [
             ("/?x=abcd%yy", "Illegal hex character in escape % pattern: %yy"),
             ("/?x=abcd%0", "Incomplete trailing escape % sequence"),
             ("/?x=abcd%", "Incomplete trailing escape % sequence"),
         ] {
             let mut fake_path = "/?x=".to_string();
             while fake_path.len() < path.len() {
-                fake_path.push_str("a");
+                fake_path.push('a');
             }
 
             let mut pq = PathAndQuery::from_maybe_shared(fake_path.clone()).unwrap();
             let pq_path = Bytes::from_static(path.as_bytes());
 
             unsafe {
                 // Rewrite the path to be invalid.
-                let pq_ptr: *mut PathAndQuerySimulate = transmute(&mut pq);
+                let pq_ptr: *mut PathAndQuerySimulate = &mut pq as *mut PathAndQuery as *mut PathAndQuerySimulate;
                 (*pq_ptr).data = pq_path;
             }
 
@@ -1487,7 +1488,7 @@ mod tests {
         let (parts, body) = request.into_parts();
 
         let (cr, _, _) = CanonicalRequest::from_request_parts(parts, body, SignatureOptions::default()).unwrap();
-        assert!(cr.query_parameters.get("foo").is_none());
+        assert!(!cr.query_parameters.contains_key("foo"));
     }
 
     #[test_log::test]
diff --git a/src/lib.rs b/src/lib.rs
@@ -36,6 +36,7 @@
 //!     GetSigningKeyRequest, GetSigningKeyResponse, KSecretKey, SignatureOptions,
 //!     SignedHeaderRequirements, service_for_signing_key_fn, sigv4_validate_request,
 //! };
+//! use std::str::FromStr;
 //! use tower::{BoxError, Service};
 //!
 //! const ACCESS_KEY: &str = "AKIAIOSFODNN7EXAMPLE";
@@ -67,7 +68,7 @@
 //!     assert_eq!(request.region(), REGION);
 //!     assert_eq!(request.service(), SERVICE);
 //!     let user = User::new(PARTITION, ACCOUNT_ID, PATH, USER_NAME)?;
-//!     let secret_key = KSecretKey::from_str(SECRET_KEY);
+//!     let secret_key = KSecretKey::from_str(SECRET_KEY).unwrap();
 //!     let signing_key = secret_key.to_ksigning(request.request_date(), REGION, SERVICE);
 //!     Ok(GetSigningKeyResponse::builder()
 //!            .principal(user)
diff --git a/src/signature.rs b/src/signature.rs
@@ -171,7 +171,7 @@ mod tests {
         lazy_static::lazy_static,
         scratchstack_aws_principal::{Principal, User},
         scratchstack_errors::ServiceError,
-        std::mem::transmute,
+        std::str::FromStr,
         tower::BoxError,
     };
 
@@ -216,7 +216,7 @@ mod tests {
     Signature=c9d5ea9f3f72853aea855b47ea873832890dbdd183b4468f858259531a5138ea";
 
     async fn get_signing_key(req: GetSigningKeyRequest) -> Result<GetSigningKeyResponse, BoxError> {
-        let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
+        let k_secret = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap();
         let k_signing = k_secret.to_ksigning(req.request_date(), req.region(), req.service());
 
         let principal = Principal::from(vec![User::new("aws", "123456789012", "/", "test").unwrap().into()]);
@@ -332,8 +332,8 @@ mod tests {
 
             if i == 0 {
                 unsafe {
-                    // Rewrite the path to be invalid.
-                    let pq_ptr: *mut PathAndQuerySimulate = transmute(&mut pq);
+                    // Rewrite the path to be invalid. This can't be done with the normal PathAndQuery API.
+                    let pq_ptr: *mut PathAndQuerySimulate = &mut pq as *mut PathAndQuery as *mut PathAndQuerySimulate;
                     (*pq_ptr).data = pq_path;
                 }
             }
@@ -499,8 +499,8 @@ mod tests {
 
             if i == 0 {
                 unsafe {
-                    // Rewrite the path to be invalid.
-                    let pq_ptr: *mut PathAndQuerySimulate = transmute(&mut pq);
+                    // Rewrite the path to be invalid. This cannot be done with the normal PathAndQuery API.
+                    let pq_ptr: *mut PathAndQuerySimulate = &mut pq as *mut PathAndQuery as *mut PathAndQuerySimulate;
                     (*pq_ptr).data = pq_path;
                 }
             }
@@ -706,7 +706,7 @@ mod tests {
             s3: true,
             ..Default::default()
         };
-        let opt3 = opt1.clone();
+        let opt3 = opt1;
         let opt4 = opt1;
         assert_eq!(opt1.s3, opt2.s3);
         assert_eq!(opt1.s3, opt3.s3);
diff --git a/src/signing_key.rs b/src/signing_key.rs
@@ -5,8 +5,10 @@ use {
     ring::digest::SHA256_OUTPUT_LEN,
     scratchstack_aws_principal::{Principal, SessionData},
     std::{
+        convert::Infallible,
         fmt::{Debug, Display, Formatter, Result as FmtResult},
         future::Future,
+        str::FromStr,
     },
     tower::{service_fn, util::ServiceFn, BoxError},
 };
@@ -140,17 +142,21 @@ impl Display for KSigningKey {
     }
 }
 
-impl KSecretKey {
+impl FromStr for KSecretKey {
+    type Err = Infallible;
+
     /// Create a new `KSecretKey` from a raw AWS secret key.
-    pub fn from_str(raw: &str) -> Self {
+    fn from_str(raw: &str) -> Result<Self, Infallible> {
         let mut prefixed_key = Vec::with_capacity(4 + raw.len());
         prefixed_key.extend_from_slice(b"AWS4");
         prefixed_key.extend_from_slice(raw.as_bytes());
-        Self {
+        Ok(Self {
             prefixed_key,
-        }
+        })
     }
+}
 
+impl KSecretKey {
     /// Create a new `KDateKey` from this `KSecretKey` and a date.
     pub fn to_kdate(&self, date: NaiveDate) -> KDateKey {
         let date = date.format("%Y%m%d").to_string();
@@ -377,15 +383,16 @@ mod tests {
         crate::{GetSigningKeyRequest, GetSigningKeyResponse, KSecretKey},
         chrono::NaiveDate,
         scratchstack_aws_principal::{AssumedRole, Principal},
+        std::str::FromStr,
     };
 
     #[test_log::test]
     fn test_signing_key_derived() {
         let date = NaiveDate::from_ymd_opt(2015, 8, 30).unwrap();
 
-        let ksecret1a = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
-        let ksecret1b = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
-        let ksecret2 = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCZEXAMPLEKEY");
+        let ksecret1a = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap();
+        let ksecret1b = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap();
+        let ksecret2 = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCZEXAMPLEKEY").unwrap();
 
         assert_eq!(ksecret1a, ksecret1b);
         assert_eq!(ksecret1a, ksecret1a.clone());
@@ -495,8 +502,11 @@ mod tests {
         assert_eq!(gsk_req1a.region, gsk_req1b.region);
         assert_eq!(gsk_req1a.service, gsk_req1b.service);
 
-        let signing_key =
-            KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").to_ksigning(date, "us-east-1", "example");
+        let signing_key = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap().to_ksigning(
+            date,
+            "us-east-1",
+            "example",
+        );
         let principal = Principal::from(AssumedRole::new("aws", "123456789012", "role", "session").unwrap());
 
         let gsk_resp1a =
@@ -520,8 +530,11 @@ mod tests {
     #[test_log::test]
     fn test_response_builder() {
         let date = NaiveDate::from_ymd_opt(2015, 8, 30).unwrap();
-        let signing_key =
-            KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").to_ksigning(date, "us-east-1", "example");
+        let signing_key = KSecretKey::from_str("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY").unwrap().to_ksigning(
+            date,
+            "us-east-1",
+            "example",
+        );
         let response = GetSigningKeyResponse::builder().signing_key(signing_key).build().unwrap();
         assert!(response.principal().is_empty());
         assert!(response.session_data().is_empty());
