Methods, equipment, and software products for detecting abnormal IAT call behavior

By replacing the IAT entry with a jump stub address in user space and calculating the timing entropy and state entropy, the problem of high false alarm rate and large computational overhead in IAT abnormal call behavior detection is solved, and efficient abnormal call behavior detection is achieved.

CN123069358APending Publication Date: 2026-11-10PURPLE MOUNTAIN LAB
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611584686.2
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-13
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing technologies for detecting abnormal IAT call behavior suffer from high false alarm rates, high computational overhead, and difficulty in identifying updated attack behaviors, especially zero-day vulnerability attacks. Traditional IAT honeypot technologies and neural network methods have significant limitations.

Method used

By replacing the external function address of the IAT entry in user mode with the jump stub address, the record information of the function call instruction is generated. The timing entropy and state entropy are calculated using the cache area to determine abnormal call behavior and terminate the target protection program.

Benefits of technology

It improves the accuracy of IAT abnormal call behavior detection, reduces the internal logic overhead of the computer system, reduces the false alarm rate and false negative rate, and enables lightweight terminal deployment.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123069358A_ABST
    Figure CN123069358A_ABST
Patent Text Reader

Abstract

This application relates to the field of terminal security protection, and discloses a method, device, and program product for detecting abnormal IAT call behavior. The method includes: determining a target protection program, wherein the target protection program is configured with multiple IAT entries, and the external function addresses stored in the IAT entries are replaced with jump stub addresses in kernel mode; responding to a function call instruction in the target protection program, calling the IAT entry pointed to by the function call instruction to jump to the jump stub corresponding to the IAT entry; generating record information of the function call instruction through the jump stub; storing the record information in a cache area; when the cache area meets preset detection conditions, determining the temporal entropy and state entropy of the current detection round; judging whether abnormal call behavior exists in the current detection round based on the temporal entropy and state entropy; and terminating the target protection program if abnormal call behavior is determined to exist. The technical solution provided by this application can improve the accuracy of IAT abnormal call behavior detection.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of endpoint security protection, and in particular to methods, devices and program products for detecting abnormal IAT call behavior. Background Technology

[0002] In endpoint security systems, the Import Address Table (IAT), serving as a bridge for dynamic linking between applications and the operating system, has long been threatened by persistent attack methods. Currently, IAT honeypot technology is commonly used to monitor abnormal IAT call behavior in real time based on fixed time windows or frequency thresholds. However, with the development of attack techniques and the changing complexity of protection environments, traditional IAT honeypot technology has gradually revealed significant limitations.

[0003] Specifically, this manifests as a high likelihood of numerous false positives when encountering highly disguised normal behavior, and attackers' ability to evade anomaly detection by extending the call interval. While some technologies have introduced neural networks for anomaly inference, this approach heavily relies on labeled samples, struggles to accurately identify increasingly sophisticated attack behaviors, and incurs significant computational overhead. Therefore, improving the accuracy of IAT anomaly detection without additional assistance and with lower computational costs has become a critical technological bottleneck that urgently needs to be overcome in the field of endpoint security. Summary of the Invention

[0004] The method, device, and program products for detecting abnormal IAT call behavior provided in this application can improve the accuracy of IAT abnormal call behavior detection, while reducing the internal logical overhead of the computer system during the detection process.

[0005] The first aspect of this application provides a method for detecting abnormal IAT call behavior. The method includes: confirming a target protection program, wherein the target protection program is configured with multiple IAT entries, and the external function addresses stored in the IAT entries are replaced with jump stub addresses in kernel mode; responding to a function call instruction in the target protection program, calling the IAT entry pointed to by the function call instruction to jump to the jump stub corresponding to the IAT entry; generating record information of the function call instruction through the jump stub, storing the record information in a cache area, and when the cache area meets preset detection conditions, determining the temporal entropy and state entropy of the current detection round based on the multiple record information in the cache area; judging whether there is abnormal call behavior in the current detection round based on the temporal entropy and state entropy, and terminating the target protection program if abnormal call behavior is determined to exist.

[0006] In one implementation, the recorded information includes timestamp information and function identifier information; the jump stub includes a timestamp recording function and an identifier extraction function; wherein: the timestamp recording function is used to generate timestamp information for function call instructions, and the timestamp information is used to determine the temporal entropy of the current detection round; the identifier extraction function is used to generate function identifier information for function call instructions, and the function identifier information is used to determine the state entropy of the current detection round.

[0007] In one implementation, the function identifier information takes values ​​in the range of integers from 0 to 255. The identifier extraction function generates the function identifier information in the following manner: determining the import form of the external function called by the function call instruction; when the import form is function name import, performing a hash operation on the function name, and extracting the function identifier information based on the hash operation result and the value range; when the import form is ordinal import, extracting the function identifier information based on the ordinal number and the value range.

[0008] In one implementation, determining the temporal entropy of the current detection round includes: acquiring multiple timestamp information within the cache area, sorting the timestamp information in ascending order according to the call sequence, and determining multiple time sub-intervals of the current detection round based on the timestamp information; for any time sub-interval, generating the distribution probability of the time sub-interval based on the number of calls represented by the time sub-interval; and determining the temporal entropy of the current detection round based on the distribution probability of each time sub-interval.

[0009] In one implementation, determining the state entropy of the current detection round includes: arranging function identification information sequentially according to the call sequence; combining adjacent function identification information arranged in the sequence into a state transition sequence for the current detection round; establishing a state transition matrix based on the state transition sequence; determining the conditional transition probability and steady-state probability of any row in the state transition matrix; and determining the state entropy of the current detection round based on the conditional transition probability and the steady-state probability.

[0010] In one implementation, the cache area includes a main cache area and a secondary cache area; storing recording information in the cache area includes: cyclically alternating between storing recording information in the main cache area and the secondary cache area until the target protection program terminates; wherein, when any cache area meets a preset detection condition, the cache area is replaced.

