Apply lints

Author: iinuwa

creds-lib/src/model.rs

@@ -22,8 +22,8 @@ pub enum CredentialRequest {
 
 #[derive(Clone, Debug)]
 pub enum CredentialResponse {
-    CreatePublicKeyCredentialResponse(MakeCredentialResponseInternal),
-    GetPublicKeyCredentialResponse(GetAssertionResponseInternal),
+    CreatePublicKeyCredentialResponse(Box<MakeCredentialResponseInternal>),
+    GetPublicKeyCredentialResponse(Box<GetAssertionResponseInternal>),
 }
 
 impl CredentialResponse {
@@ -32,17 +32,18 @@ impl CredentialResponse {
         transports: &[&str],
         modality: &str,
     ) -> CredentialResponse {
-        CredentialResponse::CreatePublicKeyCredentialResponse(MakeCredentialResponseInternal::new(
-            response.clone(),
-            transports.iter().map(|s| s.to_string()).collect(),
-            modality.to_string(),
+        CredentialResponse::CreatePublicKeyCredentialResponse(Box::new(
+            MakeCredentialResponseInternal::new(
+                response.clone(),
+                transports.iter().map(|s| s.to_string()).collect(),
+                modality.to_string(),
+            ),
         ))
     }
 
     pub fn from_get_assertion(assertion: &Assertion, modality: &str) -> CredentialResponse {
-        CredentialResponse::GetPublicKeyCredentialResponse(GetAssertionResponseInternal::new(
-            assertion.clone(),
-            modality.to_string(),
+        CredentialResponse::GetPublicKeyCredentialResponse(Box::new(
+            GetAssertionResponseInternal::new(assertion.clone(), modality.to_string()),
         ))
     }
 }

creds-ui/src/client.rs

@@ -81,7 +81,7 @@ impl FlowController for DbusCredentialClient {
             .initiate_event_stream()
             .await
             .map_err(|err| tracing::error!("Failed to initialize event stream: {err}"))
-            .and_then(|_| Ok(stream))
+            .map(|_| stream)
     }
 
     async fn enter_client_pin(&mut self, pin: String) -> std::result::Result<(), ()> {

creds-ui/src/gui/view_model/mod.rs

@@ -61,8 +61,8 @@ impl<F: FlowController + Send> ViewModel<F> {
 
     async fn update_title(&mut self) {
         self.title = match self.operation {
-            Operation::Create { .. } => "Create new credential",
-            Operation::Get { .. } => "Use a credential",
+            Operation::Create => "Create new credential",
+            Operation::Get => "Use a credential",
         }
         .to_string();
         self.tx_update
@@ -158,12 +158,13 @@ impl<F: FlowController + Send> ViewModel<F> {
                         cred_id, self.selected_device
                     );
 
-                    if let Err(_) = self
+                    if self
                         .flow_controller
                         .lock()
                         .await
                         .select_credential(cred_id)
                         .await
+                        .is_err()
                     {
                         let error_msg = "Failed to select credential from device.";
                         tracing::error!(error_msg);

credsd/src/credential_service/hybrid.rs

@@ -124,7 +124,7 @@ impl HybridHandler for InternalHybridHandler {
                     }
                 };
                 let terminal_state = match response {
-                    Ok(auth_response) => HybridStateInternal::Completed(auth_response),
+                    Ok(auth_response) => HybridStateInternal::Completed(Box::new(auth_response)),
                     Err(_) => HybridStateInternal::Failed,
                 };
                 if let Err(err) = tx.send(terminal_state).await {
@@ -154,7 +154,7 @@ pub(super) enum HybridStateInternal {
     Connected,
 
     /// Authenticator data
-    Completed(AuthenticatorResponse),
+    Completed(Box<AuthenticatorResponse>),
 
     Failed,
     // TODO(cancellation)
@@ -341,7 +341,7 @@ pub(super) mod test {
                 states: vec![
                     HybridStateInternal::Init(qr_code),
                     HybridStateInternal::Connecting,
-                    HybridStateInternal::Completed(response.into()),
+                    HybridStateInternal::Completed(Box::new(response.into())),
                 ],
             }
         }

credsd/src/credential_service/mod.rs

@@ -15,7 +15,7 @@ use libwebauthn::{
     self,
     ops::webauthn::{GetAssertionResponse, MakeCredentialResponse},
 };
-use tokio::sync::{oneshot::Sender, Mutex as AsyncMutex};
+use tokio::sync::oneshot::Sender;
 
 use creds_lib::{
     model::{
@@ -133,7 +133,7 @@ impl<H: HybridHandler + Debug, U: UsbHandler + Debug, UC: UiController + Debug>
     ) -> Pin<Box<dyn Stream<Item = HybridState> + Send + 'static>> {
         let guard = self.ctx.lock().unwrap();
         if let Some((ref cred_request, _)) = *guard {
-            let stream = self.hybrid_handler.start(&cred_request);
+            let stream = self.hybrid_handler.start(cred_request);
             let ctx = self.ctx.clone();
             Box::pin(HybridStateStream { inner: stream, ctx })
         } else {
@@ -147,7 +147,7 @@ impl<H: HybridHandler + Debug, U: UsbHandler + Debug, UC: UiController + Debug>
     pub fn get_usb_credential(&self) -> Pin<Box<dyn Stream<Item = UsbState> + Send + 'static>> {
         let guard = self.ctx.lock().unwrap();
         if let Some((ref cred_request, _)) = *guard {
-            let stream = self.usb_handler.start(&cred_request);
+            let stream = self.usb_handler.start(cred_request);
             let ctx = self.ctx.clone();
             Box::pin(UsbStateStream { inner: stream, ctx })
         } else {
@@ -179,7 +179,7 @@ where
             Poll::Pending => Poll::Pending,
             Poll::Ready(Some(HybridEvent { state })) => {
                 if let HybridStateInternal::Completed(hybrid_response) = &state {
-                    let response = match hybrid_response {
+                    let response = match &**hybrid_response {
                         AuthenticatorResponse::CredentialCreated(make_credential_response) => {
                             CredentialResponse::from_make_credential(
                                 make_credential_response,
@@ -250,13 +250,13 @@ fn complete_request(ctx: &Mutex<Option<RequestContext>>, response: CredentialRes
 
 #[derive(Debug, Clone)]
 enum AuthenticatorResponse {
-    CredentialCreated(MakeCredentialResponse),
+    CredentialCreated(Box<MakeCredentialResponse>),
     CredentialsAsserted(GetAssertionResponse),
 }
 
 impl From<MakeCredentialResponse> for AuthenticatorResponse {
     fn from(value: MakeCredentialResponse) -> Self {
-        Self::CredentialCreated(value)
+        Self::CredentialCreated(Box::new(value))
     }
 }
 
@@ -307,7 +307,7 @@ mod test {
                 let hybrid_handler = DummyHybridHandler::new(vec![
                     HybridStateInternal::Init(qr_code),
                     HybridStateInternal::Connecting,
-                    HybridStateInternal::Completed(authenticator_response),
+                    HybridStateInternal::Completed(Box::new(authenticator_response)),
                 ]);
                 let usb_handler = InProcessUsbHandler {};
                 let (ui_server, ui_client) = DummyUiServer::new(Vec::new());

credsd/src/credential_service/usb.rs

@@ -165,12 +165,12 @@ impl InProcessUsbHandler {
                     .cloned();
                 match assertion {
                     Some(assertion) => Ok(UsbStateInternal::Completed(
-                        CredentialResponse::GetPublicKeyCredentialResponse(
+                        CredentialResponse::GetPublicKeyCredentialResponse(Box::new(
                             GetAssertionResponseInternal::new(
                                 assertion,
                                 "cross-platform".to_string(),
                             ),
-                        ),
+                        )),
                     )),
                     None => Err(Error::NoCredentials),
                 }
@@ -201,7 +201,7 @@ impl InProcessUsbHandler {
                     Ok(UsbStateInternal::NeedsUserVerification { attempts_left })
                 }
                 Ok(UsbUvMessage::NeedsUserPresence) => Ok(UsbStateInternal::NeedsUserPresence),
-                Ok(UsbUvMessage::ReceivedCredentials(response)) => match response {
+                Ok(UsbUvMessage::ReceivedCredentials(response)) => match *response {
                     AuthenticatorResponse::CredentialCreated(make_credential_response) => Ok(
                         UsbStateInternal::Completed(CredentialResponse::from_make_credential(
                             &make_credential_response,
@@ -307,12 +307,16 @@ async fn handle_events(
                         channel
                             .webauthn_make_credential(make_cred_request)
                             .await
-                            .map(|response| UsbUvMessage::ReceivedCredentials(response.into()))
+                            .map(|response| {
+                                UsbUvMessage::ReceivedCredentials(Box::new(response.into()))
+                            })
                     }
                     CredentialRequest::GetPublicKeyCredentialRequest(get_cred_request) => channel
                         .webauthn_get_assertion(get_cred_request)
                         .await
-                        .map(|response| UsbUvMessage::ReceivedCredentials(response.into())),
+                        .map(|response| {
+                            UsbUvMessage::ReceivedCredentials(Box::new(response.into()))
+                        }),
                 };
                 match response {
                     Ok(response) => {
@@ -613,5 +617,5 @@ enum UsbUvMessage {
         attempts_left: Option<u32>,
     },
     NeedsUserPresence,
-    ReceivedCredentials(AuthenticatorResponse),
+    ReceivedCredentials(Box<AuthenticatorResponse>),
 }

credsd/src/dbus/flow_control.rs

@@ -29,8 +29,8 @@ use crate::credential_service::{
     usb::UsbHandler,
     CredentialService, UiController, UsbState,
 };
-pub const SERVICE_PATH: &'static str = "/xyz/iinuwa/credentials/FlowControl";
-pub const SERVICE_NAME: &'static str = "xyz.iinuwa.credentials.FlowControl";
+pub const SERVICE_PATH: &str = "/xyz/iinuwa/credentials/FlowControl";
+pub const SERVICE_NAME: &str = "xyz.iinuwa.credentials.FlowControl";
 
 pub async fn start_flow_control_service<
     H: HybridHandler + Debug + Send + Sync + 'static,
@@ -157,7 +157,7 @@ where
                         tracing::error!("Failed to serialize state update: {err}");
                         break;
                     }
-                    Ok(event) => match send_state_update(&emitter, &signal_state, event).await {
+                    Ok(event) => match send_state_update(emitter, &signal_state, event).await {
                         Ok(_) => {}
                         Err(err) => {
                             tracing::error!("Failed to send state update to UI: {err}");
@@ -207,7 +207,7 @@ where
                         tracing::error!("Failed to serialize state update: {err}");
                         break;
                     }
-                    Ok(event) => match send_state_update(&emitter, &signal_state, event).await {
+                    Ok(event) => match send_state_update(emitter, &signal_state, event).await {
                         Ok(_) => {}
                         Err(err) => {
                             tracing::error!("Failed to send state update to UI: {err}");

credsd/src/dbus/gateway.rs

@@ -19,8 +19,8 @@ use crate::dbus::{
     CredentialRequestController,
 };
 
-pub const SERVICE_NAME: &'static str = "xyz.iinuwa.credentials.Credentials";
-pub const SERVICE_PATH: &'static str = "/xyz/iinuwa/credentials/Credentials";
+pub const SERVICE_NAME: &str = "xyz.iinuwa.credentials.Credentials";
+pub const SERVICE_PATH: &str = "/xyz/iinuwa/credentials/Credentials";
 
 pub async fn start_gateway<C: CredentialRequestController + Send + Sync + 'static>(
     controller: C,
@@ -51,12 +51,10 @@ impl<C: CredentialRequestController + Send + Sync + 'static> CredentialGateway<C
         &self,
         request: CreateCredentialRequest,
     ) -> Result<CreateCredentialResponse, Error> {
-        let (_origin, is_same_origin, _top_origin) = check_origin(
-            request.origin.as_ref().map(|s| s.as_str()),
-            request.is_same_origin,
-        )
-        .await
-        .map_err(Error::from)?;
+        let (_origin, is_same_origin, _top_origin) =
+            check_origin(request.origin.as_deref(), request.is_same_origin)
+                .await
+                .map_err(Error::from)?;
         if let ("publicKey", Some(_)) = (request.r#type.as_ref(), &request.public_key) {
             if !is_same_origin {
                 // TODO: Once we modify the models to convey the top-origin in cross origin requests to the UI, we can remove this error message.
@@ -107,12 +105,10 @@ impl<C: CredentialRequestController + Send + Sync + 'static> CredentialGateway<C
         &self,
         request: GetCredentialRequest,
     ) -> Result<GetCredentialResponse, Error> {
-        let (_origin, is_same_origin, _top_origin) = check_origin(
-            request.origin.as_ref().map(|s| s.as_str()),
-            request.is_same_origin,
-        )
-        .await
-        .map_err(Error::from)?;
+        let (_origin, is_same_origin, _top_origin) =
+            check_origin(request.origin.as_deref(), request.is_same_origin)
+                .await
+                .map_err(Error::from)?;
         if let ("publicKey", Some(_)) = (request.r#type.as_ref(), &request.public_key) {
             if !is_same_origin {
                 // TODO: Once we modify the models to convey the top-origin in cross origin requests to the UI, we can remove this error message.
@@ -199,11 +195,12 @@ async fn check_origin(
         origin.clone()
     } else {
         tracing::warn!("Client attempted to issue cross-origin request for credentials, which are not supported by this platform.");
-        return Err(WebAuthnError::NotAllowedError.into());
+        return Err(WebAuthnError::NotAllowedError);
     };
     Ok((origin, true, top_origin))
 }
 
+#[allow(clippy::enum_variant_names)]
 #[derive(DBusError, Debug)]
 #[zbus(prefix = "xyz.iinuwa.credentials")]
 enum Error {

credsd/src/dbus/ui_control.rs

@@ -1,6 +1,6 @@
 //! These methods are called by the flow controller to launch the trusted UI.
 
-use std::{error::Error, future::Future};
+use std::error::Error;
 
 use zbus::{fdo, proxy, Connection};
 

credsd/src/webauthn.rs

@@ -685,8 +685,8 @@ pub fn format_client_data_json(
     is_cross_origin: bool,
 ) -> String {
     let op_str = match op {
-        Operation::Create { .. } => "webauthn.create",
-        Operation::Get { .. } => "webauthn.get",
+        Operation::Create => "webauthn.create",
+        Operation::Get => "webauthn.get",
     };
     let cross_origin_str = if is_cross_origin { "true" } else { "false" };
     format!("{{\"type\":\"{op_str}\",\"challenge\":\"{challenge}\",\"origin\":\"{origin}\",\"crossOrigin\":{cross_origin_str}}}")