id |
ftnortheast:/neu:m044wr38j
|
record_format |
openpolar
|
spelling |
ftnortheast:/neu:m044wr38j 2023-08-20T04:10:08+02:00 Defending in-process memory abuse with mitigation and testing http://hdl.handle.net/2047/D20328773 unknown http://hdl.handle.net/2047/D20328773 ftnortheast 2023-07-29T22:34:06Z Modern softwares often include large code bases from different origins with different trust levels. This creates a large attack surface and raises security concerns that sensitive information of one component is directly accessible by other (malicious or manipulated) components in memory. In this thesis, I refer to this problem as in-process memory abuse. Despite the prevalence of in-process abuses, the defense mechanisms are not well studied, due to the complex root causes and attack surfaces of such attacks. First of all, a large amount of the existing software is written in type-unsafe languages such as C and C++. Such languages are notorious for being error-prone. These programming errors have incurred countless high-severity security bugs that lead to in-process memory attacks. Secondly, contemporary defenses such as data execution prevention (DEP) and address space layout randomization (ASLR) have little effect on preventing in-process memory attacks. Last but not least, developers are often helpless when they are trying to protect their sensitive data, due to the lack of operating system support to create boundaries within the same process context. As a result, as long as one of the many components is successfully exploited, the whole program's sensitive data and code are subject to abuse. A common belief is that in-process abuse cannot be defended without high-overhead or loss of backward compatibility. To reduce memory corruption bugs, options like formally verifying every software or rewriting the whole software stack with type safe language is impractical, due to the poor scalability of formal verification methods and the immense engineering cost required to rebuild all existing software infrastructures. To prevent exploitations of memory corruption bugs, one may suggest adopting full memory safety by bound checking all the pointers and tracking the liveness of every allocated memory objects. However, this comes with intolerable overheads. Lastly, existing work proposes rewriting established operating ... Other/Unknown Material The Pointers Northeastern University, Boston: DRS - Digital Repository Service
|
institution |
Open Polar
|
collection |
Northeastern University, Boston: DRS - Digital Repository Service
|
op_collection_id |
ftnortheast
|
language |
unknown
|
description |
Modern softwares often include large code bases from different origins with different trust levels. This creates a large attack surface and raises security concerns that sensitive information of one component is directly accessible by other (malicious or manipulated) components in memory. In this thesis, I refer to this problem as in-process memory abuse. Despite the prevalence of in-process abuses, the defense mechanisms are not well studied, due to the complex root causes and attack surfaces of such attacks. First of all, a large amount of the existing software is written in type-unsafe languages such as C and C++. Such languages are notorious for being error-prone. These programming errors have incurred countless high-severity security bugs that lead to in-process memory attacks. Secondly, contemporary defenses such as data execution prevention (DEP) and address space layout randomization (ASLR) have little effect on preventing in-process memory attacks. Last but not least, developers are often helpless when they are trying to protect their sensitive data, due to the lack of operating system support to create boundaries within the same process context. As a result, as long as one of the many components is successfully exploited, the whole program's sensitive data and code are subject to abuse. A common belief is that in-process abuse cannot be defended without high-overhead or loss of backward compatibility. To reduce memory corruption bugs, options like formally verifying every software or rewriting the whole software stack with type safe language is impractical, due to the poor scalability of formal verification methods and the immense engineering cost required to rebuild all existing software infrastructures. To prevent exploitations of memory corruption bugs, one may suggest adopting full memory safety by bound checking all the pointers and tracking the liveness of every allocated memory objects. However, this comes with intolerable overheads. Lastly, existing work proposes rewriting established operating ...
|
title |
Defending in-process memory abuse with mitigation and testing
|
spellingShingle |
Defending in-process memory abuse with mitigation and testing
|
title_short |
Defending in-process memory abuse with mitigation and testing
|
title_full |
Defending in-process memory abuse with mitigation and testing
|
title_fullStr |
Defending in-process memory abuse with mitigation and testing
|
title_full_unstemmed |
Defending in-process memory abuse with mitigation and testing
|
title_sort |
defending in-process memory abuse with mitigation and testing
|
url |
http://hdl.handle.net/2047/D20328773
|
genre |
The Pointers
|
genre_facet |
The Pointers
|
op_relation |
http://hdl.handle.net/2047/D20328773
|
_version_ |
1774724115539689472
|