/* $OpenBSD: a_time_tm.c,v 1.24 2022/07/04 14:39:43 tb Exp $ */
/*
 * Copyright (c) 2015 Bob Beck <beck@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

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

#include <openssl/asn1t.h>
#include <openssl/err.h>

#include "bytestring.h"
#include "o_time.h"

#define RFC5280 0
#define GENTIME_LENGTH 15
#define UTCTIME_LENGTH 13

int
ASN1_time_tm_cmp(struct tm *tm1, struct tm *tm2)
{
        if (tm1->tm_year < tm2->tm_year)
                return (-1);
        if (tm1->tm_year > tm2->tm_year)
                return (1);
        if (tm1->tm_mon < tm2->tm_mon)
                return (-1);
        if (tm1->tm_mon > tm2->tm_mon)
                return (1);
        if (tm1->tm_mday < tm2->tm_mday)
                return (-1);
        if (tm1->tm_mday > tm2->tm_mday)
                return (1);
        if (tm1->tm_hour < tm2->tm_hour)
                return (-1);
        if (tm1->tm_hour > tm2->tm_hour)
                return (1);
        if (tm1->tm_min < tm2->tm_min)
                return (-1);
        if (tm1->tm_min > tm2->tm_min)
                return (1);
        if (tm1->tm_sec < tm2->tm_sec)
                return (-1);
        if (tm1->tm_sec > tm2->tm_sec)
                return (1);
        return 0;
}

int
ASN1_time_tm_clamp_notafter(struct tm *tm)
{
#ifdef SMALL_TIME_T
        struct tm broken_os_epoch_tm;
        time_t broken_os_epoch_time = INT_MAX;

        if (gmtime_r(&broken_os_epoch_time, &broken_os_epoch_tm) == NULL)
                return 0;

        if (ASN1_time_tm_cmp(tm, &broken_os_epoch_tm) == 1)
                memcpy(tm, &broken_os_epoch_tm, sizeof(*tm));
#endif
        return 1;
}

/* Convert time to GeneralizedTime, X.690, 11.7. */
ASN1_TIME *
tm_to_gentime(struct tm *tm, ASN1_TIME *atime)
{
        char *time_str = NULL;
        int year;

        year = tm->tm_year + 1900;
        if (year < 0 || year > 9999) {
                ASN1error(ASN1_R_ILLEGAL_TIME_VALUE);
                goto err;
        }

        if (asprintf(&time_str, "%04u%02u%02u%02u%02u%02uZ", year,
            tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
            tm->tm_sec) == -1) {
                time_str = NULL;
                ASN1error(ERR_R_MALLOC_FAILURE);
                goto err;
        }

        if (atime == NULL)
                atime = ASN1_TIME_new();
        if (atime == NULL) {
                ASN1error(ERR_R_MALLOC_FAILURE);
                goto err;
        }

        free(atime->data);
        atime->data = time_str;
        atime->length = GENTIME_LENGTH;
        atime->type = V_ASN1_GENERALIZEDTIME;

        return (atime);

 err:
        free(time_str);

        return (NULL);
}

/* Convert time to UTCTime, X.690, 11.8. */
ASN1_TIME *
tm_to_utctime(struct tm *tm, ASN1_TIME *atime)
{
        char *time_str = NULL;

        if (tm->tm_year >= 150 || tm->tm_year < 50) {
                ASN1error(ASN1_R_ILLEGAL_TIME_VALUE);
                goto err;
        }

        if (asprintf(&time_str, "%02u%02u%02u%02u%02u%02uZ",
            tm->tm_year % 100,  tm->tm_mon + 1, tm->tm_mday,
            tm->tm_hour, tm->tm_min, tm->tm_sec) == -1) {
                time_str = NULL;
                ASN1error(ERR_R_MALLOC_FAILURE);
                goto err;
        }

        if (atime == NULL)
                atime = ASN1_TIME_new();
        if (atime == NULL) {
                ASN1error(ERR_R_MALLOC_FAILURE);
                goto err;
        }

        free(atime->data);
        atime->data = time_str;
        atime->length = UTCTIME_LENGTH;
        atime->type = V_ASN1_UTCTIME;

        return (atime);

 err:
        free(time_str);

        return (NULL);
}

