An artificial intelligence-based financial data sharing security monitoring system and method

Abstract

This invention provides an artificial intelligence-based financial data sharing security monitoring system and method, belonging to the field of data security. It solves the problem of low efficiency in financial data sharing. The system is as follows: a data acquisition module acquires the file to be protected; the file to be protected is encrypted and segmented to obtain fragment files; a data sharing module constructs a Merkle tree based on the fragment files, saves the fragment files according to the Merkle tree, and uploads them to the blockchain; a security monitoring module defines a binary logistic regression model for security monitoring and constructs a security monitoring model using the APPDRR model as a reference model to protect the data to be protected; a continuous update module monitors whether the data in the file to be protected has changed; if it has changed, the changed file to be protected is synchronized to the blockchain; if it has not changed, monitoring continues. This invention, through encryption, segmentation, storage, and monitoring of financial data, enables users to access financial data more comprehensively and securely, ensuring the integrity and security of financial data.

Description

Technical Field

[0001] This invention relates to an artificial intelligence-based financial data sharing security monitoring system and method, and pertains to the field of data sharing. Background Technology

[0002] Existing systems and methods for sharing or monitoring financial data have the following shortcomings:

[0003] Data processing and accuracy issues: Although existing financial data sharing systems have powerful data processing and analysis capabilities, their efficiency and accuracy are still affected by the amount of data and the amount of local data loaded. If the total amount of input data or the amount of input data in a single instance exceeds the data storage capacity of the existing system, the existing system will be unable to identify and process this data, resulting in deviations or errors in the data sharing process or security monitoring process.

[0004] Security risks and vulnerabilities: Existing systems are susceptible to hacker attacks or malware intrusion, leading to data leaks or system crashes; furthermore, the algorithms and models of existing systems may contain biases or vulnerabilities, thus affecting the results of data analysis and processing.

[0005] Dependency and Technology Updates: Existing systems are highly dependent on technology; however, as technology continues to develop and upgrade, existing systems gradually become obsolete or unable to meet new demands. Enterprises need to continuously monitor technological developments and market changes, and establish professional technical teams or partnerships to support the continuous operation and maintenance of the systems. Summary of the Invention

[0006] In view of the shortcomings of existing technologies, the purpose of this invention is to provide an artificial intelligence-based financial data sharing security monitoring system and method, which aims to solve the problems of low efficiency and insecurity in financial data sharing.

[0007] To achieve the above objectives, the present invention provides the following technical solution: A financial data sharing security monitoring system and method based on artificial intelligence, comprising:

[0008] An artificial intelligence-based financial data sharing security monitoring system includes:

[0009] Data acquisition module: used to acquire data or files from the file to be scanned to obtain the file to be protected; to perform decentralized attribute encryption on the file to be protected to obtain the encrypted file; and to perform segmentation processing on the encrypted file to obtain fragmented files;

[0010] Data sharing module: This module constructs a Merkle tree based on fragmented files; allocates storage space A and storage space B on the user server; stores the node relationships of the Merkle tree in storage space A, with each node in storage space A storing its own hash value and the hash values ​​of its neighboring nodes; stores the fragmented files in storage space B and returns the address of the stored fragmented files to the corresponding node in storage space A; and uploads the data from storage spaces A and B to the blockchain.

[0011] Security monitoring module: used to obtain process parameters of the data to be protected being accessed normally; based on the process parameters, define a binary logistic regression model for security monitoring; use the APPDRR model as a reference model and combine it with the binary logistic regression model to construct a security monitoring model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected;

[0012] Continuous update module: Used to monitor whether the data or files in the file to be protected have changed; if they have changed, the changed file to be protected is synchronized to the blockchain; if they have not changed, monitoring continues.

[0013] Furthermore, the workflow of the data acquisition module is as follows:

[0014] Process A1: Scan the data or files in the file to be scanned to obtain the file to be protected;

[0015] Process A2: Encrypt the file to be protected to obtain an encrypted file;

[0016] Process A3: Obtain the user's identity information and split the encrypted file to obtain fragmented files;

[0017] Process A31: Use the os.path.getsize() function to get the size of the encrypted file, denoted as fs; count the number of identity information entries, denoted as pn;

[0018] Process A32: Calculate the number of file splits, denoted as n, where n = (pn) 4 ;

[0019] Use a PowerShell script to split an encrypted file into n parts, resulting in n fragment files; the size of each fragment file is (fs / n); where / represents a division operation;

[0020] If (fs%n)≠0, then the size of the nth fragment file is: (fs / n)+(fs%n); where % represents modulo operation; the size of the 1st to (n-1)th fragment files is: (fs / n);

[0021] Summarize the fragmented files from the 1st to the nth and proceed to the data sharing module.

[0022] Furthermore, the specific process of process A2 is as follows:

[0023] Process A21: Use secure communication protocols such as TLS / SSL to establish an encrypted channel with an authoritative institution and obtain security parameters, denoted as λ;

[0024] Process A22: Select Setup, KeyGen, and Encrypt algorithms as the foundational algorithms for decentralized encryption;

[0025] Process A23: Obtain the user's identity information;

[0026] Setup(λ) → (PK, MSK); Input security parameter λ, call the Setup algorithm, and output public key and master key; denote the public key as PK and the master key as MSK;

