crossmool 1.3.0__py3-none-any.whl

crossmool/__init__.py

@@ -0,0 +1,11 @@
+from crossmool.sm2_util import SM2Util
+from crossmool.sm3_util import SM3Util
+from crossmool.sm4_util import SM4Util
+
+__all__ = [
+    "SM2Util",
+    "SM3Util",
+    "SM4Util",
+]
+
+__version__ = "1.3.0"

crossmool/der.py

@@ -0,0 +1,84 @@
+"""
+Minimal DER reader to parse SPKI (X.509) and PKCS8 used by crossmool JS/Java utils.
+This is a small port of the project's JS `DerReader` used to extract raw EC keys.
+"""
+from typing import Tuple
+
+
+class DerReader:
+    def __init__(self, data: bytes):
+        self.data = data
+        self.pos = 0
+        self.len = len(data)
+
+    def _read_length(self) -> int:
+        first = self._read(1)[0]
+        if first & 0x80 == 0:
+            return first
+        num = first & 0x7F
+        val = 0
+        for _ in range(num):
+            val = (val << 8) | self._read(1)[0]
+        return val
+
+    def _read(self, n: int) -> bytes:
+        if self.pos + n > self.len:
+            raise ValueError('Truncated DER')
+        out = self.data[self.pos:self.pos + n]
+        self.pos += n
+        return out
+
+    def read_sequence(self) -> 'DerReader':
+        tag = self._read(1)[0]
+        if tag != 0x30:
+            raise ValueError('Expected SEQUENCE')
+        length = self._read_length()
+        content = self._read(length)
+        return DerReader(content)
+
+    def read_integer_bytes(self) -> bytes:
+        tag = self._read(1)[0]
+        if tag != 0x02:
+            raise ValueError('Expected INTEGER')
+        length = self._read_length()
+        return self._read(length)
+
+    def read_oid(self) -> str:
+        tag = self._read(1)[0]
+        if tag != 0x06:
+            raise ValueError('Expected OID')
+        length = self._read_length()
+        oid_bytes = self._read(length)
+        # decode OID
+        first = oid_bytes[0]
+        oid_nodes = [str(first // 40), str(first % 40)]
+        value = 0
+        for b in oid_bytes[1:]:
+            value = (value << 7) | (b & 0x7F)
+            if not (b & 0x80):
+                oid_nodes.append(str(value))
+                value = 0
+        return '.'.join(oid_nodes)
+
+    def read_bit_string(self) -> Tuple[int, bytes]:
+        tag = self._read(1)[0]
+        if tag != 0x03:
+            raise ValueError('Expected BIT STRING')
+        length = self._read_length()
+        content = self._read(length)
+        unused_bits = content[0]
+        data = content[1:]
+        return unused_bits, data
+
+    def read_octet_string(self) -> bytes:
+        tag = self._read(1)[0]
+        if tag != 0x04:
+            raise ValueError('Expected OCTET STRING')
+        length = self._read_length()
+        return self._read(length)
+
+    def read(self, n: int) -> bytes:
+        return self._read(n)
+
+    def eof(self) -> bool:
+        return self.pos >= self.len

crossmool/encoding.py

@@ -0,0 +1,56 @@
+import base64
+import re
+
+
+def is_hex_string(s: str) -> bool:
+    if not isinstance(s, str):
+        return False
+    s = s.strip()
+    return bool(re.fullmatch(r"[0-9a-fA-F]+", s))
+
+
+def is_base64_string(s: str) -> bool:
+    if not isinstance(s, str):
+        return False
+    s = s.strip()
+    try:
+        # len check: base64 length divisible by 4 (with padding)
+        if len(s) % 4 != 0:
+            return False
+        base64.b64decode(s, validate=True)
+        return True
+    except Exception:
+        return False
+
+
+def hex_to_bytes(hex_str: str) -> bytes:
+    return bytes.fromhex(hex_str.strip())
+
+
+def bytes_to_hex(b: bytes) -> str:
+    return b.hex()
+
+
+def base64_to_bytes(s: str) -> bytes:
+    return base64.b64decode(s)
+
+
+def bytes_to_base64(b: bytes) -> str:
+    return base64.b64encode(b).decode('ascii')
+
+
+def detect_string_encoding(s: str) -> str:
+    s = s.strip()
+    if is_hex_string(s):
+        return 'hex'
+    if is_base64_string(s):
+        return 'base64'
+    return 'unknown'
+
+
+def utf8_to_bytes(s: str) -> bytes:
+    return s.encode('utf-8')
+
+
+def bytes_to_utf8(b: bytes) -> str:
+    return b.decode('utf-8')

crossmool/sm2_util.py

@@ -0,0 +1,497 @@
+from gmssl import sm2, func
+from crossmool.encoding import (
+    is_hex_string,
+    is_base64_string,
+    hex_to_bytes,
+    bytes_to_hex,
+    base64_to_bytes,
+    bytes_to_base64,
+    utf8_to_bytes,
+)
+from crossmool.der import DerReader
+
+# SM2 signature/verification user ID (kept identical to Java BouncyCastle)
+USER_ID = b"1234567812345678"
+
+def _ensure_uncompressed_pubhex(hexstr: str) -> str:
+    """Ensure the public key is in uncompressed form (04 + X + Y, 66 bytes / 130 hex chars)."""
+    s = hexstr.strip().lower()
+    if len(s) == 128:
+        return '04' + s
+    if len(s) == 130 and s.startswith('04'):
+        return s
+    raise ValueError('Unsupported public key hex length')
+
+def sm2_public_key_to_raw_hex(key_input) -> str:
+    """
+    Convert a public key to raw uncompressed form (04 + X + Y, 66 bytes / 130 hex chars).
+    Supports X.509 SPKI DER (HEX/Base64/bytes) and raw 64/128-char HEX.
+    """
+    if isinstance(key_input, bytes):
+        b = key_input
+    else:
+        s = key_input.strip()
+        if is_hex_string(s):
+            b = hex_to_bytes(s)
+        elif is_base64_string(s):
+            b = base64_to_bytes(s)
+        else:
+            return _ensure_uncompressed_pubhex(s)
+
+    # X.509 SPKI DER format (starts with 0x30)
+    if len(b) > 2 and b[0] == 0x30:
+        try:
+            spki = DerReader(b).read_sequence()
+            # Read algorithm identifier (SEQUENCE)
+            alg = spki.read_sequence()
+            try:
+                _ = alg.read_oid()  # EC OID
+            except Exception:
+                pass
+            try:
+                _ = alg.read_oid()  # Curve OID
+            except Exception:
+                pass
+            # Read public key BIT STRING
+            unused_bits, data = spki.read_bit_string()
+            if unused_bits != 0:
+                raise ValueError('Unsupported BIT STRING with unused bits')
+            raw = bytes_to_hex(data)
+            return _ensure_uncompressed_pubhex(raw)
+        except Exception as e:
+            raise ValueError(f'Failed to parse X.509 public key: {e}')
+
+    # fallback: assume hex string
+    return _ensure_uncompressed_pubhex(bytes_to_hex(b))
+
+def sm2_private_key_to_raw_hex(key_input) -> str:
+    """
+    Convert a private key to raw 32-byte HEX form.
+    Supports PKCS#8 DER (HEX/Base64/bytes) and raw 64-char HEX.
+    """
+    if isinstance(key_input, bytes):
+        b = key_input
+    else:
+        s = key_input.strip()
+        if is_hex_string(s):
+            if s.startswith('30'):
+                b = hex_to_bytes(s)
+            else:
+                if len(s) == 64:
+                    return s.lower()
+                b = hex_to_bytes(s)
+        elif is_base64_string(s):
+            b = base64_to_bytes(s)
+        else:
+            raise ValueError('Unsupported private key format')
+
+    if len(b) > 2 and b[0] == 0x30:
+        # parse PKCS#8 DER format
+        try:
+            pki = DerReader(b).read_sequence()
+            _ = pki.read_integer_bytes()  # version
+            _ = pki.read_sequence()  # algorithm
+            private_octets = pki.read_octet_string()
+            # Parse ECPrivateKey from OCTET STRING
+            ec = DerReader(private_octets).read_sequence()
+            _ = ec.read_integer_bytes()  # version
+            d_octets = ec.read_octet_string()  # private key bytes
+            d_hex = bytes_to_hex(d_octets)
+            if len(d_hex) < 64:
+                d_hex = d_hex.rjust(64, '0')
+            return d_hex
+        except Exception as e:
+            raise ValueError(f'Failed to parse PKCS#8 private key: {e}')
+
+    # fallback: assume raw bytes
+    hex_result = bytes_to_hex(b)
+    if len(hex_result) < 64:
+        hex_result = hex_result.rjust(64, '0')
+    return hex_result
+
+def _der_encode_int(i_bytes: bytes) -> bytes:
+    """DER-encode an INTEGER."""
+    bi = i_bytes.lstrip(b'\x00')
+    if not bi:
+        bi = b'\x00'
+    if bi[0] & 0x80:
+        bi = b'\x00' + bi
+    length = len(bi)
+    if length < 128:
+        return b'\x02' + bytes([length]) + bi
+    len_bytes = length.to_bytes((length.bit_length() + 7) // 8, 'big')
+    return b'\x02' + bytes([0x80 | len(len_bytes)]) + len_bytes + bi
+
+def _der_encode_sequence(elements: bytes) -> bytes:
+    """DER-encode a SEQUENCE."""
+    length = len(elements)
+    if length < 128:
+        return b'\x30' + bytes([length]) + elements
+    len_bytes = length.to_bytes((length.bit_length() + 7) // 8, 'big')
+    return b'\x30' + bytes([0x80 | len(len_bytes)]) + len_bytes + elements
+
+def raw_rs_to_der(r_hex: str, s_hex: str) -> bytes:
+    """Convert raw r||s into a DER-encoded signature."""
+    r = bytes.fromhex(r_hex)
+    s = bytes.fromhex(s_hex)
+    r_enc = _der_encode_int(r)
+    s_enc = _der_encode_int(s)
+    return _der_encode_sequence(r_enc + s_enc)
+
+# ────────────────── DER key encoding helpers ──────────────────
+
+OID_EC_PUBLIC_KEY = '1.2.840.10045.2.1'
+OID_SM2_CURVE = '1.2.156.10197.1.301'
+
+def _der_encode_oid(oid: str) -> bytes:
+    """DER encode an OID string."""
+    parts = [int(x) for x in oid.split('.')]
+    result = [parts[0] * 40 + parts[1]]
+    for v in parts[2:]:
+        stack = [v & 0x7f]
+        v >>= 7
+        while v > 0:
+            stack.insert(0, (v & 0x7f) | 0x80)
+            v >>= 7
+        result.extend(stack)
+    content = bytes(result)
+    if len(content) < 128:
+        return b'\x06' + bytes([len(content)]) + content
+    len_bytes = len(content).to_bytes((len(content).bit_length() + 7) // 8, 'big')
+    return b'\x06' + bytes([0x80 | len(len_bytes)]) + len_bytes + content
+
+def _der_encode_octet_string(data: bytes) -> bytes:
+    if len(data) < 128:
+        return b'\x04' + bytes([len(data)]) + data
+    len_bytes = len(data).to_bytes((len(data).bit_length() + 7) // 8, 'big')
+    return b'\x04' + bytes([0x80 | len(len_bytes)]) + len_bytes + data
+
+def _der_encode_bit_string(data: bytes, unused_bits: int = 0) -> bytes:
+    content = bytes([unused_bits]) + data
+    if len(content) < 128:
+        return b'\x03' + bytes([len(content)]) + content
+    len_bytes = len(content).to_bytes((len(content).bit_length() + 7) // 8, 'big')
+    return b'\x03' + bytes([0x80 | len(len_bytes)]) + len_bytes + content
+
+def _der_encode_context_specific(tag_number: int, content: bytes) -> bytes:
+    tag = 0xa0 | tag_number
+    if len(content) < 128:
+        return bytes([tag, len(content)]) + content
+    len_bytes = len(content).to_bytes((len(content).bit_length() + 7) // 8, 'big')
+    return bytes([tag, 0x80 | len(len_bytes)]) + len_bytes + content
+
+def _encode_public_key_to_der(pub_hex: str) -> bytes:
+    """Encode raw-hex public key (130 chars, 04+X+Y) to X.509 SPKI DER."""
+    pub_bytes = bytes.fromhex(pub_hex)  # 65 bytes
+    alg_seq = _der_encode_sequence(
+        _der_encode_oid(OID_EC_PUBLIC_KEY) + _der_encode_oid(OID_SM2_CURVE)
+    )
+    return _der_encode_sequence(alg_seq + _der_encode_bit_string(pub_bytes, 0))
+
+def _encode_private_key_to_der(priv_hex: str, pub_hex: str) -> bytes:
+    """Encode raw-hex keys to PKCS#8 PrivateKeyInfo DER."""
+    d = bytes.fromhex(priv_hex)  # 32 bytes
+    pub = bytes.fromhex(pub_hex)  # 65 bytes
+    # ECPrivateKey (SEC1)
+    ec_priv = _der_encode_sequence(
+        _der_encode_int(b'\x01') +
+        _der_encode_octet_string(d) +
+        _der_encode_context_specific(1, _der_encode_bit_string(pub, 0))
+    )
+    # AlgorithmIdentifier
+    alg_seq = _der_encode_sequence(
+        _der_encode_oid(OID_EC_PUBLIC_KEY) + _der_encode_oid(OID_SM2_CURVE)
+    )
+    return _der_encode_sequence(
+        _der_encode_int(b'\x00') + alg_seq + _der_encode_octet_string(ec_priv)
+    )
+
+def der_to_raw_rs(der_sig: bytes) -> (str, str):
+    """Convert a DER-encoded signature back to r||s (strip DER INTEGER sign padding)."""
+    d = DerReader(der_sig).read_sequence()
+    r = d.read_integer_bytes()
+    s = d.read_integer_bytes()
+    # strip the leading 0x00 that DER INTEGER may add to represent a positive number
+    r = r.lstrip(b'\x00') or b'\x00'
+    s = s.lstrip(b'\x00') or b'\x00'
+    r_hex = bytes_to_hex(r).rjust(64, '0')
+    s_hex = bytes_to_hex(s).rjust(64, '0')
+    return r_hex, s_hex
+
+def _new_crypt(private_key='', public_key_hex=None, mode=0):
+    """
+    Construct a gmssl CryptSM2 instance while bypassing its __init__ lstrip("04")
+    bug (which strips every leading '0'/'4' char instead of only the "04" prefix).
+    gmssl internally expects the public key as 128 hex chars (X+Y, no 04 prefix).
+    """
+    crypt = sm2.CryptSM2(private_key=private_key, public_key='', mode=mode)
+    if public_key_hex is not None:
+        pub = public_key_hex.strip()
+        if pub.startswith('04') and len(pub) == 130:
+            pub = pub[2:]
+        crypt.public_key = pub
+    return crypt
+
+class SM2Util:
+    """
+    SM2 encryption/decryption/signature utility class.
+    Compatible with Java BouncyCastle SM2Engine (C1C3C2) and SM2Signer.
+
+    Fully based on the low-level gmssl library to guarantee interop with Java BouncyCastle.
+    """
+
+    @staticmethod
+    def generate_keypair_raw() -> (str, str):
+        """Generate a raw keypair (private_hex, public_hex)."""
+        priv = func.random_hex(64)
+        temp_crypt = sm2.CryptSM2(private_key=priv, public_key='04' + '00' * 64)
+        pub = temp_crypt._kg(int(priv, 16), temp_crypt.ecc_table['g'])
+        if not pub.startswith('04'):
+            pub = '04' + pub
+        return priv.lower(), pub.lower()
+
+    @staticmethod
+    def generate_keypair_hex() -> dict:
+        """Generate a HEX keypair, returning {'publicKey': ..., 'privateKey': ...} (public key 130 chars, private key 64 chars)."""
+        priv_hex, pub_hex = SM2Util.generate_keypair_raw()
+        return {'publicKey': pub_hex, 'privateKey': priv_hex}
+
+    @staticmethod
+    def generate_keypair_base64() -> dict:
+        """Generate a Base64 keypair, returning {'publicKey': ..., 'privateKey': ...}."""
+        priv_hex, pub_hex = SM2Util.generate_keypair_raw()
+        return {
+            'publicKey': bytes_to_base64(hex_to_bytes(pub_hex)),
+            'privateKey': bytes_to_base64(hex_to_bytes(priv_hex))
+        }
+
+    @staticmethod
+    def encrypt_to_hex(content: bytes, public_key) -> str:
+        """
+        Encrypt SM2 plaintext (C1C3C2 format, compatible with Java/Go).
+
+        Standard C1C3C2 layout: 04||X(32)||Y(32)||C3(32)||C2(msg_len).
+        gmssl's built-in encrypt returns a 64-byte C1 (no 04 prefix);
+        we prepend the 04 prefix here to match the standard Go/Java C1C3C2 format.
+        """
+        pub_hex = sm2_public_key_to_raw_hex(public_key)
+        crypt = _new_crypt(private_key='', public_key_hex=pub_hex, mode=1)
+        enc_bytes = crypt.encrypt(content)
+        # gmssl: C1(64 bytes) + C3(32) + C2(msg_len)
+        # -> standard: C1(65 bytes with 04) + C3(32) + C2(msg_len)
+        enc_bytes = b'\x04' + enc_bytes[:64] + enc_bytes[64:]
+        return enc_bytes.hex()
+
+    @staticmethod
+    def encrypt_to_bytes(content: bytes, public_key) -> bytes:
+        """Encrypt SM2 plaintext and return the C1C3C2 ciphertext bytes."""
+        return bytes.fromhex(SM2Util.encrypt_to_hex(content, public_key))
+
+    @staticmethod
+    def decrypt_from_bytes(cipher_bytes: bytes, private_key) -> bytes:
+        """Decrypt C1C3C2 ciphertext bytes and return the plaintext bytes."""
+        return SM2Util.decrypt_from_hex(cipher_bytes.hex(), private_key)
+
+    @staticmethod
+    def encrypt_to_base64(content: bytes, public_key) -> str:
+        hex_out = SM2Util.encrypt_to_hex(content, public_key)
+        return bytes_to_base64(bytes.fromhex(hex_out))
+
+    @staticmethod
+    def decrypt_from_hex(cipher_hex: str, private_key, public_key=None) -> bytes:
+        """
+        Decrypt SM2 ciphertext (C1C3C2 format, compatible with Java/Go/Python).
+
+        Supports two C1C3C2 layouts:
+        - standard (Java/Go): C1(65 bytes, 04+X+Y) + C3(32) + C2(msg_len)
+        - gmssl format: C1(64 bytes, X+Y) + C3(32) + C2(msg_len)
+        Auto-detects and handles both.
+        """
+        priv_hex = sm2_private_key_to_raw_hex(private_key)
+
+        # get or derive the public key
+        if public_key is not None:
+            pub_hex = sm2_public_key_to_raw_hex(public_key)
+        else:
+            temp_crypt = sm2.CryptSM2(private_key=priv_hex, public_key='04' + '00' * 64)
+            pub_hex = temp_crypt._kg(int(priv_hex, 16), temp_crypt.ecc_table['g'])
+            if not pub_hex.startswith('04'):
+                pub_hex = '04' + pub_hex
+
+        cipher_bytes = bytes.fromhex(cipher_hex)
+
+        # gmssl's built-in decrypt expects C1 without the 04 prefix (64 bytes)
+        # if the input is the standard format (C1 starts with 04, 65 bytes), strip the 04 prefix
+        if len(cipher_bytes) > 0 and cipher_bytes[0] == 0x04:
+            # standard: 04||X(32)||Y(32)||C3(32)||C2(msg_len) = 1+32+32+32+msg_len
+            # -> gmssl: X(32)||Y(32)||C3(32)||C2(msg_len) = 32+32+32+msg_len
+            cipher_bytes = cipher_bytes[1:65] + cipher_bytes[65:97] + cipher_bytes[97:]
+
+        crypt = _new_crypt(private_key=priv_hex, public_key_hex=pub_hex, mode=1)
+        result = crypt.decrypt(cipher_bytes)
+        if isinstance(result, str):
+            result = result.encode('latin-1')
+        return bytes(result)
+
+    @staticmethod
+    def decrypt_from_base64(cipher_b64: str, private_key) -> bytes:
+        cipher_bytes = base64_to_bytes(cipher_b64)
+        return SM2Util.decrypt_from_hex(bytes_to_hex(cipher_bytes), private_key)
+
+    @staticmethod
+    def sign_to_der(content: bytes, private_key) -> bytes:
+        """
+        Sign SM2 plaintext and return a DER-encoded signature.
+        Java: SM2Signer uses USER_ID="1234567812345678".
+        gmssl's sign_with_sm3 uses USER_ID = b"1234567812345678" by default.
+        """
+        priv_hex = sm2_private_key_to_raw_hex(private_key)
+
+        # gmssl sign requires public_key; derive it from the private key first
+        temp_crypt = sm2.CryptSM2(private_key=priv_hex, public_key='04' + '00' * 64)
+        pub_hex = temp_crypt._kg(int(priv_hex, 16), temp_crypt.ecc_table['g'])
+        if not pub_hex.startswith('04'):
+            pub_hex = '04' + pub_hex
+
+        crypt = _new_crypt(private_key=priv_hex, public_key_hex=pub_hex)
+        # sign_with_sm3 uses SM3 hash and auto-generates random K
+        sig_raw = crypt.sign_with_sm3(content)  # returns hex r||s
+
+        if len(sig_raw) % 2 != 0:
+            raise ValueError('Invalid signature length')
+        half = len(sig_raw) // 2
+        r = sig_raw[:half]
+        s = sig_raw[half:]
+        return raw_rs_to_der(r, s)
+
+    @staticmethod
+    def sign_to_hex(content: bytes, private_key) -> str:
+        return SM2Util.sign_to_der(content, private_key).hex()
+
+    @staticmethod
+    def sign_to_base64(content: bytes, private_key) -> str:
+        return bytes_to_base64(SM2Util.sign_to_der(content, private_key))
+
+    @staticmethod
+    def verify(content: bytes, public_key, signature) -> bool:
+        """
+        Verify an SM2 signature.
+        Java: SM2Signer uses USER_ID="1234567812345678".
+        gmssl's verify uses USER_ID = b"1234567812345678" by default.
+        """
+        pub_hex = sm2_public_key_to_raw_hex(public_key)
+
+        # signature may be hex/base64/bytes; convert to raw r||s hex
+        sig_bytes = None
+        if isinstance(signature, bytes):
+            sig_bytes = signature
+        else:
+            s = signature.strip()
+            if is_hex_string(s):
+                sig_bytes = bytes.fromhex(s)
+            elif is_base64_string(s):
+                sig_bytes = base64_to_bytes(s)
+            else:
+                raise ValueError('Unsupported signature encoding')
+
+        # if DER (starts with 0x30) decode
+        if len(sig_bytes) > 0 and sig_bytes[0] == 0x30:
+            r_hex, s_hex = der_to_raw_rs(sig_bytes)
+            sig_raw = (r_hex + s_hex)
+        else:
+            sig_raw = sig_bytes.hex()
+
+        crypt = _new_crypt(private_key=None, public_key_hex=pub_hex)
+        return crypt.verify_with_sm3(sig_raw, content)
+
+    # convenience wrappers similar to Java API
+    @staticmethod
+    def encrypt(content: str, public_key, to_base64: bool = False) -> str:
+        b = utf8_to_bytes(content)
+        return SM2Util.encrypt_to_base64(b, public_key) if to_base64 else SM2Util.encrypt_to_hex(b, public_key)
+
+    @staticmethod
+    def decrypt(cipher_text: str, private_key) -> str:
+        s = cipher_text.strip()
+        if is_hex_string(s):
+            dec = SM2Util.decrypt_from_hex(s, private_key)
+        else:
+            dec = SM2Util.decrypt_from_base64(s, private_key)
+        return dec.decode('utf-8')
+
+    @staticmethod
+    def sign(content: str, private_key, to_base64: bool = False) -> str:
+        b = utf8_to_bytes(content)
+        if to_base64:
+            return SM2Util.sign_to_base64(b, private_key)
+        return SM2Util.sign_to_hex(b, private_key)
+
+    @staticmethod
+    def verify_str(content: str, public_key, signature: str) -> bool:
+        return SM2Util.verify(utf8_to_bytes(content), public_key, signature)
+
+    # ────────────────── Encrypt+Sign / Verify+Decrypt ──────────────────
+
+    @staticmethod
+    def encrypt_sign(content: str, enc_public_key, sign_private_key, to_base64: bool = False) -> dict:
+        """Encrypt and sign UTF-8 content. Returns {'ciphertext': ..., 'signature': ...}."""
+        ct = SM2Util.encrypt(content, enc_public_key, to_base64=to_base64)
+        sig = SM2Util.sign(ct, sign_private_key, to_base64=to_base64)
+        return {'ciphertext': ct, 'signature': sig}
+
+    @staticmethod
+    def verify_decrypt(ciphertext: str, signature: str, sign_public_key, dec_private_key) -> str:
+        """Verify signature then decrypt. Returns UTF-8 plaintext."""
+        if not SM2Util.verify_str(ciphertext, sign_public_key, signature):
+            raise ValueError('SM2 signature verification failed')
+        return SM2Util.decrypt(ciphertext, dec_private_key)
+
+    # ────────────────── PEM Export / Import ──────────────────
+
+    @staticmethod
+    def export_public_key_pem(pub_hex: str) -> str:
+        """Export raw-hex public key (130 chars) as PEM (X.509 SubjectPublicKeyInfo)."""
+        der = _encode_public_key_to_der(pub_hex)
+        b64 = bytes_to_base64(der)
+        lines = ['-----BEGIN PUBLIC KEY-----']
+        for i in range(0, len(b64), 64):
+            lines.append(b64[i:i + 64])
+        lines.append('-----END PUBLIC KEY-----')
+        return '\n'.join(lines)
+
+    @staticmethod
+    def export_private_key_pem(priv_hex: str, pub_hex: str) -> str:
+        """Export raw-hex keys as PEM (PKCS#8 PrivateKeyInfo)."""
+        der = _encode_private_key_to_der(priv_hex, pub_hex)
+        b64 = bytes_to_base64(der)
+        lines = ['-----BEGIN PRIVATE KEY-----']
+        for i in range(0, len(b64), 64):
+            lines.append(b64[i:i + 64])
+        lines.append('-----END PRIVATE KEY-----')
+        return '\n'.join(lines)
+
+    @staticmethod
+    def import_public_key_pem(pem: str) -> str:
+        """Import PEM (X.509 SPKI) and return raw-hex public key (130 chars)."""
+        begin = '-----BEGIN PUBLIC KEY-----'
+        end = '-----END PUBLIC KEY-----'
+        s = pem.find(begin)
+        e = pem.find(end)
+        if s == -1 or e == -1:
+            raise ValueError('Invalid PEM: missing PUBLIC KEY boundaries')
+        b64 = pem[s + len(begin):e].replace('\n', '').replace('\r', '').replace(' ', '')
+        der = base64_to_bytes(b64)
+        return sm2_public_key_to_raw_hex(der)
+
+    @staticmethod
+    def import_private_key_pem(pem: str) -> str:
+        """Import PEM (PKCS#8) and return raw-hex private key (64 chars)."""
+        begin = '-----BEGIN PRIVATE KEY-----'
+        end = '-----END PRIVATE KEY-----'
+        s = pem.find(begin)
+        e = pem.find(end)
+        if s == -1 or e == -1:
+            raise ValueError('Invalid PEM: missing PRIVATE KEY boundaries')
+        b64 = pem[s + len(begin):e].replace('\n', '').replace('\r', '').replace(' ', '')
+        der = base64_to_bytes(b64)
+        return sm2_private_key_to_raw_hex(der)

crossmool/sm3_util.py

@@ -0,0 +1,117 @@
+from gmssl import sm3
+from os import urandom
+from crossmool.encoding import (
+    bytes_to_hex, bytes_to_base64, hex_to_bytes, base64_to_bytes,
+    is_hex_string, is_base64_string
+)
+
+class SM3Util:
+    @staticmethod
+    def digest(data: bytes) -> bytes:
+        return bytes.fromhex(sm3.sm3_hash(list(data)))
+
+    @staticmethod
+    def digest_to_hex(data: bytes) -> str:
+        return sm3.sm3_hash(list(data))
+
+    @staticmethod
+    def digest_to_bytes(data: bytes) -> bytes:
+        return SM3Util.digest(data)
+
+    @staticmethod
+    def digest_to_base64(data: bytes) -> str:
+        return bytes_to_base64(SM3Util.digest(data))
+
+    @staticmethod
+    def digest_to_str(data: bytes, to_base64: bool = False) -> str:
+        digest_bytes = SM3Util.digest(data)
+        if to_base64:
+            return bytes_to_base64(digest_bytes)
+        return bytes_to_hex(digest_bytes)
+
+    @staticmethod
+    def digest_str(input_str: str, to_base64: bool = False) -> str:
+        if not input_str or not input_str.strip():
+            raise ValueError("input_str cannot be empty")
+        data = input_str.encode('utf-8')
+        digest_bytes = SM3Util.digest(data)
+        if to_base64:
+            return bytes_to_base64(digest_bytes)
+        return bytes_to_hex(digest_bytes)
+
+    @staticmethod
+    def hmac(key: bytes, data: bytes) -> bytes:
+        block_size = 64
+        if len(key) > block_size:
+            key = SM3Util.digest(key)
+        if len(key) < block_size:
+            key = key + b"\x00" * (block_size - len(key))
+        o_key = bytes((b ^ 0x5C) for b in key)
+        i_key = bytes((b ^ 0x36) for b in key)
+        inner = sm3.sm3_hash(list(i_key + data))
+        inner_bytes = bytes.fromhex(inner)
+        outer = sm3.sm3_hash(list(o_key + inner_bytes))
+        return bytes.fromhex(outer)
+
+    @staticmethod
+    def hmac_from_str(key_str: str, data_str: str) -> bytes:
+        if not key_str or not key_str.strip():
+            raise ValueError("key_str cannot be empty")
+        if not data_str or not data_str.strip():
+            raise ValueError("data_str cannot be empty")
+
+        if is_hex_string(key_str):
+            key_bytes = hex_to_bytes(key_str)
+        elif is_base64_string(key_str):
+            key_bytes = base64_to_bytes(key_str)
+        else:
+            raise ValueError("key_str must be Hex string or Base64 string")
+
+        if is_hex_string(data_str):
+            data_bytes = hex_to_bytes(data_str)
+        elif is_base64_string(data_str):
+            data_bytes = base64_to_bytes(data_str)
+        else:
+            data_bytes = data_str.encode('utf-8')
+
+        return SM3Util.hmac(key_bytes, data_bytes)
+
+    @staticmethod
+    def hmac_to_hex(key: bytes, data: bytes) -> str:
+        return bytes_to_hex(SM3Util.hmac(key, data))
+
+    @staticmethod
+    def hmac_to_base64(key: bytes, data: bytes) -> str:
+        return bytes_to_base64(SM3Util.hmac(key, data))
+
+    @staticmethod
+    def hmac_to_str(key: bytes, data: bytes, to_base64: bool = False) -> str:
+        hmac_bytes = SM3Util.hmac(key, data)
+        if to_base64:
+            return bytes_to_base64(hmac_bytes)
+        return bytes_to_hex(hmac_bytes)
+
+    @staticmethod
+    def hmac_str(key_str: str, data_str: str, to_base64: bool = False) -> str:
+        hmac_bytes = SM3Util.hmac_from_str(key_str, data_str)
+        if to_base64:
+            return bytes_to_base64(hmac_bytes)
+        return bytes_to_hex(hmac_bytes)
+
+    @staticmethod
+    def generate_hmac_key(key_length: int = 32) -> bytes:
+        if key_length < 32:
+            raise ValueError("key_length must be >= 32")
+        return urandom(key_length)
+
+    @staticmethod
+    def generate_hmac_key_to_str(key_length: int = 32, to_base64: bool = False) -> str:
+        key_bytes = SM3Util.generate_hmac_key(key_length)
+        if to_base64:
+            return bytes_to_base64(key_bytes)
+        return bytes_to_hex(key_bytes)
+
+    @staticmethod
+    def hmac_verify(key_str: str, data_str: str, received_hmac: str) -> bool:
+        """Verify HMAC by computing expected value and comparing."""
+        return SM3Util.hmac_str(key_str, data_str) == received_hmac

crossmool/sm4_util.py

@@ -0,0 +1,186 @@
+from os import urandom
+from crossmool.encoding import (
+    bytes_to_hex, hex_to_bytes, bytes_to_base64, base64_to_bytes,
+    is_hex_string, is_base64_string
+)
+from gmssl import sm4
+
+GCM_IV_SIZE = 12   # 96 bits
+GCM_TAG_SIZE = 16  # 128 bits
+BLOCK_SIZE = 16
+
+def _xor_bytes(a: bytes, b: bytes) -> bytes:
+    return bytes(x ^ y for x, y in zip(a, b))
+
+def _inc32(counter: bytes) -> bytes:
+    """GCM counter increment (increment the rightmost 32 bits)"""
+    counter_int = int.from_bytes(counter, 'big')
+    low_32 = (counter_int & 0xFFFFFFFF) + 1
+    result = (counter_int & ~0xFFFFFFFF) | (low_32 & 0xFFFFFFFF)
+    return result.to_bytes(16, 'big')
+
+def _gf128_mul(x: int, y: int) -> int:
+    """Multiply two elements in GF(2^128) with reduction polynomial x^128+x^7+x^2+x+1"""
+    R = 0xE1000000000000000000000000000000
+    MASK = (1 << 128) - 1
+    z = 0
+    v = y
+    for i in range(128):
+        if x & (1 << (127 - i)):
+            z ^= v
+        if v & 1:
+            v = (v >> 1) ^ R
+        else:
+            v >>= 1
+    return z & MASK
+
+def _ghash(h: bytes, aad: bytes, ciphertext: bytes) -> bytes:
+    """GHASH computation for GCM"""
+    h_int = int.from_bytes(h, 'big')
+
+    aad_padded = aad + b'\x00' * ((16 - len(aad) % 16) % 16)
+    ct_padded = ciphertext + b'\x00' * ((16 - len(ciphertext) % 16) % 16)
+    len_block = (len(aad) * 8).to_bytes(8, 'big') + (len(ciphertext) * 8).to_bytes(8, 'big')
+
+    y = 0
+    for i in range(0, len(aad_padded), 16):
+        y ^= int.from_bytes(aad_padded[i:i + 16], 'big')
+        y = _gf128_mul(y, h_int)
+    for i in range(0, len(ct_padded), 16):
+        y ^= int.from_bytes(ct_padded[i:i + 16], 'big')
+        y = _gf128_mul(y, h_int)
+    y ^= int.from_bytes(len_block, 'big')
+    y = _gf128_mul(y, h_int)
+
+    return y.to_bytes(16, 'big')
+
+def _sm4_ecb_encrypt_block(key: bytes, block: bytes) -> bytes:
+    """Encrypt a single 16-byte block using SM4 ECB (no padding)"""
+    crypt = sm4.CryptSM4()
+    crypt.set_key(key, sm4.SM4_ENCRYPT)
+    return crypt.crypt_ecb(block)[:16]
+
+def _sm4_ctr_encrypt(key: bytes, counter: bytes, plaintext: bytes) -> bytes:
+    """SM4 CTR mode encryption"""
+    result = bytearray()
+    for i in range(0, len(plaintext), BLOCK_SIZE):
+        keystream = _sm4_ecb_encrypt_block(key, counter)
+        block = plaintext[i:i + BLOCK_SIZE]
+        result.extend(_xor_bytes(keystream[:len(block)], block))
+        counter = _inc32(counter)
+    return bytes(result)
+
+def _detect_and_decode(s: str) -> bytes:
+    """Auto-detect Hex/Base64 encoding and decode to bytes"""
+    if is_hex_string(s):
+        return hex_to_bytes(s)
+    if is_base64_string(s):
+        return base64_to_bytes(s)
+    raise ValueError("Input string must be Hex or Base64 encoded")
+
+class SM4Util:
+    @staticmethod
+    def generate_key() -> bytes:
+        return urandom(16)
+
+    @staticmethod
+    def generate_key_hex() -> str:
+        return bytes_to_hex(SM4Util.generate_key())
+
+    @staticmethod
+    def generate_key_base64() -> str:
+        return bytes_to_base64(SM4Util.generate_key())
+
+    @staticmethod
+    def parse_hex_key(hex_key: str) -> bytes:
+        return hex_to_bytes(hex_key)
+
+    @staticmethod
+    def encrypt_gcm(key: bytes, plaintext: bytes, aad: bytes = b'', to_base64: bool = False) -> str:
+        """
+        SM4 GCM encrypt; returns Hex(IV[12] + ciphertext + Tag[16]) or Base64.
+        """
+        if len(key) != 16:
+            raise ValueError('SM4 key must be 16 bytes')
+
+        iv = urandom(GCM_IV_SIZE)
+        j0 = iv + b'\x00\x00\x00\x01'
+        h = _sm4_ecb_encrypt_block(key, b'\x00' * 16)
+        ciphertext = _sm4_ctr_encrypt(key, _inc32(j0), plaintext)
+        ghash_result = _ghash(h, aad, ciphertext)
+        j0_encrypted = _sm4_ecb_encrypt_block(key, j0)
+        tag = _xor_bytes(ghash_result, j0_encrypted)
+
+        combined = iv + ciphertext + tag
+        if to_base64:
+            return bytes_to_base64(combined)
+        return bytes_to_hex(combined)
+
+    @staticmethod
+    def decrypt_gcm(key: bytes, ciphertext_str: str, aad: bytes = b'') -> bytes:
+        """
+        SM4 GCM decrypt; auto-detects Hex/Base64 input encoding.
+        """
+        if len(key) != 16:
+            raise ValueError('SM4 key must be 16 bytes')
+
+        combined = _detect_and_decode(ciphertext_str)
+        if len(combined) < GCM_IV_SIZE + GCM_TAG_SIZE:
+            raise ValueError('Invalid GCM ciphertext: too short')
+
+        iv = combined[:GCM_IV_SIZE]
+        tag = combined[-GCM_TAG_SIZE:]
+        ciphertext = combined[GCM_IV_SIZE:-GCM_TAG_SIZE]
+
+        j0 = iv + b'\x00\x00\x00\x01'
+        h = _sm4_ecb_encrypt_block(key, b'\x00' * 16)
+        ghash_result = _ghash(h, aad, ciphertext)
+        j0_encrypted = _sm4_ecb_encrypt_block(key, j0)
+        computed_tag = _xor_bytes(ghash_result, j0_encrypted)
+
+        if computed_tag != tag:
+            raise ValueError('SM4 GCM decryption failed (authentication failed)')
+
+        return _sm4_ctr_encrypt(key, _inc32(j0), ciphertext)
+
+    @staticmethod
+    def encrypt_gcm_hex(key: bytes, plaintext: bytes, aad: bytes = b'') -> str:
+        return SM4Util.encrypt_gcm(key, plaintext, aad, to_base64=False)
+
+    @staticmethod
+    def decrypt_gcm_from_hex(key: bytes, hex_str: str, aad: bytes = b'') -> bytes:
+        if not is_hex_string(hex_str):
+            raise ValueError("Input must be Hex encoded")
+        return SM4Util.decrypt_gcm(key, hex_str, aad)
+
+    @staticmethod
+    def encrypt_gcm_string(key: bytes, plain_text: str, to_base64: bool = False) -> str:
+        return SM4Util.encrypt_gcm(key, plain_text.encode('utf-8'), to_base64=to_base64)
+
+    @staticmethod
+    def decrypt_gcm_to_string(key: bytes, ciphertext_str: str) -> str:
+        return SM4Util.decrypt_gcm(key, ciphertext_str).decode('utf-8')
+
+if __name__ == '__main__':
+    key = SM4Util.generate_key()
+    hex_key = SM4Util.generate_key_hex()
+    print(f'Key (HEX): {hex_key}')
+
+    plain_text = 'Hello, 這是国密SM4測試數據'
+    print(f'Plaintext: {plain_text}')
+
+    encrypted_hex = SM4Util.encrypt_gcm_string(key, plain_text)
+    print(f'Encrypted (Hex): {encrypted_hex}')
+
+    encrypted_b64 = SM4Util.encrypt_gcm_string(key, plain_text, to_base64=True)
+    print(f'Encrypted (Base64): {encrypted_b64}')
+
+    decrypted = SM4Util.decrypt_gcm_to_string(key, encrypted_hex)
+    print(f'Decrypted from Hex: {decrypted}')
+
+    decrypted_b64 = SM4Util.decrypt_gcm_to_string(key, encrypted_b64)
+    print(f'Decrypted from Base64: {decrypted_b64}')
+
+    assert decrypted == plain_text, 'Decryption failed!'
+    assert decrypted_b64 == plain_text, 'Decryption from Base64 failed!'
+    print('GCM test passed!')

crossmool-1.3.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: crossmool
+Version: 1.3.0
+Summary: Cross-language SM2/SM3/SM4 cryptographic utilities, interoperable with the Java/Go/Rust/C/C++/C#/JavaScript implementations
+Author: crossmool
+License-Expression: LGPL-3.0-only
+Project-URL: Homepage, https://gitee.com/iilic/crossmool
+Project-URL: Repository, https://gitee.com/iilic/crossmool
+Keywords: sm2,sm3,sm4,cryptography,gmssl,sm-crypto,chinese-cryptography,encryption
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: gmssl>=3.2.2
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+
+# crossmool
+
+Cross-language SM2/SM3/SM4 cryptographic utilities. The Python implementation is fully interoperable with the Java/Go/Rust/C/C++/C#/JavaScript implementations in the [crossmool](https://gitee.com/iilic/crossmool) project.
+
+## Features
+
+- **SM2** — asymmetric encryption/decryption and signature (C1C3C2 ciphertext, X.509 / PKCS#8 DER keys, DER signatures).
+- **SM3** — hash and HMAC-SM3.
+- **SM4** — symmetric GCM encryption/decryption.
+- Hex and Base64 encodings supported throughout.
+- Guaranteed cross-language interop (simplified Chinese, traditional Chinese and English Unicode input).
+
+## Installation
+
+```bash
+pip install crossmool
+```
+
+Requires Python 3.8+.
+
+## Quick start
+
+### SM2 — encrypt / decrypt / sign / verify
+
+```python
+from crossmool import SM2Util
+
+priv, pub = SM2Util.generate_keypair_raw()
+
+# encrypt then decrypt (Hex)
+cipher = SM2Util.encrypt('hello', pub)
+assert SM2Util.decrypt(cipher, priv) == 'hello'
+
+# sign then verify
+sig = SM2Util.sign(cipher, priv)
+assert SM2Util.verify_str(cipher, pub, sig)
+```
+
+### SM3 — hash / HMAC
+
+```python
+from crossmool import SM3Util
+
+digest = SM3Util.digest_str('hello 国密')
+key = SM3Util.generate_hmac_key_to_str()
+mac = SM3Util.hmac_str(key, 'hello 国密')
+assert SM3Util.hmac_verify(key, 'hello 国密', mac)
+```
+
+### SM4 — GCM encrypt / decrypt
+
+```python
+from crossmool import SM4Util
+
+key = SM4Util.generate_key()
+cipher = SM4Util.encrypt_gcm_string(key, 'hello 国密')
+plain = SM4Util.decrypt_gcm_to_string(key, cipher)
+assert plain == 'hello 国密'
+```
+
+## Development
+
+Editable install for development:
+
+```bash
+cd <repo-root>
+pip install -e python/crossmool
+```
+
+Run the test suite:
+
+```bash
+cd python/crossmool
+pytest -q
+```
+
+## License
+
+LGPL-v3. See the [LICENSE](https://gitee.com/iilic/crossmool) file for details.

crossmool-1.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+crossmool/__init__.py,sha256=tvacNRkKMlEiwnsI9iCrUxay76-CRrG79Ero76ddKWI,200
+crossmool/der.py,sha256=JU_nsecWDM3GIew5skqbHpT5zccRznOHSzt5esf4k1U,2591
+crossmool/encoding.py,sha256=8TFB878y7VJDAIzz4ic1SabrFNK5LggjuR3Qr6RVy8Q,1195
+crossmool/sm2_util.py,sha256=xDsfreRd8Gb6ckRTjhqQpF7Q-16_JhUvOcRLNpvM-n0,20641
+crossmool/sm3_util.py,sha256=vpncOd9FJ__fyrohNDDipGnU9xK28WF5UvYYx3cgiCM,4123
+crossmool/sm4_util.py,sha256=cyM4WniSngDGK-jJzhMeshJJ8OHJD4CENIQQ2EVT3Cc,6625
+crossmool-1.3.0.dist-info/METADATA,sha256=Hp0Gy-KaKjRcedNCOJv_TtWXjQ5Srj6z7zXqlKFPpZ4,3109
+crossmool-1.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+crossmool-1.3.0.dist-info/top_level.txt,sha256=8ct3CncA4ykxKOlngLTUo6I02vZ2YVnKrSHaUwtgd6I,10
+crossmool-1.3.0.dist-info/RECORD,,

crossmool-1.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

crossmool-1.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+crossmool