/* test/heartbeat_test.c */
/*
 * Unit test for TLS heartbeats.
 *
 * Acts as a regression test against the Heartbleed bug (CVE-2014-0160).
 *
 * Author:  Mike Bland (mbland@acm.org, http://mike-bland.com/)
 * Date:    2014-04-12
 * License: Creative Commons Attribution 4.0 International (CC By 4.0)
 *          http://creativecommons.org/licenses/by/4.0/deed.en_US
 *
 * OUTPUT
 * ------
 * The program returns zero on success. It will print a message with a count
 * of the number of failed tests and return nonzero if any tests fail.
 *
 * It will print the contents of the request and response buffers for each
 * failing test. In a "fixed" version, all the tests should pass and there
 * should be no output.
 *
 * In a "bleeding" version, you'll see:
 *
 *   test_dtls1_heartbleed failed:
 *     expected payload len: 0
 *     received: 1024
 *   sent 26 characters
 *     "HEARTBLEED                "
 *   received 1024 characters
 *     "HEARTBLEED                \xde\xad\xbe\xef..."
 *   ** test_dtls1_heartbleed failed **
 *
 * The contents of the returned buffer in the failing test will depend on the
 * contents of memory on your machine.
 *
 * MORE INFORMATION
 * ----------------
 * http://mike-bland.com/2014/04/12/heartbleed.html
 * http://mike-bland.com/tags/heartbleed.html
 */

#define OPENSSL_UNIT_TEST

#include "../ssl/ssl_locl.h"

#include "testutil.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if !defined(OPENSSL_NO_HEARTBEATS) && !defined(OPENSSL_NO_UNIT_TEST)

/* As per https://tools.ietf.org/html/rfc6520#section-4 */
#define MIN_PADDING_SIZE	16

/* Maximum number of payload characters to print as test output */
#define MAX_PRINTABLE_CHARACTERS	1024

typedef struct heartbeat_test_fixture
	{
	SSL_CTX *ctx;
	SSL *s;
	const char* test_case_name;
	int (*process_heartbeat)(SSL* s);
	unsigned char* payload;
	int sent_payload_len;
	int expected_return_value;
	int return_payload_offset;
	int expected_payload_len;
	const char* expected_return_payload;
	} HEARTBEAT_TEST_FIXTURE;

static HEARTBEAT_TEST_FIXTURE set_up(const char* const test_case_name,
	const SSL_METHOD* meth)
	{
	HEARTBEAT_TEST_FIXTURE fixture;
	int setup_ok = 1;
	memset(&fixture, 0, sizeof(fixture));
	fixture.test_case_name = test_case_name;

	fixture.ctx = SSL_CTX_new(meth);
	if (!fixture.ctx)
		{
		fprintf(stderr, "Failed to allocate SSL_CTX for test: %s\n",
			test_case_name);
		setup_ok = 0;
		goto fail;
		}

	fixture.s = SSL_new(fixture.ctx);
	if (!fixture.s)
		{
		fprintf(stderr, "Failed to allocate SSL for test: %s\n", test_case_name);
		setup_ok = 0;
		goto fail;
		}

	if (!ssl_init_wbio_buffer(fixture.s, 1))
		{
		fprintf(stderr, "Failed to set up wbio buffer for test: %s\n",
			test_case_name);
		setup_ok = 0;
		goto fail;
		}

	if (!ssl3_setup_buffers(fixture.s))
		{
		fprintf(stderr, "Failed to setup buffers for test: %s\n",
			test_case_name);
		setup_ok = 0;
		goto fail;
		}

	/* Clear the memory for the return buffer, since this isn't automatically
	 * zeroed in opt mode and will cause spurious test failures that will change
	 * with each execution.
	 */
	memset(fixture.s->s3->wbuf.buf, 0, fixture.s->s3->wbuf.len);

	fail:
	if (!setup_ok)
		{
		ERR_print_errors_fp(stderr);
		exit(EXIT_FAILURE);
		}
	return fixture;
	}

static HEARTBEAT_TEST_FIXTURE set_up_dtls(const char* const test_case_name)
	{
	HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
		DTLSv1_server_method());
	fixture.process_heartbeat = dtls1_process_heartbeat;

	/* As per dtls1_get_record(), skipping the following from the beginning of
	 * the returned heartbeat message:
	 * type-1 byte; version-2 bytes; sequence number-8 bytes; length-2 bytes
	 *
	 * And then skipping the 1-byte type encoded by process_heartbeat for
	 * a total of 14 bytes, at which point we can grab the length and the
	 * payload we seek.
	 */
	fixture.return_payload_offset = 14;
	return fixture;
	}

