Upgradable Runtime Monitoring for SoC

This course was developed as a MEST Micro-Certificate. MEST Micro-Certificates offer short, self-paced learning opportunities through focused training modules and webinars on specialized technical topics. Participants who successfully complete the program requirements earn a certificate of completion.

These programs are designed for U.S. citizens, including Department of War and other government personnel, government-affiliated employees, industry professionals, college students, and faculty.


Fault injection attacks are one of the most powerful hardware attack techniques, capable of corrupting computations, bypassing security checks, and extracting secret keys from cryptographic hardware. By deliberately inducing transient or permanent faults through clock/voltage glitching, electromagnetic pulses, or invasive methods, adversaries can exploit vulnerabilities in SoCs and IP cores. Understanding these attacks is essential for engineers and researchers developing secure systems, as they highlight the limits of traditional verification and the need for robust countermeasures. This certificate provides hands-on exposure to fault injection techniques, detection methods, security property development, and emulation-based vulnerability assessment, enabling learners to analyze and defend real-world hardware against such threats.

In this certificate course, students will learn how runtime monitoring can provide continuous and upgradable security protection for modern System-on-Chip (SoC) designs. The course covers security assets, threat models, runtime security policies, distributed Security Status Monitors (SSMs), and eFPGA-based policy enforcement. Students will apply these concepts to AES denial-of-service and information-leakage vulnerabilities and learn how reconfigurable eFPGA resources enable security policies to be updated after deployment. The course also introduces Large Language Model (LLM)-based automation for generating security policies, mapping those policies to Common Weakness Enumeration (CWE) entries, and translating high-level policies into hardware-observable monitoring events that can be implemented using SSM and eFPGA monitoring logic.

The Upgradable Runtime Monitoring of SoC micro-certificate introduces students to the principles, architectures, implementation techniques, and emerging AI-assisted methodologies used to continuously monitor System-on-Chip (SoC) designs for security violations during operation. Modern SoCs integrate processors, accelerators, memories, cryptographic components, peripherals, and third-party IPs into increasingly complex architectures. While conventional design-time verification and fixed security mechanisms can address known vulnerabilities before fabrication, they cannot easily respond to vulnerabilities or adversarial behaviors discovered after deployment. Hardware runtime monitoring addresses this limitation by continuously observing system behavior, enforcing security policies, and identifying violations such as unauthorized access, information leakage, malicious configuration, and denial-of-service conditions during actual operation.

This course emphasizes upgradable runtime monitoring, where security monitoring logic can evolve after fabrication to address newly discovered threats. Students learn how embedded FPGA (eFPGA) resources can provide reconfigurable security enforcement and how lightweight Security Status Monitors (SSMs) can observe security-relevant signals inside individual IP blocks that are not visible at the system bus. The combination of distributed SSMs and reconfigurable eFPGA-based enforcement provides local observability while allowing new policies and detection mechanisms to be deployed through updated eFPGA bitstreams without redesigning the physical SoC.

