安全加解密引擎基础(TRNG/HASH/HMAC)

常见的安全加解密引擎包括TRNG、HASH、SKE、PKE、MD5、SHA1、SHA2、SM3等。

TRNG用于生成真随机数；HASH用于生成一个固定长度的消息摘要；SKE进行对称加密；PKE进行非对称加密。

1 TRNG

TRNG(True Random Numeral Generator)一般指利用物理方法实现的随机数发生器。

产生真随机数是信息安全领域的核心问题之一。

2 HASH

HASH是把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值。散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不能从散列值来确定唯一的输入值。

常用的HASH算法包括MD4、MD5、SHA系列算法。

2.1 MD4

MD4是麻省理工学院教授Ronald Rivest于1990年设计的一种信息摘要算法。它是一种用来测试信息完整性的密码散列函数的实行。其摘要长度为128位，一般128位长的MD4散列被表示为32位的十六进制数字。

Den boer和Bosselaers以及其他人很快的发现了攻击MD4版本中第一步和第三步的漏洞。Dobbertin向大家演示了如何利用一部普通的个人电脑在几分钟内找到MD4完整版本中的冲突（这个冲突实际上是一种漏洞，它将导致对不同的内容进行加密却可能得到相同的加密后结果）。毫无疑问，MD4就此被淘汰掉了。

更多参考：《MD4_百度百科 (baidu.com)》

2.2 MD5

MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代MD4算法。这套算法的程序在 RFC 1321 标准中被加以规范。1996年后该算法被证实存在弱点，可以被加以破解，对于需要高度安全性的数据，专家一般建议改用其他算法，如SHA-2。2004年，证实MD5算法无法防止碰撞（collision），因此不适用于安全性认证，如SSL公开密钥认证或是数字签名等用途。

更多参考：《MD5_百度百科 (baidu.com)》

2.3 SHA

在Federal Information (nist.gov)中详细定义了SHA系列算法的预处理、算法规则等。

安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。

SHA家族的包括SHA-1、SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256等。SHA224和SHA384是SHA256和SHA512的截短版，利用不同的初始值做计算。

MD5 与 SHA-1 算法已被攻破，不应该被用于新的用途；SHA-2 与 SHA-3 还是安全的，可以使用。

SHA-2包括：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。

SHA-3包括：SHA3-224、SHA3-256、SHA3-384、SHA3-512。

2.4 SM3

SM3是中华人民共和国政府采用的一种密码散列函数标准。

SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等，其算法公开。据国家密码管理局表示，其安全性及效率与SHA-256相当。

密码散列函数（英语：Cryptographic hash function），又译为加密散列函数、密码散列函数、加密散列函数，是散列函数的一种。它被认为是一种单向函数，也就是说极其难以由散列函数输出的结果，回推输入的数据是什么。这样的单向函数被称为“现代密码学的驮马”。这种散列函数的输入数据，通常被称为消息（message），而它的输出结果，经常被称为消息摘要（message digest）或摘要（digest）。

2.5 各种HASH算法对比

不同HASH算法的Digest和Block对比如下：

