StackVault: Protection from Untrusted Functions

@article{Zhang2020StackVaultPF,
  title={StackVault: Protection from Untrusted Functions},
  author={Qi Zhang and Zehra Sura and Ashish Kundu and Gong Su and Arun Iyengar and Ling Liu},
  journal={2020 Second IEEE International Conference on Trust, Privacy and Security in Intelligent Systems and Applications (TPS-ISA)},
  year={2020},
  pages={294-306}
}
  • Qi ZhangZehra Sura Ling Liu
  • Published 8 July 2019
  • Computer Science
  • 2020 Second IEEE International Conference on Trust, Privacy and Security in Intelligent Systems and Applications (TPS-ISA)
Data exfiltration attacks have led to huge data breaches. Recently, the Equifax attack affected 147M users and a third party library - Apache Struts - was alleged to be responsible for it. These attacks often exploit the fact that sensitive data are stored unencrypted in process memory and can be accessed by any function executing within the same process, including untrusted third party library functions.This paper presents StackVault, a kernel-based system to prevent sensitive stack-based data… 
1 Citations

Figures and Tables from this paper

Edge Security: Challenges and Issues

The security threats and vulnerabilities emerging from the edge network architecture spanning from the hardware layer to the system layer are discussed and the need for a holistic approach to analyze edge network security posture is argued, which must consider knowledge from each layer.

References

SHOWING 1-10 OF 46 REFERENCES

UniSan: Proactive Kernel Memory Initialization to Eliminate Data Leakages

UniSan is proposed, a novel, compiler-based approach to eliminate all information leaks caused by uninitialized read in the OS kernel, and can successfully prevent 43 known and many new uninitialized data leak vulnerabilities.

StackArmor: Comprehensive Protection From Stack-based Memory Error Vulnerabilities for Binaries

An implementation of StackArmor for x86 64 Linux is presented and a detailed experimental analysis of the prototype is provided to demonstrate that StackArmor offers better security than prior binary and source-level approaches, at the cost of only modest performance and memory overhead even with full protection.

SafeDispatch: Securing C++ Virtual Calls from Memory Corruption Attacks

This paper presents SAFEDISPATCH, a novel defense to prevent vtable hijacking by statically analyzing C++ programs and inserting sufficient runtime checks to ensure that control flow at virtual method call sites cannot be arbitrarily influenced by an attacker.

Transparent Runtime Shadow Stack : Protection against malicious return address modifications

This paper introduces the use of a T ransparent RUntime Shadow Stack (TRUSS) to protect against function return address modification and discusses the implementation details of the scheme as well as provides a performance evaluation.

Shreds: Fine-Grained Execution Units with Private Memory

Shreds, a set of OS-backed programming primitives that addresses developers' currently unmet needs for fine-grained, convenient, and efficient protection of sensitive memory content against in-process adversaries, is proposed.

Breaking the memory secrecy assumption

This paper identifies a new class of vulnerabilities -- buffer overreads -- that occur in practice and that can be exploited to read parts of the memory contents of a process running a vulnerable application.

Comprehensively and efficiently protecting the heap

Through existing virtual memory and inter-process protection mechanisms, Heap Server prevents the heap meta-data from being illegally overwritten, and heap data from being meaningfully overwritten and verified against several real-world exploits and attack kernels.

HeapSentry: Kernel-Assisted Protection against Heap Overflows

HeapSentry is a system designed to detect and stop heap overflow attacks through the cooperation of the memory allocation library of a program and the operating system's kernel, and provides stronger security guarantees than the current state of the art in heap protection mechanisms for a modest performance overhead.

Samurai: protecting critical data in unsafe languages

This work presents a data-centric solution to memory corruption called critical memory, a memory model that allows programmers to identify and protect data that is critical for correct program execution, and presents Samurai, a runtime system that implements critical memory in software.

KCoFI: Complete Control-Flow Integrity for Commodity Operating System Kernels

A subset of KCoFI's design is formally verified by modeling several features in small-step semantics and providing a partial proof that the semantics maintain control-flow integrity, and the overheads are far lower than heavyweight memory-safety techniques.