Python - 密码学编程

当前位置:

首页 > temp > 简明python教程 >

Python - 密码学编程

1、简介

信息加密和信息隐藏是实现信息安全与保密的主要手段。从古至今人类发明了大量的加密算法和隐藏信息的方法。例如，把纸条螺旋缠绕在一根木棍上然后往上写字，展开后通过一定的渠道把纸条传递给对方，对方把纸条螺旋缠绕到同样粗细的木棍上就可以正常阅读信息，其他人即使知道这样的方法，如果不知道木棍的直径也无法解密信息，可以说木棍的直径是这种加密方法中的密钥。再如，古代武林高手把一些秘籍通过特定的手段写到羊皮上，只有使用正确的方法才能看到上面的内容，战争年代聪明的老百姓也发明了在煮熟的鸡蛋清上写字的方法来传递情报，电视剧《连城诀》中的终极秘密则是隐藏在一本《唐诗300首》书中。

除了可以设计自己的加密算法或者自己编写程序实现经典的加密解密算法之外，带可以充分利用Python标准库和扩展库提供的丰富功能。Python标准库hashlib实现了SHA1、SHA224、SHA256、SHA384、SHA512以及MD5等多个安全哈希算法。在众多的Python扩展库中，pycrypto可以说是密码学编程模块中最成功也是最成熟的一个，具有很高的市场占在率。另外，cryptography也有一定数量的用户在使用。扩展库pycrypto和cryptography提供了SHA系统算法和RIPEMD160等多个安全哈希算法，以及DES、AES、RSA、DSA、ElGamal等多个加密算法和数字签名算法的实现。

2、经典密码算法

很多经典密码算法的安全性很低，甚至很容易被词频分析这样的简易攻击手段破解，因此已经很少再使用。尽管如此，经典密码算法的一些思想还是很有借鉴意义和参考价值的。

2.1、恺撒密码算法

恺撒密码作为古老的加密算法之一，在古罗马的时候就已经广泛使用了。恺撒密码算法的基本思想是：通过把字母移动一定的位数来实现加密和解密。明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推，X将变成A，Y变成B，Z变成C。移动的位数就是恺撒密码加密和解密的密钥。

#! /usr/bin/env python3
# -*- coding:utf-8 -*-

# Author   : MaYi
# Blog     : http://www.cnblogs.com/mayi0312/
# Date     : 2020-04-16
# Name     : test01
# Software : PyCharm
# Note     : 恺撒密码算法


def kai_sa_encrypt(ch, k):
    if (not isinstance(ch, str)) or len(ch) != 1:
        print("The first parameter must be a character!")
        return

    if (not isinstance(k, int)) or (not 1<= k <= 25):
        print("The second parameter must be an integer between 1 and 25!")
        return

    # 把英文字母变换为后面第k个字母
    if "a" <= ch <= chr(ord("z") - k):
        return chr(ord(ch) + k)
    elif chr(ord("z") - k) < ch <= "z":
        return chr((ord(ch) - ord("a") + k) % 26 + ord("a"))
    elif "A" <= ch <= chr(ord("Z") - k):
        return chr(ord(ch) + k)
    elif chr(ord("Z") - k) < ch <= "Z":
        return chr((ord(ch) - ord("A") + k) % 26 + ord("A"))
    else:
        return ch


def encrypt(plain, k):
    return "".join([kai_sa_encrypt(ch, k) for ch in plain])


def kai_sa_decrypt(ch, k):
    if (not isinstance(ch, str)) or len(ch) != 1:
        print("The first parameter must be a character!")
        return

    if (not isinstance(k, int)) or (not 1<= k <= 25):
        print("The second parameter must be an integer between 1 and 25!")
        return

    # 把英文字母首尾相连，然后把每个字母变换为前面第k个字母
    if chr(ord("a") + k) <= ch <= "z":
        return chr(ord(ch) - k)
    elif "a" <= ch < chr(ord("a") + k):
        return chr((ord(ch) - k + 26))
    elif chr(ord("A") + k) <= ch <= "Z":
        return chr(ord(ch) - k)
    elif "A" <= ch < chr(ord("A") + k):
        return chr((ord(ch) - k + 26))
    else:
        return ch


