Data access method and apparatus, electronic device, and storage medium

Abstract

This application relates to a data access method, apparatus, electronic device, and storage medium. The data access method includes: acquiring actual data access requests; determining the actual number of requests; constructing virtual data access requests based on the actual number of requests, a cache size, and a database size; determining a current target access request from the actual and virtual data access requests based on cached data in the cache, wherein the number of current target access requests is equal to the number of actual requests, and the cache is used to cache historical target data retrieved from the database based on historical target access requests; and accessing the current target data corresponding to the current target access request from the database. This application solves the problem of low efficiency in data access via unintentional random access machines and improves data access efficiency.

Description

Technical Field

[0001] This application relates to the field of information security technology, and in particular to a data access method, apparatus, electronic device, and storage medium. Background Technology

[0002] With the rapid development of cloud computing, more and more organizations are choosing to deploy their digital assets and online services to cloud databases to obtain higher-quality services at a lower cost. While deploying data to cloud databases offers convenience, it also presents certain security risks. Although cloud databases can protect data content through encrypted storage, malicious servers and attackers can still infer private information by observing users' access patterns to the cloud database. For example, if a hospital stores patient information on a cloud server, a doctor's access patterns to the medical database on that cloud server could potentially expose the patient's diagnosis.

[0003] Oblivious Random Access Machines (ORAMs) are an important means of protecting access patterns. In existing ORAM designs, when a client communicates with a server, the server needs to traverse and access all data in the database for each client request. This prevents attackers from knowing which specific data in the database the client's request maps to, thus achieving obfuscation. While this method effectively hides data access patterns, it also increases data access time and impacts efficiency.

[0004] There is currently no effective solution to the problem of low efficiency in data access by unintentional random access machines in related technologies. Summary of the Invention

[0005] This embodiment provides a data access method, apparatus, electronic device, and storage medium to address the problem of low efficiency in data access via unintentional random access in related technologies.

[0006] Firstly, this embodiment provides a data access method, which is applied to a server, the server including a cache and a database, including:

[0007] Obtain the actual data access request;

[0008] Determine the actual number of data access requests;

[0009] A virtual data access request is constructed based on the actual number of requests, the cache size, and the database size.

[0010] Based on the cached data in the cache area, the current target access request is determined from the actual data access request and the virtual data access request. The number of the current target access requests is equal to the number of actual requests. The cache area is used to cache historical target data obtained from the database based on historical target access requests.

[0011] Access the current target data corresponding to the current target access request from the database.

[0012] In some embodiments, determining the target access request from the actual data access request and the virtual data access request based on the cached data in the cache area includes:

[0013] Based on the cached data in the cache area, respond to the actual data access request and the virtual data access request, and determine the response result;

[0014] Based on the response results, the responded data access requests, the unresponded actual data access requests, and the unresponded virtual data access requests are determined. The responded data access requests include responded actual data access requests and / or responded virtual data access requests.

[0015] The unresponsive actual data access requests, the unresponsive virtual data access requests, and the responded data access requests are sorted sequentially to obtain the sorted access requests;

[0016] The first N requests in the sorted access requests are determined as the current target access requests, where N is equal to the actual number of requests.

[0017] In some embodiments, after accessing the current target data corresponding to the current target access request from the database, the method further includes:

[0018] Respond to the unresponsive actual data access request based on the current target data;

[0019] The actual data access request is returned to the client in response.

[0020] In some embodiments, after accessing the current target data corresponding to the current target access request from the database, the method further includes:

[0021] The current target data is cached in the cache area.

[0022] In some embodiments, before determining the actual number of actual data access requests, the method further includes:

[0023] Determine the storage status of the cache area;

[0024] If the cache is full, the cached data in the cache is written back to the database, and the cache is cleared.

[0025] Retrieve stored data from the database;

[0026] The storage locations of the stored data are rearranged, and the actual data access request is responded to based on the stored data.

[0027] In some embodiments, the database includes multiple local storage data, and the rearrangement of the storage locations of the stored data and the response to the actual data access request based on the stored data includes:

[0028] The database is processed in multiple rounds of full processing. Each round of full processing includes multiple local processing stages. Each local processing stage processes a corresponding local storage data. The following steps are performed in each local processing stage:

[0029] Scan the local storage data of the current local processing stage to obtain the current local storage data;

[0030] The storage locations of the current local storage data are rearranged to obtain the current local rearranged data;

[0031] The actual data access request is responded to based on the current locally rearranged data.

[0032] In some embodiments, after responding to the actual data access request based on the current local rearrangement data, the method further includes:

[0033] After completing a full round of processing, the actual data access request is returned to the client in response.

[0034] In some embodiments, constructing a virtual data access request based on the actual number of requests, the cache size, and the database size includes:

[0035] The number of virtual requests is determined based on the actual number of requests, the cache size, and the database size.

[0036] The virtual data access requests are randomly generated based on the number of virtual requests.

[0037] Secondly, this embodiment provides a data access device applied to a server, the server including a cache and a database, comprising:

[0038] The acquisition module is used to acquire actual data access requests;

[0039] The first determining module is used to determine the actual number of actual data access requests;

[0040] A request construction module is used to construct virtual data access requests based on the actual number of requests, the cache size, and the database size.

[0041] The second determining module is used to determine the current target access request from the actual data access request and the virtual data access request based on the cached data in the cache area. The number of the current target access requests is equal to the number of actual requests. The cache area is used to cache historical target data obtained from the database based on historical target access requests.

[0042] The data access module is used to access the current target data corresponding to the current target access request from the database.

[0043] Thirdly, this embodiment provides an electronic device including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the data access method described in any embodiment of the first aspect above.

[0044] Fourthly, this embodiment provides a storage medium storing a computer program that, when executed by a processor, implements the data access method described in any embodiment of the first aspect above.

