python密码学实验 - H1S97X's Blog

实验一：熟悉 Python 开发环境，凯撒密码与仿射密码#

实验目的#

熟悉 Pycharm/ Python Idle 开发
完成 Casear 密码的编程。

实验内容#

1、安装 Python、Pycharm；了解 Idle 的应用；学会 pip 安装命令，将 Cryptography gmpy2 库安装到 python 中。

2、编写 Casear 密码程序，扩展到仿射密码、以及 Casear 密码的破译程序。

caesar 密码 python 实现#

Python 密码学教程 - w3schools

第一版代码：

两个函数分别实现对 Caesar 密码的加密和解密，关键的操作公式是相同的，只是对密钥进行加减操作。

1
for i in message:
2
  ciphertext += (chr(ord(i) + k)) # 将明文汉字转换为对应ASCLL数值或Unicode数值（ord函数），然后在此数值上+3，再将该值返回汉字（chr函数）

第二版代码：

同样是两个函数分别实现对 Caesar 密码的加密和解密，将公式进行修改，第一版并不能把密码限制在 26 个字母。

1
for i in range(len(text)):
2
    char = text[i]
3
    if (char.isupper()):
4
        ciphertext += chr((ord(char) + key - ord('a')) % 26 + ord('a'))
5
    else:
6
        ciphertext += chr((ord(char) + key - ord('A')) % 26 + ord('A'))

第三版：

能够自定义

1
SYMBOLS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890 !?.'
2
def caesar_encrypt(mode, message, key):
3
    if mode[0] == 'd':
4
        key = -key
5
    ciphertext = ''
6
    for symbol in message:
7
        if symbol.isalpha():
8
          num = ord(symbol)+key
9
          if symbol.isupper():  # 所有密文字母是大写
10
              if num > ord('Z'):
11
                  num -= 26
12
              elif num < ord('A'):
13
                  num += 26
14
          elif symbol.islower():
15
              if num > ord('z'):
16
                  num -= 26
17
              elif num < ord('a'):
18
                  num += 26
19
        ciphertext += chr(num)
20
        else:
21
            ciphertext += symbol
22
    return ciphertext

暴力破解

1
def caesar_decrypt(message):
2
    LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
3
    letters = "abcdefghijklmnopqrstuvwxyz"
4
    for key in range(26):
5
        translated = ''
6
        for symbol in message:
7
            if symbol in LETTERS:
8
                num = LETTERS.find(symbol)
9
                num = num - key
10
                if num < 0:
11
                    num = num + len(LETTERS)
12
                translated = translated + LETTERS[num]
13
            elif symbol in letters:
14
                num = letters.find(symbol)
15
                num = num - key
16
                if num < 0:
17
                    num = num + len(letters)
18
                translated = translated + letters[num]
19
            else:
20
                translated = translated + symbol
21
        print('Hacking key #%s: %s' % (key, translated))

仿射密码#

仿射密码 Python 实现仿射密码是一种替换密码。它是利用加密函数一个字母对一个字母的加密。

加密函数是 E(x)= (ax + b) (mod m)，其中，a 和 m 互质，m 是字符集的大小。（例如，26 即是以 26 个字母作为编码，当 m 是 26 时，a 必须是 1，3，5，7，9，11，15，17，19，21，23，25 其中之一）

解密函数为 D(x) = a^-1(x - b) (mod m)，其中 a^-1是 a 在 Zm 群的乘法逆元。

乘法逆元 群 G 中任意一个元素 a，都在 G 中有唯一的逆元 a’，具有性质 aa’ = a’a = e，其中 e 为群的单位元。

1
'''
2
仿射密码
3
(a,b)
4
m = 26，字符集为小写字母
5
加密函数是E(x)= (ax + b) (mod m)
6
解密函数为D(x) = (a^-1)(x - b) (mod m)，其中a^-1是a的乘法逆元
7
'''
8

9
#通过一个简单的遍历得到a的乘法逆元，也可以通过gmpy2库中的invert函数实现
10
def get_inverse(a):
11
    for i in range(1,27):
