/src/openssl35/crypto/x509/v3_timespec.c

Source
/*
 * Copyright 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
 */

#include <stdio.h>
#include <openssl/asn1t.h>
#include <openssl/x509v3.h>
#include <crypto/asn1.h>
#include "ext_dat.h"

static const char *WEEKDAY_NAMES[7] = {
    "SUN",
    "MON",
    "TUE",
    "WED",
    "THU",
    "FRI",
    "SAT"
};

static const char *WEEK_NAMES[5] = {
    "first",
    "second",
    "third",
    "fourth",
    "final"
};

static const char *MONTH_NAMES[12] = {
    "JAN",
    "FEB",
    "MAR",
    "APR",
    "MAY",
    "JUN",
    "JUL",
    "AUG",
    "SEPT",
    "OCT",
    "NOV",
    "DEC"
};

ASN1_SEQUENCE(OSSL_TIME_SPEC_ABSOLUTE) = {
    ASN1_EXP_OPT(OSSL_TIME_SPEC_ABSOLUTE, startTime, ASN1_GENERALIZEDTIME, 0),
    ASN1_EXP_OPT(OSSL_TIME_SPEC_ABSOLUTE, endTime, ASN1_GENERALIZEDTIME, 1),
} ASN1_SEQUENCE_END(OSSL_TIME_SPEC_ABSOLUTE)

ASN1_SEQUENCE(OSSL_DAY_TIME) = {
    ASN1_EXP_OPT(OSSL_DAY_TIME, hour, ASN1_INTEGER, 0),
    ASN1_EXP_OPT(OSSL_DAY_TIME, minute, ASN1_INTEGER, 1),
    ASN1_EXP_OPT(OSSL_DAY_TIME, second, ASN1_INTEGER, 2),
} ASN1_SEQUENCE_END(OSSL_DAY_TIME)

ASN1_SEQUENCE(OSSL_DAY_TIME_BAND) = {
    ASN1_EXP_OPT(OSSL_DAY_TIME_BAND, startDayTime, OSSL_DAY_TIME, 0),
    ASN1_EXP_OPT(OSSL_DAY_TIME_BAND, endDayTime, OSSL_DAY_TIME, 1),
} ASN1_SEQUENCE_END(OSSL_DAY_TIME_BAND)

ASN1_CHOICE(OSSL_NAMED_DAY) = {
    ASN1_SET_OF(OSSL_NAMED_DAY, choice.intNamedDays, ASN1_ENUMERATED),
    ASN1_SIMPLE(OSSL_NAMED_DAY, choice.bitNamedDays, ASN1_BIT_STRING),
} ASN1_CHOICE_END(OSSL_NAMED_DAY)

ASN1_CHOICE(OSSL_TIME_SPEC_X_DAY_OF) = {
    ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.first, OSSL_NAMED_DAY, 1),
    ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.second, OSSL_NAMED_DAY, 2),
    ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.third, OSSL_NAMED_DAY, 3),
    ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.fourth, OSSL_NAMED_DAY, 4),
    ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.fifth, OSSL_NAMED_DAY, 5),
} ASN1_CHOICE_END(OSSL_TIME_SPEC_X_DAY_OF)

ASN1_CHOICE(OSSL_TIME_SPEC_DAY) = {
    ASN1_SET_OF(OSSL_TIME_SPEC_DAY, choice.intDay, ASN1_INTEGER),
    ASN1_SIMPLE(OSSL_TIME_SPEC_DAY, choice.bitDay, ASN1_BIT_STRING),
    ASN1_SIMPLE(OSSL_TIME_SPEC_DAY, choice.dayOf, OSSL_TIME_SPEC_X_DAY_OF),
} ASN1_CHOICE_END(OSSL_TIME_SPEC_DAY)

ASN1_CHOICE(OSSL_TIME_SPEC_WEEKS) = {
    ASN1_SIMPLE(OSSL_TIME_SPEC_WEEKS, choice.allWeeks, ASN1_NULL),
    ASN1_SET_OF(OSSL_TIME_SPEC_WEEKS, choice.intWeek, ASN1_INTEGER),
    ASN1_SIMPLE(OSSL_TIME_SPEC_WEEKS, choice.bitWeek, ASN1_BIT_STRING),
} ASN1_CHOICE_END(OSSL_TIME_SPEC_WEEKS)

ASN1_CHOICE(OSSL_TIME_SPEC_MONTH) = {
    ASN1_SIMPLE(OSSL_TIME_SPEC_MONTH, choice.allMonths, ASN1_NULL),
    ASN1_SET_OF(OSSL_TIME_SPEC_MONTH, choice.intMonth, ASN1_INTEGER),
    ASN1_SIMPLE(OSSL_TIME_SPEC_MONTH, choice.bitMonth, ASN1_BIT_STRING),
} ASN1_CHOICE_END(OSSL_TIME_SPEC_MONTH)

ASN1_SEQUENCE(OSSL_TIME_PERIOD) = {
    ASN1_EXP_SET_OF_OPT(OSSL_TIME_PERIOD, timesOfDay, OSSL_DAY_TIME_BAND, 0),
    ASN1_EXP_OPT(OSSL_TIME_PERIOD, days, OSSL_TIME_SPEC_DAY, 1),
    ASN1_EXP_OPT(OSSL_TIME_PERIOD, weeks, OSSL_TIME_SPEC_WEEKS, 2),
    ASN1_EXP_OPT(OSSL_TIME_PERIOD, months, OSSL_TIME_SPEC_MONTH, 3),
    ASN1_EXP_SET_OF_OPT(OSSL_TIME_PERIOD, years, ASN1_INTEGER, 4),
} ASN1_SEQUENCE_END(OSSL_TIME_PERIOD)

ASN1_CHOICE(OSSL_TIME_SPEC_TIME) = {
    ASN1_SIMPLE(OSSL_TIME_SPEC_TIME, choice.absolute, OSSL_TIME_SPEC_ABSOLUTE),
    ASN1_SET_OF(OSSL_TIME_SPEC_TIME, choice.periodic, OSSL_TIME_PERIOD)
} ASN1_CHOICE_END(OSSL_TIME_SPEC_TIME)

ASN1_SEQUENCE(OSSL_TIME_SPEC) = {
    ASN1_SIMPLE(OSSL_TIME_SPEC, time, OSSL_TIME_SPEC_TIME),
    ASN1_OPT(OSSL_TIME_SPEC, notThisTime, ASN1_FBOOLEAN),
    ASN1_OPT(OSSL_TIME_SPEC, timeZone, ASN1_INTEGER),
} ASN1_SEQUENCE_END(OSSL_TIME_SPEC)

IMPLEMENT_ASN1_FUNCTIONS(OSSL_DAY_TIME)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_DAY_TIME_BAND)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_DAY)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_WEEKS)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_MONTH)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_NAMED_DAY)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_X_DAY_OF)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_ABSOLUTE)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_TIME)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC)
IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_PERIOD)