[0045] Compared with related technologies, the data access provided in this embodiment obtains actual data access requests and determines the actual number of requests. Further, it constructs virtual data access requests based on the actual number of requests, cache size, and database size. Further, based on cached data in the cache, it determines the current target access request from the actual and virtual data access requests, ensuring the number of target access requests equals the number of actual data access requests. This constructs the target access request by obfuscating the actual and virtual data access requests. Further, it accesses the current target data corresponding to the current target access request from the database, thus accessing the database through the obfuscated target access request. This prevents attackers from determining the authenticity of the target access request, thereby protecting the data access mode. Furthermore, the fact that the number of current target access requests equals the number of actual data access requests ensures that the number of database accesses corresponds to the number of actual data requests. When accessing target data in the database, only the target data corresponding to the target access request is accessed, rather than traversing all data in the database. That is, an access request only needs to access the corresponding data in the database, reducing data access time and improving data access efficiency.

[0046] Details of one or more embodiments of this application are set forth in the following drawings and description to make other features, objects and advantages of this application more readily apparent. Attached Figure Description

[0047] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0048] Figure 1 This is a schematic diagram illustrating an application scenario of a data access method provided in an embodiment of this application;

[0049] Figure 2 This is a flowchart of a data access method provided in an embodiment of this application;

[0050] Figure 3 This is a flowchart of an embodiment of a data access method provided in this application;

[0051] Figure 4 This is a schematic diagram of the structure of a hash table provided in an embodiment of this application;

[0052] Figure 5 This is a schematic diagram of another hash table structure provided in an embodiment of this application;

[0053] Figure 6This is a structural block diagram of a data access device provided in an embodiment of this application;

[0054] Figure 7 This is a schematic diagram of a computer device structure provided in an embodiment of this application. Detailed Implementation

[0055] To better understand the purpose, technical solution, and advantages of this application, the application is described and illustrated below in conjunction with the accompanying drawings and embodiments.

[0056] Unless otherwise defined, the technical or scientific terms used in this application shall have the general meaning as understood by one of ordinary skill in the art to which this application pertains. Words such as “a,” “an,” “an,” “the,” “the,” and “these,” used in this application, do not indicate quantitative limitation and may be singular or plural. The terms “comprising,” “including,” “having,” and any variations thereof used in this application are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or device that comprises a series of steps or modules (units) is not limited to the listed steps or modules (units) but may include steps or modules (units) not listed, or may include other steps or modules (units) inherent to such processes, methods, products, or devices. The terms “connected,” “linked,” and “coupled,” used in this application, are not limited to physical or mechanical connections but may include electrical connections, whether direct or indirect. The term “multiple” used in this application refers to two or more. The "and / or" operator describes the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: A alone, A and B simultaneously, and B alone. Typically, the character " / " indicates that the objects before and after it are in an "or" relationship. The terms "first," "second," and "third," etc., used in this application are merely for distinguishing similar objects and do not represent a specific ordering of the objects.

[0057] With the rapid development of cloud computing, more and more organizations are choosing to deploy their digital assets and online services to cloud databases to obtain higher-quality services at a lower cost. While deploying data to cloud databases offers convenience, it also presents certain security risks. Although cloud databases can protect data content through encrypted storage, malicious servers and attackers can still infer private information by observing users' access patterns to the cloud database. For example, if a hospital stores patient information on a cloud server, a doctor's access patterns to the medical database on that cloud server could potentially expose the patient's diagnosis.

[0058] Oblivious Random Access Machines (ORAMs) are an important means of protecting access patterns. In existing ORAM designs, when a client communicates with a server, the server needs to traverse and access all data in the database for each client request. This prevents attackers from knowing which specific data in the database the client's request maps to, thus achieving obfuscation. While this method effectively hides data access patterns, it also increases data access time and impacts efficiency.

[0059] Therefore, how to improve the efficiency of data access when using an unintentional random access machine is a problem that needs to be solved.

[0060] The data access method provided in this application embodiment can be applied to, for example, Figure 1 The application environment shown. Figure 1 This is a schematic diagram of an application scenario for a data access method provided in this application embodiment, wherein the client 102 communicates with the server 104 via a network. The client 102 can be, but is not limited to, various personal computers, laptops, smartphones, tablets, IoT devices, and portable wearable devices. IoT devices can be smart speakers, smart TVs, smart air conditioners, smart in-vehicle devices, etc. Portable wearable devices can be smartwatches, smart bracelets, head-mounted devices, etc. The server 104 can be implemented using a standalone server or a server cluster composed of multiple servers. The server 104 includes two modules: a database 10 and a Trusted Execution Environment (TEE). The TEE technology can establish a secure computing area in the computer and provide hardware-level security isolation and protection for internal code and data. The database 10 can store up to M data items and can achieve O(1) data access; the TEE is required to open a cache area 21, which can store up to m data items, where m is much smaller than M.

[0061] This embodiment provides a data access method. Figure 2 This is a flowchart illustrating a data access method provided in this embodiment. The executing entity of this method can be an electronic device. Optionally, the electronic device can be a server or a client. This embodiment applies the data access method to a server as an example, but this application is not limited thereto. Specifically, as shown... Figure 2 As shown, the process includes the following steps:

[0062] Step S201: Obtain the actual data access request.

[0063] For example, the client sends a batch of actual data access requests to the server, and further, the server receives the actual data access requests sent by the client. Specifically, the actual data access requests are usually encrypted. When the server receives the encrypted actual data access requests, it forwards the encrypted actual data access requests to the trusted execution environment, thereby enabling the trusted execution environment to obtain the actual data access requests.

[0064] Step S202: Determine the actual number of data access requests.

[0065] Furthermore, the trusted execution environment decrypts the received encrypted actual data access requests and determines the actual number of actual data access requests in the batch of requests.

[0066] Step S203: Construct a virtual data access request based on the actual number of requests, the size of the cache, and the size of the database.

