MATLAB实现RSA加密算法：从原理到攻防实践

1. 项目概述：当MATLAB遇上RSA

在密码学和信息安全的教学、研究与原型验证领域，MATLAB一直扮演着一个独特而重要的角色。它不像Python那样拥有庞大的密码学库生态，也不像C/C++那样追求极致的性能，但其强大的矩阵运算能力、直观的可视化工具以及集成的开发环境，使其成为算法原理剖析、教学演示和快速验证的绝佳平台。今天，我们就来聊聊如何用MATLAB实现RSA加密算法，并在此基础上，深入探讨其潜在的攻击面以及我们可以实施的防护策略。这不仅仅是一个编程练习，更是一次对非对称加密核心逻辑的深度解构。

RSA算法自1977年诞生以来，已成为现代安全通信的基石之一，从HTTPS的SSL/TLS握手到数字签名，无处不在。然而，很多初学者对它的理解停留在“公钥加密，私钥解密”的抽象层面，对其背后的数论原理、实现细节以及安全边界往往一知半解。通过MATLAB亲手实现一遍RSA，你会对“大素数生成”、“模幂运算”、“欧拉函数”这些概念有血肉般的感受。更重要的是，我们将超越简单的加密解密功能，模拟和分析针对RSA的几种经典攻击（如因式分解攻击、选择密文攻击），并探讨在实际工程中如何加固你的RSA实现。无论你是信息安全专业的学生，还是对密码学感兴趣的工程师，亦或是需要快速验证密码学概念的科研人员，这篇内容都将提供一条从理论到实践、从实现到攻防的清晰路径。

2. RSA算法核心原理与MATLAB实现思路

在动手写代码之前，我们必须彻底吃透RSA的数学骨架。RSA的安全性建立在大数分解的困难性之上，这个“大数”就是我们的模数n。整个算法流程可以概括为密钥生成、加密和解密三个步骤，每一步都深深扎根于数论。

2.1 密钥生成：寻找安全基石

密钥生成是RSA的起点，也是最关键的一步，它直接决定了后续加密体系的安全强度。

1. 选择两个大素数p和q：这是所有安全性的源头。在MATLAB中，我们需要生成足够大的随机素数。randi函数可以生成大随机整数，但判断其是否为素数需要用到isprime函数。需要注意的是，对于非常大的数（比如超过2^50），isprime的确定性检验可能会很慢，在实际的高安全级应用中，通常会使用概率性素性测试（如Miller-Rabin测试）。为了教学和原型验证的清晰度，我们初期可以使用较小但安全的素数（如512位或1024位对应的十进制数范围），并依赖isprime。
2. 计算模数n = p * q：n的长度（以比特计）就是所谓的密钥长度。常见的RSA-2048意味着n是一个2048比特（约617位十进制数）的大整数。MATLAB的高精度整数运算可以很好地处理这类乘法。
3. 计算欧拉函数φ(n) = (p-1)*(q-1)：φ(n)表示在小于n的正整数中，与n互质的数的个数。由于p和q都是素数，这个计算变得非常简单。
4. 选择公钥指数e：e是一个与φ(n)互质的小整数，通常取65537 (0x10001)。这是一个广泛使用的固定值，因为它二进制表示中只有两个1，使得模幂运算速度较快，且其大小在安全性和计算效率之间取得了良好平衡。在MATLAB中，我们需要用gcd(e, phi_n) == 1来验证互质性。
5. 计算私钥指数d：d是e关于模φ(n)的模逆元，即满足e * d ≡ 1 (mod φ(n))。计算模逆元需要用到扩展欧几里得算法。MATLAB的gcd函数可以返回最大公约数和系数，我们可以利用它来实现扩展欧几里得算法，从而解出d。

至此，公钥为(n, e)，私钥为(n, d)。一个至关重要的注意事项是：必须彻底销毁或安全存储p,q,φ(n)这些中间值。一旦攻击者获得p和q中的任何一个，他就可以轻松计算出φ(n)和私钥d，整个加密体系便瞬间崩塌。在MATLAB脚本中，这意味着在生成密钥对后，应该将这些敏感变量从工作空间中清除。

