Bug 1756061 - PSM changes corresponding to mozilla::pkix signature verification changes in bug 1755092 r=jschanck

Bug 1755092 changed how mozilla::pkix verifies signatures. This patch makes the
corresponding changes in PSM.

Depends on D140597

Differential Revision: https://phabricator.services.mozilla.com/D139202

security/apps/AppTrustDomain.cpp

@@ -228,11 +228,13 @@ Result AppTrustDomain::CheckRSAPublicKeyModulusSizeInBits(
   return Success;
 }
 
-Result AppTrustDomain::VerifyRSAPKCS1SignedDigest(
+Result AppTrustDomain::VerifyRSAPKCS1SignedData(Input data,
-    const SignedDigest& signedDigest, Input subjectPublicKeyInfo) {
+                                                DigestAlgorithm digestAlgorithm,
+                                                Input signature,
+                                                Input subjectPublicKeyInfo) {
   // TODO: We should restrict signatures to SHA-256 or better.
-  return VerifyRSAPKCS1SignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+  return VerifyRSAPKCS1SignedDataNSS(data, digestAlgorithm, signature,
-                                       nullptr);
+                                     subjectPublicKeyInfo, nullptr);
 }
 
 Result AppTrustDomain::CheckECDSACurveIsAcceptable(
@@ -247,10 +249,12 @@ Result AppTrustDomain::CheckECDSACurveIsAcceptable(
   return Result::ERROR_UNSUPPORTED_ELLIPTIC_CURVE;
 }
 
-Result AppTrustDomain::VerifyECDSASignedDigest(const SignedDigest& signedDigest,
+Result AppTrustDomain::VerifyECDSASignedData(Input data,
-                                               Input subjectPublicKeyInfo) {
+                                             DigestAlgorithm digestAlgorithm,
-  return VerifyECDSASignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+                                             Input signature,
-                                    nullptr);
+                                             Input subjectPublicKeyInfo) {
+  return VerifyECDSASignedDataNSS(data, digestAlgorithm, signature,
+                                  subjectPublicKeyInfo, nullptr);
 }
 
 Result AppTrustDomain::CheckValidityIsAcceptable(

security/apps/AppTrustDomain.h

@@ -51,14 +51,16 @@ class AppTrustDomain final : public mozilla::pkix::TrustDomain {
   virtual Result CheckRSAPublicKeyModulusSizeInBits(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       unsigned int modulusSizeInBits) override;
-  virtual Result VerifyRSAPKCS1SignedDigest(
+  virtual Result VerifyRSAPKCS1SignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
   virtual Result CheckECDSACurveIsAcceptable(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       mozilla::pkix::NamedCurve curve) override;
-  virtual Result VerifyECDSASignedDigest(
+  virtual Result VerifyECDSASignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
   virtual Result CheckValidityIsAcceptable(
       mozilla::pkix::Time notBefore, mozilla::pkix::Time notAfter,

security/certverifier/NSSCertDBTrustDomain.cpp

@@ -161,15 +161,8 @@ static bool ShouldSkipSelfSignedNonTrustAnchor(TrustDomain& trustDomain,
   if (trust != TrustLevel::InheritsTrust) {
     return false;
   }
-  uint8_t digestBuf[MAX_DIGEST_SIZE_IN_BYTES];
+  if (VerifySignedData(trustDomain, cert.GetSignedData(),
-  pkix::der::PublicKeyAlgorithm publicKeyAlg;
+                       cert.GetSubjectPublicKeyInfo()) != Success) {
-  SignedDigest signature;
-  if (DigestSignedData(trustDomain, cert.GetSignedData(), digestBuf,
-                       publicKeyAlg, signature) != Success) {
-    return false;
-  }
-  if (VerifySignedDigest(trustDomain, publicKeyAlg, signature,
-                         cert.GetSubjectPublicKeyInfo()) != Success) {
     return false;
   }
   // This is a self-signed, non-trust-anchor certificate, so we shouldn't use it
@@ -1479,10 +1472,11 @@ Result NSSCertDBTrustDomain::CheckRSAPublicKeyModulusSizeInBits(
   return Success;
 }
 
-Result NSSCertDBTrustDomain::VerifyRSAPKCS1SignedDigest(
+Result NSSCertDBTrustDomain::VerifyRSAPKCS1SignedData(
-    const SignedDigest& signedDigest, Input subjectPublicKeyInfo) {
+    Input data, DigestAlgorithm digestAlgorithm, Input signature,
-  return VerifyRSAPKCS1SignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+    Input subjectPublicKeyInfo) {
-                                       mPinArg);
+  return VerifyRSAPKCS1SignedDataNSS(data, digestAlgorithm, signature,
+                                     subjectPublicKeyInfo, mPinArg);
 }
 
 Result NSSCertDBTrustDomain::CheckECDSACurveIsAcceptable(
@@ -1497,10 +1491,11 @@ Result NSSCertDBTrustDomain::CheckECDSACurveIsAcceptable(
   return Result::ERROR_UNSUPPORTED_ELLIPTIC_CURVE;
 }
 
-Result NSSCertDBTrustDomain::VerifyECDSASignedDigest(
+Result NSSCertDBTrustDomain::VerifyECDSASignedData(
-    const SignedDigest& signedDigest, Input subjectPublicKeyInfo) {
+    Input data, DigestAlgorithm digestAlgorithm, Input signature,
-  return VerifyECDSASignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+    Input subjectPublicKeyInfo) {
-                                    mPinArg);
+  return VerifyECDSASignedDataNSS(data, digestAlgorithm, signature,
+                                  subjectPublicKeyInfo, mPinArg);
 }
 
 Result NSSCertDBTrustDomain::CheckValidityIsAcceptable(

security/certverifier/NSSCertDBTrustDomain.h

@@ -171,16 +171,18 @@ class NSSCertDBTrustDomain : public mozilla::pkix::TrustDomain {
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       unsigned int modulusSizeInBits) override;
 
-  virtual Result VerifyRSAPKCS1SignedDigest(
+  virtual Result VerifyRSAPKCS1SignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
 
   virtual Result CheckECDSACurveIsAcceptable(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       mozilla::pkix::NamedCurve curve) override;
 
-  virtual Result VerifyECDSASignedDigest(
+  virtual Result VerifyECDSASignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
 
   virtual Result DigestBuf(mozilla::pkix::Input item,

security/certverifier/OCSPVerificationTrustDomain.cpp

@@ -59,10 +59,11 @@ Result OCSPVerificationTrustDomain::CheckRSAPublicKeyModulusSizeInBits(
       aEEOrCA, aModulusSizeInBits);
 }
 
-Result OCSPVerificationTrustDomain::VerifyRSAPKCS1SignedDigest(
+Result OCSPVerificationTrustDomain::VerifyRSAPKCS1SignedData(
-    const SignedDigest& aSignedDigest, Input aSubjectPublicKeyInfo) {
+    Input data, DigestAlgorithm digestAlgorithm, Input signature,
-  return mCertDBTrustDomain.VerifyRSAPKCS1SignedDigest(aSignedDigest,
+    Input subjectPublicKeyInfo) {
-                                                       aSubjectPublicKeyInfo);
+  return mCertDBTrustDomain.VerifyRSAPKCS1SignedData(
+      data, digestAlgorithm, signature, subjectPublicKeyInfo);
 }
 
 Result OCSPVerificationTrustDomain::CheckECDSACurveIsAcceptable(
@@ -70,10 +71,11 @@ Result OCSPVerificationTrustDomain::CheckECDSACurveIsAcceptable(
   return mCertDBTrustDomain.CheckECDSACurveIsAcceptable(aEEOrCA, aCurve);
 }
 
-Result OCSPVerificationTrustDomain::VerifyECDSASignedDigest(
+Result OCSPVerificationTrustDomain::VerifyECDSASignedData(
-    const SignedDigest& aSignedDigest, Input aSubjectPublicKeyInfo) {
+    Input data, DigestAlgorithm digestAlgorithm, Input signature,
-  return mCertDBTrustDomain.VerifyECDSASignedDigest(aSignedDigest,
+    Input subjectPublicKeyInfo) {
-                                                    aSubjectPublicKeyInfo);
+  return mCertDBTrustDomain.VerifyECDSASignedData(
+      data, digestAlgorithm, signature, subjectPublicKeyInfo);
 }
 
 Result OCSPVerificationTrustDomain::CheckValidityIsAcceptable(

security/certverifier/OCSPVerificationTrustDomain.h

@@ -38,16 +38,18 @@ class OCSPVerificationTrustDomain : public mozilla::pkix::TrustDomain {
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       unsigned int modulusSizeInBits) override;
 
-  virtual Result VerifyRSAPKCS1SignedDigest(
+  virtual Result VerifyRSAPKCS1SignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
 
   virtual Result CheckECDSACurveIsAcceptable(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       mozilla::pkix::NamedCurve curve) override;
 
-  virtual Result VerifyECDSASignedDigest(
+  virtual Result VerifyECDSASignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
 
   virtual Result DigestBuf(mozilla::pkix::Input item,

security/ct/BTVerifier.cpp

@@ -100,54 +100,23 @@ Result DecodeAndVerifySignedTreeHead(
     return rv;
   }
 
-  SECOidTag unusedDigestAlgorithmId;
-  size_t digestAlgorithmLength;
-  rv = GetDigestAlgorithmLengthAndIdentifier(
-      digestAlgorithm, digestAlgorithmLength, unusedDigestAlgorithmId);
-  if (rv != Success) {
-    return rv;
-  }
-
-  uint8_t digestBuf[MAX_DIGEST_SIZE_IN_BYTES];
-  rv = DigestBufNSS(signedDataInput, digestAlgorithm, digestBuf,
-                    digestAlgorithmLength);
-  if (rv != Success) {
-    return rv;
-  }
-
-  Input digestInput;
-  rv = digestInput.Init(digestBuf, digestAlgorithmLength);
-  if (rv != Success) {
-    return rv;
-  }
-
   Input signatureInput;
   rv = ReadVariableBytes<kSTHSignatureLengthBytes>(reader, signatureInput);
   if (rv != Success) {
     return rv;
   }
 
-  SignedDigest signedDigest = {digestInput, digestAlgorithm, signatureInput};
   switch (publicKeyAlgorithm) {
     case der::PublicKeyAlgorithm::ECDSA:
-      rv = VerifyECDSASignedDigestNSS(signedDigest, signerSubjectPublicKeyInfo,
+      rv = VerifyECDSASignedDataNSS(signedDataInput, digestAlgorithm,
-                                      nullptr);
+                                    signatureInput, signerSubjectPublicKeyInfo,
+                                    nullptr);
       break;
     case der::PublicKeyAlgorithm::RSA_PKCS1:
-    case der::PublicKeyAlgorithm::Uninitialized:
     default:
       return Result::FATAL_ERROR_INVALID_ARGS;
   }
   if (rv != Success) {
-    // VerifyECDSASignedDigestNSS eventually calls VFY_VerifyDigestDirect, which
-    // can set the PR error code to SEC_ERROR_PKCS7_KEYALG_MISMATCH if the type
-    // of key decoded from the SPKI does not match the given signature
-    // algorithm. mozilla::pkix does not have a corresponding Result value and
-    // turns this error code into Result::ERROR_UNKNOWN_ERROR. Since this is
-    // uninformative, we'll turn that result into a bad signature error.
-    if (rv == Result::ERROR_UNKNOWN_ERROR) {
-      return Result::ERROR_BAD_SIGNATURE;
-    }
     return rv;
   }
 

security/ct/CTLogVerifier.cpp

@@ -66,7 +66,7 @@ class SignatureParamsTrustDomain final : public TrustDomain {
     return Success;
   }
 
-  Result VerifyECDSASignedDigest(const SignedDigest&, Input) override {
+  Result VerifyECDSASignedData(Input, DigestAlgorithm, Input, Input) override {
     return Result::FATAL_ERROR_LIBRARY_FAILURE;
   }
 
@@ -82,7 +82,8 @@ class SignatureParamsTrustDomain final : public TrustDomain {
     return Success;
   }
 
-  Result VerifyRSAPKCS1SignedDigest(const SignedDigest&, Input) override {
+  Result VerifyRSAPKCS1SignedData(Input, DigestAlgorithm, Input,
+                                  Input) override {
     return Result::FATAL_ERROR_LIBRARY_FAILURE;
   }
 
@@ -216,8 +217,8 @@ bool CTLogVerifier::SignatureParametersMatch(const DigitallySigned& signature) {
       DigitallySigned::HashAlgorithm::SHA256, mSignatureAlgorithm);
 }
 
-static Result FasterVerifyECDSASignedDigestNSS(const SignedDigest& sd,
+static Result FasterVerifyECDSASignedDataNSS(Input data, Input signature,
-                                               UniqueSECKEYPublicKey& pubkey) {
+                                             UniqueSECKEYPublicKey& pubkey) {
   assert(pubkey);
   if (!pubkey) {
     return Result::FATAL_ERROR_LIBRARY_FAILURE;
@@ -226,7 +227,7 @@ static Result FasterVerifyECDSASignedDigestNSS(const SignedDigest& sd,
   // expects the signature as only the two integers r and s (so no encoding -
   // just two series of bytes each half as long as SECKEY_SignatureLen(pubkey)).
   // DSAU_DecodeDerSigToLen converts from the former format to the latter.
-  SECItem derSignatureSECItem(UnsafeMapInputToSECItem(sd.signature));
+  SECItem derSignatureSECItem(UnsafeMapInputToSECItem(signature));
   size_t signatureLen = SECKEY_SignatureLen(pubkey.get());
   if (signatureLen == 0) {
     return MapPRErrorCodeToResult(PR_GetError());
@@ -236,47 +237,30 @@ static Result FasterVerifyECDSASignedDigestNSS(const SignedDigest& sd,
   if (!signatureSECItem) {
     return MapPRErrorCodeToResult(PR_GetError());
   }
-  SECItem digestSECItem(UnsafeMapInputToSECItem(sd.digest));
+  SECItem dataSECItem(UnsafeMapInputToSECItem(data));
-  SECStatus srv = PK11_Verify(pubkey.get(), signatureSECItem.get(),
+  SECStatus srv =
-                              &digestSECItem, nullptr);
+      PK11_VerifyWithMechanism(pubkey.get(), CKM_ECDSA_SHA256, nullptr,
+                               signatureSECItem.get(), &dataSECItem, nullptr);
   if (srv != SECSuccess) {
     return MapPRErrorCodeToResult(PR_GetError());
   }
-
   return Success;
 }
 
 Result CTLogVerifier::VerifySignature(Input data, Input signature) {
-  uint8_t digest[SHA256_LENGTH];
-  Result rv = DigestBufNSS(data, DigestAlgorithm::sha256, digest,
-                           MOZILLA_CT_ARRAY_LENGTH(digest));
-  if (rv != Success) {
-    return rv;
-  }
-
-  SignedDigest signedDigest;
-  signedDigest.digestAlgorithm = DigestAlgorithm::sha256;
-  rv = signedDigest.digest.Init(digest, MOZILLA_CT_ARRAY_LENGTH(digest));
-  if (rv != Success) {
-    return rv;
-  }
-  rv = signedDigest.signature.Init(signature);
-  if (rv != Success) {
-    return rv;
-  }
-
   Input spki;
-  rv = BufferToInput(mSubjectPublicKeyInfo, spki);
+  Result rv = BufferToInput(mSubjectPublicKeyInfo, spki);
   if (rv != Success) {
     return rv;
   }
 
   switch (mSignatureAlgorithm) {
     case DigitallySigned::SignatureAlgorithm::RSA:
-      rv = VerifyRSAPKCS1SignedDigestNSS(signedDigest, spki, nullptr);
+      rv = VerifyRSAPKCS1SignedDataNSS(data, DigestAlgorithm::sha256, signature,
+                                       spki, nullptr);
       break;
     case DigitallySigned::SignatureAlgorithm::ECDSA:
-      rv = FasterVerifyECDSASignedDigestNSS(signedDigest, mPublicECKey);
+      rv = FasterVerifyECDSASignedDataNSS(data, signature, mPublicECKey);
       break;
     // We do not expect new values added to this enum any time soon,
     // so just listing all the available ones seems to be the easiest way

security/ct/tests/gtest/BTSignedTreeHeadTest.cpp

@@ -125,7 +125,7 @@ static const BTSignedTreeHeadTestParams BT_SIGNED_TREE_HEAD_TEST_PARAMS[] = {
      Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {ValidSTH::kSPKIHex, pkix::DigestAlgorithm::sha512,
      pkix::der::PublicKeyAlgorithm::ECDSA, ValidSecp521r1SHA512STH::kSTHHex,
-     Result::ERROR_BAD_DER, 0, 0, nullptr},
+     Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {SignatureCoversLogIDSTH::kSPKIHex, pkix::DigestAlgorithm::sha256,
      pkix::der::PublicKeyAlgorithm::ECDSA, SignatureCoversLogIDSTH::kSTHHex,
      Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
@@ -134,7 +134,7 @@ static const BTSignedTreeHeadTestParams BT_SIGNED_TREE_HEAD_TEST_PARAMS[] = {
      Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {WrongSigningKeySTH::kSPKIHex, pkix::DigestAlgorithm::sha256,
      pkix::der::PublicKeyAlgorithm::ECDSA, WrongSigningKeySTH::kSTHHex,
-     Result::ERROR_BAD_DER, 0, 0, nullptr},
+     Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {MissingLogIDSTH::kSPKIHex, pkix::DigestAlgorithm::sha256,
      pkix::der::PublicKeyAlgorithm::ECDSA, MissingLogIDSTH::kSTHHex,
      Result::ERROR_BAD_DER, 0, 0, nullptr},
@@ -170,10 +170,10 @@ static const BTSignedTreeHeadTestParams BT_SIGNED_TREE_HEAD_TEST_PARAMS[] = {
      Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {RSASignerECSPKISTH::kSPKIHex, pkix::DigestAlgorithm::sha256,
      pkix::der::PublicKeyAlgorithm::ECDSA, RSASignerECSPKISTH::kSTHHex,
-     Result::ERROR_BAD_DER, 0, 0, nullptr},
+     Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
     {ECSignerRSASPKISTH::kSPKIHex, pkix::DigestAlgorithm::sha256,
      pkix::der::PublicKeyAlgorithm::ECDSA, ECSignerRSASPKISTH::kSTHHex,
-     Result::ERROR_BAD_SIGNATURE, 0, 0, nullptr},
+     Result::ERROR_INVALID_KEY, 0, 0, nullptr},
 };
 
 TEST_P(BTSignedTreeHeadTest, BTSignedTreeHeadSimpleTest) {

security/ct/tests/gtest/CTTestUtils.cpp

@@ -705,10 +705,12 @@ class OCSPExtensionTrustDomain : public TrustDomain {
     return pkix::Result::FATAL_ERROR_LIBRARY_FAILURE;
   }
 
-  pkix::Result VerifyECDSASignedDigest(const SignedDigest& signedDigest,
+  pkix::Result VerifyECDSASignedData(Input data,
-                                       Input subjectPublicKeyInfo) override {
+                                     DigestAlgorithm digestAlgorithm,
-    return VerifyECDSASignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+                                     Input signature,
-                                      nullptr);
+                                     Input subjectPublicKeyInfo) override {
+    return VerifyECDSASignedDataNSS(data, digestAlgorithm, signature,
+                                    subjectPublicKeyInfo, nullptr);
   }
 
   pkix::Result CheckRSAPublicKeyModulusSizeInBits(EndEntityOrCA,
@@ -717,10 +719,12 @@ class OCSPExtensionTrustDomain : public TrustDomain {
     return pkix::Result::FATAL_ERROR_LIBRARY_FAILURE;
   }
 
-  pkix::Result VerifyRSAPKCS1SignedDigest(const SignedDigest& signedDigest,
+  pkix::Result VerifyRSAPKCS1SignedData(Input data,
-                                          Input subjectPublicKeyInfo) override {
+                                        DigestAlgorithm digestAlgorithm,
-    return VerifyRSAPKCS1SignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+                                        Input signature,
-                                         nullptr);
+                                        Input subjectPublicKeyInfo) override {
+    return VerifyRSAPKCS1SignedDataNSS(data, digestAlgorithm, signature,
+                                       subjectPublicKeyInfo, nullptr);
   }
 
   pkix::Result CheckValidityIsAcceptable(Time, Time, EndEntityOrCA,

security/manager/ssl/CSTrustDomain.cpp

@@ -145,10 +145,12 @@ Result CSTrustDomain::CheckRSAPublicKeyModulusSizeInBits(
   return Success;
 }
 
-Result CSTrustDomain::VerifyRSAPKCS1SignedDigest(
+Result CSTrustDomain::VerifyRSAPKCS1SignedData(Input data,
-    const SignedDigest& signedDigest, Input subjectPublicKeyInfo) {
+                                               DigestAlgorithm digestAlgorithm,
-  return VerifyRSAPKCS1SignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+                                               Input signature,
-                                       nullptr);
+                                               Input subjectPublicKeyInfo) {
+  return VerifyRSAPKCS1SignedDataNSS(data, digestAlgorithm, signature,
+                                     subjectPublicKeyInfo, nullptr);
 }
 
 Result CSTrustDomain::CheckECDSACurveIsAcceptable(EndEntityOrCA endEntityOrCA,
@@ -163,10 +165,12 @@ Result CSTrustDomain::CheckECDSACurveIsAcceptable(EndEntityOrCA endEntityOrCA,
   return Result::ERROR_UNSUPPORTED_ELLIPTIC_CURVE;
 }
 
-Result CSTrustDomain::VerifyECDSASignedDigest(const SignedDigest& signedDigest,
+Result CSTrustDomain::VerifyECDSASignedData(Input data,
-                                              Input subjectPublicKeyInfo) {
+                                            DigestAlgorithm digestAlgorithm,
-  return VerifyECDSASignedDigestNSS(signedDigest, subjectPublicKeyInfo,
+                                            Input signature,
-                                    nullptr);
+                                            Input subjectPublicKeyInfo) {
+  return VerifyECDSASignedDataNSS(data, digestAlgorithm, signature,
+                                  subjectPublicKeyInfo, nullptr);
 }
 
 Result CSTrustDomain::CheckValidityIsAcceptable(Time notBefore, Time notAfter,

security/manager/ssl/CSTrustDomain.h

@@ -46,14 +46,16 @@ class CSTrustDomain final : public mozilla::pkix::TrustDomain {
   virtual Result CheckRSAPublicKeyModulusSizeInBits(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       unsigned int modulusSizeInBits) override;
-  virtual Result VerifyRSAPKCS1SignedDigest(
+  virtual Result VerifyRSAPKCS1SignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
   virtual Result CheckECDSACurveIsAcceptable(
       mozilla::pkix::EndEntityOrCA endEntityOrCA,
       mozilla::pkix::NamedCurve curve) override;
-  virtual Result VerifyECDSASignedDigest(
+  virtual Result VerifyECDSASignedData(
-      const mozilla::pkix::SignedDigest& signedDigest,
+      mozilla::pkix::Input data, mozilla::pkix::DigestAlgorithm digestAlgorithm,
+      mozilla::pkix::Input signature,
       mozilla::pkix::Input subjectPublicKeyInfo) override;
   virtual Result CheckValidityIsAcceptable(
       mozilla::pkix::Time notBefore, mozilla::pkix::Time notAfter,

security/manager/ssl/nsNSSIOLayer.cpp

@@ -2061,16 +2061,18 @@ class ClientAuthCertNonverifyingTrustDomain final : public TrustDomain {
       EndEntityOrCA endEntityOrCA, unsigned int modulusSizeInBits) override {
     return Success;
   }
-  virtual mozilla::pkix::Result VerifyRSAPKCS1SignedDigest(
+  virtual mozilla::pkix::Result VerifyRSAPKCS1SignedData(
-      const SignedDigest& signedDigest, Input subjectPublicKeyInfo) override {
+      Input data, DigestAlgorithm, Input signature,
+      Input subjectPublicKeyInfo) override {
     return Success;
   }
   virtual mozilla::pkix::Result CheckECDSACurveIsAcceptable(
       EndEntityOrCA endEntityOrCA, NamedCurve curve) override {
     return Success;
   }
-  virtual mozilla::pkix::Result VerifyECDSASignedDigest(
+  virtual mozilla::pkix::Result VerifyECDSASignedData(
-      const SignedDigest& signedDigest, Input subjectPublicKeyInfo) override {
+      Input data, DigestAlgorithm, Input signature,
+      Input subjectPublicKeyInfo) override {
     return Success;
   }
   virtual mozilla::pkix::Result CheckValidityIsAcceptable(