static int i2r_OSSL_TIME_SPEC_ABSOLUTE(X509V3_EXT_METHOD *method,
                                       OSSL_TIME_SPEC_ABSOLUTE *time,
                                       BIO *out, int indent)
{
    if (time->startTime != NULL && time->endTime != NULL) {
        if (!BIO_puts(out, "Any time between "))
            return 0;
        if (!ossl_asn1_time_print_ex(out, time->startTime, 0))
            return 0;
        if (!BIO_puts(out, " and "))
            return 0;
        if (!ossl_asn1_time_print_ex(out, time->endTime, 0))
            return 0;
    } else if (time->startTime != NULL) {
        if (!BIO_puts(out, "Any time after "))
            return 0;
        if (!ossl_asn1_time_print_ex(out, time->startTime, 0))
            return 0;
        if (BIO_printf(out, "%.*s", time->startTime->length, time->startTime->data) <= 0)
            return 0;
    } else if (time->endTime != NULL) {
        if (!BIO_puts(out, "Any time until "))
            return 0;
        if (!ossl_asn1_time_print_ex(out, time->endTime, 0))
            return 0;
    } else { /* Invalid: there must be SOME time specified. */
        return BIO_puts(out, "INVALID (EMPTY)");
    }
    return 1;
}

static int i2r_OSSL_DAY_TIME(X509V3_EXT_METHOD *method,
                             OSSL_DAY_TIME *dt,
                             BIO *out, int indent)
{
    int64_t h = 0;
    int64_t m = 0;
    int64_t s = 0;

    if (!dt->hour || !ASN1_INTEGER_get_int64(&h, dt->hour))
        return 0;
    if (dt->minute && !ASN1_INTEGER_get_int64(&m, dt->minute))
        return 0;
    if (dt->minute && !ASN1_INTEGER_get_int64(&s, dt->second))
        return 0;
    return BIO_printf(out, "%02lld:%02lld:%02lld",
                      (long long int)h, (long long int)m, (long long int)s) > 0;
}

static int i2r_OSSL_DAY_TIME_BAND(X509V3_EXT_METHOD *method,
                                  OSSL_DAY_TIME_BAND *band,
                                  BIO *out, int indent)
{
    if (band->startDayTime) {
        if (!i2r_OSSL_DAY_TIME(method, band->startDayTime, out, indent))
            return 0;
    } else if (!BIO_puts(out, "00:00:00")) {
        return 0;
    }
    if (!BIO_puts(out, " - "))
        return 0;
    if (band->endDayTime) {
        if (!i2r_OSSL_DAY_TIME(method, band->endDayTime, out, indent))
            return 0;
    } else if (!BIO_puts(out, "23:59:59")) {
        return 0;
    }
    return 1;
}

static int print_int_month(BIO *out, int64_t month)
{
    switch (month) {
    case (OSSL_TIME_SPEC_INT_MONTH_JAN):
        return BIO_puts(out, "JAN");
    case (OSSL_TIME_SPEC_INT_MONTH_FEB):
        return BIO_puts(out, "FEB");
    case (OSSL_TIME_SPEC_INT_MONTH_MAR):
        return BIO_puts(out, "MAR");
    case (OSSL_TIME_SPEC_INT_MONTH_APR):
        return BIO_puts(out, "APR");
    case (OSSL_TIME_SPEC_INT_MONTH_MAY):
        return BIO_puts(out, "MAY");
    case (OSSL_TIME_SPEC_INT_MONTH_JUN):
        return BIO_puts(out, "JUN");
    case (OSSL_TIME_SPEC_INT_MONTH_JUL):
        return BIO_puts(out, "JUL");
    case (OSSL_TIME_SPEC_INT_MONTH_AUG):
        return BIO_puts(out, "AUG");
    case (OSSL_TIME_SPEC_INT_MONTH_SEP):
        return BIO_puts(out, "SEP");
    case (OSSL_TIME_SPEC_INT_MONTH_OCT):
        return BIO_puts(out, "OCT");
    case (OSSL_TIME_SPEC_INT_MONTH_NOV):
        return BIO_puts(out, "NOV");
    case (OSSL_TIME_SPEC_INT_MONTH_DEC):
        return BIO_puts(out, "DEC");
    default:
        return 0;
    }
    return 0;
}

static int print_bit_month(BIO *out, ASN1_BIT_STRING *bs)
{
    int i = OSSL_TIME_SPEC_BIT_MONTH_JAN;
    int j = 0;

    for (; i <= OSSL_TIME_SPEC_BIT_MONTH_DEC; i++) {
        if (ASN1_BIT_STRING_get_bit(bs, i)) {
            if (j > 0 && !BIO_puts(out, ", "))
                return 0;
            j++;
            if (!BIO_puts(out, MONTH_NAMES[i]))
                return 0;
        }
    }
    return 1;
}

/*
 * It might seem like you could just print the bits of the string numerically,
 * but the fifth bit has the special meaning of "the final week" imputed to it
 * by the text of ITU-T Recommendation X.520.
 */
static int print_bit_week(BIO *out, ASN1_BIT_STRING *bs)
{
    int i = OSSL_TIME_SPEC_BIT_WEEKS_1;
    int j = 0;

    for (; i <= OSSL_TIME_SPEC_BIT_WEEKS_5; i++) {
        if (ASN1_BIT_STRING_get_bit(bs, i)) {
            if (j > 0 && !BIO_puts(out, ", "))
                return 0;
            j++;
            if (!BIO_puts(out, WEEK_NAMES[i]))
                return 0;
        }
    }
    return 1;
}

static int print_day_of_week(BIO *out, ASN1_BIT_STRING *bs)
{
    int i = OSSL_TIME_SPEC_DAY_BIT_SUN;
    int j = 0;

    for (; i <= OSSL_TIME_SPEC_DAY_BIT_SAT; i++) {
        if (ASN1_BIT_STRING_get_bit(bs, i)) {
            if (j > 0 && !BIO_puts(out, ", "))
                return 0;
            j++;
            if (!BIO_puts(out, WEEKDAY_NAMES[i]))
                return 0;
        }
    }
    return 1;
}

static int print_int_day_of_week(BIO *out, int64_t dow)
{
    switch (dow) {
    case (OSSL_TIME_SPEC_DAY_INT_SUN):
        return BIO_puts(out, "SUN");
    case (OSSL_TIME_SPEC_DAY_INT_MON):
        return BIO_puts(out, "MON");
    case (OSSL_TIME_SPEC_DAY_INT_TUE):
        return BIO_puts(out, "TUE");
    case (OSSL_TIME_SPEC_DAY_INT_WED):
        return BIO_puts(out, "WED");
    case (OSSL_TIME_SPEC_DAY_INT_THU):
        return BIO_puts(out, "THU");
    case (OSSL_TIME_SPEC_DAY_INT_FRI):
        return BIO_puts(out, "FRI");
    case (OSSL_TIME_SPEC_DAY_INT_SAT):
        return BIO_puts(out, "SAT");
    default:
        return 0;
    }
    return 0;
}

