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

/*
 * Copyright 1999-2024 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
 */

/* Time tests for the asn1 module */

#include <limits.h>
#include <stdio.h>
#include <string.h>

#include <crypto/asn1.h>
#include <openssl/asn1.h>
#include <openssl/evp.h>
#include <openssl/objects.h>
#include "testutil.h"
#include "internal/nelem.h"

struct testdata {
    char *data;             /* TIME string value */
    int type;               /* GENERALIZED OR UTC */
    int expected_type;      /* expected type after set/set_string_gmt */
    int check_result;       /* check result */
    time_t t;               /* expected time_t*/
    int cmp_result;         /* comparison to baseline result */
    int convert_result;     /* conversion result */
};

struct TESTDATA_asn1_to_utc {
    char *input;
    time_t expected;
};

static const struct TESTDATA_asn1_to_utc asn1_to_utc[] = {
    {
        /*
         * last second of standard time in central Europe in 2021
         * specified in GMT
         */
        "210328005959Z",
        1616893199,
    },
    {
        /*
         * first second of daylight saving time in central Europe in 2021
         * specified in GMT
         */
        "210328010000Z",
        1616893200,
    },
    {
        /*
         * last second of standard time in central Europe in 2021
         * specified in offset to GMT
         */
        "20210328015959+0100",
        1616893199,
    },
    {
        /*
         * first second of daylight saving time in central Europe in 2021
         * specified in offset to GMT
         */
        "20210328030000+0200",
        1616893200,
    },
    {
        /*
         * Invalid strings should get -1 as a result
         */
        "INVALID",
        -1,
    },
};

