Schneier on Security

Nick P • January 10, 2014 8:42 PM

NSA revelations have led many to make movie references like Enemy of the State. I rewatched it myself. All the conspiratorial thinking and pervasive surveillance brings another old movie to my mind though.

https://www.youtube.com/watch?v=c3gI9ms8Fdc

Good flick. Watching it again tonight. The kind of battle Truman faces in understanding and escaping their world is similar to what’s waiting for someone doing the same in our surveillance state. Just no movie magic to help.

Nick P • January 12, 2014 10:28 PM

It’s that time again: papers with cutting edge security tech!

Hopefully I won’t have to do this again for a while as I just went through almost a years worth of ACM and IEEE submissions. The more practical or interesting ones were filtered through to become this list. Threw in a few crypto papers so cryptogeeks can have fun too. A few really exciting pieces of work in here. Enjoy.

MinimaLT: Minimal-latency Networking Through Better
Security by Petulo et al

“Minimal Latency Tunneling (MinimaLT) is a new net-
work protocol that provides ubiquitous encryption for max-
imal confidentiality, including protecting packet headers.
MinimaLT provides server and user authentication, exten-
sive Denial-of-Service protections, privacy-preserving IP mo-
bility, and fast key erasure. We describe the protocol,
demonstrate its performance relative to TLS and unen-
crypted TCP/IP, and analyze its protections, including its
resilience against DoS attacks. By exploiting the proper-
ties of its cryptographic protections, MinimaLT is able to
eliminate three-way handshakes and thus create connections
faster than unencrypted TCP/IP.”

{Nick: Reading that abstract makes me say “hell yeah good work!”}

Anon-Pass: Practical Anonymous Subscriptions by Lee et al

“We present Anon-Pass, a protocol and system
for anonymous subscription services that allow users to anon-
ymously authenticate while preventing mass sharing of
credentials. Service providers cannot correlate users’ actions,
yet service providers are guaranteed that each account is in
use at most once at a given time.
A central tension in anonymous subscription services is
balancing a service provider’s computational resource use
with users’ desire for flexible access. Anon-Pass focuses on
practical anonymity, for example, in multi-media services,
making all accesses to different items (e.g. articles, songs)
appear to be from different users, but not decorrelating ac-
cess to different parts of the same item. This level of practical
anonymity allows Anon-Pass to provide users with flexible
service at low cost to the provider. We measure the perfor-
mance of a prototype and use it in several services including a
music streaming service and an unlimited-use subway pass.”

ASIST – architectural support for instruction set randomization by Papadogiannakis et al

“Code injection attacks continue to pose a threat to today’s computing systems, as they exploit software vulnerabilities to inject and execute arbitrary, malicious code. Instruction Set Randomization (ISR) is able to protect a system against remote machine code injection attacks by randomizing the instruction set of each process. This way, the attacker will inject invalid code that will fail to execute on the randomized processor. However, all the existing implementations of ISR are based on emulators and binary instrumentation tools that (i) incur a significant runtime performance overhead, (ii) limit the ease of deployment of ISR, (iii) cannot protect the underlying operating system kernel, and (iv) are vulnerable to evasion attempts trying to bypass ISR protection.

To address these issues we propose ASIST: an architecture with hardware and operating system support for ISR. We present the design and implementation of ASIST by modifying and mapping a SPARC processor onto an FPGA board and running our modified Linux kernel to support the new features. The operating system loads the randomization key of each running process into a newly defined register, and the modified processor decodes the process’s instructions with this key before execution. Moreover, ASIST protects the system against attacks that exploit kernel vulnerabilities to run arbitrary code with elevated privileges, by using a separate randomization key for the operating system. We show that ASIST transparently protects all applications and the operating system kernel from machine code injection attacks with less than 1.5% runtime overhead, while only requiring 0.7% additional hardware.”

Bringing Java’s Wild Native World under Control by Sun et al.

