A dictionary partitioning two-layer structure encryption index creation method supporting fast encrypted document sorting and retrieval

Abstract

The present invention belongs to the technical field of user data privacy protection and discloses a dictionary-partitioned two-layer structure encryption index creation method that supports rapid encrypted document sorting and retrieval. The method comprises the following steps: first, extracting keywords from each document in a document collection to construct an initial global dictionary; second, clustering the keywords in the global dictionary using a binary k-means clustering method to achieve rearrangement of the keywords in the global dictionary; then, dividing the rearranged global dictionary into equal-length partitions to generate mutually disjoint equal-length sub-dictionaries; then, constructing a one-hot code selection vector corresponding to the sub-dictionary, and constructing a corresponding document sub-vector for each document containing keywords belonging to the sub-dictionary to construct a two-layer structure plaintext index; finally, encrypting the plaintext index to generate a two-layer structure encrypted index. The encrypted index created by the present invention can be used for rapid sorting and retrieval of encrypted documents in an outsourced environment, thereby improving retrieval efficiency.

Description

Technical Field

[0001] The present invention belongs to the technical field of user data privacy protection, and in particular relates to a dictionary-partitioned two-layer structure encryption index creation method that supports fast encrypted document sorting and retrieval. Background Art

[0002] The rapid development of cloud computing has led more and more businesses and individuals to outsource their data to cloud servers. Cloud servers pool computing resources and share them with users, allowing them to use them as needed. To protect the privacy of outsourced data, the most common and straightforward approach is to encrypt the data before outsourcing it to the cloud server and then outsource the encrypted data to the cloud server. However, encrypted data reduces its usability, making basic operations like data retrieval more complex and difficult. Therefore, searchable encryption technology has emerged. It can sort and retrieve ciphertext based on user search requests without obtaining the plaintext documents, and return the k most relevant encrypted documents to the user.

[0003] To implement ciphertext ranked retrieval, the mainstream approach for multi-keyword ranked retrieval is to use the TF-IDF vector space model and the secure inner product algorithm to convert the relevance matching between documents and search keywords into the inner product calculation between the document vector and the search keyword vector. However, while directly calculating the relevance between the search keyword and all documents is simple and convenient, it suffers from low retrieval efficiency. Therefore, based on the TF-IDF vector space model, many indexes have been proposed to improve the efficiency of ranked retrieval, such as tree indexes and inverted indexes. These indexes effectively reduce the number of secure inner product calculations and improve retrieval efficiency. However, in large-scale document applications, the document vector dimension increases, increasing its storage cost and the time consumption of the secure inner product calculation. Furthermore, since the number of keywords contained in a single document is far less than the dictionary capacity, the document vector becomes sparse, which reduces the efficiency of ciphertext ranked retrieval. Therefore, if an index can be proposed that reduces the number of secure inner products while also compressing the document vector dimension, the efficiency of ciphertext ranked retrieval can be further improved and the index storage cost can be reduced. Summary of the Invention

[0004] In order to address the shortcomings of the existing technology, the present invention provides a two-layer structure encrypted index creation method that supports fast sorting and retrieval of encrypted documents and has low space storage cost. Specifically, a secure two-layer index tree is constructed based on binary k-means clustering and dictionary partitioning strategy, which can be used for fast sorting and retrieval of encrypted documents in an outsourced environment, thereby improving retrieval efficiency.

[0005] In order to achieve the above object, the present invention is achieved through the following technical solutions:

[0006] The present invention is a method for creating a dictionary-partitioned two-layer structure encrypted index that supports fast encrypted document sorting and retrieval. The method includes the following steps:

[0007] (1) According to the document set F = {f1,f2,…,f n}, extract the k most frequent keywords from each document in F, and construct the initial global dictionary W = {w1,w2,…,w m};