[0067] Furthermore, the trusted execution environment randomly constructs multiple virtual data access requests based on the actual number of requests, cache size, and database size.

[0068] Step S204: Based on the cached data in the cache area, determine the current target access request from the actual data access request and the virtual data access request.

[0069] The number of current target access requests is equal to the actual number of requests, and the cache is used to cache historical target data obtained from the database based on historical target access requests.

[0070] Furthermore, based on the cached data in the cache area, the current target access request is determined from the actual data access requests and the virtual data access requests. The data of the current target access request is equal to the number of actual data access requests in the batch, thereby constructing the current target access request by confusing the actual data access requests with the virtual data access requests.

[0071] A cache area can be a high-speed cache region opened in a trusted execution environment to cache historical target data accessed from the database based on historical target access requests.

[0072] Specifically, when the cache is not full and the cache contains historical target data obtained from the database based on historical target access requests, the actual data access request can be responded to based on the historical target data cached in the cache, and the current target access request can be determined from the actual data access request and the virtual data access request based on the response result.

[0073] To prevent attackers from inferring private information by detecting database access patterns, the current target access request is determined from both actual and virtual data access requests. By obfuscating the current target access request, attackers are unable to determine its authenticity, thus achieving data access pattern protection.

[0074] It should be noted that during multiple data accesses by a client to the database, there is a high probability that the same data will be accessed repeatedly. Furthermore, multiple requests during these accesses may correspond to any data in the database. Therefore, the cached data in the cache area is very likely to contain data that can respond to the current actual data access request.

[0075] Therefore, the current target access request is determined from both actual and virtual data access requests. This ensures that the current target access request includes the remaining actual data access requests that have not been responded to by cached data in the cache, as well as some virtual data access requests. Furthermore, it ensures that the number of current target access requests is equal to the number of actual data access requests. That is, some actual data access requests that can be responded to by cached data in the cache are replaced with virtual data access requests. This results in the current target access request including both actual and virtual data access requests. Even if an attacker monitors the current target access request's access pattern to the database, they cannot determine whether the data currently accessed from the database belongs to an actual or virtual data access request. This prevents attackers from knowing the storage location, access frequency, and access order of the client's accessed data, thus achieving access pattern protection.

[0076] Step S205: Access the current target data corresponding to the current target access request from the database.

[0077] Furthermore, the current target data corresponding to the current target access request is accessed from the database. Specifically, for each current target access request, a corresponding current target data is accessed from the database, thereby realizing data access for each current target access request. Moreover, when accessing the current target data in the database according to the current target access request, only one data in the database needs to be accessed for each request, realizing data access with a time complexity of O(1), without having to traverse and access all data in the database, thus improving the efficiency of data access by the random access machine.

[0078] In the above implementation process, virtual data access requests are constructed based on the actual number of actual data access requests, the size of the cache, and the size of the database. The current target access request is determined from the actual and virtual data access requests based on the cached data in the cache. The current target request is constructed by obfuscating the actual and virtual data access requests. Furthermore, the current target data corresponding to the current target access request is accessed from the database, ensuring that the data in the database is accessed at most once. This prevents attackers from verifying the authenticity of the current target access request when monitoring the database, thus protecting user access patterns. Moreover, for each current target access request, only the corresponding current target data needs to be accessed from the database, eliminating the need to traverse and access all data in the database, thereby improving the efficiency of unintentional random access machine data access.

[0079] In some embodiments, determining the target access request from actual data access requests and virtual data access requests based on cached data in the cache may include the following steps:

[0080] Step 1: Based on the cached data in the cache area, respond to both actual data access requests and virtual data access requests, and determine the response results.

[0081] For example, based on each cached data in the cache area, responses are made to actual data access requests and virtual data access requests to determine the response results of actual data access requests and virtual data access requests. The response results of actual data access requests and virtual data access requests include which requests were responded to and which requests were not responded to.

[0082] Specifically, actual data access requests and virtual data access requests are mapped to a hash table using a hash function. Furthermore, each cached data in the cache area is mapped to the aforementioned hash table using a hash function, and the requests at the hash positions corresponding to the cached data are traversed in the hash table to determine which requests among the actual data access requests and virtual data access requests are responded to and which requests are not responded to.

[0083] Step 2: Based on the response results, determine the responded data access requests, the unresponded actual data access requests, and the unresponded virtual data access requests. The responded data access requests include the responded actual data access requests and / or the responded virtual data access requests.

[0084] Furthermore, based on the response results, the actual data access requests and virtual data access requests are identified as responded data access requests, unresponded actual data access requests, and unresponded virtual data access requests. The responded data access requests include responded actual data access requests and / or responded virtual data access requests.

[0085] Specifically, based on the response results of all cached data in the cache area, the actual data access requests and virtual data access requests are identified as having responded, not having responded to actual data access requests, and not having responded to virtual data access requests.

[0086] If the cached data in the cache only contains data that can respond to actual data access requests, and does not contain data that can respond to virtual data access requests, then the responded data access requests only include the responded actual data access requests. If the cached data in the cache only contains data that can respond to virtual data access requests, and does not contain data that can respond to actual data access requests, then the responded data access requests only include the responded virtual data access requests. If the cached data in the cache contains data that can respond to both actual and virtual data access requests, then the responded data access requests include both the responded actual data access requests and the responded virtual data access requests.

[0087] Step 3: Sort the unresponsive actual data access requests, unresponsive virtual data access requests, and responded data access requests in sequence to obtain the sorted access requests.

[0088] Step 4: Determine the top N requests from the sorted access requests as the current target access requests, where N is equal to the actual number of requests.

[0089] Furthermore, in order to ensure that all unresponsive actual data access requests can be responded to by the data in the database, unresponsive actual data access requests are given the first priority, unresponsive virtual data access requests are given the second priority, and responded data access requests are given the third priority. The unresponsive actual data access requests, unresponsive virtual data access requests, and responded data access requests are sorted according to their priorities to obtain the sorted access requests.

