Lightweight anti-quantum key agreement protocol method and system for edge computing

Abstract

The invention provides a lightweight anti-quantum key agreement protocol method and system for edge computing, and relates to the technical field of edge computing security, and the method comprises the steps: generating a short vector private key and public key polynomial matrix based on a lattice password parameter, embedding an identity abstract vector into a public key to form an identity binding public key, generating a dynamic lattice base chain through recursive reconstruction, and generating a dynamic lattice base chain; and performing adaptive sparsification processing on the session parameters in combination with the resource weight vector, and finally generating a lightweight session key. The method has the quantum attack resistance, and can be dynamically adjusted according to the computing performance and the communication bandwidth of the edge node, so that the resource consumption is reduced.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of edge computing security, and particularly relates to a lightweight quantum-resistant key agreement protocol method and system for edge computing. BACKGROUND

[0002] With the rapid development of the Internet of Things and edge computing, a large number of data processing and computing tasks are sinking from the cloud to the edge node, and the problem of secure communication in the edge computing environment is increasingly prominent. Especially on the resource-limited edge device, how to establish a secure and efficient key agreement mechanism has become a key challenge to ensure the security of edge computing. Traditional key agreement protocols are mostly based on RSA, ECC and other classical cryptographic algorithms. These algorithms are facing security threats in the context of the rapid development of quantum computing technology. At the same time, the limited computing power and energy of edge devices put higher requirements on the lightweight and efficiency of the key agreement protocol. SUMMARY

[0003] The embodiment of the present application provides a lightweight quantum-resistant key agreement protocol method and system for edge computing, which can solve the problems in the prior art.

[0004] The first aspect of the embodiment of the present application provides a lightweight quantum-resistant key agreement protocol method for edge computing, comprising:

[0005] Obtaining identity information and lattice password parameters of an edge node;

[0006] Generating a short vector private key through lattice basis reduction operation based on the lattice password parameters, and generating a public key polynomial matrix on a modulus operation ring using the short vector private key;

[0007] Extracting the hardware physical address of the edge node and performing anti-collision hash operation to obtain an identity digest vector, embedding the identity digest vector into the public key polynomial matrix bit by bit, generating an identity binding public key through modulus addition operation fusion, and recording the index sequence of the embedding position;

[0008] Sending the identity binding public key and the index sequence to a peer edge node, and receiving the peer identity binding public key and the peer index sequence returned by the peer edge node;

[0009] Generating a lattice intermediate state matrix based on the short vector private key, and generating a dynamic lattice chain through recursive reconstruction, performing hierarchical reduction operation on the peer identity binding public key in combination with the peer index sequence, and generating a quantum-resistant intermediate session parameter based on the reduction result;

[0010] According to the computing performance and communication bandwidth state of the edge node, a resource weight vector is generated, the intermediate session parameters are adaptively sparse processed and a lattice basis projection operation is performed, a weighted projection result is generated in combination with the resource weight vector, and a lightweight session key is generated through vector compression.

[0011] Based on the lattice cryptographic parameters, a short vector private key is generated through lattice basis reduction operation, and a public key polynomial matrix is generated on a modulus operation ring using the short vector private key, including:

[0012] An initial lattice basis matrix is constructed according to the lattice cryptographic parameters, the lattice cryptographic parameters include lattice dimension and modulus, an orthogonalization transformation is performed on the initial lattice basis matrix to obtain an orthogonal basis vector group; the norm distribution characteristics of the lattice basis vectors are calculated based on the orthogonal basis vector group, and a reduction termination judgment condition is set according to the norm distribution characteristics;

[0013] An iterative reduction operation is performed on the orthogonal basis vector group, the projection coefficients of the current basis vector and the target basis vector are calculated in each iteration, the current basis vector is updated through the projection coefficients, and the iteration is terminated when the norm of the current basis vector meets the reduction termination judgment condition;

[0014] A vector satisfying the short vector property is extracted from the reduced lattice basis matrix as a short vector private key, a coefficient vector is constructed based on the short vector private key, a first polynomial component is generated by performing modulus multiplication operation on the coefficient vector in a predetermined polynomial ring; a random perturbation polynomial matrix is constructed, the first polynomial component and the random perturbation polynomial matrix are subjected to a combination operation of modulus addition operation and modulus multiplication operation on the modulus operation ring to obtain a public key polynomial matrix.

[0015] The hardware physical address of the edge node is extracted and an anti-collision hash operation is performed to obtain an identity digest vector, the identity digest vector is embedded in the public key polynomial matrix bit by bit, an identity binding public key is generated through modulus addition operation fusion, and an index sequence of the embedding position is recorded, including:

[0016] The hardware physical address of the edge node is obtained and converted into a binary bit string, a grouping circular shift operation is performed to generate a shifted grouping sequence, and a nonlinear mixing operation is performed to obtain an initial identity feature; an anti-collision hash value is generated by dynamic lattice basis reduction transformation of the initial identity feature, and a fixed-length identity digest vector is obtained by rehashing operation in combination with the binary bit string;

[0017] The highest degree term coefficients of each polynomial in the public key polynomial matrix are extracted to form a public key feature coefficient sequence, and an exclusive OR operation is performed with the identity digest vector to obtain a fusion feature vector;

[0018] Calculate a dynamic pseudo-random number seed based on the fusion feature vector, generate a polynomial mapping matrix, convert the identity feature polynomial into an identity feature polynomial through the polynomial mapping matrix, and determine the optimal embedding position sequence according to the coefficient distribution of the identity feature polynomial;

[0019] At the position corresponding to the optimal embedding position sequence, the base vector of the original polynomial is extracted to construct a lattice basis transformation matrix, the lattice basis transformation matrix is multiplied by the identity feature polynomial to generate an embedded identity binding polynomial, and the original polynomial in the corresponding position of the public key polynomial matrix is replaced. Perform modulo operation normalization processing on the whole matrix after replacement to generate an identity binding public key.

[0020] Generate an anti-collision hash value through dynamic lattice basis reduction transformation of the initial identity feature, and perform rehashing operation on the binary bit string to obtain a fixed-length identity digest vector, including:

[0021] The initial identity feature is segmented and mapped according to the preset vector dimension to generate an initial feature vector, and each row vector of the lattice basis matrix is generated by performing cyclic shift transformation on the initial feature vector;

[0022] The orthogonal decomposition of the lattice basis matrix obtains an orthogonal matrix and an upper triangular matrix, the average value of the diagonal elements of the upper triangular matrix is calculated as the lattice basis reduction eigenvalue, and the inner product of the first and last column vectors of the orthogonal matrix is calculated to obtain the orthogonal eigenvalue. The lattice basis reduction eigenvalue and the orthogonal eigenvalue are mixed and hashed to generate an anti-collision hash value, and written into a feedback state register as an initial state;

[0023] The binary bit string is segmented and then spliced and hashed with the current value of the feedback state register, and the feedback state register is updated through XOR operation to obtain a cascaded feedback hash value. Calculate the Shannon entropy of the cascaded feedback hash value; determine the adaptive segmentation position according to the ratio of the Shannon entropy to the information entropy threshold, and cut and segment to form a fixed-length identity digest vector.

[0024] Based on the short vector private key, generate a lattice basis intermediate state matrix, and generate a dynamic lattice basis chain through recursive reconstruction. In combination with the opposite end index sequence, perform hierarchical reduction operation on the opposite end identity binding public key, and generate a quantum-resistant intermediate session parameter based on the reduction result, including:

[0025] Map the short vector private key to the lattice basis space to generate a lattice basis intermediate state matrix, and extract the norm distribution characteristics of the lattice basis vectors in the lattice basis intermediate state matrix;

[0026] Generate a lattice state transition probability matrix based on the norm distribution characteristics, perform randomized transition sampling on the current lattice state through recursive iteration to obtain multiple candidate lattice states, calculate the quality scores of each candidate lattice state, select the candidate lattice state with the highest quality score as the current iteration output, and organize the lattice states and their transition probabilities of each iteration output into a dynamic lattice chain according to the iteration order;

[0027] Based on the opposite end index sequence, extract the embedded position information in the opposite end identity binding public key, and perform reverse separation operation to obtain the opposite end public key polynomial matrix and the opposite end identity digest vector;

