@alizadefaig/pos-server 1.2.25 → 1.2.27

package/app/security.js

@@ -0,0 +1,218 @@
+const {timingSafeEqual} = require('node:crypto');
+const {internalKey, INTERNAL_KEY_HEADER, isSyncEnabled, isLanFrontEnabled} = require('./sync/config');
+const {getConfig} = require('./config');
+
+/** Сравнение секретов за постоянное время (длина сравнивается отдельно — это не секрет). */
+const safeEqual = (provided, expected) => {
+    if (typeof provided !== 'string' || typeof expected !== 'string' || !provided || !expected) {
+        return false;
+    }
+    const a = Buffer.from(provided);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+};
+
+// Служебные пути Laravel → Node: бродкаст в комнату компании, запрос к терминалу (печать),
+// ретрансляция мастер-кассе. Снаружи до них достучаться не должен никто.
+// Без учёта регистра: роутер Express сопоставляет пути так же, и GET /SOCKET?... иначе
+// дошёл бы до router.all('/socket') мимо ключа.
+const INTERNAL_PATHS = [/^\/socket\/?$/i, /^\/socket\/request\/?$/i, /^\/master(\/|$)/i];
+
+const isInternalPath = (path) => INTERNAL_PATHS.some((pattern) => pattern.test(path));
+
+/**
+ * Express-middleware: служебные пути требуют заголовок x-internal-key = INTERNAL_API_KEY.
+ * Ключ не задан — no-op (поведение как раньше), поэтому включается одной переменной на
+ * облачном Node вместе с тем же ключом в .env Laravel.
+ */
+const internalGuard = (req, res, next) => {
+    const expected = internalKey();
+    if (!expected || !isInternalPath(req.path)) {
+        return next();
+    }
+    if (safeEqual(req.get(INTERNAL_KEY_HEADER), expected)) {
+        return next();
+    }
+    return res.status(403).json({success: false, message: 'Forbidden'});
+};
+
+// ---------------------------------------------------------------- Origin (desktop Node)
+
+/**
+ * Касса слушает localhost, а CORS у неё `*`: любая страница, открытая в любом браузере на
+ * этой машине, могла дёрнуть локальный Node — провести чек в офлайн-ядре, подменить сессию
+ * синка, отправить команду фискальному аппарату через /tax. Для «простых» запросов (form-POST)
+ * браузер даже не спрашивает preflight, поэтому заголовки CORS тут не защита — отказываем сами.
+ *
+ * Правило: браузер всегда присылает Origin; нет Origin — это не страница (Electron main,
+ * локальный процесс, ведомый терминал) — пропускаем. Origin есть и не из списка — 403.
+ */
+const DEFAULT_ALLOWED_ORIGINS = [
+    'https://*.cafepos.az',
+    'https://cafepos.az',
+    'http://localhost:*',
+    'http://127.0.0.1:*',
+];
+
+const originPatterns = () => {
+    const raw = process.env.CAFEPOS_ALLOWED_ORIGINS;
+    const list = raw ? raw.split(',').map((value) => value.trim()).filter(Boolean) : DEFAULT_ALLOWED_ORIGINS;
+    return list.map((value) => new RegExp('^' + value
+        .toLowerCase()
+        .replace(/\/+$/, '')
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/:\*$/, '(:\\d+)?')
+        .replace(/\*/g, '[a-z0-9-]+(?:\\.[a-z0-9-]+)*') + '$'));
+};
+
+const originAllowed = (origin) => {
+    if (origin === undefined || origin === null || origin === '') {
+        return true;
+    }
+    const value = String(origin).toLowerCase().replace(/\/+$/, '');
+    return originPatterns().some((pattern) => pattern.test(value));
+};
+
+/**
+ * Мастер, раздающий фронт по LAN (LAN_FRONT): телефон официанта открывает страницу с самого
+ * мастера, и её скрипты и запросы приходят с Origin `http://<IP мастера>:<порт>`. Пускаем только
+ * собственные IPv4 этой машины и её порт — чужой адрес в сети так не пройдёт. Сессию синка
+ * (strictOriginGuard) это не открывает.
+ */
+const lanOriginAllowed = (origin) => {
+    if (!origin || !isLanFrontEnabled()) {
+        return false;
+    }
+    const match = /^http:\/\/(\d{1,3}(?:\.\d{1,3}){3}):(\d{1,5})\/?$/.exec(String(origin).toLowerCase());
+    if (!match || Number(match[2]) !== Number(getConfig().port)) {
+        return false;
+    }
+    return require('./sync/lanFront').isOwnAddress(match[1]);
+};
+
+/**
+ * CAFEPOS_ORIGIN_GUARD: true | false; не задан → включён только на кассе с офлайн-контуром
+ * (там локальный Node держит данные и сессию). Облачный Node не трогаем: к нему ходят браузеры
+ * с разных доменов, его защищают токены.
+ */
+const originGuardActive = () => {
+    const flag = process.env.CAFEPOS_ORIGIN_GUARD;
+    if (flag === 'true') {
+        return true;
+    }
+    if (flag === 'false') {
+        return false;
+    }
+    return !getConfig().isServer && isSyncEnabled();
+};
+
+const refuseOrigin = (req, res) => {
+    console.warn(`[security] origin refused: ${req.get('origin')} ${req.method} ${req.path}`);
+    return res.status(403).json({success: false, message: 'Forbidden origin'});
+};
+
+/** Express-middleware для всего desktop Node (no-op, пока guard не активен). */
+const originGuard = (req, res, next) => {
+    if (!originGuardActive() || originAllowed(req.get('origin')) || lanOriginAllowed(req.get('origin'))) {
+        return next();
+    }
+    return refuseOrigin(req, res);
+};
+
+/** Для путей, которые обязаны быть защищены всегда (сессия синка), — без флага. */
+const strictOriginGuard = (req, res, next) => (originAllowed(req.get('origin')) ? next() : refuseOrigin(req, res));
+
+/** socket.io allowRequest: тот же список для WebSocket (CORS на него не распространяется). */
+const socketAllowRequest = (req, callback) => {
+    const origin = req.headers && req.headers.origin;
+    if (!originGuardActive() || originAllowed(origin) || lanOriginAllowed(origin)) {
+        return callback(null, true);
+    }
+    console.warn(`[security] socket origin refused: ${req.headers.origin}`);
+    return callback('Forbidden origin', false);
+};
+
+// ---------------------------------------------------------------- /tax
+
+/**
+ * Прокси к фискальным аппаратам и банковским терминалам. Цель берётся из запроса, поэтому
+ * без проверки это открытый SSRF: link-local 169.254.* — метаданные облака, сам Node — петля.
+ * Приватные сети (192.168.*, 10.*) и localhost разрешены: аппараты живут именно там.
+ * DNS-имена не резолвим (rebinding не закрыт) — это отдельный шаг, если понадобится.
+ */
+const BLOCKED_TAX_HOSTS = new Set(['metadata', 'metadata.google.internal', 'instance-data', '0.0.0.0', '::']);
+
+const isLoopbackHost = (host) => host === 'localhost' || host === '::1' || /^127\./.test(host);
+
+const taxTarget = (raw) => {
+    if (typeof raw !== 'string' || !raw) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(raw);
+    } catch (e) {
+        return null;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return null;
+    }
+    const host = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    if (!host || BLOCKED_TAX_HOSTS.has(host) || /^169\.254\./.test(host) || /^fe80:/.test(host)
+        || /^::ffff:(169\.254\.|a9fe:)/.test(host)) {
+        return null;
+    }
+    const port = url.port || (url.protocol === 'https:' ? '443' : '80');
+    if (isLoopbackHost(host) && String(getConfig().port) === port) {
+        return null;
+    }
+    return url;
+};
+
+/** TAX_PROXY_ENABLED: true | false; не задан → только касса (облаку прокси к аппаратам не нужен). */
+const taxProxyEnabled = () => {
+    const flag = process.env.TAX_PROXY_ENABLED;
+    if (flag === 'true' || flag === 'false') {
+        return flag === 'true';
+    }
+    return !getConfig().isServer;
+};
+
+// ---------------------------------------------------------------- логи
+
+const SECRET_HEADERS = new Set(['authorization', 'proxy-authorization', 'cookie', 'set-cookie',
+    INTERNAL_KEY_HEADER.toLowerCase(), 'x-cafepos-lan-key']);
+const SECRET_FIELDS = /pass|token|secret|^pin$|^code$|ic_card|lan_key/i;
+
+const redact = (value, isSecret) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return value;
+    }
+    const copy = {};
+    for (const [key, item] of Object.entries(value)) {
+        copy[key] = isSecret(key) && item !== null && item !== undefined && item !== '' ? '***' : item;
+    }
+    return copy;
+};
+
+/** Копия заголовков без секретов (для логов). */
+const redactHeaders = (headers) => redact(headers, (key) => SECRET_HEADERS.has(String(key).toLowerCase()));
+
+/** Копия тела без паролей, токенов и PIN (верхний уровень — для логов этого достаточно). */
+const redactBody = (body) => redact(body, (key) => SECRET_FIELDS.test(key));
+
+module.exports = {
+    safeEqual,
+    internalGuard,
+    isInternalPath,
+    originAllowed,
+    lanOriginAllowed,
+    originGuard,
+    originGuardActive,
+    strictOriginGuard,
+    socketAllowRequest,
+    taxTarget,
+    taxProxyEnabled,
+    redactHeaders,
+    redactBody,
+};

