Secure interaction method and system for data space sandbox and data source

Abstract

The invention discloses a secure interaction method and system for a data space sandbox and a data source, and the method comprises the steps: initializing and authenticating a sandbox environment, and generating a unique environment identifier EnvID; based on the threshold signature scheme, negotiating among the plurality of key management nodes, the sandbox and the data source to generate a session key; the method comprises the following steps: sending a data request to a data source through a sandbox, requesting data added with an environment identifier EnvID based on a sandbox private key signature, after the data source receives the data request and verifies the signature, encrypting outer-layer data based on a session key, encrypting inner-layer data based on an attribute-based encryption algorithm, and generating Merkle root hash of response data; and decrypting outer-layer data based on the session key in a memory through a sandbox, decrypting and processing inner-layer data based on an attribute-based encryption private key, generating a zero-knowledge proof zkProof, and submitting Merkle root hash and the zero-knowledge proof zkProof to a block chain for evidence storage and auditing.

Description

Technical Field

[0001] This invention relates to the field of secure interaction technology, and more specifically, to a method and system for secure interaction between a data space sandbox and a data source. Background Technology

[0002] With the rapid development of the digital economy, the value of data as a new production factor is becoming increasingly prominent. However, the security and privacy protection issues in data circulation have become core challenges hindering its efficient utilization. Trusted Data Space (TDS), as a new type of data circulation infrastructure, aims to achieve multi-party data sharing and value co-creation through rule constraints, technical safeguards, and ecological collaboration.

[0003] However, the current trusted data space still faces the following technical bottlenecks:

[0004] Security Challenges of Trusted Data Space (TDS)

[0005] Data source risks: Remote data sources need to provide sensitive data to the sandbox, but cannot verify whether the sandbox's runtime state is compliant (e.g., whether malicious code has been injected); Transport layer defects: Traditional TLS only guarantees the security of the transmission channel, but the data is exposed after decryption once it arrives at the sandbox, making it vulnerable to memory extraction attacks; Audit blind spots: Existing log audits cannot cryptographically prove that the data processing process has not exceeded authority (e.g., whether the original data has been copied).

[0006] Existing sandbox data encryption schemes are mainly based on hardware support, static key management, and blockchain-based evidence storage, but they have some limitations:

[0007] Hardware-dependent solutions: These rely on TEE technologies such as Intel SGX, which require specific hardware support and are vulnerable to side-channel attacks.

[0008] Static key management: The existing method of using fixed transmission keys means that historical data can be decrypted if the key is leaked.

[0009] High verification overhead: Although blockchain-based evidence storage prevents tampering, uploading all data to the chain leads to a decrease in throughput and affects system performance. Summary of the Invention

[0010] According to the present invention, a method for secure interaction between a data space sandbox and a data source is provided, comprising:

[0011] Initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID;

[0012] Based on the threshold signature scheme, session keys are negotiated and generated among multiple key management nodes, sandboxes, and data sources;

[0013] The sandbox sends a data request to the data source, and the request requests the data with the attached environment identifier Env_ID based on the sandbox private key signature. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data.

[0014] The outer data is decrypted in memory using the session key via a sandbox, and the inner data is decrypted and processed using the attribute-based encryption private key to generate a zero-knowledge proof zkProof. The Merkle root hash and the zero-knowledge proof zkProof are then submitted to the blockchain for storage and auditing.

[0015] Optionally, initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID, including:

[0016] Initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB;

[0017] The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

[0018] Optionally, based on a threshold signature scheme, a session key is negotiated and generated among multiple key management nodes, sandboxes, and data sources, including:

[0019] Select several key management nodes through the key management module;

[0020] A threshold signature scheme is used to generate multiple key fragments corresponding to a session;

[0021] The key fragments are encrypted using the data source public key, sandbox public key, and control plane public key, and then transmitted to the data source, sandbox, and key management node, respectively.

[0022] The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

[0023] Optionally, a data request is sent to the data source via a sandbox. The request is made by signing the data with the attached environment identifier Env_ID using the sandbox private key. After receiving the data request and verifying the signature, the data source encrypts the outer data using the session key and the inner data using an attribute-based encryption algorithm, generating a Merkle root hash of the response data, including:

