Merge pull request #5668 from randombit/jack/asn1-time-refactor

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

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