[0090] Furthermore, the top N requests in the sorted access requests are determined as the current target access requests, where N is equal to the actual number of requests. Since some of the actual data access requests have already been responded to by cached data in the cache, the number of unresponsive actual data access requests is less than or equal to the actual number of requests. Also, the number of current target access requests is equal to the number of actual requests, and the unresponsive actual data access requests have the highest priority. Therefore, the target access requests must include all unresponsive actual data access requests, and possibly some virtual data access requests, thus ensuring that all actual data access requests can be responded to.

[0091] As one specific embodiment, after constructing a virtual data access request, the constructed virtual data access request is first marked, and the current target access request is determined, which can be achieved through the following steps:

[0092] Step 1: Construct a two-layer hash table using cryptographic hash functions Hs1 and Hs2, and map all virtual data access requests and all actual data access requests into this hash table to obtain the original hash table.

[0093] Step 2: Traverse the cached data in the cache area and map all the cached data to the original hash table using the cryptographic hash functions Hs1 and Hs2, thereby determining the requests that have been answered in the original hash table and marking the answered requests with a second mark.

[0094] Step 3: Determine the responded data access requests, the unresponded actual data access requests, and the unresponded virtual data access requests based on the first and second tags in the original hash table.

[0095] Step 4: Create a new hash table. Prioritize unresponsive actual data access requests as first priority, unresponsive virtual data access requests as second priority, and responded data access requests as third priority. Randomly sort all requests and map the sorted requests to the newly created hash table. The resulting sorted hash table will have the following order: any unresponsive actual data access request takes precedence over any unresponsive virtual data access request, and any unresponsive virtual data access request takes precedence over any responded data access request.

[0096] Step 5: Truncate the first N positions in the sorted hash table and take the requests corresponding to the first N positions as the current target access requests, where N is equal to the actual number of requests.

[0097] In the above implementation process, based on the cached data in the cache area, the actual data access requests and virtual data access requests are identified as follows: responded data access requests, unresponded actual data access requests, and unresponded virtual data access requests. The unresponded actual data access requests, unresponded virtual data access requests, and responded data access requests are then sorted in sequence. The top N requests after sorting are identified as the current target access requests, where N is equal to the number of actual requests. This ensures that the current target access requests include all unresponded actual data access requests, thereby ensuring that all actual data access requests can be responded to.

[0098] In some embodiments, after accessing the current target data corresponding to the current target access request from the database, the following steps may also be included:

[0099] Step 1: Respond to unresponsive actual data access requests based on the current target data.

[0100] Step 2: Return the actual data access request after the response to the client.

[0101] For example, after retrieving the current target data corresponding to the current target access request from the database, the trusted execution environment responds to the unresponsive actual data access requests based on the current target data, thereby achieving a response to all actual data access requests. Further, the trusted execution environment returns all responded actual data access requests to the client.

[0102] In one specific embodiment, after the trusted execution environment obtains the corresponding current target data from the database based on the current target access request, it maps the current target data to the original hash table. This allows it to respond to actual data access requests that are not responded to by cached data in the cache area of ​​the original hash table using the current target data, thereby enabling the response to all actual data access requests. Furthermore, the original hash table is inadvertently compressed to extract all responded actual data access requests. Finally, all responded actual data access requests are encrypted and returned to the client.

[0103] In the above implementation process, after the trusted execution environment obtains the current target data from the database, it responds to the unresponsive actual data access requests based on the current target data, thereby realizing the response to all actual data access requests, and returns all the responded actual data access requests to the client, thus realizing the response to the client.

[0104] In some embodiments, after accessing the current target data corresponding to the current target access request from the database, the method further includes: caching the current target data in a cache area.

[0105] For example, after the trusted execution environment retrieves the corresponding current target data from the database based on the current target access request, it can also cache the current target data in the cache area, so that the cached data can respond to the next batch of actual data access requests.

[0106] In the above implementation process, after accessing the current target data corresponding to the current target access request from the database, the current target data is stored in the cache area, so that the cached data in the cache area can respond to the next batch of actual request data.

[0107] In some embodiments, the following steps may be included before determining the actual number of actual data access requests:

[0108] Step 1: Determine the storage status of the cache area.

[0109] For example, after receiving an actual data access request, the trusted execution environment can also determine the storage status of the cache before determining the actual number of actual data requests. The storage status of the cache may include a full state or a non-full state.

[0110] Step 2: If the cache is full, write the cached data back to the database and clear the cache.

[0111] Step 3: Retrieve the stored data from the database.

[0112] Step 4: Reorder the storage locations of the stored data and respond to the actual data access request based on the stored data.

[0113] Furthermore, if the storage state of the cache is not full, the trusted execution environment enters the normal state, that is, in the normal state, the trusted execution environment executes steps S202 to S205.

[0114] If the cache is full, the cached data is written back to the database and the cache is cleared, thus putting the trusted execution environment into a reordered state.

[0115] Specifically, when the Trusted Execution Environment (TEE) enters the rearrangement state, it retrieves the stored data from the database, further rearranges the storage locations of the stored data, and responds to the actual data access request based on the retrieved stored data. Furthermore, it encrypts the responded actual data access request and returns it to the client.

[0116] Furthermore, after the storage location of the stored data is rearranged, the state of the cache is switched to an unloaded state, and the trusted execution environment is switched to a normal state.

[0117] In the above implementation process, when the cache storage is full, the cached data is written back to the database and the cache is cleared, which facilitates the reuse of the limited cache. Furthermore, after obtaining the stored data from the database, the storage location of the stored data is rearranged, and the actual data access request is responded to based on the rearranged data. Thus, while the stored data is being rearranged, the current request can also be responded to, avoiding response interruptions during data access. Moreover, responding to the actual data access request with the rearranged data can effectively protect the data access mode.

