Python realiza el algoritmo de cifrado comercial nacional sm2/sm3/sm4/sm9 (secreto nacional)

Desde 2010, la Administración Nacional de Criptografía de mi país ha lanzado sucesivamente una serie de algoritmos de cifrado domésticos, incluidos SM1, SM2, SM3, SM4, SM7, SM9, ZUC (algoritmo de cifrado de Zu Chong), etc. SM significa secreto comercial, es decir, El cifrado comercial se refiere a la tecnología de cifrado que se utiliza para los negocios y no involucra secretos de estado. Los algoritmos de SM1 y SM7 no se divulgan, y otros algoritmos se han convertido en estándares internacionales ISO/IEC. En la actualidad, los algoritmos SM2, SM3 y SM4 se utilizan ampliamente y el uso de estos tres es diferente.

la diferencia

Algoritmo de cifrado	definición	Campo de aplicación	características	algoritmo similar	es publico
sm1	Algoritmo de cifrado simétrico	chip	La longitud del paquete y la longitud de la clave son ambas de 128 bits.	DES, 3 DES	privado
sm2	Algoritmo de cifrado asimétrico	cifrado de datos	Mecanismo de cifrado de curva elíptica ECC de 256 bits, mayor velocidad de procesamiento y menor consumo que RSA	RSA, RSA4096	público
sm3	Algoritmo de función hash	verificación de integridad	La seguridad y la eficiencia del algoritmo hash son equivalentes a SHA-256, y la función de compresión es más compleja	SHA1, SHA-256, SHA-384, SHA-512	público
sm4	Algoritmo de cifrado simétrico	Cifrado de datos y productos LAN	La longitud del bloque y la longitud de la clave son ambas de 128 bits, y la cantidad de rondas de cálculo es grande	DES, AES	público
sm7	Algoritmo de cifrado simétrico	Tarjeta IC sin contacto	La longitud del paquete y la longitud de la clave son ambas de 128 bits.		privado
sm9	Algoritmo de cifrado de identidad (IBC)	Comunicación segura fuera de línea de extremo a extremo	La fuerza del cifrado es equivalente al algoritmo de cifrado RSA con una clave de 3072 bits		público
ZUC	Algoritmo de cifrado simétrico	Comunicación móvil, red 4G	cifrado de flujo		público

SM2

Tanto el algoritmo SM2 como el algoritmo RSA son algoritmos criptográficos de clave pública.El algoritmo SM2 es un algoritmo más avanzado y seguro que se utiliza para reemplazar el algoritmo RSA en el sistema de encriptación comercial de nuestro país.
Con el desarrollo de la criptografía y la tecnología informática, el algoritmo RSA de 1024 bits de uso común en la actualidad enfrenta serias amenazas de seguridad. Después de una investigación, nuestro departamento nacional de administración de cifrado decidió reemplazar el algoritmo RSA con el algoritmo de curva elíptica SM2.
Introducción a la secuencia de datos de texto cifrado
El resultado del cifrado asimétrico SM2 consta de tres partes: C1, C2 y C3. Entre ellos, C1 es el punto de la curva elíptica calculado según el número aleatorio generado, C2 son los datos del texto cifrado y C3 es el valor resumen de SM3. Los resultados del estándar secreto nacional original se almacenan en el orden de C1, C2 y C3, y el nuevo estándar se almacena en el orden de C1, C3 y C2. Por lo tanto, hemos agregado una nueva configuración de orden de datos de texto cifrado cuando haciendo encriptación SM2. , para ser compatible con la encriptación del algoritmo SM2 anterior.

import base64
import binascii
from gmssl import sm2, func


def test_sm2():
    private_key = '00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5'
    public_key = 'B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207'

    sm2_crypt = sm2.CryptSM2(
        public_key=public_key, private_key=private_key)
    data = b"111"
    enc_data = sm2_crypt.encrypt(data)
    #print("enc_data:%s" % enc_data)
    #print("enc_data_base64:%s" % base64.b64encode(bytes.fromhex(enc_data)))
    dec_data = sm2_crypt.decrypt(enc_data)
    print(b"dec_data:%s" % dec_data)
    assert data == dec_data

    print("-----------------test sign and verify---------------")
    random_hex_str = func.random_hex(sm2_crypt.para_len)
    sign = sm2_crypt.sign(data, random_hex_str)
    print('sign:%s' % sign)
    verify = sm2_crypt.verify(sign, data)
    print('verify:%s' % verify)
    assert verify

    