12
        if a*i%26==1:
13
            return i
14

15
#加密
16
def encipher(a, b, p):
17
    c=[]
18
    for i in p:
19
        temp=((ord(i)-97)*a+b)%26+97
20
        c.append(chr(temp))
21
    print(''.join(c))
22

23
#解密
24
def decipher(a, b, c):
25
    a_inv = get_inverse(a)
26
    p=[]
27
    for i in c:
28
        temp=(((ord(i)-97)-b)*a_inv)%26+97
29
        p.append(chr(temp))
30
    print(''.join(p))
31

32
if __name__ == "__main__":
33
    a = 11
34
    b = 6
35
    message = 'sorcery'
36
    encipher(a,b,message)
37
    #decipher(a,b,message)

1
'''
2
仿射密码
3
m = 52
4
字符集为小写和大写字母
5
'''
6
import string
7
def encrypt(k1,k2,message):
8
    dic = string.ascii_letters
9
    c = []
10
    for i in message:
11
        if i.islower():
12
            num = ord(i)-ord('a')
13
            c.append(dic[(num*k1+k2)%52])
14
        elif i.isupper():
15
            num = ord(i)-ord('A')+26
16
            c.append(dic[(num*k1+k2)%52])
17
        else:
18
            c.append(i)
19
    print(''.join(c))
20

21
def decrypt(k1,k2,message):
22
    for i in range(52):
23
        if k1*i%52==1:
24
            inv = i
25
            break
26
    dic = string.ascii_letters
27
    m = []
28
    for i in message:
29
        if i.islower():
30
            num = ord(i)-ord('a')
31
            m.append(dic[inv*(num-k2)%52])
32
        elif i.isupper():
33
            num = ord(i)-ord('A')+26
34
            m.append(dic[inv*(num-k2)%52])
35
        else:
36
            m.append(i)
37
    print(''.join(m))
38

39
message = 'gVEXGT iDIT' #待加密或解密的消息
40
a = 5 # key的范围0~51之间
41
b = 29 # key的范围0~51之间
42
# encrypt(a,b,message)
43
decrypt(a,b,message)

1
class Affine(object):
2
    DIE = 128
3
    KEY = (7, 3, 55)
4

5
    def __init__(self):
6
        pass
7

8
    def encryptChar(self, char):
9
        K1, K2, kI = self.KEY
10
        return chr((K1 * ord(char) + K2) % self.DIE)
11

12
    def encrypt(self, string):
13
        return "".join(map(self.encryptChar, string))
14

15
    def decryptChar(self, char):
16
        K1, K2, KI = self.KEY
17
        return chr(KI * (ord(char) - K2) % self.DIE)
18

19
    def decrypt(self, string):
20
        return "".join(map(self.decryptChar, string))
21

22
affine = Affine()
23
print(affine.encrypt('Affine Cipher'))
24
print(affine.decrypt('*18?FMT'))

实验二：哈希函数#

1、编程实现生成空字符串、‘Alice’、‘Bob’的 md5、sha256 的哈希值；

1
import hashlib
2
def hash_md5():
3
    alice = hashlib.md5(b"Alice")
4
    bob = hashlib.md5(b"Bob")
5
    print('"Alice" md5:' + alice.hexdigest())
6
    print('"Bob" md5:' + bob.hexdigest())
7

8
def hash_sha256():
9
    alice = hashlib.sha256(b"Alice")
10
    bob = hashlib.sha256(b"Bob")
11
    print('"Alice" sha256:' + alice.hexdigest())
12
    print('"Bob" sha256:' + bob.hexdigest())

2、编程实现生成自己名字的哈希值，注意编码的转换；

1
def myhash(str = "Yangjiaqing"):
2
    res = hashlib.md5(str.encode(encoding="utf-8"))
3
    print(str + " md5: " + res.hexdigest())

3、编写体现哈希雪崩的代码，哈希值用二进制表示；参考 Listing2-5 代码； Python 哈希函数与消息认证实验展示散列函数的雪崩效应

