Гайд Как сделать авторизацию по ключу на python

[ualte]

Перед прочтением основного контента ниже, пожалуйста, обратите внимание на обновление внутри секции Майна на нашем форуме. У нас появились:

• бесплатные читы для Майнкрафт — любое использование на свой страх и риск;
• маркетплейс Майнкрафт — абсолютно любая коммерция, связанная с игрой, за исключением продажи читов (аккаунты, предоставления услуг, поиск кодеров читов и так далее);
• приватные читы для Minecraft — в этом разделе только платные хаки для игры, покупайте группу "Продавец" и выставляйте на продажу свой софт;
• обсуждения и гайды — всё тот же раздел с вопросами, но теперь модернизированный: поиск нужных хаков, пати с игроками-читерами и другая полезная информация.

Спасибо!

Короче, нам понадобиться 7 библиотек, можете их скачать вот импорты

import base64
import ctypes
import hashlib
import os
import subprocess

import requests
from colorama import init, Fore

Не забываем иницилизировать колораму и заголовок консоли поменять

# Init
init(autoreset=True)
ctypes.windll.kernel32.SetConsoleTitleW("Cloaker")

делаем две переменные 1 ссылка на фанпей(потом поймёте зачем) и путь где будет находится всякие вещи от лоадера(если понадобиться)

# variables
funpayurl = "пока что нету"
path = r"C:\Cloaker"

Потом создаём папку

os.makedirs(path, exist_ok=True)

делаем эту функцию

def generate_unique_payment(username):
    unique_id = get_hwid()  # Получаем UUID в виде строки без разделителей
    encoded_username = base64.urlsafe_b64encode(username.encode()).decode()  # Кодируем ник в Base64
    key = f"{encoded_username}-{unique_id}"  # Объединяем ник и UUID
    encoded_key_payment = base64.urlsafe_b64encode(key.encode()).decode()
    return encoded_key_payment

Ну и остальные делаем

# Функция для получения информации о процессоре (CPU)
def get_cpu_info():
    try:
        if subprocess.os.name == 'nt':  # Windows
            command = "wmic cpu get ProcessorId"
        else:  # Linux / MacOS
            command = "cat /proc/cpuinfo | grep 'Serial'"
        result = subprocess.check_output(command, shell=True).strip().decode()
        return result.split("\n")[1] if subprocess.os.name == 'nt' else result
    except Exception as e:
        return f"Error retrieving CPU info: {e}"


# Функция для получения информации о жестком диске (Serial Number)
def get_disk_info():
    try:
        if subprocess.os.name == 'nt':  # Windows
            command = "wmic diskdrive get SerialNumber"
        else:  # Linux / MacOS
            command = "sudo hdparm -I /dev/sda | grep 'Serial Number'"
        result = subprocess.check_output(command, shell=True).strip().decode()
        return result.split("\n")[1] if subprocess.os.name == 'nt' else result
    except Exception as e:
        return f"Error retrieving Disk info: {e}"


# Функция для получения MAC-адреса сетевого адаптера
def get_mac_address():
    try:
        if subprocess.os.name == 'nt':  # Windows
            command = "getmac"
        else:  # Linux / MacOS
            command = "ifconfig | grep 'ether' | awk '{print $2}'"
        result = subprocess.check_output(command, shell=True).strip().decode()
        return result.split("\n")[0]
    except Exception as e:
        return f"Error retrieving MAC address: {e}"


# Генерация HWID на основе CPU, диска и MAC-адреса
def get_hwid():
    cpu_info = get_cpu_info()
    disk_info = get_disk_info()
    mac_address = get_mac_address()

    # Комбинируем информацию и создаем хэш
    hwid_raw = f"{cpu_info}-{disk_info}-{mac_address}"
    hwid_hash = hashlib.sha256(hwid_raw.encode()).hexdigest()
    return hwid_hash


