xref: /titanic_50/usr/src/uts/i86pc/os/ssp.c (revision 6a59053b922dcd35760db6b042abda7cb6ef1c80)

/*
 * 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 2015 Alex Wilson, the University of Queensland
 * Use is subject to license terms.
 */

/*
 * Support functions for stack smashing protection (-fstack-protector
 * and family)
 *
 * The principle behind SSP is to place a "canary" value on the stack
 * just below the arguments to a given function (which are in turn
 * below the previous %rbp and return pointer). We write it onto the
 * stack at the start of a function, and then at the end just before
 * we execute "leave" and "ret", we check that the value is still there.
 *
 * If the check fails, we jump immediately to a handler (which typically
 * just executes panic() straight away).
 *
 * Since an attacker will not know the value of the "canary", they will
 * not be able to repair it correctly when overwriting the stack (and in
 * almost all cases they must overwrite the canary to get to the return
 * pointer), and the check will fail (and safely panic) instead of
 * letting them gain control over %rip in a kernel thread.
 *
 * To debugging tools the canary just looks like another local variable
 * (since it's placed below the normal argument space), and so there
 * should be minimal/no impact on things that try to parse the
 * function preamble.
 *
 * Of course, adding these guards to every single function does not come
 * without a price in performance, so normally only a subset of functions
 * in a given program are guarded. Selecting which subset, and adding the
 * guards is all handled automatically by the compiler.
 *
 * There are 3 (or 4) major relevant compiler options in GCC:
 *     * -fstack-protector
 *     * -fstack-protector-strong (only in GCC >= 4.9)
 *     * -fstack-protector-all
 *     * -fno-stack-protector
 *
 * The only differences between -fstack-protector, -strong and -all is in
 * which functions are selected for adding guards.
 *
 * -fstack-protector adds guards to functions that make use of a stack-
 * allocated char array (or aggregate containing one) of at least 8 bytes
 * in length.
 *
 * -fstack-protector-strong adds guards everywhere -fstack-protector
 * does, and also adds guards to all functions that take or pass an address
 * to a stack-allocated array of any type (eg arr, &arr[1] etc), as well as
 * functions containing certain kinds of pointer arithmetic.
 *
 * -fstack-protector-all (as the name suggests) adds guards to every single
 * function.
 *
 * There is also another variant, in the ProPolice patches which are used
 * by some members of the BSD family (eg OpenBSD), which also guards any
 * functions that store function pointers on the stack, as well as a few
 * other heuristics (like re-ordering variables so arrays are as close as
 * possible to the canary)
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/time.h>
#include <sys/note.h>

/*
 * The symbol __stack_chk_guard contains the magic guard value used
 * to check stack integrity before returning from selected functions.
 *
 * Its value is set at startup to a "random" number -- this does not have
 * to be cryptographically secure, but it does have to be done before
 * calling any C functions that the stack guards may have been generated
 * for.
 *
 * For this reason, the uts/i86pc/os directory is always built *without*
 * stack protection enabled so that we can bootstrap.
 */

uintptr_t __stack_chk_guard = 0;

/*
 * The function __stack_chk_fail is called whenever a guard check fails.
 */
void
__stack_chk_fail(void)
{
	/*
	 * Currently we just panic, but some more debug info could be useful.
	 * Note that we absolutely cannot trust any part of our stack at this
	 * point (we already know there's an attack in progress).
	 */
	panic("Stack smashing detected");
}

static void salsa_hash(unsigned int *);

#ifdef __sparc
extern uint64_t ultra_gettick(void);
#define	SSP_GET_TICK ultra_gettick
#else
extern hrtime_t tsc_read(void);
#define	SSP_GET_TICK tsc_read
#endif /* __sparc */

/* called from os/startup.c */
void
ssp_init(void)
{
	int i;

	if (__stack_chk_guard == 0) {
		union {
			unsigned int state[16];
			hrtime_t ts[8];
			uintptr_t g;
		} s;

		for (i = 0; i < 8; ++i)
			s.ts[i] = SSP_GET_TICK();

		salsa_hash(s.state);

		__stack_chk_guard = s.g;
	}
}

/*
 * Stealing the chacha/salsa hash function. It's simple, fast and
 * public domain. We don't need/want the full cipher (which would
 * belong in crypto) and we can't use the fully fledged PRNG
 * framework either, since ssp_init has to be called extremely
 * early in startup.
 *
 * Since we don't have to be cryptographically secure, just using
 * this to hash some high res timer values should be good enough.
 */
#define	QR(a, b, c, d)	do {  \
				a += b; d ^= a; d <<= 16;	\
				c += d; b ^= c; b <<= 12;	\
				a += b; d ^= a; d <<= 8;	\
				c += d; b ^= c; b <<= 7;	\
			_NOTE(CONSTANTCONDITION)		\
			} while (0)

static inline void
salsa_dr(unsigned int *state)
{
	QR(state[0], state[4], state[ 8], state[12]);
	QR(state[1], state[5], state[ 9], state[13]);
	QR(state[2], state[6], state[10], state[14]);
	QR(state[3], state[7], state[11], state[15]);
	QR(state[0], state[5], state[10], state[15]);
	QR(state[1], state[6], state[11], state[12]);
	QR(state[2], state[7], state[ 8], state[13]);
	QR(state[3], state[4], state[ 9], state[14]);
}

static void
salsa_hash(unsigned int *state)
{
	/* 10x applications of salsa doubleround */
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
	salsa_dr(state);
}