Refactor ASN1_Time and tweak rules on ASN.1 date formats accepted

RFC 5280 is silent on the issue of leap seconds, but both Go and OpenSSL reject them
entirely. Given that, it seems safe to assume they are not used anywhere in practice.
Previously leap seconds were accepted for GeneralizedTime.

Previously years past 3100 were rejected. However this prevented parsing certificates
which use RFC 5280's "no well-defined expiration date" of 99991231235959Z. Extend this
so that years up to 9999 are accepted.

Skip gmtime thread-safety gymnastics and use Howard Hinnant's civil_from_days algorithm.

Change types in ASN1_Time and calendar_point to not waste storage.

Author: randombit

src/cli/roughtime.cpp

@@ -16,11 +16,22 @@
 
    #include <fstream>
    #include <iomanip>
+   #include <sstream>
 
 namespace Botan_CLI {
 
 namespace {
 
+// Format the time point as YYYY-MM-DDTHH:MM:SS in UTC
+std::string format_utc_datetime(const std::chrono::system_clock::time_point& tp) {
+   const Botan::calendar_point c(tp);
+   std::ostringstream out;
+   out << std::setfill('0') << std::setw(4) << c.year() << "-" << std::setw(2) << c.month() << "-" << std::setw(2)
+       << c.day() << "T" << std::setw(2) << c.hour() << ":" << std::setw(2) << c.minutes() << ":" << std::setw(2)
+       << c.seconds();
+   return out.str();
+}
+
 class RoughtimeCheck final : public Command {
    public:
       RoughtimeCheck() : Command("roughtime_check --raw-time chain-file") {}
@@ -38,7 +49,7 @@ class RoughtimeCheck final : public Command {
                output()
                   << Botan::Roughtime::Response::sys_microseconds64(response.utc_midpoint()).time_since_epoch().count();
             } else {
-               output() << Botan::calendar_point(response.utc_midpoint()).to_string();
+               output() << format_utc_datetime(response.utc_midpoint());
             }
             output() << " (+-" << Botan::Roughtime::Response::microseconds32(response.utc_radius()).count() << "us)\n";
          }
@@ -100,7 +111,7 @@ class Roughtime final : public Command {
                << "UTC "
                << Botan::Roughtime::Response::sys_microseconds64(response.utc_midpoint()).time_since_epoch().count();
          } else {
-            output() << "UTC " << Botan::calendar_point(response.utc_midpoint()).to_string();
+            output() << "UTC " << format_utc_datetime(response.utc_midpoint());
          }
          output() << " (+-" << Botan::Roughtime::Response::microseconds32(response.utc_radius()).count() << "us)";
          if(!response.validate(public_key)) {

src/lib/asn1/asn1_time.cpp

@@ -14,37 +14,146 @@
 #include <botan/internal/calendar.h>
 #include <botan/internal/fmt.h>
 #include <botan/internal/parsing.h>
-#include <iomanip>
+#include <sstream>
 
 namespace Botan {
 
+namespace {
+
+// Format an integer as exactly `digits` zero-padded decimal digits
+std::string zero_pad(uint32_t value, size_t digits) {
+   std::string s = std::to_string(value);
+   BOTAN_ASSERT_NOMSG(s.size() <= digits);
+   const size_t padding = digits - s.size();
+   if(padding == 0) {
+      return s;
+   } else {
+      return std::string(padding, '0') + s;
+   }
+}
+
+}  // namespace
+
 ASN1_Time ASN1_Time::from_seconds_since_epoch(uint64_t time_since_epoch) {
-   return ASN1_Time(std::chrono::system_clock::time_point(std::chrono::seconds(time_since_epoch)));
+   return ASN1_Time::from_time_point(std::chrono::system_clock::time_point(std::chrono::seconds(time_since_epoch)));
+}
+
+ASN1_Time::ASN1_Time(
+   uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, ASN1_Type tag) :
+      m_year(year), m_month(month), m_day(day), m_hour(hour), m_minute(minute), m_second(second), m_tag(tag) {
+   if(tag != ASN1_Type::UtcTime && tag != ASN1_Type::GeneralizedTime) {
+      throw Invalid_Argument("ASN1_Time tag must be UtcTime or GeneralizedTime");
+   }
+
+   /*
+   * RFC 5280 Section 4.1.2.5:
+   *    To indicate that a certificate has no well-defined expiration date,
+   *    the notAfter SHOULD be assigned the GeneralizedTime value of
+   *    99991231235959Z.
+   */
+   const uint16_t min_year = 1950;
+   const uint16_t max_year = (tag == ASN1_Type::UtcTime) ? 2049 : 9999;
+
+   if(m_year < min_year || m_year > max_year) {
+      throw Invalid_Argument(fmt("ASN1_Time year {} is out of range ({} to {})", m_year, min_year, max_year));
+   }
+
+   if(m_month < 1 || m_month > 12) {
+      throw Invalid_Argument(fmt("ASN1_Time month {} is out of range", static_cast<uint32_t>(m_month)));
+   }
+
+   constexpr uint8_t days_in_month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+   const bool is_leap_year = (m_year % 4 == 0) && (m_year % 100 != 0 || m_year % 400 == 0);
+   const uint8_t max_day = (m_month == 2 && is_leap_year) ? 29 : days_in_month[m_month - 1];
+
+   if(m_day < 1 || m_day > max_day) {
+      throw Invalid_Argument(fmt("ASN1_Time day {} is out of range for month {}",
+                                 static_cast<uint32_t>(m_day),
+                                 static_cast<uint32_t>(m_month)));
+   }
+
+   if(m_hour > 23) {
+      throw Invalid_Argument(fmt("ASN1_Time hour {} is out of range", static_cast<uint32_t>(m_hour)));
+   }
+
+   if(m_minute > 59) {
+      throw Invalid_Argument(fmt("ASN1_Time minute {} is out of range", static_cast<uint32_t>(m_minute)));
+   }
+
+   /*
+   * RFC 5280 is silent on the issue of leap seconds in certificate fields, but both
+   * OpenSSL and Go reject which suggests they are rarely if ever used in practice.
+   */
+   if(m_second > 59) {
+      throw Invalid_Argument(fmt("ASN1_Time second {} is out of range", static_cast<uint32_t>(m_second)));
+   }
 }
 
-ASN1_Time::ASN1_Time(const std::chrono::system_clock::time_point& time) {
+//static
+ASN1_Time ASN1_Time::from_time_point(const std::chrono::system_clock::time_point& time) {
    const calendar_point cal(time);
 
-   m_year = cal.year();
-   m_month = cal.month();
-   m_day = cal.day();
-   m_hour = cal.hour();
-   m_minute = cal.minutes();
-   m_second = cal.seconds();
+   const ASN1_Type tag = (cal.year() >= 2050) ? ASN1_Type::GeneralizedTime : ASN1_Type::UtcTime;
 
-   // NOLINTNEXTLINE(*-prefer-member-initializer)
-   m_tag = (m_year >= 2050) ? ASN1_Type::GeneralizedTime : ASN1_Type::UtcTime;
+   return ASN1_Time(static_cast<uint16_t>(cal.year()),
+                    static_cast<uint8_t>(cal.month()),
+                    static_cast<uint8_t>(cal.day()),
+                    static_cast<uint8_t>(cal.hour()),
+                    static_cast<uint8_t>(cal.minutes()),
+                    static_cast<uint8_t>(cal.seconds()),
+                    tag);
 }
 
-ASN1_Time::ASN1_Time(std::string_view t_spec, ASN1_Type tag) {
-   set_to(t_spec, tag);
+//static
+ASN1_Time ASN1_Time::from_string(std::string_view t_spec, ASN1_Type tag) {
+   BOTAN_ARG_CHECK(tag == ASN1_Type::UtcTime || tag == ASN1_Type::GeneralizedTime, "Invalid tag for ASN1_Time");
+
+   if(tag == ASN1_Type::GeneralizedTime) {
+      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
+   } else {
+      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
+   }
+
+   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
+
+   const size_t field_len = 2;
+   const size_t year_len = (tag == ASN1_Type::UtcTime) ? 2 : 4;
+
+   const size_t year_start = 0;
+   const size_t month_start = year_start + year_len;
+   const size_t day_start = month_start + field_len;
+   const size_t hour_start = day_start + field_len;
+   const size_t min_start = hour_start + field_len;
+   const size_t sec_start = min_start + field_len;
+
+   uint32_t year = to_u32bit(t_spec.substr(year_start, year_len));
+   const uint32_t month = to_u32bit(t_spec.substr(month_start, field_len));
+   const uint32_t day = to_u32bit(t_spec.substr(day_start, field_len));
+   const uint32_t hour = to_u32bit(t_spec.substr(hour_start, field_len));
+   const uint32_t minute = to_u32bit(t_spec.substr(min_start, field_len));
+   const uint32_t second = to_u32bit(t_spec.substr(sec_start, field_len));
+
+   if(tag == ASN1_Type::UtcTime) {
+      // Interpret the two digit year by the 1950/2050 split (RFC 5280 Section 4.1.2.5.1)
+      year += (year >= 50) ? 1900 : 2000;
+   }
+
+   return ASN1_Time(static_cast<uint16_t>(year),
+                    static_cast<uint8_t>(month),
+                    static_cast<uint8_t>(day),
+                    static_cast<uint8_t>(hour),
+                    static_cast<uint8_t>(minute),
+                    static_cast<uint8_t>(second),
+                    tag);
 }
 
-ASN1_Time::ASN1_Time(std::string_view t_spec) {
+//static
+ASN1_Time ASN1_Time::from_string(std::string_view t_spec) {
    if(t_spec.size() == 13) {
-      set_to(t_spec, ASN1_Type::UtcTime);
+      return ASN1_Time::from_string(t_spec, ASN1_Type::UtcTime);
    } else if(t_spec.size() == 15) {
-      set_to(t_spec, ASN1_Type::GeneralizedTime);
+      return ASN1_Time::from_string(t_spec, ASN1_Type::GeneralizedTime);
    } else {
       throw Invalid_Argument("Time string could not be parsed as GeneralizedTime or UTCTime.");
    }
@@ -67,7 +176,9 @@ void ASN1_Time::decode_from(BER_Decoder& source) {
    }
 
    try {
-      set_to(ASN1::to_string(ber_time), ber_time.type());
+      // Assigning only after a successful parse means that a decoding error
+      // cannot leave this object in a partially written state
+      *this = ASN1_Time::from_string(ASN1::to_string(ber_time), ber_time.type());
    } catch(Invalid_Argument& e) {
       throw Decoding_Error(fmt("Invalid ASN1_Time encoding: {}", e.what()));
    }
@@ -78,46 +189,45 @@ std::string ASN1_Time::to_string() const {
       throw Invalid_State("ASN1_Time::to_string: No time set");
    }
 
-   uint32_t full_year = m_year;
+   BOTAN_ASSERT_NOMSG(m_year <= 9999);
+
+   std::ostringstream out;
 
+   // UTCTime uses a 2 digit year, GeneralizedTime a 4 digit year
    if(m_tag == ASN1_Type::UtcTime) {
       if(m_year < 1950 || m_year >= 2050) {
          throw Encoding_Error(fmt("ASN_Time: The time {} cannot be encoded as UTCTime", readable_string()));
       }
 
-      full_year = (m_year >= 2000) ? (m_year - 2000) : (m_year - 1900);
+      out << (zero_pad((m_year >= 2000) ? (m_year - 2000) : (m_year - 1900), 2));
+   } else {
+      out << zero_pad(m_year, 4);
    }
 
-   const uint64_t year_factor = 10000000000;
-   const uint64_t mon_factor = 100000000;
-   const uint64_t day_factor = 1000000;
-   const uint64_t hour_factor = 10000;
-   const uint64_t min_factor = 100;
-
-   const uint64_t int_repr = year_factor * full_year + mon_factor * m_month + day_factor * m_day +
-                             hour_factor * m_hour + min_factor * m_minute + m_second;
-
-   const std::string repr = std::to_string(int_repr) + "Z";
+   // clang-format off
+   out << zero_pad(m_month, 2)
+       << zero_pad(m_day, 2)
+       << zero_pad(m_hour, 2)
+       << zero_pad(m_minute, 2)
+       << zero_pad(m_second, 2) << "Z";
+   // clang-format on
 
-   const size_t desired_size = (m_tag == ASN1_Type::UtcTime) ? 13 : 15;
-
-   const std::string zero_padding(desired_size - repr.size(), '0');
-
-   return zero_padding + repr;
+   return out.str();
 }
 
 std::string ASN1_Time::readable_string() const {
    if(!time_is_set()) {
       throw Invalid_State("ASN1_Time::readable_string: No time set");
    }
 
-   // desired format: "%04d/%02d/%02d %02d:%02d:%02d UTC"
-   std::stringstream output;
-   output << std::setfill('0') << std::setw(4) << m_year << "/" << std::setw(2) << m_month << "/" << std::setw(2)
-          << m_day << " " << std::setw(2) << m_hour << ":" << std::setw(2) << m_minute << ":" << std::setw(2)
-          << m_second << " UTC";
+   // desired format: "YYYY/MM/DD HH:MM:SS UTC"
+
+   std::ostringstream out;
 
-   return output.str();
+   out << zero_pad(m_year, 4) << "/" << zero_pad(m_month, 2) << "/" << zero_pad(m_day, 2) << " ";
+   out << zero_pad(m_hour, 2) << ":" << zero_pad(m_minute, 2) << ":" << zero_pad(m_second, 2) << " UTC";
+
+   return out.str();
 }
 
 bool ASN1_Time::time_is_set() const {
@@ -173,97 +283,6 @@ int32_t ASN1_Time::cmp(const ASN1_Time& other) const {
    return SAME_TIME;
 }
 
-void ASN1_Time::set_to(std::string_view t_spec, ASN1_Type spec_tag) {
-   BOTAN_ARG_CHECK(spec_tag == ASN1_Type::UtcTime || spec_tag == ASN1_Type::GeneralizedTime,
-                   "Invalid tag for ASN1_Time");
-
-   if(spec_tag == ASN1_Type::GeneralizedTime) {
-      BOTAN_ARG_CHECK(t_spec.size() == 15, "Invalid GeneralizedTime input string");
-   } else if(spec_tag == ASN1_Type::UtcTime) {
-      BOTAN_ARG_CHECK(t_spec.size() == 13, "Invalid UTCTime input string");
-   }
-
-   BOTAN_ARG_CHECK(t_spec.back() == 'Z', "Botan does not support ASN1 times with timezones other than Z");
-
-   const size_t field_len = 2;
-
-   const size_t year_start = 0;
-   const size_t year_len = (spec_tag == ASN1_Type::UtcTime) ? 2 : 4;
-   const size_t month_start = year_start + year_len;
-   const size_t day_start = month_start + field_len;
-   const size_t hour_start = day_start + field_len;
-   const size_t min_start = hour_start + field_len;
-   const size_t sec_start = min_start + field_len;
-
-   m_year = to_u32bit(t_spec.substr(year_start, year_len));
-   m_month = to_u32bit(t_spec.substr(month_start, field_len));
-   m_day = to_u32bit(t_spec.substr(day_start, field_len));
-   m_hour = to_u32bit(t_spec.substr(hour_start, field_len));
-   m_minute = to_u32bit(t_spec.substr(min_start, field_len));
-   m_second = to_u32bit(t_spec.substr(sec_start, field_len));
-   m_tag = spec_tag;
-
-   if(spec_tag == ASN1_Type::UtcTime) {
-      if(m_year >= 50) {
-         m_year += 1900;
-      } else {
-         m_year += 2000;
-      }
-   }
-
-   if(!passes_sanity_check()) {
-      throw Invalid_Argument(fmt("ASN1_Time string '{}' does not seem to be valid", t_spec));
-   }
-}
-
-/*
-* Do a general sanity check on the time
-*/
-bool ASN1_Time::passes_sanity_check() const {
-   // AppVeyor's trust store includes a cert with expiration date in 3016 ...
-   if(m_year < 1950 || m_year > 3100) {
-      return false;
-   }
-   if(m_month == 0 || m_month > 12) {
-      return false;
-   }
-
-   const uint32_t days_in_month[12] = {31, 28 + 1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-
-   if(m_day == 0 || m_day > days_in_month[m_month - 1]) {
-      return false;
-   }
-
-   if(m_month == 2 && m_day == 29) {
-      if(m_year % 4 != 0) {
-         return false;  // not a leap year
-      }
-
-      if(m_year % 100 == 0 && m_year % 400 != 0) {
-         return false;
-      }
-   }
-
-   if(m_hour >= 24 || m_minute >= 60 || m_second > 60) {
-      return false;
-   }
-
-   if(m_tag == ASN1_Type::UtcTime) {
-      /*
-      UTCTime limits the value of components such that leap seconds
-      are not covered. See "UNIVERSAL 23" in "Information technology
-      Abstract Syntax Notation One (ASN.1): Specification of basic notation"
-
-      http://www.itu.int/ITU-T/studygroups/com17/languages/
-      */
-      if(m_second > 59) {
-         return false;
-      }
-   }
-
-   return true;
-}
-
 std::chrono::system_clock::time_point ASN1_Time::to_std_timepoint() const {
    return calendar_point(m_year, m_month, m_day, m_hour, m_minute, m_second).to_std_timepoint();
 }