[thirdparty/openssl.git] / test / heartbeat_test.c

/* 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 *p, unsigned int length);
    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->rlayer.wbuf.buf, 0, fixture.s->rlayer.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->rlayer.rrec.data = payload;
    s->rlayer.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(sent_buf, payload, sizeof(sent_buf));

    return_value = fixture.process_heartbeat(s, s->rlayer.rrec.data,
        s->rlayer.rrec.length);

    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->rlayer.
          wbuf.buf[fixture.return_payload_offset + s->rlayer.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 =
            OPENSSL_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 */
Commit	Line	Data
6af080ac	1	/* test/heartbeat_test.c */
1d97c843	2	/*-
6af080ac MB	3	* Unit test for TLS heartbeats.
	4	*
	5	* Acts as a regression test against the Heartbleed bug (CVE-2014-0160).
	6	*
	7	* Author: Mike Bland (mbland@acm.org, http://mike-bland.com/)
	8	* Date: 2014-04-12
	9	* License: Creative Commons Attribution 4.0 International (CC By 4.0)
	10	* http://creativecommons.org/licenses/by/4.0/deed.en_US
	11	*
	12	* OUTPUT
	13	* ------
	14	* The program returns zero on success. It will print a message with a count
	15	* of the number of failed tests and return nonzero if any tests fail.
	16	*
	17	* It will print the contents of the request and response buffers for each
	18	* failing test. In a "fixed" version, all the tests should pass and there
	19	* should be no output.
	20	*
	21	* In a "bleeding" version, you'll see:
	22	*
	23	* test_dtls1_heartbleed failed:
	24	* expected payload len: 0
	25	* received: 1024
	26	* sent 26 characters
	27	* "HEARTBLEED "
	28	* received 1024 characters
	29	* "HEARTBLEED \xde\xad\xbe\xef..."
	30	* test_dtls1_heartbleed failed
	31	*
	32	* The contents of the returned buffer in the failing test will depend on the
	33	* contents of memory on your machine.
	34	*
	35	* MORE INFORMATION
	36	* ----------------
	37	* http://mike-bland.com/2014/04/12/heartbleed.html
	38	* http://mike-bland.com/tags/heartbleed.html
	39	*/
	40
e0fc7961 DSH	41	#define OPENSSL_UNIT_TEST
e0fc7961 DSH	42
6af080ac	43	#include "../ssl/ssl_locl.h"
50bba685 MB	44
50bba685 MB	45	#include "testutil.h"
6af080ac MB	46	#include <ctype.h>
	47	#include <stdio.h>
	48	#include <stdlib.h>
	49	#include <string.h>
	50
