| // Copyright 2015 The Chromium Authors | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // https://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include <algorithm> | |
| #include "certificate_policies.h" | |
| #include <openssl/base.h> | |
| #include "cert_error_params.h" | |
| #include "cert_errors.h" | |
| #include "input.h" | |
| #include "parse_values.h" | |
| #include "parser.h" | |
| BSSL_NAMESPACE_BEGIN | |
| namespace { | |
| // --------------------------------------------------------------- | |
| // Errors | |
| // --------------------------------------------------------------- | |
| DEFINE_CERT_ERROR_ID(kPolicyQualifiersEmptySequence, | |
| "The policy qualifiers SEQUENCE is empty"); | |
| DEFINE_CERT_ERROR_ID(kUnknownPolicyQualifierOid, | |
| "Unknown policy qualifier OID (not CPS or User Notice)"); | |
| DEFINE_CERT_ERROR_ID(kPoliciesEmptySequence, "Policies is an empty SEQUENCE"); | |
| DEFINE_CERT_ERROR_ID(kPoliciesDuplicateOid, "Policies contains duplicate OIDs"); | |
| DEFINE_CERT_ERROR_ID(kPolicyInformationTrailingData, | |
| "PolicyInformation has trailing data"); | |
| DEFINE_CERT_ERROR_ID(kFailedParsingPolicyQualifiers, | |
| "Failed parsing policy qualifiers"); | |
| DEFINE_CERT_ERROR_ID(kMissingQualifier, | |
| "PolicyQualifierInfo is missing qualifier"); | |
| DEFINE_CERT_ERROR_ID(kPolicyQualifierInfoTrailingData, | |
| "PolicyQualifierInfo has trailing data"); | |
| // Minimally parse policyQualifiers, storing in |policy_qualifiers| if non-null. | |
| // If a policy qualifier other than User Notice/CPS is present, parsing | |
| // will fail if |restrict_to_known_qualifiers| was set to true. | |
| bool ParsePolicyQualifiers(bool restrict_to_known_qualifiers, | |
| der::Parser *policy_qualifiers_sequence_parser, | |
| std::vector<PolicyQualifierInfo> *policy_qualifiers, | |
| CertErrors *errors) { | |
| BSSL_CHECK(errors); | |
| // If it is present, the policyQualifiers sequence should have at least 1 | |
| // element. | |
| // | |
| // policyQualifiers SEQUENCE SIZE (1..MAX) OF | |
| // PolicyQualifierInfo OPTIONAL } | |
| if (!policy_qualifiers_sequence_parser->HasMore()) { | |
| errors->AddError(kPolicyQualifiersEmptySequence); | |
| return false; | |
| } | |
| while (policy_qualifiers_sequence_parser->HasMore()) { | |
| // PolicyQualifierInfo ::= SEQUENCE { | |
| der::Parser policy_information_parser; | |
| if (!policy_qualifiers_sequence_parser->ReadSequence( | |
| &policy_information_parser)) { | |
| return false; | |
| } | |
| // policyQualifierId PolicyQualifierId, | |
| der::Input qualifier_oid; | |
| if (!policy_information_parser.ReadTag(CBS_ASN1_OBJECT, &qualifier_oid)) { | |
| return false; | |
| } | |
| if (restrict_to_known_qualifiers && | |
| qualifier_oid != der::Input(kCpsPointerId) && | |
| qualifier_oid != der::Input(kUserNoticeId)) { | |
| errors->AddError(kUnknownPolicyQualifierOid, | |
| CreateCertErrorParams1Der("oid", qualifier_oid)); | |
| return false; | |
| } | |
| // qualifier ANY DEFINED BY policyQualifierId } | |
| der::Input qualifier_tlv; | |
| if (!policy_information_parser.ReadRawTLV(&qualifier_tlv)) { | |
| errors->AddError(kMissingQualifier); | |
| return false; | |
| } | |
| // Should not have trailing data after qualifier. | |
| if (policy_information_parser.HasMore()) { | |
| errors->AddError(kPolicyQualifierInfoTrailingData); | |
| return false; | |
| } | |
| if (policy_qualifiers) { | |
| policy_qualifiers->push_back({qualifier_oid, qualifier_tlv}); | |
| } | |
| } | |
| return true; | |
| } | |
| // RFC 5280 section 4.2.1.4. Certificate Policies: | |
| // | |
| // certificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation | |
| // | |
| // PolicyInformation ::= SEQUENCE { | |
| // policyIdentifier CertPolicyId, | |
| // policyQualifiers SEQUENCE SIZE (1..MAX) OF | |
| // PolicyQualifierInfo OPTIONAL } | |
| // | |
| // CertPolicyId ::= OBJECT IDENTIFIER | |
| // | |
| // PolicyQualifierInfo ::= SEQUENCE { | |
| // policyQualifierId PolicyQualifierId, | |
| // qualifier ANY DEFINED BY policyQualifierId } | |
| // | |
| // PolicyQualifierId ::= OBJECT IDENTIFIER ( id-qt-cps | id-qt-unotice ) | |
| // | |
| // Qualifier ::= CHOICE { | |
| // cPSuri CPSuri, | |
| // userNotice UserNotice } | |
| // | |
| // CPSuri ::= IA5String | |
| // | |
| // UserNotice ::= SEQUENCE { | |
| // noticeRef NoticeReference OPTIONAL, | |
| // explicitText DisplayText OPTIONAL } | |
| // | |
| // NoticeReference ::= SEQUENCE { | |
| // organization DisplayText, | |
| // noticeNumbers SEQUENCE OF INTEGER } | |
| // | |
| // DisplayText ::= CHOICE { | |
| // ia5String IA5String (SIZE (1..200)), | |
| // visibleString VisibleString (SIZE (1..200)), | |
| // bmpString BMPString (SIZE (1..200)), | |
| // utf8String UTF8String (SIZE (1..200)) } | |
| bool ParseCertificatePoliciesExtensionImpl( | |
| der::Input extension_value, bool fail_parsing_unknown_qualifier_oids, | |
| std::vector<der::Input> *policy_oids, | |
| std::vector<PolicyInformation> *policy_informations, CertErrors *errors) { | |
| BSSL_CHECK(policy_oids); | |
| BSSL_CHECK(errors); | |
| // certificatePolicies ::= SEQUENCE SIZE (1..MAX) OF PolicyInformation | |
| der::Parser extension_parser(extension_value); | |
| der::Parser policies_sequence_parser; | |
| if (!extension_parser.ReadSequence(&policies_sequence_parser)) { | |
| return false; | |
| } | |
| // Should not have trailing data after certificatePolicies sequence. | |
| if (extension_parser.HasMore()) { | |
| return false; | |
| } | |
| // The certificatePolicies sequence should have at least 1 element. | |
| if (!policies_sequence_parser.HasMore()) { | |
| errors->AddError(kPoliciesEmptySequence); | |
| return false; | |
| } | |
| policy_oids->clear(); | |
| if (policy_informations) { | |
| policy_informations->clear(); | |
| } | |
| while (policies_sequence_parser.HasMore()) { | |
| // PolicyInformation ::= SEQUENCE { | |
| der::Parser policy_information_parser; | |
| if (!policies_sequence_parser.ReadSequence(&policy_information_parser)) { | |
| return false; | |
| } | |
| // policyIdentifier CertPolicyId, | |
| der::Input policy_oid; | |
| if (!policy_information_parser.ReadTag(CBS_ASN1_OBJECT, &policy_oid)) { | |
| return false; | |
| } | |
| policy_oids->push_back(policy_oid); | |
| std::vector<PolicyQualifierInfo> *policy_qualifiers = nullptr; | |
| if (policy_informations) { | |
| policy_informations->emplace_back(); | |
| policy_informations->back().policy_oid = policy_oid; | |
| policy_qualifiers = &policy_informations->back().policy_qualifiers; | |
| } | |
| if (!policy_information_parser.HasMore()) { | |
| continue; | |
| } | |
| // policyQualifiers SEQUENCE SIZE (1..MAX) OF | |
| // PolicyQualifierInfo OPTIONAL } | |
| der::Parser policy_qualifiers_sequence_parser; | |
| if (!policy_information_parser.ReadSequence( | |
| &policy_qualifiers_sequence_parser)) { | |
| return false; | |
| } | |
| // Should not have trailing data after policyQualifiers sequence. | |
| if (policy_information_parser.HasMore()) { | |
| errors->AddError(kPolicyInformationTrailingData); | |
| return false; | |
| } | |
| // RFC 5280 section 4.2.1.4: When qualifiers are used with the special | |
| // policy anyPolicy, they MUST be limited to the qualifiers identified in | |
| // this section. | |
| if (!ParsePolicyQualifiers(fail_parsing_unknown_qualifier_oids || | |
| policy_oid == der::Input(kAnyPolicyOid), | |
| &policy_qualifiers_sequence_parser, | |
| policy_qualifiers, errors)) { | |
| errors->AddError(kFailedParsingPolicyQualifiers); | |
| return false; | |
| } | |
| } | |
| // RFC 5280 section 4.2.1.4: A certificate policy OID MUST NOT appear more | |
| // than once in a certificate policies extension. | |
| std::sort(policy_oids->begin(), policy_oids->end()); | |
| auto dupe_policy_iter = | |
| std::adjacent_find(policy_oids->begin(), policy_oids->end()); | |
| if (dupe_policy_iter != policy_oids->end()) { | |
| errors->AddError(kPoliciesDuplicateOid, | |
| CreateCertErrorParams1Der("oid", *dupe_policy_iter)); | |
| return false; | |
| } | |
| return true; | |
| } | |
| } // namespace | |
| PolicyInformation::PolicyInformation() = default; | |
| PolicyInformation::~PolicyInformation() = default; | |
| PolicyInformation::PolicyInformation(const PolicyInformation &) = default; | |
| PolicyInformation::PolicyInformation(PolicyInformation &&) = default; | |
| bool ParseCertificatePoliciesExtension(der::Input extension_value, | |
| std::vector<PolicyInformation> *policies, | |
| CertErrors *errors) { | |
| std::vector<der::Input> unused_policy_oids; | |
| return ParseCertificatePoliciesExtensionImpl( | |
| extension_value, /*fail_parsing_unknown_qualifier_oids=*/false, | |
| &unused_policy_oids, policies, errors); | |
| } | |
| bool ParseCertificatePoliciesExtensionOids( | |
| der::Input extension_value, bool fail_parsing_unknown_qualifier_oids, | |
| std::vector<der::Input> *policy_oids, CertErrors *errors) { | |
| return ParseCertificatePoliciesExtensionImpl( | |
| extension_value, fail_parsing_unknown_qualifier_oids, policy_oids, | |
| nullptr, errors); | |
| } | |
| // From RFC 5280: | |
| // | |
| // PolicyConstraints ::= SEQUENCE { | |
| // requireExplicitPolicy [0] SkipCerts OPTIONAL, | |
| // inhibitPolicyMapping [1] SkipCerts OPTIONAL } | |
| // | |
| // SkipCerts ::= INTEGER (0..MAX) | |
| bool ParsePolicyConstraints(der::Input policy_constraints_tlv, | |
| ParsedPolicyConstraints *out) { | |
| der::Parser parser(policy_constraints_tlv); | |
| // PolicyConstraints ::= SEQUENCE { | |
| der::Parser sequence_parser; | |
| if (!parser.ReadSequence(&sequence_parser)) { | |
| return false; | |
| } | |
| // RFC 5280 prohibits CAs from issuing PolicyConstraints as an empty sequence: | |
| // | |
| // Conforming CAs MUST NOT issue certificates where policy constraints | |
| // is an empty sequence. That is, either the inhibitPolicyMapping field | |
| // or the requireExplicitPolicy field MUST be present. The behavior of | |
| // clients that encounter an empty policy constraints field is not | |
| // addressed in this profile. | |
| if (!sequence_parser.HasMore()) { | |
| return false; | |
| } | |
| std::optional<der::Input> require_value; | |
| if (!sequence_parser.ReadOptionalTag(CBS_ASN1_CONTEXT_SPECIFIC | 0, | |
| &require_value)) { | |
| return false; | |
| } | |
| if (require_value) { | |
| uint8_t require_explicit_policy; | |
| if (!ParseUint8(require_value.value(), &require_explicit_policy)) { | |
| // TODO(eroman): Surface reason for failure if length was longer than | |
| // uint8. | |
| return false; | |
| } | |
| out->require_explicit_policy = require_explicit_policy; | |
| } | |
| std::optional<der::Input> inhibit_value; | |
| if (!sequence_parser.ReadOptionalTag(CBS_ASN1_CONTEXT_SPECIFIC | 1, | |
| &inhibit_value)) { | |
| return false; | |
| } | |
| if (inhibit_value) { | |
| uint8_t inhibit_policy_mapping; | |
| if (!ParseUint8(inhibit_value.value(), &inhibit_policy_mapping)) { | |
| // TODO(eroman): Surface reason for failure if length was longer than | |
| // uint8. | |
| return false; | |
| } | |
| out->inhibit_policy_mapping = inhibit_policy_mapping; | |
| } | |
| // There should be no remaining data. | |
| if (sequence_parser.HasMore() || parser.HasMore()) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| // From RFC 5280: | |
| // | |
| // InhibitAnyPolicy ::= SkipCerts | |
| // | |
| // SkipCerts ::= INTEGER (0..MAX) | |
| std::optional<uint8_t> ParseInhibitAnyPolicy( | |
| der::Input inhibit_any_policy_tlv) { | |
| der::Parser parser(inhibit_any_policy_tlv); | |
| std::optional<uint8_t> num_certs = std::make_optional<uint8_t>(); | |
| // TODO(eroman): Surface reason for failure if length was longer than uint8. | |
| if (!parser.ReadUint8(&num_certs.value())) { | |
| return std::nullopt; | |
| } | |
| // There should be no remaining data. | |
| if (parser.HasMore()) { | |
| return std::nullopt; | |
| } | |
| return num_certs; | |
| } | |
| // From RFC 5280: | |
| // | |
| // PolicyMappings ::= SEQUENCE SIZE (1..MAX) OF SEQUENCE { | |
| // issuerDomainPolicy CertPolicyId, | |
| // subjectDomainPolicy CertPolicyId } | |
| bool ParsePolicyMappings(der::Input policy_mappings_tlv, | |
| std::vector<ParsedPolicyMapping> *mappings) { | |
| mappings->clear(); | |
| der::Parser parser(policy_mappings_tlv); | |
| // PolicyMappings ::= SEQUENCE SIZE (1..MAX) OF SEQUENCE { | |
| der::Parser sequence_parser; | |
| if (!parser.ReadSequence(&sequence_parser)) { | |
| return false; | |
| } | |
| // Must be at least 1 mapping. | |
| if (!sequence_parser.HasMore()) { | |
| return false; | |
| } | |
| while (sequence_parser.HasMore()) { | |
| der::Parser mapping_parser; | |
| if (!sequence_parser.ReadSequence(&mapping_parser)) { | |
| return false; | |
| } | |
| ParsedPolicyMapping mapping; | |
| if (!mapping_parser.ReadTag(CBS_ASN1_OBJECT, | |
| &mapping.issuer_domain_policy)) { | |
| return false; | |
| } | |
| if (!mapping_parser.ReadTag(CBS_ASN1_OBJECT, | |
| &mapping.subject_domain_policy)) { | |
| return false; | |
| } | |
| // There shouldn't be extra unconsumed data. | |
| if (mapping_parser.HasMore()) { | |
| return false; | |
| } | |
| mappings->push_back(mapping); | |
| } | |
| // There shouldn't be extra unconsumed data. | |
| if (parser.HasMore()) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| BSSL_NAMESPACE_END |