static struct testdata tbl_testdata_pos[] = {
    { "0",                 V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, }, /* Bad time */
    { "ABCD",              V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "0ABCD",             V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1-700101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "`9700101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "19700101000000Z",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 0, },
    { "A00101000000Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 0, },
    { "A9700101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1A700101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "19A00101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "197A0101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1970A101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "19700A01000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "197001A1000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1970010A000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "19700101A00000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "197001010A0000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1970010100A000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "19700101000A00Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "197001010000A0Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "1970010100000AZ",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "700101000000X",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 0, },
    { "19700101000000X",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "209912312359Z",     V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "199912310000Z",     V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0,           0,  0, 0, },
    { "9912312359Z",       V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 0, },
    { "9912310000Z",       V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 0, },
    { "19700101000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,           0, -1, 1, }, /* Epoch begins */
    { "700101000000Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,           0, -1, 1, }, /* ditto */
    { "20380119031407Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,  0x7FFFFFFF,  1, 1, }, /* Max 32bit time_t */
    { "380119031407Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,  0x7FFFFFFF,  1, 1, },
    { "20371231235959Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,  2145916799,  1, 1, }, /* Just before 2038 */
    { "20371231235959Z",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         0,           0,  0, 1, }, /* Bad UTC time */
    { "371231235959Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,  2145916799,  1, 1, },
    { "19701006121456Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,    24063296, -1, 1, },
    { "701006121456Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,    24063296, -1, 1, },
    { "19991231000000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,   946598400,  0, 1, }, /* Match baseline */
    { "991231000000Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "9912310000+0000",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "199912310000+0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "9912310000-0000",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "199912310000-0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "199912310100+0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "199912302300-0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "199912302300-A000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         0,   946598400,  0, 1, },
    { "199912302300-0A00", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         0,   946598400,  0, 1, },
    { "9912310100+0100",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
    { "9912302300-0100",   V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,   946598400,  0, 1, },
};

/* ASSUMES SIGNED TIME_T */
static struct testdata tbl_testdata_neg[] = {
    { "19011213204552Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1,     INT_MIN, -1, 0, },
    { "691006121456Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,    -7472704, -1, 1, },
    { "19691006121456Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,    -7472704, -1, 1, },
};

/* explicit casts to time_t short warnings on systems with 32-bit time_t */
static struct testdata tbl_testdata_pos_64bit[] = {
    { "20380119031408Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,  (time_t)0x80000000,  1, 1, },
    { "20380119031409Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME,         1,  (time_t)0x80000001,  1, 1, },
    { "380119031408Z",     V_ASN1_UTCTIME,         V_ASN1_UTCTIME,         1,  (time_t)0x80000000,  1, 1, },
    { "20500101120000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1,  (time_t)0x967b1ec0,  1, 0, },
};

/* ASSUMES SIGNED TIME_T */
static struct testdata tbl_testdata_neg_64bit[] = {
    { "19011213204551Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2147483649LL, -1, 0, },
    { "19000101120000Z",   V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2208945600LL, -1, 0, },
};

/* A baseline time to compare to */
static ASN1_TIME gtime = {
    15,
    V_ASN1_GENERALIZEDTIME,
    (unsigned char*)"19991231000000Z",
    0
};
static time_t gtime_t = 946598400;

static int test_table(struct testdata *tbl, int idx)
{
    int error = 0;
    ASN1_TIME atime;
    ASN1_TIME *ptime;
    struct testdata *td = &tbl[idx];
    int day, sec;

    atime.data = (unsigned char*)td->data;
    atime.length = strlen((char*)atime.data);
    atime.type = td->type;
    atime.flags = 0;

    if (!TEST_int_eq(ASN1_TIME_check(&atime), td->check_result)) {
        TEST_info("ASN1_TIME_check(%s) unexpected result", atime.data);
        error = 1;
    }
    if (td->check_result == 0)
        return 1;

    if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, td->t), 0)) {
        TEST_info("ASN1_TIME_cmp_time_t(%s vs %ld) compare failed", atime.data, (long)td->t);
        error = 1;
    }

    if (!TEST_true(ASN1_TIME_diff(&day, &sec, &atime, &atime))) {
        TEST_info("ASN1_TIME_diff(%s) to self failed", atime.data);
        error = 1;
    }
    if (!TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
        TEST_info("ASN1_TIME_diff(%s) to self not equal", atime.data);
        error = 1;
    }

    if (!TEST_true(ASN1_TIME_diff(&day, &sec, &gtime, &atime))) {
        TEST_info("ASN1_TIME_diff(%s) to baseline failed", atime.data);
        error = 1;
    } else if (!((td->cmp_result == 0 && TEST_true((day == 0 && sec == 0))) ||
                 (td->cmp_result == -1 && TEST_true((day < 0 || sec < 0))) ||
                 (td->cmp_result == 1 && TEST_true((day > 0 || sec > 0))))) {
        TEST_info("ASN1_TIME_diff(%s) to baseline bad comparison", atime.data);
        error = 1;
    }

    if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, gtime_t), td->cmp_result)) {
        TEST_info("ASN1_TIME_cmp_time_t(%s) to baseline bad comparison", atime.data);
        error = 1;
    }

    ptime = ASN1_TIME_set(NULL, td->t);
    if (!TEST_ptr(ptime)) {
        TEST_info("ASN1_TIME_set(%ld) failed", (long)td->t);
        error = 1;
    } else {
        int local_error = 0;
        if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
            TEST_info("ASN1_TIME_set(%ld) compare failed (%s->%s)",
                    (long)td->t, td->data, ptime->data);
            local_error = error = 1;
        }
        if (!TEST_int_eq(ptime->type, td->expected_type)) {
            TEST_info("ASN1_TIME_set(%ld) unexpected type", (long)td->t);
            local_error = error = 1;
        }
        if (local_error)
            TEST_info("ASN1_TIME_set() = %*s", ptime->length, ptime->data);
        ASN1_TIME_free(ptime);
    }

    ptime = ASN1_TIME_new();
    if (!TEST_ptr(ptime)) {
        TEST_info("ASN1_TIME_new() failed");
        error = 1;
    } else {
        int local_error = 0;
        if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
            TEST_info("ASN1_TIME_set_string_gmt(%s) failed", td->data);
            local_error = error = 1;
        }
        if (!TEST_int_eq(ASN1_TIME_normalize(ptime), td->check_result)) {
            TEST_info("ASN1_TIME_normalize(%s) failed", td->data);
            local_error = error = 1;
        }
        if (!TEST_int_eq(ptime->type, td->expected_type)) {
            TEST_info("ASN1_TIME_set_string_gmt(%s) unexpected type", td->data);
            local_error = error = 1;
        }
        day = sec = 0;
        if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) || !TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
            TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string_gmt() failed", day, sec, td->data);
            local_error = error = 1;
        }
        if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
            TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string_gnt() to baseline bad comparison", td->data);
            local_error = error = 1;
        }
        if (local_error)
            TEST_info("ASN1_TIME_set_string_gmt() = %*s", ptime->length, ptime->data);
        ASN1_TIME_free(ptime);
    }

    ptime = ASN1_TIME_new();
    if (!TEST_ptr(ptime)) {
        TEST_info("ASN1_TIME_new() failed");
        error = 1;
    } else {
        int local_error = 0;
        if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
            TEST_info("ASN1_TIME_set_string(%s) failed", td->data);
            local_error = error = 1;
        }
        day = sec = 0;
        if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) || !TEST_int_eq(day, 0) || !TEST_int_eq(sec, 0)) {
            TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string() failed", day, sec, td->data);
            local_error = error = 1;
        }
        if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
            TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string() to baseline bad comparison", td->data);
            local_error = error = 1;
        }
        if (local_error)
            TEST_info("ASN1_TIME_set_string() = %*s", ptime->length, ptime->data);
        ASN1_TIME_free(ptime);
    }

    if (td->type == V_ASN1_UTCTIME) {
        ptime = ASN1_TIME_to_generalizedtime(&atime, NULL);
        if (td->convert_result == 1 && !TEST_ptr(ptime)) {
            TEST_info("ASN1_TIME_to_generalizedtime(%s) failed", atime.data);
            error = 1;
        } else if (td->convert_result == 0 && !TEST_ptr_null(ptime)) {
            TEST_info("ASN1_TIME_to_generalizedtime(%s) should have failed", atime.data);
            error = 1;
        }
        if (ptime != NULL && !TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
            TEST_info("ASN1_TIME_to_generalizedtime(%s->%s) bad result", atime.data, ptime->data);
            error = 1;
        }
        ASN1_TIME_free(ptime);
    }
    /* else cannot simply convert GENERALIZEDTIME to UTCTIME */

    if (error)
        TEST_error("atime=%s", atime.data);

    return !error;
}

static int test_table_pos(int idx)
{
    return test_table(tbl_testdata_pos, idx);
}

static int test_table_neg(int idx)
{
    return test_table(tbl_testdata_neg, idx);
}

static int test_table_pos_64bit(int idx)
{
    return test_table(tbl_testdata_pos_64bit, idx);
}

static int test_table_neg_64bit(int idx)
{
    return test_table(tbl_testdata_neg_64bit, idx);
}

struct compare_testdata {
    ASN1_TIME t1;
    ASN1_TIME t2;
    int result;
};

static unsigned char TODAY_GEN_STR[] = "20170825000000Z";
static unsigned char TOMORROW_GEN_STR[] = "20170826000000Z";
static unsigned char TODAY_UTC_STR[] = "170825000000Z";
static unsigned char TOMORROW_UTC_STR[] = "170826000000Z";

#define TODAY_GEN    { sizeof(TODAY_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TODAY_GEN_STR, 0 }
#define TOMORROW_GEN { sizeof(TOMORROW_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TOMORROW_GEN_STR, 0 }
#define TODAY_UTC    { sizeof(TODAY_UTC_STR)-1, V_ASN1_UTCTIME, TODAY_UTC_STR, 0 }
#define TOMORROW_UTC { sizeof(TOMORROW_UTC_STR)-1, V_ASN1_UTCTIME, TOMORROW_UTC_STR, 0 }

static struct compare_testdata tbl_compare_testdata[] = {
    { TODAY_GEN,    TODAY_GEN,     0 },
    { TODAY_GEN,    TODAY_UTC,     0 },
    { TODAY_GEN,    TOMORROW_GEN, -1 },
    { TODAY_GEN,    TOMORROW_UTC, -1 },

    { TODAY_UTC,    TODAY_GEN,     0 },
    { TODAY_UTC,    TODAY_UTC,     0 },
    { TODAY_UTC,    TOMORROW_GEN, -1 },
    { TODAY_UTC,    TOMORROW_UTC, -1 },

    { TOMORROW_GEN, TODAY_GEN,     1 },
    { TOMORROW_GEN, TODAY_UTC,     1 },
    { TOMORROW_GEN, TOMORROW_GEN,  0 },
    { TOMORROW_GEN, TOMORROW_UTC,  0 },

    { TOMORROW_UTC, TODAY_GEN,     1 },
    { TOMORROW_UTC, TODAY_UTC,     1 },
    { TOMORROW_UTC, TOMORROW_GEN,  0 },
    { TOMORROW_UTC, TOMORROW_UTC,  0 }
};

static int test_table_compare(int idx)
{
    struct compare_testdata *td = &tbl_compare_testdata[idx];

    return TEST_int_eq(ASN1_TIME_compare(&td->t1, &td->t2), td->result);
}

static int test_time_dup(void)
{
    int ret = 0;
    ASN1_TIME *asn1_time = NULL;
    ASN1_TIME *asn1_time_dup = NULL;
    ASN1_TIME *asn1_gentime = NULL;

    asn1_time = ASN1_TIME_adj(NULL, time(NULL), 0, 0);
    if (asn1_time == NULL) {
        TEST_info("Internal error.");
        goto err;
    }

    asn1_gentime = ASN1_TIME_to_generalizedtime(asn1_time, NULL);
    if (asn1_gentime == NULL) {
        TEST_info("Internal error.");
        goto err;
    }

    asn1_time_dup = ASN1_TIME_dup(asn1_time);
    if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
        TEST_info("ASN1_TIME_dup() failed.");
        goto err;
    }
    if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
        TEST_info("ASN1_TIME_dup() duplicated non-identical value.");
        goto err;
    }
    ASN1_STRING_free(asn1_time_dup);

    asn1_time_dup = ASN1_UTCTIME_dup(asn1_time);
    if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
        TEST_info("ASN1_UTCTIME_dup() failed.");
        goto err;
    }
    if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
        TEST_info("ASN1_UTCTIME_dup() duplicated non-identical UTCTIME value.");
        goto err;
    }
    ASN1_STRING_free(asn1_time_dup);

    asn1_time_dup = ASN1_GENERALIZEDTIME_dup(asn1_gentime);
    if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
        TEST_info("ASN1_GENERALIZEDTIME_dup() failed.");
        goto err;
    }
    if (!TEST_int_eq(ASN1_TIME_compare(asn1_gentime, asn1_time_dup), 0)) {
        TEST_info("ASN1_GENERALIZEDTIME_dup() dup'ed non-identical value.");
        goto err;
    }

