Hash-based post-quantum context-constrained pseudonym authentication method and system

Abstract

The application relates to the technical field of information security, and discloses a post-quantum context-constrained pseudonym authentication method and system based on a hash, which comprises the following steps: a registration authority initializes a hash signature environment and generates public parameters and a registration authority state; an Internet of Things device generates a user master key, normalizes coding of a service context, derives a one-time signature key pair, constructs a Merkle tree root and generates a link label, forms a registration request, and the registration authority verifies a revocation state and a combined registration state, generates a context pseudonym and a context certificate; the Internet of Things device determines a current use index according to a local use count, generates a one-time signature and a Merkle authentication path, forms an authentication certificate, an edge server verifies context matching relationship, signature and Merkle tree root consistency, and a state check node performs atomic update of a use counter. The application binds the pseudonym, the authentication key and the use state with the service context, and reduces the risks of cross-context association, certificate replay and repeated use.

Description

Technical Field

[0001] This invention relates to the field of information security technology, and in particular to a hash-based post-quantum context-constrained pseudonym authentication method and system. Background Technology

[0002] As the number of IoT devices increases, edge servers are gradually taking on processing tasks such as device access authentication, data upload verification, and service call control. In practical applications, the same IoT device may initiate authentication requests under different service types, time windows, geographical regions, or business domains. In addition to verifying the legitimacy of the device, the edge server also needs to distinguish the service context corresponding to the authentication request and limit the number of authentication attempts within the same service context.

[0003] Existing authentication methods typically use device identity, public key certificates, or static pseudonyms as long-term authentication identifiers. When such identifiers are reused in different service contexts, different edge servers can associate access records of devices with the same identifier, which can easily form cross-service device behavior trajectories. Although completely anonymous authentication methods can hide device identity, it is difficult to determine whether multiple authentication credentials in the same service context are generated by the same device. Therefore, it is impossible to balance identity privacy and duplicate authentication detection.

[0004] Some authentication schemes use one-time keys or temporary credentials to reduce the risk of long-term identity exposure. However, as the number of one-time public keys increases, the verification end needs to store or transmit more public key data, and it becomes difficult to verify whether the currently used one-time public key belongs to the public key set determined during the registration phase. Existing stateless verification methods typically only check the cryptographic validity of the signature and cannot combine the one-time key index with the number of accepted authentications to verify the authentication order. This can easily lead to problems such as the repeated use of the same index, out-of-order authentication requests, or authentication counts exceeding preset limits. When multiple edge servers provide services together, each node maintaining its own counting state may also cause asynchronous authentication counts.

[0005] Furthermore, existing device revocation methods typically rely on revocation list queries, key updates, or credential reissue. For authentication credentials that have already been issued and are still cryptographically valid, simply updating the device revocation status may not be sufficient to prevent their continued use in a timely manner. If revocation is accomplished by updating the system key or reissued other device credentials, it will increase communication and computational overhead. At the same time, some authentication schemes rely on number theory difficulties such as integer factorization or discrete logarithms, and their long-term security may be affected by the development of quantum computing technology.

[0006] Therefore, there is an urgent need for a hash-based post-quantum context-constrained pseudo-name authentication method and system. Summary of the Invention

[0007] The purpose of this invention is to overcome one or more of the above-mentioned existing technical problems and provide a hash-based post-quantum context-constrained pseudo-name authentication method and system.

[0008] To achieve the above objectives, this invention provides a hash-based post-quantum context-constrained pseudo-name authentication method, comprising:

[0009] The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally.

[0010] The service context is normalized and encoded. A number of one-time signature key pairs corresponding to the preset usage limit value are derived based on the user master key and the normalized service context. A Merkle root is constructed based on the public key in the key pair, and a link tag corresponding to the service context is generated. The device identity, service context, Merkle root and link tag are encapsulated into a registration request.

[0011] The registration authority verifies the revocation status of the device identity and the registration status of the combination of the device identity and service context. It performs hash signatures on the context pseudonym, Merkle root, link tag and normalized service context to form a context credential, and initializes the usage counter corresponding to the link tag.

[0012] IoT devices determine the local usage count corresponding to the service context as the current usage index, and perform a one-time signature on the digest of the bound access message, context credentials, service context and current usage index based on the one-time private key corresponding to the current usage index, and attach the corresponding Merkle authentication path to form authentication credentials;

[0013] The edge server verifies the context matching relationship, the currently used index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags.

[0014] After the authentication credentials are verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates its local usage count to the current usage index.

[0015] According to one aspect of the present invention, public environment parameters of the underlying hash signature scheme are generated based on security parameters, a context pseudonym generation hash function, a link tag generation hash function, and an authentication message digest hash function that are separated from each other in the domain are instantiated, and a registry hash signature public key and a registry hash signature private key are generated.

[0016] Establish a device registry for storing device registration records, a count status table for storing link tag count status, a revocation set for storing revoked device identities, and a combination registration set for storing the combination of device identity and service context;

[0017] Write the public environment parameters, the separate hash functions for each domain, the public key for the registry's hash signature, and the preset usage limit value into the public parameters; write the private key for the registry's hash signature, the device registry, the count status table, the revocation set, and the combined registration set into the registry status.

[0018] IoT devices randomly generate link tag derived keys and one-time signature key derived seeds, and combine the two to form the user master key.

[0019] According to one aspect of the present invention, a corresponding number of one-time signature key pairs are derived based on a one-time signature key derivation seed and a normalized service context, according to a preset usage limit value;

[0020] Each one-time public key is compressed into a corresponding Merkle leaf node. Based on the position of each Merkle leaf node in the tree, pairwise hash operations are performed layer by layer according to the node position to obtain the Merkle tree root.

[0021] Record the values ​​of adjacent nodes at the same level and their left and right positions that each Merkle leaf node passes through to the Merkle root, forming the corresponding Merkle authentication path;

[0022] The link tag derived key and the normalized service context are concatenated sequentially and then input into the link tag to generate a hash function to obtain the link tag. The one-time signature key pair, Merkle tree structure, Merkle authentication path and service context are associated and stored in the user's local state.

