Control Hijacking

Basic Control
Hijacking Attacks
Dan Boneh
 Control hijacking attacks
• Attacker’s goal:
Take over target machine (e.g. web server)
• Execute arbitrary code on target by hijacking
application control flow

• Examples:
– Buffer overflow and integer overflow attacks
– Format string vulnerabilities
– Use after free
Dan Boneh
 First example: buffer overflows
Extremely common bug in C/C++ programs.
• First major exploit: 1988 Internet Worm. Fingerd.

Whenever possible avoid C/C++

Often cannot avoid C/C++ :

• Need to understand
attacks and defenses

Source: web.nvd.nist.gov
Dan Boneh
 What is needed
• Understanding C functions, the stack, and the heap.
• Know how system calls are made
• The exec() system call

• Attacker needs to know which CPU and OS used on the target machine:
– Our examples are for x86 running Linux or Windows
– Details vary slightly between CPUs and OSs:
• Stack Frame structure (Unix vs. Windows, x86 vs. ARM)
• Little endian vs. big endian
Dan Boneh
 Linux process memory layout (x86_64)

0x0000 7FFF FFFF FFFF (128 TB)

user stack
%rsp
(stack pointer)

shared libraries
0x0000 7F1F6 XXXX XXXX

run time heap

Loaded text and data
from executable 0x0000 0000 0040 0040
unused
0
Dan Boneh
 Stack Frame
high

arguments

return address
rbp stack base pointer
exception handlers
Stack
local variables Growth
rsp callee saved registers
low
(esp in 32-bit mode)
Dan Boneh
 What are buffer overflows?
Suppose a web server contains a function: void func(char *str) {
char buf[128];
After func() is called stack looks like:
strcpy(buf, str);
do-something(buf);
argument: str }
return address
stack base pointer

char buf[128]

rsp
Dan Boneh
 What are buffer overflows?
What if *str is 136 bytes long? void func(char *str) {
After strcpy: char buf[128];
strcpy(buf, str);
do-something(buf);
argument: str }
return address
stack base pointer Poisoned return address!
*str
Problem:
char buf[128] no bounds checking in strcpy()
rsp
Dan Boneh
 Stack
Basic stack exploit
high

Suppose *str is such that Program P

after strcpy stack looks like:

Program P: exec(“/bin/sh”)
(exact shell code by Aleph One)
return address

When func() exits, the user gets shell ! char buf[128]

Note: attack code P runs in stack.
low
Dan Boneh
 Stack
The NOP slide high
Program P
Problem: how does attacker
determine ret-address?
NOP Slide

Solution: NOP slide

return address
• Guess approximate stack state
when func() is called
• Insert many NOPs before program P:
char buf[128]
nop (0x90) , xor eax,eax , inc ax
low
Dan Boneh
 Details and examples
• Some complications:
– Program P should not contain the ‘\0’ character.
– Overflow should not crash program before func() exits.

• (in)Famous remote stack smashing overflows:

– Overflow in Windows animated cursors (ANI). LoadAniIcon()
– Buffer overflow in Symantec virus detection (May 2016)

overflow when parsing PE headers … kernel vuln.

Dan Boneh
 Many unsafe libc functions
strcpy (char *dest, const char *src)
strcat (char *dest, const char *src)
gets (char *s)
scanf ( const char *format, … ) and many more.
• “Safe” libc versions strncpy(), strncat() are misleading
– e.g. strncpy() may leave string unterminated.

• Windows C run time (CRT):

– strcpy_s (*dest, DestSize, *src): ensures proper termination
Dan Boneh
 Buffer overflow opportunities
• Exception handlers: (… more on this in a bit)
– Overwrite the address of an exception handler in stack frame.

• Function pointers: (e.g. PHP 4.0.2, MS MediaPlayer Bitmaps)

Heap
buf[128] FuncPtr or
stack
– Overflowing buf will override function pointer.

• Longjmp buffers: longjmp(pos) (e.g. Perl 5.003)

– Overflowing buf next to pos overrides value of pos. Dan Boneh
 Heap exploits: corrupting virtual tables
Compiler generated function pointers (e.g. C++ code)

FP1 method #1
vptr FP2 method #2
FP3
method #3
data vtable

Object T NOP shell

slide code
After overflow of buf :

vptr

data
buf[256] vtable

object T Dan Boneh