1
def cmpcount(str1, str2):
2
    count = 0
3
    for i in range(0, len(str1)):
4
        if str1[i] != str2[i]:
5
            count += 1
6
    return count
7

8
def avalanche(str1 = 'bob', str2 = 'aob'):
9
    bin1 = str1.encode('utf-8')
10
    bin2 = str2.encode('utf-8')
11
    hexstring1 = hashlib.md5(bin1).hexdigest()
12
    binstring1 = '{:08b}'.format(int(hexstring1, 16))
13
    # binstring1 = bin(int(hexstring1, 16))
14
    hexstring2 = hashlib.md5(bin2).hexdigest()
15
    binstring2 = '{:08b}'.format(int(hexstring2, 16))
16
    # binstring2 = bin(int(hexstring2, 16))
17
    print(int(hexstring1, 16))
18
    print(int(hexstring2, 16))
19
    print(str1 + " md5:" + binstring1)
20
    print(str2 + " md5:" + binstring2)
21
    print("两个哈希值不同的位数：" + str(cmpcount(binstring1, binstring2)))

4、利用 scrypt 密钥派生函数，实现口令加盐，生成更加安全的密钥（口令）；创建一个 Python 盐 Scrypt 介绍 Scrypt 是一个强大的密钥派生函数，其通过内存密集的计算方式来抵抗 GPU、ASIC、FPGA 这类密码破解硬件的攻击。

Scrypt 接收多个输入参数，进行计算后输出密钥：

key = Scrypt(password, salt, N, r, p, derived-key-len) 其中的参数被称为” Scrypt 配置参数”，说明如下：

N - 迭代次数，将影响 CPU 和内存用量，例：16384 、2048 ； r - 块大小，将影响 CPU 和内存用量，例：8 ； p - 并行因数（并行运行的线程数，将影响 CPU 和内存用量），通常为 1 ； password - 输入的密码（推荐至少为 8 - 10 个字符）； salt - 安全产生的随机字节序列（最小为 64 位，推荐 128 位）； derived-key-len - 输出的密钥要有多少字节长，例如 32 （256 位） Scrypt 的输出密钥长度可以是 128 位到 512 位，但是通常为 256 位。

Salt 用使用 secrets 模块生成，也可以用 os.urandom()随机生成

1
def hash_password(password = b'p@$Sw0rD~7'):
2
    salt_length = 16
3
    salt = secrets.token_bytes(salt_length)
4
    key = pyscrypt.hash(password, salt, 2048, 8, 1, 32)
5
    return key.hex()

5、实现区块链中的工作量证明编程，通过设置不同的难度，体会生成符合要求哈希值需要时间长短的不同；从零开始构建一个区块链（二）：工作量证明使用 python 实现简版区块链-工作量证明区块链的简单实现 - GitHub

1
import sys
2
import hashlib
3
class NonceNotFoundError(Exception):
4
    pass
5

6
def encode(str, code='utf-8'):
7
    return str.encode(code)
8

9
def decode(bytes, code='utf-8'):
10
    return bytes.decode(code)
11

12
def sum256_hex(*args):
13
    m = hashlib.sha256()
14
    for arg in args:
15
        if isinstance(arg, str):
16
            m.update(arg.encode())
17
        else:
18
            m.update(arg)
19
    return m.hexdigest()
20

21
def sum256_byte(*args):
22
    m = hashlib.sha256()
23
    for arg in args:
24
        if isinstance(arg, str):
25
            m.update(arg.encode())
26
        else:
27
            m.update(arg)
28
    return m.digest()
29

30
class ProofOfWork(object):
31
    _N_BITS = 20
32
    MAX_BITS = 256
33
    MAX_SIZE = sys.maxsize
34
    def __init__(self, n_bits=_N_BITS):
35
        self._n_bits = n_bits
36
        self._target_bits = 1 << (self.MAX_BITS - n_bits)
