sangge/mimajingsai_3
1
0
Fork 0
Code Issues Pull Requests Actions Releases Activity

style: format code style

Browse Source
This commit is contained in:
sangge
2023-11-29 17:44:27 +08:00
parent 5ee3057bac
commit f850f3d461
2 changed files with 144 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
aesDrbg.py
View File

@@ -1,41 +1,44 @@
from Crypto.Cipher import AES
import secrets
import time
import binascii # 引入hexlify方法
import binascii # 引入hexlify方法
class AES_CTR_DRBG:
def __init__(self, personalization_string: bytes = b"", nonce: bytes = b""):
self.keylen = 16 # AES密钥长度为128比特
self.blocklen = 16 # AES块大小为128比特
self.seedlen = 32 # 种子长度为256比特
self.outlen = 16 # 输出长度为128比特
# 重播种计数器，表明自初始化或者重播种期间获得新的熵输入依赖，请求随机数生成的次数
self.keylen = 16 # AES密钥长度为128比特
self.blocklen = 16 # AES块大小为128比特
self.seedlen = 32 # 种子长度为256比特
self.outlen = 16 # 输出长度为128比特
# 重播种计数器，表明自初始化或者重播种期间获得新的熵输入依赖，请求随机数生成的次数
self.reseed_counter = 0
# 重播种计数器阈值，在重播种之前能够产生随机数的最大请求次数
# level 1 2^20次
# level 2 2^10次
self.reseed_interval_in_counter = 1<<30
# 重播种时间阈值，距离上一次重播种的最大时间间隔，单位 秒
# 重播种计数器阈值，在重播种之前能够产生随机数的最大请求次数
# level 1 2^20次
# level 2 2^10次
self.reseed_interval_in_counter = 1 << 30
# 重播种时间阈值，距离上一次重播种的最大时间间隔，单位 秒
# level 1 600s
# level 2 60s
self.reseed_interval_in_time = 6000
# 最小的熵输入长度
self.min_entropy_input_length = 32 # 256比特
# 最大的熵输入长度
self.max_ectropy_input_length = 1<<35 - 1 # 2^35比特
# 最小的熵输入长度
self.min_entropy_input_length = 32 # 256比特
# 最大的熵输入长度
self.max_ectropy_input_length = 1 << 35 - 1 # 2^35比特
self.seed_material = ""
self.aes = AES.new(b"\x00" * self.keylen, AES.MODE_ECB)
self.AES_CTR_DRBG_Instantiate(personalization_string, nonce)
def AES_CTR_DRBG_Instantiate(self, personalization_string: bytes = b"", nonce: bytes = b""):
def AES_CTR_DRBG_Instantiate(
self, personalization_string: bytes = b"", nonce: bytes = b""
):
self.min_entropy = self.seedlen
self.entropy_input = secrets.token_bytes(self.min_entropy)
self.seed_material = self.entropy_input + nonce + personalization_string
self.seed_material = self.AES_CTR_DRBG_df(self.seed_material, self.seedlen)
self.Key = self.seed_material[:self.keylen]
self.V = self.seed_material[-self.blocklen:]
self.Key = self.seed_material[: self.keylen]
self.V = self.seed_material[-self.blocklen :]
self.reseed_counter = 1
self.last_reseed_time = int(time.time())
@@ -45,11 +48,11 @@ class AES_CTR_DRBG:
self.V = (int.from_bytes(self.V, "big") + 1) % (1 << (8 * self.blocklen))
self.V = self.V.to_bytes(self.blocklen, "big")
temp += self.aes.encrypt(self.V)
temp = temp[:len(seed_material)]
temp = temp[: len(seed_material)]
temp = int.from_bytes(temp, "big") ^ int.from_bytes(seed_material, "big")
temp = temp.to_bytes(len(seed_material), "big")
self.Key = temp[:self.keylen]
self.V = temp[-self.blocklen:]
self.Key = temp[: self.keylen]
self.V = temp[-self.blocklen :]
def AES_CTR_DRBG_df(self, input_string: bytes, number_of_bits_to_return: int):
L = len(input_string).to_bytes(4, "big")
@@ -59,13 +62,15 @@ class AES_CTR_DRBG:
S += b"\x00"
temp = b""
i = 0
K = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"[:self.keylen]
K = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"[
: self.keylen
]
while len(temp) < self.keylen + self.outlen:
IV = i.to_bytes(4, "big") + b"\x00" * (self.blocklen - 4)
temp += self.CBC_MAC(K, IV + S)
i += 1
K = temp[:self.keylen]
X = temp[self.keylen:self.keylen + self.outlen]
K = temp[: self.keylen]
X = temp[self.keylen : self.keylen + self.outlen]
tmp = b""
while len(tmp) < number_of_bits_to_return:
X = self.aes.encrypt(X)
@@ -76,9 +81,13 @@ class AES_CTR_DRBG:
def CBC_MAC(self, Key, data_to_MAC):
chaining_value = b"\x00" * self.blocklen
for i in range(0, len(data_to_MAC), self.blocklen):
block = data_to_MAC[i:i + self.blocklen]
input_block = int.from_bytes(chaining_value, "big") ^ int.from_bytes(block, "big")
chaining_value = self.aes.encrypt(input_block.to_bytes(self.blocklen, "big"))
block = data_to_MAC[i : i + self.blocklen]
input_block = int.from_bytes(chaining_value, "big") ^ int.from_bytes(
block, "big"
)
chaining_value = self.aes.encrypt(
input_block.to_bytes(self.blocklen, "big")
)
return chaining_value
def AES_CTR_DRBG_Reseed(self, additional_input: bytes):
@@ -90,10 +99,15 @@ class AES_CTR_DRBG:
self.reseed_counter = 1
self.last_reseed_time = int(time.time())
def AES_CTR_DRBG_Generate(self, requested_number_of_bits, additional_input: bytes = b""):
def AES_CTR_DRBG_Generate(
self, requested_number_of_bits, additional_input: bytes = b""
):
length = requested_number_of_bits // 8
returned_bits = b""
if self.reseed_counter > (1 << 48) or int(time.time()) - self.last_reseed_time > 600:
if (
self.reseed_counter > (1 << 48)
or int(time.time()) - self.last_reseed_time > 600
):
self.AES_CTR_DRBG_Reseed(additional_input)
if additional_input != b"":
additional_input = self.AES_CTR_DRBG_df(additional_input, self.seedlen)
@@ -109,18 +123,20 @@ class AES_CTR_DRBG:
self.reseed_counter += 1
return returned_bits[:length]
if __name__ == "__main__":
bit_len = int(input("Enter the length of the bit string to be generated(bit):"))
num = int(input("Enter the number of the bit string to be generated:"))
file_name = input("Enter the name of the saved file:")
start_time = time.time() # 记录开始时间
start_time = time.time() # 记录开始时间
aesDrbg = AES_CTR_DRBG()
with open(file_name,"w") as f: # 改为以文本方式写入
with open(file_name, "w") as f: # 改为以文本方式写入
for i in range(num):
hex_output = binascii.hexlify(aesDrbg.AES_CTR_DRBG_Generate(bit_len)).decode() # 转为十六进制并解码为string
f.write(hex_output + '\n') # 在每次写入后换行
end_time = time.time() # 记录结束时间
elapsed_time = end_time - start_time # 计算经过的时间
print(f"running time: {elapsed_time} ") # 打印出运行时间
hex_output = binascii.hexlify(
aesDrbg.AES_CTR_DRBG_Generate(bit_len)
).decode() # 转为十六进制并解码为string
f.write(hex_output + "\n") # 在每次写入后换行
end_time = time.time() # 记录结束时间
elapsed_time = end_time - start_time # 计算经过的时间
print(f"running time: {elapsed_time} ") # 打印出运行时间

