Incremental hot patching methods and systems for server hardware firmware vulnerabilities

Abstract

This application provides a method and system for incremental hot patching of server hardware firmware vulnerabilities, relating to the field of server hardware firmware repair technology. This application identifies abnormal function nodes with abnormal power consumption by acquiring the operating status data of multiple functional modules; then, based on these nodes, it dynamically adjusts the power state of specific modules and collects power consumption change data when the power supply changes; next, it associates this data with the execution cycle of specific module functions to establish a mapping relationship between function calls and power consumption modes to mark functions to be repaired; subsequently, it generates corresponding hot patch function code and stores it in the system's secure memory area; finally, when a specific module meets low-power conditions, it switches the execution flow of the function to be repaired to the hot patch code through function jump redirection, completing the incremental hot patching of vulnerabilities. This method can accurately identify abnormal functions in server hardware firmware and generate hot patches, and switch the execution flow when a specific module is at low power consumption, thus achieving incremental hot patching of firmware vulnerabilities.

Description

Technical Field

[0001] This application relates to the field of server hardware firmware repair technology, and in particular to a method and system for incremental hot patching of server hardware firmware vulnerabilities. Background Technology

[0002] In edge computing scenarios, servers are often deployed in environments with limited energy supply, such as industrial sites and remote areas. They must undertake core tasks such as data acquisition, localized computing, and low-latency response, while strictly controlling energy consumption to reduce maintenance costs and energy consumption pressure. Hardware firmware, as the core hub for interaction between server hardware and software, directly determines the device's operating status. Firmware vulnerabilities can lead to device downtime, data leaks, or surges in power consumption. Because edge nodes are typically deployed in a dispersed and numerous manner, and maintenance personnel cannot quickly reach the site, firmware vulnerability remediation must meet stringent requirements such as uninterrupted business operations, low network bandwidth usage, and low storage resource consumption. This poses a significant challenge to the energy efficiency and precise operation capabilities of hotfix technologies.

[0003] Currently, the mainstream solution for firmware vulnerability hot patching in this scenario is a hot patching technique based on full function replacement. This solution first uses a static decompilation tool to analyze the firmware image and locates the vulnerable target function using a vulnerability signature database. Then, according to the original function's code structure and interface specifications, a full replacement hot patch containing complete repair logic is generated. The patch not only includes the vulnerability repair code but also all normal business logic of the original function. Finally, during system operation, the hot patch is injected into memory using dynamic loading technology, pausing the execution flow of the original function and overwriting its code segment. Execution resumes after the patch is loaded, thus achieving vulnerability repair without restarting the server.

[0004] However, this solution has significant drawbacks in edge computing scenarios where energy efficiency is limited: full function replacement requires transmitting patch files containing complete function logic. For functions with large amounts of code, the patch size is usually large, resulting in long transmission times under the limited network bandwidth of edge nodes, and also consuming too much local storage resources; pausing the execution of the original function during the replacement process can cause momentary interruptions in the business process, which may lead to data loss or response delays for edge services with high real-time requirements; in addition, full replacement may disrupt the original power balance due to modifications in the relationship logic or calling relationship between functions, leading to new power consumption anomalies, which seriously contradicts the core requirement of low power consumption and high efficiency in edge computing. Summary of the Invention

[0005] The purpose of this application is to provide a method and system for incremental hot patching of server hardware firmware vulnerabilities, in order to solve the problems of existing full function replacement hot patching schemes consuming too many resources, easily causing business interruptions, and potentially leading to abnormal power consumption in energy-constrained scenarios.

[0006] To address the aforementioned technical problems, in a first aspect, this application provides a method for incremental hot patching of server hardware firmware vulnerabilities, comprising:

[0007] Obtain the operating status data of multiple functional modules in the server hardware firmware, and identify abnormal function nodes with abnormal power consumption based on the operating status data;

[0008] Based on the abnormal function node, the power state of a specific module in the functional module is dynamically adjusted, and the power consumption change data of the specific module during the power supply state change process is collected.

[0009] The power consumption change data is associated with the function execution cycle of the specific module to establish a mapping relationship between function calls and power consumption modes, so as to mark the functions to be repaired;

[0010] Generate hot patch function code corresponding to the function to be repaired, and store the hot patch function code in a secure area of ​​system memory;

[0011] When the specific module meets the low power consumption condition, the execution flow of the function to be repaired is switched to the hot patch function code through function jump redirection, thereby completing the incremental hot patching of the vulnerability in the server hardware firmware.

[0012] Optionally, generating the hot patch function code corresponding to the function to be repaired and storing the hot patch function code in a secure area of ​​system memory includes:

[0013] Code analysis was performed on the function to be repaired to locate the problematic code segment causing abnormal power consumption;

[0014] Based on the problematic code segment, generate a hot patch function code that is functionally equivalent but has improved power consumption characteristics, and ensure that the hot patch function code has the same input / output interface as the function to be repaired;

[0015] The generated hot patch function code is encrypted, and the encrypted and signed hot patch function code is written into the secure area of ​​the system memory through the secure memory manager. The access permission of the secure area is set to read-only through the memory management unit.

[0016] Optionally, the step of generating functionally equivalent but power-efficient hot-patch function code based on the problematic code segment, and ensuring that the hot-patch function code has the same input / output interfaces as the function to be repaired, includes:

[0017] The problematic code segment is subjected to instruction-level power consumption analysis to identify the core instruction sequence that generates abnormal power consumption in the problematic code segment. Based on predefined low-power instruction replacement rules, the high-power instructions are replaced with functionally equivalent low-power instruction combinations.

[0018] The control flow structure of the problematic code segment is reconstructed, the computationally intensive loop is decomposed into multiple interleaved sub-loops, and a controllable sleep cycle is inserted between each sub-loop to reduce the peak power consumption per unit time.

[0019] Optimize the memory access mode of the problematic code segment by reorganizing randomly distributed memory access requests into a sequential batch access mode, thereby reducing the active time of the memory controller.

[0020] By replacing, reconstructing, and optimizing the content in the problematic code segment, hot patch function code is generated. During the code generation phase, the call stack frame layout, parameter passing mechanism, and return value handling method of the hot patch function code are strictly kept to be completely consistent with the function to be repaired. Interface consistency verification ensures the compatibility of the two at the binary level.

