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

/*
 * Copyright 2007-2019 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright Nokia 2007-2019
 * Copyright Siemens AG 2015-2019
 *
 * 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 "cmp_testlib.h"

static unsigned char rand_data[OSSL_CMP_TRANSACTIONID_LENGTH];

typedef struct test_fixture {
    const char *test_case_name;
    int expected;
    OSSL_CMP_CTX *cmp_ctx;
    OSSL_CMP_PKIHEADER *hdr;

} CMP_HDR_TEST_FIXTURE;

static void tear_down(CMP_HDR_TEST_FIXTURE *fixture)
{
    OSSL_CMP_PKIHEADER_free(fixture->hdr);
    OSSL_CMP_CTX_free(fixture->cmp_ctx);
    OPENSSL_free(fixture);
}

static CMP_HDR_TEST_FIXTURE *set_up(const char *const test_case_name)
{
    CMP_HDR_TEST_FIXTURE *fixture;

    if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))))
        return NULL;
    fixture->test_case_name = test_case_name;
    if (!TEST_ptr(fixture->cmp_ctx = OSSL_CMP_CTX_new()))
        goto err;
    if (!TEST_ptr(fixture->hdr = OSSL_CMP_PKIHEADER_new()))
        goto err;
    return fixture;

 err:
    tear_down(fixture);
    return NULL;
}

static int execute_HDR_set_get_pvno_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    int pvno = 77;

    if (!TEST_int_eq(ossl_cmp_hdr_set_pvno(fixture->hdr, pvno), 1))
        return 0;
    if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), pvno))
        return 0;
    return 1;
}

static int test_HDR_set_get_pvno(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_set_get_pvno_test, tear_down);
    return result;
}

#define X509_NAME_ADD(n, rd, s) \
    X509_NAME_add_entry_by_txt((n), (rd), MBSTRING_ASC, (unsigned char *)(s), \
                               -1, -1, 0)

static int execute_HDR_get0_senderNonce_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    X509_NAME *sender = X509_NAME_new();
    ASN1_OCTET_STRING *sn;

    if (!TEST_ptr(sender))
        return 0;

    X509_NAME_ADD(sender, "CN", "A common sender name");
    if (!TEST_int_eq(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, sender),
                     1))
        return 0;
    if (!TEST_int_eq(ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr),
                     1))
        return 0;
    sn = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
    if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->cmp_ctx->senderNonce, sn),
                     0))
        return 0;
    X509_NAME_free(sender);
    return 1;
}

static int test_HDR_get0_senderNonce(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_get0_senderNonce_test, tear_down);
    return result;
}

static int execute_HDR_set1_sender_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    X509_NAME *x509name = X509_NAME_new();

    if (!TEST_ptr(x509name))
        return 0;

    X509_NAME_ADD(x509name, "CN", "A common sender name");
    if (!TEST_int_eq(ossl_cmp_hdr_set1_sender(fixture->hdr, x509name), 1))
        return 0;
    if (!TEST_int_eq(fixture->hdr->sender->type, GEN_DIRNAME))
        return 0;

    if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->sender->d.directoryName,
                                   x509name), 0))
        return 0;

    X509_NAME_free(x509name);
    return 1;
}

static int test_HDR_set1_sender(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_set1_sender_test, tear_down);
    return result;
}

static int execute_HDR_set1_recipient_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    X509_NAME *x509name = X509_NAME_new();

    if (!TEST_ptr(x509name))
        return 0;

    X509_NAME_ADD(x509name, "CN", "A common recipient name");
    if (!TEST_int_eq(ossl_cmp_hdr_set1_recipient(fixture->hdr, x509name), 1))
        return 0;

    if (!TEST_int_eq(fixture->hdr->recipient->type, GEN_DIRNAME))
        return 0;

    if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->recipient->d.directoryName,
                                   x509name), 0))
        return 0;

    X509_NAME_free(x509name);
    return 1;
}

static int test_HDR_set1_recipient(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_set1_recipient_test, tear_down);
    return result;
}

static int execute_HDR_update_messageTime_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    struct tm hdrtm;
    time_t hdrtime, before, after, now;

    now = time(NULL);
    before = mktime(gmtime(&now));
    if (!TEST_true(ossl_cmp_hdr_update_messageTime(fixture->hdr)))
        return 0;
    if (!TEST_true(ASN1_TIME_to_tm(fixture->hdr->messageTime, &hdrtm)))
        return 0;

    hdrtime = mktime(&hdrtm);
    if (!TEST_true(before <= hdrtime))
        return 0;
    now = time(NULL);
    after = mktime(gmtime(&now));
    return TEST_true(hdrtime <= after);
}

static int test_HDR_update_messageTime(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_update_messageTime_test, tear_down);
    return result;
}

static int execute_HDR_set1_senderKID_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    ASN1_OCTET_STRING *senderKID = ASN1_OCTET_STRING_new();

    if (!TEST_ptr(senderKID))
        return 0;

    if (!TEST_int_eq(ASN1_OCTET_STRING_set(senderKID, rand_data,
                                           sizeof(rand_data)), 1))
        return 0;
    if (!TEST_int_eq(ossl_cmp_hdr_set1_senderKID(fixture->hdr, senderKID), 1))
        return 0;
    if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->hdr->senderKID,
                                           senderKID), 0))
        return 0;

    ASN1_OCTET_STRING_free(senderKID);
    return 1;
}

static int test_HDR_set1_senderKID(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_set1_senderKID_test, tear_down);
    return result;
}

static int execute_HDR_push0_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();

    if (!TEST_ptr(text))
        return 0;

    if (!ASN1_STRING_set(text, "A free text", -1))
        return 0;

    if (!TEST_int_eq(ossl_cmp_hdr_push0_freeText(fixture->hdr, text), 1))
        return 0;

    if (!TEST_true(text == sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0)))
        return 0;

    return 1;
}

static int test_HDR_push0_freeText(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_push0_freeText_test, tear_down);
    return result;
}

static int execute_HDR_push1_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();
    ASN1_UTF8STRING *pushed_text;

    if (!TEST_ptr(text))
        return 0;

    if (!ASN1_STRING_set(text, "A free text", -1))
        return 0;

    if (!TEST_int_eq(ossl_cmp_hdr_push1_freeText(fixture->hdr, text), 1))
        return 0;

    pushed_text = sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0);
    if (!TEST_int_eq(ASN1_STRING_cmp(text, pushed_text), 0))
        return 0;

    ASN1_UTF8STRING_free(text);
    return 1;
}

static int test_HDR_push1_freeText(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_push1_freeText_test, tear_down);
    return result;
}

static int
execute_HDR_generalInfo_push0_item_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    OSSL_CMP_ITAV *itav = OSSL_CMP_ITAV_new();

    if (!TEST_ptr(itav))
        return 0;

    if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push0_item(fixture->hdr, itav),
                     1))
        return 0;

    if (!TEST_true(itav == sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo,
                                                  0)))
        return 0;

    return 1;
}

static int test_HDR_generalInfo_push0_item(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_generalInfo_push0_item_test, tear_down);
    return result;
}

static int
execute_HDR_generalInfo_push1_items_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    const char oid[] = "1.2.3.4";
    char buf[20];
    OSSL_CMP_ITAV *itav, *pushed_itav;
    STACK_OF(OSSL_CMP_ITAV) *itavs = NULL, *ginfo;
    ASN1_INTEGER *asn1int = ASN1_INTEGER_new();
    ASN1_TYPE *val = ASN1_TYPE_new();
    ASN1_TYPE *pushed_val;

    if (!TEST_ptr(asn1int))
        return 0;

    if (!TEST_ptr(val))
        return 0;

    ASN1_INTEGER_set(asn1int, 88);
    ASN1_TYPE_set(val, V_ASN1_INTEGER, asn1int);
    itav = OSSL_CMP_ITAV_create(OBJ_txt2obj(oid, 1), val);
    OSSL_CMP_ITAV_push0_stack_item(&itavs, itav);

    if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push1_items(fixture->hdr, itavs),
                     1))
        return 0;
    ginfo = fixture->hdr->generalInfo;
    pushed_itav = sk_OSSL_CMP_ITAV_value(ginfo, 0);
    OBJ_obj2txt(buf, sizeof(buf), OSSL_CMP_ITAV_get0_type(pushed_itav), 0);
    if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0))
        return 0;

    pushed_val = OSSL_CMP_ITAV_get0_value(sk_OSSL_CMP_ITAV_value(ginfo, 0));
    if (!TEST_int_eq(ASN1_TYPE_cmp(itav->infoValue.other, pushed_val), 0))
        return 0;

    sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free);
    return 1;
}

static int test_HDR_generalInfo_push1_items(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 1;
    EXECUTE_TEST(execute_HDR_generalInfo_push1_items_test, tear_down);
    return result;
}

static int
execute_HDR_set_and_check_implicitConfirm_test(CMP_HDR_TEST_FIXTURE
                                               * fixture)
{
    return TEST_false(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr))
        && TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr))
        && TEST_true(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr));
}

static int test_HDR_set_and_check_implicit_confirm(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    EXECUTE_TEST(execute_HDR_set_and_check_implicitConfirm_test, tear_down);
    return result;
}


static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture)
{
    ASN1_OCTET_STRING *header_nonce, *header_transactionID;
    ASN1_OCTET_STRING *ctx_nonce;

    if (!TEST_int_eq(fixture->expected,
                     ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr)))
        return 0;
    if (fixture->expected == 0)
        return 1;

    if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO))
        return 0;

    header_nonce = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
    if (!TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
                                              fixture->cmp_ctx->senderNonce)))
        return 0;
    header_transactionID = OSSL_CMP_HDR_get0_transactionID(fixture->hdr);
    if (!TEST_true(0 == ASN1_OCTET_STRING_cmp(header_transactionID,
                                              fixture->cmp_ctx->transactionID)))
        return 0;

    header_nonce = OSSL_CMP_HDR_get0_recipNonce(fixture->hdr);
    ctx_nonce = fixture->cmp_ctx->recipNonce;
    if (ctx_nonce != NULL
            && (!TEST_ptr(header_nonce)
                    || !TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
                                                             ctx_nonce))))
        return 0;

    return 1;
}

static int test_HDR_init(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    unsigned char ref[CMP_TEST_REFVALUE_LENGTH];

    fixture->expected = 1;
    if (!TEST_int_eq(1, RAND_bytes(ref, sizeof(ref)))
            || !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx,
                                                           ref, sizeof(ref)))) {
        tear_down(fixture);
        fixture = NULL;
    }
    EXECUTE_TEST(execute_HDR_init_test, tear_down);
    return result;
}

static int test_HDR_init_with_subject(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    X509_NAME *subject = NULL;

    fixture->expected = 1;
    if (!TEST_ptr(subject = X509_NAME_new())
            || !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name"))
            || !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx,
                                                        subject))) {
        tear_down(fixture);
        fixture = NULL;
    }
    X509_NAME_free(subject);
    EXECUTE_TEST(execute_HDR_init_test, tear_down);
    return result;
}

static int test_HDR_init_no_ref_no_subject(void)
{
    SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
    fixture->expected = 0;
    EXECUTE_TEST(execute_HDR_init_test, tear_down);
    return result;
}


void cleanup_tests(void)
{
    return;
}

int setup_tests(void)
{
    RAND_bytes(rand_data, OSSL_CMP_TRANSACTIONID_LENGTH);
    /* Message header tests */
    ADD_TEST(test_HDR_set_get_pvno);
    ADD_TEST(test_HDR_get0_senderNonce);
    ADD_TEST(test_HDR_set1_sender);
    ADD_TEST(test_HDR_set1_recipient);
    ADD_TEST(test_HDR_update_messageTime);
    ADD_TEST(test_HDR_set1_senderKID);
    ADD_TEST(test_HDR_push0_freeText);
    /* indirectly tests ossl_cmp_pkifreetext_push_str(): */
    ADD_TEST(test_HDR_push1_freeText);
    ADD_TEST(test_HDR_generalInfo_push0_item);
    ADD_TEST(test_HDR_generalInfo_push1_items);
    ADD_TEST(test_HDR_set_and_check_implicit_confirm);
    /* also tests public function OSSL_CMP_HDR_get0_transactionID(): */
    /* also tests public function OSSL_CMP_HDR_get0_recipNonce(): */
    /* also tests internal function ossl_cmp_hdr_get_pvno(): */
    ADD_TEST(test_HDR_init);
    ADD_TEST(test_HDR_init_with_subject);
    ADD_TEST(test_HDR_init_no_ref_no_subject);
    /*
     *  TODO make sure that total number of tests (here currently 24) is shown,
     *  also for other cmp_*text.c. Currently the test drivers always show 1.
     */

    return 1;
}
Commit	Line	Data
4dde554c DDO	1	/*
	2	* Copyright 2007-2019 The OpenSSL Project Authors. All Rights Reserved.
	3	* Copyright Nokia 2007-2019
	4	* Copyright Siemens AG 2015-2019
	5	*
	6	* Licensed under the Apache License 2.0 (the "License"). You may not use
	7	* this file except in compliance with the License. You can obtain a copy
	8	* in the file LICENSE in the source distribution or at
	9	* https://www.openssl.org/source/license.html
	10	*/
	11
	12	#include "cmp_testlib.h"
	13
	14	static unsigned char rand_data[OSSL_CMP_TRANSACTIONID_LENGTH];
	15
	16	typedef struct test_fixture {
	17	const char *test_case_name;
	18	int expected;
	19	OSSL_CMP_CTX *cmp_ctx;
	20	OSSL_CMP_PKIHEADER *hdr;
	21
	22	} CMP_HDR_TEST_FIXTURE;
	23
	24	static void tear_down(CMP_HDR_TEST_FIXTURE *fixture)
	25	{
	26	OSSL_CMP_PKIHEADER_free(fixture->hdr);
	27	OSSL_CMP_CTX_free(fixture->cmp_ctx);
	28	OPENSSL_free(fixture);
	29	}
	30
	31	static CMP_HDR_TEST_FIXTURE set_up(const char const test_case_name)
	32	{
	33	CMP_HDR_TEST_FIXTURE *fixture;
	34
	35	if (!TEST_ptr(fixture = OPENSSL_zalloc(sizeof(*fixture))))
	36	return NULL;
	37	fixture->test_case_name = test_case_name;
	38	if (!TEST_ptr(fixture->cmp_ctx = OSSL_CMP_CTX_new()))
	39	goto err;
	40	if (!TEST_ptr(fixture->hdr = OSSL_CMP_PKIHEADER_new()))
	41	goto err;
	42	return fixture;
	43
	44	err:
	45	tear_down(fixture);
	46	return NULL;
	47	}
	48
	49	static int execute_HDR_set_get_pvno_test(CMP_HDR_TEST_FIXTURE *fixture)
	50	{
	51	int pvno = 77;
	52
	53	if (!TEST_int_eq(ossl_cmp_hdr_set_pvno(fixture->hdr, pvno), 1))
	54	return 0;
	55	if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), pvno))
	56	return 0;
	57	return 1;
	58	}
	59
	60	static int test_HDR_set_get_pvno(void)
	61	{
	62	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	63	fixture->expected = 1;
	64	EXECUTE_TEST(execute_HDR_set_get_pvno_test, tear_down);
65	return result;
66	}
67
235595c4 DDO	68	#define X509_NAME_ADD(n, rd, s) \
	69	X509_NAME_add_entry_by_txt((n), (rd), MBSTRING_ASC, (unsigned char *)(s), \
	70	-1, -1, 0)