static int print_int_named_day(BIO *out, int64_t nd)
{
    switch (nd) {
    case (OSSL_NAMED_DAY_INT_SUN):
        return BIO_puts(out, "SUN");
    case (OSSL_NAMED_DAY_INT_MON):
        return BIO_puts(out, "MON");
    case (OSSL_NAMED_DAY_INT_TUE):
        return BIO_puts(out, "TUE");
    case (OSSL_NAMED_DAY_INT_WED):
        return BIO_puts(out, "WED");
    case (OSSL_NAMED_DAY_INT_THU):
        return BIO_puts(out, "THU");
    case (OSSL_NAMED_DAY_INT_FRI):
        return BIO_puts(out, "FRI");
    case (OSSL_NAMED_DAY_INT_SAT):
        return BIO_puts(out, "SAT");
    default:
        return 0;
    }
    return 0;
}

static int print_bit_named_day(BIO *out, ASN1_BIT_STRING *bs)
{
    return print_day_of_week(out, bs);
}

static int i2r_OSSL_PERIOD(X509V3_EXT_METHOD *method,
                           OSSL_TIME_PERIOD *p,
                           BIO *out, int indent)
{
    int i;
    OSSL_DAY_TIME_BAND *band;
    ASN1_INTEGER *big_val;
    int64_t small_val;
    OSSL_NAMED_DAY *nd;

    if (BIO_printf(out, "%*sPeriod:\n", indent, "") <= 0)
        return 0;
    if (p->timesOfDay) {
        if (BIO_printf(out, "%*sDaytime bands:\n", indent + 4, "") <= 0)
            return 0;
        for (i = 0; i < sk_OSSL_DAY_TIME_BAND_num(p->timesOfDay); i++) {
            band = sk_OSSL_DAY_TIME_BAND_value(p->timesOfDay, i);
            if (BIO_printf(out, "%*s", indent + 8, "") <= 0)
                return 0;
            if (!i2r_OSSL_DAY_TIME_BAND(method, band, out, indent + 8))
                return 0;
            if (!BIO_puts(out, "\n"))
                return 0;
        }
    }
    if (p->days) {
        if (p->days->type == OSSL_TIME_SPEC_DAY_TYPE_INT) {
            if (p->weeks != NULL) {
                if (BIO_printf(out, "%*sDays of the week: ", indent + 4, "") <= 0)
                    return 0;
            } else if (p->months != NULL) {
                if (BIO_printf(out, "%*sDays of the month: ", indent + 4, "") <= 0)
                    return 0;
            } else if (p->years != NULL) {
                if (BIO_printf(out, "%*sDays of the year: ", indent + 4, "") <= 0)
                    return 0;
            }
        } else {
            if (BIO_printf(out, "%*sDays: ", indent + 4, "") <= 0)
                return 0;
        }

        switch (p->days->type) {
        case (OSSL_TIME_SPEC_DAY_TYPE_INT):
            for (i = 0; i < sk_ASN1_INTEGER_num(p->days->choice.intDay); i++) {
                big_val = sk_ASN1_INTEGER_value(p->days->choice.intDay, i);
                if (!ASN1_INTEGER_get_int64(&small_val, big_val))
                    return 0;
                if (i > 0 && !BIO_puts(out, ", "))
                    return 0;
                /* If weeks is defined, then print day of week by name. */
                if (p->weeks != NULL) {
                    if (!print_int_day_of_week(out, small_val))
                        return 0;
                } else if (BIO_printf(out, "%lld", (long long int)small_val) <= 0) {
                    return 0;
                }
            }
            break;
        case (OSSL_TIME_SPEC_DAY_TYPE_BIT):
            if (!print_day_of_week(out, p->days->choice.bitDay))
                return 0;
            break;
        case (OSSL_TIME_SPEC_DAY_TYPE_DAY_OF):
            switch (p->days->choice.dayOf->type) {
            case (OSSL_TIME_SPEC_X_DAY_OF_FIRST):
                if (!BIO_puts(out, "FIRST "))
                    return 0;
                nd = p->days->choice.dayOf->choice.first;
                break;
            case (OSSL_TIME_SPEC_X_DAY_OF_SECOND):
                if (!BIO_puts(out, "SECOND "))
                    return 0;
                nd = p->days->choice.dayOf->choice.second;
                break;
            case (OSSL_TIME_SPEC_X_DAY_OF_THIRD):
                if (!BIO_puts(out, "THIRD "))
                    return 0;
                nd = p->days->choice.dayOf->choice.third;
                break;
            case (OSSL_TIME_SPEC_X_DAY_OF_FOURTH):
                if (!BIO_puts(out, "FOURTH "))
                    return 0;
                nd = p->days->choice.dayOf->choice.fourth;
                break;
            case (OSSL_TIME_SPEC_X_DAY_OF_FIFTH):
                if (!BIO_puts(out, "FIFTH "))
                    return 0;
                nd = p->days->choice.dayOf->choice.fifth;
                break;
            default:
                return 0;
            }
            switch (nd->type) {
            case (OSSL_NAMED_DAY_TYPE_INT):
                if (!ASN1_INTEGER_get_int64(&small_val, nd->choice.intNamedDays))
                    return 0;
                if (!print_int_named_day(out, small_val))
                    return 0;
                break;
            case (OSSL_NAMED_DAY_TYPE_BIT):
                if (!print_bit_named_day(out, nd->choice.bitNamedDays))
                    return 0;
                break;
            default:
                return 0;
            }
            break;
        default:
            return 0;
        }
        if (!BIO_puts(out, "\n"))
            return 0;
    }
    if (p->weeks) {
        if (p->weeks->type == OSSL_TIME_SPEC_WEEKS_TYPE_INT) {
            if (p->months != NULL) {
                if (BIO_printf(out, "%*sWeeks of the month: ", indent + 4, "") <= 0)
                    return 0;
            } else if (p->years != NULL) {
                if (BIO_printf(out, "%*sWeeks of the year: ", indent + 4, "") <= 0)
                    return 0;
            }
        } else {
            if (BIO_printf(out, "%*sWeeks: ", indent + 4, "") <= 0)
                return 0;
        }

        switch (p->weeks->type) {
        case (OSSL_TIME_SPEC_WEEKS_TYPE_ALL):
            if (!BIO_puts(out, "ALL"))
                return 0;
            break;
        case (OSSL_TIME_SPEC_WEEKS_TYPE_INT):
            for (i = 0; i < sk_ASN1_INTEGER_num(p->weeks->choice.intWeek); i++) {
                big_val = sk_ASN1_INTEGER_value(p->weeks->choice.intWeek, i);
                if (!ASN1_INTEGER_get_int64(&small_val, big_val))
                    return 0;
                if (i > 0 && !BIO_puts(out, ", "))
                    return 0;
                if (!BIO_printf(out, "%lld", (long long int)small_val))
                    return 0;
            }
            break;
        case (OSSL_TIME_SPEC_WEEKS_TYPE_BIT):
            if (!print_bit_week(out, p->weeks->choice.bitWeek))
                return 0;
            break;
        default:
            return 0;
        }
        if (!BIO_puts(out, "\n"))
            return 0;
    }
    if (p->months) {
        if (BIO_printf(out, "%*sMonths: ", indent + 4, "") <= 0)
            return 0;
        switch (p->months->type) {
        case (OSSL_TIME_SPEC_MONTH_TYPE_ALL):
            if (!BIO_puts(out, "ALL"))
                return 0;
            break;
        case (OSSL_TIME_SPEC_MONTH_TYPE_INT):
            for (i = 0; i < sk_ASN1_INTEGER_num(p->months->choice.intMonth); i++) {
                big_val = sk_ASN1_INTEGER_value(p->months->choice.intMonth, i);
                if (!ASN1_INTEGER_get_int64(&small_val, big_val))
                    return 0;
                if (i > 0 && !BIO_puts(out, ", "))
                    return 0;
                if (!print_int_month(out, small_val))
                    return 0;
            }
            break;
        case (OSSL_TIME_SPEC_MONTH_TYPE_BIT):
            if (!print_bit_month(out, p->months->choice.bitMonth))
                return 0;
            break;
        default:
            return 0;
        }
        if (!BIO_puts(out, "\n"))
            return 0;
    }
    if (p->years) {
        if (BIO_printf(out, "%*sYears: ", indent + 4, "") <= 0)
            return 0;
        for (i = 0; i < sk_ASN1_INTEGER_num(p->years); i++) {
            big_val = sk_ASN1_INTEGER_value(p->years, i);
            if (!ASN1_INTEGER_get_int64(&small_val, big_val))
                return 0;
            if (i > 0 && !BIO_puts(out, ", "))
                return 0;
            if (BIO_printf(out, "%04lld", (long long int)small_val) <= 0)
                return 0;
        }
    }
    return 1;
}