[0118] In some embodiments, the database includes multiple local storage data, the storage locations of the stored data are rearranged, and responses to actual data access requests are based on the stored data, which may include:

[0119] The database undergoes multiple rounds of full processing, each round comprising multiple partial processing stages. Each partial processing stage processes a corresponding local storage data, and the following steps are executed in each partial processing stage:

[0120] Step 1: Scan the local storage data of the current local processing stage to obtain the current local storage data.

[0121] Step 2: Rearrange the storage locations of the current local storage data to obtain the current local rearranged data.

[0122] Step 3: Respond to the actual data access request based on the current local rearranged data.

[0123] For example, when the feasible execution environment enters the rearrangement state, it needs to rearrange the stored data in the database. However, due to the limited processing performance of the trusted execution environment, it can only process a portion of the stored data in the database. Therefore, the stored data in the database can be divided into multiple local stored data, so that the trusted execution environment can process each local stored data separately.

[0124] When rearranging the storage locations of stored data, a bitonic sorting algorithm can be used to rearrange the storage locations of the stored data, and to respond to actual data access requests during the rearrangement process. Specifically, the process of using a bitonic sorting algorithm for rearrangement and responding to actual data access requests can include:

[0125] The bitonic sorting algorithm determines the number of times to process the database based on its size. Furthermore, based on this determined number of processing times, it performs multiple complete processing operations on the database, i.e., multiple rounds of complete processing. Due to the limited processing performance of the trusted execution environment, each round of complete processing is divided into multiple local processing stages. Each local processing stage processes a corresponding local storage data. This process includes rearrangement and response. Specifically, each local processing stage may include:

[0126] According to the preset scanning order in the bitonic sorting algorithm, the local storage data corresponding to the current local processing stage is scanned in pairs to obtain the current local storage data.

[0127] Furthermore, based on the sorting rules of the bitonic sorting algorithm, the storage locations of the acquired local storage data are rearranged to obtain the current local rearranged data, and the actual data access request is responded to based on the current local rearranged data.

[0128] As another example, in the current local processing stage, after obtaining the current local storage data, it may also include: rearranging the storage location of the obtained current local storage data according to the sorting rules of the bitonic sorting algorithm, and responding to the actual data access request according to the current local storage data.

[0129] Repeat steps 1 to 3 above until multiple local processing stages are completed, thus completing one round of processing. This means that a traversal of all stored data in the database is achieved, and a batch of actual data access requests can be responded to during a single traversal.

[0130] Furthermore, the process proceeds to the next complete processing round. In this round, the system can respond to the next batch of actual data access requests and repeat steps 1 to 3 until the multiple rounds of complete processing are finished, at which point the process of rearranging the data stored in the database ends.

[0131] In the above implementation process, the database rearrangement process is divided into multiple repeated processes, thereby improving the randomness of the rearranged stored data. Each rearrangement process is divided into multiple local stages. In each local processing stage, the acquired local stored data is rearranged, and the actual data access request is responded to based on the rearranged local data. This achieves protection of the data access mode. Furthermore, when the trusted execution environment enters the rearrangement state, not only can the storage location of the stored data in the database be rearranged, but requests can also be responded to, avoiding the interruption of the data access process due to stopping the response to requests during the data rearrangement process.

[0132] In some embodiments, after responding to the actual data access request based on the current local rearranged data, the method further includes: after completing a full round of processing, returning the responded actual data access request to the client.

[0133] For example, after completing a full round of processing, a traversal of all stored data in the database is achieved, thereby enabling a response to a batch of actual data access requests. Furthermore, the actual data access requests after the response are returned to the client, thus realizing the response to the requests during the reordering process.

[0134] In one specific embodiment, when the trusted execution environment receives a batch of actual data access requests and the cache is in a full state, a two-layer hash table is constructed using a cryptographic hash function, and the batch of actual data access requests is mapped to the hash table.

[0135] Furthermore, the trusted execution environment performs a rearrangement process. In each local processing stage, local storage data in the database is obtained according to the predefined order in the bitonic sorting algorithm, and the storage location of the obtained local storage data is rearranged using the bitonic sorting algorithm to obtain the rearranged local storage data.

[0136] Furthermore, the rearranged local storage data is mapped to the aforementioned hash table, so that the rearranged data responds to actual data access requests. After all actual data access requests are responded to, the hash table is compressed using an inadvertent algorithm to extract all responded actual data access requests. All responded actual data access requests are then encrypted and returned to the client, and the next round of complete processing is repeated until the rearrangement process set by the bitonic sorting algorithm ends.

[0137] In the above implementation process, during the reordering process, after a complete processing of the database, it is possible to achieve a complete response to a batch of actual data access requests and return the responded actual data access requests to the client, thus realizing the response to the client's access requests.

[0138] In some embodiments, constructing virtual data access requests based on the actual number of requests, cache size, and database size may include the following steps:

[0139] Step 1: Determine the number of virtual requests based on the actual number of requests, the cache size, and the database size.

[0140] Step 2: Based on the number of virtual requests, randomly construct virtual data access requests.

[0141] For example, determining the number of virtual requests based on the actual number of requests, the cache size, and the database size can include: determining the number of virtual requests based on the actual number of requests, the cache size, the database size, and a preset probability threshold.

[0142] Specifically, assuming that all actual data access requests can be responded to by the cached data in the cache area, the actual number of actual data access requests is B, and the number of randomly constructed virtual data access requests is P. Assuming that there are no duplicate requests among the B+P requests consisting of P virtual requests and B actual requests, in the worst case (when all B actual data access requests have been accessed), it is necessary to determine P that satisfies the condition that at least B virtual data access requests have not been accessed.

[0143] That is, the number P of randomly constructed virtual data access requests satisfies the following condition:

[0144]

[0145] Where B represents the actual number of data access requests, C represents the size of the cache, D represents the size of the database, and P represents the number of virtual requests.

