1
# Python: SHA-256
2
import hashlib
3

4
digest = hashlib.sha256(b"Hello, World!").hexdigest()
5
# 输出: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
6

7
# SHA-512
8
digest512 = hashlib.sha512(b"Hello, World!").hexdigest()

1
// Java: SHA-256
2
MessageDigest digest = MessageDigest.getInstance("SHA-256");
3
byte[] hash = digest.digest("Hello, World!".getBytes(StandardCharsets.UTF_8));

1
// Go: SHA-256 流式计算（处理大文件）
2
package main
3

4
import (
5
    "crypto/sha256"
6
    "fmt"
7
)
8

9
func main() {
10
    h := sha256.New()
11
    h.Write([]byte("Hello, "))
12
    h.Write([]byte("World!"))
13
    fmt.Printf("%x\n", h.Sum(nil))
14
}

1
# Python: SHA-3
2
import hashlib
3

4
digest = hashlib.sha3_256(b"Hello, World!").hexdigest()
5

6
# SHAKE128（可扩展输出函数）
7
shake = hashlib.shake_128(b"Hello, World!")
8
output = shake.hexdigest(32)  # 32 字节输出

1
HMAC(K, m) = H((K' ⊕ opad) || H((K' ⊕ ipad) || m))
2

3
其中：
4
- K' = 如果 K > block_size，则 K' = H(K)；否则 K' = K 填充到 block_size
5
- ipad = 0x36 重复 block_size 次
6
- opad = 0x5C 重复 block_size 次

1
# Python: HMAC-SHA256
2
import hmac
3
import hashlib
4

5
key = b"secret-key"
6
message = b"Hello, World!"
7

8
# 生成 HMAC
9
mac = hmac.new(key, message, hashlib.sha256).hexdigest()
10

11
# 验证 HMAC（常数时间比较）
12
received_mac = "..."
13
hmac.compare_digest(mac, received_mac)  # 安全
14
# mac == received_mac  # 不安全（时序攻击）

1
// Go: HMAC-SHA256
2
package main
3

4
import (
5
    "crypto/hmac"
6
    "crypto/sha256"
7
    "encoding/hex"
8
    "fmt"
9
)
10

11
func main() {
12
    key := []byte("secret-key")
13
    message := []byte("Hello, World!")
14

15
    mac := hmac.New(sha256.New, key)
16
    mac.Write(message)
17
    fmt.Println(hex.EncodeToString(mac.Sum(nil)))
18
}

1
JWT = Base64(header) + "." + Base64(payload) + "." + Base64(HMAC-SHA256(key, header + "." + payload))

1
# Python: JWT HMAC 签名验证
2
import hmac, hashlib, base64
3

4
def verify_jwt_hs256(token: str, secret: str) -> bool:
5
    parts = token.split(".")
6
    if len(parts) != 3:
7
        return False
8
    signing_input = f"{parts[0]}.{parts[1]}".encode()
9
    expected_sig = hmac.new(secret.encode(), signing_input, hashlib.sha256).digest()
10
    actual_sig = base64.urlsafe_b64decode(parts[2] + "==")
11
    return hmac.compare_digest(expected_sig, actual_sig)

1
# 演示：MD5 碰撞的严重性
2
import hashlib
3

4
# 两个不同的输入产生相同的 MD5（概念演示）
5
m1 = bytes.fromhex("d131dd02c5e6eec4693d9a0698aff95c...")
6
m2 = bytes.fromhex("d131dd02c5e6eec4693d9a0698aff95c...")
7

8
# m1 != m2，但 MD5(m1) == MD5(m2)
9
assert m1 != m2
10
assert hashlib.md5(m1).hexdigest() == hashlib.md5(m2).hexdigest()

