RISC-V 架构

RISC-V 是一种开源的精简指令集架构（ISA），由加州大学伯克利分校于 2010 年发起，现由 RISC-V 国际基金会维护

基本特征

位数：RV32（32位）、RV64（64位）、RV128（未来扩展）。常用的是 RV32/64

字节序：默认为小端（Little-Endian），也允许大端（非主流）

指令格式：定长 16 位（压缩指令）或 32 位（标准指令）。编码极为规整，字段位置几乎固定

模块化指令集：

• 基础整数指令集（I）：加减、逻辑、移位、分支、访存、系统调用

• 标准扩展：

  • M：乘除法

  • A：原子操作

  • F / D：单/双精度浮点

  • C：压缩指令（16 位，提高代码密度）

  • V：向量扩展（尚未完全冻结）

• 组合如 RV64IMAC 即为 64 位基础整数、乘除、原子、压缩指令

寄存器与调用约定

RISC-V 有 32 个通用寄存器（x0–x31），以及可选的浮点寄存器（f0–f31）。每个通用寄存器在 ABI 中有别名和用途

寄存器	ABI 名称	用途	调用者/被调用者保存
x0	zero	恒为 0	-
x1	ra	返回地址	调用者保存
x2	sp	栈指针	被调用者保存
x3	gp	全局指针	被调用者保存
x4	tp	线程指针	被调用者保存
x5–x7	t0–t2	临时寄存器	调用者保存
x8	s0 / fp	帧指针（可用作 s0）	被调用者保存
x9	s1	保存寄存器	被调用者保存
x10–x11	a0–a1	函数参数/返回值	调用者保存
x12–x17	a2–a7	函数参数	调用者保存
x18–x27	s2–s11	保存寄存器	被调用者保存
x28–x31	t3–t6	临时寄存器	调用者保存

指令格式与编码

RISC-V 的 32 位指令被分成 6 种基本格式（R、I、S、B、U、J），opcode 和 funct3/funct7 字段位置高度一致，反汇编时易于解析

• R-type（寄存器-寄存器）：ADD rd, rs1, rs2

• I-type（寄存器-立即数）：ADDI rd, rs1, imm12

• S-type（存储）：SW rs2, offset(rs1)

• B-type（分支）：BEQ rs1, rs2, offset

• U-type（上移立即数）：LUI rd, imm20、AUIPC rd, imm20（用于 PC 相对寻址）

• J-type（跳转）：JAL rd, offset

压缩指令（C 扩展）：16 位指令，仅操作常用寄存器（x8–x15），由最低 2 位非 11 标识。C.ADDI4SPN, C.LW, C.J 等。反汇编工具会自动处理

实战案例

IoT（RISC-V 架构 + XOR）

IDA 逆向，根据流程图一步一步来

main 函数用途：

• 调用 scanf 从标准输入读取字符串到全局缓冲区 str

• 调用 strlen 获取输入长度

• 若长度等于 20，则跳转到 loc_1018E 进入处理逻辑；否则顺序执行

main:
var_s0   =  0
var_s8   =  8
var_s10  = 10h
arg_0    = 18h

addi    sp, sp, -30h          ; 分配栈空间 0x30 字节
sd      ra, 18h+var_s10(sp)   ; 保存返回地址到 sp+0x10
sd      s0, 18h+var_s8(sp)    ; 保存 s0 到 sp+0x8
sd      s1, 18h+var_s0(sp)    ; 保存 s1 到 sp+0x0
addi    s0, sp, 18h+arg_0     ; 设置帧指针 s0 = sp + 0x18
lui     a5, %hi(str)          ; 加载 str 地址高20位
addi    a1, a5, %lo(str)      ; a1 = str 完整地址（scanf 第二个参数）
lui     a5, %hi(unk_1F3D0)    ; 加载格式字符串高20位
addi    a0, a5, %lo(unk_1F3D0); a0 = 格式字符串（scanf 第一个参数）
jal     scanf                 ; 调用 scanf
lui     a5, %hi(str)          ; 重新加载 str 地址
addi    a0, a5, %lo(str)      ; a0 = str
jal     strlen                ; 调用 strlen，返回值在 a0
mv      a4, a0                ; a4 = 字符串长度
li      a5, 0x14              ; a5 = 20
beq     a4, a5, loc_1018E     ; 如果长度等于 20 则跳转到 loc_1018E

loc_1018E 函数用途：

• 将局部变量 i 置零，然后跳到 loc_101F4

loc_1018E:
sw      zero, -24h(s0)       ; 将 0 存入 s0-0x24 处（局部变量初始化）
j       loc_101F4            ; 无条件跳转到 loc_101F4

loc_101F4 函数用途：

• 从栈上重新加载 i，调用 strlen 获得长度 20，用 bltu 比较，若 i < 20 则跳回 loc_10194（循环体），否则退出循环

• 实现一个 20 次迭代的 for 循环，用于逐字节处理输入字符串

loc_101F4:
lw      s1, -24h(s0)          ; s1 = i （从栈上局部变量加载）
lui     a5, %hi(str)          ; 加载 str 地址高 20 位
addi    a0, a5, %lo(str)      ; a0 = str （输入缓冲区）
jal     strlen                ; 调用 strlen(str)
mv      a5, a0                ; a5 = 字符串长度 (应为 20)
bltu    s1, a5, loc_10194     ; 如果 i < 长度则跳转到 loc_10194（循环体）
                              ; 否则顺序执行（退出循环）

该循环体对输入字符串 str 的每个字符 str[i] 进行如下操作：

• 读取 str[i]

• 从 xor 表中读取一个 32 位整数 xor[i]

• 计算 xor[i] ^ str[i]

• 从 __DATA_BEGIN__ 表中读取 expected[i]

• 比较 xor[i] ^ str[i] 与 expected[i]

loc_10194:
lui     a5, %hi(str)            ; a5 = str 的高 20 位地址
addi    a4, a5, %lo(str)        ; a4 = str 的完整地址
lw      a5, -24h(s0)            ; a5 = i （从栈上加载循环计数器）
add     a5, a5, a4              ; a5 = &str[i]
lbu     a5, 0(a5)               ; a5 = str[i]（无符号字节）
sext.w  a4, a5                  ; a4 = 将字节符号扩展为 32 位（实际仍为原值）
lui     a5, %hi(xor)            ; 加载 xor 表地址
addi    a3, a5, %lo(xor)        ; a3 = xor 表基址
lw      a5, -24h(s0)            ; a5 = i
slli    a5, a5, 2               ; a5 = i * 4 （因为 xor 表是 4 字节整数数组）
add     a5, a5, a3              ; a5 = &xor[i]
lw      a5, 0(a5)               ; a5 = xor[i] （32 位值）
xor     a5, a5, a4              ; a5 = xor[i] ^ str[i] （32 位异或，高 24 位为 0）
sext.w  a3, a5                  ; a3 = 异或结果（符号扩展，实际低位有效）
lui     a5, %hi(__DATA_BEGIN__) ; 加载 __DATA_BEGIN__ 表地址
addi    a4, a5, %lo(__DATA_BEGIN__) ; a4 = __DATA_BEGIN__ 基址
lw      a5, -24h(s0)            ; a5 = i
slli    a5, a5, 2               ; a5 = i * 4
add     a5, a5, a4              ; a5 = &__DATA_BEGIN__[i]
lw      a5, 0(a5)               ; a5 = __DATA_BEGIN__[i]
mv      a4, a3                  ; a4 = 异或结果
beq     a4, a5, loc_101EA       ; 如果 xor[i] ^ str[i] == __DATA_BEGIN__[i] 则跳转到 loc_101EA
                                 ; 否则顺序执行（可能走向失败路径）

提取 xor 表和 __DATA_BEGIN__ 的数据解密

# 已知的 xor 表与 expected 表（32 位整数数组）
xor_table = [
    159, 249, 383, 227, 56,
    326, 295, 468, 315, 321,
    364, 129, 236, 72, 444,
    141, 309, 392, 231, 377
]

expected = [
    249, 149, 286, 132, 67,
    286, 328, 390, 356, 264,
    345, 222, 191, 120, 483,
    200, 340, 507, 158, 260
]

# 计算密钥字节：低 8 位异或
key_bytes = [(x ^ e) & 0xFF for x, e in zip(xor_table, expected)]

# 转换为字节串并输出
key = bytes(key_bytes)
print("Key bytes:", key)

最后得到 flag{XoR_I5_S0_Easy}