Forgets

Dockerfile

@@ -0,0 +1,33 @@
+FROM node:20-bullseye
+
+# Install ALL dependencies untuk OpenCV + Chrome
+RUN apt update && apt install -y \
+    wget gnupg ca-certificates xvfb \
+    fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 \
+    libatk1.0-0 libxss1 libnss3 libxcomposite1 libxdamage1 libxrandr2 libgbm1 \
+    python3 make g++ pkg-config cmake \
+    libcairo2-dev libjpeg-dev libpng-dev libgif-dev librsvg2-dev \
+    libopencv-dev \
+    && wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb \
+    && apt install -y ./google-chrome-stable_current_amd64.deb \
+    && rm google-chrome-stable_current_amd64.deb \
+    && apt clean
+
+WORKDIR /app
+
+RUN mkdir -p /app/endpoints && \
+    mkdir -p /app/cache
+
+COPY package*.json ./
+
+# Install OpenCV dengan build from source
+RUN npm install
+
+COPY . .
+
+EXPOSE 7860
+
+CMD rm -f /tmp/.X99-lock && \
+    Xvfb :99 -screen 0 1024x768x24 & \
+    export DISPLAY=:99 && \
+    npm start

README.md

@@ -1,12 +1,12 @@
 ---
-title: '1'
-emoji: 🐨
+title: Khususan Indra
+emoji: 🤣
 colorFrom: blue
-colorTo: red
-sdk: gradio
-sdk_version: 6.13.0
-app_file: app.py
-pinned: false
+colorTo: yellow
+sdk: docker
+sdk_version: 6.0.0
+license: apache-2.0
+short_description: antibot ai
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

api_test.py

@@ -0,0 +1,26 @@
+import asyncio
+import httpx
+
+async def main():
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp1 = await client.post(
+            "http://localhost:8080/cloudflare",
+            json={
+                "domain": "https://olamovies.watch/generate",
+                "mode": "iuam",
+            },
+        )
+        print(resp1.json())
+
+        resp2 = await client.post(
+            "http://localhost:8080/cloudflare",
+            json={
+                "domain": "https://lksfy.com/",
+                "siteKey": "0x4AAAAAAA49NnPZwQijgRoi",
+                "mode": "turnstile",
+            },
+        )
+        print(resp2.json())
+
+if __name__ == "__main__":
+    asyncio.run(main())

cache/cache.json

@@ -0,0 +1,10 @@
+{
+  "{\"domain\":\"https://v2links.org\",\"mode\":\"iuam\"}": {
+    "timestamp": 1758616160392,
+    "value": {
+      "cf_clearance": "qqs5f4MpFMgA0v78Qmh_HYDWoKhbwqlQ57bTW5KeIr8-1758616161-1.2.1.1-D5PdpmheHl.26ssIRKQBsXzPtPPkSXntEZ_H9FUJVt7MMTS_BEE8iH.E48MDzKtFBLwZqRYxE_1GLo1gj3ChXrwatOGEJcmGRUwavy2qvGgUPizn7qufd.sW0ULfhaRO7Gz_H_eO1TU3iEqCzltEUDNk0SviKRFkF8ozbvJ91MW_qmO.qrjQorbu_jxcgJv5BHs6rTNOitWtVDAmYMDukASq0viHXIUAIvTM.LIfQ88",
+      "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+      "elapsed_time": 5.028
+    }
+  }
+}

endpoints/antibot.js

