Как создать сервер проверки лицензии на Python/C++

# Пример многофакторной проверки
def verify_license(user_token, device_fingerprint):
    # Проверка токена пользователя
    if not validate_token(user_token):
        return False
    
    # Проверка отпечатка устройства
    if not validate_device(device_fingerprint):
        return False
    
    # Проверка временного ключа
    if not validate_temp_key():
        return False
    
    return True

// Пример привязки к аппаратному обеспечению
#include <iostream>
#include <string>
#include <sstream>

std::string getHardwareFingerprint() {
    std::stringstream ss;
    // Собираем уникальные идентификаторы оборудования
    ss << "CPU_ID:" << getCPUId() << "|";
    ss << "MOTHERBOARD:" << getMotherboardId() << "|";
    ss << "DISK:" << getDiskId();
    return ss.str();
}

# Пример обнаружения отладчика
import ctypes
import sys

def is_debugger_present():
    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
    return kernel32.IsDebuggerPresent() != 0

if is_debugger_present():
    # Действия при обнаружении отладчика
    sys.exit(1)

Клиент (Python/C++) → Сервер лицензий → База данных
     ↑                    ↓              ↓
 Интерфейс пользователя → Логика проверки → Хранилище ключей

from flask import Flask, request, jsonify
import sqlite3
import hashlib
import secrets

app = Flask(__name__)

def get_db_connection():
    conn = sqlite3.connect('licenses.db')
    conn.row_factory = sqlite3.Row
    return conn

@app.route('/activate', methods=['POST'])
def activate_license():
    data = request.json
    activation_key = data.get('activation_key')
    hardware_id = data.get('hardware_id')
    
    # Проверка ключа активации
    conn = get_db_connection()
    cursor = conn.cursor()
    
    cursor.execute('SELECT * FROM activation_keys WHERE key = ?', (activation_key,))
    key_data = cursor.fetchone()
    
    if not key_data or key_data['used']:
        return jsonify({'error': 'Invalid activation key'}), 400
    
    # Генерация постоянного ключа
    permanent_key = secrets.token_hex(32)
    encrypted_key = encrypt_key(permanent_key, hardware_id)
    
    # Сохранение ключа
    cursor.execute(
        'INSERT INTO permanent_keys (user_id, hardware_id, key) VALUES (?, ?, ?)',
        (key_data['user_id'], hardware_id, encrypted_key)
    )
    
    # Отметка ключа как использованного
    cursor.execute(
        'UPDATE activation_keys SET used = 1 WHERE key = ?',
        (activation_key,)
    )
    
    conn.commit()
    conn.close()
    
    return jsonify({'permanent_key': permanent_key})

@app.route('/verify', methods=['POST'])
def verify_license():
    data = request.json
    permanent_key = data.get('permanent_key')
    hardware_id = data.get('hardware_id')
    
    conn = get_db_connection()
    cursor = conn.cursor()
    
    cursor.execute(
        'SELECT * FROM permanent_keys WHERE key = ? AND hardware_id = ?',
        (permanent_key, hardware_id)
    )
    
    license_data = cursor.fetchone()
    conn.close()
    
    if license_data:
        return jsonify({'valid': True})
    else:
        return jsonify({'valid': False}), 401

if __name__ == '__main__':
    app.run(ssl_context='adhoc')  # Запуск с SSL

import requests
import hashlib
import json
import os
from cryptography.fernet import Fernet

