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

/*
 * Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/ssl.h>
#include <string.h>
#include "ssltestlib.h"
#include "testutil.h"
#include "../ssl/packet_locl.h"

static char *cert = NULL;
static char *privkey = NULL;

static BIO *s_to_c_fbio = NULL, *c_to_s_fbio = NULL;
static int chseen = 0, shseen = 0, sccsseen = 0, ccsaftersh = 0;
static int ccsbeforesh = 0, sappdataseen = 0, cappdataseen = 0, badccs = 0;
static int badvers = 0, badsessid = 0;

static unsigned char chsessid[SSL_MAX_SSL_SESSION_ID_LENGTH];
static size_t chsessidlen = 0;

static int watchccs_new(BIO *bi);
static int watchccs_free(BIO *a);
static int watchccs_read(BIO *b, char *out, int outl);
static int watchccs_write(BIO *b, const char *in, int inl);
static long watchccs_ctrl(BIO *b, int cmd, long num, void *ptr);
static int watchccs_gets(BIO *bp, char *buf, int size);
static int watchccs_puts(BIO *bp, const char *str);

/* Choose a sufficiently large type likely to be unused for this custom BIO */
# define BIO_TYPE_WATCHCCS_FILTER  (0x80 | BIO_TYPE_FILTER)

static BIO_METHOD *method_watchccs = NULL;

static const BIO_METHOD *bio_f_watchccs_filter()
{
    if (method_watchccs == NULL) {
        method_watchccs = BIO_meth_new(BIO_TYPE_WATCHCCS_FILTER,
                                       "Watch CCS filter");
        if (   method_watchccs == NULL
            || !BIO_meth_set_write(method_watchccs, watchccs_write)
            || !BIO_meth_set_read(method_watchccs, watchccs_read)
            || !BIO_meth_set_puts(method_watchccs, watchccs_puts)
            || !BIO_meth_set_gets(method_watchccs, watchccs_gets)
            || !BIO_meth_set_ctrl(method_watchccs, watchccs_ctrl)
            || !BIO_meth_set_create(method_watchccs, watchccs_new)
            || !BIO_meth_set_destroy(method_watchccs, watchccs_free))
            return NULL;
    }
    return method_watchccs;
}

static int watchccs_new(BIO *bio)
{
    BIO_set_init(bio, 1);
    return 1;
}

static int watchccs_free(BIO *bio)
{
    BIO_set_init(bio, 0);
    return 1;
}

static int watchccs_read(BIO *bio, char *out, int outl)
{
    int ret = 0;
    BIO *next = BIO_next(bio);

    if (outl <= 0)
        return 0;
    if (next == NULL)
        return 0;

    BIO_clear_retry_flags(bio);

    ret = BIO_read(next, out, outl);
    if (ret <= 0 && BIO_should_read(next))
        BIO_set_retry_read(bio);

    return ret;
}