e0fc7961	51	#if !defined(OPENSSL_NO_HEARTBEATS) && !defined(OPENSSL_NO_UNIT_TEST)
647c70f7	52
6af080ac	53	/* As per https://tools.ietf.org/html/rfc6520#section-4 */
0f113f3e	54	# define MIN_PADDING_SIZE 16
6af080ac MB	55
6af080ac MB	56	/* Maximum number of payload characters to print as test output */
0f113f3e MC	57	# define MAX_PRINTABLE_CHARACTERS 1024
	58
	59	typedef struct heartbeat_test_fixture {
	60	SSL_CTX *ctx;
	61	SSL *s;
	62	const char *test_case_name;
2c60ed04	63	int (process_heartbeat) (SSL s, unsigned char *p, unsigned int length);
0f113f3e MC	64	unsigned char *payload;
	65	int sent_payload_len;
	66	int expected_return_value;
	67	int return_payload_offset;
	68	int expected_payload_len;
	69	const char *expected_return_payload;
	70	} HEARTBEAT_TEST_FIXTURE;
	71
	72	static HEARTBEAT_TEST_FIXTURE set_up(const char *const test_case_name,
	73	const SSL_METHOD *meth)
	74	{
	75	HEARTBEAT_TEST_FIXTURE fixture;
	76	int setup_ok = 1;
	77	memset(&fixture, 0, sizeof(fixture));
	78	fixture.test_case_name = test_case_name;
	79
	80	fixture.ctx = SSL_CTX_new(meth);
	81	if (!fixture.ctx) {
	82	fprintf(stderr, "Failed to allocate SSL_CTX for test: %s\n",
	83	test_case_name);
	84	setup_ok = 0;
	85	goto fail;
	86	}
	87
	88	fixture.s = SSL_new(fixture.ctx);
	89	if (!fixture.s) {
	90	fprintf(stderr, "Failed to allocate SSL for test: %s\n",
	91	test_case_name);
	92	setup_ok = 0;
	93	goto fail;
	94	}
	95
	96	if (!ssl_init_wbio_buffer(fixture.s, 1)) {
	97	fprintf(stderr, "Failed to set up wbio buffer for test: %s\n",
	98	test_case_name);
	99	setup_ok = 0;
	100	goto fail;
	101	}
	102
	103	if (!ssl3_setup_buffers(fixture.s)) {
	104	fprintf(stderr, "Failed to setup buffers for test: %s\n",
	105	test_case_name);
	106	setup_ok = 0;
	107	goto fail;
	108	}
	109
	110	/*
	111	* Clear the memory for the return buffer, since this isn't automatically
	112	* zeroed in opt mode and will cause spurious test failures that will
	113	* change with each execution.
	114	*/
2c60ed04	115	memset(fixture.s->rlayer.wbuf.buf, 0, fixture.s->rlayer.wbuf.len);
0f113f3e MC	116
	117	fail:
	118	if (!setup_ok) {
	119	ERR_print_errors_fp(stderr);
	120	exit(EXIT_FAILURE);
	121	}
	122	return fixture;
	123	}
	124
	125	static HEARTBEAT_TEST_FIXTURE set_up_dtls(const char *const test_case_name)
	126	{
	127	HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
	128	DTLSv1_server_method());
	129	fixture.process_heartbeat = dtls1_process_heartbeat;
	130
	131	/*
	132	* As per dtls1_get_record(), skipping the following from the beginning
	133	* of the returned heartbeat message: type-1 byte; version-2 bytes;
	134	* sequence number-8 bytes; length-2 bytes And then skipping the 1-byte
	135	* type encoded by process_heartbeat for a total of 14 bytes, at which
	136	* point we can grab the length and the payload we seek.
	137	*/
	138	fixture.return_payload_offset = 14;
	139	return fixture;
	140	}
6af080ac MB	141
6af080ac MB	142	/* Needed by ssl3_write_bytes() */
0f113f3e MC	143	static int dummy_handshake(SSL *s)
	144	{
	145	return 1;
	146	}
	147
	148	static HEARTBEAT_TEST_FIXTURE set_up_tls(const char *const test_case_name)
	149	{
	150	HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
	151	TLSv1_server_method());
	152	fixture.process_heartbeat = tls1_process_heartbeat;
	153	fixture.s->handshake_func = dummy_handshake;
	154
	155	/*
	156	* As per do_ssl3_write(), skipping the following from the beginning of
	157	* the returned heartbeat message: type-1 byte; version-2 bytes; length-2
	158	* bytes And then skipping the 1-byte type encoded by process_heartbeat
	159	* for a total of 6 bytes, at which point we can grab the length and the
	160	* payload we seek.
	161	*/
	162	fixture.return_payload_offset = 6;
	163	return fixture;
	164	}
6af080ac MB	165
6af080ac MB	166	static void tear_down(HEARTBEAT_TEST_FIXTURE fixture)
0f113f3e MC	167	{
	168	ERR_print_errors_fp(stderr);
	169	SSL_free(fixture.s);
	170	SSL_CTX_free(fixture.ctx);
	171	}
	172
	173	static void print_payload(const char *const prefix,
	174	const unsigned char *payload, const int n)
	175	{
	176	const int end = n < MAX_PRINTABLE_CHARACTERS ? n
	177	: MAX_PRINTABLE_CHARACTERS;
	178	int i = 0;
	179
	180	printf("%s %d character%s", prefix, n, n == 1 ? "" : "s");
	181	if (end != n)
	182	printf(" (first %d shown)", end);
	183	printf("\n \"");
	184
	185	for (; i != end; ++i) {
	186	const unsigned char c = payload[i];
	187	if (isprint(c))
	188	fputc(c, stdout);
	189	else
	190	printf("\\x%02x", c);
	191	}
	192	printf("\"\n");
	193	}