2.2 加密与解密：模幂运算的艺术

RSA的加密和解密本质上是同一个数学操作：模幂运算。

• 加密：对于明文消息m（需要先将其转换为一个小于n的整数），计算密文c = m^e mod n。
• 解密：对于密文c，计算明文m = c^d mod n。

这里的关键在于m^e或c^d这两个数会极其巨大，直接计算再取模在计算上是不可行的。我们必须使用快速模幂算法（也称为平方-乘算法）。该算法通过对指数进行二进制分解，将计算复杂度从O(e)降低到O(log e)。例如，计算a^b mod n，算法通过反复的平方和条件乘法来实现，MATLAB实现起来非常优雅。

实操心得：在MATLAB中实现快速模幂时，要特别注意大整数的处理。虽然MATLAB默认使用双精度浮点数，但对于大整数运算，其精度可能丢失。我们可以使用符号数学工具箱（sym）或者vpi（可变精度整数）工具箱来确保计算的精确性。对于性能要求不高的原型验证，sym工具箱的powermod函数可以直接完成模幂运算，非常方便。

2.3 数据分组与编码

RSA算法本身是用于加密“整数”的。在实际应用中，我们需要加密的通常是文本、文件等字节流。这就涉及到一个预处理步骤：分组编码。

1. 分组：根据模数n的大小，确定每个分组能表示的最大整数（必须小于n）。将原始数据（如字符串转换为的字节数组）按此大小进行分组。
2. 编码：将每个分组转换为一个大整数。通常使用简单的编码方式，如将字节视为256进制的数字。例如，一个分组字节[B1, B2, B3]可以转换为整数B1*256^2 + B2*256^1 + B3*256^0。
3. 加密/解密：对每个整数分组分别进行RSA操作。
4. 解码：将解密后得到的整数，再转换回字节数组，最后拼接成原始数据。

注意事项：这里存在一个常见的陷阱——不正确的编码可能导致安全性降低。简单的将字节转换为整数，如果分组后的整数m与n不互质（虽然概率极低），或者m为0或1，加密后将得不到保护。更健壮的做法是使用OAEP（最优非对称加密填充）等填充方案，它在加密前对明文进行随机化处理，不仅能解决上述问题，还能增强抵抗某些攻击的能力。在我们的MATLAB实现中，为了首先聚焦核心算法，可以先实现基础的编码解码，但必须意识到这是需要后续加固的关键点。

3. MATLAB核心代码实现与分步解析

下面，我们将把上述理论转化为具体的MATLAB代码。我将采用自顶向下的方式，先构建主函数框架，再逐一实现关键子功能。

3.1 密钥生成函数实现

首先，我们实现一个可靠的密钥生成函数。考虑到教学目的，我们允许指定比特长度，但会在内部使用稍小但更可控的素数来保证演示的流畅性。