[0027] KeyGen(PK, MSK, user identity information) → (SK, ID); The public key PK, master key MSK, and user identity information are used as parameters for the KeyGen algorithm. The KeyGen algorithm is executed to generate the user's key and unique identifier, i.e., ID number; The key is denoted as SK;

[0028] Create an identity list and save the user's ID number;

[0029] Process A24: Obtain the absolute path of the file to be protected as the storage path; use the RSA or ECC algorithm to generate the symmetric key of the file to be protected, and denot the symmetric key as ck;

[0030] Encrypt(PK, SK, ck, storage path) → (CT); The public key PK, the private key SK, the symmetric key ck, and the storage path are used as inputs to the Encrypt algorithm. The Encrypt algorithm is executed to obtain attribute-based ciphertext, which is used as the encrypted file. The attribute-based ciphertext is denoted as CT; the encryption process of the file to be protected is completed.

[0031] Furthermore, the workflow of the data sharing module is as follows: it is used to construct a Merkle tree based on the fragmented files.

[0032] Process B1: Construct a Merkle tree based on the fragmented files;

[0033] Process B2: On the local server, create two storage spaces, denoted as space A and space B;

[0034] Process B3: Mark the leaf nodes at the bottom of the Merkle tree as storage nodes;

[0035] Using the pre-traversal algorithm, traverse all nodes in the Merkle tree, store the hash values ​​of all nodes in the Merkle tree into space A in the order output by the pre-traversal algorithm, and return the address of the corresponding node in space A.

[0036] Process B4: Based on the Merkle tree and the address returned by process B3, store the hash values ​​of the adjacent nodes corresponding to the storage node and the relation node in space A;

[0037] Process B5; x1~x n Randomly store it in space B;

[0038] In space b, read x1 to x2. n Store the address and index corresponding to the location, and assign them to x1 to x1. n The order of the storage location indices, from x1 to x n The address of the storage location is stored in the location corresponding to the index of the storage node in space A;

[0039] Process B6: Using the Flask and Requests libraries, create a blockchain and upload the data from Space A and Space B to the blockchain;

[0040] Set the data in space A and space B on the user's local server to be protected, and then enter the security monitoring module.

[0041] Furthermore, the specific process of process B13 is as follows:

[0042] Process B131: Group the fragmented files once; group x1 to x n Grouping by consecutive and adjacent indices yields the following groups: (x1, x2), (x3, x4), and so on, up to (x...). n-1 x n );

[0043] Count the number of groups in one operation, denoted as cn, where cn = n / 2;

[0044] Process B132: Define cn independent binary trees as first-order binary trees; assign hash values ​​H1 to H2 of the fragmented files. n As a leaf node of a first-order binary tree; call processing formula B1, according to (x1, x2), (x3, x4) ~ (x n-1 x n ) in the order of ) calculate the first-order hash value H corresponding to each group once. 1-1 H 1-2 ~H 1-cn ;

[0045] The first-order hash value H of the first primary group (x1, x2) 1-1 H 1-1=Hash(H1, H2);

[0046] The first-order hash value H of the second first group (x3, x4) 1-2 H 1-2 =Hash(H3, H4);

[0047] And so on, the cnth first group (x n-1 x n The first-order hash value H) 1-cn H 1-cn =Hash(H n-1 H n );

[0048] Process B133: Transfer H 1-1 ~H 1-cn As the root node of a first-order binary tree;

[0049] Define an independent binary tree dn as a second-order binary tree; where dn represents the number of second-order binary trees, dn = cn / 2;

[0050] H 1-1 ~H 1-cn As a leaf node of a second-order binary tree, H 1-1 ~H 1-cn Grouping by consecutive and adjacent indices yields secondary grouping (H). 1-1 H 1-2 ), (H 1-3 H 1-4 )~(H 1-(cn-1) H 1-cn );

[0051] Repeat the process of calculating the first-order hash value in process B132, and calculate (H) 1-1 H 1-2 )~(H 1-(cn-1) H 1-cn The corresponding second-order hash value H) 2-1 ~H 2-dn ;

[0052] Process B134: Count the number of second-order hash values, denoted as en;

[0053] If they are equal, then the Merkle tree has been successfully constructed. Calculate the root node of the Merkle tree, denoted as Hr, where Hr = H 2-1 *H 2-d ;

[0054] If not equal, the Merkle tree construction fails. Check if en is even (2) and proceed to process B135.

[0055] Procedure B135: If en is even, then H 2-1 ~H 2-dn Using the format of consecutive and adjacent indices as even nodes, call the Merkle Tree generation function to construct a Merkle tree;

[0056] If en is not even, then H 2-1 ~H 2-(dn-1) Use consecutive and adjacent indices as even nodes; H 2-dn As an independent node, it calls the Merkle Tree generation function to construct a Merkle tree.

[0057] Furthermore, the workflow of the security monitoring module is as follows:

[0058] Process C1: Obtain the operation codes and operation addresses of all processes created by this system during the execution of the data acquisition module and the data sharing module, and use them as process parameters for the data to be protected to be accessed normally;

[0059] Define a set YC to store all process parameters;

