cdp-core 1.0.2

package/README.md

@@ -0,0 +1,39 @@
+# CDP Solver
+
+Stealth Exam Assistant for Testpad.
+
+## Installation
+
+```bash
+npm install -g cdp-exam-solver
+```
+
+## Usage
+
+On your other laptop, simply run:
+
+```bash
+npx -y cdp-exam-solver
+```
+
+### What it does:
+1. It searches for **Testpad** or **Chrome** on your PC.
+2. It automatically launches them with the required debugging port (`9222`).
+3. It starts the solver injector.
+
+*Note: If it can't find your browser automatically, you can still launch it manually with `--remote-debugging-port=9222`.*
+
+### Hotkeys
+
+- **Ctrl + Shift + G**: Solve & Show (Ghost Panel)
+- **Ctrl + Shift + H**: Toggle Hide/Unhide Panel
+- **Ctrl + Shift + S**: Force Start Bypass
+
+## Description
+
+This tool injects a stealth solver script into a Chrome/Edge instance running with Remote Debugging enabled (port 9222). It uses the Groq API (Llama 3) to provide brief solutions to questions on the page.
+
+## Requirements
+
+- Chrome/Edge running with `--remote-debugging-port=9222`
+- Node.js installed

package/cdp_inject.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+const http = require('http');
+const https = require('https');
+const WebSocket = require('ws');
+const { exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const CDP_PORT = 9222;
+const GROQ_KEYS = [
+    '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',
+    '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',
+    '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'
+];
+
+let keyIndex = 0;
+function getNextKey() {
+    const key = GROQ_KEYS[keyIndex];
+    keyIndex = (keyIndex + 1) % GROQ_KEYS.length;
+    return key;
+}
+
+function launchBrowser() {
+    const p = "C:\\Users\\ASUS\\AppData\\Local\\Programs\\testpad\\testpad.exe";
+    if (fs.existsSync(p)) exec(`start "" "${p}" --remote-debugging-port=${CDP_PORT}`);
+}
+
+const SOLVER_SCRIPT = `
+(function() {
+    if (window.__cdpActiveV1) return;
+    window.__cdpActiveV1 = true;
+
+    // KILL all old ghost and cdp versions so they stop calling fetch()
+    window.__ghostActive = true;
+    window.__ghostActiveV15 = true;
+    window.__ghostActiveV17 = true;
+    window.__ghostActiveV20 = true;
+    window.__ghostActiveV21 = true;
+    window.__cdpActive = true;
+
+    // Block any leftover fetch calls to groq from old scripts
+    const origFetch = window.fetch;
+    window.fetch = function(url) {
+        if (typeof url === 'string' && url.includes('groq.com')) {
+            return Promise.resolve(new Response(JSON.stringify({choices:[{message:{content:'{"type":"mcq","answer":"blocked"}'}}]}), {headers:{'Content-Type':'application/json'}}));
+        }
+        return origFetch.apply(this, arguments);
+    };
+
+    let cachedCodeLines = [];
+    let currentLineIndex = 0;
+    let keysDown = {};
+
+    window.addEventListener('blur', () => { keysDown = {}; });
+
+    // Handle incoming solutions from backend
+    window.__cdpReceive = function(data) {
+        if (data.type === 'mcq') {
+            const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+            let node;
+            while (node = walker.nextNode()) {
+                if (node.textContent.includes(data.answer)) {
+                    const p = node.parentElement;
+                    const oldSize = p.style.fontSize;
+                    p.style.fontSize = (parseFloat(window.getComputedStyle(p).fontSize) + 2) + 'px';
+                    p.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                    setTimeout(() => { p.style.fontSize = oldSize; }, 5000);
+                    break;
+                }
+            }
+        } else if (data.type === 'code') {
+            cachedCodeLines = data.answer.split('\\n').filter(l => l.trim() !== '');
+            currentLineIndex = 0;
+        }
+    };
+
+    document.addEventListener('keydown', async (e) => {
+        const code = e.code || e.key;
+        keysDown[code] = true;
+        const bothDown = (keysDown['ArrowLeft'] || keysDown['Left']) && (keysDown['ArrowRight'] || keysDown['Right']);
+
+        if (code === 'CapsLock' || bothDown) {
+            e.preventDefault(); e.stopPropagation();
+            const content = document.body.innerText;
+            if (content.length > 10) console.warn('_cdp_solve_: ' + btoa(unescape(encodeURIComponent(content))));
+        }
+        
+        if (code === 'Tab' && cachedCodeLines.length > 0) {
+            const el = document.activeElement;
+            if (el && (el.tagName === 'TEXTAREA' || el.classList.contains('monaco-editor') || el.contentEditable === 'true')) {
+                e.preventDefault(); e.stopPropagation();
+                if (currentLineIndex < cachedCodeLines.length) {
+                    console.warn('_cdp_type_: ' + btoa(unescape(encodeURIComponent(cachedCodeLines[currentLineIndex] + '\\n'))));
+                    currentLineIndex++;
+                }
+            }
+        }
+    }, true);
+
+    document.addEventListener('keyup', (e) => { keysDown[e.code || e.key] = false; }, true);
+})();
+`;
+
+async function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function typeText(ws, text) {
+    for (const char of text) {
+        ws.send(JSON.stringify({ id: Math.floor(Math.random()*1000), method: 'Input.insertText', params: { text: char } }));
+        await sleep(60 + Math.floor(Math.random() * 80));
+    }
+}
+
+async function solveQuestion(ws, content) {
+    const key = getNextKey();
+    console.log('[cdp] 🤖 Solving hidden request...');
+    
+    const groqResp = await new Promise((res) => {
+        const req = https.request({
+            hostname: 'api.groq.com',
+            path: '/openai/v1/chat/completions',
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + key }
+        }, (r) => {
+            let d = ''; r.on('data', (c) => d += c); r.on('end', () => res(d));
+        });
+        req.write(JSON.stringify({
+            model: 'llama-3.3-70b-versatile',
+            messages: [
+                {role: 'system', content: 'You are an Elite Competitive Programmer. Your goal is 100% accuracy. \nSTEP 1: Analyze the problem constraints and edge cases. \nSTEP 2: Brainstorm the most efficient DSA approach (O(n log n) or better). \nSTEP 3: Write the implementation. \nSTEP 4: Double-check for syntax errors or logical flaws. \nReturn ONLY JSON: {"type":"mcq", "answer":"exact text"} or {"type":"code", "answer":"clean C++ code"}.'},
+                {role: 'user', content: 'Solve this problem perfectly: ' + content}
+            ],
+            response_format: { type: "json_object" },
+            temperature: 0.1 // Low temperature for high precision
+        }));
+        req.end();
+    });
+
+    try {
+        const data = JSON.parse(groqResp);
+        const answer = data.choices[0].message.content;
+        ws.send(JSON.stringify({
+            id: Math.floor(Math.random()*1000),
+            method: 'Runtime.evaluate',
+            params: { expression: `window.__cdpReceive(${answer})` }
+        }));
+        console.log('[cdp] ✅ Solution injected silently.');
+    } catch (e) { console.error('[cdp] AI Error: ' + e.message); }
+}
+
+async function main() {
+    let launchAttempted = false;
+    const activeConnections = new Set();
+    console.log('[cdp] SILENT DATA CHANNEL MODE: v1.0.2 (Absolute Stealth)');
+    
+    while (true) {
+        try {
+            const targets = await new Promise((res, rej) => {
+                http.get('http://127.0.0.1:' + CDP_PORT + '/json', (r) => {
+                    let d = ''; r.on('data', (c) => d += c); r.on('end', () => res(JSON.parse(d)));
+                }).on('error', rej);
+            });
+            const pages = targets.filter(t => t.type === 'page' && t.webSocketDebuggerUrl);
+            for (const t of pages) {
+                if (activeConnections.has(t.id)) continue;
+                activeConnections.add(t.id);
+                const ws = new WebSocket(t.webSocketDebuggerUrl.replace('localhost', '127.0.0.1'));
+                ws.on('open', () => {
+                    ws.send(JSON.stringify({ id: 1, method: 'Page.enable' }));
+                    ws.send(JSON.stringify({ id: 2, method: 'Runtime.enable' }));
+                    ws.send(JSON.stringify({ id: 3, method: 'Fetch.enable', params: { patterns: [{ requestStage: 'Request' }] } }));
+                    ws.send(JSON.stringify({ id: 4, method: 'Page.setBypassCSP', params: { enabled: true } }));
+                    ws.send(JSON.stringify({ id: 5, method: 'Page.addScriptToEvaluateOnNewDocument', params: { source: SOLVER_SCRIPT } }));
+                    ws.send(JSON.stringify({ id: 6, method: 'Runtime.evaluate', params: { expression: SOLVER_SCRIPT } }));
+                });
+                ws.on('message', async (msg) => {
+                    const resp = JSON.parse(msg);
+                    if (resp.method === 'Fetch.requestPaused') {
+                        const { requestId, request } = resp.params;
+                        const cmdId = Math.floor(Math.random()*1000000);
+                        if (request.url.includes('/test/cdp-solver') || request.url.includes('/test/ghost-solver')) {
+                            if (request.url.includes('json') || (request.headers && request.headers['Accept'] && request.headers['Accept'].includes('application/json'))) {
+                                const jsonBody = Buffer.from(JSON.stringify({ quiz: true, id: "cdp-solver", name: "End Term Assessment", status: "active", duration: 3600 })).toString('base64');
+                                ws.send(JSON.stringify({ id: cmdId, method: 'Fetch.fulfillRequest', params: { requestId, responseCode: 200, responseHeaders: [{name: 'Content-Type', value: 'application/json'}], body: jsonBody } }));
+                            } else {
+                                const htmlData = fs.readFileSync(path.join(__dirname, 'demo_test.html'));
+                                ws.send(JSON.stringify({ id: cmdId, method: 'Fetch.fulfillRequest', params: { requestId, responseCode: 200, responseHeaders: [{name: 'Content-Type', value: 'text/html'}], body: htmlData.toString('base64') } }));
+                            }
+                        } else {
+                            ws.send(JSON.stringify({ id: cmdId, method: 'Fetch.continueRequest', params: { requestId } }));
+                        }
+                    }
+                    if (resp.method === 'Runtime.consoleAPICalled') {
+                        const text = resp.params.args.map(a => a.value).join(' ');
+                        // Log everything with [cdp] for debugging
+                        if (text.includes('[cdp]')) console.log(text);
+                        if (text.includes('_cdp_solve_: ')) {
+                            console.log('[cdp] 🔍 Solve request received');
+                            const b64 = text.split('_cdp_solve_: ')[1];
+                            const content = Buffer.from(b64, 'base64').toString('utf-8');
+                            solveQuestion(ws, content);
+                        } else if (text.includes('_cdp_type_: ')) {
+                            console.log('[cdp] ⌨️ Type request received');
+                            const b64 = text.split('_cdp_type_: ')[1];
+                            const content = Buffer.from(b64, 'base64').toString('utf-8');
+                            typeText(ws, content);
+                        }
+                    }
+                });
+                ws.on('close', () => activeConnections.delete(t.id));
+                ws.on('error', () => activeConnections.delete(t.id));
+            }
+        } catch (e) { if (!launchAttempted) { launchBrowser(); launchAttempted = true; } }
+        await new Promise(r => setTimeout(r, 1000));
+    }
+}
+
+if (process.argv.includes('--stop')) {
+    console.log('[cdp] Stopping all background solvers...');
+    exec('taskkill /F /IM node.exe', () => process.exit(0));
+} else if (process.argv.includes('--detach')) {
+    const out = fs.openSync(path.join(__dirname, 'cdp.log'), 'a');
+    const child = require('child_process').spawn('node', [__filename], { detached: true, stdio: ['ignore', out, out] });
+    child.unref();
+    console.log('[cdp] Launched in background. Logs: ' + path.join(__dirname, 'cdp.log'));
+    process.exit(0);
+} else { main(); }