6af080ac MB	194
6af080ac MB	195	static int execute_heartbeat(HEARTBEAT_TEST_FIXTURE fixture)
0f113f3e MC	196	{
	197	int result = 0;
	198	SSL *s = fixture.s;
	199	unsigned char *payload = fixture.payload;
	200	unsigned char sent_buf[MAX_PRINTABLE_CHARACTERS + 1];
	201	int return_value;
	202	unsigned const char *p;
	203	int actual_payload_len;
	204
2c60ed04 MC	205	s->rlayer.rrec.data = payload;
2c60ed04 MC	206	s->rlayer.rrec.length = strlen((const char *)payload);
0f113f3e MC	207	*payload++ = TLS1_HB_REQUEST;
	208	s2n(fixture.sent_payload_len, payload);
	209
	210	/*
	211	* Make a local copy of the request, since it gets overwritten at some
	212	* point
	213	*/
16f8d4eb	214	memcpy(sent_buf, payload, sizeof(sent_buf));
0f113f3e	215
2c60ed04 MC	216	return_value = fixture.process_heartbeat(s, s->rlayer.rrec.data,
2c60ed04 MC	217	s->rlayer.rrec.length);
0f113f3e MC	218
	219	if (return_value != fixture.expected_return_value) {
	220	printf("%s failed: expected return value %d, received %d\n",
	221	fixture.test_case_name, fixture.expected_return_value,
	222	return_value);
	223	result = 1;
	224	}
	225
	226	/*
	227	* If there is any byte alignment, it will be stored in wbuf.offset.
	228	*/
2c60ed04 MC	229	p = &(s->rlayer.
2c60ed04 MC	230	wbuf.buf[fixture.return_payload_offset + s->rlayer.wbuf.offset]);
0f113f3e MC	231	actual_payload_len = 0;
	232	n2s(p, actual_payload_len);
	233
	234	if (actual_payload_len != fixture.expected_payload_len) {
	235	printf("%s failed:\n expected payload len: %d\n received: %d\n",
	236	fixture.test_case_name, fixture.expected_payload_len,
	237	actual_payload_len);
	238	print_payload("sent", sent_buf, strlen((const char *)sent_buf));
	239	print_payload("received", p, actual_payload_len);
	240	result = 1;
	241	} else {
	242	char *actual_payload =
7644a9ae	243	OPENSSL_strndup((const char *)p, actual_payload_len);
0f113f3e MC	244	if (strcmp(actual_payload, fixture.expected_return_payload) != 0) {
	245	printf
	246	("%s failed:\n expected payload: \"%s\"\n received: \"%s\"\n",
	247	fixture.test_case_name, fixture.expected_return_payload,
	248	actual_payload);
	249	result = 1;
	250	}
	251	OPENSSL_free(actual_payload);
	252	}
	253
	254	if (result != 0) {
	255	printf(" %s failed \n--------\n", fixture.test_case_name);
	256	}
	257	return result;
	258	}
6af080ac MB	259
6af080ac MB	260	static int honest_payload_size(unsigned char payload_buf[])
0f113f3e MC	261	{
	262	/* Omit three-byte pad at the beginning for type and payload length */
	263	return strlen((const char *)&payload_buf[3]) - MIN_PADDING_SIZE;
	264	}