class LicenseManager:
    def __init__(self, server_url):
        self.server_url = server_url
        self.license_file = 'license.dat'
        self.temp_files = []
        
    def activate(self, activation_key):
        """Активация программы с помощью ключа активации"""
        hardware_id = self.get_hardware_id()
        
        response = requests.post(
            f'{self.server_url}/activate',
            json={
                'activation_key': activation_key,
                'hardware_id': hardware_id
            },
            verify=True  # Проверка SSL-сертификата
        )
        
        if response.status_code == 200:
            data = response.json()
            self.save_license(data['permanent_key'])
            return True
        return False
    
    def verify_license(self):
        """Проверка лицензии при запуске"""
        if not os.path.exists(self.license_file):
            return False
        
        with open(self.license_file, 'r') as f:
            permanent_key = f.read().strip()
        
        hardware_id = self.get_hardware_id()
        
        response = requests.post(
            f'{self.server_url}/verify',
            json={
                'permanent_key': permanent_key,
                'hardware_id': hardware_id
            },
            verify=True
        )
        
        return response.json().get('valid', False)
    
    def decrypt_files(self):
        """Расшифровка файлов на время работы программы"""
        if not self.verify_license():
            raise LicenseError("Invalid license")
        
        # Загрузка ключа лицензии
        with open(self.license_file, 'r') as f:
            license_key = f.read().strip()
        
        # Генерация ключа шифрования из ключа лицензии
        encryption_key = self.derive_encryption_key(license_key)
        cipher = Fernet(encryption_key)
        
        # Расшифровка файлов
        encrypted_files = ['module1.pyc', 'config.json', 'assets.bin']
        
        for file in encrypted_files:
            if os.path.exists(file):
                self.decrypt_file(file, cipher)
                self.temp_files.append(file)
    
    def encrypt_file(self, filename, cipher):
        """Шифрование файла"""
        with open(filename, 'rb') as f:
            data = f.read()
        
        encrypted_data = cipher.encrypt(data)
        
        with open(filename + '.enc', 'wb') as f:
            f.write(encrypted_data)
        
        os.remove(filename)
    
    def decrypt_file(self, filename, cipher):
        """Расшифровка файла"""
        with open(filename + '.enc', 'rb') as f:
            encrypted_data = f.read()
        
        decrypted_data = cipher.decrypt(encrypted_data)
        
        with open(filename, 'wb') as f:
            f.write(decrypted_data)
    
    def get_hardware_id(self):
        """Получение уникального идентификатора оборудования"""
        try:
            import platform
            import uuid
            
            # Собираем информацию о системе
            system_info = {
                'machine': platform.machine(),
                'node': platform.node(),
                'processor': platform.processor(),
            }
            
            # Генерация хеша от информации о системе
            system_string = json.dumps(system_info, sort_keys=True)
            hardware_id = hashlib.sha256(system_string.encode()).hexdigest()
            
            return hardware_id
        except Exception as e:
            print(f"Error getting hardware ID: {e}")
            return hashlib.sha256(b'unknown').hexdigest()
    
    def save_license(self, license_key):
        """Сохранение ключа лицензии"""
        with open(self.license_file, 'w') as f:
            f.write(license_key)
    
    def derive_encryption_key(self, license_key):
        """Производный ключ шифрования из ключа лицензии"""
        from cryptography.hazmat.primitives import hashes
        from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
        
        password = license_key.encode()
        salt = b'salt'  # В реальном приложении используйте случайную соль
        
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=100000,
        )
        
        key = kdf.derive(password)
        return Fernet(base64.urlsafe_b64encode(key))

# Пример использования в программе
if __name__ == "__main__":
    license_manager = LicenseManager('https://your-license-server.com')
    
    # Проверка лицензии при запуске
    if not license_manager.verify_license():
        print("Программа не активирована")
        activation_key = input("Введите ключ активации: ")
        
        if license_manager.activate(activation_key):
            print("Программа успешно активирована")
        else:
            print("Неверный ключ активации")
            exit(1)
    
    # Расшифровка файлов на время работы
    try:
        license_manager.decrypt_files()
        
        # Основной код программы
        print("Программа запущена")
        
    except LicenseError as e:
        print(f"Ошибка лицензии: {e}")
        exit(1)
    finally:
        # Очистка временных файлов
        for file in license_manager.temp_files:
            if os.path.exists(file + '.enc'):
                os.remove(file + '.enc')