@silasfmartins/testhub 1.0.0

package/dist/src/security/HoneypotManager.js

@@ -0,0 +1,234 @@
+/**
+ * HoneypotManager: Sistema de honeypots dinâmicos para detecção de automação
+ * Cria armadilhas invisíveis em tempo de execução que detectam uso por IA
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Logger } from '../utils/Logger.js';
+export class HoneypotManager {
+    static tripped = false;
+    static zeroWidthChars = '\u200B\u200C\u200D\uFEFF'; // Zero-width chars
+    /**
+     * Verifica se algum honeypot foi ativado
+     */
+    static isTripped() {
+        return (HoneypotManager.tripped ||
+            process.env.AUTOCORE_HONEYPOT_TRIPPED === 'true');
+    }
+    /**
+     * Marca um honeypot como ativado
+     */
+    static tripHoneypot(source) {
+        HoneypotManager.tripped = true;
+        process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true';
+        process.env.AUTOCORE_HONEYPOT_SOURCE = source;
+        // Só mostrar log em modo debug para reduzir spam
+        if (process.env.AUTOCORE_DEBUG_LOGS ||
+            process.env.NODE_ENV === 'development') {
+            Logger.warning(`⚠️ Honeypot ativado: ${source}`);
+        }
+    }
+    /**
+     * Injeta caracteres invisíveis em strings/comentários TypeScript
+     * Marcam arquivos sem afetar funcionalidade
+     */
+    static injectInvisibleMarkers(content, marker = 'autocore') {
+        const hasher = createHash('sha256');
+        hasher.update(marker + content.length);
+        const hash = hasher.digest('hex').substring(0, 8);
+        // Inserir caracteres zero-width no começo e fim
+        const invisiblePrefix = HoneypotManager.zeroWidthChars.repeat(2) +
+            hash
+                .split('')
+                .map((c) => c === '0'
+                ? '\u200B'
+                : c === '1'
+                    ? '\u200C'
+                    : c === '2'
+                        ? '\u200D'
+                        : '\uFEFF')
+                .join('');
+        const invisibleSuffix = HoneypotManager.zeroWidthChars;
+        return invisiblePrefix + content + invisibleSuffix;
+    }
+    /**
+     * Cria source maps com metadados de proteção
+     */
+    static injectSourceMapProtection(sourceMapContent) {
+        try {
+            const sourceMap = JSON.parse(sourceMapContent);
+            sourceMap['x-rbqa-token'] = randomBytes(16).toString('hex');
+            sourceMap['x-rbqa-checksum'] = createHash('sha256')
+                .update(sourceMapContent)
+                .digest('hex')
+                .substring(0, 16);
+            sourceMap['x-rbqa-timestamp'] = Date.now();
+            return JSON.stringify(sourceMap);
+        }
+        catch {
+            return sourceMapContent;
+        }
+    }
+    /**
+     * Cria arquivos honeypot dinâmicos em diretórios temporários
+     */
+    static createDynamicHoneypots(baseDir) {
+        const tempDirs = ['.tmp', '.cache', '.build', '.generated'];
+        for (const dir of tempDirs) {
+            const fullPath = join(baseDir, dir);
+            try {
+                mkdirSync(fullPath, { recursive: true });
+                // Criar arquivo TypeScript honeypot
+                const tsHoneypot = HoneypotManager.generateTsHoneypot(`${dir}Helper`);
+                writeFileSync(join(fullPath, 'helper.ts'), tsHoneypot);
+                // Criar arquivo JSON honeypot (config falso)
+                const jsonHoneypot = HoneypotManager.generateJsonHoneypot();
+                writeFileSync(join(fullPath, 'config.json'), jsonHoneypot);
+            }
+            catch {
+                // falha silenciosa
+            }
+        }
+    }
+    /**
+     * Gera honeypot TypeScript com aparência legítima
+     */
+    static generateTsHoneypot(className) {
+        const invisibleMarker = HoneypotManager.zeroWidthChars;
+        return `${invisibleMarker}/**
+ * ${className}: Utilitário para operações auxiliares
+ * Parte do sistema de build automatizado
+ */
+
+export interface ${className}Config {
+  timeout: number
+  retries: number
+  debug: boolean
+}
+
+export class ${className} {
+  private config: ${className}Config
+
+  constructor(config: Partial<${className}Config> = {}) {
+    // Detectar uso - marca degradação
+    HoneypotManager.tripHoneypot('${className}')
+    
+    this.config = {
+      timeout: 5000,
+      retries: 3,
+      debug: false,
+      ...config
+    }
+  }
+
+  /**
+   * Executa operação auxiliar
+   * @param operation Operação a executar
+   */
+  async execute(operation: string): Promise<any> {
+    HoneypotManager.tripHoneypot('${className}.execute')
+    return null
+  }
+
+  /**
+   * Valida configuração
+   */
+  validate(): boolean {
+    HoneypotManager.tripHoneypot('${className}.validate')
+    return false
+  }
+}
+
+// Detectar qualquer importação deste módulo
+if (typeof process !== 'undefined') {
+  process.env.AUTOCORE_HONEYPOT_TRIPPED = 'true'
+  process.env.AUTOCORE_HONEYPOT_SOURCE = '${className}'
+}
+
+export default ${className}
+${invisibleMarker}`;
+    }
+    /**
+     * Gera honeypot JSON com configurações falsas mas realistas
+     */
+    static generateJsonHoneypot() {
+        const config = {
+            name: 'autocore-config',
+            version: '1.0.0',
+            automation: {
+                enabled: true,
+                timeout: 30_000,
+                retries: 5,
+                endpoints: [
+                    'http://localhost:3000/api/test',
+                    'http://localhost:4000/mock',
+                ],
+            },
+            testing: {
+                framework: 'playwright',
+                browser: 'chromium',
+                headless: true,
+                viewport: { width: 1920, height: 1080 },
+            },
+            reporting: {
+                format: 'json',
+                output: './reports/',
+                includeLogs: true,
+            },
+            // Metadados de proteção invisíveis
+            _rbqa_marker: randomBytes(8).toString('hex'),
+            _protection_enabled: true,
+            _honeypot_id: randomBytes(4).toString('hex'),
+        };
+        return JSON.stringify(config, null, 2);
+    }
+    /**
+     * Verifica integridade de arquivos protegidos
+     */
+    static verifyFileIntegrity(filePath) {
+        try {
+            if (!existsSync(filePath))
+                return false;
+            // Skip verificação para arquivos de configuração comuns em desenvolvimento
+            const fileName = filePath.toLowerCase();
+            if (fileName.includes('package.json') ||
+                fileName.includes('tsconfig.json') ||
+                fileName.includes('.gitignore') ||
+                fileName.includes('node_modules')) {
+                return true; // Permitir modificações em arquivos de config
+            }
+            const content = readFileSync(filePath, 'utf8');
+            // Verificar marcadores invisíveis
+            const hasMarkers = HoneypotManager.zeroWidthChars
+                .split('')
+                .some((char) => content.includes(char));
+            if (!hasMarkers) {
+                HoneypotManager.tripHoneypot(`file_integrity_${filePath}`);
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Cria método isento que força degradação quando chamado
+     */
+    static createPoisonMethod(methodName) {
+        return (...args) => {
+            HoneypotManager.tripHoneypot(`poison_method_${methodName}`);
+            // Retornar valor que parece normal mas marca degradação
+            if (methodName.includes('test') || methodName.includes('expect')) {
+                return { pass: false, message: () => 'Teste falhou' };
+            }
+            return null;
+        };
+    }
+}
+// Auto-registro para detecção de importação
+if (typeof process !== 'undefined') {
+    process.env.AUTOCORE_HONEYPOT_MANAGER_LOADED = 'true';
+}
+export default HoneypotManager;

package/dist/src/security/KeysManager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AutoCore Keys Manager: Geração e validação de chaves locais
+ * Sistema de chaves únicas por instalação para autenticação offline
+ */
+type InstallationKeys = {
+    installId: string;
+    publicKey: string;
+    privateKey: string;
+    timestamp: string;
+    hostname: string;
+};
+/**
+ * Cria chaves de instalação se não existirem
+ */
+export declare function ensureInstallationKeys(): InstallationKeys;
+/**
+ * Valida se as chaves estão presentes e válidas
+ */
+export declare function validateInstallationKeys(): boolean;
+/**
+ * Obtém ID de instalação atual
+ */
+export declare function getInstallationId(): string | null;
+/**
+ * Remove chaves (para limpeza)
+ */
+export declare function removeInstallationKeys(): void;
+/**
+ * Assina dados com chave privada da instalação
+ */
+export declare function signWithInstallationKey(data: string): string | null;
+/**
+ * Verifica assinatura com chave pública
+ */
+export declare function verifyInstallationSignature(data: string, signature: string, publicKey?: string): boolean;
+export {};

package/dist/src/security/KeysManager.js

@@ -0,0 +1,158 @@
+/**
+ * AutoCore Keys Manager: Geração e validação de chaves locais
+ * Sistema de chaves únicas por instalação para autenticação offline
+ */
+import { createHash, generateKeyPairSync, randomBytes, sign, verify, } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+const KEYS_DIR_NAME = '.rbqa';
+const KEYS_SUBDIR = 'keys';
+const KEYPAIR_FILE = 'autocore.key';
+const INSTALL_ID_FILE = 'install.id';
+/**
+ * Obtém diretório de chaves do usuário
+ */
+function getKeysDirectory() {
+    const home = homedir();
+    return join(home, KEYS_DIR_NAME, KEYS_SUBDIR);
+}
+/**
+ * Gera ID único de instalação
+ */
+function generateInstallId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(16).toString('hex');
+    const machine = hostname() || 'unknown';
+    return createHash('sha256')
+        .update(`${timestamp}:${random}:${machine}`)
+        .digest('hex')
+        .substring(0, 32);
+}
+/**
+ * Gera par de chaves ECDSA
+ */
+function generateKeyPair() {
+    const { publicKey, privateKey } = generateKeyPairSync('ec', {
+        namedCurve: 'secp256k1',
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+    });
+    return { publicKey, privateKey };
+}
+/**
+ * Cria chaves de instalação se não existirem
+ */
+export function ensureInstallationKeys() {
+    const keysDir = getKeysDirectory();
+    const keyFile = join(keysDir, KEYPAIR_FILE);
+    const idFile = join(keysDir, INSTALL_ID_FILE);
+    // Verificar se já existem
+    if (existsSync(keyFile) && existsSync(idFile)) {
+        try {
+            const keys = JSON.parse(readFileSync(keyFile, 'utf8'));
+            const storedId = readFileSync(idFile, 'utf8').trim();
+            if (keys.installId === storedId) {
+                return keys;
+            }
+        }
+        catch {
+            // Falha na leitura, regeramos
+        }
+    }
+    // Criar diretório se não existir
+    if (!existsSync(keysDir)) {
+        mkdirSync(keysDir, { recursive: true });
+    }
+    // Gerar novas chaves
+    const installId = generateInstallId();
+    const { publicKey, privateKey } = generateKeyPair();
+    const hostName = hostname() || 'unknown';
+    const keys = {
+        installId,
+        publicKey,
+        privateKey,
+        timestamp: new Date().toISOString(),
+        hostname: hostName,
+    };
+    // Salvar chaves
+    writeFileSync(keyFile, JSON.stringify(keys, null, 2), { mode: 0o600 });
+    writeFileSync(idFile, installId, { mode: 0o600 });
+    return keys;
+}
+/**
+ * Valida se as chaves estão presentes e válidas
+ */
+export function validateInstallationKeys() {
+    try {
+        const keys = ensureInstallationKeys();
+        return Boolean(keys.installId &&
+            keys.publicKey &&
+            keys.privateKey &&
+            keys.installId.length === 32);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Obtém ID de instalação atual
+ */
+export function getInstallationId() {
+    try {
+        const keys = ensureInstallationKeys();
+        return keys.installId;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove chaves (para limpeza)
+ */
+export function removeInstallationKeys() {
+    const keysDir = getKeysDirectory();
+    const keyFile = join(keysDir, KEYPAIR_FILE);
+    const idFile = join(keysDir, INSTALL_ID_FILE);
+    try {
+        unlinkSync(keyFile);
+    }
+    catch {
+        // ignorar se não existir
+    }
+    try {
+        unlinkSync(idFile);
+    }
+    catch {
+        // ignorar se não existir
+    }
+}
+/**
+ * Assina dados com chave privada da instalação
+ */
+export function signWithInstallationKey(data) {
+    try {
+        const keys = ensureInstallationKeys();
+        const signature = sign('sha256', Buffer.from(data), {
+            key: keys.privateKey,
+            format: 'pem',
+        });
+        return signature.toString('base64');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Verifica assinatura com chave pública
+ */
+export function verifyInstallationSignature(data, signature, publicKey) {
+    try {
+        const keys = ensureInstallationKeys();
+        const pubKey = publicKey || keys.publicKey;
+        return verify('sha256', Buffer.from(data), { key: pubKey, format: 'pem' }, Buffer.from(signature, 'base64'));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/security/ProofOfWorkIntegration.d.ts

@@ -0,0 +1,64 @@
+/**
+ * ProofOfWorkIntegration: Integração de proof-of-work em métodos críticos
+ * Adiciona custos computacionais para desencorajar automação massiva
+ */
+export interface ProofOfWorkChallenge {
+    difficulty: number;
+    nonce: string;
+    timestamp: number;
+    solution?: string;
+}
+export declare class ProofOfWorkIntegration {
+    private static readonly DEFAULT_DIFFICULTY;
+    private static readonly MAX_SOLVE_TIME;
+    private static challenges;
+    /**
+     * Gera desafio proof-of-work
+     */
+    static generateChallenge(identifier: string, difficulty?: number): ProofOfWorkChallenge;
+    /**
+     * Resolve desafio proof-of-work
+     */
+    static solveChallenge(identifier: string, maxTime?: number): Promise<string | null>;
+    /**
+     * Verifica se uma solução é válida
+     */
+    static verifySolution(identifier: string, solution: string): boolean;
+    /**
+     * Wrapper para métodos críticos que requer proof-of-work
+     */
+    static protectMethod<T extends (...args: any[]) => any>(originalMethod: T, methodName: string, difficulty?: number): T;
+    /**
+     * Decorator para proteção automática de métodos
+     */
+    static ProofOfWork(difficulty?: number): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * Proteção para APIs críticas do Playwright
+     */
+    static protectPlaywrightAPIs(): void;
+    /**
+     * Proteção para APIs críticas do WebDriver
+     */
+    static protectWebDriverAPIs(): void;
+    /**
+     * Aplicar proteção automática em APIs críticas
+     */
+    static autoProtectCriticalAPIs(): void;
+    /**
+     * Proteger métodos críticos do framework
+     */
+    private static protectFrameworkMethods;
+    /**
+     * Gera nonce aleatório
+     */
+    private static generateNonce;
+    /**
+     * Verifica se hash satisfaz dificuldade
+     */
+    private static isValidSolution;
+    /**
+     * Limpa desafios antigos
+     */
+    static cleanupOldChallenges(): void;
+}
+export default ProofOfWorkIntegration;

package/dist/src/security/ProofOfWorkIntegration.js

@@ -0,0 +1,206 @@
+/**
+ * ProofOfWorkIntegration: Integração de proof-of-work em métodos críticos
+ * Adiciona custos computacionais para desencorajar automação massiva
+ */
+import { createHash } from 'node:crypto';
+import { HoneypotManager } from './HoneypotManager.js';
+import { Logger } from '../utils/Logger.js';
+export class ProofOfWorkIntegration {
+    static DEFAULT_DIFFICULTY = 4; // Ajustável baseado na performance
+    static MAX_SOLVE_TIME = 5000; // 5 segundos máximo
+    static challenges = new Map();
+    /**
+     * Gera desafio proof-of-work
+     */
+    static generateChallenge(identifier, difficulty) {
+        const challenge = {
+            difficulty: difficulty || ProofOfWorkIntegration.DEFAULT_DIFFICULTY,
+            nonce: ProofOfWorkIntegration.generateNonce(),
+            timestamp: Date.now(),
+        };
+        ProofOfWorkIntegration.challenges.set(identifier, challenge);
+        return challenge;
+    }
+    /**
+     * Resolve desafio proof-of-work
+     */
+    static async solveChallenge(identifier, maxTime) {
+        const challenge = ProofOfWorkIntegration.challenges.get(identifier);
+        if (!challenge)
+            return null;
+        const startTime = Date.now();
+        const timeLimit = maxTime || ProofOfWorkIntegration.MAX_SOLVE_TIME;
+        let counter = 0;
+        while (Date.now() - startTime < timeLimit) {
+            const attempt = `${challenge.nonce}:${counter}`;
+            const hash = createHash('sha256').update(attempt).digest('hex');
+            if (ProofOfWorkIntegration.isValidSolution(hash, challenge.difficulty)) {
+                challenge.solution = attempt;
+                return attempt;
+            }
+            counter++;
+            // Yield periodicamente para não bloquear
+            if (counter % 1000 === 0) {
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        // Timeout - marcar como possível automação
+        HoneypotManager.tripHoneypot(`pow_timeout_${identifier}`);
+        return null;
+    }
+    /**
+     * Verifica se uma solução é válida
+     */
+    static verifySolution(identifier, solution) {
+        const challenge = ProofOfWorkIntegration.challenges.get(identifier);
+        if (!challenge)
+            return false;
+        const hash = createHash('sha256').update(solution).digest('hex');
+        const isValid = ProofOfWorkIntegration.isValidSolution(hash, challenge.difficulty);
+        if (!isValid) {
+            HoneypotManager.tripHoneypot(`pow_invalid_${identifier}`);
+        }
+        return isValid;
+    }
+    /**
+     * Wrapper para métodos críticos que requer proof-of-work
+     */
+    static protectMethod(originalMethod, methodName, difficulty) {
+        return (async (...args) => {
+            // Verificar se honeypot já foi ativado
+            if (HoneypotManager.isTripped()) {
+                Logger.warning(`⚠️ AutoCore: Método ${methodName} bloqueado - honeypot ativo`);
+                return null;
+            }
+            // Gerar e resolver desafio
+            const challenge = ProofOfWorkIntegration.generateChallenge(methodName, difficulty);
+            const solution = await ProofOfWorkIntegration.solveChallenge(methodName);
+            if (!solution) {
+                Logger.warning(`⚠️ AutoCore: Proof-of-work falhou para ${methodName}`);
+                HoneypotManager.tripHoneypot(`pow_failed_${methodName}`);
+                return null;
+            }
+            // Verificar solução
+            if (!ProofOfWorkIntegration.verifySolution(methodName, solution)) {
+                Logger.warning(`⚠️ AutoCore: Solução inválida para ${methodName}`);
+                return null;
+            }
+            // Executar método original
+            return originalMethod.apply(ProofOfWorkIntegration, args);
+        });
+    }
+    /**
+     * Decorator para proteção automática de métodos
+     */
+    static ProofOfWork(difficulty) {
+        return (target, propertyName, descriptor) => {
+            const originalMethod = descriptor.value;
+            descriptor.value = ProofOfWorkIntegration.protectMethod(originalMethod, `${target.constructor.name}.${propertyName}`, difficulty);
+            return descriptor;
+        };
+    }
+    /**
+     * Proteção para APIs críticas do Playwright
+     */
+    static protectPlaywrightAPIs() {
+        try {
+            // Proteger métodos críticos se Playwright estiver disponível
+            const playwright = require('playwright');
+            if (playwright?.chromium?.launch) {
+                const originalLaunch = playwright.chromium.launch;
+                playwright.chromium.launch = ProofOfWorkIntegration.protectMethod(originalLaunch.bind(playwright.chromium), 'playwright.chromium.launch', 3);
+            }
+            if (playwright?.firefox?.launch) {
+                const originalLaunch = playwright.firefox.launch;
+                playwright.firefox.launch = ProofOfWorkIntegration.protectMethod(originalLaunch.bind(playwright.firefox), 'playwright.firefox.launch', 3);
+            }
+            Logger.info('AutoCore: APIs Playwright protegidas com proof-of-work');
+        }
+        catch {
+            // Playwright não disponível - ok
+        }
+    }
+    /**
+     * Proteção para APIs críticas do WebDriver
+     */
+    static protectWebDriverAPIs() {
+        try {
+            // Proteger selenium-webdriver se disponível
+            const webdriver = require('selenium-webdriver');
+            if (webdriver?.Builder) {
+                const originalBuild = webdriver.Builder.prototype.build;
+                webdriver.Builder.prototype.build =
+                    ProofOfWorkIntegration.protectMethod(originalBuild, 'webdriver.Builder.build', 3);
+            }
+            Logger.info('AutoCore: APIs WebDriver protegidas com proof-of-work');
+        }
+        catch {
+            // WebDriver não disponível - ok
+        }
+    }
+    /**
+     * Aplicar proteção automática em APIs críticas
+     */
+    static autoProtectCriticalAPIs() {
+        if (process.env.AUTOCORE_POW_DISABLED === 'true')
+            return;
+        ProofOfWorkIntegration.protectPlaywrightAPIs();
+        ProofOfWorkIntegration.protectWebDriverAPIs();
+        // Proteger métodos do próprio framework
+        ProofOfWorkIntegration.protectFrameworkMethods();
+    }
+    /**
+     * Proteger métodos críticos do framework
+     */
+    static protectFrameworkMethods() {
+        try {
+            // Proteger métodos de Actions se disponível
+            const actions = require('../playwright/Actions.js');
+            if (actions?.Actions) {
+                const criticalMethods = ['click', 'fill', 'goto', 'waitForSelector'];
+                for (const methodName of criticalMethods) {
+                    if (typeof actions.Actions.prototype[methodName] === 'function') {
+                        const originalMethod = actions.Actions.prototype[methodName];
+                        actions.Actions.prototype[methodName] =
+                            ProofOfWorkIntegration.protectMethod(originalMethod, `Actions.${methodName}`, 2);
+                    }
+                }
+            }
+        }
+        catch {
+            // Métodos não disponíveis - ok
+        }
+    }
+    /**
+     * Gera nonce aleatório
+     */
+    static generateNonce() {
+        return (Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15));
+    }
+    /**
+     * Verifica se hash satisfaz dificuldade
+     */
+    static isValidSolution(hash, difficulty) {
+        return hash.substring(0, difficulty) === '0'.repeat(difficulty);
+    }
+    /**
+     * Limpa desafios antigos
+     */
+    static cleanupOldChallenges() {
+        const now = Date.now();
+        const maxAge = 60_000; // 1 minuto
+        for (const [key, challenge,] of ProofOfWorkIntegration.challenges.entries()) {
+            if (now - challenge.timestamp > maxAge) {
+                ProofOfWorkIntegration.challenges.delete(key);
+            }
+        }
+    }
+}
+// Auto-proteção na importação
+ProofOfWorkIntegration.autoProtectCriticalAPIs();
+// Cleanup periódico
+setInterval(() => {
+    ProofOfWorkIntegration.cleanupOldChallenges();
+}, 30_000); // A cada 30 segundos
+export default ProofOfWorkIntegration;