Method and system for hop-by-hop secret computation execution based on behavior commitment graph

Abstract

The application discloses a hop-by-hop secret release confidential computing execution method and system based on a behavior commitment graph, and relates to the technical field of trusted data space. The method comprises the following steps: joint compiling target code, a policy and a task seed to generate a restricted intermediate representation, constructing a normalized behavior commitment graph and generating a unique graph root; in each state transition step of task execution, a trusted execution environment generates a state proof according to a current node identifier; after an external authorized party verifies that the state proof and a target edge conform to a legal migration path, the external authorized party derives a micro-capability used only for this migration; the trusted execution environment executes resource access by using the micro-capability and updates an execution chain root; when advancing to a terminal output node, a result conforming to a constraint is output, and a final execution credential is generated. The application aims to sink the authorized granularity to the path level, avoid total decryption capability leakage, and realize fine-grained security boundary control on the whole execution process.

Description

Technical Field

[0001] This invention relates to the field of trusted data space technology, and in particular to a method and system for executing hop-by-hop decryption confidential computation based on behavioral commitment graphs. Background Technology

[0002] In scenarios such as data element circulation, privacy analysis, joint modeling, and medical statistics, the code provider typically provides the algorithm program, the data provider provides encrypted data, and a trusted execution environment (HEA) serves as the execution carrier. Existing confidential computing schemes mainly rely on remote authentication mechanisms, releasing data decryption capabilities or task-level session keys to the HEA only after an external system verifies the trustworthiness of the execution environment. However, the authorization object of such schemes is essentially the execution entity rather than a specific legitimate execution path. When factors such as target code, task context, policy semantics, and multi-round call budgets need to participate in authorization, existing technologies struggle to form a fine-grained and continuously effective control mechanism.

[0003] Existing technologies have the following drawbacks: First, key release typically only binds to the execution environment identity, failing to precisely bind to the code version, task instance, and specific execution path. Second, data access policies and output constraints often exist as independent text or configuration files, making it difficult to reliably map them to execution control inputs, thus increasing the risk of policy bypass. Third, output control is mostly filtered after execution, failing to block high-risk outputs during the authorization phase through path reachability checks. Furthermore, in scenarios with multi-task concurrency or partial compromise of the execution environment, one-time key release mechanisms can easily lead to risks such as cross-task capability reuse, rollback of older versions, and cumulative leakage of sensitive information.

[0004] Therefore, how to achieve fine-grained control over the execution process at the path level has become a pressing technical challenge. Summary of the Invention

[0005] The main objective of this invention is to provide a method and system for executing hop-by-hop decryption confidential computation based on behavioral commitment graphs, aiming to achieve fine-grained path-level control over the execution process.

[0006] To achieve the above objectives, this invention proposes a hop-by-hop decryption confidentiality computation execution method based on behavioral commitment graphs, comprising the following steps:

[0007] Include the target code, preset strategies, and task seeds. A restricted intermediate representation is generated through joint compilation, and a normalized behavioral commitment graph is constructed based on the restricted intermediate representation. Regarding the above After normalization, a unique root is generated. ;

[0008] Each state transition step in task execution In China, Trusted Execution Environment Based on the current situation Node identifier Generate state proof ,in, ,in Signing functions for trusted execution environments, Given the current budget status, For step counter, Execute the root of the chain for the previous hop;

[0009] External licensor verification The target edge identifier of the request Conforms to the above After establishing a legitimate migration path, derive micro-capabilities that are only used for this migration. ,in, ,in Derived function for key. For the authorization master key, This marks the execution epoch of the current task.

[0010] The Using the Execute the resource access and state advancement actions corresponding to the target edge, and update the execution chain root. ;

[0011] When the state progresses to a predefined terminal output node, a result that conforms to the constraints of the terminal output node is output, and a graph root is generated based on the entire state transition chain. and the task seed The final execution certificate.

[0012] Preferably, the behavioral commitment graph It includes at least a set of nodes, a set of edges, and graph-level constraints; wherein the set of nodes contains multiple nodes for representing the execution state, and the nodes are at least classified into the following types: data reading nodes, calculation nodes, conditional branch nodes, loop nodes, intermediate state nodes, exception nodes, and terminal output nodes.

[0013] Preferably, the normalization process includes: normalizing the... The graph structure is normalized in terms of node numbering, edge order, condition expression, budget rule, and terminal output category.

