127 lines
3.4 KiB
C++
127 lines
3.4 KiB
C++
// Copyright 2017 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "base/memory/protected_memory.h"
|
|
#include "base/cfi_buildflags.h"
|
|
#include "base/memory/protected_memory_cfi.h"
|
|
#include "base/synchronization/lock.h"
|
|
#include "base/test/gtest_util.h"
|
|
#include "build/build_config.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace base {
|
|
|
|
namespace {
|
|
|
|
struct Data {
|
|
Data() = default;
|
|
Data(int foo_) : foo(foo_) {}
|
|
int foo;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
class ProtectedMemoryTest : public ::testing::Test {
|
|
protected:
|
|
// Run tests one at a time. Some of the negative tests can not be made thread
|
|
// safe.
|
|
void SetUp() final { lock.Acquire(); }
|
|
void TearDown() final { lock.Release(); }
|
|
|
|
Lock lock;
|
|
};
|
|
|
|
PROTECTED_MEMORY_SECTION ProtectedMemory<int> init;
|
|
|
|
TEST_F(ProtectedMemoryTest, Initializer) {
|
|
static ProtectedMemory<int>::Initializer I(&init, 4);
|
|
EXPECT_EQ(*init, 4);
|
|
}
|
|
|
|
PROTECTED_MEMORY_SECTION ProtectedMemory<Data> data;
|
|
|
|
TEST_F(ProtectedMemoryTest, Basic) {
|
|
AutoWritableMemory writer = AutoWritableMemory::Create(data);
|
|
data->foo = 5;
|
|
EXPECT_EQ(data->foo, 5);
|
|
}
|
|
|
|
#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
|
|
|
|
#if PROTECTED_MEMORY_ENABLED
|
|
TEST_F(ProtectedMemoryTest, ReadOnlyOnStart) {
|
|
EXPECT_DEATH({ data->foo = 6; AutoWritableMemory::Create(data); }, "");
|
|
}
|
|
|
|
TEST_F(ProtectedMemoryTest, ReadOnlyAfterSetWritable) {
|
|
{ AutoWritableMemory writer = AutoWritableMemory::Create(data); }
|
|
EXPECT_DEATH({ data->foo = 7; }, "");
|
|
}
|
|
|
|
TEST_F(ProtectedMemoryTest, AssertMemoryIsReadOnly) {
|
|
AssertMemoryIsReadOnly(&data->foo);
|
|
{ AutoWritableMemory::Create(data); }
|
|
AssertMemoryIsReadOnly(&data->foo);
|
|
|
|
ProtectedMemory<Data> writable_data;
|
|
EXPECT_DCHECK_DEATH({ AssertMemoryIsReadOnly(&writable_data->foo); });
|
|
}
|
|
|
|
TEST_F(ProtectedMemoryTest, FailsIfDefinedOutsideOfProtectMemoryRegion) {
|
|
ProtectedMemory<Data> data;
|
|
EXPECT_DCHECK_DEATH({ AutoWritableMemory::Create(data); });
|
|
}
|
|
|
|
TEST_F(ProtectedMemoryTest, UnsanitizedCfiCallOutsideOfProtectedMemoryRegion) {
|
|
ProtectedMemory<void (*)(void)> data;
|
|
EXPECT_DCHECK_DEATH({ UnsanitizedCfiCall(data)(); });
|
|
}
|
|
#endif // PROTECTED_MEMORY_ENABLED
|
|
|
|
namespace {
|
|
|
|
struct BadIcall {
|
|
BadIcall() = default;
|
|
BadIcall(int (*fp_)(int)) : fp(fp_) {}
|
|
int (*fp)(int);
|
|
};
|
|
|
|
unsigned int bad_icall(int i) {
|
|
return 4 + i;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
PROTECTED_MEMORY_SECTION ProtectedMemory<BadIcall> icall_pm1;
|
|
|
|
TEST_F(ProtectedMemoryTest, BadMemberCall) {
|
|
static ProtectedMemory<BadIcall>::Initializer I(
|
|
&icall_pm1, BadIcall(reinterpret_cast<int (*)(int)>(&bad_icall)));
|
|
|
|
EXPECT_EQ(UnsanitizedCfiCall(icall_pm1, &BadIcall::fp)(1), 5);
|
|
#if !BUILDFLAG(CFI_ICALL_CHECK)
|
|
EXPECT_EQ(icall_pm1->fp(1), 5);
|
|
#elif BUILDFLAG(CFI_ENFORCEMENT_TRAP) || BUILDFLAG(CFI_ENFORCEMENT_DIAGNOSTIC)
|
|
EXPECT_DEATH({ icall_pm1->fp(1); }, "");
|
|
#endif
|
|
}
|
|
|
|
PROTECTED_MEMORY_SECTION ProtectedMemory<int (*)(int)> icall_pm2;
|
|
|
|
TEST_F(ProtectedMemoryTest, BadFnPtrCall) {
|
|
static ProtectedMemory<int (*)(int)>::Initializer I(
|
|
&icall_pm2, reinterpret_cast<int (*)(int)>(&bad_icall));
|
|
|
|
EXPECT_EQ(UnsanitizedCfiCall(icall_pm2)(1), 5);
|
|
#if !BUILDFLAG(CFI_ICALL_CHECK)
|
|
EXPECT_EQ((*icall_pm2)(1), 5);
|
|
#elif BUILDFLAG(CFI_ENFORCEMENT_TRAP) || BUILDFLAG(CFI_ENFORCEMENT_DIAGNOSTIC)
|
|
EXPECT_DEATH({ (*icall_pm2)(1); }, "");
|
|
#endif
|
|
}
|
|
|
|
#endif // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
|
|
|
|
} // namespace base
|