standardize MSRV for clippy

Author: mcginty

.github/workflows/rust.yml

@@ -26,6 +26,7 @@ jobs:
         with:
           toolchain: ${{ matrix.rust }}
           components: clippy
+      - uses: Swatinem/rust-cache@v2
       - name: Install LLVM and Clang
         if: startsWith(matrix.os, 'windows')
         uses: KyleMayes/install-llvm-action@v2

Cargo.toml

@@ -102,7 +102,6 @@ serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
 hex = "0.4"
-lazy_static = "1.4"
 x25519-dalek = "2.0"
 # TODO: Waiting on https://github.com/RustCrypto/traits/issues/1642
 rand = "0.8"

clippy.toml

@@ -0,0 +1 @@
+msrv = "1.81.0"

examples/oneway.rs

@@ -10,24 +10,25 @@
 //! as `cargo run --example oneway` to see the magic happen.
 
 use hex::FromHex;
-use lazy_static::lazy_static;
 use snow::{params::NoiseParams, Builder, Keypair};
 use std::{
     io::{self, Read, Write},
     net::{TcpListener, TcpStream},
+    sync::LazyLock,
 };
 
 static SECRET: &[u8; 32] = b"i don't care for fidget spinners";
-lazy_static! {
-    static ref PARAMS: NoiseParams = "Noise_Xpsk1_25519_ChaChaPoly_BLAKE2s".parse().unwrap();
-    // The responder key is static in this example because the X pattern means
-    // the initiator has pre-handshake knowledge of the responder's public key
-    // (and of course both share the same psk `SECRET`)
-    static ref RESPONDER: Keypair = Keypair {
-        private: Vec::from_hex("52fbe3721d1adbe312d270ca2db5ce5bd39ddc206075f3a8f06d422619c8eb5d").expect("valid hex"),
-        public: Vec::from_hex("435ce8a8415ccd44de5e207581ac7207b416683028bcaecc9eb38d944e6f900c").expect("valid hex"),
-    };
-}
+static PARAMS: LazyLock<NoiseParams> =
+    LazyLock::new(|| "Noise_Xpsk1_25519_ChaChaPoly_BLAKE2s".parse().unwrap());
+// The responder key is static in this example because the X pattern means
+// the initiator has pre-handshake knowledge of the responder's public key
+// (and of course both share the same psk `SECRET`)
+static RESPONDER: LazyLock<Keypair> = LazyLock::new(|| Keypair {
+    private: Vec::from_hex("52fbe3721d1adbe312d270ca2db5ce5bd39ddc206075f3a8f06d422619c8eb5d")
+        .expect("valid hex"),
+    public:  Vec::from_hex("435ce8a8415ccd44de5e207581ac7207b416683028bcaecc9eb38d944e6f900c")
+        .expect("valid hex"),
+});
 
 #[cfg(any(feature = "default-resolver", feature = "ring-accelerated"))]
 fn main() {

examples/simple.rs

@@ -9,17 +9,16 @@
 //! Run the server a-like-a-so `cargo run --example simple -- -s`, then run the client
 //! as `cargo run --example simple` to see the magic happen.
 
-use lazy_static::lazy_static;
 use snow::{params::NoiseParams, Builder};
 use std::{
     io::{self, Read, Write},
     net::{TcpListener, TcpStream},
+    sync::LazyLock,
 };
 
 static SECRET: &[u8; 32] = b"i don't care for fidget spinners";
-lazy_static! {
-    static ref PARAMS: NoiseParams = "Noise_XXpsk3_25519_ChaChaPoly_BLAKE2s".parse().unwrap();
-}
+static PARAMS: LazyLock<NoiseParams> =
+    LazyLock::new(|| "Noise_XXpsk3_25519_ChaChaPoly_BLAKE2s".parse().unwrap());
 
 #[cfg(any(feature = "default-resolver", feature = "ring-accelerated"))]
 fn main() {

tests/vectors.rs

@@ -12,6 +12,7 @@ use serde::{
 use snow::{params::*, Builder, HandshakeState};
 use std::{
     fmt,
+    fmt::Write as _,
     fs::{File, OpenOptions},
     io::Read,
     marker::PhantomData,
@@ -21,7 +22,7 @@ use std::{
 #[derive(Clone)]
 struct HexBytes<T> {
     original: String,
-    payload: T,
+    payload:  T,
 }
 
 impl<T: AsRef<[u8]>> From<T> for HexBytes<T> {
@@ -82,7 +83,7 @@ impl<T: AsRef<[u8]>> Serialize for HexBytes<T> {
 
 #[derive(Serialize, Deserialize)]
 struct TestMessage {
-    payload: HexBytes<Vec<u8>>,
+    payload:    HexBytes<Vec<u8>>,
     ciphertext: HexBytes<Vec<u8>>,
 }
 
@@ -125,13 +126,13 @@ struct TestVector {
     #[serde(skip_serializing_if = "Option::is_none")]
     init_remote_static: Option<HexBytes<Vec<u8>>>,
 
-    resp_prologue: HexBytes<Vec<u8>>,
+    resp_prologue:      HexBytes<Vec<u8>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    resp_psks: Option<Vec<HexBytes<[u8; 32]>>>,
+    resp_psks:          Option<Vec<HexBytes<[u8; 32]>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    resp_static: Option<HexBytes<Vec<u8>>>,
+    resp_static:        Option<HexBytes<Vec<u8>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    resp_ephemeral: Option<HexBytes<Vec<u8>>>,
+    resp_ephemeral:     Option<HexBytes<Vec<u8>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     resp_remote_static: Option<HexBytes<Vec<u8>>>,
 
@@ -218,10 +219,10 @@ fn confirm_message_vectors(
             .map_err(|_| format!("read_message failed on message {i}"))?;
         if sendbuf[..len] != (*message.ciphertext)[..] || *message.payload != recvbuf[..recv_len] {
             let mut s = String::new();
-            s.push_str(&format!("message {i}"));
-            s.push_str(&format!("plaintext: {}\n", hex::encode(&*message.payload)));
-            s.push_str(&format!("expected:  {}\n", hex::encode(&*message.ciphertext)));
-            s.push_str(&format!("actual:    {}", hex::encode(&sendbuf[..len])));
+            writeln!(&mut s, "message {i}").unwrap();
+            writeln!(&mut s, "plaintext: {}", hex::encode(&*message.payload)).unwrap();
+            writeln!(&mut s, "expected:  {}", hex::encode(&*message.ciphertext)).unwrap();
+            writeln!(&mut s, "actual:    {}", hex::encode(&sendbuf[..len])).unwrap();
             return Err(s);
         }
     }
@@ -236,14 +237,16 @@ fn confirm_message_vectors(
         let recv_len = recv.read_message(&sendbuf[..len], &mut recvbuf).unwrap();
         if sendbuf[..len] != (*message.ciphertext)[..] || *message.payload != recvbuf[..recv_len] {
             let mut s = String::new();
-            s.push_str(&format!("message {i}"));
-            s.push_str(&format!("plaintext          : {}\n", hex::encode(&*message.payload)));
-            s.push_str(&format!("expected ciphertext: {}\n", hex::encode(&*message.ciphertext)));
-            s.push_str(&format!(
-                "actual ciphertext  : {}\n",
+            writeln!(&mut s, "message {i}").unwrap();
+            writeln!(&mut s, "plaintext          : {}", hex::encode(&*message.payload)).unwrap();
+            writeln!(&mut s, "expected ciphertext: {}", hex::encode(&*message.ciphertext)).unwrap();
+            writeln!(
+                &mut s,
+                "actual ciphertext  : {}",
                 hex::encode(&sendbuf[..message.ciphertext.len()])
-            ));
-            s.push_str(&format!("actual plaintext   : {}", hex::encode(&recvbuf[..recv_len])));
+            )
+            .unwrap();
+            writeln!(&mut s, "actual plaintext   : {}", hex::encode(&recvbuf[..recv_len])).unwrap();
             return Err(s);
         }
     }
@@ -375,7 +378,7 @@ fn generate_vector(params: NoiseParams) -> TestVector {
         let payload = random_vec(32);
         let len = init.write_message(&payload, &mut ibuf).unwrap();
         messages.push(TestMessage {
-            payload: payload.clone().into(),
+            payload:    payload.clone().into(),
             ciphertext: ibuf[..len].to_vec().into(),
         });
         let _ = resp.read_message(&ibuf[..len], &mut obuf).unwrap();
@@ -387,7 +390,7 @@ fn generate_vector(params: NoiseParams) -> TestVector {
         let payload = random_vec(32);
         let len = resp.write_message(&payload, &mut ibuf).unwrap();
         messages.push(TestMessage {
-            payload: payload.clone().into(),
+            payload:    payload.clone().into(),
             ciphertext: ibuf[..len].to_vec().into(),
         });
         let _ = init.read_message(&ibuf[..len], &mut obuf).unwrap();