Data security sharing and authorized access control method and system based on privacy computing

Abstract

The invention discloses a data security sharing and authorized access control method and system based on privacy computing, and belongs to the technical field of computer data processing, and the method comprises the steps: obtaining a data sharing request and an authorized access strategy of each data provider, and carrying out the causal strategy mapping processing; and performing causal constraint segmentation processing in combination with local data of each data provider, performing causal privacy calculation with the causal privacy initialization vector and attribute information of the access requester, generating a causal authorization sharing calculation result, performing causal chain verification processing, generating a dynamic evolution access credential to verify the attribute information of the access requester, and sending the dynamic evolution access credential to the data provider. And generating an authorization access token to perform causal unlocking access on the result of the causal authorization sharing calculation, and generating authorization sharing data. By adopting a mode of combining causal policy mapping and multi-party privacy calculation, traceable and auditing dynamic authorization access control in a full life cycle of data can be realized, and high security and policy consistency in a data sharing process are ensured.

Description

Technical Field

[0001] This invention relates to the field of computer data processing technology, and in particular to a method and system for secure data sharing and authorized access control based on privacy computing. Background Technology

[0002] In the digital information age, electronic data processing technology, as a core driving force for social operation, has permeated all sectors. The value of data lies in its flow and integration; secure data sharing across institutions and fields is key to unleashing the potential of data elements and driving technological innovation and business development. However, while data brings enormous convenience to society, it also carries a large amount of personal privacy and trade secrets. How to achieve efficient and controllable data collaboration and value exchange while ensuring data security and privacy rights has become a core issue of ongoing concern in the field of data processing.

[0003] In existing technologies, data sharing typically employs various data processing and access control schemes. For example, a centralized data lake or data warehouse is built, where a data control center manages the aggregated data and assigns permissions based on access control lists or role-based access control models. Another common approach is to provide data services through application programming interfaces (APIs), where users obtain the required data using authentication tokens. In distributed scenarios, techniques such as federated learning are also used for joint modeling without directly sharing raw data, achieving collaboration by exchanging model parameters or intermediate gradients.

[0004] However, centralized data storage architectures face significant risks of single points of failure and attacks. A breach of the central node can lead to catastrophic data leaks, and their static access control systems struggle to handle complex and dynamically changing sharing needs. Application programming interface (API)-based sharing methods often directly expose the processed raw data. Even after anonymization, there is a risk of reverse engineering or re-identification through association with other data, and authorization tokens typically lack traceability proof of the entire data processing process. Federated learning and similar technologies are primarily suited for specific machine learning tasks, offering insufficient support for general data querying and complex computational scenarios, and their security also faces challenges such as model reverse engineering attacks. Summary of the Invention

[0005] To address the aforementioned issues, this invention provides a data security sharing and authorized access control method and system based on privacy computing. By combining causal policy mapping with multi-party privacy computing, it can achieve traceable and auditable dynamic authorized access control throughout the entire data lifecycle, ensuring high security and policy consistency during the data sharing process.

[0006] The above objectives can be achieved through the following approach: A data security sharing and authorized access control method based on privacy computing includes: acquiring data sharing requests and authorized access policies of each data provider; obtaining sharing request information and performing causal policy mapping processing to generate a causal privacy initialization vector; performing causal constraint segmentation processing on the local data of each data provider in conjunction with the causal privacy initialization vector to generate causal protected data fragments; performing causal privacy computing on the causal protected data fragments, the causal privacy initialization vector, and the attribute information of the access requester to generate a causal authorized sharing computing result; performing causal chain verification processing based on the causal authorized sharing computing result to generate a dynamically evolving access credential; verifying the attribute information of the access requester based on the dynamically evolving access credential to generate an authorized access token; and using the authorized access token to perform causal unlocking access on the causal authorized sharing computing result to generate authorized shared data.

[0007] Based on the same inventive concept, this invention also provides a data security sharing and authorized access control system based on privacy computing. The system includes: a causal privacy initialization module, used to acquire data sharing requests and authorized access policies of each data provider, obtain sharing request information, perform causal policy mapping processing, and generate a causal privacy initialization vector; a causal protection segmentation module, used to perform causal constraint segmentation processing on the local data of each data provider in conjunction with the causal initialization vector, generating causal protection data fragments; a causal privacy computing execution module, used to perform causal privacy computing on the causal protection data fragments, the causal privacy initialization vector, and the attribute information of the access requester, generating a causal authorized sharing computing result; a dynamic credential generation module, used to perform causal chain verification processing based on the causal authorized sharing computing result, generating a dynamically evolving access credential; an authorization verification module, used to verify the attribute information of the access requester based on the dynamically evolving access credential, generating an authorized access token; and a causal unlocking access module, used to use the authorized access token to perform causal unlocking access on the causal authorized sharing computing result, generating authorized sharing data.

[0008] Compared with the prior art, the present invention has the following advantages: This invention achieves precise and dynamic execution of access policies through a causal association mechanism, ensuring that every step of data processing is consistent with the initial authorization intent and causal logic. This enables authorization decisions to deeply understand and adapt to complex data sharing scenarios, improving the accuracy of policy execution and context awareness.

[0009] This invention segments the original data into causal protection data fragments and generates intermediate evolutionary shares in a multi-party secure computing environment. The resulting dynamic evolutionary access credentials cryptographically bind the initial strategy, computation process, and final result together, thereby ensuring the security and compliance of the entire data sharing lifecycle.

[0010] This invention meets the needs of data collaboration without exposing any original sensitive data, cuts off the leakage path of original data, and minimizes the risk of privacy leakage while maximizing the value of data application.

[0011] This invention enables the system to quantify the deviation between the actual effect of policy execution and the initial expectation by conducting in-depth audits of the actual usage records of authorized access tokens. Based on this, the system can automatically adjust the policy constraint parameters, allowing the data sharing policy to continuously evolve based on real-world interactive feedback, gradually improving the intelligence level of authorization decisions, and building a more robust and efficient data governance ecosystem. Attached Figure Description

[0012] Figure 1 This is a flowchart illustrating the data security sharing and authorized access control method based on privacy computing according to an embodiment of the present invention.

[0013] Figure 2 This is a schematic diagram of the data security sharing and authorized access control system based on privacy computing according to an embodiment of the present invention. Detailed Implementation

[0014] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0015] Reference Figure 1 One embodiment of the present invention proposes a data security sharing and authorized access control method based on privacy computing. By combining causal policy mapping and multi-party privacy computing, it can achieve traceable and auditable dynamic authorized access control throughout the entire data lifecycle, ensuring high security and policy consistency in the data sharing process.

