Chip-level dynamic key negotiation method for sensor data

Abstract

The present invention relates to the field of sensor data security technology and discloses a chip-level dynamic key negotiation method for sensor data. The method obtains the unique hardware identifier and key parameters of the sensor node to generate a dynamic key seed matrix. After the acquisition is completed, randomly intercepted data segments are subjected to median filtering and normalization preprocessing to extract local statistical features and global features to generate a data feature sequence, which is then spliced ​​into the seed matrix to obtain a dynamic key generation matrix. The dynamic negotiation key is generated through standardization and encryption using the SM3 hash algorithm and stored in the cloud and node security unit. During verification, double verification is achieved through hash comparison and plaintext bit-by-bit matching. An environmental parameter anomaly trigger mechanism is set, and the key is updated when the cumulative anomaly exceeds the limit. The method integrates hardware and dynamic data features to improve key security and adaptability.

Description

Technical Field

[0001] The present invention relates to the field of sensor data security technology, and in particular to a sensor data chip-level dynamic key negotiation method. Background Art

[0002] With the widespread adoption of IoT technology, sensor nodes, as the core units for data collection, face significant challenges in ensuring data transmission security. Traditional static key negotiation methods, due to their fixed keys, struggle to cope with the dynamic changes in environmental parameters, hardware characteristics, and real-time data in sensor networks. This makes the keys vulnerable to cracking and poses a security risk.

[0003] From a hardware-level security perspective, the physical unclonability of sensor nodes (such as the random noise patterns generated by variations in silicon wafer manufacturing processes) is not fully utilized for key generation. Traditional methods rely on preset static keys or simple hashing algorithms, failing to establish a unique and unclonable key foundation at the chip-level hardware level. Attackers can obtain static keys through physical attacks or side-channel analysis, leading to the risk of node identity forgery or data tampering.

[0004] During data collection and transmission, the operating status of sensor nodes (such as voltage fluctuations and ambient temperature changes) and data stream characteristics (such as acquisition frequency, timestamps, and signal noise) are highly dynamic. Traditional key negotiation methods fail to incorporate these real-time parameters into the key generation system, resulting in the inability to dynamically adjust the key to the acquisition environment and data characteristics. This can lead to mismatches between the encryption key and the current data characteristics, increasing the likelihood of data being reverse analyzed or brute-forced. For example, in industrial equipment monitoring scenarios, changes in the frequency and amplitude of equipment vibration signals may indicate abnormal operating conditions. If the key cannot respond to such changes in real time, attackers can decrypt the encrypted data by analyzing the correlation between the signal characteristics and the fixed key.

[0005] The limitations of key management mechanisms are also a prominent issue with traditional solutions. In existing technologies, the key verification process between the cloud and nodes typically relies on simple comparisons, lacking multi-layered security protection. For example, direct storage of plaintext keys or single-layer hashing makes them vulnerable to man-in-the-middle attacks and hash collision attacks. Furthermore, key updates often rely on fixed cycles or manual triggers, failing to detect environmental anomalies (such as sudden temperature changes, voltage overruns, and data outages) in real time. This leaves keys at risk under abnormal conditions for extended periods, failing to meet the stringent real-time and security requirements of scenarios such as the Industrial Internet of Things and smart grids.

[0006] At the algorithmic level, the traditional key generation process handles multidimensional parameters in a crude manner, failing to fully utilize algorithms such as principal component analysis (PCA) and dynamic time warping (DTW) to achieve parameter dimensionality reduction and time alignment. This results in redundant dimensions in the key generation matrix or misaligned temporal features, compromising the randomness and effectiveness of the key. Furthermore, the lack of noise suppression and amplitude normalization in data preprocessing can allow interference signals in the raw data to participate in key generation, reducing key quality.

[0007] Existing sensor data key negotiation technologies have significant defects in hardware feature utilization, dynamic parameter fusion, key verification mechanism and adaptive update. There is an urgent need for a key negotiation method based on chip-level dynamic parameters and integrating real-time data features to improve the anti-attack capability and security reliability of sensor networks in complex environments. Summary of the Invention

[0008] The purpose of the present invention is to provide a sensor data chip-level dynamic key negotiation method to solve the problems raised in the above background technology.

[0009] To achieve the above objectives, the present invention provides the following technical solution: a sensor data chip-level dynamic key negotiation method, the method comprising:

[0010] Obtaining a unique hardware identifier for the sensor node and recording key parameters during the sensor data acquisition process, the key parameters including a data acquisition timestamp, a data acquisition frequency, and state parameters of the sensor node; the state parameters including node voltage and ambient temperature; and generating a dynamic key seed matrix based on the unique hardware identifier and the key parameters.

[0011] After the sensor data is collected, a data segment of a set length is randomly selected from the sensor data stream, feature information of the data segment is extracted, and a data feature sequence is generated; the data feature sequence is spliced ​​into the dynamic key seed matrix to obtain a dynamic key generation matrix;

[0012] Encrypting the dynamic key generation matrix to generate a dynamic negotiation key, and storing the dynamic negotiation key in a secure storage unit of a cloud server and a sensor node;

[0013] During key verification, the dynamic negotiated key in the secure storage unit of the sensor node is read and matched with the dynamic negotiated key in the cloud server. In response to a successful match, a key valid signal is returned; in response to a match failure, a key invalid signal is returned.

[0014] Preferably, the method for obtaining the data feature sequence includes:

[0015] A sliding window algorithm is used to obtain the local statistical features of the data segment to obtain a statistical feature matrix; a hierarchical clustering algorithm is used to obtain a set number of cluster groups in the statistical feature matrix, and the centroids of the cluster groups constitute a centroid sequence; based on autocorrelation analysis, the global features of the data segment are obtained to obtain an eigenvalue sequence, and the eigenvalue sequence includes mean, variance, peak factor, kurtosis and waveform factor; the elements in the centroid sequence and the eigenvalue sequence are added bit by bit to obtain a data feature sequence.

[0016] Preferably, randomly selecting a data segment of a set length in the sensor data stream includes:

[0017] A starting time point is randomly selected in the sensor data stream, and a data segment of a preset length is intercepted based on the starting time point.

