Sandboxing and Workload Isolation
https://fly.io/blog/sandboxing-and-workload-isolation/ [fly.io]
2021-01-10 00:19
tags:
defense
development
security
unix
virtualization
Workload isolation makes it harder for a vulnerability in one service to compromise every other part of the platform. It has a long history going back to 1990s qmail, and we generally agree that it’s a good, useful thing.
From chroot to privsep to docker to firecracker.
Rust programming language exploit mitigations
http://rcvalle.blog/2020/09/16/rust-lang-exploit-mitigations/ [rcvalle.blog]
2020-10-02 21:28
tags:
compiler
defense
development
rust
security
This section documents the exploit mitigations applicable to the Rust compiler when building programs for the Linux operating system on the AMD64 architecture and equivalent.
source: L
The core of Apple is PPL: Breaking the XNU kernel's kernel
https://googleprojectzero.blogspot.com/2020/07/the-core-of-apple-is-ppl-breaking-xnu.html [googleprojectzero.blogspot.com]
2020-08-01 01:27
tags:
defense
exploit
iphone
malloc
programming
security
systems
While doing research for the one-byte exploit technique, I considered several ways it might be possible to bypass Apple’s Page Protection Layer (PPL) using just a physical address mapping primitive, that is, before obtaining kernel read/write or defeating PAC. Given that PPL is even more privileged than the rest of the XNU kernel, the idea of compromising PPL “before” XNU was appealing. In the end, though, I wasn’t able to think of a way to break PPL using the physical mapping primitive alone.
However, it’s not the Project Zero way to leave any mitigation unbroken. So, having exhausted my search for design flaws, I returned to the ever-faithful technique of memory corruption. Sure enough, decompiling a few PPL functions in IDA was sufficient to find some memory corruption.
A Technical Look at Intel’s Control-flow Enforcement Technology
https://software.intel.com/content/www/us/en/develop/articles/technical-look-control-flow-enforcement-technology.html [software.intel.com]
2020-06-15 21:21
tags:
cpu
defense
security
Since ROP relies on RET instructions, where the address of the next instruction to execute is fetched from a stack, stack corruption plays a critical role in ROP attacks. CET enables the OS to create a Shadow Stack, which is designed to be protected from application code memory accesses, and stores CPU-stored copies of the return addresses. This helps ensure that even when an attacker is able to modify/corrupt the return addresses in the data stack for the purpose of carrying out a ROP attack, the attacker is not able to modify the Shadow Stack, and the CET state machine in the CPU detects mismatches between the address on the shadow and data stack to help prevent the attack via an exception reported to the OS.
Unicode Security Considerations
https://unicode.org/reports/tr36/ [unicode.org]
2020-06-11 17:41
tags:
defense
language
security
text
turtles
Because Unicode contains such a large number of characters and incorporates the varied writing systems of the world, incorrect usage can expose programs or systems to possible security attacks. This is especially important as more and more products are internationalized. This document describes some of the security considerations that programmers, system analysts, standards developers, and users should take into account, and provides specific recommendations to reduce the risk of problems.
A large number of problems as well.
source: solar
Before you ship a "security mitigation" ...
http://addxorrol.blogspot.com/2020/03/before-you-ship-security-mitigation.html [addxorrol.blogspot.com]
2020-04-10 00:48
tags:
defense
development
security
During my years doing vulnerability research and my time in Project Zero, I frequently encountered proposals for new security mitigations. Some of these were great, some of these - were not so great.
I think Halvar is at times too dismissive of “raising the bar”, but he’s also the expert here, and these are not bad guidelines.
source: grugq
AWS re:Invent 2019: Speculation & leakage: Timing side channels & multi-tenant computing
https://www.youtube.com/watch?v=kQ4H6XO-iao [www.youtube.com]
2020-03-28 02:59
tags:
cloud
cpu
defense
security
sidechannel
video
virtualization
In January 2018, the world learned about Spectre and Meltdown, a new class of issues that affects virtually all modern CPUs via nearly imperceptible changes to their micro-architectural states and can result in full access to physical RAM or leaking of state between threads, processes, or guests. In this session, we examine one of these side-channel attacks in detail and explore the implications for multi-tenant computing. We discuss AWS design decisions and what AWS does to protect your instances, containers, and function invocations. Finally, we discuss what the future looks like in the presence of this new class of issue.
This is a good recap. Specific defenses starts around 42:00.
Speculative Load Hardening
https://llvm.org/docs/SpeculativeLoadHardening.html [llvm.org]
2020-01-09 20:40
tags:
c
compiler
cxx
defense
development
security
sidechannel
While several approaches are being actively pursued to mitigate specific branches and/or loads inside especially risky software (most notably various OS kernels), these approaches require manual and/or static analysis aided auditing of code and explicit source changes to apply the mitigation. They are unlikely to scale well to large applications. We are proposing a comprehensive mitigation approach that would apply automatically across an entire program rather than through manual changes to the code. While this is likely to have a high performance cost, some applications may be in a good position to take this performance / security tradeoff.
OpenSSH Key Shielding
https://xorhash.gitlab.io/xhblog/0010.html [xorhash.gitlab.io]
2019-12-18 13:48
tags:
crypto
defense
openbsd
programming
random
security
sidechannel
On June 21, 2019, support for SSH key shielding was introduced into the OpenBSD tree, from which the OpenSSH releases are derived. SSH key shielding is a measure intended to protect private keys in RAM against attacks that abuse bugs in speculative execution that current CPUs exhibit. This functionality has been part of OpenSSH since the 8.1 release. SSH private keys are now being held in memory in a shielded form; keys are only unshielded when they are used and re‐shielded as soon as they are no longer in active use. When a key is shielded, it is encrypted in memory with AES‐256‐CTR; this is how it works:
source: L
Pointer Authentication
https://github.com/apple/llvm-project/blob/apple/master/clang/docs/PointerAuthentication.rst [github.com]
2019-12-15 21:48
tags:
c
compiler
cpu
defense
development
hash
programming
security
Pointer authentication is a technology which offers strong probabilistic protection against exploiting a broad class of memory bugs to take control of program execution. When adopted consistently in a language ABI, it provides a form of relatively fine-grained control flow integrity (CFI) check that resists both return-oriented programming (ROP) and jump-oriented programming (JOP) attacks.
While pointer authentication can be implemented purely in software, direct hardware support (e.g. as provided by ARMv8.3) can dramatically lower the execution speed and code size costs. Similarly, while pointer authentication can be implemented on any architecture, taking advantage of the (typically) excess addressing range of a target with 64-bit pointers minimizes the impact on memory performance and can allow interoperation with existing code (by disabling pointer authentication dynamically). This document will generally attempt to present the pointer authentication feature independent of any hardware implementation or ABI. Considerations that are implementation-specific are clearly identified throughout.
source: HN
Defense in depth against SSRF vulnerabilities with the EC2 Instance Metadata Service
https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/ [aws.amazon.com]
2019-11-22 03:26
tags:
bugfix
cloud
defense
security
web
Today, AWS is making v2 of the EC2 Instance Metadata Service (IMDSv2) available. The existing instance metadata service (IMDSv1) is fully secure, and AWS will continue to support it. But IMDSv2 adds new “belt and suspenders” protections for four types of vulnerabilities that could be used to try to access the IMDS. These new protections go well beyond other types of mitigations, while working seamlessly with existing mitigations such as restricting IAM roles and using local firewall rules to restrict access to the IMDS. AWS is also making new versions of the AWS SDKs and CLIs available that support IMDSv2.
Eh, seems this could have been better from the start, but oh well.
Some near-term arm64 hardening patches
https://lwn.net/Articles/804982/ [lwn.net]
2019-11-19 04:15
tags:
defense
linux
security
The arm64 architecture is found at the core of many, if not most, mobile devices; that means that arm64 devices are destined to be the target of attackers worldwide. That has led to a high level of interest in technologies that can harden these systems. There are currently several such technologies, based in both hardware and software, that are being readied for the arm64 kernel; read on for a survey on what is coming.
source: HN
The Bytecode Alliance: Building a secure, composable future for WebAssembly
https://hacks.mozilla.org/2019/11/announcing-the-bytecode-alliance/ [hacks.mozilla.org]
2019-11-13 00:29
tags:
defense
development
library
security
systems
vapor
virtualization
wasm
We have a vision of a WebAssembly ecosystem that is secure by default, fixing cracks in today’s software foundations. And based on advances rapidly emerging in the WebAssembly community, we believe we can make this vision real.
WebAssembly can provide the kind of isolation that makes it safe to run untrusted code. We can have an architecture that’s like Unix’s many small processes, or like containers and microservices. But this isolation is much lighter weight, and the communication between them isn’t much slower than a regular function call. This means you can use them to wrap a single WebAssembly module instance, or a small collection of module instances that want to share things like memory among themselves.
source: HN
Two New Tools that Tame the Treachery of Files
https://blog.trailofbits.com/2019/11/01/two-new-tools-that-tame-the-treachery-of-files/ [blog.trailofbits.com]
2019-11-04 07:25
tags:
defense
development
format
programming
release
security
swtools
turtles
Parsing is hard, even when a file format is well specified. But when the specification is ambiguous, it leads to unintended and strange parser and interpreter behaviors that make file formats susceptible to security vulnerabilities. What if we could automatically generate a “safe” subset of any file format, along with an associated, verified parser? That’s our collective goal in Dr. Sergey Bratus’s DARPA SafeDocs program.
We’ve developed two new tools that take the pain out of parsing and make file formats safer:
PolyFile: A polyglot-aware file identification utility with manually instrumented parsers that can semantically label the bytes of a file hierarchically; and
PolyTracker: An automated instrumentation framework that efficiently tracks input file taint through the execution of a program.
source: grugq
Defense at Scale
https://www.netmeister.org/blog/defense-at-scale.html [www.netmeister.org]
2019-10-01 05:54
tags:
admin
cloud
defense
security
Last year, my colleague Chris Rohlf gave a keynote at BSidesNOLA entitled “Offense at Scale”. Offense sounds fun. Pwn all the things. And you’re always going to win! And normally I’m a big fan of being massively offensive. Unfortunately, I find myself on the defense when it comes to information security.
Here’s how you defend at scale. Can’t be done. The end. Everything’s fucked. You’re pwned.
Plenty of good points here. Also a fun read.
source: grugq
APRR - Access Protection ReRouting
https://siguza.github.io/APRR/ [siguza.github.io]
2019-08-09 01:57
tags:
cpu
defense
investigation
iphone
malloc
programming
security
systems
Almost a year ago I did a write-up on KTRR, first introduced in Apple’s A10 chip series. Now over the course of the last year, there has been a good bit of talk as well as confusion about the new mitigations shipped with Apple’s A12. One big change, PAC, has already been torn down in detail by Brandon Azad, so I’m gonna leave that out here. What’s left to cover is more than just APRR, but APRR is certainly the biggest chunk, hence the title of this post.
APRR is a pretty cool feature, even if parts of it are kinda broke. What I really like about it (besides the fact that it is an efficient and elegant solution to switching privileges) is that it untangles EL1 and EL0 memory permissions, giving you more flexibility than a standard ARMv8 implementation. What I don’t like though is that it has clearly been designed as a lockdown feature, allowing you only to take permissions away rather than freely remap them.
It’s also evident that Apple is really fond of post-exploit mitigations, or just mitigations in general. And on one hand, getting control over the physical address space is a good bit harder now. But on the other hand, Apple’s stacking of mitigations is taking a problematic turn when adding new mitigations actively creates vulnerabilities now.
source: L
Adopting the Arm Memory Tagging Extension in Android
https://security.googleblog.com/2019/08/adopting-arm-memory-tagging-extension.html [security.googleblog.com]
2019-08-04 16:54
tags:
android
cpu
defense
development
security
update
vapor
As part of our continuous commitment to improve the security of the Android ecosystem, we are partnering with Arm to design the memory tagging extension (MTE). Memory safety bugs, common in C and C++, remain one of the largest vulnerabilities in the Android platform and although there have been previous hardening efforts, memory safety bugs comprised more than half of the high priority security bugs in Android 9.
We believe that memory tagging will detect the most common classes of memory safety bugs in the wild, helping vendors identify and fix them, discouraging malicious actors from exploiting them. During the past year, our team has been working to ensure readiness of the Android platform and application software for MTE. We have deployed HWASAN, a software implementation of the memory tagging concept, to test our entire platform and a few select apps. This deployment has uncovered close to 100 memory safety bugs. The majority of these bugs were detected on HWASAN enabled phones in everyday use. MTE will greatly improve upon this in terms of overhead, ease of deployment, and scale. In parallel, we have been working on supporting MTE in the LLVM compiler toolchain and in the Linux kernel. The Android platform support for MTE will be complete by the time of silicon availability.
source: grugq
Map Guard and Intel MPK
https://struct.github.io/mapguard.html [struct.github.io]
2019-07-29 00:04
tags:
c
defense
library
malloc
programming
security
Earlier this year I pushed a small library to Github called Map Guard. The goal of Map Guard is to enforce non-invasive security policies with regards to how pages of memory may be allocated, or modified, with the mmap syscall. For example, we may want to deny any page allocations marked Read, Write, and Execute as it introduces an easy mechanism for an exploit developer to take advantage of. In the rest of this post I will break down the approach I took to implement each of these security policies, and finally how Map Guard uses Intel’s Memory Protection Keys to allow transparently enabling Execute Only memory for all regions of mapped code.
source: grugq
security things in Linux v5.2
https://outflux.net/blog/archives/2019/07/17/security-things-in-linux-v5-2/ [outflux.net]
2019-07-18 19:17
tags:
defense
development
linux
malloc
security
update
page allocator freelist randomization
And some other things as well.
security things in Linux v5.1
https://outflux.net/blog/archives/2019/05/27/security-things-in-linux-v5-1/ [outflux.net]
2019-05-28 15:50
tags:
defense
linux
security
Linux kernel v5.1 has been released! Here are some security-related things that stood out to me: