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

/*
 * Copyright 2016-2017 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 <stdio.h>
#include <string.h>
#include <openssl/evp.h>
#include <openssl/bio.h>
#include <openssl/rand.h>

#include "testutil.h"

#define ENCRYPT  1
#define DECRYPT  0

#define DATA_SIZE    1024
#define MAX_IV       32
#define BUF_SIZE     (DATA_SIZE + MAX_IV)

static const unsigned char KEY[] = {
    0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a,
    0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c,
    0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1,
    0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b
};

static const unsigned char IV[] = {
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
};

static int do_bio_cipher(const EVP_CIPHER* cipher, const unsigned char* key,
    const unsigned char* iv)
{
    BIO *b;
    static unsigned char inp[BUF_SIZE] = { 0 };
    unsigned char out[BUF_SIZE], ref[BUF_SIZE];
    int i, lref, len;

    /* Fill buffer with non-zero data so that over steps can be detected */
    if (!TEST_int_gt(RAND_bytes(inp, DATA_SIZE), 0))
        return 0;

    /* Encrypt tests */

    /* reference output for single-chunk operation */
    b = BIO_new(BIO_f_cipher());
    if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT)))
        return 0;
    BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
    lref = BIO_read(b, ref, sizeof(ref));
    BIO_free_all(b);

    /* perform split operations and compare to reference */
    for (i = 1; i < lref; i++) {
        b = BIO_new(BIO_f_cipher());
        if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
            TEST_info("Split encrypt failed @ operation %d", i);
            return 0;
        }
        BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
        memset(out, 0, sizeof(out));
        out[i] = ~ref[i];
        len = BIO_read(b, out, i);
        /* check for overstep */
        if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
            TEST_info("Encrypt overstep check failed @ operation %d", i);
            return 0;
        }
        len += BIO_read(b, out + len, sizeof(out) - len);
        BIO_free_all(b);

        if (!TEST_mem_eq(out, len, ref, lref)) {
            TEST_info("Encrypt compare failed @ operation %d", i);
            return 0;
        }
    }

    /* perform small-chunk operations and compare to reference */
    for (i = 1; i < lref / 2; i++) {
        int delta;

        b = BIO_new(BIO_f_cipher());
        if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
            TEST_info("Small chunk encrypt failed @ operation %d", i);
            return 0;
        }
        BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
        memset(out, 0, sizeof(out));
        for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
            len += delta;
        }
        BIO_free_all(b);

        if (!TEST_mem_eq(out, len, ref, lref)) {
            TEST_info("Small chunk encrypt compare failed @ operation %d", i);
            return 0;
        }
    }

    /* Decrypt tests */

    /* reference output for single-chunk operation */
    b = BIO_new(BIO_f_cipher());
    if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT)))
        return 0;
    /* Use original reference output as input */
    BIO_push(b, BIO_new_mem_buf(ref, lref));
    (void)BIO_flush(b);
    memset(out, 0, sizeof(out));
    len = BIO_read(b, out, sizeof(out));
    BIO_free_all(b);

    if (!TEST_mem_eq(inp, DATA_SIZE, out, len))
        return 0;

    /* perform split operations and compare to reference */
    for (i = 1; i < lref; i++) {
        b = BIO_new(BIO_f_cipher());
        if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
            TEST_info("Split decrypt failed @ operation %d", i);
            return 0;
        }
        BIO_push(b, BIO_new_mem_buf(ref, lref));
        memset(out, 0, sizeof(out));
        out[i] = ~ref[i];
        len = BIO_read(b, out, i);
        /* check for overstep */
        if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
            TEST_info("Decrypt overstep check failed @ operation %d", i);
            return 0;
        }
        len += BIO_read(b, out + len, sizeof(out) - len);
        BIO_free_all(b);

        if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
            TEST_info("Decrypt compare failed @ operation %d", i);
            return 0;
        }
    }

    /* perform small-chunk operations and compare to reference */
    for (i = 1; i < lref / 2; i++) {
        int delta;

        b = BIO_new(BIO_f_cipher());
        if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
            TEST_info("Small chunk decrypt failed @ operation %d", i);
            return 0;
        }
        BIO_push(b, BIO_new_mem_buf(ref, lref));
        memset(out, 0, sizeof(out));
        for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
            len += delta;
        }
        BIO_free_all(b);

        if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
            TEST_info("Small chunk decrypt compare failed @ operation %d", i);
            return 0;
        }
    }

    return 1;
}