[0023] According to one aspect of the invention, device identity, service context, Merkle root, and link tags are parsed from the registration request to query the revocation set and the combined registration set;

[0024] Terminate context credential issuance when the device identity has been written to the revocation set or the combination of the device identity and service context has been written to the combined registration set.

[0025] When the query is successful, a random salt value is generated. The device identity, the normalized service context and the random salt value are concatenated in sequence and then input into the context pseudonym to generate a hash function to obtain the context pseudonym.

[0026] The context pseudonym, Merkle root, link tag, and normalized service context are concatenated sequentially to form credential signature data. The credential signature data is signed using the registry's hash signature private key. The context pseudonym, Merkle root, link tag, service context, and the obtained registry signature are then encapsulated into a context credential.

[0027] Write the context pseudonym, Merkle root, link tag, and random salt value to the device registry, write the corresponding device identity and service context to the combined registry set, and initialize the usage counter corresponding to the link tag to zero.

[0028] According to one aspect of the present invention, the user's local state and context credentials are parsed, and the service context in the context credentials is checked to see if it is consistent with the current service context;

[0029] If there is no local usage count corresponding to the current service context in the user's local state, the local usage count is initialized to zero, and the generation of authentication credentials is terminated when the local usage count is not less than the preset usage threshold.

[0030] Increment the local usage count to get the current usage index, and read the one-time private key and Merkle authentication path corresponding to the current usage index;

[0031] The access message, context pseudonym, Merkle root, link tag, normalized service context, and current index are concatenated sequentially and input into the authentication message digest hash function to obtain the digest to be signed. A one-time private key is used to sign the digest to be signed, and the current index, Merkle authentication path, one-time signature, and context credentials are encapsulated into authentication credentials.

[0032] According to one aspect of the present invention, the currently used index, Merkle authentication path, one-time signature and context credential are parsed, the service context in the context credential is verified against the current service context, and it is verified whether the currently used index is within a preset usage limit;

[0033] Based on the registry's hash signature public key, the credential signature data formed by sequentially concatenating the context pseudonym, Merkle root, link tag, and normalized service context, as well as the registry signature, are verified.

[0034] Regenerate the digest to be verified according to the same field order when the authentication credential was generated. Reconstruct the candidate one-time public key based on the one-time signature and the digest to be verified. Compress the candidate one-time public key into a candidate Merkle leaf node. Combine the currently used index and the Merkle authentication path to reconstruct the candidate Merkle root layer by layer. Compare the candidate Merkle root with the Merkle root in the context credential. If any verification fails, output an invalid authentication result.

[0035] For two valid authentication credentials, output a result showing a link relationship if their service contexts and link tags are identical.

[0036] According to one aspect of the invention, the current usage index and link tag are extracted from the verified authentication credential, and the usage counter record indexed by the link tag is queried in the count status table;

[0037] If the usage counter exists, the current usage index is equal to the usage counter value, and the usage counter value is less than the preset usage limit, the usage counter value is atomically updated to the current usage index plus one and the authentication acceptance result is output; otherwise, the authentication rejection result is output.

[0038] Multiple edge servers synchronize a count state table and an undo set by sharing a state store;

[0039] In response to a device revocation command, the identity of the device to be revoked is added to the revocation set. The combined registration set is traversed to determine the service contexts corresponding to the device. The link tags corresponding to each service context are obtained from the device registry. The usage counter records indexed by each link tag are deleted from the count status table.

[0040] To achieve the above objectives, this invention provides a hash-based post-quantum context-constrained pseudo-name authentication system, comprising:

[0041] Initialization and Master Key Generation Module: The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally;

[0042] Registration request generation module: Normalizes the service context, derives a number of one-time signature key pairs corresponding to the preset usage limit value based on the user master key and the normalized service context, constructs a Merkle root based on the public key in the key pair, and generates a link tag corresponding to the service context. It encapsulates the device identity, service context, Merkle root and link tag into a registration request.

[0043] Context credential generation module: The registration authority verifies the revocation status of the device identity and the registration status of the combination of device identity and service context, performs hash signature on the context pseudonym, Merkle root, link tag and normalized service context to form context credentials, and initializes the usage counter corresponding to the link tag;

[0044] Authentication credential generation module: The IoT device determines the local usage count corresponding to the service context as the current usage index, performs a one-time signature on the digest of the bound access message, context credential, service context and current usage index based on the one-time private key corresponding to the current usage index, and attaches the corresponding Merkle authentication path to form authentication credentials;

[0045] Authentication verification and link determination module: The edge server verifies the context matching relationship, the current index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags.

[0046] Using the status check and count update module: After the authentication credential is verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates the local usage count to the current usage index.

[0047] To achieve the above objectives, the present invention provides an electronic device, including a processor, a memory, and a computer program stored in the memory and executable on the processor. When the computer program is executed by the processor, it implements the above-described hash-based post-quantum context-constrained pseudo-name authentication method.

[0048] To achieve the above objectives, the present invention provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the above-described hash-based post-quantum context-constrained pseudo-name authentication method.

[0049] Based on this, the beneficial effects of the present invention are as follows: by adopting a low-level hash signature scheme and a hash-based one-time signature, the security basis of registration authority signature and device authentication is limited to the security properties related to hash functions, thereby reducing the security risks faced by traditional number theory-based public key cryptography in a quantum computing environment;

[0050] Link tags are generated based on the key derived from the link tag and the normalized service context. Context pseudonyms are also generated based on the device identity, the normalized service context, and a random salt value, enabling different service contexts to form separate pseudonyms and link domains. At the same time, it allows the link relationship between authentication credentials to be determined based on the link tag within the same service context.

[0051] The one-time signature key pair is associated with the current usage index, the Merkle authentication path, and the preset usage limit value. The membership of the one-time public key is verified through the candidate Merkle tree root. The same usage index is prevented from being accepted repeatedly by using the sequential verification of the counter and atomic updates, thereby reducing credential replay and concurrent duplicate authentication.

[0052] This allows multiple edge servers to synchronize the count state table and revocation set through a shared state store, and to clean up the corresponding usage counter records along the combined registration set and device registry when a device is revoked, thereby maintaining the consistency of the distributed authentication state and improving the integrity of the revocation process. Attached Figure Description

