Compiler optimizations to reduce security overhead

In this work, we present several compiler optimizations to reduce the overhead due to software protection. We first propose an aggressive rematerialization algorithm which attempts to maximally realize non-trusted values from other trusted values thereby avoiding the security cost for those non-trusted values. We further propose a compiler technique to utilize the secure storage in our machine model efficiently. To optimize the security cost on data that has to be stored in non-trusted storage, we propose a data grouping technique. Security operations can be performed over the group of data instead of over each piece separately. We show an interesting application of the data grouping technique to reduce the security cost. We test the effectiveness of our optimizations on a recently proposed software protection scheme that involves large overhead. Our results show that the above optimizations are effective and reduce the security overhead significantly.

[1]  Dan Boneh,et al.  Architectural support for copy and tamper resistant software , 2000, SIGP.

[2]  Mahmut T. Kandemir,et al.  A compiler-based approach for dynamically managing scratch-pad memories in embedded systems , 2004, IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems.

[3]  Monica S. Lam,et al.  Efficient context-sensitive pointer analysis for C programs , 1995, PLDI '95.

[4]  Adi Shamir,et al.  How to share a secret , 1979, CACM.

[5]  Ken Kennedy,et al.  Improving cache performance in dynamic applications through data and computation reorganization at run time , 1999, PLDI '99.

[6]  Keith D. Cooper,et al.  Compiler-controlled memory , 1998, ASPLOS VIII.

[7]  Josep Llosa Espuny Reducing the impact of register pressure on software pipelined loops , 1996 .

[8]  Yunheung Paek,et al.  Efficient and precise array access analysis , 2002, TOPL.

[9]  Eugene W. Myers,et al.  A precise inter-procedural data flow algorithm , 1981, POPL '81.

[10]  Tao Zhang,et al.  Building intrusion-tolerant secure software , 2005, International Symposium on Code Generation and Optimization.

[11]  Gao Song Reducing Register Pressure Through LAER Algorithm , 2004, ACSC.

[12]  Keith D. Cooper,et al.  Improvements to graph coloring register allocation , 1994, TOPL.

[13]  Mary Hall Managing interprocedural optimization , 1992 .

[14]  Miodrag Potkonjak,et al.  MediaBench: a tool for evaluating and synthesizing multimedia and communications systems , 1997, Proceedings of 30th Annual International Symposium on Microarchitecture.

[15]  G. Edward Suh,et al.  Caches and hash trees for efficient memory integrity verification , 2003, The Ninth International Symposium on High-Performance Computer Architecture, 2003. HPCA-9 2003. Proceedings..

[16]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[17]  Ken Kennedy,et al.  Optimizing Compilers for Modern Architectures: A Dependence-based Approach , 2001 .

[18]  William Pugh,et al.  A practical algorithm for exact array dependence analysis , 1992, CACM.

[19]  Gregory J. Chaitin,et al.  Register allocation and spilling via graph coloring , 2004, SIGP.

[20]  Seth D. Bergmann,et al.  Compilers , 1973, CSC '73.

[21]  Rajiv Gupta,et al.  Register Pressure Sensitive Redundancy Elimination , 1999, CC.

[22]  Erik Brockmeyer,et al.  Data reuse analysis technique for software-controlled memory hierarchies , 2004, Proceedings Design, Automation and Test in Europe Conference and Exhibition.

[23]  G. G. Stokes "J." , 1890, The New Yale Book of Quotations.

[24]  John M. Mellor-Crummey,et al.  FIAT: A Framework for Interprocedural Analysis and Transfomation , 1993, LCPC.

[25]  Todd M. Austin,et al.  The SimpleScalar tool set, version 2.0 , 1997, CARN.

[26]  Andrew W. Appel,et al.  Optimal spilling for CISC machines with few registers , 2001, PLDI '01.

[27]  Josep Llosa,et al.  Reducing The Impact Of Register Pressure On Software Pipelined Loops , 1996 .