static int do_test_bio_cipher(const EVP_CIPHER* cipher, int idx)
{
    switch(idx)
    {
        case 0:
            return do_bio_cipher(cipher, KEY, NULL);
        case 1:
            return do_bio_cipher(cipher, KEY, IV);
    }
    return 0;
}

static int test_bio_enc_aes_128_cbc(int idx)
{
    return do_test_bio_cipher(EVP_aes_128_cbc(), idx);
}

static int test_bio_enc_aes_128_ctr(int idx)
{
    return do_test_bio_cipher(EVP_aes_128_ctr(), idx);
}

static int test_bio_enc_aes_256_cfb(int idx)
{
    return do_test_bio_cipher(EVP_aes_256_cfb(), idx);
}

static int test_bio_enc_aes_256_ofb(int idx)
{
    return do_test_bio_cipher(EVP_aes_256_ofb(), idx);
}

# ifndef OPENSSL_NO_CHACHA
static int test_bio_enc_chacha20(int idx)
{
    return do_test_bio_cipher(EVP_chacha20(), idx);
}

#  ifndef OPENSSL_NO_POLY1305
static int test_bio_enc_chacha20_poly1305(int idx)
{
    return do_test_bio_cipher(EVP_chacha20_poly1305(), idx);
}
#  endif
# endif

int setup_tests(void)
{
    ADD_ALL_TESTS(test_bio_enc_aes_128_cbc, 2);
    ADD_ALL_TESTS(test_bio_enc_aes_128_ctr, 2);
    ADD_ALL_TESTS(test_bio_enc_aes_256_cfb, 2);
    ADD_ALL_TESTS(test_bio_enc_aes_256_ofb, 2);
# ifndef OPENSSL_NO_CHACHA
    ADD_ALL_TESTS(test_bio_enc_chacha20, 2);
#  ifndef OPENSSL_NO_POLY1305
    ADD_ALL_TESTS(test_bio_enc_chacha20_poly1305, 2);
#  endif
# endif
    return 1;
}
Commit	Line	Data
e6ed2b91	1	/*
ad887416	2	* Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
e6ed2b91	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
e6ed2b91 AP	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	#include <stdio.h>
	10	#include <string.h>
	11	#include <openssl/evp.h>
	12	#include <openssl/bio.h>
61884b81	13	#include <openssl/rand.h>
e6ed2b91	14
dd94c37a JS	15	#include "testutil.h"
	16
	17	#define ENCRYPT 1
	18	#define DECRYPT 0
	19
	20	#define DATA_SIZE 1024
	21	#define MAX_IV 32
	22	#define BUF_SIZE (DATA_SIZE + MAX_IV)
	23
	24	static const unsigned char KEY[] = {
	25	0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a,
	26	0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c,
	27	0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1,
	28	0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b
	29	};
	30
	31	static const unsigned char IV[] = {
	32	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
	33	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
	34	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
	35	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
	36	};
	37
	38	static int do_bio_cipher(const EVP_CIPHER* cipher, const unsigned char* key,
	39	const unsigned char* iv)
e6ed2b91 AP	40	{
e6ed2b91 AP	41	BIO *b;
dd94c37a JS	42	static unsigned char inp[BUF_SIZE] = { 0 };
dd94c37a JS	43	unsigned char out[BUF_SIZE], ref[BUF_SIZE];
e6ed2b91 AP	44	int i, lref, len;
e6ed2b91 AP	45
61884b81	46	/* Fill buffer with non-zero data so that over steps can be detected */
dd94c37a JS	47	if (!TEST_int_gt(RAND_bytes(inp, DATA_SIZE), 0))
dd94c37a JS	48	return 0;
e6ed2b91	49
dd94c37a	50	/* Encrypt tests */
e6ed2b91 AP	51
	52	/* reference output for single-chunk operation */
	53	b = BIO_new(BIO_f_cipher());
