CN114691197A - Code analysis method and device, electronic equipment and storage medium - Google Patents

Abstract

The application provides a code analysis method, a code analysis device, electronic equipment and a storage medium. The method comprises the following steps: acquiring a syntax tree of a source code to be analyzed and an analysis rule corresponding to a target defect type; and analyzing the syntax tree by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed. Thus, defects in the source code in the code library can be determined by this method.

Description

Code analysis method, apparatus, electronic device and storage medium

technical field

The present application relates to the technical field of data processing, and in particular, to a code analysis method, apparatus, electronic device, and storage medium.

Background technique

The code base can usually be used to store the source code of the application. In practical applications, the source code in the code base can be statically analyzed to determine the defects in the source code. Therefore, how to statically analyze the source code is crucial.

SUMMARY OF THE INVENTION

The purpose of the embodiments of the present application is to provide a code analysis method, an apparatus, an electronic device, and a storage medium, so as to solve the problems in the prior art.

A first aspect of the embodiments of the present application provides a code analysis method, the method comprising:

Obtain the syntax tree of the source code to be analyzed, and the analysis rules corresponding to the target defect type;

The syntax tree is analyzed by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed.

In one embodiment, the method further includes:

Obtain a code analysis request, where the code analysis request includes the target defect type and the identification information of the source code to be analyzed; accordingly,

Obtain the syntax tree of the source code to be analyzed and the analysis rules corresponding to the target defect type, including:

Obtain the syntax tree of the source code to be analyzed by using the identification information of the source code to be analyzed; and obtain the analysis rule by using the target defect type.

In one embodiment, the method further includes:

Build corresponding code analysis tasks separately for the source code of different applications in the code base and/or the source code of different versions of the same application; and,

Get code analysis requests, including:

When the code analysis task is triggered, the code analysis request is acquired.

In one embodiment, acquiring the syntax tree of the source code to be analyzed specifically includes: acquiring the syntax tree from a syntax tree database.

In one embodiment, acquiring the syntax tree of the source code to be analyzed specifically includes:

Perform lexical analysis on the source code to be analyzed according to the grammar rules of the programming language of the source code to be analyzed;

The result of the lexical analysis is parsed to generate the syntax tree.

In one embodiment, the analysis rules corresponding to the target defect types are obtained in the following manner:

The analysis rule corresponding to the target defect type is obtained by using the preset correspondence between the defect type and the analysis rule.

In one embodiment, the syntax tree is analyzed by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed, which specifically includes:

Perform type analysis, constant analysis, syntax tree analysis, control flow analysis, data flow analysis and/or taint analysis on the syntax tree using the analysis rules to determine the code of the target defect type in the source code to be analyzed content.

In one embodiment, the method further includes: highlighting the code content.

A second aspect of the embodiments of the present application provides a code analysis device, including:

The acquisition unit is used to acquire the syntax tree of the source code to be analyzed, and the analysis rules corresponding to the target defect type;

An analysis unit, configured to analyze the syntax tree by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed.

In one embodiment, the device further includes: a request obtaining unit, configured to obtain a code analysis request, where the code analysis request includes identification information of the target defect type and identification information of the source code to be analyzed; corresponding ,

The obtaining unit is configured to obtain the syntax tree of the source code to be analyzed through the identification information of the source code to be analyzed; and obtain the analysis rule through the identification information of the target defect type.

In one embodiment, the apparatus further includes: a task construction unit, configured to respectively construct corresponding code analysis tasks for source codes of different applications in the code base and/or source codes of different versions of the same application; and,

The request acquisition unit specifically includes: a request acquisition subunit, configured to acquire the code analysis request when the code analysis task is triggered.

In an embodiment, the obtaining unit specifically includes: a first obtaining subunit, configured to obtain the syntax tree from a syntax tree database.

In one embodiment, the obtaining unit specifically includes: a second obtaining subunit, configured to perform lexical analysis on the source code to be analyzed according to the grammar rules of the programming language of the source code to be analyzed; The results are parsed to generate the syntax tree.

In one embodiment, the obtaining unit specifically includes: a third obtaining subunit, configured to obtain the analysis rule corresponding to the target defect type by using the preset correspondence between the defect type and the analysis rule.

