Fix clippy::pedantic

.github/workflows/ci.yaml

@@ -12,18 +12,28 @@ on:
   # Also on PRs, just be careful not to publish anything
   pull_request:
 
-
 jobs:
-  ci:
-    runs-on: ubuntu-22.04
+  library-ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        subcmd: [build, clippy, test]
+
     steps:
       - uses: actions/checkout@v4
 
-      - name: Build
-        run: cargo check
+      - name: Run `cargo ${{ matrix.subcmd }}` for library
+        run: cargo ${{ matrix.subcmd }}
+
+  example-ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        example: [embassy, blocking, tokio, nrf52]
 
-      - name: Test
-        run: cargo test -- --nocapture
+    steps:
+      - uses: actions/checkout@v4
 
-      - name: Build examples
-        run: for i in embassy blocking tokio nrf52; do pushd examples/$i; cargo build; popd; done;
+      - name: Run `cargo build` for example ${{ matrix.example }}
+        working-directory: examples/${{ matrix.example }}
+        run: cargo build

src/alert.rs

@@ -10,6 +10,7 @@ pub enum AlertLevel {
 }
 
 impl AlertLevel {
+    #[must_use]
     pub fn of(num: u8) -> Option<Self> {
         match num {
             1 => Some(AlertLevel::Warning),
@@ -52,6 +53,7 @@ pub enum AlertDescription {
 }
 
 impl AlertDescription {
+    #[must_use]
     pub fn of(num: u8) -> Option<Self> {
         match num {
             0 => Some(AlertDescription::CloseNotify),
@@ -94,6 +96,7 @@ pub struct Alert {
 }
 
 impl Alert {
+    #[must_use]
     pub fn new(level: AlertLevel, description: AlertDescription) -> Self {
         Self { level, description }
     }

src/application_data.rs

@@ -1,4 +1,4 @@
-use crate::buffer::*;
+use crate::buffer::CryptoBuffer;
 use crate::record::RecordHeader;
 use core::fmt::{Debug, Formatter};
 

src/asynch.rs

@@ -1,6 +1,6 @@
 use crate::common::decrypted_buffer_info::DecryptedBufferInfo;
 use crate::common::decrypted_read_handler::DecryptedReadHandler;
-use crate::connection::*;
+use crate::connection::{decrypt_record, Handshake, State};
 use crate::key_schedule::KeySchedule;
 use crate::key_schedule::{ReadKeySchedule, SharedState, WriteKeySchedule};
 use crate::read_buffer::ReadBuffer;

src/blocking.rs

@@ -1,6 +1,6 @@
 use crate::common::decrypted_buffer_info::DecryptedBufferInfo;
 use crate::common::decrypted_read_handler::DecryptedReadHandler;
-use crate::connection::*;
+use crate::connection::{decrypt_record, Handshake, State};
 use crate::key_schedule::KeySchedule;
 use crate::key_schedule::{ReadKeySchedule, SharedState, WriteKeySchedule};
 use crate::read_buffer::ReadBuffer;

src/buffer.rs

@@ -127,7 +127,7 @@ impl<'b> CryptoBuffer<'b> {
     }
 
     pub fn truncate(&mut self, len: usize) {
-        self.truncate_internal(len)
+        self.truncate_internal(len);
     }
 
     pub fn len(&self) -> usize {
@@ -235,7 +235,7 @@ impl<'b> Buffer for CryptoBuffer<'b> {
     }
 
     fn truncate(&mut self, len: usize) {
-        self.truncate_internal(len)
+        self.truncate_internal(len);
     }
 }
 

src/change_cipher_spec.rs

@@ -6,6 +6,7 @@ use crate::TlsError;
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct ChangeCipherSpec {}
 
+#[allow(clippy::unnecessary_wraps)] // TODO
 impl ChangeCipherSpec {
     pub fn new() -> Self {
         Self {}
@@ -21,8 +22,8 @@ impl ChangeCipherSpec {
         Ok(Self {})
     }
 
-    #[allow(dead_code)]
-    pub(crate) fn encode(&self, buf: &mut CryptoBuffer<'_>) -> Result<(), TlsError> {
+    #[allow(dead_code, clippy::unused_self)]
+    pub(crate) fn encode(self, buf: &mut CryptoBuffer<'_>) -> Result<(), TlsError> {
         buf.push(1).map_err(|_| TlsError::EncodeError)?;
         Ok(())
     }

src/common/decrypted_read_handler.rs

@@ -56,7 +56,7 @@ impl DecryptedReadHandler<'_> {
                 // by the user.
                 Ok(())
             }
-            _ => {
+            ServerRecord::Handshake(_) => {
                 unimplemented!()
             }
         }

src/config.rs

@@ -120,6 +120,7 @@ where
 
 #[derive(Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[must_use = "TlsConfig does nothing unless consumed"]
 pub struct TlsConfig<'a> {
     pub(crate) server_name: Option<&'a str>,
     pub(crate) psk: Option<(&'a [u8], Vec<&'a [u8], 4>)>,

src/connection.rs

@@ -5,7 +5,7 @@ use crate::record::{ClientRecord, ServerRecord};
 use crate::record_reader::RecordReader;
 use crate::write_buffer::WriteBuffer;
 use crate::{
-    alert::*,
+    alert::{Alert, AlertDescription, AlertLevel},
     handshake::{certificate::CertificateRef, certificate_request::CertificateRequest},
 };
 use crate::{CertificateVerify, CryptoProvider, TlsError, TlsVerifier};
@@ -551,11 +551,11 @@ where
         Ok((mut signing_key, signature_scheme)) => {
             let ctx_str = b"TLS 1.3, client CertificateVerify\x00";
             let mut msg: heapless::Vec<u8, 130> = heapless::Vec::new();
-            msg.resize(64, 0x20).map_err(|_| TlsError::EncodeError)?;
+            msg.resize(64, 0x20).map_err(|()| TlsError::EncodeError)?;
             msg.extend_from_slice(ctx_str)
-                .map_err(|_| TlsError::EncodeError)?;
+                .map_err(|()| TlsError::EncodeError)?;
             msg.extend_from_slice(&key_schedule.transcript_hash().clone().finalize())
-                .map_err(|_| TlsError::EncodeError)?;
+                .map_err(|()| TlsError::EncodeError)?;
 
             let signature = signing_key.sign(&msg);
 

src/crypto_engine.rs

@@ -4,6 +4,7 @@ use p256::ecdh::SharedSecret;
 
 pub struct CryptoEngine {}
 
+#[allow(clippy::unused_self, clippy::needless_pass_by_value)] // TODO
 impl CryptoEngine {
     pub fn new(_group: NamedGroup, _shared: SharedSecret) -> Self {
         Self {}

src/extensions/extension_data/key_share.rs

@@ -36,7 +36,7 @@ impl<'a, const N: usize> KeyShareClientHello<'a, N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for client_share in self.client_shares.iter() {
+            for client_share in &self.client_shares {
                 client_share.encode(buf)?;
             }
             Ok(())

src/extensions/extension_data/pre_shared_key.rs

@@ -19,7 +19,7 @@ impl<const N: usize> PreSharedKeyClientHello<'_, N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for identity in self.identities.iter() {
+            for identity in &self.identities {
                 buf.with_u16_length(|buf| buf.extend_from_slice(identity))
                     .map_err(|_| TlsError::EncodeError)?;
 
@@ -56,7 +56,7 @@ impl PreSharedKeyServerHello {
         })
     }
 
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.push_u16(self.selected_identity)
             .map_err(|_| TlsError::EncodeError)
     }

src/extensions/extension_data/psk_key_exchange_modes.rs

@@ -23,8 +23,8 @@ impl PskKeyExchangeMode {
         }
     }
 
-    fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
-        buf.push(*self as u8).map_err(|_| TlsError::EncodeError)
+    fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+        buf.push(self as u8).map_err(|_| TlsError::EncodeError)
     }
 }
 
@@ -44,7 +44,7 @@ impl<const N: usize> PskKeyExchangeModes<N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u8_length(|buf| {
-            for mode in self.modes.iter() {
+            for mode in &self.modes {
                 mode.encode(buf)?;
             }
             Ok(())

src/extensions/extension_data/server_name.rs

@@ -24,8 +24,8 @@ impl NameType {
         }
     }
 
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
-        buf.push(*self as u8).map_err(|_| TlsError::EncodeError)
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+        buf.push(self as u8).map_err(|_| TlsError::EncodeError)
     }
 }
 
@@ -97,7 +97,7 @@ impl<'a, const N: usize> ServerNameList<'a, N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for name in self.names.iter() {
+            for name in &self.names {
                 name.encode(buf)?;
             }
 
@@ -118,13 +118,14 @@ pub struct ServerNameResponse;
 
 impl ServerNameResponse {
     pub fn parse(buf: &mut ParseBuffer) -> Result<Self, ParseError> {
-        if !buf.is_empty() {
-            Err(ParseError::InvalidData)
-        } else {
+        if buf.is_empty() {
             Ok(Self)
+        } else {
+            Err(ParseError::InvalidData)
         }
     }
 
+    #[allow(clippy::unused_self, clippy::unnecessary_wraps)]
     pub fn encode(&self, _buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         Ok(())
     }

src/extensions/extension_data/signature_algorithms.rs

@@ -77,6 +77,7 @@ impl SignatureScheme {
         }
     }
 
+    #[must_use]
     pub fn as_u16(self) -> u16 {
         match self {
             Self::RsaPkcs1Sha256 => 0x0401,
@@ -126,7 +127,7 @@ impl<const N: usize> SignatureAlgorithms<N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for &a in self.supported_signature_algorithms.iter() {
+            for &a in &self.supported_signature_algorithms {
                 buf.push_u16(a.as_u16())
                     .map_err(|_| TlsError::EncodeError)?;
             }

src/extensions/extension_data/signature_algorithms_cert.rs

@@ -24,7 +24,7 @@ impl<const N: usize> SignatureAlgorithmsCert<N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for &a in self.supported_signature_algorithms.iter() {
+            for &a in &self.supported_signature_algorithms {
                 buf.push_u16(a.as_u16())
                     .map_err(|_| TlsError::EncodeError)?;
             }

src/extensions/extension_data/supported_groups.rs

@@ -58,7 +58,7 @@ impl NamedGroup {
         }
     }
 
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.push_u16(self.as_u16())
             .map_err(|_| TlsError::EncodeError)
     }
@@ -81,7 +81,7 @@ impl<const N: usize> SupportedGroups<N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u16_length(|buf| {
-            for g in self.supported_groups.iter() {
+            for g in &self.supported_groups {
                 g.encode(buf)?;
             }
             Ok(())

src/extensions/extension_data/supported_versions.rs

@@ -10,7 +10,7 @@ use heapless::Vec;
 pub struct ProtocolVersion(u16);
 
 impl ProtocolVersion {
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.push_u16(self.0).map_err(|_| TlsError::EncodeError)
     }
 
@@ -38,7 +38,7 @@ impl<const N: usize> SupportedVersionsClientHello<N> {
 
     pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         buf.with_u8_length(|buf| {
-            for v in self.versions.iter() {
+            for v in &self.versions {
                 v.encode(buf)?;
             }
             Ok(())
@@ -59,7 +59,7 @@ impl SupportedVersionsServerHello {
         })
     }
 
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
         self.selected_version.encode(buf)
     }
 }

src/extensions/extension_data/unimplemented.rs

@@ -11,6 +11,7 @@ pub struct Unimplemented<'a> {
 }
 
 impl<'a> Unimplemented<'a> {
+    #[allow(clippy::unnecessary_wraps)]
     pub fn parse(buf: &mut ParseBuffer<'a>) -> Result<Self, ParseError> {
         Ok(Self {
             data: buf.as_slice(),

src/extensions/mod.rs

@@ -72,8 +72,7 @@ impl ExtensionType {
         }
     }
 
-    pub fn encode(&self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
-        buf.push_u16(*self as u16)
-            .map_err(|_| TlsError::EncodeError)
+    pub fn encode(self, buf: &mut CryptoBuffer) -> Result<(), TlsError> {
+        buf.push_u16(self as u16).map_err(|_| TlsError::EncodeError)
     }
 }

src/handshake/binder.rs

@@ -1,4 +1,4 @@
-use crate::buffer::*;
+use crate::buffer::CryptoBuffer;
 use crate::TlsError;
 use core::fmt::{Debug, Formatter};
 //use digest::generic_array::{ArrayLength, GenericArray};

src/handshake/certificate.rs

@@ -51,7 +51,7 @@ impl<'a> CertificateRef<'a> {
     pub(crate) fn encode(&self, buf: &mut CryptoBuffer<'_>) -> Result<(), TlsError> {
         buf.with_u8_length(|buf| buf.extend_from_slice(self.request_context))?;
         buf.with_u24_length(|buf| {
-            for entry in self.entries.iter() {
+            for entry in &self.entries {
                 entry.encode(buf)?;
             }
             Ok(())
@@ -146,11 +146,11 @@ impl<'a, const N: usize> TryFrom<CertificateRef<'a>> for Certificate<N> {
         let mut request_context = Vec::new();
         request_context
             .extend_from_slice(cert.request_context)
-            .map_err(|_| TlsError::OutOfMemory)?;
+            .map_err(|()| TlsError::OutOfMemory)?;
         let mut entries_data = Vec::new();
         entries_data
             .extend_from_slice(cert.raw_entries)
-            .map_err(|_| TlsError::OutOfMemory)?;
+            .map_err(|()| TlsError::OutOfMemory)?;
 
         Ok(Self {
             request_context,

src/handshake/certificate_request.rs

@@ -40,7 +40,7 @@ impl<'a> TryFrom<CertificateRequestRef<'a>> for CertificateRequest {
         let mut request_context = Vec::new();
         request_context
             .extend_from_slice(cert.request_context)
-            .map_err(|_| {
+            .map_err(|()| {
                 error!("CertificateRequest: InsufficientSpace");
                 TlsError::InsufficientSpace
             })?;

src/handshake/client_hello.rs

@@ -21,7 +21,7 @@ use crate::extensions::messages::ClientHelloExtension;
 use crate::handshake::{Random, LEGACY_VERSION};
 use crate::key_schedule::{HashOutputSize, WriteKeySchedule};
 use crate::TlsError;
-use crate::{buffer::*, CryptoProvider};
+use crate::{buffer::CryptoBuffer, CryptoProvider};
 
 pub struct ClientHello<'config, CipherSuite>
 where

src/handshake/finished.rs

@@ -1,4 +1,4 @@
-use crate::buffer::*;
+use crate::buffer::CryptoBuffer;
 use crate::parse_buffer::ParseBuffer;
 use crate::TlsError;
 use core::fmt::{Debug, Formatter};