Cleanup X509CertificateMac style nits

net/base/x509_openssl_util.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/x509_openssl_util.h"
 
 #include "base/logging.h"
-#include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
-#include "base/time.h"
+#include "net/base/x509_cert_types.h"
 
 namespace net {
 
 namespace x509_openssl_util {
 
-namespace {
-
-// Helper for ParseDate. |*field| must contain at least |field_len| characters.
-// |*field| will be advanced by |field_len| on exit. |*ok| is set to false if
-// there is an error in parsing the number, but left untouched otherwise.
-// Returns the parsed integer.
-int ParseIntAndAdvance(const char** field, size_t field_len, bool* ok) {
-  int result = 0;
-  *ok &= base::StringToInt(*field, *field + field_len, &result);
-  *field += field_len;
-  return result;
-}
-
-}  // namespace
-
 bool ParsePrincipalKeyAndValueByIndex(X509_NAME* name,
                                       int index,
                                       std::string* key,
                                       std::string* value) {
   X509_NAME_ENTRY* entry = X509_NAME_get_entry(name, index);
   if (!entry)
     return false;
 
   if (key) {
     ASN1_OBJECT* object = X509_NAME_ENTRY_get_object(entry);
@@ skipping 29 matching lines @@
 }
 
 bool ParseDate(ASN1_TIME* x509_time, base::Time* time) {
   if (!x509_time ||
       (x509_time->type != V_ASN1_UTCTIME &&
        x509_time->type != V_ASN1_GENERALIZEDTIME))
     return false;
 
   base::StringPiece str_date(reinterpret_cast<const char*>(x509_time->data),
                              x509_time->length);
-  // UTCTime: YYMMDDHHMMSSZ
-  // GeneralizedTime: YYYYMMDDHHMMSSZ
-  size_t year_length = x509_time->type == V_ASN1_UTCTIME ? 2 : 4;
 
-  if (str_date.length() < 11 + year_length)
-    return false;
-
-  const char* field = str_date.data();
-  bool valid = true;
-  base::Time::Exploded exploded = {0};
-
-  exploded.year =         ParseIntAndAdvance(&field, year_length, &valid);
-  exploded.month =        ParseIntAndAdvance(&field, 2, &valid);
-  exploded.day_of_month = ParseIntAndAdvance(&field, 2, &valid);
-  exploded.hour =         ParseIntAndAdvance(&field, 2, &valid);
-  exploded.minute =       ParseIntAndAdvance(&field, 2, &valid);
-  exploded.second =       ParseIntAndAdvance(&field, 2, &valid);
-  if (valid && year_length == 2)
-    exploded.year += exploded.year < 50 ? 2000 : 1900;
-
-  valid &= exploded.HasValidValues();
-
-  if (!valid) {
-    NOTREACHED() << "can't parse x509 date " << str_date;
-    return false;
-  }
-
-  *time = base::Time::FromUTCExploded(exploded);
-  return true;
+  CertDateFormat format = x509_time->type == V_ASN1_UTCTIME ?
+      CERT_DATE_FORMAT_UTC_TIME : CERT_DATE_FORMAT_GENERALIZED_TIME;
+  return ParseCertificateDate(str_date, format, time);
 }
 
 // TODO(joth): Investigate if we can upstream this into the OpenSSL library,
 // to avoid duplicating this logic across projects.
 bool VerifyHostname(const std::string& hostname,
                     const std::vector<std::string>& cert_names) {
   DCHECK(!hostname.empty());
 
   // Simple host name validation. A valid domain name must only contain
   // alpha, digits, hyphens, and dots. An IP address may have digits and dots,
@@ skipping 98 matching lines @@
     // detect these and skip those candidate cert names.
     if (cert_match == wildcard_domain)
       return true;
   }
   DVLOG(1) << "Could not find any match for " << hostname
            << " (canonicalized as " << reference_name
            << ") in cert names " << JoinString(cert_names, '|');
   return false;
 }
 
-} // namespace x509_openssl_util
+}  // namespace x509_openssl_util
 
-} // namespace net
+}  // namespace net