Implement OTP clipboard and QR TUI

crates/storage/src/otp.rs

@@ -427,6 +427,7 @@ impl OtpWriteOutcome {
 pub struct OtpCodeOutcome {
     code: SecretBytes,
     counter: Option<u64>,
+    valid_until: Option<u64>,
 }
 
 impl OtpCodeOutcome {
@@ -437,6 +438,15 @@ impl OtpCodeOutcome {
     pub fn counter(&self) -> Option<u64> {
         self.counter
     }
+
+    pub fn valid_until(&self) -> Option<u64> {
+        self.valid_until
+    }
+
+    pub fn remaining_at(&self, unix_seconds: u64) -> Option<u64> {
+        self.valid_until
+            .map(|valid_until| valid_until.saturating_sub(unix_seconds))
+    }
 }
 
 impl fmt::Debug for OtpCodeOutcome {
@@ -445,6 +455,7 @@ impl fmt::Debug for OtpCodeOutcome {
             .debug_struct("OtpCodeOutcome")
             .field("code", &"[REDACTED]")
             .field("counter", &self.counter)
+            .field("valid_until", &self.valid_until)
             .finish()
     }
 }
@@ -463,6 +474,10 @@ impl<'a> OtpService<'a> {
         OtpUri::parse_str(encoded).map(|_| ())
     }
 
+    pub fn validate_input(input: OtpInput) -> Result<(), OtpError> {
+        OtpUri::parse(input.into_secret()).map(|_| ())
+    }
+
     pub fn prepare_insert(
         &self,
         request: &OtpInsertRequest,
@@ -639,9 +654,16 @@ impl<'a> OtpService<'a> {
     ) -> Result<OtpCodeOutcome, OtpError> {
         let (path, original, plaintext, range, uri) = self.load_code_entry(entry, provider)?;
         if uri.kind() == OtpKind::Totp {
+            let period = uri.period().ok_or(OtpError::NotTotp)?;
             return Ok(OtpCodeOutcome {
                 code: uri.code_at(unix_seconds)?,
                 counter: None,
+                valid_until: Some(
+                    (unix_seconds / period)
+                        .checked_add(1)
+                        .and_then(|counter| counter.checked_mul(period))
+                        .ok_or(OtpError::CounterOverflow)?,
+                ),
             });
         }
         let entry = path.to_string();
@@ -692,6 +714,13 @@ impl<'a> OtpService<'a> {
             OtpKind::Totp => Ok(OtpCodeOutcome {
                 code: uri.code_at(unix_seconds)?,
                 counter: None,
+                valid_until: Some({
+                    let period = uri.period().ok_or(OtpError::NotTotp)?;
+                    (unix_seconds / period)
+                        .checked_add(1)
+                        .and_then(|counter| counter.checked_mul(period))
+                        .ok_or(OtpError::CounterOverflow)?
+                }),
             }),
             OtpKind::Hotp => {
                 let (counter, incremented) = uri.incremented_hotp()?;
@@ -714,6 +743,7 @@ impl<'a> OtpService<'a> {
                 Ok(OtpCodeOutcome {
                     code,
                     counter: Some(counter),
+                    valid_until: None,
                 })
             }
         }

crates/storage/tests/otp.rs

@@ -477,6 +477,8 @@ fn automatic_code_supports_pass_diff_config_and_opens_git_only_for_hotp() -> Tes
     let totp_before = repository.read_entry(&totp_path)?;
     let totp = service.code_automatic("otp/totp", 59, None, &mut provider)?;
     assert_eq!(totp.counter(), None);
+    assert_eq!(totp.valid_until(), Some(60));
+    assert_eq!(totp.remaining_at(59), Some(1));
     assert_eq!(repository.read_entry(&totp_path)?, totp_before);
     let git = GitRepository::open(&repository, identity.clone())?;
     assert_eq!(git.log(None)?.len(), initial_commits);
@@ -484,6 +486,7 @@ fn automatic_code_supports_pass_diff_config_and_opens_git_only_for_hotp() -> Tes
 
     let hotp = service.code_automatic("otp/hotp", 0, None, &mut provider)?;
     assert_eq!(hotp.counter(), Some(1));
+    assert_eq!(hotp.valid_until(), None);
     assert_eq!(service.uri("otp/hotp", &mut provider)?.counter(), Some(1));
     let git = GitRepository::open(&repository, identity)?;
     assert_eq!(git.log(None)?.len(), initial_commits + 1);