@@ -0,0 +1,139 @@
+const fs = require('fs');
+const path = require('path');
+// Pastikeun file imageProcessor.js aya dina folder anu sarua
+const { extractTextFromImage } = require('./imageProcessor');
+
+// --- KONFIGURASI & MAPPING ---
+const NUMBER_WORDS = {
+  'nol': '0', 'satu': '1', 'dua': '2', 'tiga': '3', 'empat': '4', 'lima': '5',
+  'enam': '6', 'tujuh': '7', 'delapan': '8', 'sembilan': '9', 'sepuluh': '10',
+  'sebelas': '11', 'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5',
+  'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
+  'zero': '0', 'eleven': '11', 'twelve': '12'
+};
+
+const LEET_MAP = {
+  '4': 'a', '@': 'a', '8': 'b', '3': 'e', '6': 'g', '1': 'i', '!': 'i', '0': 'o',
+  '5': 's', '$': 's', '7': 't', '+': 't', '2': 'z'
+};
+
+// --- FUNGSI HELPER ---
+function safeString(s) { return (s || '').toString(); }
+
+function normalizeText(text) {
+  let normalized = safeString(text).normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+  normalized = normalized.toLowerCase();
+  
+  // Apply Leet Map (anti-deteksi karakter anéh)
+  let leetOut = '';
+  for (const ch of normalized) { leetOut += (LEET_MAP[ch] !== undefined) ? LEET_MAP[ch] : ch; }
+  normalized = leetOut;
+  
+  // Beberesih karakter non-alfanumerik
+  normalized = normalized.replace(/[^a-z0-9\s]/g, ' ').replace(/\s+/g, ' ').trim();
+  
+  // Mapping kecap angka jadi digit
+  const tokens = normalized.split(/\s+/);
+  return tokens.map(t => NUMBER_WORDS[t] !== undefined ? NUMBER_WORDS[t] : t).join(' ');
+}
+
+function levenshtein(a = '', b = '') {
+  const alen = a.length, blen = b.length;
+  if (alen === 0) return blen;
+  if (blen === 0) return alen;
+  const matrix = Array.from({ length: alen + 1 }, () => new Array(blen + 1));
+  for (let i = 0; i <= alen; i++) matrix[i][0] = i;
+  for (let j = 0; j <= blen; j++) matrix[0][j] = j;
+  for (let i = 1; i <= alen; i++) {
+    for (let j = 1; j <= blen; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[alen][blen];
+}
+
+function similarity(a, b) {
+  a = normalizeText(a); b = normalizeText(b);
+  if (a === b || a.includes(b) || b.includes(a)) return 1;
+  const dist = levenshtein(a, b);
+  const maxLen = Math.max(a.length, b.length);
+  return maxLen === 0 ? 1 : 1 - (dist / maxLen);
+}
+
+// --- LOGIKA UTAMA SOLVER ---
+async function solve(data) {
+  try {
+    console.log("🛠️  Processing Antibot Challenge...");
+    
+    const mainBuffer = Buffer.from(data.main, 'base64');
+    const botsBuffers = data.bots.map(b => Buffer.from(b, 'base64'));
+
+    // OCR Gambar Instruksi Utama
+    const mainOCR = await extractTextFromImage(mainBuffer);
+    let rawMain = (mainOCR.response || "").toLowerCase();
+    console.log("🎯 Raw Instruction:", rawMain);
+
+    // --- BAGIAN TARGET NU DIUBAH (LEMBUT TAPI TEGAS) ---
+    const targets = rawMain
+      .replace(/please\s*click\s*on\s*the\s*anti-bot\s*links\s*in\s*the\s*following\s*order/gi, '')
+      .replace(/[:.,|+&-]/g, ' ') // Ganti karakter separator ku spasi
+      .split(/\s+/) 
+      .filter(t => t.length > 0 && t !== 'and');
+
+    console.log("🔍 Cleaned Targets:", targets);
+
+    // OCR Kabéh Gambar Pilihan (Bots)
+    const botResults = [];
+    for (let i = 0; i < botsBuffers.length; i++) {
+      const res = await extractTextFromImage(botsBuffers[i]);
+      botResults.push({
+        index: (i + 1).toString(), 
+        text: normalizeText(res.response || "")
+      });
+      console.log(`🖼️  Bot ${i+1} OCR: "${res.response}"`);
+    }
+
+    // Matching Strategy
+    let finalOrder = [];
+    let usedIndices = new Set();
+
+    for (const target of targets) {
+      let bestMatch = { index: null, score: -1 };
+      
+      for (const bot of botResults) {
+        if (usedIndices.has(bot.index)) continue;
+        
+        const score = similarity(bot.text, target);
+        if (score > bestMatch.score) {
+          bestMatch = { index: bot.index, score: score };
+        }
+      }
+
+      // Skor minimal 0.3 (30%) bisi OCR-na rada burem
+      if (bestMatch.index && bestMatch.score > 0.3) {
+        finalOrder.push(bestMatch.index);
+        usedIndices.add(bestMatch.index);
+      }
+    }
+
+    // Fallback: Mun aya bot nu can kapaéh, asupkeun dumasar urutan
+    if (finalOrder.length < botsBuffers.length) {
+       botResults.forEach(b => {
+         if(!usedIndices.has(b.index)) finalOrder.push(b.index);
+       });
+    }
+
+    // Pastikeun ngan ngirim jumlah nu sarua jeung bot nu aya
+    finalOrder = finalOrder.slice(0, botsBuffers.length);
+
+    console.log("✅ Final Solution:", finalOrder.join(", "));
+    return { status: "Success", result: finalOrder };
+
+  } catch (error) {
+    console.error("❌ Solver Error:", error.message);
+    return { status: "Error", message: error.message, result: ["1", "2", "3"] };
+  }
+}
+
+module.exports = solve;

endpoints/cloudflare.js

@@ -0,0 +1,79 @@
+async function cloudflare(data, page) {
+  return new Promise(async (resolve, reject) => {
+    if (!data.domain) return reject(new Error("Missing domain parameter"))
+
+    const startTime = Date.now()
+    let isResolved = false
+    let userAgent = null
+
+    const cl = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true
+        const elapsedTime = (Date.now() - startTime) / 1000
+        resolve({
+          cf_clearance: null,
+          user_agent: userAgent,
+          elapsed_time: elapsedTime,
+        })
+      }
+    }, 20000)
+
+    try {
+      if (data.proxy?.username && data.proxy?.password) {
+        await page.authenticate({
+          username: data.proxy.username,
+          password: data.proxy.password,
+        })
+      }
+
+      page.removeAllListeners("request")
+      page.removeAllListeners("response")
+      await page.setRequestInterception(true)
+
+      page.on("request", async (req) => {
+        try {
+          await req.continue()
+        } catch (_) {}
+      })
+
+      page.on("response", async (res) => {
+        try {
+          const url = res.url()
+          if (url.includes("/cdn-cgi/challenge-platform/")) {
+            const headers = res.headers()
+            if (headers["set-cookie"]) {
+              const match = headers["set-cookie"].match(/cf_clearance=([^;]+)/)
+              if (match) {
+                const cf_clearance = match[1]
+                const userAgent = (await res.request().headers())["user-agent"]
+                const elapsedTime = (Date.now() - startTime) / 1000
+
+                if (!isResolved) {
+                  isResolved = true
+                  clearTimeout(cl)
+
+                  resolve({
+                    cf_clearance,
+                    user_agent: userAgent,
+                    elapsed_time: elapsedTime,
+                  })
+                }
+              }
+            }
+          }
+        } catch (_) {}
+      })
+
+      await page.goto(data.domain, { waitUntil: "domcontentloaded" })
+      userAgent = await page.evaluate(() => navigator.userAgent)
+    } catch (err) {
+      if (!isResolved) {
+        isResolved = true
+        clearTimeout(cl)
+        reject(err)
+      }
+    }
+  })
+}
+
+module.exports = cloudflare