[0011] In one implementation, cache region replacement is performed via an atomic substitution operation; the atomic substitution operation includes: transiently switching the current write pointer from the current cache region in a write state to point to another cache region, so that the current cache region switches to a read state and the other cache region switches to a write state.

[0012] In one implementation, determining whether there is abnormal calling behavior in the current detection round based on temporal entropy and state entropy includes: obtaining temporal reference information and state reference information for the current detection round; updating the temporal reference information based on temporal entropy; determining whether there is a temporal entropy anomaly based on the temporal entropy and the updated temporal reference information; updating the state reference information based on state entropy; determining whether there is a state entropy anomaly based on the state entropy and the updated state reference information; and determining that there is abnormal calling behavior in the current detection round if both temporal entropy and state entropy anomalies are determined to exist.

[0013] In one implementation, the time-series reference information includes the time-series entropy mean and the time-series entropy variance, and the state reference information includes the state entropy mean and the state entropy variance. Updating the time-series reference information and the state reference information includes: updating the time-series entropy mean and the time-series entropy variance according to the time-series entropy and a preset update weight, respectively; and updating the time-series entropy mean and the time-series entropy variance according to the state entropy and a preset update weight, respectively.

[0014] In one implementation, if it is determined that there is no abnormal call behavior, the system jumps to the address of the external function corresponding to the function call instruction.

[0015] In one embodiment, after determining the target protection procedure, the method further includes: in response to the activation of the target protection procedure, entering a baseline learning phase; during the baseline learning phase, stopping the judgment of the abnormal call behavior, and performing the generation and storage of record information, the determination of temporal entropy and state entropy, updating the temporal reference information according to the temporal entropy, and updating the state reference information according to the state entropy; and exiting the baseline learning phase when the preset learning duration is reached.

[0016] A second aspect of this application also provides a method for detecting abnormal IAT call behavior. The method includes: scanning the image structure of a target protection program to locate multiple IAT entries of the target protection program; replacing the external function addresses under the IAT entries with jump stub addresses pointing to jump stubs, so that when the user mode executes the function call instruction of the target protection instruction, it can determine whether there is an abnormal call through the corresponding jump stub; wherein, the jump stub is used to generate record information of the function call instruction, the record information is stored in a cache area, and the record information is used to determine the temporal entropy and state entropy of the current detection round when the cache area meets preset detection conditions, the temporal entropy and state entropy are used to determine whether there is an abnormal call in the current detection round, so that if an abnormal call behavior is determined to exist, the target protection program is terminated.

[0017] A third aspect of this application provides a computer device, comprising: a memory and a processor, wherein the memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the computer instructions to perform the IAT abnormal call behavior detection method as described in any of the preceding aspects.

[0018] A fourth aspect of this application provides a computer program product, including computer instructions for causing a computer to execute a method for detecting abnormal IAT call behavior as described in any of the preceding aspects.

[0019] The technical solution provided in this application can improve the accuracy of IAT abnormal call behavior detection. Specifically, by caching the recorded information of function call instructions, the temporal entropy and state entropy of the detection round are calculated when preset detection conditions are met. The existence of abnormal call behavior is jointly determined by the threshold judgment of temporal entropy and state entropy. Compared with the abnormal call behavior detection methods in traditional IAT honeypot technology, which use fixed time window analysis in kernel mode, immediate detection and alarm, or neural network analysis, this technical solution can reduce the false alarm rate of normal call instructions and the false negative rate of abnormal call instructions based on the two-dimensional entropy value judgment of preset detection conditions (such as reaching the full load value), thereby improving the accuracy of IAT call behavior detection. It can also be deployed in a lightweight terminal at the operating system application layer (user mode), thereby reducing the internal logic overhead of the operating system core layer (kernel mode).

[0020] It is evident that the technical solution provided in this application can improve the accuracy of IAT abnormal call behavior detection, while reducing the internal logical overhead of the computer system during the detection process. Attached Figure Description

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

[0022] Figure 1 A schematic diagram illustrating the steps of a method for detecting abnormal IAT call behavior provided in an embodiment of this application; Figure 2 This is a schematic diagram illustrating the steps for determining temporal entropy in one embodiment of this application; Figure 3 This is a schematic diagram illustrating the steps for determining state entropy according to an embodiment of this application; Figure 4A schematic diagram illustrating the steps of a method for detecting abnormal IAT call behavior provided in one embodiment of this application; Figure 5 This is a schematic diagram of the structure of a computer device provided in one embodiment of this application. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0024] Furthermore, the use of terms such as "first," "second," etc., in this application is for descriptive purposes only and should not be construed as indicating or implying their relative importance or implicitly specifying the number of technical features indicated. Therefore, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of embodiments in this application, unless otherwise stated, "multiple" means two or more. Additionally, the use of "based on" or "according to" implies openness and inclusiveness, because processes, steps, calculations, or other actions "based on" or "according to" one or more of the stated conditions or values ​​may in practice be based on additional conditions or beyond the stated values.

[0025] The IAT table is a data structure in the system executable file used for dynamic linking. It stores the actual memory address of an external DLL function when the program calls it, thus dynamically associating the function call instruction with the DLL's actual address. Because the IAT table is located at a critical point in dynamic link library calls, it is constantly threatened by attacks such as process injection, API hijacking, and remote thread injection. Zero-day vulnerability attacks, in particular, exploit security flaws in software, hardware, or systems that have not been discovered by developers and for which no official patches have been released, are often highly unpredictable and destructive.

[0026] Traditional IAT honeypot technology primarily involves replacing the valid function addresses in the IAT entry with custom honeypot function addresses. When malicious code calls a protected API, the execution flow is redirected to the honeypot trap, thus enabling real-time monitoring of unauthorized calls. However, because it cannot understand the semantics, call order, and timing behind the call behavior, it is highly prone to generating numerous false positives in highly complex business scenarios (such as browser extensions and dynamically loaded script engines). Furthermore, attackers can now artificially lengthen API call intervals by embedding delay instructions to circumvent detection rules based on fixed time windows or frequency thresholds. This makes it difficult to distinguish between normal business operations and malicious code execution, and attack chains with strict sequential characteristics are difficult to effectively identify.

[0027] To improve the accuracy of anomaly detection, some technologies employ machine learning methods, such as Long Short-Term Memory (LSTM) networks, to perform deep fitting of API call sequences. However, these methods face significant obstacles in lightweight terminal deployments, including: high computational overhead for neural network inference, making it difficult to meet real-time requirements; heavy reliance on high-quality labeled samples during training, making it difficult to detect unknown zero-day vulnerabilities; and the introduction of third-party AI libraries increasing system coupling, introducing new security boundaries, and raising maintenance costs. This approach not only struggles to accurately detect anomalous API call behavior (especially zero-day vulnerabilities) but also incurs substantial logical computational overhead.

[0028] In view of the above, this application provides one or more embodiments of a method, device and program product for detecting abnormal IAT call behavior, which can solve the above problems. Without additional assistance or relying on labeled samples, it can identify abnormal call behavior in real time from the user level, thereby improving the accuracy of IAT abnormal call behavior detection and reducing the internal logic overhead of the computer system during the detection process.

[0029] Please see Figure 1 In one aspect, this application provides a method for detecting abnormal IAT call behavior, which is applied to the operating system application layer. The method may include the following steps: S1: Confirm the target protection program, wherein the target protection program is configured with multiple IAT entries, and the external function addresses stored in the IAT entries are replaced with jump stub addresses in kernel mode.

[0030] During execution, the aforementioned target protection program typically exists as a process in user-space memory, representing an instance of the application process to be monitored and protected. This target protection program usually adopts a PE format and has a fixed data structure, namely the PE image structure. This data structure includes an IAT table, which contains multiple IAT entries. During execution, the target protection program is copied into user-space memory according to the composition of this data structure.

[0031] In this implementation, the kernel mode performs only one IAT address replacement operation, replacing the external function address with a jump stub address. Specifically, the security agent driver in kernel mode initiates the IAT address replacement operation by scanning the PE image structure of the target protected program to find the range address of the IAT table pointed to by its import table. For each valid IAT entry, the previously stored external function address (usually a DLL exported function pointer) is replaced with a predefined jump stub address to transfer control flow to the jump stub address. This captures all function call instructions targeting the controlled external function interface while maintaining the original call intent, enabling precise protection against abnormal call behavior. Simultaneously, all subsequent detection and calculation logic is performed in user mode, effectively reducing the internal logic consumption of the computer system.

[0032] S3: In response to the function call instruction in the target protection program, call the IAT entry pointed to by the function call instruction to jump to the jump stub corresponding to the IAT entry.

[0033] The aforementioned target protection program contains multiple function call instructions, including normal call instructions and abnormal call instructions. The aforementioned jump stubs are machine instruction fragments deployed in the user-mode address space, used to receive jumps from IAT entries for abnormal call behavior detection. For example, a jump stub may include a sequence of instructions such as saving register states, generating timestamps and identifiers for call record functions, restoring register states, and jumping to the actual external function address.

[0034] Typically, each IAT entry stores the address of an external function to be called. Control flow jumps to the target external function based on the external function address stored in the IAT table. To avoid abnormal calls, the external function address is replaced with a jump stub address. When the program executes a function call instruction, it naturally jumps to the jump stub through the IAT entry. The jump stub performs anomaly detection through its internal instruction sequence. If the detection result indicates that everything is normal, it continues to jump to the target external function. If the detection result indicates that something is wrong, it no longer provides the external function address and terminates the program. This is the IAT honeypot mechanism.

[0035] S5: Generate the function call instruction record information through the jump stub, store the record information in the cache area, and when the cache area meets the preset detection conditions, determine the temporal entropy and state entropy of the current detection round based on the multiple record information in the cache area.

[0036] The aforementioned recorded information can be understood as structured data of a single call event generated by a jump stub. This recorded information may include timestamp information and function identifier information. The timestamp information can be the moment when the address transfer occurred during the function call instruction, and the function identifier information can be the function number of the function pointed to by the function call instruction. For example, the recorded information may include timestamp information and function identifier information, and the aforementioned cache area is used to temporarily store the recorded information of the most recent few function call instructions. Optionally, the aforementioned cache area adopts a circular cache structure, including a main cache area and a secondary cache area. When any cache area meets a preset detection condition, an abnormal behavior judgment is performed on the function call instructions in that cache area, and the system switches to another cache area to continue receiving function call instructions.

[0037] In this embodiment, the preset detection condition is reaching a preset storage quantity. For example, when the temporary storage quantity reaches the preset storage quantity of the cache area, such as when the cache area is full, it is determined that the cache area meets the preset detection condition, and abnormal behavior detection is performed on all function call instructions within the current detection round. The preset storage quantity is less than or equal to the maximum storage quantity of the cache area. Specifically, the cache area includes a specified number of storage units, each used to store a set of record information. The preset storage quantity is less than or equal to the specified quantity. Generally, the number of record information entries for each instruction with abnormal call behavior is usually greater than or equal to the preset storage quantity of the cache area.

[0038] In this implementation, information entropy is used to determine whether there are abnormal function call instructions in the current detection round. Generally, normal user input-induced function call instructions are highly random and complex, exhibiting high information entropy. In contrast, mechanically generated abnormal function call instructions (such as script viruses) follow fixed patterns and exhibit low information entropy. Therefore, by measuring the information entropy of function call instructions in real-time at the user level, and effectively identifying abnormal call instructions exhibiting low entropy, the existence of abnormal call behavior can be determined.