static int i2r_OSSL_TIME_SPEC_TIME(X509V3_EXT_METHOD *method,
                                   OSSL_TIME_SPEC_TIME *time,
                                   BIO *out, int indent)
{
    OSSL_TIME_PERIOD *tp;
    int i;

    switch (time->type) {
    case (OSSL_TIME_SPEC_TIME_TYPE_ABSOLUTE):
        if (BIO_printf(out, "%*sAbsolute: ", indent, "") <= 0)
            return 0;
        if (i2r_OSSL_TIME_SPEC_ABSOLUTE(method, time->choice.absolute, out, indent + 4) <= 0)
            return 0;
        return BIO_puts(out, "\n");
    case (OSSL_TIME_SPEC_TIME_TYPE_PERIODIC):
        if (BIO_printf(out, "%*sPeriodic:\n", indent, "") <= 0)
            return 0;
        for (i = 0; i < sk_OSSL_TIME_PERIOD_num(time->choice.periodic); i++) {
            if (i > 0 && !BIO_puts(out, "\n"))
                return 0;
            tp = sk_OSSL_TIME_PERIOD_value(time->choice.periodic, i);
            if (!i2r_OSSL_PERIOD(method, tp, out, indent + 4))
                return 0;
        }
        return BIO_puts(out, "\n");
    default:
        return 0;
    }
    return 0;
}

static int i2r_OSSL_TIME_SPEC(X509V3_EXT_METHOD *method,
                              OSSL_TIME_SPEC *time,
                              BIO *out, int indent)
{
    int64_t tz;

    if (time->timeZone) {
        if (ASN1_INTEGER_get_int64(&tz, time->timeZone) != 1)
            return 0;
        if (BIO_printf(out, "%*sTimezone: UTC%+03lld:00\n", indent, "", (long long int)tz) <= 0)
            return 0;
    }
    if (time->notThisTime > 0) {
        if (BIO_printf(out, "%*sNOT this time:\n", indent, "") <= 0)
            return 0;
    } else if (BIO_printf(out, "%*sTime:\n", indent, "") <= 0) {
        return 0;
    }
    return i2r_OSSL_TIME_SPEC_TIME(method, time->time, out, indent + 4);
}

const X509V3_EXT_METHOD ossl_v3_time_specification = {
    NID_time_specification, X509V3_EXT_MULTILINE,
    ASN1_ITEM_ref(OSSL_TIME_SPEC),
    0, 0, 0, 0,
    0, 0,
    0,
    0,
    (X509V3_EXT_I2R)i2r_OSSL_TIME_SPEC,
    NULL,
    NULL
};

Coverage Report

Created: 2025-12-04 06:33