“For performance and for incorporating legacy libraries, many Java applications contain native-code components written in unsafe languages such as C and C++. Native-code components interoperate with Java components through the Java Native Interface (JNI). As native code is not regulated by Java’s security model, it poses serious security threats to the managed Java world. We introduce a security framework that extends Java’s security model and brings native code under control. Leveraging software-based fault isolation, the framework puts native code in a separate sandbox and allows the interaction between the native world and the Java world only through a carefully designed pathway. Two different implementations were built. In one implementation, the security framework is integrated into a Java Virtual Machine (JVM). In the second implementation, the framework is built outside of the JVM and takes advantage of JVM-independent interfaces. The second implementation provides JVM portability, at the expense of some performance degradation. Evaluation of our framework demonstrates that it incurs modest runtime overhead while significantly enhancing the security of Java applications.”

CipherXRay: Exposing Cryptographic Operations and
Transient Secrets from Monitored Binary Execution by Li et al

“To enable more effective malware analysis, forensics and
reverse engineering, we have developed CipherXRay – a novel
binary analysis framework that can automatically identify and
recover the cryptographic operations and transient secrets from
the execution of potentially obfuscated binary executables. Based
on the avalanche effect of cryptographic functions, CipherXRay
is able to accurately pinpoint the boundary of cryptographic
operation and recover truly transient cryptographic secrets
that only exist in memory for one instant in between multi-
ple nested cryptographic operations. CipherXRay can further
identify certain operation modes (e.g., ECB, CBC, CFB) of the
identified block cipher and tell whether the identified block cipher
operation is encryption or decryption in certain cases.
We have empirically validated CipherXRay with OpenSSL,
popular password safe KeePassX, the ciphers used by malware
Stuxnet, Kraken and Agobot, and a number of third party
softwares with built-in compression and checksum. CipherXRay
is able to identify various cryptographic operations and recover
cryptographic secrets that exist in memory for only a few
microseconds. Our results demonstrate that current software
implementations of cryptographic algorithms hardly achieve any
secrecy if their execution can be monitored.”

Certified Computer-Aided Cryptography: Efficient Provably
Secure Machine Code from High-Level Implementations by Almeida et al

“We present a computer-aided framework for proving con-
crete security bounds for cryptographic machine code imple-
mentations. The front-end of the framework is an interac-
tive verification tool that extends the EasyCrypt framework
to reason about relational properties of C-like programs ex-
tended with idealised probabilistic operations in the style
of code-based security proofs. The framework also incor-
porates an extension of the CompCert certified compiler to
support trusted libraries providing complex arithmetic cal-
culations or instantiating idealized components such as sam-
pling operations. This certified compiler allows us to carry
to executable code the security guarantees established at the
high-level, and is also instrumented to detect when compi-
lation may interfere with side-channel countermeasures de-
ployed in source code.
We demonstrate the applicability of the framework by ap-
plying it to the RSA-OAEP encryption scheme, as standard-
ized in PKCS#1 v2.1. The outcome is a rigorous analysis
of the advantage of an adversary to break the security of as-
sembly implementations of the algorithms specified by the
standard. The example also provides two contributions of
independent interest: it bridges the gap between computer-
assisted security proofs and real-world cryptographic imple-
mentations as described by standards such as PKCS,and
demonstrates the use of the CompCert certified compiler in
the context of cryptographic software development.”

Countering Intelligent Jamming with Full Protocol
Stack Agility by Corbett et al
{IEEE members only}

“This project aims to create a moving-target
in the network protocol stack, specifically focused on
mitigating intelligent jamming (IJ) attacks. An intelli-
gent jamming technique goes beyond applying brute-
force power at the physical link and instead exploits
vulnerabilities specific to protocols or configurations. An
IJ-equipped attacker that can gain a foothold into a
network by understanding and exploiting vulnerabilities
can operate with a much lower chance of detection and
a much more highly targeted impact on the network.
For example, one intelligent jamming technique exploits
MAC layer packet structure to selectively jam packets
originating from or destined to a specific user. This work
attempts to introduce protocol agility at all layers of the
stack to make such protocol driven attacks infeasible. Our
prototype counter-intelligent jamming (CIJ) system lever-
ages software-defined radio (SDR) and software-defined
networking (SDN) technologies that make this approach
feasible. SDRs are based on implementing communication
algorithms in software as close to the RF signal as possible.
SDRs are used for protocols like modulation and coding
at the physical and data link layers. SDN provides an
interface and abstractions allowing software definition of
network forwarding behavior such as routing. We use
the SDR/SDN combination to enable a holistic approach
that applies a variety of moving-target defenses across the
network stack.”