[0039] Specifically, the aforementioned information entropy includes temporal entropy and state entropy, characterizing the temporal and logical order of function call instructions. Since the call order and timing of some highly disguised normal call instructions conform to the call flow characteristics of common software vulnerability exploits, the method of sending an alert upon triggering cannot effectively distinguish between normal business operations and malicious code execution. By statistically analyzing the temporal and state entropy of a continuous set of function call instructions, the contextual characteristics of a batch of function call instructions can be quantified from both temporal and logical characteristics, enabling more accurate anomaly detection. Furthermore, attackers can circumvent IAT honeypot detection, which analyzes calls within fixed time windows, by adjusting the time difference between adjacent abnormal call instructions. Replacing timed triggering with a preset number of calls prevents attackers from diluting the contextual characteristics of abnormal call instructions by inserting null operations, achieving accurate anomaly detection while effectively reducing computational overhead.

[0040] In this embodiment, temporal entropy and state entropy are determined based on the recorded information of function call instructions. Temporal entropy can be calculated using Shannon entropy to measure the temporal distribution characteristics of a series of consecutive function call instructions on the time axis. State entropy can be calculated using Markov transition entropy to measure whether the call order of a series of consecutive function call instructions has strong logical determinism. For example, the recorded information includes timestamp information and function identifier information. When the preset detection condition in the cache area is to reach 64 recorded function call instructions, the 64 timestamps are sorted and divided into 8 equal-length intervals. The number of calls within each interval is counted and converted into probabilities, which are then substituted into the Shannon entropy formula. Furthermore, adjacent pairs of the 64 function identifiers are sequentially extracted to form 63 transitions, which are filled into a 256×256 transition matrix. The conditional transition probability and steady-state probability are calculated for each row and then substituted into the Markov transition entropy formula.

[0041] S7: Based on the time sequence entropy and the state entropy, determine whether there is any abnormal calling behavior in the current detection round. If it is determined that there is abnormal calling behavior, terminate the target protection program.

[0042] Because abnormal call behaviors (such as script viruses and ROP attack chains) often occur in concentrated timeframes (e.g., bursts within a short period), they are characterized by low temporal entropy. Furthermore, they typically follow a strict call order, resulting in low state entropy. Therefore, by jointly judging temporal and state entropy, it can be determined whether abnormal call behaviors exist in the current detection round. This can be understood as follows: only when a batch of function call instructions is significantly concentrated in time distribution (low temporal entropy) and significantly determined in call order (low state entropy) is it considered abnormal.

[0043] Specifically, when both the timing entropy and state entropy are below the timing threshold and the state threshold, abnormal call behavior is determined. These thresholds can be determined based on the timing and state entropies of previous detection rounds, or they can be preset. If abnormal call behavior is detected, the target protection program is terminated. Optionally, before termination, forensic operations can be performed, such as generating memory storage and saving context logs, to ensure both timely blocking and no loss of analysis data. If no abnormal call behavior is detected, the program jumps to the address of the external function corresponding to the function call instruction.

[0044] Based on the above ideas, the technical solution provided by this embodiment of the application can improve the accuracy of IAT abnormal call behavior detection, thereby enhancing the protection capability of the computer system and reducing internal logic overhead. Specifically, by caching the recorded information of function call instructions, the temporal entropy and state entropy of the detection round are calculated when preset detection conditions are met. The existence of abnormal call behavior is jointly determined by the threshold judgment of temporal entropy and state entropy. Compared with the abnormal call behavior detection methods in traditional IAT honeypot technology, which use fixed time window analysis in kernel mode, or immediate detection and alarm, or neural network analysis, this technical solution can not only reduce the false alarm rate of normal call instructions and the false negative rate of abnormal call instructions based on the two-dimensional entropy value of a specified number of call instructions (full load value), thereby improving the accuracy of IAT call behavior detection, but also deploy lightweight terminals in user mode and significantly reduce the amount of computation in kernel mode, thereby reducing the internal logic overhead of the computer system.

[0045] In one embodiment, the recorded information includes timestamp information and function identifier information; the jump stub includes a timestamp recording function and an identifier extraction function; wherein: the timestamp recording function is used to generate timestamp information for function call instructions, and the identifier extraction function is used to generate function identifier information for function call instructions.

[0046] In one embodiment, the timestamp recording function can be the QueryPerformanceCounter function (a function for high-precision timing) provided by the operating system. This function can achieve microsecond or even nanosecond-level timing accuracy in mainstream operating environments such as Windows, Linux, and macOS. Specifically, generating timestamp information for function call instructions using the timestamp recording function involves obtaining a 64-bit integer value from the current system performance counter and using it as the timestamp information for the occurrence of this recorded call event. The timestamp information provides raw data for time-series entropy calculation, enabling the system to analyze the uniformity of the distribution of a batch of function call instructions along the timeline.

[0047] In one embodiment, the identifier extraction function can be a deterministic hash function. Specifically, generating function identification information for a function call instruction using the identifier extraction function includes determining the import form of the external function called by the function call instruction, and calculating the corresponding function identification information based on the import form. The function identification information takes values ​​from 0 to 255, ensuring that it occupies no more than one byte. Importing external functions includes two feasible methods: function name import and ordinal import. Function name import identifies the external function to be called using a function name string, while ordinal import identifies the external function to be called using a sequence number in an export table.

[0048] Specifically, when importing in the form of function name, a hash operation is performed on the function name, and the function identification information is extracted based on the hash operation result and the value range (0 to 255); when importing in the form of ordinal number, the function identification information is extracted based on the ordinal number and the value range (0 to 255).

[0049] For example, the name (or ordinal number) of the external function corresponding to the current IAT entry is obtained, and then a deterministic hash calculation (such as CRC32 check) is performed to use the lower 8 bits of the calculation result (i.e., the last byte, with a value of 0-255) as the function identification information. For example, when the external function is imported in ordinal form, the lower 8 bits of this ordinal number are directly extracted as the function identification information, so that the same external function has the same representative label regardless of which process and what runtime environment, and at the same time, these identifiers are limited to a finite range (0-255).

