[ slides, video, video (french subtitles) ] Pursuing Durably Safe Systems Software (SSTIC 2020)
[ slides ] Trends and challenges in the vulnerability mitigation landscape (WOOT 2019)
[ slides, video ] Trends, challenges, and strategic shifts in the software vulnerability mitigation landscape (BlueHat Israel 2019)
[ video ] CppCon 2018: Closing Panel: Spectre (CppCon 2018)
[ video ] CppCon 2018: Software Security Panel (CppCon 2018)
[ slides ] Toward mitigating arbitrary native code execution in Windows 10 (SyScan 360 Seattle)
[ slides ] Microsoft's strategy and technology improvements toward mitigating arbitrary native code execution (CanSecWest 2017), with David Weston.
[ slides, video ] Windows 10 mitigation improvements (BlackHat 2016), with David Weston.
[ slides ] Modeling the exploitation and mitigation of memory safety vulnerabilities (Breakpoint 2012).
[ slides, video ] Exploit mitigation improvements in Windows 8 (BlackHat USA 2012), with Skywing.
[ slides ] Targeted taint driven fuzzing using software metrics (CanSecWest 2011), with Dustin Duran and David Weston.
[ slides ] The Evolution of Microosft's Exploit Mitigations: Past, Present, and Future (CanSecWest 2009), with Tim Burrell.
[ video ] The Evolution of Microsoft's Exploit Mitigations (Blue Hat Fall 2008)
[ slides ] Avoiding Driver Security Pitfalls (DDC 2008)
[ slides ] Modeling the trust boundaries created by securable objects (WOOT 2008)
[ slides ] State of the Exploit (Seattle ToorCon 2008)
[ slides ] A Brief History of Exploitation Techniques and Mitigations on Windows (BreakPoint 2007)
[ slides ] Cthulhu: A software analysis framework built on Phoenix (ToorCon 2007)
[ slides, video ] Exploitation Chronomancy (ToorCon 2005 and BlueHat 2005)
[ slides, video ] Beyond EIP (Black Hat USA 2005), with spoonm.
Security analysis of memory tagging (Mar, 2020)
Using dual-mappings to evade automated unpackers (Oct, 2008)
Automated unpackers such as Renovo, Saffron, and Pandora's Bochs
attempt to dynamically unpack executables by detecting the execution of code
from regions of virtual memory that have been written to. While this is an
elegant method of detecting dynamic code execution, it is possible to evade
these unpackers by dual-mapping physical pages to two distinct virtual address
regions where one region is used as an editable mapping and the second region
is used as an executable mapping. In this way, the editable mapping is
written to during the unpacking process and the executable mapping is used to
execute the unpacked code dynamically. This effectively evades automated
unpackers which rely on detecting the execution of code from virtual addresses
that have been written to.
Modeling the trust boundaries created by securable objects (Jul, 2008)
One of the most critical steps of any security review involves identifying the trust boundaries that an application is exposed to. While methodologies such as threat modeling can be used to help obtain this understanding from an application's design, it can be difficultcult to accurately map this understanding to an application's implementation. This difficultculty suggests that there is a need for techniques that can be used to gain a better understanding of the trust boundaries that exist within an application's implementation.
To help address this problem, this paper describes a technique that can be used to model the trust boundaries that are created by securable objects on Windows. Dynamic instrumentation is used to generate object trace logs which describe the contexts in which securable objects are defned, used, and have their security descriptor updated. This information is used to identify the data flows that are permitted by the access rights granted to securable objects. It is then shown how these data flows can be analyzed to gain an understanding of the trust boundaries, threats, and potential elevation paths that exist within a given system.
Improving Software Security Analysis using Exploitation Properties (Dec, 2007)
Reliable exploitation of software vulnerabilities has continued to
become more difficult as formidable mitigations have been established
and are now included by default with most modern operating systems.
Future exploitation of software vulnerabilities will rely on either
discovering ways to circumvent these mitigations or uncovering flaws
that are not adequately protected. Since the majority of the mitigations
that exist today lack universal bypass techniques, it has become more
fruitful to take the latter approach. It is in this vein that this paper
introduces the concept of exploitation properties and describes how they
can be used to better understand the exploitability of a system
irrespective of a particular vulnerability. Perceived exploitability is
of utmost importance to both an attacker and to a defender given the
presence of modern mitigations. The ANI vulnerability (MS07-017) is used
to help illustrate these points by acting as a simple example of a
vulnerability that may have been more easily identified as code that
should have received additional scrutiny by taking exploitation
properties into consideration.
A Catalog of Local Windows Kernel-mode Backdoor Techniques (Aug, 2007)
This paper presents a detailed catalog of techniques that can be used to
create local kernel-mode backdoors on Windows. These techniques include
function trampolines, descriptor table hooks, model-specific register
hooks, page table modifications, as well as others that have not
previously been described. The majority of these techniques have been
publicly known far in advance of this paper. However, at the time of
this writing, there appears to be no detailed single point of reference
for many of them. The intention of this paper is to provide a solid
understanding on the subject of local kernel-mode backdoors. This
understanding is necessary in order to encourage the thoughtful
discussion of potential countermeasures and perceived advancements.
In the vein of countermeasures, some additional thoughts are given to
the common misconception that PatchGuard, in its current design, can
be used to prevent kernel-mode rootkits.
Generalizing Data Flow Information (Aug, 2007)
Generalizing information is a common method of reducing the quantity of
data that must be considered during analysis. This fact has been
plainly illustrated in relation to static data flow analysis where
previous research has described algorithms that can be used to
generalize data flow information. These generalizations have helped
support more optimal data flow analysis in certain situations. In the
same vein, this paper describes a process that can be employed to
generalize and persist data flow information along multiple
generalization tiers. Each generalization tier is meant to describe the
data flow behaviors of a conceptual software element such as an
instruction, a basic block, a procedure, a data type, and so on. This
process makes use of algorithms described in previous literature to
support the generalization of data flow information. To illustrate the
usefulness of the generalization process, this paper also presents an
algorithm that can be used to determine reachability at each
generalization tier. The algorithm determines reachability starting
from the least specific generalization tier and uses the set of
reachable paths found to progressively qualify data flow information for
each successive generalization tier. This helps to constrain the amount
of data flow information that must be considered to a minimal subset.
Memalyze: Dynamic
Analysis of Memory Access Behavior in Software (Apr, 2007)
This paper describes strategies for dynamically analyzing an
application's memory access behavior. These strategies make it possible
to detect when a read or write is about to occur at a given location in
memory while an application is executing. An application's memory
access behavior can provide additional insight into its behavior. For
example, it may be able to provide an idea of how data propagates
throughout the address space. Three individual strategies which can be
used to intercept memory accesses are described in this paper. Each
strategy makes use of a unique method of intercepting memory accesses.
These methods include the use of Dynamic Binary Instrumentation (DBI),
x86 hardware paging features, and x86 segmentation features. A detailed
description of the design and implementation of these strategies for
32-bit versions of Windows is given. Potential uses for these analysis
techniques are described in detail.
Reducing the Effective
Entropy of GS Cookies (Mar, 2007)
This paper describes a technique that can be used to reduce the
effective entropy in a given GS cookie by roughly 15 bits. This
reduction is made possible because GS uses a number of weak entropy
sources that can, with varying degrees of accuracy, be calculated by an
attacker. It is important to note, however, that the ability to
calculate the values of these sources for an arbitrary cookie currently
relies on an attacker having local access to the machine, such as
through the local console or through terminal services. This
effectively limits the use of this technique to stack-based local
privilege escalation vulnerabilities. In addition to the general
entropy reduction technique, this paper discusses the amount of
effective entropy that exists in services that automatically start
during system boot. It is hypothesized that these services may have
more predictable states of entropy due to the relative consistency of
the boot process. While the techniques described in this paper do not
illustrate a complete break of GS, any inherent weakness can have
disastrous consequences given that GS is a static, compile-time security
solution. It is not possible to simply distribute a patch. Instead,
applications must be recompiled to take advantage of any security
improvements. In that vein, the paper proposes some solutions that
could be applied to address the problems that are outlined.
Locreate: An Anagram
for Relocate (Dec, 2006)
This paper presents a proof of concept executable packer that does not
use any custom code to unpack binaries at execution time. This is
different from typical packers which generally rely on packed
executables containing code that is used to perform the inverse of the
packing operation at runtime. Instead of depending on custom code, the
technique described in this paper uses documented behavior of the
dynamic loader as a mechanism for performing the unpacking operation.
This difference can make binaries packed using this technique more
difficult to signature and analyze, but only when presented to an
untrained eye. The description of this technique is meant to be an
example of a fun thought exercise and not as some sort of revolutionary
packer. In fact, it's been used in the virus world many years prior to
this paper.
Exploiting 802.11
Wireless Driver Vulnerabilities on Windows (Nov, 2006)
This paper describes the process of identifying and exploiting 802.11
wireless device driver vulnerabilities on Windows. This process is
described in terms of two steps: pre-exploitation and exploitation. The
pre-exploitation step provides a basic introduction to the 802.11
protocol along with a description of the tools and libraries the authors
used to create a basic 802.11 protocol fuzzer. The exploitation step
describes the common elements of an 802.11 wireless device driver
exploit. These elements include things like the underlying payload
architecture that is used when executing arbitrary code in kernel-mode
on Windows, how this payload architecture has been integrated into the
3.0 version of the Metasploit Framework, and the interface that the
Metasploit Framework exposes to make developing 802.11 wireless device
driver exploits easy. Finally, three separate real world wireless
device driver vulnerabilities are used as case studies to illustrate the
application of this process. It is hoped that the description and
illustration of this process can be used to show that kernel-mode
vulnerabilities can be just as dangerous and just as easy to exploit as
user-mode vulnerabilities. In so doing, awareness of the need for more
robust kernel-mode exploit prevention technology can be raised.
Preventing the
Exploitation of SEH Overwrites (Sep, 2006)
This paper proposes a technique that can be used to prevent
the exploitation of SEH overwrites on 32-bit Windows applications
without requiring any recompilation. While Microsoft has attempted to
address this attack vector through changes to the exception dispatcher
and through enhanced compiler support, such as with /SAFESEH and /GS,
the majority of benefits they offer are limited to image files that have
been compiled to make use of the compiler enhancements. This limitation
means that without all image files being compiled with these
enhancements, it may still be possible to leverage an SEH overwrite to
gain code execution. In particular, many third-party applications are
still vulnerable to SEH overwrites even on the latest versions of
Windows because they have not been recompiled to incorporate these
enhancements. To that point, the technique described in this paper does
not rely on any compile time support and instead can be applied at
runtime to existing applications without any noticeable performance
degradation. This technique is also backward compatible with all
versions of Windows NT+, thus making it a viable and proactive solution
for legacy installations.
Implementing a Custom
x86 Encoder (Aug, 2006)
This paper describes the process of implementing a custom
encoder for the x86 architecture. To help set the stage, the McAfee
Subscription Manager ActiveX control vulnerability, which was discovered
by eEye, will be used as an example of a vulnerability that requires the
implementation of a custom encoder. In particular, this vulnerability
does not permit the use of uppercase characters. To help make things
more interesting, the encoder described in this paper will also avoid
all characters above 0x7f. This will make the encoder both UTF-8 safe
and tolower safe.
Exploiting the
Otherwise Non-exploitable on Windows (May, 2006)
This paper describes a technique that can be applied in certain
situations to gain arbitrary code execution through software bugs that
would not otherwise be exploitable, such as NULL pointer dereferences.
To facilitate this, an attacker gains control of the top-level unhandled
exception filter for a process in an indirect fashion. While there has
been previous work illustrating the usefulness in gaining control
of the top-level unhandled exception filter, Microsoft has taken steps
in XPSP2 and beyond, such as function pointer encoding[4], to prevent
attackers from being able to overwrite and control the unhandled
exception filter directly. While this security enhancement is a marked
improvement, it is still possible for an attacker to gain control of the
top-level unhandled exception filter by taking advantage of a design
flaw in the way unhandled exception filters are chained. This approach,
however, is limited by an attacker's ability to control the chaining of
unhandled exception filters, such as through the loading and unloading
of DLLs. This does reduce the global impact of this approach; however,
there are some interesting cases where it can be immediately applied,
such as with Internet Explorer.
Improving Automated
Analysis of Windows x64 Binaries (Apr, 2006)
As Windows x64 becomes a more prominent platform, it will
become necessary to develop techniques that improve the binary analysis
process. In particular, automated techniques that can be performed
prior to doing code or data flow analysis can be useful in getting a
better understanding for how a binary operates. To that point, this
paper gives a brief explanation of some of the changes that have been
made to support Windows x64 binaries. From there, a few basic
techniques are illustrated that can be used to improve the process of
identifying functions, annotating their stack frames, and describing
their exception handler relationships. Source code to an example IDA
plugin is also included that shows how these techniques can be
implemented.
Bypassing PatchGuard on
Windows x64 (Dec, 2005)
The Windows kernel that runs on the x64 platform has introduced a new
feature, nicknamed PatchGuard, that is intended to prevent both
malicious software and third-party vendors from modifying certain
critical operating system structures. These structures include things
like specific system images, the SSDT, the IDT, the GDT, and certain
critical processor MSRs. This feature is intended to ensure kernel
stability by preventing uncondoned behavior, such as hooking. However,
it also has the side effect of preventing legitimate products from
working properly. For that reason, this paper will serve as an in-depth
analysis of PatchGuard's inner workings with an eye toward techniques
that can be used to bypass it. Possible solutions will also be proposed
for the bypass techniques that are suggested.
Windows Kernel-mode
Payload Fundamentals (Dec, 2005)
This paper discusses the theoretical and practical implementations of
kernel-mode payloads on Windows. At the time of this writing,
kernel-mode research is generally regarded as the realm of a few, but it
is hoped that documents such as this one will encourage a thoughtful
progression of the subject matter. To that point, this paper will
describe some of the general techniques and algorithms that may be
useful when implementing kernel-mode payloads. Furthermore, the anatomy
of a kernel-mode payload will be broken down into four distinct units,
known as payload components, and explained in detail. In the end, the
reader should walk away with a concrete understanding of the way in
which kernel-mode payloads operate on Windows.
Bypassing Windows
Hardware-enforced Data Execution Prevention (Oct, 2005)
This paper describes a technique that can be used to bypass Windows
hardware-enforced Data Execution Prevention (DEP) on default
installations of Windows XP Service Pack 2 and Windows 2003 Server
Service Pack 1. This technique makes it possible to execute code from
regions that are typically non-executable when hardware support is
present, such as thread stacks and process heaps. While other techniques
have been used to accomplish similar feats, such as returning into
NtProtectVirtualMemory, this approach requires no direct reprotecting of
memory regions, no copying of arbitrary code to other locations, and
does not have issues with NULL bytes. The result is a feasible approach
that can be used to easily bypass the enhancements offered by
hardware-enforced DEP on Windows in a way that requires very minimal
modifications to existing exploits.
Temporal Return
Addresses: Exploitation Chronomancy (Aug, 2005)
Nearly all existing exploitation vectors depend on some knowledge of a
process' address space prior to an attack in order to gain meaningful
control of execution flow. In cases where this is necessary, exploit
authors generally make use of static addresses that may or may not be
portable between various operating system and application revisions.
This fact can make exploits unreliable depending on how well researched
the static addresses were at the time that the exploit was implemented.
In some cases, though, it may be possible to predict and make use of
certain addresses in memory that do not have static contents. This
document introduces the concept of temporal addresses and describes how
they can be used, under certain circumstances, to make exploitation more
reliable.
Annoyances Caused by
Unsafe Assumptions (Apr, 2005)
This installation of What Were They Thinking illustrates some of the
annoyances that can be caused when developing software that has to
inter-operate with third-party applications. Two such cases will be
dissected and discussed in detail for the purpose of showing how
third-party applications can fail when used in conjunction with software
that performs certain tasks. The analysis of the two cases is meant to
show how complex failure conditions can be analyzed and used to
determine inter-operability problems.
Post-Exploitation on
Windows using ActiveX Controls (Mar, 2005)
When exploiting software vulnerabilities it is sometimes impossible to
build direct communication channels between a target machine and an
attacker's machine due to restrictive outbound filters that may be in
place on the target machine's network. Bypassing these filters involves
creating a post-exploitation payload that is capable of masquerading as
normal user traffic from within the context of a trusted process. One
method of accomplishing this is to create a payload that enables ActiveX
controls by modifying Internet Explorer's zone restrictions. With
ActiveX controls enabled, the payload can then launch a hidden instance
of Internet Explorer that is pointed at a URL with an embedded ActiveX
control. The end result is the ability for an attacker to run custom
code in the form of a DLL on a target machine by using a trusted process
that uses one or more trusted communication protocols, such as HTTP or
DNS.
Metasploit's
Meterpreter (Dec, 2004)
Meterpreter, short for The Meta-Interpreter, is an advanced payload that
is included in the Metasploit Framework. Its purpose is to provide
complex and advanced features that would otherwise be tedious to
implement purely in assembly. The way that it accomplishes this is by
allowing developers to write their own extensions in the form of shared
object (DLL) files that can be uploaded and injected into a running
process on a target computer after exploitation has occurred.
Meterpreter and all of the extensions that it loads are executed
entirely from memory and never touch the disk, thus allowing them to
execute under the radar of standard Anti-Virus detection.
Safely Searching Process Virtual Address Space (Sep, 2004)
This paper describes some techniques that can be used to search the
virtual address space of a process for a unique key as a part of running
code that is at an unknown location in memory. The code that is used to
search the process address space is designed to be extremely compact in
order to make it useful in scenarios where a particularly imposes
limitations on the size of the payload that can be used in the context
of the initial overflow.
Remote Library Injection (Apr, 2004)
The common methods currently employed to compromise comput- ers are
ineffective and easily detected by standard Anti-Virus practices.
Despite this, worm authors continue to use these same approaches,
blindly hoping that at least some of the hosts will remain infected long
enough for the worm au- thor to make use of them. An alternative to the
standard methods of computer compromise involves making use of a more
complicated, yet high-yield, solution: library injection. When used in
conjunction with a remote vulnerability, such as the DCOM vulnerability,
library injection can lead to an undetectable com- promise at the host
level as far as current Anti-Virus detection mechanisms are concerned.
The impact from this is far-reaching; so much so that a completely
automated, high-retention, operating system independent super-worm is an
ever approaching reality.
Reverse Engineering: Memory Analysis (Dec, 2003)
This paper describes some basic techniques that can be used to
dynamically analyze a program by inspecting the content of its address
space at runtime. The techniques presented are then applied to show how
they can be used to perform basic reverse engineering of a closed source
game known as ADOM.
Understanding Windows Shellcode (Dec, 2003)
This paper provides an exhaustive description of the structure and
purpose of windows shellcode. An in-depth walkthrough of various types
of windows payloads is given including reverse connect, port bind, file
descriptor re-use, and so on.
ELF binary signing and verification (Jan, 2003)
This paper provides an introduction to binary signing of ELF
executables.
Linux x86 run-time process manipulation (Jan, 2003)
This paper illustrates run-time process manipulation techniques on Linux.