def decrypt(plain, k):
    return "".join([kai_sa_decrypt(ch, k) for ch in plain])

# 入口函数
if __name__ == '__main__':
    plain_text = "Explicit is better than implicit."
    cipher_text = encrypt(plain_text, 5)
    print("明文", plain_text)
    print("密文", cipher_text)
    print("明文", decrypt(cipher_text, 5))

程序运行结果：

明文 Explicit is better than implicit.
密文 Jcuqnhny nx gjyyjw ymfs nruqnhny.
明文 Explicit is better than implicit.

2.2、维吉尼亚密码

维吉尼亚密码算法使用一个密钥和一个表来实现加密，根据明文和密钥的对应关系进行查表来决定加密结果。假设替换表如图1所示，最上面一行表示明文，最左边一列表示密钥，那么二维表格中与明文字母和密钥字母对应的字母就是加密结果。例如，单词PYTHON使用ABCDEF做密钥的加密结果为PZVKSS。

　　图1 维吉尼亚密码替换表

#! /usr/bin/env python3
# -*- coding:utf-8 -*-

# Author   : MaYi
# Blog     : http://www.cnblogs.com/mayi0312/
# Date     : 2020-04-16
# Name     : test02
# Software : PyCharm
# Note     : 维吉尼亚密码
#            维吉尼亚密码算法使用一个密钥和一个表来实现加密，根据明文和密钥的对应
#            关系进行查表来决定加密结果。
from string import ascii_uppercase as uppercase
from itertools import cycle

# 创建密码表
table = dict()
for ch in uppercase:
    index = uppercase.index(ch)
    table[ch] = uppercase[index:] + uppercase[:index]

# 创建解密密码表
de_table = {"A": "A"}
start = "Z"
for ch in uppercase[1:]:
    index = uppercase.index(ch)
    de_table[ch] = chr(ord(start) + 1 - index)


# 解密密钥
def de_key(s_key):
    return "".join([de_table[i] for i in s_key])


# 加密/解密
def encrypt(plain_text, key):
    result = []
    # 创建cycle对象，支持密钥字母的循环使用
    current_key = cycle(key)
    for c in plain_text:
        if "A" <= c <= "Z":
            i_index = uppercase.index(c)
            # 获取密钥字母
            ck = next(current_key)
            result.append(table[ck][i_index])
        else:
            result.append(c)

    return "".join(result)

# 入口函数
if __name__ == '__main__':
    key = "MAYI"
    p = "PYTHON 3.5.2 PYTHON 2.7.11"
    c = encrypt(p, key)
    print("明文", p)
    print("密文", c)
    print("明文", encrypt(c, de_key(key)))

程序运行结果：

明文 PYTHON 3.5.2 PYTHON 2.7.11
密文 BYRPAN 3.5.2 NGFHMV 2.7.11
明文 PYTHON 3.5.2 PYTHON 2.7.11

2.3换位密码算法

换位密码也是一种比较常见的经典密码算法，基本原理是先把明文按固定长度进行分组，然后对每一组的字符进行换位操作，从而实现加密。例如，字符串“Errors should never pass silently.”使用密钥1432进行加密时，首先将字符串分成若干长度为4的分组，然后对每个组的字符进行换位，第1个字符和第3个字符位置不变，把第2个字符和第4个字符交换位置，得到“Eorrrs shluoden v repssa liseltny.”。

#! /usr/bin/env python3
# -*- coding:utf-8 -*-

