blob: d16970a7c9b3631081ada9afcb9745cab1816809 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Copyright 2014 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 "third_party/base/allocator/partition_allocator/address_space_randomization.h"
#include "build/build_config.h"
#include "third_party/base/allocator/partition_allocator/page_allocator.h"
#include "third_party/base/allocator/partition_allocator/spin_lock.h"
#if defined(OS_WIN)
#include <windows.h>
#else
#include <sys/time.h>
#include <unistd.h>
#endif
// VersionHelpers.h must be included after windows.h.
#if defined(OS_WIN)
#include <VersionHelpers.h>
#endif
namespace pdfium {
namespace base {
namespace {
// This is the same PRNG as used by tcmalloc for mapping address randomness;
// see http://burtleburtle.net/bob/rand/smallprng.html
struct ranctx {
subtle::SpinLock lock;
bool initialized;
uint32_t a;
uint32_t b;
uint32_t c;
uint32_t d;
};
#define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
uint32_t ranvalInternal(ranctx* x) {
uint32_t e = x->a - rot(x->b, 27);
x->a = x->b ^ rot(x->c, 17);
x->b = x->c + x->d;
x->c = x->d + e;
x->d = e + x->a;
return x->d;
}
#undef rot
uint32_t ranval(ranctx* x) {
subtle::SpinLock::Guard guard(x->lock);
if (UNLIKELY(!x->initialized)) {
x->initialized = true;
char c;
uint32_t seed = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&c));
uint32_t pid;
uint32_t usec;
#if defined(OS_WIN)
pid = GetCurrentProcessId();
SYSTEMTIME st;
GetSystemTime(&st);
usec = static_cast<uint32_t>(st.wMilliseconds * 1000);
#else
pid = static_cast<uint32_t>(getpid());
struct timeval tv;
gettimeofday(&tv, 0);
usec = static_cast<uint32_t>(tv.tv_usec);
#endif
seed ^= pid;
seed ^= usec;
x->a = 0xf1ea5eed;
x->b = x->c = x->d = seed;
for (int i = 0; i < 20; ++i) {
(void)ranvalInternal(x);
}
}
uint32_t ret = ranvalInternal(x);
return ret;
}
static struct ranctx s_ranctx;
} // namespace
// Calculates a random preferred mapping address. In calculating an address, we
// balance good ASLR against not fragmenting the address space too badly.
void* GetRandomPageBase() {
uintptr_t random;
random = static_cast<uintptr_t>(ranval(&s_ranctx));
#if defined(ARCH_CPU_X86_64)
random <<= 32UL;
random |= static_cast<uintptr_t>(ranval(&s_ranctx));
// This address mask gives a low likelihood of address space collisions. We
// handle the situation gracefully if there is a collision.
#if defined(OS_WIN)
random &= 0x3ffffffffffUL;
// Windows >= 8.1 has the full 47 bits. Use them where available.
static bool windows_81 = false;
static bool windows_81_initialized = false;
if (!windows_81_initialized) {
windows_81 = IsWindows8Point1OrGreater();
windows_81_initialized = true;
}
if (!windows_81) {
random += 0x10000000000UL;
}
#elif defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
// This range is copied from the TSan source, but works for all tools.
random &= 0x007fffffffffUL;
random += 0x7e8000000000UL;
#else
// Linux and OS X support the full 47-bit user space of x64 processors.
random &= 0x3fffffffffffUL;
#endif
#elif defined(ARCH_CPU_ARM64)
// ARM64 on Linux has 39-bit user space.
random &= 0x3fffffffffUL;
random += 0x1000000000UL;
#else // !defined(ARCH_CPU_X86_64) && !defined(ARCH_CPU_ARM64)
#if defined(OS_WIN)
// On win32 host systems the randomization plus huge alignment causes
// excessive fragmentation. Plus most of these systems lack ASLR, so the
// randomization isn't buying anything. In that case we just skip it.
// TODO(jschuh): Just dump the randomization when HE-ASLR is present.
static BOOL isWow64 = -1;
if (isWow64 == -1 && !IsWow64Process(GetCurrentProcess(), &isWow64))
isWow64 = FALSE;
if (!isWow64)
return nullptr;
#endif // defined(OS_WIN)
// This is a good range on Windows, Linux and Mac.
// Allocates in the 0.5-1.5GB region.
random &= 0x3fffffff;
random += 0x20000000;
#endif // defined(ARCH_CPU_X86_64)
random &= kPageAllocationGranularityBaseMask;
return reinterpret_cast<void*>(random);
}
} // namespace base
} // namespace pdfium
|