In one embodiment, the analysis unit specifically includes: an analysis subunit, configured to perform type analysis, constant analysis, syntax tree analysis, control flow analysis, data flow analysis and/or analysis on the syntax tree by using the analysis rule. Stain analysis to determine the code content of the target defect type in the source code to be analyzed.

In one embodiment, the apparatus further includes: a display unit, configured to highlight the code content.

A third aspect of the embodiments of the present application provides an electronic device, including:

memory for storing computer programs;

The processor is configured to execute the method described in any one of the method embodiments of this application.

A fourth aspect of the embodiments of the present application provides a storage medium, including: a program, when running on an electronic device, enables the electronic device to execute the method described in any one of the method embodiments of the present application.

The code analysis method provided by the embodiment of the present application includes acquiring the syntax tree of the source code to be analyzed, and the analysis rule corresponding to the target defect type, and then analyzing the syntax tree by using the analysis rule to determine the source code to be analyzed. The code content of the target defect type in . Therefore, defects in the source code in the code base can be determined by this method.

Description of drawings

In order to explain the technical solutions of the embodiments of the present application more clearly, the following briefly introduces the accompanying drawings that need to be used in the embodiments of the present application. It should be understood that the following drawings only show some embodiments of the present application, therefore It should not be regarded as a limitation of the scope. For those of ordinary skill in the art, other related drawings can also be obtained from these drawings without any creative effort.

FIG. 1 is a schematic structural diagram of an electronic device provided by an embodiment of the present application;

2 is a schematic flowchart of a code analysis method provided by an embodiment of the present application;

3 is a schematic flowchart of a code analysis method in a specific application scenario, provided by an embodiment of the present application;

FIG. 4 is a schematic diagram of a specific structure of a code analysis apparatus provided by an embodiment of the present application.

Detailed ways

The technical solutions in the embodiments of the present application will be described below with reference to the accompanying drawings in the embodiments of the present application. In the description of the present application, terms such as "first", "second", "third" and the like are only used to distinguish the description, and should not be construed as indicating or implying relative importance or sequence.

As mentioned earlier, defects in source code can be identified by static analysis of the source code in the code base.

For example, the source code of many different applications can be stored in the code base, and these applications may be continuously updated, so even for the same application, its source code may have multiple different versions. How to perform static analysis on the source code of these different applications, or even the source code of different versions of the same application, to determine its defects is very important.

As shown in FIG. 1 , this embodiment provides an electronic device 1, including: at least one processor 11 and a memory 12. In FIG. 1, one processor is used as an example. The processor 11 and the memory 12 can be connected through the bus 10, and the memory 12 stores instructions that can be executed by the processor 11, and the instructions are executed by the processor 11, so that the electronic device 1 can execute all or part of the methods in the following embodiments process.

The electronic device 1 may be a mobile phone, a notebook computer, a desktop computer, or a large server or server cluster composed thereof.

In one embodiment, when the source code stored in the code base needs to be statically analyzed (ProgramStatic Analysis), for example, without running the source code, through syntax tree analysis, control flow analysis, data flow analysis, etc. The technology scans the source code to verify whether the source code satisfies the specifications, security, reliability, maintainability and other indicators. At this time, all or part of the methods in the following embodiments can be executed by the electronic device 1 Process to achieve static analysis of the source code.

FIG. 2 is a schematic flowchart of a code analysis method according to an embodiment of the present application. Some or all of the steps of the method may be performed by the electronic device 1 shown in FIG. 1 , which can be used as an example here to describe the method. The method includes the following steps:

Step S21: Obtain the syntax tree of the source code to be analyzed.

The source code to be analyzed can be the source code of any application in the code base, or the source code of any version of any application in the code base, for example, the source code of any version of an application is randomly obtained from the code base The source code is the source code to be analyzed; of course, in practical applications, the source code to be analyzed may also be the source code of a specified version of an application selected from the code base according to analysis needs.

