Update server.js

server.js

@@ -1,6 +1,10 @@
+// server.js
 const express = require('express');
 const { v4: uuidv4 } = require('uuid');
 const crypto = require('crypto');
+const { exec } = require('child_process');
+const fs = require('fs').promises;
+const path = require('path');
 
 const app = express();
 const port = process.env.PORT || 3000;
@@ -10,129 +14,213 @@ app.use(express.json({ limit: '5mb' }));
 const challengeStore = {};
 const CHALLENGE_EXPIRY_MS = 5 * 60 * 1000;
 
+// Обновленный OCR_CHAR_SET
+const OCR_CHAR_SET = "ABCDEFGHJKMNPQRSTUVWXYZ2345689"; // Без 0, O, I, 1, L, 7 (7 похожа на 1)
+const OCR_CHALLENGE_LENGTH = 6;
+
+const WEBGL_CHALLENGE_COLORS = [
+    { name: "red", rgb: [1.0, 0.0, 0.0] }, { name: "green", rgb: [0.0, 1.0, 0.0] },
+    { name: "blue", rgb: [0.0, 0.0, 1.0] }, { name: "yellow", rgb: [1.0, 1.0, 0.0] },
+    { name: "magenta", rgb: [1.0, 0.0, 1.0] }, { name: "cyan", rgb: [0.0, 1.0, 1.0] }
+];
+
 app.use((req, res, next) => {
     res.header('Access-Control-Allow-Origin', '*');
     res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
     res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    if (req.method === 'OPTIONS') {
-        return res.sendStatus(200);
-    }
+    if (req.method === 'OPTIONS') return res.sendStatus(200);
     next();
 });
 
+async function recognizeTextWithTesseract(imageDataUrl) {
+    if (!imageDataUrl || !imageDataUrl.startsWith('data:image/png;base64,')) return null;
+    const base64Data = imageDataUrl.replace(/^data:image\/png;base64,/, "");
+    const tempImageFileName = `temp_ocr_image_${uuidv4()}.png`;
+    const tempImagePath = path.join(__dirname, tempImageFileName);
+    
+    try {
+        await fs.writeFile(tempImagePath, base64Data, 'base64');
+        // Используем обновленный whitelist
+        const tesseractConfig = `-c tessedit_char_whitelist=${OCR_CHAR_SET}`; 
+        return new Promise((resolve, reject) => {
+            // --psm 7: Treat the image as a single text line.
+            // --psm 8: Treat the image as a single word. (Может быть лучше для коротких строк)
+            // --psm 10: Treat the image as a single character.
+            exec(`tesseract ${tempImagePath} stdout ${tesseractConfig} -l eng --psm 8`, (error, stdout, stderr) => {
+                if (error) {
+                    console.error(`Tesseract error: ${error.message} (stderr: ${stderr})`);
+                    return reject(new Error(`Tesseract execution failed`));
+                }
+                resolve(stdout.trim().replace(new RegExp(`[^${OCR_CHAR_SET}]`, 'g'), '')); // Очищаем строго по OCR_CHAR_SET
+            });
+        });
+    } catch (err) {
+        console.error("Error in Tesseract processing:", err);
+        return null;
+    } finally {
+        try { await fs.unlink(tempImagePath); } catch (e) { /* ignore */ }
+    }
+}
+
 app.get('/api/challenge', (req, res) => {
-    const token = uuidv4();
-    const expiresAt = Date.now() + CHALLENGE_EXPIRY_MS;
-    challengeStore[token] = { issuedAt: Date.now(), expiresAt, used: false };
-    res.json({ challengeToken: token });
-});
+    const sessionToken = uuidv4();
+    let ocrChallengeString = "";
+    for (let i = 0; i < OCR_CHALLENGE_LENGTH; i++) {
+        ocrChallengeString += OCR_CHAR_SET[Math.floor(Math.random() * OCR_CHAR_SET.length)];
+    }
+    const webglChallengeColor = WEBGL_CHALLENGE_COLORS[Math.floor(Math.random() * WEBGL_CHALLENGE_COLORS.length)];
 