dd94c37a JS	54	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT)))
	55	return 0;
	56	BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
e6ed2b91 AP	57	lref = BIO_read(b, ref, sizeof(ref));
	58	BIO_free_all(b);
	59
	60	/* perform split operations and compare to reference */
	61	for (i = 1; i < lref; i++) {
	62	b = BIO_new(BIO_f_cipher());
dd94c37a JS	63	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
	64	TEST_info("Split encrypt failed @ operation %d", i);
	65	return 0;
	66	}
	67	BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
e6ed2b91 AP	68	memset(out, 0, sizeof(out));
	69	out[i] = ~ref[i];
	70	len = BIO_read(b, out, i);
	71	/* check for overstep */
dd94c37a JS	72	if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
	73	TEST_info("Encrypt overstep check failed @ operation %d", i);
	74	return 0;
e6ed2b91 AP	75	}
	76	len += BIO_read(b, out + len, sizeof(out) - len);
	77	BIO_free_all(b);
	78
dd94c37a JS	79	if (!TEST_mem_eq(out, len, ref, lref)) {
	80	TEST_info("Encrypt compare failed @ operation %d", i);
	81	return 0;
e6ed2b91 AP	82	}
	83	}
	84
	85	/* perform small-chunk operations and compare to reference */
	86	for (i = 1; i < lref / 2; i++) {
	87	int delta;
	88
	89	b = BIO_new(BIO_f_cipher());
dd94c37a JS	90	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, ENCRYPT))) {
	91	TEST_info("Small chunk encrypt failed @ operation %d", i);
	92	return 0;
	93	}
	94	BIO_push(b, BIO_new_mem_buf(inp, DATA_SIZE));
e6ed2b91 AP	95	memset(out, 0, sizeof(out));
	96	for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
	97	len += delta;
	98	}
	99	BIO_free_all(b);
	100
dd94c37a JS	101	if (!TEST_mem_eq(out, len, ref, lref)) {
	102	TEST_info("Small chunk encrypt compare failed @ operation %d", i);
	103	return 0;
e6ed2b91 AP	104	}
	105	}
	106
dd94c37a	107	/* Decrypt tests */
e6ed2b91 AP	108
	109	/* reference output for single-chunk operation */
	110	b = BIO_new(BIO_f_cipher());
dd94c37a JS	111	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT)))
	112	return 0;
	113	/* Use original reference output as input */
	114	BIO_push(b, BIO_new_mem_buf(ref, lref));
	115	(void)BIO_flush(b);
	116	memset(out, 0, sizeof(out));
	117	len = BIO_read(b, out, sizeof(out));
e6ed2b91 AP	118	BIO_free_all(b);
e6ed2b91 AP	119
dd94c37a JS	120	if (!TEST_mem_eq(inp, DATA_SIZE, out, len))
	121	return 0;
	122
e6ed2b91 AP	123	/* perform split operations and compare to reference */
	124	for (i = 1; i < lref; i++) {
	125	b = BIO_new(BIO_f_cipher());
dd94c37a JS	126	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
	127	TEST_info("Split decrypt failed @ operation %d", i);
	128	return 0;
	129	}
	130	BIO_push(b, BIO_new_mem_buf(ref, lref));
e6ed2b91 AP	131	memset(out, 0, sizeof(out));
	132	out[i] = ~ref[i];
	133	len = BIO_read(b, out, i);
	134	/* check for overstep */
dd94c37a JS	135	if (!TEST_uchar_eq(out[i], (unsigned char)~ref[i])) {
	136	TEST_info("Decrypt overstep check failed @ operation %d", i);
	137	return 0;
e6ed2b91 AP	138	}
	139	len += BIO_read(b, out + len, sizeof(out) - len);
	140	BIO_free_all(b);
	141
