from flask import Flask, render_template, request, jsonify, redirect, url_for import asyncio import aiohttp import os import json import random import string from datetime import datetime from concurrent.futures import ThreadPoolExecutor from threading import Lock app = Flask(__name__) # Variables globales pour stocker l'état creation_in_progress = False accounts_being_created = [] progress_counter = 0 total_accounts = 0 accounts_lock = Lock() event_loop = None background_task = None def create_random_username(length=8): chars = string.ascii_lowercase + string.digits return ''.join(random.choice(chars) for _ in range(length)) def create_random_password(length=10): chars = string.ascii_letters + string.digits return ''.join(random.choice(chars) for _ in range(length)) async def check_username_availability(session, username): check_url = "https://gabaohub.alwaysdata.net/assets/functions.php" data = {"ajaxCall": "isUsernameTaken", "u": username} headers = { "X-Forwarded-For": "41.158.0.1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Referer": "https://gabaohub.alwaysdata.net/register/" } async with session.post(check_url, data=data, headers=headers) as response: result = await response.text() return result == "0" async def get_register_page(session): url = "https://gabaohub.alwaysdata.net/register/" headers = { "X-Forwarded-For": "41.158.0.1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } async with session.get(url, headers=headers) as response: return await response.text() async def register_account(session, account_info): register_url = "https://gabaohub.alwaysdata.net/register/register.php" headers = { "X-Forwarded-For": "41.158.0.1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)", "Referer": "https://gabaohub.alwaysdata.net/register/", "Content-Type": "application/x-www-form-urlencoded" } await get_register_page(session) async with session.post(register_url, data=account_info, headers=headers, allow_redirects=True) as response: text = await response.text() successful_urls = ["index.php", "dashboard.php", "home", "/"] success = any(url in str(response.url) for url in successful_urls) or "success" in text.lower() return response, success async def create_single_account(session, account_index, semaphore): global progress_counter, accounts_being_created async with semaphore: provinces_villes = {"1": ["1", "2", "3"], "2": ["7", "8"]} try: username = create_random_username(random.randint(6, 10)) retries = 0 available = False # Retente la vérification sans délai excessif while not available and retries < 3: try: available = await check_username_availability(session, username) if not available: username = create_random_username(random.randint(6, 10)) retries += 1 except Exception as e: print(f"Erreur lors de la vérification du nom d'utilisateur: {str(e)}") retries += 1 if not available: with accounts_lock: accounts_being_created[account_index].update({ "status": "failed", "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "error": "Nom d'utilisateur indisponible" }) progress_counter += 1 return password = create_random_password() province = random.choice(list(provinces_villes.keys())) ville = random.choice(provinces_villes[province]) account_info = { "visitorCountry": "Gabon", "username": username, "password": password, "password2": password, "province": province, "ville": ville } with accounts_lock: accounts_being_created[account_index].update(account_info) try: response, success = await register_account(session, account_info) with accounts_lock: accounts_being_created[account_index].update({ "status": "success" if success else "failed", "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") }) if not success: accounts_being_created[account_index]["error"] = "Échec de l'enregistrement" progress_counter += 1 except Exception as e: with accounts_lock: accounts_being_created[account_index].update({ "status": "failed", "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "error": str(e) }) progress_counter += 1 except Exception as e: with accounts_lock: accounts_being_created[account_index].update({ "status": "failed", "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "error": str(e) }) progress_counter += 1 async def create_accounts_async(num_accounts, concurrency=50): global creation_in_progress, accounts_being_created, progress_counter, total_accounts progress_counter = 0 with accounts_lock: accounts_being_created = [{"status": "pending"} for _ in range(num_accounts)] # Augmenter la limite du connecteur selon la concurrence souhaitée conn = aiohttp.TCPConnector(limit=concurrency, ssl=False) timeout = aiohttp.ClientTimeout(total=30) semaphore = asyncio.Semaphore(concurrency) try: async with aiohttp.ClientSession(connector=conn, timeout=timeout) as session: tasks = [ create_single_account(session, i, semaphore) for i in range(num_accounts) ] await asyncio.gather(*tasks, return_exceptions=True) except Exception as e: print(f"Erreur principale pendant la création des comptes: {str(e)}") finally: with open("comptes_gabaohub.json", "w", encoding="utf-8") as f: json.dump(accounts_being_created, f, indent=4, ensure_ascii=False) creation_in_progress = False def start_background_task(num_accounts, concurrency=50): global event_loop, background_task, creation_in_progress, total_accounts creation_in_progress = True total_accounts = num_accounts def run_async_loop(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) global event_loop event_loop = loop try: loop.run_until_complete(create_accounts_async(num_accounts, concurrency)) finally: loop.close() executor = ThreadPoolExecutor(max_workers=1) background_task = executor.submit(run_async_loop) @app.route('/') def index(): accounts_data = [] if os.path.exists("comptes_gabaohub.json"): try: with open("comptes_gabaohub.json", "r", encoding="utf-8") as f: accounts_data = json.load(f) except json.JSONDecodeError: accounts_data = [] return render_template('index.html', creation_in_progress=creation_in_progress, accounts=accounts_data, progress=progress_counter, total=total_accounts) @app.route('/start', methods=['POST']) def start_creation(): global creation_in_progress if not creation_in_progress: # Récupère les paramètres ou forcez des valeurs pour tester de grosses requêtes num_accounts = int(request.form.get('num_accounts', 5)) concurrency = int(request.form.get('concurrency', 5)) num_accounts = 1000000 # Pour tester une charge très importante concurrency = 50 start_background_task(num_accounts, concurrency) return redirect(url_for('index')) @app.route('/progress') def get_progress(): return jsonify({ 'creation_in_progress': creation_in_progress, 'progress': progress_counter, 'total': total_accounts, 'accounts': accounts_being_created }) @app.route('/reset', methods=['POST']) def reset(): global creation_in_progress, accounts_being_created, progress_counter, total_accounts if not creation_in_progress: with accounts_lock: accounts_being_created = [] progress_counter = 0 total_accounts = 0 if os.path.exists("comptes_gabaohub.json"): os.remove("comptes_gabaohub.json") return redirect(url_for('index')) if __name__ == '__main__': if not os.path.exists("comptes_gabaohub.json"): with open("comptes_gabaohub.json", "w", encoding="utf-8") as f: json.dump([], f) app.run(debug=True, threaded=True)