[0024] Data requests are sent to the data source based on the sandbox. The data requests are signed with the sandbox private key and attached with a policy token Token_Policy, and request data with an attached environment identifier Env_ID.

[0025] After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and encrypts the inner data based on the attribute-based encryption algorithm bound to the policy attribute. The policy attribute includes at least the environment identifier Env_ID and the prohibit copying attribute.

[0026] The data source generates the Merkle root hash of the response data and signs the Merkle root hash using the data source's private key.

[0027] Optionally, the sandbox decrypts the outer data in memory based on the session key, decrypts and processes the inner data based on the attribute-based encryption private key, generates a zero-knowledge proof zkProof, and submits the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for notarization and auditing, including:

[0028] The outer data is decrypted in memory using the session key via a sandbox, and the inner data is decrypted using the attribute-based encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data.

[0029] The decrypted data is processed in an isolated memory area using a sandbox to obtain the processing results and prevent persistent data storage.

[0030] The sandbox generates a zero-knowledge proof zkProof based on the processing results, and submits the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0031] According to another aspect of the present invention, a secure interaction system between a data space sandbox and a data source is also provided, comprising:

[0032] The environment identifier generation module is used to initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID;

[0033] The session key generation module is used to negotiate and generate session keys between multiple key management nodes, sandboxes, and data sources based on a threshold signature scheme.

[0034] The root hash generation module is used to send data requests to the data source through the sandbox. It requests data with the attached environment identifier Env_ID based on the sandbox private key signature. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data.

[0035] A zero-knowledge proof generation module is used to decrypt outer data in memory based on the session key through a sandbox, decrypt inner data based on the attribute-based encryption private key and process it to generate a zero-knowledge proof zkProof. The Merkle root hash and the zero-knowledge proof zkProof are then submitted to the blockchain for storage and auditing.

[0036] Optionally, an environment identification module is generated, including:

[0037] The environment identifier generation submodule is used to initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB;

[0038] The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

[0039] Optionally, the session key generation module includes:

[0040] The Key Management Node Selection submodule is used to select several key management nodes through the Key Management Module.

[0041] The key fragment generation submodule is used to generate multiple key fragments corresponding to a session using a threshold signature scheme.

[0042] The encryption key sharding submodule is used to encrypt key shards using the data source public key, sandbox public key, and control plane public key, and then transmit them to the data source, sandbox, and key management node, respectively.

[0043] The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

[0044] Optionally, the root hash module is generated, including:

[0045] The data request sending submodule is used to send data requests to the data source based on the sandbox. The data request is signed with the sandbox private key and attached with a policy token Token_Policy, and requests data with an attached environment identifier Env_ID.

[0046] The data encryption submodule is used to encrypt the outer layer data based on the session key and the inner layer data based on the attribute-based encryption algorithm bound to the policy attribute after the data source receives the data request and verifies the signature. The policy attribute includes at least the environment identifier Env_ID and the prohibition of copying attribute.

[0047] The Root Hash Generation Submodule is used to generate the Merkle root hash of the response data from the data source and to sign the Merkle root hash using the data source's private key.

[0048] Optionally, a zero-knowledge proof module is generated, including:

[0049] The decryption data acquisition submodule is used to decrypt the outer data in memory based on the session key through a sandbox, and decrypt the inner data based on the attribute base encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data;

[0050] The "Obtain Processing Result" submodule is used to process the decrypted data in an isolated memory area through a sandbox, obtain the processing result, and prohibit persistent storage of the data.

[0051] The zero-knowledge proof generation submodule is used to generate a zero-knowledge proof zkProof based on the processing results through a sandbox, and submit the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0052] This enhances sandbox security by binding sandbox environment identifiers and signatures, effectively reducing the risk of cloning attacks; session-level key lifecycle management effectively mitigates the risk of key reuse attacks. It also improves data transmission security through multi-layered encryption, further reducing security risks associated with interactions between the sandbox and data sources within the data space. Finally, it improves the efficiency of data proof in the data space by adopting the Groth16 scheme and optimizing zkProof generation efficiency. Attached Figure Description

[0053] Exemplary embodiments of the present invention can be more fully understood by referring to the following figures:

[0054] Figure 1 This is a flowchart illustrating a secure interaction method between a data space sandbox and a data source as described in this embodiment.