[0008] (2) The keywords in the initial global dictionary W are clustered using the binary k-means clustering method to generate a clustered binary k-means clustering tree. The root nodes of the clustering tree are traversed in turn to obtain the keywords in the nodes, and then the keywords in the global dictionary W are rearranged to generate the clustered global dictionary W'.

[0009] (3) According to the given partition parameter τ, the clustered global dictionary W' is divided into equal lengths. Each sub-dictionary contains τ keywords. If the number of keywords in the last sub-dictionary is less than τ, virtual keywords are added to make up for it. The final result is There are mutually disjoint equal-length sub-dictionaries D = {D1, D2, ..., D s};

[0010] (4) For each sub-dictionary D after equal length division i , construct the sub-dictionary D i The corresponding one-hot code selection vector is constructed, and the corresponding document sub-vector is constructed for each document containing the keyword belonging to the sub-dictionary. Then, based on these generated vectors, a two-layer structure plaintext index L is constructed;

[0011] (5) Encrypt L to generate a two-layer structure encryption index

[0012] A further improvement of the present invention is that the specific operation steps of step (2) are as follows:

[0013] (2.1) Use a keyword distance formula (such as Jaccard distance) to measure the distance between any two keywords in W. Then, perform a top-down binary k-means clustering of the keywords in W based on the distance between the keywords until each subcluster contains only one keyword. Finally, a binary k-means clustering tree is formed. The clustering tree is a binary tree with each leaf node containing only one keyword.

[0014] (2.2) Create an empty keyword list List, and then perform a pre-order traversal on the binary k-means clustering tree formed in step 2-1. During the traversal, if the node visited is a leaf node, the unique keyword in the leaf node is added to the keyword list List, and then the global dictionary W' after the keyword rearrangement is obtained, that is, W'=List.

[0015] A further improvement of the present invention is that for each sub-dictionary D in D i , execute the following sub-steps included in step (4) to construct i The corresponding index item L[i]=<VS,entry> , where VS is the sub-dictionary D i The one-hot code selection vector, entry is the same as D i The corresponding entry of the binary balanced search tree points to the root node of the binary balanced search tree. Finally, a two-layer structure plaintext index L is generated.

[0016] (4.1) Generation and sub-dictionary D i The corresponding one-hot code selection vector VS has a dimension equal to the number of sub-dictionaries. The calculation rule for the j-th dimension is as follows:

[0017]

[0018] (4.2) Construction and D i The corresponding binary balanced search tree T i , and set entry to point to T i The root node of .

[0019] Furthermore, the step (4.2) constructs the same i The corresponding binary balanced search tree T i The steps are as follows:

[0020] (4.2.1) Get the sub-dictionary D i The set FS(D i );then FS(D i ) for each document f j , generate the corresponding document sub-vector The vector dimension is τ, and the value of any g-th dimension is calculated as follows:

[0021]

[0022] in, Represents the sub-dictionary D i The gth keyword in In the document f j TF value within;

[0023] (4.2.2) Create an empty queue Queue, for FS(D i ) for each document f j In the sub-dictionary D i The document subvector under Construct a leaf node u=<lch,fid,VP,rch> ,in u.fid stores document f j Identifier, And store the generated leaf node in the queue;

[0024] (4.2.3) For the nodes in the queue in step (4.2.2), generate the corresponding upper-level parent node for each two nodes as a group and store them in the queue; let there be two leaf nodes u and v, and the generated parent node is p =<lch,fid,VP,rch> , where p.lch=u,p.rch=v, p.VP is a vector of length τ, and its arbitrary j-th dimension is calculated as follows:

[0025] p.VP[j]=max{u.VP[j],v.VP[j]};

[0026] Repeat step (4.2.3) to construct parent nodes layer by layer from bottom to top until there is only one parent node left in the queue. At this point, the only parent node is the one with D i The corresponding binary balanced search tree T i The root node of .

[0027] A further improvement of the present invention is that the encryption process for the plaintext index L in step (5) includes the following steps:

