CN114115884B - Method and related device for managing programming service - Google Patents
Method and related device for managing programming service Download PDFInfo
- Publication number
- CN114115884B CN114115884B CN202010871294.0A CN202010871294A CN114115884B CN 114115884 B CN114115884 B CN 114115884B CN 202010871294 A CN202010871294 A CN 202010871294A CN 114115884 B CN114115884 B CN 114115884B
- Authority
- CN
- China
- Prior art keywords
- function
- target
- test
- task
- programming
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 151
- 238000012360 testing method Methods 0.000 claims abstract description 92
- 230000008569 process Effects 0.000 claims abstract description 69
- 230000003993 interaction Effects 0.000 claims abstract description 28
- 230000006870 function Effects 0.000 claims description 274
- 238000002347 injection Methods 0.000 claims description 61
- 239000007924 injection Substances 0.000 claims description 61
- 230000002159 abnormal effect Effects 0.000 claims description 35
- 238000012545 processing Methods 0.000 claims description 32
- 230000004044 response Effects 0.000 claims description 19
- 238000006243 chemical reaction Methods 0.000 claims description 13
- 230000003068 static effect Effects 0.000 claims description 8
- 238000004458 analytical method Methods 0.000 claims description 5
- 238000004590 computer program Methods 0.000 claims description 4
- 238000007726 management method Methods 0.000 abstract description 62
- 206010000117 Abnormal behaviour Diseases 0.000 description 12
- 238000010586 diagram Methods 0.000 description 9
- 239000000243 solution Substances 0.000 description 7
- 238000003780 insertion Methods 0.000 description 6
- 230000037431 insertion Effects 0.000 description 6
- 238000004891 communication Methods 0.000 description 5
- 238000004364 calculation method Methods 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000003111 delayed effect Effects 0.000 description 2
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012549 training Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/447—Target code generation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Library & Information Science (AREA)
- Debugging And Monitoring (AREA)
Abstract
The application discloses a programming service management method and a related device. Acquiring a corresponding source code in the execution process of the programming service; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a method and an apparatus for managing programming services.
Background
Cloud computing (clouding) is a computing model that distributes computing tasks across a large pool of computers, enabling various application systems to acquire computing power, storage space, and information services as needed. The network that provides the resources is referred to as the "cloud". Resources in the cloud are infinitely expandable in the sense of users, and can be acquired at any time, used as needed, expanded at any time and paid for use as needed.
While as cloud computing evolves, more and more projects are developed using the Go programming language. In performing an anomaly test at a function level, a tester needs to perform an anomaly operation such as falsifying a parameter of a function, throwing the function by mistake, or delaying execution of the function to verify the robustness of the service.
However, in the function modification process of the static programming language, function insertion cannot be realized during running, and compiling instruction insertion is not easy to be performed on compiled machine codes so as to realize function insertion, thereby influencing the efficiency of exception testing.
Disclosure of Invention
In view of this, the present application provides a method for managing programming services, which can effectively improve the efficiency of the anomaly test in the programming services.
The first aspect of the present application provides a method for managing a programming service, which can be applied to a system or a program including a management function of the programming service in a terminal device, and specifically includes:
acquiring a corresponding source code in the execution process of the programming service;
parsing the source code to convert the source code into a structured file;
injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file;
and performing interaction of target tasks based on the target executable file, wherein the interaction process of the target tasks is associated with the hook function.
Optionally, in some possible implementations of the present application, injecting a hook function into a function declaration corresponding to the structured document to obtain a target executable file includes:
determining the function declaration corresponding to the structured document;
Converting the structured document into an anonymous function based on the function declaration;
and injecting the hook function into the anonymous function through the function declaration to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting the hook function into the anonymous function through the function declaration to obtain the target executable file includes:
Determining the injection node corresponding to the function statement;
And injecting the hook function into the anonymous function through the injection node so as to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting, by the injection node, the hook function into the anonymous function to obtain the target executable file includes:
Injecting the hook function into the anonymous function through the injection node to obtain an intermediate code;
Converting the intermediate code into machine code;
Compiling based on the machine code to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting, by the injection node, the hook function into the anonymous function to obtain an intermediate code includes:
determining an enhancement code corresponding to the hook function;
injecting the enhancement codes into the anonymous function through the injection node to obtain conversion codes;
determining a node operator corresponding to the conversion code;
transcoding is performed based on the node operators to obtain the intermediate code.
Optionally, in some possible implementations of the present application, the interaction of the target task based on the target executable file includes:
Determining function call information output by the target executable file in the running process;
interacting with a cache database based on the function call information;
Determining the target task in response to a task instruction in the cache database;
And configuring the function call information based on the target task to test the programming service.
Optionally, in some possible implementations of the present application, the determining the target task in response to a task instruction in the cache database includes:
determining a function tag in response to the task instruction in the cache database;
a task function is determined based on the function tag to generate the target task.
Optionally, in some possible implementations of the present application, the configuring the function call information based on the target task to test the programming service includes:
determining configuration information based on the task function corresponding to the target task, wherein the configuration information comprises calling party information and called party information;
And configuring the function call information according to the configuration information so as to test the programming service.
Optionally, in some possible implementations of the present application, the configuring the function call information based on the target task to test the programming service includes:
configuring the function call information based on the target task to determine a test function;
determining corresponding method parameters in the test function;
An execution rule is determined based on the method parameters to test the programming service.
Optionally, in some possible implementations of the present application, the method further includes:
determining test parameters in response to the test instruction, wherein the test parameters comprise the type, the occurrence time or the occurrence probability of the test case;
Updating the method parameters based on the test parameters.
Optionally, in some possible implementations of the present application, the target task is an anomaly test task, and the method further includes:
determining an abnormal processing capacity value of the programming service based on the test information of the abnormal test task;
and determining the processing authority of the programming service according to the comparison relation between the abnormal processing capability value and the preset value, wherein the processing authority is used for indicating the payment operation in the financial scene.
Optionally, in some possible implementations of the present application, the programming service is edited based on a static programming language, the structured file is set based on an abstract syntax tree, and the target task is an abnormal test task.
A second aspect of the present application provides a management apparatus of a programming service, including: the acquisition unit is used for acquiring the corresponding source codes in the execution process of the programming service;
The analysis unit is used for analyzing the source code so as to convert the source code into a structured file;
the injection unit is used for injecting a hook function into the function statement corresponding to the structured file to obtain a target executable file;
And the management unit is used for carrying out interaction of the target task based on the target executable file, and the interaction process of the target task is associated with the hook function.
Optionally, in some possible implementations of the present application, the injecting unit is specifically configured to determine the function declaration corresponding to the structured document;
the injection unit is specifically configured to convert the structured document into an anonymous function based on the function declaration;
The injection unit is specifically configured to inject the hook function into the anonymous function through the function declaration, so as to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injection unit is specifically configured to determine an injection node corresponding to the function declaration;
The injection unit is specifically configured to inject the hook function into the anonymous function through the injection node, so as to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting unit is specifically configured to inject, by the injecting node, the hook function into the anonymous function, so as to obtain an intermediate code;
The injection unit is specifically configured to convert the intermediate code into a machine code;
The injection unit is specifically configured to compile based on the machine code to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injection unit is specifically configured to determine an enhancement code corresponding to the hook function;
the injection unit is specifically configured to inject the enhancement code into the anonymity function through the injection node, so as to obtain a conversion code;
the injection unit is specifically configured to determine a node operator corresponding to the conversion code;
the injection unit is specifically configured to perform transcoding based on the node operator, so as to obtain the intermediate code.
Optionally, in some possible implementations of the present application, the management unit is specifically configured to determine function call information output by the target executable file in a running process;
The management unit is specifically used for interacting with the cache database based on the function call information;
The management unit is specifically configured to determine the target task in response to a task instruction in the cache database;
the management unit is specifically configured to configure the function call information based on the target task so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit is specifically configured to determine a function tag in response to the task instruction in the cache database;
The management unit is specifically configured to determine a task function based on the function label, so as to generate the target task.
Optionally, in some possible implementations of the present application, the management unit is specifically configured to determine configuration information based on the task function corresponding to the target task, where the configuration information includes caller information and callee information;
the management unit is specifically configured to configure the function call information according to the configuration information so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit is specifically configured to configure the function call information based on the target task to determine a test function;
The management unit is specifically configured to determine a corresponding method parameter in the test function;
The management unit is specifically configured to determine an execution rule based on the method parameter, so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit is specifically configured to determine a test parameter in response to a test instruction, where the test parameter includes a type, an occurrence opportunity, or an occurrence probability of a test case;
the management unit is specifically configured to update the method parameter based on the test parameter.
Optionally, in some possible implementations of the present application, the target task is an abnormal test task, and the management unit is specifically configured to determine an abnormal processing capability value of the programming service based on test information of the abnormal test task;
the management unit is specifically configured to determine a processing right of the programming service according to a comparison relationship between the abnormal processing capability value and a preset value, where the processing right is used to indicate a payment operation in a financial scenario.
A third aspect of the present application provides a computer apparatus comprising: a memory, a processor, and a bus system; the memory is used for storing program codes; the processor is configured to execute the method for managing a programming service according to the first aspect or any one of the first aspects according to instructions in the program code.
A fourth aspect of the present application provides a computer readable storage medium having instructions stored therein which, when run on a computer, cause the computer to perform the method of managing programming services of the first aspect or any of the first aspects described above.
According to one aspect of the present application, there is provided a computer program product or computer program comprising computer instructions stored in a computer readable storage medium. The computer instructions are read from a computer-readable storage medium by a processor of a computer device, the computer instructions being executed by the processor to cause the computer device to perform the method of managing programming services provided in the above-described first aspect or various alternative implementations of the first aspect.
From the above technical solutions, the embodiment of the present application has the following advantages:
Acquiring a corresponding source code in the execution process of the programming service; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings that are required to be used in the embodiments or the description of the prior art will be briefly described below, and it is obvious that the drawings in the following description are only embodiments of the present application, and that other drawings can be obtained according to the provided drawings without inventive effort for a person skilled in the art.
FIG. 1 is a network architecture diagram of the operation of a management system for programming services;
FIG. 2 is a flowchart illustrating the management of a programming service according to an embodiment of the present application;
FIG. 3 is a flowchart of a method for managing programming services according to an embodiment of the present application;
FIG. 4 is a flowchart illustrating a method for managing a programming service according to an embodiment of the present application;
FIG. 5 is a schematic view of a method for managing a programming service according to an embodiment of the present application;
FIG. 6 is a flowchart illustrating another method for managing programming services according to an embodiment of the present application;
FIG. 7 is a schematic diagram of another embodiment of a method for managing programming services;
FIG. 8 is a flowchart illustrating another method for managing programming services according to an embodiment of the present application;
FIG. 9 is a flowchart illustrating another method for managing programming services according to an embodiment of the present application;
Fig. 10 is a schematic structural diagram of a management device for programming services according to an embodiment of the present application;
fig. 11 is a schematic structural diagram of a server according to an embodiment of the present application.
Detailed Description
The embodiment of the application provides a programming service management method and a related device, which can be applied to a system or a program containing a programming service management function in terminal equipment, and the corresponding source codes in the execution process of the programming service are obtained; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
The terms "first," "second," "third," "fourth" and the like in the description and in the claims and in the above drawings, if any, are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the application described herein may be implemented, for example, in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "includes" and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed or inherent to such process, method, article, or apparatus.
First, some terms that may appear in the embodiments of the present application will be explained.
Go programming language: also called Golang, is a statically strong typed, compiled language. The Go language grammar is similar to the C language, but has the characteristics of safe memory, garbage collection, structural morphology and concurrent calculation.
Function declaration: for informing the compiling system of the name, function type, shape parameter type, number and sequence of the function, so that the system checks against this rule when the function is called; for example, whether the function name is correct, and whether the types and numbers of real parameters and shape parameters are consistent.
Abstract syntax tree (Abstract Syntax Tree, AST): the syntax structure of the programming language is expressed in the form of a tree.
Hook function (hook): before the system calls the original function, the hook function can obtain control right, process or change the behavior of the original function, and can force the transmission of the message to be ended.
It should be understood that the method for managing a programming service provided by the present application may be applied to a system or a program including a management function of the programming service in a terminal device, for example, programming software, specifically, the management system of the programming service may be operated in a network architecture shown in fig. 1, as shown in fig. 1, which is a network architecture diagram operated by the management system of the programming service, as shown in fig. 1, the management system of the programming service may provide a management process of the programming service with a plurality of information sources, that is, each terminal may execute a respective corresponding programming service process, and when an exception handling capability test is required, send an executable file encapsulated with a hook to a server to perform a test, thereby determining an exception handling capability; it will be appreciated that in fig. 1, various terminal devices are shown, and in an actual scenario, there may be more or less terminal devices involved in the process of managing the programming service, and the specific number and types are not limited herein, depending on the actual scenario, and in fig. 1, one server is shown, but in an actual scenario, there may also be multiple servers involved, and in particular, in a scenario of multi-model training interaction, the specific number of servers is dependent on the actual scenario.
In this embodiment, the server may be an independent physical server, or may be a server cluster or a distributed system formed by a plurality of physical servers, or may be a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDNs, and basic cloud computing services such as big data and artificial intelligence platforms. The terminal may be, but is not limited to, a smart phone, a tablet computer, a notebook computer, a desktop computer, a smart speaker, a smart watch, etc. The terminal and the server may be directly or indirectly connected through wired or wireless communication, and the present application is not limited herein.
It will be appreciated that the management system of programming services described above may be run on a personal mobile terminal, for example: the application as programming software can also be operated on a server, and can also be operated on third-party equipment to provide management of programming service so as to obtain the management processing result of the programming service of the information source; the specific programming service management system may be implemented in a program form in the device, may also be implemented as a system component in the device, or may be implemented as a cloud service program, where a specific operation mode is determined according to an actual scenario, and is not limited herein.
Cloud computing (clouding) is a computing model that distributes computing tasks across a large pool of computers, enabling various application systems to acquire computing power, storage space, and information services as needed. The network that provides the resources is referred to as the "cloud". Resources in the cloud are infinitely expandable in the sense of users, and can be acquired at any time, used as needed, expanded at any time and paid for use as needed.
As a basic capability provider of cloud computing, a cloud computing resource pool (abbreviated as a cloud platform, generally referred to as IaaS (Infrastructure AS A SERVICE) platform) is established, in which multiple types of virtual resources are deployed for external clients to select for use.
According to the logic function division, a PaaS (Platform AS A SERVICE, platform service) layer can be deployed on an IaaS (Infrastructure AS A SERVICE, infrastructure service) layer, and a SaaS (Software AS A SERVICE, service) layer can be deployed above the PaaS layer, or the SaaS can be directly deployed on the IaaS. PaaS is a platform on which software runs, such as a database, web container, etc. SaaS is a wide variety of business software such as web portals, sms mass senders, etc. Generally, saaS and PaaS are upper layers relative to IaaS.
While as cloud computing evolves, more and more projects are developed using the Go programming language. In performing an anomaly test at a function level, a tester needs to perform an anomaly operation such as falsifying a parameter of a function, throwing the function by mistake, or delaying execution of the function to verify the robustness of the service.
However, in the function modification process of the static programming language, function insertion cannot be realized during running, and compiling instruction insertion is not easy to be performed on compiled machine codes so as to realize function insertion, thereby influencing the efficiency of exception testing.
In order to solve the above problems, the present application proposes a method for managing a programming service, which is applied to a flow framework for managing a programming service shown in fig. 2, as shown in fig. 2, and is a flow framework for managing a programming service provided by an embodiment of the present application, that is, a Go native tool AST library is used to implement full scan on Go service source codes and to structure source codes AST, then hook is injected into a function body under the AST structure, and interaction can be performed by using an external cache database, so as to achieve a process of implementing function test in an operation state by setting the external cache database.
It can be understood that the method provided by the application can be a program writing method, which is used as a processing logic in a hardware system, and can also be used as a management device of programming service, and the processing logic is realized in an integrated or external mode. As an implementation manner, the management device of the programming service obtains the corresponding source code in the execution process of the programming service; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
With reference to fig. 3, fig. 3 is a flowchart of a method for managing a programming service according to an embodiment of the present application, where the method may be executed by a terminal device, or may be executed by a server, or may be executed by the terminal device and the server together, and is described below by taking the terminal device as an example. The embodiment of the application at least comprises the following steps:
301. and acquiring the corresponding source code in the execution process of the programming service.
In this embodiment, the programming language corresponding to the programming service is a static programming language, for example, go language; this is because in performing an anomaly test at the function level, a tester needs to perform an anomaly operation such as falsifying a parameter of a function, causing the function to be thrown wrong, or delaying execution of the function to verify the robustness of the service. The Go language is a static programming language, different from the Java programming language, has no virtual machine, cannot realize function capability enhancement during running, and cannot easily realize function capability enhancement by compiling instruction enhancement on compiled machine codes. To achieve functional capability enhancement at runtime, go language native standard tools do not provide a corresponding tool to meet the requirements of anomaly testing.
It will be appreciated that the present application is also applicable to other static programming languages in the process of testing abnormal capability, and the specific language form is determined by the actual scenario, and the present application is illustrated by using the Go language as an example.
302. The source code is parsed to convert the source code into a structured file.
In this embodiment, the process of resolving the source code may be to perform full-scale scanning on the source code of the Go programming service, and convert the file included in each Go programming service into a structured file, for example, perform AST structuring, and other specific structural functions are also applicable to this embodiment, which is not limited herein.
In a possible scenario, an AST structuring process is shown in fig. 4, and fig. 4 is a flow chart of a method for managing a programming service according to an embodiment of the present application; the form of the source code is shown, along with a tree diagram after AST structured transformation.
303. And injecting a hook function into the function statement corresponding to the structured file to obtain the target executable file.
In this embodiment, the hook function (hook) is injected into the structured document to obtain function information corresponding to the running process of the programming service in the running process of the programming service, which may be specifically a full function or a specific part, which is not limited herein.
In particular, for the process of obtaining the target executable file, the source function body of all functions can be converted into an internal anonymous function as it is based on an AST structure, and the specific conversion involves the processing operation of function declaration. Firstly, determining a function statement corresponding to a structured document; then converting the structured document into an anonymous function based on the function declaration; and furthermore, a hook function is injected into the anonymous function through the function declaration, so that a target executable file is obtained, and the code logic is ensured not to be changed after the hook is injected into the source code.
It can be appreciated that, for the injection of the hook function, the injection can be performed based on the injection node, specifically, the injection node corresponding to the function statement is determined first; then, the hook function is injected into the anonymous function through the injection node, so that the target executable file is obtained. In one possible scenario, referring to fig. 5, fig. 5 is a flowchart of another method for managing programming services according to an embodiment of the present application; the figure shows a source code structure A1, a position A2 of a function declaration, an injection node A3 and a code part A4 after injecting a hook function, wherein the position A2 of the function declaration indicates a position corresponding to a feature field of the function declaration in the source code, namely (×ast. Funcdecl); the injection node A3 indicates an operation node specifically corresponding to the hook function, for example, the stmt method shown in the figure, that is, the stmt method is called for each node in the incoming source code, in this method, the compiler will convert the current AST into a corresponding intermediate code according to the difference of node operators, and the resolution degree of the source code can be improved and the resolution accuracy can be improved due to the generation of the intermediate code.
Specifically, for the use of the intermediate code, a hook function is injected into the anonymous function through an injection node to obtain the intermediate code; then converting the intermediate code into machine code; and compiling based on the machine code to obtain the target executable file.
Since the hook injection expands the functions of the source code, the expanded content can also be called enhancement code, so that the determination process of the intermediate code can also be that the enhancement code corresponding to the hook function is determined first; then, injecting an enhancement code into the anonymous function through an injection node to obtain a conversion code; further determining a node operator corresponding to the conversion code; therefore, the intermediate codes are obtained by transcoding based on the node operators, and because the intermediate codes are a representation form which is closer to a machine language, the optimization and analysis of the intermediate codes are easier than the direct analysis of a high-level programming language, so that the efficiency of the original code conversion is improved.
In one possible scenario, referring to fig. 6 for a process of generating the target executable file, fig. 6 is a schematic flow chart of another method for managing a programming service according to an embodiment of the present application; firstly, carrying out code analysis on the Go source code, and further carrying out structural conversion; based on the function statement in the structured file, converting the original function body into an anonymous function, and injecting a hook function to update the function body; in order to facilitate the recognition of the updated function body by the device, intermediate codes may be further generated and corresponding machine codes may be generated.
Correspondingly, the transcoding process can be obtained by compiling the Go programming service through a full function hook compiling tool; the Go build-ASTENHANCE XXX _project instruction is executed, for example, by a full function hook compilation tool that injects hook enhancement code on the basis of source code during the compilation process and compiles an executable file. Then implementing AST structure weave in function declaration position (AST. FuncDecl) by using Go standard tool AST library to implement full function hook method injection, the injection result is shown in FIG. 7, FIG. 7 is a scene schematic diagram of a management method of programming service provided by the embodiment of the application; the figure shows (1) in the injection result fig. 7 and (2) in the source code fig. 7, and it can be seen that the injection part B1 based on the hook contains the execution logic B3 of the source code in the injection result, and the execution logic B3 is identical to the code B2 in the source code, so that the code logic of the original function is ensured not to be changed because the original function is repeatedly mounted in the internal anonymous function in the full function hook method.
It will be appreciated that, since the AST structuring of the Go service source code is implemented based on the Go proto tool AST library, the function declaration of the source code is modified, rather than directly modifying the source code, ensuring that the source code is not modified by the hook method, but that the generated executable file contains hook injection enhancement code.
304. And performing interaction of the target task based on the target executable file.
In this embodiment, the interaction process of the target task is associated with the hook function, that is, the whole function in the running process of the programming service is obtained through the hook function, and then the whole function is processed based on the target task, and relevant test information is obtained. In particular, the test information may include testing of abnormal behavior handling capabilities, such as testing the response of programming services to delayed, skipped, repeated, thrown, tampered operations.
In one possible scenario, the hook-injected enhancement code, i.e., the target executable; the method can interact with a cache database, and can ensure that abnormal behaviors of corresponding functions can be set directly according to specific function labels in an operation stage, wherein the specific cache database is positioned outside programming service, namely can be in another device or can be a virtual machine of the same device, and the specific position is determined by an actual scene.
Specifically, an interaction process with a cache database is shown in fig. 8, and fig. 8 is a flow chart of another method for managing programming services according to an embodiment of the present application; firstly, determining function call information output by a target executable file in the running process; then interacting with the cache database based on the function call information; further determining a target task in response to the task instruction in the cache database; thus, the function call information is configured based on the target task to test the programming service.
Alternatively, the process of determining the target task may be set based on the function tag, i.e., the function tag is determined in response to the task instruction in the cache database; a task function is then determined based on the function tags to generate a target task. Specifically, an executable file with a full function hook is deployed to a test environment, and cache database information is set; the tester or the control equipment calls the function tag by setting the configuration instruction so as to enable the cache database to interact with the Go programming service in the running period in real time, and corresponding abnormal behaviors are set.
In the process of testing the set abnormal behavior, the function call information can be firstly configured based on the target task so as to determine a test function; then determining corresponding method parameters in the test function; and determining execution rules based on the method parameters to test the programming service. The execution rule may be an execution order, for example, because the method body of the original function testHook is moved into the internal anonymous function innerFunc, before the internal anonymous function is declared, the method parameters and the returned result may be respectively packaged into a structure body, so that the method parameters and the returned result are conveniently and uniformly transferred to the whole function hook injection object. After the hook injection object is created, the pre-method, the original function method and the post-method are sequentially executed, and parameters are returned according to the original function rule, so that the testing process is realized.
Optionally, the setting of the abnormal behavior may further include setting of configuration information and execution information; determining calling party information and called party information for configuration information, namely based on task functions corresponding to target tasks; and thus, the function call information is configured according to the configuration information to test the programming service. The code form of the configuration information may include call_func_name: calling party function name; called _func_name: callee function name.
For configuration of execution information, test parameters including types, occurrence occasions or occurrence probabilities of test cases may be determined in response to the test instructions; the method parameters are then updated based on the test parameters. For example, the process that the full function hook injection object outputs function call information at the running time and interacts with the cache database; and when the user is configured in the cache database according to the abnormal effective rule, starting the execution of the real-time abnormal behavior. The rules corresponding to the abnormal behavior may include:
call_func_name:called_func_name#inject_name.params1.params2…
Wherein, call_func_name: calling party function name;
called _func_name: called party function name;
Object_name: the name of the abnormal injection can be set as delay, skip, repeat, misthrowing panic, falsification and the like;
params1/2: setting parameters including occurrence probability, occurrence time, occurrence parameters and the like by abnormal injection;
if the main function call is main, the main function call is executed by the main function call, and the main function call is executed by the main function call;
main, testhook#delay, probability of occurrence of delayed abnormal behavior;
main, testhook#delay, mean, means that delay the occurrence of abnormal behavior is average to sleep.
Therefore, the setting of abnormal behaviors with different dimensions is realized, and the comprehensiveness of detecting the abnormal capability of the programming service is ensured.
By combining the above embodiments, it can be known that by acquiring the corresponding source code in the execution process of the programming service; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
The above-described embodiment introduces the determination process of the abnormal behavior processing capability, and a description is given below of a scenario corresponding to the role of the abnormal behavior processing capability. Referring to fig. 9, fig. 9 is a flowchart of another method for managing programming services according to an embodiment of the present application, where the method includes at least the following steps:
901. the target executable file is entered into a cache database.
In this embodiment, the generating process of the target executable file refers to steps 301-303 in the embodiment shown in fig. 3, and will not be described herein.
902. An abnormal task is set in response to the target operation.
In this embodiment, the target operation may be set by a related person, or may be an operation of automatically generating the cache database, for example, an abnormal task in the history record is adopted as an abnormal task of the current test, and a specific manner depends on an actual scene.
903. And determining an abnormal capability processing value according to the execution condition of the abnormal task.
In this embodiment, the determination of the abnormal capability processing value is positively related to the execution situation of the abnormal task, that is, the greater the number of execution completions of the abnormal task is, the higher the corresponding abnormal capability processing value is; the specific calculation mode of the abnormal capability processing value can also be used for carrying out weighted calculation based on different abnormal tasks, for example, the higher the abnormal occurrence frequency is, the larger the corresponding weight of the task is, and the specific calculation mode is determined according to an actual scene.
904. The programming service is assigned execution authority based on the exception capability handling value.
In this embodiment, the magnitude of the abnormal capability processing value verifies the robustness of the programming service, and for the programming service with higher robustness, the service with high risk can be allocated.
In one possible scenario, the processing rights of the programming service may be determined based on a comparison of the exception handling capability value to a preset value, the processing rights being used to indicate payment operations in a financial scenario. For example, when the value of the exception handling capability reaches the preset value 80, the payment-related operation can be processed, so that the security of the payment process is ensured.
In order to better implement the above-described aspects of the embodiments of the present application, the following provides related apparatuses for implementing the above-described aspects. Referring to fig. 10, fig. 10 is a schematic structural diagram of a programming service management device according to an embodiment of the present application, and a programming service management device 1000 includes:
an obtaining unit 1001, configured to obtain a source code corresponding to a program service in an execution process;
A parsing unit 1002, configured to parse the source code to convert the source code into a structured file;
An injection unit 1003, configured to inject a hook function into a function declaration corresponding to the structured document, so as to obtain a target executable document;
And the management unit 1004 is used for performing interaction of target tasks based on the target executable file, wherein the interaction process of the target tasks is associated with the hook function.
Optionally, in some possible implementations of the present application, the injecting unit 1003 is specifically configured to determine the function declaration corresponding to the structured document;
The injection unit 1003 is specifically configured to convert the structured document into an anonymous function based on the function declaration;
The injecting unit 1003 is specifically configured to inject the hook function into the anonymous function through the function declaration, so as to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injection unit 1003 is specifically configured to determine an injection node corresponding to the function declaration;
The injection unit 1003 is specifically configured to inject, by the injection node, the hook function into the anonymous function, so as to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting unit 1003 is specifically configured to inject, by the injecting node, the hook function into the anonymous function, so as to obtain an intermediate code;
The injection unit 1003 is specifically configured to convert the intermediate code into a machine code;
The injection unit 1003 is specifically configured to compile based on the machine code to obtain the target executable file.
Optionally, in some possible implementations of the present application, the injecting unit 1003 is specifically configured to determine an enhancement code corresponding to the hook function;
The injection unit 1003 is specifically configured to inject, by the injection node, the enhancement code into the anonymization function, so as to obtain a conversion code;
The injection unit 1003 is specifically configured to determine a node operator corresponding to the conversion code;
The injection unit 1003 is specifically configured to perform transcoding based on the node operator, so as to obtain the intermediate code.
Optionally, in some possible implementations of the present application, the management unit 1004 is specifically configured to determine function call information output by the target executable file during a running process;
The management unit 1004 is specifically configured to interact with a cache database based on the function call information;
The management unit 1004 is specifically configured to determine the target task in response to a task instruction in the cache database;
the management unit 1004 is specifically configured to configure the function call information based on the target task, so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit 1004 is specifically configured to determine a function tag in response to the task instruction in the cache database;
The management unit 1004 is specifically configured to determine a task function based on the function label, so as to generate the target task.
Optionally, in some possible implementations of the present application, the management unit 1004 is specifically configured to determine configuration information based on the task function corresponding to the target task, where the configuration information includes caller information and callee information;
The management unit 1004 is specifically configured to configure the function call information according to the configuration information, so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit 1004 is specifically configured to configure the function call information based on the target task to determine a test function;
The management unit 1004 is specifically configured to determine a corresponding method parameter in the test function;
The management unit 1004 is specifically configured to determine an execution rule based on the method parameter, so as to test the programming service.
Optionally, in some possible implementations of the present application, the management unit 1004 is specifically configured to determine a test parameter in response to a test instruction, where the test parameter includes a type, an occurrence opportunity, or an occurrence probability of a test case;
the management unit 1004 is specifically configured to update the method parameter based on the test parameter.
Optionally, in some possible implementations of the present application, the target task is an abnormal test task, and the management unit 1004 is specifically configured to determine an abnormal processing capability value of the programming service based on test information of the abnormal test task;
The management unit 1004 is specifically configured to determine a processing authority of the programming service according to a comparison relationship between the abnormal processing capability value and a preset value, where the processing authority is used to indicate a payment operation in a financial scenario.
Acquiring a corresponding source code in the execution process of the programming service; then resolving the source code to convert the source code into a structured file; injecting a hook function into a function statement corresponding to the structured file to obtain a target executable file; and then, the interaction of the target task is carried out based on the target executable file, and the interaction process of the target task is associated with the hook function. Therefore, the target task executing process in the programming service running process is realized, and the hook function is adopted to compile the executable file indicating the source code, so that the target task can be conveniently set, the running of the programming service is not influenced, and the executing efficiency of the test task in the programming service is improved.
Referring to fig. 11, fig. 11 is a schematic structural diagram of a server according to an embodiment of the present application, where the server 1100 may have a relatively large difference due to different configurations or performances, and may include one or more central processing units (central processing units, CPU) 1122 (e.g., one or more processors) and a memory 1132, one or more storage mediums 1130 (e.g., one or more mass storage devices) storing application programs 1142 or data 1144. Wherein the memory 1132 and the storage medium 1130 may be transitory or persistent. The program stored on the storage medium 1130 may include one or more modules (not shown), each of which may include a series of instruction operations on a server. Still further, the central processor 1122 may be provided in communication with a storage medium 1130, executing a series of instruction operations in the storage medium 1130 on the server 1100.
The server 1100 may also include one or more power supplies 1126, one or more wired or wireless network interfaces 1150, one or more input-output interfaces 1158, and/or one or more operating systems 1141, such as Windows Server, mac OS XTM, unixTM, linuxTM, freeBSDTM, and the like.
The steps performed by the management apparatus in the above-described embodiments may be based on the server structure shown in fig. 11.
Embodiments of the present application also provide a computer-readable storage medium having stored therein management instructions of a programming service, which when executed on a computer, cause the computer to perform the steps performed by the management apparatus of the programming service in the method described in the embodiments of fig. 2 to 9 described above.
There is also provided in an embodiment of the application a computer program product comprising management instructions for programming a service, which when run on a computer causes the computer to perform the steps performed by the management means for programming the service in the method described in the embodiment of figures 2 to 9 as described above.
The embodiment of the application also provides a management system of the programming service, which can comprise the management device of the programming service in the embodiment shown in fig. 10 or the server shown in fig. 11.
It will be clear to those skilled in the art that, for convenience and brevity of description, specific working procedures of the above-described systems, apparatuses and units may refer to corresponding procedures in the foregoing method embodiments, which are not repeated herein.
In the several embodiments provided in the present application, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of the units is merely a logical function division, and there may be additional divisions when actually implemented, e.g., multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or units, which may be in electrical, mechanical or other form.
The units described as separate units may or may not be physically separate, and units shown as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.
In addition, each functional unit in the embodiments of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.
The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on this understanding, the technical solution of the present application may be embodied essentially or partly in the form of a software product or all or part of the technical solution, which is stored in a storage medium, and includes several instructions for causing a computer device (which may be a personal computer, a management device of a programming service, or a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a read-only memory (ROM), a random access memory (random access memory, RAM), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
The above embodiments are only for illustrating the technical solution of the present application, and not for limiting the same; although the application has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present application.
Claims (15)
1. A method of managing programming services, comprising:
Acquiring a corresponding source code in the execution process of a programming service, wherein the programming service is obtained by editing based on a static programming language;
parsing the source code to convert the source code into a structured file;
determining a function statement corresponding to the structured document;
Converting the structured document into an anonymous function based on the function declaration;
Injecting a hook function into the anonymous function through the function declaration to obtain a target executable file;
and performing interaction of a target task based on the target executable file, wherein the interaction process of the target task is associated with the hook function, and the target task is an abnormal test task.
2. The method of claim 1, wherein said injecting the hook function into the anonymous function through the function declaration to obtain the target executable file comprises:
Determining the injection node corresponding to the function statement;
And injecting the hook function into the anonymous function through the injection node so as to obtain the target executable file.
3. The method according to claim 2, wherein said injecting, by the injection node, the hook function into the anonymous function to obtain the target executable file comprises:
Injecting the hook function into the anonymous function through the injection node to obtain an intermediate code;
Converting the intermediate code into machine code;
Compiling based on the machine code to obtain the target executable file.
4. A method according to claim 3, wherein said injecting, by said injection node, said hook function into said anonymizing function to obtain an intermediate code, comprises:
determining an enhancement code corresponding to the hook function;
injecting the enhancement codes into the anonymous function through the injection node to obtain conversion codes;
determining a node operator corresponding to the conversion code;
transcoding is performed based on the node operators to obtain the intermediate code.
5. The method of claim 1, wherein the interacting of the target task based on the target executable file comprises:
Determining function call information output by the target executable file in the running process;
interacting with a cache database based on the function call information;
Determining the target task in response to a task instruction in the cache database;
And configuring the function call information based on the target task to test the programming service.
6. The method of claim 5, wherein the determining the target task in response to a task instruction in the cache database comprises:
determining a function tag in response to the task instruction in the cache database;
a task function is determined based on the function tag to generate the target task.
7. The method of claim 5, wherein configuring the function call information based on the target task to test the programming service comprises:
determining configuration information based on a task function corresponding to the target task, wherein the configuration information comprises calling party information and called party information;
And configuring the function call information according to the configuration information so as to test the programming service.
8. The method of claim 5, wherein configuring the function call information based on the target task to test the programming service comprises:
configuring the function call information based on the target task to determine a test function;
determining corresponding method parameters in the test function;
An execution rule is determined based on the method parameters to test the programming service.
9. The method of claim 8, wherein the method further comprises:
determining test parameters in response to the test instruction, wherein the test parameters comprise the type, the occurrence time or the occurrence probability of the test case;
Updating the method parameters based on the test parameters.
10. The method according to any one of claims 1-9, wherein the method further comprises:
determining an abnormal processing capacity value of the programming service based on the test information of the abnormal test task;
and determining the processing authority of the programming service according to the comparison relation between the abnormal processing capability value and the preset value, wherein the processing authority is used for indicating the payment operation in the financial scene.
11. The method of claim 1, wherein the structured document is based on an abstract syntax tree setting.
12. A programming service management apparatus, comprising:
The system comprises an acquisition unit, a programming service generation unit and a programming service generation unit, wherein the acquisition unit is used for acquiring a corresponding source code in the execution process of the programming service, and the programming service is edited based on a static programming language;
The analysis unit is used for analyzing the source code so as to convert the source code into a structured file;
the injection unit is used for injecting a hook function into the function statement corresponding to the structured file to obtain a target executable file;
the management unit is used for carrying out interaction of target tasks based on the target executable file, the interaction process of the target tasks is associated with the hook function, and the target tasks are abnormal test tasks;
The injection unit is specifically configured to determine the function declaration corresponding to the structured document; converting the structured document into an anonymous function based on the function declaration; and injecting the hook function into the anonymous function through the function declaration to obtain the target executable file.
13. A computer device, the computer device comprising a processor and a memory:
The memory is used for storing program codes; the processor is configured to execute the method of managing programming services of any one of claims 1 to 11 according to instructions in the program code.
14. A computer readable storage medium having instructions stored therein which, when run on a computer, cause the computer to perform the method of managing programming services of any one of the preceding claims 1 to 11.
15. A computer program product comprising computer instructions which, when run on a computer device, cause the computer device to perform the method of managing programming services of any one of claims 1 to 11.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010871294.0A CN114115884B (en) | 2020-08-26 | 2020-08-26 | Method and related device for managing programming service |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010871294.0A CN114115884B (en) | 2020-08-26 | 2020-08-26 | Method and related device for managing programming service |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114115884A CN114115884A (en) | 2022-03-01 |
| CN114115884B true CN114115884B (en) | 2024-06-25 |
Family
ID=80374372
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010871294.0A Active CN114115884B (en) | 2020-08-26 | 2020-08-26 | Method and related device for managing programming service |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114115884B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115599645B (en) * | 2022-10-13 | 2023-05-02 | 安芯网盾(北京)科技有限公司 | Method and device for testing stability of linux driving module |
| CN116775040B (en) * | 2023-08-16 | 2023-11-17 | 北京安普诺信息技术有限公司 | Pile inserting method for realizing code vaccine and application testing method based on code vaccine |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104217163A (en) * | 2014-09-10 | 2014-12-17 | 珠海市君天电子科技有限公司 | Method and device for detecting structured exception handling (SEH) attacks |
Family Cites Families (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2002103493A2 (en) * | 2001-03-05 | 2002-12-27 | Anysoft Limited Partnership | Hook and subclass manager |
| ITTO20070915A1 (en) * | 2007-12-19 | 2009-06-20 | Antonio Remollino | PROCEDURE FOR VERIFICATION OF CODES BY PROCESSOR AND ITS VERIFICATION SYSTEM |
| US8793662B2 (en) * | 2008-03-25 | 2014-07-29 | Microsoft Corporation | Runtime code hooking for print driver and functionality testing |
| US9678747B2 (en) * | 2011-02-08 | 2017-06-13 | Openspan, Inc. | Code injection and code interception in an operating system with multiple subsystem environments |
| US8806437B2 (en) * | 2011-06-29 | 2014-08-12 | International Business Machines Corporation | Automated testing process |
| US9886249B2 (en) * | 2015-11-16 | 2018-02-06 | Sap Se | Universal transcompiling framework |
| US10642717B2 (en) * | 2018-07-06 | 2020-05-05 | International Business Machines Corporation | Application user interface testing system and method |
| CN108985017A (en) * | 2018-09-26 | 2018-12-11 | 北京京东金融科技控股有限公司 | The reinforcement means and device of application program |
| CN109453522B (en) * | 2018-11-09 | 2022-06-14 | 火烈鸟网络(广州)股份有限公司 | Game operation safety detection method and device, storage medium and electronic equipment |
| CN109684219A (en) * | 2018-12-26 | 2019-04-26 | 百度在线网络技术（北京）有限公司 | System performance testing method, apparatus and storage medium |
| CN111124906B (en) * | 2019-12-17 | 2022-06-28 | 蚂蚁财富(上海)金融信息服务有限公司 | Tracking method, compiling method and device based on dynamic embedded points and electronic equipment |
-
2020
- 2020-08-26 CN CN202010871294.0A patent/CN114115884B/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104217163A (en) * | 2014-09-10 | 2014-12-17 | 珠海市君天电子科技有限公司 | Method and device for detecting structured exception handling (SEH) attacks |
Non-Patent Citations (1)
| Title |
|---|
| 基于HOOK技术的监控软件设计;张勇;邢红宏;张继磊;;计算机应用与软件;20090215(第02期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114115884A (en) | 2022-03-01 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106156186B (en) | Data model management device, server and data processing method | |
| US8347272B2 (en) | Call graph dependency extraction by static source code analysis | |
| CN109032825B (en) | Fault injection method, device and equipment | |
| CN107678748B (en) | Source code file compiling method and device | |
| CN114115884B (en) | Method and related device for managing programming service | |
| CN110673837B (en) | Code repairing method and device, electronic equipment and computer readable storage medium | |
| WO2021175053A1 (en) | Method and apparatus for executing functional module in virtual machine | |
| US11157249B1 (en) | Method and system for identifying and extracting independent services from a computer program | |
| CN106933642B (en) | Application program processing method and processing device | |
| CN111913741A (en) | Object interception method, device, medium and electronic equipment | |
| US9405652B2 (en) | Regular expression support in instrumentation languages using kernel-mode executable code | |
| CN108304164B (en) | Business logic development method and development system | |
| CN110598419A (en) | Block chain client vulnerability mining method, device, equipment and storage medium | |
| CN116305131B (en) | Static confusion removing method and system for script | |
| CN109426546B (en) | Application starting method and device, computer storage medium and equipment | |
| US11429358B2 (en) | Representing asynchronous state machine in intermediate code | |
| CN107977304B (en) | System debugging method and device | |
| US11435989B2 (en) | Thread-local return structure for asynchronous state machine | |
| CN114706586A (en) | Code compiling method, code running method, code compiling device, code running device, computer equipment and storage medium | |
| CN111061642B (en) | Full-automatic competition data processing system and method based on user data | |
| CN109308256B (en) | Dynamic analysis method, equipment and storage medium for java program | |
| CN113032256A (en) | Automatic test method, device, computer system and readable storage medium | |
| CN114707124B (en) | NET platform code protection method and system based on code virtualization | |
| CN117093286B (en) | Plug-in generation method, device, equipment and computer readable storage medium | |
| CN115809086A (en) | Three-party library transplanting method, terminal and readable storage medium |
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 | ||
| GR01 | Patent grant |