[0053] Figure 1 This is a flowchart illustrating a hash-based post-quantum context-constrained pseudo-name authentication method according to an exemplary embodiment;

[0054] Figure 2 This is a model diagram illustrating a hash-based post-quantum context-constrained pseudo-name authentication method according to an exemplary embodiment;

[0055] Figure 3 This is a flowchart illustrating a hash-based post-quantum context-constrained pseudonym authentication system according to an exemplary embodiment. Detailed Implementation

[0056] The invention will now be discussed with reference to exemplary embodiments. It should be understood that the described embodiments are merely intended to enable those skilled in the art to better understand and thus implement the invention, and are not intended to imply any limitation on the scope of the invention.

[0057] As used herein, the term “comprising” and its variations are to be interpreted as open-ended terms meaning “including but not limited to”. The term “based on” is to be interpreted as “at least partially based on”, and the terms “one embodiment” and “an embodiment” are to be interpreted as “at least one embodiment”.

[0058] According to one embodiment of the present invention, Figure 1 This is a flowchart illustrating a hash-based post-quantum context-constrained pseudo-name authentication method according to an exemplary embodiment, such as... Figure 1As shown, to achieve the above objective, this invention provides a hash-based post-quantum context-constrained pseudo-name authentication method, comprising:

[0059] The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally.

[0060] The service context is normalized and encoded. A number of one-time signature key pairs corresponding to the preset usage limit value are derived based on the user master key and the normalized service context. A Merkle root is constructed based on the public key in the key pair, and a link tag corresponding to the service context is generated. The device identity, service context, Merkle root and link tag are encapsulated into a registration request.

[0061] The registration authority verifies the revocation status of the device identity and the registration status of the combination of the device identity and service context. It performs hash signatures on the context pseudonym, Merkle root, link tag and normalized service context to form a context credential, and initializes the usage counter corresponding to the link tag.

[0062] IoT devices determine the local usage count corresponding to the service context as the current usage index, and perform a one-time signature on the digest of the bound access message, context credentials, service context and current usage index based on the one-time private key corresponding to the current usage index, and attach the corresponding Merkle authentication path to form authentication credentials;

[0063] The edge server verifies the context matching relationship, the currently used index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags.

[0064] After the authentication credentials are verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates its local usage count to the current usage index.

[0065] According to one embodiment of the present invention, public environment parameters of the underlying hash signature scheme are generated based on security parameters, a context pseudonym generation hash function, a link tag generation hash function, and an authentication message digest hash function that are separated from each other in the domain are instantiated, and a registry hash signature public key and a registry hash signature private key are generated.

[0066] Establish a device registry for storing device registration records, a count status table for storing link tag count status, a revocation set for storing revoked device identities, and a combination registration set for storing the combination of device identity and service context;

[0067] Write the public environment parameters, the separate hash functions for each domain, the public key for the registry's hash signature, and the preset usage limit value into the public parameters; write the private key for the registry's hash signature, the device registry, the count status table, the revocation set, and the combined registration set into the registry status.

[0068] IoT devices randomly generate link tag derived keys and one-time signature key derived seeds, and combine the two to form the user master key.

[0069] According to one embodiment of the present invention, a corresponding number of one-time signature key pairs are derived based on the one-time signature key derivation seed and the normalized service context, according to a preset usage limit value;

[0070] Each one-time public key is compressed into a corresponding Merkle leaf node. Based on the position of each Merkle leaf node in the tree, pairwise hash operations are performed layer by layer according to the node position to obtain the Merkle tree root.

[0071] Record the values ​​of adjacent nodes at the same level and their left and right positions that each Merkle leaf node passes through to the Merkle root, forming the corresponding Merkle authentication path;

[0072] The link tag derived key and the normalized service context are concatenated sequentially and then input into the link tag to generate a hash function to obtain the link tag. The one-time signature key pair, Merkle tree structure, Merkle authentication path and service context are associated and stored in the user's local state.

[0073] According to one embodiment of the present invention, device identity, service context, Merkle root, and link tags are parsed from the registration request to query the revocation set and the combined registration set;

[0074] Terminate context credential issuance when the device identity has been written to the revocation set or the combination of the device identity and service context has been written to the combined registration set.

[0075] When the query is successful, a random salt value is generated. The device identity, the normalized service context and the random salt value are concatenated in sequence and then input into the context pseudonym to generate a hash function to obtain the context pseudonym.

[0076] The context pseudonym, Merkle root, link tag, and normalized service context are concatenated sequentially to form credential signature data. The credential signature data is signed using the registry's hash signature private key. The context pseudonym, Merkle root, link tag, service context, and the obtained registry signature are then encapsulated into a context credential.

[0077] Write the context pseudonym, Merkle root, link tag, and random salt value to the device registry, write the corresponding device identity and service context to the combined registry set, and initialize the usage counter corresponding to the link tag to zero.

[0078] According to one embodiment of the present invention, the user's local state and context credentials are parsed, and the service context in the context credentials is checked to see if it is consistent with the current service context;

[0079] If there is no local usage count corresponding to the current service context in the user's local state, the local usage count is initialized to zero, and the generation of authentication credentials is terminated when the local usage count is not less than the preset usage threshold.

[0080] Increment the local usage count to get the current usage index, and read the one-time private key and Merkle authentication path corresponding to the current usage index;

[0081] The access message, context pseudonym, Merkle root, link tag, normalized service context, and current index are concatenated sequentially and input into the authentication message digest hash function to obtain the digest to be signed. A one-time private key is used to sign the digest to be signed, and the current index, Merkle authentication path, one-time signature, and context credentials are encapsulated into authentication credentials.

[0082] According to one embodiment of the present invention, the currently used index, Merkle authentication path, one-time signature and context credential are parsed, the service context in the context credential is checked against the current service context, and it is verified whether the currently used index is within a preset usage limit;

[0083] Based on the registry's hash signature public key, the credential signature data formed by sequentially concatenating the context pseudonym, Merkle root, link tag, and normalized service context, as well as the registry signature, are verified.