[0028] (5.1) Generate a set of keys KEY = {S1, M 11 ,M 12 ,S2,M 21 ,M 22}, where S1 and S2 are random bit vectors, M 11 、M 12 、M 21 and M 22 is a random reversible matrix;

[0029] (5.2) Using {S1,M 11 ,M 12} Encrypt all sub-dictionary one-hot code selection vectors in index L;

[0030] (5.3) Using {S2,M 21 ,M 22} Encrypt all binary balanced search trees linked in index L;

[0031] (5.4) After the encryption processing of steps (5.2) and (5.3), a two-layer structure encryption index is generated

[0032] A further improvement of the present invention is that the encryption process of each one-hot code selection vector L[i].VS in L in step (5.2) includes the following steps:

[0033] (5.2.1) Based on the random bit vector S1, split L[i].VS into two vectors {L[i].VS′, L[i].VS″}. The splitting method is as follows:

[0034]

[0035] (5.2.2) Using the random reversible matrix M 11 and M 12 Perform encryption processing on the split vector {L[i].VS′,L[i].VS″} in step (5.2.1) to generate the encrypted vector The encryption method is as follows:

[0036]

[0037] A further improvement of the present invention is that in step (5.3), a binary balanced search tree T is linked to each L[i].entry in L. i The encryption process of each node u in includes the following steps:

[0038] (5.3.1) Based on the random bit vector S2, the vector u.VP in u is split into two vectors {u.VP′, u.VP″}. The splitting method is as follows:

[0039]

[0040] (5.3.2) Using the random reversible matrix M 21 and M 22 Perform encryption processing on the split vector {u.VP′, u.VP″} in step (5.3.1) to generate the encrypted vector The encryption method is as follows:

[0041]

[0042] The two-layer encryption index proposed by the present invention It can be used for ciphertext sorting retrieval and can improve retrieval efficiency. The specific application method is as follows:

[0043] 1) Generate sub-dictionary filter vector VF based on the given search keyword Q Q , whose dimension is the number of sub-dictionaries s; when the sub-dictionary D i When any keyword in Q is included, VF Q The i-th dimension is set to 1, otherwise it is set to 0; the specific calculation formula is as follows:

[0044]

[0045] Where Dict(Q) represents the set of sub-dictionaries containing any keyword in Q;

[0046] 2) Based on the given search keyword Q, generate each sub-dictionary D i The search subvector The vector dimension is τ, and the value of any g-th dimension is calculated as follows:

[0047]

[0048] in, Represents the sub-dictionary D i The IDF value of the g-th keyword in the document set F;

[0049] 3) Filter the sub-dictionary vector VF according to the random bit vector S1 Q Perform vector splitting to generate the split vector {VF Q ′,VF Q ″}, the splitting method is as follows:

[0050]

[0051] Then, according to the random reversible matrix M 11 and M 12 Encryption, the split vector {VF Q ′,VF Q ″} is encrypted as follows:

[0052]

[0053] 4) According to the random bit vector S2, each retrieval sub-vector Perform vector splitting to generate split vectors The splitting method is as follows:

[0054]

[0055] Then, according to the random reversible matrix M 21 and M 22 Encryption, the split vector Encrypt as follows:

[0056]

[0057] 5) Utilize exist The upper index and the sub-dictionary one-hot code selection vector Perform inner product operation to find the entry L[i].entry of the lower index tree whose inner product result is greater than 0, and find the corresponding lower index tree T through this entry i ; Then in each determined target lower level index tree T i In the example, we use the search subvector In T i Search for the k documents with the highest local relevance to Q; finally, sum the local relevance of the same document to Q in different lower-level index trees to obtain the global relevance of the document to Q, and finally obtain the k documents with the highest global relevance to Q as the retrieval results.

[0058] The beneficial effects of the present invention are:

