如何对数字进行加密python

对数字进行加密的方法包括：使用对称加密算法、使用非对称加密算法、使用哈希函数、结合盐值和迭代次数的哈希加密。其中，使用对称加密算法是一种常见且有效的方式。对称加密算法是指加密和解密使用相同的密钥，这种方法通常效率较高，适用于大部分需要加密的场景。接下来将详细介绍如何使用对称加密算法对数字进行加密。

一、对称加密算法

对称加密算法（Symmetric-key encryption）是一种加密方法，其中加密和解密使用相同的密钥。在Python中，可以使用cryptography库来实现对称加密。cryptography库提供了多种加密算法，其中AES（Advanced Encryption Standard，高级加密标准）是最常用的一种。

1、安装cryptography库

在开始加密之前，首先需要安装cryptography库。可以使用以下命令来安装：

pip install cryptography

2、使用AES算法进行加密

下面是一个使用AES算法进行数字加密的示例：

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
import os
def encrypt_number(number, key):
    # 将数字转换为字节
    number_bytes = str(number).encode('utf-8')
    # 生成随机初始化向量（IV）
    iv = os.urandom(16)
    # 创建AES加密器
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    # 对数据进行填充
    padder = padding.PKCS7(algorithms.AES.block_size).padder()
    padded_data = padder.update(number_bytes) + padder.finalize()
    # 加密数据
    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()
    return iv + encrypted_data
def decrypt_number(encrypted_data, key):
    # 提取初始化向量（IV）
    iv = encrypted_data[:16]
    encrypted_data = encrypted_data[16:]
    # 创建AES解密器
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    # 解密数据
    decrypted_padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
    # 去除填充
    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
    decrypted_data = unpadder.update(decrypted_padded_data) + unpadder.finalize()
    return int(decrypted_data.decode('utf-8'))
示例
key = os.urandom(32)  # 生成一个随机密钥（32字节）
number = 123456
encrypted_number = encrypt_number(number, key)
print(f"Encrypted Number: {encrypted_number}")
decrypted_number = decrypt_number(encrypted_number, key)
print(f"Decrypted Number: {decrypted_number}")

二、非对称加密算法

非对称加密算法（Asymmetric-key encryption）使用一对密钥进行加密和解密：公钥（用于加密）和私钥（用于解密）。在Python中，可以使用cryptography库中的RSA算法来实现非对称加密。

1、生成RSA密钥对

首先，需要生成一对RSA密钥：

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
生成RSA密钥对
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
导出私钥
private_key_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)
导出公钥
public_key = private_key.public_key()
public_key_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
保存密钥到文件（可选）
with open('private_key.pem', 'wb') as f:
    f.write(private_key_pem)
with open('public_key.pem', 'wb') as f:
    f.write(public_key_pem)

2、使用RSA算法进行加密和解密

下面是一个使用RSA算法进行数字加密和解密的示例：

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
def encrypt_number_rsa(number, public_key):
    # 将数字转换为字节
    number_bytes = str(number).encode('utf-8')
    # 使用公钥加密数据
    encrypted_data = public_key.encrypt(
        number_bytes,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return encrypted_data
def decrypt_number_rsa(encrypted_data, private_key):
    # 使用私钥解密数据
    decrypted_data = private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return int(decrypted_data.decode('utf-8'))
示例
number = 123456
加载公钥和私钥
public_key = serialization.load_pem_public_key(public_key_pem, backend=default_backend())
private_key = serialization.load_pem_private_key(private_key_pem, password=None, backend=default_backend())
encrypted_number = encrypt_number_rsa(number, public_key)
print(f"Encrypted Number: {encrypted_number}")
decrypted_number = decrypt_number_rsa(encrypted_number, private_key)
print(f"Decrypted Number: {decrypted_number}")

三、哈希函数

哈希函数（Hash Function）是一种将数据映射为固定长度散列值的算法。哈希函数通常用于数据完整性校验和密码存储。在Python中，可以使用hashlib库来实现哈希加密。

1、使用SHA-256进行哈希加密

下面是一个使用SHA-256哈希函数对数字进行加密的示例：

import hashlib
def hash_number(number):
    # 将数字转换为字节
    number_bytes = str(number).encode('utf-8')
    # 计算SHA-256哈希值
    sha256_hash = hashlib.sha256(number_bytes).hexdigest()
    return sha256_hash
示例
number = 123456
hashed_number = hash_number(number)
print(f"Hashed Number: {hashed_number}")

四、结合盐值和迭代次数的哈希加密

为了增强哈希加密的安全性，可以结合盐值（Salt）和迭代次数（Iterations）来进行哈希加密。在Python中，可以使用hashlib库和os库来实现。

1、生成盐值

盐值是一种随机数据，通常与原始数据一起进行哈希计算，以防止彩虹表攻击。可以使用os.urandom()函数生成盐值。

2、结合盐值和迭代次数进行哈希加密

下面是一个结合盐值和迭代次数进行哈希加密的示例：

import hashlib
import os
def hash_number_with_salt(number, salt, iterations=100000):
    # 将数字转换为字节
    number_bytes = str(number).encode('utf-8')
    # 结合盐值进行哈希计算
    hash_value = hashlib.pbkdf2_hmac('sha256', number_bytes, salt, iterations)
    return hash_value.hex()
示例
number = 123456
salt = os.urandom(16)  # 生成随机盐值
iterations = 100000  # 迭代次数
hashed_number = hash_number_with_salt(number, salt, iterations)
print(f"Salt: {salt.hex()}")
print(f"Hashed Number: {hashed_number}")