SM4 分组密码填充模式实战：PKCS7、ANSI X9.23、ISO/IEC 10126 的工程实现与踩坑指南

from cryptography.hazmat.primitives.ciphers import Cipher, modes
from cryptography.hazmat.primitives.ciphers.algorithms import SM4
from cryptography.hazmat.primitives.padding import PKCS7

key = bytes.fromhex('0123456789abcdeffedcba9876543210')
iv = bytes(16)  # CBC 模式需要 IV
data = b'Hello World!'

# 加密
padder = PKCS7(128).padder()
padded_data = padder.update(data) + padder.finalize()

cipher = Cipher(SM4(key), modes.CBC(iv))
encryptor = cipher.encryptor()
ciphertext = encryptor.update(padded_data) + encryptor.finalize()

# 解密
decryptor = cipher.decryptor()
decrypted_padded = decryptor.update(ciphertext) + decryptor.finalize()
unpadder = PKCS7(128).unpadder()
plaintext = unpadder.update(decrypted_padded) + unpadder.finalize()

assert plaintext == data

from gmssl import sm4

key = bytes.fromhex('0123456789abcdeffedcba9876543210')
data = b'Hello World!'

# gmssl 的 padding 函数返回 list，需要手动转换
def pkcs7_pad(data: bytes, block: int = 16) -> bytes:
    pad_len = block - len(data) % block
    return data + bytes([pad_len] * pad_len)

def pkcs7_unpad(data: bytes, block: int = 16) -> bytes:
    pad_len = data[-1]
    if pad_len < 1 or pad_len > block:
        raise ValueError("Invalid PKCS7 padding")
    return data[:-pad_len]

padded = pkcs7_pad(data, 16)
print(f"Padded: {padded.hex()}")  # 0x04, 0x04, 0x04, 0x04

sm4_obj = sm4.CryptSM4()
sm4_obj.set_key(key, sm4.SM4_ENCRYPT)
ct = sm4_obj.crypt_ecb(padded)

sm4_obj2 = sm4.CryptSM4()
sm4_obj2.set_key(key, sm4.SM4_DECRYPT)
pt_padded = bytes(sm4_obj2.crypt_ecb(ct))
pt = pkcs7_unpad(pt_padded, 16)
assert pt == data

from gmssl import sm4
import os

key = bytes.fromhex('0123456789abcdeffedcba9876543210')
iv = os.urandom(16)  # 随机 IV

sm4_obj = sm4.CryptSM4(mode=1, padding_mode=1)  # CBC + PKCS7 padding
sm4_obj.set_key(key, sm4.SM4_ENCRYPT)
ct = sm4_obj.crypt_cbc(iv, data)  # gmssl 的 crypt_cbc 内部处理填充

# 解密
sm4_obj2 = sm4.CryptSM4(mode=1, padding_mode=1)
sm4_obj2.set_key(key, sm4.SM4_DECRYPT)
pt = sm4_obj2.crypt_cbc(iv, ct)

from enum import Enum
from cryptography.hazmat.primitives.ciphers import Cipher, modes
from cryptography.hazmat.primitives.ciphers.algorithms import SM4
from cryptography.hazmat.primitives.padding import PKCS7
import os

class PaddingMode(Enum):
    PKCS7 = "pkcs7"
    ANSI_X923 = "ansi_x923"
    ISO_10126 = "iso_10126"