1
已知：H(m) 和 len(m)
2
可以计算：H(m || padding || m')  而不需要知道 m！

1
# 长度扩展攻击演示（使用 hashpumpy 库）
2
# pip install hashpumpy
3
import hashpumpy, hashlib
4

5
# 场景：服务器使用 H(key || message) 验证消息
6
secret_key = b"my-secret-key"  # 攻击者不知道
7
original_message = b"data=value"
8

9
server_hash = hashlib.sha256(secret_key + original_message).hexdigest()
10
key_length = len(secret_key)
11

12
# 长度扩展攻击：追加 "&admin=true"
13
new_data, new_hash = hashpumpy.hashpump(
14
    server_hash,           # 原始哈希
15
    original_message,      # 原始消息
16
    b"&admin=true",        # 要追加的数据
17
    key_length             # 密钥长度
18
)
19
# new_hash == H(key || original_message || padding || "&admin=true")
20
# 服务器会验证通过！

1
# Python: Argon2 密码哈希（推荐）
2
from argon2 import PasswordHasher
3

4
ph = PasswordHasher(
5
    time_cost=3, memory_cost=65536, parallelism=4,
6
    hash_len=32, salt_len=16
7
)
8

9
hash = ph.hash("my-password")
10
# 输出: $argon2id$v=19$m=65536,t=3,p=4$c2FsdHNhbHQ$hash...
11

12
try:
13
    ph.verify(hash, "my-password")  # True
14
except Exception:
15
    print("Password incorrect")
16

17
# 检查是否需要重新哈希（参数变更后）
18
if ph.check_needs_rehash(hash):
19
    new_hash = ph.hash("my-password")

1
// Go: bcrypt 密码哈希
2
package main
3

4
import (
5
    "fmt"
6
    "golang.org/x/crypto/bcrypt"
7
)
8

9
func main() {
10
    password := "my-password"
11
    hash, _ := bcrypt.GenerateFromPassword([]byte(password), 12)
12
    fmt.Println(string(hash))
13
    err := bcrypt.CompareHashAndPassword(hash, []byte(password))
14
    fmt.Println(err == nil) // true
15
}

1
# 简化的去重存储系统
2
import hashlib, os
3

4
class DedupStorage:
5
    def __init__(self, storage_dir):
6
        self.storage_dir = storage_dir
7
        self.hash_to_ref = {}
8

9
    def store(self, filepath: str) -> str:
10
        with open(filepath, "rb") as f:
11
            content = f.read()
12
        content_hash = hashlib.sha256(content).hexdigest()
13
        if content_hash not in self.hash_to_ref:
14
            path = os.path.join(self.storage_dir, content_hash)
15
            with open(path, "wb") as f:
16
                f.write(content)
17
            self.hash_to_ref[content_hash] = 1
18
        else:
19
            self.hash_to_ref[content_hash] += 1
20
        return content_hash

1
import hashlib
2

3
message = b"Hello, Cryptography!"
4

5
# SHA-256
6
sha256 = hashlib.sha256(message).hexdigest()
7
print(f"SHA-256:  {sha256}")
8

9
# SHA-512
10
sha512 = hashlib.sha512(message).hexdigest()
11
print(f"SHA-512:  {sha512}")
12

13
# SHA3-256
14
sha3_256 = hashlib.sha3_256(message).hexdigest()
15
print(f"SHA3-256: {sha3_256}")
16

17
# 雪崩效应：仅改一个字符
18
message2 = b"Hello, Cryptography?"
19
sha256_2 = hashlib.sha256(message2).hexdigest()
20
h1, h2 = int(sha256, 16), int(sha256_2, 16)
21
diff_bits = bin(h1 ^ h2).count('1')
22
print(f"\n--- 雪崩效应 ---")
23
print(f"SHA-256('...y!'): {sha256}")
24
print(f"SHA-256('...?'):  {sha256_2}")
25
print(f"不同位数: {diff_bits}/256 ({diff_bits/256*100:.1f}%)")

1
SHA-256:  29aff889935f5a275ec562ef46c138e917a270aab79b4d5577ee8ea5af308f73
2
SHA-512:  c3528d42b472281ab0ee4ad4410dbe351eefda688dff8550c9dfcc7b29a2bc1b70c1fcfa9f3d1f552e928f7a97b02b2b50dd675b1e17019b383c0162655c6918
3
SHA3-256: f2d6e73d4c107550fae2b9a08e2f85c820e5811c0ea37cc9a412df33b195f904
4

5
--- 雪崩效应 ---
6
SHA-256('...y!'): 29aff889935f5a275ec562ef46c138e917a270aab79b4d5577ee8ea5af308f73
7
SHA-256('...?'):  1084ad7edc449759443809509c3e4a87f64c4ea206d5900e997859877e26814e
8
不同位数: 151/256 (59.0%)

1
import hashlib
2
import tempfile
3
import os
4

5
def file_hash(path, algo="sha256"):
6
    """计算文件的哈希值（流式读取，支持大文件）"""
7
    h = hashlib.new(algo)
8
    with open(path, "rb") as f:
9
        while chunk := f.read(8192):
10
            h.update(chunk)
11
    return h.hexdigest()
12

13
# 创建临时文件
14
tmpdir = tempfile.mkdtemp()
15
filepath = os.path.join(tmpdir, "important_data.txt")
16

17
original_content = (
18
    b"Critical system configuration:\n"
19
    b"server=prod-db-01\n"
20
    b"port=5432\n"
21
    b"ssl=enabled\n"
22
)
23
with open(filepath, "wb") as f:
24
    f.write(original_content)
25

26
# 计算原始哈希
27
original_hash = file_hash(filepath)
28
print(f"原始文件 SHA-256: {original_hash}")
29

30
# 完整性校验——通过
31
current_hash = file_hash(filepath)
32
print(f"完整性校验: {' 通过' if current_hash == original_hash else ' 失败'}")
33

34
# 模拟篡改
35
print(f"\n--- 模拟篡改 ---")
36
tampered_content = (
37
    b"Critical system configuration:\n"
38
    b"server=attacker-evil\n"
39
    b"port=5432\n"
40
    b"ssl=disabled\n"
41
)
42
with open(filepath, "wb") as f:
43
    f.write(tampered_content)
44

45
tampered_hash = file_hash(filepath)
46
print(f"篡改后 SHA-256: {tampered_hash}")
47
print(f"完整性校验: {' 通过' if tampered_hash == original_hash else ' 失败（文件已被篡改！）'}")
48

49
# 同一文件多种算法对比
50
print(f"\n--- 同一文件多种算法 ---")
51
with open(filepath, "wb") as f:
52
    f.write(original_content)
53

54
for algo in ["md5", "sha1", "sha256", "sha512"]:
55
    print(f"{algo.upper():8s}: {file_hash(filepath, algo)}")
56

57
os.remove(filepath)
58
os.rmdir(tmpdir)

1
原始文件 SHA-256: cb470cc7dff2ff61629f30749e41a73c7d16af67603783578f7050a3940f6025
2
完整性校验:  通过
3

4
--- 模拟篡改 ---
5
篡改后 SHA-256: 5b2168683c5957063d4a0539d57f68f81217fbe9d401969c204521b2e386a580
6
完整性校验:  失败（文件已被篡改！）
7

8
--- 同一文件多种算法 ---
9
MD5     : 05bf53ced9b5a06bc9fdc8abfc5d8dac
10
SHA1    : 14382d3c827a478f38d0626476f37e64666c0c74
11
SHA256  : cb470cc7dff2ff61629f30749e41a73c7d16af67603783578f7050a3940f6025
12
SHA512  : ed4c0ca7f34efbe36364f67275537a6b29297dd048b95cd2d8c928056a02e20ae08455da3e95a90c3f58bf645575f20a54755f2476714b7d5222d1ffb6ecd282

1
import hmac
2
import hashlib
3

4
secret_key = b"my-secret-key-2024"
5
message = b"Transfer $1000 to account 12345"
6

7
# 生成 HMAC-SHA256 签名
8
mac_value = hmac.new(secret_key, message, hashlib.sha256).hexdigest()
9
print(f"密钥:         {secret_key.decode()}")
10
print(f"消息:         {message.decode()}")
11
print(f"HMAC-SHA256:  {mac_value}")
12

13
# 正确密钥验证
14
is_valid = hmac.compare_digest(
15
    hmac.new(secret_key, message, hashlib.sha256).hexdigest(),
16
    mac_value
17
)
18
print(f"\n--- 验证（正确密钥） ---")
19
print(f"验证结果: {' 签名有效' if is_valid else ' 签名无效'}")
20

21
# 错误密钥验证
22
wrong_key = b"wrong-secret-key"
23
is_valid_wrong = hmac.compare_digest(
24
    hmac.new(wrong_key, message, hashlib.sha256).hexdigest(),
25
    mac_value
26
)
27
print(f"\n--- 验证（错误密钥） ---")
28
print(f"错误密钥: {wrong_key.decode()}")
29
print(f"验证结果: {' 签名有效' if is_valid_wrong else ' 签名无效（密钥不匹配）'}")
30

31
# 篡改消息验证
32
tampered_message = b"Transfer $9000 to account 12345"
33
is_valid_tampered = hmac.compare_digest(
34
    hmac.new(secret_key, tampered_message, hashlib.sha256).hexdigest(),
35
    mac_value
36
)
37
print(f"\n--- 验证（篡改消息） ---")
38
print(f"篡改消息: {tampered_message.decode()}")
39
print(f"验证结果: {' 签名有效' if is_valid_tampered else ' 签名无效（消息被篡改）'}")
40

41
# 不同算法的 HMAC
42
print(f"\n--- 不同算法的 HMAC ---")
43
for algo in ["md5", "sha1", "sha256", "sha512"]:
44
    mac = hmac.new(secret_key, message, algo).hexdigest()
45
    print(f"HMAC-{algo.upper():6s}: {mac}")

1
密钥:         my-secret-key-2024
2
消息:         Transfer $1000 to account 12345
3
HMAC-SHA256:  b6c909a9cd218c40a881e7de606f9b633a709befc225eb1210b380e39d35c753
4

5
--- 验证（正确密钥） ---
6
验证结果:  签名有效
7

8
--- 验证（错误密钥） ---
9
错误密钥: wrong-secret-key
10
验证结果:  签名无效（密钥不匹配）
11

12
--- 验证（篡改消息） ---
13
篡改消息: Transfer $9000 to account 12345
14
验证结果:  签名无效（消息被篡改）
15

16
--- 不同算法的 HMAC ---
17
HMAC-MD5   : d1e2ea83d3cb132d0227cdd3468a6adf
18
HMAC-SHA1  : 4d6ea70b9e3b1cf7e704db516270d444430a4052
19
HMAC-SHA256: b6c909a9cd218c40a881e7de606f9b633a709befc225eb1210b380e39d35c753
20
HMAC-SHA512: 8fbfffc9c87a0554ecc9ced3f7170cbba63d1dc1142ac4362c538a13d64d8dc3e22443bbd0ff1843fa3c05dc10e0e23052ebc502608cfc08477ac092cfaa2aee

1
import hashlib
2
import struct
3

4
# SHA-256 轮常数
5
K = [
6
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
7
    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
8
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
9
    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
10
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
11
    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
12
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
13
    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
14
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
15
    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
16
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
17
    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
18
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
19
    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
20
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
21
    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
22
]
23

24
def rotr(x, n):
25
    return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF
26

27
def sha256_compress(state, block):
28
    """SHA-256 压缩函数：处理一个 512 位块"""
29
    W = list(struct.unpack('>16I', block))
30
    for i in range(16, 64):
31
        s0 = rotr(W[i-15], 7) ^ rotr(W[i-15], 18) ^ (W[i-15] >> 3)
32
        s1 = rotr(W[i-2], 17) ^ rotr(W[i-2], 19) ^ (W[i-2] >> 10)
33
        W.append((W[i-16] + s0 + W[i-7] + s1) & 0xFFFFFFFF)
34
    a, b, c, d, e, f, g, h = state
35
    for i in range(64):
36
        S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)
