diff --git a/app/src/App.tsx b/app/src/App.tsx index f0dc5942..d9ed9e1f 100644 --- a/app/src/App.tsx +++ b/app/src/App.tsx @@ -16,6 +16,7 @@ import NotFound from "./pages/NotFound"; import { Landing } from "./pages/Landing"; import ProtectedRoute from "./components/auth/ProtectedRoute"; import Account from "./pages/Account"; +import { Security } from "./pages/Security"; const queryClient = new QueryClient({ defaultOptions: { @@ -91,6 +92,14 @@ const App = () => ( } /> + + + + } + /> } /> } /> diff --git a/app/src/api/security.ts b/app/src/api/security.ts new file mode 100644 index 00000000..5d6a9172 --- /dev/null +++ b/app/src/api/security.ts @@ -0,0 +1,613 @@ +import { useEffect, useState } from 'react'; +import { + Shield, + AlertTriangle, + CheckCircle, + Monitor, + Globe, + Clock, + RefreshCw, + Trash2, + Check, + X, +} from 'lucide-react'; +import { api } from './client'; +import { useToast } from '@/components/ui/use-toast'; + +interface LoginEvent { + id: number; + ip_address: string | null; + user_agent: string | null; + success: boolean; + anomaly_score: number; + anomaly_reasons: string | null; + created_at: string; +} + +interface LoginStats { + total_logins: number; + unique_ips: number; + unique_devices: number; + suspicious_count: number; + last_anomaly: string | null; +} + +interface UserDevice { + id: number; + device_name: string | null; + device_fingerprint: string; + ip_address: string; + user_agent: string | null; + country: string | null; + city: string | null; + first_seen: string; + last_seen: string; + is_trusted: boolean; + is_revoked: boolean; +} + +interface SecurityAlert { + id: number; + anomaly_type: string; + severity: string; + details: string | null; + acknowledged: boolean; + created_at: string; +} + +export async function getLoginHistory(limit = 50): Promise { + return api(`/security/login-history?limit=${limit}`); +} + +export async function getAnomalies(limit = 50): Promise { + return api(`/security/alerts?limit=${limit}`); +} + +export async function getLoginStats(): Promise { + return api('/security/login-stats'); +} + +export async function getDevices(): Promise { + return api('/security/devices'); +} + +export async function acknowledgeAlert(alertId: number): Promise { + return api(`/security/alerts/${alertId}/acknowledge`, { method: 'POST' }); +} + +export async function acknowledgeAllAlerts(): Promise<{ count: number }> { + return api<{ count: number }>('/security/alerts/acknowledge-all', { method: 'POST' }); +} + +export async function trustDevice(deviceId: number): Promise { + return api(`/security/devices/${deviceId}`, { + method: 'PATCH', + body: JSON.stringify({ is_trusted: true }), + }); +} + +export async function revokeDevice(deviceId: number): Promise { + return api(`/security/devices/${deviceId}`, { method: 'DELETE' }); +} + +function riskLabel(score: number): { label: string; color: string } { + if (score === 0) return { label: 'Safe', color: 'text-green-600' }; + if (score < 0.4) return { label: 'Low', color: 'text-yellow-500' }; + if (score < 0.7) return { label: 'Medium', color: 'text-orange-500' }; + return { label: 'High', color: 'text-red-600' }; +} + +function formatDate(iso: string | null): string { + if (!iso) return '—'; + return new Date(iso).toLocaleString(); +} + +function severityColor(severity: string): string { + switch (severity) { + case 'high': return 'text-red-600 bg-red-50'; + case 'medium': return 'text-orange-600 bg-orange-50'; + case 'low': return 'text-yellow-600 bg-yellow-50'; + default: return 'text-gray-600 bg-gray-50'; + } +} + +function anomalyTypeLabel(type: string): string { + const labels: Record = { + new_device: 'New Device', + new_location: 'New Location', + unusual_time: 'Unusual Time', + multiple_failures: 'Multiple Failures', + suspicious_ip: 'Suspicious IP', + impossible_travel: 'Impossible Travel', + }; + return labels[type] || type; +} + +export function Security() { + const [stats, setStats] = useState(null); + const [history, setHistory] = useState([]); + const [devices, setDevices] = useState([]); + const [alerts, setAlerts] = useState([]); + const [loading, setLoading] = useState(true); + const [activeTab, setActiveTab] = useState<'history' | 'devices' | 'alerts'>('history'); + const { toast } = useToast(); + + const load = async () => { + setLoading(true); + try { + const [s, h, d, a] = await Promise.all([ + getLoginStats(), + getLoginHistory(20), + getDevices(), + getAnomalies(20), + ]); + setStats(s); + setHistory(h); + setDevices(d); + setAlerts(a); + } catch (err: unknown) { + toast({ + variant: 'destructive', + title: 'Failed to load security data', + description: err instanceof Error ? err.message : 'Unknown error', + }); + } finally { + setLoading(false); + } + }; + + useEffect(() => { + load(); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []); + + const handleAcknowledgeAlert = async (alertId: number) => { + try { + await acknowledgeAlert(alertId); + setAlerts(alerts.map(a => a.id === alertId ? { ...a, acknowledged: true } : a)); + toast({ title: 'Alert acknowledged' }); + } catch (err: unknown) { + toast({ + variant: 'destructive', + title: 'Failed to acknowledge alert', + description: err instanceof Error ? err.message : 'Unknown error', + }); + } + }; + + const handleAcknowledgeAll = async () => { + try { + const result = await acknowledgeAllAlerts(); + setAlerts(alerts.map(a => ({ ...a, acknowledged: true }))); + toast({ title: `${result.count} alerts acknowledged` }); + } catch (err: unknown) { + toast({ + variant: 'destructive', + title: 'Failed to acknowledge alerts', + description: err instanceof Error ? err.message : 'Unknown error', + }); + } + }; + + const handleTrustDevice = async (deviceId: number) => { + try { + await trustDevice(deviceId); + setDevices(devices.map(d => d.id === deviceId ? { ...d, is_trusted: true } : d)); + toast({ title: 'Device trusted' }); + } catch (err: unknown) { + toast({ + variant: 'destructive', + title: 'Failed to trust device', + description: err instanceof Error ? err.message : 'Unknown error', + }); + } + }; + + const handleRevokeDevice = async (deviceId: number) => { + try { + await revokeDevice(deviceId); + setDevices(devices.map(d => d.id === deviceId ? { ...d, is_revoked: true } : d)); + toast({ title: 'Device revoked' }); + } catch (err: unknown) { + toast({ + variant: 'destructive', + title: 'Failed to revoke device', + description: err instanceof Error ? err.message : 'Unknown error', + }); + } + }; + + if (loading) { + return ( +
+ + Loading security data… +
+ ); + } + + return ( +
+ {/* Header */} +
+
+ +
+

Security Center

+

+ Monitor login activity and manage security alerts +

+
+
+ +
+ + {/* Stats cards */} + {stats && ( +
+ } + label="Total Logins" + value={stats.total_logins} + /> + } + label="Unique IPs" + value={stats.unique_ips} + /> + } + label="Devices" + value={stats.unique_devices} + /> + } + label="Alerts" + value={stats.suspicious_count} + highlight={stats.suspicious_count > 0} + /> +
+ )} + + {stats?.last_anomaly && ( +
+ + + Last suspicious login at {formatDate(stats.last_anomaly)}. + Review your alerts below. + +
+ )} + + {/* Tabs */} +
+ + + +
+ + {/* Tab Content */} + {activeTab === 'history' && ( + + )} + + {activeTab === 'devices' && ( + + )} + + {activeTab === 'alerts' && ( + + )} +
+ ); +} + +function StatCard({ + icon, + label, + value, + highlight = false, +}: { + icon: React.ReactNode; + label: string; + value: number; + highlight?: boolean; +}) { + return ( +
+
+ {icon} + {label} +
+
{value}
+
+ ); +} + +function LoginHistoryTable({ history }: { history: LoginEvent[] }) { + if (history.length === 0) { + return

No login events recorded yet.

; + } + + return ( +
+ + + + + + + + + + + + {history.map((evt) => { + const { label, color } = riskLabel(evt.anomaly_score); + return ( + 0 + ? 'bg-orange-50/40 hover:bg-orange-50/60' + : 'hover:bg-muted/30' + } + > + + + + + + + ); + })} + +
Date & TimeIP AddressStatusRiskDetails
{formatDate(evt.created_at)} + {evt.ip_address || '—'} + + {evt.success ? ( + + + Success + + ) : ( + + + Failed + + )} + {label} + {evt.anomaly_reasons || '—'} +
+
+ ); +} + +function DevicesTable({ + devices, + onTrust, + onRevoke, +}: { + devices: UserDevice[]; + onTrust: (id: number) => void; + onRevoke: (id: number) => void; +}) { + const activeDevices = devices.filter(d => !d.is_revoked); + + if (activeDevices.length === 0) { + return

No devices registered.

; + } + + return ( +
+ + + + + + + + + + + + {activeDevices.map((device) => ( + + + + + + + + ))} + +
DeviceLocationLast SeenStatusActions
+
+ +
+
+ {device.device_name || 'Unknown Device'} +
+
+ {device.device_fingerprint?.substring(0, 12)}... +
+
+
+ 		+ {device.city && device.country + ? `${device.city}, ${device.country}` + : device.country || '—'} + + {formatDate(device.last_seen)} + + {device.is_trusted ? ( + + + Trusted + + ) : ( + Untrusted + )} + +
+ {!device.is_trusted && ( + + )} + +
+
+
+ ); +} + +function AlertsTable({ + alerts, + onAcknowledge, + onAcknowledgeAll, +}: { + alerts: SecurityAlert[]; + onAcknowledge: (id: number) => void; + onAcknowledgeAll: () => void; +}) { + const unacknowledged = alerts.filter(a => !a.acknowledged); + + if (alerts.length === 0) { + return

No security alerts.

; + } + + return ( +
+ {unacknowledged.length > 0 && ( + + )} + +
+ + + + + + + + + + + + {alerts.map((alert) => ( + + + + + + + + ))} + +
AlertSeverityTimeStatusAction
+
+ + {anomalyTypeLabel(alert.anomaly_type)} +
+ {alert.details && ( +
+ {alert.details} +
+ )} + 		+ + {alert.severity} + + + {formatDate(alert.created_at)} + + {alert.acknowledged ? ( + Acknowledged + ) : ( + Pending + )} + + {!alert.acknowledged && ( + + )} +
+
+
+ ); +} diff --git a/app/src/components/layout/Navbar.tsx b/app/src/components/layout/Navbar.tsx index c7593b70..dc1f48e7 100644 --- a/app/src/components/layout/Navbar.tsx +++ b/app/src/components/layout/Navbar.tsx @@ -13,6 +13,7 @@ const navigation = [ { name: 'Reminders', href: '/reminders' }, { name: 'Expenses', href: '/expenses' }, { name: 'Analytics', href: '/analytics' }, + { name: 'Security', href: '/security' }, ]; export function Navbar() { diff --git a/app/src/pages/Security.tsx b/app/src/pages/Security.tsx new file mode 100644 index 00000000..f2dd5761 --- /dev/null +++ b/app/src/pages/Security.tsx @@ -0,0 +1 @@ +export { Security } from '../api/security'; diff --git a/packages/backend/app/db/migrations/001_login_anomaly.sql b/packages/backend/app/db/migrations/001_login_anomaly.sql new file mode 100644 index 00000000..a822b197 --- /dev/null +++ b/packages/backend/app/db/migrations/001_login_anomaly.sql @@ -0,0 +1,74 @@ +-- Migration: Login Anomaly Detection Tables +-- Issue: #124 +-- Date: 2026-03-29 + +-- Login attempts tracking +CREATE TABLE IF NOT EXISTS login_attempts ( + id SERIAL PRIMARY KEY, + user_id INTEGER REFERENCES users(id) ON DELETE SET NULL, + email VARCHAR(255) NOT NULL, + ip_address VARCHAR(45) NOT NULL, + user_agent VARCHAR(500), + device_fingerprint VARCHAR(64), + success BOOLEAN NOT NULL DEFAULT FALSE, + failure_reason VARCHAR(100), + country VARCHAR(2), + city VARCHAR(100), + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); + +-- Known devices for users +CREATE TABLE IF NOT EXISTS user_devices ( + id SERIAL PRIMARY KEY, + user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE, + device_fingerprint VARCHAR(64) NOT NULL, + device_name VARCHAR(200), + ip_address VARCHAR(45) NOT NULL, + user_agent VARCHAR(500), + country VARCHAR(2), + city VARCHAR(100), + first_seen TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + last_seen TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + is_trusted BOOLEAN NOT NULL DEFAULT FALSE, + is_revoked BOOLEAN NOT NULL DEFAULT FALSE, + UNIQUE(user_id, device_fingerprint) +); + +-- Login anomalies +CREATE TABLE IF NOT EXISTS login_anomalies ( + id SERIAL PRIMARY KEY, + user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE, + login_attempt_id INTEGER REFERENCES login_attempts(id) ON DELETE SET NULL, + anomaly_type VARCHAR(50) NOT NULL, + severity VARCHAR(20) NOT NULL DEFAULT 'medium', + details TEXT, + acknowledged BOOLEAN NOT NULL DEFAULT FALSE, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); + +-- Indexes for performance +CREATE INDEX IF NOT EXISTS idx_login_attempts_user_id ON login_attempts(user_id); +CREATE INDEX IF NOT EXISTS idx_login_attempts_email ON login_attempts(email); +CREATE INDEX IF NOT EXISTS idx_login_attempts_created_at ON login_attempts(created_at); +CREATE INDEX IF NOT EXISTS idx_login_attempts_success ON login_attempts(success); + +CREATE INDEX IF NOT EXISTS idx_user_devices_user_id ON user_devices(user_id); +CREATE INDEX IF NOT EXISTS idx_user_devices_fingerprint ON user_devices(device_fingerprint); + +CREATE INDEX IF NOT EXISTS idx_login_anomalies_user_id ON login_anomalies(user_id); +CREATE INDEX IF NOT EXISTS idx_login_anomalies_type ON login_anomalies(anomaly_type); +CREATE INDEX IF NOT EXISTS idx_login_anomalies_acknowledged ON login_anomalies(acknowledged); + +-- Enum type for anomaly types (PostgreSQL) +DO $$ BEGIN + CREATE TYPE login_anomaly_type AS ENUM ( + 'new_device', + 'new_location', + 'unusual_time', + 'multiple_failures', + 'suspicious_ip', + 'impossible_travel' + ); +EXCEPTION + WHEN duplicate_object THEN null; +END $$; diff --git a/packages/backend/app/models.py b/packages/backend/app/models.py index 64d44810..b1ba1e12 100644 --- a/packages/backend/app/models.py +++ b/packages/backend/app/models.py @@ -133,3 +133,58 @@ class AuditLog(db.Model): user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True) action = db.Column(db.String(100), nullable=False) created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + + +class LoginAttempt(db.Model): + """Tracks all login attempts for anomaly detection.""" + __tablename__ = "login_attempts" + id = db.Column(db.Integer, primary_key=True) + user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True) + email = db.Column(db.String(255), nullable=False) + ip_address = db.Column(db.String(45), nullable=False) + user_agent = db.Column(db.String(500), nullable=True) + device_fingerprint = db.Column(db.String(64), nullable=True) + success = db.Column(db.Boolean, default=False, nullable=False) + failure_reason = db.Column(db.String(100), nullable=True) + country = db.Column(db.String(2), nullable=True) + city = db.Column(db.String(100), nullable=True) + created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + + +class UserDevice(db.Model): + """Known devices for each user.""" + __tablename__ = "user_devices" + id = db.Column(db.Integer, primary_key=True) + user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) + device_fingerprint = db.Column(db.String(64), nullable=False) + device_name = db.Column(db.String(200), nullable=True) + ip_address = db.Column(db.String(45), nullable=False) + user_agent = db.Column(db.String(500), nullable=True) + country = db.Column(db.String(2), nullable=True) + city = db.Column(db.String(100), nullable=True) + first_seen = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + last_seen = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + is_trusted = db.Column(db.Boolean, default=False, nullable=False) + is_revoked = db.Column(db.Boolean, default=False, nullable=False) + + +class LoginAnomalyType(str, Enum): + """Types of login anomalies.""" + NEW_DEVICE = "new_device" + NEW_LOCATION = "new_location" + UNUSUAL_TIME = "unusual_time" + MULTIPLE_FAILURES = "multiple_failures" + SUSPICIOUS_IP = "suspicious_ip" + + +class LoginAnomaly(db.Model): + """Recorded login anomalies.""" + __tablename__ = "login_anomalies" + id = db.Column(db.Integer, primary_key=True) + user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) + login_attempt_id = db.Column(db.Integer, db.ForeignKey("login_attempts.id"), nullable=True) + anomaly_type = db.Column(SAEnum(LoginAnomalyType), nullable=False) + severity = db.Column(db.String(20), default="medium", nullable=False) # low, medium, high + details = db.Column(db.Text, nullable=True) # JSON details + acknowledged = db.Column(db.Boolean, default=False, nullable=False) + created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) diff --git a/packages/backend/app/routes/__init__.py b/packages/backend/app/routes/__init__.py index f13b0f89..6bbd11e1 100644 --- a/packages/backend/app/routes/__init__.py +++ b/packages/backend/app/routes/__init__.py @@ -7,6 +7,7 @@ from .categories import bp as categories_bp from .docs import bp as docs_bp from .dashboard import bp as dashboard_bp +from .security import bp as security_bp def register_routes(app: Flask): @@ -18,3 +19,4 @@ def register_routes(app: Flask): app.register_blueprint(categories_bp, url_prefix="/categories") app.register_blueprint(docs_bp, url_prefix="/docs") app.register_blueprint(dashboard_bp, url_prefix="/dashboard") + app.register_blueprint(security_bp, url_prefix="/security") diff --git a/packages/backend/app/routes/auth.py b/packages/backend/app/routes/auth.py index 05a39377..ddb64e13 100644 --- a/packages/backend/app/routes/auth.py +++ b/packages/backend/app/routes/auth.py @@ -10,6 +10,10 @@ ) from ..extensions import db, redis_client from ..models import User +from ..services.login_anomaly import ( + detector, + get_login_context, +) import logging import time @@ -56,14 +60,51 @@ def login(): email = data.get("email") password = data.get("password") user = db.session.query(User).filter_by(email=email).first() + if not user or not check_password_hash(user.password_hash, password): + # Record failed login attempt + context = get_login_context(request, user.id if user else None, email) + detector.process_login(context, success=False, failure_reason="invalid_credentials") + db.session.commit() logger.warning("Login failed for email=%s", email) return jsonify(error="invalid credentials"), 401 + + # Process successful login with anomaly detection + context = get_login_context(request, user.id, email) + attempt, anomalies = detector.process_login(context, success=True) + db.session.commit() + access = create_access_token(identity=str(user.id)) refresh = create_refresh_token(identity=str(user.id)) _store_refresh_session(refresh, str(user.id)) + logger.info("Login success user_id=%s", user.id) - return jsonify(access_token=access, refresh_token=refresh) + + # Include anomaly alerts in response + anomaly_alerts = [] + if anomalies: + anomaly_alerts = [ + { + "type": a.anomaly_type.value, + "severity": a.severity, + } + for a in anomalies + ] + logger.warning( + "Login anomalies detected for user_id=%s: %s", + user.id, + [a.anomaly_type.value for a in anomalies] + ) + + response = { + "access_token": access, + "refresh_token": refresh, + } + + if anomaly_alerts: + response["security_alerts"] = anomaly_alerts + + return jsonify(response) @bp.get("/me") diff --git a/packages/backend/app/routes/security.py b/packages/backend/app/routes/security.py new file mode 100644 index 00000000..25c87b9d --- /dev/null +++ b/packages/backend/app/routes/security.py @@ -0,0 +1,216 @@ +"""Security endpoints for login anomaly detection. + +Provides endpoints for users to: +- View their login history +- Manage known devices +- View and acknowledge security alerts +""" + +from flask import Blueprint, jsonify, request +from flask_jwt_extended import jwt_required, get_jwt_identity +from sqlalchemy import desc +from ..extensions import db +from ..models import UserDevice, LoginAttempt, LoginAnomaly, LoginAnomalyType +import logging + +bp = Blueprint("security", __name__) +logger = logging.getLogger("finmind.security") + + +@bp.get("/devices") +@jwt_required() +def list_devices(): + """List all registered devices for the current user.""" + uid = int(get_jwt_identity()) + + devices = db.session.query(UserDevice).filter( + UserDevice.user_id == uid + ).order_by(desc(UserDevice.last_seen)).all() + + return jsonify([ + { + "id": d.id, + "device_name": d.device_name, + "device_fingerprint": d.device_fingerprint[:8] + "...", # Partial fingerprint + "ip_address": d.ip_address, + "user_agent": d.user_agent, + "country": d.country, + "city": d.city, + "first_seen": d.first_seen.isoformat() if d.first_seen else None, + "last_seen": d.last_seen.isoformat() if d.last_seen else None, + "is_trusted": d.is_trusted, + "is_revoked": d.is_revoked, + } + for d in devices + ]) + + +@bp.patch("/devices/") +@jwt_required() +def update_device(device_id): + """Update a device (trust/revoke/rename).""" + uid = int(get_jwt_identity()) + data = request.get_json() or {} + + device = db.session.query(UserDevice).filter( + UserDevice.id == device_id, + UserDevice.user_id == uid + ).first() + + if not device: + return jsonify(error="device not found"), 404 + + if "device_name" in data: + device.device_name = data["device_name"][:200] + + if "is_trusted" in data: + device.is_trusted = bool(data["is_trusted"]) + + if "is_revoked" in data: + device.is_revoked = bool(data["is_revoked"]) + if device.is_revoked: + logger.info( + "Device revoked: user_id=%s device_id=%s fingerprint=%s", + uid, device_id, device.device_fingerprint[:8] + ) + + db.session.commit() + + return jsonify({ + "id": device.id, + "device_name": device.device_name, + "is_trusted": device.is_trusted, + "is_revoked": device.is_revoked, + }) + + +@bp.delete("/devices/") +@jwt_required() +def revoke_device(device_id): + """Revoke a device.""" + uid = int(get_jwt_identity()) + + device = db.session.query(UserDevice).filter( + UserDevice.id == device_id, + UserDevice.user_id == uid + ).first() + + if not device: + return jsonify(error="device not found"), 404 + + device.is_revoked = True + db.session.commit() + + logger.info( + "Device revoked: user_id=%s device_id=%s", + uid, device_id + ) + + return jsonify(message="device revoked"), 200 + + +@bp.get("/login-history") +@jwt_required() +def login_history(): + """Get recent login history for the current user.""" + uid = int(get_jwt_identity()) + + limit = request.args.get("limit", 20, type=int) + limit = min(limit, 100) # Cap at 100 + + attempts = db.session.query(LoginAttempt).filter( + LoginAttempt.user_id == uid + ).order_by(desc(LoginAttempt.created_at)).limit(limit).all() + + return jsonify([ + { + "id": a.id, + "ip_address": a.ip_address, + "user_agent": a.user_agent, + "success": a.success, + "failure_reason": a.failure_reason, + "country": a.country, + "city": a.city, + "created_at": a.created_at.isoformat() if a.created_at else None, + } + for a in attempts + ]) + + +@bp.get("/alerts") +@jwt_required() +def list_alerts(): + """List security alerts for the current user.""" + uid = int(get_jwt_identity()) + + limit = request.args.get("limit", 20, type=int) + limit = min(limit, 100) + unacknowledged_only = request.args.get("unacknowledged", "false").lower() == "true" + + query = db.session.query(LoginAnomaly).filter( + LoginAnomaly.user_id == uid + ) + + if unacknowledged_only: + query = query.filter(LoginAnomaly.acknowledged == False) + + alerts = query.order_by(desc(LoginAnomaly.created_at)).limit(limit).all() + + import json + return jsonify([ + { + "id": a.id, + "anomaly_type": a.anomaly_type.value if a.anomaly_type else None, + "severity": a.severity, + "details": json.loads(a.details) if a.details else {}, + "acknowledged": a.acknowledged, + "created_at": a.created_at.isoformat() if a.created_at else None, + } + for a in alerts + ]) + + +@bp.post("/alerts//acknowledge") +@jwt_required() +def acknowledge_alert(alert_id): + """Acknowledge a security alert.""" + uid = int(get_jwt_identity()) + + alert = db.session.query(LoginAnomaly).filter( + LoginAnomaly.id == alert_id, + LoginAnomaly.user_id == uid + ).first() + + if not alert: + return jsonify(error="alert not found"), 404 + + alert.acknowledged = True + db.session.commit() + + logger.info( + "Alert acknowledged: user_id=%s alert_id=%s type=%s", + uid, alert_id, alert.anomaly_type.value if alert.anomaly_type else None + ) + + return jsonify(message="alert acknowledged"), 200 + + +@bp.post("/alerts/acknowledge-all") +@jwt_required() +def acknowledge_all_alerts(): + """Acknowledge all unacknowledged alerts for the current user.""" + uid = int(get_jwt_identity()) + + updated = db.session.query(LoginAnomaly).filter( + LoginAnomaly.user_id == uid, + LoginAnomaly.acknowledged == False + ).update({"acknowledged": True}) + + db.session.commit() + + logger.info( + "All alerts acknowledged: user_id=%s count=%s", + uid, updated + ) + + return jsonify(message="all alerts acknowledged", count=updated), 200 diff --git a/packages/backend/app/services/login_anomaly.py b/packages/backend/app/services/login_anomaly.py new file mode 100644 index 00000000..dce3d324 --- /dev/null +++ b/packages/backend/app/services/login_anomaly.py @@ -0,0 +1,505 @@ +"""Login Anomaly Detection Service. + +Detects and alerts on suspicious login behavior: +- New device detection +- Anomaly IP/geo detection +- Anomaly login time +- Multiple failed attempts +""" + +import hashlib +import json +import logging +from datetime import datetime, timedelta +from typing import Optional +from dataclasses import dataclass, asdict + +from sqlalchemy import func, and_ +from ..extensions import db +from ..models import ( + LoginAttempt, + UserDevice, + LoginAnomaly, + LoginAnomalyType, + User, +) + +logger = logging.getLogger("finmind.login_anomaly") + + +@dataclass +class AnomalyResult: + """Result of anomaly detection.""" + is_anomaly: bool + anomaly_type: Optional[LoginAnomalyType] = None + severity: str = "low" # low, medium, high + details: dict = None + + def __post_init__(self): + if self.details is None: + self.details = {} + + +@dataclass +class LoginContext: + """Context for a login attempt.""" + user_id: Optional[int] + email: str + ip_address: str + user_agent: Optional[str] = None + device_fingerprint: Optional[str] = None + country: Optional[str] = None + city: Optional[str] = None + + +class LoginAnomalyDetector: + """Detects anomalous login behavior.""" + + # Thresholds for detection + MAX_FAILED_ATTEMPTS = 5 # Max failed attempts before alert + FAILED_ATTEMPTS_WINDOW_HOURS = 1 # Time window for counting failures + UNUSUAL_HOUR_START = 0 # Midnight + UNUSUAL_HOUR_END = 5 # 5 AM + MIN_LOGINS_FOR_PATTERN = 5 # Min logins before detecting time patterns + + def __init__(self, app=None): + self.app = app + + def detect_device_fingerprint(self, user_agent: str, ip_address: str) -> str: + """Generate a device fingerprint from user agent and IP.""" + if not user_agent: + user_agent = "unknown" + data = f"{user_agent}" + return hashlib.sha256(data.encode()).hexdigest()[:32] + + def record_login_attempt( + self, + context: LoginContext, + success: bool, + failure_reason: Optional[str] = None + ) -> LoginAttempt: + """Record a login attempt and return the created record.""" + attempt = LoginAttempt( + user_id=context.user_id, + email=context.email, + ip_address=context.ip_address, + user_agent=context.user_agent, + device_fingerprint=context.device_fingerprint, + success=success, + failure_reason=failure_reason, + country=context.country, + city=context.city, + ) + db.session.add(attempt) + db.session.flush() # Get the ID without committing + return attempt + + def check_new_device(self, context: LoginContext) -> AnomalyResult: + """Check if this is a new/unknown device for the user.""" + if not context.user_id: + return AnomalyResult(is_anomaly=False) + + if not context.device_fingerprint: + return AnomalyResult(is_anomaly=False) + + existing = db.session.query(UserDevice).filter( + and_( + UserDevice.user_id == context.user_id, + UserDevice.device_fingerprint == context.device_fingerprint, + UserDevice.is_revoked == False + ) + ).first() + + if existing: + # Update last seen + existing.last_seen = datetime.utcnow() + existing.ip_address = context.ip_address + return AnomalyResult(is_anomaly=False) + + # New device detected + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.NEW_DEVICE, + severity="medium", + details={ + "device_fingerprint": context.device_fingerprint, + "user_agent": context.user_agent, + "ip_address": context.ip_address, + } + ) + + def check_new_location(self, context: LoginContext) -> AnomalyResult: + """Check if this is a new geographic location for the user.""" + if not context.user_id: + return AnomalyResult(is_anomaly=False) + + if not context.country: + return AnomalyResult(is_anomaly=False) + + # Check if we've seen this country before + previous_locations = db.session.query( + LoginAttempt.country, LoginAttempt.city + ).filter( + and_( + LoginAttempt.user_id == context.user_id, + LoginAttempt.success == True, + LoginAttempt.country != None + ) + ).distinct().all() + + if not previous_locations: + # First login, no baseline + return AnomalyResult(is_anomaly=False) + + known_countries = {loc[0] for loc in previous_locations} + + if context.country not in known_countries: + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.NEW_LOCATION, + severity="high", + details={ + "new_country": context.country, + "new_city": context.city, + "known_countries": list(known_countries), + } + ) + + return AnomalyResult(is_anomaly=False) + + def check_unusual_time(self, context: LoginContext) -> AnomalyResult: + """Check if login time is unusual for this user.""" + if not context.user_id: + return AnomalyResult(is_anomaly=False) + + # Get user's typical login hours + successful_logins = db.session.query( + func.extract('hour', LoginAttempt.created_at).label('hour') + ).filter( + and_( + LoginAttempt.user_id == context.user_id, + LoginAttempt.success == True + ) + ).all() + + if len(successful_logins) < self.MIN_LOGINS_FOR_PATTERN: + # Not enough data to establish pattern + return AnomalyResult(is_anomaly=False) + + # Calculate typical login hours (hours with at least 1 login) + typical_hours = {int(login.hour) for login in successful_logins} + + current_hour = datetime.utcnow().hour + + # Check if current hour is in unusual range AND not in typical hours + if (self.UNUSUAL_HOUR_START <= current_hour <= self.UNUSUAL_HOUR_END + and current_hour not in typical_hours): + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.UNUSUAL_TIME, + severity="low", + details={ + "current_hour": current_hour, + "typical_hours": sorted(list(typical_hours)), + } + ) + + return AnomalyResult(is_anomaly=False) + + def check_multiple_failures(self, email: str) -> AnomalyResult: + """Check for multiple failed login attempts.""" + window_start = datetime.utcnow() - timedelta(hours=self.FAILED_ATTEMPTS_WINDOW_HOURS) + + failed_count = db.session.query(func.count(LoginAttempt.id)).filter( + and_( + LoginAttempt.email == email, + LoginAttempt.success == False, + LoginAttempt.created_at >= window_start + ) + ).scalar() + + if failed_count >= self.MAX_FAILED_ATTEMPTS: + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.MULTIPLE_FAILURES, + severity="high", + details={ + "failed_count": failed_count, + "window_hours": self.FAILED_ATTEMPTS_WINDOW_HOURS, + } + ) + + return AnomalyResult(is_anomaly=False) + + # Known suspicious IP patterns + SUSPICIOUS_IP_PATTERNS = [ + "10.", # Private IP (should not appear in production) + "192.168.", # Private IP + "127.", # Localhost (suspicious for remote login) + "0.0.0.0", # Invalid + ] + + # Known VPN/Proxy/Tor exit node indicators (can be expanded) + TOR_EXIT_NODE_INDICATORS = [] # Would be populated from external source + + def check_suspicious_ip(self, context: LoginContext) -> AnomalyResult: + """ + Check if the IP address is suspicious. + + Detects: + - Private/internal IPs (should not appear in production login) + - Known Tor exit nodes (if data available) + - VPN/Proxy indicators (if data available) + - IP from high-risk country (placeholder for Geo-IP risk scoring) + """ + if not context.ip_address: + return AnomalyResult(is_anomaly=False) + + ip = context.ip_address + + # Check for private/internal IPs (suspicious for production) + for pattern in self.SUSPICIOUS_IP_PATTERNS: + if ip.startswith(pattern): + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.SUSPICIOUS_IP, + severity="high", + details={ + "ip_address": ip, + "reason": "private_or_internal_ip", + "pattern_matched": pattern, + } + ) + + # Check for high-risk countries (if geo data available) + HIGH_RISK_COUNTRIES = [] # Placeholder: would be from threat intelligence + if context.country and context.country in HIGH_RISK_COUNTRIES: + return AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.SUSPICIOUS_IP, + severity="medium", + details={ + "ip_address": ip, + "country": context.country, + "reason": "high_risk_country", + } + ) + + return AnomalyResult(is_anomaly=False) + + def run_all_checks( + self, + context: LoginContext, + is_success: bool + ) -> list[AnomalyResult]: + """Run all anomaly checks and return list of detected anomalies.""" + anomalies = [] + + # Check for multiple failures (for both success and failure) + failure_anomaly = self.check_multiple_failures(context.email) + if failure_anomaly.is_anomaly: + anomalies.append(failure_anomaly) + + # Only run device/location/time checks on successful login + if is_success and context.user_id: + device_anomaly = self.check_new_device(context) + if device_anomaly.is_anomaly: + anomalies.append(device_anomaly) + + location_anomaly = self.check_new_location(context) + if location_anomaly.is_anomaly: + anomalies.append(location_anomaly) + + time_anomaly = self.check_unusual_time(context) + if time_anomaly.is_anomaly: + anomalies.append(time_anomaly) + + # Check for suspicious IP (for both success and failure) + ip_anomaly = self.check_suspicious_ip(context) + if ip_anomaly.is_anomaly: + anomalies.append(ip_anomaly) + + return anomalies + + def register_device( + self, + context: LoginContext, + device_name: Optional[str] = None + ) -> UserDevice: + """Register a new device for a user.""" + if not context.user_id: + raise ValueError("user_id required to register device") + + device = UserDevice( + user_id=context.user_id, + device_fingerprint=context.device_fingerprint or self.detect_device_fingerprint( + context.user_agent or "", context.ip_address + ), + device_name=device_name, + ip_address=context.ip_address, + user_agent=context.user_agent, + country=context.country, + city=context.city, + ) + db.session.add(device) + return device + + def record_anomaly( + self, + user_id: int, + login_attempt_id: Optional[int], + anomaly_type: LoginAnomalyType, + severity: str, + details: dict + ) -> LoginAnomaly: + """Record a detected anomaly.""" + anomaly = LoginAnomaly( + user_id=user_id, + login_attempt_id=login_attempt_id, + anomaly_type=anomaly_type, + severity=severity, + details=json.dumps(details) if details else None, + ) + db.session.add(anomaly) + return anomaly + + def process_login( + self, + context: LoginContext, + success: bool, + failure_reason: Optional[str] = None + ) -> tuple[LoginAttempt, list[LoginAnomaly]]: + """ + Process a login attempt: record it, detect anomalies, and create alerts. + Returns the LoginAttempt and any detected anomalies. + """ + # Generate device fingerprint if not provided + if not context.device_fingerprint and context.user_agent: + context.device_fingerprint = self.detect_device_fingerprint( + context.user_agent, context.ip_address + ) + + # Record the attempt + attempt = self.record_login_attempt(context, success, failure_reason) + + # Detect anomalies + anomalies = self.run_all_checks(context, success) + + # Record anomalies + recorded_anomalies = [] + for anomaly in anomalies: + if context.user_id: + recorded = self.record_anomaly( + user_id=context.user_id, + login_attempt_id=attempt.id, + anomaly_type=anomaly.anomaly_type, + severity=anomaly.severity, + details=anomaly.details, + ) + recorded_anomalies.append(recorded) + logger.warning( + "Login anomaly detected: user_id=%s type=%s severity=%s", + context.user_id, + anomaly.anomaly_type.value, + anomaly.severity + ) + + # On successful login, ensure device is registered + if success and context.user_id: + existing_device = db.session.query(UserDevice).filter( + and_( + UserDevice.user_id == context.user_id, + UserDevice.device_fingerprint == context.device_fingerprint + ) + ).first() + + if existing_device: + existing_device.last_seen = datetime.utcnow() + existing_device.ip_address = context.ip_address + else: + self.register_device(context) + + return attempt, recorded_anomalies + + +# Global detector instance +detector = LoginAnomalyDetector() + + +def get_client_ip(request) -> str: + """Extract client IP from request, handling proxies.""" + # Check X-Forwarded-For header (behind proxy) + forwarded = request.headers.get('X-Forwarded-For') + if forwarded: + return forwarded.split(',')[0].strip() + + # Check X-Real-IP header (nginx) + real_ip = request.headers.get('X-Real-IP') + if real_ip: + return real_ip + + # Fall back to direct connection + return request.remote_addr or '0.0.0.0' + + +def get_geo_from_ip(ip_address: str) -> dict: + """ + Get geographic information from IP address. + + Uses ip-api.com (free tier, no API key required, 45 requests/min limit). + For production, consider using MaxMind GeoIP2 or similar paid service. + + Returns: {"country": str, "city": str} or empty dict on failure. + """ + if not ip_address: + return {} + + # Skip private/internal IPs + PRIVATE_IP_PREFIXES = ("10.", "192.168.", "172.16.", "172.17.", "172.18.", + "172.19.", "172.20.", "172.21.", "172.22.", "172.23.", + "172.24.", "172.25.", "172.26.", "172.27.", "172.28.", + "172.29.", "172.30.", "172.31.", "127.", "169.254.", "::1") + if ip_address.startswith(PRIVATE_IP_PREFIXES): + return {"country": None, "city": None} + + try: + import requests + response = requests.get( + f"http://ip-api.com/json/{ip_address}", + timeout=2.0, + params={"fields": "status,countryCode,city"} + ) + + if response.status_code == 200: + data = response.json() + if data.get("status") == "success": + return { + "country": data.get("countryCode"), + "city": data.get("city"), + } + except Exception as e: + logger.debug(f"Geo-IP lookup failed for {ip_address}: {e}") + + return {} + + +def get_login_context(request, user_id: Optional[int], email: str) -> LoginContext: + """Build LoginContext from Flask request.""" + user_agent = request.headers.get('User-Agent', '')[:500] # Truncate to fit column + ip_address = get_client_ip(request) + + # Generate device fingerprint + device_fingerprint = detector.detect_device_fingerprint(user_agent, ip_address) + + # Get geo information from IP + geo = get_geo_from_ip(ip_address) + + return LoginContext( + user_id=user_id, + email=email, + ip_address=ip_address, + user_agent=user_agent, + device_fingerprint=device_fingerprint, + country=geo.get("country"), + city=geo.get("city"), + ) diff --git a/packages/backend/docs/login-anomaly-detection.md b/packages/backend/docs/login-anomaly-detection.md new file mode 100644 index 00000000..1b8079e5 --- /dev/null +++ b/packages/backend/docs/login-anomaly-detection.md @@ -0,0 +1,220 @@ +# Login Anomaly Detection + +FinMind includes a login anomaly detection system to help protect user accounts from unauthorized access. + +## Features + +### Detection Types + +1. **New Device Detection** + - Tracks known devices using browser fingerprinting + - Alerts when a login occurs from an unrecognized device + - Severity: Medium + +2. **New Location Detection** + - Tracks geographic locations (country) of successful logins + - Alerts when a login occurs from a new country + - Severity: High + +3. **Unusual Time Detection** + - Learns typical login hours for each user + - Alerts on logins during unusual hours (midnight to 5 AM UTC) if not typical + - Severity: Low + +4. **Multiple Failed Attempts** + - Monitors failed login attempts per email address + - Alerts after 5+ failed attempts within 1 hour + - Severity: High + +## API Endpoints + +### Security Endpoints + +All endpoints require authentication via JWT. + +#### List Devices +``` +GET /security/devices +``` +Returns list of registered devices for the current user. + +**Response:** +```json +[ + { + "id": 1, + "device_name": "My Laptop", + "ip_address": "192.168.1.1", + "user_agent": "Mozilla/5.0...", + "country": "US", + "city": "New York", + "first_seen": "2024-01-15T10:30:00Z", + "last_seen": "2024-01-20T08:15:00Z", + "is_trusted": true, + "is_revoked": false + } +] +``` + +#### Update Device +``` +PATCH /security/devices/{device_id} +``` +Update device settings (name, trusted status, or revoke). + +**Request Body:** +```json +{ + "device_name": "My Work Laptop", + "is_trusted": true, + "is_revoked": false +} +``` + +#### Revoke Device +``` +DELETE /security/devices/{device_id} +``` +Revoke a device's access. + +#### Login History +``` +GET /security/login-history?limit=20 +``` +Get recent login attempts for the current user. + +**Response:** +```json +[ + { + "id": 1, + "ip_address": "192.168.1.1", + "user_agent": "Mozilla/5.0...", + "success": true, + "country": "US", + "city": "New York", + "created_at": "2024-01-20T08:15:00Z" + } +] +``` + +#### List Security Alerts +``` +GET /security/alerts?limit=20&unacknowledged=true +``` +Get security alerts for the current user. + +**Response:** +```json +[ + { + "id": 1, + "anomaly_type": "new_device", + "severity": "medium", + "details": { + "device_fingerprint": "abc123...", + "ip_address": "10.0.0.1" + }, + "acknowledged": false, + "created_at": "2024-01-20T08:15:00Z" + } +] +``` + +#### Acknowledge Alert +``` +POST /security/alerts/{alert_id}/acknowledge +``` +Mark an alert as acknowledged. + +#### Acknowledge All Alerts +``` +POST /security/alerts/acknowledge-all +``` +Mark all unacknowledged alerts as acknowledged. + +### Login Response + +When anomalies are detected during login, the response includes a `security_alerts` field: + +```json +{ + "access_token": "eyJ...", + "refresh_token": "eyJ...", + "security_alerts": [ + { + "type": "new_device", + "severity": "medium" + } + ] +} +``` + +## Database Models + +### LoginAttempt +Tracks all login attempts (successful and failed). + +| Field | Type | Description | +|-------|------|-------------| +| user_id | Integer | User ID (null for unknown email) | +| email | String | Email used for login | +| ip_address | String | Client IP address | +| user_agent | String | Browser user agent | +| device_fingerprint | String | Device identifier | +| success | Boolean | Whether login succeeded | +| failure_reason | String | Reason for failure | +| country | String | Country code (2-letter) | +| city | String | City name | +| created_at | DateTime | Timestamp | + +### UserDevice +Registered devices for each user. + +| Field | Type | Description | +|-------|------|-------------| +| user_id | Integer | User ID | +| device_fingerprint | String | Unique device identifier | +| device_name | String | User-assigned name | +| ip_address | String | Last IP address | +| user_agent | String | Browser user agent | +| country | String | Country code | +| city | String | City name | +| first_seen | DateTime | First login timestamp | +| last_seen | DateTime | Most recent login | +| is_trusted | Boolean | User-marked as trusted | +| is_revoked | Boolean | Device access revoked | + +### LoginAnomaly +Detected anomalies. + +| Field | Type | Description | +|-------|------|-------------| +| user_id | Integer | User ID | +| login_attempt_id | Integer | Related login attempt | +| anomaly_type | Enum | Type of anomaly | +| severity | String | low/medium/high | +| details | JSON | Additional details | +| acknowledged | Boolean | User acknowledged | +| created_at | DateTime | Detection timestamp | + +## Configuration + +Thresholds can be configured in `LoginAnomalyDetector`: + +```python +class LoginAnomalyDetector: + MAX_FAILED_ATTEMPTS = 5 # Max failures before alert + FAILED_ATTEMPTS_WINDOW_HOURS = 1 # Time window for failures + UNUSUAL_HOUR_START = 0 # Midnight + UNUSUAL_HOUR_END = 5 # 5 AM + MIN_LOGINS_FOR_PATTERN = 5 # Min logins for time pattern +``` + +## Future Enhancements + +- GeoIP integration for accurate location detection +- Email/SMS notifications for high-severity alerts +- Device verification via email code +- Rate limiting based on anomaly score +- Machine learning for improved pattern detection diff --git a/packages/backend/tests/test_login_anomaly.py b/packages/backend/tests/test_login_anomaly.py new file mode 100644 index 00000000..c663d740 --- /dev/null +++ b/packages/backend/tests/test_login_anomaly.py @@ -0,0 +1,346 @@ +"""Tests for login anomaly detection.""" + +import pytest +from datetime import datetime, timedelta +from unittest.mock import patch, MagicMock +import json + +from app import create_app +from app.extensions import db +from app.models import ( + User, + LoginAttempt, + UserDevice, + LoginAnomaly, + LoginAnomalyType, +) +from app.services.login_anomaly import ( + LoginAnomalyDetector, + LoginContext, + AnomalyResult, + get_client_ip, +) + + +class FakeRedis: + """Fake Redis client for testing.""" + def __init__(self): + self.data = {} + + def get(self, key): + return self.data.get(key) + + def setex(self, key, ttl, value): + self.data[key] = value + + def delete(self, key): + self.data.pop(key, None) + + def flushdb(self): + self.data.clear() + + +@pytest.fixture +def fake_redis(): + """Create fake Redis client.""" + return FakeRedis() + + +@pytest.fixture +def app(fake_redis): + """Create test app with in-memory database and fake Redis.""" + from app.config import Settings + settings = Settings( + database_url="sqlite:///:memory:", + jwt_secret="test-secret-with-32-plus-chars-1234567890", + ) + app = create_app(settings) + + # Patch redis_client at module level + import app.extensions as ext + import app.routes.auth as auth_mod + original_redis = ext.redis_client + original_auth_redis = auth_mod.redis_client + + ext.redis_client = fake_redis + auth_mod.redis_client = fake_redis + + with app.app_context(): + db.create_all() + yield app + + # Restore + ext.redis_client = original_redis + auth_mod.redis_client = original_auth_redis + + +@pytest.fixture +def client(app): + """Create test client.""" + return app.test_client() + + +@pytest.fixture +def detector_instance(): + """Create detector instance.""" + return LoginAnomalyDetector() + + +class TestLoginContext: + """Tests for LoginContext dataclass.""" + + def test_create_context(self): + context = LoginContext( + user_id=1, + email="test@example.com", + ip_address="192.168.1.1", + user_agent="Mozilla/5.0", + device_fingerprint="abc123", + country="US", + city="New York", + ) + assert context.user_id == 1 + assert context.email == "test@example.com" + assert context.ip_address == "192.168.1.1" + + +class TestAnomalyResult: + """Tests for AnomalyResult dataclass.""" + + def test_no_anomaly(self): + result = AnomalyResult(is_anomaly=False) + assert result.is_anomaly is False + assert result.anomaly_type is None + + def test_with_anomaly(self): + result = AnomalyResult( + is_anomaly=True, + anomaly_type=LoginAnomalyType.NEW_DEVICE, + severity="medium", + details={"device": "test"} + ) + assert result.is_anomaly is True + assert result.anomaly_type == LoginAnomalyType.NEW_DEVICE + + +class TestLoginAnomalyDetector: + """Tests for LoginAnomalyDetector class.""" + + def test_device_fingerprint_generation(self, detector_instance): + fp1 = detector_instance.detect_device_fingerprint("Chrome/1.0", "192.168.1.1") + fp2 = detector_instance.detect_device_fingerprint("Chrome/1.0", "192.168.1.1") + assert fp1 == fp2 + assert len(fp1) == 32 + + def test_different_devices_different_fingerprints(self, detector_instance): + fp1 = detector_instance.detect_device_fingerprint("Chrome/1.0", "192.168.1.1") + fp2 = detector_instance.detect_device_fingerprint("Firefox/1.0", "192.168.1.1") + assert fp1 != fp2 + + def test_record_login_attempt(self, app, detector_instance): + with app.app_context(): + context = LoginContext( + user_id=1, + email="test@example.com", + ip_address="192.168.1.1", + user_agent="Test Agent", + device_fingerprint="abc123", + ) + attempt = detector_instance.record_login_attempt(context, success=True) + db.session.commit() + assert attempt.id is not None + assert attempt.email == "test@example.com" + assert attempt.success is True + + def test_check_new_device_no_user(self, app, detector_instance): + with app.app_context(): + context = LoginContext( + user_id=None, + email="test@example.com", + ip_address="192.168.1.1", + device_fingerprint="abc123", + ) + result = detector_instance.check_new_device(context) + assert result.is_anomaly is False + + def test_check_new_device_first_device(self, app, detector_instance): + with app.app_context(): + user = User(email="test@example.com", password_hash="hash") + db.session.add(user) + db.session.commit() + context = LoginContext( + user_id=user.id, + email="test@example.com", + ip_address="192.168.1.1", + device_fingerprint="abc123", + ) + result = detector_instance.check_new_device(context) + assert result.is_anomaly is True + assert result.anomaly_type == LoginAnomalyType.NEW_DEVICE + + def test_check_new_device_known_device(self, app, detector_instance): + with app.app_context(): + user = User(email="test@example.com", password_hash="hash") + db.session.add(user) + db.session.commit() + device = UserDevice( + user_id=user.id, + device_fingerprint="abc123", + ip_address="192.168.1.1", + ) + db.session.add(device) + db.session.commit() + context = LoginContext( + user_id=user.id, + email="test@example.com", + ip_address="192.168.1.1", + device_fingerprint="abc123", + ) + result = detector_instance.check_new_device(context) + assert result.is_anomaly is False + + def test_check_new_location_different_country(self, app, detector_instance): + with app.app_context(): + user = User(email="test@example.com", password_hash="hash") + db.session.add(user) + db.session.commit() + attempt = LoginAttempt( + user_id=user.id, + email="test@example.com", + ip_address="192.168.1.1", + success=True, + country="US", + ) + db.session.add(attempt) + db.session.commit() + context = LoginContext( + user_id=user.id, + email="test@example.com", + ip_address="10.0.0.1", + country="CN", + city="Beijing", + ) + result = detector_instance.check_new_location(context) + assert result.is_anomaly is True + assert result.anomaly_type == LoginAnomalyType.NEW_LOCATION + + def test_check_multiple_failures_at_threshold(self, app, detector_instance): + with app.app_context(): + for _ in range(5): + attempt = LoginAttempt( + user_id=None, + email="test@example.com", + ip_address="192.168.1.1", + success=False, + failure_reason="invalid_credentials", + ) + db.session.add(attempt) + db.session.commit() + result = detector_instance.check_multiple_failures("test@example.com") + assert result.is_anomaly is True + assert result.anomaly_type == LoginAnomalyType.MULTIPLE_FAILURES + + def test_check_suspicious_ip_private(self, app, detector_instance): + """Test that private IPs are flagged as suspicious.""" + with app.app_context(): + context = LoginContext( + user_id=None, + email="test@example.com", + ip_address="192.168.1.1", + ) + result = detector_instance.check_suspicious_ip(context) + assert result.is_anomaly is True + assert result.anomaly_type == LoginAnomalyType.SUSPICIOUS_IP + assert result.details["reason"] == "private_or_internal_ip" + + def test_check_suspicious_ip_public(self, app, detector_instance): + """Test that public IPs are not flagged as suspicious.""" + with app.app_context(): + context = LoginContext( + user_id=None, + email="test@example.com", + ip_address="8.8.8.8", # Google's public DNS + ) + result = detector_instance.check_suspicious_ip(context) + assert result.is_anomaly is False + + def test_process_login_success(self, app, detector_instance): + with app.app_context(): + user = User(email="test@example.com", password_hash="hash") + db.session.add(user) + db.session.commit() + context = LoginContext( + user_id=user.id, + email="test@example.com", + ip_address="8.8.8.8", # Use public IP to avoid SUSPICIOUS_IP detection + user_agent="Test Agent", + ) + attempt, anomalies = detector_instance.process_login(context, success=True) + db.session.commit() + assert attempt.id is not None + assert attempt.success is True + assert len(anomalies) == 1 # Only new_device, no suspicious_ip for public IP + device = db.session.query(UserDevice).filter( + UserDevice.user_id == user.id + ).first() + assert device is not None + + +class TestSecurityEndpoints: + """Tests for security API endpoints.""" + + @pytest.fixture + def auth_header(self, client): + client.post("/auth/register", json={ + "email": "test@example.com", + "password": "password123" + }) + response = client.post("/auth/login", json={ + "email": "test@example.com", + "password": "password123" + }) + data = response.get_json() + return {"Authorization": f"Bearer {data['access_token']}"} + + def test_list_devices_after_login(self, client, auth_header): + response = client.get("/security/devices", headers=auth_header) + assert response.status_code == 200 + data = response.get_json() + assert len(data) >= 1 + + def test_login_history(self, client, auth_header): + response = client.get("/security/login-history", headers=auth_header) + assert response.status_code == 200 + data = response.get_json() + assert len(data) >= 1 + + def test_list_alerts(self, client, auth_header): + response = client.get("/security/alerts", headers=auth_header) + assert response.status_code == 200 + data = response.get_json() + assert isinstance(data, list) + + +class TestGetClientIP: + """Tests for get_client_ip helper.""" + + def test_direct_connection(self): + mock_request = MagicMock() + mock_request.remote_addr = "192.168.1.1" + mock_request.headers = {} + ip = get_client_ip(mock_request) + assert ip == "192.168.1.1" + + def test_x_forwarded_for(self): + mock_request = MagicMock() + mock_request.remote_addr = "10.0.0.1" + mock_request.headers = {"X-Forwarded-For": "203.0.113.1, 70.41.3.18"} + ip = get_client_ip(mock_request) + assert ip == "203.0.113.1" + + def test_x_real_ip(self): + mock_request = MagicMock() + mock_request.remote_addr = "10.0.0.1" + mock_request.headers = {"X-Real-IP": "198.51.100.1"} + ip = get_client_ip(mock_request) + assert ip == "198.51.100.1"