Method and system for generating and proving the unique identity of a device
By generating a unique identity seed in the device and combining it with PUF response and system state for dynamic trusted proof, the problem of easy cloning and hardware replacement of device identity is solved, realizing the absolute uniqueness of device identity and trusted state proof, thus improving device security.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- 山东三未信安信息科技有限公司
- Filing Date
- 2026-03-16
- Publication Date
- 2026-06-09
AI Technical Summary
Existing technologies suffer from problems such as easy cloning of device identities, lack of awareness of hardware replacement, and lack of trusted state proofs, resulting in insufficient device security.
A secure cryptographic chip is used to generate a unique identity seed for the device based on a PUF circuit and a cryptographic hash function, along with an intrinsic public key and private key. Dynamic and trusted proof is then achieved through a self-signed device credential and certificate system, combined with real-time PUF response and system status.
It achieves absolute uniqueness of device identity, prevents credential copying and hardware impersonation, supports devices in actively proving the trustworthiness of their hardware and software status, and improves device security.
Smart Images
Figure CN122179096A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of Internet of Things (IoT) device security technology, and more specifically to a method and system for generating and verifying the unique identity of a device. Background Technology
[0002] With the explosive growth of the Internet of Things (IoT) and smart unmanned devices, device identity security has become increasingly prominent. Traditional identity authentication schemes typically rely on keys or certificates pre-installed in the device's non-volatile memory. Attackers can physically access, extract, or clone these static credentials, thereby forging legitimate device identities to infiltrate networks, steal data, or launch attacks. Furthermore, existing solutions cannot effectively detect malicious acts such as the complete replacement of the hardware motherboard. Therefore, the industry urgently needs a fundamental solution that addresses the issue at the physical level, enabling device identities to be intrinsically generated, unclonable, and dynamically bound to the device's state.
[0003] The current solutions typically include: device authentication based on pre-set asymmetric certificates and simple identification authentication based on PUF responses.
[0004] Device authentication schemes based on pre-installed asymmetric certificates involve the device manufacturer pre-generating a pair of asymmetric cryptographic public and private keys for each device before it leaves the factory, and a centralized Certificate Authority (CA) issuing a device certificate for the public key. This certificate and corresponding private key are written to the device's storage unit. During network authentication, the device presents this certificate via a protocol such as TLS and completes a signature challenge based on the private key. The server verifies the certificate chain to authenticate the device. This method has the following drawbacks:
[0005] 1) The pre-set private key is stored on a general-purpose storage medium, which is vulnerable to physical probes, side-channel attacks or software vulnerabilities and can be stolen. Once leaked, it can be infinitely copied to other hardware to achieve large-scale identity forgery.
[0006] 2) Cryptographic identity is not necessarily related to the physical entity of the device. Attackers can directly replace the motherboard and pre-install legitimate credentials. The system cannot detect the hardware-level replacement, and the security boundary is virtually non-existent.
[0007] 3) It can only prove that the device "owns" the private key, but cannot prove whether the firmware, configuration and other software states currently running on the device are trustworthy or have not been tampered with.
[0008] A simple identification and authentication scheme based on PUF response utilizes a random pattern generated when the device's main processor's internal memory powers on as a weak PUF. During the registration phase, this value is read as the device identifier and recorded on the server. During the authentication phase, the device powers on again and provides this identifier value, which the server compares to perform authentication. This approach has the following drawbacks: 1) Weak PUF response has high noise and limited entropy, is easily affected by environmental interference, requires complex error correction, and may be cracked by modeling attacks.
[0009] 2) This scheme only uses the PUF response as a one-time or static identifier and does not transform it into a high-strength root key that can be used for full cryptographic operations. Its security level is low and it cannot be integrated into the standard public key infrastructure.
[0010] 3) This scheme is a passive comparison and cannot support the device to actively prove its hardware uniqueness and software integrity to the remote party.
[0011] Therefore, how to solve the core security problems in existing technologies, such as the ease with which device identities can be cloned, the lack of awareness of hardware replacements, and the lack of trusted state proofs, is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention
[0012] In view of the above problems, the present invention proposes a method and system for generating and verifying the unique identity of a device, so as to overcome the above problems or at least partially solve the above problems.
[0013] To achieve the above objectives, the present invention adopts the following technical solution: In a first aspect, the present invention provides a method for generating and verifying a unique device identity, comprising the following steps: During the device identity intrinsic initialization phase, the secure cryptographic chip generates a unique device identity seed based on the PUF circuit and cryptographic hash function; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. During the device registration phase, the device sends its self-signed device credential and public key to the designated device identity management platform. The device identity management platform verifies the signature value and extended information of the signed device credential. After successful verification, it uses the root certificate to issue a device identity certificate with validity period and permission attributes to the public key and distributes it to the device for storage. During the device operation phase, the verifier sends a newly generated true random number to the device as a challenge. The secure cryptographic chip inside the device uses the private key, the random number, and system status information to generate a proof signature, and sends the device identity certificate, system status information, and proof signature together to the verifier for verification.
[0014] Furthermore, the steps for generating a device's unique identity seed include: A pre-defined and fixed challenge C_base is applied to the PUF circuit through the secure firmware layer of the secure cryptographic chip; whereby the secure firmware layer is a trusted execution environment running inside the secure cryptographic chip. Obtain the raw response R_raw, process the raw response R_raw using a fuzz extractor to remove noise, and output the PUF key material K_puf; Read the unique chip identifier ID_chip stored in the security cryptographic chip; The PUF key material K_puf is mixed with the unique chip identifier ID_chip, and its digest is calculated using a cryptographic hash function to generate the final device unique identity seed Seed_device.
[0015] Furthermore, the formula for calculating the device's unique identity seed is: Seed_device = Hash(K_puf || ID_chip), where || represents a mixed operation and Hash represents a cryptographic hash function; the final device unique identity seed Seed_device is stored in the protected area of the cryptographic security chip and is never output.
[0016] Furthermore, the steps for generating self-signed device credentials include: Using the device's unique identity seed Seed_device as a deterministic random entropy source, an asymmetric cryptographic key generation algorithm is invoked to generate a unique public-private key pair (SK_device, PK_device) inside the secure cryptographic chip. Here, PK_device is the public key, SK_device is the private key, and the private key SK_device is permanently protected by the hardware of the secure cryptographic chip. The secure cryptographic chip uses its private key SK_device to issue a self-signed device credential for its public key PK_device. The self-signed device credential Cert_self is represented as: Cert_self = Cert_self_Content || (r,s), where Cert_self_Content is the content part, which contains the public key PK_device and extended information of the unique chip identifier ID_chip; (r,s) is the signature value, where r and s are both integers.
[0017] Furthermore, during the device network registration phase, the process by which the device identity management platform verifies the signature value of the signed device credential Cert_self includes: Extract the content portion Cert_self_Content and the signature value (r,s) from the self-signed device credential Cert_self. Calculate a new signature value r' on the extracted content portion Cert_self_Content using the public key PK_device. If r' = r, the signature is valid, indicating that the content portion Cert_self_Content has not been tampered with and was indeed signed using the private key corresponding to the current public key PK_device.
[0018] Furthermore, during the device registration phase, the process by which the device identity management platform verifies the extended information of the signed device credential Cert_self includes: Extract the content portion Cert_self_Content from the self-signed device credential Cert_self, parse the Extensions field in the content portion Cert_self_Content, extract the ID_chip_hash extension item from the Extensions field, and obtain the hash value of the unique chip identifier ID_chip; Based on the pre-stored range of valid chip IDs or through other secure channels, the device ID information is obtained and compared with the parsed ID_chip_hash extension. At the same time, it is verified whether the ID_chip_hash extension and other custom fields in the Extensions field conform to the expected format. If the comparison passes and the format is as expected, the extended information of the signing device credential Cert_self is valid.
[0019] Furthermore, during the device operation phase, the random number is forwarded to the secure cryptographic chip through the device-side service module, requesting the generation of a trusted certificate, and the secure cryptographic chip performs the certificate signature generation.
[0020] Furthermore, during the device operation phase, the steps for generating the signature include: The secure cryptographic chip rereads the PUF circuit's response to the challenge C_base and generates the current device unique identity seed Seed_device_current; The secure cryptographic chip or device's main processor collects the system state information, State_info, that needs to be proven. The secure cryptographic chip uses the private key SK_device to digitally sign the joint hash value of the random number Nonce and the system state information State_info to generate a proof signature Proof_Sig, which is represented as: Proof_Sig = Sign(SK_device, Hash(Nonce || State_info)), where Sign represents the signature operation.
[0021] Furthermore, after receiving the device identity certificate Cert_device, system status information State_info, and proof signature Proof_Sig, the verifier performs the following verification: Verify the validity period of the device identity certificate and the validity of the issuance chain; use the public key PK_device encapsulated in the device identity certificate Cert_device to verify the validity of the proof signature Proof_Sig.
[0022] Secondly, the present invention provides a device unique identity generation and trusted authentication system, which employs the method described above, including: The device identity intrinsic initialization module is used to generate a unique device identity seed based on PUF circuit and cryptographic hash function during the device identity intrinsic initialization stage; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. The identity registration and credential issuance module is used during the device network registration phase to send the device's self-signed device credential and public key to the designated device identity management platform to verify the signature value and extended information of the signed device credential. After successful verification, the root certificate of the device identity management platform is used to issue a device identity certificate with validity period and permission attributes to the public key and then the certificate is issued to the device. The active verification module is used during the device operation phase to send a newly generated true random number to the device as a challenge by the verifier. This enables the security cryptographic chip inside the device to use the private key, the random number, and system status information to generate a verification signature. The device identity certificate, system status information, and verification signature are then sent to the verifier for verification.
[0023] As can be seen from the above technical solution, compared with the prior art, the present invention has the following beneficial effects: 1. This invention deeply integrates the inherent physical characteristics of dedicated hardware PUF with the chip's unique identifier, generates a stable device identity seed through cryptographic processing, and uses this seed to generate a public-private key pair in a secure hardware environment, constructing a unified root of trust that simultaneously covers identity authentication, hardware binding, and state proof, ensuring that the identity of each device and each chip is absolutely unique, fundamentally eliminating credential duplication and hardware impersonation.
[0024] 2. This invention upgrades one-time identity authentication to dynamic trusted proof that combines real-time PUF response and system status, effectively defending against attacks that static authentication cannot handle, such as firmware tampering and hardware replacement. Attached Figure Description
[0025] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.
[0026] Figure 1 This is a flowchart of the device unique identity generation and trusted verification method provided in this embodiment of the invention; Figure 2This is a flowchart of the device identity intrinsic initialization phase provided in an embodiment of the present invention; Figure 3 This is a flowchart of the device network access registration stage provided in an embodiment of the present invention; Figure 4 This is a flowchart of the device operation phase provided in an embodiment of the present invention. Detailed Implementation
[0027] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.
[0028] like Figure 1 As shown in the figure, this invention discloses a method for generating and verifying a device's unique identity, including the following steps: S1. During the device identity intrinsic initialization phase, the secure cryptographic chip generates a unique device identity seed based on the PUF circuit and cryptographic hash function; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. S2. During the device registration phase, the device sends its self-signed device credential and public key to the designated device identity management platform. The device identity management platform verifies the signature value and extended information of the signed device credential. After successful verification, it uses the root certificate to issue a device identity certificate with validity period and permission attributes to the public key and distributes it to the device for storage. S3. During the device operation phase, the verifier sends a newly generated true random number to the device as a challenge. The security cryptographic chip inside the device uses the private key, the random number, and the system status information to generate a proof signature, and sends the device identity certificate, system status information, and proof signature together to the verifier for verification.
[0029] The hardware used in this invention includes a hardware security root, a security firmware layer, a device-side service module, and a verification server. The hardware security root is a secure cryptographic chip that integrates a dedicated, highly stable PUF circuit (such as a ring oscillator PUF or an arbiter PUF) and a unique identifier. This chip has a protected storage area and a cryptographic operation engine.
[0030] The secure firmware layer is a trusted execution environment running inside the secure cryptographic chip, implementing PUF driver, fuzzy extraction, cryptographic algorithms, key management, and proof protocol logic.
[0031] The device-side service module is an agent program running on the device's main processor. It acts as a bridge between the secure cryptographic chip and the external network world, and is responsible for protocol encapsulation and communication.
[0032] The verification server is a remote management platform or peer device with certificate issuance and verification capabilities. It is responsible for initiating challenges, verifying credentials, and managing the device identity lifecycle.
[0033] The following is a further explanation of each of the above steps.
[0034] S1. Device identity intrinsic initialization phase, i.e. when leaving the factory or powering on for the first time, specifically includes PUF activation and seed generation, as well as the steps of creating intrinsic key pairs and self-authentication credentials.
[0035] Among them, such as Figure 2 As shown, the PUF activation and seed generation steps include: 1a. When the secure cryptographic chip is powered on, a preset and fixed challenge C_base is applied to the PUF circuit through the secure firmware layer; whereby the secure firmware layer is a trusted execution environment running inside the secure cryptographic chip. 1b. Obtain the original response R_raw, and use a fuzz extractor to process the original response R_raw to eliminate noise and output a stable, high-entropy PUF key material K_puf; 1c. Read the unique chip identifier ID_chip stored in the security password chip; 1d. Perform a mixing operation on the PUF key material K_puf and the unique chip identifier ID_chip, and use a cryptographic hash function to calculate its digest to generate the final device unique identity seed Seed_device. The calculation formula for the device unique identity seed is: Seed_device = Hash(K_puf || ID_chip), where || represents the mixing operation, which can be a mixed concatenation operation, and Hash represents the cryptographic hash function. The final device unique identity seed Seed_device is stored in the protected area of the cryptographic security chip and is never output.
[0036] The fuzzy extractor is a cryptographic tool that stably extracts a completely identical, uniformly random key from non-perfectly consistent original data containing "noise" or "errors." The main operations include information reconciliation and privacy amplification. In the information reconciliation stage, since environmental factors may cause bit flips in the PUF response, error correction coding techniques are used to eliminate noise and recover the original stable response R_recovered. In the privacy amplification stage, the recovered stable response R_recovered is input into a cryptographic hash function (preferably SM3) to extract high-entropy key material K_puf, ensuring that the output key material K_puf has a uniform distribution and high cryptographic strength.
[0037] The steps for creating endogenous key pairs and self-authenticating credentials include: 1e. Using the device's unique identity seed Seed_device as a deterministic random entropy source, an asymmetric cryptographic key generation algorithm is invoked to generate a unique public-private key pair (SK_device, PK_device) inside the secure cryptographic chip. Here, PK_device is the public key and SK_device is the private key. The private key SK_device is permanently protected by the hardware of the secure cryptographic chip and cannot be read or exported.
[0038] Taking the SM2 algorithm (China's national cryptographic standard) as an example, the process of generating public and private keys is as follows: Determine the source of random entropy: Use the device's unique identity seed Seed_device as the seed for the deterministic random number generator, and call the key generation function specified in the SM2 standard.
[0039] Generate a private key: SK_device = H(Seed_device || Counter) mod n; where H is the cryptographic hash function (SM3 is preferred), Counter is a counter that increments from 1 (a fixed value such as 1 can be used), and n is the elliptic curve base point order of the SM2 algorithm. To ensure that the private key is in the range [1, n-2], Counter can be incremented cyclically until the condition is met.
[0040] Calculate the public key: PK_device = SK_device × G; where G is the base point of the SM2 elliptic curve, and the operation is an elliptic curve dot product.
[0041] 1f. The secure cryptographic chip uses its private key SK_device to issue a self-signed device certificate for its public key PK_device. The self-signed device certificate Cert_self is represented as: Cert_self = Cert_self_Content || (r,s), where Cert_self_Content is the content part, which contains the public key PK_device and extended information of the unique chip identifier ID_chip; (r,s) is the signature value, where r and s are both integers.
[0042] The act of signing the corresponding public key and related information using a private key is called self-signing. There are various algorithms, including RSA, ECC, and SM2. For details, refer to the generation process of the self-signed device credential Cert_self, which follows the digital certificate signing process. Taking the Chinese national cryptographic SM2 signature algorithm as an example, the specific process includes: Construct the data to be signed: Cert_self_Content = Version || SerialNumber || Issuer || Validity || Subject || SubjectPublicKeyInfo(PK_device) || Extensions; Among them, Extensions contains extended information such as the hash value of ID_chip, SubjectPublicKeyInfo indicates the encapsulation of the public key, Version indicates the version, SerialNumber indicates the serial number, Issuer indicates the issuer, Validity indicates the validity period, and Subject indicates the subject.
[0043] Calculate the hash value of the data to be signed: H = SM3(Cert_self_Content).
[0044] SM2 signing is performed using the private key SK_device. The SM2 signing algorithm outputs a signature value (r, s), where r and s are 256-bit integers. The signing process is as follows: (x1, y1) = k×G, where k is a random number or a deterministic random number; r = (x1 + H) mod n; s = ((1 + SK_device) (-1) (k - r ×SK_device)) mod n; The signature result is Signature = (r, s) Finally, assemble the complete self-signed device certificate: Cert_self = Cert_self_Content ||Signature.
[0045] During verification, the verifier uses the public key PK_device to perform the SM2 signature verification algorithm on the Cert_self_Content part of the signature and the signature (r, s) to confirm the validity of the signature.
[0046] S2, Device registration stage, such as Figure 3 As shown, it includes: 2a. The device is connected to the designated device identity management platform.
[0047] 2b. The device sends its self-signed device credential Cert_self and public key PK_device to the device identity management platform.
[0048] 2c. The device identity management platform verifies the signature of Cert_self and checks its extended information. Successful verification means the platform recognizes that the public key originates from a private key generated by unique hardware (PUF + ID_chip).
[0049] In this embodiment, the process of verifying Cert_self by the device identity management platform includes two levels: signature validity verification and extended information verification.
[0050] The signature validity verification uses the SM2 signature verification algorithm, and the verification process includes: 1) Separate the content portion Cert_self_Content and the signature value (r,s) from the self-signed device credential Cert_self; 2) Calculate H' = SM3(Cert_self_Content).
[0051] 3) Execute the SM2 signature verification algorithm: Verify whether (r, s) is in the range [1, n-1]. Calculate t = (r + s) mod n; Calculate (x1', y1') = s × G + t × PK_device; Calculate r' = (x1' + H') mod n; 4) Verify whether r' is equal to r. If r' = r, the signature is valid, indicating that the content part Cert_self_Content has not been tampered with and is indeed signed by the private key corresponding to the current public key PK_device.
[0052] The process by which the device identity management platform verifies the extended information of the signed device credential Cert_self includes: 1) Extract the content part Cert_self_Content from the self-signed device certificate Cert_self, parse the Extensions field in the content part Cert_self_Content, extract the ID_chip_hash extension item from the Extensions field, and obtain the hash value of the unique chip identifier ID_chip; 2) Obtain the device ID information based on the pre-stored range of valid chip IDs or through other secure channels, compare it with the parsed ID_chip_hash extension, and verify whether the ID_chip_hash extension and other custom fields in the Extensions field conform to the expected format; 3) If the comparison passes and the format is as expected, the extended information of the signing device credential Cert_self is valid.
[0053] The verification passes only if the signature value and extended information of the signing device credential Cert_self both meet the conditions.
[0054] 2d. The platform uses its root certificate to issue a formal device identity certificate, Cert_device, with validity period and permission attributes for PK_device, and securely distributes it to the device storage.
[0055] S3, Equipment operation phase, such as Figure 4 As shown, it specifically includes: 3a. When a device needs to connect to the authenticator (service platform or peer device) to establish a secure session, the authenticator sends a newly generated true random number (nonce) to the device as a challenge.
[0056] 3b. The device-side service module forwards this challenge to the secure cryptographic chip, requesting the generation of a trusted proof.
[0057] 3c. Secure cryptographic chip execution proof signature generation, specifically including: 1) Real-time reconstruction of identity seed: Reread the current response of the PUF circuit to challenge C_base, repeat the PUF activation and seed generation steps in S1, and generate the identity seed Seed_device_current at the current moment. This step ensures that the proof is bound to the current hardware state in real time.
[0058] 2) Collect runtime state: The secure cryptographic chip or device main processor collects the system state information State_info that needs to be proven, including bootloader hash, key application metrics, security version number, etc.
[0059] 3) Generate proof signature: The secure cryptographic chip uses the private key SK_device to digitally sign the joint hash value of the random number Nonce and the system state information State_info to generate a proof signature Proof_Sig, which is represented as: Proof_Sig = Sign(SK_device, Hash(Nonce || State_info)), where Sign represents the signature operation.
[0060] 3d. The device sends the official certificate Cert_device, system status information State_info, and proof signature Proof_Sig to the verifier.
[0061] 3e. After receiving the device identity certificate Cert_device, system status information State_info, and proof signature Proof_Sig, the verifier performs the following verification: Verify the validity period of the device identity certificate and the validity of the issuance chain; use the public key PK_device encapsulated in the device identity certificate Cert_device to verify the validity of the proof signature Proof_Sig.
[0062] Successful verification signifies triple confirmation: ① The device possesses the private key corresponding to the legitimate certificate; ② This private key is generated by a unique hardware PUF feature at the current moment (resistant to hardware replacement); ③ The device is in the trusted software state described by State_info, resistant to software tampering.
[0063] In another embodiment, the present invention also provides a device unique identity generation and trusted verification system, which employs the method described above, including: The device identity intrinsic initialization module is used to generate a unique device identity seed based on PUF circuit and cryptographic hash function during the device identity intrinsic initialization stage; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. The identity registration and credential issuance module is used during the device network registration phase to send the device's self-signed device credential and public key to the designated device identity management platform to verify the signature value and extended information of the signed device credential. After successful verification, the root certificate of the device identity management platform is used to issue a device identity certificate with validity period and permission attributes to the public key and then the certificate is issued to the device. The active verification module is used during the device operation phase to send a newly generated true random number to the device as a challenge by the verifier. This enables the security cryptographic chip inside the device to use the private key, the random number, and system status information to generate a verification signature. The device identity certificate, system status information, and verification signature are then sent to the verifier for verification.
[0064] Next, the method of the present invention will be further described using a specific scenario.
[0065] The scenario is: a certain unmanned device provides a secure identity solution based on PUF and password.
[0066] The hardware consists of a password security chip integrated into the flight control board of each unmanned device. This chip has built-in PUF capabilities and a unique serial number.
[0067] Implementation process: (1) Production line initialization: After the unmanned equipment is assembled and powered on, the security chip is automatically activated. Its PUF circuit responds to fixed stimuli and obtains the PUF key material K_puf after fuzzy extraction. The security chip reads its own unique serial number SN and uses the national cryptographic SM3 algorithm to calculate the device's unique identity seed Seed_device = SM3(K_puf || SN). Based on this seed, a national cryptographic SM2 key pair is generated in the security chip, and a self-signed certificate Cert_self containing the hash value of SN is generated.
[0068] (2) Network registration: The unmanned device connects to the "Security Operation Platform" for the first time. The platform receives its self-signed certificate Cert_self and SM2 public key, and after verification, issues an SM2 device certificate Cert_device for it.
[0069] (3) Daily Task Authentication: The unmanned device needs to authenticate with the warehouse console daily. The console sends a random challenge Nonce. The unmanned device chip reads the current RO PUF response in real time, combines it with the SM3 hash value of the current firmware version FW, and signs SM3(Nonce || SM3(FW)) using the internal SM2 private key. The unmanned device sends the device certificate, firmware version, and proof signature.
[0070] (4) Verification and Authorization: The console verifies the certificate chain and signature. Success proves that: ① This is a legitimate unmanned device of the company; ② Its motherboard has not been replaced (PUF response matches); ③ It is running approved firmware.
[0071] (5) Handling violations: If the firmware of an unmanned device is tampered with to an unauthorized version, it will cause the signature verification to fail, the console will immediately issue an alarm and refuse service, triggering the security audit process.
[0072] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.
[0073] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims
1. A method for generating and verifying a unique device identity, characterized in that, Includes the following steps: During the device identity intrinsic initialization phase, the secure cryptographic chip generates a unique device identity seed based on the PUF circuit and cryptographic hash function; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. During the device registration phase, the device sends its self-signed device credential and public key to the designated device identity management platform. The device identity management platform verifies the signature value and extended information of the signed device credential. After successful verification, it uses the root certificate to issue a device identity certificate with validity period and permission attributes to the public key and distributes it to the device for storage. During the device operation phase, the verifier sends a newly generated true random number to the device as a challenge. The secure cryptographic chip inside the device uses the private key, the random number, and system status information to generate a proof signature, and sends the device identity certificate, system status information, and proof signature together to the verifier for verification.
2. The method for generating and verifying a device's unique identity as described in claim 1, characterized in that, The steps for generating a device's unique identity seed include: A pre-defined and fixed challenge C_base is applied to the PUF circuit through the secure firmware layer of the secure cryptographic chip; whereby the secure firmware layer is a trusted execution environment running inside the secure cryptographic chip. Obtain the raw response R_raw, process the raw response R_raw using a fuzz extractor to remove noise, and output the PUF key material K_puf; Read the unique chip identifier ID_chip stored in the security cryptographic chip; The PUF key material K_puf is mixed with the unique chip identifier ID_chip, and its digest is calculated using a cryptographic hash function to generate the final device unique identity seed Seed_device.
3. The method for generating and verifying a unique device identity as described in claim 2, characterized in that, The formula for calculating the device's unique identity seed is: Seed_device = Hash(K_puf || ID_chip), where || represents mixed operation and Hash represents the cryptographic hash function; the final device unique identity seed Seed_device is stored in the protected area of the cryptographic security chip and is never output.
4. The method for generating and verifying a unique device identity as described in claim 1, characterized in that, The steps for generating a self-signed device certificate include: Using the device's unique identity seed Seed_device as a deterministic random entropy source, an asymmetric cryptographic key generation algorithm is invoked to generate a unique public-private key pair (SK_device, PK_device) inside the secure cryptographic chip. Here, PK_device is the public key, SK_device is the private key, and the private key SK_device is permanently protected by the hardware of the secure cryptographic chip. The secure cryptographic chip uses its private key SK_device to issue a self-signed device credential for its public key PK_device. The self-signed device credential Cert_self is represented as: Cert_self = Cert_self_Content || (r,s), where Cert_self_Content is the content part, which contains the public key PK_device and extended information of the unique chip identifier ID_chip; (r,s) is the signature value, where r and s are both integers.
5. The method for generating and verifying a device's unique identity as described in claim 4, characterized in that, During the device registration phase, the process by which the device identity management platform verifies the signature value of the signed device credential Cert_self includes: Extract the content portion Cert_self_Content and the signature value (r,s) from the self-signed device credential Cert_self. Calculate a new signature value r' on the extracted content portion Cert_self_Content using the public key PK_device. If r' = r, the signature is valid, indicating that the content portion Cert_self_Content has not been tampered with and was indeed signed using the private key corresponding to the current public key PK_device.
6. The method for generating and verifying a unique device identity as described in claim 4, characterized in that, During the device registration phase, the process by which the device identity management platform verifies the extended information of the signed device credential Cert_self includes: Extract the content portion Cert_self_Content from the self-signed device credential Cert_self, parse the Extensions field in the content portion Cert_self_Content, extract the ID_chip_hash extension item from the Extensions field, and obtain the hash value of the unique chip identifier ID_chip; Based on the pre-stored range of valid chip IDs or through other secure channels, the device ID information is obtained and compared with the parsed ID_chip_hash extension. At the same time, it is verified whether the ID_chip_hash extension and other custom fields in the Extensions field conform to the expected format. If the comparison passes and the format is as expected, the extended information of the signing device credential Cert_self is valid.
7. The method for generating and verifying a device's unique identity as described in claim 1, characterized in that, During the device operation phase, the random number is forwarded to the secure cryptographic chip through the device-side service module, requesting the generation of a trusted certificate. The secure cryptographic chip then performs the certificate signature generation.
8. The method for generating and verifying a device's unique identity as described in claim 1, characterized in that, During the device operation phase, the steps for generating the signature proof include: The secure cryptographic chip rereads the PUF circuit's response to the challenge C_base and generates the current device unique identity seed Seed_device_current; The secure cryptographic chip or device's main processor collects the system state information, State_info, that needs to be proven. The secure cryptographic chip uses the private key SK_device to digitally sign the joint hash value of the random number Nonce and the system state information State_info to generate a proof signature Proof_Sig, which is represented as: Proof_Sig = Sign(SK_device,Hash(Nonce || State_info)), where Sign represents the signature operation.
9. The method for generating and verifying a device's unique identity as described in claim 1, characterized in that, After receiving the device identity certificate Cert_device, system status information State_info, and proof signature Proof_Sig, the verifier performs the following verification: Verify the validity period of the device identity certificate and the validity of the issuance chain; use the public key PK_device encapsulated in the device identity certificate Cert_device to verify the validity of the proof signature Proof_Sig.
10. A device unique identity generation and trusted verification system, characterized in that, It employs the method described in any one of claims 1-9, comprising: The device identity intrinsic initialization module is used to generate a unique device identity seed based on PUF circuit and cryptographic hash function during the device identity intrinsic initialization stage; it uses the unique device identity seed as a deterministic random entropy source to generate a pair of public and private keys, and uses the private key to issue a self-signed device credential for its public key. The identity registration and credential issuance module is used during the device network registration phase to send the device's self-signed device credential and public key to the designated device identity management platform to verify the signature value and extended information of the signed device credential. After successful verification, the root certificate of the device identity management platform is used to issue a device identity certificate with validity period and permission attributes to the public key and then the certificate is issued to the device. The active verification module is used during the device operation phase to send a newly generated true random number to the device as a challenge by the verifier. This enables the security cryptographic chip inside the device to use the private key, the random number, and system status information to generate a verification signature. The device identity certificate, system status information, and verification signature are then sent to the verifier for verification.