37
        ch = (e & f) ^ ((~e) & g)
38
        temp1 = (h + S1 + ch + K[i] + W[i]) & 0xFFFFFFFF
39
        S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)
40
        maj = (a & b) ^ (a & c) ^ (b & c)
41
        temp2 = (S0 + maj) & 0xFFFFFFFF
42
        h, g, f, e, d, c, b, a = g, f, e, (d+temp1)&0xFFFFFFFF, c, b, a, (temp1+temp2)&0xFFFFFFFF
43
    return tuple((s+v) & 0xFFFFFFFF for s, v in zip(state, (a,b,c,d,e,f,g,h)))
44

45
def sha256_padding(msg_length):
46
    """计算 SHA-256 的 Merkle-Damgård 填充"""
47
    padding = b'\x80'
48
    pad_len = (55 - msg_length % 64) % 64
49
    padding += b'\x00' * pad_len
50
    padding += struct.pack('>Q', msg_length * 8)
51
    return padding
52

53
def sha256_from_state(state, prior_length, append_data):
54
    """从已知内部状态继续哈希计算（长度扩展攻击的核心）"""
55
    total_length = prior_length + len(append_data)
56
    padded = append_data + sha256_padding(total_length)
57
    for i in range(0, len(padded), 64):
58
        block = padded[i:i+64]
