CN114329478A - Android system service memory consumption vulnerability mining method - Google Patents
Android system service memory consumption vulnerability mining method Download PDFInfo
- Publication number
- CN114329478A CN114329478A CN202111484888.7A CN202111484888A CN114329478A CN 114329478 A CN114329478 A CN 114329478A CN 202111484888 A CN202111484888 A CN 202111484888A CN 114329478 A CN114329478 A CN 114329478A
- Authority
- CN
- China
- Prior art keywords
- input
- memory
- seeds
- fuzzy test
- test
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Abstract
The invention belongs to the technical field of software vulnerability mining, and particularly relates to a vulnerability mining method for android system service memory consumption. The method comprises two stages of static analysis and dynamic fuzzy test; the task of the static analysis stage is to position potential bugs, firstly, positioning data storage instructions and system service interfaces capable of reaching the instructions through heuristic rules; constraints are then collected for arriving at the data store instructions, and initial inputs for the fuzz tests are generated based on the constraints. The dynamic fuzzy test stage is to judge whether the attack to the data storage instruction in the time window is enough to cause the security influence; in the dynamic fuzzing test process, a new method is provided in the four aspects of feedback collection, seed selection, seed generation and mutation and attack code generation, so that the high-efficiency fuzzing test is realized: the method can efficiently and accurately detect the memory consumption vulnerability in the android system service.
Description
Technical Field
The invention belongs to the technical field of software vulnerability mining, and particularly relates to a vulnerability mining method for android system service memory consumption.
Background
The memory consumption type bug is a bug which can cause denial of service attack by occupying process memory resources and influencing the normal operation of a process by triggering a data storage instruction for multiple times. A large number of data storage processes which are not monitored exist in the android system service, and the data storage processes and related data storage operations thereof can cause memory consumption type bugs in the android system service. Many work today detects memory leak problems by determining data in a program that is not needed but not released, but this approach is not suitable for detecting memory consumption-like vulnerabilities of android services, because memory data stored in the android services may be used in the future and therefore cannot be considered as data that is not needed; there is also some work focused on determining boundaries for program memory consumption.
The fuzzy test is an efficient vulnerability mining technology, but the existing method is difficult to meet the requirement of automatically mining memory consumption type vulnerabilities of the android system. The existing fuzzy test method is difficult to meet the requirement of mining memory consumption type bugs in android system services. First, designs lack systematic understanding of data storage instructions, so they cannot effectively cover different kinds of data storage instructions in a large number of android system service interfaces; secondly, most of the fuzzy test methods rely on the field knowledge provided by human on the input generation and seed selection, for example, AFLGO [1] adopts fixed time to perform stage division during seed selection, but different android system service interfaces provide different functions, so that a general solution which does not rely on expert knowledge is needed; in addition, some works, although they propose a measure of alleviating this problem, are still not efficient enough in terms of memory consumption type vulnerability mining, such as Vuzzer [2] uses static analysis technology to aggressively extract data stream features of conditional checking for input generation, but it is better to understand the process of data storage first, and then identify conditional checking data stream features having a data stream relationship with data storage instructions, and the conditional checking in the android system usually depends on dynamic values determined by the system operating state, and thus is difficult to obtain directly through static analysis; thirdly, most of the existing tools are insensitive to the change of the size of the memory, and the feedback information is difficult to be utilized to effectively improve the efficiency of the directional fuzzy test; finally, the existing working instrumentation method has a large overhead, which can seriously affect the efficiency of feedback collection.
Disclosure of Invention
The invention aims to provide a brand-new android system service memory consumption vulnerability mining method based on instruction identification and directional fuzzy test, which is suitable for automatically mining and verifying resource consumption vulnerabilities in android system services.
The android system service memory consumption vulnerability mining method based on instruction identification and directional fuzzy test provided by the invention combines static analysis to position potential memory consumption vulnerabilities according to heuristic rules; in a directional fuzzy test process with the potential vulnerability as a target, aiming at the memory consumption vulnerability, designing a lightweight feedback collection, high-quality seed selection and staged seed generation variation method; in the process, the time overhead of the fuzzy test path exploration phase and the vulnerability attack phase is balanced. The method can efficiently and accurately detect the memory consumption vulnerability in the android system service. The method specifically comprises two stages of static analysis and dynamic fuzzy test.
A static analysis stage; the task of static analysis is to locate potential vulnerabilities and generate initial inputs for the fuzzy test; specifically, data storage instructions and system service interfaces capable of reaching the instructions are first located through heuristic rules; constraints are then collected for arriving at the data store instructions, and initial inputs for the fuzz tests are generated based on the constraints.
And (II) a dynamic fuzzing test stage, wherein the purpose of the dynamic fuzzing test is to judge whether the attack on the data storage instruction in the time window is enough to cause the security influence. In the dynamic fuzzy test process, the invention provides a new method in four aspects of feedback collection, seed selection, seed generation and variation and attack code generation, thereby realizing high-efficiency fuzzy test:
(1) regarding feedback collection, the invention designs a lightweight feedback collection method to guide the fuzzy test; the method comprises the steps of efficiently collecting an execution path and a memory consumption condition input in the fuzzy test process so as to evaluate the contribution of seed input in the aspects of exploration and memory consumption; specifically, the distance from the execution path to the target instruction is collected as feedback information (exploration contribution) of the fuzz test exploration, and the change of the memory size is collected as feedback information (memory consumption contribution) of the fuzz test attack;
(2) regarding seed selection, the fuzzy test needs to select high-quality seed input for mutation and execution; the invention adopts a simulated annealing algorithm, combines the collected feedback information, and dynamically selects and eliminates the input of seeds;
(3) regarding seed generation and variation, the invention adopts different variation strategies to generate new input according to the stage of the seed at which the fuzzy test is positioned;
(4) with regard to attack code generation, the invention reuses high-quality seeds in the fuzz test to generate effective attack codes.
The process flow of the method of the invention is shown in FIG. 1.
Further, in the static analysis phase:
the potential vulnerability location is specifically implemented by observing memory consumption vulnerabilities in android system services, wherein the vulnerabilities have some constraint conditions, namely, the system services need to store references of stored data, and a data structure used for storing the references has variable size. Based on this observation, first identify all fields defined in the android system service, and all global static fields in the android framework; then selecting container fields from the container fields, and marking the capacity expansion operation of the container fields as a data storage instruction; and finally, finding a system service interface which can possibly reach the data storage instruction by using backward control flow analysis, and filtering out an interface with parameters depending on data with the target instruction by using data flow analysis.
The fuzzy test initial input is generated by selecting the initial input from the branch condition of the path constraint. Branch statements typically compare the input to a particular constant or dynamic system state variable (e.g., userlandler. getuserld ()). Thus, the present invention directly uses the return value of a constant or such function as an initial input.
In the static analysis process, the interface parameters are divided into control flow related input, data flow related input and other types of input through the analysis results of the control flow and the data flow, and then the fuzzy test can selectively change different types of input at different stages.
Further, in the fuzz testing stage:
(1) regarding feedback collection
The calculation flow of the distance from the execution path to the target instruction is as follows: considering whether data store instructions are called or not depending on preconditions in their caller control flow structure, the present invention collects function-level execution paths and uses intra-function Control Flow (CFG) information to improve the accuracy of function-level distance calculations, to calculate an estimated probability of a function reaching a target, and thus uses this probability to calculate the "distance" of a directed fuzzy test. Specifically, the reachable probability of a target function on a function Call Graph (CG) is set to 1.0, then the estimated probability of each reachable function reaching the target is calculated in a backward traversal mode on the CG graph, and the maximum value c of the estimated probability of the function is set for an execution path input by a seed in the fuzzy test processrAs a heuristic contribution score for the seed. During backward traversal, the probability of calling adjacent functions on the CG by the function is estimated according to the CFG of the function, and then the estimated probability of finally calling the target function by the function is calculated through traversal. As shown in fig. 3.
In order to observe the accumulation result of multiple executions, the invention designs a memory size monitor. Specifically, the monitor selects two indicators to observe the memory size change. Respectively as follows: 1) the size of the JVM heap, and the android JVM limits the heap memory upper limit occupied by the process; 2) customizing the size of the memory, distributing the customized memory objects in the android system service, and identifying the objects through static analysisAnd the invention further finds the conditional judgment statements for checking the sizes of the objects through control flow analysis, and extracts constants representing the upper limit of the customized memory size from the conditional judgment statements. System service memory indicator size m before execution through observation interfaceiAfter execution size meIn combination with the memory indicator upper limit mtThe memory consumption contribution c of the seed can be calculatedm：
(2) Regarding seed selection
The specific process is as follows: the method comprises the steps of selecting seeds which are closer to a target or consume more memory resources, dynamically selecting exploratory or aggressive seeds by adopting a simulated annealing algorithm, and simultaneously preventing the fuzzy test from wasting too much time in an exploration stage or on a path which is difficult to succeed in attack. The key to the simulated annealing algorithm is to gradually eliminate inefficient seeds, and for seeds that are executed or mutated multiple times, the simulated annealing algorithm gradually decreases its "temperature," i.e., decreases its priority for selection and mutation.
(3) Relating to seed production and variation
Respectively adopting different variation strategies to generate new input according to the stage of the seeds in the fuzzy test; the specific process is as follows:
in the exploration phase, the fuzzy test target is to find a seed which can reach the fuzzy test target, so that the input parameters of the service interface of the system to be tested related to the control flow are mainly concerned in the phase. After the seeds are selected in the stage, a series of new seeds are generated on the basis of the selected seeds by compiling the seeds and inputting the seeds related to the control flow, and the generated quantity depends on the energy of the seeds.
In the attack stage, in order to ensure that the target of the fuzz test can be stably executed, the invention does not change the input parameters related to the input of the seeds, but only changes the parameters related to the memory consumption. Variability of memory consumption related parameters at this stage is necessary because repeated calls to the interface using the same input parameters may not result in cumulative consumption of memory in some cases. For example, when the data storage instruction inserts data into the hash table, if the inserted data has the same key value as the existing data of the hash table, the memory usage of the hash table is not increased by the inserting operation. This stage is intended to consume memory resources of the android services, so the present invention will mutate memory consumption related inputs in the direction of increasing memory size. Specifically, we observe that memory consumption inputs generally serve two purposes: 1) the size of the memory allocation, such as the length of the container; 2) content stored in memory, such as elements in storage and containers. For inputs of the first type, which are typically of a particular integer type, the invention will tend to generate integer values for such inputs that are of a larger value and, when mutated, generate inputs that differ less from them. The memory occupied by the second type of input is typically dependent on the String objects stored in the input, and the length of String objects in Java is not limited. Therefore, the present invention tends to generate different and longer String values for such inputs at this stage.
(4) Code generation for attacks
The method for multiplexing the high-quality seeds in the fuzzy test to generate the effective attack codes comprises the following specific processes: firstly, collecting high-quality seeds in the fuzziness test, and then multiplexing the seeds in the attack stage to generate new seeds in the attack codes; in attack code, only the inputs that are relevant to the input are mutated. And constructing an android application program of a third party according to the code template, wherein the code template comprises codes for sending requests to the android system service through Binder interprocess communication, and the generated application program can consume memory resources of the android system service.
Drawings
Fig. 1 is a diagram of the overall architecture of the system.
FIG. 2 is an example of extracting initial input from an android.
Fig. 3 is an example of distance calculation in feedback collection, and calculates the probability of the function e reaching the target data storage instruction s according to the information provided by the intra-function control flow graph.
Detailed Description
The invention designs and realizes the android system service memory consumption vulnerability mining method based on instruction recognition and directional fuzzy test. This section details the specific implementation of the framework.
(one) static analysis
The method uses Smali/BakSmali and vDexExtractor tools to disassemble Java byte codes of the android system, and uses the Soot framework to realize static analysis of the android system codes. First, screening system services and fields of various containers of types such as arrays, sets, maps, queues, lists, or databases in the global static state and capacity expansion operations such as add (), put () and insert () therein are used as data storage instructions, and a total of 96 kinds of such instructions are obtained. Then, a backward control flow analysis and a data flow analysis are used on the instructions to determine the reachable interfaces and the functions having data dependent parameters with the data store instructions. In this way, 609 fuzzy test targets and 1244 associated common interfaces are screened.
(II) fuzz testing
The present invention collects input feedback through dynamic instrumentation and uses it for seed selection. Specifically, function level instrumentation is carried out on the android system by utilizing an Xpos framework to collect function paths passed by input execution in the dynamic fuzzy test, and the distance from an interface function to a fuzzy test target is estimated by combining a static calculation method, so that an exploration contribution score c of the input execution is obtainedr. In addition, instrumentation is performed before and after execution of the data storage instructions, and the size change of the customized memory in the interface calling process is collected. In order to collect the memory changes of the system JVM as a whole, the seed and its multiple variants are executed, and the memory changes in this period are collected to observe the memory changes as a whole. Thus, the memory consumption contribution c can be estimatedm。
During seed selection, the method gradually eliminates the low-efficiency seeds by adopting a simulated annealing mode. First, according to the number of times N the seed is variant executed, the "temperature" coefficient is calculated:
thereby calculating the final contribution score c ═ c of the seedr+cm) T. Then, the energy of the seed (the number of times of execution of the single round of mutation) is calculated based on the score
Where b is the initial energy and k is 100.
When the seed variation is generated, the input is dynamically generated according to the stage of the seed. For example, the system service interface account () has only one parameter, which includes three fields, name, type, and accessId. The first field is identified as the input related to memory consumption, and the other two fields are the input related to control flow, so that the name field is mutated into a character string with longer length in the fuzz test of the attack stage. This can increase the efficiency of the mutation and make memory consumption faster.
When the seeds are generated and mutated, a mutation strategy is dynamically selected, and compared with a fixed time distribution strategy, the strategy can more effectively find the vulnerability. Specifically, 5 rounds of 300 seconds of directional fuzz testing are carried out on the discovered vulnerability by using three time allocation strategies of 5:1, 1:1 and dynamic, and the speed of the vulnerability crash triggered by the dynamic strategy is about four times that of the other two allocation strategies.
The analysis time of the android system is about 204 hours, wherein the static analysis takes about 4 hours to locate 435 potentially dangerous data storage instructions and 963 public interfaces, and the dynamic analysis takes about 148 hours to explore and 52 hours to attack. The fuzz test timeout for each interface in the experiment was 300 seconds, and the tool output a total of 673 crash and 673 attack codes. These crashes were analyzed to cover 40 bugs, 35 of which were memory consumption class bugs and no false positives. The detected vulnerability may be triggered by 474 different interfaces.
Reference to the literature
[1]
Marcel,et al."Directed greybox fuzzing."Proceedings of the 2017ACM SIGSAC Conference on Computer and Communications Security.2017.
[2]Rawat,Sanjay,et al."VUzzer:Application-aware Evolutionary Fuzzing."NDSS.Vol.17.2017。
Claims (8)
1. A vulnerability mining method for android system service memory consumption is characterized by comprising two stages of static analysis and dynamic fuzzy test; wherein:
a static analysis stage; the task of static analysis is to locate potential vulnerabilities and generate initial inputs for the fuzzy test; specifically, data storage instructions and system service interfaces capable of reaching the instructions are first located through heuristic rules; then collecting the constraint conditions of the data storage instruction, and generating the initial input of the fuzzy test according to the constraint conditions;
step two, a dynamic fuzzy test stage, wherein the purpose of the dynamic fuzzy test is to judge whether the attack to the data storage instruction in the time window is enough to cause the security influence; in the dynamic fuzzing test process, a new method is adopted in the four aspects of feedback collection, seed selection, seed generation and mutation and attack code generation, so that the high-efficiency fuzzing test is realized: the method specifically comprises the following steps:
(1) regarding feedback collection, a lightweight feedback collection method is designed to guide the fuzzy test; the method comprises the steps of efficiently collecting an execution path and a memory consumption condition input in the fuzzy test process so as to evaluate the contribution of seed input in the aspects of exploration and memory consumption; specifically, the distance from the execution path to the target instruction is collected as feedback information of the fuzz test exploration, which is called exploration contribution, and the change of the memory size is collected as feedback information of the fuzz test attack, which is called memory consumption contribution;
(2) regarding seed selection, the fuzzy test needs to select high-quality seed input for mutation and execution; specifically, a simulated annealing algorithm is adopted, and the collected feedback information is combined to dynamically select and eliminate seed input;
(3) regarding generation and variation of seeds, respectively adopting different variation strategies to generate new input according to the stage of the seeds in the fuzzy test;
(4) with regard to attack code generation, high-quality seeds in the fuzz test are multiplexed to generate effective attack codes.
2. The android system service memory consumption vulnerability mining method of claim 1, wherein in a static analysis stage:
the specific method for positioning the potential vulnerability comprises the following steps: based on observation of memory consumption vulnerabilities in android system services, there are some constraints on vulnerabilities — the system services are to save references to stored data, and the data structures used for saving are of variable size; accordingly, all fields defined in the android system service and all global static fields in the android frame are identified; then selecting container fields from the container fields, and marking the capacity expansion operation of the container fields as a data storage instruction; finally, a system service interface which can possibly reach a data storage instruction is found by using backward control flow analysis, and an interface with data dependence between a parameter and a target instruction is filtered by using data flow analysis;
the fuzzy test initial input is generated by selecting an initial input from a branch condition of path constraint; the branch statement compares the input with a specific constant or dynamic system state variable; the constants or the return values of such functions are used directly as initial inputs.
3. The android system service memory consumption vulnerability discovery method of claim 2, characterized in that in the static analysis process, interface parameters are further divided into control flow related inputs, data flow related inputs and other types of inputs according to control flow and data flow analysis results, so that later fuzzy tests can selectively vary different types of inputs at different stages.
4. The android system services memory of claim 3The consumption vulnerability mining method is characterized in that in the fuzzy test stage, the calculation process of the distance from the execution path to the target instruction in the feedback collection is as follows: collecting execution paths of function levels according to the fact that whether the data storage instructions are called depends on the precondition in the control flow structure of the caller, and improving the accuracy of function level distance calculation by using CFG (computational fluid dynamics) information of the control flow in the function so as to calculate the estimated probability of the function reaching a target; further, the distance of the directional fuzz test is calculated by utilizing the probability; specifically, the reachable probability of a target function on a function call graph CG is set to 1.0, and then the estimated probability of each reachable function reaching the target is calculated in a backward traversal mode on the CG graph; in the fuzzy test process, for the execution path of the seed input, the maximum value of the function estimation probability is used as the exploration contribution of the seedc r (ii) a During backward traversal, the probability of calling adjacent functions on the CG by the function is estimated according to the CFG of the function, and then the estimated probability of finally calling the target function by the function is calculated through traversal.
5. The android system services memory consumption vulnerability discovery method of claim 4, characterized in that, in order to observe the cumulative consequences of multiple executions, a memory size monitor is designed; the monitor selects two indicators to observe the memory size change, which are respectively: (1) JVM heap size; (2) customizing the size of the memory; finding out condition judgment statements for checking the sizes of the objects through control flow analysis, and extracting constants representing the upper limit of the size of the customized memory from the condition judgment statements; system service memory indicator size before execution through observation interfacem i Size after executionm e In combination with memory indicator upper boundm t Calculating the memory consumption contribution of the seedc m ：
6. The android system service memory consumption vulnerability mining method of claim 5, wherein in the fuzzy test stage, the specific flow regarding seed selection is as follows:
selecting seeds which are closer to a target or consume more memory resources, dynamically selecting exploratory or offensive seeds by adopting a simulated annealing algorithm, and simultaneously preventing the fuzzy test from wasting too much time in an exploration stage or on a path which is difficult to attack successfully; gradually eliminating inefficient seeds by a simulated annealing algorithm; for a seed that is executed or mutated multiple times, the priority of being selected and mutated is gradually reduced by the simulated annealing algorithm.
7. The android system service memory consumption vulnerability discovery method of claim 6, wherein in the fuzzy test stage, regarding the seed generation and variation, different variation strategies are respectively adopted to generate new inputs according to the stage where the seed is in the fuzzy test, and the specific flow is as follows:
in the exploration phase, the fuzzy test target is to find seeds which can reach the fuzzy test target, so that the input parameters of the service interface of the system to be tested and the related control flow are mainly concerned in the phase; after the seeds are selected, a series of new seeds are generated by compiling the seeds and inputting the seeds related to the control flow on the basis of the selected seeds, and the generated quantity depends on the energy of the seeds;
in the attack stage, in order to ensure that the target of the fuzzy test can be stably executed, the input parameters related to the input of the seeds are not mutated, and only the parameters related to the memory consumption are mutated; specifically, there are two uses in view of memory consumption input: (1) the size of the memory allocation; (2) content stored in the memory; a first input, typically of a specific integer type, for which a numerically larger integer value is generated and, upon mutation, an input differing less therefrom; the second input, the occupied memory depends on the String object stored in the input, and the length of the String object in Java is not limited; thus, different and longer String values are generated for this type of input at this stage.
8. The android system services memory consumption vulnerability mining method of claim 7, wherein in a fuzzy test stage, effective attack codes are generated with respect to high quality seeds in the multiplexing fuzzy test in attack code generation, and a specific flow is as follows: firstly, collecting high-quality seeds in the fuzziness test, and then multiplexing the seeds in the attack stage to generate new seeds in the attack codes; in attack code, only the inputs that are relevant to the input are mutated; and constructing an android application program of a third party according to the code template, wherein the code template comprises codes for sending requests to the android system service through Binder interprocess communication, and the generated application program can consume memory resources of the android system service.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111484888.7A CN114329478A (en) | 2021-12-07 | 2021-12-07 | Android system service memory consumption vulnerability mining method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111484888.7A CN114329478A (en) | 2021-12-07 | 2021-12-07 | Android system service memory consumption vulnerability mining method |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114329478A true CN114329478A (en) | 2022-04-12 |
Family
ID=81047807
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111484888.7A Pending CN114329478A (en) | 2021-12-07 | 2021-12-07 | Android system service memory consumption vulnerability mining method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114329478A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115270139A (en) * | 2022-09-20 | 2022-11-01 | 哈尔滨工业大学(深圳)(哈尔滨工业大学深圳科技创新研究院) | IoT equipment network service automatic vulnerability analysis method and system |
-
2021
- 2021-12-07 CN CN202111484888.7A patent/CN114329478A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115270139A (en) * | 2022-09-20 | 2022-11-01 | 哈尔滨工业大学(深圳)(哈尔滨工业大学深圳科技创新研究院) | IoT equipment network service automatic vulnerability analysis method and system |
| CN115270139B (en) * | 2022-09-20 | 2023-01-17 | 哈尔滨工业大学(深圳)(哈尔滨工业大学深圳科技创新研究院) | IoT equipment network service automatic vulnerability analysis method and system |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7975256B2 (en) | Optimizing application performance through data mining | |
| US7448020B2 (en) | Autonomic computing system, execution environment control method and program | |
| CN111695119B (en) | Web vulnerability detection method based on fine-grained static stain analysis and symbol execution | |
| RU2427890C2 (en) | System and method to compare files based on functionality templates | |
| CN111240991B (en) | Dynamic stain detection method and system for resisting implicit stain propagation | |
| CN111723380B (en) | Method and device for detecting component vulnerability | |
| CN101853200A (en) | High-efficiency dynamic software vulnerability exploiting method | |
| CN109948338B (en) | Android application sensitive path triggering method based on static analysis | |
| CN112866292B (en) | Attack behavior prediction method and device for multi-sample combination attack | |
| CN113326050A (en) | Intelligent contract vulnerability detection method based on combination of neural network and dynamic fuzzy test | |
| CN115455435A (en) | Intelligent contract fuzzy test method and device, storage medium and electronic equipment | |
| CN114329478A (en) | Android system service memory consumption vulnerability mining method | |
| CN114780962B (en) | Windows program fuzzy test method and system based on dynamic energy regulation and control | |
| CN112948828A (en) | Binary program malicious code detection method, terminal device and storage medium | |
| CN112506564B (en) | Method, system and medium for establishing control flow graph | |
| CN113971135A (en) | Coverage-guided intelligent contract test case generation method | |
| CN109766690A (en) | A kind of ROP and mutation attacks dynamic testing method based on the detection of more policy instructions | |
| CN113836009A (en) | Intelligent contract fuzzy test method and system based on reinforcement learning | |
| US8418127B2 (en) | Autonomic computing system, execution environment control program | |
| US7647581B2 (en) | Evaluating java objects across different virtual machine vendors | |
| US20060004810A1 (en) | Method, system and product for determining standard java objects | |
| CN117331826A (en) | Mixed fuzzy test optimization method for mining security holes | |
| CN111428247A (en) | Method for improving computer leak library | |
| US11822463B2 (en) | Computer-implemented method and device for selecting a fuzzing method for testing a program code | |
| Jiang et al. | An exploitability analysis technique for binary vulnerability based on automatic exception suppression |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |