关于4096位RSA加密在校园墙的运用

[Air-ban]

校园墙加密方式

本文会详细介绍该校园墙的加密方式，以及实现方式以及实现细节

技术细节

由于考虑到人数，这里使用RSA加密，并且是4096的RSA加密，可以极大提高用户数据安全性，以下是实现RSA4096的具体方式

首先，需要获取私钥与密钥，这里使用一个生成器，借用python中cryptography库来进行所有有关RSA加解密的操作，以下是生成4096位私钥和公钥的源代码

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend

def generate_rsa_key_pair(key_size=4096):
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=key_size,
        backend=default_backend()
    )
    public_key = private_key.public_key()
    return private_key, public_key

def save_key(key, filename):
    with open(filename, 'wb') as f:
        f.write(key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.PKCS8,
            encryption_algorithm=serialization.NoEncryption()
        ))

def save_public_key(key, filename):
    with open(filename, 'wb') as f:
        f.write(key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        ))

# 生成RSA密钥对
private_key, public_key = generate_rsa_key_pair()

# 保存私钥和公钥到文件
save_key(private_key, 'private_key.pem')
save_public_key(public_key, 'public_key.pem')

print("RSA key pair generated and saved.")

上述代码均添加了注释，简单易懂，因为是使用系统随机数生成的密钥对，就算是按照这份程序重新生成，也无法得到一样的密钥

在RSA中，公钥用于加密，私钥用于解密，所以，加密时使用公钥，解密时使用私钥，以下是加密代码

from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding, rsa
from cryptography.hazmat.backends import default_backend
import os

def load_public_key(key_path: str):
    with open(key_path, 'rb') as key_file:
        public_key = serialization.load_pem_public_key(
            key_file.read(),
            backend=default_backend()
        )
    return public_key

def encrypt_file_rsa(public_key: rsa.RSAPublicKey, input_file_path: str, output_file_path: str):
    with open(input_file_path, 'rb') as f:
        data = f.read()

    # 由于RSA加密的局限性，这里假设文件内容不会超过公钥的最大加密尺寸
    # 对于大文件，您应该使用对称加密来加密文件内容，然后只使用RSA加密对称密钥
    encrypted_data = public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

    with open(output_file_path, 'wb') as f:
        f.write(encrypted_data)

def main():
    # 加载公钥
    public_key_path = 'public_key.pem'
    public_key = load_public_key(public_key_path)

    # 加密文件 格式可以是任意格式，并不局限于这两种格式
    input_file_path = '加密前文件.txt'
    output_file_path = '加密后文件.bin'
    encrypt_file_rsa(public_key, input_file_path, output_file_path)

    print(f'File "{input_file_path}" has been encrypted to "{output_file_path}"')

if __name__ == '__main__':
    main()

这一切看上去真的是十分的美妙且优雅，没话说，一切加密的运作及其合理，使用公钥进行文件加密，并且加密后直接删除源文件，密钥丢了就彻底寄了，所以不要考虑信息或文件泄露，你们的信息安全是我唯一保证的目标

你上次不是说要用PGP吗？为什么不用了？

针对这个问题，相信会写代码的都会选择较为轻松且加密效果好的加密算法，像RSA这种非对称加密算法，就十分符合我们的需求，并且对于单一文件并不需要消耗过多的资源

好的，说完了加密，我们要来说说解密，以下是使用RSA私钥进行解密的代码

from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding, rsa
from cryptography.hazmat.backends import default_backend
import os

def load_private_key(key_path: str):
    with open(key_path, 'rb') as key_file:
        private_key = serialization.load_pem_private_key(
            key_file.read(),
            password=None,  # 如果私钥有密码，请在此处提供
            backend=default_backend()
        )
    return private_key

def decrypt_file_rsa(private_key: rsa.RSAPrivateKey, input_file_path: str, output_file_path: str):
    with open(input_file_path, 'rb') as f:
        encrypted_data = f.read()

    # 使用RSA私钥解密数据
    decrypted_data = private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

    with open(output_file_path, 'wb') as f:
        f.write(decrypted_data)

def main():
    # 加载私钥
    private_key_path = 'private_key.pem'
    private_key = load_private_key(private_key_path)

    # 解密文件
    input_file_path = '加密后文件.bin'
    output_file_path = '解密后文件.txt'
    decrypt_file_rsa(private_key, input_file_path, output_file_path)

    print(f'File "{input_file_path}" has been decrypted to "{output_file_path}"')