[0084] Regenerate the digest to be verified according to the same field order when the authentication credential was generated. Reconstruct the candidate one-time public key based on the one-time signature and the digest to be verified. Compress the candidate one-time public key into a candidate Merkle leaf node. Combine the currently used index and the Merkle authentication path to reconstruct the candidate Merkle root layer by layer. Compare the candidate Merkle root with the Merkle root in the context credential. If any verification fails, output an invalid authentication result.

[0085] For two valid authentication credentials, output a result showing a link relationship if their service contexts and link tags are identical.

[0086] According to one embodiment of the present invention, the current usage index and link tag are extracted from the verified authentication credential, and the usage counter record indexed by the link tag is queried in the count status table;

[0087] If the usage counter exists, the current usage index is equal to the usage counter value, and the usage counter value is less than the preset usage limit, the usage counter value is atomically updated to the current usage index plus one and the authentication acceptance result is output; otherwise, the authentication rejection result is output.

[0088] Multiple edge servers synchronize a count state table and an undo set by sharing a state store;

[0089] In response to a device revocation command, the identity of the device to be revoked is added to the revocation set. The combined registration set is traversed to determine the service contexts corresponding to the device. The link tags corresponding to each service context are obtained from the device registry. The usage counter records indexed by each link tag are deleted from the count status table.

[0090] According to one embodiment of the present invention, Figure 2 This is a model diagram illustrating a hash-based post-quantum context-constrained pseudo-name authentication method according to an exemplary embodiment, such as... Figure 2 As shown, the process is jointly executed by IoT devices, a registration authority, an edge server, a status check node, and a shared state storage. The IoT devices are responsible for generating user master keys, registration requests, and authentication credentials. The registration authority is responsible for hash signature environment initialization, context credential generation, and device revocation. The edge server is responsible for authentication verification and connection determination. After the authentication credentials are verified, the status check node performs usage status checks and count updates. The status check node can be set on the registration authority side, the edge server side, or as an independent execution component connected to the shared state storage.

[0091] As resource-constrained terminal devices, IoT devices / users request access from edge services. The IoT device locally holds the user's master key and derives a set of keys for each accessible service context. The structure of a one-time key pair is used to build a Merkle tree commitment. During authentication, the device uses the next available one-time key to generate authentication credentials, and the entire process does not expose its true identity.

[0092] The Registration Authority (RA), as a trusted authority, is responsible for system initialization, device registration, context credential issuance, state initialization, and device revocation. The RA generates a structured credential for each valid service context of each device, which is bound to a context pseudonym. Merkle roots ( ), link tags ( ) and service context ( ).

[0093] Device identity is only used by the registration authority to verify the revocation status, determine whether the combination of device identity and service context has been registered, and establish an index for device registration records. It is not written into the authentication credentials. The context credentials received by the edge server consist of the context pseudonym, Merkle root, link tag, service context, and registration authority signature. Therefore, its authentication verification and link determination do not require reading the device identity.

[0094] The edge server performs authentication verification and link determination. It parses the currently used index, Merkle authentication path, one-time signature, and context credentials from the authentication credentials. It reconstructs the digest to be verified according to the same field order in the authentication credential generation stage, and verifies the service context matching relationship, the currently used index range, the registry signature, and the candidate Merkle tree root in sequence. Only when all the above verifications pass can the authentication credential enter the link determination or usage status check. For two authentication credentials that have passed verification, the edge server determines whether they have a link relationship based on their service context and link tags.

[0095] The shared state store saves and synchronizes the count state table and the undo set for multiple edge servers or state check nodes to read. The count state table saves the usage counter value corresponding to the accepted authentication by using the link tag as an index. The state check node only atomically updates the usage counter to the current usage index when the record exists, the usage counter value is less than the preset usage limit value, and the current usage index is equal to the usage counter value plus one. Atomic updates can be achieved through comparison and swap operations, transaction locks, or write mechanisms with equivalent atomicity.

[0096] The so-called service context is structured context data used to define the scope of application for one-time registration and limited authentication. IoT devices, registration authorities, edge servers, and status check nodes use the same set of fields, field order, and encoding rules to normalize and encode it. Unnormalized service context is used for business-side identification, while normalized service context is used for one-time signature key pair derivation, link tag generation, context pseudonym generation, registration authority signing, and authentication message digest calculation, so that each processing stage uses the same context semantics.

[0097] According to one embodiment of the present invention, an initialization algorithm Enter security parameters and preset usage limit values The Registration Authority (RA) generates public parameters. Status with the registration authority ,in, To be made public HBS stands for Hilary Birth Standard, which is secretly stored by the registration authority. Common environment parameters used to initialize this signature scheme. The hash signature key pair used to generate the registration authority is given by the following algorithm:

[0098] Initialization algorithm ;

[0099] enter: and ;

[0100] Output: and ;

[0101] 1: Initialize the hash signature environment: ;

[0102] 2: Instantiate the domain-separated hash function: ;

[0103] 3: Generate the hash signature key pair for the registration authority: ;

[0104] 4: Initialize the registration agency status table: , , , ;

[0105] 5: Set common parameters: ;

[0106] 6: Set the registration status: ;

[0107] return: ;

[0108] in, These are common environment parameters for the underlying hash signature scheme. These are used for context pseudonym generation, service context link tag generation, and authentication message digest calculation, respectively. These are used to store device registration records, link tag count status, revoked device sets, and combinations of registered device identities and service contexts, respectively.

[0109] Registration agencies use security parameters and preset usage limit values As initialization input, common parameters The IoT devices, edge servers, and status check nodes are publicly disclosed, among which... Simultaneously, the number of one-time signature key pairs and the effective index usage range are limited; Registry status. Saved by the registration authority or controlled state component. and Domain separation is achieved by using distinct domain identifiers or independent instances, allowing context pseudonyms, link tags, and authentication message digests to be computed within different input domains. (Device Registry) Counting Status Table Cancel set and combined registration set It is empty during initialization and then takes over the subsequent registration records, usage counts, revocation status, and combinations of device identity and service context.

[0110] According to one embodiment of the present invention, a user master key generation algorithm Input common parameters IoT devices generate user master keys locally This process requires no interaction with the registration authority; the algorithm is as follows:

[0111] User Master Key Generation Algorithm ;

