1. 项目概述：当AES遇上FPGA

如果你在嵌入式安全、高速数据处理或者硬件加速领域摸爬滚打过，一定对这两个词不陌生：AES和FPGA。AES，高级加密标准，是目前全球应用最广泛的对称加密算法，从你的HTTPS网页浏览到手机支付，背后都有它的身影。FPGA，现场可编程门阵列，则以其高度的并行性和可重构性，成为实现定制化硬件加速的利器。那么，当“软件世界”的加密王者AES，与“硬件世界”的灵活悍将FPGA结合，会碰撞出怎样的火花？这就是我们今天要深入探讨的“AES-FPGA项目”的核心。

简单来说，这个项目就是在FPGA芯片上，用硬件描述语言（如Verilog或VHDL）设计并实现一个完整的AES加密/解密引擎。它的目标绝非仅仅为了“实现功能”，而是追求极致的效率、吞吐率和低延迟。在软件中运行AES，需要CPU逐条执行指令，处理一轮轮的字节代换、行移位、列混合和轮密钥加。而在FPGA上，我们可以将这些操作全部“摊平”，设计成并行的数据通路，甚至通过流水线技术，让数据像在工厂流水线上一样，不同阶段同时处理多组数据。实测下来，一个优化良好的FPGA AES实现，其加密吞吐率轻松达到每秒数吉比特（Gbps）甚至更高，这是通用处理器难以企及的。

这个项目适合谁？首先是FPGA开发者或学习者，它是一个绝佳的练手项目，涵盖了状态机设计、时序约束、资源优化等核心技能。其次是嵌入式系统工程师或网络安全工程师，当你设计的设备需要高速、低功耗的数据加密，且CPU资源紧张时，一个独立的硬件加密IP核就是最优解。最后，对于任何对硬件加速和密码学硬件实现感兴趣的朋友，这都是一个能让你深入理解算法本质和硬件思维融合的经典案例。

2. AES-FPGA项目的核心设计思路与架构选型

动手之前，得先想清楚怎么干。在FPGA上实现AES，绝不是把C语言代码直译成Verilog那么简单。硬件设计有硬件的哲学，核心思路就八个字：空间换时间，并行换速度。

2.1 AES算法核心与硬件映射思考

AES-128算法（密钥长度128位）加密一轮的主要操作包括：SubBytes（字节代换）、ShiftRows（行移位）、MixColumns（列混合）和AddRoundKey（轮密钥加），共执行10轮（最后一轮略去MixColumns）。解密则是其逆过程。

在软件中，这些操作通常是顺序执行的。但在硬件里，我们的设计思路完全不同：

1. 查找表（LUT）化SubBytes：SubBytes的非线性变换是AES安全的基础，但其数学运算（在GF(2^8)上的求逆和仿射变换）直接硬件实现面积大、速度慢。因此，标准做法是预计算并存储S盒（Substitution Box）和逆S盒。在FPGA上，我们可以用Block RAM（BRAM）来存储这些256字节的查找表，实现单周期完成一个字节的替换。这是最经典的“以存储资源换取计算速度和逻辑简化”的策略。
2. 并行化与流水线：这是性能提升的关键。对于128位的数据块（16字节），SubBytes和ShiftRows可以天然地对16个字节并行操作。MixColumns虽然是对4字节列的操作，但我们可以设计一个组合逻辑电路，使其在一个时钟周期内完成一列（4字节）的变换，那么四列也就可以并行处理。更进一步，我们可以将一轮的四个操作（SubBytes, ShiftRows, MixColumns, AddRoundKey）设计成流水线的一级，让多组数据同时在流水线的不同阶段被处理，极大提高吞吐率。
3. 密钥扩展（Key Expansion）的时机：轮密钥可以在加密开始前全部预计算并存储起来，这样加密过程中直接读取即可，节省实时计算的时间，但会消耗额外的存储资源。另一种方案是实时计算，即每轮加密的同时计算下一轮的轮密钥，这需要设计一个并行的密钥扩展电路，对时序要求更高，但节省存储。在资源允许的情况下，预计算并存储是更稳妥和简单的选择，能确保加密主通路时序更优。

2.2 整体架构选型：迭代式 vs 流水线式