[0018] Preferably, the method for generating the dynamic key seed matrix includes:

[0019] Based on the unique hardware identifier of the sensor node, its physical unclonable eigenvalue is extracted. The physical unclonable eigenvalue includes a random noise pattern generated by silicon wafer manufacturing process deviations. A multidimensional parameter vector is constructed by combining the data acquisition timestamp, data acquisition frequency, and state parameters of the sensor node. The multidimensional parameter vector is subjected to principal component analysis and dimensionality reduction, and the principal component components whose variance contribution exceeds a preset threshold are retained. The reduced principal component components are arranged in time series to form a dynamic key seed matrix.

[0020] During the splicing process of data feature sequences, the dynamic time warping algorithm is used to align the time dimension of the data feature sequence and the dynamic key seed matrix; the singular value decomposition of the spliced ​​dynamic key generation matrix is ​​performed, and its singular value vector is extracted as the basic element for key generation.

[0021] Preferably, the dynamic key generation matrix is ​​stored in a local secure storage unit of the sensor node.

[0022] Preferably, the verification mechanism of the dynamically negotiated key includes:

[0023] In the local secure storage unit of the sensor node, a lightweight encryption algorithm is used to perform secondary obfuscation processing on the dynamically negotiated key to generate an obfuscated key tag; the cloud server synchronously stores the hash summary value of the obfuscated key tag;

[0024] During key verification, the main control module reads the obfuscated key tag and calculates its hash value, and sends the hash value to the cloud server; the cloud server compares the received hash value with the stored hash summary value, and triggers the plaintext matching process of the dynamic negotiation key in response to a consistency; in the plaintext matching process, the cloud server decrypts the stored encrypted dynamic negotiation key and compares it bit by bit with the plaintext dynamic negotiation key sent by the sensor node; in response to a complete match, it returns a key validity signal.

[0025] Preferably, the triggering conditions for the dynamic key update mechanism include:

[0026] Real-time monitoring of the ambient temperature change rate, power supply voltage fluctuation range, and data acquisition interruption frequency of the sensor node; when the ambient temperature change rate exceeds ±2°C / minute, the voltage fluctuation range is greater than ±5% of the rated voltage, or the data acquisition interruption frequency reaches 3 times per minute, it is determined that the environmental parameters are abnormal;

[0027] In response to abnormal environmental parameters, the main control module starts the key update counter; if the counter accumulates more than 5 abnormal times within 10 minutes, it sends a key update request to the cloud server; the cloud server generates a new dynamic key seed matrix and sends it to the sensor node, while destroying the cloud storage record of the historical dynamic negotiated key.

[0028] Preferably, the data segment further includes a pre-processing operation: using a median filtering algorithm to suppress noise, and using a normalization algorithm to adjust the data amplitude range.

[0029] Preferably, encrypting the dynamic key generation matrix includes:

[0030] Performing minimum-maximum normalization processing on the dynamic key generation matrix, arranging all data in the normalized dynamic key generation matrix in order from left to right and from top to bottom to obtain a data stream; encrypting the data stream using the SM3 hash algorithm.

[0031] Preferably, the dynamic negotiation key is destroyed from the cloud server after successful verification.

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

[0033] During key generation, the dynamic key seed matrix is ​​generated by extracting the physically unclonable eigenvalues ​​of the sensor node's unique hardware identifier (such as the random noise pattern generated by silicon wafer manufacturing process deviations) and combining them with dynamic parameters such as data acquisition timestamps, frequency, node voltage, and ambient temperature. This design, after dimensionality reduction through principal component analysis, deeply integrates chip-level hardware fingerprints with real-time environmental parameters, making the key highly unique and dynamically adaptable. This makes it difficult for attackers to counterfeit the key through static analysis or physical attacks, thus enhancing the key's crackability from the source.

[0034] The introduction of data feature sequences further strengthens the real-time relevance of keys. A sliding window algorithm extracts local statistical features (such as mean and variance) of data segments. A hierarchical clustering algorithm generates a centroid sequence, and autocorrelation analysis is combined to obtain a sequence of eigenvalues ​​containing global features such as peak factor and kurtosis. Finally, this sequence is added bit by bit to form a data feature sequence. This sequence, when combined with the dynamic key seed matrix, enables the key generation matrix to simultaneously incorporate hardware characteristics, environmental parameters, and real-time data features. This significantly expands the complexity of the key space and effectively resists differential attacks, statistical analysis attacks, and brute-force enumeration attacks.

[0035] The key verification mechanism employs a multi-layered security design. Sensor nodes perform a secondary obfuscation of the dynamically negotiated key using a lightweight encryption algorithm to generate an obfuscated key tag, which is then stored in the cloud. Verification begins with a hash value comparison, followed by a bit-by-bit plaintext match. This dual verification mechanism significantly reduces the risk of man-in-the-middle attacks and hash collisions. Furthermore, upon successful verification, the dynamically negotiated key is immediately destroyed in the cloud, reducing the storage time of the key in non-secure environments and further enhancing key management security.

[0036] The dynamic key update mechanism is based on real-time environmental parameter monitoring. When abnormal conditions are detected, such as an ambient temperature change exceeding ±2°C / minute, a voltage fluctuation exceeding ±5% of the rated voltage, or a data collection interruption frequency exceeding three times per minute, a counter accumulates these abnormalities (more than five in 10 minutes) and triggers a key update request. This adaptive mechanism promptly responds to sudden environmental changes, preventing long-term key invalidation due to parameter anomalies. It is particularly suitable for scenarios with high real-time requirements, such as industrial monitoring and intelligent sensing, ensuring the continued validity of keys in dynamic environments.

[0037] During data preprocessing, a median filter algorithm is used to suppress noise, and a normalization algorithm is used to adjust data amplitude. This ensures the accuracy and reliability of the data characteristics input into the key generation process, preventing key deviations caused by noise interference. Min-max normalization and SM3 hashing are performed on the dynamic key generation matrix, which not only standardizes the data format but also enhances encryption strength using national encryption algorithms, complying with domestic security standards and improving the algorithm's practicality and compliance.