[0112] enter: ;

[0113] Output: ;

[0114] 1: Randomly sample two master key values: , ;

[0115] 2: ;

[0116] return: ;

[0117] IoT devices randomly generate link tag derived keys. and one-time signature key derivation seed And encapsulate both into a user master key. The link tag derived key is only used to generate link tags in combination with the normalized service context, and the one-time signature key derived seed is used to generate one-time signature key pairs under the service context. Both are stored locally by the IoT device. The registration authority does not participate in the generation of the user master key, nor does it obtain the above two local secrets.

[0118] According to one embodiment of the present invention, a user registration request generation algorithm Input device's true identity The service context corresponding to the current registration request User master key and parameters IoT devices generate local key materials and registration requests The algorithm is as follows:

[0119] User registration request generation algorithm ;

[0120] enter: , , and ;

[0121] Output: ;

[0122] 1: Derivation from seeds One-time key pair: ;

[0123] 2: Construct the Merkle root tree: ;

[0124] 3: Calculate link tags: ;

[0125] return: ;

[0126] in, Indicates the derivation of a seed based on a one-time signature key. and context derived A one-time signature key pair Used to construct a Merkle root from a set of one-time public keys. This root serves as a commitment to the entire set of one-time public keys within the service context. This indicates that the context is being normalized and encoded.

[0127] IoT devices first check the service context Performing normalized coding ensures that the same service context is consistent across different participants. In the algorithm In implementation, the normalized service context is used as the context-derived input to generate k one-time signature key pairs. Each one-time public key is processed by LTree or equivalent compression to form a Merkle leaf node. The values ​​of adjacent nodes at the same level are concatenated in the order of left node first and right node last and then hashed to obtain the Merkle tree root layer by layer. Simultaneously, the values ​​and left and right positions of adjacent nodes at the same level from each leaf node to the root node are recorded to form a Merkle authentication path. The one-time signature key pair set, the Merkle tree structure, and each Merkle authentication path are written using the service context as an index. Then, the link tag will be used to derive the key. and Concatenate and input in sequence Get the link tag Then identify the device Service Context Merkle roots and link tags Encapsulated as a registration request .

[0128] According to one embodiment of the present invention, a registration and certificate issuance algorithm for registration authorities. Input the registration request, registration authority status, and common parameters. The registration authority verifies the request and issues a context credential corresponding to the service context. The algorithm is as follows:

[0129] Registration and Certificate Issuance Algorithm ;

[0130] enter: , and ;

[0131] Output: , or ;

[0132] 1: Parse request: ;

[0133] 2: If or Then return ;

[0134] 3: Sample random numbers: ;

[0135] 4: Compute context pseudonames: ;

[0136] 5: The registry uses the registry hash to sign the private key. Sign the voucher: ;

[0137] 6: Build and store credentials: ;

[0138] 7: Update the registration status: , , ;

[0139] 8: Update ;

[0140] return: ;

[0141] in, This indicates that registration failed or that the certificate was refused. Random salt values ​​generated for the registration authority are used to enhance the randomness of the pseudonym generation process. This indicates that a counter is initialized for this link tag, which is used for subsequent bounded usage checks.

[0142] The registration authority parses the device identity from the registration request. Service Context Merkle roots and link tags And query the cancellation set respectively. and combined registration set If the device identity has been revoked or the same device identity and service context combination has already been registered, the issuance of credentials will be terminated. After the query is successful, the registration authority will generate a random salt value. It generates context pseudonyms based on device identity, normalized service context, and random salt value. The registry uses a registry hash to sign the private key. Sign the ordered concatenation of the context pseudonym, Merkle root, link tags, and normalized service context to obtain the registry signature. and will , , , and Encapsulated as context credentials The registration agency will also write the registration record to Combine device identity and service context in writing and in Middle The corresponding counter is initialized to zero.

[0143] According to one embodiment of the present invention, an authentication generation algorithm : Enter access message Service Context User master key Contextual credentials User local status and common parameters IoT devices generate authentication credentials The algorithm is as follows:

[0144] Authentication generation algorithm ;

[0145] enter: , , , , and ;

[0146] Output: , ;

[0147] 1: Parse the user's local state: ;

[0148] 2: Parse the context credentials: ;

[0149] 3: Verify the context in the credentials Is it related to the input? If it matches, return 0; otherwise, return 0. ;

[0150] 4: If There is no context in If the count record is set, then set ;

[0151] 5: Get the current local usage count: .if Then return ;

[0152] 6: Set the index to use this time: ;

[0153] 7: Obtain the corresponding one-time signature key pair: ;

[0154] 8: Calculate the Merkle authentication path corresponding to the j-th one-time public key: ;

[0155] 9: Calculate the digest to be signed: ;

[0156] 10: Generate a one-time signature using a one-time private key: ;

[0157] 11: Assembly certification certificate: ;

[0158] return: ;

[0159] in, This represents the context stored locally by the IoT device. Next A one-time signature key pair This is a local usage counter table. The local usage counter can be updated after the authentication is accepted by the validator to avoid prematurely consuming the one-time key index when authentication fails. Used to generate the Each one-time public key corresponds to a Merkle authentication path. Indicates the use of the first A one-time private key is used to treat the signature digest. Generate a one-time signature.

[0160] User local status Depend on and The IoT device first verifies the service context in the context credential against the current service context. When there is no corresponding entry, the local usage count is initialized to zero. Achieved The generation will terminate at the specified time; otherwise, it will... Add one to determine the index currently in use. ,from Read the first A one-time private key and its Merkle authentication path IoT devices according to access messages Contextual pseudonyms Merkle roots , link tags Standardized service context and currently used index Generate the digest to be signed in the order of generation , adopt the first A one-time private key is used to generate a one-time signature. and will , , and Encapsulated as authentication credentials Before the status check node returns the authentication acceptance result, The local usage count remains unchanged.

[0161] According to one embodiment of the present invention, an authentication verification algorithm : Enter access message Service Context Authentication certificate and common parameters The edge server runs an algorithm to verify the cryptographic validity of the credentials, where the algorithm is:

[0162] Authentication verification algorithm ;

[0163] enter: , , and ;