[0146] In other words, the above condition (1) is that, under the condition that all actual data access requests have been accessed and the randomly generated virtual data access requests are not repeated, at least B of the generated P virtual data access requests have not been accessed.

[0147] Furthermore, the probability that the above conditions are met by controlling the number P of randomly constructed virtual data access requests can be used to ensure that virtual data access requests do not overlap with actual data access requests, and that the randomly constructed virtual data access requests themselves do not overlap. If the probability threshold to be controlled is X, then the following expression exists:

[0148]

[0149] Where X represents the number of virtual data access requests P that satisfies the preset probability threshold of condition (1) when there is no duplication between virtual data access requests and actual data access requests, and when there is no duplication between virtual data access requests themselves. i is a natural number.

[0150] Furthermore, the number of virtual requests can be determined according to the above expressions (1) and (2). Further, parameters are randomly selected from the database according to the number of virtual requests to construct virtual data access requests.

[0151] In the above implementation process, the number of virtual requests is determined based on the actual number of requests, the size of the cache, and the size of the database. This allows us to determine the conditions that must be met for database access requests to be unique. Furthermore, it facilitates the control of these conditions through a preset probability threshold, thereby ensuring, probabilistically, that the constructed virtual data access requests are not duplicates of the actual data access requests, and that the virtual data access requests themselves are unique. In addition, virtual data access requests are randomly constructed based on the number of virtual requests, thus realizing the construction of virtual data access requests.

[0152] Figure 3 This is a flowchart of an embodiment of a data access method provided in this application, as shown in the example. Figure 3 As shown, the flowchart includes the following steps:

[0153] Step S301: Obtain the actual data access request.

[0154] Specifically, the server receives the actual data access request sent by the client and transmits the actual data access request to the trusted execution environment, thereby enabling the trusted execution environment to obtain the actual data access request.

[0155] Step S302: Determine whether the cache is full.

[0156] Furthermore, the trusted execution environment determines whether the cache is fully loaded. If the cache is not fully loaded, the trusted execution environment enters the normal state; if the cache is fully loaded, the trusted execution environment enters the reordering state.

[0157] Step S303: Construct a virtual data access request.

[0158] Specifically, when the cache storage is not full, the trusted execution environment enters the normal state. Furthermore, the trusted execution environment determines the number of virtual requests based on the number of actual data requests, the size of the cache, and the size of the database. It then randomly selects enough keys from the database keys to generate virtual data requests based on the data of the virtual requests. If the number of generated virtual requests is P and the number of actual data requests sent by the client is B, then the total number of requests is B', i.e., B' = B + P.

[0159] Furthermore, a two-layer hash table is constructed using cryptographic hash functions Hs1 and Hs2, and B' requests are mapped to this hash table. Specifically, the randomly generated P requests are specially marked.

[0160] Specifically, a bucket size S is defined. For B' requests, a two-level hash table is built using cryptographic hash functions Hs1 and Hs2. Figure 4This is a schematic diagram of the structure of a hash table provided in an embodiment of this application, such as... Figure 4 As shown, each hash table contains (B' / S) hash positions, and each hash position can store up to 2S requests, meaning each hash position includes 2S data bits; the two-level hash tables are stored contiguously, as shown below. Figure 4 In the table, the first to the second S data bits correspond to the first hash position of the first-level hash table, and the second S*(B' / S)+1 to the second S*(B' / S)+2S data bits correspond to the first hash position of the second-level hash table. All data bits in the table have four bit flags: dummy, padding, hit, and excess. All flags of all data bits are initially 0. For all currently empty data bits in the table, their dummy flag is set to 1, indicating that the data bit is empty.

[0161] Furthermore, B' data bits are added before the hash table to temporarily store the requests. Figure 5 This is a schematic diagram of another hash table structure provided in an embodiment of this application. Figure 5 The hash table shown is in Figure 4 The hash table shown has B' data bits added before it.

[0162] Furthermore, the aforementioned B' requests are mapped to [the appropriate methods] in the order that actual data access requests take precedence over virtual data access requests. Figure 5 The first B' data bits in the hash table shown are... Figure 5 The first to B' data bits are shown, and the padding flag of the last (B'-B) data bits is set to 1, i.e. Figure 5 The data bits from B+1 to B' shown represent virtual data access requests.

[0163] Furthermore, based on the position of each request in the first-level hash table, the first B'+2S*(B' / S) positions are inadvertently sorted, and the sorted first B'+2S*(B' / S) positions are traversed, i.e. Figure 5 If the number of data bits at a hash position exceeds 2S, the overflow flag of the overflow portion is set to 1. Based on the overflow flag and the hash position of the first level, all overflow portions are sequentially placed at the end of the first-level hash table. Figure 5 The hash table shown contains data bits from the 2S*(B' / S)+1 to the 2S*(B' / S)+B'th bits.

