第1关：使用快速乘方求幂进行RSA加解密
#从底层实现RSA算法的加密和解密，要求加密和解密过程的求幂过程采用快速乘方算法
class rsatest():
def __init__(self, e, d, n):
self.e = e # 公钥
self.d = d # 私钥
self.n = n # 模
def fast_exp(self, base, exp, mod):
result = 1
base = base % mod
while exp > 0:
if (exp % 2) == 1: # 如果 exp 是奇数
result = (result * base) % mod
exp = exp >> 1 # exp 除以 2
base = (base * base) % mod
return result
def encrypt(self, plaintext):
return self.fast_exp(plaintext, self.e, self.n)
def decrypt(self, ciphertext):
return self.fast_exp(ciphertext, self.d, self.n)
def Evidence(p,e,d,n):
"""
:param p: 明文
:param e: 公钥
:param d: 私钥
:param n: 模
"""
rsa = rsatest(e,d,n)
enc = rsa.encrypt(p)
print(enc)
detext = rsa.decrypt(enc)
print(detext)
第2关：使用rsa模块进行加解密
import base64
import rsa
from OpenSSL.crypto import PKey
from OpenSSL.crypto import TYPE_RSA, FILETYPE_PEM, dump_privatekey, dump_publickey
def generate_keys():
# 生成 RSA 密钥对
public_key, private_key = rsa.newkeys(512) # 使用 512 位密钥
return public_key, private_key
def save_keys_to_file(public_key, private_key):
# 将公钥和私钥保存为 PEM 格式
with open("public_key.pem", "wb") as pub_file:
pub_file.write(public_key.save_pkcs1()) # 保存公钥
with open("private_key.pem", "wb") as priv_file:
priv_file.write(private_key.save_pkcs1()) # 保存私钥
def encrypt_message(public_key, message):
# 加密消息
encrypted_message = rsa.encrypt(message.encode('utf-8'), public_key)
return base64.b64encode(encrypted_message).decode('utf-8') # 返回 base64 编码的密文
def decrypt_message(private_key, encrypted_message):
# 解密消息
encrypted_bytes = base64.b64decode(encrypted_message.encode('utf-8'))
decrypted_message = rsa.decrypt(encrypted_bytes, private_key).decode('utf-8')
return decrypted_message
def main(text):
# 生成密钥对
public_key, private_key = generate_keys()
# 保存密钥到文件
save_keys_to_file(public_key, private_key)
# 加密和解密
encrypted_message = encrypt_message(public_key, text)
decrypted_message = decrypt_message(private_key, encrypted_message)
# 输出解密后的消息
print(decrypted_message)
if __name__=='__main__':
text = input()
main(text)
第1关：GmSSL SM2加解密
#!/bin/bash
#在以下部分写出完成任务的命令
#***********begin*************#
echo GuetPython >msg.txt
gmssl sm2 -genkey -out sm2.pem
gmssl pkey -in sm2.pem -pubout -out sm2Pub.pem
gmssl sm2utl -sign -in msg.txt -inke sm2.pem -id Alice -out sig.der
gmssl sm2utl -encrypt -pubin -inkey sm2Pub.pem -in msg.txt -out msg.en
gmssl sm2utl -decrypt -inkey sm2.pem -in msg.en -out msg.de
#************end**************#
第2关：GmSSL签名验证
#!/bin/bash
#在以下部分写出完成任务的命令
#***********begin*************#
echo GuetPython >msg.txt
gmssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:sm2p256v1 -out signkey.pem
gmssl pkeyutl -sign -pkeyopt ec_scheme:sm2 -inkey signkey.pem -in msg.txt -out msg.txt.sig
gmssl pkey -pubout -in signkey.pem -out vrfykey.pem
gmssl pkeyutl -verify -pkeyopt ec_scheme:sm2 -pubin -inkey vrfykey.pem -in msg.txt -sigfile msg.txt.sig >cmp.txt
#************end**************#
第1关：RSA加解密
#!/bin/bash
#在以下部分写出完成任务的命令
#***********begin*************#
echo "GuetPython" > hello.txt
openssl genrsa -out privacy.pem 1024
openssl rsa -in privacy.pem -pubout -out public.pem
openssl rsautl -encrypt -inkey public.pem -pubin -in hello.txt -out hello.en
openssl rsautl -decrypt -inkey privacy.pem -in hello.en -out hello.de
cat hello.de
#************end**************#
第2关：RSA签名验证
#!/bin/bash
#
#在以下部分写出完成任务的命令
#***********begin*************#
# 创建 hello.txt 文件
echo "GuetPython" > hello.txt
# 生成1024位的私钥
openssl genrsa -out privacy.pem 1024
# 从私钥中提取公钥
openssl rsa -in privacy.pem -pubout -out public.pem
# 使用私钥对 hello.txt 文件进行签名
openssl dgst -sha256 -sign privacy.pem -out hello.sig hello.txt
# 使用公钥验证签名
openssl dgst -sha256 -verify public.pem -signature hello.sig hello.txt > verification_result.txt 2>&1
# 检查签名是否验证通过，并输出 hello.txt 的内容
if grep -q "Verified OK" verification_result.txt; then
cat hello.txt > hello.ver
else
echo "Verification failed" > hello.ver
fi
# 输出 hello.ver 文件的内容
cat hello.ver
#************end**************#
第3关：实用的RSA签名验证
#!/bin/bash
#在以下部分写出完成任务的命令
#***********begin*************#
# 创建 hello.txt 文件
echo "GuetPython" > hello.txt
# 生成1024位的私钥
openssl genrsa -out privacy.pem 1024
# 从私钥中提取公钥
openssl rsa -in privacy.pem -pubout -out public.pem
# 对 hello.txt 计算 SHA256 摘要并进行签名
openssl dgst -sha256 -sign privacy.pem -out hello.sha256 hello.txt
# 使用公钥验证签名，并将结果输出到 result.txt
openssl dgst -sha256 -verify public.pem -signature hello.sha256 hello.txt > result.txt 2>&1
# 输出 result.txt 文件的内容
#************end**************#
第1关 计算哈希值和消息验证码
import hashlib
import hmac
def myhash(str):
#***********Begin**************
# 计算并打印输入字符串的 MD5 和 SHA-512 哈希值
# 参数:
# str: 要计算哈希值的输入字符串
# 创建 MD5 哈希对象
res_md5 = hashlib.md5()
# 更新哈希对象，传入编码后的字符串
res_md5.update(str.encode())
# 打印 MD5 哈希值的十六进制表示
print(res_md5.hexdigest())
# 创建 SHA-512 哈希对象
res_sha512 = hashlib.sha512()
# 更新哈希对象，传入编码后的字符串
res_sha512.update(str.encode())
# 打印 SHA-512 哈希值的十六进制表示
print(res_sha512.hexdigest())
#************End***************
def myhmac(key,str,mode):
# 计算并返回输入字符串的 HMAC 值
# 参数:
# key: 用于计算 HMAC 的密钥
# str: 要计算 HMAC 的输入字符串
# mode: 指定使用的哈希函数，如 hashlib.md5 或 hashlib.sha256
# 使用给定的密钥和哈希函数计算 HMAC
res = hmac.new(key.encode(), str.encode(), digestmod=mode).hexdigest()
# 返回 HMAC 值的十六进制表示
print(res)
#************End***************
第2关：哈希函数的雪崩效应
import hashlib
def avalanche(str,nbyte,mbit):
# 计算哈希值的雪崩效应
# 参数:
# str: 要计算哈希值的输入字符串
# nbyte: 从低位到高位，指定要替换的字节位置
# mbit: 从低位到高位，指定要替换的位位置
# 替换指定字节和位
str1 = replaceStr(str, nbyte, mbit)
# 计算原字符串的 MD5 哈希值
res1 = hashlib.md5()
res1.update(str.encode())
res1 = res1.hexdigest()
# 计算修改后的字符串的 MD5 哈希值
res2 = hashlib.md5()
res2.update(str1.encode())
res2 = res2.hexdigest()
# 将哈希值转换为二进制字符串
str_bit1 = hex_to_bin(res1)
str_bit2 = hex_to_bin(res2)
# 比较两个二进制字符串的不同位数
count = cmpcount(str_bit1, str_bit2)
print(count)
def hex_to_bin(hexStr):
# 将十六进制字符串转换为二进制字符串
# 参数:
# hexStr: 输入的十六进制字符串
res = ""
for digit in hexStr:
# 将十六进制数字转换为十进制，再格式化为四位二进制
decimal_num = int(digit, 16)
binary_num = format(decimal_num, "04b")
res += binary_num
return res
def cmpcount(str1, str2):
# 计算两个二进制字符串的不同位数
# 参数:
# str1: 第一个二进制字符串
# str2: 第二个二进制字符串
count = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
count += 1
return count
def replaceStr(str, nbyte, mbit):
# 替换字符串中特定字节的特定位
# 参数:
# str: 输入字符串
# nbyte: 指定替换的字节位置
# mbit: 指定替换的位位置
str1 = str.encode() # 将字符串编码为字节串
replace_byte = hex(str1[-nbyte]) # 获取指定字节的十六进制表示
res = ""
# 将十六进制转换为二进制字符串
for i in range(2, len(replace_byte)):
decimal_num = int(replace_byte[i], 16)
binary_num = format(decimal_num, "04b")
res += binary_num
temp_list = list(res) # 将二进制字符串转换为列表以便修改
# 切换指定位
if res[-mbit] == "1":
temp_list[-mbit] = '0'
else:
temp_list[-mbit] = '1'
res = "".join(temp_list) # 将列表重新连接为字符串
letter = chr(int(res, 2)) # 将二进制字符串转换为字符
res_list = list(str) # 将原字符串转换为列表
res_list[-nbyte] = letter # 替换指定字节
return "".join(res_list) # 返回修改后的字符串
#************End***************
if __name__ == "__main__":
str,nbyte,mbit = input().split()
nbyte = int(nbyte)
mbit = int(mbit)
avalanche(str,nbyte,mbit)
第3关：暴力破解md5
from hashlib import md5 # 导入md5哈希函数
from string import ascii_letters, digits, punctuation # 导入字母、数字和标点符号
from itertools import permutations # 导入排列函数
import time # 导入时间模块，用于测量执行时间
# 将所有字符（字母、数字、标点）组合成一个字符串
all = ascii_letters + digits + punctuation
def brute_md5(md5_value):
md5_value = md5_value.lower() # 将输入的MD5值转换为小写
if len(md5_value) == 32: # 检查MD5值是否为32个字符长
count = 5 # 从长度为5的排列开始
start = time.time() # 记录开始时间
while True: # 无限循环以不断尝试不同长度
for item in permutations(all, count): # 生成给定长度的排列
item = "".join(item) # 将元组连接成字符串
if md5(item.encode()).hexdigest() == md5_value: # 检查MD5哈希是否匹配
end = time.time() # 记录结束时间
#print(end - start) # 打印找到匹配所花的时间
print(item) # 打印找到的字符串
return # 找到匹配后退出函数
count += 1 # 增加长度以进行下一次迭代
else:
print("不是有效的md5值") # 如果输入不是有效的MD5哈希，打印错误消息
# 用户输入
md5_value = input()
brute_md5(md5_value) # 使用提供的MD5值调用暴力破解函数
数字信封—接收方验证签名
import CryptoTest
import os
# 进入相应的目录（请根据实际路径调整）
os.chdir('step1')
# 第一步：用接收方B的私钥解密对称密钥文件
Arsa = CryptoTest.rsatest()
Arsa.decrypt('keyencrypted.bin', 'aeskey.txt', 'Bprikey.bin')
print('对称密钥文件：')
# 读取解密后的对称密钥
with open('aeskey.txt', 'rb') as f:
aeskey = f.read()
print(aeskey.decode('utf-8')) # 解码并输出会话密钥（假设是文本）
# 第二步：用解密后的对称密钥解密密文
with open('aeskey.txt', 'rb') as f:
aessymkey = f.read()
Baestest = CryptoTest.aestest(aessymkey) # 实例化AES对象
# 读取密文文件并解密
print("明文文件：")
with open('ciphertext.bin', 'rb') as f: # 使用rb模式读取密文
ciphertext = f.read() # 读取密文文件中的所有数据
plain = Baestest.decrypt(ciphertext) # 解密密文
# 将解密后的明文写入文件
with open('plaintext.bin', 'wb') as obj: # 使用wb模式写入解密后的明文
obj.write(plain.encode('utf-8')) # 编码成utf-8格式保存
# 打开并打印解密后的明文内容
with open('plaintext.bin', 'r', encoding='utf-8') as f:
plaintext = f.read()
print(plaintext)
# 第三步：用发送方A的公钥Apubkey.bin验证签名
print("验证结果：")
asign = CryptoTest.signverify()
# 验证数字签名
if asign.verify('plaintext.bin', 'Apubkey.bin', 'digitalsign.bin'):
print("验证失败")
else:
print("验证正确")
数字信封—接收方解密密钥
import CryptoTest # 引入加解密模块
# 第一步：用接收方B的私钥解密对称密钥文件
Brsa = CryptoTest.rsatest()
# 解密对称密钥文件
Brsa.decrypt('keyencrypted.bin', 'aeskey.txt', 'Bprikey.bin')
# 读取解密后的会话密钥
with open('aeskey.txt', 'rb') as f: # 以二进制模式读取密钥文件
p = f.read()
print('解密后的对称密钥是：\n' + p.decode('utf-8')) # 输出会话密钥，注意解码
# 第二步：用对称密钥解密密文
with open('aeskey.txt', 'rb') as f: # 以二进制模式读取对称密钥
aessymkey = f.read()
Baestest2 = CryptoTest.aestest(aessymkey) # 实例化 AES 对象
with open('ciphertext.bin', 'rb') as f: # 以二进制模式读取密文文件
m = f.read()
plaintext = Baestest2.decrypt(m) # 解密密文
print("解密后的明文是：")
print(plaintext)
2 Responses
QWQ
Very goood code makes me hard