static int watchccs_write(BIO *bio, const char *in, int inl)
{
    int ret = 0;
    BIO *next = BIO_next(bio);
    PACKET pkt, msg, msgbody, sessionid;
    unsigned int rectype, recvers, msgtype, expectedrecvers;

    if (inl <= 0)
        return 0;
    if (next == NULL)
        return 0;

    BIO_clear_retry_flags(bio);

    if (!PACKET_buf_init(&pkt, (const unsigned char *)in, inl))
        return 0;

    /* We assume that we always write complete records each time */
    while (PACKET_remaining(&pkt)) {
        if (!PACKET_get_1(&pkt, &rectype)
                || !PACKET_get_net_2(&pkt, &recvers)
                || !PACKET_get_length_prefixed_2(&pkt, &msg))
            return 0;

        expectedrecvers = TLS1_2_VERSION;

        if (rectype == SSL3_RT_HANDSHAKE) {
            if (!PACKET_get_1(&msg, &msgtype)
                    || !PACKET_get_length_prefixed_3(&msg, &msgbody))
                return 0;
            if (msgtype == SSL3_MT_CLIENT_HELLO) {
                chseen++;

                /*
                 * Skip legacy_version (2 bytes) and Random (32 bytes) to read
                 * session_id.
                 */
                if (!PACKET_forward(&msgbody, 34)
                        || !PACKET_get_length_prefixed_1(&msgbody, &sessionid))
                    return 0;

                if (chseen == 1) {
                    expectedrecvers = TLS1_VERSION;

                    /* Save the session id for later */
                    chsessidlen = PACKET_remaining(&sessionid);
                    if (!PACKET_copy_bytes(&sessionid, chsessid, chsessidlen))
                        return 0;
                } else {
                    /*
                     * Check the session id for the second ClientHello is the
                     * same as the first one.
                     */
                    if (PACKET_remaining(&sessionid) != chsessidlen
                            || (chsessidlen > 0
                                && memcmp(chsessid, PACKET_data(&sessionid),
                                          chsessidlen) != 0))
                        badsessid = 1;
                }
            } else if (msgtype == SSL3_MT_SERVER_HELLO) {
                shseen++;
                /*
                 * Skip legacy_version (2 bytes) and Random (32 bytes) to read
                 * session_id.
                 */
                if (!PACKET_forward(&msgbody, 34)
                        || !PACKET_get_length_prefixed_1(&msgbody, &sessionid))
                    return 0;

                /*
                 * Check the session id is the same as the one in the
                 * ClientHello
                 */
                if (PACKET_remaining(&sessionid) != chsessidlen
                        || (chsessidlen > 0
                            && memcmp(chsessid, PACKET_data(&sessionid),
                                      chsessidlen) != 0))
                    badsessid = 1;
            }
        } else if (rectype == SSL3_RT_CHANGE_CIPHER_SPEC) {
            if (bio == s_to_c_fbio) {
                /*
                 * Server writing. We shouldn't have written any app data
                 * yet, and we should have seen both the ClientHello and the
                 * ServerHello
                 */
                if (!sappdataseen
                        && chseen == 1
                        && shseen == 1
                        && !sccsseen)
                    sccsseen = 1;
                else
                    badccs = 1;
            } else if (!cappdataseen) {
                /*
                 * Client writing. We shouldn't have written any app data
                 * yet, and we should have seen the ClientHello
                 */
                if (shseen == 1 && !ccsaftersh)
                    ccsaftersh = 1;
                else if (shseen == 0 && !ccsbeforesh)
                    ccsbeforesh = 1;
                else
                    badccs = 1;
            } else {
                badccs = 1;
            }
        } else if(rectype == SSL3_RT_APPLICATION_DATA) {
            if (bio == s_to_c_fbio)
                sappdataseen = 1;
            else
                cappdataseen = 1;
        }
        if (recvers != expectedrecvers)
            badvers = 1;
    }

    ret = BIO_write(next, in, inl);
    if (ret <= 0 && BIO_should_write(next))
        BIO_set_retry_write(bio);

    return ret;
}

static long watchccs_ctrl(BIO *bio, int cmd, long num, void *ptr)
{
    long ret;
    BIO *next = BIO_next(bio);

    if (next == NULL)
        return 0;

    switch (cmd) {
    case BIO_CTRL_DUP:
        ret = 0;
        break;
    default:
        ret = BIO_ctrl(next, cmd, num, ptr);
        break;
    }
    return ret;
}

static int watchccs_gets(BIO *bio, char *buf, int size)
{
    /* We don't support this - not needed anyway */
    return -1;
}

static int watchccs_puts(BIO *bio, const char *str)
{
    return watchccs_write(bio, str, strlen(str));
}