[0021] Optionally, associating the power consumption change data with the function execution cycle of the specific module to establish a mapping relationship between function calls and power consumption modes to mark functions to be repaired includes:

[0022] The power consumption change data is correlated with the function execution cycle of the specific module in terms of time, and the function execution cycle is defined by the function call instruction and the function return instruction;

[0023] From the power consumption change data corresponding to each function execution cycle, extract the power consumption change curve within the corresponding cycle as the power consumption mode of the corresponding function;

[0024] The power consumption mode of each function is compared with the preset normal power consumption range. When the power consumption mode of a function exceeds the normal power consumption range, the corresponding function is marked as a function to be repaired.

[0025] Optionally, when the specific module meets the low-power condition, the execution flow of the function to be repaired is switched to the hot-patching function code through function jump redirection to complete the incremental hot patching of the vulnerability in the server hardware firmware, including:

[0026] The current power consumption value of the specific module is continuously monitored. When the current power consumption value is lower than the preset power consumption threshold, it is determined that the low power consumption condition is met.

[0027] When the low power consumption condition is met, modify the jump address corresponding to the function to be repaired in the function jump table of the server hardware firmware, and replace the original jump address with the storage address of the hot patch function code in the system memory safe area;

[0028] When the function to be repaired is called, the execution flow is automatically redirected to the hot-patched function code through the function jump table;

[0029] The hot patch function code is executed to replace the function to be repaired, thereby completing the incremental hot patching of the vulnerability in the server hardware firmware.

[0030] Optionally, the step of dynamically adjusting the power state of a specific module in the functional module based on the abnormal function node, and collecting power consumption change data of the specific module during the power supply state change process, includes:

[0031] Determine the specific module to which the abnormal function node belongs;

[0032] During the continuous operation of the server hardware firmware, the power supply voltage and clock frequency of the specific module are gradually adjusted in a cyclic manner through a power consumption gating circuit.

[0033] After each adjustment of the power supply voltage and clock frequency, power consumption change data of the specific module is collected. The power consumption change data includes the current voltage value, the current frequency value, and the corresponding power consumption value.

[0034] Optionally, the step of acquiring the operating status data of multiple functional modules in the server hardware firmware, and identifying abnormal function nodes with abnormal power consumption based on the operating status data, includes:

[0035] Collect current and voltage measurements from multiple functional modules in the server hardware firmware as operating status data;

[0036] For each function node in a functional module, during the normal operation of the server, the running status data of the function node during execution is periodically acquired, and the reference power consumption value of the corresponding function node is determined based on the running status data.

[0037] A power consumption deviation threshold is set, which is determined based on a fixed proportion of the reference power consumption value;

[0038] During server operation, the current running status data of each function node is continuously monitored and the node power consumption value is calculated. When the node power consumption value meets the predetermined power consumption condition multiple times, the corresponding function node is marked as an abnormal function node with abnormal power consumption. The predetermined power consumption condition is set according to the reference power consumption value and the power consumption deviation threshold.

[0039] Secondly, this application provides a server hardware firmware vulnerability incremental hot patching system, comprising:

[0040] The acquisition module is used to acquire the running status data of multiple functional modules in the server hardware firmware, and to identify abnormal function nodes with abnormal power consumption based on the running status data.

[0041] The acquisition module is used to dynamically adjust the power state of a specific module in the functional module based on the abnormal function node, and to acquire the power consumption change data of the specific module during the power supply state change process.

[0042] The marking module is used to associate the power consumption change data with the function execution cycle of the specific module, establish a mapping relationship between function calls and power consumption modes, and mark the functions to be repaired;

[0043] The generation module is used to generate hot patch function code corresponding to the function to be repaired, and store the hot patch function code in a secure area of ​​the system memory.

[0044] The repair module is used to switch the execution flow of the function to be repaired to the hot patch function code through function jump redirection when the specific module meets the low power consumption condition, so as to complete the incremental hot patching of the vulnerability in the server hardware firmware.

[0045] Thirdly, this application provides an electronic device, comprising:

[0046] Memory, used to store computer programs;

[0047] A processor, configured to implement the steps of the incremental hot patching method for server hardware firmware vulnerabilities as described in the first aspect above when executing the computer program.

[0048] Fourthly, this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, can implement the steps of the incremental hot patching method for server hardware firmware vulnerabilities as described in the first aspect above.

[0049] The incremental hot patching method for server hardware firmware vulnerabilities provided in this application accurately identifies function nodes with abnormal power consumption by acquiring runtime status data. It establishes a mapping relationship between power consumption change data collected by dynamically adjusting power status and function execution cycle, which can accurately mark the functions to be repaired. The generated incremental hot patch code is stored in a secure area, and the execution flow is switched by jump redirection only when specific modules meet the low power consumption conditions. This not only realizes incremental repair of server hardware firmware vulnerabilities to reduce resource consumption, but also avoids business interruption during the repair process, and reduces the additional power consumption caused by the repair operation. It is suitable for the low-power, high-efficiency, and non-interrupted business requirements of firmware hot repair in energy-constrained scenarios such as edge computing.

[0050] Furthermore, the code of the marked functions to be repaired is first analyzed to locate the problematic code segment causing abnormal power consumption. Then, based on this problematic code segment, a hot patch function with equivalent functionality but better power consumption characteristics is generated, ensuring that its input / output interfaces are consistent with the function to be repaired. Finally, the generated hot patch function code is encrypted, and the encrypted and signed code is written to a secure area of ​​system memory through a secure memory manager. The access permissions of this secure area are set to read-only using the memory management unit. By accurately locating the problematic code segment, the generated hot patch effectively addresses the abnormal power consumption problem. The design of functional equivalence and consistent interfaces ensures the compatibility of the patch with the original system, avoiding functional conflicts. Encryption, secure area storage, and read-only permission settings effectively prevent the patch from being tampered with or illegally accessed, improving the security of the hot patch process. At the same time, the improved power consumption characteristics further adapt to the needs of energy-constrained scenarios. Attached Figure Description