function [public_key, private_key] = generate_rsa_keys(bit_length) % 生成RSA密钥对 % 输入：bit_length - 期望的模数n的比特长度（建议>=512） % 输出：public_key - 结构体，包含字段 n 和 e % private_key - 结构体，包含字段 n 和 d % 1. 选择两个大素数p和q（这里简化，在实际中应使用更强的随机源和素性测试） % 为确保p和q大小相近且乘积接近目标比特长度，我们生成一半比特长度的素数 half_bits = ceil(bit_length / 2); prime_lower_bound = 2^(half_bits - 1); prime_upper_bound = 2^half_bits - 1; % 寻找素数p while true p = randi([prime_lower_bound, prime_upper_bound]); if isprime(p) && p > 2 break; end end % 寻找素数q，确保q不等于p while true q = randi([prime_lower_bound, prime_upper_bound]); if isprime(q) && q > 2 && q ~= p break; end end fprintf('生成素数: p = %d, q = %d\n', p, q); % 2. 计算模数n和欧拉函数phi_n n = p * q; phi_n = (p-1) * (q-1); fprintf('计算得到: n = %d, φ(n) = %d\n', n, phi_n); % 3. 选择公钥指数e，常用65537，确保与phi_n互质 e = 65537; if gcd(e, phi_n) ~= 1 % 如果65537不互质（极其罕见），则寻找一个较小的互质奇数 e = 3; while gcd(e, phi_n) ~= 1 e = e + 2; end end fprintf('公钥指数 e = %d\n', e); % 4. 计算私钥指数d，即e关于模phi_n的模逆元 % 使用扩展欧几里得算法 [g, d, ~] = gcd(e, phi_n); if g ~= 1 error('e和φ(n)不互质，无法计算模逆元！'); end % 确保d是正数 d = mod(d, phi_n); if d < 0 d = d + phi_n; end fprintf('私钥指数 d = %d\n', d); % 5. 封装密钥 public_key = struct('n', n, 'e', e); private_key = struct('n', n, 'd', d); % 6. 安全提醒：在实际应用中，应从内存中清除p, q, phi_n % clear p q phi_n; end

代码解析与避坑：

• randi函数生成的随机数范围是包含边界的，我们用它来在指定比特长度的范围内寻找素数。
• isprime函数对于教学级别的素数大小（几十位十进制数）是高效且确定的。对于真正的密码学强度（数百位），你需要实现或调用更高级的Miller-Rabin测试。
• 计算模逆元d时，我们使用了MATLAB自带的gcd函数，它返回最大公约数g和满足e*d + phi_n*y = g的系数d,y。当g==1时，d就是e模phi_n的逆元。但需要注意d可能为负数，所以要通过取模操作将其调整到[0, phi_n)的正数范围内。
• 最后的clear语句被注释掉了，因为在函数工作区内，这些局部变量在函数结束时就会被销毁。但在脚本或更复杂的环境中，主动清除敏感中间变量是一个好习惯。

3.2 快速模幂运算函数

这是RSA运算的核心，我们必须高效地计算base^exp mod modulus。

function result = mod_pow(base, exp, modulus) % 使用平方-乘算法计算 (base^exp) mod modulus % 输入：base - 底数，exp - 指数，modulus - 模数 % 输出：result - 模幂结果 result = 1; base = mod(base, modulus); % 先取模，减少后续计算量 % 将指数exp转换为二进制进行处理 % 这里我们通过循环右移exp来实现 while exp > 0 % 如果当前二进制位为1 if mod(exp, 2) == 1 result = mod(result * base, modulus); end % 平方底数 base = mod(base * base, modulus); % 右移指数（相当于除以2取整） exp = floor(exp / 2); end end

原理解读：这个算法之所以快，是因为它将指数exp用二进制表示。例如exp = 13 (二进制1101)，那么base^13 = base^(8+4+1) = base^8 * base^4 * base^1。算法从最低位开始扫描二进制位，遇到1就做一次乘法（result * base），每一步都对底数做平方（base * base）以准备下一位的计算。整个过程都在模modulus下进行，避免了巨大中间值的产生。

3.3 数据分组与编码/解码函数

为了加密字符串，我们需要将其转换为整数序列，并确保每个整数小于模数n。