if __name__ == '__main__':
    main()

这里也可以看到，RSA解密也是非常的好写且通俗易懂，这三个模块已经融合在了校园墙机器人中，并且会在内部进行互相调用，我是啥也不知道，所以请对你们的个人隐私放100个心

RSA技术原理

下面将为各位彻底解释清楚什么是RSA加密，以及RSA加密的原理

加密

RSA的加密过程可以使用一个通式来表达

密文＝明文EmodN密文＝明文EmodN

也就是说RSA加密是对明文的E次方后除以N后求余数的过程。就这么简单？对，就是这么简单。 从通式可知，只要知道E和N任何人都可以进行RSA加密了，所以说E、N是RSA加密的密钥，也就是说E和N的组合就是公钥，我们用(E,N)来表示公钥

公钥＝(E,N)公钥＝(E,N)

不过E和N不并不是随便什么数都可以的，它们都是经过严格的数学计算得出的，关于E和N拥有什么样的要求及其特性后面会讲到。顺便啰嗦一句E是加密（Encryption）的首字母，N是数字（Number）的首字母

解密

RSA的解密同样可以使用一个通式来表达

明文＝密文DmodN明文＝密文DmodN

也就是说对密文进行D次方后除以N的余数就是明文，这就是RSA解密过程。知道D和N就能进行解密密文了，所以D和N的组合就是私钥

私钥＝(D,N)私钥＝(D,N)

从上述可以看出RSA的加密方式和解密方式是相同的，加密是求“E次方的mod N”;解密是求“D次方的mod N” 此处D是解密（Decryption）的首字母；N是数字（Number）的首字母。

密钥对的生成

既然公钥是（E，N），私钥是（D，N）所以密钥对即为（E，D，N）但密钥对是怎样生成的？步骤如下：

1. 求N
2. 求L（L为中间过程的中间数）
3. 求E
4. 求D

   求N

   准备两个质数p，q。这两个数不能太小，太小则会容易破解，将p乘以q就是N

   N=p∗qN=p∗q

   求L

   L 是 p－1 和 q－1的最小公倍数，可用如下表达式表示 L=lcm（p－1，q－1）L=lcm（p－1，q－1）

   求E

   E必须满足两个条件：E是一个比1大比L小的数，E和L的最大公约数为1 用gcd(X,Y)来表示X，Y的最大公约数则E条件如下： 1 < E < L

gcd（E，L）=1

之所以需要E和L的最大公约数为1是为了保证一定存在解密时需要使用的数D。现在我们已经求出了E和N也就是说我们已经生成了密钥对中的公钥了

求D

数D是由数E计算出来的。D、E和L之间必须满足以下关系：

1 < D < L E＊D mod L ＝ 1

只要D满足上述2个条件，则通过E和N进行加密的密文就可以用D和N进行解密。 简单地说条件2是为了保证密文解密后的数据就是明文。 现在私钥自然也已经生成了，密钥对也就自然生成了

简单的实践一下

我们用具体的数字来实践下RSA的密钥对对生成，及其加解密对全过程。为方便我们使用较小数字来模拟

求N

我们准备两个很小对质数， p ＝ 17 q ＝ 19 N ＝ p ＊ q ＝ 323

求L

L ＝ lcm（p－1， q－1）＝ lcm(16，18） ＝ 144 144为16和18对最小公倍数

求E

求E必须要满足2个条件：1 < E < L ，gcd（E，L）=1 即1 < E < 144，gcd（E，144） ＝ 1 E和144互为质数，5显然满足上述2个条件 故E ＝ 5

此时公钥=(E，N）＝ （5，323）

求D

求D也必须满足2个条件：1 < D < L，E＊D mod L ＝ 1 即1 < D < 144，5 ＊ D mod 144 ＝ 1 显然当D＝ 29 时满足上述两个条件 1 < 29 < 144 5＊29 mod 144 ＝ 145 mod 144 ＝ 1 此时私钥＝（D，N）＝（29，323）

加密

准备的明文必须时小于N的数，因为加密或者解密都要mod N其结果必须小于N 假设明文 ＝ 123 则 密文＝明文EmodN＝1235mod323=225密文＝明文EmodN＝1235mod323=225

解密

明文＝密文DmodN＝22529mod323=123明文＝密文DmodN＝22529mod323=123 解密后的明文为123

结尾

说了这么多，只是希望各位同学可以提高网络安全意识，并且做到洁身自好

共勉