基于以上思路，通常有两种主流的FPGA AES实现架构：

架构一：迭代式（Iterative）架构这是最节省面积的方案。整个设计只有一个“加密轮”的硬件电路。加密时，同一个数据块被送入这个轮函数电路，执行一轮操作后，结果写回寄存器，然后控制逻辑（一个状态机）控制它再次进入轮函数，如此循环10次，完成加密。解密同理。

• 优点：逻辑资源（LUT、寄存器）消耗极少，面积最小。
• 缺点：吞吐率低，加密一个128位数据块需要至少10个时钟周期（加上控制开销可能更多），且无法同时处理多个数据块。
• 适用场景：对面积极端敏感、吞吐率要求不高的低成本、低功耗应用。

架构二：流水线式（Pipelined）架构这是我们本次项目详解的重点，也是追求高性能的选择。它将完整的10轮加密（或解密）展开，每一轮（或每几轮）作为流水线的一级（Stage）。数据从第一级流入，每个时钟周期都向前推进一级，同时新的数据可以流入第一级。经过固定的延迟（流水线深度，例如10个周期）后，第一个加密结果输出，之后每个时钟周期都能输出一个加密结果。

• 优点：吞吐率达到极致，理论上可达到时钟频率 * 128位。例如，在100MHz时钟下，吞吐率约为100e6 * 128 bit = 12.8 Gbps。
• 缺点：资源消耗巨大，是迭代式的近10倍。因为你需要实例化10套轮函数电路。同时，初始延迟（Latency）固定为流水线深度。
• 适用场景：高速网络加密、大数据流实时加密、加密存储控制器等对带宽要求极高的场合。

对于大多数学习和中高性能应用，我会推荐从迭代式架构入手，理解基本流程，然后再挑战部分流水线或全流水线架构。本次详解，我们将以迭代式架构作为基础框架进行解析，并在关键部分指出如何向流水线架构演进。

注意：选择架构前，一定要明确你的设计约束。是更看重面积（资源）还是速度（吞吐率）？FPGA设计本质上是在资源、速度和功耗之间做权衡的艺术。

3. AES-FPGA核心模块详解与Verilog实现要点

接下来，我们深入到代码层面，拆解AES-128加密的核心模块。我会用Verilog HDL来举例说明，这是目前工业界最主流的硬件描述语言之一。假设我们的目标是在一个迭代式架构中实现加密功能。

3.1 顶层模块（aes_top）与接口定义

首先，我们需要定义清晰的数据接口和控制信号。一个典型的AES加密模块顶层接口如下：

