blob: c2017363fc3c0f089713e430d9706ae1e1febcca [file] [log] [blame]
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "fillins/openssl_util.h"
#include "parse_certificate.h"
#include <utility>
#include "cert_error_params.h"
#include "cert_errors.h"
#include "general_names.h"
#include "string_util.h"
#include "input.h"
#include "parse_values.h"
#include "parser.h"
#include <optional>
namespace bssl {
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.
[[nodiscard]] 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.
[[nodiscard]] 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.
[[nodiscard]] 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();
}
// Returns true if every bit in |bits| is zero (including empty).
[[nodiscard]] 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()[i] != 0) {
return false;
}
}
return true;
}
// Parses a DistributionPointName.
//
// From RFC 5280:
//
// DistributionPointName ::= CHOICE {
// fullName [0] GeneralNames,
// nameRelativeToCRLIssuer [1] RelativeDistinguishedName }
bool ParseDistributionPointName(const der::Input& dp_name,
ParsedDistributionPoint* distribution_point) {
der::Parser parser(dp_name);
std::optional<der::Input> der_full_name;
if (!parser.ReadOptionalTag(
der::kTagContextSpecific | der::kTagConstructed | 0,
&der_full_name)) {
return false;
}
if (der_full_name) {
// TODO(mattm): surface the CertErrors.
CertErrors errors;
distribution_point->distribution_point_fullname =
GeneralNames::CreateFromValue(*der_full_name, &errors);
if (!distribution_point->distribution_point_fullname)
return false;
return !parser.HasMore();
}
if (!parser.ReadOptionalTag(
der::kTagContextSpecific | der::kTagConstructed | 1,
&distribution_point
->distribution_point_name_relative_to_crl_issuer)) {
return false;
}
if (distribution_point->distribution_point_name_relative_to_crl_issuer) {
return !parser.HasMore();
}
// The CHOICE must contain either fullName or nameRelativeToCRLIssuer.
return false;
}
// 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,
std::optional<der::Input> distribution_point_name;
if (!distrib_point_parser.ReadOptionalTag(
der::kTagContextSpecific | der::kTagConstructed | 0,
&distribution_point_name)) {
return false;
}
if (distribution_point_name &&
!ParseDistributionPointName(*distribution_point_name,
&distribution_point)) {
return false;
}
// reasons [1] ReasonFlags OPTIONAL,
if (!distrib_point_parser.ReadOptionalTag(der::kTagContextSpecific | 1,
&distribution_point.reasons)) {
return false;
}
// cRLIssuer [2] GeneralNames OPTIONAL }
if (!distrib_point_parser.ReadOptionalTag(
der::kTagContextSpecific | der::kTagConstructed | 2,
&distribution_point.crl_issuer)) {
return false;
}
// TODO(eroman): Parse "cRLIssuer"?
// RFC 5280, section 4.2.1.13:
// either distributionPoint or cRLIssuer MUST be present.
if (!distribution_point_name && !distribution_point.crl_issuer)
return false;
if (distrib_point_parser.HasMore())
return false;
distribution_points->push_back(std::move(distribution_point));
return true;
}
} // namespace
ParsedTbsCertificate::ParsedTbsCertificate() = default;
ParsedTbsCertificate::ParsedTbsCertificate(ParsedTbsCertificate&& other) =
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[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 ReadUTCOrGeneralizedTime(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;
}
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 (!ReadUTCOrGeneralizedTime(&validity_parser, not_before))
return false;
// notAfter Time }
if (!ReadUTCOrGeneralizedTime(&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;
}
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.
CertErrors unused_errors;
if (!out_errors)
out_errors = &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 }
std::optional<der::BitString> signature_value =
certificate_parser.ReadBitString();
if (!signature_value) {
out_errors->AddError(kSignatureValueNotBitString);
return false;
}
*out_signature_value = signature_value.value();
// 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.
CertErrors unused_errors;
if (!errors)
errors = &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,
std::optional<der::Input> version;
if (!tbs_parser.ReadOptionalTag(der::ContextSpecificConstructed(0),
&version)) {
errors->AddError(kFailedReadingVersion);
return false;
}
if (version) {
if (!ParseVersion(version.value(), &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
std::optional<der::Input> issuer_unique_id;
if (!tbs_parser.ReadOptionalTag(der::ContextSpecificPrimitive(1),
&issuer_unique_id)) {
errors->AddError(kFailedReadingIssuerUniqueId);
return false;
}
if (issuer_unique_id) {
out->issuer_unique_id = der::ParseBitString(issuer_unique_id.value());
if (!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
std::optional<der::Input> subject_unique_id;
if (!tbs_parser.ReadOptionalTag(der::ContextSpecificPrimitive(2),
&subject_unique_id)) {
errors->AddError(kFailedReadingSubjectUniqueId);
return false;
}
if (subject_unique_id) {
out->subject_unique_id = der::ParseBitString(subject_unique_id.value());
if (!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)) {
errors->AddError(kFailedReadingExtensions);
return false;
}
if (out->extensions_tlv) {
// extensions_tlv must be a single element. Also check that it is a
// SEQUENCE.
if (!IsSequenceTLV(out->extensions_tlv.value())) {
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;
}
OPENSSL_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;
}
OPENSSL_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;
}
// TODO(crbug.com/1314019): return std::optional<BitString> when converting
// has_key_usage_ and key_usage_ into single std::optional field.
bool ParseKeyUsage(const der::Input& key_usage_tlv, der::BitString* key_usage) {
der::Parser parser(key_usage_tlv);
std::optional<der::BitString> key_usage_internal = parser.ReadBitString();
if (!key_usage_internal)
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_internal.value()))
return false;
*key_usage = key_usage_internal.value();
return true;
}
bool ParseAuthorityInfoAccess(
const der::Input& authority_info_access_tlv,
std::vector<AuthorityInfoAccessDescription>* out_access_descriptions) {
der::Parser parser(authority_info_access_tlv);
out_access_descriptions->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()) {
AuthorityInfoAccessDescription access_description;
// AccessDescription ::= SEQUENCE {
der::Parser access_description_sequence_parser;
if (!sequence_parser.ReadSequence(&access_description_sequence_parser))
return false;
// accessMethod OBJECT IDENTIFIER,
if (!access_description_sequence_parser.ReadTag(
der::kOid, &access_description.access_method_oid)) {
return false;
}
// accessLocation GeneralName }
if (!access_description_sequence_parser.ReadRawTLV(
&access_description.access_location)) {
return false;
}
if (access_description_sequence_parser.HasMore())
return false;
out_access_descriptions->push_back(access_description);
}
return true;
}
bool ParseAuthorityInfoAccessURIs(
const der::Input& authority_info_access_tlv,
std::vector<std::string_view>* out_ca_issuers_uris,
std::vector<std::string_view>* out_ocsp_uris) {
std::vector<AuthorityInfoAccessDescription> access_descriptions;
if (!ParseAuthorityInfoAccess(authority_info_access_tlv,
&access_descriptions)) {
return false;
}
for (const auto& access_description : access_descriptions) {
der::Parser access_location_parser(access_description.access_location);
der::Tag access_location_tag;
der::Input access_location_value;
if (!access_location_parser.ReadTagAndValue(&access_location_tag,
&access_location_value)) {
return false;
}
// GeneralName ::= CHOICE {
if (access_location_tag == der::ContextSpecificPrimitive(6)) {
// uniformResourceIdentifier [6] IA5String,
std::string_view uri = access_location_value.AsStringView();
if (!bssl::string_util::IsAscii(uri))
return false;
if (access_description.access_method_oid == der::Input(kAdCaIssuersOid))
out_ca_issuers_uris->push_back(uri);
else if (access_description.access_method_oid == der::Input(kAdOcspOid))
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;
}
ParsedAuthorityKeyIdentifier::ParsedAuthorityKeyIdentifier() = default;
ParsedAuthorityKeyIdentifier::~ParsedAuthorityKeyIdentifier() = default;
ParsedAuthorityKeyIdentifier::ParsedAuthorityKeyIdentifier(
ParsedAuthorityKeyIdentifier&& other) = default;
ParsedAuthorityKeyIdentifier& ParsedAuthorityKeyIdentifier::operator=(
ParsedAuthorityKeyIdentifier&& other) = default;
bool ParseAuthorityKeyIdentifier(
const der::Input& extension_value,
ParsedAuthorityKeyIdentifier* authority_key_identifier) {
// RFC 5280, section 4.2.1.1.
// AuthorityKeyIdentifier ::= SEQUENCE {
// keyIdentifier [0] KeyIdentifier OPTIONAL,
// authorityCertIssuer [1] GeneralNames OPTIONAL,
// authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
//
// KeyIdentifier ::= OCTET STRING
der::Parser extension_value_parser(extension_value);
der::Parser aki_parser;
if (!extension_value_parser.ReadSequence(&aki_parser))
return false;
if (extension_value_parser.HasMore())
return false;
// TODO(mattm): Should having an empty AuthorityKeyIdentifier SEQUENCE be an
// error? RFC 5280 doesn't explicitly say it.
// keyIdentifier [0] KeyIdentifier OPTIONAL,
if (!aki_parser.ReadOptionalTag(der::ContextSpecificPrimitive(0),
&authority_key_identifier->key_identifier)) {
return false;
}
// authorityCertIssuer [1] GeneralNames OPTIONAL,
if (!aki_parser.ReadOptionalTag(
der::ContextSpecificConstructed(1),
&authority_key_identifier->authority_cert_issuer)) {
return false;
}
// authorityCertSerialNumber [2] CertificateSerialNumber OPTIONAL }
if (!aki_parser.ReadOptionalTag(
der::ContextSpecificPrimitive(2),
&authority_key_identifier->authority_cert_serial_number)) {
return false;
}
// -- authorityCertIssuer and authorityCertSerialNumber MUST both
// -- be present or both be absent
if (authority_key_identifier->authority_cert_issuer.has_value() !=
authority_key_identifier->authority_cert_serial_number.has_value()) {
return false;
}
// There shouldn't be any unconsumed data in the AuthorityKeyIdentifier
// SEQUENCE.
if (aki_parser.HasMore())
return false;
return true;
}
bool ParseSubjectKeyIdentifier(const der::Input& extension_value,
der::Input* subject_key_identifier) {
// SubjectKeyIdentifier ::= KeyIdentifier
//
// KeyIdentifier ::= OCTET STRING
der::Parser extension_value_parser(extension_value);
if (!extension_value_parser.ReadTag(der::kOctetString,
subject_key_identifier)) {
return false;
}
// There shouldn't be any unconsumed data in the extension SEQUENCE.
if (extension_value_parser.HasMore())
return false;
return true;
}
} // namespace net