[0059] First, a dictionary partitioning strategy is adopted to compress the dimensions of the document vector, thereby reducing the storage cost of the two-layer index created using the compressed document sub-vectors, effectively saving the index space overhead in the ciphertext sorting retrieval scheme.

[0060] Secondly, the inner product operation of the document sub-vector after dimensionality reduction and the search sub-vector can effectively reduce the safe inner product time;

[0061] Thirdly, the present invention combines the keyword clustering method to effectively reduce the number of safe inner products in the two-layer index. Therefore, the efficiency of sorting and searching using the present invention is high. BRIEF DESCRIPTION OF THE DRAWINGS

[0062] Figure 1 It is a flow chart of the index creation method of the present invention.

[0063] Figure 2 This is an example diagram of the binary k-means clustering tree of the present invention.

[0064] Figure 3 This is an example diagram of the two-layer index L in the plaintext state of the present invention. DETAILED DESCRIPTION

[0065] The following diagrams illustrate embodiments of the present invention. For clarity, many practical details are included in the following description. However, it should be understood that these practical details are not intended to limit the present invention. In other words, in some embodiments of the present invention, these practical details are not essential.

[0066] For the convenience of description, the relevant symbols are defined as follows:

[0067] Key KEY = {K, S1, M 11 ,M 12 ,S2,M 21 ,M 22}, where K is the symmetric encryption key used to encrypt the plaintext document, S1 and S2 are random bit vectors, and M 11 、M 12 、M 21 and M 22 is a random reversible matrix; the document set F={f1,f2,…,f n}; Global dictionary W = {w1,w2,…,w m}, global dictionary W' after keyword rearrangement; dictionary partition parameter τ; equal-length sub-dictionary set D = {D1, D2, ..., D s}; Two-layer structure plaintext index L; and sub-dictionary D i The corresponding index item L[i]=<VS,entry> , where VS is the sub-dictionary D i The one-hot code selection vector, entry is the same as D i The corresponding binary balanced search tree T i Entrance; contains sub-dictionary D i The set FS(D i ); document f j Corresponding document subvector fid represents the document identifier; lch and rch are the left child pointer and right child pointer respectively; VP is the pruning vector; the encrypted sub-dictionary D i One-hot encoding selection vector Two-layer structure encrypted index

[0068] like Figure 1 As shown, the present invention is a dictionary-partitioned two-layer structure encryption index creation method that supports fast encrypted document sorting and retrieval, and the creation method includes the following steps:

[0069] Step 1: According to the document set F = {f1,f2,…,f n}, extract the k most frequent keywords from each document in F, and construct the initial global dictionary W = {w1,w2,…,w m};

[0070] Step 2: Use the binary k-means clustering method to cluster the keywords in the initial global dictionary W and generate a clustered binary k-means clustering tree, as shown in Figure 2As shown in the example, the root nodes of the clustering tree are traversed in turn to obtain the keywords in the nodes, and then the keywords in the initial global dictionary W are rearranged to generate the clustered global dictionary W'. The specific process is as follows:

[0071] Step 2-1: Use a keyword distance formula, such as Jaccard distance, to measure the distance between any two keywords in W. Then, perform a top-down binary k-means clustering of the keywords in W based on the distance between the keywords until each subcluster contains only one keyword. This ultimately forms a binary k-means clustering tree, which is a binary tree with each leaf node containing only one keyword.

[0072] Step 2-2, create an empty keyword list List, and then perform a pre-order traversal on the binary k-means clustering tree formed in step 2-1. During the traversal process, if the visited node is a leaf node, the unique keyword in the leaf node is added to the keyword list List, and then the global dictionary W' after the keyword rearrangement is obtained, that is, W'=List.

[0073] Step 3: Divide the clustered global dictionary W' into equal-length partitions to generate a set of non-intersecting equal-length sub-dictionaries D = {D1, D2, ..., D s}.