[0051] To more clearly illustrate the technical solutions of the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0052] Figure 1 A flowchart illustrating a method for incremental hot patching of server hardware firmware vulnerabilities provided in this application embodiment;

[0053] Figure 2 A flowchart illustrating a specific embodiment of a server hardware firmware vulnerability incremental hot patching method provided in this application;

[0054] Figure 3 A schematic diagram of a specific embodiment of a server hardware firmware vulnerability incremental hot patching method provided in this application;

[0055] Figure 4 This is a schematic diagram of the structure of a server hardware firmware vulnerability incremental hot patching system provided in an embodiment of this application. Detailed Implementation

[0056] In energy-constrained edge computing scenarios, existing firmware hot-repair solutions based on full function replacement have significant drawbacks: full patch files are large, resulting in long transmission times and excessive storage resources under limited bandwidth; pausing the original function execution during replacement can easily cause momentary service interruptions, potentially leading to data loss or response delays; and it may disrupt the power balance between functions, generating new power anomalies, which contradicts the requirements for low power consumption and high efficiency. These problems stem from the indiscriminate full processing of functions in the current solution, necessitating a precise, low-power, and non-interruptive hot-repair method.

[0057] To address the aforementioned issues, this application proposes an incremental hot patching method for server hardware firmware vulnerabilities. The core of this method lies in identifying abnormal power consumption function nodes through runtime status data, associating power consumption change data with function execution cycles to mark functions to be patched, generating incremental hot patches, and storing them in a secure memory area. When a specific module is at low power consumption, the patch is completed through function redirection. This method significantly reduces patch size and resource consumption through incremental patching; it avoids service interruption by switching during low-power periods; and it accurately locates abnormal functions to reduce power balance disruption. It fundamentally solves the resource consumption, service interruption, and abnormal power consumption problems of existing solutions, and is suitable for edge computing scenarios.

[0058] To enable those skilled in the art to better understand the present application, the present application will be further described in detail below with reference to the accompanying drawings and specific embodiments. Obviously, the described embodiments are merely some embodiments of the present application, and not all embodiments. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0059] The core of this application is to provide an incremental hot patching method for server hardware firmware vulnerabilities, and a flowchart of one specific implementation is shown below. Figure 1 As shown, the method includes:

[0060] S101. Obtain the running status data of multiple functional modules in the server hardware firmware, and identify abnormal function nodes with abnormal power consumption based on the running status data.

[0061] Optionally, step S101 may specifically include the following steps:

[0062] S1011. Collect current and voltage measurement values ​​from multiple functional modules in the server hardware firmware as operating status data;

[0063] S1012. For each function node in a functional module, during the normal operation of the server, periodically acquire the running status data of the function node during execution, and determine the reference power consumption value of the corresponding function node based on the running status data.

[0064] S1013. Set a power consumption deviation threshold, wherein the power consumption deviation threshold is determined based on a fixed proportion of the reference power consumption value;

[0065] S1014. During server operation, continuously monitor the current operating status data of each function node and calculate the node power consumption value. When the node power consumption value meets the predetermined power consumption condition multiple times, mark the corresponding function node as an abnormal function node with abnormal power consumption. The predetermined power consumption condition is set according to the reference power consumption value and the power consumption deviation threshold.

[0066] In this embodiment of the application, the current measurement values ​​and voltage measurement values ​​of multiple functional modules in the server hardware firmware are first collected as operating status data through step S1011.

[0067] Secondly, in step S1012, for each function node in the functional module, during the normal operation of the server, the running status data of the function node is recorded multiple times at fixed time intervals; the power consumption value is calculated based on each recorded running status data, and the calculation formula is as follows: power consumption value = current measurement value × voltage measurement value. Then, the power consumption values ​​of multiple times are added together and divided by the number of times they are recorded. The average value obtained is the reference power consumption value of the corresponding function node.

[0068] Next, a power consumption deviation threshold is set in step S1013, which is determined based on a fixed proportion of the reference power consumption value.

[0069] Specifically, if the calculated reference power consumption value of a certain function node is 60W, and a fixed percentage of 20% is set according to the stability requirements of server operation, then the reference power consumption value is multiplied by this fixed percentage, i.e., 60W × 20% = 12W. This 12W is the power consumption deviation threshold of the function node.

[0070] Finally, in step S1014, during the server operation, the current running status data of each function node is continuously monitored and the node power consumption value is calculated. The calculated node power consumption value is compared with the predetermined power consumption condition, which is set according to the reference power consumption value and the power consumption deviation threshold. For example, the predetermined power consumption condition is set as node power consumption value > reference power consumption value + power consumption deviation threshold. Finally, when the node power consumption value meets the predetermined power consumption condition multiple times, the corresponding function node is marked as an abnormal function node with abnormal power consumption.

[0071] In practical applications, when the E server hardware firmware is running, the current and voltage of its computing module, storage module, and communication module are first collected as operating status data. Then, for function node E1 of the computing module, function node E2 of the storage module, and function node E3 of the communication module, execution data is recorded 8 times at fixed intervals of 10 seconds during normal server operation, and the reference power consumption values ​​of E1 (55W), E2 (40W), and E3 (35W) are calculated. Then, a fixed ratio of 20% is set to obtain the threshold values ​​of E1 (11W), E2 (8W), and E3 (7W). Finally, each node is continuously monitored, and when the power consumption value of E2 node exceeds 48W (40W+8W) multiple times, E2 is marked as an abnormal function node.

[0072] S102. Based on the abnormal function node, dynamically adjust the power state of a specific module in the functional module, and collect the power consumption change data of the specific module during the power supply state change process.

[0073] Optionally, step S102 may specifically include the following steps:

[0074] S1021. Determine the specific module to which the abnormal function node belongs;

[0075] S1022. During the continuous operation of the server hardware firmware, the power supply voltage and clock frequency of the specific module are gradually adjusted in a cyclic manner through the power consumption gating circuit.

[0076] S1023. After each adjustment of the power supply voltage and clock frequency is completed, the power consumption change data of the specific module is collected. The power consumption change data includes the current voltage value, the current frequency value and the corresponding power consumption value.

[0077] In the above scheme, an abnormal function node refers to a function unit that has been marked as having abnormal power consumption. A specific module refers to the functional module in the server hardware firmware to which the abnormal function node belongs; that is, within which functional module does the abnormal function node execute its specific function? A power gating circuit refers to a circuit component used to control the power supply on / off of the functional module and adjust its power supply parameters. Power consumption change data refers to the set of data reflecting power consumption recorded by the specific module during changes in power supply status. The current voltage value refers to the actual power supply voltage value of the specific module after each adjustment. The current frequency value refers to the clock frequency value corresponding to the specific module after each adjustment. The corresponding power consumption value refers to the power consumption of the specific module under the current voltage and frequency values.

[0078] In this embodiment of the application, the specific module to which the abnormal function node belongs is first determined by step S1021.

[0079] Specifically, in the server hardware firmware, each function node has its own clear attribution information. When an abnormal function node A1 is identified, by querying the module function mapping table of the server firmware, the functional module A is the specific module corresponding to the abnormal function node A1.

[0080] Secondly, in step S1022, after determining the specific module to be adjusted during the continuous operation of the server hardware firmware, the power supply voltage and clock frequency of the module are gradually adjusted in a cyclic manner using a power gating circuit.

[0081] Specifically, if the initial value of the power supply voltage of a specific module is set to 12V and the fixed step size is set to 0.5V, the adjustment method of decreasing by step size is selected. Each time the adjustment is performed, the power supply voltage is first reduced by 0.5V from the current value, for example, from 12V to 11.5V. Then the clock frequency is adjusted accordingly. For example, if the original clock frequency is 1GHz, it is adjusted to 0.9GHz after the voltage is reduced. The adjustment operation is repeated continuously in this cyclical manner.

[0082] Finally, in step S1023, after each adjustment is completed, the current voltage value, current frequency value, and corresponding power consumption value are collected as power consumption change data, thus completing the process of dynamically adjusting the power state of a specific module based on the abnormal function node and collecting power consumption change data.

[0083] Specifically, when the power supply voltage of a specific module is adjusted from 12V to 11.5V and the clock frequency is synchronously adjusted to 0.9GHz, the voltage sensor, frequency sensor and power consumption detection element collect the current voltage value of 11.5V, the current frequency value of 0.9GHz and the corresponding power consumption value of 55W respectively. These three data are combined as the power consumption change data after one adjustment and stored.

[0084] The overall solution described in S102 involves identifying the specific module to which the abnormal function node belongs, thus clearly defining the target for adjustment and avoiding indiscriminate operations. Then, it dynamically adjusts the module's power supply voltage and clock frequency in a cyclical, step-by-step manner to ensure stable operation during the adjustment process. Finally, it collects power consumption change data under different power conditions. This data comprehensively presents the correlation between power supply parameters and power consumption, providing detailed data support for subsequently establishing a function call-power consumption pattern mapping and accurately marking functions to be repaired, thereby promoting the orderly progress of the vulnerability remediation process.

[0085] S103. Associate the power consumption change data with the function execution cycle of the specific module to establish a mapping relationship between function calls and power consumption modes, so as to mark the functions to be repaired;

[0086] Optionally, step S103 may specifically include the following steps:

[0087] S1031. The power consumption change data is correlated with the function execution cycle of the specific module in terms of time, wherein the function execution cycle is defined by the function call instruction and the function return instruction;

[0088] S1032. Extract the power consumption change curve within the corresponding cycle from the power consumption change data corresponding to each function execution cycle, and use it as the power consumption mode of the corresponding function.

[0089] S1033. Compare the power consumption mode of each function with the preset normal power consumption range. When the power consumption mode of a function exceeds the normal power consumption range, mark the corresponding function as a function to be repaired.

[0090] In the above scheme, a function call instruction is the command that triggers the start of function execution. A function return instruction is the command that returns a result after the function has completed execution. The time window of the function execution cycle refers to the time interval from the occurrence of the function call instruction to the occurrence of the function return instruction. The power consumption pattern refers to the overall characteristics of the function's power consumption performance, composed of a sequence of features. The function to be repaired refers to the function that has been determined to have an abnormal power consumption pattern.

[0091] In this embodiment of the application, firstly, during the execution of a specific module, the occurrence time of function call instructions and function return instructions is monitored in step S1031 to determine the time window of each function execution cycle. Then, the collected power consumption change data is allocated to the time window of each function execution cycle according to the timestamp, ensuring that each piece of data corresponds to the execution cycle of its respective function.

[0092] Specifically, during the execution of a specific module of the J-model server, the instruction monitoring program is activated. It detects that the function J1's call instruction occurs at 14:30:05, and the return instruction occurs at 14:30:08, determining the function's execution cycle time window to be 14:30:05-14:30:08. Simultaneously, three power consumption change data points are collected, with timestamps of 14:30:06, 14:30:07, and 14:30:09. The data with the first two timestamps within the window are allocated to the time window of function J1, while the data with the third timestamp exceeding the window is temporarily stored and awaits allocation to the corresponding function.

[0093] Secondly, in step S1032, the power consumption change data within the time window of each function execution cycle is processed to extract a feature sequence including power consumption peak, power consumption average and power consumption fluctuation frequency, and the feature sequence is used as the power consumption mode of the corresponding function.

[0094] Specifically, in the computation module of server K, six power consumption data points within the execution cycle time window of function K1—55W, 58W, 56W, 60W, 57W, and 59W—are processed. The calculated peak power consumption is 60W, the average power consumption is (55+58+56+60+57+59)÷6=57.5W, the time window duration is 3 seconds, the power consumption changes 5 times, and the fluctuation frequency is 5÷3≈1.67 times / second. These three characteristic data points are combined into a feature sequence to form the power consumption pattern of function K1.

[0095] Finally, in step S1033, the power consumption mode is matched and compared with the pre-stored normal function power consumption feature library, and the difference between the two is calculated. When the difference exceeds a set threshold, the function is determined to be abnormal. Based on the matching result, the function with abnormal power consumption mode is marked as a function to be repaired.

