| // Copyright 2019 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. |
| |
| #ifndef COMPONENTS_CERTIFICATE_MATCHING_CERTIFICATE_PRINCIPAL_PATTERN_H_ |
| #define COMPONENTS_CERTIFICATE_MATCHING_CERTIFICATE_PRINCIPAL_PATTERN_H_ |
| |
| #include <string> |
| |
| #include "base/component_export.h" |
| #include "base/strings/string_piece_forward.h" |
| |
| namespace base { |
| class Value; |
| } |
| |
| namespace net { |
| struct CertPrincipal; |
| } // namespace net |
| |
| namespace certificate_matching { |
| |
| // Class to represent fields of a principal (issuer or subject) of a X509 |
| // certificate and compare them. |
| class COMPONENT_EXPORT(CERTIFICATE_MATCHING) CertificatePrincipalPattern { |
| public: |
| // Creates a pattern that matches every certificate principal. |
| CertificatePrincipalPattern(); |
| // Creates a pattern that requires an exact equality with the specified |
| // |common_name|, |locality|, |organization| and |organization_unit| for a |
| // certificate to match. If one of these is empty, no constraint is put on the |
| // corresponding principal field. |
| CertificatePrincipalPattern(std::string common_name, |
| std::string locality, |
| std::string organization, |
| std::string organization_unit); |
| CertificatePrincipalPattern(const CertificatePrincipalPattern& rhs); |
| CertificatePrincipalPattern(CertificatePrincipalPattern&& rhs); |
| ~CertificatePrincipalPattern(); |
| |
| CertificatePrincipalPattern& operator=( |
| const CertificatePrincipalPattern& rhs); |
| CertificatePrincipalPattern& operator=(CertificatePrincipalPattern&& rhs); |
| |
| // Returns true if all fields in the pattern are empty. A return value of true |
| // means that this pattern will match every |CertPrincipal|. |
| bool Empty() const; |
| |
| // Returns true if this pattern matches |principal|. |
| bool Matches(const net::CertPrincipal& principal) const; |
| |
| const std::string& common_name() const { return common_name_; } |
| const std::string& locality() const { return locality_; } |
| const std::string& organization() const { return organization_; } |
| const std::string& organization_unit() const { return organization_unit_; } |
| |
| // Parses |value| to create a |CertificatePrincipalPattern|. If |value| is |
| // present and a dictionary, the |key_*| parameters will be used to fill |
| // corresponding fields of the resulting |CertificatePrincipalPattern|. If a |
| // key is not present in the dictionary, the corresponding field will be left |
| // empty (putting no constraint on the principal field). If |value| is nullptr |
| // or not a dictionary, returns an empty pattern. |
| static CertificatePrincipalPattern ParseFromOptionalDict( |
| const base::Value* dict, |
| base::StringPiece key_common_name, |
| base::StringPiece key_locality, |
| base::StringPiece key_organization, |
| base::StringPiece key_organization_unit); |
| |
| private: |
| std::string common_name_; |
| std::string locality_; |
| std::string organization_; |
| std::string organization_unit_; |
| }; |
| |
| } // namespace certificate_matching |
| |
| #endif // COMPONENTS_CERTIFICATE_MATCHING_CERTIFICATE_PRINCIPAL_PATTERN_H_ |