[0060] Process C2: Define the constraints of the binary logistic regression model for safety monitoring based on the set YC;

[0061] Process C3: Using the APPDRR model as a reference model and combining it with a binary logistic regression model to construct a safety monitoring model;

[0062] Process C4: Deploy the security monitoring model to the blockchain storage space to protect the data to be protected.

[0063] Furthermore, the specific process of process C2 is as follows:

[0064] Process C21: When a visitor accesses data to be protected, the system creates a monitoring process.

[0065] Define sets BB1 and BB2 to store all opcodes and operation addresses in the monitoring process, respectively;

[0066] Process C22: Define the partial function Y:

[0067] Y = 1, x ∈ YC; Y = 0,

[0068] Where x represents the input, i.e. (x∈BB1)∪(x∈BB2);

[0069] Procedure C23: Define the conditional probability distribution P(Y=1|x) or P(Y=0|x):

[0070]

[0071] Where exp represents the natural exponential function; ω represents the weight vector; b represents the bias; and ω*x represents the inner product of ω and x.

[0072] Process C24: Define the Logit function Logit(P):

[0073]

[0074] In Logit(P), P represents either P(Y = 1|x) or P(Y = 0|x).

[0075] An AI-based method for monitoring the security of shared financial data includes:

[0076] Step S1: Obtain data or files from the file to be scanned to obtain the file to be protected; perform decentralized attribute encryption on the file to be protected to obtain the encrypted file; split the encrypted file to obtain fragmented files;

[0077] Step S2: Construct a Merkle tree based on the fragmented files; allocate storage space A and storage space B on the user server; based on the Merkle tree, store the node relationships of the Merkle tree in storage space A, and store the hash value of the current node and the hash values ​​of its adjacent nodes at each node position in storage space A; store the fragmented files in storage space B, and return the address of the stored fragmented files to the corresponding node position in storage space A; and upload the data in storage space A and storage space B to the blockchain.

[0078] Step S3: Obtain process parameters for the data to be protected being accessed normally; define a binary logistic regression model for security monitoring based on the process parameters; construct a security monitoring model using the APPDRR model as a reference model and combining it with the binary logistic regression model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected.

[0079] Step S4: Monitor whether the data or file in the file to be protected has changed; if it has changed, synchronize the changed file to be protected to the blockchain; if it has not changed, continue monitoring.

[0080] Compared with the prior art, the beneficial effects of the present invention are:

[0081] Automated processing and real-time monitoring: This invention enables automated processing and real-time monitoring of financial data, improving work efficiency and the accuracy of data sharing. It can automatically identify and quickly summarize financial data, reducing the workload and error rate of manual operations. Simultaneously, it can monitor the company's financial status in real time and provide early warning functions. Through real-time analysis of financial data, the system can promptly detect anomalies such as abnormal access or hacker attacks, and automatically trigger alarms and reminders.

[0082] Enhanced security and reliability: This invention can identify and prevent potential security threats; in data sharing, this invention encrypts financial data based on data encryption and blockchain technology and stores it in the blockchain; in security monitoring, this invention uses machine learning to continuously optimize security strategies and improve defense capabilities.

[0083] Reduce labor costs: Traditional financial processing requires a large amount of manpower, which not only increases the company's operating costs but is also prone to human error; while this invention can automate most financial work, significantly reducing labor costs. Attached Figure Description

[0084] Other features, objects, and advantages of the invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0085] Figure 1 This is a schematic diagram of the system of the present invention;

[0086] Figure 2 This is a schematic diagram of the method of the present invention;

[0087] Figure 3 This is a schematic diagram of the Merkle tree of the present invention. Detailed Implementation

[0088] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0089] Example 1

[0090] Please see Figure 1 An artificial intelligence-based financial data sharing security monitoring system includes: a data acquisition module, a data sharing module, a security monitoring module, a continuous update module, a database, and a server; wherein the data acquisition module, data sharing module, security monitoring module, and continuous update module are respectively connected to the database and the server.

[0091] It should be noted that "financial data" is considered personal privacy and sensitive information.

[0092] This invention uses a "user-authorized scanning" method to obtain "financial data";

[0093] The implementation steps for the "user authorization scan" method are as follows:

[0094] Step 1: The user creates a folder named "Files to be Scanned" on the PC and configures the absolute path of the "Files to be Scanned" (folder) in "A Financial Data Sharing Security Monitoring System Based on Artificial Intelligence";

[0095] Step II: The user saves the "data or files that need to be protected by this invention" into the "files to be scanned" (folder) as the files to be protected;

[0096] Step 3: The "AI-based financial data sharing security monitoring system" automatically locates the "file to be scanned" (folder) using an absolute path, and then reads the data or files in the "file to be scanned" (folder) to obtain the file to be protected.

[0097] Data acquisition module: used to acquire data or files in the file (folder) to be scanned, to obtain the file to be protected; to encrypt the file to be protected with "decentralized attributes", to obtain the encrypted file; to split the encrypted file, to obtain fragmented files;

[0098] Process A: The workflow of the data acquisition module is as follows:

[0099] Process A1: Scan the data or files in the folder to be scanned to obtain the files to be protected;

[0100] Process A2: Encrypt the file to be protected using "decentralized attributes" to obtain the encrypted file;

