Financial data sharing safety monitoring system and method based on artificial intelligence

Abstract

The invention provides a financial data sharing safety monitoring system and method based on artificial intelligence, and belongs to the field of data safety. The problem of low financial data sharing efficiency is solved; the system is characterized in that a data acquisition module acquires a to-be-protected file; encrypting and segmenting the to-be-protected file to obtain a fragment file; the data sharing module constructs a Merkle tree according to the fragmented files, saves the fragmented files according to the Merkle tree, and uploads the fragmented files to a block chain; the safety monitoring module defines a binary logic regression model for safety monitoring, constructs a safety monitoring model by taking the APPDRR model as a reference model, and protects to-be-protected data; the continuous updating module monitors whether data in the to-be-protected file is changed or not; if the to-be-protected file is changed, synchronizing the changed to-be-protected file to the block chain; if not, continuing to monitor; according to the method, the financial data are encrypted, segmented, stored and monitored, so that the financial data can be accessed by the user more comprehensively and safely, and the integrity and safety of the financial data are guaranteed.

Description

Technical Field

[0001] The present invention discloses a financial data sharing security monitoring system and method based on artificial intelligence, and relates to the field of data sharing. Background Art

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

[0003] Data processing and accuracy issues: Although the existing financial data sharing system has powerful data processing and analysis capabilities, its data processing efficiency and accuracy are still affected by the amount of data and the amount of local data loaded; if the complete input data volume or the single input data volume exceeds the data storage range of the existing system, the existing system will not be able to recognize and process the data, resulting in deviations or errors in the data sharing process or security monitoring process.

[0004] Security risks and hazards: Existing systems may be attacked by hackers or malware, leading to data leakage or system failure. In addition, the algorithms and models of existing systems may have biases or loopholes, thus affecting the results of data analysis and processing.

[0005] Dependency and technology updates: Existing systems are highly dependent; however, with the continuous development and upgrading of technology, existing systems are gradually becoming outdated or unable to meet new needs. Enterprises need to continue to pay attention to technological development trends and market changes, and establish professional technical teams or partnerships to support the continuous operation and maintenance of the system. Summary of the invention

[0006] In view of the shortcomings of the prior art, the purpose of the present invention is to provide a financial data sharing security monitoring system and method based on artificial intelligence, aiming to solve the problems of low efficiency and insecurity of financial data sharing.

[0007] In order to achieve the above object, the present invention is implemented through the following technical solutions: A financial data sharing security monitoring system and method based on artificial intelligence includes:

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

[0009] Data acquisition module: used to acquire data or files in 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 an encrypted file; to perform segmentation processing on the encrypted file to obtain fragmented files;

[0010] Data sharing module: used to build a Merkle tree based on fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node at each node position in storage space A; store fragmented files in storage space B, and return the address of the stored fragmented files to the position of the corresponding node in storage space A; and upload the data in storage space A and storage space B to the blockchain;

[0011] Security monitoring module: used to obtain the process parameters of the normal access to the protected data; define the binary logistic regression model of security monitoring based on the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring model; deploy the security monitoring model to the storage space of the blockchain to protect the protected data;

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

[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 the encrypted file;

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

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

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

[0019] Use PowerShell script to split the encrypted file into n pieces, and get n pieces of fragmented files; the size of each fragmented file is (fs / n); where / represents division operation;

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

[0021] Summarize the 1st to nth fragment files and enter 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 the authority and obtain security parameters, denoted as λ;

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

[0025] Process A23: Obtaining user identity information;

[0026] Setup(λ)→(PK, MSK); input security parameter λ, call Setup algorithm, 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); use the public key PK, master key MSK and user identity information as the parameters of the KeyGen algorithm, execute the KeyGen algorithm, generate the user's key and unique identifier, that is, the ID number; record the key as SK;

[0028] Create an identity list to 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 algorithm or the ECC algorithm to generate a symmetric key for the file to be protected, and record the symmetric key as ck;