ASN1_TIME *
tm_to_rfc5280_time(struct tm *tm, ASN1_TIME *atime)
{
        int year;

        year = tm->tm_year + 1900;
        if (year < 1950 || year > 9999) {
                ASN1error(ASN1_R_ILLEGAL_TIME_VALUE);
                return (NULL);
        }

        if (year < 2050)
                return (tm_to_utctime(tm, atime));

        return (tm_to_gentime(tm, atime));
}


static int
cbs_get_two_digit_value(CBS *cbs, int *out)
{
        uint8_t first_digit, second_digit;

        if (!CBS_get_u8(cbs, &first_digit))
                return 0;
        if (!isdigit(first_digit))
                return 0;
        if (!CBS_get_u8(cbs, &second_digit))
                return 0;
        if (!isdigit(second_digit))
                return 0;

        *out = (first_digit - '0') * 10 + (second_digit - '0');

        return 1;
}

static int
is_valid_day(int year, int month, int day)
{
        if (day < 1)
                return 0;
        switch (month) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
                return day <= 31;
        case 4:
        case 6:
        case 9:
        case 11:
                return day <= 30;
        case 2:
                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
                        return day <= 29;
                 else
                        return day <= 28;
        default:
                return 0;
        }
}

/*
 * asn1_time_parse_cbs returns one if |cbs| is a valid DER-encoded, ASN.1 Time
 * body within the limitations imposed by RFC 5280, or zero otherwise. The time
 * is expected to parse as a Generalized Time if is_gentime is true, and as a
 * UTC Time otherwise. If |out_tm| is non-NULL, |*out_tm| will be zeroed, and
 * then set to the corresponding time in UTC. This function does not compute
 * |out_tm->tm_wday| or |out_tm->tm_yday|. |cbs| is not consumed.
 */
int
asn1_time_parse_cbs(const CBS *cbs, int is_gentime, struct tm *out_tm)
{
        int year, month, day, hour, min, sec, val;
        CBS copy;
        uint8_t tz;

        CBS_dup(cbs, &copy);

        if (is_gentime) {
                if (!cbs_get_two_digit_value(&copy, &val))
                        return 0;
                year = val * 100;
                if (!cbs_get_two_digit_value(&copy, &val))
                        return 0;
                year += val;
        } else {
                year = 1900;
                if (!cbs_get_two_digit_value(&copy, &val))
                        return 0;
                year += val;
                if (year < 1950)
                        year += 100;
                if (year >= 2050)
                        return 0;  /* A Generalized time must be used. */
        }

        if (!cbs_get_two_digit_value(&copy, &month))
                return 0;
        if (month < 1 || month > 12)
                return 0; /* Reject invalid months. */

        if (!cbs_get_two_digit_value(&copy, &day))
                return 0;
        if (!is_valid_day(year, month, day))
                return 0; /* Reject invalid days. */

        if (!cbs_get_two_digit_value(&copy, &hour))
                return 0;
        if (hour > 23)
                return 0; /* Reject invalid hours. */

        if (!cbs_get_two_digit_value(&copy, &min))
                return 0;
        if (min > 59)
                return 0; /* Reject invalid minutes. */

        if (!cbs_get_two_digit_value(&copy, &sec))
                return 0;
        if (sec > 59)
                return 0; /* Reject invalid seconds. Leap seconds are invalid. */

        if (!CBS_get_u8(&copy, &tz))
                return 0;
        if (tz != 'Z')
                return 0; /* Reject anything but Z on the end. */

        if (CBS_len(&copy) != 0)
                return 0;  /* Reject invalid lengths. */

        if (out_tm != NULL) {
                memset(out_tm, 0, sizeof(*out_tm));
                /* Fill in the tm fields corresponding to what we validated. */
                out_tm->tm_year = year - 1900;
                out_tm->tm_mon = month - 1;
                out_tm->tm_mday = day;
                out_tm->tm_hour = hour;
                out_tm->tm_min = min;
                out_tm->tm_sec = sec;
        }

        return 1;
}