37
    def _prepare_data(self, nonce):
38
        data_lst = [str(nonce)]
39
        return encode(''.join(data_lst))
40
    def run(self):
41
        nonce = 0
42
        found = False
43
        hash_hex = None
44
        print('Mining a new block')
45
        while nonce < self.MAX_SIZE:
46
            data = self._prepare_data(nonce)
47
            hash_hex = sum256_hex(data)
48
            hash_val = int(hash_hex, 16)
49
            sys.stdout.write("try nonce == %d hash_hex == %s \r" % (nonce, hash_hex))
50
            if (hash_val < self._target_bits):
51
                found = True
52
                break
53

54
            nonce += 1
55
        if found:
56
            print('Found nonce == %d' % nonce)
57
        else:
58
            print('Not Found nonce')
59
            raise NonceNotFoundError('nonce not found')
60
        return nonce, hash_hex
61
if __name__ == "__main__":
62
    bc = ProofOfWork()
63
    bc.run()

实验三：实现对称加密编程#

分组密码的五大工作模式

使用 cryptography 进行 AES 的 cbc 模式加密 - 知乎 (zhihu.com)

istommao/cryptokit: cryptokit is a cryptography kit (github.com)

4、练习 3-12 手工 CBC:编程应用 AES 的 ECB 模式实现 CBC 模式

1
def ecbTocbc(self, data):
2
    if not isinstance(data, bytes):
3
        data = data.encode()
4
    cipher = Cipher(algorithms.AES(self.aes_key),
5
                    modes.ECB(),
6
                    backend=default_backend())
7
    dataList = []
8
    cipherText = []
9
    padded_data = self.pkcs7_padding(data)
10
    binary_data = bin((int(padded_data.hex(), 16)))[2:]
11
    while len(binary_data) / 128 >= 0:
12
        if len(binary_data) / 128 == 0 & len(binary_data) % 128 == 0:
13
            break
14
        elif len(binary_data) / 128 == 0 & len(binary_data) % 128 != 0:
15
            dataList.append(binary_data[0:])
16
            dataList.remove()
17
        else:
18
            dataList.append(binary_data[0:128])
19
            binary_data = binary_data[128:]
20

21
    c = "{:08b}".format(int(self.aes_iv.hex(), 16))
22
    for i in dataList:
23
        ci = cipher.encryptor().update(bytes(i^c))
24
        cipherText.append(ci)
25
        c = ci.decode()
26
        print(c)
27
    m = ''.join([c.hex() for c in cipherText])
28
    return m

5、练习 3-13 简单 CTR 模式：编程应用 AES 的 ECB 模式实现 CTR 模式

1
def ecbToctr(self, data):
2
    if not isinstance(data, bytes):
3
        data = data.encode()
4
    iv = self.aes_iv
5
    cipher = Cipher(algorithms.AES(self.aes_key),
6
                    modes.ECB(),
7
                    backend=default_backend())
8

9
    dataList = []
10
    cipherText = []
11
    padded_data = self.pkcs7_padding(data)
12
    binary_data = "{:08b}".format(int(padded_data.hex(), 16)) + '0'
13
    while len(binary_data) / 128 >= 0:
14
        if len(binary_data) / 128 == 0 & len(binary_data) % 128 == 0:
15
            break
16
        elif len(binary_data) / 128 == 0 & len(binary_data) % 128 != 0:
17
            dataList.append(binary_data[0:])
18
            dataList.remove()
19
        else:
20
            dataList.append(binary_data[0:128])
21
            binary_data = binary_data[128:]
22

23

24
    for i in dataList:
25
        ci = cipher.encryptor().update(iv) ^ i.encode()
26
        iv += 1
27
        cipherText.append(ci)
28
        print(ci)
29
    m = ''.join(cipherText)
30
    return m

实验四：实现非对称加密编程#

非对称密钥沉思系列（1）：RSA 专题之 PKCSv1.5 填充模式下的选择性密文攻击概述-腾讯云开发者社区-腾讯云 (tencent.com)