dd94c37a JS	142	if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
	143	TEST_info("Decrypt compare failed @ operation %d", i);
	144	return 0;
e6ed2b91 AP	145	}
	146	}
	147
	148	/* perform small-chunk operations and compare to reference */
	149	for (i = 1; i < lref / 2; i++) {
	150	int delta;
	151
	152	b = BIO_new(BIO_f_cipher());
dd94c37a JS	153	if (!TEST_true(BIO_set_cipher(b, cipher, key, iv, DECRYPT))) {
	154	TEST_info("Small chunk decrypt failed @ operation %d", i);
	155	return 0;
	156	}
	157	BIO_push(b, BIO_new_mem_buf(ref, lref));
e6ed2b91 AP	158	memset(out, 0, sizeof(out));
	159	for (len = 0; (delta = BIO_read(b, out + len, i)); ) {
	160	len += delta;
	161	}
	162	BIO_free_all(b);
	163
dd94c37a JS	164	if (!TEST_mem_eq(inp, DATA_SIZE, out, len)) {
	165	TEST_info("Small chunk decrypt compare failed @ operation %d", i);
	166	return 0;
e6ed2b91 AP	167	}
	168	}
	169
dd94c37a JS	170	return 1;
	171	}
	172
	173	static int do_test_bio_cipher(const EVP_CIPHER* cipher, int idx)
	174	{
	175	switch(idx)
	176	{
	177	case 0:
	178	return do_bio_cipher(cipher, KEY, NULL);
	179	case 1:
	180	return do_bio_cipher(cipher, KEY, IV);
	181	}
e6ed2b91 AP	182	return 0;
e6ed2b91 AP	183	}
dd94c37a JS	184
	185	static int test_bio_enc_aes_128_cbc(int idx)
	186	{
	187	return do_test_bio_cipher(EVP_aes_128_cbc(), idx);
	188	}
	189
	190	static int test_bio_enc_aes_128_ctr(int idx)
	191	{
	192	return do_test_bio_cipher(EVP_aes_128_ctr(), idx);
	193	}
	194
	195	static int test_bio_enc_aes_256_cfb(int idx)
	196	{
	197	return do_test_bio_cipher(EVP_aes_256_cfb(), idx);
	198	}
	199
	200	static int test_bio_enc_aes_256_ofb(int idx)
	201	{
	202	return do_test_bio_cipher(EVP_aes_256_ofb(), idx);
	203	}
	204
0139ce7c	205	# ifndef OPENSSL_NO_CHACHA
dd94c37a JS	206	static int test_bio_enc_chacha20(int idx)
	207	{
	208	return do_test_bio_cipher(EVP_chacha20(), idx);
	209	}
	210
0139ce7c	211	# ifndef OPENSSL_NO_POLY1305
dd94c37a JS	212	static int test_bio_enc_chacha20_poly1305(int idx)
	213	{
	214	return do_test_bio_cipher(EVP_chacha20_poly1305(), idx);
	215	}
0139ce7c MC	216	# endif
0139ce7c MC	217	# endif
dd94c37a	218
ad887416	219	int setup_tests(void)
dd94c37a JS	220	{
	221	ADD_ALL_TESTS(test_bio_enc_aes_128_cbc, 2);
	222	ADD_ALL_TESTS(test_bio_enc_aes_128_ctr, 2);
	223	ADD_ALL_TESTS(test_bio_enc_aes_256_cfb, 2);
	224	ADD_ALL_TESTS(test_bio_enc_aes_256_ofb, 2);
	225	# ifndef OPENSSL_NO_CHACHA
	226	ADD_ALL_TESTS(test_bio_enc_chacha20, 2);
	227	# ifndef OPENSSL_NO_POLY1305
	228	ADD_ALL_TESTS(test_bio_enc_chacha20_poly1305, 2);
	229	# endif
	230	# endif
ad887416	231	return 1;
dd94c37a	232	}