[0016] The method described in this embodiment specifically includes: S1. Obtain data sharing requests and authorized access policies of each data provider, obtain sharing request information and perform causal policy mapping processing to generate causal privacy initialization vectors; In one embodiment of the present invention, step S1 includes the following steps: Obtain data sharing requests and the authorized access policies of each data provider to obtain sharing request information; Obtain the local data format information and policy constraint parameters of each data provider to obtain local constraint characteristics; The local constraint features and the shared request information are subjected to causal mapping matching processing to generate an initial causal mapping result; The initial causal mapping result and the policy constraint parameters are used to perform causal state fusion calculation to generate a causal privacy initialization vector.

[0017] Specifically, the entire process begins with the system receiving a data sharing request from an external entity, while simultaneously retrieving pre-configured authorization access policies from multiple data providers associated with the request. These two pieces of information together form the basic input for subsequent processing. The system parses the data sharing request, extracts key request elements, and forms structured sharing request information. A data sharing request is essentially a description of the intent to access a specific dataset, while authorization access policies are a series of rules and conditions set by the data owner or administrator to protect data assets.

[0018] The system interacts with each data provider involved to obtain their respective local data format information and policy constraint parameters. Local data format information describes the data's organizational structure, such as field types, data schemas, or file formats, while policy constraint parameters quantify the authorized access policy, such as data sensitivity levels, allowed access time windows, or geographical location restrictions. Combining these two pieces of information, the system generates unique local constraint features for each data provider. These local constraint features can be understood as a multi-dimensional vector that comprehensively characterizes the ownership and privacy boundaries of a specific dataset under the current policy.

[0019] The system performs a crucial causal mapping matching process, the core of which lies in assessing the compatibility and causal relationship between the shared request information and each local constraint feature. Instead of performing simple Boolean logic matching, the system analyzes whether there are potential causal conflicts between the purpose of the data request and the constraints imposed by the data provider. For example, a request for data for business analysis might causally mismatch the provider's "academic research only" policy constraint parameters. The output of this process is the initial causal mapping result, which generates a matching score or status identifier for each data provider, quantifying the likelihood of the request being granted and its potential privacy risks.

[0020] The initial causal mapping results are generated according to the following calculation method: , in, Representative regarding the first The initial causal mapping result of the data provider is a scalar value whose magnitude reflects the degree of matching. This indicates the number of key request elements contained in the shared request information. It is the first The weighting coefficients for each request element are determined based on compliance audit analysis of 200 historical cross-institutional medical data sharing instances. This analysis identifies the importance of different request elements (such as requester identity and data purpose) to privacy risks. The values ​​range from 0 to 1. . This is a causal similarity calculation function used to calculate the matching degree between request elements and policy constraint parameters. The function outputs a value in the range [0,1], where 1 indicates a complete match and 0 indicates a complete mismatch. The first in the representative sharing request information Key request elements, such as requester identity attributes or a statement of purpose for data use. Representing the The policy constraint parameters of the data provider are related to the first one. The constraint values ​​corresponding to each request element.

[0021] The system performs causal state fusion calculations, which integrate the initial causal mapping results from all data providers with their respective policy constraint parameters to generate a global, structured causal privacy initialization vector. This vector not only contains the conclusions of the matching evaluation but also incorporates all relevant policy constraint details, serving as the fundamental basis and "initial state" for all subsequent privacy protection and authorization calculation steps. The causal privacy initialization vector is a complex data structure that sets the initial privacy protection tone and operational boundaries for the entire data sharing lifecycle. The generation process of the causal privacy initialization vector can be described by the following formula: , in, This represents the final generated causal privacy initialization vector. It is a fusion function responsible for integrating the various input elements into a unified structured vector. The operations performed by this function include result aggregation, constraint encoding, and metadata appending. It is made by all A set consisting of the initial causal mapping results of each data provider. It is all The set of policy constraint parameters for each data provider, here It guides calculation The original parameter set. It is a unique transaction identifier generated for this data sharing transaction, ensuring the uniqueness and traceability of the vector.

[0022] For example, suppose there is a medical data sharing scenario. A research institution initiates a data sharing request, and its sharing request information... Parsed as {requester identity attribute} =“Certified Research Institutions”, Declaration of Data Use Purpose =“Analysis of the effectiveness of new drug development”. This request involves two hospitals, namely data provider 1 and data provider 2.

[0023] The system first obtains the local data format information from data provider 1, such as "JSON format, containing 'patient_id' and 'diagnosis_code' fields", and the policy constraint parameters. The constraint value related to the request is {identity requirements}. =“Certified Research Institutions”, Usage Restrictions =“Non-commercial academic research”}. Similarly, obtain the local data format information (e.g., “CSV format, containing 'ID' and 'DIAGNOSIS' fields”) and policy constraint parameters from data provider 2. The relevant constraint value is {identity requirement}. =“Entities within the cooperation agreement”, usage restrictions =“Clinical pathway optimization”}. These two sets of information constitute the local constraint characteristics of the two hospitals, respectively.

[0024] Next, the system performs causal mapping matching on them. Assuming that the weights of identity attributes are determined based on historical data analysis... Set to 0.4, using the weight of the purpose. Set to 0.6. For data provider 1, the requester's identity is an exact match ("Certified Research Institution"). However, using partial matching of the target ("new drug development" falls within the research scope but has commercial potential), it is assumed that the similarity function is calculated as follows: Therefore, the initial causal mapping result The calculation is as follows: For data provider 2, the requester's identity does not match (the research institution is not included in the cooperation agreement). The intended uses also do not match ("new drug development" and "clinical pathway optimization" have different purposes), assuming Therefore, the initial causal mapping result The calculation is as follows: .

[0025] Finally, the system performs causal state fusion calculations. Assume the unique transaction identifier for this transaction is... =“TXN20231026”. The system merges the above calculation results with the original constraint parameters to generate a causal privacy initialization vector. Its content can be represented as: ={Transaction ID:“TXN20231026”,Mapping Result:[{Provider:1,Score:0.7},{Provider:2,Score:0.16}],Activation Constraints:[{Provider:1,Constraints:{Identity Requirement:“Certified Research Institution”,Usage Restriction:“Non-commercial Academic Research”}},{Provider:2,Constraints:{Identity Requirement:“Institution within the Cooperation Agreement”,Usage Restriction:“Clinical Pathway Optimization”}}]},This generated causal privacy initialization vector records the initial state of this data sharing request and all relevant privacy boundary conditions, providing a solid and comprehensive computational foundation for subsequent steps S2 to S7.

[0026] S2. Combine the local data of each data provider with the causal privacy initialization vector to perform causal constraint segmentation processing to generate causal protected data fragments; In one embodiment of the present invention, step S2 includes the following steps: The constraint guidance information in the causal privacy initialization vector is identified to obtain the constraint evaluation result; Based on the constraint evaluation results, causal classification processing is performed on the local data of each data provider to generate a constraint feature set; The local data corresponding to the constraint feature set is subjected to causal segmentation and encapsulated with the non-constraint part to generate a causal protection data fragment.