/*
 * Parse an RFC 5280 format ASN.1 time string.
 *
 * mode must be:
 * 0 if we expect to parse a time as specified in RFC 5280 for an X509 object.
 * V_ASN1_UTCTIME if we wish to parse an RFC5280 format UTC time.
 * V_ASN1_GENERALIZEDTIME if we wish to parse an RFC5280 format Generalized time.
 *
 * Returns:
 * -1 if the string was invalid.
 * V_ASN1_UTCTIME if the string validated as a UTC time string.
 * V_ASN1_GENERALIZEDTIME if the string validated as a Generalized time string.
 *
 * Fills in *tm with the corresponding time if tm is non NULL.
 */
int
ASN1_time_parse(const char *bytes, size_t len, struct tm *tm, int mode)
{
        struct tm tml, *tmp = tm ? tm : &tml;
        int type = 0;
        CBS cbs;

        if (bytes == NULL)
                return (-1);

        CBS_init(&cbs, bytes, len);

        if (CBS_len(&cbs) == UTCTIME_LENGTH)
                type = V_ASN1_UTCTIME;
        if (CBS_len(&cbs) == GENTIME_LENGTH)
                type = V_ASN1_GENERALIZEDTIME;
        if (asn1_time_parse_cbs(&cbs, type == V_ASN1_GENERALIZEDTIME, tmp)) {
                if (mode != 0 && mode != type)
                        return -1;
                return type;
        }

        return -1;
}

/*
 * ASN1_TIME generic functions.
 */

static int
ASN1_TIME_set_string_internal(ASN1_TIME *s, const char *str, int mode)
{
        int type;
        char *tmp;

        if ((type = ASN1_time_parse(str, strlen(str), NULL, mode)) == -1)
                return (0);
        if (mode != 0 && mode != type)
                return (0);

        if (s == NULL)
                return (1);

        if ((tmp = strdup(str)) == NULL)
                return (0);
        free(s->data);
        s->data = tmp;
        s->length = strlen(tmp);
        s->type = type;

        return (1);
}

static ASN1_TIME *
ASN1_TIME_adj_internal(ASN1_TIME *s, time_t t, int offset_day, long offset_sec,
    int mode)
{
        struct tm tm;

        if (gmtime_r(&t, &tm) == NULL)
                return (NULL);

        if (offset_day != 0 || offset_sec != 0) {
                if (!OPENSSL_gmtime_adj(&tm, offset_day, offset_sec))
                        return (NULL);
        }

        switch (mode) {
        case V_ASN1_UTCTIME:
                return (tm_to_utctime(&tm, s));
        case V_ASN1_GENERALIZEDTIME:
                return (tm_to_gentime(&tm, s));
        case RFC5280:
                return (tm_to_rfc5280_time(&tm, s));
        default:
                return (NULL);
        }
}

ASN1_TIME *
ASN1_TIME_set(ASN1_TIME *s, time_t t)
{
        return (ASN1_TIME_adj(s, t, 0, 0));
}

ASN1_TIME *
ASN1_TIME_set_tm(ASN1_TIME *s, struct tm *tm)
{
        time_t t;

        if ((t = timegm(tm)) == -1)
                return NULL;
        return (ASN1_TIME_adj(s, t, 0, 0));
}

ASN1_TIME *
ASN1_TIME_adj(ASN1_TIME *s, time_t t, int offset_day, long offset_sec)
{
        return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec, RFC5280));
}

int
ASN1_TIME_check(const ASN1_TIME *t)
{
        if (t->type != V_ASN1_GENERALIZEDTIME && t->type != V_ASN1_UTCTIME)
                return (0);
        return (t->type == ASN1_time_parse(t->data, t->length, NULL, t->type));
}

ASN1_GENERALIZEDTIME *
ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, ASN1_GENERALIZEDTIME **out)
{
        ASN1_GENERALIZEDTIME *agt = NULL;
        struct tm tm;

        if (t->type != V_ASN1_GENERALIZEDTIME && t->type != V_ASN1_UTCTIME)
                return (NULL);

        if (t->type != ASN1_time_parse(t->data, t->length, &tm, t->type))
                return (NULL);

        if (out != NULL)
                agt = *out;
        if ((agt = tm_to_gentime(&tm, agt)) == NULL)
                return (NULL);
        if (out != NULL)
                *out = agt;

        return (agt);
}

int
ASN1_TIME_set_string(ASN1_TIME *s, const char *str)
{
        return (ASN1_TIME_set_string_internal(s, str, 0));
}

static int
ASN1_TIME_cmp_time_t_internal(const ASN1_TIME *s, time_t t2, int mode)
{
        struct tm tm1, tm2;

        /*
         * This function has never handled failure conditions properly
         * The OpenSSL version used to simply follow NULL pointers on failure.
         * BoringSSL and OpenSSL now make it return -2 on failure.
         *
         * The danger is that users of this function will not differentiate the
         * -2 failure case from s < t2. Callers must be careful. Sadly this is
         * one of those pervasive things from OpenSSL we must continue with.
         */

        if (ASN1_time_parse(s->data, s->length, &tm1, mode) == -1)
                return -2;

        if (gmtime_r(&t2, &tm2) == NULL)
                return -2;

        return ASN1_time_tm_cmp(&tm1, &tm2);
}

int
ASN1_TIME_compare(const ASN1_TIME *t1, const ASN1_TIME *t2)
{
        struct tm tm1, tm2;

        if (t1->type != V_ASN1_UTCTIME && t1->type != V_ASN1_GENERALIZEDTIME)
                return -2;

        if (t2->type != V_ASN1_UTCTIME && t2->type != V_ASN1_GENERALIZEDTIME)
                return -2;

        if (ASN1_time_parse(t1->data, t1->length, &tm1, t1->type) == -1)
                return -2;

        if (ASN1_time_parse(t1->data, t2->length, &tm2, t2->type) == -1)
                return -2;

        return ASN1_time_tm_cmp(&tm1, &tm2);
}

int
ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t)
{
        if (s->type == V_ASN1_UTCTIME)
                return ASN1_TIME_cmp_time_t_internal(s, t, V_ASN1_UTCTIME);
        if (s->type == V_ASN1_GENERALIZEDTIME)
                return ASN1_TIME_cmp_time_t_internal(s, t,
                    V_ASN1_GENERALIZEDTIME);
        return -2;
}

/*
 * ASN1_UTCTIME wrappers
 */

int
ASN1_UTCTIME_check(const ASN1_UTCTIME *d)
{
        if (d->type != V_ASN1_UTCTIME)
                return (0);
        return (d->type == ASN1_time_parse(d->data, d->length, NULL, d->type));
}

int
ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str)
{
        if (s != NULL && s->type != V_ASN1_UTCTIME)
                return (0);
        return (ASN1_TIME_set_string_internal(s, str, V_ASN1_UTCTIME));
}

ASN1_UTCTIME *
ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
{
        return (ASN1_UTCTIME_adj(s, t, 0, 0));
}

ASN1_UTCTIME *
ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, int offset_day, long offset_sec)
{
        return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec,
            V_ASN1_UTCTIME));
}

int
ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t)
{
        if (s->type == V_ASN1_UTCTIME)
                return ASN1_TIME_cmp_time_t_internal(s, t, V_ASN1_UTCTIME);
        return -2;
}

/*
 * ASN1_GENERALIZEDTIME wrappers
 */

int
ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
{
        if (d->type != V_ASN1_GENERALIZEDTIME)
                return (0);
        return (d->type == ASN1_time_parse(d->data, d->length, NULL, d->type));
}

int
ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)
{
        if (s != NULL && s->type != V_ASN1_GENERALIZEDTIME)
                return (0);
        return (ASN1_TIME_set_string_internal(s, str, V_ASN1_GENERALIZEDTIME));
}

ASN1_GENERALIZEDTIME *
ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, time_t t)
{
        return (ASN1_GENERALIZEDTIME_adj(s, t, 0, 0));
}

ASN1_GENERALIZEDTIME *
ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, time_t t, int offset_day,
    long offset_sec)
{
        return (ASN1_TIME_adj_internal(s, t, offset_day, offset_sec,
            V_ASN1_GENERALIZEDTIME));
}

int
ASN1_TIME_normalize(ASN1_TIME *t)
{
        struct tm tm;

        if (!ASN1_TIME_to_tm(t, &tm))
                return 0;
        return tm_to_rfc5280_time(&tm, t) != NULL;
}

int
ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str)
{
        return ASN1_TIME_set_string_internal(s, str, RFC5280);
}