[0096] Specifically, in the storage module of server L, the power consumption pattern of function L1 (peak 70W, average 65W, fluctuation frequency 2 times / second) is compared with the power consumption pattern of normal functions in the storage module (peak 62W, average 60W, fluctuation frequency 1.2 times / second) in the normal function power consumption feature library. The difference between the two is calculated to be 0.25, while the preset difference threshold is 0.2. Because the difference exceeds the threshold, function L1 is determined to be abnormal and is marked as a function to be repaired.

[0097] The overall solution described in S103 establishes a complete abnormal function localization chain. First, it achieves precise matching of power consumption change data with function execution cycles through instruction monitoring, avoiding data confusion. Then, it extracts the raw power consumption data into power consumption patterns including peak, average, and fluctuation frequencies, simplifying the comparison dimensions. Finally, it matches the data with a normal function power consumption feature library, accurately marking the functions to be repaired based on differences. This entire process transforms fragmented data into clearly defined repair targets, ensuring accurate location of the functions to be repaired and providing crucial support for subsequent targeted hot patch generation and efficient repair processes.

[0098] S104. Generate hot patch function code corresponding to the function to be repaired, and store the hot patch function code in a secure area of ​​system memory;

[0099] Optionally, step S104 may specifically include the following steps:

[0100] S1041. Perform code analysis on the function to be repaired to locate the problematic code segment that causes abnormal power consumption;

[0101] S1042. Based on the problematic code segment, generate a hot patch function code with equivalent functionality but improved power consumption characteristics, and ensure that the hot patch function code has the same input / output interface as the function to be repaired.

[0102] S1043. The generated hot patch function code is encrypted, and the encrypted and signed hot patch function code is written into the secure area of ​​the system memory through the secure memory manager. The access permission of the secure area is set to read-only through the memory management unit.

[0103] Specifically, step S1042 includes the following processes: performing instruction-level power consumption analysis on the problematic code segment, identifying the core instruction sequence that generates abnormal power consumption in the problematic code segment, and replacing high-power instructions with functionally equivalent low-power instruction combinations based on predefined low-power instruction replacement rules; reconstructing the control flow structure of the problematic code segment, decomposing intensive computation loops into multiple interleaved sub-loops, and inserting controllable sleep cycles between each sub-loop to reduce the peak power consumption per unit time; optimizing the memory access mode of the problematic code segment, reorganizing randomly scattered memory access requests into a sequential batch processing access mode to reduce the proportion of active time of the memory controller; generating hot patch function code by replacing, reconstructing, and optimizing the content in the problematic code segment, and strictly maintaining the call stack frame layout, parameter passing mechanism, and return value processing method of the hot patch function code to be completely consistent with the function to be repaired during the code generation stage, and ensuring binary-level compatibility between the two through interface consistency verification.

[0104] In the above scheme, the problematic code segment refers to the execution path portion containing a specific instruction sequence that causes abnormal power consumption. The core instruction sequence refers to the key instruction combination within the problematic code segment that truly causes abnormal power consumption. Low-power instruction replacement rules refer to pre-defined rules that replace high-power instructions with low-power instructions while maintaining functionality. A computationally intensive loop refers to loop code that performs a large amount of computation and runs continuously. A sub-loop refers to a smaller loop formed by splitting a computationally intensive loop. A controllable sleep cycle refers to a controllable rest period inserted during code execution. Memory access mode refers to the way code accesses memory. Sequential batch access mode refers to the way multiple memory access requests are processed sequentially. Call stack frame layout refers to the structure of space allocated in the memory stack during function calls. Hot-patched function code refers to code used to fix vulnerabilities in functions to be patched. A secure memory manager refers to the component responsible for managing secure areas in system memory. Cryptographically signed hot-patched function code refers to hot-patched code that has been encrypted and has a verified signature added. A secure area refers to a region in system memory specifically used to store sensitive data and has access protection mechanisms. A memory management unit refers to the hardware component responsible for managing memory access permissions. Read-only attributes refer to the access permissions set for memory regions that can only be read and cannot be modified.

[0105] In the embodiments of this application, such as Figure 2As shown, firstly, a multi-dimensional code structure analysis is performed on the function to be repaired in step S1041. High-power execution paths are identified by constructing a function control flow graph. For example, a control flow graph is constructed for function A1, showing the execution branches from instruction 1 to instruction 20. By analyzing the power consumption data of each branch, it is found that the power consumption of the branch from instruction 5 to instruction 15 is significantly higher, and it is identified as a high-power execution path. Subsequently, combined with the power consumption change data, the data flow dependency is analyzed to locate the specific instruction sequence that causes abnormal power consumption. For example, by examining the data transmission and usage in this high-power path, it is found that the data processing of the consecutive instructions from instruction 8 to instruction 10 causes a sudden increase in power consumption, and it is determined to be a specific instruction sequence. The execution path containing the specific instruction sequence is marked as the problematic code segment that causes abnormal power consumption.

[0106] Secondly, in step S1042, instruction-level power consumption analysis is performed on the problematic code segment to identify the core instruction sequence. Based on the low-power instruction replacement rule, high-power instructions are replaced with functionally equivalent low-power instruction combinations. For example, the high-power multiplication instruction sequence in the problematic code segment is replaced with low-power shift and addition combination instructions according to the rule. Next, the control flow structure is reconstructed, and the intensive calculation loop is decomposed into multiple sub-loops. A controllable sleep cycle is inserted between the sub-loops. For example, a calculation loop that executes 100 times continuously is split into 5 sub-loops that execute 20 times each, and a 1-millisecond sleep cycle is inserted after each sub-loop. Then, the memory access mode is optimized, and random memory access is reorganized into sequential batch access to reduce the active time of the memory controller. During the code generation stage, the call stack frame layout, parameter passing mechanism, and return value handling method of the hot patch function are kept consistent with the function to be repaired. Binary-level compatibility is ensured through interface consistency verification, and the hot patch function code is generated.

[0107] Finally, the generated hot patch function code is encrypted in step S1043, for example, by using a symmetric encryption algorithm to ensure that the code content cannot be easily obtained. The encrypted hot patch function code is written to a secure area of ​​the system memory by a secure memory manager. The secure memory manager first verifies the validity of the encryption signature, and after successful verification, stores the code in a specially designated secure area in memory. The access permission of the secure area is set to read-only by the memory management unit to prevent the hot patch code stored in the area from being accidentally modified or maliciously tampered with.