[0030] Encrypt(PK, SK, ck, storage path)→(CT); take the public key PK, the secret key SK, the symmetric key ck and the storage path as the input of the Encrypt algorithm, execute the Encrypt algorithm, and obtain the attribute-based ciphertext as the encrypted file; record the attribute-based ciphertext as CT; and complete the encryption process of the file to be protected.

[0031] Furthermore, the workflow of the data sharing module is as follows: used to construct a Merkle tree according to the fragment files,

[0032] Process B1: Build a Merkle tree based on the fragment file;

[0033] Process B2: Create two storage spaces in the local server, denoted as Space A and Space B;

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

[0035] Use the forward traversal algorithm to 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 forward traversal algorithm, and return the address of the corresponding node in space A;

[0036] Process B4: According to the Merkle tree and the address returned by process B3, the hash values ​​of the adjacent nodes corresponding to the storage node and the relationship node are stored in space A;

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

[0038] In space b, read x1~x n The address and subscript corresponding to the storage location, and press x1~x n The order of the storage position subscripts is x1 to x n The address of the storage location is stored in the location corresponding to the storage node index in space A;

[0039] Process B6: Use the Flask library and the Requests library to create a blockchain and upload the data in Space A and Space B to the blockchain;

[0040] Set the data in Space A and Space B in the user's local server to protection and enter the security monitoring module.

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

[0042] Process B131: Group the fragmented files; n Group by the format of consecutive and adjacent subscripts, and get a group (x1, x2), (x3, x4) ~ (x n-1 , x n );

[0043] Count the number of groups at a time, recorded as cn, cn = n / 2;

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

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

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

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

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

[0049] Define dn independent binary trees as second-order binary trees; 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 the second-order binary tree, H 1-1 ~H 1-cn Group by the format of continuous and adjacent subscripts to obtain the 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 to calculate (H 1-1 , H 1-2 )~(H 1-(cn-1) , H 1-cn ) corresponds to the second-order hash value H 2-1 ~H 2-dn ;

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

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

[0054] If not, the Merkle tree construction fails, and it is determined whether en is an even number 2, and the process goes to process B135;

[0055] Process B135: If en is an even number, then H 2-1 ~H 2-dn In the format where the subscripts are continuous and adjacent, as even nodes, the Merkle Tree generation function is called to construct the Merkle tree;

[0056] If en is not an even number, then H 2-1 ~H 2-(dn-1) In the format where the subscripts are continuous and adjacent, it is treated as an even node; H 2-dn As an independent node, call the Merkle Tree generation function to build a Merkle tree.

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

[0058] Process C1: Obtain the operation codes and operation addresses of all processes created by the system during the execution of the entire process of the data acquisition module and the data sharing module as process parameters for normal access to the protected data;

[0059] Define the set YC to save all process parameters;

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

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

[0062] Process C4: Deploy the security monitoring model to the storage space of the blockchain 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 the data to be protected, the system creates a monitoring process;

[0065] Define set BB1 and set BB2 to store all operation codes and operation addresses in the monitoring process respectively;

[0066] Process C22: Define partial function Y:

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

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

[0069] Process 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; ω*x represents the inner product of ω and x;

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

[0073]

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

[0075] A financial data sharing security monitoring method based on artificial intelligence includes:

[0076] Step S1: obtaining data or files in the file to be scanned to obtain the file to be protected; performing decentralized attribute encryption on the file to be protected to obtain an encrypted file; performing segmentation processing on the encrypted file to obtain fragmented files;

[0077] Step S2: construct a Merkle tree based on the fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node 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 position of the corresponding node in storage space A; and upload the data in storage space A and storage space B to the blockchain;

[0078] Step S3: Obtain the process parameters of the data to be protected being normally accessed; define the binary logistic regression model of security monitoring according to the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring 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 changed, synchronize the changed file to be protected to the blockchain; if not changed, continue monitoring.