[0038] The present invention builds a full-process security protection system from key generation to destruction through the deep integration of hardware features and dynamic parameters, multi-level verification mechanism, adaptive update strategy and data preprocessing optimization, providing a highly robust and attack-resistant key negotiation solution for IoT sensor networks. It can be widely used in industrial Internet, intelligent transportation, environmental monitoring and other fields with strict data security requirements, and effectively protect the confidentiality and integrity of sensor data during the collection, transmission and storage process. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] Figure 1 This is a working principle diagram of the sensor data chip-level dynamic key agreement method according to the present invention;

[0040] Figure 2 This is a working principle diagram of the method for obtaining data feature sequence;

[0041] Figure 3 A diagram showing the working principle of dynamic key seed matrix generation and dynamic key generation matrix processing;

[0042] Figure 4 The figure shows the working principle of the dynamic key update mechanism. DETAILED DESCRIPTION

[0043] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0044] See also Figure 1 The sensor data chip-level dynamic key negotiation method of the present invention is specifically implemented in the following steps:

[0045] The unique hardware identifier of the sensor node is obtained, and key parameters in the sensor data acquisition process are recorded, wherein the key parameters include the data acquisition timestamp, the data acquisition frequency, and the state parameters of the sensor node; the state parameters include the node voltage and the ambient temperature; and a dynamic key seed matrix is ​​generated based on the unique hardware identifier and the key parameters.

[0046] After the sensor data collection is completed, a data segment of a set length is randomly selected from the sensor data stream, and the feature information of the data segment is extracted to generate a data feature sequence; the data feature sequence is spliced ​​into the dynamic key seed matrix to obtain a dynamic key generation matrix.

[0047] Perform an encryption process on the dynamic key generation matrix to generate a dynamic negotiation key, and store the dynamic negotiation key in the secure storage units of the cloud server and the sensor nodes.

[0048] During key verification, read the dynamic negotiation key in the secure storage unit of the sensor node and match it with the dynamic negotiation key in the cloud server. In response to a successful match, return a key valid signal; in response to a failed match, return a key invalid signal.

[0049] Example 1: Please refer to Figure 2 , in this embodiment, it involves the specific acquisition process of the data feature sequence. After the sensor data is collected, for a randomly selected data segment of a set length, operations such as local statistical feature extraction, clustering processing, global feature analysis, and sequence fusion need to be performed in sequence. The sliding window algorithm is used to extract local statistical features from the data segment. This algorithm slides a window of a fixed size over the data segment at a preset step size and performs multi-dimensional statistical calculations on the data points within each window. For example, for a data segment of a set length containing N data points, the window size can be set to M (M < N), and the step size can be set to S (S < M). Let the window start from the starting position of the data segment and slide S data points each time until it covers the entire data segment. Within each window, calculate statistics such as the mean, variance, maximum value, minimum value, and median. These statistics reflect the distribution characteristics and fluctuations of the data within the window from different dimensions, forming a row vector containing multiple statistics. The row vectors corresponding to all windows are arranged in order to form a statistical feature matrix. Suppose the data segment length is 2000, the window size is 100, and the step size is 20, then 96 windows can be generated ((2000 - 100) / 20 + 1 = 96), and each window corresponds to a row vector containing 5 statistics, thus forming a statistical feature matrix of 96 rows and 5 columns.

[0050] A hierarchical clustering algorithm is used to process the statistical feature matrix to obtain a set number of cluster groups. The hierarchical clustering algorithm constructs a tree-like clustering structure by calculating the distance between each data point in the matrix (i.e., the statistical feature vector of each window). Distance metrics can include Euclidean distance, Manhattan distance, etc. This embodiment uses Euclidean distance as an example, and its calculation method is the square root of the sum of the squares of the differences between the corresponding elements of two vectors. When constructing the tree structure, each data point is first treated as an independent cluster. Then, the two closest clusters are gradually merged in order of distance from closest to farthest until all clusters are merged into a large cluster. The number of clusters K is set according to actual needs (e.g., K=8). The split points corresponding to the K clusters are found in the tree structure, and the data points in the statistical feature matrix are divided into K cluster groups. The centroid of each cluster group is determined by calculating the average of the statistical values ​​of each dimension of all data points in the group. For example, if a cluster group contains 12 data points, each of which is a 5-dimensional statistical feature vector, then the value of each dimension of the centroid vector is the arithmetic mean of the corresponding dimension values ​​of all data points in the group. Arrange the centroids of the K cluster groups in cluster order, that is, form a centroid sequence of length K.

[0051] Autocorrelation analysis is used to obtain the global characteristics of a data segment, generating a sequence of eigenvalues. Autocorrelation analysis measures the correlation of data at different time points within a data segment. By calculating the autocorrelation function of a data segment, the variation in correlation at different delays is analyzed. In this embodiment, eigenvalues ​​such as mean, variance, crest factor, kurtosis, and shape factor are extracted from the autocorrelation analysis results. The mean is the average of all data points in the data segment, reflecting the overall level of the data; the variance is the average of the squares of the differences between each data point and the mean, reflecting the degree of data dispersion; the crest factor is the ratio of the peak value to the effective value of the data segment, characterizing the strength of the impulse component in the signal; the kurtosis measures the tail thickness of the data distribution, reflecting the probability of occurrence of extreme values ​​in the data; and the shape factor is the ratio of the effective value to the mean, reflecting the waveform shape of the signal. These eigenvalues ​​describe the statistical properties and signal characteristics of the data segment from a global perspective. They are arranged in a fixed order (such as mean, variance, crest factor, kurtosis, and shape factor) to form a sequence of eigenvalues ​​containing multiple elements. Assuming that the eigenvalue sequence contains five elements, the length of the sequence is 5.