The syntax tree (abstract syntax code, AST) is a tree-like representation of the abstract syntax structure of the source code to be analyzed. The syntax tree represents the syntax structure of the programming language of the source code to be analyzed in the form of a tree, wherein each node on the syntax tree represents a structure in the source code to be analyzed, and the syntax tree does not depend on the source code to be analyzed. The syntax of the programming language that analyzes the source code.

There are many specific ways to obtain the syntax tree of the source code to be analyzed in practical applications. Here are several examples for description:

Method 1: Generate the syntax tree of the source code to be analyzed.

In the first manner, the source code to be analyzed may be obtained first, and then a syntax tree may be generated by using the source code to be analyzed. Wherein, the process of generating a syntax tree by using the source code to be analyzed may include: first, according to the grammar rules of the programming language of the source code to be analyzed, performing lexical analysis on the source code to be analyzed, and then performing syntax analysis on the result of the lexical analysis to generate the syntax tree.

For example, according to the grammar rules of the programming language of the source code to be analyzed, lexical analysis is performed on the source code to be analyzed, so as to realize the word segmentation of the source code to be analyzed. In this process, the finite character sequence in the source code to be analyzed can be obtained in sequence, and combined with the grammar rules of the corresponding programming language, it can be identified whether the finite character sequence is a word with lexical meaning, if so, it is regarded as a word segmentation, otherwise, continue Get other characters. For example, if the programming language of the source code to be analyzed is the C language, it can be combined with the grammar rules of the C language, including the operators, control characters and legal identifiers of the C language, to identify whether the obtained limited character sequence has lexical meaning. word, and then determine whether it is a participle.

After the lexical analysis of the source code to be analyzed, the obtained lexical analysis results are multiple word segmentations, and then grammatical analysis is performed to determine whether there is a grammatical error, if so, an error message is output, otherwise, the lexical analysis result is converted into a tree shape form to generate a syntax tree.

Method 2: Obtain the syntax tree from the syntax tree database.

The syntax tree database is used to store the syntax trees of each source code, so the syntax tree of the source code to be analyzed can be obtained from the syntax tree database.

For example, the identification information of the source code to be analyzed can be used to query the syntax tree database, so as to obtain the syntax tree of the source code to be analyzed. The identification information of the source code to be analyzed may be the name and version number of the application corresponding to the source code to be analyzed, or other characters or strings that can be used to uniquely identify the source code to be analyzed.

In addition, the syntax tree stored in the syntax tree database can be generated through the first method, and after the syntax tree is generated, it can be stored in the syntax tree database.

In practical applications, the syntax tree of the source code to be analyzed can also be obtained in other ways. For example, the above-mentioned method 1 and method 2 can also be combined to obtain the syntax tree of the source code to be analyzed. For example, first query the syntax tree database through the identification information of the source code to be analyzed, if the syntax tree of the source code to be analyzed is stored in the syntax tree database, then use method 2 to obtain the syntax tree from the syntax tree database; The syntax tree of the source code to be analyzed is not stored in the syntax tree database, and the syntax tree of the source code to be analyzed is generated using the first method.

Of course, after the syntax tree of the source code to be analyzed is generated, the syntax tree may also be stored in a syntax tree database for subsequent acquisition.

Step S22: Obtain an analysis rule corresponding to the target defect type.

In practical applications, when static analysis is performed on the source code, it may usually include analyzing whether the source code has a specified vulnerability, whether it does not conform to the program specification, and the like. Therefore, the target defect type may specifically be any one or more of the following defect types: there is a certain specified vulnerability, non-compliance with program specifications, and the like.

In addition, according to the work standard process, a corresponding analysis rule can be set for each of the above defect types in advance, and a preset corresponding relationship between the defect type and the analysis rule can be established, wherein whether there is a corresponding defect in the source code can be determined according to the analysis rule. type of defect. In this way, when the analysis rule corresponding to the target defect type is obtained, the analysis rule corresponding to the target defect type can be obtained by using the preset correspondence between the defect type and the analysis rule.

For example, the identification information of the target defect type can be obtained first, and the identification information can be the serial number of the target defect type, or other characters or strings that can uniquely identify the target defect type; Set the corresponding relationship and the identification information of the target defect type, so as to obtain the analysis rule corresponding to the target defect type.