Demo: Inherent PUFs and Secure PRNGs on
Commercial Off-the-Shelf Microcontrollers by Herrewege et al
{ACM members only}

“Research on Physically Unclonable Functions (PUFs) has
become very popular in recent years. However, all PUFs
researched so far require either ASICs, FPGAs or a micro-
controller with external components. Our research focuses
on identifying PUFs in commercial off-the-shelf devices, e.g.
microcontrollers. We show that PUFs exist in several off-the-
shelf products, which can be used for security applications.
We present measurement results on the PUF behavior
of five of the most popular microcontrollers today: ARM
Cortex-A, ARM Cortex-M, Atmel AVR, Microchip PIC16 and
Texas Instruments MSP430. Based on these measurements,
we can calculate whether these chips can be considered for
applications requiring strong cryptography.
As a result of these findings, we present a secure bootloader
for the ARM Cortex-A9 platform based on a PUF inherent to
the device, requiring no external components. Furthermore,
instead of discarding the randomness in PUF responses, we
utilize this to create strong seeds for pseudo-random number
generators (PRNGs). The existence of a secure RNG is at
the heart of virtually every cryptographic protocol, yet very
often overlooked. We present the implementation of a strongly
seeded PRNG for the ARM Cortex-M family, again requiring
no external components.”

DNS for Massive-Scale Command and Control by Xu et al

“Attackers, in particular botnet controllers, use stealthy messaging systems to set up large-scale command and control. To systematically understand the potential capability of attackers, we investigate the feasibility of using domain name service (DNS) as a stealthy botnet command-and-control channel. We describe and quantitatively analyze several techniques that can be used to effectively hide malicious DNS activities at the network level. Our experimental evaluation makes use of a two-month-long 4.6-GB campus network data set and 1 million domain names obtained from alexa.com. We conclude that the DNS-based stealthy command-and-control channel (in particular, the codeword mode) can be very powerful for attackers, showing the need for further research by defenders in this direction. The statistical analysis of DNS payload as a countermeasure has practical limitations inhibiting its large-scale deployment.”

DriverGuard: Virtualization-Based Fine-Grained Protection on I/O Flows by Cheng et al

“Most commodity peripheral devices and their drivers are geared to achieve high performance with security functions being opted out. The absence of strong security measures invites attacks on the I/O data and consequently posts threats to those services feeding on them, such as fingerprint-based biometric authentication. In this article, we present a generic solution called DriverGuard, which dynamically protects the secrecy of I/O flows such that the I/O data are not exposed to the malicious kernel. Our design leverages a composite of cryptographic and virtualization techniques to achieve fine-grained protection without using any extra devices and modifications on user applications. We implement the DriverGuard prototype on Xen by adding around 1.7K SLOC. DriverGuard is lightweight as it only needs to protect around 2% of the driver code’s execution. We measure the performance and evaluate the security of DriverGuard with three input devices (keyboard, fingerprint reader and camera) and three output devices (printer, graphic card, and sound card). The experiment results show that DriverGuard induces negligible overhead to the applications.”

Efficient User-Space Information Flow Control by Niu and Tan