[0050] The technical solution provided in this embodiment refines the method for determining the recording information, including timestamp information and function identifier information. Specifically, it obtains 64-bit integer timestamp information at the microsecond or even nanosecond level through a timestamp recording function, thereby providing accurate raw data for time-series entropy calculation. This facilitates determining the uniformity of function call instructions across the time dimension and, through identifier extraction, maps each called external function to function identifier information in the range of 0-255, ensuring the consistency of the identifier of the same external function across different processes and environments for subsequent calculation of time-series entropy and state entropy.

[0051] In one embodiment, the aforementioned cache area includes a main cache area and a secondary cache area; storing recording information in the cache area includes: cyclically alternating between storing recording information in the main cache area and the secondary cache area until the target protection program terminates; wherein, when any cache area meets a preset detection condition, the cache area is replaced.

[0052] In this embodiment, cache region replacement is performed through an atomic substitution operation: the current write pointer is transiently switched from the current cache region in the write state to point to another cache region, so that the current cache region switches to the read state and the other cache region switches to the write state.

[0053] Specifically, when the main cache does not meet the preset detection conditions, it is in a write state, storing the recorded information. When the main cache meets the preset detection conditions, a cache region replacement is performed, that is, the main cache is switched to a read state to perform abnormal call analysis in the background based on the recorded information in the main cache, and the secondary cache is switched to a write state to store the recorded information of subsequent function call instructions. This process continues until the secondary cache meets the preset detection conditions, at which point a cache region replacement is performed, that is, the secondary cache is switched to a read state, and the main cache is switched to a write state, and so on.

[0054] Understandably, when any cache region is in a read state, an entropy calculation operation is performed. Specifically, based on multiple records within that cache region, the temporal entropy and state entropy of the current detection round are determined to complete the entropy calculation operation for that cache region. At this time, another cache region is in a write state, meaning that the record information of subsequent function call instructions is stored in this other cache region until the other cache region meets the preset detection conditions.

[0055] The technical solution provided in this embodiment adopts a double-buffer structure to receive recorded information and trigger double entropy calculation, which can realize the parallelism of recorded information acquisition and entropy analysis calculation, ensuring that recorded information can be continuously and uninterruptedly acquired and stored, so as to avoid information loss due to analysis delay. This ensures the integrity and accuracy of abnormal call behavior detection in high-frequency function call scenarios. At the same time, since the acquisition and calculation processes no longer wait for each other, and the batch calculation of multiple rounds of temporal entropy and state entropy is completed in an orderly manner, the data processing efficiency can be greatly improved.

[0056] In one implementation, timestamp information is used to determine the temporal entropy of the current detection round, and function identifier information is used to determine the state entropy of the current detection round.

[0057] Specifically, please refer to Figure 2 The temporal entropy of the current detection round is determined by following these steps: S41: Obtain multiple timestamp information within the cache area, sort the timestamp information in ascending order according to the call sequence, and determine multiple time sub-intervals of the current detection round based on the timestamp information; S43: For any time sub-interval, generate the probability distribution of the time sub-interval based on the number of calls represented by the time sub-interval; S45: Determine the temporal entropy of the current detection round based on the probability distribution of each time sub-interval.

[0058] In step S43 above, a frequency vector of the time sub-interval is generated based on the number of calls represented by the time sub-interval, and the frequency vector is normalized to obtain the distribution probability of the time sub-interval.

[0059] In step S45 above, the temporal entropy can be Shannon entropy. The distribution probability of each time subinterval is substituted into the frequency entropy formula of Shannon entropy, and the output data is used as the temporal entropy.

[0060] Specifically, please refer to Figure 3 Determine the state entropy of the current detection round by following these steps: S51: Obtain multiple function identifiers within the cache area, arrange the function identifiers in order of call sequence, and combine the adjacent function identifiers arranged in the order into a state transition sequence for the current detection round. S53: Establish the state transition matrix based on the state transition sequence; S55: For any row of the state transition matrix, determine the conditional transition probability and steady-state probability of the row, and determine the state entropy of the current detection round based on the conditional transition probability and the steady-state probability.

[0061] In steps S51 and S53 above, in the sequentially arranged function identifier information, the transition combinations formed by every two adjacent function identifiers are arranged sequentially to form a state transition sequence. The frequency of all possible transition combinations is statistically analyzed based on the state transition sequence, and a state transition matrix is ​​established. This state transition matrix is ​​a 256×256 two-dimensional array, where the row index represents the function identifier information of the previous time step, and the column index represents the function identifier information of the next time step. It should be noted that since the actual number of external functions called during program execution is much less than 256, the state transition matrix contains many zero values; however, for ease of memory management, a 256×256 two-dimensional array is still used.

[0062] In step S55 above, the Markov transition entropy is used as the state entropy. The conditional transition probability can be expressed as: This indicates that the current function identifier information is known. Under the condition that, the next function identifier information is The probability of the steady state above can be expressed as: This represents the probability that the current function identifier information appears as a preceding state in the entire state transition sequence, i.e. .

[0063] In one embodiment, temporal entropy is represented by Shannon entropy, and the full load threshold of the cache region is 64 records. The temporal entropy of the current detection round is determined as follows: all timestamp information is arranged in ascending order into an ordered sequence. Using the minimum time value and maximum time value Determine the time window The time window is divided into 8 consecutive and mutually exclusive time sub-intervals, such that the length of each time sub-interval is... The i-th time sub-interval can be represented as , The 8th time sub-interval is .

[0064] In this embodiment, the number of calls falling within each time sub-interval is calculated to generate a frequency vector. and satisfy Furthermore, the frequency vector is transformed into a normalized probability to obtain the probability distribution. Furthermore, the temporal entropy is calculated using the formula for the frequency entropy value of Shannon entropy: It should be noted that if If there are function call instructions that fall within the same counter cycle, then the time distribution is considered to be the most concentrated case, and the time entropy is set to zero.