59
        if len(block) == 64:
60
            state = sha256_compress(state, block)
61
    return struct.pack('>8I', *state).hex()
62

63
# ===== 攻击演示 =====
64
secret_key = b"secret-key-123"    # 攻击者不知道
65
original_message = b"data=hello"
66

67
# 服务器计算 H(key||msg)
68
server_hash = hashlib.sha256(secret_key + original_message).hexdigest()
69
print(f"[服务器端]")
70
print(f"密钥（攻击者未知）: {secret_key.decode()}")
71
print(f"原始消息:           {original_message.decode()}")
72
print(f"H(key||msg):        {server_hash}")
73

74
# 攻击者已知信息
75
print(f"\n[攻击者已知]")
76
print(f"原始消息:      {original_message.decode()}")
77
print(f"H(key||msg):   {server_hash}")
78
print(f"key 长度:      {len(secret_key)} 字节")
79

80
# 步骤 1：从哈希值恢复内部状态
81
recovered_state = struct.unpack('>8I', bytes.fromhex(server_hash))
82

83
# 步骤 2：计算原始消息的填充（glue padding）
84
original_full_length = len(secret_key) + len(original_message)
85
glue_padding = sha256_padding(original_full_length)
86
padded_length = original_full_length + len(glue_padding)
87

88
# 步骤 3：构造伪造消息
89
append_data = b"&admin=true"
90
forged_data = original_message + glue_padding + append_data
91