endpoints/imageProcessor

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const https = require('https');
+
+async function extractTextFromImage(imageBuffer) {
+    console.log('[DEBUG] extractTextFromImage: Starting image text extraction');
+    console.log('[DEBUG] Image buffer size:', imageBuffer.length, 'bytes');
+    
+    return new Promise((resolve, reject) => {
+        const base64Image = imageBuffer.toString('base64');
+        console.log('[DEBUG] Base64 image length:', base64Image.length);
+
+        const requestData = JSON.stringify({
+            "contents": [
+                {
+                    "parts": [
+                        {
+                            "inline_data": {
+                                "mime_type": "image/png",
+                                "data": base64Image
+                            }
+                        },
+                        {
+                            "text": "Berikan text yang ada di gambar ini saja, tidak ada informasi lain cukup yang ada di gambar saja, jangan ada text lain kalo bukan dari gambar nya."
+                        }
+                    ]
+                }
+            ]
+        });
+
+        console.log('[DEBUG] Request data prepared, length:', requestData.length);
+
+        const options = {
+            hostname: 'generativelanguage.googleapis.com',
+            path: '/v1beta/models/gemini-2.5-flash-lite:generateContent',
+            method: 'POST',
+            headers: {
+                'x-goog-api-key': 'AIzaSyB3-2egs0udKCDX_F7I58uVRAwv7OUX1G8',
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(requestData)
+            }
+        };
+
+        console.log('[DEBUG] Making request to Gemini API...');
+
+        const req = https.request(options, (res) => {
+            console.log('[DEBUG] API Response status:', res.statusCode);
+            console.log('[DEBUG] API Response headers:', res.headers);
+
+            let data = '';
+
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                console.log('[DEBUG] Received all response data');
+                console.log('[DEBUG] Response data length:', data.length);
+                
+                try {
+                    const response = JSON.parse(data);
+                    console.log('[DEBUG] Response parsed successfully');
+                    
+                    if (response.candidates && response.candidates[0] && response.candidates[0].content) {
+                        const text = response.candidates[0].content.parts[0].text;
+                        console.log('[DEBUG] ✅ Text extracted:', text);
+                        resolve({ status: true, response: text });
+                    } else {
+                        console.log('[DEBUG] ❌ No text found in response');
+                        console.log('[DEBUG] Response structure:', JSON.stringify(response, null, 2));
+                        
+                        if (response.error) {
+                            console.log('[DEBUG] API Error:', response.error);
+                        }
+                        
+                        resolve({ status: false, response: 'Tidak ada teks yang ditemukan' });
+                    }
+                } catch (error) {
+                    console.error('[DEBUG] ❌ JSON parse error:', error);
+                    console.log('[DEBUG] Raw response data:', data);
+                    reject(error);
+                }
+            });
+        });
+
+        req.on('error', (error) => {
+            console.error('[DEBUG] ❌ Request error:', error);
+            reject(error);
+        });
+
+        req.on('timeout', () => {
+            console.error('[DEBUG] ❌ Request timeout');
+            req.destroy();
+            reject(new Error('Request timeout'));
+        });
+
+        req.setTimeout(30000); // 30 second timeout
+
+        console.log('[DEBUG] Sending request...');
+        req.write(requestData);
+        req.end();
+        console.log('[DEBUG] Request sent');
+    });
+}
+
+module.exports = { extractTextFromImage };

