cff5bef948
The KCFI sanitizer, enabled with `-fsanitize=kcfi`, implements a
forward-edge control flow integrity scheme for indirect calls. It
uses a !kcfi_type metadata node to attach a type identifier for each
function and injects verification code before indirect calls.
Unlike the current CFI schemes implemented in LLVM, KCFI does not
require LTO, does not alter function references to point to a jump
table, and never breaks function address equality. KCFI is intended
to be used in low-level code, such as operating system kernels,
where the existing schemes can cause undue complications because
of the aforementioned properties. However, unlike the existing
schemes, KCFI is limited to validating only function pointers and is
not compatible with executable-only memory.
KCFI does not provide runtime support, but always traps when a
type mismatch is encountered. Users of the scheme are expected
to handle the trap. With `-fsanitize=kcfi`, Clang emits a `kcfi`
operand bundle to indirect calls, and LLVM lowers this to a
known architecture-specific sequence of instructions for each
callsite to make runtime patching easier for users who require this
functionality.
A KCFI type identifier is a 32-bit constant produced by taking the
lower half of xxHash64 from a C++ mangled typename. If a program
contains indirect calls to assembly functions, they must be
manually annotated with the expected type identifiers to prevent
errors. To make this easier, Clang generates a weak SHN_ABS
`__kcfi_typeid_<function>` symbol for each address-taken function
declaration, which can be used to annotate functions in assembly
as long as at least one C translation unit linked into the program
takes the function address. For example on AArch64, we might have
the following code:
```
.c:
int f(void);
int (*p)(void) = f;
p();
.s:
.4byte __kcfi_typeid_f
.global f
f:
...
```
Note that X86 uses a different preamble format for compatibility
with Linux kernel tooling. See the comments in
`X86AsmPrinter::emitKCFITypeId` for details.
As users of KCFI may need to locate trap locations for binary
validation and error handling, LLVM can additionally emit the
locations of traps to a `.kcfi_traps` section.
Similarly to other sanitizers, KCFI checking can be disabled for a
function with a `no_sanitize("kcfi")` function attribute.
Relands 67504c9549 with a fix for
32-bit builds.
Reviewed By: nickdesaulniers, kees, joaomoreira, MaskRay
Differential Revision: https://reviews.llvm.org/D119296
116 lines
3.7 KiB
C++
116 lines
3.7 KiB
C++
//===---- AArch64KCFI.cpp - Implements KCFI -------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements KCFI indirect call checking.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "AArch64.h"
|
|
#include "AArch64InstrInfo.h"
|
|
#include "AArch64Subtarget.h"
|
|
#include "AArch64TargetMachine.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
#include "llvm/CodeGen/MachineInstrBundle.h"
|
|
#include "llvm/CodeGen/MachineModuleInfo.h"
|
|
|
|
using namespace llvm;
|
|
|
|
#define DEBUG_TYPE "aarch64-kcfi"
|
|
#define AARCH64_KCFI_PASS_NAME "Insert KCFI indirect call checks"
|
|
|
|
STATISTIC(NumKCFIChecksAdded, "Number of indirect call checks added");
|
|
|
|
namespace {
|
|
class AArch64KCFI : public MachineFunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
AArch64KCFI() : MachineFunctionPass(ID) {}
|
|
|
|
StringRef getPassName() const override { return AARCH64_KCFI_PASS_NAME; }
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
|
|
|
private:
|
|
/// Machine instruction info used throughout the class.
|
|
const AArch64InstrInfo *TII = nullptr;
|
|
|
|
/// Emits a KCFI check before an indirect call.
|
|
/// \returns true if the check was added and false otherwise.
|
|
bool emitCheck(MachineBasicBlock &MBB,
|
|
MachineBasicBlock::instr_iterator I) const;
|
|
};
|
|
|
|
char AArch64KCFI::ID = 0;
|
|
} // end anonymous namespace
|
|
|
|
INITIALIZE_PASS(AArch64KCFI, DEBUG_TYPE, AARCH64_KCFI_PASS_NAME, false, false)
|
|
|
|
FunctionPass *llvm::createAArch64KCFIPass() { return new AArch64KCFI(); }
|
|
|
|
bool AArch64KCFI::emitCheck(MachineBasicBlock &MBB,
|
|
MachineBasicBlock::instr_iterator MBBI) const {
|
|
assert(TII && "Target instruction info was not initialized");
|
|
|
|
// If the call instruction is bundled, we can only emit a check safely if
|
|
// it's the first instruction in the bundle.
|
|
if (MBBI->isBundled() && !std::prev(MBBI)->isBundle())
|
|
report_fatal_error("Cannot emit a KCFI check for a bundled call");
|
|
|
|
switch (MBBI->getOpcode()) {
|
|
case AArch64::BLR:
|
|
case AArch64::BLRNoIP:
|
|
case AArch64::TCRETURNri:
|
|
case AArch64::TCRETURNriBTI:
|
|
break;
|
|
default:
|
|
llvm_unreachable("Unexpected CFI call opcode");
|
|
}
|
|
|
|
MachineOperand &Target = MBBI->getOperand(0);
|
|
assert(Target.isReg() && "Invalid target operand for an indirect call");
|
|
Target.setIsRenamable(false);
|
|
|
|
MachineInstr *Check =
|
|
BuildMI(MBB, MBBI, MBBI->getDebugLoc(), TII->get(AArch64::KCFI_CHECK))
|
|
.addReg(Target.getReg())
|
|
.addImm(MBBI->getCFIType())
|
|
.getInstr();
|
|
MBBI->setCFIType(*MBB.getParent(), 0);
|
|
|
|
// If not already bundled, bundle the check and the call to prevent
|
|
// further changes.
|
|
if (!MBBI->isBundled())
|
|
finalizeBundle(MBB, Check->getIterator(), std::next(MBBI->getIterator()));
|
|
|
|
++NumKCFIChecksAdded;
|
|
return true;
|
|
}
|
|
|
|
bool AArch64KCFI::runOnMachineFunction(MachineFunction &MF) {
|
|
const Module *M = MF.getMMI().getModule();
|
|
if (!M->getModuleFlag("kcfi"))
|
|
return false;
|
|
|
|
const auto &SubTarget = MF.getSubtarget<AArch64Subtarget>();
|
|
TII = SubTarget.getInstrInfo();
|
|
|
|
bool Changed = false;
|
|
for (MachineBasicBlock &MBB : MF) {
|
|
for (MachineBasicBlock::instr_iterator MII = MBB.instr_begin(),
|
|
MIE = MBB.instr_end();
|
|
MII != MIE; ++MII) {
|
|
if (MII->isCall() && MII->getCFIType())
|
|
Changed |= emitCheck(MBB, MII);
|
|
}
|
|
}
|
|
|
|
return Changed;
|
|
}
|