-function sha256(data) {
-    return crypto.createHash('sha256').update(data).digest('hex');
-}
+    challengeStore[sessionToken] = {
+        issuedAt: Date.now(), expiresAt: Date.now() + CHALLENGE_EXPIRY_MS, used: false, ip: req.ip,
+        expectedOcrText: ocrChallengeString,
+        expectedWebglColorName: webglChallengeColor.name, expectedWebglColorRgb: webglChallengeColor.rgb
+    };
+    res.json({
+        sessionToken: sessionToken, ocrChallengeText: ocrChallengeString,
+        webglChallengeColor: webglChallengeColor.rgb,
+    });
+});
 
-app.post('/api/check', (req, res) => {
+app.post('/api/check', async (req, res) => {
     const clientData = req.body;
-    let score = 100;
+    let score = 100; // Начинаем с идеального счета
     let verdict = "Не определено";
     const reasons = [];
+    let isLikelyBot = false; // Флаг для явного определения бота
+
+    const { sessionToken, ocrCanvasDataUrl, webglChallengeResult, navigatorInfo, performanceTimings } = clientData;
+    let challengeSessionValid = false;
+    let serverChallengeDetails = null;
+
+    // 1. Проверка сессионного токена (КРИТИЧНО)
+    if (!sessionToken) { score = 0; reasons.push("FATAL: Отсутствует сессионный токен."); isLikelyBot = true; }
+    else if (!challengeStore[sessionToken]) { score = 0; reasons.push("FATAL: Неизвестный сессионный токен."); isLikelyBot = true; }
+    else if (challengeStore[sessionToken].used) { score = 0; reasons.push("FATAL: Сессионный токен уже был использован."); isLikelyBot = true; }
+    else if (Date.now() > challengeStore[sessionToken].expiresAt) { score = 0; reasons.push("FATAL: Сессионный токен истек."); isLikelyBot = true; }
+    else {
+        serverChallengeDetails = challengeStore[sessionToken];
+        challengeSessionValid = true;
+        reasons.push("OK: Сессионный токен валиден.");
+    }
 
-    const { usedChallengeToken, canvasDataUrl } = clientData;
-    let canvasCheckPassed = false;
-
-    if (!usedChallengeToken) {
-        score -= 90;
-        reasons.push("Отсутствует challenge токен.");
-    } else if (!challengeStore[usedChallengeToken]) {
-        score -= 90;
-        reasons.push("Неизвестный challenge токен.");
-    } else if (challengeStore[usedChallengeToken].used) {
-        score -= 90;
-        reasons.push("Challenge токен уже был использован.");
-    } else if (Date.now() > challengeStore[usedChallengeToken].expiresAt) {
-        score -= 90;
-        reasons.push("Challenge токен истек.");
-    } else {
-        challengeStore[usedChallengeToken].used = true;
-        canvasCheckPassed = true;
-        reasons.push("Challenge токен валиден.");
-
-        if (!canvasDataUrl || !canvasDataUrl.startsWith('data:image/png;base64,')) {
-            score -= 20;
-            reasons.push("Canvas data URL отсутствует или имеет неверный формат.");
-            canvasCheckPassed = false;
+    // 2. OCR Проверка Canvas (КРИТИЧНО, если токен валиден)
+    if (challengeSessionValid) {
+        if (!ocrCanvasDataUrl || !ocrCanvasDataUrl.startsWith('data:image/png;base64,') || ocrCanvasDataUrl.length < 300) { // Немного увеличил мин. длину
+            score -= 70; reasons.push("CRITICAL_OCR: Canvas для OCR отсутствует, невалиден или слишком мал."); isLikelyBot = true;
         } else {
-            reasons.push("Canvas data URL присутствует.");
+            const recognizedText = await recognizeTextWithTesseract(ocrCanvasDataUrl);
+            const expectedText = serverChallengeDetails.expectedOcrText;
+            if (recognizedText !== null) {
+                if (recognizedText === expectedText) {
+                    score = Math.min(score + 5, 100); // Небольшой бонус, но не выше 100
+                    reasons.push(`OK_OCR: Tesseract успешно распознал текст: "${recognizedText}".`);
+                } else {
+                    score -= 80; reasons.push(`CRITICAL_OCR: Tesseract распознал текст НЕВЕРНО. Ожидалось: "${expectedText}", Распознано: "${recognizedText}".`); isLikelyBot = true;
+                }
+            } else { score -= 75; reasons.push("CRITICAL_OCR: Ошибка выполнения Tesseract OCR на сервере."); isLikelyBot = true; }
         }
     }
 
-    if (!canvasCheckPassed && score > 10) {
-        score = Math.min(score, 10);
-        reasons.push("Основная проверка Canvas по токену не пройдена, сильно снижен рейтинг.");
-    }
-
-    if (clientData.webglPixelSample) {
-        const sample = clientData.webglPixelSample;
-        if (sample.length >= 4 && sample.slice(0, 4).every(p => p === 0)) {
-            score -= 10;
-            reasons.push("WebGL: Считанные пиксели нулевые, возможно, рендеринг не удался или подделан.");
-        } else if (sample.length > 0) {
-            score += 5;
-            reasons.push("WebGL: Данные о пикселях присутствуют.");
+    // 3. WebGL Challenge Проверка (ВАЖНО, если токен валиден)
+    if (challengeSessionValid && webglChallengeResult) {
+        const expectedRgb = serverChallengeDetails.expectedWebglColorRgb;
+        // Alpha может быть не 1.0 если фон прозрачный, но цвет треугольника должен быть с alpha 1.0
+        const expectedPixel = [Math.round(expectedRgb[0]*255), Math.round(expectedRgb[1]*255), Math.round(expectedRgb[2]*255)]; // Сравниваем только RGB
+        
+        if (webglChallengeResult.pixels && webglChallengeResult.pixels.length >= 3) {
+            const clientPixel = webglChallengeResult.pixels.slice(0,3);
+            // Более строгий допуск для цвета
+            let match = clientPixel.every((val, idx) => Math.abs(val - expectedPixel[idx]) <= 5); 
+            if (match) { score = Math.min(score + 3, 100); reasons.push(`OK_WEBGL: WebGL пиксели соответствуют цвету "${serverChallengeDetails.expectedWebglColorName}".`);}
+            else { score -= 35; reasons.push(`FAIL_WEBGL: WebGL пиксели Н�� соответствуют цвету "${serverChallengeDetails.expectedWebglColorName}". Ожидались ~[${expectedPixel.join(',')}], получены [${clientPixel.join(',')}].`); isLikelyBot = true; }
+        } else { score -= 30; reasons.push("FAIL_WEBGL: Данные о пикселях WebGL challenge отсутствуют или неполные."); isLikelyBot = true; }
+
+        const ua = navigatorInfo?.userAgent?.toLowerCase() || "";
+        const renderer = webglChallengeResult.renderer?.toLowerCase() || "";
+        const vendor = webglChallengeResult.vendor?.toLowerCase() || "";
+        if (renderer.includes("swiftshader") || renderer.includes("llvmpipe")) { // Явные признаки программного рендеринга
+            score -= 25; reasons.push("SUSPICIOUS_WEBGL: Обнаружен программный WebGL рендерер (SwiftShader/LLVMpipe)."); isLikelyBot = true;
         }
-    } else if (clientData.webglError) {
-        score -= 5;
-        reasons.push(`WebGL: Ошибка инициализации/работы (${clientData.webglError}).`);
-    } else {
-        reasons.push("WebGL: Данные о пикселях отсутствуют.");
-    }
+        // ... (другие проверки renderer/vendor можно добавить) ...
 
-    if (clientData.navigator?.webdriver === true) {
-        score -= 50;
-        reasons.push("Обнаружен navigator.webdriver=true.");
+    } else if (challengeSessionValid && !webglChallengeResult?.error) { 
+        score -= 25; reasons.push("FAIL_WEBGL: Данные WebGL challenge отсутствуют, хотя ошибок на клиенте не заявлено."); isLikelyBot = true;
+    } else if (webglChallengeResult?.error) {
+        score -= 15; reasons.push(`WARN_WEBGL: Ошибка WebGL на клиенте: ${webglChallengeResult.error}.`);
     }
 
-    if (clientData.automationVars && Object.keys(clientData.automationVars).length > 0) {
-        score -= 30;
-        reasons.push(`Обнаружены переменные автоматизации: ${Object.keys(clientData.automationVars).join(', ')}.`);
-    }
 
-    const ua = clientData.navigator?.userAgent || "";
-    if (ua.toLowerCase().includes("bot") || ua.toLowerCase().includes("spider") || ua.toLowerCase().includes("headless")) {
-        if (!ua.toLowerCase().includes("headlesschrome")) {
-             score -= 20;
-             reasons.push("Подозрительный User-Agent.");
+    // 4. Анализ NavigatorInfo (ВТОРИЧНЫЕ ПРИЗНАКИ)
+    if (navigatorInfo) {
+        if (navigatorInfo.webdriver === true) { score -= 60; reasons.push("FATAL_NAV: navigator.webdriver=true."); isLikelyBot = true; }
+        
+        if (!navigatorInfo.userAgent || navigatorInfo.userAgent === "") { score -= 20; reasons.push("FAIL_NAV: User-Agent пустой."); isLikelyBot = true; }
+        else if (navigatorInfo.userAgent.toLowerCase().includes("bot") || 
+                 navigatorInfo.userAgent.toLowerCase().includes("spider") || 
+                 navigatorInfo.userAgent.toLowerCase().includes("headless")) {
+            if (!navigatorInfo.userAgent.toLowerCase().includes("headlesschrome")) { // HeadlessChrome может быть для тестов
+                score -= 40; reasons.push("FAIL_NAV: User-Agent идентифицирован как бот/паук/headless."); isLikelyBot = true;
+            }
+        }
+        // Проверка на несоответствие платформы и User-Agent (очень упрощенно)
+        const platform = navigatorInfo.platform?.toLowerCase() || "";
+        const ua = navigatorInfo.userAgent?.toLowerCase() || "";
+        if (platform.includes("win") && (ua.includes("linux") || ua.includes("mac os"))) {
+            score -= 15; reasons.push("SUSPICIOUS_NAV: Несоответствие Platform (Win) и User-Agent (Linux/Mac).");
+        }
+        if ((platform.includes("linux") || platform.includes("mac")) && ua.includes("windows nt")) {
+            score -= 15; reasons.push("SUSPICIOUS_NAV: Несоответствие Platform (Linux/Mac) и User-Agent (Win).");
         }
-    }
 
-    score = Math.max(0, Math.min(score, 100));
+    } else { score -= 10; reasons.push("WARN_NAV: Информация Navigator отсутствует."); }
 
-    let threshold = canvasCheckPassed ? 50 : 85;
+    // 5. Анализ PerformanceTimings (ВТОРИЧНЫЕ ПРИЗНАКИ)
+    if (performanceTimings) {
+        const { dataCollectionTime, ocrCanvasRenderTime, webglRenderTime } = performanceTimings;
+        // Сделаем проверки строже
+        if (typeof dataCollectionTime === 'number' && dataCollectionTime < 5 && challengeSessionValid) { 
+            score -= 20; reasons.push("SUSPICIOUS_PERF: Аномально быстрое время сбора данных (<5ms)."); isLikelyBot = true;
+        }
+        if (typeof ocrCanvasRenderTime === 'number' && ocrCanvasRenderTime < 1 && ocrCanvasDataUrl && challengeSessionValid) { 
+            score -= 25; reasons.push("SUSPICIOUS_PERF: Аномально быстрое время рендера OCR Canvas (<1ms)."); isLikelyBot = true;
+        }
+        if (typeof webglRenderTime === 'number' && webglRenderTime < 1 && webglChallengeResult?.pixels && challengeSessionValid) { 
+            score -= 25; reasons.push("SUSPICIOUS_PERF: Аномально быстрое время рендера WebGL (<1ms)."); isLikelyBot = true;
+        }
+    } else { score -= 5; reasons.push("WARN_PERF: Данные о времени выполнения отсутствуют."); }
 
-    if (score >= threshold) {
-        verdict = "Разрешено (Allow)";
+    // 6. Переменные автоматизации (КРИТИЧНО)
+    if (clientData.automationVars && Object.keys(clientData.automationVars).length > 0) {
+        score -= 70; reasons.push(`FATAL_AUTO: Обнаружены переменные автоматизации: ${Object.keys(clientData.automationVars).join(', ')}.`); isLikelyBot = true;
+    }
+    
+    score = Math.max(0, Math.min(score, 100)); // Окончательный счет
+
+    // --- Вынесение вердикта ---
+    // Если любая из FATAL или CRITICAL проверок провалена, или isLikelyBot=true, то это почти всегда блок.
+    // Порог для "Разрешено" должен быть высоким.
+    let blockThreshold = 30; // Если score упал ниже этого, точно блок.
+    let allowThreshold = 85; // Нужно набрать столько для разрешения.
+
+    if (isLikelyBot || score < blockThreshold) {
+        verdict = "Блокировать (Bot Detected)";
+        if (!isLikelyBot) reasons.push("OVERRIDE: Блокировка из-за низкого общего балла.");
+    } else if (score >= allowThreshold && challengeSessionValid) { // Дополнительно проверяем challengeSessionValid
+        verdict = "Разрешено (Human Likely)";
+        if (serverChallengeDetails) serverChallengeDetails.used = true; // Помечаем токен как использованный
     } else {
-        verdict = "Блокировать (Block)";
+        verdict = "Блокировать (Suspicious)"; // Если не бот, но и не прошел порог
+        reasons.push("INFO: Недостаточный балл для разрешения, но не определен как явный бот.");
     }
 
-    console.log(`Check for token ${usedChallengeToken}: Score=${score}, Verdict=${verdict}`);
-    console.log(`Client User-Agent: ${clientData.navigator?.userAgent}`);
+    // Логирование
+    console.log(`[${new Date().toISOString()}] Check: Token=${sessionToken || 'N/A'}, Score=${score}, Verdict=${verdict}, IP=${req.ip}, LikelyBot=${isLikelyBot}`);
+    if (reasons.length > 0) console.log(`Reasons: ${reasons.join(' | ')}`);
     
-    res.json({
-        verdictText: verdict,
-        score: score,
-        reasons: reasons,
-        receivedData: {
-            usedChallengeToken: clientData.usedChallengeToken,
-            canvasDataUrlLength: clientData.canvasDataUrl?.length,
-            webglPixelSampleStart: clientData.webglPixelSample?.slice(0,8),
-            webdriver: clientData.navigator?.webdriver,
-            userAgent: clientData.navigator?.userAgent
-        }
-    });
+    res.json({ verdictText: verdict, score: score, reasons: reasons, isBot: isLikelyBot });
 });
 
-setInterval(() => {
+setInterval(() => { /* ... (очистка токенов как раньше) ... */
     const now = Date.now();
     for (const token in challengeStore) {
         if (challengeStore[token].expiresAt < now || (challengeStore[token].used && (now - challengeStore[token].issuedAt > CHALLENGE_EXPIRY_MS * 2))) {
@@ -142,5 +230,5 @@ setInterval(() => {
 }, 60 * 1000);
 
 app.listen(port, () => {
-    console.log(`Browser check API server listening on port ${port}`);
+    console.log(`Strict Browser check API server listening on port ${port}`);
 });