[0055] Figure 2 This is a schematic diagram of the system architecture described in this embodiment;

[0056] Figure 3 This is a schematic diagram illustrating the interaction timing between the sandbox, control plane, data source, and blockchain described in this embodiment.

[0057] Figure 4 This is a schematic diagram of a data space sandbox and data source security interaction system described in this embodiment. Detailed Implementation

[0058] Exemplary embodiments of the invention will now be described with reference to the accompanying drawings. However, the invention may be embodied in many different forms and is not limited to the embodiments described herein. These embodiments are provided to fully and completely disclose the invention and to fully convey its scope to those skilled in the art. The terminology used in the exemplary embodiments illustrated in the drawings is not intended to limit the invention. In the drawings, the same units / elements are referred to by the same reference numerals.

[0059] Unless otherwise stated, the terms used herein (including technical terms) have their common meaning as understood by one of ordinary skill in the art. Furthermore, it is understood that terms defined in commonly used dictionaries should be understood to have a meaning consistent with the context of their relevant field, and not to be interpreted as having an idealized or overly formal meaning.

[0060] According to a first aspect of the present invention, a method 100 for secure interaction between a data space sandbox and a data source is provided, with reference to... Figure 1 As shown, the method 100 includes:

[0061] S101: Initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID;

[0062] S102: Based on the threshold signature scheme, a session key is negotiated and generated among multiple key management nodes, sandboxes, and data sources;

[0063] S103: Send a data request to the data source through the sandbox, request data with the attached environment identifier Env_ID based on the sandbox private key signature, and after the data source receives the data request and verifies the signature, encrypt the outer data based on the session key and encrypt the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data.

[0064] S104: Decrypt the outer data in memory using the session key through a sandbox, decrypt the inner data using the attribute-based encryption private key and process it to generate a zero-knowledge proof zkProof, and submit the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0065] Specifically, this implementation proposes a method and system for secure interaction between a data space sandbox and a data source. The system architecture is shown in the appendix. Figure 2 .

[0066] The system mainly consists of a key management module, a policy engine module, and an audit agent module. The key management module is responsible for generating session key fragments with a certain validity period based on threshold signatures (TSS); the policy engine is responsible for defining data usage policies and compiling them into ABE policy attributes; the audit agent module verifies the correctness of zkProof and is responsible for triggering the violation circuit breaker mechanism.

[0067] The core interaction flow of the system is as follows:

[0068] Sandbox Environment Initialization and Authentication

[0069] When the sandbox starts, it collects the hardware fingerprint (CPU microcode hash + memory address randomization seed) and generates the environment identifier Env_ID;

[0070] Register the Env_ID with the control plane and obtain the digital certificate Cert_SB.

[0071] Dynamic key negotiation

[0072] Through decentralized key fragmentation management and strict lifecycle control, session-level keys achieve single-use validity and attack resistance. (Reference) Figure 3 As shown, the specific process is as follows:

[0073] Select 3 key management nodes;

[0074] Key fragments are generated using the Shamir threshold scheme;

[0075] The encrypted fragment transmission key is sent to three locations: the KM node, the sandbox, and the data source.

[0076] Memory combination key.

[0077] The code example is as follows:

[0078] # Pseudocode: Key distribution based on threshold signature def key_negotiation(data_source_id,sandbox_id,policy_id):

[0079] #Select 3 KM nodes (n=3, t=2)

[0080] nodes=select_km_nodes(t=2)

[0081] # Generate key fragments (Shamir threshold scheme)

[0082] key_shards=[generate_shard()for_in range(3)]

[0083] #Encrypted Fragmented Transmission

[0084] #Data source key

[0085] encrypt_to_ds(key_shards[0],data_source_pubkey)

[0086] #Sandbox Key

[0087] encrypt_to_sb(key_shards[1],sandbox_pubkey)

[0088] #Key Management Keys

[0089] encrypt_to_cp(key_shards[2],control_plane_pubkey)

[0090] #Memory combination key (lifetime = 300 seconds)

[0091] return combine_in_memory(key_shards,expiry=now+300)

[0092] Data Requests and Layered Encrypted Responses

[0093] The sandbox sends requests to the data source.

[0094] Signature request: Sign(Request||Env_ID,sandbox_PrivateKey);