[0052] The elements in the centroid sequence and the eigenvalue sequence are added bit by bit to obtain the data feature sequence. During the specific operation, it is necessary to ensure that the lengths of the two sequences are consistent. If the lengths are inconsistent, they can be adjusted by padding with zeros or truncating. In this embodiment, it is assumed that the length of the centroid sequence is K (such as K=8) and the length of the eigenvalue sequence is L (such as L=5). In order to achieve bit-by-bit addition, the eigenvalue sequence can be repeatedly extended or padded with zeros to make its length consistent with the centroid sequence (such as the length after extension or zero padding is 8). Then, the first element of the centroid sequence is added to the first element of the eigenvalue sequence to obtain the first element of the data feature sequence; and so on, until all elements of the two sequences are added. For example, if the elements of the centroid sequence are [c1,c2,c3,c4,c5,c6,c7,c8], and the eigenvalue sequence is expanded to [f1,f2,f3,f4,f5,f1,f2,f3], then the elements of the data feature sequence are [c1+f1,c2+f2,c3+f3,c4+f4,c5+f5,c6+f1,c7+f2,c8+f3]. In this way, the centroid information of the local statistical features is fused with the eigenvalue information of the global features to form a data feature sequence that can comprehensively reflect the multi-dimensional characteristics of the data segment, providing rich feature information for the subsequent construction of the dynamic key generation matrix. Throughout the entire process, parameters such as the window size and step size of the sliding window algorithm, the number of clusters in hierarchical clustering, and the type of eigenvalue extraction can be flexibly adjusted according to the sensor type, data characteristics, and security requirements to adapt to the data feature extraction requirements in different application scenarios, ensuring that the generated data feature sequence can accurately reflect the characteristics of the data segment and has sufficient randomness and complexity, thereby improving the security and uniqueness of the dynamic key.

[0053] Example 2: In this embodiment, the specific operation of randomly selecting a data segment of a set length in the sensor data stream is mainly described. The whole process involves random starting point generation, data segment interception logic and parameter setting principles, and the randomness of the selection process and the validity of the data segment must be ensured. During the continuous acquisition of the sensor data stream, the system determines the starting position of the data segment through the built-in random number generation mechanism. The random number generation mechanism can be implemented based on hardware or software: at the hardware level, the physical random number generator inside the chip can be used to generate random numbers by collecting unpredictable physical phenomena such as thermal noise and clock jitter; at the software level, pseudo-random number algorithms such as the linear congruential method and the Mersenne rotation algorithm can be used to generate pseudo-random numbers by setting a random seed (such as the current timestamp, sensor node state parameters, etc.). Regardless of the method used, the generated random number needs to be mapped to the time axis range of the sensor data acquisition. For example, if the time range of data acquisition is from time arrive , the random number generation range must be limited to Within the interval, ensure the generated starting time point It is within the valid collection time period.

[0054] To determine the starting time point Based on the time series characteristics of the data, the system performs data segment interception. Start at the moment, according to the preset length Continuously acquire data points. Preset length It can be defined in two ways: one is based on the number of data points, such as intercept continuous data points; the other is based on the length of time, such as intercepting the duration of Both methods need to be consistent with the sampling frequency of the sensor. Matching: If defined by the number of data points, the actual intercepted time length is ; If defined by time length, the actual number of data points intercepted is For example, when the sampling frequency is 1000 Hz, intercepting 5000 data points corresponds to a time length of 5 seconds, while intercepting a data segment of 10 seconds must contain 10,000 data points.

[0055] The introduction of a random starting point aims to avoid regularity in data segment selection and enhance the randomness of subsequently generated dynamic keys. For example, if a fixed-length data segment is always intercepted from the beginning of the data stream, an attacker could analyze the overlapping data segments during multiple key generation processes and infer the pattern of feature extraction, thereby compromising the security of the key. However, by randomly selecting the starting point, the position of each data segment is not fixed. Even if the same sensor node collects data under similar conditions, the data feature sequences generated at different times will vary due to differences in the position of the data segments, making it more difficult for an attacker to predict or reverse engineer the data.

[0056] When setting parameters, a comprehensive balance between computing resources and feature extraction performance must be considered. The preset length L must meet the following conditions: On the one hand, L cannot be too small, otherwise the data segment will contain insufficient information, resulting in insufficient discriminability of the extracted feature sequence and affecting the uniqueness of the dynamic key. On the other hand, L cannot be too large, as this increases the computational complexity of feature extraction. This can lead to a decrease in real-time performance, especially when sensor node resources are limited. For example, for sensors with high-frequency sampling (such as vibration sensors, which can sample at frequencies above 10kHz), if the preset length is set to 100,000 data points, the feature extraction process may consume a significant amount of computing time and storage resources. In actual applications, it may be sufficient to simply intercept a shorter data segment containing a typical signal period to meet feature extraction requirements. Therefore, the specific value of the preset length L needs to be optimized according to the sensor type, signal characteristics and node computing power. For example, for temperature sensors in the industrial Internet of Things, the sampling frequency is low (such as 1Hz), and a longer preset time length (such as 300 seconds) can be set to obtain sufficient temperature change information; for audio sensors, the sampling frequency is high (such as 44.1kHz), and a shorter number of data points (such as 4096) can be set to balance feature richness and computing overhead.

[0057] The randomness of data segments is also reflected in the frequency of starting point generation. During each key generation process, a new random starting point is generated, ensuring that even the same sensor node selects different data segment locations during two consecutive data collections. This mechanism avoids feature sequence duplication caused by reusing the same data segment locations, further enhancing the dynamic nature and security of dynamic keys. For example, when a sensor node generates a new dynamic key every hour, a different starting point is randomly selected each time. This ensures that each key generation matrix is ​​based on data segment features at different locations, effectively defending against security threats such as replay attacks.

[0058] During implementation, the system must record the timestamp information of the sensor data stream to ensure the validity of the starting time point T0 and the accuracy of data segment interception. The timestamp can be generated by the real-time clock (RTC) module built into the sensor node, with millisecond accuracy or higher. After generating a random starting point T0, the system traverses the timestamps in the data stream, finds the sampling point closest to T0 as the starting position of the data segment, and continuously reads data points from this position according to the preset length. If T0 falls between the timestamps of two sampling points, methods such as linear interpolation can be used to estimate the data value at that time, or directly select the previous or next sampling point as the starting position. The specific processing method must be clarified during system design to ensure the consistency and repeatability of data segment interception.

