from sm_bc.crypto.cipher import create_sm4_cipher

# 使用推荐设置进行简单加密
cipher = create_sm4_cipher(mode='CBC', padding='PKCS7')
cipher.init(True, key, iv)
ciphertext = cipher.encrypt(plaintext)

# 解密
cipher.init(False, key, iv)
plaintext = cipher.decrypt(ciphertext)

import sm_bc
print(sm_bc.__version__)  # 0.1.0

from sm_bc.crypto.cipher import create_sm4_cipher
import secrets

# 生成随机密钥和 IV
key = secrets.token_bytes(16)  # 128 位密钥
iv = secrets.token_bytes(16)   # 128 位 IV

# 使用 CBC 模式和 PKCS#7 填充创建密码器（推荐）
cipher = create_sm4_cipher(mode='CBC', padding='PKCS7')

# 加密
cipher.init(True, key, iv)
plaintext = b"Hello, SM4 encryption!"
ciphertext = cipher.encrypt(plaintext)

# 解密
cipher.init(False, key, iv)
decrypted = cipher.decrypt(ciphertext)

assert plaintext == bytes(decrypted)

from sm_bc.crypto.digests import SM3Digest

# 创建摘要
digest = SM3Digest()

# 哈希数据
data = b"Hello, SM3!"
digest.update(data, 0, len(data))

# 获取哈希输出（32 字节 / 256 位）
hash_output = bytearray(32)
digest.do_final(hash_output, 0)

print(f"SM3 哈希: {hash_output.hex()}")

from sm_bc.crypto.signers import SM2Signer
from sm_bc.crypto.params.ec_key_parameters import ECPrivateKeyParameters, ECPublicKeyParameters
from sm_bc.math.ec_curve import SM2P256V1Curve
import secrets

# 生成密钥对
curve = SM2P256V1Curve()
d = secrets.randbelow(curve.n)  # 私钥
public_key = curve.G.multiply(d)  # 公钥

# 创建签名器
signer = SM2Signer()

# 签名消息
message = b"Message to sign"
priv_params = ECPrivateKeyParameters(d, curve.domain_params)
signer.init(True, priv_params)
signature = signer.generate_signature(message)

# 验证签名
pub_params = ECPublicKeyParameters(public_key, curve.domain_params)
signer.init(False, pub_params)
is_valid = signer.verify_signature(message, signature)

print(f"签名有效: {is_valid}")

from sm_bc.crypto.engines import SM2Engine
from sm_bc.crypto.params.ec_key_parameters import ECPrivateKeyParameters, ECPublicKeyParameters
from sm_bc.math.ec_curve import SM2P256V1Curve
import secrets

# 生成密钥对
curve = SM2P256V1Curve()
d = secrets.randbelow(curve.n)
public_key = curve.G.multiply(d)

# 创建引擎
engine = SM2Engine()

# 加密
plaintext = b"Secret message"
pub_params = ECPublicKeyParameters(public_key, curve.domain_params)
engine.init(True, pub_params)
ciphertext = engine.process_block(plaintext, 0, len(plaintext))

# 解密
priv_params = ECPrivateKeyParameters(d, curve.domain_params)
engine.init(False, priv_params)
decrypted = engine.process_block(ciphertext, 0, len(ciphertext))

assert plaintext == bytes(decrypted)

from sm_bc.crypto.engines import ZUCEngine, ZUC256Engine
from sm_bc.crypto.params import KeyParameter, ParametersWithIV
import secrets

# ZUC-128 加密
key = secrets.token_bytes(16)  # 128 位密钥
iv = secrets.token_bytes(16)   # 128 位 IV

cipher = ZUCEngine()
cipher.init(True, ParametersWithIV(KeyParameter(key), iv))

plaintext = b"Hello, ZUC-128!"
ciphertext = bytearray(len(plaintext))
cipher.process_bytes(plaintext, 0, len(plaintext), ciphertext, 0)

# ZUC-256 加密（增强安全性）
key256 = secrets.token_bytes(32)  # 256 位密钥
iv256 = secrets.token_bytes(23)   # 184 位 IV

cipher256 = ZUC256Engine(mac_bits=128)
cipher256.init(True, ParametersWithIV(KeyParameter(key256), iv256))

plaintext = b"Hello, ZUC-256!"
ciphertext = bytearray(len(plaintext))
cipher256.process_bytes(plaintext, 0, len(plaintext), ciphertext, 0)

from sm_bc.crypto.macs import ZUC128MAC, ZUC256MAC
from sm_bc.crypto.params import KeyParameter, ParametersWithIV
import secrets

# ZUC-128 MAC (128-EIA3) - 3GPP LTE/5G 完整性算法
key = secrets.token_bytes(16)
iv = secrets.token_bytes(16)

mac = ZUC128MAC(mac_bits=32)  # 32 位或 64 位 MAC
mac.init(ParametersWithIV(KeyParameter(key), iv))

message = b"Message to authenticate"
mac.update_bytes(message, 0, len(message))

tag = bytearray(mac.get_mac_size())
mac.do_final(tag, 0)

# ZUC-256 MAC (256-EIA3) - 增强安全性
key256 = secrets.token_bytes(32)
iv256 = secrets.token_bytes(23)

mac256 = ZUC256MAC(mac_bits=128)  # 64 位或 128 位 MAC
mac256.init(ParametersWithIV(KeyParameter(key256), iv256))
mac256.update_bytes(message, 0, len(message))

tag256 = bytearray(mac256.get_mac_size())
mac256.do_final(tag256, 0)