[0095] Attach strategy token:

[0096] Token_Policy=ABE_Encrypt(policy_id,data_source_PubKey).

[0097] Data source response

[0098] Outer encryption: AES-GCM(Data, Session_Key)

[0099] Inner encryption: ABE_Encrypt(Inner_Data,policy_attributes:{Env_ID,"NO_RAW_COPY"})

[0100] Generate the Merkle root hash: Root_Hash = MerkleTree(Data).root, and sign it with Sign(Root_Hash, data_source_PrivateKey).

[0101] Safety handling inside the sandbox

[0102] Decryption within the sandbox: First, decrypt the outer layer using the Session_Key, and then decrypt the inner layer using the ABE private key (bound to Env_ID);

[0103] Data is processed in an isolated memory area, and persistent storage is prohibited.

[0104] Generate a zero-knowledge proof (Groth16 scheme), and submit the result hash and zkProof to the blockchain.

[0105] This implementation achieves hardware-level environment isolation. The inner-layer ABE encryption binds data decryption permissions to the sandbox environment fingerprint (Env_ID), ensuring that even if the key is leaked, decryption is impossible outside the original environment. A session-level key self-destruction mechanism stores key fragments in three locations: the KM node, the sandbox, and the data source. The complete key is only assembled in memory, and fragments automatically expire after timeout. Lightweight verifiable computational proofs utilize optimized zk-SNARKs circuitry, significantly reducing proof generation time compared to traditional methods. Auditors can verify computational compliance (e.g., failure to retain original data) without obtaining the plaintext.

[0106] Optionally, initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID, including:

[0107] Initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB;

[0108] The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

[0109] Optionally, based on a threshold signature scheme, a session key is negotiated and generated among multiple key management nodes, sandboxes, and data sources, including:

[0110] Select several key management nodes through the key management module;

[0111] A threshold signature scheme is used to generate multiple key fragments corresponding to a session;

[0112] The key fragments are encrypted using the data source public key, sandbox public key, and control plane public key, and then transmitted to the data source, sandbox, and key management node, respectively.

[0113] The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

[0114] Optionally, a data request is sent to the data source via a sandbox. The request is made by signing the data with the attached environment identifier Env_ID using the sandbox private key. After receiving the data request and verifying the signature, the data source encrypts the outer data using the session key and the inner data using an attribute-based encryption algorithm, generating a Merkle root hash of the response data, including:

[0115] Data requests are sent to the data source based on the sandbox. The data requests are signed with the sandbox private key and attached with a policy token Token_Policy, and request data with an attached environment identifier Env_ID.

[0116] After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and encrypts the inner data based on the attribute-based encryption algorithm bound to the policy attribute. The policy attribute includes at least the environment identifier Env_ID and the prohibit copying attribute.

[0117] The data source generates the Merkle root hash of the response data and signs the Merkle root hash using the data source's private key.

[0118] Optionally, the sandbox decrypts the outer data in memory based on the session key, decrypts and processes the inner data based on the attribute-based encryption private key, generates a zero-knowledge proof zkProof, and submits the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for notarization and auditing, including:

[0119] The outer data is decrypted in memory using the session key via a sandbox, and the inner data is decrypted using the attribute-based encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data.

[0120] The decrypted data is processed in an isolated memory area using a sandbox to obtain the processing results and prevent persistent data storage.

[0121] The sandbox generates a zero-knowledge proof zkProof based on the processing results, and submits the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0122] This enhances sandbox security by binding sandbox environment identifiers and signatures, effectively reducing the risk of cloning attacks. Session-level key lifecycle management further mitigates the risk of key reuse attacks. Data transmission security is also improved through multi-layered encryption, significantly reducing security risks associated with interactions between the sandbox and data sources within the data space. Finally, the efficiency of data proof in the data space is enhanced by employing the Groth16 scheme and optimizing zkProof generation efficiency.

[0123] According to another aspect of the present invention, a data space sandbox and data source secure interaction system 400 is also provided, with reference to... Figure 4 As shown, the system 400 includes:

[0124] The environment identifier generation module 410 is used to initialize and authenticate the sandbox environment and generate a unique environment identifier Env_ID.

[0125] The session key generation module 420 is used to negotiate and generate session keys between multiple key management nodes, sandboxes, and data sources based on a threshold signature scheme.

