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

/*
 * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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 <string.h>
#include <openssl/buffer.h>
#include <openssl/rand.h>
#include "internal/packet.h"
#include "testutil.h"

static const unsigned char simple1[] = { 0xff };
static const unsigned char simple2[] = { 0x01, 0xff };
static const unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
static const unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
static const unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
static const unsigned char empty[] = { 0x00 };
static const unsigned char alloc[] = { 0x02, 0xfe, 0xff };
static const unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
static const unsigned char fixed[] = { 0xff, 0xff, 0xff };
static const unsigned char simpleder[] = {
    0xfc, 0x04, 0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd
};

static BUF_MEM *buf;

static int cleanup(WPACKET *pkt)
{
    WPACKET_cleanup(pkt);
    return 0;
}

static int test_WPACKET_init(void)
{
    WPACKET pkt;
    int i;
    size_t written;
    unsigned char sbuf[3];

    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
                /* Closing a top level WPACKET should fail */
            || !TEST_false(WPACKET_close(&pkt))
                /* Finishing a top level WPACKET should succeed */
            || !TEST_true(WPACKET_finish(&pkt))
                /*
                 * Can't call close or finish on a WPACKET that's already
                 * finished.
                 */
            || !TEST_false(WPACKET_close(&pkt))
            || !TEST_false(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
        return cleanup(&pkt);

    /* Now try with a one byte length prefix */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
        return cleanup(&pkt);

    /* And a longer length prefix */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
        return cleanup(&pkt);

    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
        return cleanup(&pkt);
    for (i = 1; i < 257; i++) {
        /*
         * Putting more bytes in than fit for the size of the length prefix
         * should fail
         */
        if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
            return cleanup(&pkt);
    }
    if (!TEST_true(WPACKET_finish(&pkt)))
        return cleanup(&pkt);

    /* Test initialising from a fixed size buffer */
    if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
                /* Adding 3 bytes should succeed */
            || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
                /* Adding 1 more byte should fail */
            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
                /* Finishing the top level WPACKET should succeed */
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
                /* Initialise with 1 len byte */
            || !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
                /* Adding 2 bytes should succeed */
            || !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
                /* Adding 1 more byte should fail */
            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
        return cleanup(&pkt);

    return 1;
}

static int test_WPACKET_set_max_size(void)
{
    WPACKET pkt;
    size_t written;

    if (!TEST_true(WPACKET_init(&pkt, buf))
                /*
                 * No previous lenbytes set so we should be ok to set the max
                 * possible max size
                 */
            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
                /* We should be able to set it smaller too */
            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
                /* And setting it bigger again should be ok */
            || !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
            || !TEST_true(WPACKET_finish(&pkt)))
        return cleanup(&pkt);

    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
                /*
                 * Should fail because we already consumed 1 byte with the
                 * length
                 */
            || !TEST_false(WPACKET_set_max_size(&pkt, 0))
                /*
                 * Max size can't be bigger than biggest that will fit in
                 * lenbytes
                 */
            || !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
                /* It can be the same as the maximum possible size */
            || !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
                /* Or it can be less */
            || !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
                /* Should fail because packet is already filled */
            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
                /* You can't put in more bytes than max size */
            || !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
        return cleanup(&pkt);

    return 1;
}

static int test_WPACKET_start_sub_packet(void)
{
    WPACKET pkt;
    size_t written;
    size_t len;

    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
                /* Can't finish because we have a sub packet */
            || !TEST_false(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_close(&pkt))
                /* Sub packet is closed so can't close again */
            || !TEST_false(WPACKET_close(&pkt))
                /* Now a top level so finish should succeed */
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
        return cleanup(&pkt);

   /* Single sub-packet with length prefix */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
        return cleanup(&pkt);

    /* Nested sub-packets with length prefixes */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_get_length(&pkt, &len))
            || !TEST_size_t_eq(len, 1)
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_get_length(&pkt, &len))
            || !TEST_size_t_eq(len, 3)
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
        return cleanup(&pkt);

    /* Sequential sub-packets with length prefixes */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
        return cleanup(&pkt);

    /* Nested sub-packets with lengths filled before finish */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_get_length(&pkt, &len))
            || !TEST_size_t_eq(len, 1)
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_get_length(&pkt, &len))
            || !TEST_size_t_eq(len, 3)
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_fill_lengths(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
            || !TEST_true(WPACKET_finish(&pkt)))
        return cleanup(&pkt);

    return 1;
}