    ret = 1;
 err:
    ASN1_STRING_free(asn1_time);
    ASN1_STRING_free(asn1_gentime);
    ASN1_STRING_free(asn1_time_dup);
    return ret;
}

static int convert_asn1_to_time_t(int idx)
{
    time_t testdateutc;

    testdateutc = ossl_asn1_string_to_time_t(asn1_to_utc[idx].input);

    if (!TEST_time_t_eq(testdateutc, asn1_to_utc[idx].expected)) {
        TEST_info("ossl_asn1_string_to_time_t (%s) failed: expected %lli, got %lli\n",
                  asn1_to_utc[idx].input,
                  (long long int)asn1_to_utc[idx].expected,
                  (long long int)testdateutc);
        return 0;
    }
    return 1;
}

/*
 * this test is here to exercise ossl_asn1_time_from_tm
 * with an integer year close to INT_MAX.
 */
static int convert_tm_to_asn1_time(void)
{
    /* we need 64 bit time_t */
#if ((ULONG_MAX >> 31) >> 31) >= 1
    time_t t;
    ASN1_TIME *at;

    if (sizeof(time_t) * CHAR_BIT >= 64) {
        t = 67768011791126057ULL;
        at = ASN1_TIME_set(NULL, t);
        /*
         * If ASN1_TIME_set returns NULL, it means it could not handle the input
         * which is fine for this edge case.
         */
        ASN1_STRING_free(at);
    }
#endif
    return 1;
}