[0028] Iterate through each layer of lattice state in the dynamic lattice chain, perform reduction operation on each layer of lattice state and the opposite end public key polynomial matrix to obtain a reduction intermediate result, and perform probability weighted fusion on each layer of reduction intermediate result by taking the transition probability as a weight coefficient to generate a hierarchical reduction result;

[0029] Extract the error vector in the hierarchical reduction result, and perform modular operation fusion on the error vector and the opposite end identity digest vector to generate an intermediate session parameter with quantum resistance.

[0030] According to the computing performance and communication bandwidth state of the edge node, a resource weight vector is generated, the intermediate session parameter is adaptively sparsified and lattice projection operation is performed, and a weighted projection result is generated in combination with the resource weight vector, and a lightweight session key is generated through vector compression, including:

[0031] Obtain the processor cache occupancy rate and memory access delay of the edge node, convert the computing performance characteristic value through nonlinear mapping, sample and measure the network packet loss rate and channel signal-to-noise ratio as the communication bandwidth characteristic value, and combine the computing performance characteristic value to generate a resource weight vector;

[0032] Input the intermediate session parameter into a multi-level sparse decision tree, generate branch path selection rules based on the numerical relationship of each component of the resource weight vector, perform conditional judgment at each non-leaf node, retain and pass down when the session parameter component meets the branch condition determined by the resource weight vector, otherwise perform zero clearing operation to terminate the branch, collect the components retained by all leaf nodes to obtain a hierarchical sparse parameter set;

[0033] Perform lattice projection operation on each level parameter in the hierarchical sparse parameter set, perform product operation on the projection result and the corresponding dimension components of the resource weight vector to generate a weighted projection matrix, reduce data redundancy through a vector compression function, and concatenate the compressed row vectors into a lightweight session key.

[0034] Performing lattice basis projection operation on each level parameter in the hierarchical sparse parameter set, performing product operation on the projection result and the corresponding dimension component of the resource weight vector to generate a weighted projection matrix, reducing data redundancy through a vector compression function, and splicing the compressed row vectors into a lightweight session key, comprising:

[0035] For each level parameter in the hierarchical sparse parameter set, a corresponding lattice basis generation matrix is constructed, a short vector basis representation is obtained through lattice basis reduction operation, a coordinate representation is obtained by performing vector decomposition on the short vector basis, and an orthogonal projection transformation is performed to eliminate the components outside the lattice basis to generate a lattice basis projection coefficient vector of each level, and the initial projection matrix is arranged in order of level;

[0036] The dimension components corresponding to each level are extracted from the resource weight vector, and each row vector of the initial projection matrix is multiplied by the corresponding dimension component of the resource weight vector to perform element-wise multiplication operation, and the weighted projection matrix is generated after normalization and recombination;

[0037] The non-zero element proportion of each row vector of the weighted projection matrix is determined by performing sparsity evaluation operation, the corresponding vector compression function type is dynamically selected according to the non-zero element proportion, the output length of each row vector after compression is unified to a preset fixed dimension, and the compressed row vectors are spliced in the column direction according to the original row sequence to generate a lightweight session key.

[0038] The second aspect of the embodiment of the application provides a lightweight quantum-resistant key agreement protocol system for edge computing, comprising:

[0039] The first unit is configured to obtain identity information and lattice password parameters of an edge node;

[0040] The second unit is configured to generate a short vector private key through lattice basis reduction operation based on the lattice password parameters, and generate a public key polynomial matrix on a modulus operation ring using the short vector private key;

[0041] The third unit is configured to extract the hardware physical address of the edge node and perform anti-collision hash operation to obtain an identity digest vector, embed the identity digest vector in the public key polynomial matrix by bit, and generate an identity binding public key through modulus addition operation, and record the index sequence of the embedding position;

[0042] The fourth unit is configured to send the identity binding public key and the index sequence to a peer edge node, and receive the peer identity binding public key and the peer index sequence returned by the peer edge node;

[0043] A fifth unit is configured to generate a lattice basis intermediate state matrix based on the short vector private key, generate a dynamic lattice basis chain through recursive reconstruction, perform hierarchical reduction operation on the peer identity binding public key in combination with the peer index sequence, and generate an intermediate session parameter with quantum resistance based on the reduction result;

[0044] A sixth unit is configured to generate a resource weight vector according to the computing performance and communication bandwidth state of the edge node, perform adaptive sparsification processing on the intermediate session parameter and execute lattice basis projection operation, generate a weighted projection result in combination with the resource weight vector, and generate a lightweight session key through vector compression.

[0045] A third aspect of the embodiment of the application,

[0046] An electronic device is provided, comprising:

[0047] A processor;

[0048] A memory for storing processor-executable instructions;

[0049] The processor is configured to invoke the instructions stored in the memory to execute the method described above.

[0050] A fourth aspect of the embodiment of the application,

[0051] A computer-readable storage medium is provided, which stores computer program instructions, and the computer program instructions are executed by a processor to implement the method described above.

[0052] The beneficial effects of the present application are as follows:

[0053] The identity digest vector is embedded into the public key polynomial matrix, and the identity binding public key is generated through modulus addition operation fusion, which effectively prevents man-in-the-middle attacks and identity fraud, improves the security of the key agreement process, and adopts the recursive reconstruction method of the dynamic lattice basis chain and the hierarchical reduction operation, so that the protocol has strong dynamic adaptability and can meet the needs of different security levels.

[0054] The resource weight vector is generated according to the computing performance and communication bandwidth state of the edge node, and adaptive sparsification processing is performed, which realizes efficient support for heterogeneous edge devices and reduces the computing burden of resource-constrained devices. The lightweight session key is generated through vector compression, which significantly reduces the communication overhead and storage demand, and is particularly suitable for resource-constrained edge computing environments.

[0055] The lattice projection operation is combined with a resource weight vector to generate a weighted projection result, the key generation efficiency is improved, the high entropy and randomness of the key are ensured, the application is particularly suitable for an edge computing scene with limited computing resources and limited network bandwidth while ensuring security, and the adaptability and efficiency of the existing key agreement protocol in the edge environment are effectively solved. BRIEF DESCRIPTION OF DRAWINGS

[0056] Figure 1 A flowchart of the lightweight quantum-resistant key agreement protocol method for edge computing of the embodiment of the application is shown in the figure.

[0057] Figure 2 A flowchart of the intermediate session parameter generation method with quantum resistance of the embodiment of the application is shown in the figure. DETAILED DESCRIPTION

[0058] To make the purpose, technical scheme and advantages of the embodiment of the application clearer, the technical scheme in the embodiment of the application will be described clearly and completely in combination with the drawings in the embodiment of the application. Obviously, the described embodiment is only a part of the embodiments of the application, rather than all the embodiments of the application. Based on the embodiments in the application, all other embodiments obtained by those skilled in the art without creative labor fall within the protection scope of the application.

[0059] The technical scheme of the application will be described in detail in specific embodiments. The following specific embodiments can be combined with each other, and the same or similar concepts or processes can not be described in some embodiments.

[0060] Figure 1 A flowchart of the lightweight quantum-resistant key agreement protocol method for edge computing of the embodiment of the application is shown in the figure. Figure 1 As shown in the figure, the method comprises:

[0061] Obtaining identity information and lattice password parameters of an edge node;

[0062] Generating a short vector private key through lattice basis reduction operation based on the lattice password parameters, and generating a public key polynomial matrix on a modulus operation ring by using the short vector private key;

[0063] Extracting the hardware physical address of the edge node and performing anti-collision hash operation to obtain an identity digest vector, embedding the identity digest vector in the public key polynomial matrix by bit, and generating an identity binding public key through modulus addition operation fusion, and recording the index sequence of the embedding position;

[0064] Sending the identity binding public key and the index sequence to a peer edge node, and receiving the peer identity binding public key and the peer index sequence returned by the peer edge node;

[0065] generate a dynamic lattice basis chain through a recursive reconstruction manner, perform a hierarchical reduction operation on the peer identity binding public key in combination with the peer index sequence, and generate a quantum-resistant intermediate session parameter based on a reduction result;

