[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();

    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;
    if (!TEST_int_eq(ASN1_STRING_cmp(
            sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0), 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;
    STACK_OF(OSSL_CMP_ITAV) *itavs = NULL;
    ASN1_INTEGER *asn1int = ASN1_INTEGER_new();
    ASN1_TYPE *val = ASN1_TYPE_new();

    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;
    OBJ_obj2txt(buf, sizeof(buf), OSSL_CMP_ITAV_get0_type(
            sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo, 0)), 0);
    if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0))
        return 0;

    if (!TEST_int_eq(ASN1_TYPE_cmp(itav->infoValue.other,
                                   OSSL_CMP_ITAV_get0_value(
            sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo, 0))), 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_check_implicitConfirm(fixture->hdr))
        && TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr))
        && TEST_true(ossl_cmp_hdr_check_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 = NULL;
    ASN1_OCTET_STRING *ctx_nonce = NULL;
    int res = 0;

    if (!TEST_int_eq(fixture->expected,
                     ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr)))
        goto err;
    if (fixture->expected != 0) {
        if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO)
                || !TEST_true(0 == ASN1_OCTET_STRING_cmp(
                        ossl_cmp_hdr_get0_senderNonce(fixture->hdr),
                        fixture->cmp_ctx->senderNonce))
                || !TEST_true(0 == ASN1_OCTET_STRING_cmp(
                            OSSL_CMP_HDR_get0_transactionID(fixture->hdr),
                            fixture->cmp_ctx->transactionID)))
            goto err;
        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))))
            goto err;
    }

    res = 1;

 err:
    return res;
}

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
68	#define X509_NAME_ADD(n, rd, s) X509_NAME_add_entry_by_txt((n), (rd), \
69	MBSTRING_ASC, (unsigned char *)(s), -1, -1, 0)
70
71	static int execute_HDR_get0_senderNonce_test(CMP_HDR_TEST_FIXTURE *fixture)
72	{
73	X509_NAME *sender = X509_NAME_new();
74	ASN1_OCTET_STRING *sn;
75
76	if (!TEST_ptr(sender))
77	return 0;
78
79	X509_NAME_ADD(sender, "CN", "A common sender name");
80	if (!TEST_int_eq(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx, sender),
81	1))
82	return 0;
83	if (!TEST_int_eq(ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr),
84	1))
85	return 0;
86	sn = ossl_cmp_hdr_get0_senderNonce(fixture->hdr);
87	if (!TEST_int_eq(ASN1_OCTET_STRING_cmp(fixture->cmp_ctx->senderNonce, sn),
88	0))
89	return 0;
90	X509_NAME_free(sender);
91	return 1;
92	}
93
94	static int test_HDR_get0_senderNonce(void)
95	{
96	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
97	fixture->expected = 1;
98	EXECUTE_TEST(execute_HDR_get0_senderNonce_test, tear_down);
99	return result;
100	}
101
102	static int execute_HDR_set1_sender_test(CMP_HDR_TEST_FIXTURE *fixture)
103	{
104	X509_NAME *x509name = X509_NAME_new();
105
106	if (!TEST_ptr(x509name))
107	return 0;
108
109	X509_NAME_ADD(x509name, "CN", "A common sender name");
110	if (!TEST_int_eq(ossl_cmp_hdr_set1_sender(fixture->hdr, x509name), 1))
111	return 0;
112	if (!TEST_int_eq(fixture->hdr->sender->type, GEN_DIRNAME))
113	return 0;
114
115	if (!TEST_int_eq(
116	X509_NAME_cmp(fixture->hdr->sender->d.directoryName, x509name), 0))
117	return 0;
118
119	X509_NAME_free(x509name);
120	return 1;
121	}
122
123	static int test_HDR_set1_sender(void)
124	{
125	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
126	fixture->expected = 1;
127	EXECUTE_TEST(execute_HDR_set1_sender_test, tear_down);
128	return result;
129	}
130
131	static int execute_HDR_set1_recipient_test(CMP_HDR_TEST_FIXTURE *fixture)
132	{
133	X509_NAME *x509name = X509_NAME_new();
134
135	if (!TEST_ptr(x509name))
136	return 0;
137
138	X509_NAME_ADD(x509name, "CN", "A common recipient name");
139	if (!TEST_int_eq(ossl_cmp_hdr_set1_recipient(fixture->hdr, x509name), 1))
140	return 0;
141
142	if (!TEST_int_eq(fixture->hdr->recipient->type, GEN_DIRNAME))
143	return 0;
144
145	if (!TEST_int_eq(
146	X509_NAME_cmp(fixture->hdr->recipient->d.directoryName, x509name),0))
147	return 0;
148
149	X509_NAME_free(x509name);
150	return 1;
151	}
152
153	static int test_HDR_set1_recipient(void)
154	{
155	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
156	fixture->expected = 1;
157	EXECUTE_TEST(execute_HDR_set1_recipient_test, tear_down);
158	return result;
159	}
160
161	static int execute_HDR_update_messageTime_test(CMP_HDR_TEST_FIXTURE *fixture)
162	{
163	struct tm hdrtm;
164	time_t hdrtime, before, after, now;
165
166	now = time(NULL);
167	before = mktime(gmtime(&now));
168	if (!TEST_true(ossl_cmp_hdr_update_messageTime(fixture->hdr)))
169	return 0;
170	if (!TEST_true(ASN1_TIME_to_tm(fixture->hdr->messageTime, &hdrtm)))
171	return 0;
172
173	hdrtime = mktime(&hdrtm);
174	if (!TEST_true(before <= hdrtime))
175	return 0;
176	now = time(NULL);
177	after = mktime(gmtime(&now));
178	return TEST_true(hdrtime <= after);
179	}
180
181	static int test_HDR_update_messageTime(void)
182	{
183	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
184	fixture->expected = 1;
185	EXECUTE_TEST(execute_HDR_update_messageTime_test, tear_down);
186	return result;
187	}
188
189	static int execute_HDR_set1_senderKID_test(CMP_HDR_TEST_FIXTURE *fixture)
190	{
191	ASN1_OCTET_STRING* senderKID = ASN1_OCTET_STRING_new();
192
193	if (!TEST_ptr(senderKID))
194	return 0;
195
3dbc5156 DDO	196	if (!TEST_int_eq(ASN1_OCTET_STRING_set(senderKID, rand_data,
	197	sizeof(rand_data)), 1))
	198	return 0;
4dde554c DDO	199	if (!TEST_int_eq(ossl_cmp_hdr_set1_senderKID(fixture->hdr, senderKID), 1))
	200	return 0;
	201	if (!TEST_int_eq(
	202	ASN1_OCTET_STRING_cmp(fixture->hdr->senderKID, senderKID), 0))
	203	return 0;
	204
	205	ASN1_OCTET_STRING_free(senderKID);
	206	return 1;
	207	}
	208
	209	static int test_HDR_set1_senderKID(void)
	210	{
	211	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	212	fixture->expected = 1;
	213	EXECUTE_TEST(execute_HDR_set1_senderKID_test, tear_down);
	214	return result;
	215	}
	216
	217	static int execute_HDR_push0_freeText_test(CMP_HDR_TEST_FIXTURE *fixture)
	218	{
	219	ASN1_UTF8STRING* text = ASN1_UTF8STRING_new();
	220
	221	if (!TEST_ptr(text))
	222	return 0;
	223
	224	if (!ASN1_STRING_set(text, "A free text", -1))
	225	return 0;
	226
	227	if (!TEST_int_eq(
	228	ossl_cmp_hdr_push0_freeText(fixture->hdr, text), 1))
	229	return 0;
	230	if (!TEST_true(text == sk_ASN1_UTF8STRING_value(
	231	fixture->hdr->freeText, 0)))
	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	{
	247	ASN1_UTF8STRING* text = ASN1_UTF8STRING_new();
	248
	249	if (!TEST_ptr(text))
	250	return 0;
	251
	252	if (!ASN1_STRING_set(text, "A free text", -1))
	253	return 0;
	254
	255	if (!TEST_int_eq(
	256	ossl_cmp_hdr_push1_freeText(fixture->hdr, text), 1))
	257	return 0;
	258	if (!TEST_int_eq(ASN1_STRING_cmp(
	259	sk_ASN1_UTF8STRING_value(fixture->hdr->freeText, 0), text), 0))
	260	return 0;
	261
	262	ASN1_UTF8STRING_free(text);
263	return 1;
264	}
265
266	static int test_HDR_push1_freeText(void)
267	{
268	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
269	fixture->expected = 1;
270	EXECUTE_TEST(execute_HDR_push1_freeText_test, tear_down);
271	return result;
272	}
273
274	static int
275	execute_HDR_generalInfo_push0_item_test(CMP_HDR_TEST_FIXTURE *fixture)
276	{
277	OSSL_CMP_ITAV *itav = OSSL_CMP_ITAV_new();
278
279	if (!TEST_ptr(itav))
280	return 0;
281
282	if (!TEST_int_eq(
283	ossl_cmp_hdr_generalInfo_push0_item(fixture->hdr, itav), 1))
284	return 0;
285	if (!TEST_true(itav == sk_OSSL_CMP_ITAV_value(
286	fixture->hdr->generalInfo, 0)))
287	return 0;
288
289	return 1;
290	}
291
292	static int test_HDR_generalInfo_push0_item(void)
293	{
294	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
295	fixture->expected = 1;
296	EXECUTE_TEST(execute_HDR_generalInfo_push0_item_test, tear_down);
297	return result;
298	}
299
300	static int
301	execute_HDR_generalInfo_push1_items_test(CMP_HDR_TEST_FIXTURE *fixture)
302	{
303	const char oid[] = "1.2.3.4";
304	char buf[20];
305	OSSL_CMP_ITAV *itav;
306	STACK_OF(OSSL_CMP_ITAV) *itavs = NULL;
307	ASN1_INTEGER *asn1int = ASN1_INTEGER_new();
308	ASN1_TYPE *val = ASN1_TYPE_new();
309
310	if (!TEST_ptr(asn1int))
311	return 0;
312
313	if (!TEST_ptr(val))
314	return 0;
315
316	ASN1_INTEGER_set(asn1int, 88);
317	ASN1_TYPE_set(val, V_ASN1_INTEGER, asn1int);
318	itav = OSSL_CMP_ITAV_create(OBJ_txt2obj(oid, 1), val);
319	OSSL_CMP_ITAV_push0_stack_item(&itavs, itav);
320
321	if (!TEST_int_eq(
322	ossl_cmp_hdr_generalInfo_push1_items(fixture->hdr, itavs), 1))
323	return 0;
324	OBJ_obj2txt(buf, sizeof(buf), OSSL_CMP_ITAV_get0_type(
325	sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo, 0)), 0);
326	if (!TEST_int_eq(memcmp(oid, buf, sizeof(oid)), 0))
327	return 0;
328
329	if (!TEST_int_eq(ASN1_TYPE_cmp(itav->infoValue.other,
330	OSSL_CMP_ITAV_get0_value(
331	sk_OSSL_CMP_ITAV_value(fixture->hdr->generalInfo, 0))), 0))
332	return 0;
333
334	sk_OSSL_CMP_ITAV_pop_free(itavs, OSSL_CMP_ITAV_free);
335	return 1;
336	}
337
338	static int test_HDR_generalInfo_push1_items(void)
339	{
340	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
341	fixture->expected = 1;
342	EXECUTE_TEST(execute_HDR_generalInfo_push1_items_test, tear_down);
343	return result;
344	}
345
346	static int
347	execute_HDR_set_and_check_implicitConfirm_test(CMP_HDR_TEST_FIXTURE
348	* fixture)
349	{
350	return TEST_false(ossl_cmp_hdr_check_implicitConfirm(fixture->hdr))
351	&& TEST_true(ossl_cmp_hdr_set_implicitConfirm(fixture->hdr))
352	&& TEST_true(ossl_cmp_hdr_check_implicitConfirm(fixture->hdr));
353	}
354
355	static int test_HDR_set_and_check_implicit_confirm(void)
356	{
357	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
358	EXECUTE_TEST(execute_HDR_set_and_check_implicitConfirm_test, tear_down);
359	return result;
360	}
361
362
363	static int execute_HDR_init_test(CMP_HDR_TEST_FIXTURE *fixture)
364	{
365	ASN1_OCTET_STRING *header_nonce = NULL;
366	ASN1_OCTET_STRING *ctx_nonce = NULL;
367	int res = 0;
368
369	if (!TEST_int_eq(fixture->expected,
370	ossl_cmp_hdr_init(fixture->cmp_ctx, fixture->hdr)))
371	goto err;
372	if (fixture->expected != 0) {
373	if (!TEST_int_eq(ossl_cmp_hdr_get_pvno(fixture->hdr), OSSL_CMP_PVNO)
374	\|\| !TEST_true(0 == ASN1_OCTET_STRING_cmp(
375	ossl_cmp_hdr_get0_senderNonce(fixture->hdr),
376	fixture->cmp_ctx->senderNonce))
3dbc5156	377	\|\| !TEST_true(0 == ASN1_OCTET_STRING_cmp(
4dde554c DDO	378	OSSL_CMP_HDR_get0_transactionID(fixture->hdr),
	379	fixture->cmp_ctx->transactionID)))
	380	goto err;
	381	header_nonce = OSSL_CMP_HDR_get0_recipNonce(fixture->hdr);
	382	ctx_nonce = fixture->cmp_ctx->recipNonce;
	383	if (ctx_nonce != NULL
	384	&& (!TEST_ptr(header_nonce)
	385	\|\| !TEST_int_eq(0, ASN1_OCTET_STRING_cmp(header_nonce,
	386	ctx_nonce))))
	387	goto err;
	388	}
	389
	390	res = 1;
	391
	392	err:
	393	return res;
	394	}
	395
	396	static int test_HDR_init(void)
	397	{
	398	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	399	unsigned char ref[CMP_TEST_REFVALUE_LENGTH];
	400
	401	fixture->expected = 1;
	402	if (!TEST_int_eq(1, RAND_bytes(ref, sizeof(ref)))
	403	\|\| !TEST_true(OSSL_CMP_CTX_set1_referenceValue(fixture->cmp_ctx,
	404	ref, sizeof(ref)))) {
	405	tear_down(fixture);
	406	fixture = NULL;
	407	}
	408	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	409	return result;
	410	}
	411
	412	static int test_HDR_init_with_subject(void)
	413	{
	414	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	415	X509_NAME *subject = NULL;
	416
	417	fixture->expected = 1;
	418	if (!TEST_ptr(subject = X509_NAME_new())
3dbc5156 DDO	419	\|\| !TEST_true(X509_NAME_ADD(subject, "CN", "Common Name"))
	420	\|\| !TEST_true(OSSL_CMP_CTX_set1_subjectName(fixture->cmp_ctx,
	421	subject))) {
4dde554c DDO	422	tear_down(fixture);
	423	fixture = NULL;
	424	}
	425	X509_NAME_free(subject);
	426	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	427	return result;
	428	}
	429
	430	static int test_HDR_init_no_ref_no_subject(void)
	431	{
	432	SETUP_TEST_FIXTURE(CMP_HDR_TEST_FIXTURE, set_up);
	433	fixture->expected = 0;
	434	EXECUTE_TEST(execute_HDR_init_test, tear_down);
	435	return result;
	436	}
	437
	438
	439	void cleanup_tests(void)
	440	{
	441	return;
	442	}
	443
	444	int setup_tests(void)
	445	{
	446	RAND_bytes(rand_data, OSSL_CMP_TRANSACTIONID_LENGTH);
	447	/* Message header tests */
	448	ADD_TEST(test_HDR_set_get_pvno);
	449	ADD_TEST(test_HDR_get0_senderNonce);
	450	ADD_TEST(test_HDR_set1_sender);
	451	ADD_TEST(test_HDR_set1_recipient);
	452	ADD_TEST(test_HDR_update_messageTime);
	453	ADD_TEST(test_HDR_set1_senderKID);
	454	ADD_TEST(test_HDR_push0_freeText);
	455	/* indirectly tests ossl_cmp_pkifreetext_push_str(): */
	456	ADD_TEST(test_HDR_push1_freeText);
	457	ADD_TEST(test_HDR_generalInfo_push0_item);
	458	ADD_TEST(test_HDR_generalInfo_push1_items);
	459	ADD_TEST(test_HDR_set_and_check_implicit_confirm);
	460	/* also tests public function OSSL_CMP_HDR_get0_transactionID(): */
	461	/* also tests public function OSSL_CMP_HDR_get0_recipNonce(): */
	462	/* also tests internal function ossl_cmp_hdr_get_pvno(): */
	463	ADD_TEST(test_HDR_init);
	464	ADD_TEST(test_HDR_init_with_subject);
	465	ADD_TEST(test_HDR_init_no_ref_no_subject);
3dbc5156 DDO	466	/*
	467	* TODO make sure that total number of tests (here currently 24) is shown,
	468	* also for other cmp_*text.c. Currently the test drivers always show 1.
	469	*/
4dde554c DDO	470
	471	return 1;
	472	}