package/app/socket/auth.js

@@ -0,0 +1,160 @@
+const {createHash} = require('node:crypto');
+const axios = require('axios');
+const {getConfig} = require('../config');
+
+/**
+ * Облачный Node: кто подключился к сокету. Раньше хватало company_id в query, чтобы сесть в
+ * комнату любой компании и слушать её бродкасты (чеки, суммы, сотрудники).
+ *
+ * SOCKET_AUTH (только облачный Node, isServer):
+ *   off     — как раньше (дефолт);
+ *   warn    — проверяем в фоне и пишем в лог, сокет пускаем всегда (смотреть, кто отвалится);
+ *   enforce — без подтверждённого токена сокет не подключится (connect_error 'unauthorized').
+ *
+ * Проверяет событие auth.check (токен + team/company/terminal): облачное ядро, если оно его
+ * обслуживает, иначе Laravel. Отказ — только на явный ответ 401/403. Laravel недоступен,
+ * таймаут или старый Laravel без auth.check —
+ * пропускаем с предупреждением: иначе рестарт PHP выбил бы все кассы из сокета разом, а они
+ * без него не получают ни печать, ни чужие изменения чеков.
+ */
+const MODES = new Set(['off', 'warn', 'enforce']);
+
+const mode = () => {
+    const value = String(process.env.SOCKET_AUTH || 'off').toLowerCase();
+    return getConfig().isServer && MODES.has(value) ? value : 'off';
+};
+
+const okTtl = () => Number(process.env.SOCKET_AUTH_CACHE_MS) || 300000;
+const denyTtl = () => Number(process.env.SOCKET_AUTH_DENY_CACHE_MS) || 30000;
+const timeout = () => Number(process.env.SOCKET_AUTH_TIMEOUT_MS) || 5000;
+
+const cache = new Map();
+const CACHE_LIMIT = 10000;
+
+const cacheKey = (claims) => createHash('sha256')
+    .update([claims.token, claims.team_id, claims.company_id, claims.terminal_id].join('|'))
+    .digest('hex');
+
+const remember = (key, result) => {
+    if (cache.size >= CACHE_LIMIT) {
+        cache.delete(cache.keys().next().value);
+    }
+    cache.set(key, {result, expires: Date.now() + (result.ok ? okTtl() : denyTtl())});
+};
+
+/** Что сокет утверждает о себе: токен и команда — из auth, компания/терминал — из query. */
+const claimsOf = (socket) => {
+    const handshake = socket.handshake || {};
+    const auth = handshake.auth || {};
+    const query = handshake.query || {};
+    return {
+        token: auth.token ? String(auth.token) : null,
+        team_id: auth.team_id ? String(auth.team_id) : null,
+        company_id: query.company_id ? String(query.company_id) : null,
+        terminal_id: query.terminal_id || auth.terminal_id ? String(query.terminal_id || auth.terminal_id) : null,
+    };
+};
+
+/**
+ * auth.check обслуживает облачное ядро (CORE_EVENTS) — спрашиваем его прямо в процессе,
+ * иначе, как раньше, Laravel по HTTP. Ответ в обоих случаях {status, data}.
+ */
+const verify = async (headers) => {
+    const core = require('../core');
+    if (core.canHandle('auth.check')) {
+        const {HttpError} = require('../core/errors');
+        try {
+            return {status: 200, data: await core.dispatch('auth.check', {headers, params: {}})};
+        } catch (e) {
+            if (e instanceof HttpError) {
+                return {status: e.status, data: e.body};
+            }
+            throw e;
+        }
+    }
+    return axios.post(`${getConfig().apiUrl}/api/auth.check`, {}, {
+        headers,
+        timeout: timeout(),
+        validateStatus: () => true,
+    });
+};
+
+const check = async (claims) => {
+    if (!claims.token || !claims.team_id || !claims.company_id) {
+        return {ok: false, reason: 'missing_credentials'};
+    }
+    const key = cacheKey(claims);
+    const cached = cache.get(key);
+    if (cached && cached.expires > Date.now()) {
+        return cached.result;
+    }
+
+    const headers = {
+        Accept: 'application/json',
+        Authorization: `Bearer ${claims.token}`,
+        'team-id': claims.team_id,
+        'company-id': claims.company_id,
+        ...(claims.terminal_id ? {'terminal-id': claims.terminal_id} : {}),
+    };
+
+    let response;
+    try {
+        response = await verify(headers);
+    } catch (e) {
+        return {ok: true, degraded: true, reason: 'verify_unavailable'};
+    }
+
+    let result;
+    if (response.status === 200 && response.data && response.data.ok === true) {
+        result = {ok: true};
+    } else if (response.status === 401 || response.status === 403) {
+        result = {ok: false, reason: (response.data && response.data.reason) || `verify_failed_${response.status}`};
+    } else {
+        // 404 (старый Laravel), 402 (лицензия), 5xx — не повод рвать сокет; не кэшируем.
+        return {ok: true, degraded: true, reason: `verify_status_${response.status}`};
+    }
+    remember(key, result);
+    return result;
+};
+
+const describe = (socket, claims) => `company=${claims.company_id} terminal=${claims.terminal_id} ` +
+    `proxy=${Boolean(socket.handshake.query && socket.handshake.query.is_proxy_server)} ` +
+    `ip=${socket.handshake.address}`;
+
+/** socket.io-middleware (io.use). */
+const socketAuth = (socket, next) => {
+    const current = mode();
+    if (current === 'off') {
+        return next();
+    }
+    const claims = claimsOf(socket);
+
+    if (current === 'warn') {
+        next();
+        check(claims).then((result) => {
+            if (!result.ok) {
+                console.warn(`[socket-auth] would refuse (${result.reason}) ${describe(socket, claims)}`);
+            }
+        }).catch(() => {});
+        return undefined;
+    }
+
+    check(claims).then((result) => {
+        if (result.ok) {
+            if (result.degraded) {
+                console.warn(`[socket-auth] allowed without verification (${result.reason}) ${describe(socket, claims)}`);
+            }
+            return next();
+        }
+        console.warn(`[socket-auth] refused (${result.reason}) ${describe(socket, claims)}`);
+        const error = new Error('unauthorized');
+        error.data = {reason: result.reason};
+        return next(error);
+    }).catch((e) => {
+        console.error('[socket-auth] check failed:', e.message);
+        next();
+    });
+    return undefined;
+};
+
+module.exports = {socketAuth, mode, _cache: cache, _check: check};