[0014] Preferably, the execution process also involves resource reference objects, which at least include: a first resource reference object for identifying the data blocks that the target edge is allowed to access. A second resource reference object used to identify the code block that is allowed to be executed by the target edge. and a third resource reference object for identifying intermediate state fragments that are allowed to be accessed by the target edge. .

[0015] Preferably, the use of the Execute the resource access and state advancement actions corresponding to the target edge, including at least one of the following restricted actions:

[0016] According to the first resource reference object Unblock the data fragment within the corresponding resource scope;

[0017] Activate the restricted operator corresponding to the preset operator category;

[0018] Through the third resource reference object Read the intermediate state content;

[0019] Proceed to the next node. .

[0020] Preferably, the output result corresponding to the terminal output node belongs to at least one of the following output categories: aggregated output, low-precision output, interval output, summary output, rejection output, and abnormal summary output.

[0021] Preferably, the update execution chain root The following iterative formula is used:

[0022]

[0023] in, For input references, For outputting references, This is an identifier for abnormal path triggering. This is the timestamp for this migration step.

[0024] Preferably, the final execution certificate It has the following structured fields:

[0025]

[0026] in, Bind the input object corresponding to this execution. Identify the final terminal node, A commitment summary of the identifier output result. Indicate the final budget consumption status. For digital signatures.

[0027] Preferably, the include , , and ;in, This indicates the number of steps that have been executed.

[0028] Preferably, if the current node is determined to be an abnormal node, a budget-exhausted node, or a prohibited node, then the... Block the release of normal results and force the output of a predefined exception summary flag or rejection flag.

[0029] This application also discloses a hop-by-hop decryption confidential computation execution system based on behavioral commitment graphs, including:

[0030] Build modules are used to combine target code, preset strategies, and task seeds. A restricted intermediate representation is generated through joint compilation, and a normalized behavioral commitment graph is constructed based on the restricted intermediate representation. Regarding the above After normalization, a unique root is generated. ;

[0031] The proof generation module is used to enable a trusted execution environment at each state transition step of task execution. Based on the current situation Node generates state proof ;

[0032] The authorization module is used to verify the... With the requested target edge Conforms to the above After establishing a legitimate migration path, derive micro-capabilities that are only used for this migration. ;

[0033] Execution module, used to enable the Using the Execute the resource access and state advancement actions corresponding to the target edge, and update the execution chain root. ;

[0034] The credential output module is used to output a result that conforms to the constraints of the predefined terminal output node when the state progresses to the predefined terminal output node, and to generate a binding graph root based on the entire state transition chain. and the task seed The final execution certificate.

[0035] The above technical solution has the following advantages:

[0036] This invention achieves fine-grained path-level control over the execution process by compiling target code, access policies, and budget rules into a standardized behavioral commitment graph. The basic authorization unit is then transformed from the execution environment entity into a legitimate state transition edge within the graph. Employing a hop-by-hop decryption mechanism, only single-use micro-capabilities are derived in each state transition step, avoiding the exposure of the generalizable total decryption key to the trusted execution environment and significantly reducing the risk of reuse after capability leakage. By forwarding the output boundary as a reachability constraint of the behavioral commitment graph, illegal sensitive data output can be blocked at the source. Simultaneously, the chained execution credentials generated throughout the process cryptographically bind the input object, execution path, and final output, providing tamper-proof evidence for post-event auditing and accountability. Attached Figure Description

[0037] The present invention will now be described in detail with reference to specific embodiments and accompanying drawings, wherein:

[0038] Figure 1 This is a flowchart illustrating the hop-by-hop decryption confidentiality computation execution method based on behavioral commitment graphs provided in an embodiment of the present invention.

[0039] Figure 2 This is a schematic diagram of the structure of a hop-by-hop decryption confidentiality computation execution system based on a behavioral commitment graph, provided in an embodiment of the present invention. Detailed Implementation

[0040] The present invention will be further described below with reference to the accompanying drawings and specific embodiments.

[0041] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. In the following detailed description, numerous specific details are set forth to provide a comprehensive understanding of the embodiments of the invention. It should be understood that various features in the embodiments of the invention can be combined with each other without conflict to produce embodiments not explicitly shown or described. Furthermore, various changes can be made to the invention without departing from its spirit and scope. Those skilled in the art will understand that the steps in this embodiment can be performed in different orders or simultaneously.

[0042] Example 1