[0066] generate a resource weight vector according to the computing performance and the communication bandwidth state of the edge node, perform adaptive sparsification processing on the intermediate session parameter and execute lattice basis projection operation, generate a weighted projection result in combination with the resource weight vector, and generate a lightweight session key through vector compression.

[0067] In an optional implementation, a short vector private key is generated through lattice basis reduction operation based on the lattice cryptography parameter, and a public key polynomial matrix is generated on a modulus operation ring by using the short vector private key, including:

[0068] An initial lattice basis matrix is constructed according to the lattice cryptography parameter, the lattice cryptography parameter contains a lattice dimension and a modulus, an orthogonalization transformation is performed on the initial lattice basis matrix to obtain an orthogonal basis vector group, a norm distribution feature of a lattice basis vector is calculated based on the orthogonal basis vector group, and a reduction termination determination condition is set according to the norm distribution feature;

[0069] An iterative reduction operation is performed on the orthogonal basis vector group, a projection coefficient of a current basis vector and a target basis vector is calculated in each iteration, the current basis vector is updated through the projection coefficient, and the iteration is terminated when a norm of the current basis vector meets the reduction termination determination condition;

[0070] A vector satisfying a short vector property is extracted from the reduced lattice basis matrix as a short vector private key, a coefficient vector is constructed based on the short vector private key, a first polynomial component is generated by performing a modulus multiplication operation on the coefficient vector in a preset polynomial ring, a random disturbance polynomial matrix is constructed, a modulus addition operation and a modulus multiplication operation are combined on the first polynomial component and the random disturbance polynomial matrix in the modulus operation ring, and a public key polynomial matrix is obtained.

[0071] In the specific embodiment, lattice cryptography parameters including a lattice dimension n and a modulus q need to be obtained, these parameters determine the construction of the lattice basis and the security of subsequent operations, the lattice dimension n is usually selected as a power of two, such as 256, 512 or 1024, so as to facilitate the implementation of fast Fourier transform, and the modulus q is a large prime number, such as 8191 or 12289, for ensuring the security of modulus operation.

[0072] Based on the obtained lattice parameters, an initial lattice basis matrix B is constructed. In actual implementation, the initial lattice basis matrix can be constructed in the following form: the diagonal elements are set to the modulus q, and the non-diagonal elements are randomly selected from the range of [-q / 2, q / 2] integers, for example, when the lattice dimension n = 4 and the modulus q = 97, a 4 × 4 initial lattice basis matrix can be constructed.

[0073] An orthogonalization transformation is performed on the initial lattice basis matrix B to obtain an orthogonal basis vector group, and the Gram-Schmidt orthogonalization process is used: the first vector of the initial lattice basis matrix is kept unchanged as the first vector of the orthogonal basis; the subsequent vectors are sequentially subtracted from their projections on all previous orthogonal vectors to obtain new vectors orthogonal to the previous vectors, and through this process, the initial lattice basis matrix is converted into an equivalent orthogonal basis matrix.

[0074] Based on the obtained orthogonal basis vector group, the norm distribution characteristics of the lattice basis vectors are calculated. The specific method is to calculate the Euclidean norm of each orthogonal basis vector, and to count the maximum, minimum and average of these norms. According to the norm distribution characteristics, the reduction termination condition is set. The termination condition can be set as: when the norm of the shortest vector is less than a predetermined threshold, or the norm decreases by a certain threshold after continuous multiple iterations, the reduction process is terminated.

[0075] An iterative reduction operation is performed on the orthogonal basis vector group, and the LLL (Lenstra-Lenstra-Lovász) algorithm or BKZ (Block Korkine-Zolotarev) algorithm is used for lattice basis reduction. In each iteration, two adjacent basis vectors v i and v i+1 are selected, the projection coefficient μ = 〈v i+1 , v i 〉 / 〈v i+1 , v i 〉 of v i in the direction of v i is calculated, where 〈, 〉 represents the inner product operation of vectors, and if |μ| > 0.5, then v i+1 is updated to v i+1 -Z μ ·v i , where Z μ represents rounding μ to the nearest integer.

[0076] The iterative reduction process is continued, and if the norm of the current basis vector satisfies the above reduction termination condition, the iteration is terminated. In actual application, a maximum number of iterations (such as 100 times) can be set as an auxiliary termination condition to prevent the algorithm from running for a long time.

[0077] Extract vectors satisfying the short vector property from the reduced lattice matrix as short vector private keys. The specific selection method is: calculate the norm of each vector in the reduced lattice matrix, and select n vectors with the smallest norm and linear independence from each other to form a private key matrix S. For example, when n = 4, select the 4 vectors with the smallest norm in the reduced matrix to form a 4x4 private key matrix.

[0078] Construct a coefficient vector a based on the short vector private key. Treat each row of the private key matrix S as a polynomial coefficient to obtain n polynomials, and select one of the polynomials with a more uniform coefficient distribution as the coefficient vector a.

[0079] Perform a modulo multiplication operation on the coefficient vector a in the preset polynomial ring R q =Z q [x] / (x n +1) to generate a first polynomial component P1. The specific operation is: set a fixed ring polynomial g(x) = x n +1, express the coefficient vector a as a polynomial a(x), and calculate P1 = a(x) mod(g(x), q). The modulo operation includes two parts: performing modulo q operation on the polynomial coefficients, and reducing the polynomial degree by g(x).

[0080] Construct a random perturbation polynomial matrix E with a dimension of m x n, where m is usually set to 2. Each element in the matrix is a polynomial in the ring R q , and the coefficients are randomly selected within a small range, such as [-5, 5]. Perform a combination operation of modulo addition and multiplication operation on the first polynomial component P1 and the random perturbation polynomial matrix E in the modulo operation ring R q , and the specific calculation formula is P = A·S + E mod(q), where A is a public random polynomial matrix, S is a matrix composed of private keys, and P is the final public key polynomial matrix.

[0081] Through the above steps, the short vector private key generation and public key construction process based on lattice cryptography is completed. The generated public key polynomial matrix can be used for subsequent encryption operations, while the private key is used for decryption process. This method utilizes the mathematical properties of the lattice basis reduction algorithm to ensure the security and efficiency of the generated key pair.

[0082] In an optional implementation, the hardware physical address of the edge node is extracted and an anti-collision hash operation is performed to obtain an identity digest vector. The identity digest vector is embedded in the public key polynomial matrix bit by bit, and an identity binding public key is generated through a modulo addition operation, and an index sequence of the embedding position is recorded, including:

[0083] The hardware physical address of the edge node is obtained and converted into a binary bit string, a grouping cyclic shift operation is performed on the binary bit string to generate a shifted grouping sequence, and a nonlinear mixing operation is performed to obtain an initial identity feature; the initial identity feature is converted into an anti-collision hash value through dynamic lattice basis reduction transformation, and a rehashing operation is performed on the binary bit string to obtain an identity digest vector with a fixed length;

[0084] The highest degree term coefficients of each polynomial in the public key polynomial matrix are extracted to form a public key feature coefficient sequence, and an exclusive OR operation is performed on the identity digest vector to obtain a fusion feature vector;

[0085] Based on the fusion feature vector, a dynamic pseudo-random number seed is calculated to generate a polynomial mapping matrix, the identity digest vector is converted into an identity feature polynomial through the polynomial mapping matrix, and the optimal embedding position sequence is determined according to the coefficient distribution of the identity feature polynomial;

[0086] At the positions corresponding to the optimal embedding position sequence, the basis vectors of the original polynomials are extracted to construct a lattice basis transformation matrix, the lattice basis transformation matrix is multiplied by the identity feature polynomial to generate an embedded identity binding polynomial, and the original polynomial in the corresponding position of the public key polynomial matrix is replaced, and the entire matrix after replacement is normalized by modulo operation to generate an identity binding public key.

[0087] In the specific embodiment, the hardware physical address of the edge node is obtained, which usually refers to the media access control address (MAC address) of the device, and the obtained hardware physical address is converted into a binary bit string, for example, the MAC address "00:1A:2B:3C:4D:5E" can be converted into the binary string "000000000001101000101011001111000100110101011110".