def download_file(url, local_filename):
    # Проверьте, существует ли файл
    if os.path.exists(local_filename):
        print(f"    {Fore.YELLOW}Файл '{local_filename}' уже существует.")
        return

    # Скачайте файл
    print(f"    {Fore.CYAN}Скачивание файла {local_filename}...")
    response = requests.get(url, stream=True)
    response.raise_for_status()  # Проверить, что запрос был успешным

    # Запишите содержимое файла на диск
    with open(local_filename, 'wb') as file:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:  # фильтруем закачанные куски и записываем их
                file.write(chunk)

    print(f"    {Fore.GREEN}Файл '{local_filename}' успешно скачан.")

# Функция для извлечения ника из ключа
def extract_username_from_key(key):
    try:
        decoded_key = base64.urlsafe_b64decode(key).decode()
        encoded_username, _ = decoded_key.split('-', 1)  # Разделяем ник и UUID
        decoded_username = base64.urlsafe_b64decode(encoded_username).decode()  # Декодируем ник
        return decoded_username
    except Exception:
        return None


# Функция для проверки ключа в удаленном JSON
def check_key_in_json(key, url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            data = response.json()
            for entry in data:
                if entry['key'] == key:
                    return entry['uuid'], entry['username'], entry['role']
        return None, None, None
    except Exception as e:
        print(f"{Fore.RED}Ошибка при проверке ключа: {e}")
        return None, None, None

А ну ещё и лого

def logo():
    print(f"""{Fore.CYAN}
                 ▄████████  ▄█        ▄██████▄     ▄████████    ▄█   ▄█▄    ▄████████    ▄████████
                ███    ███ ███       ███    ███   ███    ███   ███ ▄███▀   ███    ███   ███    ███
                ███    █▀  ███       ███    ███   ███    ███   ███▐██▀     ███    █▀    ███    ███
                ███        ███       ███    ███   ███    ███  ▄█████▀     ▄███▄▄▄      ▄███▄▄▄▄██▀
                ███        ███       ███    ███ ▀███████████ ▀▀█████▄    ▀▀███▀▀▀     ▀▀███▀▀▀▀▀ 
                ███    █▄  ███       ███    ███   ███    ███   ███▐██▄     ███    █▄  ▀███████████
                ███    ███ ███▌    ▄ ███    ███   ███    ███   ███ ▀███▄   ███    ███   ███    ███
                ████████▀  █████▄▄██  ▀██████▀    ███    █▀    ███   ▀█▀   ██████████   ███    ███
                           ▀                                   ▀                        ███    ███
    {Fore.RESET}""")


def logo_logged(uuid, username, role):
    if not role in ["developer"]:
        print(f"""{Fore.CYAN}
                     ▄████████  ▄█        ▄██████▄     ▄████████    ▄█   ▄█▄    ▄████████    ▄████████
                    ███    ███ ███       ███    ███   ███    ███   ███ ▄███▀   ███    ███   ███    ███
                    ███    █▀  ███       ███    ███   ███    ███   ███▐██▀     ███    █▀    ███    ███
                    ███        ███       ███    ███   ███    ███  ▄█████▀     ▄███▄▄▄      ▄███▄▄▄▄██▀
                    ███        ███       ███    ███ ▀███████████ ▀▀█████▄    ▀▀███▀▀▀     ▀▀███▀▀▀▀▀ 
                    ███    █▄  ███       ███    ███   ███    ███   ███▐██▄     ███    █▄  ▀███████████
                    ███    ███ ███▌    ▄ ███    ███   ███    ███   ███ ▀███▄   ███    ███   ███    ███
                    ████████▀  █████▄▄██  ▀██████▀    ███    █▀    ███   ▀█▀   ██████████   ███    ███
                               ▀                                   ▀                        ███    ███
                    hwid: {uuid}
                    username: {username}
                    role: {role}

                    1 - Прокси (BETA)
                    2 - Изменить заголовок окна
                    3 - Изменить иконку окна
                    4 - Скрыть папку
                    5 - Показать папку
        {Fore.RESET}""")
    else:
        print(f"""{Fore.CYAN}
                     ▄████████  ▄█        ▄██████▄     ▄████████    ▄█   ▄█▄    ▄████████    ▄████████
                    ███    ███ ███       ███    ███   ███    ███   ███ ▄███▀   ███    ███   ███    ███
                    ███    █▀  ███       ███    ███   ███    ███   ███▐██▀     ███    █▀    ███    ███
                    ███        ███       ███    ███   ███    ███  ▄█████▀     ▄███▄▄▄      ▄███▄▄▄▄██▀
                    ███        ███       ███    ███ ▀███████████ ▀▀█████▄    ▀▀███▀▀▀     ▀▀███▀▀▀▀▀ 
                    ███    █▄  ███       ███    ███   ███    ███   ███▐██▄     ███    █▄  ▀███████████
                    ███    ███ ███▌    ▄ ███    ███   ███    ███   ███ ▀███▄   ███    ███   ███    ███
                    ████████▀  █████▄▄██  ▀██████▀    ███    █▀    ███   ▀█▀   ██████████   ███    ███
                               ▀                                   ▀                        ███    ███
                    hwid: {uuid}
                    username: {username}
                    role: {role}

                    1 - Прокси (BETA)
                    2 - Изменить заголовок окна
                    3 - Изменить иконку окна
                    4 - Скрыть папку
                    5 - Показать папку
                    dev1 - Показать базу данных
        {Fore.RESET}""")

Создаём функцию которая очищает консоль

def clear():
    os.system("cls")

Делаем Цикл и пока что там будет очищать консоль, принтить лого, и запрашивать что собственно надо

while True:
    clear()
    logo()
    choice = input(f"""{Fore.YELLOW}
    Что вы хотите сделать?
    1 - Запустить
    2 - Купить
    {Fore.BLUE}cloaker> {Fore.RESET}""")

Прописываем логику для "Запустить"

    if choice == "1":
        keytocheck = input(f"    {Fore.LIGHTBLUE_EX}Введите свой ключ: ")
        url = "" # но но но

        # Проверка ключа в JSON
        uuid_server, username, role = check_key_in_json(keytocheck, url)
        uuid_user = get_hwid()

        if uuid_server != uuid_user:
            print(f"    {Fore.RED}Неверный HWID.")
        else:
            if uuid_server and username and role:
                if role in ["developer"]:
                    ctypes.windll.kernel32.SetConsoleTitleW("Cloaker [DEV]")
                elif role in ["betauser"]:
                    ctypes.windll.kernel32.SetConsoleTitleW("Cloaker [BETA]")
                elif role in ["user"]:
                    ctypes.windll.kernel32.SetConsoleTitleW("Cloaker [BASIC]")
                while True:
                    # тут ты можешь поменять что нибудь типо сделать не просто программу как Hider читов а допустим запуск чита тупо не важно
                    uuid_server, username, role = check_key_in_json(keytocheck, url)
                    if not uuid_server and username and role:
                        print(f"    {Fore.RED}Неверный ключ или данные.")
                        input()
                        exit(1)
                    elif uuid_server != uuid_user:
                        if not uuid_server:
                            print(f"    {Fore.RED}Неверный ключ или данные.")
                            input()
                            exit(1)
                        else:
                            print(f"    {Fore.RED}Неверный HWID.")
                            input()
                            exit(1)

                  
                    clear()
                    logo_logged(uuid_server, username, role)
                    choice = input(f"""    {Fore.BLUE}cloaker> {Fore.RESET}""")
                  
                    if role in ["developer"]:
                        if choice == "dev1":
                            r = requests.get(url)
                            r.raise_for_status()
                            print(f"{Fore.GREEN}" + r.text)
                            input()
            else:
                print(f"    {Fore.RED}Ключ не найден или некорректен.")
                input()

Теперь прописываем логику для "Купить"

    elif choice == "2":
        nickname = input(f"    {Fore.LIGHTBLUE_EX}Напишите свой ник: ")
        generated_key = generate_unique_payment(nickname)
        print(f"    {Fore.GREEN}Сгенерированный ключ для оплаты: {generated_key}")
        print(
            f"    {Fore.GREEN}Купите на фанпей ключ и дайте ему этот ключ для оплаты: " + f"{Fore.YELLOW}" + funpayurl)
        input()

ну всё готово! кстати вот json который нужно

[
    {
        "key": "ключ",
        "uuid": "хвид",
        "username": "AkaruiNeko1337",
        "role": "developer"
    }
]

ну ещё веб панель на пайтоне для генерации ключа, и т.д

from flask import Flask, render_template_string, request
import uuid
import base64
import hashlib
import re

app = Flask(__name__)

def generate_custom_key(unique_id):
    base64_encoded_uuid = base64.urlsafe_b64encode(unique_id.bytes).decode().rstrip('=')
    sha256_hashed = hashlib.sha256(base64_encoded_uuid.encode()).hexdigest()
    formatted_key = re.sub(r'(\w{5})(\w{7})(\w{5})(\w{7})', r'\1-\2-\3-\4', sha256_hashed[:24])
    combined_key = f"{base64_encoded_uuid}-{formatted_key}"
    return combined_key

def extract_uuid_and_username(encoded_key_payment):
    try:
        decoded_key = base64.urlsafe_b64decode(encoded_key_payment).decode()
        encoded_username, unique_id = decoded_key.split('-', 1)
        username = base64.urlsafe_b64decode(encoded_username).decode()
        return unique_id, username
    except Exception as e:
        print(f"Ошибка при извлечении данных из ключа: {e}")
        return None, None

def extract_uuid_from_key(key):
    try:
        base64_encoded_uuid, _ = key.split('-', 1)
        uuid_bytes = base64.urlsafe_b64decode(base64_encoded_uuid + "==")
        extracted_uuid = uuid.UUID(bytes=uuid_bytes)
        return extracted_uuid
    except Exception as e:
        print(f"Ошибка при извлечении UUID из ключа: {e}")
        return None

@app.route('/', methods=['GET', 'POST'])
def index():
    result = None
    action = request.form.get('action')

    if action == 'generate_key':
        testuid = uuid.UUID(request.form['uuid'])
        result = generate_custom_key(testuid)
    elif action == 'extract_uuid':
        key = request.form['key']
        result = extract_uuid_from_key(key)
    elif action == 'extract_uuid_username':
        key_payment = request.form['key_payment']
        unique_id, username = extract_uuid_and_username(key_payment)
        result = f"UUID: {unique_id}, Ник: {username}"

    # HTML и CSS код
    html_template = '''
    <!doctype html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Cloaker Web Panel</title>
        <style>
            @keyframes fadeIn {
                from { opacity: 0; }
                to { opacity: 1; }
            }

            body {
                font-family: 'Arial', sans-serif;
                background: radial-gradient(circle, #0f0c29, #302b63, #24243e);
                padding: 40px;
                color: #ffffff;
                display: flex;
                justify-content: center;
                align-items: center;
                height: 100vh;
                margin: 0;
                animation: fadeIn 1.5s ease-in-out;
            }
            .container {
                background-color: #151515;
                padding: 40px;
                border-radius: 15px;
                box-shadow: 0 0 40px rgba(0, 0, 0, 0.7);
                max-width: 900px;
                width: 100%;
                display: flex;
                flex-direction: column;
                align-items: center;
                animation: fadeIn 2s ease-in-out;
            }
            h1 {
                color: #f9f9f9;
                text-align: center;
                margin-bottom: 40px;
                font-size: 2.5em;
                background: linear-gradient(90deg, #ff4e50, #f9d423);
                -webkit-background-clip: text;
                -webkit-text-fill-color: transparent;
                animation: fadeIn 1.8s ease-in-out;
            }
            .form-group {
                margin-bottom: 20px;
                width: 100%;
                animation: fadeIn 2s ease-in-out;
            }
            .form-group label {
                display: block;
                margin-bottom: 10px;
                font-weight: bold;
                font-size: 16px;
                color: #c0c0c0;
            }
            .form-group input {
                width: calc(100% - 22px);
                padding: 12px;
                border: 1px solid #444;
                border-radius: 5px;
                font-size: 16px;
                background-color: #2c2c2c;
                color: #e0e0e0;
                transition: border-color 0.3s ease;
            }
            .form-group input:focus {
                border-color: #ff6e7f;
                outline: none;
            }
            .form-group button {
                width: 100%;
                padding: 15px;
                background: linear-gradient(to right, #0f2027, #203a43, #2c5364);
                color: white;
                border: none;
                border-radius: 5px;
                cursor: pointer;
                font-size: 18px;
                font-weight: bold;
                transition: all 0.3s ease;
                margin-top: 10px;
            }
            .form-group button:hover {
                background: linear-gradient(to right, #1f4037, #99f2c8);
                box-shadow: 0 4px 15px rgba(0, 0, 0, 0.4);
            }
            .result {
                margin-top: 20px;
                padding: 20px;
                background-color: #ffffff;
                color: #000;
                border-radius: 5px;
                font-size: 16px;
                line-height: 1.5;
                box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
                animation: fadeIn 2.5s ease-in-out;
            }
            .result span {
                font-weight: bold;
                color: #ff6e7f;
            }
            .dashboard {
                display: flex;
                flex-direction: column;
                gap: 20px;
                width: 100%;
            }
            .dashboard .card {
                background-color: #212121;
                padding: 20px;
                border-radius: 10px;
                box-shadow: 0 0 20px rgba(0, 0, 0, 0.4);
                color: #fff;
                text-align: center;
                animation: fadeIn 2.2s ease-in-out;
            }
            .dashboard .card h3 {
                margin-bottom: 20px;
                font-size: 1.5em;
                color: #ff6e7f;
            }
            .dashboard .card p {
                font-size: 16px;
                color: #bbb;
            }
        </style>
    </head>
    <body>
        <div class="container">
            <h1>Cloaker Web Panel</h1>
            <div class="dashboard">
                <div class="card">
                    <h3>Генерация ключа</h3>
                    <form method="post">
                        <div class="form-group">
                            <label for="uuid">Введите HWID:</label>
                            <input type="text" id="uuid" name="uuid" placeholder="Введите HWID" required>
                            <input type="hidden" name="action" value="generate_key">
                            <button type="submit">Сгенерировать ключ</button>
                        </div>
                        {% if result and action == 'generate_key' %}
                            <div class="result"><span>Сгенерированный ключ:</span> {{ result }}</div>
                        {% endif %}
                    </form>
                </div>

                <div class="card">
                    <h3>Извлечение HWID из ключа</h3>
                    <form method="post">
                        <div class="form-group">
                            <label for="key">Введите ключ:</label>
                            <input type="text" id="key" name="key" placeholder="Введите ключ" required>
                            <input type="hidden" name="action" value="extract_uuid">
                            <button type="submit">Извлечь HWID</button>
                        </div>
                        {% if result and action == 'extract_uuid' %}
                            <div class="result"><span>Извлеченный HWID:</span> {{ result }}</div>
                        {% endif %}
                    </form>
                </div>

                <div class="card">
                    <h3>Извлечение HWID и ника</h3>
                    <form method="post">
                        <div class="form-group">
                            <label for="key_payment">Введите платёжный ключ:</label>
                            <input type="text" id="key_payment" name="key_payment" placeholder="Введите платёжный ключ" required>
                            <input type="hidden" name="action" value="extract_uuid_username">
                            <button type="submit">Извлечь HWID и Ник</button>
                        </div>
                        {% if result and action == 'extract_uuid_username' %}
                            <div class="result"><span>HWID и Ник:</span> {{ result }}</div>
                        {% endif %}
                    </form>
                </div>
            </div>
        </div>
    </body>
    </html>
    '''
    return render_template_string(html_template, result=result, action=action)

if __name__ == '__main__':
    app.run(debug=True)

 

[Wpaske Protect]

def get_hwid():
cpu_info = get_cpu_info()
disk_info = get_disk_info()
mac_address = get_mac_address()

# Комбинируем информацию и создаем хэш
hwid_raw = f"{cpu_info}-{disk_info}-{mac_address}"
hwid_hash = hashlib.sha256(hwid_raw.encode()).hexdigest()
return hwid_hash

[/CODE]

Отлично, залей на crackme чтобы было над чем поржать

 

[Whymakudov]

/del python & install low-level programming language