function int_blocks = str_to_blocks(str, n) % 将字符串转换为整数分组，每个分组表示的整数 < n % 输入：str - 待编码字符串，n - RSA模数 % 输出：int_blocks - 整数分组数组 % 将字符串转换为uint8类型的字节数组 data = uint8(str); block_size = floor(log2(n)) / 8; % 计算每个分组最大字节数（取整） block_size = max(1, floor(block_size)); % 确保至少1字节 num_blocks = ceil(length(data) / block_size); int_blocks = zeros(1, num_blocks); for i = 1:num_blocks start_idx = (i-1)*block_size + 1; end_idx = min(i*block_size, length(data)); block_data = data(start_idx:end_idx); % 将字节数组转换为一个大整数（256进制） int_val = 0; for j = 1:length(block_data) int_val = int_val * 256 + double(block_data(j)); end int_blocks(i) = int_val; % 安全检查：转换后的整数必须小于n if int_blocks(i) >= n error('编码错误：分组整数 %d 不小于模数 n=%d。请减小block_size。', int_blocks(i), n); end end end function str = blocks_to_str(int_blocks) % 将整数分组数组转换回字符串 % 输入：int_blocks - 整数分组数组 % 输出：str - 解码后的字符串 byte_list = []; for i = 1:length(int_blocks) int_val = int_blocks(i); % 将整数分解为字节 bytes = []; while int_val > 0 byte = mod(int_val, 256); bytes = [byte, bytes]; % 注意顺序，高位在前 int_val = floor(int_val / 256); end % 如果bytes为空（即int_val=0），则补充一个0字节（根据编码规则，这通常代表空数据，需谨慎处理） if isempty(bytes) bytes = 0; end byte_list = [byte_list, bytes]; end str = char(byte_list); end

关键细节与陷阱：

• block_size的计算基于n的对数，确保256^block_size < n。这里使用floor向下取整是保守安全的做法。
• 在字节转整数的循环中，我们使用double类型来避免乘法溢出，但最终存储为double类型的整数。对于非常大的n和分组，MATLAB的double类型可能无法精确表示巨大的整数，这时必须使用vpi或符号整数。这是从教学演示迈向实用化必须跨越的一步。
• 解码时，while循环将整数按256进制逐位分解。注意字节拼接的顺序是[byte, bytes]，这确保了高位字节在前，与编码过程匹配。
• 一个严重的边界情况是当int_val为0时，while循环不会执行，导致bytes为空。在我们的简单编码中，明文整数为0是可能的（例如字符串开头有特定字节组合）。这会导致信息丢失。更健壮的编码方案（如PKCS#1填充）会避免这种情况。

3.4 完整的加密与解密函数

现在，我们可以组装出完整的加密和解密函数。

function encrypted_blocks = rsa_encrypt(plaintext, public_key) % RSA加密函数 % 输入：plaintext - 明文字符串，public_key - 公钥结构体（包含n和e） % 输出：encrypted_blocks - 加密后的整数分组数组 n = public_key.n; e = public_key.e; % 1. 将明文字符串编码为整数分组 int_blocks = str_to_blocks(plaintext, n); fprintf('明文编码为 %d 个整数分组。\n', length(int_blocks)); % 2. 对每个分组进行加密：c = m^e mod n encrypted_blocks = zeros(size(int_blocks)); for i = 1:length(int_blocks) m = int_blocks(i); encrypted_blocks(i) = mod_pow(m, e, n); end end function decrypted_text = rsa_decrypt(encrypted_blocks, private_key) % RSA解密函数 % 输入：encrypted_blocks - 加密的整数分组数组，private_key - 私钥结构体（包含n和d） % 输出：decrypted_text - 解密后的明文字符串 n = private_key.n; d = private_key.d; % 1. 对每个分组进行解密：m = c^d mod n decrypted_blocks = zeros(size(encrypted_blocks)); for i = 1:length(encrypted_blocks) c = encrypted_blocks(i); decrypted_blocks(i) = mod_pow(c, d, n); end % 2. 将解密后的整数分组解码为字符串 decrypted_text = blocks_to_str(decrypted_blocks); end

3.5 主程序示例与测试

让我们写一个简单的脚本来测试整个流程。