[0043] like Figures 1 to 2 As shown, this embodiment provides a hop-by-hop declassification confidential computation execution method based on a behavior commitment graph. This method aims to reduce the authorization granularity of confidential computation from the environment level to the path level. By unifying and solidifying factors such as code semantics, access policies, and output constraints into a behavior commitment graph, it achieves fine-grained control over the execution process.

[0044] During the system initialization phase, the construction process of the behavior commitment graph is executed first. Specifically, the construction module receives the target code submitted by the code provider and related preset strategies. The preset strategies include code execution strategies, i.e. Data access strategy, i.e. Output constraint strategy, i.e. And budget rules The build module compiles the target code into a restricted intermediate representation, from which executable operators, data dependencies, conditional branches, loop structures, exception paths, and output points are extracted. Subsequently, the build module jointly compiles the restricted intermediate representation with the aforementioned strategies to generate a standardized behavioral commitment graph. .

[0045] The Behavioral Commitment Diagram The graph is a directed graph structure, comprising at least a set of nodes, a set of edges, and graph-level constraints. Nodes represent permitted execution states and include types such as data read nodes, computation nodes, conditional branch nodes, loop nodes, intermediate state nodes, exception nodes, and terminal output nodes. Each node contains a node identifier. Node type Data range constraints Operator category constraints Budget status and output category .in, Used to limit the range of data that the current node is allowed to access. Used to limit the types of operators that the current node is allowed to execute. This is used to directly embed budget consumption information into the state transitions of the graph. Edges represent permitted state transitions; each edge corresponds to a permitted action and includes an edge identifier. Source node identifier Target node identifier Resource Scope and ability categories .

[0046] To ensure the uniqueness and immutability of the behavioral commitment diagram in terms of legal logic and technical implementation, the construction module... Normalization is performed. Specifically, the normalization process includes: […]. The graph structure is normalized in terms of node numbering, edge order, condition expression, budget rule, and terminal output category. After processing, a unique graph root is generated using a hash function. Satisfying the formula ,in The function represents the normalization operation. This graph root serves as the sole root trust credential for all subsequent authorization and execution processes.

[0047] Upon entering the task initiation phase, the state transition authorization module generates a task seed for this task. Execution Era Initial step counter and initial budget status .in, Used to distinguish different task instances Used to identify the current security version or reverted epoch. Trusted Execution Environment (TEE) is... Loading and The corresponding executor is generated, and remote proof evidence is produced to demonstrate that the current execution environment is not only hardware-trusted, but also indeed loaded with the [relevant / compatible] [device / system]. The semantically consistent code logic has entered the correct initial node.

[0048] Each state transition step in task execution In the middle, the jump-by-jump decryption execution module does not send to Release the master decryption key at the task level. At this point... According to the current situation Node identifier Generate state proof The formula for calculating this state proof is as follows: .in, For the private key signing function within the trusted execution environment, This is the root of the execution chain up to the point after the previous hop. This indicates the current node in the graph; Indicates the current budget status; Indicates the number of steps that have been executed; This indicates the execution chain root up to the previous step.

[0049] External licensors received and the target edge identifier requested Then, verify whether it conforms to Defined valid migration path. Upon successful verification, the licensor derives micro-capabilities solely for this migration. This micro-capability uses a key derivation function, i.e. The calculation is obtained, and the formula is: .in, This is the authorized master key.

[0050] Utilize the acquired micro-capabilities Perform the resource access and state advancement actions corresponding to the target edge. This execution involves resource reference objects, including a first resource reference object used to identify the data blocks that are allowed access. A second resource reference object used to identify the code block that is allowed to be executed. and a third resource reference object used to identify the intermediate state fragments that are allowed to be accessed. Specific restricted actions include: according to Unblock data fragments within the corresponding resource scope; activate restricted operators corresponding to preset operator categories; through Reading intermediate state content; and advancing the execution state to the next node. .

[0051] After execution, the system updates the execution chain root. It uses the following iterative formula for calculation: .in, This step outputs a reference. This is an identifier for abnormal path triggering. This is the Arabic numeral format timestamp for this migration step.

[0052] When the state progresses to a predefined terminal output node, the terminal output and chained credential module is responsible for releasing the final result. The system only outputs a valid execution result if the current state meets the constraints of a valid terminal node. The output categories include aggregated output, specified precision output, interval-based output, summary output, rejection output, or abnormal summary output. If the current node is determined to be entering an abnormal node, a budget-exhausted node, or a prohibited node, then... Forcefully block the release of normal results and only output predefined exception flags.

[0053] When the task is completed, the system generates a binding graph root based on the state transition chain of the entire process. and task seeds Final execution certificate This voucher has the following structured fields: .in, Bind the input object corresponding to this execution. Identify the final terminal node, A commitment summary of the identifier output result. A summary indicating the final budget consumption status. for or the digital signature of the relevant entity.

[0054] Through the aforementioned hop-by-hop authorization and execution mechanism, this embodiment achieves the transformation of the authorization unit from an entity into a legitimate migration path. Since each release only releases a micro-capability for a single state advancement, even... With the environment partially compromised, attackers are unable to obtain the total decryption capability that can be reused across tasks and paths. Simultaneously, the output boundary is pre-defined as a graph reachability constraint, limiting the risk of sensitive data leakage through intermediate results or anomalous information from the source, providing more granular and secure boundary control for data element flow.

[0055] Example 2

[0056] Based on Example 1, this example focuses on the behavioral commitment graph, i.e. This document details the internal composition and standardized construction process of the solution. Because existing confidential computing schemes often separate code semantics from access policies, authorization determination becomes disconnected from the actual execution process, easily leading to policy bypass risks. This embodiment constructs a structured and standardized behavior commitment graph, deeply coupling execution logic with constraints.

[0057] The Behavioral Commitment Diagram The set of nodes constitutes the complete legal state space for task execution. Nodes in the set are categorized into several specific types based on their logical functions, including: data reading nodes for loading and reading input data, computation nodes for executing specific algorithm logic, conditional branch nodes for handling logical branching, loop nodes for handling repetitive actions, intermediate state nodes for storing interim computation results, exception nodes for handling illegal or unexpected situations, and terminal output nodes as the execution endpoint. Each node contains data range constraints that identify the data range that the current node is allowed to access. Operator category constraints are used to limit the types of operators that the current node is allowed to execute. Output category constraints are used to identify the output categories that can be reached from the current state. And the budget state that directly solidifies budget constraints, i.e. This design ensures The resources that can be accessed in each hop state are strictly limited to the scope defined by the node.

[0058] To eliminate the strategy bypass problem caused by semantic equivalence but different expressions, the construction module performs strict normalization processing on the behavior commitment graph. This normalization processing includes: node number normalization (standardizing and rearranging node numbers), edge order normalization (fixing the logical order of sibling edges), standardization of logical judgment conditions into conditional expressions with a unified paradigm, normalization of complex budget consumption logic into budget rules with a unified incremental step size, and terminal output category normalization (aligning the output result format). The resulting graph root after normalization processing... It can uniquely represent a piece of code and its accompanying complete policy semantics, achieving a consistent binding between code and policy.

[0059] Example 3

[0060] This embodiment further illustrates how to achieve fine-grained resource isolation through resource reference objects during the hop-by-hop decryption process. During execution, the system introduces multiple types of resource reference objects to identify the specific content that the target edge is allowed to access.

[0061] Specifically, the resource reference object includes the first resource reference object. Second resource reference object and third-party resource reference objects .in, Encrypted data blocks used to precisely point to the target edge that is allowed access. Points to the restricted operator or code snippet that is allowed to be loaded. This is used to reference intermediate state fragments in protected memory space. When Obtain the target edge Derived micro-capabilities Then, the execution module allows it to reference the object based on the first resource. Unblock the data fragment under the corresponding resource scope, or activate the restricted operator corresponding to the preset operator category, or reference the object through the third resource. Read the intermediate state content.

[0062] This resource-reference-based restricted action pattern makes At any given time, only the minimum authorization required for the current migration edge can be obtained. Compared to the traditional method of releasing task-level session keys all at once, this scheme fundamentally avoids... It provides total decryption capabilities that can be reused across tasks or paths, ensuring that even if a single point of failure occurs in the execution environment, attackers cannot access any resources outside the path definition through the acquired micro-capabilities.

[0063] Example 4

[0064] This embodiment details the chain-like evidence storage throughout the execution process and the mechanism for generating the final execution credential. To ensure the traceability and immutability of the execution process, the system updates the execution chain root after each migration step. .

[0065] The execution chain root The update logic uses a hash chain structure, and the specific iteration formula is as follows:

[0066]

[0067] in, It records whether the current step triggered an abnormal branch. It is a precise timestamp based on Arabic numerals. By pushing key elements such as input references, output references, starting nodes, target edges, ending nodes, and exception flags into the hash chain hop by hop, the system constructs a complete execution fingerprint.

[0068] When the state progresses to a valid terminal output node, the system generates the final execution credential. This certificate has rigorously structured fields, including: a unique root. , task seed , Bind the initial input commitment of the input object for this execution The final node identifier that marks the final pause node. The final output commitment of the identifier result summary 1. Identify the final execution chain root of the entire state transition chain. Budget summary recording the final budget status and the current era With digital signatures This certificate provides legally valid cryptographic evidence for post-event auditing, dispute resolution, and accountability.

[0069] Example 5

[0070] This embodiment illustrates how the present invention leverages hardware security features to further enhance the credibility of state proofs. During execution, after each state progression step, the TEE generates a proof of the current state. . .in, This indicates the current node in the graph; Indicates the current budget status; Indicates the number of steps that have been executed; This indicates the execution chain root up to the previous step. Additionally, if the current execution node is determined to be an abnormal node, a budget-exhausted node, or a node explicitly prohibited by a policy, then... The internal logic will forcibly block any normal result release path and instead output a predefined rejection flag or anomaly summary identifier, thereby ensuring that the output boundary control is an endogenous constraint based on graph path reachability.

[0071] Example 6

[0072] This embodiment provides a detailed description of the hop-by-hop decryption confidential computation execution system based on behavioral commitment graphs that implements the above method. The system is logically divided into five core functional modules: a construction module, a proof generation module, an authorization module, an execution module, and a credential output module.

[0073] The building module receives the target code and a preset strategy, compiles them into a restricted intermediate representation, and constructs a normalized behavior commitment graph. After normalization, a unique root is generated. The proof generation module is deployed on Within the environment, it is responsible for generating state proofs at each state transition step based on the current node position, task seed, and execution chain root. The authorization module acts as an independent trust anchor point, used to verify whether the state proof is compliant. Define a valid migration path and derive the micro-capabilities required for the current migration step after successful verification. Execution module driver The micro-capabilities are used to complete resource unsealing, operator activation, and state progression, and to update the execution chain root. The credential output module, upon reaching the terminal node, outputs the constrained results and summarizes all process information to generate the final execution credential. The modules collaborate through predefined interfaces, forming a secure computation loop with continuous authorization and hop-by-hop decryption.

[0074] like Figure 2 As shown, the system includes a construction module, a proof generation module, an authorization module, an execution module, and a credential output module. The proof generation module, execution module, and credential output module are preferably deployed within a Trusted Execution Environment (TEE) of the computing device; the authorization module is preferably deployed in an external authorizing device; the construction module can be deployed in the computing device, the external authorizing device, or an independent construction device. For illustrative simplicity, these are uniformly represented in the system logical structure in this embodiment. Figure 2 This is a logical structure diagram, and the physical deployment method of each module is not restricted. The aforementioned state transition authorization module, hop-by-hop decryption execution module, and terminal output and chained credential module can be respectively referred to as: Figure 2 The authorization module, execution module, and credential output module are included.

[0075] Example 7

[0076] This embodiment provides chain-based evidence storage for the entire execution process and the execution chain root. The update logic will be explained in detail. To ensure the immutability and sequential consistency of the execution path, the system updates the execution chain root after each state transition.

[0077] Specifically, after completing the restricted actions defined in this migration step, the execution module will generate a migration record based on the current state, target edge, migration result, and environmental parameters. Subsequently, the system uses the following hash iteration formula to calculate the new execution chain root:

[0078]

[0079] In this formula, This identifies the input data block referenced in this migration step, namely the first resource reference object. This identifies the output references generated in this migration step, such as intermediate results or terminal output snippets. Used to identify whether this migration step triggered an abnormal path or predefined error handling logic. The system records the Arabic numeral timestamps of the migration steps that occurred, which are used to reconstruct the timing of the execution during the audit process.

[0080] Through this chain-binding mechanism, the proof of each execution hop depends on the root of the execution chain of the previous hop, thus constructing a complete and unforgeable chain of execution evidence. External verifiers can reconstruct this hash chain to verify whether the execution nodes strictly follow the behavioral commitment graph. Operate through the prescribed legal path.

[0081] Example 8

[0082] This embodiment details the final execution certificate after the task is completed, i.e. The generation and structure of the final execution credentials are crucial for assessing whether confidential computing tasks comply with pre-defined policies and whether data access is compliant.

[0083] When the state progresses to the predefined terminal output node, the credential output module will generate a binding graph root based on the state transition chain of the entire process. With the mission seed The final execution certificate. The final execution certificate has the following structured fields:

[0084]

[0085] in, Used to bind the original input object corresponding to this execution, ensuring the consistency of input data. This field clearly identifies the final endpoint of the execution. Since the endpoint type directly maps to the output category, this field reflects whether the output conforms to the specified criteria. . A commitment digest identifying the output result is used to prevent the output result from being tampered with during transmission. This is the root of the execution chain generated in the final step, which covers the migration facts of the entire path. It indicates the final budget consumption status and is used to calculate the quota consumption of computing resources or data access limits. The field identifies the execution epoch to which the current task belongs, and is used to handle version update or undo logic. A digital signature is generated jointly by a trusted execution environment, a hardware platform, or a consortium of signatories.

[0086] Example 9

[0087] This embodiment illustrates how the present invention enhances the anti-replay and anti-rollback capabilities of state proofs by combining hardware security features. In complex confidential computing scenarios, a malicious host may attempt to obtain expired micro-capabilities by replaying old state proofs.

[0088] To address the aforementioned issues, in generating state proofs Previously, Trusted Execution Environment (TEE) It is necessary to read the monotonic counter of its hardware platform. Then, The current execution environment metric evidence is solidified with the value of the monotonic counter to generate a metric summary and embed it into the [database name missing]. In this process, each state proof is unique and bound to the hardware clock logic. When verifying the proof, the authorization module checks the continuity of the monotonic counter; if the counter value is not increasing or does not match expectations, it rejects the derivation of the micro-capability.

[0089] Example 10

[0090] This embodiment details the blocking logic for abnormal nodes and budget exhaustion scenarios. In this invention, output boundary control is no longer a simple post-execution filtering, but an intrinsic constraint deeply integrated into the state transition path.

[0091] If, during execution, the current node is determined to be an abnormal node, a budget-exhausted node, or a prohibited node, then The system will forcibly block the release of normal results based on the limitations of the micro-capabilities. Specifically, in this case, the system will be unable to derive micro-capabilities pointing to normal output operations, or the already derived micro-capabilities will become invalid because they do not conform to the current abnormal state. In this situation, Only predefined exception summary identifiers or rejection flags are allowed to be output, and an exception path trigger identifier is generated. The execution credentials. This mechanism, through path reachability, limits the risk of malicious code smuggling sensitive information through exception information or intermediate states from the source.

[0092] Example 11

[0093] This embodiment uses financial risk control inference as an application scenario to illustrate the specific application of the present invention in multi-party collaborative computing. In this scenario, the bank, as the data provider, provides encrypted customer credit data, and the fintech company, as the code provider, provides the scoring model algorithm.

[0094] Both parties first jointly compiled and generated a behavioral commitment graph by combining the scoring algorithm with credit data access strategies, result accuracy requirements, and single query budget. Within the execution node, for each credit data field read by the model, it must apply to the authorizing party for specific... The ability to unblock. Only when the access order of credit fields, operator category, and current budget status all meet the requirements. Only when the defined path is reached can the fintech company's model algorithm obtain the decryption results for the corresponding fields. After the calculation is completed, the bank can only receive the final risk control score that meets the aggregation requirements when the model enters the preset aggregation output node. The system will also automatically generate a final execution certificate that binds the credit data fingerprint and the entire model execution process, serving as the original evidence for compliance auditing.

[0095] Example 12

[0096] This embodiment uses medical research statistics as an application scenario to illustrate the role of this invention in data element circulation. The hospital acts as the data provider, and the research institution as the code provider. Privacy-preserving computations are performed within it.

[0097] To prevent research models from inferring individual information through multiple queries, hospitals... Strict budget rules were set up in the middle. With the terminal output type When the computational logic of the research model attempts to access patient records beyond a predetermined range, the execution flow will automatically redirect to a budget exhaustion node and cease execution due to the inability to obtain the micro-capability for the next hop migration. The final output is forcibly constrained to either range-based output or summary output; that is, the output is limited to a precision error within 10% or released in de-identified summary form. The final execution certificate obtained by the research institution proves that the statistics were indeed completed through a legitimate statistical path without touching the original ID, thus meeting data security regulatory requirements.

[0098] The solutions provided in the embodiments of the present invention are not limited to the technical solutions described in the above embodiments. Those skilled in the art should understand that various changes and modifications can be made to the above embodiments without departing from the spirit and scope of the present invention. These changes and modifications should fall within the protection scope of the claims of the present invention. The specific embodiments described above further illustrate the purpose, technical solutions, and beneficial effects of the present invention. It should be understood that the above descriptions are merely specific embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs, characterized in that, Includes the following steps: Include the target code, preset strategies, and task seeds. A restricted intermediate representation is generated through joint compilation, and a normalized behavioral commitment graph is constructed based on the restricted intermediate representation. Regarding the above After normalization, a unique root is generated. ; Each state transition step in task execution In China, Trusted Execution Environment Based on the current situation Node identifier Generate state proof ,in, ,in Sign functions for trusted execution environments. Given the current budget status, For step counter, Execute the root of the chain for the previous hop; External licensor verification The target edge identifier of the request Conforms to the above After establishing a legitimate migration path, derive micro-capabilities that are only used for this migration. ,in, ,in Derived function for key. For the authorization master key, This marks the execution epoch of the current task. The Using the Execute the resource access and state advancement actions corresponding to the target edge, and update the execution chain root. ; When the state progresses to a predefined terminal output node, a result that conforms to the constraints of the terminal output node is output, and a graph root is generated based on the entire state transition chain. and the task seed The final execution certificate.

2. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The Behavioral Commitment Diagram It includes at least a set of nodes, a set of edges, and graph-level constraints; wherein the set of nodes contains multiple nodes for representing the execution state, and the nodes are at least classified into the following types: data reading nodes, calculation nodes, conditional branch nodes, loop nodes, intermediate state nodes, exception nodes, and terminal output nodes.

3. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The normalization process includes: [processing the normalization process] The graph structure is normalized in terms of node numbering, edge order, condition expression, budget rule, and terminal output category.

4. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The execution process also involves resource reference objects, which at least include: a first resource reference object used to identify the data blocks that the target edge is allowed to access. A second resource reference object used to identify the code block that is allowed to be executed by the target edge. and a third resource reference object for identifying intermediate state fragments that are allowed to be accessed by the target edge. .

5. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 4, characterized in that, The use of the Execute the resource access and state advancement actions corresponding to the target edge, including at least one of the following restricted actions: According to the first resource reference object Unblock the data segment within the corresponding resource scope; Activate the restricted operator corresponding to the preset operator category; Through the third resource reference object Read the intermediate state content; Proceed to the next node. .

6. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The output results corresponding to the terminal output node belong to at least one of the following output categories: aggregated output, low-precision output, interval output, summary output, rejection output, and abnormal summary output.

7. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The update execution chain root The following iterative formula is used: in, For input references, To output a reference, This is an identifier for abnormal path triggering. This is the timestamp for this migration step.

8. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The final execution certificate It has the following structured fields: in, Bind the input object corresponding to this execution. Identify the final terminal node, A commitment summary of the identifier output result. Indicate the final budget consumption status. For digital signatures.

9. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, The include , , and ;in, This indicates the number of steps that have been executed.

10. The hop-by-hop decryption confidential computation execution method based on behavioral commitment graphs according to claim 1, characterized in that, If the current node is determined to be an abnormal node, a budget-exhausted node, or a prohibited node, then the following... Block the release of normal results and force the output of a predefined exception summary flag or rejection flag.

11. A hop-by-hop decryption confidential computation execution system based on behavioral commitment graphs, characterized in that, include: Build modules are used to combine target code, preset strategies, and task seeds. A restricted intermediate representation is generated through joint compilation, and a normalized behavioral commitment graph is constructed based on the restricted intermediate representation. Regarding the above After normalization, a unique root is generated. ; The proof generation module is used to enable a trusted execution environment at each state transition step of task execution. Based on the current situation Node generates state proof ; The authorization module is used to verify the... With the requested target edge Conforms to the above After establishing a legitimate migration path, derive micro-capabilities that are only used for this migration. ; Execution module, used to enable the Using the Execute the resource access and state advancement actions corresponding to the target edge, and update the execution chain root. ; The credential output module is used to output a result that conforms to the constraints of the predefined terminal output node when the state progresses to the predefined terminal output node, and to generate a binding graph root based on the entire state transition chain. and the task seed The final execution certificate.

Images