仅供测试使用，实际可用效果待后续测试。

[login]

1. 根据内容，获取uuid。

#!/bin/bash

# 设置脚本在遇到错误时立即退出
set -e

# 函数：获取 Linux 系统的第一个 MAC 地址
get_first_mac_linux() {
    # 使用 ip 命令获取所有网络接口的 MAC 地址，提取第一个
    FIRST_MAC=$(ip link show | awk '/ether/ {print $2}' | head -n 1)
    echo "$FIRST_MAC"
}

# 函数：获取 macOS 系统的第一个 MAC 地址
get_first_mac_macos() {
    # 使用 ifconfig 命令获取所有网络接口的 MAC 地址，提取第一个
    FIRST_MAC=$(ifconfig | awk '/ether/ {print $2}' | head -n 1)
    echo "$FIRST_MAC"
}

# 函数：计算 MD5 哈希值
compute_md5() {
    local INPUT="$1"
    local OS_TYPE="$2"

    if [[ "$OS_TYPE" == "Linux" ]]; then
        # 在 Linux 上使用 md5sum
        echo -n "$INPUT" | md5sum | awk '{print $1}'
    elif [[ "$OS_TYPE" == "Darwin" ]]; then
        # 在 macOS 上使用 md5
        echo -n "$INPUT" | md5 | awk '{print $NF}'
    else
        echo "不支持的操作系统。无法计算 MD5。"
        exit 1
    fi
}

# 主函数
main() {
    # 获取操作系统类型
    OS_TYPE="$(uname)"

    case "$OS_TYPE" in
        Linux*)
            MAC_ADDRESS=$(get_first_mac_linux)
            ;;
        Darwin*)
            MAC_ADDRESS=$(get_first_mac_macos)
            ;;
        *)
            echo "不支持的操作系统。无法获 MAC 地址。"
            exit 1
            ;;
    esac

    # 检查是否成功获取 MAC 地址
    if [[ -z "$MAC_ADDRESS" ]]; then
        echo "未能获取到 MAC 地址。"
        exit 1
    fi

    #echo "获取到的第一个 MAC 地址: $MAC_ADDRESS"

    # 计算 MD5 哈希值
    MAC_MD5=$(compute_md5 "$MAC_ADDRESS" "$OS_TYPE")
    #echo "MAC 地址的 MD5 哈希值: $MAC_MD5"
    echo "$MAC_MD5"
}

# 执行主函数
main

2. 根据uuid生成license。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import base64
import json
import random
import string
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes

# ------------------ 1. AES 加密函数（与 aes.go 完全一致） ------------------
def aes_encrypt_cbc(plaintext: str, key: str) -> str:
    """
    模拟 encryption.AesEncrypt
    模式: AES-CBC, IV = key[:16], 填充: PKCS7
    返回: Base64 编码的密文
    """
    key_bytes = key.encode('utf-8')
    if len(key_bytes) not in (16, 24, 32):
        raise ValueError(f"Key length {len(key_bytes)} invalid, must be 16/24/32")
    iv = key_bytes[:16]                     # IV = 密钥的前16字节
    cipher = AES.new(key_bytes, AES.MODE_CBC, iv)
    padded_data = pad(plaintext.encode('utf-8'), AES.block_size)
    ciphertext = cipher.encrypt(padded_data)
    return base64.b64encode(ciphertext).decode('utf-8')


# ------------------ 2. RSA 签名函数（与 rsa.go 一致） ------------------
def rsa_sign(data: str, private_key_pem: str) -> str:
    """
    使用 RSA 私钥对 data 进行签名
    算法: SHA256 + PKCS1v15
    返回: Base64 编码的签名
    """
    key = RSA.import_key(private_key_pem)
    h = SHA256.new(data.encode('utf-8'))
    signature = pkcs1_15.new(key).sign(h)
    return base64.b64encode(signature).decode('utf-8')


# ------------------ 3. 生成授权 JSON（可自定义） ------------------
def build_auth_json(uid="test_user", phone="13800000000", auth_id="AUTH123",
                    server_id="test_server_id", product="cloud_waf",
                    end_time=None, auth_type=1, sites=100,
                    smart_cc=1, location=3) -> str:
    """
    构造 Authorization 结构体的 JSON
    auth_type: 0=免费,1=专业,2=旗舰,3=企业
    """
    if end_time is None:
        import time
        end_time = int(time.time()) + 365 * 24 * 3600 * 125 # 125年后过期

    auth_info = {
        "product": product,
        "uid": uid,
        "phone": phone,
        "auth_id": auth_id,
        "server_id": server_id,
        "end_time": end_time,
        "auth": {
            "menu": [],
            "pages": [],
            "apis": ["*"],          # 可根据需要放行 API
            "extra": {
                "type": auth_type,
                "site": sites,
                "smart_cc": smart_cc,
                "location": location
            },
            "site_map": {}          # 解析时会根据 type 自动填充
        }
    }
    return json.dumps(auth_info, separators=(',', ':'))