Line	Count	Source
1		/*
2		* Copyright 2024 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include <stdio.h>
11		#include <openssl/asn1t.h>
12		#include <openssl/x509v3.h>
13		#include <crypto/asn1.h>
14		#include "ext_dat.h"
15
16		static const char *WEEKDAY_NAMES[7] = {
17		"SUN",
18		"MON",
19		"TUE",
20		"WED",
21		"THU",
22		"FRI",
23		"SAT"
24		};
25
26		static const char *WEEK_NAMES[5] = {
27		"first",
28		"second",
29		"third",
30		"fourth",
31		"final"
32		};
33
34		static const char *MONTH_NAMES[12] = {
35		"JAN",
36		"FEB",
37		"MAR",
38		"APR",
39		"MAY",
40		"JUN",
41		"JUL",
42		"AUG",
43		"SEPT",
44		"OCT",
45		"NOV",
46		"DEC"
47		};
48
49		ASN1_SEQUENCE(OSSL_TIME_SPEC_ABSOLUTE) = {
50		ASN1_EXP_OPT(OSSL_TIME_SPEC_ABSOLUTE, startTime, ASN1_GENERALIZEDTIME, 0),
51		ASN1_EXP_OPT(OSSL_TIME_SPEC_ABSOLUTE, endTime, ASN1_GENERALIZEDTIME, 1),
52	31.4k	} ASN1_SEQUENCE_END(OSSL_TIME_SPEC_ABSOLUTE)
53	31.4k
54	31.4k	ASN1_SEQUENCE(OSSL_DAY_TIME) = {
55	31.4k	ASN1_EXP_OPT(OSSL_DAY_TIME, hour, ASN1_INTEGER, 0),
56	31.4k	ASN1_EXP_OPT(OSSL_DAY_TIME, minute, ASN1_INTEGER, 1),
57	31.4k	ASN1_EXP_OPT(OSSL_DAY_TIME, second, ASN1_INTEGER, 2),
58	31.4k	} ASN1_SEQUENCE_END(OSSL_DAY_TIME)
59	8.18k
60	8.18k	ASN1_SEQUENCE(OSSL_DAY_TIME_BAND) = {
61	8.18k	ASN1_EXP_OPT(OSSL_DAY_TIME_BAND, startDayTime, OSSL_DAY_TIME, 0),
62	8.18k	ASN1_EXP_OPT(OSSL_DAY_TIME_BAND, endDayTime, OSSL_DAY_TIME, 1),
63	31.1k	} ASN1_SEQUENCE_END(OSSL_DAY_TIME_BAND)
64	31.1k
65	31.1k	ASN1_CHOICE(OSSL_NAMED_DAY) = {
66	31.1k	ASN1_SET_OF(OSSL_NAMED_DAY, choice.intNamedDays, ASN1_ENUMERATED),
67	31.1k	ASN1_SIMPLE(OSSL_NAMED_DAY, choice.bitNamedDays, ASN1_BIT_STRING),
68	31.1k	} ASN1_CHOICE_END(OSSL_NAMED_DAY)
69	6.17k
70	6.17k	ASN1_CHOICE(OSSL_TIME_SPEC_X_DAY_OF) = {
71	6.17k	ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.first, OSSL_NAMED_DAY, 1),
72	6.17k	ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.second, OSSL_NAMED_DAY, 2),
73	6.17k	ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.third, OSSL_NAMED_DAY, 3),
74	6.17k	ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.fourth, OSSL_NAMED_DAY, 4),
75	6.17k	ASN1_EXP(OSSL_TIME_SPEC_X_DAY_OF, choice.fifth, OSSL_NAMED_DAY, 5),
76	7.77k	} ASN1_CHOICE_END(OSSL_TIME_SPEC_X_DAY_OF)
77	7.77k
78	7.77k	ASN1_CHOICE(OSSL_TIME_SPEC_DAY) = {
79	7.77k	ASN1_SET_OF(OSSL_TIME_SPEC_DAY, choice.intDay, ASN1_INTEGER),
80	7.77k	ASN1_SIMPLE(OSSL_TIME_SPEC_DAY, choice.bitDay, ASN1_BIT_STRING),
81	7.77k	ASN1_SIMPLE(OSSL_TIME_SPEC_DAY, choice.dayOf, OSSL_TIME_SPEC_X_DAY_OF),
82	229k	} ASN1_CHOICE_END(OSSL_TIME_SPEC_DAY)
83	229k
84	229k	ASN1_CHOICE(OSSL_TIME_SPEC_WEEKS) = {
85	229k	ASN1_SIMPLE(OSSL_TIME_SPEC_WEEKS, choice.allWeeks, ASN1_NULL),
86	229k	ASN1_SET_OF(OSSL_TIME_SPEC_WEEKS, choice.intWeek, ASN1_INTEGER),
87	229k	ASN1_SIMPLE(OSSL_TIME_SPEC_WEEKS, choice.bitWeek, ASN1_BIT_STRING),
88	229k	} ASN1_CHOICE_END(OSSL_TIME_SPEC_WEEKS)
89	226k
90	226k	ASN1_CHOICE(OSSL_TIME_SPEC_MONTH) = {
91	226k	ASN1_SIMPLE(OSSL_TIME_SPEC_MONTH, choice.allMonths, ASN1_NULL),
92	226k	ASN1_SET_OF(OSSL_TIME_SPEC_MONTH, choice.intMonth, ASN1_INTEGER),
93	226k	ASN1_SIMPLE(OSSL_TIME_SPEC_MONTH, choice.bitMonth, ASN1_BIT_STRING),
94	226k	} ASN1_CHOICE_END(OSSL_TIME_SPEC_MONTH)
95	226k
96	226k	ASN1_SEQUENCE(OSSL_TIME_PERIOD) = {
97	226k	ASN1_EXP_SET_OF_OPT(OSSL_TIME_PERIOD, timesOfDay, OSSL_DAY_TIME_BAND, 0),
98	226k	ASN1_EXP_OPT(OSSL_TIME_PERIOD, days, OSSL_TIME_SPEC_DAY, 1),
99	226k	ASN1_EXP_OPT(OSSL_TIME_PERIOD, weeks, OSSL_TIME_SPEC_WEEKS, 2),
100	226k	ASN1_EXP_OPT(OSSL_TIME_PERIOD, months, OSSL_TIME_SPEC_MONTH, 3),
101	226k	ASN1_EXP_SET_OF_OPT(OSSL_TIME_PERIOD, years, ASN1_INTEGER, 4),
102	226k	} ASN1_SEQUENCE_END(OSSL_TIME_PERIOD)
103	65.2k
104	65.2k	ASN1_CHOICE(OSSL_TIME_SPEC_TIME) = {
105	65.2k	ASN1_SIMPLE(OSSL_TIME_SPEC_TIME, choice.absolute, OSSL_TIME_SPEC_ABSOLUTE),
106	65.2k	ASN1_SET_OF(OSSL_TIME_SPEC_TIME, choice.periodic, OSSL_TIME_PERIOD)
107	193k	} ASN1_CHOICE_END(OSSL_TIME_SPEC_TIME)
108	193k
109	193k	ASN1_SEQUENCE(OSSL_TIME_SPEC) = {
110	193k	ASN1_SIMPLE(OSSL_TIME_SPEC, time, OSSL_TIME_SPEC_TIME),
111	193k	ASN1_OPT(OSSL_TIME_SPEC, notThisTime, ASN1_FBOOLEAN),
112	193k	ASN1_OPT(OSSL_TIME_SPEC, timeZone, ASN1_INTEGER),
113	193k	} ASN1_SEQUENCE_END(OSSL_TIME_SPEC)
114	54.7k
115	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_DAY_TIME)
116	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_DAY_TIME_BAND)
117	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_DAY)
118	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_WEEKS)
119	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_MONTH)
120	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_NAMED_DAY)
121	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_X_DAY_OF)
122	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_ABSOLUTE)
123	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC_TIME)
124	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_SPEC)
125	54.7k	IMPLEMENT_ASN1_FUNCTIONS(OSSL_TIME_PERIOD)
126	54.7k
127	54.7k	static int i2r_OSSL_TIME_SPEC_ABSOLUTE(X509V3_EXT_METHOD *method,
128	54.7k	OSSL_TIME_SPEC_ABSOLUTE *time,
129	54.7k	BIO *out, int indent)
130	54.7k	{
131	2.71k	if (time->startTime != NULL && time->endTime != NULL) {
132	0	if (!BIO_puts(out, "Any time between "))
133	0	return 0;
134	0	if (!ossl_asn1_time_print_ex(out, time->startTime, 0))
135	0	return 0;
136	0	if (!BIO_puts(out, " and "))
137	0	return 0;
138	0	if (!ossl_asn1_time_print_ex(out, time->endTime, 0))
139	0	return 0;
140	2.71k	} else if (time->startTime != NULL) {
141	0	if (!BIO_puts(out, "Any time after "))
142	0	return 0;
143	0	if (!ossl_asn1_time_print_ex(out, time->startTime, 0))
144	0	return 0;
145	0	if (BIO_printf(out, "%.*s", time->startTime->length, time->startTime->data) <= 0)
146	0	return 0;
147	2.71k	} else if (time->endTime != NULL) {
148	0	if (!BIO_puts(out, "Any time until "))
149	0	return 0;
150	0	if (!ossl_asn1_time_print_ex(out, time->endTime, 0))
151	0	return 0;
152	2.71k	} else { /* Invalid: there must be SOME time specified. */
153	2.71k	return BIO_puts(out, "INVALID (EMPTY)");
154	2.71k	}
155	0	return 1;
156	2.71k	}
157
158		static int i2r_OSSL_DAY_TIME(X509V3_EXT_METHOD *method,
159		OSSL_DAY_TIME *dt,
160		BIO *out, int indent)
161	38	{
162	38	int64_t h = 0;
163	38	int64_t m = 0;
164	38	int64_t s = 0;
165
166	38	if (!dt->hour \|\| !ASN1_INTEGER_get_int64(&h, dt->hour))
167	38	return 0;
168	0	if (dt->minute && !ASN1_INTEGER_get_int64(&m, dt->minute))
169	0	return 0;
170	0	if (dt->minute && !ASN1_INTEGER_get_int64(&s, dt->second))
171	0	return 0;
172	0	return BIO_printf(out, "%02lld:%02lld:%02lld",
173	0	(long long int)h, (long long int)m, (long long int)s) > 0;
174	0	}
175
176		static int i2r_OSSL_DAY_TIME_BAND(X509V3_EXT_METHOD *method,
177		OSSL_DAY_TIME_BAND *band,
178		BIO *out, int indent)
179	914	{
180	914	if (band->startDayTime) {
181	19	if (!i2r_OSSL_DAY_TIME(method, band->startDayTime, out, indent))
182	19	return 0;
183	895	} else if (!BIO_puts(out, "00:00:00")) {
184	0	return 0;
185	0	}
186	895	if (!BIO_puts(out, " - "))
187	0	return 0;
188	895	if (band->endDayTime) {
189	19	if (!i2r_OSSL_DAY_TIME(method, band->endDayTime, out, indent))
190	19	return 0;
191	876	} else if (!BIO_puts(out, "23:59:59")) {
192	0	return 0;
193	0	}
194	876	return 1;
195	895	}
196
197		static int print_int_month(BIO *out, int64_t month)
198	252	{
199	252	switch (month) {
200	178	case (OSSL_TIME_SPEC_INT_MONTH_JAN):
201	178	return BIO_puts(out, "JAN");
202	0	case (OSSL_TIME_SPEC_INT_MONTH_FEB):
203	0	return BIO_puts(out, "FEB");
204	1	case (OSSL_TIME_SPEC_INT_MONTH_MAR):
205	1	return BIO_puts(out, "MAR");
206	5	case (OSSL_TIME_SPEC_INT_MONTH_APR):
207	5	return BIO_puts(out, "APR");
208	7	case (OSSL_TIME_SPEC_INT_MONTH_MAY):
209	7	return BIO_puts(out, "MAY");
210	4	case (OSSL_TIME_SPEC_INT_MONTH_JUN):
211	4	return BIO_puts(out, "JUN");
212	5	case (OSSL_TIME_SPEC_INT_MONTH_JUL):
213	5	return BIO_puts(out, "JUL");
214	2	case (OSSL_TIME_SPEC_INT_MONTH_AUG):
215	2	return BIO_puts(out, "AUG");
216	5	case (OSSL_TIME_SPEC_INT_MONTH_SEP):
217	5	return BIO_puts(out, "SEP");
218	11	case (OSSL_TIME_SPEC_INT_MONTH_OCT):
219	11	return BIO_puts(out, "OCT");
220	1	case (OSSL_TIME_SPEC_INT_MONTH_NOV):
221	1	return BIO_puts(out, "NOV");
222	4	case (OSSL_TIME_SPEC_INT_MONTH_DEC):
223	4	return BIO_puts(out, "DEC");
224	29	default:
225	29	return 0;
226	252	}
227	0	return 0;
228	252	}
229
230		static int print_bit_month(BIO out, ASN1_BIT_STRING bs)
231	310	{
232	310	int i = OSSL_TIME_SPEC_BIT_MONTH_JAN;
233	310	int j = 0;
234
235	4.03k	for (; i <= OSSL_TIME_SPEC_BIT_MONTH_DEC; i++) {
236	3.72k	if (ASN1_BIT_STRING_get_bit(bs, i)) {
237	1.86k	if (j > 0 && !BIO_puts(out, ", "))
238	0	return 0;
239	1.86k	j++;
240	1.86k	if (!BIO_puts(out, MONTH_NAMES[i]))
241	0	return 0;
242	1.86k	}
243	3.72k	}
244	310	return 1;
245	310	}
246
247		/*
248		* It might seem like you could just print the bits of the string numerically,
249		* but the fifth bit has the special meaning of "the final week" imputed to it
250		* by the text of ITU-T Recommendation X.520.
251		*/
252		static int print_bit_week(BIO out, ASN1_BIT_STRING bs)
253	187	{
254	187	int i = OSSL_TIME_SPEC_BIT_WEEKS_1;
255	187	int j = 0;
256
257	1.12k	for (; i <= OSSL_TIME_SPEC_BIT_WEEKS_5; i++) {
258	935	if (ASN1_BIT_STRING_get_bit(bs, i)) {
259	721	if (j > 0 && !BIO_puts(out, ", "))
260	0	return 0;
261	721	j++;
262	721	if (!BIO_puts(out, WEEK_NAMES[i]))
263	0	return 0;
264	721	}
265	935	}
266	187	return 1;
267	187	}
268
269		static int print_day_of_week(BIO out, ASN1_BIT_STRING bs)
270	706	{
271	706	int i = OSSL_TIME_SPEC_DAY_BIT_SUN;
272	706	int j = 0;
273
274	5.64k	for (; i <= OSSL_TIME_SPEC_DAY_BIT_SAT; i++) {
275	4.94k	if (ASN1_BIT_STRING_get_bit(bs, i)) {
276	3.30k	if (j > 0 && !BIO_puts(out, ", "))
277	0	return 0;
278	3.30k	j++;
279	3.30k	if (!BIO_puts(out, WEEKDAY_NAMES[i]))
280	0	return 0;
281	3.30k	}
282	4.94k	}
283	706	return 1;
284	706	}
285
286		static int print_int_day_of_week(BIO *out, int64_t dow)
287	0	{
288	0	switch (dow) {
289	0	case (OSSL_TIME_SPEC_DAY_INT_SUN):
290	0	return BIO_puts(out, "SUN");
291	0	case (OSSL_TIME_SPEC_DAY_INT_MON):
292	0	return BIO_puts(out, "MON");
293	0	case (OSSL_TIME_SPEC_DAY_INT_TUE):
294	0	return BIO_puts(out, "TUE");
295	0	case (OSSL_TIME_SPEC_DAY_INT_WED):
296	0	return BIO_puts(out, "WED");
297	0	case (OSSL_TIME_SPEC_DAY_INT_THU):
298	0	return BIO_puts(out, "THU");
299	0	case (OSSL_TIME_SPEC_DAY_INT_FRI):
300	0	return BIO_puts(out, "FRI");
301	0	case (OSSL_TIME_SPEC_DAY_INT_SAT):
302	0	return BIO_puts(out, "SAT");
303	0	default:
304	0	return 0;
305	0	}
306	0	return 0;
307	0	}
308
309		static int print_int_named_day(BIO *out, int64_t nd)
310	0	{
311	0	switch (nd) {
312	0	case (OSSL_NAMED_DAY_INT_SUN):
313	0	return BIO_puts(out, "SUN");
314	0	case (OSSL_NAMED_DAY_INT_MON):
315	0	return BIO_puts(out, "MON");
316	0	case (OSSL_NAMED_DAY_INT_TUE):
317	0	return BIO_puts(out, "TUE");
318	0	case (OSSL_NAMED_DAY_INT_WED):
319	0	return BIO_puts(out, "WED");
320	0	case (OSSL_NAMED_DAY_INT_THU):
321	0	return BIO_puts(out, "THU");
322	0	case (OSSL_NAMED_DAY_INT_FRI):
323	0	return BIO_puts(out, "FRI");
324	0	case (OSSL_NAMED_DAY_INT_SAT):
325	0	return BIO_puts(out, "SAT");
326	0	default:
327	0	return 0;
328	0	}
329	0	return 0;
330	0	}
331
332		static int print_bit_named_day(BIO out, ASN1_BIT_STRING bs)
333	608	{
334	608	return print_day_of_week(out, bs);
335	608	}
336
337		static int i2r_OSSL_PERIOD(X509V3_EXT_METHOD *method,
338		OSSL_TIME_PERIOD *p,
339		BIO *out, int indent)
340	14.5k	{
341	14.5k	int i;
342	14.5k	OSSL_DAY_TIME_BAND *band;
343	14.5k	ASN1_INTEGER *big_val;
344	14.5k	int64_t small_val;
345	14.5k	OSSL_NAMED_DAY *nd;
346
347	14.5k	if (BIO_printf(out, "%*sPeriod:\n", indent, "") <= 0)
348	0	return 0;
349	14.5k	if (p->timesOfDay) {
350	192	if (BIO_printf(out, "%*sDaytime bands:\n", indent + 4, "") <= 0)
351	0	return 0;
352	1.06k	for (i = 0; i < sk_OSSL_DAY_TIME_BAND_num(p->timesOfDay); i++) {
353	914	band = sk_OSSL_DAY_TIME_BAND_value(p->timesOfDay, i);
354	914	if (BIO_printf(out, "%*s", indent + 8, "") <= 0)
355	0	return 0;
356	914	if (!i2r_OSSL_DAY_TIME_BAND(method, band, out, indent + 8))
357	38	return 0;
358	876	if (!BIO_puts(out, "\n"))
359	0	return 0;
360	876	}
361	192	}
362	14.5k	if (p->days) {
363	863	if (p->days->type == OSSL_TIME_SPEC_DAY_TYPE_INT) {
364	143	if (p->weeks != NULL) {
365	1	if (BIO_printf(out, "%*sDays of the week: ", indent + 4, "") <= 0)
366	0	return 0;
367	142	} else if (p->months != NULL) {
368	10	if (BIO_printf(out, "%*sDays of the month: ", indent + 4, "") <= 0)
369	0	return 0;
370	132	} else if (p->years != NULL) {
371	0	if (BIO_printf(out, "%*sDays of the year: ", indent + 4, "") <= 0)
372	0	return 0;
373	0	}
374	720	} else {
375	720	if (BIO_printf(out, "%*sDays: ", indent + 4, "") <= 0)
376	0	return 0;
377	720	}
378
379	863	switch (p->days->type) {
380	143	case (OSSL_TIME_SPEC_DAY_TYPE_INT):
381	335	for (i = 0; i < sk_ASN1_INTEGER_num(p->days->choice.intDay); i++) {
382	258	big_val = sk_ASN1_INTEGER_value(p->days->choice.intDay, i);
383	258	if (!ASN1_INTEGER_get_int64(&small_val, big_val))
384	66	return 0;
385	192	if (i > 0 && !BIO_puts(out, ", "))
386	0	return 0;
387		/* If weeks is defined, then print day of week by name. */
388	192	if (p->weeks != NULL) {
389	0	if (!print_int_day_of_week(out, small_val))
390	0	return 0;
391	192	} else if (BIO_printf(out, "%lld", (long long int)small_val) <= 0) {
392	0	return 0;
393	0	}
394	192	}
395	77	break;
396	98	case (OSSL_TIME_SPEC_DAY_TYPE_BIT):
397	98	if (!print_day_of_week(out, p->days->choice.bitDay))
398	0	return 0;
399	98	break;
400	622	case (OSSL_TIME_SPEC_DAY_TYPE_DAY_OF):
401	622	switch (p->days->choice.dayOf->type) {
402	22	case (OSSL_TIME_SPEC_X_DAY_OF_FIRST):
403	22	if (!BIO_puts(out, "FIRST "))
404	0	return 0;
405	22	nd = p->days->choice.dayOf->choice.first;
406	22	break;
407	31	case (OSSL_TIME_SPEC_X_DAY_OF_SECOND):
408	31	if (!BIO_puts(out, "SECOND "))
409	0	return 0;
410	31	nd = p->days->choice.dayOf->choice.second;
411	31	break;
412	509	case (OSSL_TIME_SPEC_X_DAY_OF_THIRD):
413	509	if (!BIO_puts(out, "THIRD "))
414	0	return 0;
415	509	nd = p->days->choice.dayOf->choice.third;
416	509	break;
417	23	case (OSSL_TIME_SPEC_X_DAY_OF_FOURTH):
418	23	if (!BIO_puts(out, "FOURTH "))
419	0	return 0;
420	23	nd = p->days->choice.dayOf->choice.fourth;
421	23	break;
422	37	case (OSSL_TIME_SPEC_X_DAY_OF_FIFTH):
423	37	if (!BIO_puts(out, "FIFTH "))
424	0	return 0;
425	37	nd = p->days->choice.dayOf->choice.fifth;
426	37	break;
427	0	default:
428	0	return 0;
429	622	}
430	622	switch (nd->type) {
431	14	case (OSSL_NAMED_DAY_TYPE_INT):
432	14	if (!ASN1_INTEGER_get_int64(&small_val, nd->choice.intNamedDays))
433	14	return 0;
434	0	if (!print_int_named_day(out, small_val))
435	0	return 0;
436	0	break;
437	608	case (OSSL_NAMED_DAY_TYPE_BIT):
438	608	if (!print_bit_named_day(out, nd->choice.bitNamedDays))
439	0	return 0;
440	608	break;
441	608	default:
442	0	return 0;
443	622	}
444	608	break;
445	608	default:
446	0	return 0;
447	863	}
448	783	if (!BIO_puts(out, "\n"))
449	0	return 0;
450	783	}
451	14.4k	if (p->weeks) {
452	274	if (p->weeks->type == OSSL_TIME_SPEC_WEEKS_TYPE_INT) {
453	63	if (p->months != NULL) {
454	3	if (BIO_printf(out, "%*sWeeks of the month: ", indent + 4, "") <= 0)
455	0	return 0;
456	60	} else if (p->years != NULL) {
457	0	if (BIO_printf(out, "%*sWeeks of the year: ", indent + 4, "") <= 0)
458	0	return 0;
459	0	}
460	211	} else {
461	211	if (BIO_printf(out, "%*sWeeks: ", indent + 4, "") <= 0)
462	0	return 0;
463	211	}
464
465	274	switch (p->weeks->type) {
466	24	case (OSSL_TIME_SPEC_WEEKS_TYPE_ALL):
467	24	if (!BIO_puts(out, "ALL"))
468	0	return 0;
469	24	break;
470	63	case (OSSL_TIME_SPEC_WEEKS_TYPE_INT):
471	121	for (i = 0; i < sk_ASN1_INTEGER_num(p->weeks->choice.intWeek); i++) {
472	69	big_val = sk_ASN1_INTEGER_value(p->weeks->choice.intWeek, i);
473	69	if (!ASN1_INTEGER_get_int64(&small_val, big_val))
474	11	return 0;
475	58	if (i > 0 && !BIO_puts(out, ", "))
476	0	return 0;
477	58	if (!BIO_printf(out, "%lld", (long long int)small_val))
478	0	return 0;
479	58	}
480	52	break;
481	187	case (OSSL_TIME_SPEC_WEEKS_TYPE_BIT):
482	187	if (!print_bit_week(out, p->weeks->choice.bitWeek))
483	0	return 0;
484	187	break;
485	187	default:
486	0	return 0;
487	274	}
488	263	if (!BIO_puts(out, "\n"))
489	0	return 0;
490	263	}
491	14.4k	if (p->months) {
492	520	if (BIO_printf(out, "%*sMonths: ", indent + 4, "") <= 0)
493	0	return 0;
494	520	switch (p->months->type) {
495	71	case (OSSL_TIME_SPEC_MONTH_TYPE_ALL):
496	71	if (!BIO_puts(out, "ALL"))
497	0	return 0;
498	71	break;
499	139	case (OSSL_TIME_SPEC_MONTH_TYPE_INT):
500	362	for (i = 0; i < sk_ASN1_INTEGER_num(p->months->choice.intMonth); i++) {
501	262	big_val = sk_ASN1_INTEGER_value(p->months->choice.intMonth, i);
502	262	if (!ASN1_INTEGER_get_int64(&small_val, big_val))
503	10	return 0;
504	252	if (i > 0 && !BIO_puts(out, ", "))
505	0	return 0;
506	252	if (!print_int_month(out, small_val))
507	29	return 0;
508	252	}
509	100	break;
510	310	case (OSSL_TIME_SPEC_MONTH_TYPE_BIT):
511	310	if (!print_bit_month(out, p->months->choice.bitMonth))
512	0	return 0;
513	310	break;
514	310	default:
515	0	return 0;
516	520	}
517	481	if (!BIO_puts(out, "\n"))
518	0	return 0;
519	481	}
520	14.3k	if (p->years) {
521	109	if (BIO_printf(out, "%*sYears: ", indent + 4, "") <= 0)
522	0	return 0;
523	290	for (i = 0; i < sk_ASN1_INTEGER_num(p->years); i++) {
524	187	big_val = sk_ASN1_INTEGER_value(p->years, i);
525	187	if (!ASN1_INTEGER_get_int64(&small_val, big_val))
526	6	return 0;
527	181	if (i > 0 && !BIO_puts(out, ", "))
528	0	return 0;
529	181	if (BIO_printf(out, "%04lld", (long long int)small_val) <= 0)
530	0	return 0;
531	181	}
532	109	}
533	14.3k	return 1;
534	14.3k	}
535
536		static int i2r_OSSL_TIME_SPEC_TIME(X509V3_EXT_METHOD *method,
537		OSSL_TIME_SPEC_TIME *time,
538		BIO *out, int indent)
539	12.3k	{
540	12.3k	OSSL_TIME_PERIOD *tp;
541	12.3k	int i;
542
543	12.3k	switch (time->type) {
544	2.71k	case (OSSL_TIME_SPEC_TIME_TYPE_ABSOLUTE):
545	2.71k	if (BIO_printf(out, "%*sAbsolute: ", indent, "") <= 0)
546	0	return 0;
547	2.71k	if (i2r_OSSL_TIME_SPEC_ABSOLUTE(method, time->choice.absolute, out, indent + 4) <= 0)
548	0	return 0;
549	2.71k	return BIO_puts(out, "\n");
550	9.62k	case (OSSL_TIME_SPEC_TIME_TYPE_PERIODIC):
551	9.62k	if (BIO_printf(out, "%*sPeriodic:\n", indent, "") <= 0)
552	0	return 0;
553	24.0k	for (i = 0; i < sk_OSSL_TIME_PERIOD_num(time->choice.periodic); i++) {
554	14.5k	if (i > 0 && !BIO_puts(out, "\n"))
555	0	return 0;
556	14.5k	tp = sk_OSSL_TIME_PERIOD_value(time->choice.periodic, i);
557	14.5k	if (!i2r_OSSL_PERIOD(method, tp, out, indent + 4))
558	174	return 0;
559	14.5k	}
560	9.44k	return BIO_puts(out, "\n");
561	0	default:
562	0	return 0;
563	12.3k	}
564	0	return 0;
565	12.3k	}
566
567		static int i2r_OSSL_TIME_SPEC(X509V3_EXT_METHOD *method,
568		OSSL_TIME_SPEC *time,
569		BIO *out, int indent)
570	12.3k	{
571	12.3k	int64_t tz;
572
573	12.3k	if (time->timeZone) {
574	1.44k	if (ASN1_INTEGER_get_int64(&tz, time->timeZone) != 1)
575	26	return 0;
576	1.42k	if (BIO_printf(out, "%*sTimezone: UTC%+03lld:00\n", indent, "", (long long int)tz) <= 0)
577	0	return 0;
578	1.42k	}
579	12.3k	if (time->notThisTime > 0) {
580	379	if (BIO_printf(out, "%*sNOT this time:\n", indent, "") <= 0)
581	0	return 0;
582	11.9k	} else if (BIO_printf(out, "%*sTime:\n", indent, "") <= 0) {
583	0	return 0;
584	0	}
585	12.3k	return i2r_OSSL_TIME_SPEC_TIME(method, time->time, out, indent + 4);
586	12.3k	}
587
588		const X509V3_EXT_METHOD ossl_v3_time_specification = {
589		NID_time_specification, X509V3_EXT_MULTILINE,
590		ASN1_ITEM_ref(OSSL_TIME_SPEC),
591		0, 0, 0, 0,
592		0, 0,
593		0,
594		0,
595		(X509V3_EXT_I2R)i2r_OSSL_TIME_SPEC,
596		NULL,
597		NULL
598		};