`af3cae8`

Add cooldown after repeated failed attempts

- Block authentication during cooldown period
- Start cooldown after max_attempts failures (default 3)
- Configurable cooldown duration (default 5 seconds)
- Reset attempt counter after cooldown expires

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: af3cae81012f8d00e846e9a8704ebeba010be80f
Parents: a9436ea
Tree: 832591b

2 changed files

Status	File	+	-
M	`garlock/src/main.rs`	15	2
M	`garlock/src/state.rs`	41	0

garlock/src/main.rsmodified

+                             }
                              KeyResult::Enter => {
 -                                if !password.is_empty() && pending_auth.is_none() {
 +                                // Block attempts during cooldown
 +                                if locker_state.is_in_cooldown() {
 +                                    let remaining = locker_state.cooldown_remaining();
 +                                    tracing::warn!(
 +                                        remaining_seconds = remaining,
 +                                        "Authentication blocked: cooldown active"
 +                                    );
 +                                    password.clear();
 +                                    ring.clear_highlight();
 +                                    needs_redraw = true;
 +                                } else if !password.is_empty() && pending_auth.is_none() {
                                      locker_state.start_validation();
                                      ring.set_state(locker_state.ring_state());
                                      needs_redraw = true;
                                  ring.set_state(locker_state.ring_state());
                                  needs_redraw = true;
 -                                // TODO: Check for cooldown after max_attempts
 +                                // Start cooldown after too many failures
 +                                if locker_state.failed_attempts >= config.general.max_attempts {
 +                                    locker_state.start_cooldown(config.general.cooldown_seconds.into());
 +                                }
+                             }
+                         }
                          pending_auth = None;

garlock/src/state.rsmodified

      invalid_since: Option<Instant>,
      /// Number of failed authentication attempts
      pub failed_attempts: u32,
 +    /// Cooldown end time (if in cooldown after too many failures)
 +    cooldown_until: Option<Instant>,
+ }
  impl LockerState {
              last_input: None,
              invalid_since: None,
              failed_attempts: 0,
 +            cooldown_until: None,
+         }
+     }
          tracing::warn!(attempts = self.failed_attempts, "Authentication failed");
+     }
 +    /// Check if currently in cooldown period
 +    pub fn is_in_cooldown(&self) -> bool {
 +        self.cooldown_until
 +            .map(|t| Instant::now() < t)
 +            .unwrap_or(false)
 +    }
++
 +    /// Start a cooldown period after too many failed attempts
 +    pub fn start_cooldown(&mut self, seconds: u64) {
 +        let duration = Duration::from_secs(seconds);
 +        self.cooldown_until = Some(Instant::now() + duration);
 +        tracing::warn!(seconds, "Cooldown started after {} failed attempts", self.failed_attempts);
 +    }
++
 +    /// Get remaining cooldown time in seconds (0 if not in cooldown)
 +    pub fn cooldown_remaining(&self) -> u64 {
 +        self.cooldown_until
 +            .map(|t| {
 +                let now = Instant::now();
 +                if now < t {
 +                    (t - now).as_secs()
 +                } else {
 +                    0
 +                }
 +            })
 +            .unwrap_or(0)
 +    }
++
      /// Check and update timers, returning true if state changed
      pub fn update_timers(&mut self) -> bool {
          let mut changed = false;
+             }
+         }
 +        // Check cooldown expiry
 +        if let Some(until) = self.cooldown_until {
 +            if Instant::now() >= until {
 +                self.cooldown_until = None;
 +                self.failed_attempts = 0; // Reset attempts after cooldown
 +                tracing::info!("Cooldown expired, attempts reset");
 +                changed = true;
 +            }
 +        }
++
          changed
+     }