FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
#pragma once
#include "core/result/Result.h"
#include <QDateTime>
#include <QObject>
#include <QString>
#include <array>
namespace fincept::auth {
/// Manages local PIN authentication — hashing, verification, and lockout.
///
/// PIN is hashed with PBKDF2-SHA256 (600k iterations, 32-byte salt) and stored
/// in OS-native SecureStorage (DPAPI / Keychain). Failure ladder (kFreeAttempts
/// = 2, kMaxAttempts = 5):
/// attempts 1-2 → silent grace period, "incorrect" message only
/// attempt 3 → 30s timed lockout
/// attempt 4 → 60s timed lockout
/// attempt 5 → permanent lockout, requires server re-authentication.
/// Total online keyspace exposure for a 6-digit PIN: 4 cheap guesses then the
/// re-auth gate. Two extra ladder tiers (5min / 15min) are deliberately *not*
/// reachable under the current kMaxAttempts — keeping them in code but
/// unreachable would be a foot-gun for future code that bumps the cap without
/// reading the comment.
class PinManager : public QObject {
Q_OBJECT
public:
static PinManager& instance();
/// True if user has configured a PIN (hash exists in SecureStorage).
bool has_pin() const;
/// Set or update the PIN. Returns error if hash/storage fails or the PIN
/// is trivially weak (all-same digits, ascending/descending sequence).
/// Note: this does NOT require the old PIN — use change_pin() for that.
Result<void> set_pin(const QString& pin);
/// Change the PIN, requiring the current PIN for authorization. A wrong
/// old_pin increments the failed-attempt counter exactly like a failed
/// unlock, so an attacker who unlocks an unattended terminal cannot
/// silently swap the PIN without facing the same lockout.
Result<void> change_pin(const QString& old_pin, const QString& new_pin);
/// Verify a PIN attempt. On failure increments attempt counter and
/// may trigger lockout. Returns true on match.
bool verify_pin(const QString& pin);
/// Remove stored PIN (e.g. on logout or account reset).
void clear_pin();
/// Current lockout state.
bool is_locked_out() const;
/// Seconds remaining until lockout expires. 0 if not locked.
int lockout_remaining_seconds() const;
/// Number of consecutive failed attempts.
int failed_attempts() const { return failed_attempts_; }
/// Max attempts before permanent lockout (requires server re-auth).
static constexpr int kMaxAttempts = 5;
/// Number of "free" wrong attempts before the timed-lockout ladder kicks
/// in. Set to 2 so the user gets 3 tries (attempts 1, 2, 3) with only a
/// generic "incorrect" error; the 3rd mistake starts the 30s lockout.
/// kMaxAttempts still caps the total at 5 before forced re-login.
static constexpr int kFreeAttempts = 2;
/// Reset lockout state (called after successful server re-auth).
void reset_lockout();
signals:
/// Emitted when lockout state changes.
void lockout_changed(bool locked, int remaining_seconds);
/// Emitted when max attempts exceeded — requires full re-login.
void max_attempts_exceeded();
private:
PinManager();
// PBKDF2-SHA256 parameters.
// 600_000 iterations per OWASP Password Storage Cheat Sheet (2023) for
// PBKDF2-SHA256. Verify cost stays well under 500ms on target hardware.
static constexpr int kIterations = 600000;
static constexpr int kSaltLength = 32;
static constexpr int kHashLength = 32;
// Lockout durations (seconds) per attempt tier. Sized to match the
// tiers that are actually reachable given kFreeAttempts + kMaxAttempts.
// If you bump kMaxAttempts, also extend this array — see class header.
static constexpr std::array<int, 2> kLockoutTiers = {30, 60};
QByteArray derive_key(const QString& pin, const QByteArray& salt) const;
int failed_attempts_ = 0;
QDateTime lockout_until_;
// Set transiently by change_pin() so the verify_pin call inside it can
// tag audit-log entries with source=change_pin. False during normal
// lock-screen unlocks. Reset to false after verify_pin returns.
bool audit_source_change_pin_ = false;
// Cached state loaded from SecureStorage
bool has_pin_ = false;
QByteArray stored_hash_;
QByteArray stored_salt_;
void load_state();
void save_lockout_state();
void load_lockout_state();
};
} // namespace fincept::auth