diff --git a/.clippy.toml b/.clippy.toml new file mode 100644 index 0000000000..ba34bf4642 --- /dev/null +++ b/.clippy.toml @@ -0,0 +1 @@ +too-many-arguments-threshold = 8 diff --git a/src/crypto.rs b/src/crypto.rs index 1282e510ae..2a5146bbfe 100644 --- a/src/crypto.rs +++ b/src/crypto.rs @@ -8,17 +8,14 @@ use sha2::Sha256; pub fn aes_256_cbc_encrypt(ptext: &[u8], key: &[u8], iv: &[u8]) -> Result> { match Cbc::::new_var(key, iv) { Ok(mode) => Ok(mode.encrypt_vec(&ptext)), - Err(block_modes::InvalidKeyIvLength) => { - return Err(SignalProtocolError::InvalidCipherCryptographicParameters( - key.len(), - iv.len(), - )) - } + Err(block_modes::InvalidKeyIvLength) => Err( + SignalProtocolError::InvalidCipherCryptographicParameters(key.len(), iv.len()), + ), } } pub fn aes_256_cbc_decrypt(ctext: &[u8], key: &[u8], iv: &[u8]) -> Result> { - if ctext.len() == 0 || ctext.len() % 16 != 0 { + if ctext.is_empty() || ctext.len() % 16 != 0 { return Err(SignalProtocolError::InvalidCiphertext); } diff --git a/src/fingerprint.rs b/src/fingerprint.rs index b3daf740a2..9d76029f94 100644 --- a/src/fingerprint.rs +++ b/src/fingerprint.rs @@ -68,7 +68,7 @@ pub struct ScannableFingerprint { impl ScannableFingerprint { fn new(version: u32, local_fprint: &[u8], remote_fprint: &[u8]) -> Self { Self { - version: version, + version, local_fingerprint: local_fprint[..32].to_vec(), remote_fingerprint: remote_fprint[..32].to_vec(), } diff --git a/src/group_cipher.rs b/src/group_cipher.rs index d675749ddd..2fe86eefb6 100644 --- a/src/group_cipher.rs +++ b/src/group_cipher.rs @@ -66,7 +66,7 @@ fn get_sender_key(state: &mut SenderKeyState, iteration: u32) -> Result Result<()> { let mut sender_key_record = sender_key_store .load_sender_key(sender_key_name)? - .unwrap_or(SenderKeyRecord::new_empty()); + .unwrap_or_else(SenderKeyRecord::new_empty); sender_key_record.add_sender_key_state( skdm.id()?, diff --git a/src/identity_key.rs b/src/identity_key.rs index baede4469c..a6c04ddb8c 100644 --- a/src/identity_key.rs +++ b/src/identity_key.rs @@ -34,7 +34,7 @@ impl TryFrom<&[u8]> for IdentityKey { type Error = SignalProtocolError; fn try_from(value: &[u8]) -> Result { - IdentityKey::decode(value).into() + IdentityKey::decode(value) } } diff --git a/src/protocol.rs b/src/protocol.rs index b06d11c33f..a6bfa0f3fa 100644 --- a/src/protocol.rs +++ b/src/protocol.rs @@ -600,7 +600,7 @@ impl TryFrom<&[u8]> for SenderKeyDistributionMessage { .ok_or(SignalProtocolError::InvalidProtobufEncoding)?; if chain_key.len() != 32 || signing_key.len() != 33 { - return Err(SignalProtocolError::InvalidProtobufEncoding)?; + return Err(SignalProtocolError::InvalidProtobufEncoding); } let signing_key = curve::PublicKey::deserialize(&signing_key)?; diff --git a/src/ratchet.rs b/src/ratchet.rs index 36eada6916..8aab91fdfd 100644 --- a/src/ratchet.rs +++ b/src/ratchet.rs @@ -13,7 +13,7 @@ use rand::{CryptoRng, Rng}; fn derive_keys(secret_input: &[u8]) -> Result<(RootKey, ChainKey)> { let kdf = crate::kdf::HKDF::new(3)?; - let secrets = kdf.derive_secrets(secret_input, "WhisperText".as_bytes(), 64)?; + let secrets = kdf.derive_secrets(secret_input, b"WhisperText", 64)?; let root_key = RootKey::new(kdf, &secrets[0..32])?; let chain_key = ChainKey::new(kdf, &secrets[32..64], 0)?; diff --git a/src/sender_keys.rs b/src/sender_keys.rs index b10f74fabe..0d57ec1690 100644 --- a/src/sender_keys.rs +++ b/src/sender_keys.rs @@ -40,7 +40,7 @@ pub struct SenderMessageKey { impl SenderMessageKey { pub fn new(iteration: u32, seed: &[u8]) -> Result { let hkdf = HKDF::new(3)?; - let derived = hkdf.derive_secrets(seed, "WhisperGroup".as_bytes(), 48)?; + let derived = hkdf.derive_secrets(seed, b"WhisperGroup", 48)?; Ok(Self { iteration, seed: seed.to_vec(), @@ -96,7 +96,7 @@ impl SenderChainKey { pub fn new(iteration: u32, chain_key: Vec) -> Result { Ok(Self { iteration, - chain_key: chain_key, + chain_key, }) } @@ -270,11 +270,11 @@ impl SenderKeyRecord { } pub fn empty(&self) -> Result { - Ok(self.states.len() == 0) + Ok(self.states.is_empty()) } pub fn sender_key_state(&mut self) -> Result<&mut SenderKeyState> { - if self.states.len() > 0 { + if !self.states.is_empty() { return Ok(&mut self.states[0]); } Err(SignalProtocolError::NoSenderKeyState) diff --git a/src/session.rs b/src/session.rs index fd86d3c08e..b95e5e2723 100644 --- a/src/session.rs +++ b/src/session.rs @@ -84,7 +84,7 @@ fn process_prekey_v3( our_signed_pre_key_pair, // signed pre key our_one_time_pre_key_pair, our_signed_pre_key_pair, // ratchet key - message.identity_key().clone(), + *message.identity_key(), *message.base_key(), ); @@ -130,7 +130,7 @@ pub fn process_prekey_bundle( let mut session_record = session_store .load_session(&remote_address)? - .unwrap_or(SessionRecord::new_fresh()); + .unwrap_or_else(SessionRecord::new_fresh); let our_base_key_pair = curve::KeyPair::new(&mut csprng); let their_signed_prekey = bundle.signed_pre_key_public()?; diff --git a/src/state/session.rs b/src/state/session.rs index 5fdc1b8228..d1fe1c1495 100644 --- a/src/state/session.rs +++ b/src/state/session.rs @@ -218,23 +218,13 @@ impl SessionState { } pub fn get_sender_chain_key(&self) -> Result { - let sender_chain = - self.session - .sender_chain - .as_ref() - .ok_or(SignalProtocolError::InvalidState( - "get_sender_chain_key", - "No chain".to_owned(), - ))?; - - let chain_key = - sender_chain - .chain_key - .as_ref() - .ok_or(SignalProtocolError::InvalidState( - "get_sender_chain_key", - "No chain key".to_owned(), - ))?; + let sender_chain = self.session.sender_chain.as_ref().ok_or_else(|| { + SignalProtocolError::InvalidState("get_sender_chain_key", "No chain".to_owned()) + })?; + + let chain_key = sender_chain.chain_key.as_ref().ok_or_else(|| { + SignalProtocolError::InvalidState("get_sender_chain_key", "No chain key".to_owned()) + })?; let hkdf = kdf::HKDF::new(self.session_version()?)?; ChainKey::new(hkdf, &chain_key.key, chain_key.index) @@ -329,12 +319,12 @@ impl SessionState { } self.session.receiver_chains[chain_and_index.1] = updated_chain; - return Ok(()); + Ok(()) } else { - return Err(SignalProtocolError::InvalidState( + Err(SignalProtocolError::InvalidState( "set_message_keys", "No receiver".to_string(), - )); + )) } } @@ -611,17 +601,14 @@ impl SessionRecord { old_session: usize, updated_session: SessionState, ) -> Result<()> { - self.previous_sessions - .remove(old_session) - .ok_or(SignalProtocolError::InvalidState( - "promote_old_session", - "out of range".into(), - ))?; + self.previous_sessions.remove(old_session).ok_or_else(|| { + SignalProtocolError::InvalidState("promote_old_session", "out of range".into()) + })?; self.promote_state(updated_session) } pub fn is_fresh(&self) -> Result { - Ok(self.current_session.is_none() && self.previous_sessions.len() == 0) + Ok(self.current_session.is_none() && self.previous_sessions.is_empty()) } pub fn promote_state(&mut self, new_state: SessionState) -> Result<()> { diff --git a/src/storage/inmem.rs b/src/storage/inmem.rs index fd3628961c..2e07d58b60 100644 --- a/src/storage/inmem.rs +++ b/src/storage/inmem.rs @@ -23,7 +23,7 @@ impl InMemIdentityKeyStore { impl traits::IdentityKeyStore for InMemIdentityKeyStore { fn get_identity_key_pair(&self) -> Result { - Ok(self.key_pair.clone()) + Ok(self.key_pair) } fn get_local_registration_id(&self) -> Result { @@ -33,14 +33,14 @@ impl traits::IdentityKeyStore for InMemIdentityKeyStore { fn save_identity(&mut self, address: &ProtocolAddress, identity: &IdentityKey) -> Result { match self.known_keys.get(address) { None => { - self.known_keys.insert(address.clone(), identity.clone()); + self.known_keys.insert(address.clone(), *identity); Ok(false) // new key } Some(k) if k == identity => { Ok(false) // same key } Some(_k) => { - self.known_keys.insert(address.clone(), identity.clone()); + self.known_keys.insert(address.clone(), *identity); Ok(true) // overwrite } } @@ -80,6 +80,12 @@ impl InMemPreKeyStore { } } +impl Default for InMemPreKeyStore { + fn default() -> Self { + Self::new() + } +} + impl traits::PreKeyStore for InMemPreKeyStore { fn get_pre_key(&self, id: PreKeyId) -> Result { Ok(self @@ -118,6 +124,12 @@ impl InMemSignedPreKeyStore { } } +impl Default for InMemSignedPreKeyStore { + fn default() -> Self { + Self::new() + } +} + impl traits::SignedPreKeyStore for InMemSignedPreKeyStore { fn get_signed_pre_key(&self, id: SignedPreKeyId) -> Result { Ok(self @@ -168,6 +180,12 @@ impl InMemSessionStore { } } +impl Default for InMemSessionStore { + fn default() -> Self { + Self::new() + } +} + impl traits::SessionStore for InMemSessionStore { fn load_session(&self, address: &ProtocolAddress) -> Result> { match self.sessions.get(address) { @@ -220,6 +238,12 @@ impl InMemSenderKeyStore { } } +impl Default for InMemSenderKeyStore { + fn default() -> Self { + Self::new() + } +} + impl traits::SenderKeyStore for InMemSenderKeyStore { fn store_sender_key( &mut self, @@ -234,7 +258,7 @@ impl traits::SenderKeyStore for InMemSenderKeyStore { &mut self, sender_key_name: &SenderKeyName, ) -> Result> { - Ok(self.keys.get(&sender_key_name).map(|x| x.clone())) + Ok(self.keys.get(&sender_key_name).cloned()) } }