static int test_tls13ccs(int tst)
{
    SSL_CTX *sctx = NULL, *cctx = NULL;
    SSL *sssl = NULL, *cssl = NULL;
    int ret = 0;
    const char msg[] = "Dummy data";
    char buf[80];
    size_t written, readbytes;
    SSL_SESSION *sess = NULL;

    chseen = shseen = sccsseen = ccsaftersh = ccsbeforesh = 0;
    sappdataseen = cappdataseen = badccs = badvers = badsessid = 0;
    chsessidlen = 0;

    if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
                                       TLS1_VERSION, TLS_MAX_VERSION,
                                       &sctx, &cctx, cert, privkey))
        || !TEST_true(SSL_CTX_set_max_early_data(sctx,
                                                 SSL3_RT_MAX_PLAIN_LENGTH))
        || !TEST_true(SSL_CTX_set_max_early_data(cctx,
                                                 SSL3_RT_MAX_PLAIN_LENGTH)))
        goto err;

    /*
     * Test 0: Simple Handshake
     * Test 1: Simple Handshake, client middlebox compat mode disabled
     * Test 2: Simple Handshake, server middlebox compat mode disabled
     * Test 3: HRR Handshake
     * Test 4: HRR Handshake, client middlebox compat mode disabled
     * Test 5: HRR Handshake, server middlebox compat mode disabled
     * Test 6: Early data handshake
     * Test 7: Early data handshake, client middlebox compat mode disabled
     * Test 8: Early data handshake, server middlebox compat mode disabled
     * Test 9: Early data then HRR
     * Test 10: Early data then HRR, client middlebox compat mode disabled
     * Test 11: Early data then HRR, server middlebox compat mode disabled
     */
    switch (tst) {
    case 0:
    case 3:
    case 6:
    case 9:
        break;
    case 1:
    case 4:
    case 7:
    case 10:
        SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
        break;
    case 2:
    case 5:
    case 8:
    case 11:
        SSL_CTX_clear_options(sctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
        break;
    default:
        TEST_error("Invalid test value");
        goto err;
    }

    if (tst >= 6) {
        /* Get a session suitable for early_data */
        if (!TEST_true(create_ssl_objects(sctx, cctx, &sssl, &cssl, NULL, NULL))
                || !TEST_true(create_ssl_connection(sssl, cssl, SSL_ERROR_NONE)))
            goto err;
        sess = SSL_get1_session(cssl);
        if (!TEST_ptr(sess))
            goto err;
        SSL_shutdown(cssl);
        SSL_shutdown(sssl);
        SSL_free(sssl);
        SSL_free(cssl);
        sssl = cssl = NULL;
    }

    if ((tst >= 3 && tst <= 5) || tst >= 9) {
        /* HRR handshake */
        if (!TEST_true(SSL_CTX_set1_groups_list(sctx, "P-256")))
            goto err;
    }

    s_to_c_fbio = BIO_new(bio_f_watchccs_filter());
    c_to_s_fbio = BIO_new(bio_f_watchccs_filter());
    if (!TEST_ptr(s_to_c_fbio)
            || !TEST_ptr(c_to_s_fbio)) {
        BIO_free(s_to_c_fbio);
        BIO_free(c_to_s_fbio);
        goto err;
    }

    /* BIOs get freed on error */
    if (!TEST_true(create_ssl_objects(sctx, cctx, &sssl, &cssl, s_to_c_fbio,
                                      c_to_s_fbio)))
        goto err;

    if (tst >= 6) {
        /* Early data */
        if (!TEST_true(SSL_set_session(cssl, sess))
                || !TEST_true(SSL_write_early_data(cssl, msg, strlen(msg),
                                                   &written))
                || (tst <= 8
                    && !TEST_int_eq(SSL_read_early_data(sssl, buf,  sizeof(buf),
                                                &readbytes),
                                                SSL_READ_EARLY_DATA_SUCCESS)))
            goto err;
        if (tst <= 8) {
            if (!TEST_int_gt(SSL_connect(cssl), 0))
                goto err;
        } else {
            if (!TEST_int_le(SSL_connect(cssl), 0))
                goto err;
        }
        if (!TEST_int_eq(SSL_read_early_data(sssl, buf,  sizeof(buf),
                                             &readbytes),
                         SSL_READ_EARLY_DATA_FINISH))
            goto err;
    }

    /* Perform handshake (or complete it if doing early data ) */
    if (!TEST_true(create_ssl_connection(sssl, cssl, SSL_ERROR_NONE)))
        goto err;

    /*
     * Check there were no unexpected CCS messages, all record versions
     * were as expected, and that the session ids were reflected by the server
     * correctly.
     */
    if (!TEST_false(badccs) || !TEST_false(badvers) || !TEST_false(badsessid))
        goto err;

    switch (tst) {
    case 0:
        if (!TEST_true(sccsseen)
                || !TEST_true(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 1:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_eq(chsessidlen, 0))
            goto err;
        break;

    case 2:
        if (!TEST_false(sccsseen)
                || !TEST_true(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 3:
        if (!TEST_true(sccsseen)
                || !TEST_true(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 4:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_eq(chsessidlen, 0))
            goto err;
        break;

    case 5:
        if (!TEST_false(sccsseen)
                || !TEST_true(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 6:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_true(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 7:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_eq(chsessidlen, 0))
            goto err;
        break;

    case 8:
        if (!TEST_false(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_true(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 9:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_true(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    case 10:
        if (!TEST_true(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_false(ccsbeforesh)
                || !TEST_size_t_eq(chsessidlen, 0))
            goto err;
        break;

    case 11:
        if (!TEST_false(sccsseen)
                || !TEST_false(ccsaftersh)
                || !TEST_true(ccsbeforesh)
                || !TEST_size_t_gt(chsessidlen, 0))
            goto err;
        break;

    default:
        TEST_error("Invalid test value");
        goto err;
    }

    ret = 1;
 err:
    SSL_SESSION_free(sess);
    SSL_free(sssl);
    SSL_free(cssl);
    SSL_CTX_free(sctx);
    SSL_CTX_free(cctx);

    return ret;
}

int setup_tests(void)
{
    if (!TEST_ptr(cert = test_get_argument(0))
            || !TEST_ptr(privkey = test_get_argument(1)))
        return 0;

    ADD_ALL_TESTS(test_tls13ccs, 12);

    return 1;
}

void cleanup_tests(void)
{
    BIO_meth_free(method_watchccs);
}
Commit	Line	Data
0ca3aea7	1	/*
0d664759	2	* Copyright 2017-2018 The OpenSSL Project Authors. All Rights Reserved.
0ca3aea7 MC	3	*
	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	#include <openssl/ssl.h>
	11	#include <string.h>
	12	#include "ssltestlib.h"
	13	#include "testutil.h"
	14	#include "../ssl/packet_locl.h"
	15
	16	static char *cert = NULL;
	17	static char *privkey = NULL;
	18
0ababfec MC	19	static BIO s_to_c_fbio = NULL, c_to_s_fbio = NULL;
	20	static int chseen = 0, shseen = 0, sccsseen = 0, ccsaftersh = 0;
	21	static int ccsbeforesh = 0, sappdataseen = 0, cappdataseen = 0, badccs = 0;
	22	static int badvers = 0, badsessid = 0;
0ca3aea7	23
0ababfec MC	24	static unsigned char chsessid[SSL_MAX_SSL_SESSION_ID_LENGTH];
0ababfec MC	25	static size_t chsessidlen = 0;
0ca3aea7 MC	26
	27	static int watchccs_new(BIO *bi);
	28	static int watchccs_free(BIO *a);
	29	static int watchccs_read(BIO b, char out, int outl);
	30	static int watchccs_write(BIO b, const char in, int inl);
	31	static long watchccs_ctrl(BIO b, int cmd, long num, void ptr);
	32	static int watchccs_gets(BIO bp, char buf, int size);
	33	static int watchccs_puts(BIO bp, const char str);
	34
	35	/* Choose a sufficiently large type likely to be unused for this custom BIO */
	36	# define BIO_TYPE_WATCHCCS_FILTER (0x80 \| BIO_TYPE_FILTER)
	37
	38	static BIO_METHOD *method_watchccs = NULL;
	39
	40	static const BIO_METHOD *bio_f_watchccs_filter()
	41	{
	42	if (method_watchccs == NULL) {
	43	method_watchccs = BIO_meth_new(BIO_TYPE_WATCHCCS_FILTER,
	44	"Watch CCS filter");
	45	if ( method_watchccs == NULL
	46	\|\| !BIO_meth_set_write(method_watchccs, watchccs_write)
	47	\|\| !BIO_meth_set_read(method_watchccs, watchccs_read)
	48	\|\| !BIO_meth_set_puts(method_watchccs, watchccs_puts)
	49	\|\| !BIO_meth_set_gets(method_watchccs, watchccs_gets)
	50	\|\| !BIO_meth_set_ctrl(method_watchccs, watchccs_ctrl)
	51	\|\| !BIO_meth_set_create(method_watchccs, watchccs_new)
	52	\|\| !BIO_meth_set_destroy(method_watchccs, watchccs_free))
	53	return NULL;
	54	}
	55	return method_watchccs;
	56	}
	57
	58	static int watchccs_new(BIO *bio)
	59	{
	60	BIO_set_init(bio, 1);
	61	return 1;
	62	}
	63
	64	static int watchccs_free(BIO *bio)
	65	{
	66	BIO_set_init(bio, 0);
	67	return 1;
	68	}
	69
	70	static int watchccs_read(BIO bio, char out, int outl)
	71	{
	72	int ret = 0;
	73	BIO *next = BIO_next(bio);
	74
	75	if (outl <= 0)
	76	return 0;
	77	if (next == NULL)
	78	return 0;
	79
	80	BIO_clear_retry_flags(bio);
	81
	82	ret = BIO_read(next, out, outl);
	83	if (ret <= 0 && BIO_should_read(next))
	84	BIO_set_retry_read(bio);
	85
	86	return ret;
	87	}
	88
	89	static int watchccs_write(BIO bio, const char in, int inl)
90	{
91	int ret = 0;
92	BIO *next = BIO_next(bio);
93	PACKET pkt, msg, msgbody, sessionid;
94	unsigned int rectype, recvers, msgtype, expectedrecvers;
95
96	if (inl <= 0)
97	return 0;
98	if (next == NULL)
99	return 0;
100
101	BIO_clear_retry_flags(bio);
102
103	if (!PACKET_buf_init(&pkt, (const unsigned char *)in, inl))
104	return 0;
105
106	/* We assume that we always write complete records each time */
107	while (PACKET_remaining(&pkt)) {
108	if (!PACKET_get_1(&pkt, &rectype)
109	\|\| !PACKET_get_net_2(&pkt, &recvers)
110	\|\| !PACKET_get_length_prefixed_2(&pkt, &msg))
111	return 0;
112
113	expectedrecvers = TLS1_2_VERSION;
114
115	if (rectype == SSL3_RT_HANDSHAKE) {
116	if (!PACKET_get_1(&msg, &msgtype)
117	\|\| !PACKET_get_length_prefixed_3(&msg, &msgbody))
118	return 0;
119	if (msgtype == SSL3_MT_CLIENT_HELLO) {
120	chseen++;
5f7470df	121
0ca3aea7 MC	122	/*
	123	* Skip legacy_version (2 bytes) and Random (32 bytes) to read
	124	* session_id.
	125	*/
	126	if (!PACKET_forward(&msgbody, 34)
	127	\|\| !PACKET_get_length_prefixed_1(&msgbody, &sessionid))
	128	return 0;
	129
	130	if (chseen == 1) {
5f7470df MC	131	expectedrecvers = TLS1_VERSION;
5f7470df MC	132
0ca3aea7 MC	133	/* Save the session id for later */
	134	chsessidlen = PACKET_remaining(&sessionid);
	135	if (!PACKET_copy_bytes(&sessionid, chsessid, chsessidlen))
	136	return 0;
	137	} else {
	138	/*
	139	* Check the session id for the second ClientHello is the
	140	* same as the first one.
	141	*/
	142	if (PACKET_remaining(&sessionid) != chsessidlen
	143	\|\| (chsessidlen > 0
	144	&& memcmp(chsessid, PACKET_data(&sessionid),
	145	chsessidlen) != 0))
	146	badsessid = 1;
	147	}
	148	} else if (msgtype == SSL3_MT_SERVER_HELLO) {
	149	shseen++;
	150	/*
	151	* Skip legacy_version (2 bytes) and Random (32 bytes) to read
	152	* session_id.
	153	*/
	154	if (!PACKET_forward(&msgbody, 34)
	155	\|\| !PACKET_get_length_prefixed_1(&msgbody, &sessionid))
	156	return 0;
	157
	158	/*
	159	* Check the session id is the same as the one in the
	160	* ClientHello
	161	*/
	162	if (PACKET_remaining(&sessionid) != chsessidlen
	163	\|\| (chsessidlen > 0
	164	&& memcmp(chsessid, PACKET_data(&sessionid),
	165	chsessidlen) != 0))
	166	badsessid = 1;
	167	}
	168	} else if (rectype == SSL3_RT_CHANGE_CIPHER_SPEC) {
	169	if (bio == s_to_c_fbio) {
	170	/*
	171	* Server writing. We shouldn't have written any app data
	172	* yet, and we should have seen both the ClientHello and the
	173	* ServerHello
	174	*/
	175	if (!sappdataseen
	176	&& chseen == 1
	177	&& shseen == 1
	178	&& !sccsseen)
	179	sccsseen = 1;
	180	else
	181	badccs = 1;
	182	} else if (!cappdataseen) {
	183	/*
	184	* Client writing. We shouldn't have written any app data
	185	* yet, and we should have seen the ClientHello
	186	*/
	187	if (shseen == 1 && !ccsaftersh)
	188	ccsaftersh = 1;
	189	else if (shseen == 0 && !ccsbeforesh)
	190	ccsbeforesh = 1;
	191	else
	192	badccs = 1;
	193	} else {
	194	badccs = 1;
	195	}
	196	} else if(rectype == SSL3_RT_APPLICATION_DATA) {
197	if (bio == s_to_c_fbio)
198	sappdataseen = 1;
199	else
200	cappdataseen = 1;
201	}
202	if (recvers != expectedrecvers)
203	badvers = 1;
204	}
205
206	ret = BIO_write(next, in, inl);
207	if (ret <= 0 && BIO_should_write(next))
208	BIO_set_retry_write(bio);
209
210	return ret;
211	}
212
213	static long watchccs_ctrl(BIO bio, int cmd, long num, void ptr)
214	{
215	long ret;
216	BIO *next = BIO_next(bio);
217
218	if (next == NULL)
219	return 0;
220
221	switch (cmd) {
222	case BIO_CTRL_DUP:
223	ret = 0;
224	break;
225	default:
226	ret = BIO_ctrl(next, cmd, num, ptr);
227	break;
228	}
229	return ret;
230	}
231
232	static int watchccs_gets(BIO bio, char buf, int size)
233	{
234	/* We don't support this - not needed anyway */
235	return -1;
236	}
237
238	static int watchccs_puts(BIO bio, const char str)
239	{
240	return watchccs_write(bio, str, strlen(str));
241	}
242
243	static int test_tls13ccs(int tst)
244	{
245	SSL_CTX sctx = NULL, cctx = NULL;
246	SSL sssl = NULL, cssl = NULL;
247	int ret = 0;
248	const char msg[] = "Dummy data";
249	char buf[80];
250	size_t written, readbytes;
251	SSL_SESSION *sess = NULL;
252
253	chseen = shseen = sccsseen = ccsaftersh = ccsbeforesh = 0;
254	sappdataseen = cappdataseen = badccs = badvers = badsessid = 0;
255	chsessidlen = 0;
256
257	if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
7d7f6834	258	TLS1_VERSION, TLS_MAX_VERSION,
c39e4048 BK	259	&sctx, &cctx, cert, privkey))
	260	\|\| !TEST_true(SSL_CTX_set_max_early_data(sctx,
	261	SSL3_RT_MAX_PLAIN_LENGTH))
	262	\|\| !TEST_true(SSL_CTX_set_max_early_data(cctx,
	263	SSL3_RT_MAX_PLAIN_LENGTH)))
0ca3aea7 MC	264	goto err;
	265
	266	/*
	267	* Test 0: Simple Handshake
	268	* Test 1: Simple Handshake, client middlebox compat mode disabled
	269	* Test 2: Simple Handshake, server middlebox compat mode disabled
	270	* Test 3: HRR Handshake
	271	* Test 4: HRR Handshake, client middlebox compat mode disabled
	272	* Test 5: HRR Handshake, server middlebox compat mode disabled
	273	* Test 6: Early data handshake
	274	* Test 7: Early data handshake, client middlebox compat mode disabled
	275	* Test 8: Early data handshake, server middlebox compat mode disabled
	276	* Test 9: Early data then HRR
	277	* Test 10: Early data then HRR, client middlebox compat mode disabled
	278	* Test 11: Early data then HRR, server middlebox compat mode disabled
	279	*/
	280	switch (tst) {
	281	case 0:
	282	case 3:
	283	case 6:
	284	case 9:
	285	break;
	286	case 1:
	287	case 4:
	288	case 7:
	289	case 10:
	290	SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
	291	break;
	292	case 2:
	293	case 5:
	294	case 8:
	295	case 11:
	296	SSL_CTX_clear_options(sctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
	297	break;
	298	default:
	299	TEST_error("Invalid test value");
	300	goto err;
	301	}
	302
	303	if (tst >= 6) {
	304	/* Get a session suitable for early_data */
	305	if (!TEST_true(create_ssl_objects(sctx, cctx, &sssl, &cssl, NULL, NULL))
	306	\|\| !TEST_true(create_ssl_connection(sssl, cssl, SSL_ERROR_NONE)))
	307	goto err;
	308	sess = SSL_get1_session(cssl);
	309	if (!TEST_ptr(sess))
	310	goto err;
	311	SSL_shutdown(cssl);
	312	SSL_shutdown(sssl);
	313	SSL_free(sssl);
	314	SSL_free(cssl);
	315	sssl = cssl = NULL;
	316	}
	317
	318	if ((tst >= 3 && tst <= 5) \|\| tst >= 9) {
	319	/* HRR handshake */
	320	if (!TEST_true(SSL_CTX_set1_groups_list(sctx, "P-256")))
	321	goto err;
	322	}
	323
	324	s_to_c_fbio = BIO_new(bio_f_watchccs_filter());
	325	c_to_s_fbio = BIO_new(bio_f_watchccs_filter());
	326	if (!TEST_ptr(s_to_c_fbio)
	327	\|\| !TEST_ptr(c_to_s_fbio)) {
328	BIO_free(s_to_c_fbio);
329	BIO_free(c_to_s_fbio);
330	goto err;
331	}
332
333	/* BIOs get freed on error */
334	if (!TEST_true(create_ssl_objects(sctx, cctx, &sssl, &cssl, s_to_c_fbio,
335	c_to_s_fbio)))
336	goto err;
337
338	if (tst >= 6) {
339	/* Early data */
340	if (!TEST_true(SSL_set_session(cssl, sess))
341	\|\| !TEST_true(SSL_write_early_data(cssl, msg, strlen(msg),
342	&written))
343	\|\| (tst <= 8
344	&& !TEST_int_eq(SSL_read_early_data(sssl, buf, sizeof(buf),
345	&readbytes),
346	SSL_READ_EARLY_DATA_SUCCESS)))
347	goto err;
348	if (tst <= 8) {
349	if (!TEST_int_gt(SSL_connect(cssl), 0))
350	goto err;
351	} else {
352	if (!TEST_int_le(SSL_connect(cssl), 0))
353	goto err;
354	}
355	if (!TEST_int_eq(SSL_read_early_data(sssl, buf, sizeof(buf),
356	&readbytes),
357	SSL_READ_EARLY_DATA_FINISH))
358	goto err;
359	}
360
361	/* Perform handshake (or complete it if doing early data ) */
362	if (!TEST_true(create_ssl_connection(sssl, cssl, SSL_ERROR_NONE)))
363	goto err;
364
365	/*
366	* Check there were no unexpected CCS messages, all record versions
367	* were as expected, and that the session ids were reflected by the server
368	* correctly.
369	*/
370	if (!TEST_false(badccs) \|\| !TEST_false(badvers) \|\| !TEST_false(badsessid))
371	goto err;
372
373	switch (tst) {
374	case 0:
375	if (!TEST_true(sccsseen)
376	\|\| !TEST_true(ccsaftersh)
377	\|\| !TEST_false(ccsbeforesh)
378	\|\| !TEST_size_t_gt(chsessidlen, 0))
379	goto err;
380	break;
381
382	case 1:
383	if (!TEST_true(sccsseen)
384	\|\| !TEST_false(ccsaftersh)
385	\|\| !TEST_false(ccsbeforesh)
386	\|\| !TEST_size_t_eq(chsessidlen, 0))
387	goto err;
388	break;
389
390	case 2:
391	if (!TEST_false(sccsseen)
392	\|\| !TEST_true(ccsaftersh)
393	\|\| !TEST_false(ccsbeforesh)
394	\|\| !TEST_size_t_gt(chsessidlen, 0))
395	goto err;
396	break;
397
398	case 3:
399	if (!TEST_true(sccsseen)
400	\|\| !TEST_true(ccsaftersh)
401	\|\| !TEST_false(ccsbeforesh)
402	\|\| !TEST_size_t_gt(chsessidlen, 0))
403	goto err;
404	break;
405
406	case 4:
407	if (!TEST_true(sccsseen)
408	\|\| !TEST_false(ccsaftersh)
409	\|\| !TEST_false(ccsbeforesh)
410	\|\| !TEST_size_t_eq(chsessidlen, 0))
411	goto err;
412	break;
413
414	case 5:
415	if (!TEST_false(sccsseen)
416	\|\| !TEST_true(ccsaftersh)
417	\|\| !TEST_false(ccsbeforesh)
418	\|\| !TEST_size_t_gt(chsessidlen, 0))
419	goto err;
420	break;
421
422	case 6:
423	if (!TEST_true(sccsseen)
424	\|\| !TEST_false(ccsaftersh)
425	\|\| !TEST_true(ccsbeforesh)
426	\|\| !TEST_size_t_gt(chsessidlen, 0))
427	goto err;
428	break;
429
430	case 7:
431	if (!TEST_true(sccsseen)
432	\|\| !TEST_false(ccsaftersh)
433	\|\| !TEST_false(ccsbeforesh)
434	\|\| !TEST_size_t_eq(chsessidlen, 0))
435	goto err;
436	break;
437
438	case 8:
439	if (!TEST_false(sccsseen)
440	\|\| !TEST_false(ccsaftersh)
441	\|\| !TEST_true(ccsbeforesh)
442	\|\| !TEST_size_t_gt(chsessidlen, 0))
443	goto err;
444	break;
445
446	case 9:
447	if (!TEST_true(sccsseen)
448	\|\| !TEST_false(ccsaftersh)
449	\|\| !TEST_true(ccsbeforesh)
450	\|\| !TEST_size_t_gt(chsessidlen, 0))
451	goto err;
452	break;
453
454	case 10:
455	if (!TEST_true(sccsseen)
456	\|\| !TEST_false(ccsaftersh)
457	\|\| !TEST_false(ccsbeforesh)
458	\|\| !TEST_size_t_eq(chsessidlen, 0))
459	goto err;
460	break;
461
462	case 11:
463	if (!TEST_false(sccsseen)
464	\|\| !TEST_false(ccsaftersh)
465	\|\| !TEST_true(ccsbeforesh)
466	\|\| !TEST_size_t_gt(chsessidlen, 0))
467	goto err;
468	break;
469
470	default:
471	TEST_error("Invalid test value");
472	goto err;
473	}
474
475	ret = 1;
476	err:
477	SSL_SESSION_free(sess);
478	SSL_free(sssl);
479	SSL_free(cssl);
480	SSL_CTX_free(sctx);
481	SSL_CTX_free(cctx);
482
483	return ret;
484	}
485
486	int setup_tests(void)
487	{
488	if (!TEST_ptr(cert = test_get_argument(0))
489	\|\| !TEST_ptr(privkey = test_get_argument(1)))
490	return 0;
491
492	ADD_ALL_TESTS(test_tls13ccs, 12);
493
494	return 1;
495	}
496
497	void cleanup_tests(void)
498	{
499	BIO_meth_free(method_watchccs);
500	}