[0164] Output: 1 (valid) or 0 (invalid);

[0165] 1: Analysis ,in ;

[0166] 2: Verify context matching: If Then it returns 0;

[0167] 3: Verify the index range: If or Then it returns 0;

[0168] 4: Verify the registration authority's signature: If Then it returns 0;

[0169] 5: Reconstructing the summary: ;

[0170] 6: Recover the one-time public key from the signature: ;

[0171] 7: Calculate Merkle leaves: ;

[0172] 8: Rebuild Merkle root: ;

[0173] 9: If If the condition is met, then 0 is returned.

[0174] Return: 1;

[0175] in, This indicates that the registry signature is verified using the registry hash signature public key. This indicates that a candidate one-time public key is reconstructed based on the one-time signature and digest. LTree is used to compress the candidate one-time public key into a Merkle leaf. Used to reconstruct candidate Merkle roots based on Merkle leaves, authentication paths, and indexes.

[0176] The edge server performs layered verification of authentication credentials. First, it checks the service context in the context credential against the current service context and verifies the currently used index. Located at 1 to Within the scope of this, secondly, the registry's hash signature public key is used. Verify the signature binding relationship between the context pseudonym, Merkle root, link tag, and normalized service context. Then, generate the digest to be verified according to the same field order from the authentication generation phase. and based on a one-time signature and Reconstruct candidate one-time public key Finally, the candidate one-time public keys are compressed into candidate Merkle leaf nodes. Combined with the Merkle authentication path And calculate the candidate Merkle root layer by layer using the left and right positions indicated by the current index. The candidate Merkle root is the same as the Merkle root in the context credential, indicating that the current one-time public key belongs to the set of public keys promised during registration. If any verification fails, an invalid authentication result is output.

[0177] According to one embodiment of the present invention, a context-aware linking algorithm Input two authentication tuples and and common parameters The edge server determines whether they were generated by the same device within the same service context, where the algorithm is as follows:

[0178] Context-aware linking algorithm :

[0179] enter: , and ;

[0180] Output: 1 (linkable) or 0 (not linkable);

[0181] 1: If or If the condition is met, then 0 is returned.

[0182] 2: Extract link tags from the two vouchers and ;

[0183] 3: If If the condition is met, then 0 is returned.

[0184] 4: If If the condition is met, then 0 is returned.

[0185] Return: 1;

[0186] Link determination is based on the premise that both authentication credentials pass the algorithm's authentication verification. The edge server extracts the service context corresponding to each of the two authentication credentials. , and link tags , The system outputs results with a link relationship only when the service context and the link label are the same. Since the link label is determined by the link label derived key of the IoT device and the normalized service context, the valid authentication of the same IoT device in the same service context can be associated within that context, while the authentication of different service contexts does not establish a link relationship. This determination does not require recovering or comparing the device identity from the authentication credentials.

[0187] According to one embodiment of the present invention, a checking and bounded coercion algorithm is used. Input authentication credentials and registration authority status. The status check node performs a stateful usage check to ensure that the number of authentications under the same service context does not exceed [number missing]. The algorithm is as follows:

[0188] Using checking and bounded coercion algorithms ;

[0189] enter: , , , and ;

[0190] Output: Updated And 1 (accept) or 0 (reject);

[0191] 1: Analyze the registration status: ;

[0192] 2: If Then return ;

[0193] 3: Extract the index from the voucher and link tags ;

[0194] 4: If There is no such thing as in If the counter record is indexed, then return... ;

[0195] 5: Get the current count: ;

[0196] 6: If or Then return ;

[0197] 7: Update the counter: ;

[0198] return: ;

[0199] The status check node only performs usage status checks on authentication credentials that have passed algorithm verification, and retrieves the current usage index from them. and link tags Status check node Query count status table Authentication is rejected if the record does not exist; if the record exists, the counter value is used to read it. Only when Less than the preset usage limit value and equal When incrementing by one, the state check node performs an atomic operation to... The value of c is updated to j, and the authentication acceptance result is output. If any condition is not met, the original value is retained and the authentication rejection result is output. When multiple edge servers share the shared state storage, the condition judgment and the count writing are completed in the same atomic operation or transaction. In response to the authentication acceptance result, the IoT device updates the local usage count corresponding to the service context. When authentication is rejected, the local usage count remains unchanged.

[0200] According to one embodiment of the present invention, the undo algorithm Enter the identity of the device to be revoked. and registration status The registration authority revokes the device registration, preventing future certifications. The algorithm used is as follows:

[0201] Undo Algorithm ;

[0202] enter: and ;

[0203] Output: Updated ;

[0204] 1: Analyze the registration status: ;

[0205] 2: If Then return ;

[0206] 3: Will Add to undo set: ;

[0207] 4: For each :if Then: proceed with steps 5 to 6;

[0208] 5: From Read the device in context Registration records below ;

[0209] 6: If There exists in If a counter record is indexed, then delete that counter record. ;

[0210] 7: Update ;

[0211] return: ;

[0212] In response to a device deregistration order, the registration authority will register the device to be deregistered. Write to undo set This prevents subsequent registration requests for the device from passing the revocation status verification, and simultaneously iterates through the combined registration set. Determine the service contexts registered for the device, and based on the device registry. Read the link tags corresponding to each service context For the counting state table The corresponding records existing in the database will be deleted. For the usage counter indexed, if it is deleted, the existing context credentials, even if they can be cryptographically verified, will be rejected because the corresponding usage counter record cannot be found. The shared state store will synchronize the updated revocation set and the count state table to each state check node.

[0213] According to one embodiment of the present invention, assuming all algorithms execute correctly and the user's local state is synchronized with the registry's state, for an honest IoT device, the information provided during registration... Yes A Merkle root commitment of a one-time public key, used by IoT devices during the authentication phase. A one-time private key pair message digest Perform the signing and generate the corresponding authentication path. After receiving the credentials, the verifier first hashes and signs the public key using the registry. Verify the validity of the credential signature and confirm. , , and The binding relationship, subsequently, the verifier from the one-time signature and message summary Reconstruct the public key And calculate its Merkle leaves ,because It is the first The correct authentication path for a public key, verified by the verifier. The root reconstructed by the function It must be equal to the promise in the voucher. Therefore, all verification steps passed, and 1 was returned.