[0126] The root hash generation module 430 is used to send data requests to the data source through the sandbox, request data with the attached environment identifier Env_ID based on the sandbox private key signature. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data.

[0127] The zero-knowledge proof generation module 440 is used to decrypt outer data in memory based on the session key through a sandbox, decrypt inner data based on the attribute-based encryption private key and process it to generate a zero-knowledge proof zkProof, and submit the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0128] Optionally, an environment identification module is generated, including:

[0129] The environment identifier generation submodule is used to initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB;

[0130] The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

[0131] Optionally, the session key generation module includes:

[0132] The Key Management Node Selection submodule is used to select several key management nodes through the Key Management Module.

[0133] The key fragment generation submodule is used to generate multiple key fragments corresponding to a session using a threshold signature scheme.

[0134] The encryption key sharding submodule is used to encrypt key shards using the data source public key, sandbox public key, and control plane public key, and then transmit them to the data source, sandbox, and key management node, respectively.

[0135] The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

[0136] Optionally, the root hash module is generated, including:

[0137] The data request sending submodule is used to send data requests to the data source based on the sandbox. The data request is signed with the sandbox private key and attached with a policy token Token_Policy, and requests data with an attached environment identifier Env_ID.

[0138] The data encryption submodule is used to encrypt the outer layer data based on the session key and the inner layer data based on the attribute-based encryption algorithm bound to the policy attribute after the data source receives the data request and verifies the signature. The policy attribute includes at least the environment identifier Env_ID and the prohibition of copying attribute.

[0139] The Root Hash Generation Submodule is used to generate the Merkle root hash of the response data from the data source and to sign the Merkle root hash using the data source's private key.

[0140] Optionally, a zero-knowledge proof module is generated, including:

[0141] The decryption data acquisition submodule is used to decrypt the outer data in memory based on the session key through a sandbox, and decrypt the inner data based on the attribute base encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data;

[0142] The "Obtain Processing Result" submodule is used to process the decrypted data in an isolated memory area through a sandbox, obtain the processing result, and prohibit persistent storage of the data.

[0143] The zero-knowledge proof generation submodule is used to generate a zero-knowledge proof zkProof based on the processing results through a sandbox, and submit the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

[0144] The data space sandbox and data source secure interaction system 400 of one embodiment of the present invention corresponds to the data space sandbox and data source secure interaction method 100 of another embodiment of the present invention, and will not be described again here.

[0145] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code. The solutions in the embodiments of this application can be implemented in various computer languages, such as the object-oriented programming language Java and the interpreted scripting language JavaScript.

[0146] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0147] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0148] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0149] Although preferred embodiments of this application have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments as well as all changes and modifications falling within the scope of this application.

[0150] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

Claims

1. A method for secure interaction between a data space sandbox and a data source, characterized in that, include: Initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID; Based on the threshold signature scheme, session keys are negotiated and generated among multiple key management nodes, sandboxes, and data sources; The sandbox sends a data request to the data source, and the request requests the data with the attached environment identifier Env_ID based on the sandbox private key signature. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data. The outer data is decrypted in memory using the session key via a sandbox, and the inner data is decrypted and processed using the attribute-based encryption private key to generate a zero-knowledge proof zkProof. The Merkle root hash and the zero-knowledge proof zkProof are then submitted to the blockchain for storage and auditing.

2. The method according to claim 1, characterized in that, Initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID, including: Initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB; The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

3. The method according to claim 1, characterized in that, Based on a threshold signature scheme, session keys are negotiated and generated among multiple key management nodes, sandboxes, and data sources, including: Select several key management nodes through the key management module; A threshold signature scheme is used to generate multiple key fragments corresponding to a session; The key fragments are encrypted using the data source public key, sandbox public key, and control plane public key, and then transmitted to the data source, sandbox, and key management node, respectively. The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