int setup_tests(void)
{
    /*
     * On platforms where |time_t| is an unsigned integer, t will be a
     * positive number.
     *
     * We check if we're on a platform with a signed |time_t| with '!(t > 0)'
     * because some compilers are picky if you do 't < 0', or even 't <= 0'
     * if |t| is unsigned.
     */
    time_t t = -1;
    /*
     * On some platforms, |time_t| is signed, but a negative value is an
     * error, and using it with gmtime() or localtime() generates a NULL.
     * If that is the case, we can't perform tests on negative values.
     */
    struct tm *ptm = localtime(&t);

    ADD_ALL_TESTS(test_table_pos, OSSL_NELEM(tbl_testdata_pos));
    if (!(t > 0) && ptm != NULL) {
        TEST_info("Adding negative-sign time_t tests");
        ADD_ALL_TESTS(test_table_neg, OSSL_NELEM(tbl_testdata_neg));
    }
    if (sizeof(time_t) > sizeof(uint32_t)) {
        TEST_info("Adding 64-bit time_t tests");
        ADD_ALL_TESTS(test_table_pos_64bit, OSSL_NELEM(tbl_testdata_pos_64bit));
#ifndef __hpux
        if (!(t > 0) && ptm != NULL) {
            TEST_info("Adding negative-sign 64-bit time_t tests");
            ADD_ALL_TESTS(test_table_neg_64bit, OSSL_NELEM(tbl_testdata_neg_64bit));
        }
#endif
    }
    ADD_ALL_TESTS(test_table_compare, OSSL_NELEM(tbl_compare_testdata));
    ADD_TEST(test_time_dup);
    ADD_ALL_TESTS(convert_asn1_to_time_t, OSSL_NELEM(asn1_to_utc));
    ADD_TEST(convert_tm_to_asn1_time);
    return 1;
}
Commit	Line	Data
cf37aaa3	1	/*
b6461792	2	* Copyright 1999-2024 The OpenSSL Project Authors. All Rights Reserved.
cf37aaa3	3	*
909f1a2e	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
cf37aaa3 TS	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	/* Time tests for the asn1 module */
	11
017fd465	12	#include <limits.h>
cf37aaa3 TS	13	#include <stdio.h>
	14	#include <string.h>
	15
065121ff	16	#include <crypto/asn1.h>
cf37aaa3 TS	17	#include <openssl/asn1.h>
	18	#include <openssl/evp.h>
	19	#include <openssl/objects.h>
	20	#include "testutil.h"
176db6dc	21	#include "internal/nelem.h"
cf37aaa3 TS	22
	23	struct testdata {
	24	char data; / TIME string value */
	25	int type; /* GENERALIZED OR UTC */
	26	int expected_type; /* expected type after set/set_string_gmt */
	27	int check_result; /* check result */
	28	time_t t; /* expected time_t*/
c2969ff6 AC	29	int cmp_result; /* comparison to baseline result */
c2969ff6 AC	30	int convert_result; /* conversion result */
cf37aaa3 TS	31	};
cf37aaa3 TS	32
065121ff AF	33	struct TESTDATA_asn1_to_utc {
	34	char *input;
	35	time_t expected;
	36	};
	37
	38	static const struct TESTDATA_asn1_to_utc asn1_to_utc[] = {
	39	{
	40	/*
	41	* last second of standard time in central Europe in 2021
	42	* specified in GMT
	43	*/
	44	"210328005959Z",
	45	1616893199,
	46	},
	47	{
	48	/*
	49	* first second of daylight saving time in central Europe in 2021
	50	* specified in GMT
	51	*/
	52	"210328010000Z",
	53	1616893200,
	54	},
	55	{
	56	/*
	57	* last second of standard time in central Europe in 2021
	58	* specified in offset to GMT
	59	*/
	60	"20210328015959+0100",
	61	1616893199,
	62	},
	63	{
	64	/*
	65	* first second of daylight saving time in central Europe in 2021
	66	* specified in offset to GMT
	67	*/
	68	"20210328030000+0200",
	69	1616893200,
	70	},
	71	{
	72	/*
	73	* Invalid strings should get -1 as a result
	74	*/
	75	"INVALID",
	76	-1,
	77	},
	78	};
	79
