python模块之hashlib

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

举个例子，你写了一篇文章，内容是一个字符串'how to use python hashlib - by Michael'，并附上这篇文章的摘要是'2d73d4f15c0db7f5ecb321b6a65e5d6d'。如果有人篡改了你的文章，并发表为'how to use python hashlib - by Bob'，你可以一下子指出Bob篡改了你的文章，因为根据'how to use python hashlib - by Bob'计算出的摘要不同于原始文章的摘要。

可见，摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

1. import hashlib
3. md5 = hashlib.md5()
4. md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
5. print(md5.hexdigest())

计算结果如下：

d26a53750bc40b38b65a520292f69306

如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：

1. import hashlib
3. md5 = hashlib.md5()
4. md5.update('how to use md5 in '.encode('utf-8'))
5. md5.update('python hashlib?'.encode('utf-8'))
6. print(md5.hexdigest())

试试改动一个字母，看看计算的结果是否完全不同。

MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。

另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似

1. import hashlib
3. sha1 = hashlib.sha1()
4. sha1.update('how to use sha1 in '.encode('utf-8'))
5. sha1.update('python hashlib?'.encode('utf-8'))
6. print(sha1.hexdigest())

SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。

比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法不仅越慢，而且摘要长度更长。

有没有可能两个不同的数据通过某个摘要算法得到了相同的摘要？完全有可能，因为任何摘要算法都是把无限多的数据集合映射到一个有限的集合中。这种情况称为碰撞，比如Bob试图根据你的摘要反推出一篇文章'how to learn hashlib in python - by Bob'，并且这篇文章的摘要恰好和你的文章完全一致，这种情况也并非不可能出现，但是非常非常困难。

摘要算法应用

摘要算法能应用到什么地方？举个常用例子：

任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。

正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：

当用户登录时，首先计算用户输入的明文口令的MD5，然后和数据库存储的MD5对比，如果一致，说明口令输入正确，如果不一致，口令肯定错误。

练习

根据用户输入的口令，计算出存储在数据库中的MD5口令：

1. def calc_md5(password):
2. pass

存储MD5的好处是即使运维人员能访问数据库，也无法获知用户的明文口令。

设计一个验证用户登录的函数，根据用户输入的口令是否正确，返回True或False：

1. # -*- coding: utf-8 -*-
2. db = {
3. 'michael': 'e10adc3949ba59abbe56e057f20f883e',
4. 'bob': '878ef96e86145580c38c87f0410ad153',
5. 'alice': '99b1c2188db85afee403b1536010c2c9'
6. }

1. # 测试:
2. assert login('michael', '123456')
3. assert login('bob', 'abc999')
4. assert login('alice', 'alice2008')
5. assert not login('michael', '1234567')
6. assert not login('bob', '123456')
7. assert not login('alice', 'Alice2008')
8. print('ok')

采用MD5存储口令是否就一定安全呢？也不一定。假设你是一个黑客，已经拿到了存储MD5口令的数据库，如何通过MD5反推用户的明文口令呢？暴力破解费事费力，真正的黑客不会这么干。

考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：

1. 'e10adc3949ba59abbe56e057f20f883e': '123456'
2. '21218cca77804d2ba1922c33e0151105': '888888'
3. '5f4dcc3b5aa765d61d8327deb882cf99': 'password'

这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。

对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？

由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：

1. def calc_md5(password):
2. return get_md5(password + 'the-Salt')

经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。

但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？

如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。

练习

根据用户输入的登录名和口令模拟用户注册，计算更安全的MD5：

1. db = {}
3. def register(username, password):
4. db[username] = get_md5(password + username + 'the-Salt')

然后，根据修改后的MD5算法实现用户登录的验证：

1. # -*- coding: utf-8 -*-
2. import hashlib, random
4. def get_md5(s):
5. return hashlib.md5(s.encode('utf-8')).hexdigest()
7. class User(object):
8. def __init__(self, username, password):
9. self.username = username
10. self.salt = ''.join([chr(random.randint(48, 122)) for i in range(20)])
11. self.password = get_md5(password + self.salt)
12. db = {
13. 'michael': User('michael', '123456'),
14. 'bob': User('bob', 'abc999'),
15. 'alice': User('alice', 'alice2008')
16. }
17. # 测试:
18. assert login('michael', '123456')
19. assert login('bob', 'abc999')
20. assert login('alice', 'alice2008')
21. assert not login('michael', '1234567')
22. assert not login('bob', '123456')
23. assert not login('alice', 'Alice2008')
24. print('ok')