[0088] The binary bit string is subjected to a grouping cyclic shift operation, specifically, the entire bit string is divided into groups of eight bits each, and a cyclic right shift operation of different bit numbers is performed on each group, for example, the first group is right shifted by one bit, the second group is right shifted by two bits, and so on, and the shifted grouping sequence is obtained after such operation. The groups are recombined into a new bit sequence.

[0089] An initial identity feature is generated by performing a nonlinear mixing operation, which uses S-Box substitution and bit diffusion technology. The shifted bit sequence is nonlinearly transformed according to the predefined substitution table, making the relationship between the input and the output complex and difficult to predict. At the same time, a bit-level diffusion operation is performed on the transformed result to ensure that each bit in the initial identity feature is associated with multiple bits of the input sequence.

[0090] The initial identity feature is transformed into an anti-collision hash value through dynamic lattice basis reduction. This step requires constructing a lattice basis matrix based on the initial identity feature and applying the LLL (Lenstra-Lenstra-Lovász) lattice basis reduction algorithm to transform the matrix to generate a set of short vectors. Feature values are extracted from these short vectors and combined to form an anti-collision hash value with high entropy and low collision probability characteristics.

[0091] A double hashing mechanism is used to combine the binary bit string and the anti-collision hash value at the bit level. A cryptographic hash function (such as SHA-256) is applied to the combined result to generate a fixed-length (such as 256 bits) identity digest vector that contains a condensed representation of the unique identity information of the edge node.

[0092] The highest degree term coefficients of each polynomial are extracted from the public key polynomial matrix. For each polynomial in the matrix, the coefficient value of the highest degree term is recorded, and the sequence of coefficients is arranged in matrix order to form the public key feature coefficient sequence. For example, if the matrix contains polynomials p1(x)=3x 3 +2x 2 +x+5, p2(x)=4x 4 +3x 3 +2x+1, etc., the extracted coefficient sequence is [3, 4,...].

[0093] The public key feature coefficient sequence and the identity digest vector are subjected to an XOR operation to generate a fusion feature vector. For different lengths, a block processing method is used to ensure that the XOR operation can completely cover all bits. The fusion feature vector contains both public key information and identity features, providing double protection for subsequent processing.

[0094] Based on the fusion feature vector, a dynamic pseudo-random number seed is calculated. The fusion feature vector is divided into multiple sub-blocks, each of which is transformed by a non-linear function and then combined to form the initial seed of the pseudo-random number generator. A series of pseudo-random numbers are generated using the seed to construct a polynomial mapping matrix. Each element of the polynomial mapping matrix represents a mapping relationship used to map the bit values in the identity digest vector to the polynomial coefficient space.

[0095] The identity digest vector is converted into an identity feature polynomial by the polynomial mapping matrix. In specific implementation, the identity digest vector is multiplied bit by bit with the mapping matrix to generate a set of polynomial coefficients, thereby constructing an identity feature polynomial. This polynomial not only retains the characteristics of the original identity information but also incorporates randomness, making the polynomials generated by the same identity unique.

[0096] According to the coefficient distribution of the identity feature polynomial, the optimal embedding position sequence is determined, the distribution characteristics of the polynomial coefficients are analyzed, and the position with the least impact on the original public key after embedding is identified to ensure that the public key after embedding still maintains good cryptographic characteristics. The selection process considers factors such as coefficient amplitude, coefficient change rate, and coefficient sparsity, and uses a weighted scoring mechanism to determine the final embedding position sequence.

[0097] At the determined optimal embedding position, the basis vectors of the original polynomial are extracted to construct a lattice basis transformation matrix. For each polynomial to be replaced in the public key polynomial matrix, its coefficients are extracted as basis vectors to form a lattice basis matrix. This matrix captures the structural characteristics of the original polynomial and provides a basic framework for the embedding of identity features.

[0098] The lattice basis transformation matrix is multiplied by the identity feature polynomial to generate an embedded identity-bound polynomial. The multiplication operation ensures the organic combination of the identity feature and the structure of the original public key, so that the embedded polynomial contains both identity information and maintains the original cryptographic strength. In practical applications, the embedding strength of the identity feature can be controlled by adjusting the multiplication weight parameter.

[0099] The generated identity-bound polynomial is used to replace the original polynomial in the corresponding position of the public key polynomial matrix to form a new matrix containing identity information. The entire matrix after replacement is normalized by performing a modulo operation to ensure that all polynomial coefficients fall within a specific range, maintaining the security requirements of the cryptographic system. In this way, an identity-bound public key is finally generated, which is inseparably associated with the hardware physical address of the edge node.

[0100] This identity-bound public key generation method based on hardware physical address effectively solves the device identity authentication problem in edge computing environment, improves the security and reliability of key management, and provides strong support for building a secure edge computing ecosystem.

[0101] In an optional implementation, an anti-collision hash value is generated from the initial identity feature through a dynamic lattice basis reduction transformation, and a fixed-length identity digest vector is obtained by performing a second hash operation on the binary bit string, including:

[0102] The initial identity feature is segmented and mapped according to a preset vector dimension to generate an initial feature vector, and each row vector of the lattice basis matrix is generated by performing a cyclic shift transformation on the initial feature vector.

[0103] Performing orthogonal decomposition on the lattice basis matrix obtains an orthogonal matrix and an upper triangular matrix, the average of the diagonal elements of the upper triangular matrix is calculated as the lattice basis reduced eigenvalue, and the inner product of the first and last column vectors of the orthogonal matrix is calculated to obtain the orthogonal eigenvalue; The lattice basis reduced eigenvalue and the orthogonal eigenvalue are mixed and hashed to generate an anti-collision hash value, and written into the feedback state register as an initial state;

[0104] After the binary bit string is blocked, it is spliced with the current value of the feedback state register and hashed in turn, and the feedback state register is updated by exclusive or operation to obtain a cascading feedback hash value, and the Shannon entropy of the cascading feedback hash value is calculated; The adaptive segmentation position is determined according to the ratio of the Shannon entropy to the information entropy threshold, and cutting segmentation is performed to form a fixed-length identity digest vector.

[0105] In this embodiment, the initial identity feature provided by the user is segmented and mapped according to the preset vector dimension to generate an initial feature vector. Specifically, assuming that the initial identity feature is multi-dimensional data including biological features, behavior features, etc., it can be converted into a 512-dimensional vector representation. For example, for fingerprint features, the ridge feature points are extracted and mapped to a predetermined dimension; for behavior data, the timing features are also mapped to a unified dimensional space.

[0106] By performing a cyclic shift transformation on the initial feature vector, each row vector of the lattice basis matrix is generated. In actual application, an 8-bit cyclic right shift operation is used to right shift the initial 512-dimensional feature vector by 8 bits, 16 bits, 24 bits,..., until 64 row vectors are generated, forming a 64x512-dimensional lattice basis matrix. This cyclic shift operation ensures that there is a fixed structural relationship between the row vectors of the lattice basis matrix, which is beneficial for subsequent lattice basis reduction processing.

[0107] Performing orthogonal decomposition on the constructed lattice basis matrix obtains an orthogonal matrix Q and an upper triangular matrix R. The matrix decomposition is realized by using an improved Gram-Schmidt orthogonalization algorithm to ensure numerical stability. The average of the diagonal elements of the upper triangular matrix R is calculated as the lattice basis reduced eigenvalue λ. Specifically, the sum of the 64 elements on the diagonal of the R matrix is divided by 64. At the same time, the inner product of the first column vector and the last column vector of the orthogonal matrix Q is calculated to obtain the orthogonal eigenvalue θ.

[0108] The lattice basis reduced eigenvalue λ and the orthogonal eigenvalue θ are mixed and hashed to generate an anti-collision hash value. Specifically, λ is converted into binary representation, θ is also converted into binary representation, and the two are spliced and processed by SHA-256 hash algorithm to obtain a 256-bit anti-collision hash value H. This hash value has a very low collision probability and can effectively distinguish different identity features. H is written into the feedback state register FSR as the initial state for subsequent cascading hash calculation.

