• Introduction to Toorcon 15 (2013)
• 
  A Tale of One Software Bypass of MS Windows 8 Secure Boot
• 
  Breaching SSL, One Byte at a Time
• 
  Running at 99%: Surviving an Application DoS
• 
  Security Response in the Age of Mass Customized Attacks
• 
  x86 Rewriting: Defeating RoP and other Shinanighans
• 
  Clowntown Express: interesting bugs and running a bug bounty program
• 
  Active Fingerprinting of Encrypted VPNs
• 
  Making Attacks Go Backwards
• 
  Mask Your Checksums—The Gorry Details
• 
  Adventures with weird machines thirty years after "Reflections on Trusting Trust"

width="329" height="235" alt="Dave, Tim,and Geo" /> The Toorcon gang (senior staff): h1kari (founder), nfiltr8, and Geo

Introduction to Toorcon 15 (2013)

Toorcon 15
is the 15th annual security conference held in San Diego.
I've attended about a third of them and blogged here about the previous conferences I attended here, starting in 2003.
As always, I've only summarized the talks I attended and interested me enough to write about them. Be aware that I may have misrepresented the speaker's remarks and that they are not my remarks or opinion, or those of my employer, so don't quote me or them.
I blame my dog for any typos.
Those seeking further details may contact the speakers directly or use The Google. For some talks, I have a URL for further information.

A Tale of One Software Bypass of MS Windows 8 Secure Boot

width="259" height="204" alt="Andrew and Alex" /> Andrew Furtak and Oleksandr Bazhaniuk

Yuri Bulygin, Oleksandr ("Alex") Bazhaniuk, and (not present) Andrew Furtak

Yuri and Alex talked about UEFI and Bootkits and bypassing MS Windows 8 Secure Boot, with vendor recommendations.
They previously gave this talk at the BlackHat 2013 conference.

MS Windows 8 Secure Boot Overview

UEFI (Unified Extensible Firmware Interface) is interface between hardware and OS.
UEFI is processor and architecture independent.
Malware can replace bootloader (bootx64.efi, bootmgfw.efi).
Once replaced can modify kernel.
Trivial to replace bootloader.

Today many legacy bootkits—UEFI replaces them most of them.
MS Windows 8 Secure Boot verifies everything you load, either through signatures or hashes.