[0074] The specific process is as follows: According to the given partition parameter τ, the clustered global dictionary W' is divided into equal lengths. Each sub-dictionary contains τ keywords. If the number of keywords in the last sub-dictionary is less than τ, virtual keywords are added to fill the gap and finally generate There are mutually disjoint equal-length sub-dictionaries D = {D1, D2, ..., D s}.

[0075] Step 4: For each sub-dictionary D after equal length division i , construct the sub-dictionary D i The corresponding one-hot code selection vector is constructed, and the corresponding document sub-vector is constructed for each document containing the keyword belonging to the sub-dictionary. Then, based on these generated vectors, a two-layer structure plaintext index L is constructed, as shown in Figure 3 Example shown.

[0076] Furthermore, for each sub-dictionary D in D i , execute the following sub-steps included in step 4 to build the D i The corresponding index item L[i]=<VS,entry> , where VS is the sub-dictionary D i The one-hot code selection vector, entry is the same as D iThe corresponding entry of the binary balanced search tree points to the root node of the binary balanced search tree. Finally, a two-layer structure plaintext index L is generated.

[0077] The specific steps include:

[0078] Step 4.1: Generate sub-dictionary D i The corresponding one-hot code selection vector VS has a dimension equal to the number of sub-dictionaries. The calculation rule for the j-th dimension is as follows:

[0079]

[0080] Step 4.2, construction and D i The corresponding binary balanced search tree T i , and set entry to point to T i The root node of .

[0081] Structure and D i The corresponding binary balanced search tree T i The steps are as follows:

[0082] Step 4.2.1, get the sub-dictionary D i The set FS(D i );then FS(D i ) for each document f j , generate the corresponding document sub-vector The vector dimension is τ, and the value of any g-th dimension is calculated as follows:

[0083]

[0084] in, Represents the sub-dictionary D i The gth keyword in In the document f j TF value within;

[0085] Step 4.2.2, create an empty queue Queue, for FS(D i ) for each document f j In the sub-dictionary D i The document subvector under Construct a leaf node u=<lch,fid,VP,rch> ,in u.fid stores document f j Identifier, And store the generated leaf node in the queue;

[0086] Step 4.2.3: For the nodes in the queue in step 4.2.2, generate the corresponding upper-level parent node for each pair as a group and store them in the queue. Suppose there are two leaf nodes u and v, and the generated parent node is p=<lch,fid,VP,rch> , where p.lch=u,p.rch=v, p.VP is a vector of length τ, and its arbitrary j-th dimension is calculated as follows:

[0087] p.VP[j]=max{u.VP[j],v.VP[j]};

[0088] Repeat steps 4.2.2 to 4.2.3, constructing parent nodes layer by layer from bottom to top, until there is only one parent node left in the queue. At this point, the only parent node is the one with D i The corresponding binary balanced search tree T i The root node of .

[0089] Step 5: Encrypt L to generate a two-layer structure encrypted index The following steps are involved:

[0090] Step 5.1, generate a set of keys KEY = {S1, M 11 ,M 12 ,S2,M 21 ,M 22}, where S1 and S2 are random bit vectors, M 11 、M 12 、M 21 and M 22 is a random reversible matrix;