Usually, the analysis rules corresponding to various defect types can be stored in the rule database. After obtaining the identification information of the target defect type, the preset corresponding relationship between the defect type and the analysis rule, and the identification information of the target defect type can be used to obtain information from the target defect type. The analysis rules corresponding to the target defect types are obtained from the rule database.

In practical applications, other methods can also be used to obtain the analysis rules corresponding to the target defect type, for example, when the rule database does not store the analysis rules corresponding to the target defect type (for example, the target defect type is a new defect Type), at this time, the target defect type can be analyzed first, so as to determine multiple characteristic information of the target defect type, and then use these characteristic information to construct an analysis process, including the analysis steps to be performed and the steps performed by each analysis step. and then use the analysis process to generate analysis rules, so that the analysis rules can be used to determine whether there is a defect of the target trap type in the source code. In addition, after the analysis rule is generated, corresponding identification information may also be assigned to the analysis rule and stored in the rule database.

Step S23: Analyze the acquired syntax tree by using the acquired analysis rule to determine the code content of the target defect type in the source code to be analyzed.

After the syntax tree and the analysis rule are obtained in the above steps S21 and S22 respectively, the syntax tree can be analyzed by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed. Wherein, using the analysis rule to analyze the syntax tree to determine the code content of the target defect type in the source code to be analyzed may include: using the analysis rule to perform type analysis, constant Analysis, syntax tree analysis, control flow analysis, data flow analysis, and/or taint analysis, etc., to determine the code content of the target defect type in the source code to be analyzed.

For example, the analysis rule can be used to perform data flow analysis on the syntax tree. Among others, data flow analysis can be a set of techniques used to obtain relevant information about how data flows along a program execution path (control-flow graph). In all data flow analysis applications, we associate each program point with a data-flow value. This value is an abstract representation of the set of all program states that may be observed at that point. The set of all possible data flow values is called the domain of this data flow application.

Therefore, when using this analysis rule to analyze the data flow of the syntax tree, the data flow values before and after the statement s corresponding to each node in the syntax tree can be recorded as IN[s] and OUT[s] respectively. (data-flowproblem) is to solve a set of constraints. This set of constraints defines the relationship between IN[s] and OUT[s] for all statements s. There are two types of constraints: constraints based on statement semantics (transfer function) and constraints based on control flow.

For example, the analysis rule can also be used to perform taint analysis on the syntax tree. Among them, taint analysis is a specific application of data flow analysis, which can analyze whether there is a taint data propagation defect in the code content of the source code to be analyzed. The taint analysis usually uses the following three analysis rules:

1. source, that is, the pollution source function; the data generated by the source function is the starting point of pollution propagation, and all source-dependent data in the program execution path are marked as tainted data.

2. Sink, that is, a dangerous function; 'If tainted data enters the sink function, it means there is a potential security vulnerability. Vulnerabilities can be detected by performing pollution transfer analysis between externally open interface functions and internal sensitive functions.

3. Transformer, that is, the pollution propagation function; the tainted data is passed from one variable to another through the propagation function. The taint propagation function transformer determines how taint information flows in the program.

Taint analysis can detect security vulnerabilities by marking external input points by source, and analyzing whether the data can reach dangerous functions (sink functions such as SQL query, command execution, etc.) according to the data flow of the program. If in the information flow, the source of the variable x cannot be trusted, it can usually be considered that x is tainted. The tainted variable x is called tainted data. The source of pollution is the untrusted input of the program, which can be files, network data, keyboard and mouse input, API return values from unknown sources, etc. A variable is tainted if the computation of its value depends on a source of taint. Similarly, the taint propagation process can be passed through variables. Assuming that variable x is the source of pollution, and the information flow flows from variable x to variable y, and then from variable y to variable z, both variable y and variable z are polluted by variable x.

The code analysis method provided by the embodiment of the present application includes acquiring the syntax tree of the source code to be analyzed, and the analysis rule corresponding to the target defect type, and then analyzing the syntax tree by using the analysis rule to determine the source code to be analyzed. The code content of the target defect type in . Therefore, defects in the source code in the code base can be determined by this method.

