Preventing Memory Error Exploits with WIT. Akritidis, P., Cadar, C., Raiciu, C., Costa, M., & Castro, M. In Proc. of the IEEE Symp. on Security and Privacy, 2008. abstract bibtex Attacks often exploit memory errors to gain control over the execution of vulnerable programs. These attacks remain a serious problem despite previous research on techniques to prevent them. We present Write Integrity Testing (WIT), a new technique that provides practical protection from these attacks. WIT uses points-to analysis at compile time to compute the control-flow graph and the set of objects that can be written by each instruction in the program. Then it generates code instrumented to prevent instructions from modifying objects that are not in the set computed by the static analysis, and to ensure that indirect control transfers are allowed by the control-flow graph. To improve coverage where the analysis is not precise enough, WIT inserts small guards between the original program objects. We describe an efficient implementation with optimizations to reduce space and time overhead. This implementation can be used in practice because it compiles C and C++ programs without modifications, it has high coverage with no false positives, and it has low overhead. WIT's average runtime overhead is only 7% across a set of CPU intensive benchmarks and it is negligible when IO is the bottleneck.
@inproceedings{akritidis_preventing_2008,
title = {Preventing {Memory} {Error} {Exploits} with {WIT}},
abstract = {Attacks often exploit memory errors to gain control over the execution of vulnerable programs. These attacks remain a serious problem despite previous research on techniques to prevent them. We present Write Integrity Testing (WIT), a new technique that provides practical protection from these attacks. WIT uses points-to analysis at compile time to compute the control-flow graph and the set of objects that can be written by each instruction in the program. Then it generates code instrumented to prevent instructions from modifying objects that are not in the set computed by the static analysis, and to ensure that indirect control transfers are allowed by the control-flow graph. To improve coverage where the analysis is not precise enough, WIT inserts small guards between the original program objects. We describe an efficient implementation with optimizations to reduce space and time overhead. This implementation can be used in practice because it compiles C and C++ programs without modifications, it has high coverage with no false positives, and it has low overhead. WIT's average runtime overhead is only 7\% across a set of CPU intensive benchmarks and it is negligible when IO is the bottleneck.},
booktitle = {Proc. of the {IEEE} {Symp}. on {Security} and {Privacy}},
author = {Akritidis, Periklis and Cadar, Cristian and Raiciu, Costin and Costa, Manuel and Castro, Miguel},
year = {2008},
keywords = {attack detection, bounds checking, instrumentation, memory errors, static analysis}
}
Downloads: 0
{"_id":"bhE7Cq9NvMkcac4Yc","bibbaseid":"akritidis-cadar-raiciu-costa-castro-preventingmemoryerrorexploitswithwit-2008","downloads":0,"creationDate":"2016-10-15T13:23:04.491Z","title":"Preventing Memory Error Exploits with WIT","author_short":["Akritidis, P.","Cadar, C.","Raiciu, C.","Costa, M.","Castro, M."],"year":2008,"bibtype":"inproceedings","biburl":"http://bibbase.org/zotero/pentarious","bibdata":{"bibtype":"inproceedings","type":"inproceedings","title":"Preventing Memory Error Exploits with WIT","abstract":"Attacks often exploit memory errors to gain control over the execution of vulnerable programs. These attacks remain a serious problem despite previous research on techniques to prevent them. We present Write Integrity Testing (WIT), a new technique that provides practical protection from these attacks. WIT uses points-to analysis at compile time to compute the control-flow graph and the set of objects that can be written by each instruction in the program. Then it generates code instrumented to prevent instructions from modifying objects that are not in the set computed by the static analysis, and to ensure that indirect control transfers are allowed by the control-flow graph. To improve coverage where the analysis is not precise enough, WIT inserts small guards between the original program objects. We describe an efficient implementation with optimizations to reduce space and time overhead. This implementation can be used in practice because it compiles C and C++ programs without modifications, it has high coverage with no false positives, and it has low overhead. WIT's average runtime overhead is only 7% across a set of CPU intensive benchmarks and it is negligible when IO is the bottleneck.","booktitle":"Proc. of the IEEE Symp. on Security and Privacy","author":[{"propositions":[],"lastnames":["Akritidis"],"firstnames":["Periklis"],"suffixes":[]},{"propositions":[],"lastnames":["Cadar"],"firstnames":["Cristian"],"suffixes":[]},{"propositions":[],"lastnames":["Raiciu"],"firstnames":["Costin"],"suffixes":[]},{"propositions":[],"lastnames":["Costa"],"firstnames":["Manuel"],"suffixes":[]},{"propositions":[],"lastnames":["Castro"],"firstnames":["Miguel"],"suffixes":[]}],"year":"2008","keywords":"attack detection, bounds checking, instrumentation, memory errors, static analysis","bibtex":"@inproceedings{akritidis_preventing_2008,\n\ttitle = {Preventing {Memory} {Error} {Exploits} with {WIT}},\n\tabstract = {Attacks often exploit memory errors to gain control over the execution of vulnerable programs. These attacks remain a serious problem despite previous research on techniques to prevent them. We present Write Integrity Testing (WIT), a new technique that provides practical protection from these attacks. WIT uses points-to analysis at compile time to compute the control-flow graph and the set of objects that can be written by each instruction in the program. Then it generates code instrumented to prevent instructions from modifying objects that are not in the set computed by the static analysis, and to ensure that indirect control transfers are allowed by the control-flow graph. To improve coverage where the analysis is not precise enough, WIT inserts small guards between the original program objects. We describe an efficient implementation with optimizations to reduce space and time overhead. This implementation can be used in practice because it compiles C and C++ programs without modifications, it has high coverage with no false positives, and it has low overhead. WIT's average runtime overhead is only 7\\% across a set of CPU intensive benchmarks and it is negligible when IO is the bottleneck.},\n\tbooktitle = {Proc. of the {IEEE} {Symp}. on {Security} and {Privacy}},\n\tauthor = {Akritidis, Periklis and Cadar, Cristian and Raiciu, Costin and Costa, Manuel and Castro, Miguel},\n\tyear = {2008},\n\tkeywords = {attack detection, bounds checking, instrumentation, memory errors, static analysis}\n}\n\n","author_short":["Akritidis, P.","Cadar, C.","Raiciu, C.","Costa, M.","Castro, M."],"key":"akritidis_preventing_2008","id":"akritidis_preventing_2008","bibbaseid":"akritidis-cadar-raiciu-costa-castro-preventingmemoryerrorexploitswithwit-2008","role":"author","urls":{},"keyword":["attack detection","bounds checking","instrumentation","memory errors","static analysis"],"downloads":0},"search_terms":["preventing","memory","error","exploits","wit","akritidis","cadar","raiciu","costa","castro"],"keywords":["attack detection","bounds checking","instrumentation","memory errors","static analysis"],"authorIDs":[],"dataSources":["QiRZ7m7shEMvADZkd"]}