Return to Where? You Can't Exploit What You Can't Find
暂无分享,去创建一个
Per Larsen | Ahmad-Reza Sadeghi | Michael Franz | Lucas Davi | Andrei Homescu | Christopher Liebchen | Stephen Crane | Stefan Brunthaler
[1] Kevin W. Hamlen,et al. Binary stirring: self-randomizing instruction addresses of legacy x86 binary code , 2012, CCS.
[2] Angelos D. Keromytis,et al. Transparent ROP Exploit Mitigation Using Indirect Branch Tracing , 2013, USENIX Security Symposium.
[3] Frank Piessens,et al. Breaking the memory secrecy assumption , 2009, EUROSEC '09.
[4] Ahmad-Reza Sadeghi,et al. Gadge me if you can: secure and efficient ad-hoc instruction-level randomization for x86 and ARM , 2013, ASIA CCS '13.
[5] Daniel C. DuVarney,et al. Efficient Techniques for Comprehensive Protection from Memory Error Exploits , 2005, USENIX Security Symposium.
[6] Ahmad-Reza Sadeghi,et al. Just-In-Time Code Reuse: On the Effectiveness of Fine-Grained Address Space Layout Randomization , 2013, 2013 IEEE Symposium on Security and Privacy.
[7] Per Larsen,et al. Opaque Control-Flow Integrity , 2015, NDSS.
[8] Hovav Shacham,et al. Return-Oriented Programming: Systems, Languages, and Applications , 2012, TSEC.
[9] Michael Backes,et al. You Can Run but You Can't Read: Preventing Disclosure Exploits in Executable Code , 2014, CCS.
[10] Robert H. Deng,et al. ROPecker: A Generic and Practical Approach For Defending Against ROP Attacks , 2014, NDSS.
[11] Mihai Budiu,et al. Control-flow integrity principles, implementations, and applications , 2009, TSEC.
[12] Peng Ning,et al. HideM: Protecting the Contents of Userspace Memory in the Face of Disclosure Vulnerabilities , 2015, CODASPY.
[13] Sorin Lerner,et al. SafeDispatch: Securing C++ Virtual Calls from Memory Corruption Attacks , 2014, NDSS.
[14] Hovav Shacham,et al. The geometry of innocent flesh on the bone: return-into-libc without function calls (on the x86) , 2007, CCS '07.
[15] Vikram S. Adve,et al. LLVM: a compilation framework for lifelong program analysis & transformation , 2004, International Symposium on Code Generation and Optimization, 2004. CGO 2004..
[16] Ben Niu,et al. RockJIT: Securing Just-In-Time Compilation Using Modular Control-Flow Integrity , 2014, CCS.
[17] George Candea,et al. Code-pointer integrity , 2014, OSDI.
[18] Michael Backes,et al. Oxymoron: Making Fine-Grained Memory Randomization Practical by Allowing Code Sharing , 2014, USENIX Security Symposium.
[19] Herbert Bos,et al. Out of Control: Overcoming Control-Flow Integrity , 2014, 2014 IEEE Symposium on Security and Privacy.
[20] Chao Zhang,et al. Exploiting and Protecting Dynamic Code Generation , 2015, NDSS.
[21] Peng Ning,et al. Address Space Layout Permutation (ASLP): Towards Fine-Grained Randomization of Commodity Software , 2006, 2006 22nd Annual Computer Security Applications Conference (ACSAC'06).
[22] Mingwei Zhang,et al. Control Flow Integrity for COTS Binaries , 2013, USENIX Security Symposium.
[23] Per Larsen,et al. Librando: transparent code randomization for just-in-time compilers , 2013, CCS.
[24] Úlfar Erlingsson,et al. Enforcing Forward-Edge Control-Flow Integrity in GCC & LLVM , 2014, USENIX Security Symposium.
[25] Ahmad-Reza Sadeghi,et al. Isomeron: Code Randomization Resilient to (Just-In-Time) Return-Oriented Programming , 2015, NDSS.
[26] Hovav Shacham,et al. Return-oriented programming without returns , 2010, CCS '10.
[27] David A. Wagner,et al. ROP is Still Dangerous: Breaking Modern Defenses , 2014, USENIX Security Symposium.
[28] Per Larsen,et al. Booby trapping software , 2013, NSPW '13.
[29] Thorsten Holz,et al. Towards automated integrity protection of C++ virtual function tables in binary programs , 2014, ACSAC.
[30] Moritz Contag,et al. Evaluating the Effectiveness of Current Anti-ROP Defenses , 2014, RAID.
[31] Helen J. Wang,et al. SubVirt: implementing malware with virtual machines , 2006, 2006 IEEE Symposium on Security and Privacy (S&P'06).
[32] Heng Yin,et al. vfGuard: Strict Protection for Virtual Function Calls in COTS C++ Binaries , 2015, NDSS.
[33] Per Larsen,et al. SoK: Automated Software Diversity , 2014, 2014 IEEE Symposium on Security and Privacy.
[34] Dawn Xiaodong Song,et al. SoK: Eternal War in Memory , 2013, 2013 IEEE Symposium on Security and Privacy.
[35] Cristiano Giuffrida,et al. Enhanced Operating System Security Through Efficient and Fine-grained Address Space Randomization , 2012, USENIX Security Symposium.
[36] Ahmad-Reza Sadeghi,et al. Counterfeit Object-oriented Programming: On the Difficulty of Preventing Code Reuse Attacks in C++ Applications , 2015, 2015 IEEE Symposium on Security and Privacy.
[37] John L. Henning. SPEC CPU2006 memory footprint , 2007, CARN.
[38] Jack W. Davidson,et al. ILR: Where'd My Gadgets Go? , 2012, 2012 IEEE Symposium on Security and Privacy.
[39] Zhenkai Liang,et al. Jump-oriented programming: a new class of code-reuse attack , 2011, ASIACCS '11.
[40] Jeff Seibert,et al. Information Leaks Without Memory Disclosures: Remote Side Channel Attacks on Diversified Code , 2014, CCS.
[41] Ahmad-Reza Sadeghi,et al. Stitching the Gadgets: On the Ineffectiveness of Coarse-Grained Control-Flow Integrity Protection , 2014, USENIX Security Symposium.
[42] David H. Ackley,et al. Building diverse computer systems , 1997, Proceedings. The Sixth Workshop on Hot Topics in Operating Systems (Cat. No.97TB100133).
[43] Thomas R. Gross,et al. CAIN: Silently Breaking ASLR in the Cloud , 2015, WOOT.
[44] Chao Zhang,et al. Practical Control Flow Integrity and Randomization for Binary Executables , 2013, 2013 IEEE Symposium on Security and Privacy.
[45] Angelos D. Keromytis,et al. Smashing the Gadgets: Hindering Return-Oriented Programming Using In-place Code Randomization , 2012, 2012 IEEE Symposium on Security and Privacy.
[46] Frederick B. Cohen,et al. Operating system protection through program evolution , 1993, Comput. Secur..
[47] Martín Abadi,et al. A Theory of Secure Control Flow , 2005, ICFEM.
[48] Herbert Bos,et al. Size Does Matter: Why Using Gadget-Chain Length to Prevent Code-Reuse Attacks is Hard , 2014, USENIX Security Symposium.
[49] ErlingssonÚlfar,et al. Language-independent sandboxing of just-in-time compilation and self-modifying code , 2011 .
[50] Martín Abadi,et al. Control-flow integrity , 2005, CCS '05.
[51] Dan Boneh,et al. Hacking Blind , 2014, 2014 IEEE Symposium on Security and Privacy.
[52] Stelios Sidiroglou,et al. Missing the Point(er): On the Effectiveness of Code Pointer Integrity , 2015, 2015 IEEE Symposium on Security and Privacy.