module aes128_encrypt_core ( input wire clk, // 系统时钟 input wire rst_n, // 低电平异步复位 input wire start_i, // 加密启动信号，高电平有效 input wire [127:0] plaintext_i, // 128位明文输入 input wire [127:0] key_i, // 128位初始密钥输入 output reg [127:0] ciphertext_o, // 128位密文输出 output reg ready_o, // 模块空闲/准备就绪信号 output reg done_o // 加密完成信号，高电平有效一个周期 );

• start_i：这是一个关键的控制信号。当外部电路准备好明文和密钥，并拉高start_i时，模块开始工作。
• ready_o：指示模块当前是否处于空闲状态，可以接收新的加密任务。在迭代式设计中，当模块正在执行加密时，ready_o应为低。
• done_o：当加密完成，密文有效时，此信号拉高一个时钟周期，通知外部电路可以取走ciphertext_o。

3.2 控制单元（Control Unit）与状态机设计

这是迭代式架构的大脑。我们需要一个状态机来协调加密的轮次和各个操作。一个简单的状态机可以设计如下：

localparam S_IDLE = 3'd0; // 空闲状态，等待启动 localparam S_KEYEXP = 3'd1; // 密钥扩展状态（若选择实时扩展） localparam S_ADDKEY = 3'd2; // 初始轮密钥加 localparam S_ROUND = 3'd3; // 执行标准轮（1-9轮） localparam S_FINAL = 3'd4; // 执行最终轮（第10轮，无MixColumns） localparam S_DONE = 3'd5; // 完成状态 reg [2:0] current_state, next_state; reg [3:0] round_counter; // 轮计数器，0-10

状态转移逻辑：

1. S_IDLE：当start_i为高且ready_o为高时，进入S_ADDKEY，同时将轮计数器清零，加载明文和密钥到内部寄存器。
2. S_ADDKEY：执行初始的AddRoundKey操作。完成后，进入S_ROUND，轮计数器加1。
3. S_ROUND：执行一轮完整的操作（SubBytes -> ShiftRows -> MixColumns -> AddRoundKey）。每完成一轮，检查round_counter。如果round_counter < 9，则继续留在S_ROUND，计数器加1；如果round_counter == 9，则进入S_FINAL。
4. S_FINAL：执行最后一轮操作（SubBytes -> ShiftRows -> AddRoundKey，无MixColumns）。完成后，进入S_DONE。
5. S_DONE：拉高done_o一个周期，并将密文输出到ciphertext_o。然后回到S_IDLE，拉高ready_o。

这个状态机清晰地勾勒出了加密的流程。在S_ROUND状态，我们需要一个子模块来执行每一轮的具体计算。

3.3 轮函数（Round Function）模块实现

轮函数是AES的核心计算单元。在迭代式设计中，我们只需要实例化一个轮函数模块，通过多路复用器（Mux）在每一轮将不同的数据（中间状态和轮密钥）送入它。

3.3.1 SubBytes的实现：S盒查找表

如前所述，我们使用查找表。可以定义一个ROM（用BRAM或寄存器数组实现）来存储S盒。

// 方式1：使用case语句综合成分布式RAM或逻辑（适用于小容量，但可能面积大） function [7:0] sub_bytes; input [7:0] byte_in; begin case (byte_in) 8'h00: sub_bytes = 8'h63; 8'h01: sub_bytes = 8'h7c; // ... 完整的256个映射 8'hff: sub_bytes = 8'h16; default: sub_bytes = 8'h00; endcase end endfunction // 方式2：更高效的是使用FPGA工具提供的IP核（如Xilinx的Block Memory Generator） // 或者使用预初始化的寄存器数组，在综合时推断为BRAM。 reg [7:0] sbox_rom [0:255]; initial begin $readmemh("sbox_contents.hex", sbox_rom); // 从文件加载S盒值 end // 使用时 wire [7:0] subbed_byte = sbox_rom[byte_in];

对于128位输入，我们需要16个并行的S盒查找实例。这可以通过生成16个相同的查找逻辑来实现。

3.3.2 ShiftRows的实现：字节重排

ShiftRows是简单的字节位置重排，不涉及计算，纯粹是连线（Wire）的重新连接。在Verilog中，这可以通过位拼接操作{}轻松完成。

// 输入：16字节（128位）数据，假设排列为 state[127:0] = {s0, s1, s2, ..., s15} // 其中s0是最高字节，s15是最低字节（具体顺序需与AES标准一致，这里仅为示例） wire [127:0] state_in; wire [127:0] state_after_shiftrows; // AES ShiftRows 操作（加密） // 行0不变，行1循环左移1字节，行2循环左移2字节，行3循环左移3字节。 // 假设state_in按列优先排列：s0 s4 s8 s12; s1 s5 s9 s13; s2 s6 s10 s14; s3 s7 s11 s15 assign state_after_shiftrows[127:120] = state_in[127:120]; // s0 assign state_after_shiftrows[119:112] = state_in[ 87: 80]; // s5 (原行1列1->行1列0) assign state_after_shiftrows[111:104] = state_in[ 47: 40]; // s10 assign state_after_shiftrows[103: 96] = state_in[ 7: 0]; // s15 // ... 以此类推，完成16个字节的重排。实际编码时需要仔细对照AES标准的状态矩阵排列。

这是一个纯组合逻辑，没有时钟延迟。

3.3.3 MixColumns的实现：GF(2^8)上的矩阵乘法

这是轮函数中最复杂的部分。它是对状态矩阵的每一列进行一个固定的线性变换。在硬件中，我们需要实现GF(2^8)上的乘法和加法（即异或）。乘法系数是固定的：{02}, {03}, {01}。我们可以通过查找表或组合逻辑实现xtime操作（即乘以{02}）。

一种高效的方法是预先计算并优化。MixColumns对一列（4字节）的操作可以展开为一系列xtime和异或操作。例如，对于结果列的第一个字节：S‘_0 = ({02} * S_0) ^ ({03} * S_1) ^ ({01} * S_2) ^ ({01} * S_3)

我们可以专门实现一个xtime模块：

function [7:0] xtime; input [7:0] a; begin xtime = {a[6:0], 1‘b0} ^ (8‘h1b & {8{a[7]}}); end endfunction

这个函数实现了乘以{02}：左移一位，如果移出的最高位是1，则结果再与{1b}异或（这是AES定义在GF(2^8)上的不可约多项式）。

然后，一列的MixColumns就可以用xtime和异或来实现：

wire [7:0] s0, s1, s2, s3; // 输入列的四个字节 wire [7:0] t0, t1, t2, t3; // 中间变量 wire [7:0] mc0, mc1, mc2, mc3; // 输出列的四个字节 assign t0 = xtime(s0); assign t1 = xtime(s1); assign t2 = xtime(s2); assign t3 = xtime(s3); assign mc0 = t0 ^ t1 ^ s1 ^ s2 ^ s3; // 等价于 (02*s0)^(03*s1)^(01*s2)^(01*s3) assign mc1 = s0 ^ t1 ^ t2 ^ s2 ^ s3; // (01*s0)^(02*s1)^(03*s2)^(01*s3) assign mc2 = s0 ^ s1 ^ t2 ^ t3 ^ s3; // (01*s0)^(01*s1)^(02*s2)^(03*s3) assign mc3 = t0 ^ s0 ^ s1 ^ s2 ^ t3; // (03*s0)^(01*s1)^(01*s2)^(02*s3)

这样，一个列的MixColumns可以在一个时钟周期内用组合逻辑完成。整个128位状态（4列）需要4个这样的模块并行工作。

3.3.4 AddRoundKey的实现：简单异或

这是最简单的部分，就是将当前的状态与对应的轮密钥进行按位异或。

assign state_after_addroundkey = state_before_addroundkey ^ round_key;

将以上四个部分按顺序（SubBytes -> ShiftRows -> MixColumns -> AddRoundKey）组合起来，就构成了一个完整的轮函数模块（最后一轮除外）。在迭代式架构中，这个模块的输入是上一轮的结果（或初始状态）和当前轮的轮密钥，输出是经过一轮加密后的状态。

3.4 密钥扩展（Key Expansion）模块

密钥扩展用于从初始密钥生成每一轮所需的轮密钥。它同样可以迭代实现。AES-128的密钥扩展算法相对直接，也是基于S盒和异或操作。我们可以设计一个密钥扩展状态机，或者在加密开始前，用一个单独的进程预先计算好所有11个轮密钥（包括初始轮密钥加用的那个），并存储在一个寄存器数组中。后者更简单，对加密主通路时序干扰小。

预计算密钥扩展的示例思路：

reg [127:0] round_key_reg [0:10]; // 存储11个轮密钥 integer i; // 使用一个always块，在复位后或密钥更新时，计算所有轮密钥 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin // 初始化... end else if (key_update) begin // 假设有一个密钥更新信号 round_key_reg[0] <= initial_key; for (i=1; i<=10; i=i+1) begin // 根据AES标准实现密钥扩展算法，计算round_key_reg[i] // 涉及对上一轮密钥最后4字节的S盒变换、与Rcon常数异或等操作 end end end

在加密过程中，状态机根据round_counter从round_key_reg中选取对应的轮密钥送入轮函数。

4. 从迭代到流水线：性能跃迁的关键改造

理解了迭代式架构，我们再来探讨如何将其改造为高性能的流水线式架构。这里的核心思想是将时间上的迭代展开为空间上的并排。

4.1 全流水线架构设计

在全流水线架构中，你需要实例化10个（对于AES-128）轮函数模块（第10轮是特殊的，没有MixColumns）。将它们首尾相连，每一级的输出寄存器连接到下一级的输入。

// 伪代码示意 wire [127:0] stage_out [0:10]; reg [127:0] stage_reg [0:10]; // 第0级：初始轮密钥加 assign stage_out[0] = plaintext_i ^ round_key[0]; always @(posedge clk) stage_reg[0] <= stage_out[0]; // 第1-9级：标准轮 genvar i; generate for (i=1; i<=9; i=i+1) begin : round_stages round_function_full u_round ( .clk(clk), .state_in(stage_reg[i-1]), .round_key(round_key[i]), .state_out(stage_out[i]) ); always @(posedge clk) stage_reg[i] <= stage_out[i]; end endgenerate // 第10级：最终轮 final_round_function u_final_round ( .clk(clk), .state_in(stage_reg[9]), .round_key(round_key[10]), .state_out(stage_out[10]) ); always @(posedge clk) ciphertext_o <= stage_out[10]; // 输出即为密文

在这个设计中，数据在每个时钟上升沿从上一级寄存器移动到下一级逻辑。经过10个时钟周期的初始延迟后，每个时钟周期都会有一个新的密文从末端输出。ready_o信号几乎可以一直为高（只要输入数据流不断），done_o信号变得不再需要，因为输出是持续有效的。

4.2 关键挑战与优化技巧

1. 时序收敛：流水线深度增加，关键路径变短（理论上关键路径只是一级轮函数的延迟），但实际布线延迟和时钟偏斜（Skew）会成为挑战。必须施加合理的时序约束（如create_clock,set_input_delay,set_output_delay），并可能需要进行流水线内部寄存器重定时（Retiming）来平衡各级延迟。
2. 资源消耗：资源消耗约为迭代式的10倍。需要仔细评估FPGA芯片的Slice/LUT、BRAM和DSP资源是否足够。优化方法包括：
   • 资源共享：对于MixColumns中的xtime操作，可以考虑在相邻级之间共享计算单元，但这会增加多路复用器和控制复杂度，可能得不偿失。
   • 使用专用硬件：一些高端FPGA的DSP Slice可以配置用于GF(2^8)运算，但通常AES的运算模式并不完全匹配DSP的整数乘加，需要评估效率。
   • S盒的BRAM共享：10个级联的S盒查找会消耗大量存储。一个巧妙的优化是，由于数据是流水通过的，可以只用一份S盒BRAM，但让10级流水线分时复用它们。这需要在每一级加入地址寄存器和数据寄存器，并精心设计访问调度，本质上是用时间换取了面积，但会略微增加每级的延迟。
3. 密钥供给：在全流水线中，每一级都需要对应的轮密钥。这意味着你需要同时提供11个轮密钥。因此，密钥扩展模块也必须能够在一个周期内输出所有轮密钥，或者提前计算好并存储在寄存器文件中。

实操心得：在实现全流水线AES时，我强烈建议先用高层次综合（HLS）工具或行为级描述快速建模，评估面积和性能。然后再手写RTL进行精细优化。同时，一定要编写完善的测试平台（Testbench），用标准测试向量（如NIST提供的）进行验证，并做大量的随机数据测试，确保功能百分百正确。硬件加密的一个小错误都是灾难性的。

5. FPGA实现中的常见问题、调试与性能评估

即使设计在仿真中完美无缺，烧录到FPGA后也可能遇到各种问题。这里分享一些踩过的坑和排查技巧。

5.1 功能验证与仿真

问题1：仿真结果与软件计算结果对不上。这是最常见的问题。排查步骤：

1. 检查字节序（Endianness）和位序：AES操作针对的是字节（8位）。确保你的数据输入、状态矩阵排列、S盒索引都与标准定义完全一致。一个字节内的高低比特位顺序也要注意。我习惯使用$display或$monitor在仿真中以十六进制格式打印中间状态，并与Python的pycryptodome库或在线AES计算器的结果逐轮对比。
2. 验证S盒内容：S盒的一个字节错误会导致整个加密结果面目全非。将你ROM中存储的S盒值完整打印出来，与标准值逐一核对。
3. 检查密钥扩展：密钥扩展错误会导致所有轮密钥错误。单独仿真密钥扩展模块，输出所有轮密钥与标准值对比。
4. 关注控制时序：状态机是否跳转正确？轮计数器是否在正确的时间点递增？start_i和done_o信号是否在预期的周期产生？使用波形查看器（如Vivado Simulator, ModelSim）仔细追踪这些控制信号。

问题2：时序仿真（Post-Synthesis / Post-Place & Route Simulation）失败。行为仿真通过，但布局布线后的仿真失败，通常意味着有时序违例（Setup/Hold Time Violation）。

1. 查看时序报告：综合和实现后，工具会生成详细的时序报告。重点关注WNS (Worst Negative Slack)和TNS (Total Negative Slack)。如果为负，说明有路径不满足时序要求。
2. 分析关键路径：时序报告会列出最差的几条路径。看看这些路径是否在你的AES设计逻辑中。常见的瓶颈可能在MixColumns的组合逻辑链太长，或者某级流水线的组合逻辑延迟过大。
3. 优化策略：
   • 增加流水线级数：如果MixColumns是关键路径，可以将其拆分成更小的组合逻辑块，中间插入寄存器（即增加流水线深度）。例如，将一列MixColumns的计算拆成两拍完成。
   • 寄存器重定时：在不改变设计功能的前提下，调整组合逻辑和寄存器之间的边界，平衡各级流水线的延迟。
   • 使用流水线平衡的S盒：如果S盒查找是关键路径（在使用LUT实现时可能发生），可以考虑将S盒查找也流水化，即用两个时钟周期完成，但这会改变整体流水线结构。
   • 放宽时钟频率：如果性能要求允许，降低设计的工作时钟频率是最直接的解决办法。

5.2 资源利用与优化

使用FPGA开发工具（如Vivado, Quartus）的综合报告，查看资源利用率。

问题3：上电后或运行时功能异常。

1. 未初始化的寄存器：确保所有寄存器在复位时都有明确的初始值。否则在FPGA上电配置后，它们可能处于随机状态，导致状态机卡死或输出错误。
2. 时钟和复位信号质量：使用示波器或逻辑分析仪检查供给FPGA的时钟是否干净、频率是否正确。复位信号是否满足FPGA要求的脉冲宽度和电平。
3. I/O约束错误：检查你的FPGA引脚约束文件（.xdc或.qsf）。确保明文、密钥、密文、控制信号被分配到了正确的FPGA引脚，并且电平标准（如LVCMOS3.3V）设置正确。
4. 同步问题：如果AES模块需要与外部异步电路（如CPU）通信，确保接口信号（如start_i,done_o）都经过了正确的同步处理（打两拍），避免亚稳态。

5.3 性能评估指标

设计完成后，如何评价你的AES-FPGA实现？

1. 吞吐率（Throughput）：最重要的指标。吞吐率 = 数据位宽 × 时钟频率 / 延迟周期数。
   • 对于迭代式：吞吐率 = 128 bits * f_clk / clock_cycles_per_block。假设加密一个块需要11个周期（1初始轮+9标准轮+1最终轮+控制开销），在100MHz下，吞吐率约为128 * 100e6 / 11 ≈ 1.16 Gbps。
   • 对于全流水线：吞吐率 = 128 bits * f_clk。因为每个周期输出一个块。在100MHz下，吞吐率就是12.8 Gbps。这是理论最大值，实际可能因后端瓶颈略低。
2. 延迟（Latency）：从输入第一个明文到输出对应密文所需的时钟周期数。迭代式约为11个周期，全流水线是固定的流水线深度（如10级）。
3. 资源效率：通常用吞吐率 / 面积来衡量，单位是 Mbps/Slice 或 Gbps/LUT。这有助于在不同实现方案之间做权衡比较。
4. 功耗：可以使用开发工具进行功耗估算。流水线设计由于寄存器翻转更频繁，动态功耗通常高于迭代式。

最后，我想分享一点个人体会。AES-FPGA项目是一个微缩的硬件系统设计，它强迫你从并发的、资源受限的硬件角度去思考一个经典的算法。从行为建模到RTL实现，从功能仿真到时序收敛，从资源评估到板上调试，完整走一遍这个流程，你对数字电路设计的理解会深刻得多。它不仅仅是实现了一个加密功能，更是锻炼了你解决复杂问题、在多重约束下进行优化折衷的能力。在实际项目中，你可能还需要考虑侧信道攻击防护（如隐藏功耗、电磁信息）、支持多种密钥长度（AES-192, AES-256）、或者将加密核封装成AXI-Stream接口以便于在SoC系统中集成，这些都是在这个基础项目之上可以继续深入探索的方向。