[0101] Process A21: Use secure communication protocols such as TLS / SSL to establish an encrypted channel with an authoritative institution and obtain security parameters, denoted as λ;

[0102] It should be noted that the "authoritative body" in process A21 refers to the organization responsible for generating, distributing, and managing key system parameters (such as keys, access control policies, user attributes, etc.); these organizations include Certificate Authorities (CAs), Attribute Authorities (AAs), or other certified third-party service providers.

[0103] Process A22: Select Setup, KeyGen, Encrypt, Keycheck, Decrypt, and Trace algorithms as the base algorithms for "decentralized attribute" encryption;

[0104] Among them, the Setup algorithm, KeyGen algorithm, and Encrypt algorithm are used for encryption;

[0105] Keycheck, Decrypt, and Trace algorithms are used for decryption.

[0106] Process A23: Obtain user identity information; (The number of user identity information is ≥ 1, i.e., "multiple users manage one file to be protected")

[0107] Setup(λ) → (PK, MSK); Input security parameter λ, call the Setup algorithm, and output public key and master key; denote the public key as PK and the master key as MSK;

[0108] KeyGen(PK, MSK, user identity information) → (SK, ID); The public key PK, master key MSK, and user identity information are used as parameters for the KeyGen algorithm. The KeyGen algorithm is executed to generate the user's key and unique identifier, i.e., ID number; The key is denoted as SK;

[0109] Create an identity list and save the user's ID number;

[0110] It should be noted that the role of the "identity list" in process A23 is explained as follows:

[0111] In "decentralized attribute" encryption, the "ID number" indicates the user's ownership relationship with the file;

[0112] Example: User 1's files to be protected are: file a and file b; User 2's file to be protected is: file a (which is the same as User 1's file a);

[0113] Case 1: User 1 has two IDs, namely ID a1 ("File a" (left part) → "User 1" (right part)) and ID b1 ("File b" → "User 1");

[0114] Case II: User 2 has one ID number, namely ID number a2 ("File a" → "User 2");

[0115] Furthermore, since "files to be protected" in this invention refers to "data or files in files (folders) to be scanned", the number of "files to be protected" is ≥ 1;

[0116] If one person has n files to be protected, which falls under "Case I", then there are n "ID numbers".

[0117] Each "ID number" has the same right side but different left sides;

[0118] If m people each have one file to be protected, which falls under "Case II", then there are m "ID numbers".

[0119] Each "ID number" has the same left side but different right side;

[0120] In summary, whether it is "one person managing x files to be protected (Scenario I)" or "x people jointly managing one file to be protected (Scenario II)," there are x "ID numbers," and each "ID number" is different.

[0121] Process A24: Obtain the absolute path of the file to be protected as the storage path; use the RSA or ECC algorithm to generate the symmetric key of the file to be protected, and denot the symmetric key as ck;

[0122] Encrypt(PK, SK, ck, storage path) → (CT); The public key PK, the private key SK, the symmetric key ck, and the storage path (of the file to be protected) are used as inputs to the Encrypt algorithm. The Encrypt algorithm is executed to obtain attribute-based ciphertext, which is used as the encrypted file. The attribute-based ciphertext is denoted as CT.

[0123] Complete the encryption process for the file to be protected;

[0124] Process A25: Obtain the public key entered by the visitor, denoted as PK`; the private key entered by the visitor, denoted as SK`; the master key entered by the visitor, denoted as MSK`; and the ID number entered by the visitor, denoted as id`.

[0125] Keycheck(PK`, MSK`, SK`) → 0 or 1; PK`, MSK`, and SK` are used as parameters for the Keycheck algorithm. The Keycheck algorithm is executed to check whether PK`, MSK`, and SK` are consistent with the format of PK, MSK, and SK.

[0126] If they match, return 1 and proceed to process A26;

[0127] If there is a discrepancy, return 0, terminate the system (an AI-based financial data sharing security monitoring system), and immediately issue an alarm.

[0128] It should be noted that in process A25, "visitor" refers to the person who accesses the "file to be protected".

[0129] Process A26: Decrypt(PK`, SK`, SK`) → (ck, storage path); PK`, SK`, and SK` are used as inputs to the Decrypt algorithm. The Decrypt algorithm is executed to obtain the storage address of the file to be protected and the symmetric key ck; The storage address of the file to be protected and the symmetric key ck are temporarily stored in the computer cache (not output), and then proceed to process A27.

[0130] Process A27: Trace(MSK`, SK`) → (user ID); This will be used as input to the Trace algorithm, executing the Decrypt algorithm and outputting the user ID (corresponding to MSK and SK), denoted as Δid;

[0131] Use regular expressions to determine if Δid and id` are the same;

[0132] If they match, then use the symmetric key ck in the computer's cache to decrypt;

[0133] If there is a discrepancy, the system (an AI-based financial data sharing security monitoring system) will be terminated and an alarm will be triggered immediately.

[0134] It should be noted that the above "processes A25 to A27" will only be executed when the user or relevant technical personnel access the "file to be protected".

[0135] Process A3: Segment the encrypted file to obtain fragmented files;

[0136] Procedure A31: Use the os.path.getsize() function to get the size of the encrypted file, denoted as fs; count the number of user IDs in the identity list, denoted as pn; (Procedure A23)

[0137] Process A32: Calculate the number of file splits, denoted as n, where n = (pn) 4 ;

[0138] Use a PowerShell script to split an encrypted file into n parts, resulting in n fragment files; the size of each fragment file is (fs / n); where / represents division (quotient);

[0139] If (fs%n)≠0, then the size of the nth fragment file is: (fs / n)+(fs%n); where % represents modulo operation (remainder); the size of the 1st to (n-1)th fragment files is: (fs / n).

[0140] It should be noted that in process A32, the "number of file splits n" must be ≥ 64; (if the number of blocks in the blockchain is too small, the overall security of the blockchain will be reduced); if (pn) 4 If <64, then n = 64.

[0141] Data sharing module: This module constructs a Merkle tree based on fragmented files; allocates storage space A and storage space B on the user server; stores the node relationships of the Merkle tree in storage space A, with each node in storage space A storing its own hash value and the hash values ​​of its neighboring nodes; stores the fragmented files in storage space B and returns the address of the stored fragmented files to the corresponding node in storage space A; and uploads the data from storage spaces A and B to the blockchain.

[0142] Process B: Please refer to Figure 3 The workflow of the data sharing module is as follows: it is used to construct a Merkle tree based on fragmented files.

[0143] Process B1: Construct a Merkle tree based on the fragmented files;

[0144] Process B11: Define a set of fragmented files, denoted as F;

[0145] F{x1, x2 ~ x n}; where n represents the number of fragmented files, x1 to x n This represents the first to nth fragment files;

[0146] Process B12: Define the processing formula for the hash function B1: H i =Hash(x) i ); where i ranges from 1 to n; Hash() represents the hash function, x i H represents the i-th fragment file. i This represents the hash value of the i-th fragment file;