“The model of Decentralized Information Flow Control (DIFC [17])
is effective at improving application security and can support rich
confidentiality and integrity policies. We describe the design and
implementation of duPro, an efficient user-space information flow
control framework. duPro adopts Software-based Fault Isolation
(SFI [22]) to isolate protection domains within the same process. It
controls the end-to-end information flow at the granularity of SFI
domains. Being a user-space framework, duPro does not require
any OS changes. Since SFI is more lightweight than hardware-
based isolation (e.g., OS processes), the inter-domain communica-
tion and scheduling in duPro are more efficient than process-level
DIFC systems. Finally, duPro supports a novel checkpointing-
restoration mechanism for efficiently reusing protection domains.
Experiments demonstrate applications can be ported to duPro with
negligible overhead, enhanced security, and with tight control over
information flow.”

Gadge Me If You Can Secure and Efficient Ad-hoc Instruction-Level Randomization
for x86 and ARM by Davi et al

“Code reuse attacks such as return-oriented programming are
one of the most powerful threats to contemporary software.
ASLR was introduced to impede these attacks by dispersing
shared libraries and the executable in memory. However, in
practice its entropy is rather low and, more importantly, the
leakage of a single address reveals the position of a whole li-
brary in memory. The recent mitigation literature followed
the route of randomization, applied it at different stages such
as source code or the executable binary. However, the code
segments still stay in one block. In contrast to previous
work, our randomization solution, called XIFER, (1) dis-
perses all code (executable and libraries) across the whole
address space, (2) re-randomizes the address space for each
run, (3) is compatible to code signing, and (4) does neither
require offline static analysis nor source-code. Our proto-
type implementation supports the Linux ELF file format
and covers both mainstream processor architectures x86 and
ARM. Our evaluation demonstrates that XIFER performs
efficiently at load- and during run-time (1.2% overhead).”

HyperCheck: A Hardware-Assisted Integrity
Monitor by Wang et al

“The advent of cloud computing and inexpensive multi-core desktop architectures has lead to the widespread
adoption of virtualization technologies. Furthermore, security researchers embraced virtual machine monitors (VMMs) as a new mechanism to guarantee deep isolation of untrusted software components, which coupled with their popularity promoted VMMs as a prime target for exploitation. In this paper, we present HyperCheck, a hardware-assisted tampering detection framework designed to protect the integrity of hypervisors and operating systems. Our approach leverages System Management Mode (SMM), a CPU mode in x86 architecture, to transparently and securely acquire and transmit the full state of a protected machine to a remote server. We have implement two prototypes based on our framework design: HyperCheck-I and HyperCheck-II, thatvary in their security assumptions and OS code dependence. In our experiments, we are able to identify rootkits that target the integrity of both hypervisors and operating systems. We show that HyperCheck can defend against attacks that attempt to evade our system. In terms of performance, we measured that HyperCheck can communicate the entire static code of Xen hypervisor and CPU register states in less than 90 million CPU cycles, or 90 ms on a 1 GHz CPU.”

Muen – An x86/64 Separation Kernel for High Assurance 2013 Buerki and Rueegsegger

“A separation kernel (SK) is a specialized microkernel that provides an execution environment
for multiple components that can only communicate according to a given policy and are otherwise
isolated from each other. Hence, the isolation also includes the limitation of potential side- and
covert channels. SKs are generally more static and smaller than dynamic microkernels, which
minimizes the possibility of kernel failure and should ease the application of formal verification
techniques.
Recent addition of advanced hardware virtualization support for the Intel x86 architecture
has the potential of greatly simplifying the implementation of a separation kernel which can
support complex systems.
This thesis presents a design of a separation kernel for the Intel x86 architecture using the
latest Intel hardware features. An open-source prototype written in SPARK demonstrates the
viability of the envisioned concept and the application of SPARK’s proof capabilities increases
the assurance of the correctness of the implementation.”

PICCO: A General-Purpose Compiler for Private
Distributed Computation by Zhang et al

“Secure computation on private data has been an active area of re-
search for many years and has received a renewed interest with
the emergence of cloud computing. In recent years, substantial
progress has been made with respect to the efficiency of the avail-
able techniques and several implementations have appeared. The
available tools, however, lacked a convenient mechanism for im-
plementing a general-purpose program in a secure computation
framework suitable for execution in not fully trusted environments.
This work fulfills this gap and describes a system, called PICCO,
for converting a program written in an extension of C into its dis-
tributed secure implementation and running it in a distributed envi-
ronment. The C extension preserves all current features of the pro-
gramming language and allows variables to be marked as private
and be used in general-purpose computation. Secure distributed
implementation of compiled programs is based on linear secret
sharing, achieving efficiency and information-theoretical security.
Our experiments also indicate that many programs can be evaluated
very efficiently on private data using PICCO.”

