2026年11月15日 星期日

應用於 RFID 的橢圓曲線密碼學處理器

應用於 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 最佳化)

在執行程式前,先了解介面中模擬的關鍵硬體模組:

  1. 有限體 $\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 限制。

  2. Montgomery Ladder 控制器(FSM):

    • 計算點乘 $Q = k \cdot P$ 時,無論私鑰 $k$ 的位元是 0 或 1,每個週期都會同時執行一次「點加(Point Addition)」與「倍點(Point Doubling)」。

    • 這確保了功耗軌跡(Power Trace)保持一致,防止攻擊者透過簡單功耗分析(SPA)竊取 RFID 標籤的私鑰。

  3. 極簡暫存器組(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()

沒有留言:

張貼留言

MIFARE DESFire對稱式加密演算法

 MIFARE DESFire對稱式加密演算法 MIFARE DESFire 採用的是 雙向挑戰-回應認證機制(Mutual Challenge-Response Authentication) ,並支援 3DES 與 AES-128 對稱式加密演算法 。透過 Python ...