算法	Digest(位)	Block(位)	IV(小端)
md5	128	512	{0x01234567,0x89ABCDEF,0xFEDCBA98,0x76543210,}
sha1	160	512	{0x67452301,0xefcdab89,0x98badcfe,0x10325476,0xc3d2e1f0,}
sha224	224	512	{0xc1059ed8,0x367cd507,0x3070dd17,0xf70e5939,0xffc00b31,0x68581511,0x64f98fa7,0xbefa4fa4,}
sha256	256	512	{0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19,}
sha384	384	1024	{0xcbbb9d5d,0xc1059ed8,0x629a292a,0x367cd507,0x9159015a,0x3070dd17,0x152fecd8,0xf70e5939, 0x67332667,0xffc00b31,0x8eb44a87,0x68581511,0xdb0c2e0d,0x64f98fa7,0x47b5481d,0xbefa4fa4,}
sha512	512	1024	{0x6a09e667,0xf3bcc908,0xbb67ae85,0x84caa73b,0x3c6ef372,0xfe94f82b,0xa54ff53a,0x5f1d36f1, 0x510e527f,0xade682d1,0x9b05688c,0x2b3e6c1f,0x1f83d9ab,0xfb41bd6b,0x5be0cd19,0x137e2179,}
sha512_224	224	1024	{0x8C3D37C8,0x19544DA2,0x73E19966,0x89DCD4D6,0x1DFAB7AE,0x32FF9C82,0x679DD514,0x582F9FCF, 0x0F6D2B69,0x7BD44DA8,0x77E36F73,0x04C48942,0x3F9D85A8,0x6A1D36C8,0x1112E6AD,0x91D692A1,}
sha512_256	256	1024	{0x22312194,0xFC2BF72C,0x9F555FA3,0xC84C64C2,0x2393B86B,0x6F53B151,0x96387719,0x5940EABD, 0x96283EE2,0xA88EFFE3,0xBE5E1E25,0x53863992,0x2B0199FC,0x2C85B8AA,0x0EB72DDC,0x81C52CA2,}
sha3_224	224	1152
sha3_256	256	1088
sha3_384	384	832
sha3_512	512	576
sm3	256	512	{0x7380166f,0x4914b2b9,0x172442d7,0xda8a0600,0xa96f30bc,0x163138aa,0xe38dee4d,0xb0fb0e4e,}

在《Federal Information (nist.gov)》的5.3 Setting the Initial Hash Value (H(0))中定义了不同算法的IV值，比如：

3 hashlib

hashlib提供了流行hash算法的Python标准库，包括md5，sha1，sha224，sha256，sha384，sha512，blake2b，blake2s，sha3_224，sha3_256，sha3_384，sha3_512，shake_128，shake_256。

3.1 常用方法

hashlib.new(name, [data, ]*, usedforsecurity=True)

一个接受所希望的算法对应的字符串 name 作为第一个形参的通用构造器。它还允许访问上面列出的哈希算法以及你的 OpenSSL 库可能提供的任何其他算法。同名的构造器要比 new() 更快所以应当优先使用。

hash.update(data): 用 bytes-like object 来更新哈希对象。重复调用相当于单次调用并传入所有参数的拼接结果: m.update(a); m.update(b) 等价于 m.update(a+b)。

在 3.1 版更改: 当使用 OpenSSL 提供的哈希算法在大于 2047 字节的数据上执行哈希更新时 Python GIL 会被释放以允许其他线程运行。

hash.digest(): 返回当前已传给 update() 方法的数据摘要。这是一个大小为 digest_size 的字节串对象，字节串中可包含 0 至 255 的完整取值范围。

hash.hexdigest(): 类似于 digest() 但摘要会以两倍长度字符串对象的形式返回，其中仅包含十六进制数码。这可以被用于在电子邮件或其他非二进制环境中安全地交换数据值。

hash.copy(): 返回哈希对象的副本（“克隆”）。这可被用来高效地计算共享相同初始子串的数据的摘要。

hashlib.algorithms_guaranteed: 一个集合，其中包含此模块在所有平台上都保证支持的哈希算法的名称。请注意 'md5' 也在此清单中，虽然某些上游厂商提供了一个怪异的排除了此算法的 "FIPS 兼容" Python 编译版本。

3.2 新版功能.

hashlib.algorithms_available: 一个集合，其中包含在所运行的 Python 解释器上可用的哈希算法的名称。将这些名称传给 new() 时将可被识别。 algorithms_guaranteed 将总是它的一个子集。同样的算法在此集合中可能以不同的名称出现多次（这是 OpenSSL 的原因）。

3.2 新版功能.

下列值会以构造器所返回的哈希对象的常量属性的形式被提供:

hash.digest_size: 以字节表示的结果哈希对象的大小。