/* Needed by ssl3_write_bytes() */
static int dummy_handshake(SSL* s)
	{
	return 1;
	}

static HEARTBEAT_TEST_FIXTURE set_up_tls(const char* const test_case_name)
	{
	HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
		TLSv1_server_method());
	fixture.process_heartbeat = tls1_process_heartbeat;
	fixture.s->handshake_func = dummy_handshake;

	/* As per do_ssl3_write(), skipping the following from the beginning of
	 * the returned heartbeat message:
	 * type-1 byte; version-2 bytes; length-2 bytes
	 *
	 * And then skipping the 1-byte type encoded by process_heartbeat for
	 * a total of 6 bytes, at which point we can grab the length and the payload
	 * we seek.
	 */
	fixture.return_payload_offset = 6;
	return fixture;
	}

static void tear_down(HEARTBEAT_TEST_FIXTURE fixture)
	{
	ERR_print_errors_fp(stderr);
	SSL_free(fixture.s);
	SSL_CTX_free(fixture.ctx);
	}

static void print_payload(const char* const prefix,
		const unsigned char *payload, const int n)
	{
	const int end = n < MAX_PRINTABLE_CHARACTERS ? n
	    : MAX_PRINTABLE_CHARACTERS;
	int i = 0;

	printf("%s %d character%s", prefix, n, n == 1 ? "" : "s");
	if (end != n) printf(" (first %d shown)", end);
	printf("\n  \"");

	for (; i != end; ++i)
		{
		const unsigned char c = payload[i];
		if (isprint(c)) fputc(c, stdout);
		else printf("\\x%02x", c);
		}
	printf("\"\n");
	}

static int execute_heartbeat(HEARTBEAT_TEST_FIXTURE fixture)
	{
	int result = 0;
	SSL* s = fixture.s;
	unsigned char *payload = fixture.payload;
	unsigned char sent_buf[MAX_PRINTABLE_CHARACTERS + 1];
	int return_value;
	unsigned const char *p;
	int actual_payload_len;

	s->s3->rrec.data = payload;
	s->s3->rrec.length = strlen((const char*)payload);
	*payload++ = TLS1_HB_REQUEST;
	s2n(fixture.sent_payload_len, payload);

	/* Make a local copy of the request, since it gets overwritten at some
	 * point */
	memcpy((char *)sent_buf, (const char*)payload, sizeof(sent_buf));

	return_value = fixture.process_heartbeat(s);

	if (return_value != fixture.expected_return_value)
		{
		printf("%s failed: expected return value %d, received %d\n",
					 fixture.test_case_name, fixture.expected_return_value,
					 return_value);
		result = 1;
		}

	/* If there is any byte alignment, it will be stored in wbuf.offset. */
	p = &(s->s3->wbuf.buf[
			fixture.return_payload_offset + s->s3->wbuf.offset]);
	actual_payload_len = 0;
	n2s(p, actual_payload_len);

	if (actual_payload_len != fixture.expected_payload_len)
		{
		printf("%s failed:\n  expected payload len: %d\n  received: %d\n",
					 fixture.test_case_name, fixture.expected_payload_len,
					 actual_payload_len);
		print_payload("sent", sent_buf, strlen((const char*)sent_buf));
		print_payload("received", p, actual_payload_len);
		result = 1;
		}
	else
		{
		char* actual_payload = BUF_strndup((const char*)p, actual_payload_len);
		if (strcmp(actual_payload, fixture.expected_return_payload) != 0)
			{
			printf("%s failed:\n  expected payload: \"%s\"\n  received: \"%s\"\n",
						 fixture.test_case_name, fixture.expected_return_payload,
						 actual_payload);
			result = 1;
			}
		OPENSSL_free(actual_payload);
		}

	if (result != 0)
		{
		printf("** %s failed **\n--------\n", fixture.test_case_name);
		}
	return result;
	}

static int honest_payload_size(unsigned char payload_buf[])
	{
	/* Omit three-byte pad at the beginning for type and payload length */
	return strlen((const char*)&payload_buf[3]) - MIN_PADDING_SIZE;
	}

