CN104735654A - Private data fusing method capable of detecting data integrity - Google Patents

Abstract

A private data fusion method that can detect data integrity. The invention requests protection of a data fusion method capable of data integrity and privacy protection, and relates to privacy protection and integrity detection of node data in wireless sensor network data fusion. In the process of data transmission between wireless sensor network nodes and nodes, it is easy for attackers to inject false or tamper data, resulting in data inconsistency with the original data collected by nodes. A method is proposed to add a homomorphic message verification code in the process of node data fusion, so that the real key of the node and the corresponding generated message verification code change with the change of the stored data, while the storage key of the node itself No change occurs. Even if the attacker captures the node's key and data at the same time, it cannot obtain the real key of the node to achieve data integrity and privacy protection.

Description

A private data fusion method that can detect data integrity

technical field

The invention relates to the fields of wireless sensor network technology and wireless communication technology, in particular to privacy protection and integrity detection of node data in wireless sensor network data fusion.

Background technique

Wireless Sensor Network (WSN) is an important part of the Internet of Things. It collects information through a large number of randomly distributed nodes in the network, and returns it to the area for analysis and processing by query users. Due to the limited energy and resources of each node in WSN, it is difficult to transmit a large amount of sensing data. In the process of information collection, it is inappropriate to use each node to transmit data to QS separately, which will increase the communication overhead and reduce the Reduce the efficiency of collecting information. Therefore, in order to effectively reduce energy consumption in WSN, effective data fusion techniques are generally adopted. Data fusion is an efficient data query processing scheme in the sensor network. It processes multiple data to combine data that is more effective and more in line with user needs. Data fusion technology is widely used in daily life. For example, in the application of forest fire prevention, it is necessary to fuse the environmental temperature data detected by multiple temperature sensors; Perform fusion processing. In sensor applications, most of the time, we only care about the monitoring results and do not need to receive a large amount of raw data. Data fusion is an important means to achieve this goal.

As the basis of IoT applications, the information collected in the sensor network is one of the important resources of the IoT. Since it is impossible for QS to directly obtain the data collected by all nodes, its security has always been a major challenge in this field. Security issues are not limited to privacy protection, but also include information integrity. In the TAG algorithm, the nodes transmit and fuse the data up the fusion tree through the wireless channel, and finally the QS obtains the required fusion data. However, due to the characteristics of wireless transmission, the data transmitted between nodes is easy to be captured or eavesdropped. It is trusted that the parent node will obtain the data of the child node. If the parent node or the link is monitored or captured, the privacy of the data will be destroyed. Therefore, it is necessary to protect the privacy of data in data fusion.

Data integrity detection is another important aspect of security issues. Integrity detection can accurately determine whether the obtained data is consistent with the original data collected by the node, so as to prevent false or tampered data from being injected during transmission. The information after data fusion is used for users to analyze and process, or formulate corresponding solutions. The correctness of the data directly affects the judgment of users. If the integrity of the information is compromised, the fused information will be inconsistent with the original information, and the analysis performed by users relying on this information will be biased. Therefore, it is very important to check the integrity of the data in data fusion.

At present, some privacy data fusion methods for detecting data integrity have been proposed. Although the aggregation results are highly accurate, the computational overhead and communication overhead are too large, and the integrity detection mechanism is not perfect, and the scope of application is limited.

Contents of the invention

Aiming at the deficiencies in the prior art, the purpose of the present invention is to provide a method with a wide range of use, comprehensive integrity detection, and relatively small communication overhead and calculation overhead. The technical solution of the present invention is as follows: a method that can detect data integrity The privacy data fusion method, it comprises the following steps:

101. In a wireless sensor network, the wireless sensor network has several nodes and a query server QS, and the query server QS uses a random key distribution mechanism to distribute an end-to-end key for each node, specifically assigning a private key to each node The key k and the prime number C disclosed to the entire wireless sensor network, while QS stores the ID and private key k of all nodes; the query server QS sends a hello signal packet containing the shared key m to each node;

102. In a certain area S of the wireless sensor network, construct a cluster group, the cluster group includes a cluster head node and several cluster internal nodes, and assign an array J[N] to each cluster head node for storing the same The number of slices of all nodes in a cluster. The index number of the array J[N] corresponds to the IDs of all nodes. If a node does not belong to the cluster, the value corresponding to the array index number corresponding to the node ID is always 0;