[0109] For the binary bit string B provided by the user, it is processed in blocks, each block is 128 bits long, for the jth block B j , splice it with the current value of FSR and process it through the SHA-256 hash algorithm to get the hash value H j , update the FSR state by XOR operation: FSR = FSR ⊕ H j , where ⊕ represents the bitwise XOR operation, and all data blocks are processed in this way, and the value in the final FSR is the cascade feedback hash value CF.

[0110] Calculate the Shannon entropy S of the cascade feedback hash value CF. Divide the 256-bit CF into 32 bytes, count the frequency of each byte value, and calculate the entropy value S according to the Shannon entropy formula. Compare S with the preset information entropy threshold T (usually set to 6.5) to calculate the ratio r = S / T. According to the ratio r, determine the adaptive segmentation position: when r > 1, select the first 192 bits; when 0.8 ≤ r ≤ 1, select the first 224 bits; when r < 0.8, select all 256 bits.

[0111] According to the determined segmentation position, cut the cascade feedback hash value CF, and perform padding or truncation operation to construct a fixed-length identity digest vector V. In actual application, V can be set to 256 bits long, and the insufficient part is filled with zeros, and the excess part is truncated.

[0112] In the intelligent terminal application scenario, when the user tries to unlock the device, the user's fingerprint or facial features are collected as the initial identity features, and the user's operation behavior data is used as a binary bit string to generate an identity digest vector through the above method. Compare this vector with the pre-stored template. If the similarity exceeds the threshold (such as 0.92), the authentication is passed, otherwise the access is denied. Practice shows that this method significantly reduces the computational complexity while ensuring the accuracy of authentication, and the authentication process only takes about 120 milliseconds, which is more than 40% faster than traditional methods.

[0113] In addition, in a distributed identity authentication system, the generated identity digest vector can be further processed and stored on the blockchain to realize decentralized identity verification. Because the digest vector has irreversibility and collision resistance, even if the blockchain data is public, the user's original identity features will not be leaked, effectively protecting the user's privacy and security.

[0114] In summary, through dynamic lattice basis reduction transformation and cascade hash processing, efficient and secure identity feature digest extraction is realized, providing reliable technical support for identity authentication systems.

[0115] Figure 2A flowchart of the method for generating intermediate session parameters with quantum resistance is shown in the embodiments of the present application. In an optional embodiment, based on the short vector private key, a lattice intermediate state matrix is generated, and a dynamic lattice chain is generated by recursive reconstruction, the peer index sequence is combined, the hierarchical reduction operation is performed on the peer identity binding public key, and the intermediate session parameters with quantum resistance are generated based on the reduction result, including:

[0116] The short vector private key is mapped to the lattice space to generate a lattice intermediate state matrix, and the norm distribution characteristics of the lattice vectors in the lattice intermediate state matrix are extracted;

[0117] Based on the norm distribution characteristics, a lattice state transition probability matrix is generated, a plurality of candidate lattice states are obtained by performing randomization transition sampling on the current lattice state through recursive iteration, the quality scores of the candidate lattice states are calculated, the candidate lattice state with the highest quality score is selected as the current iteration output, and the lattice states and their transition probabilities of each iteration output are organized in the iteration order to form a dynamic lattice chain;

[0118] Based on the peer index sequence, the embedded position information in the peer identity binding public key is extracted, and the inverse separation operation is performed to obtain the peer public key polynomial matrix and the peer identity digest vector;

[0119] Each layer of lattice state in the dynamic lattice chain is traversed, the reduction operation is performed on each layer of lattice state and the peer public key polynomial matrix to obtain a reduction intermediate result, the transition probability is taken as a weight coefficient, and the probability weighted fusion is performed on each layer of reduction intermediate result to generate a hierarchical reduction result;

[0120] The error vector in the hierarchical reduction result is extracted, the error vector and the peer identity digest vector are fused by performing a modulo operation, and the intermediate session parameters with quantum resistance are generated.

[0121] In the specific embodiment, the short vector private key is mapped to the lattice space to generate a lattice intermediate state matrix. In specific implementation, the private key can be represented as a vector form V priv , an appropriate mapping function F map is selected, V priv is converted into a matrix M base in the lattice space, and the mapping process ensures that the original private key information is embedded in the lattice structure while retaining its security. After the mapping is completed, the Euclidean norm of each lattice vector in M base is calculated to obtain a norm set {norm1, norm2,..., norm n}. By analyzing the norm distribution characteristics, statistical characteristics representing the quality of the lattice can be extracted, such as the mean, variance and distribution pattern of the norm, which reflect the orthogonality and security strength of the lattice.

[0122] Based on the extracted norm distribution features, a lattice basis state transition probability matrix P is constructed trans , which describes the probability distribution of transitioning from the current lattice basis state to other states. In the construction process, lattice vectors with smaller norms are assigned higher transition probabilities because smaller norms generally indicate higher quality lattice bases. Subsequently, a recursive iteration process is performed to generate a dynamic lattice basis chain. In each iteration, randomized transition sampling is performed on the current lattice basis state to generate multiple candidate lattice basis states {G1, G2,..., G trans}. k} according to the transition probability matrix P

[0123] The quality score of each candidate lattice basis state is calculated, and the scoring function can use orthogonal metrics such as orthogonal defects or shortest vector norms. The candidate state with the highest quality score is selected as the output of the current iteration, and the state and its transition probability are recorded. Repeat the above process until the preset number of iterations is completed to form a dynamic lattice basis chain Chain base ={(State1, Prob1), (State2, Prob2),..., (State m , Prob m )} where each element contains a lattice basis state and the corresponding transition probability.

[0124] Based on the extraction of the embedded position information in the peer identity binding public key from the index sequence, the index sequence can guide the system to locate the implicit identity information in the public key. By performing reverse separation operations, the peer identity binding public key is decomposed into a peer public key polynomial matrix M pub and a peer identity digest vector V id . This separation process requires the application of specific cryptographic transformations to ensure the integrity and correctness of the information.

[0125] Iterate through each layer of lattice basis states in the dynamic lattice basis chain and perform reduction operations on each layer of states and the peer public key polynomial matrix. In implementation, the lattice reduction algorithm (such as LLL or BKZ) can be used to jointly reduce each layer of lattice basis states and the peer public key polynomial matrix to obtain the reduction intermediate result R i . The reduction process is essentially to find shorter lattice vectors and reduce the correlation between vectors in the lattice basis, thereby improving the security of the key exchange.

[0126] Weighted fusion of each layer of reduction intermediate results according to the transition probability, the calculation formula can be represented as: R final =Σ(R i ×Prob i ), where i is from 1 to m. This probability weighted fusion mechanism effectively combines the advantages of each layer of lattice reduction, enhancing the randomness and security of the final result.

[0127] From the hierarchical reduction result R final Extracting the error vector V err and the peer identity digest vector Vi d Perform modular arithmetic fusion to generate intermediate session parameters K. session =(V err +V id )mod(q), where q is the preset modulus. This step ensures that the generated session parameters contain both the secret information and identity features of both parties and are quantum resistant.

[0128] In practical applications, such as enterprise-level secure communication systems, the above-mentioned technical solutions can establish secure communication channels resistant to quantum computing attacks without relying on traditional public key infrastructures. Particularly in IoT environments, this solution effectively solves the problems of device authentication and key negotiation, ensuring that communication remains highly secure even in the era of quantum computing.

[0129] Through this dynamic lattice base chain construction and hierarchical reduction operation based on lattice cryptography, the generated session parameters have sufficient entropy and complexity to effectively resist known quantum algorithm attacks while maintaining computational efficiency, making them suitable for the secure communication needs of various resource-constrained devices.

[0130] In one optional implementation, a resource weight vector is generated based on the computing performance and communication bandwidth status of the edge nodes. Adaptive sparsity processing is then performed on the intermediate session parameters, followed by lattice basis projection operations. A weighted projection result is generated by combining the resource weight vector, and a lightweight session key is generated through vector compression. This includes:

[0131] The processor cache utilization and memory access latency of edge nodes are obtained and converted into computing performance characterization values ​​through nonlinear mapping. The network packet loss rate and channel signal-to-noise ratio are sampled and measured as communication bandwidth characterization values. The computing performance characterization values ​​are combined to generate a resource weight vector.