It should be further noted that, in the above code analysis method, there is no need to limit the execution order. For example, step S21 may be executed first, and then step S22 and step S23 may be executed respectively, or step S22 may be executed first, and then step S22 may be executed separately. Steps S21 and S23 are executed, or steps S21 and S22 are executed simultaneously, and then step S23 is executed, or other execution sequences are also possible.

In addition, after performing the above step S23 to determine the code content of the target defect type in the source code to be analyzed, the method may further include: highlighting the code content. For example, if the target defect type is a specified vulnerability, the code content with the specified vulnerability in the source code to be analyzed can be highlighted, so as to facilitate subsequent modification of the code content to patch the specified vulnerability . Wherein, as for the specific manner of highlighting, the code content may be marked with a highlighted color, the text line should be thickened, and the text line should be underlined. Of course, after the code content of the target defect type in the source code to be analyzed is determined, a prompt message may also be sent to prompt relevant personnel to modify the code content.

In practical applications, other methods can usually be used to perform static analysis on the source code in the code base. For example, the source code to be analyzed can be obtained from the code base first, and then the source code to be analyzed can be analyzed in a compilation and construction environment corresponding to the source code to be analyzed, wherein the compilation and construction environment includes a code editor, Debugger, debugger, graphical user interface, etc. However, in this analysis method, the compilation and construction environment corresponding to the source code to be analyzed is relied on, while the compilation and construction environments on which the source codes of different applications depend are usually different, and even the source codes of different versions of the same application program depend on the compilation and construction environments. The dependent compilation and build environments may also be different, so that when static analysis is performed on the source code of different applications in the code base and/or the source code of different versions of the same application, multiple different compilation and build environments may need to be generated to support The static analysis. Generating a compilation and build environment is usually time-consuming and labor-intensive, resulting in the time-consuming and labor-intensive static analysis.

With the code analysis method provided by the embodiment of the present application, when analyzing the source code to be analyzed, the syntax tree of the source code to be analyzed is analyzed through the analysis rules, instead of relying on the compilation and construction environment to perform static analysis on the source code to be analyzed itself. Therefore, The code analysis method provided by the embodiment of the present application does not need to generate a corresponding compilation and construction environment, which reduces the cost of static analysis.

In practical applications, before the above step S21, the method may further include obtaining a code analysis request, wherein the code analysis request includes identification information of the target defect type and identification information of the source code to be analyzed, and then passes the source code to be analyzed through the source code to be analyzed. The identification information of the code is used to obtain the syntax tree of the source code to be analyzed. For example, the syntax tree database is queried through the identification information. If the syntax tree of the source code to be analyzed is stored in the syntax tree database, it is obtained from the syntax tree database. The syntax tree, or if the syntax tree of the source code to be analyzed is not stored in the syntax tree database, the source code to be analyzed is obtained first, and then the syntax tree is generated from the source code to be analyzed. Of course, the analysis rule corresponding to the target defect type can also be obtained through the identification information of the target defect type in the code analysis request.

The code analysis request may be a code analysis request generated when a code analysis task is triggered. For example, the source codes stored in the code base include the source codes of different applications, and/or the source codes of different versions of the same application. In order to perform static analysis on the source codes in the code base, different applications in the code base can be The source code of the program and/or the source code of different versions of the same application, respectively build the corresponding code analysis task; in this way, when the code analysis task is triggered, the corresponding code analysis request can be generated, so the code can be obtained. Analyze the request. For example, these code analysis tasks can be performed in the order of execution time or generation time to generate a task list, and execute them in sequence according to the order in the task list.

The electronic device shown in FIG. 1 (referred to as the first electronic device) can be connected to other electronic devices (referred to as the second electronic device), at this time, these code analysis tasks can be set in the second electronic device, and when When a code analysis task in the second electronic device is triggered, a code analysis request is generated, and the code analysis request is sent to the first electronic device, so the first electronic device can obtain the code analysis request. For example, the second electronic device may be a user's mobile phone, a notebook computer, etc., and the first electronic device may be a server or the like.