4dde554c DDO	71
	72	static int execute_HDR_get0_senderNonce_test(CMP_HDR_TEST_FIXTURE *fixture)
	73	{
	74	X509_NAME *sender = X509_NAME_new();
	75	ASN1_OCTET_STRING *sn;
	76
	77	if (!TEST_ptr(sender))
	78	return 0;
	79
	80	X509_NAME_ADD(sender, "CN", "A common sender name");
	81	if (!TEST_int_eq(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, sender),
	82	1))
	83	return 0;
	84	if (!TEST_int_eq(ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr),
	85	1))
	86	return 0;
	87	sn = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
	88	if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->cmp_ctx->senderNonce, sn),
	89	0))
	90	return 0;
	91	X509_NAME_free(sender);
	92	return 1;
	93	}
	94
	95	static int test_HDR_get0_senderNonce(void)
	96	{
	97	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	98	fixture->expected = 1;
	99	EXECUTE_TEST(execute_HDR_get0_senderNonce_test, tear_down);
	100	return result;
	101	}
	102
	103	static int execute_HDR_set1_sender_test(CMP_HDR_TEST_FIXTURE *fixture)
	104	{
	105	X509_NAME *x509name = X509_NAME_new();
	106
	107	if (!TEST_ptr(x509name))
	108	return 0;
	109
	110	X509_NAME_ADD(x509name, "CN", "A common sender name");
	111	if (!TEST_int_eq(ossl_cmp_hdr_set1_sender(fixture->hdr, x509name), 1))
	112	return 0;
	113	if (!TEST_int_eq(fixture->hdr->sender->type, GEN_DIRNAME))
	114	return 0;
	115
235595c4 DDO	116	if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->sender->d.directoryName,
235595c4 DDO	117	x509name), 0))
4dde554c DDO	118	return 0;
	119
	120	X509_NAME_free(x509name);
	121	return 1;
	122	}
	123
	124	static int test_HDR_set1_sender(void)
	125	{
	126	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	127	fixture->expected = 1;
	128	EXECUTE_TEST(execute_HDR_set1_sender_test, tear_down);
	129	return result;
	130	}
	131
	132	static int execute_HDR_set1_recipient_test(CMP_HDR_TEST_FIXTURE *fixture)
	133	{
	134	X509_NAME *x509name = X509_NAME_new();
	135
	136	if (!TEST_ptr(x509name))
	137	return 0;
	138
	139	X509_NAME_ADD(x509name, "CN", "A common recipient name");
	140	if (!TEST_int_eq(ossl_cmp_hdr_set1_recipient(fixture->hdr, x509name), 1))
	141	return 0;
	142
	143	if (!TEST_int_eq(fixture->hdr->recipient->type, GEN_DIRNAME))
	144	return 0;
	145
235595c4 DDO	146	if (!TEST_int_eq(X509_NAME_cmp(fixture->hdr->recipient->d.directoryName,
235595c4 DDO	147	x509name), 0))
4dde554c DDO	148	return 0;
	149
	150	X509_NAME_free(x509name);
	151	return 1;
	152	}
	153
	154	static int test_HDR_set1_recipient(void)
	155	{
	156	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	157	fixture->expected = 1;
	158	EXECUTE_TEST(execute_HDR_set1_recipient_test, tear_down);
	159	return result;
	160	}
	161
	162	static int execute_HDR_update_messageTime_test(CMP_HDR_TEST_FIXTURE *fixture)
	163	{
	164	struct tm hdrtm;
	165	time_t hdrtime, before, after, now;
	166
	167	now = time(NULL);
	168	before = mktime(gmtime(&now));
	169	if (!TEST_true(ossl_cmp_hdr_update_messageTime(fixture->hdr)))
	170	return 0;
	171	if (!TEST_true(ASN1_TIME_to_tm(fixture->hdr->messageTime, &hdrtm)))
	172	return 0;
	173
	174	hdrtime = mktime(&hdrtm);
	175	if (!TEST_true(before <= hdrtime))
	176	return 0;
	177	now = time(NULL);
	178	after = mktime(gmtime(&now));
	179	return TEST_true(hdrtime <= after);
	180	}
	181
	182	static int test_HDR_update_messageTime(void)
	183	{
	184	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	185	fixture->expected = 1;
	186	EXECUTE_TEST(execute_HDR_update_messageTime_test, tear_down);
	187	return result;
	188	}
	189
	190	static int execute_HDR_set1_senderKID_test(CMP_HDR_TEST_FIXTURE *fixture)
	191	{
235595c4	192	ASN1_OCTET_STRING *senderKID = ASN1_OCTET_STRING_new();
4dde554c DDO	193
	194	if (!TEST_ptr(senderKID))
	195	return 0;
	196
3dbc5156 DDO	197	if (!TEST_int_eq(ASN1_OCTET_STRING_set(senderKID, rand_data,
	198	sizeof(rand_data)), 1))
	199	return 0;
4dde554c DDO	200	if (!TEST_int_eq(ossl_cmp_hdr_set1_senderKID(fixture->hdr, senderKID), 1))
4dde554c DDO	201	return 0;
235595c4 DDO	202	if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->hdr->senderKID,
235595c4 DDO	203	senderKID), 0))
4dde554c DDO	204	return 0;
	205
	206	ASN1_OCTET_STRING_free(senderKID);
	207	return 1;
	208	}
	209
	210	static int test_HDR_set1_senderKID(void)
	211	{
	212	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	213	fixture->expected = 1;
	214	EXECUTE_TEST(execute_HDR_set1_senderKID_test, tear_down);
	215	return result;
	216	}
	217
	218	static int execute_HDR_push0_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
	219	{
235595c4	220	ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();
4dde554c DDO	221
	222	if (!TEST_ptr(text))
	223	return 0;
	224
	225	if (!ASN1_STRING_set(text, "A free text", -1))
	226	return 0;
	227
235595c4	228	if (!TEST_int_eq(ossl_cmp_hdr_push0_freeText(fixture->hdr, text), 1))
4dde554c	229	return 0;
235595c4 DDO	230
235595c4 DDO	231	if (!TEST_true(text == sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0)))
4dde554c DDO	232	return 0;
	233
	234	return 1;
	235	}
	236
	237	static int test_HDR_push0_freeText(void)
	238	{
	239	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	240	fixture->expected = 1;
	241	EXECUTE_TEST(execute_HDR_push0_freeText_test, tear_down);
	242	return result;
	243	}
	244
	245	static int execute_HDR_push1_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
	246	{
235595c4 DDO	247	ASN1_UTF8STRING *text = ASN1_UTF8STRING_new();
235595c4 DDO	248	ASN1_UTF8STRING *pushed_text;
4dde554c DDO	249
	250	if (!TEST_ptr(text))
	251	return 0;
	252
	253	if (!ASN1_STRING_set(text, "A free text", -1))
	254	return 0;
	255
235595c4	256	if (!TEST_int_eq(ossl_cmp_hdr_push1_freeText(fixture->hdr, text), 1))
4dde554c	257	return 0;
235595c4 DDO	258
	259	pushed_text = sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0);
	260	if (!TEST_int_eq(ASN1_STRING_cmp(text, pushed_text), 0))