# ------------------ 4. 生成完整 License ------------------
def generate_license(auth_json: str, rsa_public_key_str: str, rsa_private_key_pem: str) -> str:
    """
    生成最终的 license 字符串（尚未 Base64 编码）
    结构: part0.part1.part2.signature
         part0 = AES(sessionKey, auth_json)
         part1 = AES(fixedKey, sessionKey)
         part2 = new RSA public key (可选，这里强制加入)
         signature = RSA_sign(part0 + "." + part1 + "." + part2)
    """
    # 4.1 固定密钥 fixedKey = RSA公钥字符串的前32个字符
    fixed_key = rsa_public_key_str[:32]
    print(f"[*] fixed_key (公钥前32字符): {fixed_key}")

    # 4.2 随机生成 sessionKey (32字节，即32个字符的字符串)
    session_key = ''.join(random.choices(string.ascii_letters + string.digits, k=32))
    print(f"[*] 生成的 session_key: {session_key}")

    # 4.3 第二层 AES 加密：用 sessionKey 加密授权 JSON -> part0
    part0 = aes_encrypt_cbc(auth_json, session_key)
    print(f"[*] part0 (长度 {len(part0)})")

    # 4.4 第一层 AES 加密：用 fixedKey 加密 sessionKey -> part1
    part1 = aes_encrypt_cbc(session_key, fixed_key)
    print(f"[*] part1 (长度 {len(part1)})")

    # 4.5 新公钥部分 part2（即我们要写入的公钥，必须是 PKIX 格式的 Base64 字符串）
    #     注意：公钥字符串不能包含换行，且需要与 fixed_key 的前32字符一致。
    part2 = rsa_public_key_str
    print(f"[*] part2 (公钥长度 {len(part2)})")

    # 4.6 拼接待签名数据
    data_to_sign = f"{part0}.{part1}.{part2}"
    print(f"[*] 待签名数据长度: {len(data_to_sign)}")

    # 4.7 RSA 签名
    signature = rsa_sign(data_to_sign, rsa_private_key_pem)
    print(f"[*] 签名长度: {len(signature)}")

    # 4.8 组合最终 license（未 Base64 编码的原始字符串）
    raw_license = f"{part0}.{part1}.{part2}.{signature}"
    return raw_license


# ------------------ 5. 主程序示例 ------------------
if __name__ == "__main__":
    # 步骤1: 生成 RSA 密钥对（也可以使用已有的）
    # 这里生成一个新的 2048 位密钥对
    print("正在生成 RSA 密钥对 (2048位)...")
    key = RSA.generate(2048)
    private_key_pem = key.export_key().decode('utf-8')
    public_key_pem = key.publickey().export_key('PEM').decode('utf-8')

    # 但是 parser.go 中使用的公钥是 PKIX 格式的 Base64 字符串（不含 PEM 头尾）
    # 我们需要将 PEM 公钥转换为 PKIX Base64
    from Crypto.PublicKey import RSA
    pub_key = RSA.import_key(public_key_pem)
    pub_key_pkix = pub_key.publickey().export_key('DER')  # DER 格式
    public_key_b64 = base64.b64encode(pub_key_pkix).decode('utf-8')
    print(f"[*] 生成的 PKIX 公钥 (Base64): {public_key_b64[:80]}...")

    # 步骤2: 构造授权 JSON（可根据需要修改）
    auth_json = build_auth_json(
        uid="",
        phone="188****8888",
        auth_id="",
        server_id="c7daad3b28b1a6e32ca8a59ae93ff1b6",   # 注意：实际系统中会和 SID() 比对，需匹配
        auth_type=3,                       # 专业版
        sites=-1,
        smart_cc=-1,
        location=-1
    )
    print(f"[*] 授权 JSON: {auth_json}")

    # 步骤3: 生成 raw license
    raw_license = generate_license(auth_json, public_key_b64, private_key_pem)

    # 步骤4: Base64 编码最终 license
    final_license = base64.b64encode(raw_license.encode('utf-8')).decode('utf-8')
    print("\n✅ 生成的 License 文件内容如下：")
    print(final_license)

    # 可选：保存到文件
    with open(".btwaf.license", "w") as f:
        f.write(final_license)
    print("\n[*] License 已保存到 .btwaf.license")

    # 同时输出公钥，以便放入 ./data/.pk（如果需要）
    with open(".pk", "w") as f:
        f.write(public_key_b64)
    print("[*] 公钥已保存到 .pk")

3. 将cloudwaf-latest中的文件打开，定位到console/CloudWaf。使用十六进制编辑器打开，屏蔽部分api.bt.cn的地址。
4. 传输到服务器，并执行 btw 1 。

[/login]