[0065] Optionally, in the above-mentioned time series entropy calculation process, the following are involved The operation is performed using a table lookup method. Calculations of logarithmic functions typically involve floating-point arithmetic, series expansion, or hardware microcode. Determining the corresponding value through a table lookup reduces computational overhead, meeting the requirements of lightweight terminals. Specifically, the target protection program establishes a coverage area upon startup. A lookup table with 256 discrete points, that is, a lookup table of intervals. Divide the data evenly into 256 segments, and store the data in the table beforehand. The corresponding value. When for When the value is an integer multiple of the given value, the probability of any distribution can be accessed via linear interpolation or direct indexing. The corresponding temporal entropy. And... In other words, all possible probability distributions can be found in the table. The corresponding value.

[0066] In one embodiment, the state entropy is represented by Markov transition entropy, and the full load threshold of the cache region is 64 records. The state entropy of the current detection round is determined as follows: all function identifiers are arranged sequentially according to the order of their calls. 63 transition combinations were extracted to form a state transition sequence. Based on the state transition sequence, the frequency of all possible transition combinations is statistically determined, and a state transition matrix is ​​constructed accordingly. .

[0067] Furthermore, regarding the state transition matrix For any row, determine the total number of transitions in that row. Then, normalize the probability of that row to obtain the conditional transition probability. And calculate the steady-state probability of that row. It should be noted that if If a position does not appear in the preceding position of the state transition sequence, the corresponding conditional transition probability is set to zero. The Markov transition entropy described above can be expressed as: Alternatively, logarithmic operations can be performed using a lookup table to reduce computational overhead.

[0068] The technical solution provided in this embodiment calculates temporal entropy (Shannon entropy) and state entropy (Markov transition entropy) based on the timestamp information and function identifier information stored in the cache. Specifically, Shannon entropy and Markov transition entropy accurately quantify the uniformity of the temporal distribution of function call instructions and the determinism of the instruction jump order, thereby measuring whether abnormal call behavior exists in the current detection round and improving the accuracy of IAT abnormal call behavior detection. Furthermore, all the above entropy calculation operations are executed in user space, thus reducing the internal logical overhead of the computer system during the detection process.

[0069] In one implementation, determining whether there is abnormal calling behavior in the current detection round based on temporal entropy and state entropy includes the following steps: S81: Obtain the timing reference information and status reference information for the current detection round; S83: Update the time series reference information based on the time series entropy, and determine whether there is a time series entropy anomaly based on the time series entropy and the updated time series reference information; S85: Update the state reference information based on the state entropy, and determine whether there is a state entropy anomaly based on the state entropy and the updated state reference information; S87: If it is determined that there are abnormal time entropy and abnormal state entropy, it is determined that there is abnormal calling behavior in the current detection round.

[0070] In this embodiment, the aforementioned temporal reference information includes the mean temporal entropy and the variance temporal entropy. Each detection round has a corresponding temporal entropy and temporal reference information. The aforementioned state reference information includes the mean state entropy and the variance state entropy. Each detection round has a corresponding state entropy and state reference information. Specifically, the temporal reference information and state reference information are updated in the following manner: the mean temporal entropy and the variance temporal entropy are updated according to the temporal entropy and a preset update weight, respectively; and the mean temporal entropy and the variance temporal entropy are updated according to the state entropy and a preset update weight, respectively.

[0071] In one embodiment, when the temporal entropy of the current detection round is determined, the temporal reference information is updated by adjusting the mean temporal entropy as follows: Update: According to the following at that time, the time series entropy variance Update: ,in, To preset the update weights, the preferred method is... , This represents the temporal entropy of the current detection round. Specifically, for the first detection round, the average temporal entropy is... Time series entropy variance .

[0072] In one embodiment, when the temporal entropy of the current detection round is determined, the state reference information is updated by adjusting the mean state entropy as follows: Update: According to the following at that time, the state entropy variance Update: ,in, To preset the update weights, the preferred method is... , This represents the state entropy of the current detection round. Specifically, for the first detection round, the average state entropy is... State entropy variance .

[0073] in, The preset update weight can be understood as the weight of the new data (temporal entropy and state entropy) compared to the historical data (the initial temporal reference information and state reference information of the current detection round). This indicates that historical data is given more weight in the process of updating the aforementioned reference information. Therefore, a small preset update weight is used, preferably 0.05. A preset update weight that is too large can easily cause fluctuations in the mean baseline due to abnormal data, while a preset update weight that is too small, although resistant to disturbances, results in excessively slow updates.

[0074] In this embodiment, the temporal entropy is based on the current detection round. With the updated time series reference information (mean time series entropy) Temporal entropy variance ),satisfy At that time, an anomaly in temporal entropy is determined. This is based on the state entropy of the current detection round. Compared with the updated state reference information (mean state entropy) State entropy variance ),satisfy When both temporal entropy and state entropy anomalies are present, it is determined that there is abnormal calling behavior in the current detection round, in order to take into account both temporal distribution characteristics and logically strong deterministic characteristics, and avoid random changes in a single indicator.

[0075] The technical solution provided in this embodiment refines the specific judgment method for abnormal call behavior. Specifically, after calculating the temporal entropy and state entropy in each detection round, the respective reference information (i.e., mean and variance) is updated. A joint threshold judgment is then performed based on the updated reference information, thus taking into account both the strong clustering characteristics in the temporal distribution and the strong deterministic characteristics in the call logic. This avoids misjudgments caused by accidental fluctuations in a single indicator, thereby accurately identifying abnormal IAT call behavior and improving the accuracy of IAT abnormal call behavior detection.

[0076] In one implementation, when it is determined that there is abnormal call behavior, the method further includes: obtaining the context data of the target protection program, generating a memory dump file of the target protection program based on the context data, the memory dump file being used for post-event forensic analysis, collecting the associated log information of the current abnormal call behavior, and sending the associated log information to the security management center to issue a system alarm.

