A compiler-level intermediate representation based binary analysis and rewriting system

A compiler-level intermediate representation based binary analysis and rewriting system. Anand, K., Smithson, M., Elwazeer, K., Kotha, A., Gruen, J., Giles, N., & Barua, R. In Proc. of the Eighth ACM European Conf. on Computer Systems, pages 295--308, 2013.
abstract bibtex

This paper presents component techniques essential for converting executables to a high-level intermediate representation (IR) of an existing compiler. The compiler IR is then employed for three distinct applications: binary rewriting using the compiler's binary back-end, vulnerability detection using source-level symbolic execution, and source-code recovery using the compiler's C backend. Our techniques enable complex high-level transformations not possible in existing binary systems, address a major challenge of input-derived memory addresses in symbolic execution and are the first to enable recovery of a fully functional source-code. We present techniques to segment the flat address space in an executable containing undifferentiated blocks of memory. We demonstrate the inadequacy of existing variable identification methods for their promotion to symbols and present our methods for symbol promotion. We also present methods to convert the physically addressed stack in an executable (with a stack pointer) to an abstract stack (without a stack pointer). Our methods do not use symbolic, relocation, or debug information since these are usually absent in deployed executables. We have integrated our techniques with a prototype x86 binary framework called SecondWrite that uses LLVM as IR. The robustness of the framework is demonstrated by handling executables totaling more than a million lines of source-code, produced by two different compilers (gcc and Microsoft Visual Studio compiler), three languages (C, C++, and Fortran), two operating systems (Windows and Linux) and a real world program (Apache server).

@inproceedings{anand_compiler-level_2013,
	title = {A compiler-level intermediate representation based binary analysis and rewriting system},
	abstract = {This paper presents component techniques essential for converting executables to a high-level intermediate representation (IR) of an existing compiler. The compiler IR is then employed for three distinct applications: binary rewriting using the compiler's binary back-end, vulnerability detection using source-level symbolic execution, and source-code recovery using the compiler's C backend. Our techniques enable complex high-level transformations not possible in existing binary systems, address a major challenge of input-derived memory addresses in symbolic execution and are the first to enable recovery of a fully functional source-code. We present techniques to segment the flat address space in an executable containing undifferentiated blocks of memory. We demonstrate the inadequacy of existing variable identification methods for their promotion to symbols and present our methods for symbol promotion. We also present methods to convert the physically addressed stack in an executable (with a stack pointer) to an abstract stack (without a stack pointer). Our methods do not use symbolic, relocation, or debug information since these are usually absent in deployed executables. We have integrated our techniques with a prototype x86 binary framework called SecondWrite that uses LLVM as IR. The robustness of the framework is demonstrated by handling executables totaling more than a million lines of source-code, produced by two different compilers (gcc and Microsoft Visual Studio compiler), three languages (C, C++, and Fortran), two operating systems (Windows and Linux) and a real world program (Apache server).},
	urldate = {2013-10-13TZ},
	booktitle = {Proc. of the {Eighth} {ACM} {European} {Conf}. on {Computer} {Systems}},
	author = {Anand, Kapil and Smithson, Matthew and Elwazeer, Khaled and Kotha, Aparna and Gruen, Jim and Giles, Nathan and Barua, Rajeev},
	year = {2013},
	pages = {295--308}
}

Downloads: 0