% 主测试脚本 clear; clc; % 1. 生成RSA密钥对（使用1024比特级别的模数，这里用较小素数便于演示） fprintf('=== 生成RSA密钥对 ===\n'); [pub_key, priv_key] = generate_rsa_keys(64); % 64位用于演示，实际应用请使用2048或更高 fprintf('公钥: (n=%d, e=%d)\n', pub_key.n, pub_key.e); fprintf('私钥: (n=%d, d=%d)\n', priv_key.n, priv_key.d); % 2. 准备明文 plaintext = 'Hello, RSA! 这是一条测试消息。'; fprintf('\n=== 加密过程 ===\n'); fprintf('原始明文: %s\n', plaintext); % 3. 加密 encrypted_blocks = rsa_encrypt(plaintext, pub_key); fprintf('生成密文分组: %s\n', mat2str(encrypted_blocks)); % 4. 解密 fprintf('\n=== 解密过程 ===\n'); decrypted_text = rsa_decrypt(encrypted_blocks, priv_key); fprintf('解密结果: %s\n', decrypted_text); % 5. 验证 if strcmp(plaintext, decrypted_text) fprintf('\n✅ 加解密测试成功！\n'); else fprintf('\n❌ 加解密测试失败！\n'); fprintf('明文长度: %d, 解密文长度: %d\n', length(plaintext), length(decrypted_text)); end

运行这个脚本，你将看到从密钥生成、字符串编码、加密到解密的完整过程。通过这个亲手搭建的系统，RSA算法不再是一个黑盒，它的每一步运算你都了然于胸。

4. RSA常见攻击模拟与防护分析

实现了一个能工作的RSA系统只是第一步。一个合格的安全从业者必须了解其弱点。我们将在MATLAB环境中，模拟几种经典的攻击，并分析如何防护。

4.1 因式分解攻击与密钥长度选择

这是最直接的攻击方式：如果攻击者能从公钥的模数n中分解出p和q，那么他就可以计算出φ(n)和私钥d。RSA的安全性完全依赖于大数分解的难度。

模拟攻击：我们可以编写一个简单的暴力分解脚本（仅适用于非常小的n用于演示）。

function [p, q] = factorize_attack(n) % 简单的因式分解演示（仅适用于极小n） % 输入：n - RSA模数 % 输出：p, q - 分解得到的两个因子 if mod(n, 2) == 0 p = 2; q = n/2; return; end % 试除法，从3开始，步长为2（只检查奇数） for i = 3:2:sqrt(n) if mod(n, i) == 0 p = i; q = n / i; fprintf('[攻击模拟] 成功分解 n=%d 为 %d * %d\n', n, p, q); return; end end p = []; q = []; fprintf('[攻击模拟] 未能分解 n=%d（可能为素数或太大）\n', n); end

防护策略：

• 使用足够长的密钥：这是抵御因式分解的根本。目前认为RSA-2048（2048位模数）是安全的，对于长期保密的需求，应使用RSA-3072或RSA-4096。在我们的generate_rsa_keys函数中，bit_length参数应至少设置为2048。
• 选择强素数：p和q本身应该是强素数（形式为2p'+1，其中p'也是素数），并且长度应大致相同，差值不宜过大，以避免费马分解法等攻击。
• 定期更换密钥：即使当前密钥长度安全，随着计算能力的提升，也应制定密钥更新策略。

4.2 小公钥指数攻击与填充方案

为了提升加密效率，公钥指数e通常取一个较小的值，如3或65537。但如果e太小，并且对不同的消息m加密时没有使用随机填充，就可能受到攻击。

攻击场景模拟（Coppersmith攻击简述）：假设同一消息m用相同的公钥(n, e)加密了e次（使用不同的随机填充可以避免，但我们假设没有填充），且e很小。攻击者可能通过中国剩余定理（CRT）在e个方程中恢复m。更常见的是，如果m^e < n，那么加密操作c = m^e mod n就退化成了c = m^e（因为没有取模），攻击者直接对c开e次方根就能得到m。

防护策略：

• 使用标准的、较大的公钥指数：始终使用e=65537。它既避免了e=3可能带来的问题，其二进制形式（10000000000000001）又使得快速模幂运算非常高效。
• 必须使用随机填充：这是最关键的一点。在加密前，使用如OAEP的填充方案对明文进行随机化处理。填充后的消息在数学上接近于一个均匀随机的大整数，完全消除了m^e < n的可能性，也使得同一明文每次加密都会产生不同的密文，抵御了上述攻击。在MATLAB中实现OAEP需要哈希函数和随机数生成器，虽然稍复杂，但对于构建一个健壮的RSA加密模块是必须的。

