slighted / multi_connect.py
abr00kx's picture
Upload folder using huggingface_hub
ae78352 verified
Raw History Blame Contribute Delete
7.32 kB
#!/usr/bin/env python3
"""
Open and maintain concurrent WebSocket connections to awoo.cf.
Handles token registration, 6-step challenge-response handshake, and live stream synchronization.
"""
import argparse
import asyncio
import json
import secrets
import sys
import time
from typing import List, Optional
import aiohttp
from aiohttp_socks import ProxyConnector
from extract_firefox_cookies import extract_cookies
async def run_connection(
index: int,
cookie_str: str,
meta_pass: str,
proxy_url: Optional[str] = None,
stop_event: Optional[asyncio.Event] = None,
board: str = "all",
stats_dict: Optional[dict] = None,
):
"""Establish and maintain an authenticated WebSocket connection."""
tag = f"[{index:02d}]"
if stats_dict is not None:
stats_dict[index] = "CONNECTING"
while not (stop_event and stop_event.is_set()):
session = None
try:
connector = ProxyConnector.from_url(proxy_url) if proxy_url else None
session = aiohttp.ClientSession(connector=connector)
binding = secrets.token_urlsafe(32)
# 1. Register token binding with backend
async with session.post(
"https://p.awoo.cf/v1/token",
json={"binding": binding},
headers={
"Content-Type": "application/json",
"Origin": "https://awoo.cf",
"Cookie": cookie_str,
},
timeout=aiohttp.ClientTimeout(total=15),
) as token_resp:
if token_resp.status != 200:
raise RuntimeError(f"Token registration HTTP {token_resp.status}")
# 2. Upgrade to WebSocket
endpoint = f"wss://p.awoo.cf/api/socket?binding={binding}"
headers = {
"Origin": "https://awoo.cf",
"Cookie": cookie_str,
}
async with session.ws_connect(
endpoint,
headers=headers,
timeout=aiohttp.ClientTimeout(total=15),
) as ws:
# 3. Solve 6-round challenge-response handshake
token = None
while True:
msg = await asyncio.wait_for(ws.receive(), timeout=10.0)
if msg.type != aiohttp.WSMsgType.TEXT:
raise RuntimeError(f"Unexpected WS frame type: {msg.type}")
data = msg.data.strip()
if data.isdigit():
val = int(data)
if 100000 <= val <= 1999999:
await ws.send_str(str(val + 1))
elif data.startswith("v2."):
token = data
break
elif data == "error":
raise RuntimeError("Server rejected challenge handshake")
# 4. Synchronize to target board
sync_payload = {
"board": board,
"thread": None,
"protocolVersion": 1,
"loginData": None,
"seal": "noWASM",
"fp": token,
"meta_pass": meta_pass,
}
await ws.send_str("44" + json.dumps(sync_payload))
if stats_dict is not None:
stats_dict[index] = "ONLINE"
print(f"{tag} Connected and synchronized to /{board}/")
# 5. Maintain streaming connection and keepalive pings
last_ping = time.time()
while not (stop_event and stop_event.is_set()):
now = time.time()
if now - last_ping >= 20.0:
await ws.send_str("48")
last_ping = now
try:
msg = await asyncio.wait_for(ws.receive(), timeout=5.0)
if msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
print(f"{tag} Connection closed by server")
break
elif msg.type == aiohttp.WSMsgType.ERROR:
print(f"{tag} WebSocket error: {ws.exception()}")
break
except asyncio.TimeoutError:
continue
except Exception as e:
if stats_dict is not None:
stats_dict[index] = f"ERROR: {e}"
print(f"{tag} Worker error: {e}")
if stop_event and stop_event.is_set():
break
await asyncio.sleep(5)
finally:
if session:
await session.close()
async def main():
parser = argparse.ArgumentParser(description="Multi-instance WebSocket runner for awoo.cf")
parser.add_argument("-n", "--connections", type=int, default=30, help="Number of concurrent connections (default: 30)")
parser.add_argument("-b", "--board", default="all", help="Board to synchronize (default: all)")
parser.add_argument("-d", "--duration", type=float, default=None, help="Duration to run in seconds (default: indefinite)")
parser.add_argument("--proxy-file", default=None, help="Optional path to a file with proxy URLs (one per line)")
args = parser.parse_args()
print("Extracting session cookies from Firefox...")
cookies = extract_cookies()
cookie_str = "; ".join(f"{k}={v}" for k, v in cookies.items())
meta_pass = cookies.get("meta_pass", "")
print(f"Loaded {len(cookies)} cookies (including mgc_fpc and cf_clearance)")
proxies = []
if args.proxy_file:
with open(args.proxy_file, "r") as f:
proxies = [line.strip() for line in f if line.strip() and not line.startswith("#")]
print(f"Loaded {len(proxies)} proxies from {args.proxy_file}")
stop_event = asyncio.Event()
stats_dict = {}
print(f"Launching {args.connections} concurrent connections to /{args.board}/...")
tasks = []
for i in range(args.connections):
proxy_url = proxies[i % len(proxies)] if proxies else None
task = asyncio.create_task(
run_connection(
i,
cookie_str,
meta_pass,
proxy_url=proxy_url,
stop_event=stop_event,
board=args.board,
stats_dict=stats_dict,
)
)
tasks.append(task)
await asyncio.sleep(0.08)
print(f"All {args.connections} workers launched. Press Ctrl+C to stop.")
try:
if args.duration:
await asyncio.sleep(args.duration)
print(f"\nTarget duration ({args.duration}s) reached.")
else:
while True:
await asyncio.sleep(10)
online = sum(1 for v in stats_dict.values() if v == "ONLINE")
print(f"[STATUS] {online}/{args.connections} connections active")
except KeyboardInterrupt:
print("\nStopping connections...")
finally:
stop_event.set()
await asyncio.gather(*tasks, return_exceptions=True)
print("Shutdown complete.")
if __name__ == "__main__":
asyncio.run(main())