PHANTOM: Practical Oblivious Computation
in a Secure Processor by Maas et al

“We introduce Phantom , a new secure processor that ob-
fuscates its memory access trace. To an adversary who can
observe the processor’s output pins, all memory access traces
are computationally indistinguishable (a property known as
obliviousness). We achieve obliviousness through a crypto-
graphic construct known as Oblivious RAM or ORAM. We
first improve an existing ORAM algorithm and construct an
empirical model for its trusted storage requirement. We then
present Phantom, an oblivious processor whose novel mem-
ory controller aggressively exploits DRAM bank parallelism
to reduce ORAM access latency and scales well to a large
number of memory channels. Finally, we build a complete
hardware implementation of Phantom on a commercially
available FPGA-based server, and through detailed exper-
iments show that Phantom is efficient in both area and
performance. Accessing 4KB of data from a 1GB ORAM
takes 26.2us (13.5us for the data to be available), a 32×
slowdown over accessing 4KB from regular memory, while
SQLite queries on a population database see 1.2 − 6× slow-
down. Phantom is the first demonstration of a practical,
oblivious processor and can provide strong confidentiality
guarantees when offloading computation to the cloud.”

OASIS: On Achieving a Sanctuary for Integrity and Secrecy
on Untrusted Platforms by Owusu et al

“We present OASIS, a CPU instruction set extension for ex-
ternally verifiable initiation, execution, and termination of
an isolated execution environment with a trusted computing
base consisting solely of the CPU. OASIS leverages the hard-
ware components available on commodity CPUs to achieve
a low-cost, low-overhead design.”

Monitor Integrity Protection with Space Efficiency and
Separate Compilation by Niu and Tan 2013

“Low-level inlined reference monitors weave monitor code into a
program for security. To ensure that monitor code cannot be by-
passed by branching instructions, some form of control-flow in-
tegrity must be guaranteed. Past approaches to protecting moni-
tor code either have high space overhead or do not support sepa-
rate compilation. We present Monitor Integrity Protection (MIP),
a form of coarse-grained control-flow integrity. The key idea of
MIP is to arrange instructions in variable-sized chunks and dynami-
cally restrict indirect branches to target only chunk beginnings. We
show that this simple idea is effective in protecting monitor code
integrity, enjoys low space and execution-time overhead, supports
separate compilation, and is largely compatible with an existing
compiler toolchain. We also show that MIP enables a separate ver-
ifier that completely disassembles a binary and verifies its security.
MIP is designed to support inlined reference monitors. As a case
study, we have implemented MIP-based Software-based Fault Iso-
lation (SFI) on both x86-32 and x86-64. The evaluation shows that
MIP-based SFI has competitive performance with other SFI imple-
mentations, while enjoying low space overhead.”

{Nick: People doing projects should learn MIPS or SPARC. Just like my last list, it seems most prototypes in this one are done on those.)

Practical and Post-Quantum Authenticated Key Exchange
from One-Way Secure Key Encapsulation Mechanism by Fujioka et al
{ACM members only}

“This paper discusses how to realize practical post-quantum authen-
ticated key exchange (AKE) with strong security, i.e., CK+ secu-
rity (Krawczyk, CRYPTO 2005). It is known that strongly secure
post-quantum AKE protocols exist on a generic construction from
IND-CCA secure key encapsulation mechanisms (KEMs) in the
standard model. However, when it is instantiated with existing
IND-CCA secure post-quantum KEMs, resultant AKE protocols
are far from practical in communication complexity. We propose
a generic construction of AKE protocols from OW-CCA secure
KEMs and prove CK+ security of the protocols in the random ora-
cle model. We exploit the random oracle and instantiate AKE pro-
tocols from various assumptions; DDH, gap DH, CDH, factoring,
RSA, DCR, (ring-)LWE, McEliece one-way, NTRU one-way, sub-
set sum, multi-variate quadratic systems, and more. For example,
communication costs of our lattice-based scheme is approximately
14 times lower than the previous instantiation (for 128-bit secu-
rity). Also, in the case of code-based scheme, it is approximately
25 times lower.”