103. Segment the data of all nodes in the cluster including the cluster head node and several nodes in the cluster to obtain slice data, that is, the cluster C _i has n _i members, that is, the size of the cluster is n _i , then the cluster’s A node will send n _i -1 pieces of slice data to other nodes in the cluster, each node retains 1 piece of slice data, and the remaining n _i -1 pieces of slice data are sent to other nodes in the cluster, among them sent to other nodes The data is encrypted data, and the encrypted data includes slice data and message authentication code MAC value;

104. When the n _i member nodes in the cluster C _i accept the encrypted data forwarded by other nodes, and after decrypting the encrypted data, cluster the private data retained by itself and the decrypted data Intra-data homomorphic fusion; then the node encrypts the data homomorphic fusion in the cluster and then broadcasts it to the cluster head node, and then the cluster head node decrypts the fusion data in the cluster, and combines the fusion data with the decrypted The fusion data in the cluster is calculated for homomorphic fusion to obtain the fusion result, and the data fusion of the nodes in the cluster is completed;

105. The cluster head node transmits the calculated fusion result to the query server QS along the routing tree established by the data fusion algorithm TAG; after the cluster head data aggregation is completed, the query server QS obtains the final network fusion result and completes the data sex test;

106. If the integrity of the data is wrong, the cluster head node no longer uploads the data according to the fusion tree, but directly uploads the data to the query server QS, and performs data integrity detection separately until all clusters whose data integrity is damaged are found The head node feeds back the destroyed cluster head node to the user.

Further, the MAC value of the message authentication code described in step 103, assuming that only one fusion tree is established in the WSN, for node i, Where a is the original data of the node, set three keys k, m, C, k is the private key of each node, only the node itself and the QS node know, N means that there are N nodes in a fusion tree, A total of N keys from k ₁ to k _N will be generated; m is the shared key of a fusion tree in a network area, and the shared keys of nodes in the same fusion tree are the same; C is a prime number that is disclosed to every node in the network. nodes.

Further, when the _ni of cluster C _i in step 103 is 3, that is, the nodes in the cluster are: X, Y and Z respectively, and assuming that node Z is the cluster head of this cluster, DATA _X , DATA _Y , and DATA _Z are respectively Represents the private data of three nodes, assuming that the private data of node X is divided into three pieces, expressed as DATA _X = seed _X + seed _XY + seed _XZ , where seed _X is the private data reserved by the node itself, and seed _XY is the node The slice data sent by X to Y, seed _XZ is the slice data sent by node X to Z, after encryption, the slice data finally sent by node X to node Y is ID _X |seed _XY |MAC(seed _XY ,k _X ), here When DATA _X = DATA _X -seed _XY .

Further, the decryption in step 104 includes the following steps: when node Y receives the slice data sent by X, after decrypting the shared key through the link communication, the following operations are performed: calculate REC _Y =REC _Y +seed _XY , MAC _Y ＝MAC _Y ⊕MAC(seed _XY ,k _X ), REC _Y represents the data received by node Y, MAC _Y represents the message verification code of node Y data, Indicates fusion. When all nodes in the cluster send and receive sliced data, the nodes perform the following calculations. Take node X as an example: MAC _X ＝MAC _X ⊕MAC(DATA _X ,k _A ); DATA _X ＝DATA _X +REC _X ; AGG _X = AGG _X + DATA _X ; DMAC _X = DMAC _X ⊕ MAC _X .

Advantage of the present invention and beneficial effect are as follows:

Due to some existing private data fusion methods for detecting data integrity, although the aggregation results are highly accurate, the communication overhead and calculation overhead are relatively large during the detection process, and the integrity detection mechanism is not perfect, and the scope of use is limited. sex. In order to overcome the defects in the above-mentioned prior art and satisfy data privacy protection at the same time, the present invention proposes a data fusion method capable of data integrity and privacy protection, by adding homomorphic message verification in the process of data mixing by nodes Code, so that both the real key of the node and the corresponding generated MAC will change with the change of the stored data, but the storage key of the node itself will not change. Even if the attacker captures the node's key and data at the same time, it cannot obtain the node's real key, so data integrity and privacy protection can be satisfied at the same time. If QS detects that the integrity of the data is wrong, it can go back to the relevant nodes for integrity detection, and use the real key calculated by QS to determine the specific node under attack. Therefore, the integrity detection is more comprehensive and the application range is wider.

Description of drawings

Fig. 1 is a data fusion model diagram involved in the present invention;

