Secure Unique ID Generation for FPGA Memory
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current field programmable gate array (FPGA) devices lack a mechanism to prevent unauthorized replication of unique IDs, making it difficult for manufacturers to track and verify the ownership of programmed logic devices.
Innovation Solution
Incorporating an encryption engine that generates a unique ID from plaintext input, which is stored in a non-volatile one-time-programmable memory accessible only through the encryption engine, ensuring the ID cannot be easily replicated on another device.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If a user-programmable non-volatile one-time-programmable memory is used to store an ID, then the FPGA user can program their own ID on to the part, but there is no mechanism which prevents someone else from repeating that same Serial ID on another part or circuit
Solution Approach 1:
An encryption engine is introduced as an intermediary component between the user and the memory. The encryption engine receives plaintext input from the user, encrypts it using a secret key, and writes the encrypted result to the one-time-programmable memory. This intermediary ensures that only the authorized user who possesses the secret key can generate the correct encrypted ID, preventing unauthorized replication while maintaining user programming capability.
2Reliability
If a manufacturer installs a unique ID on the FPGA, then the FPGA can be tracked, but the end user cannot program their own unique ID
Solution Approach 1:
The encryption engine serves multiple functions: it enables the manufacturer to install unique IDs for tracking purposes, allows end users to program their own unique IDs using their secret keys, and prevents unauthorized replication. This multi-functional design resolves the contradiction by making the system universally applicable to both manufacturer tracking and user programming requirements.
3Reliability
If an encryption engine is introduced to prevent ID replication, then the uniqueness of the ID is secured, but the device complexity increases
Solution Approach 1:
The encryption engine is implemented as a self-service component that uses the FPGA's existing cryptographic resources. The engine leverages the built-in encryption capabilities of modern FPGAs to perform ID generation and protection without requiring external security hardware or complex additional circuitry. This approach provides secure unique ID generation while minimizing the increase in device complexity.
Data Source
AI summary
Methods, circuits, and apparatus are provided an FPGA user, ASIC designer, or the like the ability to program a unique ID per each circuit into a memory, such as a non-volatile one-time programmable memory bank on an FPGA. This unique ID is secure such that no one else can replicate it on another part, thus keeping it unique to the user for which it was intended. An encryption engine receives plaintext and produces the unique ID that is stored in memory that is designed to only be writeable through the encryption engine. Thus, the FPGA/ASIC designer can track who is the customer they sold this part to or who the last authorized user is.