Python 实现国产SM3加密算法的示例代码-6ren

Python 实现国产SM3加密算法的示例代码

转载作者：qq735679552 更新时间：2022-09-27 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python 实现国产SM3加密算法的示例代码由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

SM3是中华人民共和国政府采用的一种密码散列函数标准，由国家密码管理局于2010年12月17日发布。主要用于报告文件数字签名及验证.

Python3代码如下:

 
    ? 
   
         from 
         math  
         import 
         ceil 
        
         ############################################################################## 
        
         # 
        
         #              国产SM3加密算法 
        
         # 
        
         ############################################################################## 
        
         IV  
         = 
         "7380166f 4914b2b9 172442d7 da8a0600 a96f30bc 163138aa e38dee4d b0fb0e4e" 
        
         IV  
         = 
         int 
         (IV.replace( 
         " " 
         , ""),  
         16 
         ) 
        
         a  
         = 
         [] 
        
         for 
         i  
         in 
         range 
         ( 
         0 
         ,  
         8 
         ): 
        
         a.append( 
         0 
         ) 
        
         a[i]  
         = 
         (IV >> (( 
         7 
         - 
         i)  
         * 
         32 
         )) &  
         0xFFFFFFFF 
        
         IV  
         = 
         a 
        
         def 
         out_hex(list1): 
        
         for 
         i  
         in 
         list1: 
        
         print 
         ( 
         "%08x" 
         % 
         i) 
        
         print 
         ( 
         "\n" 
         ) 
        
         def 
         rotate_left(a, k): 
        
         k  
         = 
         k  
         % 
         32 
        
         return 
         ((a << k) &  
         0xFFFFFFFF 
         ) | ((a &  
         0xFFFFFFFF 
         ) >> ( 
         32 
         - 
         k)) 
        
         T_j  
         = 
         [] 
        
         for 
         i  
         in 
         range 
         ( 
         0 
         ,  
         16 
         ): 
        
         T_j.append( 
         0 
         ) 
        
         T_j[i]  
         = 
         0x79cc4519 
        
         for 
         i  
         in 
         range 
         ( 
         16 
         ,  
         64 
         ): 
        
         T_j.append( 
         0 
         ) 
        
         T_j[i]  
         = 
         0x7a879d8a 
        
         def 
         FF_j(X, Y, Z, j): 
        
         if 
         0 
         < 
         = 
         j  
         and 
         j <  
         16 
         : 
        
         ret  
         = 
         X ^ Y ^ Z 
        
         elif 
         16 
         < 
         = 
         j  
         and 
         j <  
         64 
         : 
        
         ret  
         = 
         (X & Y) | (X & Z) | (Y & Z) 
        
         return 
         ret 
        
         def 
         GG_j(X, Y, Z, j): 
        
         if 
         0 
         < 
         = 
         j  
         and 
         j <  
         16 
         : 
        
         ret  
         = 
         X ^ Y ^ Z 
        
         elif 
         16 
         < 
         = 
         j  
         and 
         j <  
         64 
         : 
        
         # ret = (X | Y) & ((2 ** 32 - 1 - X) | Z) 
        
         ret  
         = 
         (X & Y) | ((~ X) & Z) 
        
         return 
         ret 
        
         def 
         P_0(X): 
        
         return 
         X ^ (rotate_left(X,  
         9 
         )) ^ (rotate_left(X,  
         17 
         )) 
        
         def 
         P_1(X): 
        
         return 
         X ^ (rotate_left(X,  
         15 
         )) ^ (rotate_left(X,  
         23 
         )) 
        
         def 
         CF(V_i, B_i): 
        
         W  
         = 
         [] 
        
         for 
         i  
         in 
         range 
         ( 
         16 
         ): 
        
         weight  
         = 
         0x1000000 
        
         data  
         = 
         0 
        
         for 
         k  
         in 
         range 
         (i  
         * 
         4 
         , (i  
         + 
         1 
         )  
         * 
         4 
         ): 
        
         data  
         = 
         data  
         + 
         B_i[k]  
         * 
         weight 
        
         weight  
         = 
         int 
         (weight  
         / 
         0x100 
         ) 
        
         W.append(data) 
        
         for 
         j  
         in 
         range 
         ( 
         16 
         ,  
         68 
         ): 
        
         W.append( 
         0 
         ) 
        
         W[j]  
         = 
         P_1(W[j  
         - 
         16 
         ] ^ W[j  
         - 
         9 
         ] ^ (rotate_left(W[j  
         - 
         3 
         ],  
         15 
         ))) ^ (rotate_left(W[j  
         - 
         13 
         ],  
         7 
         )) ^ W[j  
         - 
         6 
         ] 
        
         str1  
         = 
         "%08x" 
         % 
         W[j] 
        
         W_1  
         = 
         [] 
        
         for 
         j  
         in 
         range 
         ( 
         0 
         ,  
         64 
         ): 
        
         W_1.append( 
         0 
         ) 
        
         W_1[j]  
         = 
         W[j] ^ W[j  
         + 
         4 
         ] 
        
         str1  
         = 
         "%08x" 
         % 
         W_1[j] 
        
         A, B, C, D, E, F, G, H  
         = 
         V_i 
        
         """ 
        
         print "00", 
        
         out_hex([A, B, C, D, E, F, G, H]) 
        
         """ 
        
         for 
         j  
         in 
         range 
         ( 
         0 
         ,  
         64 
         ): 
        
         SS1  
         = 
         rotate_left(((rotate_left(A,  
         12 
         ))  
         + 
         E  
         + 
         (rotate_left(T_j[j], j))) &  
         0xFFFFFFFF 
         ,  
         7 
         ) 
        
         SS2  
         = 
         SS1 ^ (rotate_left(A,  
         12 
         )) 
        
         TT1  
         = 
         (FF_j(A, B, C, j)  
         + 
         D  
         + 
         SS2  
         + 
         W_1[j]) &  
         0xFFFFFFFF 
        
         TT2  
         = 
         (GG_j(E, F, G, j)  
         + 
         H  
         + 
         SS1  
         + 
         W[j]) &  
         0xFFFFFFFF 
        
         D  
         = 
         C 
        
         C  
         = 
         rotate_left(B,  
         9 
         ) 
        
         B  
         = 
         A 
        
         A  
         = 
         TT1 
        
         H  
         = 
         G 
        
         G  
         = 
         rotate_left(F,  
         19 
         ) 
        
         F  
         = 
         E 
        
         E  
         = 
         P_0(TT2) 
        
         A  
         = 
         A &  
         0xFFFFFFFF 
        
         B  
         = 
         B &  
         0xFFFFFFFF 
        
         C  
         = 
         C &  
         0xFFFFFFFF 
        
         D  
         = 
         D &  
         0xFFFFFFFF 
        
         E  
         = 
         E &  
         0xFFFFFFFF 
        
         F  
         = 
         F &  
         0xFFFFFFFF 
        
         G  
         = 
         G &  
         0xFFFFFFFF 
        
         H  
         = 
         H &  
         0xFFFFFFFF 
        
         V_i_1  
         = 
         [] 
        
         V_i_1.append(A ^ V_i[ 
         0 
         ]) 
        
         V_i_1.append(B ^ V_i[ 
         1 
         ]) 
        
         V_i_1.append(C ^ V_i[ 
         2 
         ]) 
        
         V_i_1.append(D ^ V_i[ 
         3 
         ]) 
        
         V_i_1.append(E ^ V_i[ 
         4 
         ]) 
        
         V_i_1.append(F ^ V_i[ 
         5 
         ]) 
        
         V_i_1.append(G ^ V_i[ 
         6 
         ]) 
        
         V_i_1.append(H ^ V_i[ 
         7 
         ]) 
        
         return 
         V_i_1 
        
         def 
         hash_msg(msg): 
        
         # print(msg) 
        
         len1  
         = 
         len 
         (msg) 
        
         reserve1  
         = 
         len1  
         % 
         64 
        
         msg.append( 
         0x80 
         ) 
        
         reserve1  
         = 
         reserve1  
         + 
         1 
        
         # 56-64, add 64 byte 
        
         range_end  
         = 
         56 
        
         if 
         reserve1 > range_end: 
        
         range_end  
         = 
         range_end  
         + 
         64 
        
         for 
         i  
         in 
         range 
         (reserve1, range_end): 
        
         msg.append( 
         0x00 
         ) 
        
         bit_length  
         = 
         (len1)  
         * 
         8 
        
         bit_length_str  
         = 
         [bit_length  
         % 
         0x100 
         ] 
        
         for 
         i  
         in 
         range 
         ( 
         7 
         ): 
        
         bit_length  
         = 
         int 
         (bit_length  
         / 
         0x100 
         ) 
        
         bit_length_str.append(bit_length  
         % 
         0x100 
         ) 
        
         for 
         i  
         in 
         range 
         ( 
         8 
         ): 
        
         msg.append(bit_length_str[ 
         7 
         - 
         i]) 
        
         # print(msg) 
        
         group_count  
         = 
         round 
         ( 
         len 
         (msg)  
         / 
         64 
         ) 
        
         B  
         = 
         [] 
        
         for 
         i  
         in 
         range 
         ( 
         0 
         , group_count): 
        
         B.append(msg[i  
         * 
         64 
         :(i  
         + 
         1 
         )  
         * 
         64 
         ]) 
        
         V  
         = 
         [] 
        
         V.append(IV) 
        
         for 
         i  
         in 
         range 
         ( 
         0 
         , group_count): 
        
         V.append(CF(V[i], B[i])) 
        
         y  
         = 
         V[i  
         + 
         1 
         ] 
        
         result  
         = 
         "" 
        
         for 
         i  
         in 
         y: 
        
         result  
         = 
         '%s%08x' 
         % 
         (result, i) 
        
         return 
         result 
        
         def 
         str2byte(msg):  
         # 字符串转换成byte数组 
        
         ml  
         = 
         len 
         (msg) 
        
         msg_byte  
         = 
         [] 
        
         msg_bytearray  
         = 
         msg  
         # 如果加密对象是字符串，则在此对msg做encode()编码即可，否则不编码 
        
         for 
         i  
         in 
         range 
         (ml): 
        
         msg_byte.append(msg_bytearray[i]) 
        
         return 
         msg_byte 
        
         def 
         byte2str(msg):  
         # byte数组转字符串 
        
         ml  
         = 
         len 
         (msg) 
        
         str1  
         = 
         b"" 
        
         for 
         i  
         in 
         range 
         (ml): 
        
         str1  
         + 
         = 
         b 
         '%c' 
         % 
         msg[i] 
        
         return 
         str1.decode( 
         'utf-8' 
         ) 
        
         def 
         hex2byte(msg):  
         # 16进制字符串转换成byte数组 
        
         ml  
         = 
         len 
         (msg) 
        
         if 
         ml  
         % 
         2 
         ! 
         = 
         0 
         : 
        
         msg  
         = 
         '0' 
         + 
         msg 
        
         ml  
         = 
         int 
         ( 
         len 
         (msg)  
         / 
         2 
         ) 
        
         msg_byte  
         = 
         [] 
        
         for 
         i  
         in 
         range 
         (ml): 
        
         msg_byte.append( 
         int 
         (msg[i  
         * 
         2 
         :i  
         * 
         2 
         + 
         2 
         ],  
         16 
         )) 
        
         return 
         msg_byte 
        
         def 
         byte2hex(msg):  
         # byte数组转换成16进制字符串 
        
         ml  
         = 
         len 
         (msg) 
        
         hexstr  
         = 
         "" 
        
         for 
         i  
         in 
         range 
         (ml): 
        
         hexstr  
         = 
         hexstr  
         + 
         ( 
         '%02x' 
         % 
         msg[i]) 
        
         return 
         hexstr 
        
         def 
         KDF(Z, klen):  
         # Z为16进制表示的比特串（str），klen为密钥长度（单位byte） 
        
         klen  
         = 
         int 
         (klen) 
        
         ct  
         = 
         0x00000001 
        
         rcnt  
         = 
         ceil(klen  
         / 
         32 
         ) 
        
         Zin  
         = 
         hex2byte(Z) 
        
         Ha  
         = 
         "" 
        
         for 
         i  
         in 
         range 
         ( 
         int 
         (rcnt)): 
        
         msg  
         = 
         Zin  
         + 
         hex2byte( 
         '%08x' 
         % 
         ct) 
        
         # print(msg) 
        
         Ha  
         = 
         Ha  
         + 
         hash_msg(msg) 
        
         # print(Ha) 
        
         ct  
         + 
         = 
         1 
        
         return 
         Ha[ 
         0 
         : klen  
         * 
         2 
         ] 
        
         def 
         sm3_hash(msg, Hexstr 
         = 
         0 
         ): 
        
         """ 
        
         封装方法，外部调用 
        
         :param msg: 二进制流（如若需要传入字符串，则把str2byte方法里msg做encode()编码一下，否则不编码） 
        
         :param Hexstr: 0 
        
         :return: 64位SM3加密结果 
        
         """ 
        
         if 
         (Hexstr): 
        
         msg_byte  
         = 
         hex2byte(msg) 
        
         else 
         : 
        
         msg_byte  
         = 
         str2byte(msg) 
        
         return 
         hash_msg(msg_byte) 
        
         if 
         __name__  
         = 
         = 
         '__main__' 
         : 
        
         print 
         (sm3_hash(b 
         'SM3Test' 
         )) 
         # 打印结果：901053b4681483b737dd2dd9f9a7f56805aa1b03337f8c1abb763a96776b8905

以上就是Python 实现国产SM3加密算法的示例代码的详细内容，更多关于Python 实现国产SM3加密算法的资料请关注我其它相关文章！。

原文链接：https://www.cnblogs.com/wcwnina/p/13604915.html 。

最后此篇关于Python 实现国产SM3加密算法的示例代码的文章就讲到这里了,如果你想了解更多关于Python 实现国产SM3加密算法的示例代码的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： Swift心得笔记之运算符

文章推荐： Go语言实现IP段范围校验示例

文章推荐： Swift中的指针操作和使用详细介绍

文章推荐： MyBatis入门程序

C - 加密算法
我正在尝试用 C 编写一个简单的加密程序。我的目标是将 abc(它可以是任何单词)翻译成 123。然后乘以 2 得到 246 然后再次翻译成文本，然后在屏幕上写 bdf。这是我的算法，它不能正常工作。
C# 加密算法
互联网上有很多关于加密的答案，但我一直无法找到我正在寻找的东西:使用 c# 提供的工具对字符串和文本文件进行加密的简单强加密。我的主要问题是我不知道如何将 IV 保存到文本文件的开头或如何创建随机
C# RSA 加密算法
C#“RSACryptoServiceProvider”加密算法是 Microsoft-CryptoAPI 的一部分吗？通过在 .Net 中使用 CryptoAPI 而不是“RSACryptoSer
c - Padding - 加密算法
我正在编写适用于“流”的 XXTEA 加密算法的实现，即可以像这样使用:crypt mykey 输出。其中一个先决条件是它根本无法访问文件(它只读取固定大小的 block ，直到找到 EOF)。该
Algorithm for Encryption(加密算法)
嘿，这是我老师给我的一个加密例子。但是，我仍然搞不懂(Int)Message[i]是什么意思？那么程序在这条线上做什么呢？
Algorithm for Encryption(加密算法)
嘿，这是我老师给我的一个加密例子。但是，我仍然搞不懂(Int)Message[i]是什么意思？那么程序在这条线上做什么呢？
python - 自定义 Python 加密算法
嘿，我研究这个已经有一段时间了，我记得我的兄弟引导我完成了这个完全相同的算法。基本上，它只是添加键中字符和短语的 ascii 值。我可以用这个加密它: def encrypt(key, strin
android - 未提供 BouncycaSTLe 加密算法
我正在尝试将 BouncyCaSTLe 与 android 一起使用来实现 ECDH 和 EL Gamal。我已经添加了 bouncycaSTLe jar 文件 (bcprov-jdk16-144.j
windows - 最小化字符数的简单数字到数字(或数字到十六进制)加密算法
我需要加密一个数字，我和这个加密的值将提供给客户询问 key ，所以我想尽量减少数字的数量并使它们都可以打印。所以我希望结果要么全是数字，要么全是十六进制字符。我正在使用的当前加密方法(对于非数字
java - 我应该使用哪些 Java 加密算法？
关闭。这个问题是opinion-based .它目前不接受答案。想改善这个问题吗？更新问题，以便可以通过 editing this post 用事实和引文回答问题. 5年前关闭。 Improve t
algorithm - 是否存在滚动 block 加密算法？
我正在制作 note taking web app它会在您键入时连续保存笔记。我正在发送差异以防止通过线路发送过多数据，这在注释为纯文本时工作正常。然而，我添加了对加密笔记的支持，所以笔记只会以加密
java - 对称 key 加密算法
我正在寻找一种与 JavaScript 和 Java 兼容的安全对称 key 加密算法。我已经尝试实现一个，但我遇到了一些编码问题。最佳答案您不想使用 JavaScript 加密，especia
[信息安全]加密算法：md5摘要算法/sha256算法
目录 1 MD5 1.1 算法定义 1.2 MD5算法不安全的原因 1.2.1 字典表很大 1
encryption - ColdFusion 的 CFMX_COMPAT 加密算法
在查看一些旧的 Coldfusion 代码时，我发现了几个通过加密/解密函数使用 CFMX_COMPAT 算法加密的数据实例。找了一阵子，一直没找到这是什么算法。文档提到它现在是最不安全的方法，但我
ios - SUP for iOS SQLite 加密算法
谁能告诉我 iOS 上 SUP 用来加密底层数据库的加密算法是什么？它是否依赖于 SQLite EE(加密扩展)，如果是，使用了 4 种可用算法中的哪一种？我的猜测是某种 AES，但官方文档中没有
c# - 此平台不支持 Diffie-Hellman 加密算法
我一直有这个问题。 The specified cryptographic algorithm is not supported on this platform. Exception Details
java - 我正在 Java 中实现长数字的 3Des 加密算法
我正在为一个项目实现 3Des 加密算法。我使用此代码作为示例: http://www.java2s.com/Code/Java/Security/TripleDES.htm 它工作正常，但我需要发
algorithm - 汇编中的 Adobe Type 1 加密算法
我正在尝试使用 adobe type 1 字体加密算法来加密文本文件。但是，我不知道如何用汇编语言正确地实现算法。如果可以，请帮助我。下面是adobe type 1字体加密算法: unsigned
c - 如何从 OpenSSL 源代码中禁用/删除特定的 OpenSSL 加密算法？
如何添加/创建具有特定加密算法的 c/c++ OpenSSL 静态库？假设我不想实现 md5。如何创建没有 md5 的库？最佳答案在配置脚本中你可以指定no-选项，它会在没有你指定的密码的情况下构
encryption - 是否有 8 位 block 大小的公私 key 加密算法？
我检查了 TripleDES。它的 block 大小是 64 位。有没有针对8位 block 大小的算法？谢谢编辑:我不打算将其用于完美保护，而是用于以防万一的情况，即看到代码的人不应该找到明文

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Python 实现国产SM3加密算法的示例代码