static int test_WPACKET_set_flags(void)
{
    WPACKET pkt;
    size_t written;

    /* Set packet to be non-zero length */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
                /* Should fail because of zero length */
            || !TEST_false(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
        return cleanup(&pkt);

    /* Repeat above test in a sub-packet */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet(&pkt))
            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
                /* Should fail because of zero length */
            || !TEST_false(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
        return cleanup(&pkt);

    /* Set packet to abandon non-zero length */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_size_t_eq(written, 0))
        return cleanup(&pkt);

    /* Repeat above test but only abandon a sub-packet */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
        return cleanup(&pkt);

    /* And repeat with a non empty sub-packet */
    if (!TEST_true(WPACKET_init(&pkt, buf))
            || !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
            || !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
        return cleanup(&pkt);
    return 1;
}

static int test_WPACKET_allocate_bytes(void)
{
    WPACKET pkt;
    size_t written;
    unsigned char *bytes;

    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
        return cleanup(&pkt);
    bytes[0] = 0xfe;
    bytes[1] = 0xff;
    if (!TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
        return cleanup(&pkt);

    /* Repeat with WPACKET_sub_allocate_bytes */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
        return cleanup(&pkt);
    bytes[0] = 0xfe;
    bytes[1] = 0xff;
    if (!TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
        return cleanup(&pkt);

    return 1;
}

static int test_WPACKET_memcpy(void)
{
    WPACKET pkt;
    size_t written;
    const unsigned char bytes[] = { 0xfe, 0xff };

    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
        return cleanup(&pkt);

    /* Repeat with WPACKET_sub_memcpy() */
    if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
            || !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written))
            || !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
        return cleanup(&pkt);

    return 1;
}

static int test_WPACKET_init_der(void)
{
    WPACKET pkt;
    unsigned char sbuf[1024];
    unsigned char testdata[] = { 0x00, 0x01, 0x02, 0x03 };
    unsigned char testdata2[259]  = { 0x82, 0x01, 0x00 };
    size_t written[2];
    int i;

    /* Test initialising for writing DER */
    if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf)))
            || !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xfffefd))
               /* Test writing data in a length prefixed sub-packet */
            || !TEST_true(WPACKET_start_sub_packet(&pkt))
            || !TEST_true(WPACKET_memcpy(&pkt, testdata, sizeof(testdata)))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xfc))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written[0]))
            || !TEST_mem_eq(WPACKET_get_curr(&pkt), written[0], simpleder,
                            sizeof(simpleder)))
        return cleanup(&pkt);

    /* Generate random packet data for test */
    if (!TEST_true(RAND_bytes(&testdata2[3], sizeof(testdata2) - 3)))
        return 0;

    /*
     * Test with a sub-packet that has 2 length bytes. We do 2 passes - first
     * with a NULL buffer, just to calculate lengths, and a second pass with a
     * real buffer to actually generate a packet
     */
    for (i = 0; i < 2; i++) {
        if (i == 0) {
            if (!TEST_true(WPACKET_init_null_der(&pkt)))
                return 0;
        } else { 
            if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf))))
                return 0;
        }
        if (!TEST_true(WPACKET_start_sub_packet(&pkt))
            || !TEST_true(WPACKET_memcpy(&pkt, &testdata2[3],
                                         sizeof(testdata2) - 3))
            || !TEST_true(WPACKET_close(&pkt))
            || !TEST_true(WPACKET_finish(&pkt))
            || !TEST_true(WPACKET_get_total_written(&pkt, &written[i])))
        return cleanup(&pkt);
    }

    /*
     * Check that the size calculated in the first pass equals the size of the
     * packet actually generated in the second pass. Also check the generated
     * packet looks as we expect it to.
     */
    if (!TEST_size_t_eq(written[0], written[1])
            || !TEST_mem_eq(WPACKET_get_curr(&pkt), written[1], testdata2,
                            sizeof(testdata2)))
        return 0;

    return 1;
}

