Google Git
Sign in
cobalt / cobalt / b95ea55ccebda33f820d043e4b4dc85c10d7584d / . / net / cert / internal / signature_algorithm.cc
blob: ec15765827dd88326d4363f73c8bcec2185b272b [file] [log] [blame]
// 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/signature_algorithm.h"
#include <memory>
#include <utility>
#include "base/memory/ptr_util.h"
#include "base/numerics/safe_math.h"
#include "net/cert/internal/cert_error_params.h"
#include "net/cert/internal/cert_errors.h"
#include "net/der/input.h"
#include "net/der/parse_values.h"
#include "net/der/parser.h"
#include "third_party/boringssl/src/include/openssl/bytestring.h"
#include "third_party/boringssl/src/include/openssl/digest.h"
namespace net {
namespace {
// md2WithRSAEncryption
// In dotted notation: 1.2.840.113549.1.1.2
const uint8_t kOidMd2WithRsaEncryption[] = {0x2a, 0x86, 0x48, 0x86, 0xf7,
0x0d, 0x01, 0x01, 0x02};
// md4WithRSAEncryption
// In dotted notation: 1.2.840.113549.1.1.3
const uint8_t kOidMd4WithRsaEncryption[] = {0x2a, 0x86, 0x48, 0x86, 0xf7,
0x0d, 0x01, 0x01, 0x03};
// md5WithRSAEncryption
// In dotted notation: 1.2.840.113549.1.1.4
const uint8_t kOidMd5WithRsaEncryption[] = {0x2a, 0x86, 0x48, 0x86, 0xf7,
0x0d, 0x01, 0x01, 0x04};
// From RFC 5912:
//
// sha1WithRSAEncryption OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1)
// pkcs-1(1) 5 }
//
// In dotted notation: 1.2.840.113549.1.1.5
const uint8_t kOidSha1WithRsaEncryption[] =
{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05};
// sha1WithRSASignature is a deprecated equivalent of
// sha1WithRSAEncryption.
//
// It originates from the NIST Open Systems Environment (OSE)
// Implementor's Workshop (OIW).
//
// It is supported for compatibility with Microsoft's certificate APIs and
// tools, particularly makecert.exe, which default(ed/s) to this OID for SHA-1.
//
// See also: https://bugzilla.mozilla.org/show_bug.cgi?id=1042479
//
// In dotted notation: 1.3.14.3.2.29
const uint8_t kOidSha1WithRsaSignature[] = {0x2b, 0x0e, 0x03, 0x02, 0x1d};
// From RFC 5912:
//
// pkcs-1 OBJECT IDENTIFIER ::=
// { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) 1 }
// From RFC 5912:
//
// sha256WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 11 }
//
// In dotted notation: 1.2.840.113549.1.1.11
const uint8_t kOidSha256WithRsaEncryption[] =
{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b};
// From RFC 5912:
//
// sha384WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 12 }
//
// In dotted notation: 1.2.840.113549.1.1.11
const uint8_t kOidSha384WithRsaEncryption[] =
{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0c};
// From RFC 5912:
//
// sha512WithRSAEncryption OBJECT IDENTIFIER ::= { pkcs-1 13 }
//
// In dotted notation: 1.2.840.113549.1.1.13
const uint8_t kOidSha512WithRsaEncryption[] =
{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0d};
// From RFC 5912:
//
// ecdsa-with-SHA1 OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) ansi-X9-62(10045)
// signatures(4) 1 }
//
// In dotted notation: 1.2.840.10045.4.1
const uint8_t kOidEcdsaWithSha1[] = {0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x01};
// From RFC 5912:
//
// ecdsa-with-SHA256 OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
// ecdsa-with-SHA2(3) 2 }
//
// In dotted notation: 1.2.840.10045.4.3.2
const uint8_t kOidEcdsaWithSha256[] =
{0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02};
// From RFC 5912:
//
// ecdsa-with-SHA384 OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
// ecdsa-with-SHA2(3) 3 }
//
// In dotted notation: 1.2.840.10045.4.3.3
const uint8_t kOidEcdsaWithSha384[] =
{0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x03};
// From RFC 5912:
//
// ecdsa-with-SHA512 OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4)
// ecdsa-with-SHA2(3) 4 }
//
// In dotted notation: 1.2.840.10045.4.3.4
const uint8_t kOidEcdsaWithSha512[] =
{0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x04};
// From RFC 5912:
//
// id-RSASSA-PSS OBJECT IDENTIFIER ::= { pkcs-1 10 }
//
// In dotted notation: 1.2.840.113549.1.1.10
const uint8_t kOidRsaSsaPss[] = {0x2a, 0x86, 0x48, 0x86, 0xf7,
0x0d, 0x01, 0x01, 0x0a};
// From RFC 5912:
//
// dsa-with-sha1 OBJECT IDENTIFIER ::= {
// iso(1) member-body(2) us(840) x9-57(10040) x9algorithm(4) 3 }
//
// In dotted notation: 1.2.840.10040.4.3
const uint8_t kOidDsaWithSha1[] = {0x2a, 0x86, 0x48, 0xce, 0x38, 0x04, 0x03};
// From RFC 5912:
//
// dsa-with-sha256 OBJECT IDENTIFIER ::= {
// joint-iso-ccitt(2) country(16) us(840) organization(1) gov(101)
// csor(3) algorithms(4) id-dsa-with-sha2(3) 2 }
//
// In dotted notation: 2.16.840.1.101.3.4.3.2
const uint8_t kOidDsaWithSha256[] = {0x60, 0x86, 0x48, 0x01, 0x65,
0x03, 0x04, 0x03, 0x02};
// From RFC 5912:
//
// id-mgf1 OBJECT IDENTIFIER ::= { pkcs-1 8 }
//
// In dotted notation: 1.2.840.113549.1.1.8
const uint8_t kOidMgf1[] = {0x2a, 0x86, 0x48, 0x86, 0xf7,
0x0d, 0x01, 0x01, 0x08};
// RFC 5280 section 4.1.1.2 defines signatureAlgorithm as:
//
// AlgorithmIdentifier ::= SEQUENCE {
// algorithm OBJECT IDENTIFIER,
// parameters ANY DEFINED BY algorithm OPTIONAL }
WARN_UNUSED_RESULT bool ParseAlgorithmIdentifier(const der::Input& input,
der::Input* algorithm,
der::Input* parameters) {
der::Parser parser(input);
der::Parser algorithm_identifier_parser;
if (!parser.ReadSequence(&algorithm_identifier_parser))
return false;
// There shouldn't be anything after the sequence. This is by definition,
// as the input to this function is expected to be a single
// AlgorithmIdentifier.
if (parser.HasMore())
return false;
if (!algorithm_identifier_parser.ReadTag(der::kOid, algorithm))
return false;
// Read the optional parameters to a der::Input. The parameters can be at
// most one TLV (for instance NULL or a sequence).
//
// Note that nothing is allowed after the single optional "parameters" TLV.
// This is because RFC 5912's notation for AlgorithmIdentifier doesn't
// explicitly list an extension point after "parameters".
*parameters = der::Input();
if (algorithm_identifier_parser.HasMore() &&
!algorithm_identifier_parser.ReadRawTLV(parameters)) {
return false;
}
return !algorithm_identifier_parser.HasMore();
}
// Returns true if |input| is empty.
WARN_UNUSED_RESULT bool IsEmpty(const der::Input& input) {
return input.Length() == 0;
}
// Returns true if the entirety of the input is a NULL value.
WARN_UNUSED_RESULT bool IsNull(const der::Input& input) {
der::Parser parser(input);
der::Input null_value;
if (!parser.ReadTag(der::kNull, &null_value))
return false;
// NULL values are TLV encoded; the value is expected to be empty.
if (!IsEmpty(null_value))
return false;
// By definition of this function, the entire input must be a NULL.
return !parser.HasMore();
}
// Parses an RSA PKCS#1 v1.5 signature algorithm given the DER-encoded
// "parameters" from the parsed AlgorithmIdentifier, and the hash algorithm
// that was implied by the AlgorithmIdentifier's OID.
//
// Returns a nullptr on failure.
//
// RFC 5912 requires that the parameters for RSA PKCS#1 v1.5 algorithms be NULL
// ("PARAMS TYPE NULL ARE required"), however an empty parameter is also
// allowed for compatibility with non-compliant OCSP responders:
//
// sa-rsaWithSHA1 SIGNATURE-ALGORITHM ::= {
// IDENTIFIER sha1WithRSAEncryption
// PARAMS TYPE NULL ARE required
// HASHES { mda-sha1 }
// PUBLIC-KEYS { pk-rsa }
// SMIME-CAPS {IDENTIFIED BY sha1WithRSAEncryption }
// }
//
// sa-sha256WithRSAEncryption SIGNATURE-ALGORITHM ::= {
// IDENTIFIER sha256WithRSAEncryption
// PARAMS TYPE NULL ARE required
// HASHES { mda-sha256 }
// PUBLIC-KEYS { pk-rsa }
// SMIME-CAPS { IDENTIFIED BY sha256WithRSAEncryption }
// }
//
// sa-sha384WithRSAEncryption SIGNATURE-ALGORITHM ::= {
// IDENTIFIER sha384WithRSAEncryption
// PARAMS TYPE NULL ARE required
// HASHES { mda-sha384 }
// PUBLIC-KEYS { pk-rsa }
// SMIME-CAPS { IDENTIFIED BY sha384WithRSAEncryption }
// }
//
// sa-sha512WithRSAEncryption SIGNATURE-ALGORITHM ::= {
// IDENTIFIER sha512WithRSAEncryption
// PARAMS TYPE NULL ARE required
// HASHES { mda-sha512 }
// PUBLIC-KEYS { pk-rsa }
// SMIME-CAPS { IDENTIFIED BY sha512WithRSAEncryption }
// }
std::unique_ptr<SignatureAlgorithm> ParseRsaPkcs1(DigestAlgorithm digest,
const der::Input& params) {
// TODO(svaldez): Add warning about non-strict parsing.
if (!IsNull(params) && !IsEmpty(params))
return nullptr;
return SignatureAlgorithm::CreateRsaPkcs1(digest);
}
// Parses a DSA signature algorithm given the DER-encoded
// "parameters" from the parsed AlgorithmIdentifier, and the hash algorithm
// that was implied by the AlgorithmIdentifier's OID.
//
// Returns a nullptr on failure.
//
// RFC 5912 requires that the parameters for DSA algorithms be absent.
std::unique_ptr<SignatureAlgorithm> ParseDsa(DigestAlgorithm digest,
const der::Input& params) {
// TODO(svaldez): Add warning about non-strict parsing.
if (!IsNull(params) && !IsEmpty(params))
return nullptr;
return SignatureAlgorithm::CreateDsa(digest);
}
// Parses an ECDSA signature algorithm given the DER-encoded "parameters" from
// the parsed AlgorithmIdentifier, and the hash algorithm that was implied by
// the AlgorithmIdentifier's OID.
//
// On failure returns a nullptr.
//
// RFC 5912 requires that the parameters for ECDSA algorithms be absent
// ("PARAMS TYPE NULL ARE absent"):
//
// sa-ecdsaWithSHA1 SIGNATURE-ALGORITHM ::= {
// IDENTIFIER ecdsa-with-SHA1
// VALUE ECDSA-Sig-Value
// PARAMS TYPE NULL ARE absent
// HASHES { mda-sha1 }
// PUBLIC-KEYS { pk-ec }
// SMIME-CAPS {IDENTIFIED BY ecdsa-with-SHA1 }
// }
//
// sa-ecdsaWithSHA256 SIGNATURE-ALGORITHM ::= {
// IDENTIFIER ecdsa-with-SHA256
// VALUE ECDSA-Sig-Value
// PARAMS TYPE NULL ARE absent
// HASHES { mda-sha256 }
// PUBLIC-KEYS { pk-ec }
// SMIME-CAPS { IDENTIFIED BY ecdsa-with-SHA256 }
// }
//
// sa-ecdsaWithSHA384 SIGNATURE-ALGORITHM ::= {
// IDENTIFIER ecdsa-with-SHA384
// VALUE ECDSA-Sig-Value
// PARAMS TYPE NULL ARE absent
// HASHES { mda-sha384 }
// PUBLIC-KEYS { pk-ec }
// SMIME-CAPS { IDENTIFIED BY ecdsa-with-SHA384 }
// }
//
// sa-ecdsaWithSHA512 SIGNATURE-ALGORITHM ::= {
// IDENTIFIER ecdsa-with-SHA512
// VALUE ECDSA-Sig-Value
// PARAMS TYPE NULL ARE absent
// HASHES { mda-sha512 }
// PUBLIC-KEYS { pk-ec }
// SMIME-CAPS { IDENTIFIED BY ecdsa-with-SHA512 }
// }
std::unique_ptr<SignatureAlgorithm> ParseEcdsa(DigestAlgorithm digest,
const der::Input& params) {
if (!IsEmpty(params))
return nullptr;
return SignatureAlgorithm::CreateEcdsa(digest);
}
// Parses a MaskGenAlgorithm as defined by RFC 5912:
//
// MaskGenAlgorithm ::= AlgorithmIdentifier{ALGORITHM,
// {PKCS1MGFAlgorithms}}
//
// mgf1SHA1 MaskGenAlgorithm ::= {
// algorithm id-mgf1,
// parameters HashAlgorithm : sha1Identifier
// }
//
// --
// -- Define the set of mask generation functions
// --
// -- If the identifier is id-mgf1, any of the listed hash
// -- algorithms may be used.
// --
//
// PKCS1MGFAlgorithms ALGORITHM ::= {
// { IDENTIFIER id-mgf1 PARAMS TYPE HashAlgorithm ARE required },
// ...
// }
//
// Note that the possible mask gen algorithms is extensible. However at present
// the only function supported is MGF1, as that is the singular mask gen
// function defined by RFC 4055 / RFC 5912.
WARN_UNUSED_RESULT bool ParseMaskGenAlgorithm(const der::Input input,
DigestAlgorithm* mgf1_hash) {
der::Input oid;
der::Input params;
if (!ParseAlgorithmIdentifier(input, &oid, &params))
return false;
// MGF1 is the only supported mask generation algorithm.
if (oid != der::Input(kOidMgf1))
return false;
return ParseHashAlgorithm(params, mgf1_hash);
}
// Consumes an optional, explicitly-tagged INTEGER from |parser|, using the
// indicated context-specific class number. Values greater than 32-bits will be
// rejected.
//
// Returns true on success and sets |*present| to true if the field was present.
WARN_UNUSED_RESULT bool ReadOptionalContextSpecificUint32(der::Parser* parser,
uint8_t class_number,
uint32_t* out,
bool* present) {
der::Input value;
bool has_value;
// Read the context specific value.
if (!parser->ReadOptionalTag(der::ContextSpecificConstructed(class_number),
&value, &has_value)) {
return false;
}
if (has_value) {
// Parse the integer contained in it.
der::Parser number_parser(value);
uint64_t uint64_value;
if (!number_parser.ReadUint64(&uint64_value))
return false;
if (number_parser.HasMore())
return false;
// Cast the number to a uint32_t
base::CheckedNumeric<uint32_t> casted(uint64_value);
if (!casted.IsValid())
return false;
*out = casted.ValueOrDie();
}
*present = has_value;
return true;
}
// Parses the parameters for an RSASSA-PSS signature algorithm, as defined by
// RFC 5912:
//
// sa-rsaSSA-PSS SIGNATURE-ALGORITHM ::= {
// IDENTIFIER id-RSASSA-PSS
// PARAMS TYPE RSASSA-PSS-params ARE required
// HASHES { mda-sha1 | mda-sha224 | mda-sha256 | mda-sha384
// | mda-sha512 }
// PUBLIC-KEYS { pk-rsa | pk-rsaSSA-PSS }
// SMIME-CAPS { IDENTIFIED BY id-RSASSA-PSS }
// }
//
// RSASSA-PSS-params ::= SEQUENCE {
// hashAlgorithm [0] HashAlgorithm DEFAULT sha1Identifier,
// maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1,
// saltLength [2] INTEGER DEFAULT 20,
// trailerField [3] INTEGER DEFAULT 1
// }
//
// Which is to say the parameters MUST be present, and of type
// RSASSA-PSS-params.
std::unique_ptr<SignatureAlgorithm> ParseRsaPss(const der::Input& params) {
der::Parser parser(params);
der::Parser params_parser;
if (!parser.ReadSequence(&params_parser))
return nullptr;
// There shouldn't be anything after the sequence (by definition the
// parameters is a single sequence).
if (parser.HasMore())
return nullptr;
bool has_field;
der::Input field;
// Parse:
// hashAlgorithm [0] HashAlgorithm DEFAULT sha1Identifier,
DigestAlgorithm hash = DigestAlgorithm::Sha1;
if (!params_parser.ReadOptionalTag(der::ContextSpecificConstructed(0), &field,
&has_field)) {
return nullptr;
}
if (has_field && !ParseHashAlgorithm(field, &hash))
return nullptr;
// Parse:
// maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1,
DigestAlgorithm mgf1_hash = DigestAlgorithm::Sha1;
if (!params_parser.ReadOptionalTag(der::ContextSpecificConstructed(1), &field,
&has_field)) {
return nullptr;
}
if (has_field && !ParseMaskGenAlgorithm(field, &mgf1_hash))
return nullptr;
// Parse:
// saltLength [2] INTEGER DEFAULT 20,
uint32_t salt_length = 20u;
if (!ReadOptionalContextSpecificUint32(&params_parser, 2, &salt_length,
&has_field)) {
return nullptr;
}
// Parse:
// trailerField [3] INTEGER DEFAULT 1
uint32_t trailer_field = 1u;
if (!ReadOptionalContextSpecificUint32(&params_parser, 3, &trailer_field,
&has_field)) {
return nullptr;
}
// RFC 4055 says that the trailer field must be 1:
//
// The trailerField field is an integer. It provides
// compatibility with IEEE Std 1363a-2004 [P1363A]. The value
// MUST be 1, which represents the trailer field with hexadecimal
// value 0xBC. Other trailer fields, including the trailer field
// composed of HashID concatenated with 0xCC that is specified in
// IEEE Std 1363a, are not supported. Implementations that
// perform signature generation MUST omit the trailerField field,
// indicating that the default trailer field value was used.
// Implementations that perform signature validation MUST
// recognize both a present trailerField field with value 1 and an
// absent trailerField field.
if (trailer_field != 1)
return nullptr;
// There must not be any unconsumed data left. (RFC 5912 does not explicitly
// include an extensibility point for RSASSA-PSS-params)
if (params_parser.HasMore())
return nullptr;
return SignatureAlgorithm::CreateRsaPss(hash, mgf1_hash, salt_length);
}
DEFINE_CERT_ERROR_ID(kUnknownAlgorithmIdentifierOid,
"Unknown AlgorithmIdentifier OID");
} // namespace
WARN_UNUSED_RESULT bool ParseHashAlgorithm(const der::Input& input,
DigestAlgorithm* out) {
CBS cbs;
CBS_init(&cbs, input.UnsafeData(), input.Length());
const EVP_MD* md = EVP_parse_digest_algorithm(&cbs);
if (md == EVP_sha1()) {
*out = DigestAlgorithm::Sha1;
} else if (md == EVP_sha256()) {
*out = DigestAlgorithm::Sha256;
} else if (md == EVP_sha384()) {
*out = DigestAlgorithm::Sha384;
} else if (md == EVP_sha512()) {
*out = DigestAlgorithm::Sha512;
} else {
// TODO(eroman): Support MD2, MD4, MD5 for completeness?
// Unsupported digest algorithm.
return false;
}
return true;
}
RsaPssParameters::RsaPssParameters(DigestAlgorithm mgf1_hash,
uint32_t salt_length)
: mgf1_hash_(mgf1_hash), salt_length_(salt_length) {
}
SignatureAlgorithm::~SignatureAlgorithm() = default;
std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::Create(
const der::Input& algorithm_identifier,
CertErrors* errors) {
// TODO(crbug.com/634443): Add useful error information.
der::Input oid;
der::Input params;
if (!ParseAlgorithmIdentifier(algorithm_identifier, &oid, &params))
return nullptr;
// TODO(eroman): Each OID is tested for equality in order, which is not
// particularly efficient.
if (oid == der::Input(kOidSha1WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Sha1, params);
if (oid == der::Input(kOidSha256WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Sha256, params);
if (oid == der::Input(kOidSha384WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Sha384, params);
if (oid == der::Input(kOidSha512WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Sha512, params);
if (oid == der::Input(kOidEcdsaWithSha1))
return ParseEcdsa(DigestAlgorithm::Sha1, params);
if (oid == der::Input(kOidEcdsaWithSha256))
return ParseEcdsa(DigestAlgorithm::Sha256, params);
if (oid == der::Input(kOidEcdsaWithSha384))
return ParseEcdsa(DigestAlgorithm::Sha384, params);
if (oid == der::Input(kOidEcdsaWithSha512))
return ParseEcdsa(DigestAlgorithm::Sha512, params);
if (oid == der::Input(kOidRsaSsaPss))
return ParseRsaPss(params);
if (oid == der::Input(kOidSha1WithRsaSignature))
return ParseRsaPkcs1(DigestAlgorithm::Sha1, params);
if (oid == der::Input(kOidMd2WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Md2, params);
if (oid == der::Input(kOidMd4WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Md4, params);
if (oid == der::Input(kOidMd5WithRsaEncryption))
return ParseRsaPkcs1(DigestAlgorithm::Md5, params);
if (oid == der::Input(kOidDsaWithSha1))
return ParseDsa(DigestAlgorithm::Sha1, params);
if (oid == der::Input(kOidDsaWithSha256))
return ParseDsa(DigestAlgorithm::Sha256, params);
// Unknown OID.
if (errors) {
errors->AddError(kUnknownAlgorithmIdentifierOid,
CreateCertErrorParams2Der("oid", oid, "params", params));
}
return nullptr;
}
std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateRsaPkcs1(
DigestAlgorithm digest) {
return base::WrapUnique(
new SignatureAlgorithm(SignatureAlgorithmId::RsaPkcs1, digest, nullptr));
}
std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateDsa(
DigestAlgorithm digest) {
return base::WrapUnique(
new SignatureAlgorithm(SignatureAlgorithmId::Dsa, digest, nullptr));
}
std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateEcdsa(
DigestAlgorithm digest) {
return base::WrapUnique(
new SignatureAlgorithm(SignatureAlgorithmId::Ecdsa, digest, nullptr));
}
std::unique_ptr<SignatureAlgorithm> SignatureAlgorithm::CreateRsaPss(
DigestAlgorithm digest,
DigestAlgorithm mgf1_hash,
uint32_t salt_length) {
return base::WrapUnique(new SignatureAlgorithm(
SignatureAlgorithmId::RsaPss, digest,
std::make_unique<RsaPssParameters>(mgf1_hash, salt_length)));
}
const RsaPssParameters* SignatureAlgorithm::ParamsForRsaPss() const {
if (algorithm_ == SignatureAlgorithmId::RsaPss)
return static_cast<RsaPssParameters*>(params_.get());
return nullptr;
}
bool SignatureAlgorithm::IsEquivalent(const der::Input& alg1_tlv,
const der::Input& alg2_tlv) {
if (alg1_tlv == alg2_tlv)
return true;
std::unique_ptr<SignatureAlgorithm> alg1 = Create(alg1_tlv, nullptr);
std::unique_ptr<SignatureAlgorithm> alg2 = Create(alg2_tlv, nullptr);
// Do checks that apply to all algorithms.
if (!alg1 || !alg2 || (alg1->algorithm() != alg2->algorithm()) ||
(alg1->digest() != alg2->digest())) {
return false;
}
// Check algorithm-specific parameters for equality.
switch (alg1->algorithm()) {
case SignatureAlgorithmId::RsaPkcs1:
case SignatureAlgorithmId::Ecdsa:
case SignatureAlgorithmId::Dsa:
DCHECK(!alg1->has_params());
DCHECK(!alg2->has_params());
return true;
case SignatureAlgorithmId::RsaPss: {
const RsaPssParameters* params1 = alg1->ParamsForRsaPss();
const RsaPssParameters* params2 = alg2->ParamsForRsaPss();
return params1 && params2 &&
(params1->salt_length() == params2->salt_length()) &&
(params1->mgf1_hash() == params2->mgf1_hash());
}
}
return false;
}
SignatureAlgorithm::SignatureAlgorithm(
SignatureAlgorithmId algorithm,
DigestAlgorithm digest,
std::unique_ptr<SignatureAlgorithmParameters> params)
: algorithm_(algorithm), digest_(digest), params_(std::move(params)) {}
} // namespace net