# Author   : MaYi
# Blog     : http://www.cnblogs.com/mayi0312/
# Date     : 2020-04-16
# Name     : test03
# Software : PyCharm
# Note     : 换位密码算法
#            换位密码也是一种比较常见的经典密码算法，基本原理是先把明文按固定长度进行
#            分组，然后对每一组的字符进行换位操作，从而实现加密。


def encrypt(plain_text, t):
    result = []
    length = len(t)
    # 把明文分组
    temp = [plain_text[i: i + length] for i in range(0, len(plain_text), length)]
    # 对除最后一组之外的其他进行换位处理
    for item in temp[:-1]:
        new_item = ""
        for i in t:
            new_item = new_item + item[i - 1]
        result.append(new_item)
    return "".join(result) + temp[-1]

p = "Errors should never pass silently."
# 加密
c = encrypt(p, (1, 4, 3, 2))
print("明文", p)
print("密文", c)
# 解密
print("明文", encrypt(c, (1, 4, 3, 2)))

程序运行结果：

明文 Errors should never pass silently.
密文 Eorrrs shluoden v repssa liseltny.
明文 Errors should never pass silently.

3、安全哈希算法

安全哈希算法也称为报文摘要算法，对任意长度的消息可以计算得到固定长度的唯一指纹。理论上，即使是内容非常相似的消息也不会得到完全相同的指纹。安全哈希算法是不可逆的，无法从指纹还原得到原始消息，属于单向变换算法。安全哈希算法常用于数字签名领域，可以验证信息是否被篡改，很多管理信息系统把用户密码的哈希值存储到数据库中而不是直接存储密码明文，大幅度提高了系统的安全性。另外，文件完整性检查也经常用到MD5或其他安全哈希算法，用来验证文件发布之后是否被非法修改。

下面的代码使用Python标准库hashlib计算字符串的安全哈希值。

>>> import hashlib
>>> hashlib.md5("abcdefg".encode()).hexdigest()
'7ac66c0f148de9519b8bd264312c4d64'
>>> hashlib.sha512("abcdefg".encode()).hexdigest()
'd716a4188569b68ab1b6dfac178e570114cdf0ea3a1cc0e31486c3e41241bc6a76424e8c37ab26f096fc85ef9886c8cb634187f4fddff645fb099f1ff54c6b8c'
>>> hashlib.sha256("abcdefg".encode()).hexdigest()
'7d1a54127b222502f5b79b5fb0803061152a44f92b37e23c6527baf665d4da9a'

Python扩展库pycrypto也提供了MD2、MD4、MD5、HMAC、RIPEMD、SHA、SHA224、SHA256、SHA384、SHA512等多个安全哈希算法的实现。

>>> from Crypto.Hash import SHA256
>>> h = SHA256.SHA256Hash("abcdefg".encode())
>>> h.hexdigest()
'7d1a54127b222502f5b79b5fb0803061152a44f92b37e23c6527baf665d4da9a'

计算文件的MD5值

#! /usr/bin/env python3
# -*- coding:utf-8 -*-

# Author   : MaYi
# Blog     : http://www.cnblogs.com/mayi0312/
# Date     : 2020-04-16
# Name     : test04
# Software : PyCharm
# Note     : 计算文件的MD5值
import sys
import hashlib
import os.path


# 入口函数
if __name__ == '__main__':
    file_name = sys.argv[1]
    if os.path.isfile(file_name):
        fp = open(file_name, "rb")
        contents = fp.read()
        fp.close()
        print(hashlib.md5(contents).hexdigest())
    else:
        print("file not exists")

把上面的代码保存为文件test04.py，然后计算指定文件的MD5值，对该文件进行微波修改后再次计算其MD5值，可以发现，哪怕只是修改了一点点内容，MD5值的变化也是非常大的，如图2所示。

　　图2 计算文件的MD5值

备注：MD5算法属于单身变换算法，不存在反函数，暴力测试几乎成为唯一可能的MD5破解方法。

4、非对称密钥密码算法RSA