[0077] Specifically, after determining that there is abnormal calling behavior in the current detection round, a set of preset security operations are executed, including: terminating the running program to interrupt the continued issuance of attack commands; obtaining context data including memory image, register values, and call stack information, and creating a memory dump file based on the context data, which is used for post-event forensic reference; and saving the associated log information when the anomaly occurred, which may include timestamp information of 64 related call events, function identification information, time entropy, state entropy, and the baseline parameters and judgment thresholds that were in effect at that time, and notifying the security management center and other system software through local sockets or operating system message queues.

[0078] In one implementation, after determining the target protection procedure, the method further includes the following steps: S111: In response to the initiation of the target protection procedure, enter the baseline learning phase; S113: During the baseline learning phase, stop judging the abnormal call behavior, and perform the generation and storage of record information, the determination of temporal entropy and state entropy, the updating of temporal reference information based on temporal entropy, and the updating of state reference information based on state entropy. S115: Exit the baseline learning phase when the preset learning time is reached.

[0079] Specifically, to avoid false alarms caused by a series of intensive initialization calls such as module loading and global object creation during the target protection program's startup, the initial 30 seconds of a single process's lifecycle are designated as a baseline learning phase. During this time, the process continues to receive and parse call information, perform entropy calculations and parameter iterations, but does not perform anomaly detection logic operations or take any form of alarm measures. After exiting the baseline learning phase, it checks whether any abnormal call behavior exists in any subsequent detection round. That is, after the 30-second countdown ends, it automatically switches to anomaly monitoring mode, using a combination of two thresholds for judgment.

[0080] Please see Figure 4 Secondly, one embodiment of this application provides a method for detecting abnormal IAT call behavior, which is applied to the operating system kernel layer. The method may include the following steps: S121: Scan the image structure of the target protection program to locate multiple IAT entries of the target protection program; S123: Replace the external function address under the IAT entry with the jump stub address pointing to the jump stub, so that when the user mode executes the function call instruction of the target protection instruction, it can determine whether there is an abnormal call through the corresponding jump stub; The jump stub is used to generate record information of function call instructions. The record information is stored in the cache area. The record information is used to determine the temporal entropy and state entropy of the current detection round when the cache area meets the preset detection conditions. The temporal entropy and state entropy are used to determine whether there is an abnormal call in the current detection round when the preset detection conditions are met, so as to terminate the target protection program when an abnormal call behavior is determined.

[0081] The further functional descriptions of each step S121-S123 above are the same as those in the corresponding embodiment of the first aspect above, and will not be repeated here.

[0082] Please see Figure 5 , Figure 5 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application, such as... Figure 5As shown, the computer device includes one or more processors 10, memory 20, and interfaces for connecting the components, including high-speed interfaces and low-speed interfaces. The components communicate with each other via different buses and can be mounted on a common motherboard or otherwise installed as needed. The processors can process instructions executed within the computer device, including instructions stored in or on memory to display graphical information of a GUI on external input / output devices (such as display devices coupled to the interfaces). In some alternative implementations, multiple processors and / or multiple buses can be used with multiple memories and multiple memory modules, if desired. Similarly, multiple computer devices can be connected, each providing some of the necessary operations (e.g., as a server array, a group of blade servers, or a multiprocessor system). Figure 5 Take a processor 10 as an example.

[0083] Processor 10 may be a central processing unit, a network processor, or a combination thereof. Processor 10 may further include a hardware chip. The hardware chip may be an application-specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The programmable logic device may be a complex programmable logic device (CAMP), a field-programmable gate array (FPGA), a general-purpose array logic (GDA), or any combination thereof.

[0084] The memory 20 stores instructions executable by at least one processor 10 to cause the at least one processor 10 to perform the method shown in the above embodiments.

[0085] The memory 20 may include a program storage area and a data storage area. The program storage area may store the operating system and applications required for at least one function; the data storage area may store data created based on the use of the computer device. Furthermore, the memory 20 may include high-speed random access memory and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some alternative embodiments, the memory 20 may optionally include memory remotely located relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0086] The memory 20 may include volatile memory, such as random access memory; the memory may also include non-volatile memory, such as flash memory, hard disk or solid-state drive; the memory 20 may also include a combination of the above types of memory.

[0087] The computer device also includes a communication interface 30 for communicating with other devices or communication networks.

[0088] This application also provides a computer-readable storage medium. The methods described in this application can be implemented in hardware or firmware, or implemented as recordable on a storage medium, or implemented as computer code downloaded over a network and originally stored on a remote storage medium or a non-transitory machine-readable storage medium and subsequently stored on a local storage medium. Thus, the methods described herein can be processed by software stored on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. The storage medium can be a magnetic disk, optical disk, read-only memory, random access memory, flash memory, hard disk, or solid-state drive, etc.; further, the storage medium can also include combinations of the above types of memory. It is understood that computers, processors, microprocessor controllers, or programmable hardware include storage components capable of storing or receiving software or computer code. When the software or computer code is accessed and executed by the computer, processor, or hardware, the methods shown in the above embodiments are implemented.

[0089] This application provides a computer program product including computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the method of any embodiment of this application.

[0090] Those skilled in the art will understand that embodiments of this application can be provided as methods, apparatus, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0091] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus, and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0092] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0093] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0094] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0095] The various embodiments in this specification are described in a progressive manner. The same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on describing the differences from other embodiments.

[0096] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

[0097] Although embodiments of this application have been described in conjunction with the accompanying drawings, those skilled in the art can make various modifications and variations without departing from the spirit and scope of this application, and such modifications and variations all fall within the scope defined by the appended claims.

Claims