An example: exploiting the browser heap
Request web page

Web page with exploit

victim browser malicious web server

Attacker’s goal is to infect browsers visiting the web site

• How: send javascript to browser that exploits a heap overflow

Dan Boneh
 A reliable exploit?
<SCRIPT language="text/javascript">
shellcode = unescape("%u4343%u4343%..."); // allocate in heap
overflow-string = unescape(“%u2332%u4276%...”);
cause-overflow(overflow-string ); // overflow buf[ ]
</SCRIPT>

Problem: attacker does not know where browser

places shellcode on the heap
???

data
ptr
buf[256] vtable shellcode
Dan Boneh
 Heap Spraying [SkyLined]

Idea: 1. use Javascript to spray heap

with shellcode (and NOP slides)
2. then point vtable ptr anywhere in spray area

NOP slide shellcode

heap
vtable

heap spray area

Dan Boneh
 Javascript heap spraying
var nop = unescape(“%u9090%u9090”)
while (nop.length < 0x100000) nop += nop;

var shellcode = unescape("%u4343%u4343%...");

var x = new Array ()
for (i=0; i<1000; i++) {
x[i] = nop + shellcode;
}

Pointing function-ptr almost anywhere in heap will

cause shellcode to execute.
Dan Boneh
 Ad-hoc heap overflow mitigations
• Better browser architecture:
– Store JavaScript strings in a separate heap from browser heap

• OpenBSD and Windows 8 heap overflow protection:

prevents
cross-page
overflows

guard pages (non-writable pages in virtual memory)

In theory: allocate every object on a separate page (eFence, Archipelago’08)

⟹ not practical: too wasteful in physical memory
Dan Boneh
 Finding overflows by fuzzing
• To find overflow:
– Run web server on local machine
– Use AFL to issue malformed requests (ending with “$$$$$” )
• Fuzzers: automated tools for this (next week)
– If web server crashes,
search core dump for “$$$$$” to find overflow location

• Construct exploit (not easy given latest defenses in next lecture)

Dan Boneh
Control Hijacking

More Control
Hijacking Attacks
Dan Boneh
 More Hijacking Opportunities
• Integer overflows: (e.g. MS DirectX MIDI Lib)
• Double free: double free space on heap
– Can cause memory mgr to write data to specific location
– Examples: CVS server
• Use after free: using memory after it is freed
• Format string vulnerabilities

Dan Boneh
 Integer Overflows (see Phrack 60)

Problem: what happens when int exceeds max value?

int m; (32 bits) short s; (16 bits) char c; (8 bits)

c = 0x80 + 0x80 = 128 + 128 ⇒ c=0

s = 0xff80 + 0x80 ⇒ s=0
m = 0xffffff80 + 0x80 ⇒ m=0

Can this be exploited? Dan Boneh

 An example
void func( char *buf1, *buf2, unsigned int len1, len2) {
char temp[256];
if (len1 + len2 > 256) {return -1} // length check
memcpy(temp, buf1, len1); // cat buffers
memcpy(temp+len1, buf2, len2);
do-something(temp); // do stuff
}

What if len1 = 0x80, len2 = 0xffffff80 ?

⇒ len1+len2 = 0
Second memcpy() will overflow heap !! Dan Boneh
An example: a better length check
void func( char *buf1, *buf2, unsigned int len1, len2) {
char temp[256];
// length check
if (len1 > 256) || (len2 > 256) || (len+ len2 > 256)
return -1;
memcpy(temp, buf1, len1); // cat buffers
memcpy(temp+len1, buf2, len2);
do-something(temp); // do stuff
}

Dan Boneh
 Integer overflow exploit stats
700

600

500

400

300

200

100

0
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 ⋯ 2015 2016 2017 2018 2019 2020

Dec. 2020: integer underflow in F5 Big IP

if (8190 − nlen <= vlen ) // length check
return -1;
Source: NVD/CVE Dan Boneh
Format string bugs

Dan Boneh
 Format string problem
int func(char *user) {
fprintf(stderr, user);
}

Problem: what if *user = “%s%s%s%s%s%s%s” ??

– Most likely program will crash: DoS.
– If not, program will print memory contents. Privacy?
– Full exploit using user = “%n”

Correct form: fprintf( stdout, “%s”, user);

Dan Boneh
 Vulnerable functions