endpoints/turnstile.js

@@ -0,0 +1,84 @@
+async function turnstile({ domain, proxy, siteKey }, page) {
+  if (!domain) throw new Error("Missing domain parameter");
+  if (!siteKey) throw new Error("Missing siteKey parameter");
+
+  const timeout = global.timeOut || 60000;
+  let isResolved = false;
+
+  const cl = setTimeout(async () => {
+    if (!isResolved) {
+      throw new Error("Timeout Error");
+    }
+  }, timeout);
+
+  try {
+    if (proxy?.username && proxy?.password) {
+      await page.authenticate({
+        username: proxy.username,
+        password: proxy.password,
+      });
+    }
+
+    const htmlContent = `
+      <!DOCTYPE html>
+      <html lang="en">
+      <body>
+        <div class="turnstile"></div>
+        <script src="https://challenges.cloudflare.com/turnstile/v0/api.js?onload=onloadTurnstileCallback" defer></script>
+        <script>
+          window.onloadTurnstileCallback = function () {
+            turnstile.render('.turnstile', {
+              sitekey: '${siteKey}',
+              callback: function (token) {
+                var c = document.createElement('input');
+                c.type = 'hidden';
+                c.name = 'cf-response';
+                c.value = token;
+                document.body.appendChild(c);
+              },
+            });
+          };
+        </script>
+      </body>
+      </html>
+    `;
+
+    await page.setRequestInterception(true);
+    page.removeAllListeners("request");
+    page.on("request", async (request) => {
+      if ([domain, domain + "/"].includes(request.url()) && request.resourceType() === "document") {
+        await request.respond({
+          status: 200,
+          contentType: "text/html",
+          body: htmlContent,
+        });
+      } else {
+        await request.continue();
+      }
+    });
+
+    await page.goto(domain, { waitUntil: "domcontentloaded" });
+
+    await page.waitForSelector('[name="cf-response"]', { timeout });
+
+    const token = await page.evaluate(() => {
+      try {
+        return document.querySelector('[name="cf-response"]').value;
+      } catch {
+        return null;
+      }
+    });
+
+    isResolved = true;
+    clearTimeout(cl);
+
+    if (!token || token.length < 10) throw new Error("Failed to get token");
+    return token;
+
+  } catch (e) {
+    clearTimeout(cl);
+    throw e;
+  }
+}
+
+module.exports = turnstile;

index.js

