client: Add a as_str helper

Author: bilelmoussaoui

cargo-credential/src/main.rs

@@ -27,15 +27,15 @@ impl SecretServiceCredential {
                     return Err(Error::NotFound);
                 }
 
+                let secret = items[0]
+                    .secret()
+                    .await
+                    .map_err(|err| Error::Other(Box::new(err)))?;
                 let token = Secret::from(
-                    std::str::from_utf8(
-                        &items[0]
-                            .secret()
-                            .await
-                            .map_err(|err| Error::Other(Box::new(err)))?,
-                    )
-                    .unwrap()
-                    .to_owned(),
+                    secret
+                        .as_str()
+                        .ok_or_else(|| Error::Other("secret is not valid UTF-8".into()))?
+                        .to_owned(),
                 );
 
                 Ok(CredentialResponse::Get {

cli/src/main.rs

@@ -147,13 +147,12 @@ impl ItemOutput {
         .unwrap();
 
         let secret_str = secret.map(|s| {
-            let bytes = s.as_bytes();
             if as_hex {
-                hex::encode(bytes)
+                hex::encode(s.as_bytes())
             } else {
-                match std::str::from_utf8(bytes) {
-                    Ok(s) => s.to_string(),
-                    Err(_) => hex::encode(bytes),
+                match s.as_str() {
+                    Some(s) => s.to_string(),
+                    None => hex::encode(s.as_bytes()),
                 }
             }
         });

client/src/secret.rs

@@ -107,6 +107,15 @@ impl Secret {
         }
     }
 
+    /// Returns the secret as a string slice, or `None` if it is not valid
+    /// UTF-8.
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Self::Text(text) => Some(text.as_str()),
+            Self::Blob(bytes) => std::str::from_utf8(bytes).ok(),
+        }
+    }
+
     pub fn as_bytes(&self) -> &[u8] {
         match self {
             Self::Text(text) => text.as_bytes(),

git-credential/src/main.rs

@@ -161,8 +161,8 @@ impl Credential {
     }
 }
 
-fn parse_secret(secret: &[u8]) -> (String, Option<String>, Option<String>) {
-    let text = std::str::from_utf8(secret).unwrap_or_default();
+fn parse_secret(secret: &oo7::Secret) -> (String, Option<String>, Option<String>) {
+    let text = secret.as_str().unwrap_or_default();
     let mut lines = text.split('\n');
     let password = lines.next().unwrap_or_default().to_owned();
     let mut password_expiry_utc = None;
@@ -186,7 +186,7 @@ async fn run(action: &str, credential: &Credential, collection: &Collection) ->
             if let Some(item) = items.first() {
                 let attrs = item.attributes_as::<GitSchema>().await?;
                 let secret = item.secret().await?;
-                let (password, expiry, oauth) = parse_secret(secret.as_bytes());
+                let (password, expiry, oauth) = parse_secret(&secret);
 
                 if let Some(user) = &attrs.user {
                     println!("username={user}");
@@ -222,7 +222,7 @@ async fn run(action: &str, credential: &Credential, collection: &Collection) ->
                 && let Some(item) = items.first()
             {
                 let secret = item.secret().await?;
-                let (stored_password, ..) = parse_secret(secret.as_bytes());
+                let (stored_password, ..) = parse_secret(&secret);
                 if stored_password != *password {
                     return Ok(());
                 }

server/src/tests.rs

@@ -535,15 +535,15 @@ impl MockPrompterService {
                     let pwd = queue.remove(0);
                     tracing::debug!(
                         "MockPrompter: using password from queue (length: {}, queue remaining: {})",
-                        std::str::from_utf8(pwd.as_bytes()).unwrap_or("<binary>"),
+                        pwd.as_str().unwrap_or("<binary>"),
                         queue.len()
                     );
                     pwd
                 } else {
                     let pwd = unlock_password.lock().await.clone().unwrap();
                     tracing::debug!(
                         "MockPrompter: using default password (length: {})",
-                        std::str::from_utf8(pwd.as_bytes()).unwrap_or("<binary>")
+                        pwd.as_str().unwrap_or("<binary>")
                     );
                     pwd
                 };
@@ -796,7 +796,7 @@ impl MockPrompterServicePlasma {
             let pwd = self.unlock_password.lock().await.clone().unwrap();
             tracing::debug!(
                 "MockPrompterServicePlasma: using default password (length: {})",
-                std::str::from_utf8(pwd.as_bytes()).unwrap_or("<binary>")
+                pwd.as_str().unwrap_or("<binary>")
             );
             MockPrompterServicePlasma::send_secret(&connection, &callback_path, &pwd).await?;
         };