[0108] In practical applications, for the marked function F1 in server F that needs repair, a multi-dimensional code structure analysis was first performed and its control flow graph was constructed. The control flow graph revealed that the power consumption of the execution path "data decoding - data operation - result temporary storage" in function F1 was significantly higher than other paths. Further analysis of data flow dependencies, combined with power consumption change data for this path, identified three consecutive multiplication instructions in the "data operation" stage as the root cause of the power consumption anomaly. The "data decoding - data operation - result temporary storage" path containing these three multiplication instructions was marked as the problematic code segment. Next, instruction-level power consumption analysis was performed on this problematic code segment. Based on low-power instruction replacement rules, the three consecutive multiplication instructions were replaced with functionally equivalent shift and addition combination instructions. Finally, a data processing loop that executed 200 times consecutively in the code was removed. The process is divided into four sub-loops, each executing 50 times. A 2-millisecond controllable sleep cycle is inserted after each sub-loop. Simultaneously, eight randomly distributed memory read requests are reorganized into batch accesses in address order. Finally, hot patch function code is generated and verified through interface consistency to confirm that its call stack frame, parameter passing, and return value processing are completely consistent with F1. The generated hot patch function code is then encrypted using a preset encryption algorithm and a digital signature is added. After the secure memory manager verifies that the digital signature is correct, it is written to a pre-allocated secure storage area in the system memory. The server's memory management unit then performs access permission settings on this secure area, configuring its permissions to read-only to ensure that the hot patch code can only be read and executed, not modified. This completes the overall operation of step S104.

[0109] The overall solution for S104 described above establishes a closed-loop process from precise problem localization to hot patch generation and secure storage. First, multi-dimensional analysis identifies the abnormal power consumption code segment in the function to be repaired. Then, through instruction replacement, control flow reconstruction, and memory access optimization, functionally equivalent, interface-compatible, and power-efficient hot patch code is generated. Finally, encryption, secure storage in a secure area, and read-only permissions ensure code security. The generated hot patch not only specifically addresses the abnormal power consumption issue of the original function but also ensures compatibility with the system, laying a reliable code foundation for the smooth execution of subsequent vulnerability hot patching.

[0110] S105. When the specific module meets the low power consumption condition, the execution flow of the function to be repaired is switched to the hot patch function code through function jump redirection to complete the incremental hot patching of the vulnerability in the server hardware firmware.

[0111] Optionally, step S105 may specifically include the following steps:

[0112] S1051. Continuously monitor the current power consumption value of the specific module, and when the current power consumption value is lower than the preset power consumption threshold, determine that the low power consumption condition is met;

[0113] S1052. When the low power consumption condition is met, modify the jump address corresponding to the function to be repaired in the function jump table of the server hardware firmware, and replace the original jump address with the storage address of the hot patch function code in the system memory safe area.

[0114] S1053. When the function to be repaired is called, the execution flow is automatically redirected to the hot patch function code through the function jump table;

[0115] S1054. Execute the hot patch function code to replace the function to be repaired, and complete the incremental hot patch for the vulnerability in the server hardware firmware.

[0116] In the above scheme, the current power consumption value refers to the power consumption of a specific module during operation. The preset power consumption threshold refers to a pre-set critical power consumption value used to determine whether a specific module is in a low-power state. The function jump table is a table in the server hardware firmware that records the jump addresses during function calls. The original jump address refers to the storage address of the function to be repaired, originally recorded in the function jump table. The hot-patched function code storage address refers to the specific storage location of the hot-patched function code in the system's secure memory area. Execution flow redirection refers to the process of switching the execution path originally pointing to the function to be repaired to the hot-patched function code. Incremental hot patching of vulnerabilities refers to a repair method that only partially repairs the vulnerable functions to be repaired, without updating the entire firmware.

[0117] In this embodiment of the application, the current power consumption value of the specific module is first continuously monitored through step S1051. The power consumption data of the module during operation is collected once per second using a power consumption monitoring tool as the current power consumption value. When the current power consumption value is lower than a preset power consumption threshold, it is determined that the low power consumption condition is met.

[0118] Secondly, in step S1052, when the low power consumption condition is met, the entry corresponding to the function to be repaired in the function jump table of the server hardware firmware is found, the jump address in that row is modified, and the original jump address is replaced with the storage address of the hot patch function code in the system memory safe area, thus completing the update of the jump address.

[0119] Next, in step S1053, when the function to be repaired is called, the server will automatically query the function jump table to find the jump address corresponding to the function to be repaired. This address has been modified to the storage address of the hot patch function code, so the execution flow will automatically redirect from the function to be repaired to the hot patch function code.

[0120] Finally, the hot patch function code is executed in step S1054. During the execution of this code, it will perform the same function as the function to be repaired. Through this function replacement, the incremental hot patching of the vulnerability in the server hardware firmware is completed. That is, only the part of the function to be repaired is repaired, without restarting the server or updating the entire firmware.

[0121] In practical applications, on server model A, a power consumption monitoring program is activated to continuously collect the current power consumption value of a specific computing module. The preset power consumption threshold for this module is set to 60W. During the monitoring process, the collected power consumption values ​​are 65W, 62W, 58W, and 57W respectively. When 58W is collected, it is determined to meet the low power consumption condition because it is below the preset threshold. Subsequently, technicians use firmware debugging tools to open the function jump table, find the entry corresponding to the function A2 to be repaired, and replace the original jump address 0x3000ABCD with the storage address 0x4000EFGH of the hot patch function code in the safe area. The modification is then saved to complete the jump address replacement. When the server runs a data processing task, the task execution triggers the call to the function A2 to be repaired at a certain stage. After the server queries the function jump table, it automatically redirects the execution flow to the memory area where the hot patch function code is located. After the hot patch function code runs, it completes the server log compression and storage function originally handled by A2 and resolves the abnormal power consumption problem of the original function. In this way, only A2 is partially repaired, and incremental hot patching of vulnerabilities in the server hardware firmware is completed.

