CN111898130B - Method and system for realizing integrity protection of fine-grained control flow - Google Patents
Method and system for realizing integrity protection of fine-grained control flow Download PDFInfo
- Publication number
- CN111898130B CN111898130B CN202010600005.3A CN202010600005A CN111898130B CN 111898130 B CN111898130 B CN 111898130B CN 202010600005 A CN202010600005 A CN 202010600005A CN 111898130 B CN111898130 B CN 111898130B
- Authority
- CN
- China
- Prior art keywords
- control flow
- jump
- address
- legal
- code segment
- 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 30
- 239000012634 fragment Substances 0.000 claims abstract description 14
- 238000004590 computer program Methods 0.000 claims description 6
- 230000003068 static effect Effects 0.000 claims description 4
- 238000010586 diagram Methods 0.000 description 8
- 238000013461 design Methods 0.000 description 6
- 238000004891 communication Methods 0.000 description 5
- 230000006399 behavior Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 238000012546 transfer Methods 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 1
- 239000011362 coarse particle Substances 0.000 description 1
- 230000007123 defense Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 239000010419 fine particle Substances 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 238000000146 jump and return pulse sequence Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
- G06F21/57—Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
- G06F21/577—Assessing vulnerabilities and evaluating computer system security
Landscapes
- Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Computer Security & Cryptography (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Computing Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Storage Device Security (AREA)
Abstract
The embodiment of the invention provides a method and a system for realizing integrity protection of a fine-grained control flow. The method comprises the following steps: acquiring legal indirect control flows of a plurality of code fragments in a target program; replacing the jump address corresponding to each code segment with a preset low-order code of the control flow instruction address based on the legal indirect control flow; a preset null instruction is added to each code segment as a legal jump destination mark of the indirect control flow. According to the embodiment of the invention, the jump address labels among the code fragments in the program operation are replaced by the low-order codes of the addresses of the jump instructions, so that the hardware cost of the memory operation is greatly reduced, and the safety is improved.
Description
Technical Field
The invention relates to the technical field of network security, in particular to a method and a system for realizing integrity protection of a fine-grained control flow.
Background
In program development, there is usually a memory bug, which refers to a problem that a programmer has a design error in time or space on the operation of a memory in the process of writing software, so that the program may make a behavior violating the design of the program itself. An attacker can construct various attacks and execute malicious behaviors by using the memory loopholes of the program.
In exploit-ing vulnerabilities, it is often necessary to bypass a widely used defense: NX protection, i.e. writable data, is not executable. This prevents an attacker from directly injecting the attack code, but rather, it is necessary to organize the code fragments of the attacked program itself to complete the attack. Thus, such an attack is referred to as a code reuse attack. The key to a code reuse attack is to organize code fragments according to the design of the attacker. In order to achieve arbitrary concatenation of code segments, indirect branch instructions are typically required. Indirect branch instructions refer to a series of branch instructions that use a pointer within a register or memory as a target address, rather than a code address fixed in code as a target address. Indirect branch instructions generally include indirect call, indirect jump and return instructions. For example, an attacker may certainly execute an instruction jmp RAX, which is an indirect jump instruction. If an attacker can control the value of RAX, it can jump to an instruction sequence of arbitrary addresses. If the next instruction sequence ends with another indirect branch, the same method can be used to continue to jump to any other address sequence. Each indirect branch may be of a different kind or of a single kind: an indirect call (e.g., call RAX) indirect jump (e.g., jmp RAX) returns an instruction (return), pops an address off the stack and jumps.
In order to defend against code reuse attacks, the concept of Control-Flow resistor (CFI) is proposed. The control flow integrity protection refers to analyzing the program before the program runs to obtain a legal control flow of the program. It is checked at program run-time whether the control flow corresponds to the result of the analysis. CFI can be broadly divided into coarse and fine particle size: fine granularity refers to the use of labels, e.g. a to b, c to d, for the source and destination addresses of each (indirect) control flow to make a fine distinction. Whereas coarse granularity generally refers to marking only one code segment as a destination address for indirect control flow transfer. If a to b, c to d are legal, then b and d will be marked as legal purposes. Whereas a to d and c to b are also legal in coarse-grained CFI. It can thus be seen that fine-grained CFI is safer, while coarse-grained CFI is simpler to implement.
At present, a CPU has only a coarse-grained hardware design, and a special null instruction is generally introduced to mark a legal destination address. For example, the IBT in Intel CET has the ENDBRANCH instruction added to it. This instruction is placed at the entrance of all legitimate jump targets. When an indirect branch occurs, the CPU checks whether the destination address of the branch is an ENDBRANCH instruction, and if not, considers an attack to have occurred. The BTI of ARM is also of similar design.
Therefore, there is a need to propose a method for implementing control flow integrity protection based on fine granularity, which solves the above-mentioned drawbacks.
Disclosure of Invention
The embodiment of the invention provides a fine-grained control flow integrity protection implementation method and a fine-grained control flow integrity protection implementation system, which are used for solving the problems or at least partially solving the problems.
In a first aspect, an embodiment of the present invention provides a method for implementing integrity protection of a fine-grained control flow, including:
acquiring legal indirect control flows of a plurality of code fragments in a target program;
based on the legal indirect control flow, replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address;
a preset null instruction is added to each code segment as a legal jump destination mark of the indirect control flow.
Further, the obtaining legal indirect control flows of a plurality of code segments in the target program specifically includes:
decomposing the target program into a plurality of code segments;
and carrying out static analysis on the code segments to obtain a path set from each code segment to the next allowable jump code segment, and taking the path set as the legal indirect control flow.
Further, based on the legal indirect control flow, replacing the preset low-order address corresponding to the jump address of each code segment with the preset low-order code of the control flow instruction address, specifically including:
acquiring a source tag and a destination tag of each code segment;
and respectively replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order codes according to the jump sequence of the legal indirect control flow.
Further, according to the jump sequence of the legal indirect control flow, the replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order codes respectively further includes:
if the source jump address of the current code segment comprises a preset low-order code and the destination jump address corresponding to the next jump code segment has the same preset low-order code as the current code segment, judging that the source jump address of the current code segment is a legal source jump address;
if the preset low-order coding set of the next code segment comprises the source jump address of at least one current code segment, judging the source jump address of the at least one current code segment as a legal source jump address set.
In a second aspect, an embodiment of the present invention provides a fine-grained control flow integrity protection implementation system, including:
the acquisition module is used for acquiring legal indirect control flows of a plurality of code fragments in the target program;
the replacing module is used for replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address based on the legal indirect control flow;
and the marking module is used for adding a preset empty instruction to each code segment as a legal jump destination mark of the indirect control flow.
In a third aspect, an embodiment of the present invention provides an electronic device, including:
a memory, a processor, and a computer program stored on the memory and executable on the processor, the processor implementing the steps of any of the fine-grained control flow integrity protection implementation methods when the program is executed.
In a fourth aspect, embodiments of the present invention provide a non-transitory computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of any of the fine-grained control flow integrity protection implementation methods.
According to the fine-grained control flow implementation method and system provided by the embodiment of the invention, the jump address labels among the code segments in the program operation are replaced by the low-order codes of the jump instruction self addresses, so that the hardware cost of the memory operation is greatly reduced, and the safety is improved.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, and it is obvious that the drawings in the following description are some embodiments of the present invention, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flowchart of a method for implementing integrity protection of a fine-grained control flow according to an embodiment of the invention;
FIG. 2 is a schematic diagram of a path result based on static analysis according to the prior art;
FIG. 3 is a schematic diagram of the results of a prior art implementation of coarse-grained control flow integrity protection;
FIG. 4 is a schematic diagram of the results of a conventional fine granularity control flow integrity protection implementation in the prior art;
FIG. 5 is a schematic diagram of the implementation results of improved fine-grained control flow integrity protection provided by an embodiment of the invention;
FIG. 6 is a block diagram of a fine granularity control flow integrity protection implementation system according to an embodiment of the present invention;
fig. 7 is a block diagram of an electronic device according to an embodiment of the present invention.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments of the present invention. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the present application. The appearances of such phrases in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments.
In the prior art, coarse-grained CFI allowed some control flow paths that should not be allowed, which made many paths available to an attacker to build an attack; both fine-grained CFI designs require the use of a tag register, tag execution at the source and destination of the control flow transfer, the source tag instruction updates the tag register, and the destination tag instruction checks whether the current tag register is a legal tag, thus there are two problems: firstly, the hardware loss is overlarge, generally about 2.5%, and the method is the most main reason that the commercial industry does not formally use the method; secondly, there is no good solution for the case where a single object is marked as multiple tags.
In response to the above problems, embodiments of the present invention use the low order bits of the address as tags for fine-grained CFI checking and modify the instruction logic of indirect branching so that the hardware wear is almost zero and provide a very simple solution for cases where a single target is marked as multiple tags.
Fig. 1 is a flowchart of a method for implementing integrity protection of a fine-grained control flow according to an embodiment of the invention, as shown in fig. 1, including:
s1, acquiring legal indirect control flows of a plurality of code fragments in a target program;
s2, replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address based on the legal indirect control flow;
s3, adding a preset empty instruction for each code segment to serve as a legal jump destination mark of the indirect control flow.
Specifically, the program to be protected is analyzed, the program is composed of a plurality of code segments, a legal jump path, namely legal indirect control flow, in the code segments is obtained, the jump between the original code segments is based on a label address, namely, whether the source address and the destination address are legal paths or not is identified, the logic of transferring the indirect control flow is modified, the low n bits of the destination address of the control flow are changed into the low n bits of the self address of the instruction, and the low bits corresponding to the jump address are copied from the low bits of the current jump instruction. Also, a special marking instruction, namely a preset blank instruction, is used for completing the detection similar to the coarse-granularity CFI, namely an object marking ENDBR as legal jump; here, the compiler is modified, reordering the binary so that all indirect calls and the low n bits of their legal destination address are equal.
According to the embodiment of the invention, the jump address labels among the code fragments in the program operation are replaced by the low-order codes of the addresses of the jump instructions, so that the hardware cost of the memory operation is greatly reduced, and the safety is improved.
Based on the above embodiment, step S1 in the method specifically includes:
decomposing the target program into a plurality of code segments;
and carrying out static analysis on the code segments to obtain a path set from each code segment to the next allowable jump code segment, and taking the path set as the legal indirect control flow.
Specifically, in the embodiment shown in fig. 2, the program is divided into 5 code segments, namely code segments A, B, C, D and E, which are statically analyzed to obtain the allowable jump paths: A-B, A-C, B-D, C-D and D-E, the path set described above is used as a legal indirect control flow.
In coarse-grained CFI in the embodiment shown in FIG. 3, endbr is a marked instruction and B-C and B-E are illegal paths, but since the jump instruction and the marked instruction are identical, the two illegal attacks cannot be prevented.
In the normal fine-granularity CFI in the embodiment shown in fig. 4, since the tag register set and the check tag register check are required to be set, the source address of the code segment a is set to 5, the destination addresses and the source addresses of the code segments B and C are set to 5 and 7, respectively, and the destination addresses of the code segments D and E are set to 7, the illegal paths B-C and B-E can only protect against B-C, but not B-E. Here, if there is only a single tag per location, the code segment CDE needs to share the tag, and there is one attack that cannot defend.
It should be noted that, the program may be embodied as any combination of code segments and any legal jump manner therebetween, and the foregoing figures are merely examples, which are not limited in any way by the embodiments of the present invention.
Based on any of the above embodiments, step S2 in the method specifically includes:
acquiring a source tag and a destination tag of each code segment;
and respectively replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order codes according to the jump sequence of the legal indirect control flow.
The step of replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order code according to the jump sequence of the legal indirect control flow, further comprises:
if the source jump address of the current code segment comprises a preset low-order code and the destination jump address corresponding to the next jump code segment has the same preset low-order code as the current code segment, judging that the source jump address of the current code segment is a legal source jump address;
if the preset low-order coding set of the next code segment comprises the source jump address of at least one current code segment, judging the source jump address of the at least one current code segment as a legal source jump address set.
Specifically, in the embodiment shown in fig. 5, the compiling of the instruction is modified based on the common fine granularity CFI, the binary file is rearranged, the source address of the code segment a, the low-order address in the destination addresses of the code segments B and C are modified to be the low-order address of the control flow control instruction, as shown in the figure to the bit "XX05", wherein the low-order address of the source address of the code segment B is modified to the bit "XX07", the low-order address of the source address of the code segment C is modified to the bit "XX08", the low-order address of the destination address of the code segment D is modified to the bits "XX07" and "XX08", the low-order address of the destination address of the code segment E is modified to the bit "XX08", and when the jump address is not endbr, an attack is considered to occur, and attacks of all illegal paths can be defended. Here, the code segment D includes two destination addresses, i.e. solves the problem of single-destination multi-address, and different jump instructions have different low-order codes of instruction addresses, where both the code segment B and the code segment C can jump to D and execute codes, and each jump address may have a different source address tag. Because the low order of the address is directly replaced by the low order code of the control instruction, the jump does not need to always start with the function of the jump, but the preset empty instruction corresponding to a range interval can be used, and the scene requirement of the multi-label control flow is met.
Here, the unified addition of a preset null instruction at the destination address of code fragments B, C, D and E as the destination tag of a legal jump completes a check similar to coarse-grained CFI, and if the entry does not have this tag, it is considered an illegal path and access is denied.
Fig. 6 is a structural diagram of a fine-grained control flow integrity protection implementation system according to an embodiment of the invention, as shown in fig. 6, including: an acquisition module 61, a replacement module 62 and a marking module 63; wherein:
the obtaining module 61 is configured to obtain legal indirect control flows of a plurality of code segments in the target program; the replacing module 62 is configured to replace, based on the legal indirect control flow, a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address; the marking module 63 is configured to add a preset null instruction to each code segment as a legal jump destination mark of the indirect control flow.
The system provided by the embodiment of the present invention is used for executing the corresponding method, and the specific implementation manner of the system is consistent with the implementation manner of the method, and the related algorithm flow is the same as the algorithm flow of the corresponding method, which is not repeated here.
According to the embodiment of the invention, the jump address labels among the code fragments in the program operation are replaced by the low-order codes of the addresses of the jump instructions, so that the hardware cost of the memory operation is greatly reduced, and the safety is improved.
Fig. 7 illustrates a physical schematic diagram of an electronic device, as shown in fig. 7, which may include: processor 710, communication interface (Communications Interface) 720, memory 730, and communication bus 740, wherein processor 710, communication interface 720, memory 730 communicate with each other via communication bus 740. Processor 710 may call logic instructions in memory 730 to perform the following method: acquiring legal indirect control flows of a plurality of code fragments in a target program; based on the legal indirect control flow, replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address; a preset null instruction is added to each code segment as a legal jump destination mark of the indirect control flow.
Further, the logic instructions in the memory 730 described above may be implemented in the form of software functional units and may be stored in a computer readable storage medium when sold or used as a stand alone product. Based on this understanding, the technical solution of the present invention may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution, in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
In another aspect, embodiments of the present invention further provide a non-transitory computer readable storage medium having stored thereon a computer program, which when executed by a processor is implemented to perform the transmission method provided in the above embodiments, for example, including: acquiring legal indirect control flows of a plurality of code fragments in a target program; based on the legal indirect control flow, replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address; a preset null instruction is added to each code segment as a legal jump destination mark of the indirect control flow.
The apparatus embodiments described above are merely illustrative, wherein the elements illustrated as separate elements may or may not be physically separate, and the elements shown as elements may or may not be physical elements, may be located in one place, or may be distributed over a plurality of network elements. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of this embodiment. Those of ordinary skill in the art will understand and implement the present invention without undue burden.
From the above description of the embodiments, it will be apparent to those skilled in the art that the embodiments may be implemented by means of software plus necessary general hardware platforms, or of course may be implemented by means of hardware. Based on this understanding, the foregoing technical solution may be embodied essentially or in a part contributing to the prior art in the form of a software product, which may be stored in a computer readable storage medium, such as ROM/RAM, a magnetic disk, an optical disk, etc., including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the method described in the respective embodiments or some parts of the embodiments.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and are not limiting; although the invention 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 invention.
Claims (5)
1. The implementation method for the integrity protection of the fine-grained control flow is characterized by comprising the following steps of:
acquiring legal indirect control flows of a plurality of code fragments in a target program;
based on the legal indirect control flow, replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address;
adding a preset empty instruction to each code segment as a legal jump destination mark of an indirect control flow;
the replacing, based on the legal indirect control flow, the preset low-order address corresponding to the jump address of each code segment with the preset low-order code of the control flow instruction address specifically includes:
acquiring a source tag and a destination tag of each code segment;
according to the jump sequence of the legal indirect control flow, respectively replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order code;
the step of replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order code according to the jump sequence of the legal indirect control flow, further comprises:
if the source jump address of the current code segment comprises a preset low-order code and the destination jump address corresponding to the next jump code segment has the same preset low-order code as the current code segment, judging that the source jump address of the current code segment is a legal source jump address;
if the preset low-order coding set of the next code segment comprises the source jump address of at least one current code segment, judging the source jump address of the at least one current code segment as a legal source jump address set.
2. The method for implementing integrity protection of fine-grained control flow according to claim 1, wherein the obtaining legal indirect control flow of a plurality of code segments in the target program specifically comprises:
decomposing the target program into a plurality of code segments;
and carrying out static analysis on the code segments to obtain a path set from each code segment to the next allowable jump code segment, and taking the path set as the legal indirect control flow.
3. A fine-grained control flow integrity protection implementation system, comprising:
the acquisition module is used for acquiring legal indirect control flows of a plurality of code fragments in the target program;
the replacing module is used for replacing a preset low-order address corresponding to the jump address of each code segment with a preset low-order code of the control flow instruction address based on the legal indirect control flow;
the marking module is used for adding a preset empty instruction to each code segment to serve as a legal jump destination mark of the indirect control flow;
the replacement module is specifically used for:
acquiring a source tag and a destination tag of each code segment;
according to the jump sequence of the legal indirect control flow, respectively replacing the preset low-order address of the source jump address corresponding to the source tag and the preset low-order address of the destination jump address corresponding to the destination tag with the preset low-order code;
the replacement module is further configured to:
if the source jump address of the current code segment comprises a preset low-order code and the destination jump address corresponding to the next jump code segment has the same preset low-order code as the current code segment, judging that the source jump address of the current code segment is a legal source jump address;
if the preset low-order coding set of the next code segment comprises the source jump address of at least one current code segment, judging the source jump address of the at least one current code segment as a legal source jump address set.
4. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the steps of the fine-grained control flow integrity protection implementation method of claim 1 or 2 when the program is executed by the processor.
5. A non-transitory computer readable storage medium having stored thereon a computer program, characterized in that the computer program when executed by a processor implements the steps of the fine-grained control flow integrity protection implementation method of claim 1 or 2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010600005.3A CN111898130B (en) | 2020-06-28 | 2020-06-28 | Method and system for realizing integrity protection of fine-grained control flow |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010600005.3A CN111898130B (en) | 2020-06-28 | 2020-06-28 | Method and system for realizing integrity protection of fine-grained control flow |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111898130A CN111898130A (en) | 2020-11-06 |
| CN111898130B true CN111898130B (en) | 2024-01-19 |
Family
ID=73207465
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010600005.3A Active CN111898130B (en) | 2020-06-28 | 2020-06-28 | Method and system for realizing integrity protection of fine-grained control flow |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111898130B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113296833B (en) * | 2021-04-30 | 2024-03-05 | 中国科学院信息工程研究所 | Identification method and device for legal instructions in binary file |
| CN113312082B (en) * | 2021-04-30 | 2024-03-08 | 中国科学院信息工程研究所 | Identification method and device for data mixed in instructions in binary file |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105867880A (en) * | 2016-04-01 | 2016-08-17 | 中国科学院计算技术研究所 | Branch target buffer for indirect skip branch prediction and design method |
| CN110276198A (en) * | 2019-06-14 | 2019-09-24 | 中国科学院信息工程研究所 | A kind of embedded changeable granularity control flow verification method and system based on probabilistic forecasting |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9390260B2 (en) * | 2014-06-09 | 2016-07-12 | Lehigh University | Methods for enforcing control flow of a computer program |
| US10628589B2 (en) * | 2016-01-22 | 2020-04-21 | The University Of North Carolina At Chapel Hill | Methods, systems, and computer readable media for preventing code reuse attacks |
| SG10201701541SA (en) * | 2017-02-27 | 2018-09-27 | Huawei Int Pte Ltd | Device and method for reinforcing control flow integrity of software application |
| US10372902B2 (en) * | 2017-03-06 | 2019-08-06 | Intel Corporation | Control flow integrity |
-
2020
- 2020-06-28 CN CN202010600005.3A patent/CN111898130B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105867880A (en) * | 2016-04-01 | 2016-08-17 | 中国科学院计算技术研究所 | Branch target buffer for indirect skip branch prediction and design method |
| CN110276198A (en) * | 2019-06-14 | 2019-09-24 | 中国科学院信息工程研究所 | A kind of embedded changeable granularity control flow verification method and system based on probabilistic forecasting |
Non-Patent Citations (2)
| Title |
|---|
| HCIC:Hardware-assisted control-flow integrity checking;J.Zhang et al.;《IEEE Internet Things》;第6卷(第1期);第458-471页 * |
| 代码重用攻击与防御机制综述;柳童 等;《信息安全学报》;第1卷(第2期);第13-28页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111898130A (en) | 2020-11-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP3779745B1 (en) | Code pointer authentication for hardware flow control | |
| CN102959556B (en) | For guaranteeing the method that the processor of software integrity realizes | |
| CN111381879B (en) | Data processing method and device | |
| CN111898130B (en) | Method and system for realizing integrity protection of fine-grained control flow | |
| US8281290B2 (en) | Software diversity using context-free grammar transformations | |
| JP2022009556A (en) | Method for securing software codes | |
| US20200380150A1 (en) | Method of encoding and decoding memory data for software security, recording medium and apparatus for performing the method | |
| CN109409086B (en) | Device for detecting falsified return address in stack based on newly added instruction | |
| CN112711760B (en) | Detection method and device for detecting vulnerability of intelligent contract malicious elimination reentry influence | |
| CN109409084B (en) | Chain type data storage structure for detecting falsified return address | |
| CN110717181B (en) | Non-control data attack detection method and device based on novel program dependency graph | |
| US11704128B2 (en) | Method for executing a machine code formed from blocks having instructions to be protected, each instruction associated with a construction instruction to modify a signature of the block | |
| CN102819703B (en) | For protecting the method and apparatus of web page attacks | |
| US8261065B2 (en) | Protecting caller function from undesired access by callee function | |
| CN111898120B (en) | Control flow integrity protection method and device | |
| CN111898119B (en) | Control flow integrity protection method, device, equipment and storage medium | |
| EP3574425B1 (en) | Method to secure a software code | |
| US10579457B1 (en) | Processor for achieving flow integrity and a method of providing notice of a fault in control flow | |
| CN113032737B (en) | Software protection method and device, electronic equipment and storage medium | |
| CN109409083B (en) | Device for detecting return address tampering in stack | |
| US10776460B2 (en) | Proactive security system based on code polymorphism | |
| WO2022135686A1 (en) | Method for securing a computing device from memory corruption and computing device | |
| Pal et al. | Memory Corruption-Basic Attacks and Counter Measures | |
| CN114707143B (en) | Method and device for monitoring memory data damage attack | |
| Karwayun et al. | War of Control Hijacking: Attacks and Defenses |
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 | ||
| GR01 | Patent grant |