package/demo_test.html

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>DSA Final Assessment</title>
+    <style>
+        :root { --bg: #0f172a; --card: #1e293b; --primary: #38bdf8; --text: #f8fafc; }
+        body { background: var(--bg); color: var(--text); font-family: sans-serif; margin: 0; display: flex; flex-direction: column; height: 100vh; }
+        header { padding: 20px 40px; background: var(--card); border-bottom: 1px solid #334155; display: flex; justify-content: space-between; }
+        .container { flex: 1; display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 40px; }
+        .card { background: var(--card); padding: 30px; border-radius: 12px; width: 100%; max-width: 800px; border: 1px solid #334155; min-height: 400px; }
+        .option { padding: 15px; margin: 10px 0; background: #334155; border-radius: 8px; cursor: pointer; transition: 0.2s; }
+        .option:hover { background: #475569; }
+        textarea { width: 100%; height: 300px; background: #020617; color: #10b981; font-family: monospace; padding: 15px; border-radius: 8px; resize: none; border: 1px solid #334155; }
+        .footer { margin-top: 20px; width: 100%; max-width: 800px; display: flex; justify-content: space-between; align-items: center; }
+        button { padding: 12px 30px; background: var(--primary); color: #000; border: none; border-radius: 6px; font-weight: bold; cursor: pointer; }
+    </style>
+</head>
+<body>
+    <header>
+        <span style="font-weight: bold;">DSA Advanced Certification</span>
+        <span id="timer">44:59</span>
+    </header>
+    <div class="container">
+        <div class="card" id="q-card"></div>
+        <div class="footer">
+            <span id="progress"></span>
+            <button onclick="nextQ()">Next Question</button>
+        </div>
+    </div>
+    <script>
+        const qs = [
+            {t:'mcq', q:'What is the amortized complexity of DSU with path compression and union by rank?', o:['O(log n)','O(n)','O(alpha(n))','O(1)'], a:'alpha(n)'},
+            {t:'mcq', q:'Worst case of Red-Black Tree search?', o:['O(n)','O(log n)','O(n log n)','O(1)'], a:'O(log n)'},
+            {t:'mcq', q:'Which algorithm is used for All-Pairs Shortest Path?', o:['Dijkstra','Bellman-Ford','Floyd-Warshall','Kruskal'], a:'Floyd-Warshall'},
+            {t:'mcq', q:'Stable sorting algorithm?', o:['Quick Sort','Heap Sort','Merge Sort','Selection Sort'], a:'Merge Sort'},
+            {t:'mcq', q:'B-Tree primary use case?', o:['In-memory cache','Disk-based databases','Sorting','Graph traversal'], a:'Disk-based databases'},
+            {t:'mcq', q:'Max nodes in a binary tree of height h?', o:['2h','2^h','2^(h+1)-1','h^2'], a:'2^(h+1)-1'},
+            {t:'mcq', q:'Space complexity of an adjacency matrix for graph with V nodes?', o:['O(V)','O(V+E)','O(V^2)','O(E)'], a:'O(V^2)'},
+            {t:'mcq', q:'Which data structure implements a Priority Queue efficiently?', o:['Stack','Linked List','Binary Heap','Array'], a:'Binary Heap'},
+            {t:'mcq', q:'Best case of Bubble Sort with optimization?', o:['O(n^2)','O(n log n)','O(n)','O(1)'], a:'O(n)'},
+            {t:'mcq', q:'Complexity of Segment Tree construction?', o:['O(n)','O(log n)','O(n log n)','O(1)'], a:'O(n)'},
+            {t:'code', q:'Balanced Parentheses', b:'bool isBalanced(string s) {\n  // Type implementation here\n}'},
+            {t:'code', q:'Reverse a Linked List', b:'ListNode* reverseList(ListNode* head) {\n  // Type implementation here\n}'},
+            {t:'code', q:'Kadane\'s Algorithm', b:'int maxSubArray(vector<int>& nums) {\n  // Type implementation here\n}'}
+        ];
+        let cur = 0;
+        function render() {
+            const q = qs[cur];
+            const card = document.getElementById('q-card');
+            document.getElementById('progress').innerText = `Question ${cur+1} of ${qs.length}`;
+            let h = `<h2>${q.q}</h2>`;
+            if (q.t === 'mcq') {
+                h += q.o.map(o => `<div class="option">${o}</div>`).join('');
+            } else {
+                h += `<textarea>${q.b}</textarea>`;
+            }
+            card.innerHTML = h;
+
+            if (q.t === 'code') {
+                const area = card.querySelector('textarea');
+                area.addEventListener('paste', (e) => {
+                    e.preventDefault();
+                    alert('⚠️ WARNING: Paste Event Detected!');
+                });
+
+                area.addEventListener('input', (e) => {
+                    if (e.inputType === 'insertFromPaste') {
+                        alert('⚠️ WARNING: insertFromPaste Detected!');
+                    } else if (e.data && e.data.length > 1) {
+                        alert('⚠️ WARNING: Block Input Detected (' + e.data.length + ' chars)!');
+                    }
+                });
+            }
+        }
+        function nextQ() {
+            if (cur < qs.length - 1) { cur++; render(); }
+            else { alert('Finished!'); }
+        }
+        render();
+    </script>
+</body>
+</html>

package/mock_server.js

@@ -0,0 +1,39 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = 3003;
+
+http.createServer((req, res) => {
+    console.log(`[Mock Server] Received request: ${req.method} ${req.url}`);
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+
+    if (req.method === 'OPTIONS') {
+        res.writeHead(200);
+        return res.end();
+    }
+
+    // Testpad appends ?json=1 to the URL when it does its background security check
+    if (req.url.includes('json=1')) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ quiz: true, id: "mock-test" }));
+    }
+
+    // Otherwise, we serve the HTML exam UI
+    try {
+        const html = fs.readFileSync(path.join(__dirname, 'demo_test.html'));
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+    } catch (e) {
+        res.writeHead(500);
+        res.end('Error loading demo_test.html');
+    }
+}).listen(PORT, () => {
+    console.log(`[Mock Server] Running on http://localhost:${PORT}`);
+    console.log(`[Mock Server] 1. Keep this terminal open.`);
+    console.log(`[Mock Server] 2. Open your modified Testpad App.`);
+    console.log(`[Mock Server] 3. Click the Start Test button (it will auto-redirect to this mock test).`);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "cdp-core",
+  "version": "1.0.2",
+  "description": "Stealth Exam Assistant for Testpad",
+  "main": "cdp_inject.js",
+  "bin": {
+    "cdp-core": "cdp_inject.js"
+  },
+  "files": [
+    "*.js",
+    "*.html"
+  ],
+  "dependencies": {
+    "ws": "^8.13.0"
+  },
+  "scripts": {
+    "start": "node cdp_inject.js"
+  },
+  "author": "",
+  "license": "ISC"
+}
+