[0122] The overall solution of S105 described above uses low-power monitoring to capture a suitable repair window, avoiding operation when the module is under high load and reducing interference with business operations. It then automatically completes the modification of jump addresses and switching of execution flows without continuous manual intervention. Using an incremental hot-patching method, it only partially repairs the function to be repaired, ensuring that the hot patch accurately replaces the original function's functionality and resolves power consumption anomalies, while avoiding problems such as system restarts and excessive resource consumption caused by full firmware updates. This achieves a balance between repair effectiveness and business continuity, perfectly adapting to the low-power, high-efficiency repair needs of servers in energy-constrained scenarios such as edge computing.

[0123] The following is a complete example for steps 101-105, such as Figure 3As shown, during the hardware firmware vulnerability repair process of Model A server, the current and voltage measurements of multiple functional modules such as the computing module and storage module in the server are first collected as operating status data. For function A1 in the computing module, the operating status data of its execution is recorded 8 times at a fixed time interval of 10 seconds during the normal operation of the server. The reference power consumption value is calculated to be 60W. A fixed ratio of 20% is set to obtain the power consumption deviation threshold of 12W. Then, the current power consumption value of function A1 is continuously monitored during the operation of the server. When its power consumption value exceeds 72W (60W+12W) multiple times, function A1 is marked as an abnormal function node.

[0124] Next, the specific module to which the abnormal function node A1 belongs is determined to be the computing module. During continuous server operation, the power supply voltage and clock frequency of the computing module are gradually adjusted in a cyclic manner through the power consumption gating circuit. The power supply voltage is reduced from the initial 12V in 0.5V steps, and the clock frequency is adjusted synchronously accordingly. After each adjustment, the current voltage value, the current frequency value, and the corresponding power consumption value are collected as power consumption change data.

[0125] Subsequently, during the execution of the computation module, the call and return instructions of function A1 are monitored, and its execution cycle time window is determined to be 15:20:00-15:20:04. The collected power consumption change data is allocated to this window according to the timestamp. The data within the window is processed to extract the feature sequence of power consumption peak of 75W, power consumption average of 70W, and power consumption fluctuation frequency of 2 times / second to form the power consumption pattern of function A1. This pattern is matched with the pre-stored normal function power consumption feature library, and the difference is calculated to be 0.25, which exceeds the set threshold of 0.2. Therefore, function A1 is marked as a function to be repaired.

[0126] Subsequently, a multi-dimensional code structure analysis was performed on function A1. A control flow graph was constructed to identify the high-power execution path of "data decoding - data operation - result temporary storage". Combined with power consumption change data, the three consecutive multiplication instructions in the "data operation" stage were located as the problematic code segment. Instruction-level power consumption analysis was performed on the problematic code segment, and the three multiplication instructions were replaced with functionally equivalent shift and addition combination instructions. A calculation loop that was executed 200 times was split into four sub-loops that were executed 50 times each, and a 2-millisecond sleep cycle was inserted between the sub-loops. At the same time, the eight randomly scattered memory read requests were reorganized into sequential batch access. Hot patch function code was generated and passed through interface consistency verification to ensure that it was completely consistent with the call stack frame layout, parameter passing mechanism and return value handling method of function A1. The hot patch code was then encrypted and digitally signed, and written to the secure area of ​​system memory through the secure memory manager. The access permission of this area was set to read-only with the help of the memory management unit.

[0127] Finally, the current power consumption of the computing module is continuously monitored. Its preset power consumption threshold is 50W. When the monitored power consumption values ​​are 55W, 52W, and 48W respectively, it is determined that the low power consumption condition is met. At this time, the jump address corresponding to function A1 in the server firmware function jump table is modified. The original address 0x10001234 is replaced with the storage address 0x20005678 of the hot patch function code in the safe area. When the server runs a data processing task and triggers the call of function A1, the execution flow is automatically redirected to the hot patch function code through the function jump table. After the hot patch function code runs, it completes the data operation function originally handled by function A1 and solves the power consumption abnormality problem. Finally, the incremental hot patch of the vulnerability in the hardware firmware of model A server is completed.

[0128] Figure 4 This is a schematic diagram illustrating a specific implementation of a server hardware firmware vulnerability incremental hot patching system provided in this application embodiment. (Refer to...) Figure 4 The system may include:

[0129] The acquisition module 41 is used to acquire the running status data of multiple functional modules in the server hardware firmware, and to identify abnormal function nodes with abnormal power consumption based on the running status data.

[0130] The acquisition module 42 is used to dynamically adjust the power state of a specific module in the functional module according to the abnormal function node, and to acquire the power consumption change data of the specific module during the power supply state change process.

[0131] The marking module 43 is used to associate the power consumption change data with the function execution cycle of the specific module, establish a mapping relationship between function calls and power consumption modes, and mark the functions to be repaired;

[0132] The generation module 44 is used to generate hot patch function code corresponding to the function to be repaired, and store the hot patch function code in a safe area of ​​the system memory;

[0133] Repair module 45 is used to switch the execution flow of the function to be repaired to the hot patch function code through function jump redirection when the specific module meets the low power consumption condition, so as to complete the incremental hot patching of the vulnerability in the server hardware firmware.

[0134] The incremental hot patching system for server hardware firmware vulnerabilities in this application is used to implement the aforementioned incremental hot patching method for server hardware firmware vulnerabilities. Therefore, the specific implementation of the incremental hot patching system for server hardware firmware vulnerabilities can be found in the embodiment section of the incremental hot patching method for server hardware firmware vulnerabilities mentioned above. The specific implementation can be referred to the description of the corresponding embodiments, which will not be repeated here.

[0135] This application also provides an electronic device, comprising: a memory for storing a computer program; and a processor for executing the computer program to implement the steps of any of the above-described server hardware firmware vulnerability incremental hot patching methods.

[0136] This application also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of any of the above-described incremental hot patching methods for server hardware firmware vulnerabilities.

[0137] In one exemplary embodiment, the aforementioned computer-readable storage medium may include, but is not limited to, various media capable of storing computer programs, such as USB flash drives, read-only memory, random access memory, portable hard drives, magnetic disks, or optical disks.

[0138] Embodiments of the present invention also provide a computer program product, which includes a computer program that, when executed by a processor, implements the steps in any of the above embodiments of the incremental hot patching method for server hardware firmware vulnerabilities.