int setup_tests(void)
{
    if (!TEST_ptr(buf = BUF_MEM_new()))
            return 0;

    ADD_TEST(test_WPACKET_init);
    ADD_TEST(test_WPACKET_set_max_size);
    ADD_TEST(test_WPACKET_start_sub_packet);
    ADD_TEST(test_WPACKET_set_flags);
    ADD_TEST(test_WPACKET_allocate_bytes);
    ADD_TEST(test_WPACKET_memcpy);
    ADD_TEST(test_WPACKET_init_der);
    return 1;
}

void cleanup_tests(void)
{
    BUF_MEM_free(buf);
}
Commit	Line	Data
d6c4cc29	1	/*
c486283c	2	* Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
d6c4cc29	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
d6c4cc29 MC	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 <string.h>
	11	#include <openssl/buffer.h>
a056ee28	12	#include <openssl/rand.h>
0d345f0e	13	#include "internal/packet.h"
d6c4cc29 MC	14	#include "testutil.h"
d6c4cc29 MC	15
f44903a4 BK	16	static const unsigned char simple1[] = { 0xff };
	17	static const unsigned char simple2[] = { 0x01, 0xff };
	18	static const unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
	19	static const unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
	20	static const unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
	21	static const unsigned char empty[] = { 0x00 };
	22	static const unsigned char alloc[] = { 0x02, 0xfe, 0xff };
	23	static const unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
	24	static const unsigned char fixed[] = { 0xff, 0xff, 0xff };
a056ee28 MC	25	static const unsigned char simpleder[] = {
	26	0xfc, 0x04, 0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd
	27	};
d6c4cc29 MC	28
	29	static BUF_MEM *buf;
	30
adcd8e37	31	static int cleanup(WPACKET *pkt)
d6c4cc29	32	{
d6c4cc29	33	WPACKET_cleanup(pkt);
adcd8e37	34	return 0;
d6c4cc29 MC	35	}
	36
	37	static int test_WPACKET_init(void)
	38	{
	39	WPACKET pkt;
	40	int i;
	41	size_t written;
9b36b7d9	42	unsigned char sbuf[3];
d6c4cc29	43
adcd8e37 RS	44	if (!TEST_true(WPACKET_init(&pkt, buf))
adcd8e37 RS	45	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
d6c4cc29	46	/* Closing a top level WPACKET should fail */
adcd8e37	47	\|\| !TEST_false(WPACKET_close(&pkt))
d6c4cc29	48	/* Finishing a top level WPACKET should succeed */
adcd8e37	49	\|\| !TEST_true(WPACKET_finish(&pkt))
d6c4cc29 MC	50	/*
	51	* Can't call close or finish on a WPACKET that's already
	52	* finished.
	53	*/
adcd8e37 RS	54	\|\| !TEST_false(WPACKET_close(&pkt))
	55	\|\| !TEST_false(WPACKET_finish(&pkt))
	56	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	57	\|\| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
	58	return cleanup(&pkt);
d6c4cc29 MC	59
d6c4cc29 MC	60	/* Now try with a one byte length prefix */
adcd8e37 RS	61	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	62	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	63	\|\| !TEST_true(WPACKET_finish(&pkt))
	64	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	65	\|\| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
	66	return cleanup(&pkt);