4dde554c DDO	261	return 0;
	262
	263	ASN1_UTF8STRING_free(text);
	264	return 1;
	265	}
	266
	267	static int test_HDR_push1_freeText(void)
	268	{
	269	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	270	fixture->expected = 1;
	271	EXECUTE_TEST(execute_HDR_push1_freeText_test, tear_down);
	272	return result;
	273	}
	274
	275	static int
	276	execute_HDR_generalInfo_push0_item_test(CMP_HDR_TEST_FIXTURE *fixture)
	277	{
	278	OSSL_CMP_ITAV *itav = OSSL_CMP_ITAV_new();
	279
	280	if (!TEST_ptr(itav))
	281	return 0;
	282
235595c4 DDO	283	if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push0_item(fixture->hdr, itav),
235595c4 DDO	284	1))
4dde554c	285	return 0;
235595c4 DDO	286
	287	if (!TEST_true(itav == sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo,
	288	0)))
4dde554c DDO	289	return 0;
	290
	291	return 1;
	292	}
	293
	294	static int test_HDR_generalInfo_push0_item(void)
	295	{
	296	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	297	fixture->expected = 1;
	298	EXECUTE_TEST(execute_HDR_generalInfo_push0_item_test, tear_down);
	299	return result;
	300	}
	301
	302	static int
	303	execute_HDR_generalInfo_push1_items_test(CMP_HDR_TEST_FIXTURE *fixture)
	304	{
	305	const char oid[] = "1.2.3.4";
	306	char buf[20];
235595c4 DDO	307	OSSL_CMP_ITAV itav, pushed_itav;
235595c4 DDO	308	STACK_OF(OSSL_CMP_ITAV) itavs = NULL, ginfo;
4dde554c DDO	309	ASN1_INTEGER *asn1int = ASN1_INTEGER_new();
4dde554c DDO	310	ASN1_TYPE *val = ASN1_TYPE_new();
235595c4	311	ASN1_TYPE *pushed_val;
4dde554c DDO	312
	313	if (!TEST_ptr(asn1int))
	314	return 0;
	315
	316	if (!TEST_ptr(val))
	317	return 0;
	318
	319	ASN1_INTEGER_set(asn1int, 88);
	320	ASN1_TYPE_set(val, V_ASN1_INTEGER, asn1int);
	321	itav = OSSL_CMP_ITAV_create(OBJ_txt2obj(oid, 1), val);
	322	OSSL_CMP_ITAV_push0_stack_item(&itavs, itav);
	323
235595c4 DDO	324	if (!TEST_int_eq(ossl_cmp_hdr_generalInfo_push1_items(fixture->hdr, itavs),
235595c4 DDO	325	1))
4dde554c	326	return 0;
235595c4 DDO	327	ginfo = fixture->hdr->generalInfo;
	328	pushed_itav = sk_OSSL_CMP_ITAV_value(ginfo, 0);
	329	OBJ_obj2txt(buf, sizeof(buf), OSSL_CMP_ITAV_get0_type(pushed_itav), 0);
4dde554c DDO	330	if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0))
	331	return 0;
	332