Process Authentication for High System
Assurance by Almohri et al

“This paper points out the need in modern operating system kernels for a process authentication mechanism, where a
process of a user-level application proves its identity to the kernel. Process authentication is different from process identification. Identification is a way to describe a principal; PIDs or process names are identifiers for processes in an OS environment. However, the information such as process names or executable paths that is conventionally used by OS to identify a process is not reliable. As a result, malware may impersonate other processes, thus violating system assurance. We propose a lightweight secure application authentication framework in which user-level applications are required to present proofs at run time to be authenticated to the kernel. To demonstrate the application of process authentication, we develop a system call monitoring framework for preventing unauthorized use or access of system resources. It verifies the identity of processes before completing the requested system calls. We implement and evaluate a prototype of our monitoring architecture in Linux. The results from our extensive performance evaluation shows that our prototype incurs reasonably low overhead, indicating the feasibility of our approach for cryptographically authenticating applications and their processes in the operating system.”

Sechduler: A Security-Aware Kernel Scheduler by Haghani et al
{ACM members only}

“Trustworthy operation of safety-critical infrastructures necessitates
efficient solutions that satisfy both realtimeness and security re-
quirements simultaneously. We present Sechduler, a formally ver-
ifiable security-aware operating system scheduler that dynamically
makes sure that system computational resources are allocated to
individual waiting tasks in an optimal order such that, if feasible,
neither realtime nor security requirements of the system are vio-
lated. Additionally, if not both of the requirements can be satisfied
simultaneously, Sechduler makes use of easy-to-define linear tem-
poral logic-based policies as well as automatically generated Büchi
automaton-based monitors, compiled as loadable kernel modules,
to enforce which requirements should get the priority. Our ex-
perimental results show that Sechduler can adaptively enforce the
system-wide logic-based temporal policies within the kernel and
with minimal performance overhead of 3% on average to guarantee
high level of combined security and realtimeness simultaneously.”

SHAMROCK: Self Contained Cryptography and
Key Management Processor by Utin et al
{ACM members only}

“In this poster, we describe a one-size-fits-many Intellectual
Property (IP) core which integrates advanced key management
technology and streaming encryption into a single component to
protect data in-transit.”

{Nick: something to imitate with an open design perhaps.}

THINC: A Virtual Display Architecture
for Thin-Client Computing by Barratto et al

“Rapid improvements in network bandwidth, cost, and ubiq-
uity combined with the security hazards and high total cost
of ownership of personal computers have created a growing
market for thin-client computing. We introduce THINC, a
virtual display architecture for high-performance thin-client
computing in both LAN and WAN environments. THINC
virtualizes the display at the device driver interface to trans-
parently intercept application display commands and trans-
late them into a few simple low-level commands that can be
easily supported by widely used client hardware. THINC’s
translation mechanism efficiently leverages display semantic
information through novel optimizations such as offscreen
drawing awareness, native video support, and server-side
screen scaling. This is integrated with an update delivery ar-
chitecture that uses shortest command first scheduling and
non-blocking operation. THINC leverages existing display
system functionality and works seamlessly with unmodified
applications, window systems, and operating systems.
We have implemented THINC in an X/Linux environ-
ment and compared its performance against widely used
commercial approaches, including Citrix MetaFrame, Mi-
crosoft RDP, GoToMyPC, X, NX, VNC, and Sun Ray. Our
experimental results on web and audio/video applications
demonstrate that THINC can provide up to 4.8 times faster
web browsing performance and two orders of magnitude bet-
ter audio/video performance. THINC is the only thin client
capable of transparently playing full-screen video and au-
dio at full frame rate in both LAN and WAN environments.
Our results also show for the first time that thin clients can
even provide good performance using remote clients located
in other countries around the world.”

{Nick: Thin clients can help with many security issues. Some already made to run on GEMSOS & MILS kernels. This should help their performance issue.}

Virtual Browser: a Virtualized Browser to Sandbox
Third-party JavaScripts with Enhanced Security by Cao et al

“Third party JavaScripts not only offer much richer features
to the web and its applications but also introduce new threats.
These scripts cannot be completely trusted and executed
with the privileges given to host web sites. Due to incom-
plete virtualization and lack of tracking all the data flows,
all existing approaches without native sandbox support can
secure only a subset of third party JavaScripts, and they
are vulnerable to attacks encoded in non-standard HTML/-
JavaScript (browser quirks) as these approaches will parse
third party JavaScripts independently at server side without
considering client-side non-standard parsing quirks. At the
same time, native sandboxes are vulnerable to attacks based
on unknown native JavaScript engine bugs.
In this paper, we propose Virtual Browser, a full browser-
level virtualized environment within existing browsers for
executing untrusted third party code. Our approach sup-
ports more complete JavaScript language features including
those hard-to-secure functions, such as with and eval. Since
Virtual Browser does not rely on native browser parsing
behavior, there is no possibility of attacks being executed
through browser quirks. Moreover, given the third-party
Javascripts are running in Virtual Browser instead of native
browsers, it is harder for the attackers to exploit unknown
vulnerabilities in the native JavaScript engine. In our de-
sign, we first completely isolate Virtual Browser from the na-
tive browser components and then introduce communication
by adding data flows carefully examined for security. The
evaluation of the Virtual Browser prototype shows that our
execution speed is the same as Microsoft Web Sandbox[27],
a state of the art runtime web-level sandbox. In addition,
Virtual Browser is more secure and supports more complete
JavaScript for third party JavaScript development.”

{Nick: Interesting is all I’ll say. Merits further research & evaluation before I’d speak to its security.}

librando: Transparent Code Randomization for Just-in-Time Compilers by Homescu et al
{ACM members only}

“Just-in-time compilers (JITs) are here to stay. Unfortunately, they
also provide new capabilities to cyber attackers, namely the ability
to supply input programs (in languages such as JavaScript) that will
then be compiled to executable code. Once this code is placed and
marked as executable, it can then be leveraged by the attacker.
Randomization techniques such as constant blinding raise the
cost to the attacker, but they significantly add to the burden of
implementing a JIT. There are a great many JITs in use today, but not
even all of the most commonly used ones randomize their outputs.
We present librando, the first comprehensive technique to harden
JIT compilers in a completely generic manner by randomizing their
output transparently ex post facto. We implement this approach
as a system-wide service that can simultaneously harden multiple
running JITs. It hooks into the memory protections of the target OS
and randomizes newly generated code on the fly when marked as
executable.”

Protecting Sensitive Web Content from Client-side Vulnerabilities with CRYPTONs by Dong et al.

“Web browsers isolate web origins, but do not provide direct abstrac-
tions to isolate sensitive data and control computation over it within
the same origin. As a result, guaranteeing security of sensitive web
content requires trusting all code in the browser and client-side ap-
plications to be vulnerability-free. In this paper, we propose a new
abstraction, called C RYPTON, which supports intra-origin control
over sensitive data throughout its life cycle. To securely enforce
the semantics of C RYPTONs, we develop a standalone component
called C RYPTON -K ERNEL, which extensively leverages the func-
tionality of existing web browsers without relying on their large
TCB. Our evaluation demonstrates that the C RYPTON abstraction
supported by the C RYPTON -K ERNEL is widely applicable to pop-
ular real-world applications with millions of users, including web-
mail, chat, blog applications, and Alexa Top 50 websites, with low
performance overhead.”

TinySec: A Link Layer Security Architecture for Wireless Sensor Networks by Karlof et al

“We introduce TinySec: the first fully-implemented link layer encryption architecture for wireless sensor networks. In our design, we leveraged recent lessons learned from design vulnerabilities in… 802.11b and GSM. Conventional protocols tend to be very conservative in their security guarantees, typically only adding 16-32 bytes of overhead. With small memories, weak processors, limited energy, and 30 byte packets, sensor networks can’t afford this luxury. TinySec addresses these extreme resource constraints with careful design; we explore the tradeoffs among different cryptographic primitives and use the inherent sensor network limitations to our advantage when choosing parameters to find a sweet spot for security, packet overhead, and resource requirements. TinySec is portable to a variety of hardware and radio platforms. Our experimental results on a 36 node distributed sensor network application clearly demonstrates that software based link layer protocols are feasible and efficient, adding less than 10% energy, latency and bandwidth overhead.”

N-Variant Systems A Secretless Framework for Security through Diversity by Cox et al

“We present an architectural framework for systematically using automated diversity to provide high assurance detection and disruption for large classes of attacks. The framework executes a set of automatically diversified variants on the same inputs, and monitors their behavior to detect divergences. The benefit of this approach is that it requires an attacker to simultaneously compromise all system variants with the same input. By constructing variants with disjoint exploitation sets, we can make it impossible to carry out large classes of important attacks. In contrast to previous approaches that use automated diversity for security, our approach does not rely on keeping any secrets. In this paper, we introduce the N-variant systems framework, present a model for analyzing security properties of N-variant systems, define variations that can be used to detect attacks that involve referencing absolute memory addresses and executing injected code, and describe and present performance results from a prototype implementation”

{Nick: Clive Robinson you might like reading this one considering your interest in voter-based schemes.}

Nick P • January 13, 2014 11:57 AM

@ Clive Robinson

Thanks for the link. I’ll check it out.

Re papers

Yeah, I agree. It’s probably the reason I’m about the only person doing it. The thing I’ve found easiest with a list the size of mine is to just look at abstracts, jot down which sound most interesting, and then look at them first. Even if you only looked at five after sorting by abstract I’m sure you’d pull out the best work of the bunch.

Nick P • January 14, 2014 12:05 AM

@ Nate

Good thinking. The NSA and VMware partnership was actually well known as I posted their HAP efforts here years ago. You can even buy it from General Dynamics. I recommended it for people looking for an affordable, strong COTS solution who were more worried about non-NSA attackers.

That the injected NSA HAP tech might have a backdoor should be assumed.

Nick P • January 14, 2014 9:54 AM

@ figureitout

“Also, just a thought, couldn’t memory encryption disastrously be used against you if you lose control of it? Sometimes I wonder if pure plaintext code as low as we can get is better; for small devices heavily isolated that is.”

If it’s unrecoverable for us, it’s unrecoverable for them. That’s same as solid disk encryption. I know this because recovery companies couldn’t get my several years of work back when my main HD and backup failed within a month of each other. Remember, though, that data can be extracted from the system to other media in a secure backup process. The resulting data can be stored in whatever way you want, even unencrypted. Different tradeoffs for different people.

“Admittedly I have a hard time seeing them b/c I’ve only read the abstracts and not all the papers; got them on a flash. And it’s like a decent sized book of papers so probably will be a while. Anyway, just wondering about actual implementations of these ideas.”

I’m not promoting any of these as the next best thing. Of all the papers I saw in security sections of ACM and IEEE, I thought these might interest Schneier readers more than most. And some might lead to a useful piece of software. Far as implementation, quite a few have been implemented by authors and some are online for download. Papers also often have enough detail that someone can reimplement from scratch.

My last big paper release has the best techniques. These are a supplement release that might add something useful to them. MinimaLT is particularly exciting seeing who it comes from. The one implementing SFI is also interesting as that’s one of leading techniques in defense. And several seamlessly introduce randomization. No secret that I like presenting attackers with a scrambled picture of things. A few were kind of radical (eg PHANTOM) so they’re mainly there for a thought-provoking read.