blob: 81d93829ea222f76c974824b65d1d3a14690ea58 (
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
|
/*
* This file and its contents are supplied under the terms of the
* Common Development and Distribution License ("CDDL"), version 1.0.
* You may only use this file in accordance with the terms of version
* 1.0 of the CDDL.
*
* A full copy of the text of the CDDL should have accompanied this
* source. A copy of the CDDL is also available via the Internet at
* http://www.illumos.org/license/CDDL.
*/
/*
* Copyright 2020 Oxide Computer Company
*/
#include <upanic.h>
#include <sys/random.h>
/*
* This provides an implementation of the stack protector functions that are
* expected by gcc's ssp implementation.
*
* We attempt to initialize the stack guard with random data, which is our best
* protection. If that fails, we'd like to have a guard that is still meaningful
* and not totally predictable. The original StackGuard paper suggests using a
* terminator canary. To make this a little more difficult, we also use a
* portion of the data from gethrtime().
*
* In a 32-bit environment, we only have four bytes worth of data. We use the
* lower two bytes of the gethrtime() value and then use pieces of the
* terminator canary, '\n\0'. In a 64-bit environment we use the full four byte
* terminator canary and then four bytes of gethrtime.
*/
/*
* Use an array here so it's easier to get the length at compile time.
*/
static const char ssp_msg[] = "*** stack smashing detected";
uintptr_t __stack_chk_guard;
void
ssp_init(void)
{
if (getrandom(&__stack_chk_guard, sizeof (__stack_chk_guard), 0) !=
sizeof (__stack_chk_guard)) {
/*
* This failed, attempt to get some data that might let us get
* off the ground.
*/
hrtime_t t = gethrtime();
#ifdef _LP32
const uint16_t guard = '\n' << 8 | '\0';
__stack_chk_guard = guard << 16 | (uint16_t)t;
#else
const uint32_t guard = '\r' << 24 | '\n' << 16 | '\0' << 8 |
'\xff';
__stack_chk_guard = (uint64_t)guard << 32 | (uint32_t)t;
#endif
}
}
void
__stack_chk_fail(void)
{
upanic(ssp_msg, sizeof (ssp_msg));
}
|