167
sm4Drbg.py
View File

@@ -1,129 +1,142 @@
import secrets
import time
from gmssl.sm4 import CryptSM4,SM4_ENCRYPT
import binascii
import secrets
import time
from gmssl.sm4 import CryptSM4, SM4_ENCRYPT # pylint: disable=e0401 # type: ignore
import binascii
class SM4_RNG:
def __init__(self,personalization_string :bytes = b"",nonce:bytes = b""):
self.keylen= 16
def __init__(self, personalization_string: bytes = b"", nonce: bytes = b""):
self.keylen = 16
self.reseed_counter = 0
self.reseed_interval_in_counter = 1<<30
self.reseed_interval_in_counter = 1 << 30
self.reseed_interval_in_time = 6000
self.min_entropy_input_length = 32
self.max_ectropy_input_length = 1<<35 - 1
self.seedlen = 32
self.outlen = 16
self.blocklen = 16
self.min_entropy_input_length = 32
self.max_ectropy_input_length = 1 << 35 - 1
self.seedlen = 32
self.outlen = 16
self.blocklen = 16
self.seed_material = ""
self.sm4 = CryptSM4()
self.SM4_RNG_Instantiate(personalization_string,nonce)
def SM4_RNG_Instantiate(self,personalization_string :bytes = b"",nonce:bytes = b""):
self.SM4_RNG_Instantiate(personalization_string, nonce)
def SM4_RNG_Instantiate(
self, personalization_string: bytes = b"", nonce: bytes = b""
):
self.min_entropy = self.min_entropy_input_length
self.entropy_input = secrets.token_bytes(self.min_entropy)
self.seed_material = self.entropy_input + nonce + personalization_string
self.seed_material = self.SM4_df(self.seed_material,self.seedlen)
self.seed_material = self.SM4_df(self.seed_material, self.seedlen)
self.Key = b"\x00" * self.keylen
self.V = b"\x00" * self.blocklen
self.SM4_RNG_Update(self.seed_material,self.Key,self.V)
self.SM4_RNG_Update(self.seed_material, self.Key, self.V)
self.reseed_counter = 1
self.last_reseed_time = int(time.time())
def SM4_RNG_Update(self,seed_material,Key,V):
def SM4_RNG_Update(self, seed_material, Key, V):
temp = b""
self.sm4.set_key(Key,SM4_ENCRYPT)
while(len(temp) < self.seedlen):
V = (int.from_bytes(V,"big") + 1) % (1<<self.blocklen)
self.output_block = self.sm4.crypt_ecb(V.to_bytes(self.blocklen,"big"))
self.sm4.set_key(Key, SM4_ENCRYPT)
while len(temp) < self.seedlen:
V = (int.from_bytes(V, "big") + 1) % (1 << self.blocklen)
self.output_block = self.sm4.crypt_ecb(V.to_bytes(self.blocklen, "big"))
temp = temp + self.output_block
temp = temp[:self.seedlen]
temp = int.from_bytes(temp,"big") ^ int.from_bytes(seed_material,"big")
temp = temp.to_bytes(self.seedlen,"big")
self.Key = temp[:self.keylen]
self.V = temp[-self.blocklen:]
def SM4_df(self,input_string:bytes,number_of_bits_to_return:int):
temp = temp[: self.seedlen]
temp = int.from_bytes(temp, "big") ^ int.from_bytes(seed_material, "big")
temp = temp.to_bytes(self.seedlen, "big")
self.Key = temp[: self.keylen]
self.V = temp[-self.blocklen :]
def SM4_df(self, input_string: bytes, number_of_bits_to_return: int):
L = len(input_string)
N = number_of_bits_to_return
S = L.to_bytes(4,"big") + N.to_bytes(4,"big") + input_string + b"\x80"
while(len(S) % self.outlen != 0):
S = L.to_bytes(4, "big") + N.to_bytes(4, "big") + input_string + b"\x80"
while len(S) % self.outlen != 0:
S = S + b"\x00"
temp = b""
i = 0
K = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F \
\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"[:self.keylen]
while len(temp)<self.keylen + self.outlen:
IV = i.to_bytes(4,"big") + b"\x00" * (self.outlen - 4)
temp = temp + self.CBC_MAC(K,(IV+S))
\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"[
: self.keylen
]
while len(temp) < self.keylen + self.outlen:
IV = i.to_bytes(4, "big") + b"\x00" * (self.outlen - 4)
temp = temp + self.CBC_MAC(K, (IV + S))
i = i + 1
K = temp[:self.keylen]
X = temp[self.keylen+1:self.keylen+self.outlen]
tmp = b""
self.sm4.set_key(K,SM4_ENCRYPT)
K = temp[: self.keylen]
X = temp[self.keylen + 1 : self.keylen + self.outlen]
tmp = b""
self.sm4.set_key(K, SM4_ENCRYPT)
while len(tmp) < number_of_bits_to_return:
X = self.sm4.crypt_ecb(X)
tmp = tmp + X
requested_bits = tmp[:number_of_bits_to_return]
return requested_bits
def CBC_MAC(self,Key,data_to_MAC):
self.sm4.set_key(Key,SM4_ENCRYPT)
def CBC_MAC(self, Key, data_to_MAC):
self.sm4.set_key(Key, SM4_ENCRYPT)
chaining_value = b"\x00" * self.outlen
n = len(data_to_MAC) / self.outlen
for i in range(int(n)):
input_block = int.from_bytes(chaining_value,"big") ^ int.from_bytes(data_to_MAC[i*self.outlen:(i+1)*self.outlen],"big")
chaining_value = self.sm4.crypt_ecb(input_block.to_bytes(self.outlen,"big"))
chaining_value = chaining_value[:self.outlen]
input_block = int.from_bytes(chaining_value, "big") ^ int.from_bytes(
data_to_MAC[i * self.outlen : (i + 1) * self.outlen], "big"
)
chaining_value = self.sm4.crypt_ecb(
input_block.to_bytes(self.outlen, "big")
)
chaining_value = chaining_value[: self.outlen]
output_block = chaining_value
return output_block
def SM4_RNG_Reseed(self,additional_input:bytes):
def SM4_RNG_Reseed(self, additional_input: bytes):
self.min_entropy = self.min_entropy_input_length
self.entropy_input = secrets.token_bytes(self.min_entropy)
self.seed_material = self.entropy_input + additional_input
self.seed_material = self.SM4_df(self.seed_material,self.seedlen)
self.SM4_RNG_Update(self.seed_material,self.Key,self.V)
self.seed_material = self.SM4_df(self.seed_material, self.seedlen)
self.SM4_RNG_Update(self.seed_material, self.Key, self.V)
self.reseed_counter = 1
self.last_reseed_time = int(time.time())
def SM4_RNG_Generate(self,requested_number_of_bits,additional_input:bytes=b""):
def SM4_RNG_Generate(self, requested_number_of_bits, additional_input: bytes = b""):
length = int(requested_number_of_bits / 8)
returned_bits = b""
if self.reseed_counter > self.reseed_interval_in_counter or int(time.time()) - self.last_reseed_time > self.reseed_interval_in_time:
if (
self.reseed_counter > self.reseed_interval_in_counter
or int(time.time()) - self.last_reseed_time > self.reseed_interval_in_time
):
self.SM4_RNG_Reseed(additional_input)
if additional_input != b"":
additional_input = self.SM4_df(additional_input,self.seedlen)
self.SM4_RNG_Update(additional_input,self.Key,self.V)
else:
additional_input = self.SM4_df(additional_input, self.seedlen)
self.SM4_RNG_Update(additional_input, self.Key, self.V)
else:
additional_input = b"\x00" * self.seedlen
self.sm4.set_key(self.Key,SM4_ENCRYPT)
while(len(returned_bits) < length):
self.V = int.from_bytes(self.V,"big") + 1 % (1<<self.blocklen)
self.V = self.V.to_bytes(self.blocklen,"big")
output_block =self.sm4.crypt_ecb(self.V)
self.sm4.set_key(self.Key, SM4_ENCRYPT)
while len(returned_bits) < length:
self.V = int.from_bytes(self.V, "big") + 1 % (1 << self.blocklen)
self.V = self.V.to_bytes(self.blocklen, "big")
output_block = self.sm4.crypt_ecb(self.V)
returned_bits = returned_bits + output_block
self.SM4_RNG_Update(additional_input,self.Key,self.V)
self.SM4_RNG_Update(additional_input, self.Key, self.V)
self.reseed_counter += 1
return returned_bits[:length]
if __name__ == "__main__":
bit_len = int(input("Enter the length of the bit string to be generated(bit):"))
num = int(input("Enter the number of the bit string to be generated:"))
file_name = input("Enter the name of the saved file:")
start_time = time.time()
start_time = time.time()
sm4Drbg = SM4_RNG()
with open(file_name,"w") as f:
with open(file_name, "w") as f:
for i in range(num):
hex_output = binascii.hexlify(sm4Drbg.SM4_RNG_Generate(bit_len)).decode()
f.write(hex_output + '\n')
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Program took {elapsed_time} seconds to run.")
hex_output = binascii.hexlify(sm4Drbg.SM4_RNG_Generate(bit_len)).decode()
f.write(hex_output + "\n")
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Program took {elapsed_time} seconds to run.")