阅读目录
前言
加密算法分类
python加密库
des加密
aes加密
rsa加密
前言
据记载，公元前400年，古希腊人发明了置换密码。1881年世界上的第一个电话保密专利出现。在第二次世界大战期间，德国军方启用“恩尼格玛”密码机，密码学在战争中起着非常重要的作用。
随着信息化和数字化社会的发展，人们对信息安全和保密的重要性认识不断提高，于是在1997年，美国国家标准局公布实施了“美国数据加密标准（des）”，民间力量开始全面介入密码学的研究和应用中，采用的加密算法有des、rsa、sha等。
随着对加密强度需求的不断提高，近期又出现了aes、ecc等。
使用密码学可以达到以下目的：
保密性：防止用户的标识或数据被读取。
数据完整性：防止数据被更改。
身份验证：确保数据发自特定的一方。
加密算法分类
对称加密算法：
对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥发送方和接收方需要持有同一把密钥，发送消息和接收消息均使用该密钥。
相对于非对称加密，对称加密具有更高的加解密速度，但双方都需要事先知道密钥，密钥在传输过程中可能会被窃取，因此安全性没有非对称加密高。
常见的对称加密算法：des，aes，3des等等
非对称加密算法：
文件加密需要公开密钥（publickey）和私有密钥（privatekey）。
接收方在发送消息前需要事先生成公钥和私钥，然后将公钥发送给发送方。发送放收到公钥后，将待发送数据用公钥加密，发送给接收方。接收到收到数据后，用私钥解密。
在这个过程中，公钥负责加密，私钥负责解密，数据在传输过程中即使被截获，攻击者由于没有私钥，因此也无法破解。
非对称加密算法的加解密速度低于对称加密算法，但是安全性更高。
非对称加密算法：rsa、dsa、ecc等算法
消息摘要算法：
消息摘要算法可以验证信息是否被篡改。
在数据发送前，首先使用消息摘要算法生成该数据的签名，然后签名和数据一同发送给接收者。
接收者收到数据后，对收到的数据采用消息摘要算法获得签名，最后比较签名是否一致，以此来判断数据在传输过程中是否发生修改。
python加密库
pycrypto是 python 中密码学方面最有名的第三方软件包。可惜的是，它的开发工作于2012年就已停止。
其他人还在继续发布最新版本的 pycrypto，如果你不介意使用第三方的二进制包，仍可以取得python 3.5 的相应版本。
比如，可以在 github 上找到了对应python3.5的pycrypto 二进制包。
幸运的是，有一个该项目的分支pycrytodome 取代了 pycrypto 。为了在 linux 上安装它，
你可以使用以下pip 命令：
pip3 install -i https://pypi.douban.com/simple pycryptodome
在windows 系统上安装则稍有不同：
pip3 install -i https://pypi.douban.com/simple pycryptodomex
des加密
全称为data encryptionstandard，即数据加密标准，是一种使用密钥加密的块算法
入口参数有三个：key、data、mode
key为7个字节共56位，是des算法的工作密钥；
data为8个字节64位，是要被加密或被解密的数据；
mode为des的工作方式,有两种:加密或解密
3des（即triple des）是des向aes过渡的加密算法，
使用两个密钥，执行三次des算法，
加密的过程是加密-解密-加密
解密的过程是解密-加密-解密
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
from crypto.cipher import des
key = b'abcdefgh' # 密钥 8位或16位,必须为bytes
def pad(text):
"""
# 加密函数，如果text不是8的倍数【加密文本text必须为8的倍数！】，那就补足为8的倍数
:param text:
:return:
"""
while len(text) % 8 != 0:
text += ' '
return text
des = des.new(key, des.mode_ecb) # 创建一个des实例
text = 'python rocks!'
padded_text = pad(text)
encrypted_text = des.encrypt(padded_text.encode('utf-8')) # 加密
print(encrypted_text)
# rstrip(' ')返回从字符串末尾删除所有字符串的字符串(默认空白字符)的副本
plain_text = des.decrypt(encrypted_text).decode().rstrip(' ') # 解密
print(plain_text)
#
|
aes加密
高级加密标准（英语：advanced encryptionstandard，缩写：aes），这个标准用来替代原先的des
aes的区块长度固定为128 比特，密钥长度则可以是128，192或256比特（16、24和32字节）
大致步骤如下：
1、密钥扩展（keyexpansion），
2、初始轮（initial round），
3、重复轮（rounds），每一轮又包括：subbytes、shiftrows、mixcolumns、addroundkey，
4、最终轮（final round），最终轮没有mixcolumns。
普通方式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
from cryptodome.cipher import aes
from binascii import b2a_hex, a2b_hex
#秘钥,此处需要将字符串转为字节
key = 'abcdefgh'
#加密内容需要长达16位字符，所以进行空格拼接
def pad(text):
while len(text) % 16 != 0:
text += ' '
return text
#加密秘钥需要长达16位字符，所以进行空格拼接
def pad_key(key):
while len(key) % 16 != 0:
key += ' '
return key
#进行加密算法，模式ecb模式，把叠加完16位的秘钥传进来
aes = aes.new(pad_key(key).encode(), aes.mode_ecb)
#加密内容,此处需要将字符串转为字节
text = 'hello'
#进行内容拼接16位字符后传入加密类中，结果为字节类型
encrypted_text = aes.encrypt(pad(text).encode())
encrypted_text_hex = b2a_hex(encrypted_text)
print(encrypted_text_hex)
# #此处是为了验证是否能将字节转为字符串后，进行解密成功
# #实际上a 就是 encrypted_text ，也就是加密后的内容
# #用aes对象进行解密，将字节类型转为str类型，错误编码忽略不计
de = str(aes.decrypt(a2b_hex(encrypted_text_hex)), encoding='utf-8',errors="ignore")
# #获取str从0开始到文本内容的字符串长度。
print(de[:len(text)])
|
面向对象方式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
from cryptodome.cipher import aes
from binascii import b2a_hex, a2b_hex
aes_length = 16
class prpcrypt():
def __init__(self, key):
self.key = key
self.mode = aes.mode_ecb
self.cryptor = aes.new(self.pad_key(self.key).encode(), self.mode)
# 加密函数，如果text不是16的倍数【加密文本text必须为16的倍数！】，那就补足为16的倍数
# 加密内容需要长达16位字符，所以进行空格拼接
def pad(self,text):
while len(text) % aes_length != 0:
text += ' '
return text
# 加密密钥需要长达16位字符，所以进行空格拼接
def pad_key(self,key):
while len(key) % aes_length != 0:
key += ' '
return key
def encrypt(self, text):
# 这里密钥key 长度必须为16（aes-128）、24（aes-192）、或32（aes-256）bytes 长度.目前aes-128足够用
# 加密的字符需要转换为bytes
# print(self.pad(text))
self.ciphertext = self.cryptor.encrypt(self.pad(text).encode())
# 因为aes加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
# 所以这里统一把加密后的字符串转化为16进制字符串
return b2a_hex(self.ciphertext)
# 解密后，去掉补足的空格用strip() 去掉
def decrypt(self, text):
plain_text = self.cryptor.decrypt(a2b_hex(text)).decode()
return plain_text.rstrip(' ')
if __name__ == '__main__':
pc = prpcrypt('abcdef') # 初始化密钥
e = pc.encrypt("0123456789abcdef")
d = pc.decrypt(e)
print(e, d)
e = pc.encrypt("00000000000000000000000000")
d = pc.decrypt(e)
print(e, d)
|
rsa加密
公钥加密算法，一种非对称密码算法
公钥加密，私钥解密
3个参数：
rsa_n， rsa_e，message
rsa_n, rsa_e 用于生成公钥
message： 需要加密的消息
安装 pip install rsa
使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import rsa
from binascii import b2a_hex, a2b_hex
class rsacrypt():
def __init__(self, pubkey, prikey):
self.pubkey = pubkey
self.prikey = prikey
def encrypt(self, text):
self.ciphertext = rsa.encrypt(text.encode(), self.pubkey)
# 因为rsa加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
# 所以这里统一把加密后的字符串转化为16进制字符串
return b2a_hex(self.ciphertext)
def decrypt(self, text):
decrypt_text = rsa.decrypt(a2b_hex(text), prikey)
return decrypt_text
if __name__ == '__main__':
pubkey, prikey = rsa.newkeys(256)
rs_obj = rsacrypt(pubkey,prikey)
text='hello'
ency_text = rs_obj.encrypt(text)
print(ency_text)
print(rs_obj.decrypt(ency_text))
"""
b'7cb319c67853067abcd16aad25b3a8658e521f83b1e6a6cf0c4c2e9303ad3e14'
b'hello'
"""
|
python 加密解密 使用base64或pycrypto模块
1. 使用base64
|
1
2
3
|
s1 = base64.encodestring('hello world')
s2 = base64.decodestring(s1)
print s1, s2
|
结果
agvsbg8gd29ybgq=
hello world
base64编码，64指a-z、a-z、0-9、+和/这64个字符，还有“=”号不属于编码字符，而是填充字符。为什么发明这么个编码呢，这个编码的原理很简单，“破解”也很容易，原因是电子邮件刚出来的时候，只传递英文字符，这没有问题，但是后来，中国人，日本人都要发email，这样问题就来了，因为这些字符有可能会被邮件服务器或者网关当成命令处理，故必须得有一种编码来对邮件进行加密，但是加密的目的是为了能够使得一些原始的服务器不出问题（现在服务器早已经能处理这些乱七八糟得情况了，不过因为已经形成了一套规范，所以邮件还是得经过base64编码才能传递）。
优点：方法简单
缺点：不保险，别人拿到密文可以自己解密出明文
编码原理：将3个字节转换成4个字节((3 x 8)=24=(4x6))，先读入3个字节，每读一个字节，左移8位，再右移四次，每次6位，这样就有4个字节了。
解码原理：将4个字节转换成3个字节，先读入4个6位(用或运算)，每次左移6位，再右移3次，每次8位，这样就还原了。
2. 使用pycrypto模块
|
1
2
3
4
5
6
7
8
9
|
>>> from crypto.cipher import aes
>>> obj = aes.new('this is a key123', aes.mode_cbc, 'this is an iv456')
>>> message = "the answer is no"
>>> ciphertext = obj.encrypt(message)
>>> ciphertext
'\xd6\x83\x8dd!vt\x92\xaa`a\x05\xe0\x9b\x8b\xf1'
>>> obj2 = aes.new('this is a key123', aes.mode_cbc, 'this is an iv456')
>>> obj2.decrypt(ciphertext)
'the answer is no'
|
高级加密标准（advanced encryption standard，aes），是美国联邦*采用的一种区块加密标准。这个标准用来替代原先的des，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（nist）于2001年11月26日发布于fips pub 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。
aes只是个基本算法，实现aes有若干模式。其中的cbc模式因为其安全性而被tls（就是https的加密标准）和ipsec（win采用的）作为技术标准。简单地说，cbc使用密码和salt（起扰乱作用）按固定算法（md5）产生key和iv。然后用key和iv（初始向量，加密第一块明文）加密（明文）和解密（密文）。
再来一例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
#coding: utf8
import sys
from crypto.cipher import aes
from binascii import b2a_hex, a2b_hex
class prpcrypt():
def __init__(self, key):
self.key = key
self.mode = aes.mode_cbc
#加密函数，如果text不是16的倍数【加密文本text必须为16的倍数！】，那就补足为16的倍数
def encrypt(self, text):
cryptor = aes.new(self.key, self.mode, self.key)
#这里密钥key 长度必须为16（aes-128）、24（aes-192）、或32（aes-256）bytes 长度.目前aes-128足够用
length = 16
count = len(text)
add = length - (count % length)
text = text + ('\0' * add)
self.ciphertext = cryptor.encrypt(text)
#因为aes加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
#所以这里统一把加密后的字符串转化为16进制字符串
return b2a_hex(self.ciphertext)
#解密后，去掉补足的空格用strip() 去掉
def decrypt(self, text):
cryptor = aes.new(self.key, self.mode, self.key)
plain_text = cryptor.decrypt(a2b_hex(text))
return plain_text.rstrip('\0')
if __name__ == '__main__':
pc = prpcrypt('keyskeyskeyskeys') #初始化密钥
e = pc.encrypt("00000")
d = pc.decrypt(e)
print e, d
e = pc.encrypt("00000000000000000000000000")
d = pc.decrypt(e)
print e, d
|
运行结果
a9755fd70d8d6db65a6fac12d4797dde 00000
2c1969f213c703ebedc36f9e7e5a2b88922ac938c983201c200da51073d00b2c 00000000000000000000000000
这篇文章就介绍到这了需要朋友可以参考一下。
原文链接：http://www.cnblogs.com/xiao-apple36/p/8744408.html