1. A method for detecting abnormal IAT call behavior, characterized in that, The method is applied to the operating system application layer; the method includes: The target protection program is determined, wherein the target protection program is configured with multiple IAT entries, and the external function addresses stored in the IAT entries are replaced with jump stub addresses in kernel mode; In response to a function call instruction in the target protection program, the IAT entry pointed to by the function call instruction is invoked to jump to the jump stub corresponding to the IAT entry; The jump stub generates a record of the function call instruction, which is then stored in a cache area. When the cache area meets a preset detection condition, the temporal entropy and state entropy of the current detection round are determined based on the multiple records in the cache area. Based on the time entropy and the state entropy, it is determined whether there is any abnormal calling behavior in the current detection round. If abnormal calling behavior is determined to exist, the target protection program is terminated.

2. The method according to claim 1, characterized in that, The recorded information includes timestamp information and function identifier information; the jump stub includes a timestamp recording function and an identifier extraction function; wherein: The timestamp recording function is used to generate timestamp information for the function call instruction, and the timestamp information is used to determine the temporal entropy of the current detection round; The identifier extraction function is used to generate function identifier information corresponding to the function call instruction, and the function identifier information is used to determine the state entropy of the current detection round.

3. The method according to claim 2, characterized in that, The value range of the function identifier information is an integer range from 0 to 255; the identifier extraction function generates the function identifier information in the following manner: Determine the import form of the external function called by the function call instruction; When the import format is function name import, a hash operation is performed on the function name, and the function identification information is extracted based on the hash operation result and the value range; When the import form is ordinal import, the function identifier information is extracted based on the ordinal number and the value range.

4. The method according to claim 2, characterized in that, Determining the temporal entropy of the current detection round includes: Obtain multiple timestamp information within the cache area, sort the timestamp information in ascending order according to the call sequence, and determine multiple time sub-intervals of the current detection round based on the timestamp information; For any given time sub-interval, generate the probability distribution of the time sub-interval based on the number of calls represented by the time sub-interval; The temporal entropy of the current detection round is determined based on the probability distribution of each of the aforementioned time sub-intervals.

5. The method according to claim 2, characterized in that, Determining the state entropy of the current detection round includes: Obtain multiple function identifiers within the cache area, arrange the function identifiers in order of call sequence, and combine adjacent function identifiers arranged in order to form the state transition sequence of the current detection round. Based on the state transition sequence, establish the state transition matrix; For any row of the state transition matrix, determine the conditional transition probability and steady-state probability of the row, and determine the state entropy of the current detection round based on the conditional transition probability and the steady-state probability.

6. The method according to claim 1, characterized in that, The cache area includes a primary cache area and a secondary cache area; Storing the recorded information in the cache area includes: The main cache and the secondary cache are used alternately to store recorded information until the target protection program terminates; wherein, when any of the cache areas meets the preset detection conditions, the cache area is replaced.

7. The method according to claim 6, characterized in that, The cache region replacement is performed via atomic substitution operations; The atomic substitution operation includes: The current write pointer is transiently switched from the current cache region in the write state to point to another cache region, so that the current cache region is switched to the read state and the other cache region is switched to the write state.

8. The method according to claim 1, characterized in that, Determining whether there is abnormal calling behavior in the current detection round based on the time sequence entropy and the state entropy includes: Obtain the timing reference information and status reference information for the current detection round; The time series reference information is updated based on the time series entropy, and the time series entropy anomaly is determined based on the time series entropy and the updated time series reference information. The state reference information is updated based on the state entropy, and the state entropy anomaly is determined based on the state entropy and the updated state reference information. If the time-series entropy and state entropy are determined to be abnormal, it is determined that there is abnormal calling behavior in the current detection round.

9. The method according to claim 8, characterized in that, The time series reference information includes the time series entropy mean and the time series entropy variance, and the state reference information includes the state entropy mean and the state entropy variance. Updating the timing reference information and the state reference information includes: The mean of the time entropy and the variance of the time entropy are updated according to the time entropy and the preset update weight, respectively. And based on the state entropy and the preset update weight, the mean of the time entropy and the variance of the time entropy are updated respectively.

10. The method according to claim 1, characterized in that, The method further includes: if it is determined that there is no abnormal call behavior, jumping to the address of the external function corresponding to the function call instruction.

11. The method according to claim 8, characterized in that, After determining the target protection program, the method further includes: In response to the initiation of the target protection procedure, the baseline learning phase begins; During the baseline learning phase, the judgment of the abnormal call behavior is stopped, and the generation and storage of the record information, the determination of the temporal entropy and the state entropy are performed, the temporal reference information is updated according to the temporal entropy, and the state reference information is updated according to the state entropy. When the preset learning time is reached, the baseline learning phase is exited.

12. A method for detecting abnormal IAT call behavior, characterized in that, The method is applied to the operating system kernel layer; the method includes: Scan the target protector's image structure to locate multiple IAT entries of the target protector; Replace the external function address under the IAT entry with the jump stub address pointing to the jump stub, so that when the user mode executes the function call instruction of the target protection instruction, it can determine whether there is an abnormal call through the corresponding jump stub; The jump stub is used to generate record information of the function call instruction. The record information is stored in a cache area. The record information is used to determine the temporal entropy and state entropy of the current detection round when the cache area meets the preset detection conditions. The temporal entropy and state entropy are used to determine whether there is abnormal call behavior in the current detection round, so as to terminate the target protection program when abnormal call behavior is determined to exist.

13. The method according to claim 12, characterized in that, If abnormal call behavior is determined to exist, the method further includes: Obtain the context data of the target protection program, and generate a memory dump file of the target protection program based on the context data. The memory dump file is used for post-event forensic analysis. Collect associated log information of the current abnormal call behavior and send the associated log information to the security management center to issue a system alarm.

14. A computer device, characterized in that, include: A memory and a processor are communicatively connected, the memory stores computer instructions, and the processor executes the computer instructions to perform the IAT abnormal call behavior detection method according to any one of claims 1 to 13.

15. A computer program product, characterized in that, It includes computer instructions for causing a computer to execute the method for detecting abnormal IAT call behavior as described in any one of claims 1 to 13.