Fig. 2 is the fusion basic principle diagram of homomorphic message verification code of the present invention;

Fig. 3 is a network model figure of the present invention;

Fig. 4 is a schematic diagram of the fusion process of node slice data in the cluster of the present invention;

Fig. 5 is a schematic diagram of the node data fusion process in the present invention;

Fig. 6 is a schematic diagram of the cluster head node data fusion flow chart of the present invention;

Fig. 7 is a flowchart of the present invention.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Apparently, the described embodiment is only one embodiment of the present invention, not all of them.

FIG. 1 is a diagram of a wireless sensor network data fusion model of the present invention. The data fusion model defined in this paper is y(t)=f(d ₁ (t),d ₂ (t),…d _N (t)), where d _i (t)(i=1,…,N) represents the node i is the data collected at time t. Because many data fusion functions, such as count, average, etc., can be simplified into sum functions, the present invention takes the sum function as the research object, and records

Fig. 2 is a schematic diagram of the fusion basic principle of the homomorphic message verification code of the present invention. Let the original data of the node be a, and set three keys k, m, and C. k is the private key of each node, only known by the node itself and the QS node. Assuming that there are N nodes in a fusion tree, a total of N keys from k ₁ to k _N will be generated; m is the shared key of a fusion tree in a network area, and the shared keys of nodes in the same fusion tree are the same; C is a large prime number that is disclosed to every node in the network. Assuming that only one fusion tree is established in WSN, for node i, its message authentication code MAC value is

The process of fusing two MAC values according to homomorphism is as follows:

Let the data collected by the node be a ₁ and the received data be a ₂ . According to the sum function, the fusion result is A=a ₁ +a ₂ . Calculate MAC(a ₁ ,k ₁ ) and MAC(a ₂ ,k ₂ ) as follows to obtain AMAC (the MAC value of data A): AMAC=MAC(a ₁ ,k ₁ )*MAC(a ₂ ,k ₂ ) , this formula is further calculated as: $\begin{array}{c}\mathrm{AMAC}=\mathrm{MAC}(a_1,k_1)*\mathrm{MAC}(a_2,k_2)=\left(m^{a_1+k_1}\mathrm{mod}C\right)*\left(m^{a_2+k_2}\mathrm{mod}C\right)\\ =m^{a_1+k_1}*m^{a_2+k_2}\mathrm{mod}C=m^{(a_1+a_2)+(k_1+k_2)}\mathrm{mod}C=\mathrm{MAC}(a_1+a_2,k_1+k_2)\end{array};$

Therefore, the MAC value of data A is obtained, and the real key at this time is k ₁ +k ₂ instead of k ₁ .

Fig. 3 is a network model diagram of the present invention. It is divided into three layers: QS, cluster head node layer, and ordinary node layer in the cluster. All nodes in the cluster collect data. First, the collected data is sliced, and the nodes in the cluster are mixed with each other; second, the nodes in the cluster send the mixed data to the cluster head node; finally, the cluster head node uses the calculated fusion results along the TAG algorithm The established routing tree is sent to QS. After receiving the transmitted data, QS decrypts it. According to the relevant characteristics of the homomorphic message verification code, it first calculates the real key, then uses the real key and the fusion data to calculate the corresponding MAC, and compares the uploaded MAC value with the calculated Whether the MAC values are equal to determine the integrity of the data. But when data integrity is compromised, retrospective error correction will be performed. At this stage, the cluster head node no longer uploads data according to the fusion tree, but directly uploads the data to QS.

FIG. 4 is a schematic diagram of a flow chart of mixing node slice data in a cluster according to the present invention. This process goes through two stages: the first stage is the data slicing stage, which is to slice the node data in the cluster. Assuming that a cluster C _i has n _i members, a node in this cluster will send n _i -1 pieces of data to other nodes in this cluster, and the number of node fragments J _X =n _i at this time. For the convenience of discussion, the simple scheme of a cluster containing three nodes is used in the figure, and the nodes in the cluster are: X, Y, and Z, and node Z is assumed to be the cluster head of this cluster. DATA _X , DATA _Y , and DATA _Z represent the private data of the three nodes respectively. Suppose the private data of node X is divided into three pieces, expressed as DATA _X = seed _X + seed _XY + seed _XZ , where seed _X is the private data retained by the node itself, and seed _XY is the sliced data sent by node X to Y. After data encryption, the slice data that node X finally sends to node Y is ID _X |seed _XY |MAC(seed _XY , k _X ), at this time DATA _X =DATA _X -seed _XY . The second stage is the stage of accepting sliced data. Node Y receives the sliced data sent by X, decrypts it through the link communication shared key, and performs the following operations: calculate REC _Y =REC _Y +seed _XY , MAC _Y =MAC _Y ⊕MAC(seed _XY ,k _X ). After all the nodes in the cluster send and receive sliced data, the nodes perform the following calculations (take node X as an example): MAC _X = MAC _X ⊕ MAC(DATA _X , k _A ); DATA _X = DATA _X +REC _X ; AGG _X =AGG _X +DATA _X ; DMAC _X =DMAC _X ⊕MAC _X .