[0091] Step 5.2, using {S1,M 11 ,M 12 Encrypt all sub-dictionary one-hot code selection vectors in index L, including the following steps:

[0092] Step 5.2.1. Split L[i].VS into two vectors {L[i].VS′, L[i].VS″} based on the random bit vector S1. The splitting method is as follows:

[0093]

[0094] Step 5.2.2: Using random reversible matrix M 11 and M 12 Perform encryption processing on the split vector {L[i].VS′,L[i].VS″} in step 5.2.1 to generate the encrypted vector The encryption method is as follows:

[0095]

[0096] Step 5.3, using {S2,M 21 ,M 22} Encrypt all binary balanced search trees linked in index L.

[0097] The binary balanced search tree T linked to each L[i].entry in L in step 5.3 i The encryption process of each node u in includes the following steps:

[0098] Step 5.3.1. Split the vector u.VP in u into two vectors {u.VP′, u.VP″} according to the random bit vector S2. The splitting method is as follows:

[0099]

[0100] Step 5.3.2: Using the random reversible matrix M 21 and M 22 Perform encryption processing on the split vector {u.VP′, u.VP″} in step 5.3.1 to generate the encrypted vector The encryption method is as follows:

[0101]

[0102] Step 5.4: After the encryption processing of steps 5.2 and 5.3, a two-layer structure encrypted index is generated.

[0103] The two-layer encryption index proposed by the present invention It can be used for fast ciphertext sorting retrieval: first, use the upper-level index to quickly locate the target lower-level index tree containing candidate results; then, find the k documents most relevant to the search keyword in the lower-level index, perform fusion processing, and then obtain the final search results.

[0104] The foregoing is merely an embodiment of the present invention and is not intended to limit the present invention. It will be apparent to those skilled in the art that various modifications and variations of the present invention are possible. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention are intended to be included within the scope of the claims of the present invention.

Claims

1. A method for creating a two-layer encrypted index using a dictionary partitioning structure that supports fast encrypted document sorting and retrieval, characterized by: The dictionary partitioning two-layer structure encryption index creation method comprises the following steps: Step 1: According to the document set F, extract the k most frequent keywords from each document in the document set F to form the initial global dictionary W = {w1, w2, ..., w m }; Step 2: Use the binary k-means clustering method to cluster the keywords in the initial global dictionary W obtained in step 1, and then rearrange the keywords in the initial global dictionary W to generate a clustered global dictionary W'; Step 3: Divide the clustered global dictionary W' into equal-length sub-dictionaries D = {D1, D2, ..., D s }; Step 4: For each sub-dictionary D in the divided equal-length sub-dictionary D i , construct the sub-dictionary D i The corresponding one-hot code selection vector is constructed, and the corresponding document sub-vector is constructed for each document containing the keyword belonging to the sub-dictionary. Then, based on these generated vectors, a two-layer structure plaintext index L is constructed; Step 5: Encrypt the two-layer structure plaintext index L obtained in step 4 to generate a two-layer structure encrypted index in: For each sub-dictionary D in the equal-length sub-dictionary D i , execute the following sub-steps included in step 4 to construct the sub-dictionary D i The corresponding index item L[i]=<VS,entry> , where VS is the sub-dictionary D i The one-hot code selection vector, entry is the same as D i The corresponding entry of the binary balanced search tree points to the root node of the binary balanced search tree, and finally generates a two-layer structure plaintext index L, which specifically includes the following steps: Step 4-1, generate sub-dictionary D i The corresponding one-hot code selection vector VS has the same dimension as the sub-dictionary D i The number is equal, and the calculation rule for the jth dimension is Step 4-2: Construct sub-dictionary D i The corresponding binary balanced search tree T i , and set entry to point to T i The root node of Step 4-2 constructs the sub-dictionary D i The corresponding binary balanced search tree T i , specifically including the steps: Step 4-2-1, get the sub-dictionary D i The set FS(D i ), then for the set FS(D i ) for each document f j , generate the corresponding document sub-vector The vector dimension is τ, and the value of any g-th dimension is calculated as in, Represents the sub-dictionary D i The gth keyword in In the document f j TF value within; Step 4-2-2, create an empty queue Queue, for the set FS (D i ) for each document f j In the sub-dictionary D i The document subvector under Construct a leaf node u=<lch,fid,VP,rch> ,in u.fid stores document f j Identifier, And store the generated leaf node in the queue; Step 4-2-3: For the nodes in the queue in step 4-2-2, generate the corresponding upper parent node for each two nodes as a group and store them in the queue; there are two leaf nodes u and v, and the generated parent node is p=<lch,fid,VP,rch> , where p.lch=u,p.rch=v, p.VP is a vector of length τ, and its arbitrary j-th dimension is calculated as: p.VP[j]=max{u.VP[j],v.VP[j]}; Step 4-2-4, repeat steps 4-2-2 to 4-2-3 to construct parent nodes layer by layer from bottom to top until there is only one parent node left in the queue. At this time, the only parent node is the one with D i The corresponding binary balanced search tree T i The root node of .

2. The method for creating a dictionary-partitioned two-layer structured encrypted index supporting fast encrypted document sorting and retrieval according to claim 1, characterized in that: In step 2, the steps for rearranging the keywords in the initial global dictionary W are as follows: Step 2-1: Use the keyword distance formula to measure the distance between any two keywords in the initial global dictionary W. Then, perform a top-down binary k-means clustering on the keywords in the initial global dictionary W based on the distance between the keywords until each subcluster contains only one keyword. Finally, a binary k-means clustering tree is formed. The clustering tree is a binary tree with each leaf node containing only one keyword. Step 2-2, create an empty keyword list List, and then perform a pre-order traversal on the binary k-means clustering tree formed in step 2-1. During the traversal process, if the visited node is a leaf node, the unique keyword in the leaf node is added to the keyword list List, and then the global dictionary W' after the keyword rearrangement is obtained, that is, W'=List.

3. The method for creating a dictionary-partitioned two-layer structured encrypted index supporting fast encrypted document sorting and retrieval according to claim 1, characterized in that: The specific process of step 3 is: according to the given partition parameter τ, the clustered global dictionary W' is divided into equal lengths, each sub-dictionary contains τ keywords, if the number of keywords in the last sub-dictionary is less than τ, virtual keywords are added to fill it, and finally generate There are mutually disjoint equal-length sub-dictionaries D = {D1, D2, ..., D s }.

4. The method for creating a dictionary-partitioned two-layer structured encrypted index supporting fast encrypted document sorting and retrieval according to claim 1, characterized in that: In step 5, the plaintext index L is encrypted, which specifically includes the following steps: Step 5-1, generate a set of keys KEY = {S1, M 11 ,M 12 ,S2,M 21 ,M 22 }, where S1 and S2 are random bit vectors, M 11 、M 12 、M 21 and M 22 is a random reversible matrix; Step 5-2, using {S1,M 11 ,M 12 Encrypt all sub-dictionary one-hot code selection vectors in the plaintext index L; Step 5-3, using {S2,M 21 ,M 22 } Encrypt all binary balanced search trees linked in the plaintext index L; Step 5-4: After the encryption processing of step 5-2 and step 5-3, a two-layer structure encrypted index is generated.

5. The method for creating a dictionary-partitioned two-layer structure encrypted index supporting fast encrypted document sorting and retrieval according to claim 4, characterized in that: Step 5-2 encrypts each one-hot code selection vector L[i].VS of all sub-dictionaries in the plaintext index L, specifically including the following steps: Step 5-2-1. Split L[i].VS into two vectors {L[i].VS′, L[i].VS″} according to the random bit vector S1. The splitting method is as follows: Step 5-2-2, using random reversible matrix M 11 and M 12 Perform encryption processing on the split vector {L[i].VS′,L[i].VS″} in step 5-2-1 to generate an encrypted vector The encryption method is as follows:

6. The method for creating a dictionary-partitioned two-layer structure encrypted index supporting fast encrypted document sorting and retrieval according to claim 4, characterized in that: In step 5-3, the binary balanced search tree T linked to each L[i].entry in the plaintext index L i Each node u in the encryption process is performed, which specifically includes the following steps: Step 5-3-1: Split the vector u.VP in u into two vectors {u.VP′, u.VP″} according to the random bit vector S2. The splitting method is as follows: Step 5-3-2, using random reversible matrix M 21 and M 22 Perform encryption processing on the split vector {u.VP′, u.VP″} in step 5-3-1 to generate an encrypted vector The encryption method is as follows:

Images