[0027] Specifically, after generating the causal privacy initialization vector in step S1, the system enters the causal constraint segmentation processing stage. The purpose of this stage is to preprocess the original local data of each data provider according to the policy instructions contained in the vector, and generate an intermediate data form suitable for subsequent privacy computation.

[0028] The first step in this process is to identify the constraint guidance information in the causal privacy initialization vector. This constraint guidance information is not a specific field in the vector, but rather a series of operational instructions comprehensively parsed from the entire vector structure. It primarily originates from the initial causal mapping result calculated in step S1 and the original policy constraint parameters. The system analyzes these two parts to generate a constraint evaluation result for each data provider. This result clarifies which data items need to be protected and the basis for such protection. For example, a low score in an initial causal mapping result may lead to all its corresponding data being marked as highly sensitive. The generation of the constraint evaluation result can be determined by the following logic: , in, Representative regarding the first The constraint assessment results from a data provider are a set of data items paired with constraint levels. It is the first The first data provider's local data Each data item or field. It is a function that, according to the first... The first data provider Each strategy constraint parameter (For example, "use restrictions") to determine a protection level, such as "high" or "medium". From causal privacy initialization vector Extracted from, targeting the The initial causal mapping score of each data provider. This is a preset activation threshold. This threshold is set based on a privacy breach risk simulation analysis of 500 sets of simulated financial transaction data, determining that a threshold of 0.5 strikes a balance between data availability and risk aversion. Only when... Only when this threshold is exceeded is the relevant constraint considered to be active. It is a Boolean function, when the policy constraint... With data items Returns true if the metadata (such as field names or labels) has a predefined mapping relationship.

[0029] After obtaining the constraint evaluation results, the system performs causal classification on the local data from each data provider based on these results. This process is essentially a logical partitioning of the data. The system iterates through all data items in the local data and compares them with the constraint evaluation results. The data items are divided into two categories. Data items marked as requiring protection are grouped together to form the constraint feature set. All other unmarked data items constitute the unconstrained portion. Based on the constraint evaluation results... Generate constrained feature set The process is as follows: , All that does not belong to The data items then constitute the unconstrained part. The final step in the processing flow is to perform causal segmentation on the classification result and encapsulate it with the unconstrained portion to generate the final causal-protected data fragment. For the constrained feature set... For each data value contained within, the system performs a causal partitioning operation, a cryptographic technique that splits a single data point into multiple shares, ensuring that no single share or combination of shares less than a predetermined number can recover the original data. (Unconstrained portion) The data remains in its original form. After the segmentation is completed, the system encapsulates the generated data shares together with the unconstrained part of the data that remains unchanged, forming a structured causally protected data fragment. The uniqueness of this data fragment lies in that it not only retains the direct usability of the non-sensitive information but also protects the sensitive information through data segmentation, preparing for the secure multi-party computation in step S3.

[0030] For any numerical data in the constrained feature set , its causal segmentation process can be expressed as: , where is the original data value to be segmented. is a threshold secret sharing function that divides the secret value into shares. is the th generated share. is the total number of shares, which is set based on the number of computing nodes participating in the subsequent calculation to ensure that each node holds only one share. is the minimum number of shares required to recover the secret value, which is set according to the security level requirements in the authorization access policy. For example, a high security level requires .

[0031] Exemplarily, we continue with the medical data sharing scenario in step S1. The causally private initialization vector generated in step S1 indicates that the initial causal mapping result of data provider 1 (hospital 1) is , and the result of data provider 2 (hospital 2) is . Assume that the activation threshold is set to 0.5.

[0032] The system first identifies the constraint guiding information in the causally private initialization vector. Since , the policy constraint of data provider 1 is activated. While , the policy constraint of data provider 2 is not activated, and its data will not be processed in this request. The system generates a constraint evaluation result for data provider 1. Assume that its local data record is , and the predefined mapping relationship indicates that the patient_id and diagnosis_code fields are related to the usage restriction of "non-commercial academic research". Therefore, may be {(patient_id, high), (diagnosis_code, high)}.

[0033] Next, based on the constraint assessment results Perform causal classification. System traversal. Data items, generate constraint feature sets Its content is {patient_id:"P001",diagnosis_code:850}. The remaining age field constitutes the unconstrained part, and its content is {age:65}.

[0034] Finally, causal segmentation is performed on the local data corresponding to the constrained feature set, and it is encapsulated with the unconstrained part. It is assumed that subsequent computations will be performed on three computation nodes, i.e. Furthermore, the security policy requirements are extremely high, with threshold values... The system splits the diagnosis_code value of 850, generating three shares. For example, two shares are randomly selected through additive secret sharing. The third share is then calculated as For the string "patient_id", the system may first convert it to a numerical representation (e.g., through hashing or encoding) before segmenting. After segmentation, these shares are encapsulated with the unconstrained portion of the age data. The final generated causal protection data fragments The structure may be as follows: ={non_constrained_data:{age:65},constrained_shares_package:[{field:“patient_id”,shares:{1:share_p1,2:share_p2,3:share_p3}},{field:“diagnosis_code”,shares:{1:200,2:450,3:200}}]}. This causal-protected data fragment is ready to be securely distributed to different computing nodes for the next step of causal privacy computation.

[0035] S3. Perform causal privacy calculations on the causal protected data fragment, the causal privacy initialization vector, and the access requester's attribute information to generate a causal authorization sharing calculation result; In one embodiment of the present invention, step S3 includes the following steps: The causal protection data fragment is distributed to multiple computing nodes and the blinded attribute information of the access requester is received to obtain distribution confirmation information. Based on the distribution confirmation information and the causal privacy initialization vector, multiple rounds of causal interaction calculations are performed at each node to generate intermediate evolutionary shares. The intermediate evolutionary shares are fused and reconstructed, and the causal privacy initialization vector is applied to perform causal path verification, generating causal authorization sharing calculation results.

[0036] Specifically, after generating the causal-protected data fragment in step S2, the system enters the core causal privacy computation phase. The goal of this phase is to perform computations on the data based on the data sharing request without disclosing the original sensitive data, while simultaneously verifying whether the access requester's attribute information meets the policy conditions specified in the causal privacy initialization vector.

[0037] The process begins by distributing each causal protection data segment to multiple pre-defined computing nodes. Each computing node receives only one share of the data, for example, the first value of a specific field in the causal protection data segment. The first share will be sent to the first Each computing node is a distributed storage system, which forms the basis for privacy-preserving computation. Simultaneously, the system receives attribute information from the requester, but not in plaintext; instead, it receives encrypted or obfuscated attribute information. Obfuscated attribute information is a special data format that allows computing nodes to verify and compute it without knowing its specific content. Once all computing nodes confirm receipt of the corresponding data share and obfuscated attribute information, the system records a distribution confirmation message as a synchronization signal indicating that computation is ready.