def test_sm2sm3():
     private_key = "3945208F7B2144B13F36E38AC6D39F95889393692860B51A42FB81EF4DF7C5B8"
     public_key = "09F9DF311E5421A150DD7D161E4BC5C672179FAD1833FC076BB08FF356F35020"\
                  "CCEA490CE26775A52DC6EA718CC1AA600AED05FBF35E084A6632F6072DA9AD13"
     random_hex_str = "59276E27D506861A16680F3AD9C02DCCEF3CC1FA3CDBE4CE6D54B80DEAC1BC21"

     sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key)
     data = b"message digest"

     print("-----------------test SM2withSM3 sign and verify---------------")
     sign = sm2_crypt.sign_with_sm3(data, random_hex_str)
     print('sign: %s' % sign)
     verify = sm2_crypt.verify_with_sm3(sign, data)
     print('verify: %s' % verify)
     assert verify


if __name__ == '__main__':
    test_sm2()
    test_sm2sm3()

SM3

Herramienta en línea SM3 National Secret Hash. Admite el cálculo SM3 de caracteres convencionales, también admite el cálculo SM3 de archivos. No es necesario cargar el archivo en el servidor, y no hay restricciones, y el cálculo del valor hash SM3 se puede completar en el navegador. El tipo de codificación (utf8/gbk, etc.) solo afecta los cálculos SM3 de caracteres regulares. Para obtener detalles técnicos relacionados con los secretos nacionales SM3, consulte: "Algoritmo hash de contraseña SM3"

from gmssl import sm3, func

if __name__ == '__main__':
    y = sm3.sm3_hash(func.bytes_to_list(b"abc"))
    print(y)

SM4

SM4.0 (anteriormente conocido como SMS4.0) es un estándar de cifrado de bloques adoptado por el gobierno de la República Popular China y publicado por la Administración Estatal de Cifrado el 21 de marzo de 2012. El estándar relevante es "GM/T 0002-2012 "Algoritmo de cifrado de bloque SM4" (anteriormente Algoritmo de cifrado de bloque SMS4)".
En el sistema de cifrado comercial, SM4 se utiliza principalmente para el cifrado de datos. Su algoritmo es público. La longitud del bloque y la longitud de la clave son de 128 bits. Tanto el algoritmo de cifrado como el algoritmo de expansión de clave adoptan una estructura iterativa no lineal de 32 rondas. Entrada de 8 bits producción.
La longitud de la instrucción en SM4.0 se incrementa a un nivel superior a 64 K (es decir, 64 × 1024), que es 128 veces la especificación SM 3.0 (la longitud de la instrucción de representación puede ser superior a 512).

from gmssl.sm4 import CryptSM4, SM4_ENCRYPT, SM4_DECRYPT

key = b'3l5butlj26hvv313'
value = b'111'
iv = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
crypt_sm4 = CryptSM4()

crypt_sm4.set_key(key, SM4_ENCRYPT)
encrypt_value = crypt_sm4.crypt_ecb(value)
crypt_sm4.set_key(key, SM4_DECRYPT)
decrypt_value = crypt_sm4.crypt_ecb(encrypt_value)
assert value == decrypt_value

crypt_sm4.set_key(key, SM4_ENCRYPT)
encrypt_value = crypt_sm4.crypt_cbc(iv , value)
crypt_sm4.set_key(key, SM4_DECRYPT)
decrypt_value = crypt_sm4.crypt_cbc(iv , encrypt_value)
assert value == decrypt_value

SM9

from gmssl import sm9

if __name__ == '__main__':
    idA = 'a'
    idB = 'b'

    print ("-----------------test sign and verify---------------")
    
    master_public, master_secret = sm9.setup ('sign')

    Da = sm9.private_key_extract ('sign', master_public, master_secret, idA)
    
    message = 'abc'
    signature = sm9.sign (master_public, Da, message)

    assert (sm9.verify (master_public, idA, message, signature))

    print ("\t\t\t success")

    print ("-----------------test key agreement---------------")
    
    master_public, master_secret = sm9.setup ('keyagreement')

    Da = sm9.private_key_extract ('keyagreement', master_public, master_secret, idA)
    Db = sm9.private_key_extract ('keyagreement', master_public, master_secret, idB)

    xa, Ra = sm9.generate_ephemeral (master_public, idB)
    xb, Rb = sm9.generate_ephemeral (master_public, idA)

    ska = sm9.generate_session_key (idA, idB, Ra, Rb, Da, xa, master_public, 'A', 128)
    skb = sm9.generate_session_key (idA, idB, Ra, Rb, Db, xb, master_public, 'B', 128)

    assert (ska == skb)

    print ("\t\t\t success")
    
    print ("-----------------test encrypt and decrypt---------------")

    master_public, master_secret = sm9.setup ('encrypt')

    Da = sm9.private_key_extract ('encrypt', master_public, master_secret, idA)

    message = 'abc'
    ct = sm9.kem_dem_enc (master_public, idA, message, 32)
    pt = sm9.kem_dem_dec (master_public, idA, Da, ct, 32)

    assert (message == pt)

    print ("\t\t\t success")

referencia

https://github.com/gongxian-ding/gmssl-python
https://github.com/duanhongyi/gmssl
https://www.lzltool.com/SM2