hash.block_size: 以字节表示的哈希算法的内部块大小。

hash 对象具有以下属性：

hash.name: 此哈希对象的规范名称，总是为小写形式并且总是可以作为 new() 的形参用来创建另一个此类型的哈希对象。

在 3.4 版更改: 该属性名称自被引入起即存在于 CPython 中，但在 Python 3.4 之前并未正式指明，因此可能不存在于某些平台上。

3.2 hashlib使用

更多参考《hashlib和hmac》。

Python使用hashlib进行HASH运算：

import random
import struct
import hashlib

data_size = 1024
data_file = "data.bin"
def hex_to_array(array, hex):
    print("unsigned char %s[] = {" % (array), end='')
    for i in range(int(len(hex)/2)):
        print("0x%c%c, "%(hex[i*2], hex[i*2+1]), end='')
    print("};")


if __name__ == '__main__':
    print(hashlib.algorithms_guaranteed)
    print(hashlib.algorithms_available)
    print("unsigned char data_bin[] = {")
    #with open(data_file, 'wb') as f:
        #for i in range(1024):
            #rnd = random.randint(0, 255)
            #f.write(struct.pack('B', rnd))
            #print("0x%02x, " % (rnd), end='')
            #if (i+1)%32 == 0:
            #    print("")
        #for i in range(16):
         #   f.write(struct.pack('B', i))
          #  print("0x%02x, " % (i), end='')
           # if (i+1)%32 == 0:
            #    print("")
    print("};")
    #f.close()

    my_md5 = hashlib.md5()
    my_sha1 = hashlib.sha1()
    my_sha224 = hashlib.sha224()
    my_sha256 = hashlib.sha256()
    my_sha384 = hashlib.sha384()
    my_sha512 = hashlib.sha512()
    my_blake2b = hashlib.blake2b()
    my_blake2s = hashlib.blake2s()
    my_sha3_224 = hashlib.sha3_224()
    my_sha3_256 = hashlib.sha3_256()
    my_sha3_384 = hashlib.sha3_384()
    my_sha3_512 = hashlib.sha3_512()
    my_shake_128 = hashlib.shake_128()
    my_shake256 = hashlib.shake_256()
    with open(data_file, 'rb') as f:
        b = f.read(data_size)
        my_md5.update(b)
        my_sha224.update(b)
        my_sha256.update(b)
        my_sha384.update(b)
        my_sha512.update(b)
        my_sha3_224.update(b)
        my_sha3_256.update(b)
        my_sha3_384.update(b)
        my_sha3_512.update(b)
    f.close()
    #hex_to_array("md5_digest", my_md5.hexdigest())
    #hex_to_array("sha224_digest", my_sha224.hexdigest())
    #hex_to_array("sha256_digest", my_sha256.hexdigest())
    #hex_to_array("sha384_digest", my_sha384.hexdigest())
    #hex_to_array("sha512_digest", my_sha512.hexdigest())
    #hex_to_array("sha3_224_digest", my_sha3_224.hexdigest())
    #hex_to_array("sha3_256_digest", my_sha3_256.hexdigest())
    #hex_to_array("sha3_384_digest", my_sha3_384.hexdigest())
    #hex_to_array("sha3_512_digest", my_sha3_512.hexdigest())
    print(my_md5.name+"(DigestSize-"+str(my_md5.digest_size*8)+", BlockSize-"+str(my_md5.block_size*8)+")", my_md5.hexdigest())

    print(my_sha1.name+"(DigestSize-"+str(my_sha1.digest_size*8)+", BlockSize-"+str(my_sha1.block_size*8)+")", my_sha1.hexdigest())

    print(my_sha224.name+"(DigestSize-"+str(my_sha224.digest_size*8)+", BlockSize-"+str(my_sha224.block_size*8)+")", my_sha224.hexdigest())
    print(my_sha256.name+"(DigestSize-"+str(my_sha256.digest_size*8)+", BlockSize-"+str(my_sha256.block_size*8)+")", my_sha256.hexdigest())
    print(my_sha384.name+"(DigestSize-"+str(my_sha384.digest_size*8)+", BlockSize-"+str(my_sha384.block_size*8)+")", my_sha384.hexdigest())
    print(my_sha512.name+"(DigestSize-"+str(my_sha512.digest_size*8)+", BlockSize-"+str(my_sha512.block_size*8)+")", my_sha512.hexdigest())

    print(my_sha3_224.name+"(DigestSize-"+str(my_sha3_224.digest_size*8)+", BlockSize-"+str(my_sha3_224.block_size*8)+")", my_sha3_224.hexdigest())
    print(my_sha3_256.name+"(DigestSize-"+str(my_sha3_256.digest_size*8)+", BlockSize-"+str(my_sha3_256.block_size*8)+")", my_sha3_256.hexdigest())
    print(my_sha3_384.name+"(DigestSize-"+str(my_sha3_384.digest_size*8)+", BlockSize-"+str(my_sha3_384.block_size*8)+")", my_sha3_384.hexdigest())
    print(my_sha3_512.name+"(DigestSize-"+str(my_sha3_512.digest_size*8)+", BlockSize-"+str(my_sha3_512.block_size*8)+")", my_sha3_512.hexdigest())