235595c4 DDO	333	pushed_val = OSSL_CMP_ITAV_get0_value(sk_OSSL_CMP_ITAV_value(ginfo, 0));
235595c4 DDO	334	if (!TEST_int_eq(ASN1_TYPE_cmp(itav->infoValue.other, pushed_val), 0))
4dde554c DDO	335	return 0;
	336
	337	sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free);
	338	return 1;
	339	}
	340
	341	static int test_HDR_generalInfo_push1_items(void)
	342	{
	343	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	344	fixture->expected = 1;
	345	EXECUTE_TEST(execute_HDR_generalInfo_push1_items_test, tear_down);
	346	return result;
	347	}
	348
	349	static int
	350	execute_HDR_set_and_check_implicitConfirm_test(CMP_HDR_TEST_FIXTURE
	351	* fixture)
	352	{
62dcd2aa	353	return TEST_false(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr))
4dde554c	354	&& TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr))
62dcd2aa	355	&& TEST_true(ossl_cmp_hdr_has_implicitConfirm(fixture->hdr));
4dde554c DDO	356	}
	357
	358	static int test_HDR_set_and_check_implicit_confirm(void)
	359	{
	360	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	361	EXECUTE_TEST(execute_HDR_set_and_check_implicitConfirm_test, tear_down);
	362	return result;
	363	}
	364
	365
	366	static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture)
	367	{
235595c4 DDO	368	ASN1_OCTET_STRING header_nonce, header_transactionID;
235595c4 DDO	369	ASN1_OCTET_STRING *ctx_nonce;
4dde554c DDO	370
	371	if (!TEST_int_eq(fixture->expected,
	372	ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr)))
235595c4 DDO	373	return 0;
	374	if (fixture->expected == 0)
	375	return 1;
4dde554c	376
235595c4 DDO	377	if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO))
235595c4 DDO	378	return 0;
4dde554c	379
235595c4 DDO	380	header_nonce = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
	381	if (!TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
	382	fixture->cmp_ctx->senderNonce)))
	383	return 0;
	384	header_transactionID = OSSL_CMP_HDR_get0_transactionID(fixture->hdr);
	385	if (!TEST_true(0 == ASN1_OCTET_STRING_cmp(header_transactionID,
	386	fixture->cmp_ctx->transactionID)))
	387	return 0;
	388
	389	header_nonce = OSSL_CMP_HDR_get0_recipNonce(fixture->hdr);
	390	ctx_nonce = fixture->cmp_ctx->recipNonce;
	391	if (ctx_nonce != NULL
	392	&& (!TEST_ptr(header_nonce)
	393	\|\| !TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
	394	ctx_nonce))))
	395	return 0;
	396
	397	return 1;
4dde554c DDO	398	}
	399
	400	static int test_HDR_init(void)
	401	{
	402	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	403	unsigned char ref[CMP_TEST_REFVALUE_LENGTH];
	404
	405	fixture->expected = 1;
	406	if (!TEST_int_eq(1, RAND_bytes(ref, sizeof(ref)))
	407	\|\| !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx,
	408	ref, sizeof(ref)))) {
	409	tear_down(fixture);
	410	fixture = NULL;
	411	}
	412	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	413	return result;
	414	}
	415
	416	static int test_HDR_init_with_subject(void)
	417	{
	418	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	419	X509_NAME *subject = NULL;
	420
	421	fixture->expected = 1;
	422	if (!TEST_ptr(subject = X509_NAME_new())
3dbc5156 DDO	423	\|\| !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name"))
	424	\|\| !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx,
	425	subject))) {
4dde554c DDO	426	tear_down(fixture);
	427	fixture = NULL;
	428	}
	429	X509_NAME_free(subject);
	430	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	431	return result;
	432	}
	433
	434	static int test_HDR_init_no_ref_no_subject(void)
	435	{
	436	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	437	fixture->expected = 0;
	438	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	439	return result;
	440	}
	441
	442
	443	void cleanup_tests(void)
	444	{
	445	return;
	446	}
	447
	448	int setup_tests(void)
	449	{
	450	RAND_bytes(rand_data, OSSL_CMP_TRANSACTIONID_LENGTH);
	451	/* Message header tests */
	452	ADD_TEST(test_HDR_set_get_pvno);
	453	ADD_TEST(test_HDR_get0_senderNonce);
	454	ADD_TEST(test_HDR_set1_sender);
	455	ADD_TEST(test_HDR_set1_recipient);
	456	ADD_TEST(test_HDR_update_messageTime);
	457	ADD_TEST(test_HDR_set1_senderKID);
	458	ADD_TEST(test_HDR_push0_freeText);
	459	/* indirectly tests ossl_cmp_pkifreetext_push_str(): */
	460	ADD_TEST(test_HDR_push1_freeText);
	461	ADD_TEST(test_HDR_generalInfo_push0_item);
	462	ADD_TEST(test_HDR_generalInfo_push1_items);
	463	ADD_TEST(test_HDR_set_and_check_implicit_confirm);
	464	/* also tests public function OSSL_CMP_HDR_get0_transactionID(): */
	465	/* also tests public function OSSL_CMP_HDR_get0_recipNonce(): */
	466	/* also tests internal function ossl_cmp_hdr_get_pvno(): */
	467	ADD_TEST(test_HDR_init);
	468	ADD_TEST(test_HDR_init_with_subject);
	469	ADD_TEST(test_HDR_init_no_ref_no_subject);
3dbc5156 DDO	470	/*
	471	* TODO make sure that total number of tests (here currently 24) is shown,
	472	* also for other cmp_*text.c. Currently the test drivers always show 1.
	473	*/
4dde554c DDO	474
	475	return 1;
	476	}