The above is a specific description of the code analysis provided by the embodiments of the present application. For ease of understanding, the embodiments of the present application may further describe the method in combination with specific application scenarios. In this application scenario, the source code of multiple versions of application A is stored in the code base, namely A1, A2, A3~An, and the source code A1~An needs to be statically analyzed to determine whether there is a specified vulnerability. . The syntax trees corresponding to the source codes A1 to An are stored in the syntax tree database.

At this time, corresponding code analysis tasks can be respectively constructed for the source codes A1 to An in the code base, wherein each code analysis task includes the identification information of the corresponding source code and the identification information of the specified vulnerability; then, these code analysis tasks are According to the order of execution time, a task list is generated, so as to be executed in sequence according to the order in the task list; at the same time, an analysis and scheduling module and a defect analysis module can be set in the electronic device, and the analysis and scheduling module can monitor whether there is any need to be executed in the task list. If the code analysis task exists, the corresponding code analysis task will be obtained in the order of the task list; if it does not exist, the operation may not be performed, or the monitoring will be performed again after a period of time (for example, 5 minutes or other time). The method in this scenario can be described with reference to Figure 3:

Step S31: The analysis and scheduling module monitors whether there is a code analysis task that needs to be executed in the task list, and if so, executes Step S32.

Step S32: Acquire the code analysis task.

Step S33: Using the identification information of the source code in the code analysis task, query the syntax tree database, and obtain the corresponding syntax tree.

Certainly, if the corresponding syntax tree is not stored in the syntax tree database, the corresponding source code can be further obtained by using the identification information, and then the syntax tree can be generated by using the source code.

Step S34: Using the identification information of the specified vulnerability in the code analysis task and the preset correspondence between the defect type and the analysis rule, obtain the analysis rule corresponding to the specified vulnerability from the rule database.

Step S35: The analysis scheduling module sends the analysis rule and the syntax tree to the defect analysis module.

Step S36: The defect analysis module analyzes the syntax tree by using the analysis rule, and outputs an analysis result, where the analysis result includes the code content of the specified vulnerability in the source code to be analyzed.

After completing the code analysis task, the process may return to step S31, and the analysis and scheduling module continues to execute cyclically until the task list is empty.

Based on the same inventive concept as the code analysis method provided by the embodiment of the present application, the embodiment of the present application also provides a code analysis device. For the device embodiment, if there is any unclear point, you can refer to the corresponding method embodiment. code content. 4 is a schematic diagram of the specific structure of the device 40, the device 40 includes: an acquisition unit 401 and an analysis unit 402, wherein:

Obtaining unit 401, for obtaining the syntax tree of the source code to be analyzed, and the analysis rule corresponding to the target defect type;

The analyzing unit 402 is configured to analyze the syntax tree by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed.

With the device 40 provided by the embodiment of the present application, since the device 40 adopts the same inventive concept as the code analysis method provided by the embodiment of the present application, on the premise that the code analysis method can solve the technical problem, the device 40 can also Solve technical problems, which will not be repeated here.

In addition, in practical applications, the technical effects obtained by combining the device 40 with specific hardware equipment, cloud technology, etc. are also within the scope of protection of the present application. The different units are arranged in different nodes in the distributed cluster, so as to improve the efficiency, etc.

In practical applications, before the obtaining unit 401, the apparatus 40 may further include a request obtaining unit for obtaining a code analysis request, where the code analysis request includes the target defect type and the identification information of the source code to be analyzed; corresponding,

The obtaining unit 401 is configured to obtain the syntax tree of the source code to be analyzed through the identification information of the source code to be analyzed; and obtain the analysis rule through the target defect type.

The apparatus 40 may further include: a task construction unit, configured to respectively construct corresponding code analysis tasks for the source codes of different application programs in the code base and/or the source codes of different versions of the same application program; at this time, the request obtains The unit may specifically include a request obtaining subunit, configured to obtain the code analysis request when the code analysis task is triggered.

In practical applications, the obtaining unit 401 may include a first obtaining sub-unit for obtaining the syntax tree from the syntax tree database.

The obtaining unit 401 may further include a second obtaining sub-unit for generating the syntax tree of the source code to be analyzed. Lexical analysis, and then syntactically analyze the results of the lexical analysis to generate the syntax tree.