data.bin为空文件，得到的结果如下：

/usr/bin/python3.8 /home/al/jupyter-notebook/edge10_scripted_code/hash_test/main.py
{'sha3_384', 'sha1', 'sha3_512', 'sha512', 'shake_256', 'sha384', 'blake2b', 'md5', 'sha224', 'shake_128', 'sha256', 'sha3_256', 'blake2s', 'sha3_224'}
{'sha3_384', 'sha3_512', 'sha512_256', 'md5', 'shake_128', 'sha256', 'mdc2', 'sha1', 'shake_256', 'sha384', 'md5-sha1', 'sha224', 'ripemd160', 'whirlpool', 'sha3_256', 'blake2s', 'sha512_224', 'sha512', 'sm3', 'blake2b', 'md4', 'sha3_224'}
unsigned char data_bin[] = {
};
md5(DigestSize-128, BlockSize-512) d41d8cd98f00b204e9800998ecf8427e
sha1(DigestSize-160, BlockSize-512) da39a3ee5e6b4b0d3255bfef95601890afd80709
sha224(DigestSize-224, BlockSize-512) d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
sha256(DigestSize-256, BlockSize-512) e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
sha384(DigestSize-384, BlockSize-1024) 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
sha512(DigestSize-512, BlockSize-1024) cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
sha3_224(DigestSize-224, BlockSize-1152) 6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7
sha3_256(DigestSize-256, BlockSize-1088) a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a
sha3_384(DigestSize-384, BlockSize-832) 0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004
sha3_512(DigestSize-512, BlockSize-576) a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26

Process finished with exit code 0

4 openssl dgst

对同样的data.bin文件使用openssl dgst执行如下脚本：

#!/bin/bash
input_file="data.bin"
dgst_list="md5 sha1 sha224 sha256 sha384 sha512 sha512-224 sha512-256 sha3-224 sha3-256 sha3-384 sha3-512 sm3"
for dgst in $dgst_list
do
    openssl dgst -$dgst $input_file
done

得到结果如下：

MD5(data.bin)= d41d8cd98f00b204e9800998ecf8427e
SHA1(data.bin)= da39a3ee5e6b4b0d3255bfef95601890afd80709
SHA224(data.bin)= d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
SHA256(data.bin)= e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
SHA384(data.bin)= 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
SHA512(data.bin)= cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
SHA512-224(data.bin)= 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4
SHA512-256(data.bin)= c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a
SHA3-224(data.bin)= 6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7
SHA3-256(data.bin)= a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a
SHA3-384(data.bin)= 0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004
SHA3-512(data.bin)= a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26
SM3(data.bin)= 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b

