| // Copyright 2015 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/cert/internal/parse_certificate.h" | |
| #include <utility> | |
| #include "base/strings/string_util.h" | |
| #include "net/cert/internal/cert_error_params.h" | |
| #include "net/cert/internal/cert_errors.h" | |
| #include "net/cert/internal/general_names.h" | |
| #include "net/der/input.h" | |
| #include "net/der/parse_values.h" | |
| #include "net/der/parser.h" | |
| namespace net { | |
| namespace { | |
| DEFINE_CERT_ERROR_ID(kCertificateNotSequence, | |
| "Failed parsing Certificate SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kUnconsumedDataInsideCertificateSequence, | |
| "Unconsumed data inside Certificate SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kUnconsumedDataAfterCertificateSequence, | |
| "Unconsumed data after Certificate SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kTbsCertificateNotSequence, | |
| "Couldn't read tbsCertificate as SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID( | |
| kSignatureAlgorithmNotSequence, | |
| "Couldn't read Certificate.signatureAlgorithm as SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kSignatureValueNotBitString, | |
| "Couldn't read Certificate.signatureValue as BIT STRING"); | |
| DEFINE_CERT_ERROR_ID(kUnconsumedDataInsideTbsCertificateSequence, | |
| "Unconsumed data inside TBSCertificate"); | |
| DEFINE_CERT_ERROR_ID(kTbsNotSequence, "Failed parsing TBSCertificate SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingVersion, "Failed reading version"); | |
| DEFINE_CERT_ERROR_ID(kFailedParsingVersion, "Failed parsing version"); | |
| DEFINE_CERT_ERROR_ID(kVersionExplicitlyV1, | |
| "Version explicitly V1 (should be omitted)"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingSerialNumber, "Failed reading serialNumber"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingSignatureValue, "Failed reading signature"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingIssuer, "Failed reading issuer"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingValidity, "Failed reading validity"); | |
| DEFINE_CERT_ERROR_ID(kFailedParsingValidity, "Failed parsing validity"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingSubject, "Failed reading subject"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingSpki, "Failed reading subjectPublicKeyInfo"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingIssuerUniqueId, | |
| "Failed reading issuerUniqueId"); | |
| DEFINE_CERT_ERROR_ID(kFailedParsingIssuerUniqueId, | |
| "Failed parsing issuerUniqueId"); | |
| DEFINE_CERT_ERROR_ID( | |
| kIssuerUniqueIdNotExpected, | |
| "Unexpected issuerUniqueId (must be V2 or V3 certificate)"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingSubjectUniqueId, | |
| "Failed reading subjectUniqueId"); | |
| DEFINE_CERT_ERROR_ID(kFailedParsingSubjectUniqueId, | |
| "Failed parsing subjectUniqueId"); | |
| DEFINE_CERT_ERROR_ID( | |
| kSubjectUniqueIdNotExpected, | |
| "Unexpected subjectUniqueId (must be V2 or V3 certificate)"); | |
| DEFINE_CERT_ERROR_ID(kFailedReadingExtensions, | |
| "Failed reading extensions SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kUnexpectedExtensions, | |
| "Unexpected extensions (must be V3 certificate)"); | |
| DEFINE_CERT_ERROR_ID(kSerialNumberIsNegative, "Serial number is negative"); | |
| DEFINE_CERT_ERROR_ID(kSerialNumberIsZero, "Serial number is zero"); | |
| DEFINE_CERT_ERROR_ID(kSerialNumberLengthOver20, | |
| "Serial number is longer than 20 octets"); | |
| DEFINE_CERT_ERROR_ID(kSerialNumberNotValidInteger, | |
| "Serial number is not a valid INTEGER"); | |
| // Returns true if |input| is a SEQUENCE and nothing else. | |
| WARN_UNUSED_RESULT bool IsSequenceTLV(const der::Input& input) { | |
| der::Parser parser(input); | |
| der::Parser unused_sequence_parser; | |
| if (!parser.ReadSequence(&unused_sequence_parser)) | |
| return false; | |
| // Should by a single SEQUENCE by definition of the function. | |
| return !parser.HasMore(); | |
| } | |
| // Reads a SEQUENCE from |parser| and writes the full tag-length-value into | |
| // |out|. On failure |parser| may or may not have been advanced. | |
| WARN_UNUSED_RESULT bool ReadSequenceTLV(der::Parser* parser, der::Input* out) { | |
| return parser->ReadRawTLV(out) && IsSequenceTLV(*out); | |
| } | |
| // Parses a Version according to RFC 5280: | |
| // | |
| // Version ::= INTEGER { v1(0), v2(1), v3(2) } | |
| // | |
| // No value other that v1, v2, or v3 is allowed (and if given will fail). RFC | |
| // 5280 minimally requires the handling of v3 (and overwhelmingly these are the | |
| // certificate versions in use today): | |
| // | |
| // Implementations SHOULD be prepared to accept any version certificate. | |
| // At a minimum, conforming implementations MUST recognize version 3 | |
| // certificates. | |
| WARN_UNUSED_RESULT bool ParseVersion(const der::Input& in, | |
| CertificateVersion* version) { | |
| der::Parser parser(in); | |
| uint64_t version64; | |
| if (!parser.ReadUint64(&version64)) | |
| return false; | |
| switch (version64) { | |
| case 0: | |
| *version = CertificateVersion::V1; | |
| break; | |
| case 1: | |
| *version = CertificateVersion::V2; | |
| break; | |
| case 2: | |
| *version = CertificateVersion::V3; | |
| break; | |
| default: | |
| // Don't allow any other version identifier. | |
| return false; | |
| } | |
| // By definition the input to this function was a single INTEGER, so there | |
| // shouldn't be anything else after it. | |
| return !parser.HasMore(); | |
| } | |
| // Consumes a "Time" value (as defined by RFC 5280) from |parser|. On success | |
| // writes the result to |*out| and returns true. On failure no guarantees are | |
| // made about the state of |parser|. | |
| // | |
| // From RFC 5280: | |
| // | |
| // Time ::= CHOICE { | |
| // utcTime UTCTime, | |
| // generalTime GeneralizedTime } | |
| WARN_UNUSED_RESULT bool ReadTime(der::Parser* parser, | |
| der::GeneralizedTime* out) { | |
| der::Input value; | |
| der::Tag tag; | |
| if (!parser->ReadTagAndValue(&tag, &value)) | |
| return false; | |
| if (tag == der::kUtcTime) | |
| return der::ParseUTCTime(value, out); | |
| if (tag == der::kGeneralizedTime) | |
| return der::ParseGeneralizedTime(value, out); | |
| // Unrecognized tag. | |
| return false; | |
| } | |
| // Parses a DER-encoded "Validity" as specified by RFC 5280. Returns true on | |
| // success and sets the results in |not_before| and |not_after|: | |
| // | |
| // Validity ::= SEQUENCE { | |
| // notBefore Time, | |
| // notAfter Time } | |
| // | |
| // Note that upon success it is NOT guaranteed that |*not_before <= *not_after|. | |
| bool ParseValidity(const der::Input& validity_tlv, | |
| der::GeneralizedTime* not_before, | |
| der::GeneralizedTime* not_after) { | |
| der::Parser parser(validity_tlv); | |
| // Validity ::= SEQUENCE { | |
| der::Parser validity_parser; | |
| if (!parser.ReadSequence(&validity_parser)) | |
| return false; | |
| // notBefore Time, | |
| if (!ReadTime(&validity_parser, not_before)) | |
| return false; | |
| // notAfter Time } | |
| if (!ReadTime(&validity_parser, not_after)) | |
| return false; | |
| // By definition the input was a single Validity sequence, so there shouldn't | |
| // be unconsumed data. | |
| if (parser.HasMore()) | |
| return false; | |
| // The Validity type does not have an extension point. | |
| if (validity_parser.HasMore()) | |
| return false; | |
| // Note that RFC 5280 doesn't require notBefore to be <= | |
| // notAfter, so that will not be considered a "parsing" error here. Instead it | |
| // will be considered an expired certificate later when testing against the | |
| // current timestamp. | |
| return true; | |
| } | |
| // Returns true if every bit in |bits| is zero (including empty). | |
| WARN_UNUSED_RESULT bool BitStringIsAllZeros(const der::BitString& bits) { | |
| // Note that it is OK to read from the unused bits, since BitString parsing | |
| // guarantees they are all zero. | |
| for (size_t i = 0; i < bits.bytes().Length(); ++i) { | |
| if (bits.bytes().UnsafeData()[i] != 0) | |
| return false; | |
| } | |
| return true; | |
| } | |
| // Parses a DistributionPointName. | |
| // | |
| // Currently this implementation is only concerned with URIs encoded in | |
| // fullName and skips the rest (it does not fully parse the GeneralNames). | |
| // | |
| // URIs found in fullName are appended to |uris|. | |
| // | |
| // From RFC 5280: | |
| // | |
| // DistributionPointName ::= CHOICE { | |
| // fullName [0] GeneralNames, | |
| // nameRelativeToCRLIssuer [1] RelativeDistinguishedName } | |
| bool ParseDistributionPointName(const der::Input& dp_name, | |
| std::vector<base::StringPiece>* uris) { | |
| bool has_full_name; | |
| der::Input der_full_name; | |
| if (!der::Parser(dp_name).ReadOptionalTag( | |
| der::kTagContextSpecific | der::kTagConstructed | 0, &der_full_name, | |
| &has_full_name)) { | |
| return false; | |
| } | |
| if (!has_full_name) { | |
| // Only process DistributionPoints which provide "fullName". | |
| return true; | |
| } | |
| // TODO(mattm): surface the CertErrors. | |
| CertErrors errors; | |
| std::unique_ptr<GeneralNames> full_name = | |
| GeneralNames::CreateFromValue(der_full_name, &errors); | |
| if (!full_name) | |
| return false; | |
| // This code is only interested in extracting the URIs from fullName. | |
| *uris = full_name->uniform_resource_identifiers; | |
| return true; | |
| } | |
| // RFC 5280, section 4.2.1.13. | |
| // | |
| // DistributionPoint ::= SEQUENCE { | |
| // distributionPoint [0] DistributionPointName OPTIONAL, | |
| // reasons [1] ReasonFlags OPTIONAL, | |
| // cRLIssuer [2] GeneralNames OPTIONAL } | |
| bool ParseAndAddDistributionPoint( | |
| der::Parser* parser, | |
| std::vector<ParsedDistributionPoint>* distribution_points) { | |
| ParsedDistributionPoint distribution_point; | |
| // DistributionPoint ::= SEQUENCE { | |
| der::Parser distrib_point_parser; | |
| if (!parser->ReadSequence(&distrib_point_parser)) | |
| return false; | |
| // distributionPoint [0] DistributionPointName OPTIONAL, | |
| bool distribution_point_present; | |
| der::Input name; | |
| if (!distrib_point_parser.ReadOptionalTag( | |
| der::kTagContextSpecific | der::kTagConstructed | 0, &name, | |
| &distribution_point_present)) { | |
| return false; | |
| } | |
| if (!distribution_point_present) { | |
| // Only process DistributionPoints which provide a "distributionPoint". | |
| return true; | |
| } | |
| // reasons [1] ReasonFlags OPTIONAL, | |
| bool reasons_present; | |
| if (!distrib_point_parser.SkipOptionalTag(der::kTagContextSpecific | 1, | |
| &reasons_present)) { | |
| return false; | |
| } | |
| // If it contains a subset of reasons then we skip it. We aren't | |
| // interested in subsets of CRLs and the RFC states that there MUST be | |
| // a CRL that covers all reasons. | |
| if (reasons_present) { | |
| return true; | |
| } | |
| // Extract the URIs from the DistributionPointName. | |
| if (!ParseDistributionPointName(name, &distribution_point.uris)) | |
| return false; | |
| // cRLIssuer [2] GeneralNames OPTIONAL } | |
| bool crl_issuer_present; | |
| der::Input crl_issuer; | |
| if (!distrib_point_parser.ReadOptionalTag( | |
| der::kTagContextSpecific | der::kTagConstructed | 2, &crl_issuer, | |
| &crl_issuer_present)) { | |
| return false; | |
| } | |
| distribution_point.has_crl_issuer = crl_issuer_present; | |
| // TODO(eroman): Parse "cRLIssuer". | |
| if (distrib_point_parser.HasMore()) | |
| return false; | |
| distribution_points->push_back(std::move(distribution_point)); | |
| return true; | |
| } | |
| } // namespace | |
| ParsedTbsCertificate::ParsedTbsCertificate() = default; | |
| ParsedTbsCertificate::~ParsedTbsCertificate() = default; | |
| bool VerifySerialNumber(const der::Input& value, | |
| bool warnings_only, | |
| CertErrors* errors) { | |
| // If |warnings_only| was set to true, the exact same errors will be logged, | |
| // only they will be logged with a lower severity (warning rather than error). | |
| CertError::Severity error_severity = | |
| warnings_only ? CertError::SEVERITY_WARNING : CertError::SEVERITY_HIGH; | |
| bool negative; | |
| if (!der::IsValidInteger(value, &negative)) { | |
| errors->Add(error_severity, kSerialNumberNotValidInteger, nullptr); | |
| return false; | |
| } | |
| // RFC 5280 section 4.1.2.2: | |
| // | |
| // Note: Non-conforming CAs may issue certificates with serial numbers | |
| // that are negative or zero. Certificate users SHOULD be prepared to | |
| // gracefully handle such certificates. | |
| if (negative) | |
| errors->AddWarning(kSerialNumberIsNegative); | |
| if (value.Length() == 1 && value.UnsafeData()[0] == 0) | |
| errors->AddWarning(kSerialNumberIsZero); | |
| // RFC 5280 section 4.1.2.2: | |
| // | |
| // Certificate users MUST be able to handle serialNumber values up to 20 | |
| // octets. Conforming CAs MUST NOT use serialNumber values longer than 20 | |
| // octets. | |
| if (value.Length() > 20) { | |
| errors->Add(error_severity, kSerialNumberLengthOver20, | |
| CreateCertErrorParams1SizeT("length", value.Length())); | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool ParseCertificate(const der::Input& certificate_tlv, | |
| der::Input* out_tbs_certificate_tlv, | |
| der::Input* out_signature_algorithm_tlv, | |
| der::BitString* out_signature_value, | |
| CertErrors* out_errors) { | |
| // |out_errors| is optional. But ensure it is non-null for the remainder of | |
| // this function. | |
| if (!out_errors) { | |
| CertErrors unused_errors; | |
| return ParseCertificate(certificate_tlv, out_tbs_certificate_tlv, | |
| out_signature_algorithm_tlv, out_signature_value, | |
| &unused_errors); | |
| } | |
| der::Parser parser(certificate_tlv); | |
| // Certificate ::= SEQUENCE { | |
| der::Parser certificate_parser; | |
| if (!parser.ReadSequence(&certificate_parser)) { | |
| out_errors->AddError(kCertificateNotSequence); | |
| return false; | |
| } | |
| // tbsCertificate TBSCertificate, | |
| if (!ReadSequenceTLV(&certificate_parser, out_tbs_certificate_tlv)) { | |
| out_errors->AddError(kTbsCertificateNotSequence); | |
| return false; | |
| } | |
| // signatureAlgorithm AlgorithmIdentifier, | |
| if (!ReadSequenceTLV(&certificate_parser, out_signature_algorithm_tlv)) { | |
| out_errors->AddError(kSignatureAlgorithmNotSequence); | |
| return false; | |
| } | |
| // signatureValue BIT STRING } | |
| if (!certificate_parser.ReadBitString(out_signature_value)) { | |
| out_errors->AddError(kSignatureValueNotBitString); | |
| return false; | |
| } | |
| // There isn't an extension point at the end of Certificate. | |
| if (certificate_parser.HasMore()) { | |
| out_errors->AddError(kUnconsumedDataInsideCertificateSequence); | |
| return false; | |
| } | |
| // By definition the input was a single Certificate, so there shouldn't be | |
| // unconsumed data. | |
| if (parser.HasMore()) { | |
| out_errors->AddError(kUnconsumedDataAfterCertificateSequence); | |
| return false; | |
| } | |
| return true; | |
| } | |
| // From RFC 5280 section 4.1: | |
| // | |
| // TBSCertificate ::= SEQUENCE { | |
| // version [0] EXPLICIT Version DEFAULT v1, | |
| // serialNumber CertificateSerialNumber, | |
| // signature AlgorithmIdentifier, | |
| // issuer Name, | |
| // validity Validity, | |
| // subject Name, | |
| // subjectPublicKeyInfo SubjectPublicKeyInfo, | |
| // issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL, | |
| // -- If present, version MUST be v2 or v3 | |
| // subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL, | |
| // -- If present, version MUST be v2 or v3 | |
| // extensions [3] EXPLICIT Extensions OPTIONAL | |
| // -- If present, version MUST be v3 | |
| // } | |
| bool ParseTbsCertificate(const der::Input& tbs_tlv, | |
| const ParseCertificateOptions& options, | |
| ParsedTbsCertificate* out, | |
| CertErrors* errors) { | |
| // The rest of this function assumes that |errors| is non-null. | |
| if (!errors) { | |
| CertErrors unused_errors; | |
| return ParseTbsCertificate(tbs_tlv, options, out, &unused_errors); | |
| } | |
| // TODO(crbug.com/634443): Add useful error information to |errors|. | |
| der::Parser parser(tbs_tlv); | |
| // TBSCertificate ::= SEQUENCE { | |
| der::Parser tbs_parser; | |
| if (!parser.ReadSequence(&tbs_parser)) { | |
| errors->AddError(kTbsNotSequence); | |
| return false; | |
| } | |
| // version [0] EXPLICIT Version DEFAULT v1, | |
| der::Input version; | |
| bool has_version; | |
| if (!tbs_parser.ReadOptionalTag(der::ContextSpecificConstructed(0), &version, | |
| &has_version)) { | |
| errors->AddError(kFailedReadingVersion); | |
| return false; | |
| } | |
| if (has_version) { | |
| if (!ParseVersion(version, &out->version)) { | |
| errors->AddError(kFailedParsingVersion); | |
| return false; | |
| } | |
| if (out->version == CertificateVersion::V1) { | |
| errors->AddError(kVersionExplicitlyV1); | |
| // The correct way to specify v1 is to omit the version field since v1 is | |
| // the DEFAULT. | |
| return false; | |
| } | |
| } else { | |
| out->version = CertificateVersion::V1; | |
| } | |
| // serialNumber CertificateSerialNumber, | |
| if (!tbs_parser.ReadTag(der::kInteger, &out->serial_number)) { | |
| errors->AddError(kFailedReadingSerialNumber); | |
| return false; | |
| } | |
| if (!VerifySerialNumber(out->serial_number, | |
| options.allow_invalid_serial_numbers, errors)) { | |
| // Invalid serial numbers are only considered fatal failures if | |
| // |!allow_invalid_serial_numbers|. | |
| if (!options.allow_invalid_serial_numbers) | |
| return false; | |
| } | |
| // signature AlgorithmIdentifier, | |
| if (!ReadSequenceTLV(&tbs_parser, &out->signature_algorithm_tlv)) { | |
| errors->AddError(kFailedReadingSignatureValue); | |
| return false; | |
| } | |
| // issuer Name, | |
| if (!ReadSequenceTLV(&tbs_parser, &out->issuer_tlv)) { | |
| errors->AddError(kFailedReadingIssuer); | |
| return false; | |
| } | |
| // validity Validity, | |
| der::Input validity_tlv; | |
| if (!tbs_parser.ReadRawTLV(&validity_tlv)) { | |
| errors->AddError(kFailedReadingValidity); | |
| return false; | |
| } | |
| if (!ParseValidity(validity_tlv, &out->validity_not_before, | |
| &out->validity_not_after)) { | |
| errors->AddError(kFailedParsingValidity); | |
| return false; | |
| } | |
| // subject Name, | |
| if (!ReadSequenceTLV(&tbs_parser, &out->subject_tlv)) { | |
| errors->AddError(kFailedReadingSubject); | |
| return false; | |
| } | |
| // subjectPublicKeyInfo SubjectPublicKeyInfo, | |
| if (!ReadSequenceTLV(&tbs_parser, &out->spki_tlv)) { | |
| errors->AddError(kFailedReadingSpki); | |
| return false; | |
| } | |
| // issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL, | |
| // -- If present, version MUST be v2 or v3 | |
| der::Input issuer_unique_id; | |
| if (!tbs_parser.ReadOptionalTag(der::ContextSpecificPrimitive(1), | |
| &issuer_unique_id, | |
| &out->has_issuer_unique_id)) { | |
| errors->AddError(kFailedReadingIssuerUniqueId); | |
| return false; | |
| } | |
| if (out->has_issuer_unique_id) { | |
| if (!der::ParseBitString(issuer_unique_id, &out->issuer_unique_id)) { | |
| errors->AddError(kFailedParsingIssuerUniqueId); | |
| return false; | |
| } | |
| if (out->version != CertificateVersion::V2 && | |
| out->version != CertificateVersion::V3) { | |
| errors->AddError(kIssuerUniqueIdNotExpected); | |
| return false; | |
| } | |
| } | |
| // subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL, | |
| // -- If present, version MUST be v2 or v3 | |
| der::Input subject_unique_id; | |
| if (!tbs_parser.ReadOptionalTag(der::ContextSpecificPrimitive(2), | |
| &subject_unique_id, | |
| &out->has_subject_unique_id)) { | |
| errors->AddError(kFailedReadingSubjectUniqueId); | |
| return false; | |
| } | |
| if (out->has_subject_unique_id) { | |
| if (!der::ParseBitString(subject_unique_id, &out->subject_unique_id)) { | |
| errors->AddError(kFailedParsingSubjectUniqueId); | |
| return false; | |
| } | |
| if (out->version != CertificateVersion::V2 && | |
| out->version != CertificateVersion::V3) { | |
| errors->AddError(kSubjectUniqueIdNotExpected); | |
| return false; | |
| } | |
| } | |
| // extensions [3] EXPLICIT Extensions OPTIONAL | |
| // -- If present, version MUST be v3 | |
| if (!tbs_parser.ReadOptionalTag(der::ContextSpecificConstructed(3), | |
| &out->extensions_tlv, &out->has_extensions)) { | |
| errors->AddError(kFailedReadingExtensions); | |
| return false; | |
| } | |
| if (out->has_extensions) { | |
| // extensions_tlv must be a single element. Also check that it is a | |
| // SEQUENCE. | |
| if (!IsSequenceTLV(out->extensions_tlv)) { | |
| errors->AddError(kFailedReadingExtensions); | |
| return false; | |
| } | |
| if (out->version != CertificateVersion::V3) { | |
| errors->AddError(kUnexpectedExtensions); | |
| return false; | |
| } | |
| } | |
| // Note that there IS an extension point at the end of TBSCertificate | |
| // (according to RFC 5912), so from that interpretation, unconsumed data would | |
| // be allowed in |tbs_parser|. | |
| // | |
| // However because only v1, v2, and v3 certificates are supported by the | |
| // parsing, there shouldn't be any subsequent data in those versions, so | |
| // reject. | |
| if (tbs_parser.HasMore()) { | |
| errors->AddError(kUnconsumedDataInsideTbsCertificateSequence); | |
| return false; | |
| } | |
| // By definition the input was a single TBSCertificate, so there shouldn't be | |
| // unconsumed data. | |
| if (parser.HasMore()) | |
| return false; | |
| return true; | |
| } | |
| // From RFC 5280: | |
| // | |
| // Extension ::= SEQUENCE { | |
| // extnID OBJECT IDENTIFIER, | |
| // critical BOOLEAN DEFAULT FALSE, | |
| // extnValue OCTET STRING | |
| // -- contains the DER encoding of an ASN.1 value | |
| // -- corresponding to the extension type identified | |
| // -- by extnID | |
| // } | |
| bool ParseExtension(const der::Input& extension_tlv, ParsedExtension* out) { | |
| der::Parser parser(extension_tlv); | |
| // Extension ::= SEQUENCE { | |
| der::Parser extension_parser; | |
| if (!parser.ReadSequence(&extension_parser)) | |
| return false; | |
| // extnID OBJECT IDENTIFIER, | |
| if (!extension_parser.ReadTag(der::kOid, &out->oid)) | |
| return false; | |
| // critical BOOLEAN DEFAULT FALSE, | |
| out->critical = false; | |
| bool has_critical; | |
| der::Input critical; | |
| if (!extension_parser.ReadOptionalTag(der::kBool, &critical, &has_critical)) | |
| return false; | |
| if (has_critical) { | |
| if (!der::ParseBool(critical, &out->critical)) | |
| return false; | |
| if (!out->critical) | |
| return false; // DER-encoding requires DEFAULT values be omitted. | |
| } | |
| // extnValue OCTET STRING | |
| if (!extension_parser.ReadTag(der::kOctetString, &out->value)) | |
| return false; | |
| // The Extension type does not have an extension point (everything goes in | |
| // extnValue). | |
| if (extension_parser.HasMore()) | |
| return false; | |
| // By definition the input was a single Extension sequence, so there shouldn't | |
| // be unconsumed data. | |
| if (parser.HasMore()) | |
| return false; | |
| return true; | |
| } | |
| der::Input KeyUsageOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-keyUsage OBJECT IDENTIFIER ::= { id-ce 15 } | |
| // | |
| // In dotted notation: 2.5.29.15 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x0f}; | |
| return der::Input(oid); | |
| } | |
| der::Input SubjectAltNameOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-subjectAltName OBJECT IDENTIFIER ::= { id-ce 17 } | |
| // | |
| // In dotted notation: 2.5.29.17 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x11}; | |
| return der::Input(oid); | |
| } | |
| der::Input BasicConstraintsOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-basicConstraints OBJECT IDENTIFIER ::= { id-ce 19 } | |
| // | |
| // In dotted notation: 2.5.29.19 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x13}; | |
| return der::Input(oid); | |
| } | |
| der::Input NameConstraintsOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-nameConstraints OBJECT IDENTIFIER ::= { id-ce 30 } | |
| // | |
| // In dotted notation: 2.5.29.30 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x1e}; | |
| return der::Input(oid); | |
| } | |
| der::Input CertificatePoliciesOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-certificatePolicies OBJECT IDENTIFIER ::= { id-ce 32 } | |
| // | |
| // In dotted notation: 2.5.29.32 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x20}; | |
| return der::Input(oid); | |
| } | |
| der::Input PolicyConstraintsOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-policyConstraints OBJECT IDENTIFIER ::= { id-ce 36 } | |
| // | |
| // In dotted notation: 2.5.29.36 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x24}; | |
| return der::Input(oid); | |
| } | |
| der::Input ExtKeyUsageOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-extKeyUsage OBJECT IDENTIFIER ::= { id-ce 37 } | |
| // | |
| // In dotted notation: 2.5.29.37 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x25}; | |
| return der::Input(oid); | |
| } | |
| der::Input AuthorityInfoAccessOid() { | |
| // From RFC 5280: | |
| // | |
| // id-pe-authorityInfoAccess OBJECT IDENTIFIER ::= { id-pe 1 } | |
| // | |
| // In dotted notation: 1.3.6.1.5.5.7.1.1 | |
| static const uint8_t oid[] = {0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01}; | |
| return der::Input(oid); | |
| } | |
| der::Input AdCaIssuersOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ad-caIssuers OBJECT IDENTIFIER ::= { id-ad 2 } | |
| // | |
| // In dotted notation: 1.3.6.1.5.5.7.48.2 | |
| static const uint8_t oid[] = {0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02}; | |
| return der::Input(oid); | |
| } | |
| der::Input AdOcspOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ad-ocsp OBJECT IDENTIFIER ::= { id-ad 1 } | |
| // | |
| // In dotted notation: 1.3.6.1.5.5.7.48.1 | |
| static const uint8_t oid[] = {0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01}; | |
| return der::Input(oid); | |
| } | |
| der::Input CrlDistributionPointsOid() { | |
| // From RFC 5280: | |
| // | |
| // id-ce-cRLDistributionPoints OBJECT IDENTIFIER ::= { id-ce 31 } | |
| // | |
| // In dotted notation: 2.5.29.31 | |
| static const uint8_t oid[] = {0x55, 0x1d, 0x1f}; | |
| return der::Input(oid); | |
| } | |
| NET_EXPORT bool ParseExtensions( | |
| const der::Input& extensions_tlv, | |
| std::map<der::Input, ParsedExtension>* extensions) { | |
| der::Parser parser(extensions_tlv); | |
| // Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension | |
| der::Parser extensions_parser; | |
| if (!parser.ReadSequence(&extensions_parser)) | |
| return false; | |
| // The Extensions SEQUENCE must contains at least 1 element (otherwise it | |
| // should have been omitted). | |
| if (!extensions_parser.HasMore()) | |
| return false; | |
| extensions->clear(); | |
| while (extensions_parser.HasMore()) { | |
| ParsedExtension extension; | |
| der::Input extension_tlv; | |
| if (!extensions_parser.ReadRawTLV(&extension_tlv)) | |
| return false; | |
| if (!ParseExtension(extension_tlv, &extension)) | |
| return false; | |
| bool is_duplicate = | |
| !extensions->insert(std::make_pair(extension.oid, extension)).second; | |
| // RFC 5280 says that an extension should not appear more than once. | |
| if (is_duplicate) | |
| return false; | |
| } | |
| // By definition the input was a single Extensions sequence, so there | |
| // shouldn't be unconsumed data. | |
| if (parser.HasMore()) | |
| return false; | |
| return true; | |
| } | |
| NET_EXPORT bool ConsumeExtension( | |
| const der::Input& oid, | |
| std::map<der::Input, ParsedExtension>* unconsumed_extensions, | |
| ParsedExtension* extension) { | |
| auto it = unconsumed_extensions->find(oid); | |
| if (it == unconsumed_extensions->end()) | |
| return false; | |
| *extension = it->second; | |
| unconsumed_extensions->erase(it); | |
| return true; | |
| } | |
| bool ParseBasicConstraints(const der::Input& basic_constraints_tlv, | |
| ParsedBasicConstraints* out) { | |
| der::Parser parser(basic_constraints_tlv); | |
| // BasicConstraints ::= SEQUENCE { | |
| der::Parser sequence_parser; | |
| if (!parser.ReadSequence(&sequence_parser)) | |
| return false; | |
| // cA BOOLEAN DEFAULT FALSE, | |
| out->is_ca = false; | |
| bool has_ca; | |
| der::Input ca; | |
| if (!sequence_parser.ReadOptionalTag(der::kBool, &ca, &has_ca)) | |
| return false; | |
| if (has_ca) { | |
| if (!der::ParseBool(ca, &out->is_ca)) | |
| return false; | |
| // TODO(eroman): Should reject if CA was set to false, since | |
| // DER-encoding requires DEFAULT values be omitted. In | |
| // practice however there are a lot of certificates that use | |
| // the broken encoding. | |
| } | |
| // pathLenConstraint INTEGER (0..MAX) OPTIONAL } | |
| der::Input encoded_path_len; | |
| if (!sequence_parser.ReadOptionalTag(der::kInteger, &encoded_path_len, | |
| &out->has_path_len)) { | |
| return false; | |
| } | |
| if (out->has_path_len) { | |
| // TODO(eroman): Surface reason for failure if length was longer than uint8. | |
| if (!der::ParseUint8(encoded_path_len, &out->path_len)) | |
| return false; | |
| } else { | |
| // Default initialize to 0 as a precaution. | |
| out->path_len = 0; | |
| } | |
| // There shouldn't be any unconsumed data in the extension. | |
| if (sequence_parser.HasMore()) | |
| return false; | |
| // By definition the input was a single BasicConstraints sequence, so there | |
| // shouldn't be unconsumed data. | |
| if (parser.HasMore()) | |
| return false; | |
| return true; | |
| } | |
| bool ParseKeyUsage(const der::Input& key_usage_tlv, der::BitString* key_usage) { | |
| der::Parser parser(key_usage_tlv); | |
| if (!parser.ReadBitString(key_usage)) | |
| return false; | |
| // By definition the input was a single BIT STRING. | |
| if (parser.HasMore()) | |
| return false; | |
| // RFC 5280 section 4.2.1.3: | |
| // | |
| // When the keyUsage extension appears in a certificate, at least | |
| // one of the bits MUST be set to 1. | |
| if (BitStringIsAllZeros(*key_usage)) | |
| return false; | |
| return true; | |
| } | |
| bool ParseAuthorityInfoAccess( | |
| const der::Input& authority_info_access_tlv, | |
| std::vector<base::StringPiece>* out_ca_issuers_uris, | |
| std::vector<base::StringPiece>* out_ocsp_uris) { | |
| der::Parser parser(authority_info_access_tlv); | |
| out_ca_issuers_uris->clear(); | |
| out_ocsp_uris->clear(); | |
| // AuthorityInfoAccessSyntax ::= | |
| // SEQUENCE SIZE (1..MAX) OF AccessDescription | |
| der::Parser sequence_parser; | |
| if (!parser.ReadSequence(&sequence_parser)) | |
| return false; | |
| if (!sequence_parser.HasMore()) | |
| return false; | |
| while (sequence_parser.HasMore()) { | |
| // AccessDescription ::= SEQUENCE { | |
| der::Parser access_description_sequence_parser; | |
| if (!sequence_parser.ReadSequence(&access_description_sequence_parser)) | |
| return false; | |
| // accessMethod OBJECT IDENTIFIER, | |
| der::Input access_method_oid; | |
| if (!access_description_sequence_parser.ReadTag(der::kOid, | |
| &access_method_oid)) | |
| return false; | |
| // accessLocation GeneralName } | |
| der::Tag access_location_tag; | |
| der::Input access_location_value; | |
| if (!access_description_sequence_parser.ReadTagAndValue( | |
| &access_location_tag, &access_location_value)) | |
| return false; | |
| // GeneralName ::= CHOICE { | |
| if (access_location_tag == der::ContextSpecificPrimitive(6)) { | |
| // uniformResourceIdentifier [6] IA5String, | |
| base::StringPiece uri = access_location_value.AsStringPiece(); | |
| if (!base::IsStringASCII(uri)) | |
| return false; | |
| if (access_method_oid == AdCaIssuersOid()) | |
| out_ca_issuers_uris->push_back(uri); | |
| else if (access_method_oid == AdOcspOid()) | |
| out_ocsp_uris->push_back(uri); | |
| } | |
| } | |
| return true; | |
| } | |
| ParsedDistributionPoint::ParsedDistributionPoint() = default; | |
| ParsedDistributionPoint::ParsedDistributionPoint( | |
| ParsedDistributionPoint&& other) = default; | |
| ParsedDistributionPoint::~ParsedDistributionPoint() = default; | |
| bool ParseCrlDistributionPoints( | |
| const der::Input& extension_value, | |
| std::vector<ParsedDistributionPoint>* distribution_points) { | |
| distribution_points->clear(); | |
| // RFC 5280, section 4.2.1.13. | |
| // | |
| // CRLDistributionPoints ::= SEQUENCE SIZE (1..MAX) OF DistributionPoint | |
| der::Parser extension_value_parser(extension_value); | |
| der::Parser distribution_points_parser; | |
| if (!extension_value_parser.ReadSequence(&distribution_points_parser)) | |
| return false; | |
| if (extension_value_parser.HasMore()) | |
| return false; | |
| // Sequence must have a minimum of 1 item. | |
| if (!distribution_points_parser.HasMore()) | |
| return false; | |
| while (distribution_points_parser.HasMore()) { | |
| if (!ParseAndAddDistributionPoint(&distribution_points_parser, | |
| distribution_points)) | |
| return false; | |
| } | |
| return true; | |
| } | |
| } // namespace net |