[0080] Compared with the prior art, the present invention has the following beneficial effects:

[0081] Automated processing and real-time monitoring: The present invention can realize automated processing and real-time monitoring of financial data, improve work efficiency and the accuracy of data sharing. The present invention can automatically identify financial data, quickly summarize it, and reduce the workload and error rate of manual operations; at the same time, the present invention can monitor the financial status of the enterprise in real time and provide early warning functions; through real-time analysis of financial data, the system can promptly detect abnormal situations such as abnormal access, hacker attacks, etc., and automatically trigger alarms and reminders.

[0082] Improved security and reliability: The present invention can identify and prevent potential security threats. In data sharing, the present invention encrypts financial data based on data encryption and blockchain technology and saves it in the blockchain. In security monitoring, the present invention continuously optimizes security strategies and improves defense capabilities based on machine learning.

[0083] Reduce labor costs: Traditional financial processing requires a lot of manpower input, which not only increases the operating costs of the enterprise, but is also prone to human errors; the present invention can automatically process most financial work, significantly reducing labor costs. BRIEF DESCRIPTION OF THE DRAWINGS

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

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

[0086] Figure 2 It 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 DESCRIPTION

[0088] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the present invention is further described in detail below with reference to the accompanying drawings and specific embodiments.

[0089] Embodiment 1

[0090] See also Figure 1 A financial data sharing security monitoring system based on artificial intelligence 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, the data sharing module, the security monitoring module and the continuous update module are connected to the database and the server respectively.

[0091] It should be noted that because "financial data" is personal privacy and also sensitive information,

[0092] The present invention uses the method of "user authorized scanning" to obtain "financial data";

[0093] The implementation steps of the "User Authorization Scan" method are as follows:

[0094] Step Ⅰ: 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 stores the "data or files to be protected by the present invention" in the "files to be scanned" (folder) as files to be protected;

[0096] Step III: "A financial data sharing security monitoring system based on artificial intelligence" automatically searches for "files to be scanned" (folders) through absolute paths, and then reads the data or files in the "files to be scanned" (folders) to obtain files 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; encrypt the file to be protected with "decentralized attributes" to obtain an encrypted file; 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 file (folder) to be scanned to obtain the file to be protected;

[0100] Process A2: Encrypt the file to be protected using the “decentralized attribute” to obtain the encrypted file;

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

[0102] It should be noted that the "authority" 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 (CA), attribute authorities (AA) or other certified third-party service providers.

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

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

[0105] Keycheck algorithm, Decrypt algorithm and Trace algorithm are used for decryption;

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

[0107] Setup(λ)→(PK, MSK); input security parameter λ, call Setup algorithm, 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); use the public key PK, master key MSK and user identity information as the parameters of the KeyGen algorithm, execute the KeyGen algorithm, generate the user's key and unique identifier, that is, the ID number; record the key as SK;

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

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

[0111] The “ID number” in the “decentralized attribute” encryption indicates the subordinate relationship between the user and the file;

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

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

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

[0115] Since the "file to be protected" in the present invention means "data or files in the file (folder) to be scanned", the number of "files to be protected" is ≥ 1;

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

[0117] Each "ID number" has the same right part and different left part;

[0118] If m persons have one file to be protected, it belongs to "Case II" and there are m "ID numbers";

[0119] Each "ID number" has the same left part and a different right part;

[0120] To sum up, whether "one person manages x files to be protected (case I)" or "x people jointly manage one file to be protected (case 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 algorithm or the ECC algorithm to generate a symmetric key for the file to be protected, and record the symmetric key as ck;

[0122] Encrypt(PK, SK, ck, storage path) → (CT); take the public key PK, the secret key SK, the symmetric key ck and the storage path (of the file to be protected) as the input of the Encrypt algorithm, execute the Encrypt algorithm, and obtain the attribute base ciphertext as the encrypted file; record the attribute base ciphertext as CT;

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