[0139] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0140] The above provides a detailed description of the incremental hot patching method and system for server hardware firmware vulnerabilities provided in this application. Specific examples have been used to illustrate the principles and implementation methods of this application. The descriptions of the embodiments above are merely for the purpose of helping to understand the method and its core ideas. It should be noted that those skilled in the art can make various improvements and modifications to this application without departing from its principles, and these improvements and modifications also fall within the protection scope of this application.

Claims

1. A server hardware firmware vulnerability incremental hot patching method, characterized in that, The method comprises the following steps: acquiring running state data of a plurality of function modules in server hardware firmware, identifying an abnormal function node with abnormal power consumption based on the running state data; dynamically adjusting the power state of a specific module in the function modules according to the abnormal function node, and collecting power consumption change data of the specific module in the power state change process; associating the power consumption change data with the function execution period of the specific module, establishing a mapping relationship between function calling and power consumption mode to mark a function to be repaired; generating a hot patch function code corresponding to the function to be repaired, and storing the hot patch function code in a secure area of system memory; when the specific module meets a low-power consumption condition, switching the execution flow of the function to be repaired to the hot patch function code through function jump redirection, and completing incremental hot repair of the server hardware firmware vulnerability.

2. The method of claim 1, wherein, The method comprises the following steps: code analysis is performed on the function to be repaired to locate the problem code segment causing abnormal power consumption; based on the problem code segment, a hot patch function code with equivalent function but improved power consumption characteristics is generated, and it is ensured that the hot patch function code has the same input and output interfaces as the function to be repaired; the generated hot patch function code is encrypted, the encrypted and signed hot patch function code is written into the secure area of system memory through a secure memory manager, and the access permission of the secure area is set to a read-only attribute through a memory management unit.

3. The method of claim 2, wherein, The method comprises the following steps: instruction-level power consumption analysis is performed on the problem code segment to identify the core instruction sequence in the problem code segment that causes abnormal power consumption, and based on a pre-defined low-power consumption instruction replacement rule, high-power consumption instructions are replaced with a combination of functionally equivalent low-power consumption instructions; the control flow structure of the problem code segment is reconstructed, intensive computation loops are decomposed into a plurality of interleaved sub-loops, and controllable sleep periods are inserted between the sub-loops to reduce the power consumption peak value per unit time; the memory access mode of the problem code segment is optimized, random and dispersed memory access requests are reorganized into a sequential batch processing access mode, and the active time proportion of the memory controller is reduced; through replacement, reconstruction and optimization of the content in the problem code segment, a hot patch function code is generated, and during code generation, the calling stack frame layout, parameter passing mechanism and return value processing mode of the hot patch function code are strictly maintained to be identical to those of the function to be repaired, and interface consistency verification is performed to ensure the binary-level compatibility of the two.

4. The method of claim 1, wherein, The method comprises the following steps: corresponding to each function execution period, as a power consumption mode of the corresponding function; comparing the power consumption mode of each function with a preset normal power consumption range, and marking the corresponding function as a to-be-repaired function when the power consumption mode of the function exceeds the normal power consumption range. The method for performing incremental hot repair on the server hardware firmware vulnerability includes:

5. The method of claim 1, wherein, continuously monitoring the current power consumption value of the specific module, and determining that the low power consumption condition is met when the current power consumption value is lower than a preset power consumption threshold; when the low power consumption condition is met, modifying the jump address corresponding to the to-be-repaired function in the function jump table of the server hardware firmware, and replacing the original jump address with the storage address of the hot patch function code in the system memory safe area; when the to-be-repaired function is called, automatically redirecting the execution flow to the hot patch function code through the function jump table; executing the hot patch function code to replace the function of the to-be-repaired function, and completing the incremental hot repair of the server hardware firmware vulnerability. The method includes:

6. The method of claim 1, wherein, determining the specific module to which the abnormal function node belongs; adjusting the supply voltage and clock frequency of the specific module in a cyclic manner through a power consumption gate circuit during the continuous running of the server hardware firmware; after completing the adjustment of the supply voltage and clock frequency each time, collecting the power consumption change data of the specific module, which includes the current voltage value, the current frequency value, and the corresponding power consumption value. The method includes:

7. The method of claim 1, wherein, collecting current measurement values and voltage measurement values of a plurality of function modules in the server hardware firmware as running state data; for each function node in each function module, periodically obtaining the running state data when the function node is executed during the normal running stage of the server, and determining the reference power consumption value of the corresponding function node based on the running state data; setting a power consumption deviation threshold, which is determined based on a fixed proportion of the reference power consumption value; during the running of the server, continuously monitoring the current running state data of each function node and calculating the node power consumption value, and marking the corresponding function node as an abnormal function node with abnormal power consumption when the node power consumption value meets a predetermined power consumption condition multiple times, the predetermined power consumption condition being set according to the reference power consumption value and the power consumption deviation threshold. The method includes:

8. A server hardware firmware vulnerability incremental hot patching system, comprising: ​ An acquisition module is configured to acquire running state data of a plurality of function modules in a server hardware firmware, and identify an abnormal function node with abnormal power consumption based on the running state data; An acquisition module is configured to acquire running state data of a plurality of function modules in a server hardware firmware, and identify an abnormal function node with abnormal power consumption based on the running state data; A marking module is configured to associate the power consumption change data with a function execution period of the specific module, establish a mapping relationship between function calling and power consumption mode, and mark a function to be repaired; A generation module is configured to generate a hot patch function code corresponding to the function to be repaired, and store the hot patch function code in a secure area of a system memory; A repair module is configured to switch an execution flow of the function to be repaired to the hot patch function code through function jump redirection when the specific module meets a low-power consumption condition, and complete incremental hot repair of a vulnerability of the server hardware firmware.

9. An electronic device, comprising: The computer readable storage medium stores a computer program, and the computer program is executed by the processor to implement the steps of the server hardware firmware vulnerability incremental hot patch method according to any one of claims 1 to 7. The computer readable storage medium stores a computer program, and the computer program is executed by the processor to implement the steps of the server hardware firmware vulnerability incremental hot patch method according to any one of claims 1 to 7. ​ 10. A computer-readable storage medium, characterized in that, ​

Images