[0059] The process of randomly selecting data segments of a set length from sensor data streams introduces a random starting point mechanism, combined with reasonable preset length settings and data interception logic, to achieve dynamic data segment selection. This provides a random and diverse data source for subsequent data feature extraction and dynamic key generation. The key to this process lies in ensuring the unpredictability of the random starting point, the rationality of the preset length, and the accuracy of data interception. Through multi-faceted parameter coordination and mechanism design, the requirements for randomness and validity of the data source for chip-level dynamic key negotiation for sensor data are met, thereby improving the security and reliability of the entire key negotiation scheme.

[0060] Example 3: See Figure 3 In this embodiment, the generation process of the dynamic key seed matrix and related processing are described in detail. Physical unclonable eigenvalues ​​are extracted based on the unique hardware identifier of the sensor node. Each sensor node is assigned a unique hardware identifier (such as a chip serial number, MAC address, etc.) during manufacturing. During the production process, the corresponding chip will generate random noise patterns due to deviations in the silicon wafer manufacturing process (such as uneven doping concentration, fluctuations in photolithography line width, etc.). These patterns are unique and cannot be cloned by physical means, constituting physical unclonable eigenvalues. These noise patterns can be collected and converted into digital signals through the chip's built-in detection circuitry or external test equipment. For example, the voltage fluctuation signal on the silicon wafer surface can be quantized into a binary sequence, which serves as a specific manifestation of the physical unclonable eigenvalue.

[0061] A multidimensional parameter vector is constructed by combining the data acquisition timestamp, data acquisition frequency, and sensor node state parameters (node ​​voltage, ambient temperature). The data acquisition timestamp records the moment of data acquisition in numerical form (such as Unix timestamp, accurate to milliseconds), the data acquisition frequency is the number of times the sensor collects data per second (unit: Hz), the node voltage is the real-time voltage value of the sensor power supply (unit: V), and the ambient temperature is the real-time temperature value of the environment in which the sensor is located (unit: ℃). These parameters are arranged in a fixed order to form a multidimensional parameter vector, for example, the vector form is ,in Indicates the data collection timestamp, Indicates the frequency of data collection, represents the node voltage, Represents the ambient temperature. This vector comprehensively reflects the working status and environmental information of the sensor node at the time of data collection.

[0062] Perform principal component analysis (PCA) dimensionality reduction on the multidimensional parameter vector. The core of principal component analysis is to convert the original multidimensional variables into a few uncorrelated principal components through linear transformation. These principal components can retain the main variance information of the original data. The specific steps are as follows: Collect multidimensional parameter vectors at multiple moments to form the original data set , where each row corresponds to a vector at a moment, and each column corresponds to a parameter dimension (such as timestamp, acquisition frequency, etc.); the original data set is standardized so that the parameters of each dimension have the same dimension (for example, dividing the timestamp by Convert to second units and normalize voltage and temperature); calculate the covariance matrix of the standardized data set , the diagonal elements of the covariance matrix are the variances of the parameters of each dimension, and the non-diagonal elements are the covariances between the parameters of each dimension; the covariance matrix is ​​decomposed by eigenvalue , and get the eigenvalue and the corresponding eigenvector , the size of the eigenvalue reflects the proportion of variance explained by the corresponding principal component; arrange the eigenvalues ​​in descending order, calculate the cumulative variance contribution rate of each eigenvalue, and retain the cumulative variance contribution rate that exceeds the preset threshold (e.g. 85%), remove the components with lower contribution rate. Assuming that the original multidimensional parameter vector is 4-dimensional, after principal component analysis, retain the first principal components ( ), then the principal component after dimensionality reduction can be expressed as , where each is the original parameter vector in The projection value on the eigenvector, that is, , where For the The transpose of the eigenvectors, is the standardized multidimensional parameter vector.

[0063] Arrange the principal component components after dimensionality reduction in time series to form a dynamic key seed matrix. As time goes by, each time the sensor node collects data, a new multidimensional parameter vector will be generated. After principal component analysis and dimensionality reduction, new principal component components are obtained. These components are arranged in the order of collection time, with each row corresponding to a principal component vector at a moment and each column corresponding to a principal component dimension, thus forming a Matrix ,in is the number of collections, The number of principal components. For example, if data is collected once an hour for 24 hours and two principal components are retained, the dynamic key seed matrix contains 24 rows and 2 columns of data, with each row recording the two principal component values ​​at a certain moment.

[0064] In the process of splicing data feature sequences, the dynamic time warping (DTW) algorithm needs to be used to align the time dimension of the data feature sequence and the dynamic key seed matrix. Since the data feature sequence is extracted based on a set length data segment of a single data acquisition, its time length may be different from the parameter vector of a single time point in the dynamic key seed matrix. Therefore, it is necessary to adjust the time axis through the DTW algorithm to align the two in the time dimension. In the specific operation, the data feature sequence is regarded as a time series, and each principal component sequence in the dynamic key seed matrix is ​​regarded as another time series. By calculating the distance matrix of the elements in the two sequences, an optimal path is found so that the sum of the element distances on the path is minimized, thereby achieving curved alignment of the time axis. After alignment, the data feature sequence is spliced ​​into the dynamic key seed matrix as a new column or row. For example, if the dynamic key seed matrix is , the length of the data feature sequence is , then after splicing, Dynamic key generation matrix .

[0065] Perform singular value decomposition (SVD) on the concatenated dynamic key generation matrix and extract its singular value vector as the basic element for key generation. Singular value decomposition is to decompose the matrix into the product of three matrices, namely ,in and is an orthogonal matrix, is a diagonal matrix with diagonal elements being matrices The singular values ​​of ( is the number of columns of the matrix), and satisfies The singular value is stable. Even if the matrix elements change slightly, the singular value changes slowly. Therefore, the singular value vector is extracted. As the basic element of key generation, it can effectively characterize the characteristics of the matrix. In practical applications, the front can be selected according to the key length requirements. Singular values ​​( ), the core part of the dynamic negotiation key is generated through certain encoding rules (such as converting singular values ​​into binary sequences).