[0124] Process A25: Get the public key entered by the visitor, recorded as PK`; the secret key entered by the visitor, recorded as SK`; the master key entered by the visitor, recorded as MSK`; the ID number entered by the visitor, recorded as id`;

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

[0126] If they are consistent, return 1 and enter process A26;

[0127] If they are inconsistent, it returns 0, terminates the system (a financial data sharing security monitoring system based on artificial intelligence), and immediately issues an alarm;

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

[0129] Process A26: Decrypt(PK`, SK`, SK`)→(ck, storage path); use PK`, SK` and SK` as the input of the Decrypt algorithm, execute the Decrypt algorithm, and obtain the storage address of the file to be protected and the symmetric key ck; temporarily store the storage address of the file to be protected and the symmetric key ck in the computer cache (not output), and enter process A27;

[0130] Process A27: Trace(MSK`, SK`) → (user ID number); use it as the input of the Trace algorithm, execute the Decrypt algorithm, and output the user ID number (corresponding to MSK and SK), recorded as Δid;

[0131] Use regular expressions to determine whether Δid is consistent with id`;

[0132] If they match, the symmetric key ck in the computer cache is used for decryption;

[0133] If there is any inconsistency, the system (an artificial intelligence-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-mentioned "Process A25 to Process A27" will only be executed when the user or relevant technical personnel access the "file to be protected".

[0135] Process A3: Split the encrypted file into fragments;

[0136] Process A31: Use the os.path.getsize() function to obtain the size of the encrypted file, recorded as fs; count the number of user ID numbers in the identity list, recorded as pn; (Process A23)

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

[0138] Use PowerShell script to split the encrypted file into n pieces, and get n pieces of fragmented files; the size of each fragmented file is (fs / n); where / represents division operation (taking the quotient);

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

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

[0141] Data sharing module: used to build a Merkle tree based on fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node at each node position in storage space A; store fragmented files in storage space B, and return the address of the stored fragmented files to the position of the corresponding node in storage space A; and upload the data in storage space A and storage space 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 build a Merkle tree based on the fragment file,

[0143] Process B1: Build a Merkle tree based on the fragment file;

[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~x n Indicates the 1st to nth fragment files;

[0146] Process B12: Define the hash function processing formula B1: 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;

[0147] Define a set Ha, and set x1 to x n Substitute into the processing formula B1 to obtain the hash values ​​of the 1st to nth fragment files, denoted as H1, H2~H n , and summarized into the set Ha; Ha{H1, H2~H n};

[0148] Process B13: construct a Merkle tree of the fragment file to determine the unique identification information of the fragment file;

[0149] Process B131: Group the fragmented files; n Group by the format of consecutive and adjacent subscripts, and get a group (x1, x2), (x3, x4) ~ (x n-1 , x n );

[0150] Count the number of groups at a time, recorded as cn, cn = n / 2;

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

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

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

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

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

[0156] Define dn independent binary trees as second-order binary trees; 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 the second-order binary tree, H 1-1 ~H 1-cn Group by the format of continuous and adjacent subscripts to obtain the 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 to calculate (H 1-1 , H 1-2 )~(H 1-(cn-1) , H 1-cn ) corresponds to the 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, the Merkle tree is constructed successfully. Calculate the root node of the Merkle tree, denoted as Hr, Hr = H 2-1 *H 2-d ;

[0161] If not, the Merkle tree construction fails, and it is determined whether en is an even number 2, and the process goes to process B135;

[0162] Process B135: If en is an even number, then H 2-1 ~H 2-dn In the format where the subscripts are continuous and adjacent, as even nodes, the Merkle Tree generation function is called to construct the Merkle tree;

[0163] If en is not an even number, then H 2-1 ~H 2-(dn-1) In the format where the subscripts are continuous and adjacent, it is treated as an even node; H 2-dn As an independent node, call the Merkle Tree generation function to build a Merkle tree;

[0164] Process B2: Create two (blank) storage spaces in the (user) 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~H n corresponding nodes); (Nodes other than "storage nodes" in the Merkle tree are relationship nodes;)

[0166] Use the forward traversal algorithm to traverse all nodes in the Merkle tree (storage nodes and relationship nodes), store the hash values ​​of all nodes in the Merkle tree into space A in the order output by the forward traversal algorithm, and return the address of the corresponding node in space A;

[0167] Process B4: According to the Merkle tree and the address returned by process B3, the hash values ​​of the adjacent nodes corresponding to the storage node and the relationship node are stored in space A;

[0168] Process B5: x1~x n Randomly store in space B (i.e. x1~x n The corresponding storage position order does not have to be the same as x1~x n );

[0169] In space b, read x1~x n The address and subscript corresponding to the storage location, and press x1~x n The order of the storage position subscripts is x1 to x n The address of the storage location is stored in the location corresponding to the storage node index in space A;

[0170] Process B6: Use the Flask library and the Requests library to create a blockchain and upload the data in Space A and Space B to the blockchain;

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

[0172] Security monitoring module: used to obtain the process parameters for normal access to the protected data; define the constraints of the binary logistic regression model for security monitoring based on the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring model; deploy the security monitoring model to the storage space of the blockchain to protect the protected data;

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

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

[0175] Define the set YC to save all process parameters;

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

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

[0178] Define set BB1 and set BB2 to store all operation codes and operation addresses in the monitoring process respectively;

[0179] Process C22: Define the partial function Y (of 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] Process C23: Define the conditional probability distribution (of the binary logistic regression model) P(Y=1|x) or P(Y=0|x):

[0183]

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

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

[0186]

[0187]

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

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

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

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

[0192] Embodiment 2

[0193] See also Figure 2 , a financial data sharing security monitoring method based on artificial intelligence includes:

[0194] Step S1: obtaining data or files in the file (folder) to be scanned to obtain the file to be protected; encrypting the file to be protected with "decentralized attributes" to obtain an encrypted file; and segmenting the encrypted file to obtain fragmented files;

[0195] Step S2: construct a Merkle tree based on the fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node 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 position of the corresponding node in storage space A; and upload the data in storage space A and storage space B to the blockchain;

[0196] Step S3: Obtain the process parameters of the data to be protected that are normally accessed; define the constraint conditions of the binary logistic regression model of security monitoring according to the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring 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 changed, synchronize the changed file to be protected to the blockchain; if not changed, continue monitoring.

[0198] The above formulas are all dimensionless and numerical calculations. The formula is a formula for the most recent real situation obtained by collecting a large amount of data and performing software simulation. The preset parameters in the formula are set by technical personnel in this field according to actual conditions. For example, if there are weight coefficients and proportional coefficients, their set sizes are to quantify each parameter to obtain a specific value, which is convenient for subsequent comparison. Regarding the size of the weight coefficient and the proportional coefficient, it is sufficient as long as it does not affect the proportional relationship between the parameter and the quantized value.

[0199] Finally, it should be noted that the above-described embodiments are only specific implementations of the present invention, which are used to illustrate the technical solutions of the present invention, rather than to limit them. The protection scope of the present invention is not limited thereto. Although the present invention is described in detail with reference to the above-described embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above-described embodiments within the technical scope disclosed by the present invention, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention shall be based on the protection scope of the claims.

Claims

1. A financial data sharing security monitoring system based on artificial intelligence, characterized in that: The system comprises: Data acquisition module: used to acquire data or files in 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 an encrypted file; to perform segmentation processing on the encrypted file to obtain fragmented files; Data sharing module: used to build a Merkle tree based on fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node at each node position in storage space A; store fragmented files in storage space B, and return the address of the stored fragmented files to the position of the corresponding node in storage space A; and upload the data in storage space A and storage space B to the blockchain; Security monitoring module: used to obtain the process parameters of the normal access to the protected data; define the binary logistic regression model of security monitoring based on the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring model; deploy the security monitoring model to the storage space of the blockchain to protect the protected data; Continuous update module: used to monitor whether the data or files in the protected file have changed; if changed, the changed protected file will be synchronized to the blockchain; if not changed, continue monitoring.

2. According to claim 1, a financial data sharing security monitoring system based on artificial intelligence is characterized in that: 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 the encrypted file; Process A3: Obtain the user's identity information and split the encrypted file into fragmented files; Process A31: Use the os.path.getsize() function to obtain the size of the encrypted file, recorded as fs; count the number of identity information, recorded as pn; Process A32: Calculate the number of file splits, denoted as n, n = (pn) 4 ; Use PowerShell script to split the encrypted file into n pieces and get n pieces of fragmented files; The size of each fragment file is (fs / n); where / represents division operation; If (fs%n)≠0, the size of the nth fragment file is: (fs / n)+(fs%n), where % represents the modulo operation; the size of the 1st to (n-1)th fragment files is: (fs / n); Summarize the 1st to nth fragment files and enter the data sharing module.

3. According to claim 2, a financial data sharing security monitoring system based on artificial intelligence is characterized in that: The specific process of process A2 is as follows: Process A21: Use secure communication protocols such as TLS / SSL to establish an encrypted channel with the authority and obtain security parameters, denoted as λ; Process A22: Select the Setup algorithm, KeyGen algorithm, and Encrypt algorithm as the basic algorithms for decentralized encryption; Process A23: Obtaining user identity information; Setup(λ)→(PK, MSK); input security parameter λ, call Setup algorithm, output public key and master key; record the public key as PK and the master key as MSK; KeyGen (PK, MSK, user identity information) → (SK, ID); use the public key PK, master key MSK and user identity information as parameters of the KeyGen algorithm, execute the KeyGen algorithm, and generate the user's key and unique identifier, that is, the ID number; The key is denoted as SK; Create an identity list to 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 algorithm or the ECC algorithm to generate a symmetric key for the file to be protected, and record the symmetric key as ck; Encrypt(PK, SK, ck, storage path)→(CT); take the public key PK, the secret key SK, the symmetric key ck and the storage path as the input of the Encrypt algorithm, execute the Encrypt algorithm, and obtain the attribute-based ciphertext as the encrypted file; record the attribute-based ciphertext as CT; and complete the encryption process of the file to be protected.

4. According to claim 2, a financial data sharing security monitoring system based on artificial intelligence is characterized in that: The workflow of the data sharing module is as follows: It is used to build a Merkle tree based on the fragment file. Process B1: Build a Merkle tree based on the fragment file; Process B2: Create two storage spaces in the local server, denoted as Space A and Space B; Process B3: Mark the leaf node at the bottom of the Merkle tree as a storage node; Use the forward traversal algorithm to 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 forward traversal algorithm, and return the address of the corresponding node in space A; Process B4: According to the Merkle tree and the address returned by process B3, the hash values ​​of the adjacent nodes corresponding to the storage node and the relationship node are stored in space A; Process B5; x1~x n Randomly store in space B; In space b, read x1~x n The address and subscript corresponding to the storage location, and press x1~x n The order of the storage position subscripts is x1 to x n The address of the storage location is stored in the location corresponding to the storage node index in space A; Process B6: Use the Flask library and the Requests library to create a blockchain and upload the data in Space A and Space B to the blockchain; Set the data in Space A and Space B in the user's local server to protection and enter the security monitoring module.

5. The financial data sharing security monitoring system based on artificial intelligence according to claim 4 is characterized in that: The specific process of process B13 is as follows: Process B131: Group the fragmented files; n Group by the format of consecutive and adjacent subscripts, and get a group (x1, x2), (x3, x4) ~ (x n-1 , x n ); Count the number of groups at a time, recorded as cn, cn = n / 2; Process B132: Define cn independent binary trees as first-order binary trees; The hash values ​​of the fragmented files H1~H n , as the leaf node of the first-order binary tree; call processing formula B1, according to (x1, x2), (x3, x4) ~ (x n-1 , x n ) in order, and calculate the first-order hash value H corresponding to each group in turn. 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 group (x3, x4) 1-2 , H 1-2 =Hash(H3,H4); And so on, the cnth group (x n-1 , x n )’s first-order hash value H 1-cn , H 1-cn =Hash(H n-1 , H n ); Process B133: H 1-1 ~H 1-cn As the root node of a first-order binary tree; Define dn independent binary trees as second-order binary trees; where dn represents the number of second-order binary trees, dn = cn / 2; H 1-1 ~H 1-cn As a leaf node of the second-order binary tree, H 1-1 ~H 1-cn Group by the format of continuous and adjacent subscripts to obtain the 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 to calculate (H 1-1 , H 1-2 )~(H 1-(cn-1) , H 1-cn ) corresponds to the second-order hash value H 2-1 ~H 2-dn ; Process B134: Process B134: Count the number of second-order hash values, denoted as en; If they are equal, the Merkle tree is constructed successfully. Calculate the root node of the Merkle tree, denoted as Hr, Hr = H 2-1 *H 2-d ; If not, the Merkle tree construction fails, and it is determined whether en is an even number 2, and the process goes to process B135; Process B135: If en is an even number, then H 2-1 ~H 2-dn In the format where the subscripts are continuous and adjacent, as even nodes, the Merkle Tree generation function is called to construct the Merkle tree; If en is not an even number, then H 2-1 ~H 2-(dn-1) In the format where the subscripts are continuous and adjacent, it is treated as an even node; H 2-dn As an independent node, call the Merkle Tree generation function to build a Merkle tree.

6. The financial data sharing security monitoring system based on artificial intelligence according to claim 4 is characterized in that: The workflow of the safety monitoring module is as follows: Process C1: Obtain the operation codes and operation addresses of all processes created by the system during the execution of the entire process of the data acquisition module and the data sharing module as process parameters for normal access to the protected data; Define the set YC to save all process parameters; Process C2: Based on the set YC, define the constraints of the binary logistic regression model for safety monitoring; Process C3: Using the APPDRR model as the reference model and combining it with the binary logistic regression model to build a safety monitoring model; Process C4: Deploy the security monitoring model to the storage space of the blockchain to protect the data to be protected.

7. The financial data sharing security monitoring system based on artificial intelligence according to claim 6 is characterized in that: The specific process of process C2 is as follows: Process C21: When a visitor accesses the data to be protected, the system creates a monitoring process; Define set BB1 and set BB2 to store all operation codes and operation addresses in the monitoring process respectively; Process C22: Define partial function Y: Y=1, x∈YC; Y=0, Where x represents the input, i.e. (x∈BB1)∪(x∈BB2); Process 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; ω*x represents the inner product of ω and x; Process C24: Define the Logit function Logit(P): Here, P in Logit(P) represents P(Y=1|x) or P(Y=0|x).

8. A financial data sharing security monitoring method based on artificial intelligence, characterized in that: The method comprises: Step S1: obtaining data or files in the file to be scanned to obtain the file to be protected; performing decentralized attribute encryption on the file to be protected to obtain an encrypted file; performing segmentation processing on the encrypted file to obtain fragmented files; Step S2: construct a Merkle tree based on the fragmented files; open storage space A and storage space B in the user server; store the node relationship of the Merkle tree in storage space A according to the Merkle tree, and store the hash value of the node and the hash value of the adjacent node 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 position of the corresponding node in storage space A; and upload the data in storage space A and storage space B to the blockchain; Step S3: Obtain the process parameters of the data to be protected being normally accessed; define the binary logistic regression model of security monitoring according to the process parameters; use the APPDRR model as a reference model and combine it with the binary logistic regression model to build a security monitoring 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 changed, synchronize the changed file to be protected to the blockchain; if not changed, continue monitoring.

Images