InnoSetup的机器码与注册码生成与验证机制

import argparse
import ctypes
import re
import tkinter as tk
from tkinter import messagebox


MACHINE_PIVOT = 1087244140

# The running installer uses the same encoder as the machine-code field, but the
# registration pivot is 195233627.
REG_PIVOT = 195233627


def _encode_standard(value: int, pivot: int, high_prefix: str, low_prefix: str) -> str:
    if value > pivot:
        body = str(value - pivot)
        prefix = high_prefix
    else:
        body = str(pivot - value)
        prefix = low_prefix

    expanded = ""
    while len(body) > 3:
        chunk = body[:3]
        body = body[3:]
        expanded += chr(65 + (int(chunk) * 26 // 4653)) + chunk

    expanded += chr(65 + (int(body) * 26 // 4653)) + body
    return prefix + _group_left_3(expanded)


def _encode_2_3_diff(diff: int, prefix: str) -> str:
    body = str(diff)
    chunks = []

    if len(body) > 3:
        chunks.append(body[:2])
        body = body[2:]

    while len(body) > 3:
        chunks.append(body[:3])
        body = body[3:]

    if body:
        chunks.append(body)

    expanded = "".join(chr(65 + (int(chunk) * 26 // 4653)) + chunk for chunk in chunks)
    return prefix + _group_with_leading_singles(expanded)


def _group_left_3(text: str) -> str:
    parts = []
    while len(text) > 3:
        parts.append(text[:3])
        text = text[3:]
    if text:
        parts.append(text)
    return "-".join(parts)


def _group_with_leading_singles(text: str) -> str:
    parts = []
    first = min(2, len(text))
    while first:
        parts.append(text[:1])
        text = text[1:]
        first -= 1
    while text:
        parts.append(text[:3])
        text = text[3:]
    return "-".join(parts)


def _machine_prefix_and_diff(machine_id: str) -> tuple[str, int]:
    machine_id = machine_id.strip().upper()
    if machine_id.startswith("V94-"):
        prefix = "V94-"
        body = machine_id[4:]
    elif machine_id.startswith("6J7-"):
        prefix = "6J7-"
        body = machine_id[4:]
    else:
        raise ValueError("Machine code must start with V94- or 6J7-.")

    digits = "".join(re.findall(r"\d+", body))
    if not digits:
        raise ValueError("No digits found in machine code.")
    return prefix, int(digits)


def gen_machine_id(volume_serial: int) -> str:
    if volume_serial > MACHINE_PIVOT:
        return _encode_2_3_diff(volume_serial - MACHINE_PIVOT, "6J7-")
    return _encode_2_3_diff(MACHINE_PIVOT - volume_serial, "V94-")


def gen_reg_code(volume_serial: int) -> str:
    if volume_serial > REG_PIVOT:
        return _encode_2_3_diff(volume_serial - REG_PIVOT, "3P6-")
    return _encode_2_3_diff(REG_PIVOT - volume_serial, "X5B-")


def reg_code_from_machine_id(machine_id: str) -> str:
    prefix, machine_diff = _machine_prefix_and_diff(machine_id)
    if prefix == "V94-":
        serial = MACHINE_PIVOT - machine_diff
    else:
        serial = MACHINE_PIVOT + machine_diff
    return gen_reg_code(serial)


def serial_from_machine_id(machine_id: str) -> int:
    prefix, diff = _machine_prefix_and_diff(machine_id)
    if prefix == "V94-":
        return MACHINE_PIVOT - diff
    return MACHINE_PIVOT + diff


def get_volume_serial(root: str) -> int:
    serial = ctypes.c_uint32()
    ok = ctypes.windll.kernel32.GetVolumeInformationW(
        ctypes.c_wchar_p(root),
        None,
        0,
        ctypes.byref(serial),
        None,
        None,
        None,
        0,
    )
    if not ok:
        raise ctypes.WinError()
    return ctypes.c_int32(serial.value).value


def run_gui() -> None:
    root = tk.Tk()
    root.title("Inno Keygen")
    root.resizable(False, False)

    machine_var = tk.StringVar()
    serial_var = tk.StringVar()
    reg_var = tk.StringVar()
    status_var = tk.StringVar(value="Enter a machine code, then click Generate.")

    def generate() -> None:
        try:
            machine = machine_var.get()
            serial = serial_from_machine_id(machine)
            reg_code = reg_code_from_machine_id(machine)
        except Exception as exc:
            messagebox.showerror("Error", str(exc))
            return

        serial_var.set(str(serial))
        reg_var.set(reg_code)
        root.clipboard_clear()
        root.clipboard_append(reg_code)
        status_var.set("Registration code copied to clipboard.")

    def paste_and_generate() -> None:
        try:
            machine_var.set(root.clipboard_get().strip())
        except tk.TclError:
            pass
        generate()

    frame = tk.Frame(root, padx=14, pady=14)
    frame.grid(row=0, column=0)

    tk.Label(frame, text="Machine code").grid(row=0, column=0, sticky="w")
    tk.Entry(frame, textvariable=machine_var, width=44).grid(row=1, column=0, columnspan=3, pady=(4, 10))

    tk.Button(frame, text="Generate + Copy", command=generate, width=16).grid(row=2, column=0, sticky="w")
    tk.Button(frame, text="Paste + Generate", command=paste_and_generate, width=16).grid(row=2, column=1, padx=8)

    tk.Label(frame, text="Decoded serial").grid(row=3, column=0, sticky="w", pady=(12, 0))
    tk.Entry(frame, textvariable=serial_var, width=44, state="readonly").grid(row=4, column=0, columnspan=3, pady=(4, 10))

    tk.Label(frame, text="Registration code").grid(row=5, column=0, sticky="w")
    tk.Entry(frame, textvariable=reg_var, width=44, state="readonly").grid(row=6, column=0, columnspan=3, pady=(4, 10))

    tk.Label(frame, textvariable=status_var, fg="#555555").grid(row=7, column=0, columnspan=3, sticky="w")

    root.bind("<Return>", lambda _event: generate())
    root.mainloop()


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Reproduce the Inno Setup machine-code to registration-code logic."
    )
    parser.add_argument("machine", nargs="?", help="machine code such as V94-A-1-1D7-01E-893-A46")
    parser.add_argument("--root", default=None, help=r"drive root to query, for example C:\ or D:\ ")
    parser.add_argument("--machine", "-m", dest="machine_option", help="machine code such as V94-A-1-1D7-01E-893-A46")
    parser.add_argument("--serial", type=int, help="decimal volume serial number")
    parser.add_argument("--gui", action="store_true", help="open the GUI and copy generated codes")
    args = parser.parse_args()

    if args.gui or (not args.machine and not args.machine_option and not args.root and args.serial is None):
        run_gui()
        return

    machine = args.machine_option or args.machine
    if machine:
        serial = serial_from_machine_id(machine)
        print(f"volume_serial={serial}")
        print(f"machine_id={machine.strip().upper()}")
        print(f"reg_code={reg_code_from_machine_id(machine)}")
        return

    if args.root:
        serial = get_volume_serial(args.root)
    elif args.serial is not None:
        serial = args.serial

    print(f"volume_serial={serial}")
    print(f"machine_id={gen_machine_id(serial)}")
    print(f"reg_code={gen_reg_code(serial)}")


if __name__ == "__main__":
    main()