[0147] Define a set Ha, which includes x1 to x2. n Substituting into processing formula B1, we obtain the hash values ​​of the 1st to nth fragment files, denoted as H1, H2 to Hn. n And summarize them into set Ha; Ha{H1, H2 ~ H n};

[0148] Process B13: Construct the Merkle tree of the fragmented files to determine the unique identification information of the fragmented files;

[0149] Process B131: Group the fragmented files once; group x1 to x n Grouping by consecutive and adjacent indices yields the following groups: (x1, x2), (x3, x4), and so on, up to (x...). n-1 x n );

[0150] Count the number of groups in one operation, denoted as cn, where cn = n / 2;

[0151] Process B132: Define cn independent binary trees as first-order binary trees; assign hash values ​​H1 to H2 of the fragmented files. n As a leaf node of a first-order binary tree; call processing formula B1, according to (x1, x2), (x3, x4) ~ (x n-1 x n ) in the order of ) calculate the first-order hash value H corresponding to each group once. 1-1 H 1-2 ~H 1-cn ;

[0152] The first-order hash value H of the first primary group (x1, x2) 1-1 H 1-1 =Hash(H1, H2);

[0153] The first-order hash value H of the second first group (x3, x4) 1-2 H 1-2 =Hash(H3, H4);

[0154] And so on, the cnth first group (x n-1 x n The first-order hash value H) 1-cn H 1-cn =Hash(H n-1 H n );

[0155] Process B133: Transfer H 1-1 ~H 1-cn As the root node of a first-order binary tree;

[0156] Define an independent binary tree dn as a second-order binary tree; where dn represents the number of second-order binary trees, dn = cn / 2;

[0157] H 1-1 ~H 1-cn As a leaf node of a second-order binary tree, H 1-1 ~H 1-cn Grouping by consecutive and adjacent indices yields secondary grouping (H). 1-1 H 1-2 ), (H 1-3 H 1-4 )~(H 1-(cn-1) H 1-cn );

[0158] Repeat the process of calculating the first-order hash value in process B132, and calculate (H) 1-1 H 1-2 )~(H 1-(cn-1) H 1-cn The corresponding second-order hash value H) 2-1 ~H2-dn ;

[0159] Process B134: Count the number of second-order hash values, denoted as en; (where en = pn)

[0160] If they are equal, then the Merkle tree has been successfully constructed. Calculate the root node of the Merkle tree, denoted as Hr, where Hr = H 2-1 *H 2-d ;

[0161] If not equal, the Merkle tree construction fails. Check if en is even (2) and proceed to process B135.

[0162] Procedure B135: If en is even, then H 2-1 ~H 2-dn Using the format of consecutive and adjacent indices as even nodes, call the Merkle Tree generation function to construct a Merkle tree;

[0163] If en is not even, then H 2-1 ~H 2-(dn-1) Use consecutive and adjacent indices as even nodes; H 2-dn As an independent node, it calls the Merkle Tree generation function to construct a Merkle tree;