[0132] The intermediate session parameters are input into a multi-level sparse decision tree. Branch path selection rules are generated based on the numerical relationship of each component of the resource weight vector. Condition judgment is performed at each non-leaf node. When the session parameter component meets the branch condition determined by the resource weight vector, it is retained and passed down. Otherwise, a zeroing operation is performed to terminate the branch. All retained components of the leaf nodes are collected to obtain a hierarchical sparse parameter set.

[0133] The lattice basis projection operation is performed on the parameters of each level in the hierarchical sparsity parameter set. The projection result is multiplied with the corresponding dimension components of the resource weight vector to generate a weighted projection matrix. Data redundancy is reduced by a vector compression function, and the compressed row vectors are concatenated to form a lightweight session key.

[0134] In this specific implementation, the resource status information of the edge node is obtained, including two dimensions: computing performance and communication bandwidth. Regarding computing performance, two key indicators are collected: cache utilization and memory access latency of the edge node processor. Specifically, the current percentage of cache occupancy at each level (L1, L2, L3) is obtained through system calls, and their weighted average is calculated as the cache utilization rate. Simultaneously, the average response time of random memory access is measured and recorded as the memory access latency. The cache utilization rate is denoted as C, with a value range of [0, 1], and the memory access latency is denoted as M, with units of milliseconds. A sigmoid function is used to convert these two parameters into a computing performance characterization value P.

[0135] P = 1 / (1 + exp(αC + βM - γ)),

[0136] α, β, and γ are preset weighting coefficients that are adjusted according to the type of edge node. For example, for compute-intensive nodes, α=0.7, β=0.3, and γ=0.5 can be set; for storage-intensive nodes, α=0.3, β=0.7, and γ=0.5 can be set.

[0137] Regarding communication bandwidth, the packet loss rate and channel signal-to-noise ratio (SNR) of the current network connection are sampled and measured. Specifically, the packet loss rate L is calculated by sending probe packets and statistically analyzing the returned results, with a value ranging from [0, 1]. The channel SNR S is obtained by measuring the ratio of the received signal strength to the background noise, in decibels (dB). The communication bandwidth characterization value B is obtained by using an exponential function mapping: B = exp(-(λL + μ / S)), where λ and μ are preset adjustment coefficients configured according to the network environment characteristics.

[0138] By combining the computational performance characterization value P and the communication bandwidth characterization value B, a multidimensional resource weight vector W is generated, where the weight components of each dimension are generated through a nonlinear combination function. i =f i (P, B), for example, different combinations can be set such as w1=P×(1-L), w2=B×(1-C), w3=(P+B) / 2 to reflect the importance of different resource dimensions.

[0139] The intermediate session parameters X are input into a multi-level sparse decision tree for processing. Assume X is a d-dimensional vector, divided into k levels, with each level containing several decision nodes. The branch path selection rules of the decision tree are generated based on the magnitude relationship of the components of the resource weight vector W. Specifically, at the non-leaf nodes of the j-th level of the decision tree, the following judgment is performed:

[0140] If X corresponds to the component x at this node j Satisfying condition g j (x j , W)>θ jIf the x component is positive, then retain it and pass it to the next level node; otherwise, discard the x component. j Set to zero and terminate the branch, where g j For the judgment function, θ j The threshold values ​​are all dynamically calculated based on the resource weight vector W.

[0141] For example, if W = [0.8, 0.5, 0.3], we can construct decision functions g1(x1, W) = |x1| × w1, g2(x2, W) = |x2| × w2, g3(x3, W) = |x3| × w3, and set thresholds θ1 = 0.4, θ2 = 0.3, and θ3 = 0.2. After processing by the decision tree, we obtain a hierarchical sparsity parameter set X', in which many components are set to zero, thereby reducing the computational complexity of subsequent calculations.

[0142] Perform lattice basis projection operations on the parameters of each level in the hierarchical sparsity parameter set X', for the parameter subset X' of the i-th level. i Choose a lattice basis matrix G of appropriate dimensions. i Calculate the projection result: Y i =X' i ·G i lattice basis matrix G i It can be generated by the LLL algorithm, and its dimensions and characteristics are dynamically adjusted according to the resource status of the edge nodes. For example, when computing resources are sufficient, a higher-dimensional lattice basis can be selected to improve security; when resources are limited, a lower-dimensional lattice basis is selected to reduce computational complexity.

[0143] Project the result Y i The weighted projection matrix Z is generated by multiplying the corresponding dimension components of the resource weight vector W: Z[i,j]=Y. i [j]×W[i] reduces data redundancy by applying a vector compression function to Z. Specifically, principal component analysis is applied to each row of Z to retain the m principal components with the largest contribution rates; or hash compression is used to map each row to a hash value of fixed length, resulting in a matrix Z' with the same number of rows but significantly reduced number of columns. The row vectors of Z' are concatenated into a one-dimensional vector to form the final lightweight session key K. The key length can be configured according to security requirements and resource constraints, with typical lengths being 128 bits, 256 bits, or 512 bits.

[0144] The above method realizes adaptive session key generation based on the resource status of edge nodes, enabling the key generation process to be dynamically adjusted according to the current computing performance and communication bandwidth of the nodes, which not only ensures security but also improves resource utilization efficiency.

[0145] In an optional embodiment, lattice basis projection operation is performed on each hierarchical parameter in the hierarchical sparse parameter set, the projection result is multiplied with the corresponding dimension component of the resource weight vector to generate a weighted projection matrix, data redundancy is reduced by a vector compression function, and the compressed row vectors are spliced into a lightweight session key, including:

[0146] For each hierarchical parameter in the hierarchical sparse parameter set, a corresponding lattice basis generating matrix is constructed, a short vector basis representation is obtained by lattice basis reduction operation, vector decomposition is performed on the short vector basis to obtain a coordinate representation, and an orthogonal projection transformation is performed to eliminate components outside the lattice basis to generate a hierarchical lattice basis projection coefficient vector, which is arranged in order of hierarchy to form an initial projection matrix.

[0147] The dimension components corresponding to each hierarchy are extracted from the resource weight vector, and each row vector of the initial projection matrix is multiplied with the corresponding dimension component of the resource weight vector by element-wise multiplication operation, and the weighted projection matrix is generated after normalization and recombination.

[0148] The sparsity evaluation operation is performed on each row vector of the weighted projection matrix to determine the proportion of non-zero elements, the corresponding vector compression function type is dynamically selected according to the proportion of non-zero elements, the output length of each row vector after compression is unified to a preset fixed dimension, and the compressed row vectors are spliced in the column direction according to the original row sequence to generate a lightweight session key.

[0149] In this specific embodiment, lattice basis projection operation is performed on each hierarchical parameter in the hierarchical sparse parameter set. The process starts with constructing a corresponding lattice basis generating matrix for each hierarchical parameter. Assuming that the hierarchical sparse parameter set contains three hierarchies L1, L2 and L3, which correspond to parameter subsets of different security levels. For hierarchy L1, a lattice basis generating matrix G1 is constructed, where the matrix elements are generated by the parameter eigenvalues of the hierarchy through a characteristic mapping function. Specifically, a circulant matrix structure can be used, so that the first row of G1 is the original parameter vector of hierarchy L1, and the subsequent rows are obtained by cyclic right shift, forming a complete lattice basis structure.

[0150] The lattice basis generating matrix is processed by LLL (Lenstra-Lenstra-Lovász) lattice basis reduction algorithm to obtain a short vector basis representation. The LLL algorithm is applied to G1 to obtain the reduced matrix Y1, and the column vectors of Y1 constitute a shorter and more orthogonal basis. Vector decomposition is performed on Y1 to express the parameter vector of hierarchy L1 as a linear combination of Y1 column vectors to obtain a coordinate representation vector c1. Orthogonal projection transformation is performed to eliminate components outside the lattice basis. The specific method is to calculate the Gram-Schmidt orthogonalization vector set of the lattice basis, project the parameter vector onto the space spanned by these orthogonal vectors, and generate the lattice basis projection coefficient vector p1 of hierarchy L1.

[0151] Similarly, the same operation is performed on levels L2 and L3, respectively obtaining projection coefficient vectors p2 and p3, and arranging these projection coefficient vectors in level order to form an initial projection matrix P = [p1 T ; p2 T ; p3 T ], where p1 T represents the transposed row vector of p1.