4. The method according to claim 1, characterized in that, Data requests are sent to the data source via a sandbox. The request is signed using the sandbox's private key, and the data request includes an environment identifier (Env_ID). After receiving the data request and verifying the signature, the data source encrypts the outer data using the session key and the inner data using an attribute-based encryption algorithm, generating a Merkle root hash of the response data, including: Data requests are sent to the data source based on the sandbox. The data requests are signed with the sandbox private key and attached with a policy token Token_Policy, and request data with an attached environment identifier Env_ID. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and encrypts the inner data based on the attribute-based encryption algorithm bound to the policy attribute. The policy attribute includes at least the environment identifier Env_ID and the prohibit copying attribute. The data source generates the Merkle root hash of the response data and signs the Merkle root hash using the data source's private key.

5. The method according to claim 1, characterized in that, The sandbox decrypts outer data in memory based on the session key, decrypts inner data based on the attribute-based encryption private key, processes the data, and generates a zero-knowledge proof zkProof. The Merkle root hash and the zkProof are then submitted to the blockchain for notarization and auditing, including: The outer data is decrypted in memory using the session key via a sandbox, and the inner data is decrypted using the attribute-based encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data. The decrypted data is processed in an isolated memory area using a sandbox to obtain the processing results and prevent persistent data storage. The sandbox generates a zero-knowledge proof zkProof based on the processing results, and submits the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

6. A secure interaction system between a data space sandbox and a data source, characterized in that, include: The environment identifier generation module is used to initialize and authenticate the sandbox environment, generating a unique environment identifier Env_ID; The session key generation module is used to negotiate and generate session keys between multiple key management nodes, sandboxes, and data sources based on a threshold signature scheme. The root hash generation module is used to send data requests to the data source through the sandbox. It requests data with the attached environment identifier Env_ID based on the sandbox private key signature. After the data source receives the data request and verifies the signature, it encrypts the outer data based on the session key and the inner data based on the attribute base encryption algorithm to generate the Merkle root hash of the response data. A zero-knowledge proof generation module is used to decrypt outer data in memory based on the session key through a sandbox, decrypt inner data based on the attribute-based encryption private key and process it to generate a zero-knowledge proof zkProof. The Merkle root hash and the zero-knowledge proof zkProof are then submitted to the blockchain for notarization and auditing.

7. The system according to claim 6, characterized in that, The environment identification generation module includes: The environment identifier generation submodule is used to initialize and authenticate the sandbox environment, collect hardware fingerprint information, generate a unique environment identifier Env_ID based on the hardware fingerprint information, and register the environment identifier Env_ID with the control plane to obtain the sandbox digital certificate Cert_SB; The hardware fingerprint information includes CPU microcode hash + memory address randomization seed.

8. The system according to claim 6, characterized in that, The session key generation module includes: The Key Management Node Selection submodule is used to select several key management nodes through the Key Management Module. The key fragment generation submodule is used to generate multiple key fragments corresponding to a session using a threshold signature scheme. The encryption key sharding submodule is used to encrypt key shards using the data source public key, sandbox public key, and control plane public key, and then transmit them to the data source, sandbox, and key management node, respectively. The key fragments are combined in the sandbox memory to generate a session key with a preset validity period, and the complete key and fragments in the memory are destroyed after the validity period expires.

9. The system according to claim 6, characterized in that, The root hash generation module includes: The data request sending submodule is used to send data requests to the data source based on the sandbox. The data request is signed with the sandbox private key and attached with a policy token Token_Policy, and requests data with an attached environment identifier Env_ID. The data encryption submodule is used to encrypt the outer layer data based on the session key and the inner layer data based on the attribute-based encryption algorithm bound to the policy attribute after the data source receives the data request and verifies the signature. The policy attribute includes at least the environment identifier Env_ID and the prohibition of copying attribute. The Root Hash Generation Submodule is used to generate the Merkle root hash of the response data from the data source and to sign the Merkle root hash using the data source's private key.

10. The system according to claim 6, characterized in that, The module for generating zero-knowledge proofs includes: The decryption data acquisition submodule is used to decrypt the outer data in memory based on the session key through a sandbox, and decrypt the inner data based on the attribute base encryption private key bound to the environment identifier Env_ID, to obtain the decrypted data; The "Obtain Processing Result" submodule is used to process the decrypted data in an isolated memory area through a sandbox, obtain the processing result, and prohibit persistent storage of the data. The zero-knowledge proof generation submodule is used to generate a zero-knowledge proof zkProof based on the processing results through a sandbox, and submit the Merkle root hash and the zero-knowledge proof zkProof to the blockchain for storage and auditing.

Images