net/der/parse_values.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/logging.h"
   6 #include "base/numerics/safe_math.h"
   7 #include "net/der/parse_values.h"
   8
   9 namespace net {
  10
  11 namespace der {
  12
  13 namespace {
  14
  15 bool ParseBoolInternal(const Input& in, bool* out, bool relaxed) {
  16   // According to ITU-T X.690 section 8.2, a bool is encoded as a single octet
  17   // where the octet of all zeroes is FALSE and a non-zero value for the octet
  18   // is TRUE.
  19   if (in.Length() != 1)
  20     return false;
  21   ByteReader data(in);
  22   uint8_t byte;
  23   if (!data.ReadByte(&byte))
  24     return false;
  25   if (byte == 0) {
  26     *out = false;
  27     return true;
  28   }
  29   // ITU-T X.690 section 11.1 specifies that for DER, the TRUE value must be
  30   // encoded as an octet of all ones.
  31   if (byte == 0xff || relaxed) {
  32     *out = true;
  33     return true;
  34   }
  35   return false;
  36 }
  37
  38 // Reads a positive decimal number with |digits| digits and stores it in
  39 // |*out|. This function does not check that the type of |*out| is large
  40 // enough to hold 10^digits - 1; the caller must choose an appropriate type
  41 // based on the number of digits they wish to parse.
  42 template <typename UINT>
  43 bool DecimalStringToUint(ByteReader& in, size_t digits, UINT* out) {
  44   UINT value = 0;
  45   for (size_t i = 0; i < digits; ++i) {
  46     uint8_t digit;
  47     if (!in.ReadByte(&digit)) {
  48       return false;
  49     }
  50     if (digit < '0' || digit > '9') {
  51       return false;
  52     }
  53     value = (value * 10) + (digit - '0');
  54   }
  55   *out = value;
  56   return true;
  57 }
  58
  59 // Checks that the values in a GeneralizedTime struct are valid. This involves
  60 // checking that the year is 4 digits, the month is between 1 and 12, the day
  61 // is a day that exists in that month (following current leap year rules),
  62 // hours are between 0 and 23, minutes between 0 and 59, and seconds between
  63 // 0 and 60 (to allow for leap seconds; no validation is done that a leap
  64 // second is on a day that could be a leap second).
  65 bool ValidateGeneralizedTime(const GeneralizedTime& time) {
  66   CHECK(time.year > 0 && time.year < 9999);
  67   if (time.month < 1 || time.month > 12)
  68     return false;
  69   if (time.day < 1)
  70     return false;
  71   if (time.hours < 0 || time.hours > 23)
  72     return false;
  73   if (time.minutes < 0 || time.minutes > 59)
  74     return false;
  75   // Leap seconds are allowed.
  76   if (time.seconds < 0 || time.seconds > 60)
  77     return false;
  78
  79   // validate upper bound for day of month
  80   switch (time.month) {
  81     case 4:
  82     case 6:
  83     case 9:
  84     case 11:
  85       if (time.day > 30)
  86         return false;
  87       break;
  88     case 1:
  89     case 3:
  90     case 5:
  91     case 7:
  92     case 8:
  93     case 10:
  94     case 12:
  95       if (time.day > 31)
  96         return false;
  97       break;
  98     case 2:
  99       if (time.year % 4 == 0 &&
 100           (time.year % 100 != 0 || time.year % 400 == 0)) {
 101         if (time.day > 29)
 102           return false;
 103       } else {
 104         if (time.day > 28)
 105           return false;
 106       }
 107       break;
 108     default:
 109       NOTREACHED();
 110       return false;
 111   }
 112   return true;
 113 }
 114
 115 }  // namespace
 116
 117 bool ParseBool(const Input& in, bool* out) {
 118   return ParseBoolInternal(in, out, false /* relaxed */);
 119 }
 120
 121 // BER interprets any non-zero value as true, while DER requires a bool to
 122 // have either all bits zero (false) or all bits one (true). To support
 123 // malformed certs, we recognized the BER encoding instead of failing to
 124 // parse.
 125 bool ParseBoolRelaxed(const Input& in, bool* out) {
 126   return ParseBoolInternal(in, out, true /* relaxed */);
 127 }
 128
 129 bool ParseUint64(const Input& in, uint64_t* out) {
 130   ByteReader reader(in);
 131   size_t bytes_read = 0;
 132   uint8_t data;
 133   uint64_t value = 0;
 134   // Note that for simplicity, this check only admits integers up to 2^63-1.
 135   if (in.Length() > sizeof(uint64_t) || in.Length() == 0)
 136     return false;
 137   while (reader.ReadByte(&data)) {
 138     if (bytes_read == 0 && (data & 0x80)) {
 139       return false;
 140     }
 141     value <<= 8;
 142     value |= data;
 143     bytes_read++;
 144   }
 145   // ITU-T X.690 section 8.3.2 specifies that an integer value must be encoded
 146   // in the smallest number of octets. If the encoding consists of more than
 147   // one octet, then the bits of the first octet and the most significant bit
 148   // of the second octet must not be all zeroes or all ones.
 149   // Because this function only parses unsigned integers, there's no need to
 150   // check for the all ones case.
 151   if (bytes_read > 1) {
 152     ByteReader first_bytes_reader(in);
 153     uint8_t first_byte;
 154     uint8_t second_byte;
 155     if (!first_bytes_reader.ReadByte(&first_byte) ||
 156         !first_bytes_reader.ReadByte(&second_byte)) {
 157       return false;
 158     }
 159     if (first_byte == 0 && !(second_byte & 0x80)) {
 160       return false;
 161     }
 162   }
 163   *out = value;
 164   return true;
 165 }
 166
 167 bool operator<(const GeneralizedTime& lhs, const GeneralizedTime& rhs) {
 168   if (lhs.year != rhs.year)
 169     return lhs.year < rhs.year;
 170   if (lhs.month != rhs.month)
 171     return lhs.month < rhs.month;
 172   if (lhs.day != rhs.day)
 173     return lhs.day < rhs.day;
 174   if (lhs.hours != rhs.hours)
 175     return lhs.hours < rhs.hours;
 176   if (lhs.minutes != rhs.minutes)
 177     return lhs.minutes < rhs.minutes;
 178   return lhs.seconds < rhs.seconds;
 179 }
 180
 181 // A UTC Time in DER encoding should be YYMMDDHHMMSSZ, but some CAs encode
 182 // the time following BER rules, which allows for YYMMDDHHMMZ. If the length
 183 // is 11, assume it's YYMMDDHHMMZ, and in converting it to a GeneralizedTime,
 184 // add in the seconds (set to 0).
 185 bool ParseUTCTimeRelaxed(const Input& in, GeneralizedTime* value) {
 186   ByteReader reader(in);
 187   GeneralizedTime time;
 188   if (!DecimalStringToUint(reader, 2, &time.year) ||
 189       !DecimalStringToUint(reader, 2, &time.month) ||
 190       !DecimalStringToUint(reader, 2, &time.day) ||
 191       !DecimalStringToUint(reader, 2, &time.hours) ||
 192       !DecimalStringToUint(reader, 2, &time.minutes)) {
 193     return false;
 194   }
 195
 196   // Try to read the 'Z' at the end. If we read something else, then for it to
 197   // be valid the next bytes should be seconds (and then followed by 'Z').
 198   uint8_t zulu;
 199   ByteReader zulu_reader = reader;
 200   if (!zulu_reader.ReadByte(&zulu))
 201     return false;
 202   if (zulu == 'Z' && !zulu_reader.HasMore()) {
 203     time.seconds = 0;
 204     *value = time;
 205     return true;
 206   }
 207   if (!DecimalStringToUint(reader, 2, &time.seconds))
 208     return false;
 209   if (!reader.ReadByte(&zulu) || zulu != 'Z' || reader.HasMore())
 210     return false;
 211   if (!ValidateGeneralizedTime(time))
 212     return false;
 213   if (time.year < 50) {
 214     time.year += 2000;
 215   } else {
 216     time.year += 1900;
 217   }
 218   *value = time;
 219   return true;
 220 }
 221
 222 bool ParseUTCTime(const Input& in, GeneralizedTime* value) {
 223   ByteReader reader(in);
 224   GeneralizedTime time;
 225   if (!DecimalStringToUint(reader, 2, &time.year) ||
 226       !DecimalStringToUint(reader, 2, &time.month) ||
 227       !DecimalStringToUint(reader, 2, &time.day) ||
 228       !DecimalStringToUint(reader, 2, &time.hours) ||
 229       !DecimalStringToUint(reader, 2, &time.minutes) ||
 230       !DecimalStringToUint(reader, 2, &time.seconds)) {
 231     return false;
 232   }
 233   uint8_t zulu;
 234   if (!reader.ReadByte(&zulu) || zulu != 'Z' || reader.HasMore())
 235     return false;
 236   if (!ValidateGeneralizedTime(time))
 237     return false;
 238   if (time.year < 50) {
 239     time.year += 2000;
 240   } else {
 241     time.year += 1900;
 242   }
 243   *value = time;
 244   return true;
 245 }
 246
 247 bool ParseGeneralizedTime(const Input& in, GeneralizedTime* value) {
 248   ByteReader reader(in);
 249   GeneralizedTime time;
 250   if (!DecimalStringToUint(reader, 4, &time.year) ||
 251       !DecimalStringToUint(reader, 2, &time.month) ||
 252       !DecimalStringToUint(reader, 2, &time.day) ||
 253       !DecimalStringToUint(reader, 2, &time.hours) ||
 254       !DecimalStringToUint(reader, 2, &time.minutes) ||
 255       !DecimalStringToUint(reader, 2, &time.seconds)) {
 256     return false;
 257   }
 258   uint8_t zulu;
 259   if (!reader.ReadByte(&zulu) || zulu != 'Z' || reader.HasMore())
 260     return false;
 261   if (!ValidateGeneralizedTime(time))
 262     return false;
 263   *value = time;
 264   return true;
 265 }
 266
 267 }  // namespace der
 268
 269 }  // namespace net