4.3 选择密文攻击与算法完整性

这种攻击模型假设攻击者能够获得一个“解密神谕机”——即他可以向系统提交任意密文（除了目标密文），并得到解密结果。通过精心构造的密文，他可能推导出私钥或解密其他密文。

模拟攻击思路（简单示例）：假设攻击者截获了一个密文c，其对应的明文是m（即c = m^e mod n）。攻击者可以构造一个新的密文c' = (c * s^e) mod n，其中s是一个任意整数。他将c'提交给解密机，得到解密结果m' = (c')^d mod n = (m * s) mod n。由于攻击者知道s，他就可以计算m = m' * s^{-1} mod n，从而破解了原始密文c。

防护策略：

• 在解密后验证消息结构：解密后的明文，在移除填充后，应该具有一个可验证的、正确的格式。例如，PKCS#1 v1.5填充有特定的结构，如果解密后的数据不符合这个结构，就应作为无效密文拒绝，并返回统一的错误信息（避免侧信道攻击）。这可以阻止攻击者利用解密结果进行数学推导。
• 使用具有主动安全性的方案：如RSA-OAEP，它在设计上就提供了抵抗选择密文攻击的安全性证明。
• 避免直接使用RSA加密：在实际协议中（如TLS），RSA通常不直接用于加密会话密钥，而是用于签名或者与密钥协商算法结合。直接加密大量数据应使用对称加密算法（如AES），RSA只用于加密那个对称密钥。

4.4 侧信道攻击防护（进阶思考）

侧信道攻击不攻击算法本身，而是攻击其物理实现。例如，通过分析设备解密时所消耗的时间、功耗或电磁辐射，来推断出私钥d的比特信息。虽然MATLAB是软件仿真环境，但了解这些攻击有助于设计更安全的系统。

• 时间攻击：快速模幂算法的运行时间可能与d的比特值相关（因为遇到1时才做乘法）。防护方法是使用常数时间实现的模幂算法，即无论d的比特是0还是1，执行的操作序列和耗时都相同。
• 功耗分析：类似地，不同的运算（乘法和平方）可能产生不同的功耗特征。防护方法包括使用蒙哥马利幂模运算、在算法中加入随机延迟或盲化操作（如先将密文乘以一个随机数的e次方，解密后再消除影响）。

在MATLAB中模拟这些攻击较为困难，但我们可以意识到，一个密码学安全的实现，远不止正确的数学公式，还包括对实现细节的极致考究。

5. 工程实践建议与常见问题排查

将上述MATLAB原型代码应用到更严肃的场景时，你会遇到一系列实际问题。以下是我从实践中总结的经验和常见陷阱。

5.1 性能优化：处理大整数

我们之前的代码使用MATLAB默认的double类型进行整数运算。当n、p、q达到真实RSA密钥的规模（数百位十进制数）时，double的精度（约15-16位有效十进制数字）完全不够，会导致计算错误。

解决方案：

1. 使用符号数学工具箱（Symbolic Math Toolbox）：sym对象可以表示任意精度的整数。powermod函数可以直接计算模幂。

   % 将数字转换为sym对象 n_sym = sym(n); e_sym = sym(e); m_sym = sym(m); c_sym = powermod(m_sym, e_sym, n_sym); % 计算 m^e mod n

   这种方法最简单，但对于大量连续运算可能较慢。
2. 使用可变精度整数工具箱（如John D'Errico的VPI工具）：如果你没有符号工具箱，可以寻找第三方的高精度整数库。VPI（Variable Precision Integers）是一个优秀的替代品，专为整数运算设计，通常比符号工具箱更快。
3. 实现大整数运算库：作为学习项目，你可以自己用字符串或数组来表示大整数，并实现加法、乘法、取模等运算。这是一个深刻的练习，但工程量大。

实操建议：对于教学和原型验证，使用sym工具箱是最快上手的。在generate_rsa_keys、mod_pow、str_to_blocks等所有涉及大数的地方，将关键变量转换为sym类型。