package/app/socket/request.js

@@ -0,0 +1,87 @@
+const {findKeyByValue} = require('../../utils');
+const {v7: uuidv7} = require('uuid');
+
+const DEFAULT_TIMEOUT = 10000;
+
+/**
+ * Запрос к конкретному терминалу через его сокет: `request:<event>:<id>` туда,
+ * ответ ждём на `response:<event>:<id>`.
+ *
+ * Раньше жило только внутри HTTP-роута `/socket/request`, куда Laravel ходит за печатью.
+ * Офлайн-ядро печатает, находясь в этом же процессе, — ему нужен тот же канал без HTTP-петли
+ * к самому себе, поэтому логика вынесена сюда, а роут стал тонкой обёрткой.
+ *
+ * Никогда не бросает: и «нет сокета», и таймаут приходят обычным ответом
+ * `{success:false, message}` — вызывающий (как и Laravel) проверяет только `success`.
+ *
+ * companyId — терминал обязан принадлежать этой компании (запрос пришёл от мастер-кассы
+ * заведения, а не от Laravel, — адресовать чужие терминалы ей нельзя).
+ *
+ * @param {{terminalId: string, eventName: string, data: *, requestId?: string, timeout?: number, companyId?: string}} options
+ * @returns {Promise<*>} ответ терминала как есть
+ */
+const socketRequest = ({terminalId, eventName, data = null, requestId = null, timeout = DEFAULT_TIMEOUT, companyId = null} = {}) => {
+    // Сервер берём лениво на каждый вызов: модуль грузится ядром раньше, чем поднимается
+    // socket.io, а прямой require на старте замкнул бы цикл server.js → core → socket/server.
+    const serverSocket = require('./server')();
+    let socket = serverSocket
+        ? findKeyByValue(serverSocket.sockets.sockets, 'terminalId', terminalId)
+        : null;
+    if (socket && companyId && String(socket.companyId) !== String(companyId)) {
+        socket = null;
+    }
+
+    if (!socket) {
+        // Модель M: касса — мастер заведения, а терминал работает через облако. Запрос уходит
+        // туда по сигнальному сокету. Вне этого режима terminalRequest отдаёт null.
+        const viaCloud = companyId ? null : cloudTerminalRequest({terminalId, eventName, data, requestId, timeout});
+        return viaCloud || Promise.resolve({
+            success: false,
+            message: 'No socket',
+        });
+    }
+
+    // Без request_id имена событий у параллельных запросов совпали бы, и ответ одного
+    // принтера засчитался бы другому, — поэтому пустой id заменяем свежим.
+    const id = requestId === null || requestId === undefined || requestId === '' ? uuidv7() : requestId;
+    const requestEventName = `request:${eventName}:${id}`;
+    const responseEventName = `response:${eventName}:${id}`;
+    // Значение отдаём setTimeout как есть — ровно как делал роут (строка из тела тоже годится).
+    const waitMs = timeout ?? DEFAULT_TIMEOUT;
+
+    return new Promise((resolve) => {
+        let timer = null;
+
+        const onResponse = (response) => {
+            clearTimeout(timer);
+            resolve(response);
+        };
+
+        socket.once(responseEventName, onResponse);
+        socket.emit(requestEventName, data);
+
+        timer = setTimeout(() => {
+            // Слушатель снимаем, иначе поздний ответ висел бы на сокете до его закрытия.
+            socket.off(responseEventName, onResponse);
+            resolve({
+                success: false,
+                message: 'Timeout error',
+            });
+        }, waitMs);
+    });
+};
+
+const cloudTerminalRequest = (options) => {
+    try {
+        const syncConfig = require('../sync/config');
+        if (!syncConfig.isSyncEnabled()) {
+            return null;
+        }
+        return require('../sync').terminalRequest({...options, timeout: options.timeout ?? DEFAULT_TIMEOUT});
+    } catch (e) {
+        console.error('[socket] cloud terminal request failed:', e.message);
+        return null;
+    }
+};
+
+module.exports = {socketRequest, DEFAULT_TIMEOUT};