應用於 RFID 的橢圓曲線密碼學處理器
https://www.boot.dev/blog/security/elliptic-curve-cryptography
Elliptic-Curve Crypto (ECC) Processor for RFID Applications(應用於 RFID 的橢圓曲線密碼學處理器),最直覺的方式是模擬硬體架構中的有限體運算單元(Finite Field Arithmetic Unit)與純量乘法(Scalar Multiplication, $Q = kP$)。
在 RFID(被動式無線射頻辨識)應用中,晶片受到極度嚴格的限制:極低的閘數(Gate Equivalent, GE,通常要求少於 10k–15k GE)、超低功耗以及極小的記憶體。因此,RFID 的 ECC 處理器通常採用 二元擴展體 $\mathbb{F}_{2^m}$(Binary Extension Field,加法只需 XOR 閘,無進位延遲)搭配 Montgomery Ladder 演算法(具備抗簡單功耗分析 SPA 的側信道攻擊防護能力)。
以下透過 Python + Tkinter 建立一個「RFID ECC 硬體架構模擬器」,視覺化呈現硬體暫存器(Registers)、有限體 ALU(FF-ALU)以及 Montgomery Ladder 的狀態機運作流程。
硬體架構核心設計(RFID 最佳化)
在執行程式前,先了解介面中模擬的關鍵硬體模組:
有限體 $\mathbb{F}_{2^m}$ 運算單元(FF-ALU):
加法(Addition):在 $\mathbb{F}_{2^m}$ 中,多項式加法等同於位元互斥或(
A ^ B),硬體上僅需一排 XOR 閘,在 1 個時脈週期內完成。平方(Squaring):在多項式基底下,平方運算只需在位元之間插入
0(Bit-interleaving),硬體連線即可完成,幾乎不消耗額外邏輯閘。乘法(Multiplication):採用 Bit-Serial(位元序列) 乘法器(如 MSB-first 演算法),每次處理 1 bit,雖然需要 $m$ 個週期,但能大幅縮減晶片面積以符合 RFID 限制。
Montgomery Ladder 控制器(FSM):
計算點乘 $Q = k \cdot P$ 時,無論私鑰 $k$ 的位元是
0或1,每個週期都會同時執行一次「點加(Point Addition)」與「倍點(Point Doubling)」。這確保了功耗軌跡(Power Trace)保持一致,防止攻擊者透過簡單功耗分析(SPA)竊取 RFID 標籤的私鑰。
極簡暫存器組(Register File):
僅使用 4 個主要座標暫存器($X_1, Z_1, X_2, Z_2$),在射影座標(Projective Coordinates)下運算,避免在迴圈中執行耗費資源的模反元素(Inversion)運算。
Python + Tkinter 視覺化模擬器程式碼
將以下程式碼儲存為 rfid_ecc_sim.py 並直接執行(無需安裝任何第三方套件,僅使用 Python 內建的 tkinter):
import tkinter as tk
from tkinter import ttk
class RFIDECCProcessorSim:
def __init__(self, root):
self.root = root
self.root.title("RFID Elliptic-Curve Crypto (ECC) Processor Simulator")
self.root.geometry("960x680")
self.root.configure(bg="#1e1e2e")
# 模擬參數:採用小型二元體 GF(2^5) 以利視覺化觀察
# 不可約多項式 f(x) = x^5 + x^2 + 1 (二進位: 100101 = 0x25)
self.m = 5
self.irred_poly = 0b100101
self.base_point_x = 0b01011 # 基底點 P 的 X 座標 (射影座標 X/Z)
self.private_key_k = 0b10110 # 5-bit 私鑰 k = 22
# 硬體狀態機變數
self.reset_state()
self.setup_ui()
self.draw_architecture()
self.update_ui_values()
def reset_state(self):
self.cycle = 0
self.bit_idx = self.m - 1
self.state = "IDLE"
self.active_bus = None
self.alu_op = "NOP"
# 硬體暫存器 (Projective Coordinates: X1, Z1, X2, Z2)
self.reg_X1 = self.base_point_x
self.reg_Z1 = 1
self.reg_X2 = self.gf_square(self.base_point_x)
self.reg_Z2 = self.base_point_x
# 閘數估算 (Gate Equivalent) 統計
self.ge_count = {
"FF-ALU (XOR/Shift)": 1450,
"Register File (4x m-bit)": 3200,
"Montgomery FSM": 980,
"IO / Control": 1120,
}
# ==========================================
# 有限體 GF(2^m) 硬體邏輯模擬 (Bit-level)
# ==========================================
def gf_add(self, a, b):
"""GF(2^m) 加法 = 位元 XOR (1 Clock Cycle, 極低功耗)"""
return a ^ b
def gf_square(self, a):
"""GF(2^m) 平方 = 插入 0 位元並模約化"""
res = 0
for i in range(self.m):
if (a >> i) & 1:
res |= 1 << (2 * i)
return self.gf_reduce(res)
def gf_mul(self, a, b):
"""GF(2^m) 位元序列乘法 (Bit-Serial Multiplier)"""
res = 0
for i in range(self.m):
if (b >> i) & 1:
res ^= a << i
return self.gf_reduce(res)
def gf_reduce(self, val):
"""模不可約多項式約化"""
for i in range(2 * self.m - 2, self.m - 1, -1):
if (val >> i) & 1:
val ^= self.irred_poly << (i - self.m)
return val & ((1 << self.m) - 1)
# ==========================================
# UI 介面建構
# ==========================================
def setup_ui(self):
style = ttk.Style()
style.theme_use("clam")
style.configure(
"TFrame", background="#1e1e2e"
)
style.configure(
"TLabel",
background="#1e1e2e",
foreground="#cdd6f4",
font=("Consolas", 10),
)
style.configure(
"Header.TLabel",
font=("Segoe UI", 14, "bold"),
foreground="#89b4fa",
)
style.configure("TButton", font=("Segoe UI", 10, "bold"), padding=6)
# 頂部標題列
top_frame = ttk.Frame(self.root, padding=10)
top_frame.pack(fill=tk.X)
ttk.Label(
top_frame,
text=(
"RFID Elliptic-Curve Crypto Processor Architecture (GF(2^m) &"
" Montgomery Ladder)"
),
style="Header.TLabel",
).pack(side=tk.LEFT)
# 主工作區分割:左側硬體方塊圖,右側暫存器與控制面板
main_frame = ttk.Frame(self.root, padding=10)
main_frame.pack(fill=tk.BOTH, expand=True)
self.canvas = tk.Canvas(
main_frame,
width=560,
height=440,
bg="#181825",
highlightthickness=1,
highlightbackground="#45475a",
)
self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 10))
right_panel = ttk.Frame(main_frame, width=350)
right_panel.pack(side=tk.RIGHT, fill=tk.Y)
# 1. 控制面板
ctrl_box = tk.LabelFrame(
right_panel,
text=" Processor Control ",
bg="#1e1e2e",
fg="#a6e3a1",
font=("Segoe UI", 10, "bold"),
padx=10,
pady=10,
)
ctrl_box.pack(fill=tk.X, pady=(0, 10))
key_frame = ttk.Frame(ctrl_box)
key_frame.pack(fill=tk.X, pady=5)
ttk.Label(key_frame, text="Private Key k (5-bit):").pack(side=tk.LEFT)
self.key_var = tk.StringVar(value=f"{self.private_key_k:05b}")
key_entry = ttk.Entry(
key_frame, textvariable=self.key_var, width=8, font=("Consolas", 11)
)
key_entry.pack(side=tk.RIGHT)
btn_frame = ttk.Frame(ctrl_box)
btn_frame.pack(fill=tk.X, pady=5)
ttk.Button(
btn_frame, text="Step Clock (單步時脈)", command=self.step_clock
).pack(side=tk.LEFT, expand=True, fill=tk.X, padx=(0, 4))
ttk.Button(btn_frame, text="Reset (重置)", command=self.reset_sim).pack(
side=tk.RIGHT, expand=True, fill=tk.X, padx=(4, 0)
)
# 2. 暫存器狀態檢視
reg_box = tk.LabelFrame(
right_panel,
text=" Hardware Registers (GF(2^5)) ",
bg="#1e1e2e",
fg="#f9e2af",
font=("Segoe UI", 10, "bold"),
padx=10,
pady=10,
)
reg_box.pack(fill=tk.X, pady=(0, 10))
self.reg_labels = {}
for reg_name in ["FSM State", "Clock Cycle", "Key Bit k[i]", "Reg X1", "Reg Z1", "Reg X2", "Reg Z2"]:
row = ttk.Frame(reg_box)
row.pack(fill=tk.X, pady=2)
ttk.Label(row, text=f"{reg_name}:").pack(side=tk.LEFT)
lbl = ttk.Label(row, text="-", foreground="#89dceb")
lbl.pack(side=tk.RIGHT)
self.reg_labels[reg_name] = lbl
# 3. RFID 晶片面積 (Gate Equivalent) 指標
ge_box = tk.LabelFrame(
right_panel,
text=" RFID Area & Power Metrics ",
bg="#1e1e2e",
fg="#f38ba8",
font=("Segoe UI", 10, "bold"),
padx=10,
pady=10,
)
ge_box.pack(fill=tk.X)
total_ge = sum(self.ge_count.values())
for k, v in self.ge_count.items():
row = ttk.Frame(ge_box)
row.pack(fill=tk.X, pady=1)
ttk.Label(row, text=k).pack(side=tk.LEFT)
ttk.Label(row, text=f"{v} GE").pack(side=tk.RIGHT)
ttk.Separator(ge_box, orient=tk.HORIZONTAL).pack(fill=tk.X, pady=5)
tot_row = ttk.Frame(ge_box)
tot_row.pack(fill=tk.X)
ttk.Label(
tot_row, text="Total Area (Target < 15k):", foreground="#a6e3a1"
).pack(side=tk.LEFT)
ttk.Label(
tot_row, text=f"{total_ge} GE", foreground="#a6e3a1"
).pack(side=tk.RIGHT)
# 底部執行日誌 (Execution Log)
log_frame = tk.LabelFrame(
self.root,
text=" Micro-Architecture Execution Log ",
bg="#1e1e2e",
fg="#cba6f7",
font=("Segoe UI", 10, "bold"),
padx=10,
pady=5,
)
log_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))
self.log_text = tk.Text(
log_frame,
height=6,
bg="#11111b",
fg="#cdd6f4",
font=("Consolas", 9),
state=tk.DISABLED,
)
self.log_text.pack(fill=tk.BOTH, expand=True)
def draw_architecture(self):
"""繪製 RFID ECC 處理器硬體方塊圖與資料匯流排"""
self.canvas.delete("all")
# 匯流排顏色邏輯 (依據當前 active_bus 高亮顯示)
bus_fsm_reg = "#f38ba8" if self.active_bus == "FSM_REG" else "#585b70"
bus_reg_alu = "#a6e3a1" if self.active_bus == "REG_ALU" else "#585b70"
bus_alu_reg = "#89b4fa" if self.active_bus == "ALU_REG" else "#585b70"
# 1. RF Front-End & Power Harvester (RFID 特有模組)
self.canvas.create_rectangle(
20, 20, 540, 65, fill="#313244", outline="#89dceb", width=2
)
self.canvas.create_text(
280,
42,
text="RF Front-End (13.56 MHz / UHF) & Energy Harvester (Ultra-Low Power)",
fill="#89dceb",
font=("Segoe UI", 9, "bold"),
)
# 2. Montgomery Ladder Controller (FSM)
self.canvas.create_rectangle(
20, 100, 230, 220, fill="#313244", outline="#cba6f7", width=2
)
self.canvas.create_text(
125,
125,
text="Montgomery Ladder FSM",
fill="#cba6f7",
font=("Segoe UI", 10, "bold"),
)
self.canvas.create_text(
125,
165,
text=f"State: {self.state}\nSPA Resistant\n(Constant Time)",
fill="#cdd6f4",
font=("Consolas", 9),
)
# 3. Minimal Register File (X1, Z1, X2, Z2)
self.canvas.create_rectangle(
310, 100, 540, 220, fill="#313244", outline="#f9e2af", width=2
)
self.canvas.create_text(
425,
120,
text="Projective Register File",
fill="#f9e2af",
font=("Segoe UI", 10, "bold"),
)
reg_str = (
f"X1: {self.reg_X1:05b} Z1: {self.reg_Z1:05b}\n"
f"X2: {self.reg_X2:05b} Z2: {self.reg_Z2:05b}"
)
self.canvas.create_text(
425, 170, text=reg_str, fill="#cdd6f4", font=("Consolas", 10)
)
# 4. Finite Field ALU (GF(2^m))
self.canvas.create_rectangle(
120, 290, 440, 410, fill="#313244", outline="#a6e3a1", width=2
)
self.canvas.create_text(
280,
315,
text="Finite Field ALU - GF(2^m)",
fill="#a6e3a1",
font=("Segoe UI", 10, "bold"),
)
self.canvas.create_text(
280,
360,
text=(
f"Active Op: {self.alu_op}\n"
"[XOR Adder] [Bit-Interleave Squarer] [Bit-Serial Multiplier]"
),
fill="#cdd6f4",
font=("Consolas", 9),
)
# 繪製連接線 (Data & Control Buses)
# FSM -> Registers
self.canvas.create_line(
230, 160, 310, 160, fill=bus_fsm_reg, width=3, arrow=tk.LAST
)
self.canvas.create_text(
270, 145, text="Ctrl", fill=bus_fsm_reg, font=("Consolas", 8)
)
# Registers -> ALU
self.canvas.create_line(
380, 220, 380, 290, fill=bus_reg_alu, width=3, arrow=tk.LAST
)
self.canvas.create_text(
415, 255, text="Operands", fill=bus_reg_alu, font=("Consolas", 8)
)
# ALU -> Registers (Write-back)
self.canvas.create_line(
200, 290, 200, 255, 340, 255, 340, 220, fill=bus_alu_reg, width=3, arrow=tk.LAST
)
self.canvas.create_text(
260, 243, text="Write-Back", fill=bus_alu_reg, font=("Consolas", 8)
)
# ==========================================
# 時脈步進邏輯 (模擬 Montgomery Ladder 迴圈)
# ==========================================
def step_clock(self):
try:
k_val = int(self.key_var.get(), 2)
self.private_key_k = k_val & ((1 << self.m) - 1)
except ValueError:
self.log("錯誤:私鑰 k 必須為 5 位元二進位字串 (例如 10110)")
return
if self.state == "DONE":
self.log("純量乘法 Q = kP 已完成!請按 Reset 重新開始。")
return
self.cycle += 1
if self.state == "IDLE":
self.state = "INIT"
self.active_bus = "FSM_REG"
self.alu_op = "LOAD_BASE_POINT"
self.log(
f"[Cycle {self.cycle}] 初始化:載入基底點 P(X={self.base_point_x:05b})"
" 至射影座標暫存器。"
)
elif self.state == "INIT":
self.state = "LADDER_STEP"
self.bit_idx = self.m - 2 # 從次高位元開始掃描
self.active_bus = "REG_ALU"
self.alu_op = "POINT_ADD_AND_DOUBLE"
self.log(
f"[Cycle {self.cycle}] 進入 Montgomery Ladder 迴圈,準備掃描私鑰位元。"
)
elif self.state == "LADDER_STEP":
if self.bit_idx >= 0:
k_bit = (self.private_key_k >> self.bit_idx) & 1
self.active_bus = "ALU_REG"
# 執行 Montgomery Ladder 核心運算 (固定執行相同運算量以防禦 SPA)
# 1. 點加 (Point Addition)
t1 = self.gf_mul(self.reg_X1, self.reg_Z2)
t2 = self.gf_mul(self.reg_X2, self.reg_Z1)
new_add_z = self.gf_square(self.gf_add(t1, t2))
new_add_x = self.gf_add(
self.gf_mul(self.base_point_x, new_add_z), self.gf_mul(t1, t2)
)
# 2. 倍點 (Point Doubling)
x_sq = self.gf_square(self.reg_X1 if k_bit == 0 else self.reg_X2)
z_sq = self.gf_square(self.reg_Z1 if k_bit == 0 else self.reg_Z2)
new_dbl_x = self.gf_add(self.gf_square(x_sq), self.gf_square(z_sq))
new_dbl_z = self.gf_mul(x_sq, z_sq)
if k_bit == 0:
self.reg_X1, self.reg_Z1 = new_dbl_x, new_dbl_z
self.reg_X2, self.reg_Z2 = new_add_x, new_add_z
self.alu_op = "P1=2*P1, P2=P1+P2"
else:
self.reg_X1, self.reg_Z1 = new_add_x, new_add_z
self.reg_X2, self.reg_Z2 = new_dbl_x, new_dbl_z
self.alu_op = "P1=P1+P2, P2=2*P2"
self.log(
f"[Cycle {self.cycle}] 處理 k[{self.bit_idx}] = {k_bit} ->"
f" 執行 {self.alu_op} (功耗恆定)"
)
self.bit_idx -= 1
else:
self.state = "AFFINE_CONV"
self.active_bus = "REG_ALU"
self.alu_op = "Z1_INVERSION (X1/Z1)"
self.log(
f"[Cycle {self.cycle}] 迴圈結束,執行最後一步射影轉仿射座標 (Z1"
" 模反元素計算)..."
)
elif self.state == "AFFINE_CONV":
self.state = "DONE"
self.active_bus = None
self.alu_op = "OUTPUT_READY"
self.log(
f"[Cycle {self.cycle}] 運算完成!產生 RFID 挑戰-回應驗證簽章 (X1 ="
f" {self.reg_X1:05b})。"
)
self.draw_architecture()
self.update_ui_values()
def reset_sim(self):
self.reset_state()
self.log_text.config(state=tk.NORMAL)
self.log_text.delete("1.0", tk.END)
self.log_text.config(state=tk.DISABLED)
self.draw_architecture()
self.update_ui_values()
self.log("系統已重置。")
def update_ui_values(self):
self.reg_labels["FSM State"].config(text=self.state)
self.reg_labels["Clock Cycle"].config(text=str(self.cycle))
k_str = f"k[{self.bit_idx}]" if self.bit_idx >= 0 else "Done"
self.reg_labels["Key Bit k[i]"].config(text=k_str)
self.reg_labels["Reg X1"].config(text=f"{self.reg_X1:05b} (0x{self.reg_X1:02X})")
self.reg_labels["Reg Z1"].config(text=f"{self.reg_Z1:05b} (0x{self.reg_Z1:02X})")
self.reg_labels["Reg X2"].config(text=f"{self.reg_X2:05b} (0x{self.reg_X2:02X})")
self.reg_labels["Reg Z2"].config(text=f"{self.reg_Z2:05b} (0x{self.reg_Z2:02X})")
def log(self, msg):
self.log_text.config(state=tk.NORMAL)
self.log_text.insert(tk.END, msg + "\n")
self.log_text.see(tk.END)
self.log_text.config(state=tk.DISABLED)
if __name__ == "__main__":
root = tk.Tk()
app = RFIDECCProcessorSim(root)
root.mainloop()




沒有留言:
張貼留言