#define SETUP_HEARTBEAT_TEST_FIXTURE(type)\
  SETUP_TEST_FIXTURE(HEARTBEAT_TEST_FIXTURE, set_up_##type)

#define EXECUTE_HEARTBEAT_TEST()\
  EXECUTE_TEST(execute_heartbeat, tear_down)

static int test_dtls1_not_bleeding()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	/* Three-byte pad at the beginning for type and payload length */
	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS+4] =
		"   Not bleeding, sixteen spaces of padding"
		"                ";
	const int payload_buf_len = honest_payload_size(payload_buf);

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = payload_buf_len;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = payload_buf_len;
	fixture.expected_return_payload = "Not bleeding, sixteen spaces of padding";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_dtls1_not_bleeding_empty_payload()
	{
	int payload_buf_len;

	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	/* Three-byte pad at the beginning for type and payload length, plus a NUL
	 * at the end */
	unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
	memset(payload_buf, ' ', MIN_PADDING_SIZE+3);
	payload_buf[MIN_PADDING_SIZE+3] = '\0';
	payload_buf_len = honest_payload_size(payload_buf);

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = payload_buf_len;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = payload_buf_len;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_dtls1_heartbleed()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	/* Three-byte pad at the beginning for type and payload length */
	unsigned char payload_buf[4+MAX_PRINTABLE_CHARACTERS] =
		"   HEARTBLEED                ";

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = 0;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_dtls1_heartbleed_empty_payload()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	/* Excluding the NUL at the end, one byte short of type + payload length +
	 * minimum padding */
	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
	memset(payload_buf, ' ', MIN_PADDING_SIZE+2);
	payload_buf[MIN_PADDING_SIZE+2] = '\0';

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = 0;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_dtls1_heartbleed_excessive_plaintext_length()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	/* Excluding the NUL at the end, one byte in excess of maximum allowed
	 * heartbeat message length */
	unsigned char payload_buf[SSL3_RT_MAX_PLAIN_LENGTH + 2];
	memset(payload_buf, ' ', sizeof(payload_buf));
	payload_buf[sizeof(payload_buf) - 1] = '\0';

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = honest_payload_size(payload_buf);
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = 0;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_tls1_not_bleeding()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	/* Three-byte pad at the beginning for type and payload length */
	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS+4] =
			"   Not bleeding, sixteen spaces of padding"
			"                ";
	const int payload_buf_len = honest_payload_size(payload_buf);

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = payload_buf_len;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = payload_buf_len;
	fixture.expected_return_payload = "Not bleeding, sixteen spaces of padding";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_tls1_not_bleeding_empty_payload()
	{
	int payload_buf_len;

	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	/* Three-byte pad at the beginning for type and payload length, plus a NUL
	 * at the end */
	unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
	memset(payload_buf, ' ', MIN_PADDING_SIZE+3);
	payload_buf[MIN_PADDING_SIZE+3] = '\0';
	payload_buf_len = honest_payload_size(payload_buf);

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = payload_buf_len;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = payload_buf_len;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_tls1_heartbleed()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	/* Three-byte pad at the beginning for type and payload length */
	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS+4] =
			"   HEARTBLEED                ";

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = 0;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

static int test_tls1_heartbleed_empty_payload()
	{
	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	/* Excluding the NUL at the end, one byte short of type + payload length +
	 * minimum padding */
	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
	memset(payload_buf, ' ', MIN_PADDING_SIZE+2);
	payload_buf[MIN_PADDING_SIZE+2] = '\0';

	fixture.payload = &payload_buf[0];
	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	fixture.expected_return_value = 0;
	fixture.expected_payload_len = 0;
	fixture.expected_return_payload = "";
	EXECUTE_HEARTBEAT_TEST();
	}

#undef EXECUTE_HEARTBEAT_TEST
#undef SETUP_HEARTBEAT_TEST_FIXTURE

int main(int argc, char *argv[])
	{
	int result = 0;

	SSL_library_init();
	SSL_load_error_strings();

	ADD_TEST(test_dtls1_not_bleeding);
	ADD_TEST(test_dtls1_not_bleeding_empty_payload);
	ADD_TEST(test_dtls1_heartbleed);
	ADD_TEST(test_dtls1_heartbleed_empty_payload);
	ADD_TEST(test_dtls1_heartbleed_excessive_plaintext_length);
	ADD_TEST(test_tls1_not_bleeding);
	ADD_TEST(test_tls1_not_bleeding_empty_payload);
	ADD_TEST(test_tls1_heartbleed);
	ADD_TEST(test_tls1_heartbleed_empty_payload);

	result = run_tests(argv[0]);
	ERR_print_errors_fp(stderr);
	return result;
	}

#else /* OPENSSL_NO_HEARTBEATS*/

int main(int argc, char *argv[])
	{
		return EXIT_SUCCESS;
	}
#endif /* OPENSSL_NO_HEARTBEATS */