6af080ac	265
0f113f3e	266	# define SETUP_HEARTBEAT_TEST_FIXTURE(type)\
3ead9f37	267	SETUP_TEST_FIXTURE(HEARTBEAT_TEST_FIXTURE, set_up_##type)
6af080ac	268
0f113f3e	269	# define EXECUTE_HEARTBEAT_TEST()\
3ead9f37	270	EXECUTE_TEST(execute_heartbeat, tear_down)
6af080ac MB	271
6af080ac MB	272	static int test_dtls1_not_bleeding()
0f113f3e MC	273	{
	274	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	275	/* Three-byte pad at the beginning for type and payload length */
	276	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
	277	" Not bleeding, sixteen spaces of padding" " ";
	278	const int payload_buf_len = honest_payload_size(payload_buf);
	279
	280	fixture.payload = &payload_buf[0];
	281	fixture.sent_payload_len = payload_buf_len;
	282	fixture.expected_return_value = 0;
	283	fixture.expected_payload_len = payload_buf_len;
	284	fixture.expected_return_payload =
	285	"Not bleeding, sixteen spaces of padding";
	286	EXECUTE_HEARTBEAT_TEST();
	287	}
6af080ac MB	288
6af080ac MB	289	static int test_dtls1_not_bleeding_empty_payload()
0f113f3e MC	290	{
	291	int payload_buf_len;
	292
	293	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	294	/*
	295	* Three-byte pad at the beginning for type and payload length, plus a
	296	* NUL at the end
	297	*/
	298	unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
	299	memset(payload_buf, ' ', MIN_PADDING_SIZE + 3);
	300	payload_buf[MIN_PADDING_SIZE + 3] = '\0';
	301	payload_buf_len = honest_payload_size(payload_buf);
	302
	303	fixture.payload = &payload_buf[0];
	304	fixture.sent_payload_len = payload_buf_len;
	305	fixture.expected_return_value = 0;
	306	fixture.expected_payload_len = payload_buf_len;
	307	fixture.expected_return_payload = "";
	308	EXECUTE_HEARTBEAT_TEST();
	309	}
6af080ac MB	310
6af080ac MB	311	static int test_dtls1_heartbleed()
0f113f3e MC	312	{
	313	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	314	/* Three-byte pad at the beginning for type and payload length */
	315	unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS] =
	316	" HEARTBLEED ";
	317
	318	fixture.payload = &payload_buf[0];
	319	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	320	fixture.expected_return_value = 0;
	321	fixture.expected_payload_len = 0;
	322	fixture.expected_return_payload = "";
	323	EXECUTE_HEARTBEAT_TEST();
	324	}
6af080ac MB	325
6af080ac MB	326	static int test_dtls1_heartbleed_empty_payload()
0f113f3e MC	327	{
	328	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	329	/*
	330	* Excluding the NUL at the end, one byte short of type + payload length
	331	* + minimum padding
	332	*/
	333	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
	334	memset(payload_buf, ' ', MIN_PADDING_SIZE + 2);
	335	payload_buf[MIN_PADDING_SIZE + 2] = '\0';
	336
	337	fixture.payload = &payload_buf[0];
	338	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	339	fixture.expected_return_value = 0;
	340	fixture.expected_payload_len = 0;
	341	fixture.expected_return_payload = "";
	342	EXECUTE_HEARTBEAT_TEST();
	343	}
6af080ac MB	344
6af080ac MB	345	static int test_dtls1_heartbleed_excessive_plaintext_length()
0f113f3e MC	346	{
	347	SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
	348	/*
	349	* Excluding the NUL at the end, one byte in excess of maximum allowed
	350	* heartbeat message length
	351	*/
	352	unsigned char payload_buf[SSL3_RT_MAX_PLAIN_LENGTH + 2];
	353	memset(payload_buf, ' ', sizeof(payload_buf));
	354	payload_buf[sizeof(payload_buf) - 1] = '\0';
	355
	356	fixture.payload = &payload_buf[0];
	357	fixture.sent_payload_len = honest_payload_size(payload_buf);
	358	fixture.expected_return_value = 0;
	359	fixture.expected_payload_len = 0;
	360	fixture.expected_return_payload = "";
	361	EXECUTE_HEARTBEAT_TEST();
	362	}
6af080ac MB	363
6af080ac MB	364	static int test_tls1_not_bleeding()
0f113f3e MC	365	{
	366	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	367	/* Three-byte pad at the beginning for type and payload length */
	368	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
	369	" Not bleeding, sixteen spaces of padding" " ";
	370	const int payload_buf_len = honest_payload_size(payload_buf);
	371
	372	fixture.payload = &payload_buf[0];
	373	fixture.sent_payload_len = payload_buf_len;
	374	fixture.expected_return_value = 0;
	375	fixture.expected_payload_len = payload_buf_len;
	376	fixture.expected_return_payload =
	377	"Not bleeding, sixteen spaces of padding";
	378	EXECUTE_HEARTBEAT_TEST();
	379	}