[0066] Throughout the entire process, the uniqueness of the physically unclonable eigenvalues ​​ensures the node specificity of the dynamic key seed matrix, the real-time nature of the multidimensional parameter vector ensures the dynamic nature of the key, the dimensionality reduction processing of the principal component analysis reduces the computational complexity while retaining key information, the alignment mechanism of dynamic time warping solves the problem of splicing data of different time scales, and the feature extraction of the singular value decomposition provides a stable and distinguishing basis for key generation. The parameters of each link (such as the preset threshold , the number of principal components , the number of singular values ​​selected It can be flexibly adjusted according to the computing power and security level requirements of the sensor nodes to strike a balance between key security and system resource consumption.

[0067] Example 4: In this embodiment, the verification mechanism for dynamically negotiated keys involves a two-way interaction and dual verification process between the sensor node and the cloud server. Taking a temperature sensor node in an industrial IoT scenario as an example, the verification process for the dynamically negotiated key is as follows:

[0068] After generating a dynamically negotiated key, the sensor node performs a secondary obfuscation process on the key in a local secure storage unit. Assuming the dynamically negotiated key is a 128-bit binary sequence, it is encrypted using a lightweight encryption algorithm (such as a simplified AES algorithm). In specific operations, the sensor node's built-in microcontroller reads the original key from the secure storage unit, invokes the encryption algorithm module, and inputs a preset obfuscation key (such as a fixed 64-bit seed key). After multiple rounds of byte substitution, row shifting, and column mixing, it generates a 128-bit obfuscated key tag. This obfuscated key tag corresponds one-to-one with the original key, but the original key cannot be directly retrieved through reverse operations, thereby enhancing the security of the key during storage and transmission.

[0069] When the cloud server receives the dynamically negotiated key, it simultaneously processes the obfuscated key tag. The server first calculates the hash digest value of the obfuscated key tag, for example, using the SHA-256 hash algorithm. The 128-bit obfuscated key tag is input into the algorithm. After padding, grouping, and compression, a 256-bit hash digest value is generated. This digest value is then associated with the corresponding sensor node identifier and stored in the database. The irreversibility of the hash digest value ensures that even if the digest value stored on the server is leaked, an attacker cannot use it to restore the original content of the obfuscated key tag.

[0070] When the validity of the dynamically negotiated key needs to be verified, the sensor node's main control module (such as an STM32 series microcontroller) initiates the verification process. First, the main control module reads the obfuscated key tag from a local secure storage unit. This storage unit uses hardware-encrypted storage technology (such as an encrypted EEPROM partition) to ensure that only authenticated modules can access it. After reading the tag, the main control module invokes a built-in hash calculation unit to hash the obfuscated key tag, generating a 256-bit hash value that matches the one on the cloud server. Assuming the obfuscated key tag is "101011001101..." (actually a 128-bit binary number), the calculated hash value is "d41d8cd98f00b204e9800998ecf8427e..." (256-bit hexadecimal representation).

[0071] The sensor node sends the hash value to the cloud server via a wireless communication module (such as Wi-Fi or LoRa). After receiving the hash value, the cloud server first retrieves the corresponding hash digest value from the database based on the sensor node's ID. For example, the sensor node ID is "SN001," and its corresponding hash digest value is the pre-stored "d41d8cd98f00b204e9800998ecf8427e..." The server compares the received hash value with the stored digest value bit by bit. If the two are identical, the plaintext matching process for the dynamically negotiated key is triggered. If not, the server immediately returns a key invalidation signal.

[0072] During the plaintext matching process, the cloud server must verify the consistency between the dynamic negotiated key held by the sensor node and the key stored on the server. Since the dynamic negotiated key is encrypted and stored on the cloud server after generation (e.g., using the RSA algorithm), the server first calls the decryption module and uses its private key to decrypt the encrypted dynamic negotiated key, obtaining the original key in plaintext. For example, the encrypted key is ciphertext encrypted with the RSA public key. The server decrypts it using its private key to obtain "010100111001..." (a 128-bit binary number). Simultaneously, the sensor node sends its stored plaintext dynamic negotiated key to the server via a secure channel (e.g., encrypted via TLS). Upon receiving the plaintext key, the server compares it bit by bit with the decrypted key, starting with the first bit ("0") and checking each bit for identity until the last bit ("1"). If all bits match, the key is considered valid and a key validity signal is returned. If any bit differs, the key is considered invalid.

[0073] The dual nature of this verification mechanism is reflected in two aspects: first, hash value comparison ensures the integrity of the obfuscated key tag, preventing the key from being tampered with during storage or transmission; second, plaintext bit-by-bit comparison ensures that the sensor node and the server hold the same original key, avoiding authentication failures due to key inconsistency. Taking the attacks that sensor nodes may face in industrial scenarios as an example, if an attacker attempts to tamper with the locally stored obfuscated key tag, the generated hash value will be inconsistent with the digest value stored in the cloud, and thus be rejected in the first step of verification. If the attacker bypasses the first step of verification by forging a hash value, the second step of bit-by-bit comparison will also fail because the attacker cannot obtain the correct plaintext of the dynamically negotiated key.

[0074] In specific implementations, the choice of lightweight encryption algorithm must be tailored to the computing power of the sensor node. For example, for resource-constrained, low-power sensors (such as those using the ARM Cortex-M0 core), a simpler encryption algorithm can be used to reduce computational time and memory usage. For edge nodes with higher computing power, the standard AES algorithm can be used for improved security. The choice of hash algorithm also requires a balance between security and performance. The SHA-256 algorithm offers high security while maintaining moderate computational complexity, making it suitable for most IoT scenarios.

[0075] Communication security is crucial during the authentication process. The transmission of hash values ​​and plaintext keys between the sensor node and the cloud server must occur over an encrypted channel (such as SSL / TLS) to prevent man-in-the-middle attacks from intercepting transmitted data. Furthermore, the cloud server must pre-authenticate the sensor node's identity (e.g., through hardware certificates or pre-shared keys) to ensure that only legitimate nodes can initiate authentication requests, preventing malicious devices from spoofing their identities and attempting key authentication.

[0076] The entire verification process utilizes a multi-layered security mechanism to ensure the authenticity and integrity of dynamically negotiated keys. From the generation of obfuscated key tags to hash value comparison and bit-by-bit verification of the plaintext key, each step incorporates safeguards against potential security threats, providing reliable key authentication for the secure transmission of sensor data. This mechanism is applicable not only to industrial temperature sensors but is also extendible to other sensor node types (such as vibration and humidity sensors). Simply adjusting the encryption algorithm and transmission method based on the node's computing resources and communication protocol ensures high versatility and scalability.

[0077] Example 5: See Figure 4 In this implementation, the dynamic key update mechanism revolves around the sensor node's environmental parameter monitoring, anomaly determination, and key update process. Taking a vibration sensor node deployed on a factory production line as an example, the dynamic key update process is as follows:

[0078] The sensor node uses a built-in temperature sensor, voltage monitoring circuit, and data acquisition controller to monitor three key environmental parameters in real time: ambient temperature change rate, power supply voltage fluctuation, and data acquisition interruption frequency. The temperature sensor collects ambient temperature values ​​once per second. For example, within a 10-minute period, the monitored temperatures may be 25°C, 25.3°C, 25.7°C, 26.1°C, and so on. By calculating the temperature difference between adjacent moments, the per-minute temperature change rate is calculated. Assuming the temperature rises from 25.5°C to 26.2°C in the third minute, the temperature change rate for that minute is (26.2-25.5) / 1 = 0.7°C / minute. If the temperature drops sharply from 28°C to 25°C within a minute, the change rate is -3°C / minute, exceeding the ±2°C / minute threshold and triggering an environmental parameter anomaly.

[0079] The supply voltage fluctuation amplitude is monitored by comparing the real-time voltage with the rated voltage. The vibration sensor's rated voltage is 3.3V. The node's built-in voltage monitoring circuit collects the supply voltage in real time. For example, if the voltage is 3.0V at a certain moment and the fluctuation amplitude is (3.0-3.3) / 3.3×100%≈-9.1%, exceeding the -5% threshold of the rated voltage, it is considered a voltage anomaly. The data collection interruption frequency is determined by counting the number of data collection tasks that are not completed on time per minute. For example, if the sensor is preset to collect data 60 times per minute (once per second), and only 55 data collections are completed in a minute, the number of interruptions is 5, exceeding the threshold of 3 per minute, and is considered a data collection interruption anomaly.

[0080] When any parameter exceeds a preset threshold, the sensor node's main control module (such as an FPGA chip with an integrated microcontroller) immediately flags an environmental parameter anomaly and initiates a key update counter. This counter is an accumulator in non-volatile memory that records the number of anomalies within a 10-minute period. For example, if an abnormal temperature rate of change (+2.5°C / minute) is detected at t=0, the counter increments by 1; at t=3 minutes, a voltage fluctuation of -6% is detected, and the counter increments to 2; at t=5 minutes, another abnormal temperature rate of change (-2.2°C / minute) is detected, and the counter increments to 3; at t=8 minutes, the data collection interruption frequency reaches 4 times / minute, and the counter increments to 4; at t=9 minutes, the voltage fluctuation of +7% is detected, and the counter increments to 5. At this point, the cumulative number of anomalies in 10 minutes has reached 5, and the main control module determines that the current environment presents a high security risk and sends a key update request to the cloud server.

[0081] After receiving the request, the cloud server triggers the key update process. First, the server regenerates the dynamic key seed matrix based on the sensor node's unique hardware identifier (e.g., chip ID: SN-VIB-001). This new seed matrix is ​​generated based on the node's latest hardware characteristics and acquisition parameters. For example, it extracts the physical unclonable eigenvalues ​​of the current chip (e.g., the most recently monitored silicon noise pattern). This is combined with the latest acquisition timestamp (e.g., Unix timestamp: 1740921600000), acquisition frequency (1Hz), node voltage (3.2V), and ambient temperature (26°C) to construct a multidimensional parameter vector. Principal component analysis (PCA) reduces the dimensionality of the matrix to form a new seed matrix. Assuming the original seed matrix has 10 rows and 2 columns, the new matrix is ​​generated based on the most recent 10 acquisitions, also with 10 rows and 2 columns, but each row of data differs due to real-time parameter changes.

[0082] After generating a new seed matrix, the cloud server sends it to the sensor node via a secure communication channel (such as the HTTPS protocol). Upon receiving the new seed matrix, the node generates a new dynamic negotiation key: first, it randomly selects a data segment of a set length from the current data stream (for example, randomly intercepting 200 data points starting at the 200th point from the most recently collected 1000 vibration data points). It then extracts the data feature sequence and concatenates it with the new seed matrix to form a dynamic key generation matrix. This matrix is ​​then encrypted using the SM3 hash algorithm to generate a new dynamic negotiation key. Throughout this process, the node automatically destroys historical keys stored in the local security unit to ensure that old keys are no longer used.

[0083] At the same time, the cloud server performs a historical key destruction operation, deleting all old dynamically negotiated key records associated with this node from the database. This includes the encrypted plaintext key and the hash digest value of the obfuscated key tag. This destruction process utilizes a secure deletion algorithm to ensure that data cannot be recovered through technical means, thus minimizing the risk of historical key leakage. For example, the database field storing the old key is overwritten multiple times (e.g., by filling it with all zeros or random bytes) and the access log is updated to record the key destruction timestamp and operation identifier.

[0084] The triggering conditions for the dynamic key update mechanism must be tailored to the sensor's actual application scenario. In a factory production line scenario, sudden changes in ambient temperature may indicate equipment overheating or cooling system failure. Voltage fluctuations may be caused by an unstable power grid or poor line contact. Data collection interruptions may be caused by sensor hardware failure or communication link anomalies. These anomalies can affect the security of sensor nodes. For example, hardware failures may cause abnormalities in the key generation module, and communication interruptions may expose nodes to the risk of unencrypted transmission. Therefore, by monitoring and counting anomalies in real time, deterioration of the node's operating environment can be detected promptly, allowing for proactive key updates to address potential security threats.

[0085] In specific implementations, the monitoring frequency and threshold settings for environmental parameters must balance sensitivity and interference resistance. For example, setting the temperature rate of change monitoring frequency to once per minute can avoid false triggers caused by short-term noise fluctuations. Setting the voltage fluctuation threshold to ±5% rather than ±3% can accommodate small voltage fluctuations common in industrial environments. Regarding the frequency of data collection interruptions, if the sensor has data buffering capabilities, occasional interruptions (e.g., three per minute) can be tolerated, but frequent interruptions (over five per minute) are considered a serious anomaly.

[0086] Furthermore, the key update counter's 10-minute window must match the sensor node's key lifecycle. If a node typically generates a new key every hour, a 10-minute window ensures timely triggering of updates during periods of high abnormal activity, without accumulating risks due to an excessively long window. The secure communication channel during the update process utilizes a two-way authentication mechanism. The sensor node sends a digital signature (generated based on a pre-shared key) with each request, and the cloud server verifies the signature before responding to the request. This prevents erroneous key updates caused by forged requests.

[0087] The dynamic key update mechanism dynamically responds to the security status of sensor nodes through multi-dimensional environmental parameter monitoring, abnormality threshold determination, and an automated key update process. Taking a vibration sensor as an example, this mechanism can promptly replace keys when the device's operating environment deteriorates or a node anomaly occurs, reducing the risk of key leakage due to environmental changes and ensuring the confidentiality and integrity of sensor data during transmission and storage. This mechanism is not only applicable to industrial IoT scenarios but can also be extended to sensor nodes in areas such as intelligent transportation and medical monitoring. By flexibly adjusting monitoring parameters and thresholds, it can adapt to the security needs of different application environments.

[0088] It should be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "comprises," "includes," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus.

[0089] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A sensor data chip-level dynamic key negotiation method, characterized in that: The method comprises: Obtaining a unique hardware identifier for the sensor node and recording key parameters during the sensor data acquisition process, the key parameters including a data acquisition timestamp, a data acquisition frequency, and state parameters of the sensor node; the state parameters including node voltage and ambient temperature; and generating a dynamic key seed matrix based on the unique hardware identifier and the key parameters. After the sensor data is collected, a data segment of a set length is randomly selected from the sensor data stream, feature information of the data segment is extracted, and a data feature sequence is generated; the data feature sequence is spliced ​​into the dynamic key seed matrix to obtain a dynamic key generation matrix; Encrypting the dynamic key generation matrix to generate a dynamic negotiation key, and storing the dynamic negotiation key in a secure storage unit of a cloud server and a sensor node; During key verification, the dynamic negotiated key in the secure storage unit of the sensor node is read and matched with the dynamic negotiated key in the cloud server. In response to a successful match, a key valid signal is returned; in response to a failed match, a key invalid signal is returned. The method for generating the dynamic key seed matrix includes: Based on the unique hardware identifier of the sensor node, its physical unclonable eigenvalue is extracted, and the physical unclonable eigenvalue includes a random noise pattern generated by silicon wafer manufacturing process deviation; a multidimensional parameter vector is constructed by combining the data acquisition timestamp, data acquisition frequency, and state parameters of the sensor node; the multidimensional parameter vector is subjected to principal component analysis dimensionality reduction processing, and the principal component components whose variance contribution rate exceeds a preset threshold are retained; the principal component components after dimensionality reduction are arranged in time series to form a dynamic key seed matrix; during the splicing process of the data feature sequence, a dynamic time warping algorithm is used to align the time dimension of the data feature sequence and the dynamic key seed matrix; the spliced ​​dynamic key generation matrix is ​​subjected to singular value decomposition, and its singular value vector is extracted as the basic element for key generation; The dynamic key generation matrix is ​​stored in a local secure storage unit of the sensor node; The verification mechanism of the dynamically negotiated key includes: In the local secure storage unit of the sensor node, a lightweight encryption algorithm is used to perform secondary obfuscation processing on the dynamically negotiated key to generate an obfuscated key tag; the cloud server synchronously stores the hash summary value of the obfuscated key tag; During key verification, the main control module reads the obfuscated key tag and calculates its hash value, and sends the hash value to the cloud server; the cloud server compares the received hash value with the stored hash summary value, and triggers the plaintext matching process of the dynamic negotiation key in response to a consistency; in the plaintext matching process, the cloud server decrypts the stored encrypted dynamic negotiation key and compares it bit by bit with the plaintext dynamic negotiation key sent by the sensor node; in response to a complete match, it returns a key validity signal.

2. A sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: Methods for obtaining data feature sequences include: A sliding window algorithm is used to obtain the local statistical features of the data segment to obtain a statistical feature matrix; a hierarchical clustering algorithm is used to obtain a set number of cluster groups in the statistical feature matrix, and the centroids of the cluster groups constitute a centroid sequence; based on autocorrelation analysis, the global features of the data segment are obtained to obtain an eigenvalue sequence, and the eigenvalue sequence includes mean, variance, peak factor, kurtosis and waveform factor; the elements in the centroid sequence and the eigenvalue sequence are added bit by bit to obtain a data feature sequence.

3. The sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: Randomly select a data segment of a set length from the sensor data stream, including: A starting time point is randomly selected in the sensor data stream, and a data segment of a preset length is intercepted based on the starting time point.

4. The sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: The triggering conditions for the dynamic key update mechanism include: Real-time monitoring of the ambient temperature change rate, power supply voltage fluctuation range, and data acquisition interruption frequency of the sensor node; when the ambient temperature change rate exceeds ±2°C / minute, the voltage fluctuation range is greater than ±5% of the rated voltage, or the data acquisition interruption frequency reaches 3 times per minute, it is determined that the environmental parameters are abnormal; In response to abnormal environmental parameters, the main control module starts the key update counter; if the counter accumulates more than 5 abnormal times within 10 minutes, it sends a key update request to the cloud server; the cloud server generates a new dynamic key seed matrix and sends it to the sensor node, while destroying the cloud storage record of the historical dynamic negotiated key.

5. The sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: The data segment also includes preprocessing operations: using a median filtering algorithm to suppress noise, and using a normalization algorithm to adjust the data amplitude range.

6. The sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: The encryption process is performed on the dynamic key generation matrix, comprising: Performing minimum-maximum normalization processing on the dynamic key generation matrix, arranging all data in the normalized dynamic key generation matrix in order from left to right and from top to bottom to obtain a data stream; encrypting the data stream using the SM3 hash algorithm.

7. The sensor data chip-level dynamic key negotiation method according to claim 1, characterized in that: The dynamic negotiated key is destroyed from the cloud server after successful verification.

Images