5 其他HASH工具

Linux下还有以下HASH专用工具，比如md5sum、shasum、sha1sum、sha224sum、sha256sum、sha384sum、sha512sum。

其中shasum功能更丰富：

Usage: shasum [OPTION]... [FILE]...
Print or check SHA checksums.
With no FILE, or when FILE is -, read standard input.

  -a, --algorithm   1 (default), 224, 256, 384, 512, 512224, 512256
  -b, --binary      read in binary mode
  -c, --check       read SHA sums from the FILEs and check them
  -t, --text        read in text mode (default)
  -U, --UNIVERSAL   read in Universal Newlines mode
                        produces same digest on Windows/Unix/Mac
  -0, --01          read in BITS mode
                        ASCII '0' interpreted as 0-bit,
                        ASCII '1' interpreted as 1-bit,
                        all other characters ignored
  -p, --portable    read in portable mode (to be deprecated)

The following two options are useful only when verifying checksums:
  -s, --status      don't output anything, status code shows success
  -w, --warn        warn about improperly formatted checksum lines

  -h, --help        display this help and exit
  -v, --version     output version information and exit

6 HMAC

HMAC是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code）的缩写。

HMAC中的H代指Hash散列算法，HMAC可以使用多种单项散列式，例如使用SHA-1，则构成HMAC-SHA1，选用SHA-256散列算法，则构成HMAC-SHA256。

6.1 HMAC工作原理

HMAC的完整操作如下图所示：

下面看看HMAC的内部工作原理，首先看看HMAC中使用的各个变量：
MD=使用的消息摘要（散列）函数
M=计算MAC的输入函数
L=消息M的块数
b=每块的位数
K=HMAC使用的共享对称密钥
ipad=字符串00110110重复b/8次
opad=字符串01011010重复b/8次

6.2 HAMC使用

6.2.1 Pyhotn使用hmac

使用Python的hmac模块对脚本本身进行一系列哈希运算认证：

生成data.bin数据。
根据key创建不同算法的HMAC。
使用不同算法对data.bin生成HAMC摘要。

import hmac
import struct

data_size = 1024
data_file = "data.bin"
hmac_key = b"1234567890"

if __name__ == '__main__':
    # hmac.new(key,msg,digestmod)
    # key:加密的key; msg:加密的内容; digestmod：加密的方式
    print(hmac_key)
    hmac_md5 = hmac.new(hmac_key, b'', digestmod='md5')
    hmac_sha1 = hmac.new(hmac_key, b'', digestmod='sha1')
    hmac_sha224 = hmac.new(hmac_key, b'', digestmod='sha224')
    hmac_sha256 = hmac.new(hmac_key, b'', digestmod='sha256')
    hmac_sha384 = hmac.new(hmac_key, b'', digestmod='sha384')
    hmac_sha512 = hmac.new(hmac_key, b'', digestmod='sha512')

    print("unsigned char data_bin[] = {")
    with open(data_file, 'wb') as f:
        for i in range(256):
            f.write(struct.pack('B', i))
            print("0x%02x, " % (i), end='')
            if (i+1)%32 == 0:
                print("")
    print("};")
    f.close()

    with open(data_file, 'rb') as f:
        b = f.read(data_size)
        hmac_md5.update(b)
        hmac_sha1.update(b)
        hmac_sha224.update(b)
        hmac_sha256.update(b)
        hmac_sha384.update(b)
        hmac_sha512.update(b)
    f.close()

    print("MD5:\t", hmac_md5.hexdigest())
    print("SHA1:\t", hmac_sha1.hexdigest())
    print("SHA224:\t", hmac_sha224.hexdigest())
    print("SHA256:\t", hmac_sha256.hexdigest())
    print("SHA384:\t", hmac_sha384.hexdigest())
    print("SHA512:\t", hmac_sha512.hexdigest())