6af080ac MB	380
6af080ac MB	381	static int test_tls1_not_bleeding_empty_payload()
0f113f3e MC	382	{
	383	int payload_buf_len;
	384
	385	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	386	/*
	387	* Three-byte pad at the beginning for type and payload length, plus a
	388	* NUL at the end
	389	*/
	390	unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
	391	memset(payload_buf, ' ', MIN_PADDING_SIZE + 3);
	392	payload_buf[MIN_PADDING_SIZE + 3] = '\0';
	393	payload_buf_len = honest_payload_size(payload_buf);
	394
	395	fixture.payload = &payload_buf[0];
	396	fixture.sent_payload_len = payload_buf_len;
	397	fixture.expected_return_value = 0;
	398	fixture.expected_payload_len = payload_buf_len;
	399	fixture.expected_return_payload = "";
	400	EXECUTE_HEARTBEAT_TEST();
	401	}
6af080ac MB	402
6af080ac MB	403	static int test_tls1_heartbleed()
0f113f3e MC	404	{
	405	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	406	/* Three-byte pad at the beginning for type and payload length */
	407	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
	408	" HEARTBLEED ";
	409
	410	fixture.payload = &payload_buf[0];
	411	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	412	fixture.expected_return_value = 0;
	413	fixture.expected_payload_len = 0;
	414	fixture.expected_return_payload = "";
	415	EXECUTE_HEARTBEAT_TEST();
	416	}
6af080ac MB	417
6af080ac MB	418	static int test_tls1_heartbleed_empty_payload()
0f113f3e MC	419	{
	420	SETUP_HEARTBEAT_TEST_FIXTURE(tls);
	421	/*
	422	* Excluding the NUL at the end, one byte short of type + payload length
	423	* + minimum padding
	424	*/
	425	unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
	426	memset(payload_buf, ' ', MIN_PADDING_SIZE + 2);
	427	payload_buf[MIN_PADDING_SIZE + 2] = '\0';
	428
	429	fixture.payload = &payload_buf[0];
	430	fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
	431	fixture.expected_return_value = 0;
	432	fixture.expected_payload_len = 0;
	433	fixture.expected_return_payload = "";
	434	EXECUTE_HEARTBEAT_TEST();
	435	}
	436
	437	# undef EXECUTE_HEARTBEAT_TEST
	438	# undef SETUP_HEARTBEAT_TEST_FIXTURE
6af080ac MB	439
6af080ac MB	440	int main(int argc, char *argv[])
0f113f3e MC	441	{
0f113f3e MC	442	int result = 0;
2ec52dc3	443
0f113f3e MC	444	SSL_library_init();
0f113f3e MC	445	SSL_load_error_strings();
6af080ac	446
0f113f3e MC	447	ADD_TEST(test_dtls1_not_bleeding);
	448	ADD_TEST(test_dtls1_not_bleeding_empty_payload);
	449	ADD_TEST(test_dtls1_heartbleed);
	450	ADD_TEST(test_dtls1_heartbleed_empty_payload);
	451	ADD_TEST(test_dtls1_heartbleed_excessive_plaintext_length);
	452	ADD_TEST(test_tls1_not_bleeding);
	453	ADD_TEST(test_tls1_not_bleeding_empty_payload);
	454	ADD_TEST(test_tls1_heartbleed);
	455	ADD_TEST(test_tls1_heartbleed_empty_payload);
6017a551	456
0f113f3e MC	457	result = run_tests(argv[0]);
	458	ERR_print_errors_fp(stderr);
	459	return result;
	460	}
647c70f7	461
0f113f3e	462	#else /* OPENSSL_NO_HEARTBEATS */
647c70f7 MB	463
647c70f7 MB	464	int main(int argc, char *argv[])
0f113f3e MC	465	{
	466	return EXIT_SUCCESS;
	467	}
	468	#endif /* OPENSSL_NO_HEARTBEATS */