class SM4Cipher:
    BLOCK_SIZE = 16  # SM4 块大小为 16 字节

    def __init__(self, key: bytes, mode: str = "cbc"):
        if len(key) != 16:
            raise ValueError("SM4 key must be 16 bytes")
        self.key = key
        self.mode = mode.upper()
        self.iv = None

    def _get_cipher(self) -> Cipher:
        algo = SM4(self.key)
        if self.mode == "ECB":
            return Cipher(algo, mode=None)
        elif self.mode == "CBC":
            self.iv = os.urandom(self.BLOCK_SIZE)
            return Cipher(algo, modes.CBC(self.iv))
        else:
            raise ValueError(f"Unsupported mode: {self.mode}")

    def encrypt(self, plaintext: bytes, padding: PaddingMode = PaddingMode.PKCS7) -> bytes:
        """加密并返回 (ciphertext, iv)"""
        cipher = self._get_cipher()
        
        # 根据填充模式处理
        if padding == PaddingMode.PKCS7:
            padder = PKCS7(self.BLOCK_SIZE * 8).padder()
            padded = padder.update(plaintext) + padder.finalize()
        elif padding == PaddingMode.ANSI_X923:
            padded = self._ansi_x923_pad(plaintext)
        elif padding == PaddingMode.ISO_10126:
            padded = self._iso_10126_pad(plaintext)
        else:
            raise ValueError(f"Unsupported padding: {padding}")
        
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(padded) + encryptor.finalize()
        
        return ciphertext, self.iv

    def decrypt(self, ciphertext: bytes, iv: bytes = None, 
                padding: PaddingMode = PaddingMode.PKCS7) -> bytes:
        """解密"""
        if self.mode == "CBC" and iv is None:
            raise ValueError("IV required for CBC mode")
        
        algo = SM4(self.key)
        if self.mode == "ECB":
            cipher = Cipher(algo, mode=None)
        else:
            cipher = Cipher(algo, modes.CBC(iv))
        
        decryptor = cipher.decryptor()
        decrypted_padded = decryptor.update(ciphertext) + decryptor.finalize()
        
        # 根据填充模式去填充
        if padding == PaddingMode.PKCS7:
            unpadder = PKCS7(self.BLOCK_SIZE * 8).unpadder()
            return unpadder.update(decrypted_padded) + unpadder.finalize()
        elif padding in (PaddingMode.ANSI_X923, PaddingMode.ISO_10126):
            return self._unpad(decrypted_padded)
        else:
            raise ValueError(f"Unsupported padding: {padding}")

    @staticmethod
    def _ansi_x923_pad(data: bytes) -> bytes:
        pad_len = SM4Cipher.BLOCK_SIZE - (len(data) % SM4Cipher.BLOCK_SIZE)
        return data + bytes(pad_len - 1) + bytes([pad_len])

    @staticmethod
    def _iso_10126_pad(data: bytes) -> bytes:
        pad_len = SM4Cipher.BLOCK_SIZE - (len(data) % SM4Cipher.BLOCK_SIZE)
        return data + os.urandom(pad_len - 1) + bytes([pad_len])

    @staticmethod
    def _unpad(data: bytes) -> bytes:
        pad_len = data[-1]
        return data[:-pad_len]

# 数据库字段加密示例
from sqlalchemy import Column, LargeBinary
from cryptography.hazmat.primitives.ciphers import Cipher, modes
from cryptography.hazmat.primitives.ciphers.algorithms import SM4
from cryptography.hazmat.primitives.padding import PKCS7

class EncryptedField:
    def __init__(self, key: bytes):
        self.key = key
    
    def encrypt(self, plaintext: str) -> tuple[bytes, bytes]:
        data = plaintext.encode('utf-8')
        padder = PKCS7(128).padder()
        padded = padder.update(data) + padder.finalize()
        
        iv = os.urandom(16)
        cipher = Cipher(SM4(self.key), modes.CBC(iv))
        encryptor = cipher.encryptor()
        ciphertext = encryptor.update(padded) + encryptor.finalize()
        
        return ciphertext, iv
    
    def decrypt(self, ciphertext: bytes, iv: bytes) -> str:
        cipher = Cipher(SM4(self.key), modes.CBC(iv))
        decryptor = cipher.decryptor()
        decrypted = decryptor.update(ciphertext) + decryptor.finalize()
        
        unpadder = PKCS7(128).unpadder()
        plaintext = unpadder.update(decrypted) + unpadder.finalize()
        return plaintext.decode('utf-8')