{"_id":"d6gD9RNeFH4GkTwvz","bibbaseid":"anand-smithson-elwazeer-kotha-gruen-giles-barua-acompilerlevelintermediaterepresentationbasedbinaryanalysisandrewritingsystem-2013","downloads":0,"creationDate":"2016-10-15T13:23:23.504Z","title":"A compiler-level intermediate representation based binary analysis and rewriting system","author_short":["Anand, K.","Smithson, M.","Elwazeer, K.","Kotha, A.","Gruen, J.","Giles, N.","Barua, R."],"year":2013,"bibtype":"inproceedings","biburl":"http://bibbase.org/zotero/pentarious","bibdata":{"bibtype":"inproceedings","type":"inproceedings","title":"A compiler-level intermediate representation based binary analysis and rewriting system","abstract":"This paper presents component techniques essential for converting executables to a high-level intermediate representation (IR) of an existing compiler. The compiler IR is then employed for three distinct applications: binary rewriting using the compiler's binary back-end, vulnerability detection using source-level symbolic execution, and source-code recovery using the compiler's C backend. Our techniques enable complex high-level transformations not possible in existing binary systems, address a major challenge of input-derived memory addresses in symbolic execution and are the first to enable recovery of a fully functional source-code. We present techniques to segment the flat address space in an executable containing undifferentiated blocks of memory. We demonstrate the inadequacy of existing variable identification methods for their promotion to symbols and present our methods for symbol promotion. We also present methods to convert the physically addressed stack in an executable (with a stack pointer) to an abstract stack (without a stack pointer). Our methods do not use symbolic, relocation, or debug information since these are usually absent in deployed executables. We have integrated our techniques with a prototype x86 binary framework called SecondWrite that uses LLVM as IR. The robustness of the framework is demonstrated by handling executables totaling more than a million lines of source-code, produced by two different compilers (gcc and Microsoft Visual Studio compiler), three languages (C, C++, and Fortran), two operating systems (Windows and Linux) and a real world program (Apache server).","urldate":"2013-10-13TZ","booktitle":"Proc. of the Eighth ACM European Conf. on Computer Systems","author":[{"propositions":[],"lastnames":["Anand"],"firstnames":["Kapil"],"suffixes":[]},{"propositions":[],"lastnames":["Smithson"],"firstnames":["Matthew"],"suffixes":[]},{"propositions":[],"lastnames":["Elwazeer"],"firstnames":["Khaled"],"suffixes":[]},{"propositions":[],"lastnames":["Kotha"],"firstnames":["Aparna"],"suffixes":[]},{"propositions":[],"lastnames":["Gruen"],"firstnames":["Jim"],"suffixes":[]},{"propositions":[],"lastnames":["Giles"],"firstnames":["Nathan"],"suffixes":[]},{"propositions":[],"lastnames":["Barua"],"firstnames":["Rajeev"],"suffixes":[]}],"year":"2013","pages":"295--308","bibtex":"@inproceedings{anand_compiler-level_2013,\n\ttitle = {A compiler-level intermediate representation based binary analysis and rewriting system},\n\tabstract = {This paper presents component techniques essential for converting executables to a high-level intermediate representation (IR) of an existing compiler. The compiler IR is then employed for three distinct applications: binary rewriting using the compiler's binary back-end, vulnerability detection using source-level symbolic execution, and source-code recovery using the compiler's C backend. Our techniques enable complex high-level transformations not possible in existing binary systems, address a major challenge of input-derived memory addresses in symbolic execution and are the first to enable recovery of a fully functional source-code. We present techniques to segment the flat address space in an executable containing undifferentiated blocks of memory. We demonstrate the inadequacy of existing variable identification methods for their promotion to symbols and present our methods for symbol promotion. We also present methods to convert the physically addressed stack in an executable (with a stack pointer) to an abstract stack (without a stack pointer). Our methods do not use symbolic, relocation, or debug information since these are usually absent in deployed executables. We have integrated our techniques with a prototype x86 binary framework called SecondWrite that uses LLVM as IR. The robustness of the framework is demonstrated by handling executables totaling more than a million lines of source-code, produced by two different compilers (gcc and Microsoft Visual Studio compiler), three languages (C, C++, and Fortran), two operating systems (Windows and Linux) and a real world program (Apache server).},\n\turldate = {2013-10-13TZ},\n\tbooktitle = {Proc. of the {Eighth} {ACM} {European} {Conf}. on {Computer} {Systems}},\n\tauthor = {Anand, Kapil and Smithson, Matthew and Elwazeer, Khaled and Kotha, Aparna and Gruen, Jim and Giles, Nathan and Barua, Rajeev},\n\tyear = {2013},\n\tpages = {295--308}\n}\n\n","author_short":["Anand, K.","Smithson, M.","Elwazeer, K.","Kotha, A.","Gruen, J.","Giles, N.","Barua, R."],"key":"anand_compiler-level_2013","id":"anand_compiler-level_2013","bibbaseid":"anand-smithson-elwazeer-kotha-gruen-giles-barua-acompilerlevelintermediaterepresentationbasedbinaryanalysisandrewritingsystem-2013","role":"author","urls":{},"downloads":0},"search_terms":["compiler","level","intermediate","representation","based","binary","analysis","rewriting","system","anand","smithson","elwazeer","kotha","gruen","giles","barua"],"keywords":[],"authorIDs":[],"dataSources":["QiRZ7m7shEMvADZkd"]}