update

Dockerfile

@@ -0,0 +1,26 @@
+FROM node:20-slim
+
+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 \
+    && 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
+
+WORKDIR /app
+
+RUN mkdir -p /app/endpoints && \
+    mkdir -p /app/cache
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+EXPOSE 7860
+
+CMD rm -f /tmp/.X99-lock && \
+    Xvfb :99 -screen 0 1024x768x24 & \
+    export DISPLAY=:99 && \
+    npm start

README.md

@@ -3,10 +3,8 @@ title: Antibot2
 emoji: 📚
 colorFrom: gray
 colorTo: indigo
-sdk: gradio
+sdk: docker
 sdk_version: 5.49.1
-app_file: app.py
-pinned: false
 license: apache-2.0
 short_description: antibot
 ---

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,193 @@
+const Tesseract = require("tesseract.js");
+const fs = require("fs");
+const path = require("path");
+const sharp = require("sharp");
+
+const WORD_TO_NUM = {
+  zero:"0",oh:"0",one:"1",won:"1",two:"2",to:"2",too:"2",three:"3",tree:"3",
+  four:"4",for:"4",five:"5",six:"6",seven:"7",eight:"8",ate:"8",nine:"9",ten:"10"
+};
+
+const LEET_REPLACE = {
+  "4":"a","3":"e","1":"i","0":"o","5":"s","7":"t","@":"a","$":"s","|":"l"
+};
+
+const buf = b => Buffer.from(b.replace(/^data:image\/\w+;base64,/,""),"base64");
+
+function fixLeetToText(s){
+  return s.toLowerCase().split("").map(c=>LEET_REPLACE[c]??c).join("");
+}
+
+function wordToDigit(t){
+  if(!t)return"";
+  t=t.toLowerCase().trim();
+  if(/^\d+$/.test(t))return t;
+  const c=t.replace(/[^a-z0-9]/gi,"");
+  const f=fixLeetToText(c);
+  if(WORD_TO_NUM[f]!==undefined)return WORD_TO_NUM[f];
+  const d=t.match(/\d+/);
+  if(d)return d[0];
+  return"";
+}
+
+function normalizeExpression(raw){
+  if(!raw)return"";
+  let s=raw.toLowerCase().replace(/\s+/g,"");
+  s=s.replace(/[×xX·•]/g,"*");
+  const parts=s.split(/([+\-*/()])/).filter(p=>p!=="");
+  return parts.map(p=>{
+    if(/^[+\-*/()]+$/.test(p))return p;
+    let num=wordToDigit(p);
+    if(num)return num;
+    const tf=fixLeetToText(p).replace(/[^a-z0-9]/g,"");
+    num=WORD_TO_NUM[tf]??"";
+    if(num)return num;
+    const dig=p.match(/\d+/);
+    if(dig)return dig[0];
+    return p;
+  }).join("");
+}
+
+function safeEvalExpression(expr){
+  if(!expr)return null;
+  const n=normalizeExpression(expr);
+  if(!/^[0-9+\-*/().]+$/.test(n))return null;
+  try{
+    const v=Function(`"use strict";return(${n});`)();
+    if(typeof v==="number"&&isFinite(v)){
+      if(Math.abs(v-Math.round(v))<1e-9)return String(Math.round(v));
+      return String(v);
+    }
+    return null;
+  }catch(e){return null;}
+}
+
+async function writeTempAndRecognize(b,opt={}){
+  const tmp=path.join(__dirname,"tmp_"+Date.now()+"_"+Math.random()+".png");
+  fs.writeFileSync(tmp,b);
+  try{
+    const r=await Tesseract.recognize(tmp,"eng",opt);
+    fs.unlinkSync(tmp);
+    return r.data.text||"";
+  }catch(e){
+    if(fs.existsSync(tmp))fs.unlinkSync(tmp);
+    return"";
+  }
+}
+
+async function ocrDigit(b){
+  const t=await writeTempAndRecognize(b,{
+    tessedit_char_whitelist:"0123456789Il!|OoZSTBGg",
+    tessedit_pageseg_mode:"7",
+    tessedit_ocr_engine_mode:"1"
+  });
+  const m={"I":"1","l":"1","|":"1","!":"1","O":"0","o":"0","Q":"0","Z":"2","z":"2",
+  "S":"5","s":"5","T":"7","t":"7","B":"8","b":"8","G":"6","g":"9"};
+  return t.split("").map(c=>m[c]??c).join("").replace(/[^0-9]/g,"");
+}
+
+async function ocrGeneric(b){
+  const t=await writeTempAndRecognize(b,{
+    tessedit_char_whitelist:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-*/()., ",
+    tessedit_pageseg_mode:"7",
+    tessedit_ocr_engine_mode:"1"
+  });
+  return t.trim();
+}
+
+async function preprocessForSoal(b){
+  return sharp(b).resize({width:1000}).grayscale().normalize().sharpen({sigma:1.2}).median(1).toBuffer();
+}
+
+async function preprocessForBot(b){
+  return sharp(b).resize({width:700}).grayscale().normalize().sharpen({sigma:1}).median(1).toBuffer();
+}
+
+module.exports = async function solveAntiBot(data){
+  try{
+    const soalBuf=buf(data.main);
+    const soalPrep=await preprocessForSoal(soalBuf);
+    const soalRawText=await ocrGeneric(soalPrep);
+
+    const tok=soalRawText.split(/[,;]+|\s+/).filter(Boolean);
+    const soalNumbers=tok.slice(0,10).map(t=>{
+      const e=safeEvalExpression(t);
+      if(e!==null&&e!=="")return e;
+      const w=wordToDigit(t);
+      if(w)return w;
+      const fx=fixLeetToText(t.replace(/[^a-z0-9+\-*/().]/gi,""));
+      if(WORD_TO_NUM[fx]!==undefined)return WORD_TO_NUM[fx];
+      const d=t.match(/\d+/);
+      if(d)return d[0];
+      return"";
+    }).filter(Boolean);
+
+    const botResults=[];
+    for(const b of data.bots){
+      const bbuf=buf(b.img);
+      const prep=await preprocessForBot(bbuf);
+      let v=await ocrDigit(prep);
+      if(!v){
+        const g=await ocrGeneric(prep);
+        if(g){
+          const ev=safeEvalExpression(g);
+          if(ev!==null)v=ev;
+          else v=wordToDigit(g)||fixLeetToText(g).replace(/[^0-9]/g,"");
+        }
+      }
+      botResults.push({id:b.id,raw:v||""});
+    }
+
+    botResults.forEach(br=>{
+      if(!br.raw)return;
+      if(!/^\d+$/.test(br.raw)){
+        br.raw=wordToDigit(br.raw)||safeEvalExpression(br.raw)||br.raw.match(/\d+/)?.[0]||"";
+      }
+    });
+
+    const result=[];
+    const used=new Set();
+    for(const need of soalNumbers){
+      let f=null;
+      for(const b of botResults){
+        if(!used.has(b.id)&&b.raw&&String(b.raw)===String(need)){
+          f=b.id;break;
+        }
+      }
+      if(!f){
+        for(const b of botResults){
+          if(!used.has(b.id)&&b.raw&&Number(b.raw)==Number(need)){
+            f=b.id;break;
+          }
+        }
+      }
+      if(!f){
+        for(const b of botResults){
+          if(!used.has(b.id)&&b.raw){
+            const bw=fixLeetToText(String(b.raw));
+            if(WORD_TO_NUM[bw]===String(need)){f=b.id;break;}
+          }
+        }
+      }
+      if(f){result.push(f);used.add(f);}
+      else result.push(null);
+    }
+
+    for(let i=0;i<result.length;i++){
+      if(result[i]===null){
+        for(const b of botResults){
+          if(!used.has(b.id)){
+            result[i]=b.id;
+            used.add(b.id);
+            break;
+          }
+        }
+      }
+    }
+
+    return {rawSoalText:soalRawText,soalNumbers,botResults,result};
+
+  }catch(e){
+    return {rawSoalText:"",soalNumbers:[],botResults:[],result:[]};
+  }
+};

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/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,179 @@
+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://fourstore-antibot2.hf.space`;
+
+global.browserLimit = Number(process.env.browserLimit) || 20;
+global.timeOut = Number(process.env.timeOut) || 60000;
+
+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');
+}
+
+function readCache(key) {
+  const cache = loadCache();
+  const entry = cache[key];
+  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+    return entry.value;
+  }
+  return null;
+}
+
+function writeCache(key, value) {
+  const cache = loadCache();
+  cache[key] = { timestamp: Date.now(), value };
+  saveCache(cache);
+}
+
+app.use(express.json({ limit: "50mb" }));
+app.use(express.urlencoded({ extended: true, limit: "50mb" }));
+
+app.get("/", (req, res) => {
+  res.json({
+    message: "Server is running!",
+    domain: domain,
+    endpoints: {
+      cloudflare: `${domain}/cloudflare`,
+      antibot: `${domain}/antibot`
+    },
+    status: {
+      browserLimit: global.browserLimit,
+      timeOut: global.timeOut,
+      authRequired: authToken !== null
+    }
+  });
+});
+
+if (process.env.NODE_ENV !== 'development') {
+  let server = app.listen(port, () => {
+    console.log(`Server running on port ${port}`);
+    console.log(`Domain: ${domain}`);
+    console.log(`Auth required: ${authToken !== null}`);
+  });
+  try {
+    server.timeout = global.timeOut;
+  } catch {}
+}
+
+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) => {
+    const type = req.resourceType();
+    if (["image", "stylesheet", "font", "media"].includes(type)) req.abort();
+    else req.continue();
+  });
+
+  return { browser, page };
+}
+
+const turnstile = require('./endpoints/turnstile');
+const cloudflare = require('./endpoints/cloudflare');
+const antibot = require('./endpoints/antibot');
+
+app.post('/cloudflare', async (req, res) => {
+  const data = req.body;
+  if (!data || typeof data.mode !== 'string')
+    return res.status(400).json({ message: 'Bad Request: missing or invalid mode' });
+
+  if (global.browserLimit <= 0)
+    return res.status(429).json({ message: 'Too Many Requests' });
+
+  let cacheKey, cached;
+  if (data.mode === "iuam") {
+    cacheKey = JSON.stringify(data);
+    cached = readCache(cacheKey);
+    if (cached) return res.status(200).json({ ...cached, cached: true });
+  }
+
+  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;
+
+    await page.goto('about:blank');
+
+    switch (data.mode) {
+      case "turnstile":
+        result = await turnstile(data, page).then(t => ({ token: t }));
+        break;
+
+      case "iuam":
+        result = await cloudflare(data, page).then(r => ({ ...r }));
+        writeCache(cacheKey, result);
+        break;
+
+      case "antibot":
+        result = await antibot(data);
+        break;
+
+      default:
+        result = { code: 400, message: 'Invalid mode' };
+    }
+  } catch (err) {
+    result = { code: 500, message: err.message };
+  } finally {
+    if (browser) try { await browser.close(); } catch {}
+    global.browserLimit++;
+  }
+
+  res.status(result.code ?? 200).json(result);
+});
+
+app.post("/antibot", async (req, res) => {
+  const data = req.body;
+
+  if (!data || !data.main || !Array.isArray(data.bots))
+    return res.status(400).json({ message: "Invalid body" });
+
+  try {
+    const result = await antibot(data);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+});
+
+app.use((req, res) => {
+  res.status(404).json({ message: 'Not Found' });
+});
+
+if (process.env.NODE_ENV === 'development') {
+  module.exports = app;
+}

package.json

@@ -0,0 +1,21 @@
+{
+  "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",
+    "tesseract.js": "^5.0.3",
+    "jimp": "^0.22.10"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}