d6c4cc29 MC	67
d6c4cc29 MC	68	/* And a longer length prefix */
adcd8e37 RS	69	if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
	70	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	71	\|\| !TEST_true(WPACKET_finish(&pkt))
	72	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	73	\|\| !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
	74	return cleanup(&pkt);
	75
	76	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
	77	return cleanup(&pkt);
d6c4cc29 MC	78	for (i = 1; i < 257; i++) {
	79	/*
	80	* Putting more bytes in than fit for the size of the length prefix
	81	* should fail
	82	*/
adcd8e37 RS	83	if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
adcd8e37 RS	84	return cleanup(&pkt);
d6c4cc29	85	}
adcd8e37 RS	86	if (!TEST_true(WPACKET_finish(&pkt)))
adcd8e37 RS	87	return cleanup(&pkt);
d6c4cc29	88
9b36b7d9	89	/* Test initialising from a fixed size buffer */
adcd8e37	90	if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
9b36b7d9	91	/* Adding 3 bytes should succeed */
adcd8e37	92	\|\| !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
9b36b7d9	93	/* Adding 1 more byte should fail */
adcd8e37	94	\|\| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
9b36b7d9	95	/* Finishing the top level WPACKET should succeed */
adcd8e37 RS	96	\|\| !TEST_true(WPACKET_finish(&pkt))
	97	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	98	\|\| !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
9b36b7d9	99	/* Initialise with 1 len byte */
adcd8e37	100	\|\| !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
9b36b7d9	101	/* Adding 2 bytes should succeed */
adcd8e37	102	\|\| !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
9b36b7d9	103	/* Adding 1 more byte should fail */
adcd8e37 RS	104	\|\| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
	105	\|\| !TEST_true(WPACKET_finish(&pkt))
	106	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	107	\|\| !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
	108	return cleanup(&pkt);
9b36b7d9	109
d6c4cc29 MC	110	return 1;
	111	}
	112
