games_app/backend/dist/services/securityService.js
2026-11-15 17:36:00 +02:00

450 lines
19 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"use strict";
/**
* Platform security: ledger integrity, alerts, withdrawal suspension, admin notifications.
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.SecurityBlockedError = exports.AUTHORIZED_LEDGER_TYPES = void 0;
exports.assertAccountUsable = assertAccountUsable;
exports.assertUserCanMoveFunds = assertUserCanMoveFunds;
exports.assertUserCanWithdraw = assertUserCanWithdraw;
exports.suspendUserForSecurity = suspendUserForSecurity;
exports.raiseAlert = raiseAlert;
exports.notifyAdminsOfAlert = notifyAdminsOfAlert;
exports.resolveAlert = resolveAlert;
exports.isDirectBalanceTamper = isDirectBalanceTamper;
exports.runLedgerIntegrityCheck = runLedgerIntegrityCheck;
exports.getSecuritySettings = getSecuritySettings;
exports.updateSecuritySettings = updateSecuritySettings;
exports.listSecurityAlerts = listSecurityAlerts;
exports.getIntegrityCheckIntervalMs = getIntegrityCheckIntervalMs;
exports.dismissSpuriousTamperAlerts = dismissSpuriousTamperAlerts;
const config_1 = require("../config");
const securityAlertRepository = __importStar(require("../repositories/securityAlertRepository"));
const ledgerRepository = __importStar(require("../repositories/ledgerRepository"));
const ledgerIntegrityRepository = __importStar(require("../repositories/ledgerIntegrityRepository"));
const adminNotificationRepository = __importStar(require("../repositories/adminNotificationRepository"));
const userRepository = __importStar(require("../repositories/userRepository"));
const auditLogRepository = __importStar(require("../repositories/auditLogRepository"));
const emailService_1 = require("./emailService");
const slackService_1 = require("./slackService");
const referralRepository = __importStar(require("../repositories/referralRepository"));
const crypto_1 = require("../utils/crypto");
const securityRealtimeService_1 = require("./securityRealtimeService");
/** Ledger entry types that may credit or debit user balances. */
exports.AUTHORIZED_LEDGER_TYPES = new Set([
'deposit',
'withdrawal',
'transfer',
'game_stake',
'game_payout',
'game_refund',
'bonus',
'admin_adjustment',
'referral_bonus',
'referral_clawback',
'bonus_to_main',
'test_credit',
'solo_encouragement_bonus',
]);
class SecurityBlockedError extends Error {
constructor(message, code) {
super(message);
this.name = 'SecurityBlockedError';
this.code = code;
}
}
exports.SecurityBlockedError = SecurityBlockedError;
/** Blocks API use when the account itself is disabled / locked / deleted. */
async function assertAccountUsable(userId) {
const user = await userRepository.findById(userId);
if (!user || user.deleted_at) {
throw new SecurityBlockedError('Account is not available.', 'ACCOUNT_DISABLED');
}
if (user.is_enabled === false) {
throw new SecurityBlockedError('Account is disabled.', 'ACCOUNT_DISABLED');
}
if (user.is_account_non_locked === false) {
// Distinct from login lockout `ACCOUNT_LOCKED` (429 + retry timer).
throw new SecurityBlockedError('Account is locked.', 'ACCOUNT_DISABLED');
}
if (user.is_account_non_expired === false) {
throw new SecurityBlockedError('Account has expired.', 'ACCOUNT_DISABLED');
}
if (user.is_credentials_non_expired === false) {
throw new SecurityBlockedError('Credentials have expired.', 'ACCOUNT_DISABLED');
}
}
/**
* Blocks cash-out style money movement (withdrawals, peer transfers, bonus→main)
* when the account is under a security hold. Predictions remain allowed.
*/
async function assertUserCanMoveFunds(userId) {
const user = await userRepository.findById(userId);
if (!user || user.deleted_at) {
throw new SecurityBlockedError('Account is not available.', 'ACCOUNT_DISABLED');
}
if (user.is_enabled === false) {
throw new SecurityBlockedError('Account is disabled.', 'ACCOUNT_DISABLED');
}
if (user.is_account_non_locked === false) {
throw new SecurityBlockedError('Account is locked.', 'ACCOUNT_DISABLED');
}
if (user.is_account_non_expired === false) {
throw new SecurityBlockedError('Account has expired.', 'ACCOUNT_DISABLED');
}
if (user.is_credentials_non_expired === false) {
throw new SecurityBlockedError('Credentials have expired.', 'ACCOUNT_DISABLED');
}
if (user.withdrawals_suspended) {
throw new SecurityBlockedError('Outgoing funds are suspended on your account pending security review. Withdrawals and transfers are temporarily disabled. Contact support.', 'WITHDRAWALS_SUSPENDED');
}
if (user.under_surveillance) {
throw new SecurityBlockedError('Your account is under security surveillance. Withdrawals and transfers are temporarily disabled. Contact support.', 'ACCOUNT_UNDER_SURVEILLANCE');
}
}
/** @deprecated Prefer assertUserCanMoveFunds — kept as a clear alias for withdrawal call sites. */
async function assertUserCanWithdraw(userId) {
await assertUserCanMoveFunds(userId);
}
async function suspendUserForSecurity(userId, reason, alertType, severity = 'high') {
await userRepository.updateSecurityFlags(userId, {
withdrawals_suspended: true,
under_surveillance: true,
security_reason_encrypted: reason,
set_suspended_at: true,
});
const alert = await securityAlertRepository.createAlert({
userId,
severity,
alertType,
title: `Security hold: ${alertType}`,
details: reason,
});
await notifyAdminsOfAlert(alert);
}
async function raiseAlert(input) {
const alert = await securityAlertRepository.createAlert(input);
if (input.suspendUser && input.userId) {
await userRepository.updateSecurityFlags(input.userId, {
withdrawals_suspended: true,
under_surveillance: true,
security_reason_encrypted: input.details ?? input.title,
set_suspended_at: true,
});
}
await auditLogRepository.create({
userId: input.userId ?? undefined,
action: 'security_alert_raised',
resourceType: 'security_alert',
resourceId: alert.id,
metadata: { alert_type: input.alertType, severity: input.severity },
});
await notifyAdminsOfAlert(alert);
return alert;
}
async function notifyAdminsOfAlert(alert) {
const emails = await securityAlertRepository.getAlertEmailsDecrypted();
const details = alert.details_encrypted ? (0, crypto_1.decryptSensitive)(alert.details_encrypted) : '';
const payload = {
alertId: alert.id,
severity: alert.severity,
type: alert.alert_type,
title: alert.title,
details,
userId: alert.user_id,
createdAt: alert.created_at,
};
console.warn('[security-alert]', JSON.stringify(payload));
try {
await adminNotificationRepository.createNotification({
title: alert.title,
body: [details, alert.user_id ? `User: ${alert.user_id}` : null].filter(Boolean).join('\n'),
severity: alert.severity,
alertId: alert.id,
});
}
catch (e) {
console.error('Failed to create admin notification:', e);
}
for (const email of emails) {
try {
await (0, emailService_1.sendSecurityAlertEmail)(email, payload);
}
catch (e) {
console.error(`Failed to send security alert email to ${email}:`, e);
}
}
const slackChannel = (0, slackService_1.isReferralSlackAlertType)(alert.alert_type) ? 'referral' : 'security';
let sendSlack = Boolean((0, slackService_1.getSlackWebhookUrl)(slackChannel));
if (slackChannel === 'referral') {
try {
const settings = await referralRepository.getSettings();
sendSlack = sendSlack && settings.slack_alerts_enabled;
}
catch (e) {
console.error('Failed to load referral settings for Slack routing:', e);
sendSlack = false;
}
}
if (sendSlack) {
try {
await (0, slackService_1.postSlackAlert)({
channel: slackChannel,
title: alert.title,
severity: alert.severity,
alertType: alert.alert_type,
details,
userId: alert.user_id,
metadata: alert.metadata,
});
}
catch (e) {
console.error('Failed to post security alert to Slack:', e);
}
}
void (0, securityRealtimeService_1.publishSecurityAdminEvent)({
type: 'security.alert.raised',
alertId: alert.id,
severity: alert.severity,
title: alert.title,
alertType: alert.alert_type,
});
void (0, securityRealtimeService_1.publishSecurityAdminEvent)({ type: 'security.notification.new' });
}
async function resolveAlert(alertId, adminUserId, status, resolutionNote, reactivateWithdrawals) {
const alert = await securityAlertRepository.updateAlertStatus(alertId, status, adminUserId, resolutionNote);
if (!alert)
return null;
if (reactivateWithdrawals && alert.user_id && status === 'resolved') {
await userRepository.updateSecurityFlags(alert.user_id, {
withdrawals_suspended: false,
under_surveillance: false,
clear_security_reason: true,
});
}
try {
await auditLogRepository.create({
userId: adminUserId,
action: 'security_alert_resolved',
resourceType: 'security_alert',
resourceId: alertId,
metadata: { status, reactivate_withdrawals: !!reactivateWithdrawals },
});
}
catch (e) {
console.error('Audit log for security alert resolution failed:', e);
}
void (0, securityRealtimeService_1.publishSecurityAdminEvent)({ type: 'security.alert.resolved', alertId });
void (0, securityRealtimeService_1.publishSecurityAdminEvent)({ type: 'security.audit.new', action: 'security_alert_resolved' });
return alert;
}
/**
* Detects balance inflation/deflation without a matching ledger entry change.
*
* Lock/unlock (withdrawal reserve / cancel) reshuffles available↔locked while keeping
* (available + locked) and entries_sum unchanged — that must NOT count as tamper.
* Real direct tamper changes the total while entries stay the same.
*/
function isDirectBalanceTamper(snap, meta) {
const snapTotal = BigInt(snap.available_balance) + BigInt(snap.locked_balance);
const metaTotal = BigInt(meta.available_balance) + BigInt(meta.locked_balance);
const totalChanged = snapTotal !== metaTotal;
const entriesUnchanged = snap.entries_sum === meta.entries_sum &&
(snap.last_entry_at?.getTime() ?? 0) === (meta.last_entry_at?.getTime() ?? 0);
return totalChanged && entriesUnchanged;
}
async function runLedgerIntegrityCheck() {
const accounts = await ledgerRepository.listAllAccountsForIntegrity();
const issues = [];
for (const account of accounts) {
const available = BigInt(account.available_balance);
const locked = BigInt(account.locked_balance);
const entriesSum = BigInt(account.entries_sum);
const total = available + locked;
if (total !== entriesSum) {
issues.push({
userId: account.user_id,
walletTypeId: account.wallet_type_id,
accountId: account.id,
available: account.available_balance,
locked: account.locked_balance,
entriesSum: account.entries_sum,
issue: 'balance_entries_mismatch',
});
}
const unauthorized = await ledgerRepository.listUnauthorizedEntryTypes(account.id, [...exports.AUTHORIZED_LEDGER_TYPES]);
if (unauthorized.length > 0) {
issues.push({
userId: account.user_id,
walletTypeId: account.wallet_type_id,
accountId: account.id,
available: account.available_balance,
locked: account.locked_balance,
entriesSum: account.entries_sum,
issue: `unauthorized_ledger_types:${unauthorized.join(',')}`,
});
}
const meta = await ledgerIntegrityRepository.getAccountLedgerMeta(account.id);
if (meta) {
const snap = await ledgerIntegrityRepository.getSnapshot(account.id);
if (snap && isDirectBalanceTamper(snap, meta)) {
issues.push({
userId: account.user_id,
walletTypeId: account.wallet_type_id,
accountId: account.id,
available: meta.available_balance,
locked: meta.locked_balance,
entriesSum: meta.entries_sum,
issue: 'direct_balance_tamper',
});
}
}
}
const lockMismatches = await ledgerIntegrityRepository.listLockedReservationMismatches();
for (const row of lockMismatches) {
issues.push({
userId: row.user_id,
walletTypeId: row.wallet_type_id,
accountId: row.account_id,
available: row.available_balance,
locked: row.locked_balance,
entriesSum: row.entries_sum,
issue: 'locked_reservation_mismatch',
amount: row.locks_sum,
});
}
const invalidRefs = await ledgerIntegrityRepository.listInvalidLedgerReferences();
for (const ref of invalidRefs) {
const account = accounts.find((a) => a.id === ref.account_id);
issues.push({
userId: ref.user_id,
walletTypeId: account?.wallet_type_id ?? 0,
accountId: ref.account_id,
available: account?.available_balance ?? '0',
locked: account?.locked_balance ?? '0',
entriesSum: account?.entries_sum ?? '0',
issue: `invalid_ledger_reference:${ref.issue}`,
entryId: ref.entry_id,
amount: ref.amount,
});
}
const issueAccountIds = new Set(issues.map((i) => i.accountId));
for (const account of accounts) {
if (issueAccountIds.has(account.id))
continue;
const meta = await ledgerIntegrityRepository.getAccountLedgerMeta(account.id);
if (meta)
await ledgerIntegrityRepository.upsertSnapshot(meta);
}
for (const issue of issues) {
const user = await userRepository.findById(issue.userId);
if (user?.under_surveillance)
continue;
const alertType = issue.issue.startsWith('unauthorized')
? 'unauthorized_ledger_entry'
: issue.issue.startsWith('invalid_ledger_reference')
? 'orphan_ledger_credit'
: issue.issue === 'direct_balance_tamper' || issue.issue === 'locked_reservation_mismatch'
? 'ledger_balance_tamper'
: 'ledger_balance_mismatch';
await suspendUserForSecurity(issue.userId, `Ledger integrity failure (${issue.issue}) on wallet type ${issue.walletTypeId}. ` +
`available=${issue.available}, locked=${issue.locked}, entries_sum=${issue.entriesSum}` +
(issue.entryId ? `, entry=${issue.entryId}` : ''), alertType, 'critical');
}
return issues;
}
async function getSecuritySettings() {
return { alertEmails: await securityAlertRepository.getAlertEmailsDecrypted() };
}
async function updateSecuritySettings(alertEmails) {
if (!Array.isArray(alertEmails)) {
throw new Error('alertEmails must be an array');
}
const emailRe = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
for (const email of alertEmails) {
if (typeof email !== 'string' || !emailRe.test(email.trim())) {
throw new Error(`Invalid alert email: ${email}`);
}
}
await securityAlertRepository.setAlertEmails(alertEmails);
return getSecuritySettings();
}
async function listSecurityAlerts(opts) {
const result = await securityAlertRepository.listAlerts(opts);
return {
items: result.items.map((a) => ({
id: a.id,
userId: a.user_id,
severity: a.severity,
alertType: a.alert_type,
status: a.status,
title: a.title,
details: a.details_encrypted ? (0, crypto_1.decryptSensitive)(a.details_encrypted) : null,
metadata: a.metadata,
resolvedBy: a.resolved_by,
resolvedAt: a.resolved_at,
resolutionNote: a.resolution_note_encrypted
? (0, crypto_1.decryptSensitive)(a.resolution_note_encrypted)
: null,
createdAt: a.created_at,
updatedAt: a.updated_at,
})),
total: result.total,
};
}
function getIntegrityCheckIntervalMs() {
return config_1.config.security.integrityCheckIntervalMs;
}
/** Dismisses false-positive alerts caused by the security_alerts INSERT detection loop (pre-fix). */
async function dismissSpuriousTamperAlerts(adminUserId) {
const { encryptSensitive } = await Promise.resolve().then(() => __importStar(require('../utils/crypto')));
const { query } = await Promise.resolve().then(() => __importStar(require('../db/connection')));
const rows = await query(`UPDATE security_alerts
SET status = 'dismissed',
resolved_by = $1,
resolved_at = NOW(),
resolution_note_encrypted = $2,
updated_at = NOW()
WHERE status IN ('open', 'investigating')
AND alert_type = 'direct_db_tamper'
AND title LIKE 'Modification directe DB: security_alerts (INSERT)%'
RETURNING id`, [
adminUserId,
encryptSensitive('Fausse alerte automatique : insertion légitime d’alerte par l’application (boucle de détection corrigée).'),
]);
return rows.length;
}
//# sourceMappingURL=securityService.js.map