Fix clippy lints

Author: robinhundt

Cargo.toml

@@ -57,3 +57,6 @@ inherits = "release"
 codegen-units = 1
 inherits = "release"
 lto = "fat"
+
+[workspace.lints.clippy]
+unwrap_used = "warn"

cryprot-codes/Cargo.toml

@@ -13,6 +13,9 @@ repository.workspace = true
 bench-libote = ["dep:libote-codes"]
 libote-compat = ["dep:libote-codes"]
 
+[lints]
+workspace = true
+
 [lib]
 bench = false
 

cryprot-codes/src/ex_conv.rs

@@ -269,7 +269,7 @@ impl ExConvCode {
         #[cfg(debug_assertions)]
         for (i, bb) in bb.iter().enumerate() {
             let exp = if ((b >> i) & 1) != 0 { xi } else { Block::ZERO };
-            debug_assert_eq!(exp, bytemuck::cast(*bb))
+            debug_assert_eq!(exp, bytemuck::cast(*bb));
         }
 
         seq!(N in 0..8 {

cryprot-core/Cargo.toml

@@ -9,6 +9,9 @@ version = "0.2.0"
 authors.workspace = true
 repository.workspace = true
 
+[lints]
+workspace = true
+
 [lib]
 bench = false
 

cryprot-core/src/aes_hash.rs

@@ -85,7 +85,7 @@ impl AesHash {
         for chunk in x.chunks_mut(AES_PAR_BLOCKS) {
             self.aes
                 .encrypt_blocks_b2b(bytemuck::cast_slice(chunk), &mut tmp[..chunk.len()])
-                .unwrap();
+                .expect("in and out always have same length");
             chunk
                 .iter_mut()
                 .zip(tmp)
@@ -101,7 +101,7 @@ impl AesHash {
         for (chunk_idx, chunk) in x.chunks_mut(AES_PAR_BLOCKS).enumerate() {
             self.aes
                 .encrypt_blocks_b2b(bytemuck::cast_slice(chunk), &mut tmp[..chunk.len()])
-                .unwrap();
+                .expect("in and out always have same length");
             chunk
                 .iter_mut()
                 .zip(&mut tmp)

cryprot-core/src/block/gf128.rs

@@ -118,7 +118,7 @@ mod clmul {
     #[inline]
     pub unsafe fn clmul128(a: __m128i, b: __m128i) -> (__m128i, __m128i) {
         // This is currently needed because we run the nightly version of
-        // clippy where this is an unused unsafe because the used 
+        // clippy where this is an unused unsafe because the used
         // intrinsincs have been marked safe on nightly but not yet on
         // stable.
         #[allow(unused_unsafe)]

cryprot-core/src/transpose/avx2.rs

@@ -153,7 +153,7 @@ const AVX_BLOCK_SHIFT: usize = 4;
 const AVX_BLOCK_SIZE: usize = 1 << AVX_BLOCK_SHIFT;
 
 /// Transpose 128x128 bit matrix using AVX2.
-/// 
+///
 /// # Safety
 /// AVX2 needs to be enabled.
 #[target_feature(enable = "avx2")]

cryprot-net/Cargo.toml

@@ -13,6 +13,9 @@ repository.workspace = true
 __testing = ["dep:anyhow", "metrics"]
 metrics = ["dep:tracing-subscriber", "serde/derive"]
 
+[lints]
+workspace = true
+
 [dependencies]
 anyhow = { workspace = true, optional = true }
 bincode.workspace = true

cryprot-ot/Cargo.toml

@@ -9,6 +9,9 @@ version = "0.2.0"
 authors.workspace = true
 repository.workspace = true
 
+[lints]
+workspace = true
+
 [lib]
 # https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
 bench = false

cryprot-ot/src/adapter.rs

@@ -1,10 +1,13 @@
 //! Adapters for OT types.
 
+use std::io;
+
 use bitvec::{order::Lsb0, vec::BitVec};
 use cryprot_core::{Block, buf::Buf};
 use cryprot_net::ConnectionError;
 use futures::{SinkExt, StreamExt};
 use subtle::ConditionallySelectable;
+use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use crate::{
@@ -38,8 +41,20 @@ impl<P: SemiHonest> SemiHonest for ChosenChoice<P> {}
 // TODO is there something I can cite that this holds?
 impl<P: Malicious> Malicious for ChosenChoice<P> {}
 
+#[derive(Error, Debug)]
+pub enum Error<E> {
+    #[error("unable to perform R-OTs")]
+    Rot(E),
+    #[error("error in sending correction values for C-OT")]
+    Correction(io::Error),
+    #[error("expected correction values but receiver is closed")]
+    MissingCorrection,
+    #[error("connection error to peer")]
+    Connecion(#[from] ConnectionError),
+}
+
 impl<R: RandChoiceRotReceiver> RotReceiver for ChosenChoice<R> {
-    type Error = R::Error;
+    type Error = Error<R::Error>;
 
     async fn receive_into(
         &mut self,
@@ -50,30 +65,33 @@ impl<R: RandChoiceRotReceiver> RotReceiver for ChosenChoice<R> {
             .0
             .rand_choice_receive_into(ots)
             .await
-            .map_err(|_| ())
-            .unwrap();
+            .map_err(Error::Rot)?;
         for (c1, c2) in rand_choices.iter_mut().zip(choices) {
             *c1 ^= *c2;
         }
         let mut bv: BitVec<u8, Lsb0> = BitVec::with_capacity(choices.len());
         bv.extend(rand_choices.iter().map(|c| c.unwrap_u8() != 0));
 
-        let (mut tx, _) = self.connection().stream().await.unwrap();
-        tx.send(bv).await.unwrap();
+        let (mut tx, _) = self.connection().stream().await?;
+        tx.send(bv).await.map_err(Error::Correction)?;
         Ok(())
     }
 }
 
 impl<S: RotSender + RandChoiceRotSender + Send> RotSender for ChosenChoice<S> {
-    type Error = S::Error;
+    type Error = Error<S::Error>;
 
     async fn send_into(
         &mut self,
         ots: &mut impl cryprot_core::buf::Buf<[cryprot_core::Block; 2]>,
     ) -> Result<(), Self::Error> {
-        self.0.send_into(ots).await.map_err(|_| ()).unwrap();
-        let (_, mut rx) = self.connection().stream().await.unwrap();
-        let correction: BitVec<u8, Lsb0> = rx.next().await.unwrap().unwrap();
+        self.0.send_into(ots).await.map_err(Error::Rot)?;
+        let (_, mut rx) = self.connection().stream().await?;
+        let correction: BitVec<u8, Lsb0> = rx
+            .next()
+            .await
+            .ok_or(Error::MissingCorrection)?
+            .map_err(Error::Correction)?;
 
         for (ots, c_bit) in ots.iter_mut().zip(correction) {
             let tmp = *ots;