The micro-certificate is organized into the following four units:

  • Unit 1: Fundamentals of Hardware Runtime Monitoring: This unit establishes the theoretical foundation for runtime security monitoring in modern SoCs. Students examine why static, design-time security mechanisms are insufficient against zero-day vulnerabilities and evolving attacks, and learn how security assets, threat models, and security policies form the basis of runtime protection. The unit introduces major policy categories, including access restriction, data/control-flow restriction, HALT/Denial-of-Service, and secure-sequence policies. Students also examine the characteristics required of practical monitoring architectures, including scalability, sustainability, adaptability, observability, and distributability.
    The unit then compares different runtime-monitoring approaches and introduces an eFPGA/SSM-based architecture. Students learn why static synthesizable assertion monitors cannot be updated after fabrication and why purely centralized monitoring can suffer from routing congestion, timing-closure problems, and limited visibility into IP-internal activity. They examine how distributed SSMs provide local observability while a reconfigurable eFPGA performs policy enforcement, enabling security monitoring to evolve throughout the operational lifetime of the SoC.

  • Unit 2: Security Policy Definition and Upgradable eFPGA Implementation: This unit translates runtime-monitoring concepts into a practical implementation workflow using an AES cryptographic design containing deliberately introduced security vulnerabilities. Students examine a denial-of-service Trojan that prevents or delays the expected valid_out behavior and an information-leakage Trojan that exposes cipher-key information through the ciphertext output. These examples illustrate attacks against availability and confidentiality, respectively.
    Students define security policies that capture expected AES behavior, implement those policies in RTL, and use simulation and waveform analysis to determine whether violations occur. For the DoS example, the expected behavior requires valid_out to assert after the defined AES processing latency; the tutorial specifically demonstrates a 41-clock-cycle timing requirement.
    The unit then demonstrates how a security-policy implementation can be mapped into an eFPGA fabric. Using OpenFPGA, students work through eFPGA fabric and bitstream generation and learn why reconfigurable logic is valuable for runtime security: security policies can be modified after deployment as new vulnerabilities emerge rather than requiring a silicon redesign.

  • Unit 3: LLM-Assisted Automated Security Policy Generation and CWE Mapping: This unit introduces Large Language Models (LLMs) as automation tools for building runtime-monitoring specifications. Students learn how an LLM can combine SoC RTL, threat models, security-asset information, example policies, security-monitoring literature, and the Common Weakness Enumeration (CWE) database to automatically generate structured and implementable runtime security policies. Each policy can be assigned a policy category, associated with an observability mechanism, and mapped to relevant CWE identifiers.
    Students also learn the importance of prompt engineering and design grounding. The LLM examines actual RTL to understand interfaces and observability, while threat models and asset tables constrain the security scope. The generated structured output is parsed into a security-policy database that can feed subsequent runtime-enforcement workflows.

  • Unit 4: LLM-Assisted Automated Security Monitoring Event Generation:In this final unit, students extend this automation process by translating high-level security policies into hardware-observable monitoring events. A monitoring event specifies the signal values, patterns, or temporal sequences that indicate a likely policy violation. These events convert natural-language policy intent into implementation-ready conditions that can be realized using comparators, counters, and finite-state machines within SSMs and eFPGA policy checkers.
    Students learn to determine whether an event should be monitored at the system-bus level, inside an IP through an SSM, or in both locations. They also learn how RTL grounding resolves actual signal names and hierarchical paths and how observable proxies can be used when a desired internal signal is unavailable. The completed workflow connects security assets → security policies → monitoring events → runtime enforcement, providing an automated and upgradable approach to SoC security monitoring.

Format: Online, asynchronous
Platform: nanoHUB Learning Management System
Estimated Time: 8 hours
Level: Advanced Undergraduate/Graduate Student
Prerequisites:

  • Basic understanding of digital logic, RTL design, and System-on-Chip (SoC) architectures.

  • Introductory knowledge of hardware security concepts, including confidentiality, integrity, availability, security assets, and threat models.

  • Basic familiarity with Verilog/SystemVerilog and hardware simulation is recommended.

  • Basic Python programming is recommended for the LLM-based automation modules.

  • Prior exposure to security asset identification is particularly helpful for Units 3 and 4 because the automated policy-generation flow uses an asset table produced by an earlier asset-identification process.

  • Familiarity with FPGA/eFPGA concepts is helpful but not required.

Instructors: Professor Farimah Farahmandi, University of Florida & Professor Mark M. Tehranipoor, University of Florida


Course Objectives:

  1. Explain the need for hardware runtime monitoring and distinguish continuous runtime security enforcement from static, design-time verification approaches.

  2. Identify security assets, associated threat models, and appropriate runtime security policies for protecting confidentiality, integrity, and availability in SoC designs.

  3. Evaluate runtime-monitoring architectures according to scalability, sustainability, adaptability, observability, and distributability requirements.

  4. Define and implement security policies for AES DoS and information-leakage vulnerabilities and verify their operation using RTL simulation and waveform analysis.

  5. Explain and apply eFPGA-based upgradable security monitoring, including the generation of reconfigurable fabric and security-policy bitstreams.

  6. Explain the role of SSMs in providing local observability for security-relevant IP-internal activity that may not be visible at the system bus.

  7. Use LLM-based workflows to generate implementable runtime security policies from RTL, threat models, asset information, reference policies, and other security knowledge.

  8. Map generated security policies to appropriate CWE identifiers to connect runtime protection requirements to standardized hardware weakness classifications.

  9. Translate high-level security policies into signal-level monitoring events that specify violation conditions and temporal behavior.

  10. Determine the appropriate implementation scope for monitoring events—system-bus/eFPGA, IP-internal/SSM, or both—and understand how these events form an implementation-ready runtime-monitoring database.

 

Request Course Enrollment

To enroll in this course, you must have a nanoHUB account. Create one here: https://nanohub.org/register/
Request membership in the MEST group in nanoHUB at https://nanohub.org/groups/mest

Next
Next

Supply Chain Security