5.2 数据编码与填充的陷阱

我们自制的str_to_blocks函数非常简陋，存在多个问题：

1. 整数0编码问题：如前所述，解码时整数0会丢失。
2. 无随机性：相同的明文总是产生相同的密文，这不符合语义安全的要求。
3. 无法验证完整性：解密后的数据无法验证是否被篡改。

解决方案：实现或使用一个标准的填充方案。对于教育目的，可以尝试实现一个简化版的PKCS#1 v1.5填充（注意：v1.5填充已知在某些场景下有弱点，OAEP更安全，但v1.5更简单易懂）。

简化PKCS#1 v1.5加密填充流程：

1. 确定分组长度k（字节数，等于模数n的字节长度）。
2. 生成一个非零的随机填充字符串PS，其长度使得：总长度 = k - 明文长度 - 3。PS至少要有8个字节。
3. 构造编码块：EB = 0x00 || 0x02 || PS || 0x00 || 明文。（||表示拼接）
4. 将这个字节块EB转换为整数m，然后进行RSA加密。

解密时，将解密得到的整数转换回字节块，检查其格式是否为0x00 0x02 ... 0x00 ...，并提取出明文。任何格式错误都意味着密文无效。

强烈建议：在实际项目中，绝对不要自己实现加密填充用于生产环境。应使用成熟的密码学库，如Java的javax.crypto、Python的cryptography、C/C++的OpenSSL等。在MATLAB中，如果必须进行安全通信，考虑调用这些库的接口，或者将加密解密工作交给更专业的后端服务。

5.3 密钥管理与存储

“密钥管理是密码学中最难的部分。”生成的RSA密钥对如何存储？

• 私钥：必须加密存储。可以使用对称加密算法（如AES-256-GCM），用由强口令派生的密钥进行加密。私钥文件本身不应以明文形式存在于磁盘上。
• 公钥：可以公开分发。通常以PEM或DER格式存储。
• MATLAB中的存储：可以将密钥结构体保存为.mat文件，但务必对私钥文件进行加密。更好的做法是将私钥的n和d转换为十六进制或Base64字符串，然后写入一个受密码保护的文件。

5.4 常见错误与调试

1. 错误：“分组整数不小于模数n”：这是str_to_blocks函数中最常见的错误。原因是block_size计算有误，或者编码时整数表示超出了n的范围。确保256^block_size < n。在计算block_size时，使用floor(log2(n-1)/8)更安全。
2. 解密后出现乱码：99%的原因在于编码和解码过程不匹配。检查str_to_blocks和blocks_to_str函数，确保字节顺序（大端序/小端序）完全一致。一个有用的调试方法是打印出加密前和解密后的整数分组，进行逐组对比。
3. 模幂运算结果错误：对于大数，确认你使用了高精度整数类型（sym或vpi）。使用double类型计算mod(123456789^65537, 一个大数)肯定会溢出并得到错误结果。
4. 密钥生成速度慢：寻找大素数是最耗时的步骤。对于演示，可以适当降低bit_length。对于更快的素数测试，可以研究Miller-Rabin算法的MATLAB实现。
5. “e和φ(n)不互质”错误：当e（如65537）恰好与φ(n)有公因子时发生。虽然概率极低，但代码中必须有处理机制。我们的generate_rsa_keys函数中已经包含了一个回退逻辑，如果65537不互质，就寻找下一个奇数。

通过这个从零到一的MATLAB RSA实现与攻防分析项目，我们不仅得到了一个可以运行的加密工具，更重要的是，我们深入到了算法的每一个齿轮内部，理解了它为何转动，以及何处可能卡壳。安全是一个过程，而非一个产品。亲手实现、攻击、再加固的过程，是理解密码学精髓的最佳途径。当你下次再听到“RSA加密”时，脑海中浮现的将不再是一个模糊的概念，而是一行行清晰的代码、一个个需要谨慎处理的边界条件，以及一份对“安全”二字更深的敬畏。