RSA是一种典型的非对称密钥密码体制，从加密密钥和解密密钥中的任何一个推导出另一个在计算上是不可行的。RSA的安全性建立在“大数分解和素性检测”这一著名数论难题的基础上。公钥可以完全公开，不需要进行保密，但必须提供完整性检测机制以保证不受篡改；私钥由用户自己保存。通信双方无须实现交换密钥就可以进行保密通信。

使用rsa模块来实现消息加密和解密。

#! /usr/bin/env python3
# -*- coding:utf-8 -*-

# Author   : MaYi
# Blog     : http://www.cnblogs.com/mayi0312/
# Date     : 2020-04-16
# Name     : test01
# Software : PyCharm
# Note     : 非对称密钥密码算法RSA
import rsa


# 入口函数
if __name__ == '__main__':
    # 生成随机密钥
    key = rsa.newkeys(3000)
    # 私钥
    private_key = key[1]
    # 公钥
    public_key = key[0]

    message = "中国广东省深圳市.Now is better than never."
    print("明文:", message)
    message = message.encode()

    crypted_message = rsa.encrypt(message, public_key)
    print("密文:\n", crypted_message)

    message = rsa.decrypt(crypted_message, private_key)
    message = message.decode()
    print("明文:", message)

程序运行结果：

明文: 中国广东省深圳市.Now is better than never.
密文:
 b'\t\xe71\xe9\xc5<\x0b\t \xec~\xa1\x88\xa2\xc0}\xbb#\xbe\x11\xb0eq~46\x80\xdf\x1c9\xabGQp\xbc\x9b\xdd\xb7f\x96\x1d\x0e\xc4\x07;]\x8d:\xb8\xd7\xb7\x96\x9d\x1ce\xb4\xc8O\xb3c\x08U\xac\xbf\xe8\xb4\x1e#8#\xc7\xbf\xc9\x9eTz\xdd\x00X(>\xc8\\\xe5\xb2~\xbc\xcd5\xab\xea\xf4\xaf\xdc\xd3\x9a\x12\xe9]\x8b\xd9\xb23\xd0C\xeb\xab\'M\x14\xe2@\'\x8e\xf0;\xfe\x18{{\xd9\xe8\xd4rf\xed\xde\x97\x81\x90\xdfh\xcf!W"\x0fk\x93\x9d\xa7\xce\xb5?\x98\xb4\xabG\xb1l=\x17}\xc4z\xad\xa6#\x8fG\xcf\xafC\xa2\xa8*q7\xd7J^\xa9\xa21tw\x1a\xd8\x80gjK\xc7Z\xf0"~M\xb6\x82\x03\xfe!\x8f\x80F\x1eJ\x84\x97\xe7\x01T\xcc\x93=\x17mb\x99\x84B\xb4z\xe33\xe7dIgG\xdd\xd2\xf9\xb9\x10\xc2\x1dM\xfc\xfe\xa2xC\x83\x93\xf5\xfbV\x16\x0f.\xd5\xa3/\xf4A\x12\xba2\x80\xcd\x1d\xe7\xa8\xe7n\xdf\xacXo\x92q\x83\x13l\x06\xb9\xb1\xf2\x80UL\x8b\xc0g`/\xe1\xb1\x80\x19Ca\x1b\xab-\x018:1\x7f\xc0\xd1\xfb\xe5\x9f\xf0\x1b;\xbc\xa9\tq\xea\xd2\xc0H\x91\xe8\x17\xa8\xc6\x9a\x87t\x85<v\xf9\xeb\xe8\xadK\x1d\x94P`QJ]\xb8\xb82\xb3\x9cm\x18\x92 \xaeT\x03\xadO\xf4\xcek\x9f\x90T,Arb,"j\x92\x02\x17i\xfdkU\xe0\xe0\x97\xab\x1d\xf1f\xda\x9e\x90'
明文: 中国广东省深圳市.Now is better than never.

栏目列表