[0214] Bounded use of enforced correctness: The registry assigns each link tag a correct value during registration. Initialize the counter An authentication credential is accepted if and only if it uses an index. satisfy (in (current counter value), and After each acceptance, the counter is atomically updated. Therefore, the counter starts from 0, increments strictly, and reaches [a certain value]. Then reject all subsequent requests, which guarantees any The maximum number of times authentication can be accepted is [number missing]. Second-rate.

[0215] Correctness of revocation: When the registration authority revokes the equipment hour, Added to the revocation set After this, the device will be rejected for registration requests in any service context, and all registered service contexts associated with the device will be deleted. Entries, due to Once revoked, even if the credentials previously issued to the device are still cryptographically valid, they cannot pass the stateful check, thus effectively blocking the service access of the revoked device. This process does not require the participation of other devices or service providers, nor does it require re-encrypting any data or re-issuing credentials to other users.

[0216] Link correctness: For the same honest IoT device in the same service context The generated authentication credentials are derived from the same link tag derived key. and the same normalized service context The calculated link tags The credentials must be identical. After confirming that both authentication credentials are valid, their service contexts and link tags are compared. Therefore, for valid authentication credentials generated by the same IoT device within the same service context, 1 is returned. For authentication credentials generated in different service contexts, 0 is returned directly due to the different service contexts, thus achieving cross-context non-linkability. For authentication credentials generated by different IoT devices within the same service context, their link tag derived keys will be different. Unlike other hash functions, under the assumptions of collision resistance and pseudo-randomness, the probability of generating the same link tag is negligible, so it returns 0.

[0217] Furthermore, to achieve the aforementioned objectives, this invention also provides a hash-based post-quantum context-constrained pseudo-name authentication system. Figure 3 This is a flowchart illustrating a hash-based post-quantum context-constrained pseudo-name authentication system according to an exemplary embodiment, such as... Figure 3 As shown, a hash-based post-quantum context-constrained pseudo-name authentication system of the present invention includes:

[0218] Initialization and Master Key Generation Module: The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally;

[0219] Registration request generation module: Normalizes the service context, derives a number of one-time signature key pairs corresponding to the preset usage limit value based on the user master key and the normalized service context, constructs a Merkle root based on the public key in the key pair, and generates a link tag corresponding to the service context. It encapsulates the device identity, service context, Merkle root and link tag into a registration request.

[0220] Context credential generation module: The registration authority verifies the revocation status of the device identity and the registration status of the combination of device identity and service context, performs hash signature on the context pseudonym, Merkle root, link tag and normalized service context to form context credentials, and initializes the usage counter corresponding to the link tag;

[0221] Authentication credential generation module: The IoT device determines the local usage count corresponding to the service context as the current usage index, performs a one-time signature on the digest of the bound access message, context credential, service context and current usage index based on the one-time private key corresponding to the current usage index, and attaches the corresponding Merkle authentication path to form authentication credentials;

[0222] Authentication verification and link determination module: The edge server verifies the context matching relationship, the current index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags.

[0223] Using the status check and count update module: After the authentication credential is verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates the local usage count to the current usage index.

[0224] To achieve the above-mentioned objectives, the present invention also provides an electronic device comprising: a processor, a memory, and a computer program stored in the memory and executable on the processor. When the computer program is executed by the processor, it implements the above-mentioned hash-based post-quantum context-constrained pseudo-name authentication method.

[0225] To achieve the above-mentioned objectives, the present invention also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the aforementioned hash-based post-quantum context-constrained pseudo-name authentication method.

[0226] Those skilled in the art will recognize that the modules and algorithm steps described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0227] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the above-described apparatus and equipment can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0228] In the embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or modules may be electrical, mechanical, or other forms.

[0229] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; that is, they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of the embodiments of the present invention, depending on actual needs.

[0230] In addition, the functional modules in the embodiments of the present invention can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module.

[0231] If the aforementioned functions are implemented as software functional modules and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, essentially, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the energy-saving signal transmission / reception methods of the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, ROM, RAM, magnetic disks, or optical disks.

[0232] The above description is merely a preferred embodiment of this application and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in this application is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the inventive concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features with similar functions disclosed in this application.

[0233] It should be understood that the sequence number of each step in the invention and embodiments of the present invention does not absolutely imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

Claims

1. A hash-based post-quantum context-constrained pseudo-name authentication method, characterized in that, include: The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally. The service context is normalized and encoded. A number of one-time signature key pairs corresponding to the preset usage limit value are derived based on the user master key and the normalized service context. A Merkle root is constructed based on the public key in the key pair, and a link tag corresponding to the service context is generated. The device identity, service context, Merkle root and link tag are encapsulated into a registration request. The registration authority verifies the revocation status of the device identity and the registration status of the combination of the device identity and service context. It performs hash signatures on the context pseudonym, Merkle root, link tag and normalized service context to form a context credential, and initializes the usage counter corresponding to the link tag. IoT devices determine the local usage count corresponding to the service context as the current usage index, and perform a one-time signature on the digest of the bound access message, context credentials, service context and current usage index based on the one-time private key corresponding to the current usage index, and attach the corresponding Merkle authentication path to form authentication credentials; The edge server verifies the context matching relationship, the currently used index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags. After the authentication credentials are verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates its local usage count to the current usage index.

2. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 1, characterized in that, Based on the security parameters, generate the public environment parameters of the underlying hash signature scheme, instantiate the context pseudonym generation hash function, the link tag generation hash function and the authentication message digest hash function that are separated from each other's domains, and generate the registry hash signature public key and registry hash signature private key. Establish a device registry for storing device registration records, a count status table for storing link tag count status, a revocation set for storing revoked device identities, and a combination registration set for storing the combination of device identity and service context; Write the public environment parameters, the separate hash functions for each domain, the public key for the registry's hash signature, and the preset usage limit value into the public parameters; write the private key for the registry's hash signature, the device registry, the count status table, the revocation set, and the combined registration set into the registry status. IoT devices randomly generate link tag derived keys and one-time signature key derived seeds, and combine the two to form the user master key.

3. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 2, characterized in that, Based on the seed of the one-time signature key and the normalized service context, a corresponding number of one-time signature key pairs are derived according to the preset usage limit value. Each one-time public key is compressed into a corresponding Merkle leaf node. Based on the position of each Merkle leaf node in the tree, pairwise hash operations are performed layer by layer according to the node position to obtain the Merkle tree root. Record the values ​​of adjacent nodes at the same level and their left and right positions that each Merkle leaf node passes through to the Merkle root, forming the corresponding Merkle authentication path; The link tag derived key and the normalized service context are concatenated sequentially and then input into the link tag to generate a hash function to obtain the link tag. The one-time signature key pair, Merkle tree structure, Merkle authentication path and service context are associated and stored in the user's local state.

4. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 3, characterized in that, Parse the device identity, service context, Merkle root, and link tags from the registration request, and query the revocation set and combined registration set; Terminate context credential issuance when the device identity has been written to the revocation set or the combination of the device identity and service context has been written to the combined registration set. When the query is successful, a random salt value is generated. The device identity, the normalized service context and the random salt value are concatenated in sequence and then input into the context pseudonym to generate a hash function to obtain the context pseudonym. The context pseudonym, Merkle root, link tag, and normalized service context are concatenated sequentially to form credential signature data. The credential signature data is signed using the registry's hash signature private key. The context pseudonym, Merkle root, link tag, service context, and the obtained registry signature are then encapsulated into a context credential. Write the context pseudonym, Merkle root, link tag, and random salt value to the device registry, write the corresponding device identity and service context to the combined registry set, and initialize the usage counter corresponding to the link tag to zero.

5. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 4, characterized in that, Parse the user's local state and context credentials, and verify whether the service context in the context credentials is consistent with the current service context; If there is no local usage count corresponding to the current service context in the user's local state, the local usage count is initialized to zero, and the generation of authentication credentials is terminated when the local usage count is not less than the preset usage threshold. Increment the local usage count to get the current usage index, and read the one-time private key and Merkle authentication path corresponding to the current usage index; The access message, context pseudonym, Merkle root, link tag, normalized service context, and current index are concatenated sequentially and input into the authentication message digest hash function to obtain the digest to be signed. A one-time private key is used to sign the digest to be signed, and the current index, Merkle authentication path, one-time signature, and context credentials are encapsulated into authentication credentials.

6. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 5, characterized in that, Parse the currently used index, Merkle authentication path, one-time signature, and context credentials; verify that the service context in the context credentials matches the current service context; and check whether the currently used index is within the preset usage limits. Based on the registry's hash signature public key, the credential signature data formed by sequentially concatenating the context pseudonym, Merkle root, link tag, and normalized service context, as well as the registry signature, are verified. Regenerate the digest to be verified according to the same field order when the authentication credential was generated. Reconstruct the candidate one-time public key based on the one-time signature and the digest to be verified. Compress the candidate one-time public key into a candidate Merkle leaf node. Combine the currently used index and the Merkle authentication path to reconstruct the candidate Merkle root layer by layer. Compare the candidate Merkle root with the Merkle root in the context credential. If any verification fails, output an invalid authentication result. For two valid authentication credentials, output a result showing a link relationship if their service contexts and link tags are identical.

7. The hash-based post-quantum context-constrained pseudo-name authentication method as described in claim 6, characterized in that, Extract the currently used index and link tag from the verified authentication credentials, and query the usage counter record in the count status table with the link tag as the index; If the usage counter exists, the current usage index is equal to the usage counter value, and the usage counter value is less than the preset usage limit, the usage counter value is atomically updated to the current usage index plus one and the authentication acceptance result is output; otherwise, the authentication rejection result is output. Multiple edge servers synchronize a count state table and an undo set by sharing a state store; In response to a device revocation command, the identity of the device to be revoked is added to the revocation set. The combined registration set is traversed to determine the service contexts corresponding to the device. The link tags corresponding to each service context are obtained from the device registry. The usage counter records indexed by each link tag are deleted from the count status table.

8. A hash-based post-quantum context-constrained pseudo-name authentication system, characterized in that, include: Initialization and Master Key Generation Module: The registration authority initializes the hash signature environment based on security parameters and preset usage limits, generates public parameters and registration authority status, and IoT devices generate user master keys locally; Registration request generation module: Normalizes the service context, derives a number of one-time signature key pairs corresponding to the preset usage limit value based on the user master key and the normalized service context, constructs a Merkle root based on the public key in the key pair, and generates a link tag corresponding to the service context. It encapsulates the device identity, service context, Merkle root and link tag into a registration request. Context credential generation module: The registration authority verifies the revocation status of the device identity and the registration status of the combination of device identity and service context, performs hash signature on the context pseudonym, Merkle root, link tag and normalized service context to form context credentials, and initializes the usage counter corresponding to the link tag; Authentication credential generation module: The IoT device determines the local usage count corresponding to the service context as the current usage index, performs a one-time signature on the digest of the bound access message, context credential, service context and current usage index based on the one-time private key corresponding to the current usage index, and attaches the corresponding Merkle authentication path to form authentication credentials; Authentication verification and link determination module: The edge server verifies the context matching relationship, the current index range, the context credential signature, the one-time signature, and the Merkle tree root consistency in the authentication credentials. For two verified authentication credentials, the link relationship is determined based on their service context and link tags. Using the status check and count update module: After the authentication credential is verified, the status check node reads the corresponding usage counter according to the link tag, and performs a judgment based on the current usage index, the usage counter value and the preset usage limit. It then atomically updates the usage counter to the current usage index and accepts or rejects authentication. In response to the authentication and authorization result, the IoT device updates the local usage count to the current usage index.

9. An electronic device, characterized in that, It includes a processor, a memory, and a computer program stored in the memory and executable on the processor, wherein the computer program, when executed by the processor, implements a hash-based post-quantum context-constrained pseudo-name authentication method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, A computer program is stored on the computer-readable storage medium, which, when executed by a processor, implements a hash-based post-quantum context-constrained pseudo-name authentication method as described in any one of claims 1 to 7.

Images