@@ -0,0 +1,141 @@
+const express = require('express');
+const { connect } = require("puppeteer-real-browser");
+const fs = require('fs');
+const path = require('path');
+
+const app = express();
+const port = process.env.PORT || 7860;
+const authToken = process.env.authToken || null;
+const domain = process.env.DOMAIN || `https://forgets-Public.hf.space`;
+
+// Konfigurasi Global
+global.browserLimit = Number(process.env.browserLimit) || 30;
+global.timeOut = Number(process.env.timeOut) || 120000;
+
+// Cache System (Pikeun Cloudflare/Turnstile)
+const CACHE_DIR = path.join(__dirname, "cache");
+const CACHE_FILE = path.join(CACHE_DIR, "cache.json");
+const CACHE_TTL = 5 * 60 * 1000;
+
+function loadCache() {
+  if (!fs.existsSync(CACHE_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8')); } catch { return {}; }
+}
+
+function saveCache(cache) {
+  if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
+  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+}
+
+// Middleware
+app.use(express.json({ limit: "50mb" }));
+app.use(express.urlencoded({ extended: true, limit: "50mb" }));
+
+// --- IMPORT ENDPOINTS ---
+// Ngaran variabel dijieun béda (solveAntibot) meh teu bentrok jeung route /antibot
+const solveTurnstile = require('./endpoints/turnstile');
+const solveCloudflare = require('./endpoints/cloudflare');
+const solveAntibot = require('./endpoints/antibot');
+
+// Dashboard Status
+app.get("/", (req, res) => {
+  res.json({
+    message: "Server is running!",
+    endpoints: {
+      cloudflare: `${domain}/cloudflare`,
+      antibot: `${domain}/antibot`
+    },
+    status: {
+      browserLimit: global.browserLimit,
+      authRequired: authToken !== null
+    }
+  });
+});
+
+// Browser Creator Utility
+async function createBrowser(proxyServer = null) {
+  const connectOptions = {
+    headless: false,
+    turnstile: true,
+    connectOption: { defaultViewport: null },
+    disableXvfb: false,
+  };
+  if (proxyServer) connectOptions.args = [`--proxy-server=${proxyServer}`];
+
+  const { browser } = await connect(connectOptions);
+  const [page] = await browser.pages();
+
+  await page.goto('about:blank');
+  await page.setRequestInterception(true);
+  page.on('request', (req) => {
+    if (["image", "stylesheet", "font", "media"].includes(req.resourceType())) req.abort();
+    else req.continue();
+  });
+
+  return { browser, page };
+}
+
+// --- ROUTE: ANTIBOT (KHUSUS PHP BOT) ---
+app.post("/antibot", async (req, res) => {
+  const data = req.body;
+
+  // Validasi data ti PHP
+  if (!data || !data.main || !Array.isArray(data.bots)) {
+    return res.status(400).json({ message: "Body format salah (kudu aya main & bots array)" });
+  }
+
+  try {
+    console.log("Menerima tantangan Antibot...");
+    // Manggil fungsi solveAntibot tina folder endpoints/
+    const result = await solveAntibot(data);
+    
+    // Kirim hasilna balik ka PHP
+    res.json(result);
+  } catch (err) {
+    console.error("Error Antibot:", err.message);
+    res.status(500).json({ message: err.message });
+  }
+});
+
+// --- ROUTE: CLOUDFLARE/TURNSTILE ---
+app.post('/cloudflare', async (req, res) => {
+  const data = req.body;
+  if (!data || !data.mode) return res.status(400).json({ message: 'Missing mode' });
+
+  if (global.browserLimit <= 0) return res.status(429).json({ message: 'Server Busy' });
+
+  global.browserLimit--;
+  let result, browser;
+
+  try {
+    const proxyServer = data.proxy ? `${data.proxy.hostname}:${data.proxy.port}` : null;
+    const ctx = await createBrowser(proxyServer);
+    browser = ctx.browser;
+    const page = ctx.page;
+
+    switch (data.mode) {
+      case "turnstile":
+        const token = await solveTurnstile(data, page);
+        result = { token };
+        break;
+      case "iuam":
+        result = await solveCloudflare(data, page);
+        break;
+      default:
+        result = { code: 400, message: 'Invalid mode' };
+    }
+  } catch (err) {
+    result = { code: 500, message: err.message };
+  } finally {
+    if (browser) await browser.close();
+    global.browserLimit++;
+  }
+
+  res.status(result.code ?? 200).json(result);
+});
+
+// Start Server
+const server = app.listen(port, () => {
+  console.log(`API Server jalan dina port ${port}`);
+});
+server.timeout = global.timeOut;

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "cf-bypass",
+  "version": "1.0",
+  "description": "get the cf_clearance cookie from any website",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "canvas": "^2.11.2",
+    "sharp": "^0.32.0",
+    "puppeteer-real-browser": "^1.4.0",
+    "axios": "^1.9.0",
+    "child_process": "*",
+    "tesseract.js": "^5.0.3",
+    "jimp": "^0.22.10"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}