• UEFI firmware relies on secure update (with signed update). You would think Secure Boot would rely on ROM (such as used for phones0, but you can't do that for PCs—PCs use writable memory with signatures
• DXE core verifies the UEFI boat loader(s)
• OS Loader (winload.efi, winresume.efi) verifies the OS kernel

A chain of trust is established with a root key (Platform Key, PK), which is a cert belonging to the platform vendor.
Key Exchange Keys (KEKs) verify an "authorized" database (db), and "forbidden" database (dbx).
X.509 certs with SHA-1/SHA-256 hashes.
Keys are stored in non-volatile (NV) flash-based NVRAM.
Boot Services (BS) allow adding/deleting keys (can't be accessed once OS starts—which uses Run-Time (RT)).
Root cert uses RSA-2048 public keys and PKCS#7 format signatures.

• SecureBoot — enable disable image signature checks
• SetupMode — update keys, self-signed keys, and secure boot variables
• CustomMode — allows updating keys

Secure Boot policy settings are: always execute, never execute, allow execute on security violation, defer execute on security violation, deny execute on security violation, query user on security violation

Attacking MS Windows 8 Secure Boot

Secure Boot does NOT protect from physical access.
Can disable from console.

Each BIOS vendor implements Secure Boot differently.
There are several platform and BIOS vendors.
It becomes a "zoo" of implementations—which can be taken advantage of.
Secure Boot is secure only when all vendors implement it correctly.

• Allow only UEFI firmware signed updates
• protect UEFI firmware from direct modification in flash memory
• protect FW update components
• program SPI controller securely
• protect secure boot policy settings in nvram
• protect runtime api
• disable compatibility support module which allows unsigned legacy

Can corrupt the Platform Key (PK) EFI root certificate variable in SPI flash. If PK is not found, FW enters setup mode wich secure boot turned off.

Can also exploit TPM in a similar manner.

One is not supposed to be able to directly modify the PK in SPI flash from the OS though.
But they found a bug that they can exploit from User Mode (undisclosed) and demoed the exploit. It loaded and ran their own bootkit. The exploit requires a reboot.
Multiple vendors are vulnerable.
They will disclose this exploit to vendors in the future.

Recommendations:

• allow only signed updates
• protect UEFI fw in ROM
• protect EFI variable store in ROM

Breaching SSL, One Byte at a Time

width="318" height="196" alt="Prado and Gluck" /> Yoel Gluck and Angelo Prado

Angelo Prado and Yoel Gluck, Salesforce.com

CRIME is software that performs a
"compression oracle attack."
This is possible because the SSL protocol doesn't hide length, and because SSL compresses the header.
CRIME requests with every possible character and measures the ciphertext length.
Look for the plaintext which compresses the most and looks for the cookie one byte-at-a-time.

SSL Compression
uses LZ77 to reduce redundancy.
Huffman coding replaces common byte sequences with shorter codes.
US CERT thinks the SSL compression problem is fixed, but it isn't.
They convinced CERT that it wasn't fixed and they issued a CVE.

BREACH,
breachattrack.com

BREACH exploits the SSL response body (Accept-Encoding response, Content-Encoding).
It takes advantage of the fact that the response is not compressed.
BREACH uses gzip and needs fairly "stable" pages that are static for ~30 seconds.
It needs attacker-supplied content (say from a web form or added to a URL parameter).
BREACH listens to a session's requests and responses, then inserts extra requests and responses.
Eventually, BREACH guesses a session's secret key.

Can use compression to guess contents one byte at-a-time.
For example, "Supersecret SupersecreX" (a wrong guess) compresses 10 bytes,
and "Supersecret Supersecret" (a correct guess) compresses 11 bytes,
so it can find each character by guessing every character.
To start the guess, BREACH needs at least three known initial characters in the response sequence.
Compression length then "leaks" information.

Some roadblocks
include no winners (all guesses wrong) or too many winners (multiple possibilities that compress the same).
The solutions include:

• lookahead (guess 2 or 3 characters at-a-time instead of 1 character). Expensive
• rollback to last known conflict
• check compression ratio
• can brute-force first 3 "bootstrap" characters, if needed (expensive)
• block ciphers hide exact plain text length. Solution is to align response in advance to block size

Mitigations

• length: use variable padding
• secrets: dynamic CSRF tokens per request
• secret: change over time
• separate secret to input-less servlets

Future work

• either understand DEFLATE/GZIP
• HTTPS extensions

Running at 99%: Surviving an Application DoS

width="243" height="287" alt="Ryan" /> Ryan Huber

Ryan Huber, Risk I/O

Ryan first discussed various ways to do a denial of service (DoS) attack against web services.
One usual method is to find a slow web page and do several wgets. Or download large files.

• Apache is not well suited at handling a large number of connections, but one can put something in front of it
• Can use Apache alternatives, such as nginx

How to identify malicious hosts

• short, sudden web requests
• user-agent is obvious (curl, python)
• same url requested repeatedly
• no web page referer (not normal)
• hidden links. hide a link and see if a bot gets it
• restricted access if not your geo IP (unless the website is global)
• missing common headers in request
• regular timing
• first seen IP at beginning of attack
• count requests per hosts (usually a very large number)

Some mitigation

• restrict access for requests not from your geo IP (unless the website is global)
• Use of captcha can mitigate attacks, but you'll lose a lot of genuine users

Bouncer, goo.gl/c2vyEc and
www.github.com/rawdigits/Bouncer

Bouncer is software written by Ryan in netflow.
Bouncer has a small, unobtrusive footprint and
detects DoS attempts.
It closes blacklisted sockets immediately (not nice about it, no proper close connection).
Aggregator collects requests and controls your web proxies.
Need NTP on the front end web servers for clean data for use by bouncer.

Bouncer is also useful for a popularity storm ("Slashdotting") and scraper storms.

Future features: gzip collection data, documentation, consumer library,
multitask, logging destroyed connections.

Takeaways:

• DoS mitigation is easier with a complete picture
• Bouncer designed to make it easier to detect and defend DoS—not a complete cure

Security Response in the Age of Mass Customized Attacks

width="383" height="218" alt="Peleus and Karthik" /> Peleus Uhley and Karthik Raman

Peleus Uhley and Karthik Raman, Adobe ASSET,
blogs.adobe.com/asset/

Peleus and Karthik talked about response to mass-customized exploits.

Attackers behave much like a business.
"Mass customization" refers to concept discussed in the book Future Perfect by Stan Davis of Harvard Business School.
Mass customization is differentiating a product for an individual customer, but at a mass production price.
For example, the same individual with a debit card receives basically the same customized ATM experience around the world.
Or designing your own PC from commodity parts.

Exploit kits are another example of mass customization.
The kits support multiple browsers and plugins, allows new modules.
Exploit kits are cheap and customizable.
Organized gangs use exploit kits.

A group at Berkeley looked at 77,000 malicious websites
(Grier et al., "Manufacturing Compromise: The Emergence of Exploit-as-a-Service", 2012). They found 10,000 distinct binaries among them, but derived from only a dozen or so exploit kits.

• Characteristics of Mass Malware: potent, resilient, relatively low cost
• Technical characteristics: multiple OS, multipe payloads, multiple scenarios, multiple languages, obfuscation

Response time for 0-day exploits has gone down from ~40 days 5 years ago to about ~10 days now.
So the drive with malware is towards mass customized exploits, to avoid detection

There's plenty of evidence
that exploit development has Project Manager bureaucracy.
They infer, from looking at the malware code, bureaucratic edicts to:

• support all versions of Reader
• support all versions of MS Windows
• support all versions of Flash
• support all browsers
• write large complex, difficult to main code (8750 lines of JavaScript for example

Exploits have "loose coupling" of multipe versions of software (Adobe), OS, and browser. This allows specific attacks against specific versions of multiple pieces of software. Also allows exploits of more obscure software/OS/browsers and obscure versions.
Gave examples of exploits that exploited 2, 3, 6, or 14 separate bugs.
However, these complete exploits are more likely to be buggy or fragile in themselves and easier to defeat.

Future research includes normalizing malware and Javascript.

Conclusion:
The coming trend is that
mass-malware with mass zero-day attacks will result in mass customization of attacks.

x86 Rewriting: Defeating RoP and other Shinanighans

width="231" height="269" alt="Richard" /> Richard Wartell

Richard Wartell

The attack vector we are addressing here is:

• First some malware causes a buffer overflow.
  The malware has no program access, but input access and buffer overflow code onto stack
• Later the stack became non-executable. The workaround malware used was to write a bogus return address to the stack jumping to malware
• Later came ASLR (Address Space Layout Randomization) to randomize memory layout and make addresses non-deterministic. The workaround malware used was to jump t existing code segments in the program that can be used in bad ways

"RoP" is Return-oriented Programming attacks.
RoP attacks use your own code and write return address on stack to (existing) expoitable code found in program ("gadgets").
Pinkie Pie was paid $60K last year for a RoP attack.

One solution is using anti-RoP compilers that
compile source code with NO return instructions.

ASLR does not randomize address space, just "gadgets".

IPR/ILR ("Instruction Location Randomization")
randomizes each instruction with a virtual machine.

Richard's goal was to randomize a binary with no source code access.
He created
"STIR" (Self-Transofrming Instruction Relocation).
STIR disassembles binary and operates on "basic blocks" of code.
The STIR disassembler is conservative in what to disassemble.
Each basic block is moved to a random location in memory.

Next, STIR writes new code sections with copies of "basic blocks" of code in randomized locations.
The old code is copied and rewritten with jumps to new code.
the original code sections in the file is marked non-executible.

STIR has better entropy than ASLR in location of code.
Makes brute force attacks much harder.

STIR runs on MS Windows (PEM) and Linux (ELF).
It eliminated 99.96% or more "gadgets" (i.e., moved the address).
Overhead usually 5-10% on MS Windows, about 1.5-4% on Linux (but some code actually runs faster!).
The unique thing about STIR is it requires no source access and the modified binary fully works!

Current work is to rewrite code to enforce security policies.
For example, don't create a *.{exe,msi,bat} file. Or don't connect to the network after reading from the disk.

Clowntown Express: interesting bugs and running a bug bounty program

width="264" height="190" border="0" alt="Collin Greene" /> Collin Greene

Collin Greene, Facebook

Collin talked about Facebook's bug bounty program.
Background at FB: FB
has good security frameworks,
such as security teams, external audits, and cc'ing on diffs.
But there's lots of "deep, dark, forgotten" parts of legacy FB code.

Collin gave several examples of bountied bugs.
Some bounty submissions were on software purchased from a third-party (but bounty claimers don't know and don't care).

We use security questions, as does everyone else,
but they are basically insecure (often easily discoverable).

Collin didn't expect many bugs from the bounty program,
but they ended getting 20+ good bugs in first 24 hours and good submissions continue to come in.
Bug bounties bring people in with different perspectives, and are paid only for success.
Bug bounty is a better use of a fixed amount of time and money versus
just code review or static code analysis.
The Bounty program started July 2011 and paid out $1.5 million to date.
14% of the submissions have been high priority problems that needed to be fixed immediately.
The best bugs come from a small % of submitters (as with everything else)—the top paid submitters are paid 6 figures a year.
Spammers like to backstab competitors.
The youngest submitter was 13.
Some submitters have been hired.
Bug bounties also allows to see bugs that were missed by tools or reviews,
allowing improvement in the process.

Bug bounties might not work for traditional software companies where the product has release cycle or is not on Internet.

Active Fingerprinting of Encrypted VPNs

width="293" height="236" border="0" alt="Anna Shubina" /> Anna Shubina

Anna Shubina, Dartmouth Institute for Security, Technology, and Society

(I missed the start of her talk because another track went overtime.
But I have the DVD of the talk, so I'll expand later)

• IPsec leaves fingerprints. Using netcat, one can easily visually distinguish various crypto chaining modes just from packet timing on a chart
  (example, DES-CBC versus AES-CBC)
• One can tell a lot about VPNs just from ping roundtrips (such as what router is used)
• Delayed packets are not informative about a network, especially if far away from the network
• More needed to explore about how TCP works in real life with respect to timing

Making Attacks Go Backwards

width="285" height="254" border="0" alt="Fuzzynop" /> Fuzzynop

FuzzyNop, Mandiant

This talk is not about threat attribution (finding who),
product solutions, politics, or sales pitches.

But who are making these malware threats?
It's not a single person or group—they have diverse skill levels.
There's a lot of fat-fingered fumblers out there.
Always look for low-hanging fruit first:

• "hiding" malware in the temp, recycle, or root directories
  
• creation of unnamed scheduled tasks
• obvious names of files and syscalls ("ClearEventLog")
• uncleared event logs.
  Clearing event log in itself, and time of clearing, is a red flag and good first clue to look for on a suspect system
  

Reverse engineering is hard.
Disassembler use takes practice and skill.
A popular tool is IDA Pro, but it takes multiple interactive iterations to get a clean disassembly.

Key loggers are used a lot in targeted attacks.
They are typically custom code or built in a backdoor.
A big tip-off is that non-printable characters need to be printed out
(such as "[Ctrl]" "[RightShift]")
or time stamp printf strings.
Look for these in files.
Presence is not proof they are used.
Absence is not proof they are not used.

Java exploits.
Can parse jar file with idxparser.py and decompile Java file.
Java typially used to target tech companies.

Backdoors are the main persistence mechanism (provided externally) for malware.
Also malware typically needs command and control.

Application of Artificial Intelligence in Ad-Hoc Static Code Analysis

alt="John Ashaman" width="206" height="198" border="0" /> John Ashaman

John Ashaman, Security Innovation

Initially John tried to analyze open source files with open source static analysis tools, but these showed thousands of false positives.
Also tried using grep, but tis fails to find anything even mildly complex.

So next John decided to write his own tool.
His approach was to first generate a call graph then analyze the graph.
However, the problem is that making a call graph is really hard.
For example, one problem is "evil" coding techniques,
such as passing function pointer.

First the tool generated an Abstract Syntax Tree (AST) with the nodes
created from method declarations and edges created from method use.
Then the tool generated a control flow graph with the
goal to find a path through the AST (a maze) from source to sink.
The algorithm is to look at adjacent nodes to see if any are "scary" (a vulnerability), using heuristics for search order.

The tool, called "Scat" (Static Code Analysis Tool),
currently looks for C# vulnerabilities and some simple PHP.
Later, he plans to add more PHP, then JSP and Java.

For more information see his posts in
Security Innovation blog
and
NRefactory on GitHub.

Mask Your Checksums—The Gorry Details

alt="Eric (Xlogicx) Davisson" width="210" height="194" border="0" /> Eric (XlogicX) Davisson

Eric (XlogicX) Davisson

Sometimes in emailing or posting TCP/IP packets to analyze problems, you may want to mask the IP address.
But to do this correctly, you need to mask the checksum too, or you'll leak information about the IP.
Problem reports found in stackoverflow.com, sans.org, and pastebin.org are usually not masked, but a few companies do care.
If only the IP is masked, the IP may be guessed from checksum (that is, it leaks data).
Other parts of packet may leak more data about the IP.
TCP and IP checksums both refer to the same data, so can get more bits of information out of using both checksums than just using one checksum.
Also, one can usually determine the OS from the TTL field and ports in a packet header.

If we get hundreds of possible results (16x each masked nibble that is unknown), one can do other things to narrow the results,
such as look at packet contents for domain or geo information.
With hundreds of results, can import as CSV format into a spreadsheet.
Can corelate with geo data and see where each possibility is located.

Eric then demoed a real email report with a masked IP packet attached. Was able to find the exact IP address, given the geo and university of the sender.

Point is if you're going to mask a packet, do it right. Eric wouldn't usually bother, but do it correctly if at all, to not create a false impression of security.

Adventures with weird machines thirty years after
"Reflections on Trusting Trust"

alt="Sergey Bratus" width="183" height="157" border="0" /> Sergey Bratus

Sergey Bratus, Dartmouth College


(and Julian Bangert and Rebecca Shapiro, not present)

"Reflections on Trusting Trust" refers to Ken Thompson's classic 1984 paper.
"You can't trust code that you did not totally create yourself."
There's invisible links in the chain-of-trust, such as "well-installed microcode bugs" or in the compiler, and other planted bugs.
Thompson showed how a compiler can introduce and propagate bugs in unmodified source.

But suppose if there's no bugs and you trust the author, can you trust the code?
Hell No!
There's too many factors—it's Babylonian in nature.
Why not? Well,

• Input is not well-defined/recognized (code's assumptions about "checked" input will be violated (bug/vunerabiliy).
  
  For example, HTML is recursive, but Regex checking is not recursive.
  
  Input well-formed but so complex there's no telling what it does
  
  For example,
  
  ELF file parsing is complex and has multiple ways of parsing.
  

• Input is seen differently by different pieces of program or toolchain

Any Input is a program

• input executes on input handlers (drives state changes & transitions)


• only a well-defined execution model can be trusted (regex/DFA, PDA, CFG)


• Input handler either is a "recognizer" for the inputs as a well-defined language
  
  (see langsec.org)
  
  or it's a "virtual machine" for inputs to drive into pwn-age
  

ELF ABI (UNIX/Linux executible file format) case study.
Problems can arise from these steps (without planting bugs):

• compiler


• linker


• loader ld.so/rtld


• relocator


• DWARF (debugger info) exceptions

The problem is you can't really automatically analyze code (it's the "halting problem" and undecidable).
Only solution is to freeze code and sign it.
But you can't freeze everything!
Can't freeze ASLR or loading—must have tables and metadata.

Any sufficiently complex input data is the same as VM byte code

• Example, ELF relocation entries + dynamic symbols == a Turing Complete Machine (TM).
  

  • @bxsays created a Turing machine in Linux from relocation data (not code) in an ELF file.
    
    For more information, see Rebecca "bx" Shapiro's presentation from last year's Toorcon,
    
    
    
    "Programming Weird Machines with ELF Metadata"
    

  
  
  • @bxsays did same thing with Mach-O bytecode
  
  

  
  

• Or a DWARF exception handling data .eh_frame + glibc == Turning Machine
• X86 MMU (IDT, GDT, TSS): used address translation to create a Turning Machine.
  
  Page handler reads and writes (on page fault) memory.
  
  Uses a page table, which can be used as Turning Machine byte code.
  
  Example on Github using this TM that will fly a glider across the screen
  

Next Sergey talked about "Parser Differentials".
That having one input format, but two parsers,
will create confusion and opportunity for exploitation.
For example, CSRs are parsed during creation by cert requestor and again by another parser at the CA.

Another example is ELF—several parsers in OS tool chain, which are all different.
Can have two different Program Headers (PHDRs) because ld.so parses multiple PHDRs.
The second PHDR can completely transform the executable.
This is described in paper in the first issue of

International Journal of PoC.

Conclusions

• trusting computers not only about bugs! Bugs are part of a problem, but no by far all of it
• complex data formats means bugs
• no "chain of trust" in Babylon! (that is, with parser differentials)
• we need to squeeze complexity out of data until data stops being "code equivalent"

Further information
See
and langsec.org.USENIX WOOT 2013 (Workshop on Offensive Technologies)
for "weird machines" papers and videos.