d6c4cc29 MC	113	static int test_WPACKET_set_max_size(void)
	114	{
	115	WPACKET pkt;
	116	size_t written;
d6c4cc29	117
adcd8e37	118	if (!TEST_true(WPACKET_init(&pkt, buf))
d6c4cc29 MC	119	/*
	120	* No previous lenbytes set so we should be ok to set the max
	121	* possible max size
	122	*/
adcd8e37	123	\|\| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
d6c4cc29	124	/* We should be able to set it smaller too */
adcd8e37	125	\|\| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
d6c4cc29	126	/* And setting it bigger again should be ok */
adcd8e37 RS	127	\|\| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
	128	\|\| !TEST_true(WPACKET_finish(&pkt)))
	129	return cleanup(&pkt);
de451856	130
adcd8e37	131	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
de451856 MC	132	/*
	133	* Should fail because we already consumed 1 byte with the
	134	* length
	135	*/
adcd8e37	136	\|\| !TEST_false(WPACKET_set_max_size(&pkt, 0))
d6c4cc29 MC	137	/*
	138	* Max size can't be bigger than biggest that will fit in
	139	* lenbytes
	140	*/
adcd8e37	141	\|\| !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
d6c4cc29	142	/* It can be the same as the maximum possible size */
adcd8e37	143	\|\| !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
d6c4cc29	144	/* Or it can be less */
adcd8e37 RS	145	\|\| !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
	146	/* Should fail because packet is already filled */
	147	\|\| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
	148	/* You can't put in more bytes than max size */
	149	\|\| !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
	150	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	151	\|\| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
	152	\|\| !TEST_true(WPACKET_finish(&pkt))
	153	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	154	\|\| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
	155	return cleanup(&pkt);
d6c4cc29 MC	156
	157	return 1;
	158	}
	159
	160	static int test_WPACKET_start_sub_packet(void)
	161	{
	162	WPACKET pkt;
	163	size_t written;
	164	size_t len;
	165
adcd8e37 RS	166	if (!TEST_true(WPACKET_init(&pkt, buf))
	167	\|\| !TEST_true(WPACKET_start_sub_packet(&pkt))
	168	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
d6c4cc29	169	/* Can't finish because we have a sub packet */
adcd8e37 RS	170	\|\| !TEST_false(WPACKET_finish(&pkt))
adcd8e37 RS	171	\|\| !TEST_true(WPACKET_close(&pkt))
d6c4cc29	172	/* Sub packet is closed so can't close again */
adcd8e37	173	\|\| !TEST_false(WPACKET_close(&pkt))
d6c4cc29	174	/* Now a top level so finish should succeed */
adcd8e37 RS	175	\|\| !TEST_true(WPACKET_finish(&pkt))
	176	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	177	\|\| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
	178	return cleanup(&pkt);
d6c4cc29 MC	179
d6c4cc29 MC	180	/* Single sub-packet with length prefix */
adcd8e37 RS	181	if (!TEST_true(WPACKET_init(&pkt, buf))
	182	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	183	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	184	\|\| !TEST_true(WPACKET_close(&pkt))
	185	\|\| !TEST_true(WPACKET_finish(&pkt))
	186	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	187	\|\| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
	188	return cleanup(&pkt);
d6c4cc29 MC	189
d6c4cc29 MC	190	/* Nested sub-packets with length prefixes */
adcd8e37 RS	191	if (!TEST_true(WPACKET_init(&pkt, buf))
	192	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	193	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	194	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	195	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	196	\|\| !TEST_true(WPACKET_get_length(&pkt, &len))
	197	\|\| !TEST_size_t_eq(len, 1)
	198	\|\| !TEST_true(WPACKET_close(&pkt))
	199	\|\| !TEST_true(WPACKET_get_length(&pkt, &len))
	200	\|\| !TEST_size_t_eq(len, 3)
	201	\|\| !TEST_true(WPACKET_close(&pkt))
	202	\|\| !TEST_true(WPACKET_finish(&pkt))
	203	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	204	\|\| !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
	205	return cleanup(&pkt);
d6c4cc29 MC	206
d6c4cc29 MC	207	/* Sequential sub-packets with length prefixes */
adcd8e37 RS	208	if (!TEST_true(WPACKET_init(&pkt, buf))
	209	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	210	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	211	\|\| !TEST_true(WPACKET_close(&pkt))
	212	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	213	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	214	\|\| !TEST_true(WPACKET_close(&pkt))
	215	\|\| !TEST_true(WPACKET_finish(&pkt))
	216	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	217	\|\| !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
	218	return cleanup(&pkt);
d6c4cc29	219
34254342	220	/* Nested sub-packets with lengths filled before finish */
adcd8e37 RS	221	if (!TEST_true(WPACKET_init(&pkt, buf))
	222	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	223	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	224	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	225	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	226	\|\| !TEST_true(WPACKET_get_length(&pkt, &len))
	227	\|\| !TEST_size_t_eq(len, 1)
	228	\|\| !TEST_true(WPACKET_close(&pkt))
	229	\|\| !TEST_true(WPACKET_get_length(&pkt, &len))
	230	\|\| !TEST_size_t_eq(len, 3)
	231	\|\| !TEST_true(WPACKET_close(&pkt))
	232	\|\| !TEST_true(WPACKET_fill_lengths(&pkt))
	233	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	234	\|\| !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
	235	\|\| !TEST_true(WPACKET_finish(&pkt)))
	236	return cleanup(&pkt);
34254342	237
d6c4cc29 MC	238	return 1;
	239	}
	240
	241
	242	static int test_WPACKET_set_flags(void)
	243	{
	244	WPACKET pkt;
	245	size_t written;
	246
	247	/* Set packet to be non-zero length */
adcd8e37 RS	248	if (!TEST_true(WPACKET_init(&pkt, buf))
adcd8e37 RS	249	\|\| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
d6c4cc29	250	/* Should fail because of zero length */
adcd8e37 RS	251	\|\| !TEST_false(WPACKET_finish(&pkt))
	252	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	253	\|\| !TEST_true(WPACKET_finish(&pkt))
	254	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	255	\|\| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
	256	return cleanup(&pkt);
d6c4cc29 MC	257
d6c4cc29 MC	258	/* Repeat above test in a sub-packet */
adcd8e37 RS	259	if (!TEST_true(WPACKET_init(&pkt, buf))
	260	\|\| !TEST_true(WPACKET_start_sub_packet(&pkt))
	261	\|\| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
d6c4cc29	262	/* Should fail because of zero length */
adcd8e37 RS	263	\|\| !TEST_false(WPACKET_close(&pkt))
	264	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	265	\|\| !TEST_true(WPACKET_close(&pkt))
	266	\|\| !TEST_true(WPACKET_finish(&pkt))
	267	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	268	\|\| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
	269	return cleanup(&pkt);
d6c4cc29 MC	270
d6c4cc29 MC	271	/* Set packet to abandon non-zero length */
adcd8e37 RS	272	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	273	\|\| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
	274	\|\| !TEST_true(WPACKET_finish(&pkt))
	275	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	276	\|\| !TEST_size_t_eq(written, 0))
	277	return cleanup(&pkt);
d6c4cc29 MC	278
d6c4cc29 MC	279	/* Repeat above test but only abandon a sub-packet */
adcd8e37 RS	280	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	281	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	282	\|\| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
	283	\|\| !TEST_true(WPACKET_close(&pkt))
	284	\|\| !TEST_true(WPACKET_finish(&pkt))
	285	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	286	\|\| !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
	287	return cleanup(&pkt);
d6c4cc29 MC	288
d6c4cc29 MC	289	/* And repeat with a non empty sub-packet */
adcd8e37 RS	290	if (!TEST_true(WPACKET_init(&pkt, buf))
	291	\|\| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
	292	\|\| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
	293	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
	294	\|\| !TEST_true(WPACKET_close(&pkt))
	295	\|\| !TEST_true(WPACKET_finish(&pkt))
	296	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	297	\|\| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
	298	return cleanup(&pkt);
d6c4cc29 MC	299	return 1;
	300	}
	301
	302	static int test_WPACKET_allocate_bytes(void)
	303	{
	304	WPACKET pkt;
	305	size_t written;
	306	unsigned char *bytes;
	307
adcd8e37 RS	308	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	309	\|\| !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
	310	return cleanup(&pkt);
d6c4cc29 MC	311	bytes[0] = 0xfe;
d6c4cc29 MC	312	bytes[1] = 0xff;
adcd8e37 RS	313	if (!TEST_true(WPACKET_finish(&pkt))
	314	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	315	\|\| !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
	316	return cleanup(&pkt);
d6c4cc29	317
b2b3024e	318	/* Repeat with WPACKET_sub_allocate_bytes */
adcd8e37 RS	319	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	320	\|\| !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
	321	return cleanup(&pkt);
b2b3024e MC	322	bytes[0] = 0xfe;
b2b3024e MC	323	bytes[1] = 0xff;
adcd8e37 RS	324	if (!TEST_true(WPACKET_finish(&pkt))
	325	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	326	\|\| !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
	327	return cleanup(&pkt);
b2b3024e	328
d6c4cc29 MC	329	return 1;
	330	}
	331
	332	static int test_WPACKET_memcpy(void)
	333	{
	334	WPACKET pkt;
	335	size_t written;
	336	const unsigned char bytes[] = { 0xfe, 0xff };
	337
adcd8e37 RS	338	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	339	\|\| !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
	340	\|\| !TEST_true(WPACKET_finish(&pkt))
	341	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	342	\|\| !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
	343	return cleanup(&pkt);
d6c4cc29 MC	344
d6c4cc29 MC	345	/* Repeat with WPACKET_sub_memcpy() */
adcd8e37 RS	346	if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
	347	\|\| !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
	348	\|\| !TEST_true(WPACKET_finish(&pkt))
	349	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written))
	350	\|\| !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
	351	return cleanup(&pkt);
d6c4cc29 MC	352
	353	return 1;
	354	}
	355
a056ee28 MC	356	static int test_WPACKET_init_der(void)
	357	{
	358	WPACKET pkt;
	359	unsigned char sbuf[1024];
	360	unsigned char testdata[] = { 0x00, 0x01, 0x02, 0x03 };
	361	unsigned char testdata2[259] = { 0x82, 0x01, 0x00 };
	362	size_t written[2];
	363	int i;
	364
	365	/* Test initialising for writing DER */
	366	if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf)))
	367	\|\| !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xfffefd))
	368	/* Test writing data in a length prefixed sub-packet */
	369	\|\| !TEST_true(WPACKET_start_sub_packet(&pkt))
	370	\|\| !TEST_true(WPACKET_memcpy(&pkt, testdata, sizeof(testdata)))
	371	\|\| !TEST_true(WPACKET_close(&pkt))
	372	\|\| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xfc))
	373	\|\| !TEST_true(WPACKET_finish(&pkt))
	374	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written[0]))
	375	\|\| !TEST_mem_eq(WPACKET_get_curr(&pkt), written[0], simpleder,
	376	sizeof(simpleder)))
	377	return cleanup(&pkt);
	378
	379	/* Generate random packet data for test */
	380	if (!TEST_true(RAND_bytes(&testdata2[3], sizeof(testdata2) - 3)))
	381	return 0;
	382
	383	/*
	384	* Test with a sub-packet that has 2 length bytes. We do 2 passes - first
	385	* with a NULL buffer, just to calculate lengths, and a second pass with a
	386	* real buffer to actually generate a packet
	387	*/
	388	for (i = 0; i < 2; i++) {
	389	if (i == 0) {
	390	if (!TEST_true(WPACKET_init_null_der(&pkt)))
	391	return 0;
	392	} else {
	393	if (!TEST_true(WPACKET_init_der(&pkt, sbuf, sizeof(sbuf))))
	394	return 0;
	395	}
	396	if (!TEST_true(WPACKET_start_sub_packet(&pkt))
	397	\|\| !TEST_true(WPACKET_memcpy(&pkt, &testdata2[3],
	398	sizeof(testdata2) - 3))
	399	\|\| !TEST_true(WPACKET_close(&pkt))
	400	\|\| !TEST_true(WPACKET_finish(&pkt))
	401	\|\| !TEST_true(WPACKET_get_total_written(&pkt, &written[i])))
	402	return cleanup(&pkt);
	403	}
	404
	405	/*
	406	* Check that the size calculated in the first pass equals the size of the
	407	* packet actually generated in the second pass. Also check the generated
	408	* packet looks as we expect it to.
	409	*/
	410	if (!TEST_size_t_eq(written[0], written[1])
	411	\|\| !TEST_mem_eq(WPACKET_get_curr(&pkt), written[1], testdata2,
	412	sizeof(testdata2)))
	413	return 0;
	414
	415	return 1;
	416	}
	417
ad887416	418	int setup_tests(void)
d6c4cc29	419	{
adcd8e37 RS	420	if (!TEST_ptr(buf = BUF_MEM_new()))
adcd8e37 RS	421	return 0;
d6c4cc29	422
adcd8e37 RS	423	ADD_TEST(test_WPACKET_init);
	424	ADD_TEST(test_WPACKET_set_max_size);
	425	ADD_TEST(test_WPACKET_start_sub_packet);
	426	ADD_TEST(test_WPACKET_set_flags);
	427	ADD_TEST(test_WPACKET_allocate_bytes);
	428	ADD_TEST(test_WPACKET_memcpy);
a056ee28	429	ADD_TEST(test_WPACKET_init_der);
ad887416 P	430	return 1;
ad887416 P	431	}
d6c4cc29	432
ad887416 P	433	void cleanup_tests(void)
ad887416 P	434	{
adcd8e37	435	BUF_MEM_free(buf);
d6c4cc29	436	}