一键修改电脑机器码， 软件机器码一键修改工具， 机器码重置工具【python】

文章附件下载：https://www.pan38.com/dow/share.php?code=JCnzE 提取密码：2710

该工具实现了完整的机器码生成、加密、验证功能
使用系统硬件信息生成唯一机器码，包括MAC地址、磁盘序列号等
采用AES加密算法保护许可证数据
支持设置有效期和自定义用户数据
提供命令行界面方便使用
包含详细的错误处理和验证机制
支持Windows和Linux系统

源码部分：

import hashlib
import uuid
import platform
import socket
import re
import json
from datetime import datetime, timedelta
import base64
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

class MachineCodeGenerator:
def init(self, secret_key=None):
self.secret_key = secret_key or "default_secret_key_123!"
self.fernet = self._init_fernet()

def _init_fernet(self):
    salt = b'salt_' + self.secret_key.encode()[:16]
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
    )
    key = base64.urlsafe_b64encode(kdf.derive(self.secret_key.encode()))
    return Fernet(key)

def get_system_info(self):
    """收集系统硬件信息"""
    try:
        info = {
            'platform': platform.platform(),
            'processor': platform.processor(),
            'machine': platform.machine(),
            'mac_address': self._get_mac_address(),
            'hostname': socket.gethostname(),
            'disk_serial': self._get_disk_serial(),
            'cpu_info': self._get_cpu_info(),
            'bios_info': self._get_bios_info(),
            'baseboard_info': self._get_baseboard_info()
        }
        return info
    except Exception as e:
        print(f"Error collecting system info: {e}")
        return {}

def _get_mac_address(self):
    """获取MAC地址"""
    mac = uuid.getnode()
    return ':'.join(("%012X" % mac)[i:i+2] for i in range(0, 12, 2))

def _get_disk_serial(self):
    """获取磁盘序列号"""
    try:
        if platform.system() == 'Windows':
            import wmi
            c = wmi.WMI()
            for disk in c.Win32_DiskDrive():
                return disk.SerialNumber.strip()
        elif platform.system() == 'Linux':
            import subprocess
            result = subprocess.check_output(
                ['lsblk', '-o', 'serial', '-n', '-d'], 
                stderr=subprocess.DEVNULL
            )
            return result.decode().strip()
    except:
        return "unknown_disk"

def _get_cpu_info(self):
    """获取CPU信息"""
    try:
        if platform.system() == 'Windows':
            import wmi
            c = wmi.WMI()
            for cpu in c.Win32_Processor():
                return cpu.ProcessorId.strip()
        elif platform.system() == 'Linux':
            with open('/proc/cpuinfo', 'r') as f:
                for line in f:
                    if line.startswith('serial'):
                        return line.split(':')[1].strip()
    except:
        return "unknown_cpu"

def _get_bios_info(self):
    """获取BIOS信息"""
    try:
        if platform.system() == 'Windows':
            import wmi
            c = wmi.WMI()
            for bios in c.Win32_BIOS():
                return bios.SerialNumber.strip()
        elif platform.system() == 'Linux':
            import subprocess
            result = subprocess.check_output(
                ['dmidecode', '-s', 'bios-serial-number'],
                stderr=subprocess.DEVNULL
            )
            return result.decode().strip()
    except:
        return "unknown_bios"

def _get_baseboard_info(self):
    """获取主板信息"""
    try:
        if platform.system() == 'Windows':
            import wmi
            c = wmi.WMI()
            for board in c.Win32_BaseBoard():
                return board.SerialNumber.strip()
        elif platform.system() == 'Linux':
            import subprocess
            result = subprocess.check_output(
                ['dmidecode', '-s', 'baseboard-serial-number'],
                stderr=subprocess.DEVNULL
            )
            return result.decode().strip()
    except:
        return "unknown_board"

def generate_machine_code(self, user_data=None):
    """生成机器码"""
    system_info = self.get_system_info()
    if user_data:
        system_info.update(user_data)

    info_str = json.dumps(system_info, sort_keys=True)
    hash_obj = hashlib.sha256(info_str.encode())
    machine_code = hash_obj.hexdigest().upper()

    return {
        'machine_code': machine_code,
        'system_info': system_info,
        'timestamp': datetime.now().isoformat()
    }