cf37aaa3 TS	80	static struct testdata tbl_testdata_pos[] = {
	81	{ "0", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, }, /* Bad time */
	82	{ "ABCD", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	83	{ "0ABCD", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	84	{ "1-700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	85	{ "`9700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	86	{ "19700101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
	87	{ "A00101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
	88	{ "A9700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	89	{ "1A700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	90	{ "19A00101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	91	{ "197A0101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	92	{ "1970A101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	93	{ "19700A01000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	94	{ "197001A1000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	95	{ "1970010A000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	96	{ "19700101A00000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	97	{ "197001010A0000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	98	{ "1970010100A000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	99	{ "19700101000A00Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	100	{ "197001010000A0Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	101	{ "1970010100000AZ", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	102	{ "700101000000X", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
	103	{ "19700101000000X", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
eadd8c47 JS	104	{ "209912312359Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	105	{ "199912310000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 0, 0, 0, 0, },
	106	{ "9912312359Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
	107	{ "9912310000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 0, },
cf37aaa3 TS	108	{ "19700101000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 0, -1, 1, }, /* Epoch begins */
	109	{ "700101000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 0, -1, 1, }, /* ditto */
	110	{ "20380119031407Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 0x7FFFFFFF, 1, 1, }, /* Max 32bit time_t */
	111	{ "380119031407Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 0x7FFFFFFF, 1, 1, },
	112	{ "20371231235959Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 2145916799, 1, 1, }, /* Just before 2038 */
	113	{ "20371231235959Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 0, 0, 0, 1, }, /* Bad UTC time */
	114	{ "371231235959Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 2145916799, 1, 1, },
	115	{ "19701006121456Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 24063296, -1, 1, },
	116	{ "701006121456Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 24063296, -1, 1, },
	117	{ "19991231000000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, }, /* Match baseline */
cf37aaa3	118	{ "991231000000Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
cf37aaa3 TS	119	{ "9912310000+0000", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	120	{ "199912310000+0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	121	{ "9912310000-0000", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	122	{ "199912310000-0000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	123	{ "199912310100+0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	124	{ "199912302300-0100", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	125	{ "199912302300-A000", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 0, 946598400, 0, 1, },
	126	{ "199912302300-0A00", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 0, 946598400, 0, 1, },
	127	{ "9912310100+0100", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	128	{ "9912302300-0100", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, 946598400, 0, 1, },
	129	};
	130
	131	/* ASSUMES SIGNED TIME_T */
	132	static struct testdata tbl_testdata_neg[] = {
3a63c0ed	133	{ "19011213204552Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, INT_MIN, -1, 0, },
cf37aaa3 TS	134	{ "691006121456Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, -7472704, -1, 1, },
	135	{ "19691006121456Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, -7472704, -1, 1, },
	136	};
	137
3a63c0ed	138	/* explicit casts to time_t short warnings on systems with 32-bit time_t */
cf37aaa3	139	static struct testdata tbl_testdata_pos_64bit[] = {
3a63c0ed AP	140	{ "20380119031408Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000000, 1, 1, },
	141	{ "20380119031409Z", V_ASN1_GENERALIZEDTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000001, 1, 1, },
	142	{ "380119031408Z", V_ASN1_UTCTIME, V_ASN1_UTCTIME, 1, (time_t)0x80000000, 1, 1, },
79a0e876	143	{ "20500101120000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)0x967b1ec0, 1, 0, },
cf37aaa3 TS	144	};
	145
	146	/* ASSUMES SIGNED TIME_T */
	147	static struct testdata tbl_testdata_neg_64bit[] = {
3a63c0ed AP	148	{ "19011213204551Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2147483649LL, -1, 0, },
3a63c0ed AP	149	{ "19000101120000Z", V_ASN1_GENERALIZEDTIME, V_ASN1_GENERALIZEDTIME, 1, (time_t)-2208945600LL, -1, 0, },
cf37aaa3 TS	150	};
	151
	152	/* A baseline time to compare to */
	153	static ASN1_TIME gtime = {
	154	15,
	155	V_ASN1_GENERALIZEDTIME,
	156	(unsigned char*)"19991231000000Z",
	157	0
	158	};
	159	static time_t gtime_t = 946598400;
	160
	161	static int test_table(struct testdata *tbl, int idx)
	162	{
	163	int error = 0;
	164	ASN1_TIME atime;
	165	ASN1_TIME *ptime;
	166	struct testdata *td = &tbl[idx];
	167	int day, sec;
	168
	169	atime.data = (unsigned char*)td->data;
	170	atime.length = strlen((char*)atime.data);
	171	atime.type = td->type;
	172	atime.flags = 0;
	173
	174	if (!TEST_int_eq(ASN1_TIME_check(&atime), td->check_result)) {
	175	TEST_info("ASN1_TIME_check(%s) unexpected result", atime.data);
	176	error = 1;
	177	}
	178	if (td->check_result == 0)
	179	return 1;
	180
	181	if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, td->t), 0)) {
	182	TEST_info("ASN1_TIME_cmp_time_t(%s vs %ld) compare failed", atime.data, (long)td->t);
	183	error = 1;
	184	}
	185
	186	if (!TEST_true(ASN1_TIME_diff(&day, &sec, &atime, &atime))) {
	187	TEST_info("ASN1_TIME_diff(%s) to self failed", atime.data);
	188	error = 1;
	189	}
	190	if (!TEST_int_eq(day, 0) \|\| !TEST_int_eq(sec, 0)) {
	191	TEST_info("ASN1_TIME_diff(%s) to self not equal", atime.data);
	192	error = 1;
	193	}
	194
	195	if (!TEST_true(ASN1_TIME_diff(&day, &sec, &gtime, &atime))) {
	196	TEST_info("ASN1_TIME_diff(%s) to baseline failed", atime.data);
	197	error = 1;
	198	} else if (!((td->cmp_result == 0 && TEST_true((day == 0 && sec == 0))) \|\|
	199	(td->cmp_result == -1 && TEST_true((day < 0 \|\| sec < 0))) \|\|
	200	(td->cmp_result == 1 && TEST_true((day > 0 \|\| sec > 0))))) {
	201	TEST_info("ASN1_TIME_diff(%s) to baseline bad comparison", atime.data);
	202	error = 1;
	203	}
	204
	205	if (!TEST_int_eq(ASN1_TIME_cmp_time_t(&atime, gtime_t), td->cmp_result)) {
	206	TEST_info("ASN1_TIME_cmp_time_t(%s) to baseline bad comparison", atime.data);
	207	error = 1;
	208	}
	209
	210	ptime = ASN1_TIME_set(NULL, td->t);
	211	if (!TEST_ptr(ptime)) {
	212	TEST_info("ASN1_TIME_set(%ld) failed", (long)td->t);
	213	error = 1;
214	} else {
215	int local_error = 0;
216	if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
217	TEST_info("ASN1_TIME_set(%ld) compare failed (%s->%s)",
218	(long)td->t, td->data, ptime->data);
219	local_error = error = 1;
220	}
221	if (!TEST_int_eq(ptime->type, td->expected_type)) {
222	TEST_info("ASN1_TIME_set(%ld) unexpected type", (long)td->t);
223	local_error = error = 1;
224	}
225	if (local_error)
226	TEST_info("ASN1_TIME_set() = %*s", ptime->length, ptime->data);
227	ASN1_TIME_free(ptime);
228	}
229
230	ptime = ASN1_TIME_new();
231	if (!TEST_ptr(ptime)) {
232	TEST_info("ASN1_TIME_new() failed");
233	error = 1;
234	} else {
235	int local_error = 0;
236	if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
237	TEST_info("ASN1_TIME_set_string_gmt(%s) failed", td->data);
238	local_error = error = 1;
239	}
240	if (!TEST_int_eq(ASN1_TIME_normalize(ptime), td->check_result)) {
241	TEST_info("ASN1_TIME_normalize(%s) failed", td->data);
242	local_error = error = 1;
243	}
244	if (!TEST_int_eq(ptime->type, td->expected_type)) {
245	TEST_info("ASN1_TIME_set_string_gmt(%s) unexpected type", td->data);
246	local_error = error = 1;
247	}
248	day = sec = 0;
249	if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) \|\| !TEST_int_eq(day, 0) \|\| !TEST_int_eq(sec, 0)) {
250	TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string_gmt() failed", day, sec, td->data);
251	local_error = error = 1;
252	}
253	if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
254	TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string_gnt() to baseline bad comparison", td->data);
255	local_error = error = 1;
256	}
257	if (local_error)
258	TEST_info("ASN1_TIME_set_string_gmt() = %*s", ptime->length, ptime->data);
259	ASN1_TIME_free(ptime);
260	}
261
262	ptime = ASN1_TIME_new();
263	if (!TEST_ptr(ptime)) {
264	TEST_info("ASN1_TIME_new() failed");
265	error = 1;
266	} else {
267	int local_error = 0;
268	if (!TEST_int_eq(ASN1_TIME_set_string(ptime, td->data), td->check_result)) {
269	TEST_info("ASN1_TIME_set_string(%s) failed", td->data);
270	local_error = error = 1;
271	}
272	day = sec = 0;
273	if (!TEST_true(ASN1_TIME_diff(&day, &sec, ptime, &atime)) \|\| !TEST_int_eq(day, 0) \|\| !TEST_int_eq(sec, 0)) {
274	TEST_info("ASN1_TIME_diff(day=%d, sec=%d, %s) after ASN1_TIME_set_string() failed", day, sec, td->data);
275	local_error = error = 1;
276	}
277	if (!TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, gtime_t), td->cmp_result)) {
278	TEST_info("ASN1_TIME_cmp_time_t(%s) after ASN1_TIME_set_string() to baseline bad comparison", td->data);
279	local_error = error = 1;
280	}
281	if (local_error)
282	TEST_info("ASN1_TIME_set_string() = %*s", ptime->length, ptime->data);
283	ASN1_TIME_free(ptime);
284	}
285
286	if (td->type == V_ASN1_UTCTIME) {
287	ptime = ASN1_TIME_to_generalizedtime(&atime, NULL);
288	if (td->convert_result == 1 && !TEST_ptr(ptime)) {
289	TEST_info("ASN1_TIME_to_generalizedtime(%s) failed", atime.data);
290	error = 1;
291	} else if (td->convert_result == 0 && !TEST_ptr_null(ptime)) {
292	TEST_info("ASN1_TIME_to_generalizedtime(%s) should have failed", atime.data);
293	error = 1;
294	}
295	if (ptime != NULL && !TEST_int_eq(ASN1_TIME_cmp_time_t(ptime, td->t), 0)) {
296	TEST_info("ASN1_TIME_to_generalizedtime(%s->%s) bad result", atime.data, ptime->data);
297	error = 1;
298	}
299	ASN1_TIME_free(ptime);
300	}
301	/* else cannot simply convert GENERALIZEDTIME to UTCTIME */
302
303	if (error)
304	TEST_error("atime=%s", atime.data);
305
306	return !error;
307	}
308
309	static int test_table_pos(int idx)
310	{
311	return test_table(tbl_testdata_pos, idx);
312	}
313
314	static int test_table_neg(int idx)
315	{
316	return test_table(tbl_testdata_neg, idx);
317	}
318
319	static int test_table_pos_64bit(int idx)
320	{
321	return test_table(tbl_testdata_pos_64bit, idx);
322	}
323
324	static int test_table_neg_64bit(int idx)
325	{
326	return test_table(tbl_testdata_neg_64bit, idx);
327	}
328
e44d3761 TS	329	struct compare_testdata {
	330	ASN1_TIME t1;
	331	ASN1_TIME t2;
	332	int result;
	333	};
	334
	335	static unsigned char TODAY_GEN_STR[] = "20170825000000Z";
	336	static unsigned char TOMORROW_GEN_STR[] = "20170826000000Z";
	337	static unsigned char TODAY_UTC_STR[] = "170825000000Z";
	338	static unsigned char TOMORROW_UTC_STR[] = "170826000000Z";
	339
	340	#define TODAY_GEN { sizeof(TODAY_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TODAY_GEN_STR, 0 }
	341	#define TOMORROW_GEN { sizeof(TOMORROW_GEN_STR)-1, V_ASN1_GENERALIZEDTIME, TOMORROW_GEN_STR, 0 }
	342	#define TODAY_UTC { sizeof(TODAY_UTC_STR)-1, V_ASN1_UTCTIME, TODAY_UTC_STR, 0 }
	343	#define TOMORROW_UTC { sizeof(TOMORROW_UTC_STR)-1, V_ASN1_UTCTIME, TOMORROW_UTC_STR, 0 }
	344
	345	static struct compare_testdata tbl_compare_testdata[] = {
	346	{ TODAY_GEN, TODAY_GEN, 0 },
	347	{ TODAY_GEN, TODAY_UTC, 0 },
	348	{ TODAY_GEN, TOMORROW_GEN, -1 },
	349	{ TODAY_GEN, TOMORROW_UTC, -1 },
	350
	351	{ TODAY_UTC, TODAY_GEN, 0 },
	352	{ TODAY_UTC, TODAY_UTC, 0 },
	353	{ TODAY_UTC, TOMORROW_GEN, -1 },
	354	{ TODAY_UTC, TOMORROW_UTC, -1 },
	355
	356	{ TOMORROW_GEN, TODAY_GEN, 1 },
	357	{ TOMORROW_GEN, TODAY_UTC, 1 },
	358	{ TOMORROW_GEN, TOMORROW_GEN, 0 },
	359	{ TOMORROW_GEN, TOMORROW_UTC, 0 },
	360
	361	{ TOMORROW_UTC, TODAY_GEN, 1 },
	362	{ TOMORROW_UTC, TODAY_UTC, 1 },
	363	{ TOMORROW_UTC, TOMORROW_GEN, 0 },
	364	{ TOMORROW_UTC, TOMORROW_UTC, 0 }
	365	};
	366
	367	static int test_table_compare(int idx)
	368	{
	369	struct compare_testdata *td = &tbl_compare_testdata[idx];
	370
	371	return TEST_int_eq(ASN1_TIME_compare(&td->t1, &td->t2), td->result);
	372	}
	373
fe4309b0 PY	374	static int test_time_dup(void)
	375	{
	376	int ret = 0;
	377	ASN1_TIME *asn1_time = NULL;
	378	ASN1_TIME *asn1_time_dup = NULL;
	379	ASN1_TIME *asn1_gentime = NULL;
	380
	381	asn1_time = ASN1_TIME_adj(NULL, time(NULL), 0, 0);
	382	if (asn1_time == NULL) {
	383	TEST_info("Internal error.");
	384	goto err;
	385	}
	386
	387	asn1_gentime = ASN1_TIME_to_generalizedtime(asn1_time, NULL);
	388	if (asn1_gentime == NULL) {
	389	TEST_info("Internal error.");
	390	goto err;
	391	}
	392
	393	asn1_time_dup = ASN1_TIME_dup(asn1_time);
	394	if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
	395	TEST_info("ASN1_TIME_dup() failed.");
	396	goto err;
	397	}
	398	if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
	399	TEST_info("ASN1_TIME_dup() duplicated non-identical value.");
	400	goto err;
	401	}
	402	ASN1_STRING_free(asn1_time_dup);
	403
	404	asn1_time_dup = ASN1_UTCTIME_dup(asn1_time);
	405	if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
	406	TEST_info("ASN1_UTCTIME_dup() failed.");
	407	goto err;
	408	}
	409	if (!TEST_int_eq(ASN1_TIME_compare(asn1_time, asn1_time_dup), 0)) {
	410	TEST_info("ASN1_UTCTIME_dup() duplicated non-identical UTCTIME value.");
	411	goto err;
	412	}
	413	ASN1_STRING_free(asn1_time_dup);
	414
	415	asn1_time_dup = ASN1_GENERALIZEDTIME_dup(asn1_gentime);
	416	if (!TEST_ptr_ne(asn1_time_dup, NULL)) {
	417	TEST_info("ASN1_GENERALIZEDTIME_dup() failed.");
	418	goto err;
	419	}
	420	if (!TEST_int_eq(ASN1_TIME_compare(asn1_gentime, asn1_time_dup), 0)) {
	421	TEST_info("ASN1_GENERALIZEDTIME_dup() dup'ed non-identical value.");
	422	goto err;
	423	}
	424
	425	ret = 1;
	426	err:
	427	ASN1_STRING_free(asn1_time);
	428	ASN1_STRING_free(asn1_gentime);
	429	ASN1_STRING_free(asn1_time_dup);
	430	return ret;
	431	}
	432
065121ff AF	433	static int convert_asn1_to_time_t(int idx)
	434	{
	435	time_t testdateutc;
	436
6097eb21	437	testdateutc = ossl_asn1_string_to_time_t(asn1_to_utc[idx].input);
065121ff AF	438
065121ff AF	439	if (!TEST_time_t_eq(testdateutc, asn1_to_utc[idx].expected)) {
1555c86e J	440	TEST_info("ossl_asn1_string_to_time_t (%s) failed: expected %lli, got %lli\n",
	441	asn1_to_utc[idx].input,
	442	(long long int)asn1_to_utc[idx].expected,
	443	(long long int)testdateutc);
065121ff AF	444	return 0;
	445	}
	446	return 1;
	447	}
	448
017fd465 PD	449	/*
	450	* this test is here to exercise ossl_asn1_time_from_tm
	451	* with an integer year close to INT_MAX.
	452	*/
	453	static int convert_tm_to_asn1_time(void)
	454	{
	455	/* we need 64 bit time_t */
	456	#if ((ULONG_MAX >> 31) >> 31) >= 1
	457	time_t t;
	458	ASN1_TIME *at;
	459
	460	if (sizeof(time_t) * CHAR_BIT >= 64) {
	461	t = 67768011791126057ULL;
	462	at = ASN1_TIME_set(NULL, t);
	463	/*
	464	* If ASN1_TIME_set returns NULL, it means it could not handle the input
	465	* which is fine for this edge case.
	466	*/
	467	ASN1_STRING_free(at);
	468	}
	469	#endif
	470	return 1;
	471	}
	472
cf37aaa3 TS	473	int setup_tests(void)
cf37aaa3 TS	474	{
fdf9450f RL	475	/*
	476	* On platforms where \|time_t\| is an unsigned integer, t will be a
	477	* positive number.
	478	*
	479	* We check if we're on a platform with a signed \|time_t\| with '!(t > 0)'
	480	* because some compilers are picky if you do 't < 0', or even 't <= 0'
	481	* if \|t\| is unsigned.
	482	*/
cf37aaa3	483	time_t t = -1;
fdf9450f RL	484	/*
	485	* On some platforms, \|time_t\| is signed, but a negative value is an
	486	* error, and using it with gmtime() or localtime() generates a NULL.
	487	* If that is the case, we can't perform tests on negative values.
	488	*/
cf37aaa3 TS	489	struct tm *ptm = localtime(&t);
	490
	491	ADD_ALL_TESTS(test_table_pos, OSSL_NELEM(tbl_testdata_pos));
fdf9450f	492	if (!(t > 0) && ptm != NULL) {
cf37aaa3 TS	493	TEST_info("Adding negative-sign time_t tests");
	494	ADD_ALL_TESTS(test_table_neg, OSSL_NELEM(tbl_testdata_neg));
	495	}
	496	if (sizeof(time_t) > sizeof(uint32_t)) {
	497	TEST_info("Adding 64-bit time_t tests");
	498	ADD_ALL_TESTS(test_table_pos_64bit, OSSL_NELEM(tbl_testdata_pos_64bit));
f5e31153	499	#ifndef __hpux
fdf9450f	500	if (!(t > 0) && ptm != NULL) {
cf37aaa3 TS	501	TEST_info("Adding negative-sign 64-bit time_t tests");
	502	ADD_ALL_TESTS(test_table_neg_64bit, OSSL_NELEM(tbl_testdata_neg_64bit));
	503	}
f5e31153	504	#endif
cf37aaa3	505	}
e44d3761	506	ADD_ALL_TESTS(test_table_compare, OSSL_NELEM(tbl_compare_testdata));
fe4309b0	507	ADD_TEST(test_time_dup);
065121ff	508	ADD_ALL_TESTS(convert_asn1_to_time_t, OSSL_NELEM(asn1_to_utc));
017fd465	509	ADD_TEST(convert_tm_to_asn1_time);
cf37aaa3 TS	510	return 1;
cf37aaa3 TS	511	}