xmppftw/xmpp-rs
Watch
1
0
Fork
You've already forked xmpp-rs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Fix clippy lints for sasl crate

Browse source
This commit is contained in:
Lucas Kent 2024-05-06 08:01:54 +10:00 • committed by pep
commit 1449d300dd
8 changed files with 37 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

1
sasl/src/client/mechanisms/anonymous.rs
View file

@ -11,6 +11,7 @@ impl Anonymous {
/// ///
/// It is recommended that instead you use a `Credentials` struct and turn it into the /// It is recommended that instead you use a `Credentials` struct and turn it into the
/// requested mechanism using `from_credentials`. /// requested mechanism using `from_credentials`.
#[allow(clippy::new_without_default)]
pub fn new() -> Anonymous { pub fn new() -> Anonymous {
Anonymous Anonymous
} }

18
sasl/src/client/mechanisms/scram.rs
View file

@ -51,7 +51,7 @@ impl<S: ScramProvider> Scram<S> {
password: password.into(), password: password.into(),
client_nonce: generate_nonce()?, client_nonce: generate_nonce()?,
state: ScramState::Init, state: ScramState::Init,
channel_binding: channel_binding, channel_binding,
_marker: PhantomData, _marker: PhantomData,
}) })
} }
@ -112,7 +112,7 @@ impl<S: ScramProvider> Mechanism for Scram<S> {
data.extend(&bare); data.extend(&bare);
self.state = ScramState::SentInitialMessage { self.state = ScramState::SentInitialMessage {
initial_message: bare, initial_message: bare,
gs2_header: gs2_header, gs2_header,
}; };
data data
} }
@ -130,9 +130,9 @@ impl<S: ScramProvider> Mechanism for Scram<S> {
let server_nonce = frame.get("r"); let server_nonce = frame.get("r");
let salt = frame.get("s").and_then(|v| Base64.decode(v).ok()); let salt = frame.get("s").and_then(|v| Base64.decode(v).ok());
let iterations = frame.get("i").and_then(|v| v.parse().ok()); let iterations = frame.get("i").and_then(|v| v.parse().ok());
let server_nonce = server_nonce.ok_or_else(|| MechanismError::NoServerNonce)?; let server_nonce = server_nonce.ok_or(MechanismError::NoServerNonce)?;
let salt = salt.ok_or_else(|| MechanismError::NoServerSalt)?; let salt = salt.ok_or(MechanismError::NoServerSalt)?;
let iterations = iterations.ok_or_else(|| MechanismError::NoServerIterations)?; let iterations = iterations.ok_or(MechanismError::NoServerIterations)?;
// TODO: SASLprep // TODO: SASLprep
let mut client_final_message_bare = Vec::new(); let mut client_final_message_bare = Vec::new();
client_final_message_bare.extend(b"c="); client_final_message_bare.extend(b"c=");
@ -158,10 +158,8 @@ impl<S: ScramProvider> Mechanism for Scram<S> {
let mut client_final_message = Vec::new(); let mut client_final_message = Vec::new();
client_final_message.extend(&client_final_message_bare); client_final_message.extend(&client_final_message_bare);
client_final_message.extend(b",p="); client_final_message.extend(b",p=");
client_final_message.extend(Base64.encode(&client_proof).bytes()); client_final_message.extend(Base64.encode(client_proof).bytes());
next_state = ScramState::GotServerData { next_state = ScramState::GotServerData { server_signature };
server_signature: server_signature,
};
ret = client_final_message; ret = client_final_message;
} }
_ => { _ => {
@ -178,7 +176,7 @@ impl<S: ScramProvider> Mechanism for Scram<S> {
ScramState::GotServerData { ScramState::GotServerData {
ref server_signature, ref server_signature,
} => { } => {
if let Some(sig) = frame.get("v").and_then(|v| Base64.decode(&v).ok()) { if let Some(sig) = frame.get("v").and_then(|v| Base64.decode(v).ok()) {
if sig == *server_signature { if sig == *server_signature {
Ok(()) Ok(())
} else { } else {

15
sasl/src/common/mod.rs
View file

@ -86,9 +86,9 @@ impl Secret {
) -> Secret { ) -> Secret {
Secret::Password(Password::Pbkdf2 { Secret::Password(Password::Pbkdf2 {
method: method.into(), method: method.into(),
salt: salt, salt,
iterations: iterations, iterations,
data: data, data,
}) })
} }
} }
@ -135,7 +135,7 @@ fn xor_works() {
pub fn xor(a: &[u8], b: &[u8]) -> Vec<u8> { pub fn xor(a: &[u8], b: &[u8]) -> Vec<u8> {
assert_eq!(a.len(), b.len()); assert_eq!(a.len(), b.len());
let mut ret = Vec::with_capacity(a.len()); let mut ret = Vec::with_capacity(a.len());
for (a, b) in a.into_iter().zip(b) { for (a, b) in a.iter().zip(b) {
ret.push(a ^ b); ret.push(a ^ b);
} }
ret ret
@ -149,11 +149,8 @@ pub fn parse_frame(frame: &[u8]) -> Result<HashMap<String, String>, FromUtf8Erro
let mut tmp = s.splitn(2, '='); let mut tmp = s.splitn(2, '=');
let key = tmp.next(); let key = tmp.next();
let val = tmp.next(); let val = tmp.next();
match (key, val) { if let (Some(k), Some(v)) = (key, val) {
(Some(k), Some(v)) => { ret.insert(k.to_owned(), v.to_owned());
ret.insert(k.to_owned(), v.to_owned());
}
_ => (),
} }
} }
Ok(ret) Ok(ret)

6
sasl/src/common/scram.rs
View file

@ -14,7 +14,7 @@ use base64::{engine::general_purpose::STANDARD as Base64, Engine};
pub fn generate_nonce() -> Result<String, RngError> { pub fn generate_nonce() -> Result<String, RngError> {
let mut data = [0u8; 32]; let mut data = [0u8; 32];
getrandom(&mut data)?; getrandom(&mut data)?;
Ok(Base64.encode(&data)) Ok(Base64.encode(data))
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@ -111,7 +111,7 @@ impl ScramProvider for Sha1 {
method.to_string(), method.to_string(),
Self::name().to_string(), Self::name().to_string(),
)) ))
} else if my_salt == &salt { } else if my_salt == salt {
Err(DeriveError::IncorrectSalt) Err(DeriveError::IncorrectSalt)
} else if my_iterations == iterations { } else if my_iterations == iterations {
Err(DeriveError::IncompatibleIterationCount( Err(DeriveError::IncompatibleIterationCount(
@ -171,7 +171,7 @@ impl ScramProvider for Sha256 {
method.to_string(), method.to_string(),
Self::name().to_string(), Self::name().to_string(),
)) ))
} else if my_salt == &salt { } else if my_salt == salt {
Err(DeriveError::IncorrectSalt) Err(DeriveError::IncorrectSalt)
} else if my_iterations == iterations { } else if my_iterations == iterations {
Err(DeriveError::IncompatibleIterationCount( Err(DeriveError::IncompatibleIterationCount(

8
sasl/src/secret.rs
View file

@ -30,8 +30,8 @@ impl Pbkdf2Sha1 {
let digest = Sha1::derive(&Password::Plain(password.to_owned()), salt, iterations)?; let digest = Sha1::derive(&Password::Plain(password.to_owned()), salt, iterations)?;
Ok(Pbkdf2Sha1 { Ok(Pbkdf2Sha1 {
salt: salt.to_vec(), salt: salt.to_vec(),
iterations: iterations, iterations,
digest: digest, digest,
}) })
} }
} }
@ -70,8 +70,8 @@ impl Pbkdf2Sha256 {
let digest = Sha256::derive(&Password::Plain(password.to_owned()), salt, iterations)?; let digest = Sha256::derive(&Password::Plain(password.to_owned()), salt, iterations)?;
Ok(Pbkdf2Sha256 { Ok(Pbkdf2Sha256 {
salt: salt.to_vec(), salt: salt.to_vec(),
iterations: iterations, iterations,
digest: digest, digest,
}) })
} }
} }

1
sasl/src/server/mechanisms/anonymous.rs
View file

@ -6,6 +6,7 @@ use getrandom::getrandom;
pub struct Anonymous; pub struct Anonymous;
impl Anonymous { impl Anonymous {
#[allow(clippy::new_without_default)]
pub fn new() -> Anonymous { pub fn new() -> Anonymous {
Anonymous Anonymous
} }

12
sasl/src/server/mechanisms/plain.rs
View file

@ -8,9 +8,7 @@ pub struct Plain<V: Validator<secret::Plain>> {
impl<V: Validator<secret::Plain>> Plain<V> { impl<V: Validator<secret::Plain>> Plain<V> {
pub fn new(validator: V) -> Plain<V> { pub fn new(validator: V) -> Plain<V> {
Plain { Plain { validator }
validator: validator,
}
} }
} }
@ -22,14 +20,10 @@ impl<V: Validator<secret::Plain>> Mechanism for Plain<V> {
fn respond(&mut self, payload: &[u8]) -> Result<Response, MechanismError> { fn respond(&mut self, payload: &[u8]) -> Result<Response, MechanismError> {
let mut sp = payload.split(|&b| b == 0); let mut sp = payload.split(|&b| b == 0);
sp.next(); sp.next();
let username = sp let username = sp.next().ok_or(MechanismError::NoUsernameSpecified)?;
.next()
.ok_or_else(|| MechanismError::NoUsernameSpecified)?;
let username = String::from_utf8(username.to_vec()) let username = String::from_utf8(username.to_vec())
.map_err(|_| MechanismError::ErrorDecodingUsername)?; .map_err(|_| MechanismError::ErrorDecodingUsername)?;
let password = sp let password = sp.next().ok_or(MechanismError::NoPasswordSpecified)?;
.next()
.ok_or_else(|| MechanismError::NoPasswordSpecified)?;
let password = String::from_utf8(password.to_vec()) let password = String::from_utf8(password.to_vec())
.map_err(|_| MechanismError::ErrorDecodingPassword)?; .map_err(|_| MechanismError::ErrorDecodingPassword)?;
let ident = Identity::Username(username); let ident = Identity::Username(username);

22
sasl/src/server/mechanisms/scram.rs
View file

@ -44,8 +44,8 @@ where
Scram { Scram {
name: format!("SCRAM-{}", S::name()), name: format!("SCRAM-{}", S::name()),
state: ScramState::Init, state: ScramState::Init,
channel_binding: channel_binding, channel_binding,
provider: provider, provider,
_marker: PhantomData, _marker: PhantomData,
} }
} }
@ -108,9 +108,9 @@ where
} }
let frame = let frame =
parse_frame(&rest).map_err(|_| MechanismError::CannotDecodeInitialMessage)?; parse_frame(&rest).map_err(|_| MechanismError::CannotDecodeInitialMessage)?;
let username = frame.get("n").ok_or_else(|| MechanismError::NoUsername)?; let username = frame.get("n").ok_or(MechanismError::NoUsername)?;
let identity = Identity::Username(username.to_owned()); let identity = Identity::Username(username.to_owned());
let client_nonce = frame.get("r").ok_or_else(|| MechanismError::NoNonce)?; let client_nonce = frame.get("r").ok_or(MechanismError::NoNonce)?;
let mut server_nonce = String::new(); let mut server_nonce = String::new();
server_nonce += client_nonce; server_nonce += client_nonce;
server_nonce += server_nonce +=
@ -125,12 +125,12 @@ where
buf.extend(pbkdf2.iterations().to_string().bytes()); buf.extend(pbkdf2.iterations().to_string().bytes());
ret = Response::Proceed(buf.clone()); ret = Response::Proceed(buf.clone());
next_state = ScramState::SentChallenge { next_state = ScramState::SentChallenge {
server_nonce: server_nonce, server_nonce,
identity: identity, identity,
salted_password: pbkdf2.digest().to_vec(), salted_password: pbkdf2.digest().to_vec(),
initial_client_message: rest, initial_client_message: rest,
initial_server_message: buf, initial_server_message: buf,
gs2_header: gs2_header, gs2_header,
}; };
} }
ScramState::SentChallenge { ScramState::SentChallenge {
@ -151,8 +151,8 @@ where
client_final_message_bare.extend(Base64.encode(&cb_data).bytes()); client_final_message_bare.extend(Base64.encode(&cb_data).bytes());
client_final_message_bare.extend(b",r="); client_final_message_bare.extend(b",r=");
client_final_message_bare.extend(server_nonce.bytes()); client_final_message_bare.extend(server_nonce.bytes());
let client_key = S::hmac(b"Client Key", &salted_password)?; let client_key = S::hmac(b"Client Key", salted_password)?;
let server_key = S::hmac(b"Server Key", &salted_password)?; let server_key = S::hmac(b"Server Key", salted_password)?;
let mut auth_message = Vec::new(); let mut auth_message = Vec::new();
auth_message.extend(initial_client_message); auth_message.extend(initial_client_message);
auth_message.extend(b","); auth_message.extend(b",");
@ -162,7 +162,7 @@ where
let stored_key = S::hash(&client_key); let stored_key = S::hash(&client_key);
let client_signature = S::hmac(&auth_message, &stored_key)?; let client_signature = S::hmac(&auth_message, &stored_key)?;
let client_proof = xor(&client_key, &client_signature); let client_proof = xor(&client_key, &client_signature);
let sent_proof = frame.get("p").ok_or_else(|| MechanismError::NoProof)?; let sent_proof = frame.get("p").ok_or(MechanismError::NoProof)?;
let sent_proof = Base64 let sent_proof = Base64
.decode(sent_proof) .decode(sent_proof)
.map_err(|_| MechanismError::CannotDecodeProof)?; .map_err(|_| MechanismError::CannotDecodeProof)?;
@ -172,7 +172,7 @@ where
let server_signature = S::hmac(&auth_message, &server_key)?; let server_signature = S::hmac(&auth_message, &server_key)?;
let mut buf = Vec::new(); let mut buf = Vec::new();
buf.extend(b"v="); buf.extend(b"v=");
buf.extend(Base64.encode(&server_signature).bytes()); buf.extend(Base64.encode(server_signature).bytes());
ret = Response::Success(identity.clone(), buf); ret = Response::Success(identity.clone(), buf);
next_state = ScramState::Done; next_state = ScramState::Done;
} }