[0038] Based on this distribution confirmation information, the system triggers each computing node to perform multiple rounds of causal interaction computation according to the computation logic defined in the causal privacy initialization vector. This is a collaborative computation mode in which no single node can independently complete all computations. In each round of computation, each node performs local computation based solely on its own data share, the results of the previous round, and encrypted messages received from other nodes. The specific computation operations are determined by the policy constraints in the causal privacy initialization vector, such as verifying whether blinded attribute information conforms to the identity requirements in the policy, or performing specific statistical analyses on the data. After each round of computation, each node generates an intermediate evolution share, which is an encrypted representation of a portion of the computation results. It does not reveal any meaningful information itself but serves as the input for the next round of computation. The generation process of the intermediate evolution share can be described as follows: , in, Representing the The computing node at the in the ... Intermediate evolutionary shares generated after rounds of calculation. It is the first The local computation function of the round, the specific form of which is determined by the causal privacy initialization vector. It is determined by the computational tasks and strategy logic contained therein. It is the first The intermediate evolutionary shares generated by each node in the previous round of calculation, among which This is the initial data share. Representing the The share of raw data held by each computing node. It is in the In round-robin computation, from other nodes Send to node Encrypted messages. It is the causal privacy initialization vector generated in step S1, which serves as a global computation instruction and policy guide.

[0039] After a predetermined number of rounds of interactive computation, the system collects the final round's intermediate evolution shares generated by all computation nodes and merges and reconstructs them. This fusion and reconstruction is the reverse process of the secret-sharing technique; it combines the shares scattered across various nodes to reconstruct the final computation result. This result remains encrypted or protected. Following this, the system applies a causal privacy initialization vector to perform a critical causal path verification. This verification aims to ensure that the entire multi-party computation process strictly adheres to [the required causal path]. The causal logic and policy constraints set in the code prevent any malicious or erroneous calculations that deviate from the preset path. For example, the system checks whether the sequence of operations performed during the calculation is completely consistent with the policy requirements. Only after passing the verification is the result of the fusion and reconstruction confirmed as a valid causal authorized shared calculation result. The logic of causal path verification can be represented as a verification function: , in, It is a boolean value that indicates whether the validation passed or failed. It is a verification function used to compare the calculation path with the strategy. It is a fusion refactoring function that will merge the final round All intermediate evolutionary shares merge. This is the total number of computing nodes. It is the computation path metadata generated during multiple rounds of computation, which records the key operation steps.

[0040] The verified computation result is encapsulated as a causal authorized shared computation result. It is a composite data structure that not only contains the numerical result of the computation, which still exists in encrypted or share form, but also contains metadata proving the compliance of its computation process.

[0041] For example, we continue with the aforementioned medical data sharing scenario. Step S2 generates causal protection data fragments for the records of data provider 1 (hospital 1). This includes three shares {200, 450, 200} with a diagnosis_code value of 850, as well as a share for patient_id.

[0042] The system will The shares were distributed across three computing nodes. Node 1 received the share {patient_id_share_1, diagnosis_code_share:200}, Node 2 received {patient_id_share_2, diagnosis_code_share:450}, and Node 3 received {patient_id_share_3, diagnosis_code_share:200}. Simultaneously, the research institution, as the requester, submitted its blinding attribute information. This corresponds to its identity as a "certified research institution." After each node confirms receipt, the system receives the distribution confirmation information.

[0043] Based on the causal privacy initialization vector generated in step S1 (This includes requirements for visitor identity), and the system instructs each node to perform multiple rounds of causal interaction computation. The first task is verification. Nodes communicate with each other by executing a secure comparison protocol without decryption. In this case, they jointly calculate whether it matches the identity required by the strategy. Assuming two rounds of interaction... They generate intermediate evolutionary shares representing the matching result true (i.e., the value 1). For example, nodes 1, 2, and 3 hold the final shares {0, 1, 0} (their sum is 1).

[0044] Subsequently, the system merges and reconstructs these intermediate evolutionary shares. The system collects {0,1,0} and sums them to obtain 1, confirming successful visitor authentication. Next, causal path verification is performed, and the system checks the computed path metadata. It was discovered that an "attribute-safe comparison" operation was performed, which is consistent with... The identity constraint policy for Provider 1 is completely consistent, therefore the verification result is correct. It is true.

[0045] Assuming the sharing request also requires calculating the average of the diagnosis codes, the nodes will continue to interact, performing a safe summation of the shares of `diagnosis_code`. Ultimately, the shares they generate can reconstruct the original sum of 850. The final causal authorization sharing calculation result is... It will have the following structure: R_{AuthShare}={Transaction ID:“TXN20231026”,Access verification result:true,Calculation result:{diagnosis_code_sum_shares:{1:s''_1,2:s''_2,3:s''_3}},Evolutionary metadata:{path_valid:true,op_log_hash:“…”}}.

[0046] S4. Perform causal chain verification processing based on the causal authorization sharing calculation result to generate a dynamic evolution access credential; In one embodiment of the present invention, step S4 includes the following steps: Extract the evolutionary metadata from the causal authorization sharing computation results to obtain the result evolution information; By combining the resulting evolution information with the causal privacy initialization vector, a link generation calculation is performed to generate a preliminary credential chain; By binding and verifying the initial credential chain with the causal privacy initialization vector, a dynamically evolving access credential is generated.

[0047] Specifically, after successfully generating the causal authorization shared computation result in step S3, the system does not directly authorize access, but instead enters a step of generating access credentials. The core task of this step is to create a verifiable and tamper-proof credential based on the legality and causal coherence of all previous steps. This credential will serve as the key for subsequent authorized access.

[0048] This process first requires extracting the evolutionary metadata contained within the causal authorized sharing computation results. This metadata is generated synchronously during the causal privacy computation in step S3, and it records key information about the computation, such as the identifiers of the data sources involved in the computation, the specific sequence of computational operations performed, and the results of causal path verification. By parsing this metadata, the system can obtain a structured result evolution information that details how it evolved from the original data share through compliant computation.

[0049] Next, the system combines this result evolution information with the causal privacy initialization vector generated in step S1, which serves as the starting point of the entire process, to perform a link generation calculation. The purpose of this calculation is to construct a logically indivisible chain of evidence, proving that each step, from the initial policy matching to the final calculation result, strictly adheres to the preset causal relationship and privacy policy. The calculation process uses a cryptographic hash function to link the key content of the causal privacy initialization vector (such as transaction ID and activated policy constraints) with the key content of the result evolution information (such as operation log hash and path verification status), generating a unique hash value that summarizes the entire processing history. This hash value, along with its original input information, constitutes a preliminary credential chain. The generation of the preliminary credential chain can be expressed by the following formula: , in, This represents the initial chain of credentials generated, the core of which is a hash digest. It is a collision-resistant cryptographic hash function, such as SHA-256. SHA-256 is chosen because of its widely recognized security in the industry, which ensures that even if the input information is slightly modified, the output hash value will be significantly different. This is the causal privacy initialization vector generated in step S1. For computation, its key fields are typically serialized into a byte string. The result evolution information is extracted from the causal authorization shared computation results and is also serialized. This indicates a byte string concatenation operation.

