常见加密算法详解 - 程序员必知的网络安全基石

唐叔在学习

于 2025-08-03 14:02:31 发布

阅读量548

点赞数 15

CC 4.0 BY-SA版权

文章标签： web安全安全加密算法 MD5 RSA AES

本文链接：https://blog.csdn.net/Tang_is_learning/article/details/149879779

作者：唐叔在学习
标签：加密算法 AES RSA MD5 网络安全 数据加密 密码学 区块链安全 信息安全 程序员面试

文章目录

一、为什么要了解加密算法？

各位CSDN的小伙伴们好啊，我是你们的老朋友唐叔！最近有粉丝私信问我："唐叔，面试总被问到加密算法，到底哪些是必须掌握的？"今天咱们就来好好聊聊这个话题。

无论是Web开发、移动App还是区块链应用，加密算法都是守护数据安全的最后防线。掌握这些知识不仅能帮你通过技术面试，更能让你写出更安全的代码。

二、加密算法三大门派

1. 哈希算法：数据的"指纹提取器"

哈希算法就像给数据做"指纹鉴定"，特点是：

单向不可逆
固定长度输出
微小的输入变化会导致输出巨变

常见算法：

MD5（128位哈希值）：虽然已被证明不安全，但在校验文件完整性时仍被广泛使用

import hashlib

def md5_hash(text):
    md5 = hashlib.md5()
    md5.update(text.encode('utf-8'))
    return md5.hexdigest()

if __name__ == "__main__":
    text = "唐叔讲算法"
    print(f"MD5哈希值: {md5_hash(text)}")
    # 输出示例: a7d8cd9e89d4f5c37f5a7d82b5a3c3f1

SHA系列（尤其是SHA-256）：比特币等区块链技术的基石

import hashlib

def sha256_hash(text):
    sha256 = hashlib.sha256()
    sha256.update(text.encode('utf-8'))
    return sha256.hexdigest()

if __name__ == "__main__":
    text = "区块链安全"
    print(f"SHA-256哈希值: {sha256_hash(text)}")
    # 输出示例: 5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8

📌 面试热点：为什么密码存储要加盐(Salt)？就是为了防止彩虹表攻击！正确的做法是：hash(密码+随机盐值)

加盐示例

import hashlib
import os
import binascii

def hash_password(password):
    # 生成随机盐
    salt = os.urandom(16)
    # 使用PBKDF2算法
    dk = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
    return salt, dk

def verify_password(password, salt, stored_hash):
    dk = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
    return dk == stored_hash

if __name__ == "__main__":
    password = "securePassword123"
    salt, hashed = hash_password(password)
    
    print(f"盐值: {binascii.hexlify(salt).decode()}")
    print(f"哈希值: {binascii.hexlify(hashed).decode()}")
    
    # 验证密码
    is_valid = verify_password(password, salt, hashed)
    print(f"密码验证结果: {is_valid}")

2. 对称加密：用同一把钥匙加解密

就像用同一把钥匙锁门和开门，特点是：

加解密速度快
适合大数据量加密
密钥分发是难点

主流算法：

AES（高级加密标准）：目前最安全的对称算法，支持128/192/256位密钥

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
import base64

def aes_encrypt(plaintext, key=None):
    if key is None:
        key = get_random_bytes(16)  # AES-128
    
    # 生成随机初始化向量
    iv = get_random_bytes(AES.block_size)
    
    cipher = AES.new(key, AES.MODE_CBC, iv)
    ciphertext = cipher.encrypt(pad(plaintext.encode('utf-8'), AES.block_size))
    
    return iv, ciphertext, key

def aes_decrypt(iv, ciphertext, key):
    cipher = AES.new(key, AES.MODE_CBC, iv)
    plaintext = unpad(cipher.decrypt(ciphertext), AES.block_size)
    return plaintext.decode('utf-8')

if __name__ == "__main__":
    message = "敏感数据"
    
    iv, ciphertext, key = aes_encrypt(message)
    
    print(f"密钥: {base64.b64encode(key).decode()}")
    print(f"IV: {base64.b64encode(iv).decode()}")
    print(f"加密结果: {base64.b64encode(ciphertext).decode()}")
    
    decrypted = aes_decrypt(iv, ciphertext, key)
    print(f"解密结果: {decrypted}")

DES（已淘汰）和3DES：由于安全性问题，现在基本被AES取代

💡 性能对比：AES-256加密1GB文件比RSA快100倍以上，这也是为什么HTTPS协议中实际数据传输使用对称加密

3. 非对称加密：公钥私钥双剑合璧

采用数学难题保证安全，特点是：

公钥加密，私钥解密
计算复杂度高
适合密钥交换和数字签名

代表算法：

RSA：基于大整数分解难题，2048位密钥是当前安全标准

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import base64

def generate_rsa_keys():
    key = RSA.generate(2048)
    private_key = key.export_key()
    public_key = key.publickey().export_key()
    return private_key, public_key

def rsa_encrypt(public_key, plaintext):
    rsa_key = RSA.import_key(public_key)
    cipher = PKCS1_OAEP.new(rsa_key)
    ciphertext = cipher.encrypt(plaintext.encode('utf-8'))
    return ciphertext

def rsa_decrypt(private_key, ciphertext):
    rsa_key = RSA.import_key(private_key)
    cipher = PKCS1_OAEP.new(rsa_key)
    plaintext = cipher.decrypt(ciphertext)
    return plaintext.decode('utf-8')

if __name__ == "__main__":
    message = "重要消息"
    
    private_key, public_key = generate_rsa_keys()
    
    print(f"公钥:\n{public_key.decode()}")
    print(f"私钥:\n{private_key.decode()}")
    
    encrypted = rsa_encrypt(public_key, message)
    print(f"加密结果: {base64.b64encode(encrypted).decode()}")
    
    decrypted = rsa_decrypt(private_key, encrypted)
    print(f"解密结果: {decrypted}")

ECC（椭圆曲线加密）：同等安全下密钥更短，特别适合移动设备

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes

def generate_ecc_keys():
    private_key = ec.generate_private_key(ec.SECP256R1())
    public_key = private_key.public_key()
    return private_key, public_key

def ecc_key_exchange(private_key, peer_public_key):
    shared_key = private_key.exchange(ec.ECDH(), peer_public_key)
    
    # 使用HKDF派生密钥
    derived_key = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b'handshake data',
    ).derive(shared_key)
    
    return derived_key

if __name__ == "__main__":
    # Alice生成密钥对
    alice_private, alice_public = generate_ecc_keys()
    
    # Bob生成密钥对
    bob_private, bob_public = generate_ecc_keys()
    
    # Alice计算共享密钥
    alice_shared = ecc_key_exchange(alice_private, bob_public)
    
    # Bob计算共享密钥
    bob_shared = ecc_key_exchange(bob_private, alice_public)
    
    print(f"Alice的共享密钥: {alice_shared.hex()}")
    print(f"Bob的共享密钥: {bob_shared.hex()}")
    print(f"密钥是否匹配: {alice_shared == bob_shared}")

🌟 前沿趋势：随着量子计算机发展，基于格密码的后量子加密算法(NIST标准)将成为下一代安全标准

三、实战中的加密组合拳

1. HTTPS中的TLS协议

用RSA/ECC交换AES密钥
用AES加密实际通信数据
用SHA系列验证数据完整性

2. 区块链中的加密技术

比特币使用SHA-256做工作量证明
以太坊账户基于ECDSA(椭圆曲线数字签名算法)
智能合约使用Keccak-256作为哈希函数

3. 密码存储最佳实践

四、加密算法选择指南

场景	推荐算法	密钥长度	备注
密码存储	PBKDF2/bcrypt	-	必须加盐
网络传输	AES-256	256位	配合RSA密钥交换
数字签名	ECDSA	256位	比RSA更高效
文件校验	SHA-256	-	替代不安全的MD5
移动端加密	ChaCha20	256位	比AES更适合ARM