[0164] Process B2: Create two (blank) storage spaces on the (user's) local server (or cloud server), denoted as space A and space B;

[0165] Process B3: Mark the leaf nodes at the bottom of the Merkle tree as storage nodes (i.e., H1 to H2). n (Corresponding nodes); (In a Merkle tree, nodes that are not "storage nodes" are relation nodes;)

[0166] Using the pre-traversal algorithm, traverse all nodes (storage nodes and relation nodes) in the Merkle tree, store the hash values ​​of all nodes in the Merkle tree into space A in the order output by the pre-traversal algorithm, and return the address of the corresponding node in space A.

[0167] Process B4: Based on the Merkle tree and the address returned by process B3, store the hash values ​​of the adjacent nodes corresponding to the storage node and the relation node in space A;

[0168] Process B5; x1~x n Randomly stored in space B (i.e., x1 to x2 in space B) n The corresponding storage order does not necessarily have to be the same as x1 to x2. n (corresponding to the subscript);

[0169] In space b, read x1 to x2. n Store the address and index corresponding to the location, and assign them to x1 to x1. n The order of the storage location indices, from x1 to x n The address of the storage location is stored in the location corresponding to the index of the storage node in space A;

[0170] Process B6: Using the Flask and Requests libraries, create a blockchain and upload the data from Space A and Space B to the blockchain;

[0171] Set the data in Space A and Space B on the user's local server (or cloud server) to protected. (The data corresponding to "Space A and Space B" in the blockchain can be accessed, but the data corresponding to "Space A and Space B" on the user's local server (or cloud server) is inaccessible.)

[0172] Security monitoring module: used to obtain process parameters of the data to be protected being accessed normally; define the constraints of the binary logistic regression model for security monitoring based on the process parameters; construct the security monitoring model by using the APPDRR model as a reference model and combining it with the binary logistic regression model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected;

[0173] Process C: The workflow of the security monitoring module is as follows:

[0174] Process C1: Obtain the operation codes and operation addresses of all processes (threads) created by this system (an artificial intelligence-based financial data sharing security monitoring system) during the execution of all processes (processes A1 to A3 and processes B1 to B6) of the data acquisition module and data sharing module, and use them as process parameters for the normal access of the data to be protected.

[0175] Define a set YC to store all process parameters;

[0176] Process C2: Define the constraints of the binary logistic regression model for safety monitoring based on the set YC;

[0177] Process C21: When a visitor accesses data to be protected, the system creates a monitoring process.

[0178] Define sets BB1 and BB2 to store all opcodes and operation addresses in the monitoring process, respectively;

[0179] Procedure C22: Define the partial function Y (for the binary logistic regression model):

[0180] Y = 1, x ∈ YC; Y = 0,

[0181] Where x represents the input, i.e. (x∈BB1)∪(x∈BB2);

[0182] Procedure C23: Define the conditional probability distribution P(Y=1|x) or P(Y=0|x) (for the binary logistic regression model):

[0183]

[0184] Where exp represents the natural exponential function; ω represents the weight vector; b represents the bias; and ω*x represents the inner product of ω and x.

[0185] Procedure C24: Define the Logit function (P) for the binary logistic regression model:

[0186]

[0187]

[0188] In Logit(P), P represents either P(Y = 1|x) or P(Y = 0|x);

[0189] Process C3: Using the APPDRR model as a reference model and combining it with a binary logistic regression model to construct a safety monitoring model;

[0190] Process C4: Deploy the security monitoring model to the blockchain storage space to protect the data to be protected.

[0191] Continuous update module: Used to monitor whether the data or files in the file to be protected have changed; if they have changed, the changed file to be protected is synchronized to the blockchain; if they have not changed, monitoring continues.

[0192] Example 2

[0193] Please see Figure 2 An artificial intelligence-based method for monitoring the security of shared financial data includes:

[0194] Step S1: Obtain the data or files in the file (folder) to be scanned to obtain the file to be protected; encrypt the file to be protected with "decentralized attributes" to obtain the encrypted file; split the encrypted file to obtain fragmented files;

[0195] Step S2: Construct a Merkle tree based on the fragmented files; allocate storage space A and storage space B on the user server; based on the Merkle tree, store the node relationships of the Merkle tree in storage space A, and store the hash value of the current node and the hash values ​​of its adjacent nodes at each node position in storage space A; store the fragmented files in storage space B, and return the address of the stored fragmented files to the corresponding node position in storage space A; and upload the data in storage space A and storage space B to the blockchain.

[0196] Step S3: Obtain process parameters for the data to be protected being accessed normally; define the constraints of the binary logistic regression model for security monitoring based on the process parameters; construct the security monitoring model using the APPDRR model as a reference model and in combination with the binary logistic regression model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected.

[0197] Step S4: Monitor whether the data or file in the file to be protected has changed; if it has changed, synchronize the changed file to be protected to the blockchain; if it has not changed, continue monitoring.

[0198] The above formulas are all dimensionless calculations. The formulas are derived from software simulations using a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation. For example, there are weighting coefficients and proportional coefficients. The values ​​set are to quantify each parameter to obtain a specific value, which is convenient for subsequent comparison. The values ​​of the weighting coefficients and proportional coefficients are only required to not affect the proportional relationship between the parameters and the quantified values.