[0164] Furthermore, based on the position of each request in the second-level hash, the last 2S*(B' / S)+B' positions are inadvertently sorted, and the sorted last 2S*(B' / S)+B' positions are traversed, i.e. Figure 5 In the hash table, from the 2S*(B' / S)+1 to the 4S*(B' / S)+B' data bits, if a hash position contains more than 2S data bits, the excess flag of the overflow portion is set to 1. Based on the excess flag and the hash position of the second layer, the overflow portion is sequentially placed at the end of the second-layer hash table. Figure 5 The data bits from the 4S*(B' / S)+1 to the 4S*(B' / S)+B'th bits in the hash table are used to ultimately map B' requests to the two-level hash table.

[0165] Step S304: Respond to actual data access requests and virtual data access requests based on the cached data in the cache area.

[0166] Furthermore, based on the cached data in the cache area, responses are made to both actual data access requests and virtual data access requests, thereby determining which requests have been responded to and which have not.

[0167] Specifically, each cached data in the cache area is traversed, and each cached data is mapped to the corresponding position in the two-layer hash table. Further, requests at the corresponding positions of cached data are traversed in the two-layer hash table to determine whether each cached data can respond to the request at the corresponding position. If a request can be responded to by the cached data at the corresponding position, the hit flag of that data bit is set to 1, indicating that the request is responded to by the cached data in the cache area. In this way, it is possible to determine the actual data access requests and virtual data access requests, including unresponsive actual data access requests, unresponsive virtual data access requests, and responded requests.

[0168] Step S305: Sort the unresponsive actual data access requests, unresponsive virtual data access requests, and responded requests.

[0169] Furthermore, the unresponsive actual data access requests, unresponsive virtual data access requests, and responded requests are sequentially sorted, and the sorted requests are mapped to a new hash table. In the new hash table, the unresponsive actual data access requests have a higher priority than the unresponsive virtual data access requests, and the unresponsive virtual data access requests have a higher priority than the responded requests. This ensures that all unresponsive actual data access requests can be responded to by the data in the database.

[0170] Step S306: Select the number of requests equal to the actual number of data access requests from the sorted requests as the target access requests.

[0171] Furthermore, among the sorted requests, the first B requests are identified as target access requests, and these target access requests are sent to the database.

[0172] Step S307: Retrieve the target data corresponding to the target access request from the database.

[0173] Furthermore, the trusted execution environment retrieves the corresponding target data from the database based on the target access request.

[0174] Step S308: Respond to the actual data access request that was not responded to based on the target data.

[0175] Furthermore, respond to unresponsive actual data access requests based on the target data.

[0176] Specifically, the trusted execution environment maps the target data obtained from the database to the hash table in step S304, so that the target data responds to the corresponding target access request, and even actual data access requests that do not respond can be responded to.

[0177] Step S309: Encrypt the actual data access request after the response is completed and return it to the client.

[0178] Furthermore, the hash table is inadvertently compressed to extract the actual data access request after the response, and this response is then encrypted and returned to the client. Additionally, all target data retrieved from the database is stored in a cache.

[0179] Step S310: Obtain the stored data from the database.

[0180] Specifically, if the cache is fully loaded, the trusted execution environment enters a reordering state, writes the cached data back to the database, and clears the cache.

[0181] Furthermore, when the trusted execution environment enters the reordering phase, it constructs a hash table using a cryptographic hash function and maps B requests to that hash table.

[0182] Step S311: Rearrange the storage locations of the stored data using a bitonic sorting algorithm and respond to actual data access requests.

[0183] Furthermore, the bitonic sorting algorithm is applied to determine the number of complete processing rounds for the database based on the size of the database. Since the processing performance of the trusted execution environment is limited, a complete round of database processing needs to be divided into multiple processing batches. If the number of complete processing rounds for the database is determined to be b rounds by the bitonic sorting algorithm, and each round needs to be divided into c processing batches, then the process of rearranging the database and responding to requests using the bitonic sorting algorithm includes a = b * c processing batches.

[0184] The database storage data is divided into c parts. In a complete processing round, each batch processes one part of the storage data. Each processing batch may include:

[0185] According to the scanning rules of the bitonic sorting algorithm, the corresponding partial storage data is scanned in pairs. According to the sorting rules of the bitonic sorting algorithm, the storage locations of the scanned partial storage data are rearranged to the data temporary storage area of ​​the trusted execution environment. The data temporary storage area can be a buffer. Further, the rearranged partial storage data in the buffer is mapped to the hash table in step S310 through a hash function. All requests corresponding to the hash location of each partial storage data are traversed to determine the actual data request to be responded to. The data in the buffer after processing is written back.

[0186] In each processing batch, only a portion of the actual data access requests may be responded to. Further, the reordering and request response process of the next processing batch is executed until c processing batches are completed, thus completing a full round of processing. After a full round of processing, responses to all actual data requests can be achieved. When the actual data access requests are responded to, step S309 is executed, which encrypts the responded actual data access requests and returns them to the client.

[0187] Specifically, the hash table after the request and response is unintentionally compressed to obtain the actual data access request after the response, and the actual data access request after the response is encrypted and returned to the client.

[0188] Further, the next round of complete processing is executed until the b-th round of complete processing is completed, at which point the data rearrangement and request-response process ends.

[0189] It should be noted that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps.

[0190] This embodiment also provides a data access device for implementing the above embodiments and preferred embodiments; details already described will not be repeated. The terms "module," "unit," "subunit," etc., used below refer to combinations of software and / or hardware that perform a predetermined function. Although the device described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0191] Figure 6 This is a structural block diagram of a data access device provided in an embodiment of this application. The device is applied to a server, which includes a cache and a database, such as... Figure 6 As shown, the device includes:

[0192] Module 601 is used to obtain actual data access requests;

[0193] The first determining module 602 is used to determine the actual number of actual data access requests;

[0194] Request building module 603 is used to build virtual data access requests based on the actual number of requests, cache size, and database size;

[0195] The second determining module 604 is used to determine the current target access request from the actual data access requests and the virtual data access requests based on the cached data in the cache area. The number of current target access requests is equal to the number of actual requests. The cache area is used to cache historical target data obtained from the database based on historical target access requests.

[0196] The data access module 605 is used to access the current target data corresponding to the current target access request from the database.

[0197] In some embodiments, the second determining module 604 is specifically used for:

[0198] Based on the cached data in the cache area, respond to both actual data access requests and virtual data access requests, and determine the response results;

[0199] Based on the response results, determine the responded data access requests, the unresponded actual data access requests, and the unresponded virtual data access requests. The responded data access requests include the responded actual data access requests and / or the responded virtual data access requests.

[0200] The unresponsive actual data access requests, unresponsive virtual data access requests, and responded data access requests are sorted sequentially to obtain the sorted access requests.

[0201] The top N requests from the sorted access requests are identified as the current target access requests, where N is equal to the actual number of requests.

[0202] In some embodiments, the data access module 605 is further configured to:

[0203] Respond to unresponsive actual data access requests based on the current target data;

[0204] The actual data access request is returned to the client in response.

[0205] In some embodiments, the data access module 605 is further configured to:

[0206] Cache the current target data in the cache area.

[0207] In some embodiments, the first determining module 602 is further configured to:

[0208] Determine the storage status of the cache;

[0209] If the cache is full, write the cached data back to the database and clear the cache.

[0210] Retrieve stored data from the database;

[0211] The storage locations of the stored data are rearranged, and actual data access requests are responded to based on the stored data.

[0212] In some embodiments, the database includes multiple locally stored data, and the first determining module 602 is specifically used for:

[0213] The database undergoes multiple rounds of full processing, each round comprising multiple partial processing stages. Each partial processing stage processes a corresponding local storage data, and the following steps are executed in each partial processing stage:

[0214] Scan the local storage data of the current local processing stage to obtain the current local storage data;

[0215] The storage locations of the current local storage data are rearranged to obtain the current locally rearranged data;

[0216] Respond to actual data access requests based on the current locally rearranged data.

[0217] In some embodiments, the first determining module 602 is specifically used for:

[0218] After completing a full round of processing, the actual data access request is returned to the client in response.

[0219] In some embodiments, the request construction module 603 is specifically used for:

[0220] The number of virtual requests is determined based on the actual number of requests, the cache size, and the database size.

[0221] Virtual data access requests are randomly generated based on the number of virtual requests.

[0222] It should be noted that the above modules can be functional modules or program modules, and can be implemented through software or hardware. For modules implemented through hardware, the above modules can reside in the same processor; or the above modules can be located in different processors in any combination.

[0223] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 7 As shown. Figure 7 This is a schematic diagram of a computer device structure provided in an embodiment of this application. The computer device includes a processor, a memory, and a network interface connected via a system bus. The processor of the computer device provides computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage medium. The database of the computer device is used to store data. The network interface of the computer device is used to communicate with external terminals via a network connection. When the computer program is executed by the processor, it implements a data access method.

[0224] Those skilled in the art will understand that Figure 7 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0225] In one embodiment, an electronic device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above method embodiments.