[0050] After generating the initial credential chain, it is not directly used as the final credential. The system uses this initial credential chain to perform a decisive binding verification with the original causal privacy initialization vector. This verification step is crucial to ensuring the validity of the credential, and it is implemented through a digital signature mechanism. The system uses a private key associated with this data-sharing transaction to sign the core hash value of the initial credential chain. Then, this signature, the content of the initial credential chain, and some public information from the causal privacy initialization vector (such as the transaction ID) are encapsulated together. This signed and encapsulated complete data structure is the final dynamically evolving access credential. The word "dynamic" reflects that the credential content is closely related to the dynamic process of the entire data processing, and "evolution" indicates that it records the evolution path of the data from the initial state to the calculation result. The process of binding verification and generating a dynamically evolving access credential can be described as follows: , in, It is the final dynamically evolved access credential. It is a digital signature function that uses a private key bound to the transaction. The input is signed. Private keys are managed according to strict security protocols to ensure they are not leaked. It is the hash digest of the preliminary credential chain calculated earlier. From causal privacy initialization vector The transaction identifier extracted is used for public indexing.

[0051] For example, we continue with the previous scenario of medical data sharing. The causal authorization sharing calculation result generated in step S3 for: ={Transaction ID:“TXN20231026”, Access Validation Result:true, Calculation Result:{…}, Evolution Metadata:{path_valid:true,op_log_hash:“a1b2c3…”}}. The system first extracts the evolution metadata to obtain the result evolution information. The content is {path_valid:true,op_log_hash:“a1b2c3...”}.

[0052] Then, the system combines With the causal privacy initialization vector generated in step S1 Perform link generation calculations. The serialized key content could be "TXN20231026|provider1:0.7|req:auth_research_inst...". After serialization, it becomes "true|a1b2c3...". These two strings are then concatenated and input into the SHA-256 hash function. Here, 0x9f86d... is the core hash value of the calculated preliminary credential chain. Finally, the system uses the preliminary credential chain to perform binding verification with the causal privacy initialization vector. The system uses the private key associated with transaction TXN20231026. right Sign: , The 0x3045a... here is the generated digital signature. The final generated dynamic evolution access credential. The above information is encapsulated: ={Transaction ID:“TXN20231026”, Credential Content:{Original Information Hash:“0x9f86d…”}, Signature:“0x3045a…”}. This dynamically evolving access credential now serves as an independent, verifiable object, recording the compliance of the entire process from policy matching to result generation, ready for the next step of final verification of the access requester's attributes.

[0053] S5. Verify the access requester's attribute information based on the dynamically evolved access credential, and generate an authorized access token; In one embodiment of the present invention, step S5 includes the following steps: Obtain the access requester's attribute information and authorization access token request to obtain the request attribute set; Perform causal matching verification on the request attribute set and the dynamically evolved access credential, and generate a matching verification result; Based on the matching verification result, a token signature is generated to produce an authorized access token.

[0054] Specifically, after generating the dynamically evolving access credentials that ensure the compliance of the computation process in step S4, the system enters a crucial step before final authorization: generating an authorized access token for actual data access. The core of this step is to re-verify the entity currently initiating the access request, ensuring it is the same entity that previously participated in privacy computation and was proven compliant, and issuing it a token with a time limit and specific permissions.

[0055] The process begins when the system receives an authorization access token request from the requester. This request must contain the requester's plaintext attribute information. The system parses this information to form a structured set of request attributes. The content of the request attribute set should correspond to the request elements in the initial data sharing request received in step S1, such as the requester's identity and organization.

[0056] Next, the system performs a crucial causal matching verification. This verification process compares the newly submitted request attribute set with the dynamically evolved access credential generated in step S4. The verification involves two levels. The first level verifies the integrity and authenticity of the dynamically evolved access credential itself. The system uses the public key associated with the transaction to verify the digital signature in the credential, ensuring that the credential has not been tampered with. Obtaining the public key relies on a trusted public key infrastructure. , in, It is a boolean value representing the result of signature verification. It is a digital signature verification function that uses a public key. . and These are the credential content and signature portion of the dynamically evolved access credential.

[0057] At the second level, after signature verification, the system needs to reconstruct the original message digest represented by the dynamically evolving access credential and match it with the request attribute set currently submitted by the access requester. The system will backtrack to the causal privacy initialization vector generated in step S1 and the result evolution information generated in step S3 (this information can be retrieved through the transaction ID in the credential), and together with the current request attribute set (which needs to be serialized in the same format as in step S1), re-execute the link generation calculation in step S4 to obtain a new hash value. Then, this new hash value is compared with the original message hash recorded in the dynamically evolving access credential. If the two are completely identical, it proves that the current requester's attributes completely match the requester's attributes at the beginning of the entire causal chain. The verification at these two levels together constitutes the matching verification result. The core logic of the matching verification can be expressed as: , in, It is the final matching verification result, which is also a boolean value. This is the set of request attributes obtained from the requester, after serialization. Note that the hash calculation here adds one item compared to step S4. This approach aims to include the current requester's attributes in the verification scope, ensuring identity consistency. Based on simulation analysis of over a hundred permission forgery attacks, incorporating the current attribute set into the hash calculation effectively prevents legitimate users from accessing data with unauthorized attributes after their credentials are stolen. Consistent with the definition in step S4. Once the matching verification result is true, indicating that the requester's identity and the legitimacy of the request have been finally confirmed, the system will generate a token signature. The system will create a data structure containing authorization information, including a transaction ID, the scope of authorized permissions (e.g., which data fields are allowed to be accessed), and a validity period timestamp. Then, the system digitally signs this data structure using a key dedicated to token issuance (different from the credential signing key). The signature, together with the data structure itself, constitutes the final authorized access token. This token is unforgeable, has an expiration date, and clearly defined permissions; it is the unique credential for accessing the final data. The formula for generating the authorized access token is as follows: , in, It is the generated authorized access token. It is a data structure that contains authorization information, such as {Transaction ID:..., Permissions:..., Validity Period:...}. It's a token signing function that uses a token to sign a private key. .