[0199] Finally, it should be noted that the above-described embodiments are merely specific implementations of the present invention, used to illustrate the technical solutions of the present invention, and not to limit it. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the technical scope disclosed in the present invention, or make equivalent substitutions for some of the technical features; and these modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A financial data sharing security monitoring system based on artificial intelligence, characterized in that, The system includes: Data acquisition module: used to acquire data or files from the file to be scanned to obtain the file to be protected; to perform decentralized attribute encryption on the file to be protected to obtain the encrypted file; and to perform segmentation processing on the encrypted file to obtain fragmented files; Data sharing module: This module constructs a Merkle tree based on fragmented files; allocates storage space A and storage space B on the local server; stores the node relationships of the Merkle tree in storage space A, with each node in storage space A storing its own hash value and the hash values ​​of its neighboring nodes; stores the fragmented files in storage space B and returns the address of the stored fragmented files to the corresponding node in storage space A; and uploads the data from storage spaces A and B to the blockchain. Security monitoring module: used to obtain process parameters of the data to be protected being accessed normally; based on the process parameters, define a binary logistic regression model for security monitoring; use the APPDRR model as a reference model and combine it with the binary logistic regression model to construct a security monitoring model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected; Continuous update module: Used to monitor whether the data or files in the file to be protected have changed; if changed, the changed file to be protected is synchronized to the blockchain; if not changed, monitoring continues. The workflow of the data acquisition module is as follows: Process A1: Scan the data or files in the file to be scanned to obtain the file to be protected; Process A2: Encrypt the file to be protected to obtain an encrypted file; Process A3: Obtain the user's identity information and split the encrypted file to obtain fragmented files; Process A31: Use the os.path.getsize() function to get the size of the encrypted file, denoted as fs; count the number of identity information entries, denoted as pn; Procedure A32: Calculate the number of splits of the file, denoted as n, n = (pn) 4 ; Use a PowerShell script to split the encrypted file into n parts, resulting in n fragment files; the size of each fragment file is fs / n; where / represents a division operation; If fs%n≠0, then the size of the nth fragment file is: (fs / n) + (fs%n); where % represents modulo operation; the size of the 1st to the (n-1)th fragment file is: fs / n; Summarize the fragmented files from the 1st to the nth and proceed to the data sharing module.

2. The financial data sharing security monitoring system based on artificial intelligence according to claim 1, characterized in that, The specific process of process A2 is as follows: Process A21: Use the TLS / SSL secure communication protocol to establish an encrypted channel with an authoritative institution and obtain security parameters, denoted as λ; Process A22: Select Setup, KeyGen, and Encrypt algorithms as the foundational algorithms for decentralized encryption; Process A23: Obtain the user's identity information; Setup(λ) → (PK, MSK); Input security parameter λ, call the Setup algorithm, and output public key and master key; denote the public key as PK and the master key as MSK; KeyGen(PK, MSK, user identity information) → (SK, ID); The public key PK, master key MSK, and user identity information are used as parameters for the KeyGen algorithm. The KeyGen algorithm is executed to generate the user's key and unique identifier, i.e., ID number. The key is denoted as SK; Create an identity list and save the user's ID number; Process A24: Obtain the absolute path of the file to be protected as the storage path; use the RSA or ECC algorithm to generate the symmetric key of the file to be protected, and denot the symmetric key as ck; Encrypt(PK, SK, ck, storage path) → (CT); The public key PK, the private key SK, the symmetric key ck, and the storage path are used as inputs to the Encrypt algorithm. The Encrypt algorithm is executed to obtain attribute-based ciphertext, which is used as the encrypted file. The attribute-based ciphertext is denoted as CT; the encryption process of the file to be protected is completed.

3. The financial data sharing security monitoring system based on artificial intelligence according to claim 1, characterized in that, The workflow of the data sharing module is as follows: it is used to construct a Merkle tree based on the fragmented files. Process B1: Construct a Merkle tree based on the fragmented files; Process B11: Define the first to nth fragment files x1 to x n The set F; Process B12: define the hash function H i = Hash(x i ); where i ranges from 1 to n; Hash() represents a hash function, x i represents the i-th fragment file, H i represents the hash value of the i-th fragment file; Define a set Ha, which includes x1 to x2. n Substituting into processing formula B1, we obtain the hash values ​​of the 1st to nth fragment files, denoted as H1, H2 to Hn. n And summarize them into set Ha; Ha{H1, H2 ~ H n }; Process B13: Construct the Merkle tree of the fragmented files to determine the unique identification information of the fragmented files; Process B2: On the local server, create two storage spaces, denoted as storage space A and storage space B; Process B3: Mark the leaf nodes at the bottom of the Merkle tree as storage nodes; Using the pre-traversal algorithm, traverse all nodes in the Merkle tree, store the hash values ​​of all nodes in the Merkle tree into storage space A in the order output by the pre-traversal algorithm, and return the address of the corresponding node in storage space A. Process B4: Based on the Merkle tree and the address returned by process B3, store the hash values ​​of the adjacent nodes corresponding to the storage node and the relation node in storage space A; Process B5; x1~x n Randomly stored in storage space B; In storage space B, read x1 to x2. n Store the address and index corresponding to the location, and assign them to x1 to x1. n The order of the storage location indices, from x1 to x n The address of the storage location is stored in the location corresponding to the index of the storage node in storage space A; Process B6: Using the Flask and Requests libraries, create a blockchain and upload the data from storage space A and storage space B to the blockchain; Set the data in storage space A and storage space B on the local server to be protected, and then enter the security monitoring module.