小结

摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

用于加密相关的操作，代替md5模块和sha模块，主要提供SHA1，SHA224，SHA256，SHA384，SHA512，MD5算法

1. >>> import hashlib
2. ####### md5 #######
3. >>> hash.update(bytes('admin',encoding='utf-8'))
4. >>> print(hash.hexdigest())
5. 21232f297a57a5a743894a0e4a801fc3
6. >>> print(hash.digest())
7. b'!#/)zW\xa5\xa7C\x89J\x0eJ\x80\x1f\xc3'
8. ####### sha1 #######
9. >>> hash = hashlib.sha1()
10. >>> hash.update(bytes('admin',encoding='utf-8'))
11. >>> print(hash.hexdigest())
12. d033e22ae348aeb5660fc2140aec35850c4da997
13. >>> print(hash.digest())
14. b'\xd03\xe2*\xe3H\xae\xb5f\x0f\xc2\x14\n\xec5\x85\x0cM\xa9\x97'
15. ####### sha256 #######
16. >>> hash = hashlib.sha256()
17. >>> hash.update(bytes('admin',encoding='utf-8'))
18. >>> print(hash.hexdigest())
19. 8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
20. >>> print(hash.digest())
21. b'\x8civ\xe5\xb5A\x04\x15\xbd\xe9\x08\xbdM\xee\x15\xdf\xb1g\xa9\xc8s\xfcK\xb8\xa8\x1fo*\xb4H\xa9\x18'
22. ####### sha384 #######
23. >>> hash = hashlib.sha384()
24. >>> hash.update(bytes('admin',encoding='utf-8'))
25. >>> print(hash.hexdigest())
26. 9ca694a90285c034432c9550421b7b9dbd5c0f4b6673f05f6dbce58052ba20e4248041956ee8c9a2
27. ec9f10290cdc0782
28. >>> print(hash.digest())
29. b'\x9c\xa6\x94\xa9\x02\x85\xc04C,\x95PB\x1b{\x9d\xbd\\\x0fKfs\xf0_m\xbc\xe5\x80R\xba \xe4$\x80A\x95n\xe8\xc9\xa2\xec\x9f\x10)\x0c\xdc\x07\x82'
30. ####### sha512 #######
31. >>> hash = hashlib.sha512()
32. >>> hash.update(bytes('admin',encoding='utf-8'))
33. >>> print(hash.hexdigest())
34. c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec
35. >>> print(hash.digest())
36. b'\xc7\xadD\xcb\xadv*]\xa0\xa4R\xf9\xe8T\xfd\xc1\xe0\xe7\xa5*8\x01_#\xf3\xea\xb1\xd8\x0b\x93\x1d\xd4rcM\xfa\xc7\x1c\xd3N\xbc5\xd1j\xb7\xfb\x8a\x90\xc8\x1f\x97Q\x13\xd6\xc7S\x8d\xc6\x9d\xd8\xde\x90w\xec'

以上加密算法虽然非常厉害,但存在缺陷,即:通过密码库可以反解.所以,有必要对加密算法中添加自定义key再来做加密.

1. >>> import hashlib
2. >>> hash = hashlib.md5(bytes('89oaFs09f',encoding='utf-8'))
3. >>> hash.update(bytes('admin',encoding='utf-8'))
4. >>> print(hash.hexdigest())
5. 0f102151d38af213af2d4f73d459d69c
6. >>> print(hash.digest())
7. b'\x0f\x10!Q\xd3\x8a\xf2\x13\xaf-Os\xd4Y\xd6\x9c'

python内置还有一个hmac模块，它内部对我们创建key和内容进行进一步的处理，然后再加密

1. >>> import hmac
2. >>> h = hmac.new(bytes('898oaFs09f',encoding='utf-8'))
3. >>> h.update(bytes('admin',encoding='utf-8'))
4. >>> print(h.hexdigest())
5. 17186c513df61e8b3fb4a134f474b130
6. >>> print(h.digest())
7. b'\x17\x18lQ=\xf6\x1e\x8b?\xb4\xa14\xf4t\xb10'