mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-22 00:17:32 +09:00
Update NSS to 3.41
This commit is contained in:
wolfbeast
Roy Tam
parent
d5f6e64f43
commit
5f0986e66f
540 changed files with 49568 additions and 10631 deletions
|
|
@ -15,7 +15,7 @@ extern "C" {
|
|||
}
|
||||
|
||||
#include "gtest_utils.h"
|
||||
#include "scoped_ptrs.h"
|
||||
#include "nss_scoped_ptrs.h"
|
||||
#include "tls_connect.h"
|
||||
#include "tls_filter.h"
|
||||
#include "tls_parser.h"
|
||||
|
|
@ -37,6 +37,50 @@ TEST_P(TlsConnectGeneric, ServerAuthRsaChain) {
|
|||
EXPECT_EQ(2UL, chain_length);
|
||||
}
|
||||
|
||||
TEST_P(TlsConnectTls12Plus, ServerAuthRsaPss) {
|
||||
static const SSLSignatureScheme kSignatureSchemePss[] = {
|
||||
ssl_sig_rsa_pss_pss_sha256};
|
||||
|
||||
Reset(TlsAgent::kServerRsaPss);
|
||||
client_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
server_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
Connect();
|
||||
CheckKeys(ssl_kea_ecdh, ssl_grp_ec_curve25519, ssl_auth_rsa_pss,
|
||||
ssl_sig_rsa_pss_pss_sha256);
|
||||
}
|
||||
|
||||
// PSS doesn't work with TLS 1.0 or 1.1 because we can't signal it.
|
||||
TEST_P(TlsConnectPre12, ServerAuthRsaPssFails) {
|
||||
static const SSLSignatureScheme kSignatureSchemePss[] = {
|
||||
ssl_sig_rsa_pss_pss_sha256};
|
||||
|
||||
Reset(TlsAgent::kServerRsaPss);
|
||||
client_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
server_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
ConnectExpectAlert(server_, kTlsAlertHandshakeFailure);
|
||||
server_->CheckErrorCode(SSL_ERROR_NO_CYPHER_OVERLAP);
|
||||
client_->CheckErrorCode(SSL_ERROR_NO_CYPHER_OVERLAP);
|
||||
}
|
||||
|
||||
// Check that a PSS certificate with no parameters works.
|
||||
TEST_P(TlsConnectTls12Plus, ServerAuthRsaPssNoParameters) {
|
||||
static const SSLSignatureScheme kSignatureSchemePss[] = {
|
||||
ssl_sig_rsa_pss_pss_sha256};
|
||||
|
||||
Reset("rsa_pss_noparam");
|
||||
client_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
server_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
Connect();
|
||||
CheckKeys(ssl_kea_ecdh, ssl_grp_ec_curve25519, ssl_auth_rsa_pss,
|
||||
ssl_sig_rsa_pss_pss_sha256);
|
||||
}
|
||||
|
||||
TEST_P(TlsConnectGeneric, ServerAuthRsaPssChain) {
|
||||
Reset("rsa_pss_chain");
|
||||
Connect();
|
||||
|
|
@ -55,6 +99,76 @@ TEST_P(TlsConnectGeneric, ServerAuthRsaCARsaPssChain) {
|
|||
EXPECT_EQ(2UL, chain_length);
|
||||
}
|
||||
|
||||
TEST_P(TlsConnectGeneric, ServerAuthRejected) {
|
||||
EnsureTlsSetup();
|
||||
client_->SetAuthCertificateCallback(
|
||||
[](TlsAgent*, PRBool, PRBool) -> SECStatus { return SECFailure; });
|
||||
ConnectExpectAlert(client_, kTlsAlertBadCertificate);
|
||||
client_->CheckErrorCode(SSL_ERROR_BAD_CERTIFICATE);
|
||||
server_->CheckErrorCode(SSL_ERROR_BAD_CERT_ALERT);
|
||||
EXPECT_EQ(TlsAgent::STATE_ERROR, client_->state());
|
||||
}
|
||||
|
||||
struct AuthCompleteArgs : public PollTarget {
|
||||
AuthCompleteArgs(const std::shared_ptr<TlsAgent>& a, PRErrorCode c)
|
||||
: agent(a), code(c) {}
|
||||
|
||||
std::shared_ptr<TlsAgent> agent;
|
||||
PRErrorCode code;
|
||||
};
|
||||
|
||||
static void CallAuthComplete(PollTarget* target, Event event) {
|
||||
EXPECT_EQ(TIMER_EVENT, event);
|
||||
auto args = reinterpret_cast<AuthCompleteArgs*>(target);
|
||||
std::cerr << args->agent->role_str() << ": call SSL_AuthCertificateComplete "
|
||||
<< (args->code ? PR_ErrorToName(args->code) : "no error")
|
||||
<< std::endl;
|
||||
EXPECT_EQ(SECSuccess,
|
||||
SSL_AuthCertificateComplete(args->agent->ssl_fd(), args->code));
|
||||
args->agent->Handshake(); // Make the TlsAgent aware of the error.
|
||||
delete args;
|
||||
}
|
||||
|
||||
// Install an AuthCertificateCallback that blocks when called. Then
|
||||
// SSL_AuthCertificateComplete is called on a very short timer. This allows any
|
||||
// processing that might follow the callback to complete.
|
||||
static void SetDeferredAuthCertificateCallback(std::shared_ptr<TlsAgent> agent,
|
||||
PRErrorCode code) {
|
||||
auto args = new AuthCompleteArgs(agent, code);
|
||||
agent->SetAuthCertificateCallback(
|
||||
[args](TlsAgent*, PRBool, PRBool) -> SECStatus {
|
||||
// This can't be 0 or we race the message from the client to the server,
|
||||
// and tests assume that we lose that race.
|
||||
std::shared_ptr<Poller::Timer> timer_handle;
|
||||
Poller::Instance()->SetTimer(1U, args, CallAuthComplete, &timer_handle);
|
||||
return SECWouldBlock;
|
||||
});
|
||||
}
|
||||
|
||||
TEST_P(TlsConnectTls13, ServerAuthRejectAsync) {
|
||||
SetDeferredAuthCertificateCallback(client_, SEC_ERROR_REVOKED_CERTIFICATE);
|
||||
ConnectExpectAlert(client_, kTlsAlertCertificateRevoked);
|
||||
// We only detect the error here when we attempt to handshake, so all the
|
||||
// client learns is that the handshake has already failed.
|
||||
client_->CheckErrorCode(SSL_ERROR_HANDSHAKE_FAILED);
|
||||
server_->CheckErrorCode(SSL_ERROR_REVOKED_CERT_ALERT);
|
||||
}
|
||||
|
||||
// In TLS 1.2 and earlier, this will result in the client sending its Finished
|
||||
// before learning that the server certificate is bad. That means that the
|
||||
// server will believe that the handshake is complete.
|
||||
TEST_P(TlsConnectGenericPre13, ServerAuthRejectAsync) {
|
||||
SetDeferredAuthCertificateCallback(client_, SEC_ERROR_EXPIRED_CERTIFICATE);
|
||||
client_->ExpectSendAlert(kTlsAlertCertificateExpired);
|
||||
server_->ExpectReceiveAlert(kTlsAlertCertificateExpired);
|
||||
ConnectExpectFailOneSide(TlsAgent::CLIENT);
|
||||
client_->CheckErrorCode(SSL_ERROR_HANDSHAKE_FAILED);
|
||||
|
||||
// The server might not receive the alert that the client sends, which would
|
||||
// cause the test to fail when it cleans up. Reset expectations.
|
||||
server_->ExpectReceiveAlert(kTlsAlertCloseNotify, kTlsAlertWarning);
|
||||
}
|
||||
|
||||
TEST_P(TlsConnectGeneric, ClientAuth) {
|
||||
client_->SetupClientAuth();
|
||||
server_->RequestClientAuth(true);
|
||||
|
|
@ -153,6 +267,81 @@ TEST_P(TlsConnectTls12, ClientAuthBigRsaCheckSigAlg) {
|
|||
2048);
|
||||
}
|
||||
|
||||
// Replaces the signature scheme in a CertificateVerify message.
|
||||
class TlsReplaceSignatureSchemeFilter : public TlsHandshakeFilter {
|
||||
public:
|
||||
TlsReplaceSignatureSchemeFilter(const std::shared_ptr<TlsAgent>& a,
|
||||
SSLSignatureScheme scheme)
|
||||
: TlsHandshakeFilter(a, {kTlsHandshakeCertificateVerify}),
|
||||
scheme_(scheme) {
|
||||
EnableDecryption();
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual PacketFilter::Action FilterHandshake(const HandshakeHeader& header,
|
||||
const DataBuffer& input,
|
||||
DataBuffer* output) {
|
||||
*output = input;
|
||||
output->Write(0, scheme_, 2);
|
||||
return CHANGE;
|
||||
}
|
||||
|
||||
private:
|
||||
SSLSignatureScheme scheme_;
|
||||
};
|
||||
|
||||
// Check if CertificateVerify signed with rsa_pss_rsae_* is properly
|
||||
// rejected when the certificate is RSA-PSS.
|
||||
//
|
||||
// This only works under TLS 1.2, because PSS doesn't work with TLS
|
||||
// 1.0 or TLS 1.1 and the TLS 1.3 1-RTT handshake is partially
|
||||
// successful at the client side.
|
||||
TEST_P(TlsConnectTls12, ClientAuthInconsistentRsaeSignatureScheme) {
|
||||
static const SSLSignatureScheme kSignatureSchemePss[] = {
|
||||
ssl_sig_rsa_pss_pss_sha256, ssl_sig_rsa_pss_rsae_sha256};
|
||||
|
||||
Reset(TlsAgent::kServerRsa, "rsa_pss");
|
||||
client_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
server_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
client_->SetupClientAuth();
|
||||
server_->RequestClientAuth(true);
|
||||
|
||||
EnsureTlsSetup();
|
||||
|
||||
MakeTlsFilter<TlsReplaceSignatureSchemeFilter>(client_,
|
||||
ssl_sig_rsa_pss_rsae_sha256);
|
||||
|
||||
ConnectExpectAlert(server_, kTlsAlertIllegalParameter);
|
||||
}
|
||||
|
||||
// Check if CertificateVerify signed with rsa_pss_pss_* is properly
|
||||
// rejected when the certificate is RSA.
|
||||
//
|
||||
// This only works under TLS 1.2, because PSS doesn't work with TLS
|
||||
// 1.0 or TLS 1.1 and the TLS 1.3 1-RTT handshake is partially
|
||||
// successful at the client side.
|
||||
TEST_P(TlsConnectTls12, ClientAuthInconsistentPssSignatureScheme) {
|
||||
static const SSLSignatureScheme kSignatureSchemePss[] = {
|
||||
ssl_sig_rsa_pss_rsae_sha256, ssl_sig_rsa_pss_pss_sha256};
|
||||
|
||||
Reset(TlsAgent::kServerRsa, "rsa");
|
||||
client_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
server_->SetSignatureSchemes(kSignatureSchemePss,
|
||||
PR_ARRAY_SIZE(kSignatureSchemePss));
|
||||
client_->SetupClientAuth();
|
||||
server_->RequestClientAuth(true);
|
||||
|
||||
EnsureTlsSetup();
|
||||
|
||||
MakeTlsFilter<TlsReplaceSignatureSchemeFilter>(client_,
|
||||
ssl_sig_rsa_pss_pss_sha256);
|
||||
|
||||
ConnectExpectAlert(server_, kTlsAlertIllegalParameter);
|
||||
}
|
||||
|
||||
class TlsZeroCertificateRequestSigAlgsFilter : public TlsHandshakeFilter {
|
||||
public:
|
||||
TlsZeroCertificateRequestSigAlgsFilter(const std::shared_ptr<TlsAgent>& a)
|
||||
|
|
@ -197,9 +386,9 @@ class TlsZeroCertificateRequestSigAlgsFilter : public TlsHandshakeFilter {
|
|||
}
|
||||
};
|
||||
|
||||
// Check that we fall back to SHA-1 when the server doesn't provide any
|
||||
// Check that we send an alert when the server doesn't provide any
|
||||
// supported_signature_algorithms in the CertificateRequest message.
|
||||
TEST_P(TlsConnectTls12, ClientAuthNoSigAlgsFallback) {
|
||||
TEST_P(TlsConnectTls12, ClientAuthNoSigAlgs) {
|
||||
EnsureTlsSetup();
|
||||
MakeTlsFilter<TlsZeroCertificateRequestSigAlgsFilter>(server_);
|
||||
auto capture_cert_verify = MakeTlsFilter<TlsHandshakeRecorder>(
|
||||
|
|
@ -207,24 +396,19 @@ TEST_P(TlsConnectTls12, ClientAuthNoSigAlgsFallback) {
|
|||
client_->SetupClientAuth();
|
||||
server_->RequestClientAuth(true);
|
||||
|
||||
ConnectExpectAlert(server_, kTlsAlertDecryptError);
|
||||
ConnectExpectAlert(client_, kTlsAlertHandshakeFailure);
|
||||
|
||||
// We're expecting a bad signature here because we tampered with a handshake
|
||||
// message (CertReq). Previously, without the SHA-1 fallback, we would've
|
||||
// seen a malformed record alert.
|
||||
server_->CheckErrorCode(SEC_ERROR_BAD_SIGNATURE);
|
||||
client_->CheckErrorCode(SSL_ERROR_DECRYPT_ERROR_ALERT);
|
||||
|
||||
CheckSigScheme(capture_cert_verify, 0, server_, ssl_sig_rsa_pkcs1_sha1, 1024);
|
||||
server_->CheckErrorCode(SSL_ERROR_HANDSHAKE_FAILURE_ALERT);
|
||||
client_->CheckErrorCode(SSL_ERROR_UNSUPPORTED_SIGNATURE_ALGORITHM);
|
||||
}
|
||||
|
||||
static const SSLSignatureScheme SignatureSchemeEcdsaSha384[] = {
|
||||
static const SSLSignatureScheme kSignatureSchemeEcdsaSha384[] = {
|
||||
ssl_sig_ecdsa_secp384r1_sha384};
|
||||
static const SSLSignatureScheme SignatureSchemeEcdsaSha256[] = {
|
||||
static const SSLSignatureScheme kSignatureSchemeEcdsaSha256[] = {
|
||||
ssl_sig_ecdsa_secp256r1_sha256};
|
||||
static const SSLSignatureScheme SignatureSchemeRsaSha384[] = {
|
||||
static const SSLSignatureScheme kSignatureSchemeRsaSha384[] = {
|
||||
ssl_sig_rsa_pkcs1_sha384};
|
||||
static const SSLSignatureScheme SignatureSchemeRsaSha256[] = {
|
||||
static const SSLSignatureScheme kSignatureSchemeRsaSha256[] = {
|
||||
ssl_sig_rsa_pkcs1_sha256};
|
||||
|
||||
static SSLNamedGroup NamedGroupForEcdsa384(uint16_t version) {
|
||||
|
|
@ -241,10 +425,10 @@ static SSLNamedGroup NamedGroupForEcdsa384(uint16_t version) {
|
|||
// for TLS 1.1 and 1.0, where they should be ignored.
|
||||
TEST_P(TlsConnectGeneric, SignatureAlgorithmServerAuth) {
|
||||
Reset(TlsAgent::kServerEcdsa384);
|
||||
client_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
Connect();
|
||||
CheckKeys(ssl_kea_ecdh, NamedGroupForEcdsa384(version_), ssl_auth_ecdsa,
|
||||
ssl_sig_ecdsa_secp384r1_sha384);
|
||||
|
|
@ -273,8 +457,8 @@ TEST_P(TlsConnectGeneric, SignatureAlgorithmClientOnly) {
|
|||
// Defaults on the client include the provided option.
|
||||
TEST_P(TlsConnectGeneric, SignatureAlgorithmServerOnly) {
|
||||
Reset(TlsAgent::kServerEcdsa384);
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
Connect();
|
||||
CheckKeys(ssl_kea_ecdh, NamedGroupForEcdsa384(version_), ssl_auth_ecdsa,
|
||||
ssl_sig_ecdsa_secp384r1_sha384);
|
||||
|
|
@ -283,16 +467,16 @@ TEST_P(TlsConnectGeneric, SignatureAlgorithmServerOnly) {
|
|||
// In TLS 1.2, curve and hash aren't bound together.
|
||||
TEST_P(TlsConnectTls12, SignatureSchemeCurveMismatch) {
|
||||
Reset(TlsAgent::kServerEcdsa256);
|
||||
client_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
Connect();
|
||||
}
|
||||
|
||||
// In TLS 1.3, curve and hash are coupled.
|
||||
TEST_P(TlsConnectTls13, SignatureSchemeCurveMismatch) {
|
||||
Reset(TlsAgent::kServerEcdsa256);
|
||||
client_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
ConnectExpectAlert(server_, kTlsAlertHandshakeFailure);
|
||||
server_->CheckErrorCode(SSL_ERROR_UNSUPPORTED_SIGNATURE_ALGORITHM);
|
||||
client_->CheckErrorCode(SSL_ERROR_NO_CYPHER_OVERLAP);
|
||||
|
|
@ -301,16 +485,16 @@ TEST_P(TlsConnectTls13, SignatureSchemeCurveMismatch) {
|
|||
// Configuring a P-256 cert with only SHA-384 signatures is OK in TLS 1.2.
|
||||
TEST_P(TlsConnectTls12, SignatureSchemeBadConfig) {
|
||||
Reset(TlsAgent::kServerEcdsa256); // P-256 cert can't be used.
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
Connect();
|
||||
}
|
||||
|
||||
// A P-256 certificate in TLS 1.3 needs a SHA-256 signature scheme.
|
||||
TEST_P(TlsConnectTls13, SignatureSchemeBadConfig) {
|
||||
Reset(TlsAgent::kServerEcdsa256); // P-256 cert can't be used.
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
ConnectExpectAlert(server_, kTlsAlertHandshakeFailure);
|
||||
server_->CheckErrorCode(SSL_ERROR_UNSUPPORTED_SIGNATURE_ALGORITHM);
|
||||
client_->CheckErrorCode(SSL_ERROR_NO_CYPHER_OVERLAP);
|
||||
|
|
@ -319,10 +503,10 @@ TEST_P(TlsConnectTls13, SignatureSchemeBadConfig) {
|
|||
// Where there is no overlap on signature schemes, we still connect successfully
|
||||
// if we aren't going to use a signature.
|
||||
TEST_P(TlsConnectGenericPre13, SignatureAlgorithmNoOverlapStaticRsa) {
|
||||
client_->SetSignatureSchemes(SignatureSchemeRsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeRsaSha384));
|
||||
server_->SetSignatureSchemes(SignatureSchemeRsaSha256,
|
||||
PR_ARRAY_SIZE(SignatureSchemeRsaSha256));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeRsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeRsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeRsaSha256,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeRsaSha256));
|
||||
EnableOnlyStaticRsaCiphers();
|
||||
Connect();
|
||||
CheckKeys(ssl_kea_rsa, ssl_auth_rsa_decrypt);
|
||||
|
|
@ -330,10 +514,10 @@ TEST_P(TlsConnectGenericPre13, SignatureAlgorithmNoOverlapStaticRsa) {
|
|||
|
||||
TEST_P(TlsConnectTls12Plus, SignatureAlgorithmNoOverlapEcdsa) {
|
||||
Reset(TlsAgent::kServerEcdsa256);
|
||||
client_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha256,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha256));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha256,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha256));
|
||||
ConnectExpectAlert(server_, kTlsAlertHandshakeFailure);
|
||||
client_->CheckErrorCode(SSL_ERROR_NO_CYPHER_OVERLAP);
|
||||
server_->CheckErrorCode(SSL_ERROR_UNSUPPORTED_SIGNATURE_ALGORITHM);
|
||||
|
|
@ -342,10 +526,10 @@ TEST_P(TlsConnectTls12Plus, SignatureAlgorithmNoOverlapEcdsa) {
|
|||
// Pre 1.2, a mismatch on signature algorithms shouldn't affect anything.
|
||||
TEST_P(TlsConnectPre12, SignatureAlgorithmNoOverlapEcdsa) {
|
||||
Reset(TlsAgent::kServerEcdsa256);
|
||||
client_->SetSignatureSchemes(SignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(SignatureSchemeEcdsaSha256,
|
||||
PR_ARRAY_SIZE(SignatureSchemeEcdsaSha256));
|
||||
client_->SetSignatureSchemes(kSignatureSchemeEcdsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeEcdsaSha256,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeEcdsaSha256));
|
||||
Connect();
|
||||
}
|
||||
|
||||
|
|
@ -366,29 +550,6 @@ TEST_P(TlsConnectTls12, SignatureAlgorithmDrop) {
|
|||
server_->CheckErrorCode(SSL_ERROR_BAD_HANDSHAKE_HASH_VALUE);
|
||||
}
|
||||
|
||||
// Replaces the signature scheme in a TLS 1.3 CertificateVerify message.
|
||||
class TlsReplaceSignatureSchemeFilter : public TlsHandshakeFilter {
|
||||
public:
|
||||
TlsReplaceSignatureSchemeFilter(const std::shared_ptr<TlsAgent>& a,
|
||||
SSLSignatureScheme scheme)
|
||||
: TlsHandshakeFilter(a, {kTlsHandshakeCertificateVerify}),
|
||||
scheme_(scheme) {
|
||||
EnableDecryption();
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual PacketFilter::Action FilterHandshake(const HandshakeHeader& header,
|
||||
const DataBuffer& input,
|
||||
DataBuffer* output) {
|
||||
*output = input;
|
||||
output->Write(0, scheme_, 2);
|
||||
return CHANGE;
|
||||
}
|
||||
|
||||
private:
|
||||
SSLSignatureScheme scheme_;
|
||||
};
|
||||
|
||||
TEST_P(TlsConnectTls13, UnsupportedSignatureSchemeAlert) {
|
||||
EnsureTlsSetup();
|
||||
MakeTlsFilter<TlsReplaceSignatureSchemeFilter>(server_, ssl_sig_none);
|
||||
|
|
@ -411,8 +572,8 @@ TEST_P(TlsConnectTls13, InconsistentSignatureSchemeAlert) {
|
|||
}
|
||||
|
||||
TEST_P(TlsConnectTls12Plus, RequestClientAuthWithSha384) {
|
||||
server_->SetSignatureSchemes(SignatureSchemeRsaSha384,
|
||||
PR_ARRAY_SIZE(SignatureSchemeRsaSha384));
|
||||
server_->SetSignatureSchemes(kSignatureSchemeRsaSha384,
|
||||
PR_ARRAY_SIZE(kSignatureSchemeRsaSha384));
|
||||
server_->RequestClientAuth(false);
|
||||
Connect();
|
||||
}
|
||||
|
|
@ -438,7 +599,7 @@ class BeforeFinished : public TlsRecordFilter {
|
|||
switch (state_) {
|
||||
case BEFORE_CCS:
|
||||
// Awaken when we see the CCS.
|
||||
if (header.content_type() == kTlsChangeCipherSpecType) {
|
||||
if (header.content_type() == ssl_ct_change_cipher_spec) {
|
||||
before_ccs_();
|
||||
|
||||
// Write the CCS out as a separate write, so that we can make
|
||||
|
|
@ -455,7 +616,7 @@ class BeforeFinished : public TlsRecordFilter {
|
|||
break;
|
||||
|
||||
case AFTER_CCS:
|
||||
EXPECT_EQ(kTlsHandshakeType, header.content_type());
|
||||
EXPECT_EQ(ssl_ct_handshake, header.content_type());
|
||||
// This could check that data contains a Finished message, but it's
|
||||
// encrypted, so that's too much extra work.
|
||||
|
||||
|
|
@ -552,25 +713,11 @@ TEST_F(TlsConnectDatagram13, AuthCompleteBeforeFinished) {
|
|||
Connect();
|
||||
}
|
||||
|
||||
static void TriggerAuthComplete(PollTarget* target, Event event) {
|
||||
std::cerr << "client: call SSL_AuthCertificateComplete" << std::endl;
|
||||
EXPECT_EQ(TIMER_EVENT, event);
|
||||
TlsAgent* client = static_cast<TlsAgent*>(target);
|
||||
EXPECT_EQ(SECSuccess, SSL_AuthCertificateComplete(client->ssl_fd(), 0));
|
||||
}
|
||||
|
||||
// This test uses a simple AuthCertificateCallback. Due to the way that the
|
||||
// entire server flight is processed, the call to SSL_AuthCertificateComplete
|
||||
// will trigger after the Finished message is processed.
|
||||
TEST_F(TlsConnectDatagram13, AuthCompleteAfterFinished) {
|
||||
client_->SetAuthCertificateCallback(
|
||||
[this](TlsAgent*, PRBool, PRBool) -> SECStatus {
|
||||
std::shared_ptr<Poller::Timer> timer_handle;
|
||||
// This is really just to unroll the stack.
|
||||
Poller::Instance()->SetTimer(1U, client_.get(), TriggerAuthComplete,
|
||||
&timer_handle);
|
||||
return SECWouldBlock;
|
||||
});
|
||||
SetDeferredAuthCertificateCallback(client_, 0); // 0 = success.
|
||||
Connect();
|
||||
}
|
||||
|
||||
|
|
@ -754,15 +901,15 @@ TEST_F(TlsAgentStreamTestServer, ConfigureCertRsaPkcs1SignAndKEX) {
|
|||
PRFileDesc* ssl_fd = agent_->ssl_fd();
|
||||
EXPECT_TRUE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_decrypt));
|
||||
EXPECT_TRUE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_sign));
|
||||
EXPECT_TRUE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_pss));
|
||||
EXPECT_FALSE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_pss));
|
||||
|
||||
// Configuring for only rsa_sign, rsa_pss, or rsa_decrypt should work.
|
||||
// Configuring for only rsa_sign or rsa_decrypt should work.
|
||||
EXPECT_TRUE(agent_->ConfigServerCert(TlsAgent::kServerRsa, false,
|
||||
&ServerCertDataRsaPkcs1Decrypt));
|
||||
EXPECT_TRUE(agent_->ConfigServerCert(TlsAgent::kServerRsa, false,
|
||||
&ServerCertDataRsaPkcs1Sign));
|
||||
EXPECT_TRUE(agent_->ConfigServerCert(TlsAgent::kServerRsa, false,
|
||||
&ServerCertDataRsaPss));
|
||||
EXPECT_FALSE(agent_->ConfigServerCert(TlsAgent::kServerRsa, false,
|
||||
&ServerCertDataRsaPss));
|
||||
}
|
||||
|
||||
// Test RSA cert with usage=[signature].
|
||||
|
|
@ -772,17 +919,17 @@ TEST_F(TlsAgentStreamTestServer, ConfigureCertRsaPkcs1Sign) {
|
|||
PRFileDesc* ssl_fd = agent_->ssl_fd();
|
||||
EXPECT_FALSE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_decrypt));
|
||||
EXPECT_TRUE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_sign));
|
||||
EXPECT_TRUE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_pss));
|
||||
EXPECT_FALSE(SSLInt_HasCertWithAuthType(ssl_fd, ssl_auth_rsa_pss));
|
||||
|
||||
// Configuring for only rsa_decrypt should fail.
|
||||
EXPECT_FALSE(agent_->ConfigServerCert(TlsAgent::kServerRsaSign, false,
|
||||
&ServerCertDataRsaPkcs1Decrypt));
|
||||
|
||||
// Configuring for only rsa_sign or rsa_pss should work.
|
||||
// Configuring for only rsa_sign should work.
|
||||
EXPECT_TRUE(agent_->ConfigServerCert(TlsAgent::kServerRsaSign, false,
|
||||
&ServerCertDataRsaPkcs1Sign));
|
||||
EXPECT_TRUE(agent_->ConfigServerCert(TlsAgent::kServerRsaSign, false,
|
||||
&ServerCertDataRsaPss));
|
||||
EXPECT_FALSE(agent_->ConfigServerCert(TlsAgent::kServerRsaSign, false,
|
||||
&ServerCertDataRsaPss));
|
||||
}
|
||||
|
||||
// Test RSA cert with usage=[encipherment].
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue