import base64
import ctypes
import os
from ctypes import c_void_p, c_char_p, c_int, create_string_buffer, POINTER

# 加载 OpenSSL 动态库
libcrypto = ctypes.CDLL("libcrypto.so")  # 根据系统选择动态库路径（Linux）

# 设置 OpenSSL 相关的函数原型
libcrypto.EVP_CIPHER_CTX_new.restype = c_void_p
libcrypto.EVP_CIPHER_CTX_new.argtypes = []

libcrypto.EVP_CIPHER_CTX_free.argtypes = [c_void_p]

libcrypto.EVP_CIPHER_CTX_get_params.argtypes = [c_void_p, POINTER(c_void_p)]
libcrypto.EVP_CIPHER_free.argtypes = [c_void_p]

libcrypto.EVP_EncryptInit_ex.argtypes = [
    c_void_p,
    c_void_p,
    c_void_p,
    c_char_p,
    c_char_p,
]
libcrypto.EVP_EncryptUpdate.argtypes = [
    c_void_p,
    c_char_p,
    POINTER(c_int),
    c_char_p,
    c_int,
]
libcrypto.EVP_EncryptFinal_ex.argtypes = [c_void_p, c_char_p, POINTER(c_int)]

libcrypto.EVP_DecryptInit_ex.argtypes = [
    c_void_p,
    c_void_p,
    c_void_p,
    c_char_p,
    c_char_p,
]
libcrypto.EVP_DecryptUpdate.argtypes = [
    c_void_p,
    c_char_p,
    POINTER(c_int),
    c_char_p,
    c_int,
]
libcrypto.EVP_DecryptFinal_ex.argtypes = [c_void_p, c_char_p, POINTER(c_int)]

libcrypto.EVP_aes_256_gcm.restype = c_void_p
libcrypto.EVP_aes_256_gcm.argtypes = []

libcrypto.EVP_CIPHER_fetch.argtypes = [c_void_p, c_char_p, c_void_p]
libcrypto.EVP_CIPHER_fetch.restype = c_void_p

libcrypto.EVP_CIPHER_CTX_ctrl.argtypes = [c_void_p, c_int, c_int, c_void_p]
libcrypto.EVP_CIPHER_CTX_ctrl.restype = c_int
# (ctx, EVP_CTRL_AEAD_SET_IVLEN, sizeof(gcm_iv), NULL)
libcrypto.BIO_dump_fp.argtypes = [c_void_p, c_void_p, c_int]
libcrypto.BIO_dump_fp.restype = c_int
libcrypto.fopen.argtypes = [c_char_p, c_char_p]
libcrypto.fopen.restype = c_void_p


# AES GCM加密
def aes_256_gcm_encrypt(key: bytes, iv: bytes, plaintext: bytes, aad: bytes = b""):
    key_ptr = c_char_p(key)
    iv_ptr = c_char_p(iv)

    # 创建加密上下文
    ctx = libcrypto.EVP_CIPHER_CTX_new()
    cipher = libcrypto.EVP_aes_256_gcm()
    #    print(11111)
    #    cipher = libcrypto.EVP_CIPHER_fetch(
    #        libctx, c_char_p(b"AES-256-GCM"), propq)
    #    print(ctypes.cast(cipher, c_void_p))
    #    print(11111)

    # 初始化加密操作
    print(2222)
    ls = libcrypto.EVP_EncryptInit_ex(ctx, cipher, None, None, None)
    print(ls)

    print(2222)
    libcrypto.EVP_CIPHER_CTX_ctrl(ctx, c_int(0x9), c_int(len(iv)), None)
    print(333)
    libcrypto.EVP_EncryptInit_ex(ctx, None, None, key_ptr, iv_ptr)
    print(444)
    # 处理AAD（附加认证数据）
    outlen = c_int(0)
    libcrypto.EVP_EncryptUpdate(
        ctx, None, ctypes.byref(outlen), c_char_p(aad), c_int(len(aad))
    )
    print(555)
    # outlen = c_int(0)
    # if not libcrypto.EVP_EncryptUpdate(ctx, None, None, aad_buffer, len(aad)):
    #    raise ValueError("Error encrypting AAD")
    outbuf = create_string_buffer(len(plaintext))
    libcrypto.EVP_EncryptUpdate(
        ctx, outbuf, ctypes.byref(outlen), c_char_p(
            plaintext), c_int(len(plaintext))
    )
    print(666)

    #    # 加密明文
    #    ciphertext = create_string_buffer(len(plaintext))
    #    if not libcrypto.EVP_EncryptUpdate(
    #        ctx, ciphertext, ctypes.byref(outlen), plaintext_buffer, len(plaintext)
    #    ):
    #        raise ValueError("Error encrypting plaintext")
    print(outbuf.raw[: outlen.value].hex())
    # 获取加密后的数据
    ciphertext = outbuf.raw[: outlen.value]
    libcrypto.EVP_EncryptFinal_ex(ctx, outbuf, ctypes.byref(outlen))
    print(777)
    import sys

    libcrypto.BIO_dump_fp(
        libcrypto.fopen(b"1", b"w"),
        c_char_p(b"test"),
        len(b"test"),
    )
    libcrypto.EVP_CIPHER_CTX_ctrl(ctx, c_int(0x10), c_int(16), outbuf)

    # 获取认证标签
    #    #tag = create_string_buffer(16)
    #    if not libcrypto.EVP_EncryptFinal_ex(ctx, tag, ctypes.byref(outlen)):
    #        raise ValueError("Error finalizing encryption")

    # 释放上下文
    libcrypto.EVP_CIPHER_CTX_free(ctx)

    return ciphertext, outbuf.raw


# AES GCM 解密
def aes_256_gcm_decrypt(
    key: bytes, iv: bytes, ciphertext: bytes, aad: bytes = b"", tag: bytes = b""
):
    print("tag:", tag.hex())
    ctx = libcrypto.EVP_CIPHER_CTX_new()
    libcrypto.EVP_DecryptInit_ex(
        ctx, libcrypto.EVP_aes_256_gcm(), None, None, None)
    libcrypto.EVP_CIPHER_CTX_ctrl(ctx, c_int(0x9), len(iv), None)
    libcrypto.EVP_DecryptInit_ex(ctx, None, None, c_char_p(key), c_char_p(iv))
    outlen = c_int(0)
    libcrypto.EVP_DecryptUpdate(
        ctx, None, ctypes.byref(outlen), c_char_p(aad), len(aad)
    )
    outbuf = create_string_buffer(len(ciphertext))
    libcrypto.EVP_DecryptUpdate(
        ctx, outbuf, ctypes.byref(outlen), c_char_p(
            ciphertext), len(ciphertext)
    )
    print("Plaintext:\n")
    # BIO_dump_fp(stdout, outbuf, outlen);
    print(outbuf.raw)
    text = outbuf.raw[: outlen.value]
    print("tag:", tag)
    libcrypto.EVP_CIPHER_CTX_ctrl(ctx, c_int(0x10), len(tag), c_char_p(tag))
    rv = libcrypto.EVP_DecryptFinal_ex(ctx, outbuf, ctypes.byref(outlen))
    print(rv)

    # 释放解密上下文
    libcrypto.EVP_CIPHER_CTX_free(ctx)

    return text


# 测试数据
key = b"77889900112233445566778899001122"
print(key.hex())
iv = b"778899001122"
print(iv.hex())
plaintext = b"1231"
print(plaintext.hex())
aad = b""

# 加密过程
ciphertext, tag = aes_256_gcm_encrypt(key, iv, plaintext, aad)
print(f"Ciphertext: {ciphertext.hex()}")
print(f"Tag: {tag.hex()}")


ciphertext = base64.b64decode(
    b"BGDr211pjM/koptwkyQ7iXWTBqVf1R89Z19MPY2QiIv4/h/UNXuDjjc+uQ/9ZkJqdOfZ8MH/j+P907tbTFJhYyyd2+dqyEzBSEKq8RlpZIbHyYcnw6XRdA4c4HiAcB0ZzW8Qu3gMnH3DydMSNHwx1r7oEGewL/2SgejQemo3wK7BlpKWAJ7oX/pXCrS3JRRKHE8QG6piJLyUBB+GwuggNbE7sev7StGjezNoD2y0w0gTagKfF4C/5bVxmxbDX+DFSTfPIwA7KhRa58Vm3vL2kf+RBi1/aL9SA2+a1E6uJEAt/EEzZJ+4UJPljqIkQOAEwmD99ijG1smrRfmMkXdwmEOYeckYNwoUQbPv1wOI40UfOh2etmu9nzmuSsoNDWGJza9x4CwOXlIHvPbZtBbYO20mBy0W2byx7dh+vGbzeLgBJ8IWbHc50DNAV6GA/sxifcZPZs8USn42WoKtuKqrUVq28H+faCNvaVdSbI+ZUSG6F/euDMVdguWMlfub4J3KLxC346MDCRoX6bEXG3J4+Mo7JPi+xfoh2JKewHF2D4RgJIEkPt9ffhEDKG7jtJGSzYYqfKBEVU2/vDuGV8Y+nHmsGFcbCiM1I7onmMS1L977O0UEMwvz8cIjnXd9kRMhGrBU6yR0DvEZ67K3a5wCxbwEbNaWPy5n2oDUF3mWESXSMSIgdN6qcgpok95xegLmcEkKtp4MYdd/cT7IS2qtWJmNJKiAqg=="
)

tag = b""

iv = base64.b64decode(b"eorS/CBlfWrqeWWj")
print(iv.hex())
key = b"4e3b9ft1a68eb6548af9y895c1b14ad5"
# 解密过程
try:
    decrypted_plaintext = aes_256_gcm_decrypt(key, iv, ciphertext, aad, tag)
    print(decrypted_plaintext[:-16])
except ValueError as e:
    print(e)

import ctypes
import sys
import base64
from ctypes import c_char_p, c_void_p, POINTER

# 加载 OpenSSL 动态库（Linux 下通常是 libcrypto.so）
libcrypto = ctypes.CDLL("libcrypto.so")  # 根据系统调整库的路径

# 定义 C 函数原型
libcrypto.PEM_read_RSAPrivateKey.argtypes = [
    c_void_p,
    POINTER(c_void_p),
    c_void_p,
    c_void_p,
]
libcrypto.PEM_read_RSAPrivateKey.restype = c_void_p  # 返回类型是 RSA*

# 打开私钥文件的 C 函数
libcrypto.fopen.argtypes = [c_char_p, c_char_p]
libcrypto.fopen.restype = c_void_p  # 返回 FILE*，即 void*
# 定义 C 函数原型
libcrypto.BN_bn2hex.argtypes = [c_void_p]
libcrypto.BN_bn2hex.restype = c_char_p  # 返回类型是 C 字符串

libcrypto.BN_bn2dec.argtypes = [c_void_p]
libcrypto.BN_bn2dec.restype = c_char_p  # 返回类型是 C 字符串


# 打开文件
def open_file(filename):
    return libcrypto.fopen(filename.encode("utf-8"), b"r")


# RSA_get0_key: 获取 RSA 密钥的模数和公钥指数
libcrypto.RSA_get0_key.argtypes = [
    c_void_p,
    POINTER(c_void_p),
    POINTER(c_void_p),
    c_void_p,
]
libcrypto.RSA_get0_key.restype = None  # 返回类型是 void


# 打印 RSA 密钥信息
def print_rsa_info(rsa):
    if rsa is None:
        print("RSA key is NULL.")
        return

    # 获取模数和公钥指数
    n = c_void_p()
    e = c_void_p()
    libcrypto.RSA_get0_key(rsa, ctypes.byref(n), ctypes.byref(e), None)

    # 打印模数 (n)
    print("RSA Key Info:")
    print("  Modulus (n):")

    # 使用 sys.stdout 获取 FILE* 类型
    n_hex = libcrypto.BN_bn2hex(n)
    print(n_hex.decode())  # 打印十六进制表示
    # libcrypto.BN_print_fp(stdout_fp, n)  # 输出到标准输出

    print("\n  Public exponent (e):")
    e_hex = libcrypto.BN_bn2hex(e)
    print(e_hex.decode())  # 打印十六进制表示
    # libcrypto.BN_print_fp(stdout_fp, e)  # 输出到标准输出

    # 获取 RSA 密钥的大小
    bits = (
        libcrypto.RSA_size(ctypes.cast(rsa, c_void_p)) * 8
    )  # RSA_size 返回字节数，乘以 8 转换为位数
    print(f"  Key size: {bits} bits")


# 错误打印函数
libcrypto.ERR_print_errors_fp.argtypes = [c_void_p]
libcrypto.ERR_print_errors_fp.restype = None


# 加载私钥
def load_private_key(privkey_filename):
    # 打开文件
    privkey_file = open_file(privkey_filename)
    if not privkey_file:
        print("Unable to open private key file")
        return None

    # 加载 RSA 私钥
    rsa = libcrypto.PEM_read_RSAPrivateKey(privkey_file, None, None, None)
    if not rsa:
        print("Unable to load private key")
        libcrypto.ERR_print_errors_fp(None)  # 输出 OpenSSL 错误
        return None

    print(f"Private key loaded successfully from {privkey_filename}.")
    return rsa


# 使用示例
privkey_filename = "private_key.pem"
rsa_privkey = load_private_key(privkey_filename)

if rsa_privkey:
    print("Private key loaded successfully")
    print_rsa_info(rsa_privkey)
else:
    print("Failed to load private key")


# 分块加密
def encrypt_rsa(rsa, data):
    rsa_len = libcrypto.RSA_size(ctypes.cast(rsa, c_void_p))
    block_size = rsa_len - 11  # 最大加密块大小：RSA_size - 填充空间

    encrypted_data = ctypes.create_string_buffer(
        rsa_len * ((len(data) // block_size) + 1)
    )

    data_len = len(data)
    encrypted_len = 0
    i = 0

    while i < data_len:
        chunk_len = min(block_size, data_len - i)
        # 对当前块进行加密
        len_encrypted = libcrypto.RSA_private_encrypt(
            chunk_len,
            ctypes.byref(ctypes.create_string_buffer(data[i: i + chunk_len])),
            ctypes.byref(encrypted_data, encrypted_len),
            ctypes.cast(rsa, c_void_p),
            1,  # RSA_PKCS1_OAEP_PADDING
        )

        if len_encrypted == -1:
            print("RSA encryption failed")
            libcrypto.ERR_print_errors_fp(sys.stderr)
            return None

        encrypted_len += len_encrypted
        i += chunk_len

    return encrypted_data.raw[:encrypted_len]


# 待加密的数据
# data = b"Hello, RSA encryption! This is a long message that will be split into multiple blocks."
data = """
test_-------TEST
""".encode("utf-8")

print(f"Original Data (length: {len(data)}):\n{data.decode()}")

# 加密
encrypted_data = encrypt_rsa(rsa_privkey, data)
if encrypted_data is None:
    sys.exit(1)

print(f"\nEncrypted Data (length: {len(encrypted_data)}):")
print(" ".join(f"{byte:02x}" for byte in encrypted_data))
print(base64.b64encode(encrypted_data))

import ctypes
import base64
import sys
from ctypes import c_char_p, c_void_p, POINTER

# 加载 OpenSSL 动态库（Linux 下通常是 libcrypto.so）
libcrypto = ctypes.CDLL("libcrypto.so")  # 根据系统调整库的路径

# 用于错误处理
libcrypto.ERR_print_errors_fp.argtypes = [c_void_p]

# 打开私钥文件的 C 函数
libcrypto.fopen.argtypes = [c_char_p, c_char_p]
libcrypto.fopen.restype = c_void_p  # 返回 FILE*，即 void*
# 定义 C 函数原型
libcrypto.BN_bn2hex.argtypes = [c_void_p]
libcrypto.BN_bn2hex.restype = c_char_p  # 返回类型是 C 字符串

libcrypto.BN_bn2dec.argtypes = [c_void_p]
libcrypto.BN_bn2dec.restype = c_char_p  # 返回类型是 C 字符串


# 打开文件
def open_file(filename):
    return libcrypto.fopen(filename.encode("utf-8"), b"r")


# RSA_get0_key: 获取 RSA 密钥的模数和公钥指数
libcrypto.RSA_get0_key.argtypes = [
    c_void_p,
    POINTER(c_void_p),
    POINTER(c_void_p),
    c_void_p,
]
libcrypto.RSA_get0_key.restype = None  # 返回类型是 void


# 打印 RSA 密钥信息
def print_rsa_info(rsa):
    if rsa is None:
        print("RSA key is NULL.")
        return

    # 获取模数和公钥指数
    n = c_void_p()
    e = c_void_p()
    libcrypto.RSA_get0_key(rsa, ctypes.byref(n), ctypes.byref(e), None)

    # 打印模数 (n)
    print("RSA Key Info:")
    print("  Modulus (n):")

    # 使用 sys.stdout 获取 FILE* 类型
    n_hex = libcrypto.BN_bn2hex(n)
    print(n_hex.decode())  # 打印十六进制表示
    # libcrypto.BN_print_fp(stdout_fp, n)  # 输出到标准输出

    print("\n  Public exponent (e):")
    e_hex = libcrypto.BN_bn2hex(e)
    print(e_hex.decode())  # 打印十六进制表示
    # libcrypto.BN_print_fp(stdout_fp, e)  # 输出到标准输出

    # 获取 RSA 密钥的大小
    bits = (
        libcrypto.RSA_size(ctypes.cast(rsa, c_void_p)) * 8
    )  # RSA_size 返回字节数，乘以 8 转换为位数
    print(f"  Key size: {bits} bits")


# 定义 C 函数原型
libcrypto.PEM_read_RSA_PUBKEY.argtypes = [
    c_void_p, c_void_p, c_void_p, c_void_p]
libcrypto.PEM_read_RSA_PUBKEY.restype = c_void_p  # 返回 RSA 对象指针


# 加载 RSA 公钥并打印信息
def load_public_key(pubkey_filename):
    try:
        # 打开文件并加载公钥
        public_file = open_file(pubkey_filename)

        if not public_file:
            print("Unable to open private key file")
            return None
        # 创建 C 字符串指针，指向文件内容
        # buffer = ctypes.create_string_buffer(file_data)

        # 加载 RSA 公钥
        rsa1 = libcrypto.PEM_read_RSA_PUBKEY(public_file, None, None, None)

        if not rsa1:
            print("Failed to load public key.")
            libcrypto.ERR_print_errors_fp(sys.stderr)  # 打印 OpenSSL 错误
            return None

        print(f"Public key loaded successfully from {pubkey_filename}.")
        return rsa1

    except Exception as e:
        print(f"An error occurred: {e}")
        return None


# 使用示例
pubkey_filename = "public_key.pem"
rsa_pubkey = load_public_key(pubkey_filename)

if rsa_pubkey:
    print("Private key loaded successfully")
    print_rsa_info(rsa_pubkey)
else:
    print("Failed to load private key")


# 分块解密
def decrypt_rsa(rsa, encrypted_data):
    rsa_len = libcrypto.RSA_size(ctypes.cast(rsa, c_void_p))
    block_size = rsa_len
    encrypted_len = len(encrypted_data)

    decrypted_data = ctypes.create_string_buffer(encrypted_len)

    decrypted_len = 0
    i = 0

    while i < encrypted_len:
        # 对当前块进行解密
        len_decrypted = libcrypto.RSA_public_decrypt(
            block_size,
            ctypes.byref(
                ctypes.create_string_buffer(encrypted_data[i: i + block_size])
            ),
            ctypes.byref(decrypted_data, decrypted_len),
            ctypes.cast(rsa, c_void_p),
            1,  # RSA_PKCS1_OAEP_PADDING
        )

        if len_decrypted == -1:
            print("RSA decryption failed")
            libcrypto.ERR_print_errors_fp(sys.stderr)
            return None

        decrypted_len += len_decrypted
        i += block_size

    return decrypted_data.raw[:decrypted_len]


encrypted_base64 = b"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"
encrypted_data = base64.b64decode(encrypted_base64)

# 解密
decrypted_data = decrypt_rsa(rsa_pubkey, encrypted_data)
if decrypted_data is None:
    sys.exit(1)

print(f"\nDecrypted Data:\n{decrypted_data.decode()}")