The obtaining unit 401 may further include a third obtaining sub-unit, configured to obtain the analysis rule corresponding to the target defect type by using the preset correspondence between the defect type and the analysis rule.

The analysis unit 402 may further include an analysis sub-unit for performing type analysis, constant analysis, syntax tree analysis, control flow analysis, data flow analysis and/or taint analysis on the syntax tree by using the analysis rules to determine the Describe the code content of the target defect type in the source code to be analyzed.

After the analyzing unit 402, the apparatus 40 may further include a display unit, configured to highlight the code content of the target defect type in the determined source code to be analyzed.

Embodiments of the present invention also provide a storage medium, including: a program, when running on an electronic device, enables the electronic device to execute all or part of the processes of the methods in the foregoing embodiments. Wherein, the storage medium may be a magnetic disk, an optical disk, a read-only memory (Read-Only Memory, ROM), a random access memory (Random Access Memory, RAM), a flash memory (Flash Memory), a hard disk (Hard Disk Drive, Abbreviation: HDD) or solid-state drive (Solid-State Drive, SSD), etc. The storage medium may also include a combination of the aforementioned kinds of memories.

Although the embodiments of the present invention have been described in conjunction with the accompanying drawings, various modifications and variations can be made by those skilled in the art without departing from the spirit and scope of the present invention, such modifications and variations falling within the scope of the appended claims within the limited range.

Claims (11)

1. A method of code analysis, the method comprising:

acquiring a syntax tree of a source code to be analyzed and an analysis rule corresponding to a target defect type;

and analyzing the syntax tree by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed.

2. The method of claim 1, further comprising:

acquiring a code analysis request, wherein the code analysis request comprises identification information of the target defect type and identification information of the source code to be analyzed; accordingly, the method can be used for solving the problems that,

obtaining a syntax tree of a source code to be analyzed and an analysis rule corresponding to a target defect type, specifically comprising:

acquiring a syntax tree of the source code to be analyzed according to the identification information of the source code to be analyzed; and acquiring the analysis rule through the identification information of the target defect type.

3. The method of claim 2, further comprising:

respectively constructing corresponding code analysis tasks aiming at source codes of different application programs in a code library and/or source codes of different versions of the same application program; and (c) a second step of,

acquiring a code analysis request, specifically comprising:

and acquiring the code analysis request under the condition that the code analysis task is triggered.

4. The method of claim 1, wherein obtaining the syntax tree of the source code to be analyzed specifically comprises: and acquiring the syntax tree from a syntax tree database.

5. The method of claim 1, wherein obtaining the syntax tree of the source code to be analyzed specifically comprises:

according to the grammatical rule of the programming language of the source code to be analyzed, performing lexical analysis on the source code to be analyzed;

and carrying out syntactic analysis on the result of the lexical analysis to generate the syntactic tree.

6. The method of claim 1, wherein the analysis rule corresponding to the target defect type is obtained by:

and acquiring the analysis rule corresponding to the target defect type by utilizing the preset corresponding relation between the defect type and the analysis rule.

7. The method according to claim 1, wherein analyzing the syntax tree using the analysis rule to determine the code content of the target defect type in the source code to be analyzed comprises:

and performing type analysis, constant analysis, syntax tree analysis, control flow analysis, data flow analysis and/or taint analysis on the syntax tree by using the analysis rule to determine the code content of the target defect type in the source code to be analyzed.

8. The method of claim 1, further comprising: highlighting the code content.

9. A code analysis apparatus, comprising:

the system comprises an acquisition unit, a processing unit and a processing unit, wherein the acquisition unit is used for acquiring a syntax tree of a source code to be analyzed and an analysis rule corresponding to a target defect type;

and the analysis unit is used for analyzing the syntax tree by using the analysis rule so as to determine the code content of the target defect type in the source code to be analyzed.

10. An electronic device, comprising:

a memory to store a computer program;

a processor to perform the method of any one of claims 1 to 8.

11. A storage medium, comprising: program which, when run on an electronic device, causes the electronic device to perform the method of any one of claims 1 to 8.

Images