92
# 步骤 4：从恢复的状态计算伪造哈希
93
forged_hash = sha256_from_state(recovered_state, padded_length, append_data)
94

95
print(f"\n[攻击者构造]")
96
print(f"追加数据:   {append_data.decode()}")
97
print(f"伪造哈希:   {forged_hash}")
98

99
# 验证
100
verification_hash = hashlib.sha256(secret_key + forged_data).hexdigest()
101
print(f"\n[验证]")
102
print(f"服务器计算 H(key||forged_msg): {verification_hash}")
103
print(f"攻击者提供的哈希:              {forged_hash}")
104
print(f"是否匹配: {' 匹配！攻击成功！' if verification_hash == forged_hash else ' 不匹配'}")
105

106
# HMAC 不受此攻击影响
107
import hmac
108
hmac_original = hmac.new(secret_key, original_message, hashlib.sha256).hexdigest()
109
hmac_forged = hmac.new(secret_key, forged_data, hashlib.sha256).hexdigest()
110
print(f"\n[HMAC 对比]")
111
print(f"HMAC(key, original): {hmac_original}")
112
print(f"HMAC(key, forged):   {hmac_forged}")
113
print(f"两者相同: {'是（漏洞！）' if hmac_original == hmac_forged else '否（HMAC 安全）'}")

1
[服务器端]
2
密钥（攻击者未知）: secret-key-123
3
原始消息:           data=hello
4
H(key||msg):        4d554309dc24740b5d3e90c69180195d0c436943bc6f82ad819fa9b648d5be02
5

6
[攻击者已知]
7
原始消息:      data=hello
8
H(key||msg):   4d554309dc24740b5d3e90c69180195d0c436943bc6f82ad819fa9b648d5be02
9
key 长度:      14 字节
10

11
[攻击者构造]
12
追加数据:   &admin=true
13
伪造哈希:   7070b7b023e4cf47ea8efcbfcf0792f0a928c2a284f019de7e906bf6690dff45
14