def encrypt_machine_code(self, machine_code_data, expiration_days=30):
    """加密机器码"""
    data = machine_code_data.copy()
    if expiration_days:
        expire_date = datetime.now() + timedelta(days=expiration_days)
        data['expire_date'] = expire_date.isoformat()

    data_str = json.dumps(data)
    encrypted = self.fernet.encrypt(data_str.encode())
    return encrypted.decode()

def decrypt_machine_code(self, encrypted_code):
    """解密机器码"""
    try:
        decrypted = self.fernet.decrypt(encrypted_code.encode())
        data = json.loads(decrypted.decode())

        if 'expire_date' in data:
            expire_date = datetime.fromisoformat(data['expire_date'])
            if datetime.now() > expire_date:
                raise ValueError("License has expired")

        return data
    except Exception as e:
        raise ValueError(f"Invalid license code: {str(e)}")

def validate_machine_code(self, encrypted_code, current_machine_code=None):
    """验证机器码"""
    try:
        data = self.decrypt_machine_code(encrypted_code)

        if current_machine_code:
            if data.get('machine_code') != current_machine_code:
                return False, "Machine code mismatch"

        return True, "Valid license"
    except Exception as e:
        return False, str(e)

def generate_license_file(self, output_file, user_data=None, expiration_days=30):
    """生成许可证文件"""
    machine_code_data = self.generate_machine_code(user_data)
    encrypted_code = self.encrypt_machine_code(machine_code_data, expiration_days)

    license_data = {
        'license_code': encrypted_code,
        'issue_date': datetime.now().isoformat(),
        'expiration_days': expiration_days,
        'user_data': user_data or {}
    }

    with open(output_file, 'w') as f:
        json.dump(license_data, f, indent=2)

    return license_data

class MachineCodeCLI:
def init(self):
self.generator = MachineCodeGenerator()

def run(self):
    import argparse

    parser = argparse.ArgumentParser(
        description='Machine Code Generator and Validator Tool'
    )

    subparsers = parser.add_subparsers(dest='command', required=True)

    # Generate command
    gen_parser = subparsers.add_parser('generate', help='Generate machine code')
    gen_parser.add_argument(
        '--output', '-o', 
        help='Output file for the license',
        default=None
    )
    gen_parser.add_argument(
        '--user-data', '-u',
        help='Additional user data as JSON string',
        default=None
    )
    gen_parser.add_argument(
        '--expire-days', '-e',
        type=int,
        help='Number of days until license expires',
        default=30
    )

    # Validate command
    val_parser = subparsers.add_parser('validate', help='Validate machine code')
    val_parser.add_argument(
        'license_code',
        help='License code to validate'
    )
    val_parser.add_argument(
        '--current', '-c',
        help='Current machine code to compare against',
        default=None
    )

    args = parser.parse_args()

    if args.command == 'generate':
        user_data = None
        if args.user_data:
            try:
                user_data = json.loads(args.user_data)
            except json.JSONDecodeError:
                print("Error: Invalid JSON format for user data")
                return

        result = self.generator.generate_machine_code(user_data)
        print("Generated Machine Code:")
        print(result['machine_code'])
        print("\nSystem Info:")
        print(json.dumps(result['system_info'], indent=2))

        if args.output:
            license_data = self.generator.generate_license_file(
                args.output,
                user_data,
                args.expire_days
            )
            print(f"\nLicense file saved to: {args.output}")

    elif args.command == 'validate':
        is_valid, message = self.generator.validate_machine_code(
            args.license_code,
            args.current
        )

        if is_valid:
            print("Validation Result: VALID")
            print(message)
            try:
                data = self.generator.decrypt_machine_code(args.license_code)
                print("\nLicense Info:")
                print(json.dumps(data, indent=2))
            except:
                pass
        else:
            print("Validation Result: INVALID")
            print(f"Reason: {message}")

if name == 'main':
cli = MachineCodeCLI()
cli.run()