Practical Integrity Protection with Oblivious Hashing

Ahmadvand, Mohsen; Hayrapetyan, Anahit; Bănescu, Sebastian; Pretschner, Alexander

doi:10.1145/3274694.3274732

Cited by 6 publications

(16 citation statements)

References 38 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…That is, if an SC protection is to be developed as a compiler pass, the expected hashes need to be adjusted once the binary representation of the program is finalized. For this purpose usually placeholders along with post-patching mechanisms are utilized [1]. Alternatively, a backend pass (similar to the one described in [25]) can be used to adjust placeholders.…”

Section: Self-checksumming (Sc)mentioning

confidence: 99%

See 1 more Smart Citation

VirtSC

Ahmadvand

Below

Bănescu

et al. 2019

Proceedings of the 3rd ACM Workshop on Software Protection

Self Cite

View full text Add to dashboard Cite

Self-checksumming (SC) is a tamper-proofing technique that ensures certain program segments (code) in memory hash to known values at runtime. SC has few restrictions on application and hence can protect a vast majority of programs. The code verification in SC requires computation of the expected hashes after compilation, as the machine-code is not known before. This means the expected hash values need to be adjusted in the binary executable, hence combining SC with other protections is limited due to this adjustment step. However, obfuscation protections are often necessary, as SC protections can be otherwise easily detected and disabled via pattern matching. In this paper, we present a layered protection using virtualization obfuscation, yielding an architecture-agnostic SC protection that requires no post-compilation adjustment. We evaluate the performance of our scheme using a dataset of 25 realworld programs (MiBench and 3 CLI games). Our results show that the SC scheme induces an average overhead of 43% for a complete protection (100% coverage). The overhead is tolerable for less CPUintensive programs (e.g. games) and when only parts of programs (e.g. license checking) are protected. However, large overheads stemming from the virtualization obfuscation were encountered. CCS CONCEPTS• Security and privacy → Software security engineering;

show abstract

Section: Self-checksumming (Sc)mentioning

confidence: 99%

“…Furthermore, SC guards are susceptible to pattern matching attacks [1,2,5]. Therefore, without proper utilization of obfuscations, SC is rather easily identifiable, and perhaps defeatable.…”

Section: Self-checksumming (Sc)mentioning

confidence: 99%

VirtSC

Ahmadvand

Below

Bănescu

et al. 2019

Proceedings of the 3rd ACM Workshop on Software Protection

Self Cite

View full text Add to dashboard Cite

show abstract

“…However, we believe random selection is unrealistic. In practice, compositions rather use some heuristics [2]. In order to capture possible improvements, we resort to a heuristicbased composition of SC and OH/SROH (presented in [2]) as our baseline.…”

Section: Performancementioning

confidence: 99%

“…In practice, compositions rather use some heuristics [2]. In order to capture possible improvements, we resort to a heuristicbased composition of SC and OH/SROH (presented in [2]) as our baseline. Our aim is to measure the overhead difference between the optimized composition versus the heuristic one.…”

Section: Performancementioning

confidence: 99%

“…Furthermore, protections have different capabilities when it comes to protecting program assets. For instance, OH is unable to protect nondeterministic program segments, while SC does not have such a restriction [2]. Moreover, the locality of the checks can have a arXiv:1909.11401v1 [cs.CR] 25 Sep 2019 huge impact on the imposed overhead [9].…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

SIP shaker

Ahmadvand

Fischer

Bănescu

2019

Proceedings of the 35th Annual Computer Security Applications Conference

Self Cite

View full text Add to dashboard Cite

Man-At-The-End (MATE) attackers are almighty adversaries against whom there exists no silver-bullet countermeasure. To raise the bar, a wide range of protection measures were proposed in the literature each of which adds resilience against certain attacks on certain digital assets of a program. Intuitively, composing a set of protections (rather than applying just one of them) can mitigate a wider range of attacks and hence offer a higher level of security. Despite the potential benefits, very limited research has been done on the composition of protections. Naive compositions could lead to conflicts which, in turn, limit the application of protections, raise false alarms, and worse yet, yield corrupted binaries. More importantly, inadequate compositions of such protections are not tailored for the program at hand and thus the offered security and performance are sub-optimal. In this paper, we first lay out a set of generic constraints for a conflict-free composition of protections. Then, we develop a composition framework based on a defense graph in which nodes and edges capture protections, their relations, and constraints. The conflicts problem together with optimization requirements are then translated into a set of integer constraints. We then use Integer Linear Programming (ILP) to handle conflicts while optimizing for a higher security and lower overhead. To measure the overhead, we use a set of real-world programs (MiBench dataset and open source games). Our evaluation results indicate that our composition framework reduces the overhead by ≈ 39% while maximizing the coverage. Moreover, our approach yields a 5-fold decrease in overhead compared to state-of-the-art heuristics.

show abstract

DG: Analysis and Slicing of LLVM Bitcode

Chalupa

2020

Automated Technology for Verification and Analysis

View full text Add to dashboard Cite

Practical Integrity Protection with Oblivious Hashing

Cited by 6 publications

References 38 publications

VirtSC

VirtSC

SIP shaker

DG: Analysis and Slicing of LLVM Bitcode

Contact Info

Product

Resources

About