Any function using a format string.

Printing:
printf, fprintf, sprintf, …
vprintf, vfprintf, vsprintf, …

Logging:
syslog, err, warn

Dan Boneh
 Exploit
• Dumping arbitrary memory:
– Walk up stack until desired pointer is found.
– printf( “%08x.%08x.%08x.%08x|%s|”)

• Writing to arbitrary memory:

– printf( “hello %n”, &temp) -- writes ‘6’ into temp.
– printf( “%08x.%08x.%08x.%08x.%n”)
Dan Boneh
Use after free exploits

Dan Boneh
High impact security vulns. in Chrome 2015 – 2020 (C++)

70% due to memory management bugs

Dan Boneh
IE11 Example: CVE-2014-0282 (simplified)
<form id="form"> (IE11 written in C++)
<textarea id="c1" name="a1" ></textarea>
<input id="c2" type="text" name="a2” value="val">
</form> Loop on form elements:
c1.DoReset()
<script> c2.DoReset()
function changer() {
document.getElementById("form").innerHTML = "";
CollectGarbage(); // erase c1 and c2 fields
}

document.getElementById("c1").onpropertychange = changer;
document.getElementById("form").reset();
</script>
Dan Boneh
 What just happened?
c1.doReset() causes changer() to be called and free object c2

object c2 FP1 doSomething

vptr FP2 doReset
FP3
doSomethingElse
data vtable

Dan Boneh
 What just happened?
c1.doReset() causes changer() to be called and free object c2

object c2 FP1
vptr FP2 ShellCode
FP3
data vtable
Use after free !

Suppose attacker allocates a string of same size as vtable

When c2.DoReset() is called, attacker gets shell

Dan Boneh
 The exploit
<script>
function changer() {
document.getElementById(”form").innerHTML = "";
CollectGarbage();

--- allocate string object to occupy vtable location ---

}

document.getElementById("c1").onpropertychange = changer;
document.getElementById("form").reset();
</script>

Lesson: use after free can be a serious security vulnerability !!

Dan Boneh
THE END

Dan Boneh
Ceng 452: Network Security

Isolation

The confinement
principle
Dan Boneh
 Running untrusted code
We often need to run buggy/unstrusted code:
– programs from untrusted Internet sites:
• mobile apps, Javascript, browser extensions

– exposed applications: browser, pdf viewer, outlook

– legacy daemons: sendmail, bind

– honeypots

Goal: if application “misbehaves” ⇒ kill it

Dan Boneh
 Approach: confinement
Confinement: ensure misbehaving app cannot harm rest of system

Can be implemented at many levels:

– Hardware: run application on isolated hw (air gap)

app 1 app 2

Network 2 air gap network 1

⇒ difficult to manage
Dan Boneh
 Approach: confinement
Confinement: ensure misbehaving app cannot harm rest of system

Can be implemented at many levels:

– Virtual machines: isolate OS’s on a single machine

app1 app2

OS1 OS2

Virtual Machine Monitor (hypervisor)

Hardware
Dan Boneh
 Approach: confinement
Confinement: ensure misbehaving app cannot harm rest of system

Can be implemented at many levels:

– Process: System Call Interposition (containers)
Isolate a process in a single operating system

process 1
process 2

Operating System
Dan Boneh
 Approach: confinement
Confinement: ensure misbehaving app cannot harm rest of system

Can be implemented at many levels:

– Threads: Software Fault Isolation (SFI)
• Isolating threads sharing same address space

– Application level confinement:

e.g. browser sandbox for Javascript and WebAssembly

Dan Boneh
 Implementing confinement
Key component: reference monitor
– Mediates requests from applications
• Enforces confinement
• Implements a specified protection policy
– Must always be invoked:
• Every application request must be mediated
– Tamperproof:
• Reference monitor cannot be killed
… or if killed, then monitored process is killed too
– Small enough to be analyzed and validated Dan Boneh
 A old example: chroot
To use do: (must be root)
chroot /tmp/guest root dir “/” is now “/tmp/guest”
su guest EUID set to “guest”

Now “/tmp/guest” is added to every file system accesses:

fopen(“/etc/passwd”, “r”) ⇒
fopen(“/tmp/guest/etc/passwd” , “r”)
⇒ application (e.g., web server) cannot access files outside of jail
Dan Boneh
 Escaping from jails
Early escapes: relative paths
fopen( “../../etc/passwd”, “r”) ⇒
fopen(“/tmp/guest/../../etc/passwd”, “r”)

chroot should only be executable by root.

– otherwise jailed app can do:
• create dummy file “/aaa/etc/passwd”
• run chroot “/aaa”
• run su root to become root
(bug in Ultrix 4.0)
Dan Boneh
Many ways to escape jail as root
• Create device that lets you access raw disk

• Send signals to non chrooted process

• Reboot system

• Bind to privileged ports

Dan Boneh
 Freebsd jail
Stronger mechanism than simple chroot

To run: jail jail-path hostname IP-addr cmd

– calls hardened chroot (no “../../” escape)
– can only bind to sockets with specified IP address
and authorized ports
– can only communicate with processes inside jail
– root is limited, e.g. cannot load kernel modules
Dan Boneh
 Problems with chroot and jail
Coarse policies:
– All or nothing access to parts of file system
– Inappropriate for apps like a web browser
• Needs read access to files outside jail
(e.g., for sending attachments in Gmail)

Does not prevent malicious apps from:

– Accessing network and messing with other machines
– Trying to crash host OS
Dan Boneh
 Isolation

System Call Interposition:

sanboxing a process

Dan Boneh
 System call interposition
Observation: to damage host system (e.g. persistent changes)
app must make system calls:
– To delete/overwrite files: unlink, open, write
– To do network attacks: socket, bind, connect, send

Idea: monitor app’s system calls and block unauthorized calls

Implementation options:
– Completely kernel space (e.g., Linux seccomp)
– Completely user space (e.g., program shepherding)
– Hybrid (e.g., Systrace)
Dan Boneh
 Early implementation (Janus) [GWTB’96]

Linux ptrace: process tracing

process calls: ptrace (… , pid_t pid , …)
and wakes up when pid makes sys call.
user space
monitored
application monitor
(browser)

fopen(“/etc/passwd”, “r”)
OS Kernel
Monitor kills application if request is disallowed
Dan Boneh
 Example policy
Sample policy file (e.g., for PDF reader)

path allow /tmp/*

path deny /etc/passwd
network deny all

Manually specifying policy for an app can be difficult:

– Recommended default policies are available
… can be made more restrictive as needed.
Dan Boneh
 Complications cd(“/tmp”)
open(“passwd”, “r”)
• If app forks, monitor must also fork
cd(“/etc”)
– forked monitor monitors forked app open(“passwd”, “r”)

• If monitor crashes, app must be killed

• Monitor must maintain all OS state associated with app

– current-working-dir (CWD), UID, EUID, GID
– When app does “cd path” monitor must update its CWD
• otherwise: relative path requests interpreted incorrectly
Dan Boneh
 Problems with ptrace
Ptrace is not well suited for this application:
– Trace all system calls or none
inefficient: no need to trace “close” system call
– Monitor cannot abort sys-call without killing app

Security problems: race conditions

– Example: symlink: me ⟶ mydata.dat
proc 1: open(“me”)
time

monitor checks and authorizes

proc 2: me ⟶ /etc/passwd not atomic
OS executes open(“me”)
Classic TOCTOU bug: time-of-check / time-of-use Dan Boneh
 SCI in Linux: seccomp-bpf
Seccomp-BPF: Linux kernel facility used to filter process sys calls
• Sys-call filter written in the BPF language (use BPFC compiler)
• Used in Chromium, in Docker containers, …

Chrome renderer
process starts
… Renderer process
renders site
user space

prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, due to exploit:

&bpf_policy) fopen(“/etc/passwd”, “r”)

seccomp-bpf run BPF program … kill process

OS Kernel
Dan Boneh
 BPF filters (policy programs)
Process can install multiple BPF filters:
– once installed, filter cannot be removed (all run on every syscall)
– if program forks, child inherits all filters
– if program calls execve, all filters are preserved

BPF filter input: syscall number, syscall args., arch. (x86 or ARM)
Filter returns one of:
– SECCOMP_RET_KILL: kill process
– SECCOMP_RET_ERRNO: return specified error to caller
– SECCOMP_RET_ALLOW: allow syscall
Dan Boneh
Installing a BPF filter
• Must be called before setting BPF filter.
• Ensures set-UID, set-GID ignored on subequent execve()
⇒ attacker cannot elevate privilege

int main (int argc , char **argv ) {

prctl(PR_SET_NO_NEW_PRIVS , 1);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bpf_policy)
fopen(“file.txt", “w”);
printf(“… will not be printed. \n” ); Kill if call open() for write
}
Dan Boneh
Docker: isolating containers using seccomp-bpf
containers

Container: process level isolation

• Container prevented from

App 1

App 2

App 3
making sys calls filtered by
secomp-BPF Docker engine
host OS
• Whoever starts container hardware
can specify BPF policy
– default policy blocks many syscalls, including ptrace
Dan Boneh
 Docker sys call filtering
Run nginx container with a specific filter called filter.json:
$ docker run --security-opt seccomp=filter.json nginx

Example filter:
“defaultAction”: “SCMP_ACT_ERRNO”, // deny by default
“syscalls”: [
{ "names": ["accept”], // sys-call name
"action": "SCMP_ACT_ALLOW", // allow (whitelist)
"args": [ ] } , // what args to allow
…
]
Dan Boneh
Ostia: SCI with minimal kernel support
Monitored app disallowed from making monitored sys calls
– Minimal kernel change (… but app can call close() itself )
Sys-call delegated to an agent that decides if call is allowed
– Can be done without changing app … using a libc stub
⇒ Incorrect state syncing will not result in policy violation
monitored user space
application agent
libc policy file
fopen(“/etc/passwd”, “r”) for app

OS Kernel
Dan Boneh
 Isolation

Isolation via
Virtual Machines

Dan Boneh
 Virtual Machines
VM2 VM1
Apps Apps

Guest OS 2 Guest OS 1
Virtual Machine Monitor (VMM, hypervisor)
Host OS
Hardware

single HW platform with isolated components

Dan Boneh
 Why so popular now?
VMs in the 1960’s:
– Few computers, lots of users
– VMs allow many users to shares a single computer

VMs 1970’s – 2000: non-existent

VMs since 2000:

– Too many computers, too few users
• Print server, Mail server, Web server, File server, Database , …
– VMs heavily used in private and public clouds
Dan Boneh
 Hypervisor security assumption
Hypervisor Security assumption:
– Malware can infect guest OS and guest apps
– But malware cannot escape from the infected VM
• Cannot infect host OS
• Cannot infect other VMs on the same hardware

Requires that hypervisor protect itself and is not buggy

• (some) hypervisors are much simpler than a full OS
Dan Boneh
 Problem: covert channels
Covert channel: unintended communication channel between
isolated components
– Can leak classified data from secure component
to public component

Classified VM Public VM
malware

secret
covert
doc listener
channel

hypervisor
Dan Boneh
 An example covert channel
Both VMs use the same underlying hardware

To send a bit b ∈ {0,1} malware does:

– b= 1: at 1:00am do CPU intensive calculation
– b= 0: at 1:00am do nothing

At 1:00am listener does CPU intensive calc. and measures completion time
b=1 ⇒ completion-time > threshold

Many covert channels exist in running system:

– File lock status, cache contents, interrupts, …
– Difficult to eliminate all
Dan Boneh
 VM isolation in practice: cloud
VM instance VM instance
customer 1 customer 2

Guest OS Guest OS
Xen hypervisor
Hardware
Type 1 hypervisor:
VMs from different customers may run on the same machine no host OS
• Hypervisor must isolate VMs … but some info leaks
Dan Boneh
 VM isolation in practice: end-user
Qubes OS: a desktop/laptop OS where everything is a VM
• Runs on top of the Xen hypervisor
• Access to peripherals (mic, camera, usb, …) controlled by VMs

Disposable VM Work VM Personal VM

sketchy PDF:

Debian OS Windows OS Debian OS

Xen hypervisor
Hardware
Dan Boneh
 VM isolation in practice: end-user
Qubes OS: a desktop/laptop OS where everything is a VM
• Runs on top of the Xen hypervisor
• Access to peripherals (mic, camera, usb, …) controlled by VMs

Vault VM Work VM Whonix VM

Personal VM
Pwd/U2F Manager Force all traffic through Tor

Debian OS Windows OS Debian OS

Xen hypervisor
Hardware
Dan Boneh
Every window frame identifies VM source

GUI VM ensures frames are drawn correctly

Dan Boneh
 Hypervisor detection
Can an OS detect it is running on top of a hypervisor?

Applications:

– Malware can detect hypervisor

• refuse to run to avoid reverse engineering

– Software that binds to hardware can refuse to run in VM

– DRM systems may refuse to run on top of hypervisor

Dan Boneh
Hypervisor detection

Dan Boneh
 Hypervisor detection (red pill techniques)
• VM platforms often emulate simple hardware
– VMWare emulates an ancient i440bx chipset
… but report 8GB RAM, dual CPUs, etc.

• Hypervisor introduces time latency variances

– Memory cache behavior differs in presence of hypervisor
– Results in relative time variations for any two operations

• Hypervisor shares the TLB with GuestOS

– GuestOS can detect reduced TLB size

• … and many more methods [GAWF’07] Dan Boneh

 Hypervisor detection in the browser [HBBP’14]

Can we identify malware web sites?

• Approach: crawl web,
load pages in a browser running in a VM,
look for pages that damage VM

• The problem: Web page can detect it is running in a VM

How? Using timing variations in writing to screen
• Malware in web page becomes benign when in a VM
⇒ evade detection
Dan Boneh
 Hypervisor detection
Bottom line: The perfect hypervisor does not exist

Hypervisors today focus on:

Compatibility: ensure off the shelf software works
Performance: minimize virtualization overhead

• VMMs do not provide transparency

– Anomalies reveal existence of hypervisor

Dan Boneh
 Isolation

Software Fault Isolation:

isolating threads

Dan Boneh
 Software Fault Isolation [Whabe et al., 1993]

Goal: confine apps running in same address space

– Kernel module should not corrupt kernel
– Native libraries should not corrupt JVM

Simple solution: runs apps in separate address spaces

– Problem: slow if apps communicate frequently
• requires context switch per message

Dan Boneh
 Software Fault Isolation
SFI approach: Partition process memory into segments

code data code data

segment segment segment segment

app #1 app #2

• Locate unsafe instructions: jmp, load, store

– At compile time, add guards before unsafe instructions
– When loading code, ensure all guards are present
Dan Boneh
 Segment matching technique
• Designed for MIPS processor. Many registers available.
Guard ensures code does not
• dr1, dr2: dedicated registers not used by binary
load data from another
– compiler pretends these registers don’t exist
segment
– dr2 contains segment ID
• Indirect load instruction R12 ⟵ [R34] becomes:
dr1 ⟵ R34
scratch-reg ⟵ (dr1 >> 20) : get segment ID
compare scratch-reg and dr2 : validate seg. ID
trap if not equal
R12 ⟵ [dr1] : do load
Dan Boneh
 Address sandboxing technique
• dr2: holds segment ID
• Indirect load instruction R12 ⟵ [R34] becomes:

dr1 ⟵ R34 & segment-mask : zero out seg bits

dr1 ⟵ dr1 | dr2 : set valid seg ID
R12 ⟵ [dr1] : do load

• Fewer instructions than segment matching

… but does not catch offending instructions
• Similar guards placed on all unsafe instructions
Dan Boneh
Problem: what if jmp [addr] jumps directly into indirect load?
(bypassing guard)

Solution:

This is why jmp instructions need a guard:

jmp guard ensures [addr] does not bypass load guard

Dan Boneh
 Cross domain calls
caller callee
domain domain
call stub draw:
call draw

return

br addr br addr
br addr ret stub br addr
br addr br addr
• Only stubs allowed to make cross-domain jumps
• Jump table contains allowed exit points
– Addresses are hard coded, read-only segment
Dan Boneh
 SFI Summary
• Performance
– Usually good: mpeg_play, 4% slowdown

• Limitations of SFI: harder to implement on x86 :

– variable length instructions: unclear where to put guards
– few registers: can’t dedicate three to SFI
– many instructions affect memory: more guards needed

Dan Boneh
 Isolation: summary
• Many sandboxing techniques:
Physical air gap, Virtual air gap (hypervisor),
System call interposition (SCI), Software Fault isolation (SFI)
Application specific (e.g. Javascript in browser)

• Often complete isolation is inappropriate

– Apps need to communicate through regulated interfaces

• Hardest aspects of sandboxing:

– Specifying policy: what can apps do and not do
– Preventing covert channels
Dan Boneh
THE END

Dan Boneh