[0152] The initial projection matrix is combined with the resource weight vector to generate a weighted projection matrix, and the dimension components corresponding to each level are extracted from the resource weight vector W, for example, the first k1 elements correspond to level L1, the next k2 elements correspond to level L2, and the remaining elements correspond to level L3, then W1 = [w1,..., w k1 ] is extracted as the weight of L1, and the weights W2 and W3 of L2 and L3 are extracted in the same way.

[0153] An element-wise multiplication operation is performed on each row vector of the initial projection matrix P, and the first row p1 T is calculated as p1 T ⊙W1 (⊙ represents element-wise multiplication), obtaining a weighted row vector a1. Similarly, a2 = p2 T ⊙W2 and a3 = p3 T ⊙W3 are calculated, and the calculation results are normalized by dividing each weighted row vector by its L2 norm, i.e. α1 = a1 / ||a1||2, to ensure that each row vector has the same energy level, and finally the normalized row vectors are recombined into a weighted projection matrix A = [α1; α2; α3].

[0154] The data redundancy is reduced by the vector compression function to generate a lightweight session key, and the sparsity of each row vector of the weighted projection matrix A is evaluated, and the proportion of non-zero elements is calculated, for example, for the row vector α1, the number of non-zero elements is divided by the total number of elements to obtain the sparsity s1. Based on the sparsity evaluation result, the most suitable vector compression function is dynamically selected, when the sparsity is lower than a preset threshold (such as 0.3), the run-length encoding compression method is selected; when the sparsity is in a moderate range (such as 0.3 to 0.7), the Huffman coding is selected; when the sparsity is higher, the principal component analysis dimension reduction is selected.

[0155] Taking α1 as an example, if its sparsity is 0.25, run-length encoding is selected, the length of consecutive zero values and non-zero values are recorded, effectively reducing the storage space, and after compression, the length of the output vector c1 is ensured to be a preset fixed dimension d, if necessary, it is adjusted by truncation or zero padding, and the same process is applied to α2 and α3 to obtain compressed vectors c2 and c3, which are also adjusted to a length of d.

[0156] The compressed vectors are spliced in a column direction according to the original row sequence to form a final lightweight session key K=[c1||c2||c3], wherein "||" represents a vector splicing operation, the session key generated by the method not only retains the key security characteristics of the original parameters, but also realizes data compression and lightweight, and is suitable for use in a resource-limited environment.

[0157] In an actual application scenario, when an Internet of Things device needs to establish a secure communication channel, the lightweight session key can be efficiently generated by using the method.

[0158] The embodiment of the application provides an edge computing-oriented lightweight quantum-resistant key agreement protocol system, which comprises:

[0159] A first unit is configured to acquire identity information and lattice password parameters of an edge node.

[0160] A second unit is configured to generate a short vector private key through lattice basis reduction operation based on the lattice password parameters, and generate a public key polynomial matrix on a modulus operation ring by using the short vector private key.

[0161] A third unit is configured to extract a hardware physical address of the edge node and perform anti-collision hash operation to obtain an identity digest vector, embed the identity digest vector in the public key polynomial matrix in a bit-by-bit manner, and generate an identity-bound public key through modulus addition operation fusion, and record an index sequence of the embedding position.

[0162] A fourth unit is configured to send the identity-bound public key and the index sequence to a peer edge node, and receive an opposite-end identity-bound public key and an opposite-end index sequence returned by the peer edge node.

[0163] A fifth unit is configured to generate a lattice basis intermediate state matrix based on the short vector private key, generate a dynamic lattice basis chain through recursive reconstruction, perform hierarchical reduction operation on the opposite-end identity-bound public key in combination with the opposite-end index sequence, and generate a quantum-resistant intermediate session parameter based on the reduction result.

[0164] A sixth unit is configured to generate a resource weight vector according to the computing performance and communication bandwidth state of the edge node, perform adaptive sparse processing on the intermediate session parameter and execute lattice basis projection operation, generate a weighted projection result in combination with the resource weight vector, and generate a lightweight session key through vector compression.

[0165] In a third aspect, the embodiment of the application provides an electronic device, which comprises:

[0166] a processor;

[0167] a memory for storing processor-executable instructions;

[0168] wherein the processor is configured to invoke the instructions stored by the memory to perform the method as described above.

[0169] In a fourth aspect, the present application provides a computer readable storage medium having stored thereon computer program instructions, which when executed by a processor implement the method as described above.

[0170] The present application can be a method, an apparatus, a system, and / or a computer program product. The computer program product can include a computer readable storage medium having computer readable program instructions stored therein, which when executed by a processor, perform various aspects of the present application.

[0171] It should be noted that the above-mentioned embodiments are merely used to illustrate the technical solutions of the present application, but not limit the present application; although the present application has been described in detail with reference to the above-mentioned embodiments, those skilled in the art should understand that: they can still make modifications to the technical solutions recorded in the above-mentioned embodiments, or make equivalent replacements to some or all of the technical features; and these modifications or replacements do not cause the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present application.

Claims

1. A lightweight quantum-resistant key negotiation protocol method for edge computing, characterized in that, include: Obtain the identity information and cipher parameters of the edge nodes; Based on the lattice cryptography parameters, a short vector private key is generated through lattice basis reduction operations, and a public key polynomial matrix is ​​generated on the modular arithmetic ring using the short vector private key. Extract the hardware physical address of the edge node and perform a collision-resistant hash operation to obtain an identity digest vector. Embed the identity digest vector bitwise into the public key multinomial matrix, fuse them through modular addition to generate an identity binding public key, and record the index sequence of the embedding position. Send the identity binding public key and the index sequence to the peer edge node, and receive the peer identity binding public key and peer index sequence returned by the peer edge node; Based on the short vector private key, a lattice basis intermediate state matrix is ​​generated, and a dynamic lattice basis chain is generated through recursive reconstruction. Combined with the peer index sequence, a hierarchical reduction operation is performed on the peer identity binding public key, and intermediate session parameters with quantum resistance are generated based on the reduction result. Based on the computing performance and communication bandwidth status of the edge nodes, a resource weight vector is generated. The intermediate session parameters are then subjected to adaptive sparsification and lattice basis projection operations are performed. The weighted projection result is generated by combining the resource weight vector, and a lightweight session key is generated through vector compression.

2. The method according to claim 1, characterized in that, Based on the lattice cryptography parameters, a short vector private key is generated through lattice basis reduction operations. The short vector private key is then used to generate a public key polynomial matrix on a modular arithmetic ring, including: An initial lattice basis matrix is ​​constructed based on the lattice cipher parameters, which include lattice dimension and modulus. An orthogonalization transformation is performed on the initial lattice basis matrix to obtain an orthogonal basis vector set. The norm distribution characteristics of the lattice basis vectors are calculated based on the orthogonal basis vector set, and a reduction termination condition is set according to the norm distribution characteristics. An iterative reduction operation is performed on the orthogonal basis vector group. In each iteration, the projection coefficients between the current basis vector and the target basis vector are calculated. The current basis vector is updated using the projection coefficients. The iteration terminates when the norm of the current basis vector satisfies the reduction termination condition. Extract the vectors that satisfy the short vector property from the reduced lattice basis matrix as short vector private keys. Construct coefficient vectors based on the short vector private keys. Perform modular multiplication on the coefficient vectors in a preset polynomial ring to generate the first polynomial component. Construct a random perturbation polynomial matrix. Perform a combination of modular addition and modular multiplication on the first polynomial component and the random perturbation polynomial matrix in the modular operation ring to obtain the public key polynomial matrix.