4. The financial data sharing security monitoring system based on artificial intelligence according to claim 3, characterized in that, The specific process of process B13 is as follows: Process B131: Group the fragmented files once; group x1 to x n Grouping by consecutive and adjacent indices yields a first group (x1, x2), (x3, x4) ~ (x... n-1 x n ); Count the number of groups in one operation, denoted as cn, where cn = n / 2; Process B132: Define cn independent binary trees as first-order binary trees; The hash values ​​H1 to H2 of the fragmented files are used to... n As a leaf node of a first-order binary tree; call processing formula B1, according to (x1, x2), (x3, x4) ~ (x n-1 x n ) in the order of ) calculate the first-order hash value H corresponding to each group once. 1-1 H 1-2 ~H 1-cn ; The first-order hash value H of the first group (x1, x2) 1-1 H 1-1 =Hash(H1, H2); The first-order hash value H of the second primary group (x3, x4) 1-2 H 1-2 =Hash(H3, H4); And so on, the cnth first group (x n-1 x n The first-order hash value H) 1-cn H 1-cn =Hash(H n-1 H n ); Process B133: Transfer H 1-1 ~H 1-cn As the root node of a first-order binary tree; Define dn independent binary trees as a second-order binary tree; where dn represents the number of second-order binary trees, dn = cn / 2; H 1-1 ~H 1-cn As a leaf node of a second-order binary tree, H 1-1 ~H 1-cn Grouping by consecutive and adjacent indices yields secondary grouping (H). 1-1 H 1-2 ), (H) 1-3 H 1-4 )~(H 1-(cn-1) H 1-cn ); Repeat the process of calculating the first-order hash value in process B132, and calculate (H) 1-1 H 1-2 )~(H 1-(cn-1) H 1-cn The corresponding second-order hash value H) 2-1 ~H 2-dn ; Process B134: Count the number of second-order hash values, denoted as en; If they are equal, then the Merkle tree has been successfully constructed. Calculate the root node of the Merkle tree, denoted as Hr, where Hr = H 2-1 *H 2-d ; If not equal, the Merkle tree construction fails. Check if en is even (2) and proceed to process B135. Procedure B135: If en is even, then H 2-1 ~H 2-dn Using the format of consecutive and adjacent indices as even nodes, call the Merkle Tree generation function to construct a Merkle tree; If en is not even, then H 2-1 ~H 2-（dn-1） Use consecutive and adjacent indices as even nodes; H 2-dn As an independent node, it calls the Merkle Tree generation function to construct a Merkle tree.

5. The financial data sharing security monitoring system based on artificial intelligence according to claim 3, characterized in that, The workflow of the security monitoring module is as follows: Process C1: Obtain the operation codes and operation addresses of all processes created by this system during the execution of the data acquisition module and the data sharing module, and use them as process parameters for the data to be protected to be accessed normally; Define a set YC to store all process parameters; Process C2: Define the constraints of the binary logistic regression model for safety monitoring based on the set YC; Process C3: Using the APPDRR model as a reference model and combining it with a binary logistic regression model to construct a safety monitoring model; Process C4: Deploy the security monitoring model to the blockchain storage space to protect the data to be protected.

6. The financial data sharing security monitoring system based on artificial intelligence according to claim 5, characterized in that, The specific process of process C2 is as follows: Process C21: When a visitor accesses data to be protected, the system creates a monitoring process. Define sets BB1 and BB2 to store all opcodes and operation addresses in the monitoring process, respectively; Procedure C22: Define the distribution function Y: Y=1, x∈YC; Y=0, x∉YC; Where x represents the input, i.e. (x∈BB1)∪(x∈BB2); Procedure C23: Define the conditional probability distribution P(Y=1|x) or P(Y=0|x): ； ； Where exp represents the natural exponential function; ω represents the weight vector; b represents the bias; and ω*x represents the inner product of ω and x. Process C24: Define the Logit function Logit(P): ； ； In Logit(P), P represents either P(Y = 1|x) or P(Y = 0|x).

7. A method for monitoring the security of financial data sharing based on artificial intelligence, applicable to the financial data sharing security monitoring system based on artificial intelligence as described in any one of claims 1-6, characterized in that, The method includes: Step S1: Obtain data or files from the file to be scanned to obtain the file to be protected; perform decentralized attribute encryption on the file to be protected to obtain the encrypted file; split the encrypted file to obtain fragmented files; Step S2: Construct a Merkle tree based on the fragmented files; allocate storage space A and storage space B on the local server; based on the Merkle tree, store the node relationships of the Merkle tree in storage space A, and store the hash value of the current node and the hash values ​​of its adjacent nodes at each node position in storage space A; store the fragmented files in storage space B, and return the address of the stored fragmented files to the corresponding node position in storage space A; and upload the data in storage space A and storage space B to the blockchain. Step S3: Obtain process parameters for the data to be protected being accessed normally; define a binary logistic regression model for security monitoring based on the process parameters; construct a security monitoring model using the APPDRR model as a reference model and combining it with the binary logistic regression model; deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected. Step S4: Monitor whether the data or file in the file to be protected has changed; if it has changed, synchronize the changed file to be protected to the blockchain; if it has not changed, continue monitoring.

Images