FIG. 5 is a schematic diagram of the process flow of node data fusion in the cluster according to the present invention. After the node slicing data mixing process in the cluster, the data of X, Y, and Z are: J _X |DMAC _X |AGG _X , J _Y |DMAC _Y |AGG _Y , J _Z |DMAC _Z |AGG _Z , nodes X, Y broadcasts the data to the cluster head node Z, at this time J _Z [N]={0,…,0,J _X ,J _Y ,J _Z ,0,…,0}, node Z receives the data and performs the following calculation: DMAC _Z = DMAC _Z ⊕ DMAC _X ⊕ DMAC _Y ; AGG _Z = AGG _Z + AGG _X + AGG _Y .

FIG. 6 is a schematic diagram of the cluster head node data fusion process in the present invention. The cluster head node transmits the calculated result to QS along the routing tree established by TAG algorithm. In addition to uploading data, the cluster head node also uploads all the collected slice numbers J _i . For example, the data uploaded by the node is J _X |J _Y |J _Z |DMAC _Z |AGG _Z .

Fig. 7 is a flowchart of the present invention, and the present invention provides a privacy data fusion method that can detect data integrity, including the following steps:

S1: In the wireless sensor network, the QS node and each node perform end-to-end key distribution. The present invention uses a random key distribution mechanism. In this link, only the private key of the node is allocated, and a larger prime number is made public to each node in the network;

S2: When a fusion tree sends a hello signal packet, the shared key m is sent to all nodes in the tree. Each node can choose itself as the cluster head. When the cluster head node is generated, an array J is allocated to each cluster head node. [N], used to store the number of slices of all nodes in the same cluster, and then used in the data backtracking and error correction stage.

S3:: Perform data slicing for each node in the cluster, the node itself retains a copy of the data, and sends the rest to other nodes in the cluster; the data sent to other nodes is encrypted data, and the data includes sliced data and MAC values.

S4: Members in the cluster accept sliced data, decrypt the data, and mix corresponding types of data; nodes encrypt and broadcast the mixed data to the cluster head node, and then the cluster head node performs related calculations on the data and fuses them.

S5: The cluster head node transmits the calculated fusion result to QS along the routing tree established by the TAG algorithm;

S6: After cluster head data aggregation is completed, QS obtains the final fusion result of the network at this time, and performs data integrity detection;

S7: If the integrity of the data is wrong, the cluster head node no longer uploads data according to the fusion tree, but directly uploads the data to QS, and performs data integrity detection separately until all cluster head nodes whose data integrity is damaged are found .

In the present invention, a random key distribution mechanism scheme is used to encrypt and decrypt data. Due to the characteristics of wireless transmission, the communication link between nodes in wireless sensor network is easy to be destroyed, and the transmitted data is easy to be monitored. In order to ensure the security of communication links between nodes, it is often necessary to encrypt data. This paper uses a random key distribution mechanism. First generate a key pool with K keys, and then randomly assign K keys to each node. If the neighbor node shares the same key with this node, then the two nodes will establish a secure communication chain road. The probability that any two nodes share the same key is p=1-((Kk)!) ² /(K!(K-2k)!). If the third node also obtains this key, the security of the communication link will be destroyed, and the probability of being destroyed is p _overhead =k/K. Under normal circumstances, p _overhead is a very small number.

The above embodiments should be understood as only for illustrating the present invention but not for limiting the protection scope of the present invention. After reading the contents of the present invention, skilled persons can make various changes or modifications to the present invention, and these equivalent changes and modifications also fall within the scope defined by the claims of the present invention.

Claims (4)

1. can the private data fusion method of check data integrity, it is characterized in that: comprise the following steps:

101, in wireless sensor network, described wireless sensor network has some nodes and querying server QS, querying server QS adopts random key distribution mechanism to carry out encryption key distribution end to end for each node, be specially and distribute to each node private cipher key k and disclose to the prime number C in whole wireless sensor network, QS stores ID and the private cipher key k of all nodes simultaneously; Querying server QS transmission includes the hello signal bag of shared key m to each node;

102, in certain region S of wireless sensor network, build a bunch of group, bunch group comprises a leader cluster node and some bunches of internal segments, and distribute an array J [N] for each leader cluster node, for storing the number of slices of all nodes in same bunch, the call number of array J [N] and the ID one_to_one corresponding of all nodes, if certain node does not belong to this bunch, then the value corresponding to array index number that this node ID is corresponding is always 0;

103, the cutting of data equivalent is carried out to all nodes comprising leader cluster node and some bunches of interior nodes in bunch group and obtain slice of data, be i.e. bunch C _ithere is n _iindividual member, size namely bunch is n _i, then a node of this bunch will send n _i-1 part of slice of data is to other nodes in this bunch, and each node self retains 1 part of slice of data, remaining n _iother node in-1 part of slice of data sends to bunch, the data after wherein sending to the data of other node to be through encryption, the data after encryption comprise slice of data and Message Authentication Code MAC value;

104, as a bunch C _iinterior n _iindividual member node all accepts other nodes and forwards the data after encryption come, and to after the decrypt data after encryption, the data after the private data that self is retained and deciphering to carry out bunch in data isomorphism merge; Then node by through bunch in data isomorphism merge data through encryption be broadcast to leader cluster node again, then leader cluster node to bunch in fused data be decrypted, and by after self fused data and deciphering bunch in fused data carry out isomorphism fusion calculation and obtain fusion results, complete a bunch interior nodes data fusion;

105, leader cluster node is sent to querying server QS the routing tree that the fusion results calculated is set up along data anastomosing algorithm TAG; After bunch head data aggregate completes, now querying server QS obtains the final fusion results of network, and carries out the integrity detection of data;

If the integrality of 106 data is wrong, leader cluster node is no longer according to fusion tree uploading data, but directly by data upload to querying server QS, carry out data integrity detection separately, until find out the destroyed leader cluster node of all data integrities, the leader cluster node that this is destroyed feeds back to user.

2. according to claim 1 a kind of can the private data fusion method of check data integrity, it is characterized in that: the Message Authentication Code MAC value described in step 103 is, suppose that only setting up one in WSN merges tree, for node i, wherein a is the initial data of node, and set three keys k, m, C, k is the private cipher key of each node, only has node self and QS node to know, N represents in a fusion tree have N number of node, will produce k ₁~ k _nn number of key altogether; M is the shared key that tree is merged in a network area, and same the shared key merging tree interior joint is identical; C is each node that a prime number is disclosed in network.

3. according to claim 1 a kind of can the private data fusion method of check data integrity, it is characterized in that: as in step 103 bunch of C _in _iwhen being 3, namely bunch interior nodes respectively: X, Y and Z, and suppose that node Z is bunch head of this bunch, DATA _x, DATA _y, DATA _zrepresent the private data of three nodes respectively, if it is three that the private data of nodes X is split, be expressed as DATA _x=seed _x+ seed _xY+ seed _xZ, wherein seed _xfor the private data that node self retains, seed _xYfor nodes X sends to the slice of data of Y, seed _xZfor nodes X sends to the slice of data of Z, through encryption, the slice of data that nodes X finally issues node Y is ID _x| seed _xY| MAC (seed _xY, k _x), now DATA _x=DATA _x-seed _xY.

4. according to claim 1 a kind of can the private data fusion method of check data integrity, it is characterized in that: when comprising the following steps after the deciphering in step 104: the slice of data sent as node Y reception X, after the deciphering of link communication shared key, proceed as follows: calculate REC _y=REC _y+ seed _xY, MAC _y=MAC _y⊕ MAC (seed _xY, k _x), REC _yrepresent the data that node Y receives, MAC _yrepresent the Message Authentication Code of node Y data, ⊕ represents fusion, when bunch in all nodes send and accept after slice of data completes, node carries out calculating for nodes X as follows: MAC _x=MAC _x⊕ MAC (DATA _x, k _a); DATA _x=DATA _x+ REC _x; AGG _x=AGG _x+ DATA _x; DMAC _x=DMAC _x⊕ MAC _x.