[0226] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon that, when executed by a processor, implements the steps in the above method embodiments.

[0227] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties.

[0228] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0229] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0230] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of patent protection. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the appended claims.

Claims

1. A data access method, characterized in that, The data access method is applied to a server, which includes a cache and a database, including: Obtain the actual data access request; Determine the actual number of data access requests; A virtual data access request is constructed based on the actual number of requests, the cache size, and the database size. Based on the cached data in the cache area, the current target access request is determined from the actual data access request and the virtual data access request. The number of the current target access requests is equal to the number of actual requests. The cache area is used to cache historical target data obtained from the database based on historical target access requests. Access the current target data corresponding to the current target access request from the database.

2. The data access method according to claim 1, characterized in that, Determining the target access request from the actual data access request and the virtual data access request based on the cached data in the cache area includes: Based on the cached data in the cache area, respond to the actual data access request and the virtual data access request, and determine the response result; Based on the response results, the responded data access requests, the unresponded actual data access requests, and the unresponded virtual data access requests are determined. The responded data access requests include responded actual data access requests and / or responded virtual data access requests. The unresponsive actual data access requests, the unresponsive virtual data access requests, and the responded data access requests are sorted sequentially to obtain the sorted access requests; The first N requests in the sorted access requests are determined as the current target access requests, where N is equal to the actual number of requests.

3. The data access method according to claim 2, characterized in that, After accessing the current target data corresponding to the current target access request from the database, the method further includes: Respond to the unresponsive actual data access request based on the current target data; The actual data access request, after being responded to, is returned to the client; The current target data is cached in the cache area.

4. The data access method according to claim 1, characterized in that, Before determining the actual number of actual data access requests, the method further includes: Determine the storage status of the cache area; If the cache is full, the cached data in the cache is written back to the database, and the cache is cleared. Retrieve stored data from the database; The storage locations of the stored data are rearranged, and the actual data access request is responded to based on the stored data.

5. The data access method according to claim 4, characterized in that, The database includes multiple local storage data. The process of rearranging the storage locations of the stored data and responding to the actual data access request based on the stored data includes: The database is processed in multiple rounds of full processing. Each round of full processing includes multiple local processing stages. Each local processing stage processes a corresponding local storage data. The following steps are performed in each local processing stage: Scan the local storage data of the current local processing stage to obtain the current local storage data; The storage locations of the current local storage data are rearranged to obtain the current local rearranged data; The actual data access request is responded to based on the current locally rearranged data.

6. The data access method according to claim 5, characterized in that, After responding to the actual data access request based on the current local rearrangement data, the method further includes: After completing a full round of processing, the actual data access request is returned to the client in response.

7. The data access method according to claim 1, characterized in that, The process of constructing a virtual data access request based on the actual number of requests, the cache size, and the database size includes: The number of virtual requests is determined based on the actual number of requests, the cache size, and the database size. The virtual data access requests are randomly generated based on the number of virtual requests.

8. A data access device, characterized in that, The data access device is applied to a server, which includes a cache and a database, including: The acquisition module is used to acquire actual data access requests; The first determining module is used to determine the actual number of actual data access requests; A request construction module is used to construct virtual data access requests based on the actual number of requests, the cache size, and the database size. The second determining module is used to determine the current target access request from the actual data access request and the virtual data access request based on the cached data in the cache area. The number of the current target access requests is equal to the number of actual requests. The cache area is used to cache historical target data obtained from the database based on historical target access requests. The data access module is used to access the current target data corresponding to the current target access request from the database.

9. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to run the computer program to perform the data access method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the data access method according to any one of claims 1 to 7.

Images