[0058] For example, we continue with the aforementioned scenario of medical data sharing. Step S4 has generated a dynamically evolving access credential for transaction TXN20231026. Now, the research institution has formally submitted a request for an authorized access token. The system has obtained the access requester's attribute information, the plaintext of which is {Identity: "Certified Research Institution", Purpose: "Effectiveness Analysis of New Drug Development"}, constituting the request attribute set. The system requests the attribute set. With dynamically evolving access credentials Perform causal matching verification. First, the system uses the transaction public key. verify The signature is 0x3045a.... Assuming the verification passes, It is true.

[0059] Next, the system retrieves the transactions associated with transaction TXN20231026. and Then , And the currently submitted Serialize and concatenate, then recalculate the hash value: =SHA256(“TXN20231026|…|true|a1b2c3…|Certified Research Institution|New Drug Development Effectiveness Analysis”), assuming that when generating the certificate, It is also hashed as input, and The original information hash 0x9f86d... is precisely what contains... The hash value. Therefore, the newly calculated H_new will be equal to 0x9f86d… Therefore, the matching verification result… It is true.

[0060] Based on the successful matching verification result, the system generates a token signature. The system constructs token data. : ={Transaction ID:“TXN20231026”, Permission:“Read diagnosis_code calculation result”, Validity period:“2023-10-27 18:00:00UTC”} Then use the token to issue the private key. Sign it: The final generated authorized access token for: ={Token Data:{Transaction ID:“TXN20231026”,…},Signature: The research institution holding this authorized access token now has rigorously verified access to specific computation results for a specified period of time.

[0061] S6. Use the authorized access token to perform causal unlocking access on the causal authorized sharing calculation result to generate authorized sharing data.

[0062] In one embodiment of the present invention, step S6 includes the following steps: Parse the permission scope information in the authorized access token to obtain the permission scope parameters; Based on the permission scope parameters, a selective causal unlocking operation is performed on the causal authorization sharing calculation result to generate partial authorization data; After verifying the integrity of the authorized data, the data is output to generate authorized shared data.

[0063] Specifically, once the requester successfully obtains an authorized access token in step S5, they enter the final stage of the data sharing process: accessing and acquiring data. This step aims to ensure that access is strictly limited to the authorized scope and to verify the final delivered data to guarantee its accuracy and integrity.

[0064] The process begins when the system receives an access request initiated by a user using an authorized access token. The system first verifies the authorized access token, including its signature and validity period, to ensure its legitimacy. After successful verification, the system parses the permission scope information contained within the authorized access token. This information, generated in step S5 based on the matching verification results, explicitly specifies which specific data items or calculation results the token holder can access. The system then organizes this parsed information into a structured permission scope parameter set.

[0065] Next, based on the permission scope parameters, the system performs a selective causal unlocking operation on the causal authorization sharing computation result generated in step S3. Sensitive data in the causal authorization sharing computation result still exists in the form of secret shares, not plaintext. The unlocking operation is the process of reconstructing the secret in the secret sharing scheme. Based on the permission scope parameters, the system instructs the computation nodes holding the relevant data shares to submit their shares to a secure reconstruction module. This module only performs reconstruction on data items that are authorized for access, while unauthorized data items retain their share status and cannot be accessed. This process generates partially authorized data, containing only plaintext data that the access requester is authorized to view. The selective causal unlocking operation can be represented as: , in, This represents the generated partial authorized data. It is a collection of key-value pairs, where the key is the identifier of the data item and the value is the reconstructed plaintext data. It is an identifier for a data item, such as a field name. It is a secret-sharing reconstruction function that receives a sufficient number of shares and recovers the original secret value. It is a data item The set of shares, in which It is a set of compute node indexes that provides a share, and the number of its elements must be greater than or equal to the reconstruction threshold. . It is the permission scope parameter parsed from the authorized access token, which specifies the set of data item identifiers that are allowed to be unlocked.

[0066] After generating partial authorization data, it is not immediately delivered to the access requester. The system also performs an integrity check. The purpose of this check is to ensure that the reconstructed data is consistent with the original calculation result and has not been erroneous or tampered with during unlocking or transmission. The check can be performed by comparing the hash value or checksum of the data. When generating the causal authorization sharing calculation result in step S3, a cryptographic hash of the result can be pre-calculated and stored. After unlocking, the system recalculates the hash of the partial authorization data and compares it with the stored hash value. The logic of the integrity check is as follows: , in It is a Boolean value representing the verification result. It is a deterministic hash function, such as MD5 or SHA-1, used to generate a compact fingerprint of data. Based on tests in 300 network transmission packet loss scenarios, the MD5 function achieves a good balance between ensuring verification speed and collision probability. It is pre-stored in the metadata of causal authorized shared computation results, corresponding to Partial hash value.

[0067] Only after the integrity verification passes will the system output a portion of the authorized data as the final authorized shared data to the access requester. This rigorous process ensures closed-loop security throughout the entire data sharing process, from policy matching to final data delivery, achieving trusted data sharing while adhering to complex causal policies.

[0068] For example, we continue with the previous medical data sharing scenario. In step S5, the research institution has obtained an authorization access token. .

[0069] Research institutions use Initiate access. After verifying the token signature and validity period, the system parses the token data to obtain the permission scope parameters. Its content is {"Read the diagnosis_code calculation result"}. The system is based on... causal authorization sharing computation results Perform a selective causal unlock operation. This includes shares {s''_1,s''_2,s''_3} of the sum of `diagnosis_code`. The system instruction for the compute nodes holding these shares is to submit them. Assuming the reconstruction threshold is 3, the reconstruction module performs reconstruction calculations after receiving all three shares. `sum_diag_code=Reconstruct({s''_1,s''_2,s''_3})`. If these shares were initially generated based on the original value 850, the reconstruction result would be 850. Therefore, the generated partial authorization data... {diagnosis_code_sum:850}.

[0070] Before output, the system performs... Perform integrity verification. Assume that at the end of step S3, the system calculated and stored the result of MD5({diagnosis_code_sum:850}), i.e. =08a1de7ec2561571212a7814a61c5c0d. Now, the system recalculates the MD5 value of the currently generated partial authorization data: =MD5({diagnosis_code_sum:850})=08a1de7ec2561571212a7814a61c5c0d. Since the newly calculated hash value is completely consistent with the stored hash value, the integrity verification result is... It is true.

[0071] After successful verification, the system encapsulates a portion of the authorized data into authorized shared data and securely transmits it to the research institution. The research institution ultimately receives the data {diagnosis_code_sum:850}, successfully obtaining the data calculation results needed for its research without accessing any original sensitive patient information.

[0072] S7. Optimize the causal privacy initialization vector for reuse in subsequent data sharing requests.

[0073] In one embodiment of the present invention, step S7 includes the following steps: Obtain the usage records of the authorized access token and generate usage log information; A causal audit calculation is performed on the usage log information and the causal privacy initialization vector to generate an audit compliance report; The authorized access policy is dynamically updated based on the audit compliance report to generate an updated policy. The audit compliance report is compared and analyzed with the causal privacy initialization vector to obtain deviation indication information; The strategy constraint parameters of each data provider are adjusted based on the deviation indication information to generate adjusted constraint parameters. The adjusted constraint parameters and the updated policy are fused together to generate an optimized causal privacy initialization vector for repeated use in subsequent data sharing requests.

[0074] Specifically, after the authorized shared data is successfully delivered in step S6, the lifecycle of a single data sharing transaction is not completely over. The system will enter a critical optimization and adaptation phase, the core objective of which is to leverage the practical experience gained from this transaction to iteratively optimize future data sharing decisions and strategy execution, forming a closed-loop learning and improvement mechanism.

[0075] This optimization process begins with the system acquiring the usage records of the authorized access token. Every operation performed using the authorized access token, including the access time, visitor identifier, accessed data items, and operation result, is securely recorded by the system. The system aggregates and structures these scattered records to generate a complete usage log, which forms the objective factual basis for this data sharing behavior.

[0076] Subsequently, the system performs an in-depth causal audit calculation on this usage log information and the causal privacy initialization vector generated in step S1 when this transaction was initiated. The purpose of this calculation is to assess whether the actual data usage behavior is completely consistent with the initial authorized intent and policy constraints. The system compares each operation in the usage log information with the policy rules defined in the causal privacy initialization vector, for example, whether the accessed data items exceeded the authorized scope, and whether the access time was within the allowed window. The final output of the calculation is an audit compliance report, which quantifies the compliance level of this transaction and highlights any potential policy deviations or violations. The compliance score in the audit compliance report can be calculated using the following formula: , in, This represents the audit compliance score, with a value range of [0,1], where 1 indicates full compliance. This is the total number of audit items. It is the first The weights for each inspection item are determined by the Data Governance Committee based on root cause analysis of 100 historical data breaches, with higher weights assigned to key strategies such as data usage consistency. All weights are positive numbers. It is a Boolean function, representing the first... One audit check item. It uses log information. and causal privacy initialization vector The input is 1. If the log behavior conforms to the policy, it returns 1; otherwise, it returns 0.

[0077] Based on this audit compliance report, the system will trigger two parallel optimization branches. The first branch is at the macro-strategy level. If the audit compliance report reveals systemic risks or policy vulnerabilities, data governance personnel will dynamically update the top-level authorization access policy based on the report's recommendations. For example, they may tighten authorization conditions for certain types of requesters and generate an updated policy.

[0078] The second branch operates at the micro-parameter level, where the system performs a deviation comparison analysis between the audit compliance report and the original causal privacy initialization vector. The core of this analysis lies in comparing the predictive initial causal mapping results from step S1 with the audit compliance score derived after the audit, which reflects the true risk. The difference between the two is quantified as deviation indication information, revealing potential assessment biases in the initial policy matching model (too lenient or too strict). The formula for calculating the deviation indication information is: , in It is aimed at the first Deviation indication information from each data provider. This is the overall audit compliance score for this transaction. It is extracted from the causal privacy initialization vector and calculated in step S1 for the first... The initial causal mapping results of each data provider.

[0079] Based on this deviation indication information, the system adjusts the policy constraint parameters of each data provider that caused the evaluation bias. For example, the weight coefficients used to calculate the initial causal mapping result in step S1 can be adjusted using an incremental update algorithm to reduce future evaluation bias. The adjustment of the weight coefficients in the policy constraint parameters can follow these rules: , in, It is the updated version of the first The weight coefficient of each request element. These are the original weighting coefficients. It is a learning rate parameter, with a value set to 0.1. This value was determined through simulation experiments on 1000 simulated policy update cycles, aiming to ensure stable convergence of the parameter adjustment process and avoid violent oscillations. It is the calculated deviation indication information. It is an impact factor, representing the first The request element is related to the first The contribution of each data provider to the initial causal mapping results is used to determine the allocation of adjustments.

[0080] The adjusted parameters constitute the adjusted constraint parameters. Finally, the system merges and updates the macroscopic updated policy with the microscopic adjusted constraint parameters. This fusion process essentially involves reconstructing a policy model template using the new policy and parameters. The resulting optimized causal privacy initialization vector will serve as a benchmark for handling similar data sharing requests in the future, enabling the entire data sharing system to continuously learn and improve.

[0081] For example, we complete the final step in the medical data sharing scenario. In step S6, the research institution successfully obtains the calculation result of the diagnosis_code. The system obtains the usage record of the authorized access token and generates usage log information. {Transaction ID: "TXN20231026", Operation: "Read diagnosis_code_sum", Result: Success}. The system performs causal audit calculations. Comparison. and All operations were found to be within the authorized scope, and an audit compliance score was calculated. The audit compliance report indicates "full compliance." Based on this report, the data governance personnel believe that the current authorized access policy does not require modification; therefore, the updated policy remains the same as the original policy. Next, the system performs a deviation comparison analysis. For data provider 1, the initial causal mapping result is... Deviation indication information The calculation is as follows: This positive deviation indicates that the system's initial risk assessment of the request was slightly conservative.

[0082] Based on this deviation indication, the system adjusts the policy constraint parameters. Assuming the initial calculation... At that time, the weight of the use restriction element The system is now updating it: (Here, we assume the influence factor of the use factor) To maintain a total weight of 1, the weight of the identity attribute... The corresponding adjustment is as follows: This new set of weights constitutes the adjusted constraint parameters. Ultimately, the system utilizes these adjusted constraint parameters. The updated policy, which remains unchanged, is then merged with the previous one to generate a template for an optimized causal privacy initialization vector. When a certified research institution requests data for a similar purpose in the future, the system will use this optimized template to execute step S1, thereby making a more accurate initial assessment.

[0083] Based on the same inventive concept, such as Figure 2 As shown, the present invention also provides a data security sharing and authorized access control system based on privacy computing, the system comprising: The causal privacy initialization module is used to obtain data sharing requests and the authorized access policies of each data provider, obtain sharing request information and perform causal policy mapping processing to generate a causal privacy initialization vector. The causal protection segmentation module is used to perform causal constraint segmentation processing on the local data of each data provider in combination with the causal privacy initialization vector to generate causal protection data fragments; The causal privacy computation execution module is used to perform causal privacy computation on the causal protected data fragment, the causal privacy initialization vector, and the attribute information of the access requester, and generate a causal authorization sharing computation result. The dynamic credential generation module is used to perform causal chain verification processing based on the causal authorization sharing calculation result and generate a dynamic evolution access credential. The authorization verification module is used to verify the attribute information of the access requester based on the dynamically evolved access credentials and generate an authorization access token. The causal unlock access module is used to use the authorized access token to perform causal unlock access on the causal authorized sharing calculation result and generate authorized sharing data.

[0084] It should be noted that the electrical connections between the various units described above do not necessarily represent direct or indirect connections. Any indirect connection method can be applied to the embodiments of the present invention as long as it achieves the purpose of the present invention. The above descriptions are merely exemplary embodiments of the present invention and should not be construed as limiting the scope of the present invention.

[0085] All equivalent changes and modifications made in accordance with the teachings of this invention are still within the scope of this invention. Those skilled in the art will readily conceive of other embodiments of this invention upon considering the specification and the disclosure of practical truth. This application is intended to cover any variations, uses, or adaptations of this invention that follow the general principles of this invention and include common knowledge or conventional techniques in the art not described herein.

Claims

1. A method for secure data sharing and authorized access control based on privacy-preserving computation, characterized in that, The method includes: Obtain data sharing requests and authorization access policies of each data provider, obtain sharing request information and perform causal policy mapping processing to generate a causal privacy initialization vector; The local data from each data provider is combined with the causal privacy initialization vector to perform causal constraint segmentation processing, generating causal protected data fragments; Perform causal privacy computation on the causal protected data fragment, the causal privacy initialization vector, and the access requester's attribute information to generate a causal authorization sharing computation result; Based on the causal authorization sharing calculation results, causal chain verification is performed to generate dynamic evolution access credentials; Based on the dynamically evolved access credentials, the access requester's attribute information is verified, and an authorized access token is generated; The authorized access token is used to perform causal unlocking access on the causal authorized sharing calculation result to generate authorized sharing data.

2. The data security sharing and authorized access control method based on privacy computing according to claim 1, characterized in that, The process of obtaining data sharing requests and the authorized access policies of each data provider, acquiring sharing request information, performing causal policy mapping processing, and generating a causal privacy initialization vector includes: Obtain data sharing requests and the authorized access policies of each data provider to obtain sharing request information; Obtain local data format information and policy constraint parameters from each data provider to obtain local constraint characteristics; The local constraint features and the shared request information are subjected to causal mapping matching processing to generate an initial causal mapping result; The initial causal mapping result and the policy constraint parameters are used to perform causal state fusion calculation to generate a causal privacy initialization vector.

3. The data security sharing and authorized access control method based on privacy computing according to claim 2, characterized in that, The step of performing causal constraint segmentation on the local data of each data provider in conjunction with the causal privacy initialization vector to generate causal-protected data fragments includes: The constraint guidance information in the causal privacy initialization vector is identified to obtain the constraint evaluation result; Based on the constraint evaluation results, causal classification processing is performed on the local data of each data provider to generate a constraint feature set; The local data corresponding to the constraint feature set is subjected to causal segmentation and encapsulated with the unconstrained part to generate a causal protection data fragment.

4. The data security sharing and authorized access control method based on privacy computing according to claim 3, characterized in that, The step of performing causal privacy computation on the causal protected data segment, the causal privacy initialization vector, and the access requester's attribute information to generate a causal authorization sharing computation result includes: The causal protection data fragment is distributed to multiple computing nodes and the blinded attribute information of the access requester is received to obtain distribution confirmation information. Based on the distribution confirmation information and the causal privacy initialization vector, multiple rounds of causal interaction calculations are performed at each node to generate intermediate evolutionary shares. The intermediate evolutionary shares are fused and reconstructed, and the causal privacy initialization vector is applied to perform causal path verification, generating causal authorization sharing calculation results.

5. The data security sharing and authorized access control method based on privacy computing according to claim 4, characterized in that, The step of performing causal chain verification based on the causal authorization sharing calculation result to generate a dynamically evolving access credential includes: Extract the evolutionary metadata from the causal authorization sharing computation results to obtain the result evolution information; By combining the resulting evolution information with the causal privacy initialization vector, a link generation calculation is performed to generate a preliminary credential chain; By binding and verifying the initial credential chain with the causal privacy initialization vector, a dynamically evolving access credential is generated.

6. The data security sharing and authorized access control method based on privacy computing according to claim 5, characterized in that, The step of verifying the access requester's attribute information based on the dynamically evolved access credential and generating an authorized access token includes: Obtain the access requester's attribute information and authorization access token request to obtain the request attribute set; Perform causal matching verification on the request attribute set and the dynamically evolved access credential, and generate a matching verification result; Based on the matching verification result, a token signature is generated to produce an authorized access token.

7. The data security sharing and authorized access control method based on privacy computing according to claim 6, characterized in that, The step of using the authorized access token to perform causal unlocking access on the causal authorized sharing calculation result and generating authorized sharing data includes: Parse the permission scope information in the authorized access token to obtain the permission scope parameter; Based on the permission scope parameters, a selective causal unlocking operation is performed on the causal authorization sharing calculation result to generate partial authorization data; After verifying the integrity of the authorized data, the data is output to generate authorized shared data.

8. The data security sharing and authorized access control method based on privacy computing according to claim 7, characterized in that, The method further includes: Obtain the usage records of the authorized access token and generate usage log information; A causal audit calculation is performed on the usage log information and the causal privacy initialization vector to generate an audit compliance report; The authorized access policy is dynamically updated based on the audit compliance report to generate an updated policy. The causal privacy initialization vector is optimized based on the updated strategy for cyclical use in subsequent data sharing requests.

9. The data security sharing and authorized access control method based on privacy computing according to claim 8, characterized in that, The optimization of the causal privacy initialization vector based on the updated policy includes: The audit compliance report is compared and analyzed with the causal privacy initialization vector to obtain deviation indication information; The strategy constraint parameters of each data provider are adjusted based on the deviation indication information to generate adjusted constraint parameters. The adjusted constraint parameters and the updated policy are fused together to generate an optimized causal privacy initialization vector for repeated use in subsequent data sharing requests.

10. A data security sharing and authorized access control system based on privacy computing, characterized in that, The system includes: The causal privacy initialization module is used to obtain data sharing requests and the authorized access policies of each data provider, obtain sharing request information and perform causal policy mapping processing to generate a causal privacy initialization vector. The causal protection segmentation module is used to perform causal constraint segmentation processing on the local data of each data provider in combination with the causal privacy initialization vector to generate causal protection data fragments; The causal privacy computation execution module is used to perform causal privacy computation on the causal protected data fragment, the causal privacy initialization vector, and the attribute information of the access requester, and generate a causal authorization sharing computation result. The dynamic credential generation module is used to perform causal chain verification processing based on the causal authorization sharing calculation result and generate dynamic evolution access credentials. The authorization verification module is used to verify the attribute information of the access requester based on the dynamically evolved access credentials and generate an authorization access token. The causal unlock access module is used to use the authorized access token to perform causal unlock access on the causal authorized sharing calculation result and generate authorized sharing data.

Images