3. The method according to claim 1, characterized in that, Extract the hardware physical address of the edge node and perform a collision-resistant hash operation to obtain an identity digest vector. Embed the identity digest vector bitwise into the public key multinomial matrix, and fuse them through modular addition to generate an identity-binding public key. Record the index sequence of the embedding positions, including: The hardware physical address of the edge node is obtained and converted into a binary bit string. A grouped cyclic shift operation is performed on the bit string to generate a shifted group sequence. A nonlinear hybrid operation is then performed to obtain the initial identity feature. The initial identity feature is then transformed into a collision-resistant hash value through a dynamic lattice basis reduction transformation. This hash value is then combined with the binary bit string for a second hash operation to obtain a fixed-length identity digest vector. Extract the coefficients of the highest degree terms of each polynomial in the public key polynomial matrix to form a public key feature coefficient sequence, and perform an XOR operation with the identity digest vector to obtain a fused feature vector. Based on the fused feature vector, a dynamic pseudo-random number seed is calculated to generate a polynomial mapping matrix. The identity digest vector is then converted into an identity feature polynomial through the polynomial mapping matrix. Based on the coefficient distribution of the identity feature polynomial, the optimal embedding position sequence is determined. At the position corresponding to the optimal embedding position sequence, the basis vectors of the original polynomial are extracted to construct a lattice basis transformation matrix. The lattice basis transformation matrix is ​​multiplied by the identity feature polynomial to generate the embedded identity binding polynomial. The original polynomial at the corresponding position in the public key polynomial matrix is ​​replaced. The overall matrix after replacement is normalized by modulo operation to generate the identity binding public key.

4. The method according to claim 3, characterized in that, The initial identity features are transformed into collision-resistant hash values ​​through dynamic lattice basis reduction, and then combined with the binary bit string for a second hash operation to obtain a fixed-length identity digest vector, including: The initial identity features are segmented and mapped according to a preset vector dimension to generate initial feature vectors. By performing a cyclic shift transformation on the initial feature vectors, the row vectors of the lattice basis matrix are generated. Perform orthogonal decomposition on the lattice basis matrix to obtain an orthogonal matrix and an upper triangular matrix. Calculate the average value of the diagonal elements of the upper triangular matrix as the lattice basis reduction eigenvalue. Calculate the inner product of the first and last column vectors of the orthogonal matrix to obtain the orthogonal eigenvalue. Perform a hybrid hash operation on the lattice basis reduction eigenvalue and the orthogonal eigenvalue to generate a collision-resistant hash value, and write it into the feedback state register as the initial state. After the binary bit string is divided into blocks, it is concatenated with the current value of the feedback status register and hashed sequentially. The feedback status register is updated by XOR operation to obtain the cascaded feedback hash value. The Shannon entropy of the cascaded feedback hash value is calculated. The adaptive segmentation position is determined according to the ratio of the Shannon entropy to the information entropy threshold, and the segments are cut to form a fixed-length identity digest vector.

5. The method according to claim 1, characterized in that, Based on the short vector private key, a lattice basis intermediate state matrix is ​​generated, and a dynamic lattice basis chain is generated through recursive reconstruction. Combined with the peer index sequence, a hierarchical reduction operation is performed on the peer identity-bound public key. Based on the reduction result, quantum-resistant intermediate session parameters are generated, including: The short vector private key is mapped to the lattice basis space to generate a lattice basis intermediate state matrix, and the norm distribution characteristics of the lattice basis vectors in the lattice basis intermediate state matrix are extracted. Based on the norm distribution characteristics, a lattice base state transition probability matrix is ​​generated. Multiple candidate lattice base states are obtained by performing randomized transition sampling on the current lattice base state through recursive iteration. The quality score of each candidate lattice base state is calculated. The candidate lattice base state with the highest quality score is selected as the current iteration output. The lattice base states and their transition probabilities output by each iteration are organized in the iteration order to form a dynamic lattice base chain. Based on the peer index sequence, the embedding position information in the peer identity binding public key is extracted, and the reverse separation operation is performed to obtain the peer public key polynomial matrix and the peer identity digest vector. Traverse the lattice base states of each layer in the dynamic lattice base chain, perform a reduction operation on each layer lattice base state and the peer public key polynomial matrix to obtain a reduction intermediate result, use the transition probability as a weight coefficient, and perform probability weighted fusion on each layer reduction intermediate result to generate a hierarchical reduction result. Extract the error vector from the hierarchical reduction result, and perform a modular operation to fuse the error vector with the peer identity digest vector to generate intermediate session parameters with quantum resistance.

6. The method according to claim 1, characterized in that, Based on the computing performance and communication bandwidth status of the edge nodes, a resource weight vector is generated. Adaptive sparsification processing is applied to the intermediate session parameters, and lattice basis projection operations are performed. A weighted projection result is generated by combining the resource weight vector, and a lightweight session key is generated through vector compression, including: The processor cache utilization and memory access latency of edge nodes are obtained and converted into computing performance characterization values ​​through nonlinear mapping. The network packet loss rate and channel signal-to-noise ratio are sampled and measured as communication bandwidth characterization values. The computing performance characterization values ​​are combined to generate a resource weight vector. The intermediate session parameters are input into a multi-level sparse decision tree. Branch path selection rules are generated based on the numerical relationship of each component of the resource weight vector. Condition judgment is performed at each non-leaf node. When the session parameter component meets the branch condition determined by the resource weight vector, it is retained and passed down. Otherwise, a zeroing operation is performed to terminate the branch. All retained components of the leaf nodes are collected to obtain a hierarchical sparse parameter set. The lattice basis projection operation is performed on the parameters of each level in the hierarchical sparsity parameter set. The projection result is multiplied with the corresponding dimension components of the resource weight vector to generate a weighted projection matrix. Data redundancy is reduced by a vector compression function, and the compressed row vectors are concatenated to form a lightweight session key.

7. The method according to claim 6, characterized in that, Perform lattice basis projection operations on the parameters of each level in the hierarchical sparsity parameter set, multiply the projection results with the corresponding dimension components of the resource weight vector to generate a weighted projection matrix, reduce data redundancy through a vector compression function, and concatenate the compressed row vectors into a lightweight session key, including: For each level parameter in the hierarchical sparsification parameter set, a corresponding lattice basis generation matrix is ​​constructed. A short vector basis representation is obtained through lattice basis reduction operation. Vector decomposition is performed on the short vector basis to obtain coordinate representation. Orthogonal projection transformation is performed to eliminate lattice basis out-of-base components, generating lattice basis projection coefficient vectors for each level. These vectors are then arranged in hierarchical order to form an initial projection matrix. Extract the dimension components corresponding to each level from the resource weight vector, perform element-wise multiplication of each row vector of the initial projection matrix with the corresponding dimension components of the resource weight vector, perform normalization processing, and then recombine to generate a weighted projection matrix. A sparsity evaluation operation is performed on each row vector of the weighted projection matrix to determine the proportion of its non-zero elements. The corresponding vector compression function type is dynamically selected based on the proportion of non-zero elements. The output length of each row vector after compression is unified to a preset fixed dimension. The compressed row vectors are then concatenated in the column direction according to the original row order to generate a lightweight session key.

8. A lightweight quantum-resistant key negotiation protocol system for edge computing, used to implement the method as described in any one of claims 1-7, characterized in that, include: The first unit is used to obtain the identity information and cipher parameters of the edge nodes; The second unit is used to generate a short vector private key based on the lattice cryptography parameters through lattice basis reduction operations, and to generate a public key polynomial matrix on the modular arithmetic ring using the short vector private key. The third unit is used to extract the hardware physical address of the edge node and perform a collision-resistant hash operation to obtain an identity digest vector. The identity digest vector is then embedded bit by bit into the public key multinomial matrix, and the identity binding public key is generated by fusion through modular addition operation. The index sequence of the embedding position is recorded. The fourth unit is used to send the identity binding public key and the index sequence to the peer edge node, and receive the peer identity binding public key and the peer index sequence returned by the peer edge node; The fifth unit is used to generate a lattice basis intermediate state matrix based on the short vector private key, and generate a dynamic lattice basis chain through recursive reconstruction. Combined with the peer index sequence, it performs a hierarchical reduction operation on the peer identity binding public key, and generates quantum-resistant intermediate session parameters based on the reduction result. The sixth unit is used to generate a resource weight vector based on the computing performance and communication bandwidth status of the edge nodes, perform adaptive sparsification processing on the intermediate session parameters and perform lattice basis projection operation, generate a weighted projection result by combining the resource weight vector, and generate a lightweight session key through vector compression.

9. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in the memory to execute the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the method described in any one of claims 1 to 7.

Images