15
[验证]
16
服务器计算 H(key||forged_msg): 7070b7b023e4cf47ea8efcbfcf0792f0a928c2a284f019de7e906bf6690dff45
17
攻击者提供的哈希:              7070b7b023e4cf47ea8efcbfcf0792f0a928c2a284f019de7e906bf6690dff45
18
是否匹配:  匹配！攻击成功！
19

20
[HMAC 对比]
21
HMAC(key, original): d51afc438daa955f2b3f0a267bf17a38f9a4caefdb80c051d95e06f4e2681afe
22
HMAC(key, forged):   608d841d5f983db31b05cfa5ec090e39b1829798b128b2321f3be8d3db3e7064
23
两者相同: 否（HMAC 安全）

1
import bcrypt
2
import time
3

4
password = b"MySecurePassword123!"
5

6
# 同一密码两次哈希——结果不同（盐不同）
7
hash1 = bcrypt.hashpw(password, bcrypt.gensalt(rounds=12))
8
hash2 = bcrypt.hashpw(password, bcrypt.gensalt(rounds=12))
9
print(f"原始密码:   {password.decode()}")
10
print(f"第一次哈希: {hash1.decode()}")
11
print(f"第二次哈希: {hash2.decode()}")
12
print(f"两次不同:   {'是（盐不同）' if hash1 != hash2 else '否'}")
13

14
# 验证正确密码
15
is_valid = bcrypt.checkpw(password, hash1)
16
print(f"\n--- 验证正确密码 ---")
17
print(f"结果: {' 密码正确' if is_valid else ' 密码错误'}")
18

19
# 验证错误密码
20
is_valid_wrong = bcrypt.checkpw(b"WrongPassword456!", hash1)
21
print(f"\n--- 验证错误密码 ---")
22
print(f"结果: {' 密码正确' if is_valid_wrong else ' 密码错误'}")
23

24
# 不同 cost factor 性能对比
25
print(f"\n--- 不同 cost factor 性能对比 ---")
26
print(f"{'Cost':>6s} | {'耗时':>10s}")
27
print(f"{'-'*6}-+-{'-'*10}")
28
for cost in [10, 12, 14]:
29
    start = time.time()
30
    bcrypt.hashpw(password, bcrypt.gensalt(rounds=cost))
31
    elapsed = time.time() - start
32
    print(f"{cost:>6d} | {elapsed:>9.4f}s")
33

34
# 解析 bcrypt 哈希格式
35
sample_hash = hash1.decode()
36
print(f"\n--- bcrypt 哈希格式解析 ---")
37
print(f"完整哈希:     {sample_hash}")
38
print(f"算法标识:     {sample_hash[:3]}")
39
print(f"代价因子:     {sample_hash[4:6]} (2^{sample_hash[4:6]} = {2**int(sample_hash[4:6])} 轮)")
40
print(f"盐(22字符):   {sample_hash[7:29]}")
41
print(f"哈希(31字符): {sample_hash[29:]}")

1
原始密码:   MySecurePassword123!
2
第一次哈希: $2b$12$YfL2C1Ue.P6Ea3Jpesr5ZOGVliP4G9MpMNAUerLOlg3KJQxCDk5BS
3
第二次哈希: $2b$12$2Dr1RtB5OtjHisQLB//Bv.lZkjnuHnUUQ.rnR5mzR4lxozllKtij2
4
两次不同:   是（盐不同）
5

6
--- 验证正确密码 ---
7
结果:  密码正确
8

9
--- 验证错误密码 ---
10
结果:  密码错误
11

12
--- 不同 cost factor 性能对比 ---
13
  Cost |         耗时
14
-------+----------
15
    10 |    0.0529s
16
    12 |    0.2143s
17
    14 |    0.8942s
18

19
--- bcrypt 哈希格式解析 ---
20
完整哈希:     $2b$12$YfL2C1Ue.P6Ea3Jpesr5ZOGVliP4G9MpMNAUerLOlg3KJQxCDk5BS
21
算法标识:     $2b
22
代价因子:     12 (2^12 = 4096 轮)
23
盐(22字符):   YfL2C1Ue.P6Ea3Jpesr5ZO
24
哈希(31字符): GVliP4G9MpMNAUerLOlg3KJQxCDk5BS