2016-03-17 22:14:30 +08:00
|
|
|
/*
|
2020-04-23 20:55:52 +08:00
|
|
|
* Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
|
2016-03-17 22:14:30 +08:00
|
|
|
*
|
2018-12-06 20:05:25 +08:00
|
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
2016-05-18 02:20:24 +08:00
|
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
|
|
|
* in the file LICENSE in the source distribution or at
|
2016-03-17 22:14:30 +08:00
|
|
|
* https://www.openssl.org/source/license.html
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
#include <string.h>
|
2016-03-17 22:14:30 +08:00
|
|
|
|
|
|
|
|
#include <openssl/conf.h>
|
|
|
|
|
#include <openssl/err.h>
|
|
|
|
|
#include <openssl/ssl.h>
|
2020-04-03 22:40:00 +08:00
|
|
|
#include <openssl/provider.h>
|
2016-03-17 22:14:30 +08:00
|
|
|
|
|
|
|
|
#include "handshake_helper.h"
|
|
|
|
|
#include "ssl_test_ctx.h"
|
|
|
|
|
#include "testutil.h"
|
|
|
|
|
|
2019-12-20 06:30:24 +08:00
|
|
|
DEFINE_STACK_OF(X509_NAME)
|
|
|
|
|
|
2016-03-17 22:14:30 +08:00
|
|
|
static CONF *conf = NULL;
|
2020-04-03 22:40:00 +08:00
|
|
|
static OSSL_PROVIDER *defctxnull = NULL, *thisprov = NULL;
|
|
|
|
|
static OPENSSL_CTX *libctx = NULL;
|
2016-03-17 22:14:30 +08:00
|
|
|
|
|
|
|
|
/* Currently the section names are of the form test-<number>, e.g. test-15. */
|
|
|
|
|
#define MAX_TESTCASE_NAME_LENGTH 100
|
|
|
|
|
|
|
|
|
|
static const char *print_alert(int alert)
|
|
|
|
|
{
|
|
|
|
|
return alert ? SSL_alert_desc_string_long(alert) : "no alert";
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_result(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->result, test_ctx->expected_result)) {
|
|
|
|
|
TEST_info("ExpectedResult mismatch: expected %s, got %s.",
|
|
|
|
|
ssl_test_result_name(test_ctx->expected_result),
|
|
|
|
|
ssl_test_result_name(result->result));
|
2016-03-17 22:14:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_alerts(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->client_alert_sent,
|
|
|
|
|
result->client_alert_received)) {
|
|
|
|
|
TEST_info("Client sent alert %s but server received %s.",
|
|
|
|
|
print_alert(result->client_alert_sent),
|
|
|
|
|
print_alert(result->client_alert_received));
|
2016-03-17 22:14:30 +08:00
|
|
|
/*
|
|
|
|
|
* We can't bail here because the peer doesn't always get far enough
|
|
|
|
|
* to process a received alert. Specifically, in protocol version
|
|
|
|
|
* negotiation tests, we have the following scenario.
|
|
|
|
|
* Client supports TLS v1.2 only; Server supports TLS v1.1.
|
|
|
|
|
* Client proposes TLS v1.2; server responds with 1.1;
|
|
|
|
|
* Client now sends a protocol alert, using TLS v1.2 in the header.
|
|
|
|
|
* The server, however, rejects the alert because of version mismatch
|
|
|
|
|
* in the record layer; therefore, the server appears to never
|
|
|
|
|
* receive the alert.
|
|
|
|
|
*/
|
|
|
|
|
/* return 0; */
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->server_alert_sent,
|
|
|
|
|
result->server_alert_received)) {
|
|
|
|
|
TEST_info("Server sent alert %s but client received %s.",
|
|
|
|
|
print_alert(result->server_alert_sent),
|
|
|
|
|
print_alert(result->server_alert_received));
|
2016-03-17 22:14:30 +08:00
|
|
|
/* return 0; */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Tolerate an alert if one wasn't explicitly specified in the test. */
|
2016-07-21 22:29:48 +08:00
|
|
|
if (test_ctx->expected_client_alert
|
2016-03-17 22:14:30 +08:00
|
|
|
/*
|
|
|
|
|
* The info callback alert value is computed as
|
|
|
|
|
* (s->s3->send_alert[0] << 8) | s->s3->send_alert[1]
|
|
|
|
|
* where the low byte is the alert code and the high byte is other stuff.
|
|
|
|
|
*/
|
2016-07-21 22:29:48 +08:00
|
|
|
&& (result->client_alert_sent & 0xff) != test_ctx->expected_client_alert) {
|
2017-03-22 12:27:55 +08:00
|
|
|
TEST_error("ClientAlert mismatch: expected %s, got %s.",
|
|
|
|
|
print_alert(test_ctx->expected_client_alert),
|
|
|
|
|
print_alert(result->client_alert_sent));
|
2016-03-17 22:14:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-21 22:29:48 +08:00
|
|
|
if (test_ctx->expected_server_alert
|
|
|
|
|
&& (result->server_alert_sent & 0xff) != test_ctx->expected_server_alert) {
|
2017-03-22 12:27:55 +08:00
|
|
|
TEST_error("ServerAlert mismatch: expected %s, got %s.",
|
|
|
|
|
print_alert(test_ctx->expected_server_alert),
|
|
|
|
|
print_alert(result->server_alert_sent));
|
2016-03-17 22:14:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_le(result->client_num_fatal_alerts_sent, 1))
|
2016-08-12 20:29:24 +08:00
|
|
|
return 0;
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_le(result->server_num_fatal_alerts_sent, 1))
|
2016-08-12 20:29:24 +08:00
|
|
|
return 0;
|
2016-03-17 22:14:30 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_protocol(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->client_protocol, result->server_protocol)) {
|
|
|
|
|
TEST_info("Client has protocol %s but server has %s.",
|
|
|
|
|
ssl_protocol_name(result->client_protocol),
|
|
|
|
|
ssl_protocol_name(result->server_protocol));
|
2016-03-17 22:14:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-21 22:29:48 +08:00
|
|
|
if (test_ctx->expected_protocol) {
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->client_protocol,
|
|
|
|
|
test_ctx->expected_protocol)) {
|
|
|
|
|
TEST_info("Protocol mismatch: expected %s, got %s.\n",
|
|
|
|
|
ssl_protocol_name(test_ctx->expected_protocol),
|
|
|
|
|
ssl_protocol_name(result->client_protocol));
|
2016-03-17 22:14:30 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_servername(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->servername, test_ctx->expected_servername)) {
|
|
|
|
|
TEST_info("Client ServerName mismatch, expected %s, got %s.",
|
|
|
|
|
ssl_servername_name(test_ctx->expected_servername),
|
|
|
|
|
ssl_servername_name(result->servername));
|
2016-06-20 23:20:25 +08:00
|
|
|
return 0;
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
}
|
2016-06-20 23:20:25 +08:00
|
|
|
return 1;
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
}
|
|
|
|
|
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_session_ticket(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
{
|
|
|
|
|
if (test_ctx->session_ticket_expected == SSL_TEST_SESSION_TICKET_IGNORE)
|
|
|
|
|
return 1;
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->session_ticket,
|
|
|
|
|
test_ctx->session_ticket_expected)) {
|
|
|
|
|
TEST_info("Client SessionTicketExpected mismatch, expected %s, got %s.",
|
|
|
|
|
ssl_session_ticket_name(test_ctx->session_ticket_expected),
|
|
|
|
|
ssl_session_ticket_name(result->session_ticket));
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
Session resume broken switching contexts
When an SSL's context is swtiched from a ticket-enabled context to
a ticket-disabled context in the servername callback, no session-id
is generated, so the session can't be resumed.
If a servername callback changes the SSL_OP_NO_TICKET option, check
to see if it's changed to disable, and whether a session ticket is
expected (i.e. the client indicated ticket support and the SSL had
tickets enabled at the time), and whether we already have a previous
session (i.e. s->hit is set).
In this case, clear the ticket-expected flag, remove any ticket data
and generate a session-id in the session.
If the SSL hit (resumed) and switched to a ticket-disabled context,
assume that the resumption was via session-id, and don't bother to
update the session.
Before this fix, the updated unit-tests in 06-sni-ticket.conf would
fail test #4 (server1 = SNI, server2 = no SNI).
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Paul Dale <paul.dale@oracle.com>
(Merged from https://github.com/openssl/openssl/pull/1529)
2016-09-01 20:40:54 +08:00
|
|
|
static int check_session_id(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
if (test_ctx->session_id_expected == SSL_TEST_SESSION_ID_IGNORE)
|
|
|
|
|
return 1;
|
|
|
|
|
if (!TEST_int_eq(result->session_id, test_ctx->session_id_expected)) {
|
|
|
|
|
TEST_info("Client SessionIdExpected mismatch, expected %s, got %s\n.",
|
|
|
|
|
ssl_session_id_name(test_ctx->session_id_expected),
|
|
|
|
|
ssl_session_id_name(result->session_id));
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-01 20:11:51 +08:00
|
|
|
static int check_compression(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->compression, test_ctx->compression_expected))
|
2017-03-01 20:11:51 +08:00
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2016-07-31 18:42:04 +08:00
|
|
|
#ifndef OPENSSL_NO_NEXTPROTONEG
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_npn(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
int ret = 1;
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_str_eq(result->client_npn_negotiated,
|
|
|
|
|
result->server_npn_negotiated))
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (!TEST_str_eq(test_ctx->expected_npn_protocol,
|
|
|
|
|
result->client_npn_negotiated))
|
|
|
|
|
ret = 0;
|
2016-07-05 02:16:14 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
2016-08-05 23:17:00 +08:00
|
|
|
#endif
|
2016-07-05 02:16:14 +08:00
|
|
|
|
|
|
|
|
static int check_alpn(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
int ret = 1;
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_str_eq(result->client_alpn_negotiated,
|
|
|
|
|
result->server_alpn_negotiated))
|
|
|
|
|
ret = 0;
|
|
|
|
|
if (!TEST_str_eq(test_ctx->expected_alpn_protocol,
|
|
|
|
|
result->client_alpn_negotiated))
|
|
|
|
|
ret = 0;
|
2016-07-05 02:16:14 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-16 01:25:55 +08:00
|
|
|
static int check_session_ticket_app_data(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
size_t result_len = 0;
|
|
|
|
|
size_t expected_len = 0;
|
|
|
|
|
|
|
|
|
|
/* consider empty and NULL strings to be the same */
|
|
|
|
|
if (result->result_session_ticket_app_data != NULL)
|
|
|
|
|
result_len = strlen(result->result_session_ticket_app_data);
|
|
|
|
|
if (test_ctx->expected_session_ticket_app_data != NULL)
|
|
|
|
|
expected_len = strlen(test_ctx->expected_session_ticket_app_data);
|
|
|
|
|
if (result_len == 0 && expected_len == 0)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
if (!TEST_str_eq(result->result_session_ticket_app_data,
|
|
|
|
|
test_ctx->expected_session_ticket_app_data))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 01:06:23 +08:00
|
|
|
static int check_resumption(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->client_resumed, result->server_resumed))
|
2016-07-06 01:06:23 +08:00
|
|
|
return 0;
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_int_eq(result->client_resumed, test_ctx->resumption_expected))
|
2016-07-06 01:06:23 +08:00
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-13 23:20:42 +08:00
|
|
|
static int check_nid(const char *name, int expected_nid, int nid)
|
2017-01-08 08:09:08 +08:00
|
|
|
{
|
2017-01-13 23:20:42 +08:00
|
|
|
if (expected_nid == 0 || expected_nid == nid)
|
2017-01-08 08:09:08 +08:00
|
|
|
return 1;
|
2017-03-22 12:27:55 +08:00
|
|
|
TEST_error("%s type mismatch, %s vs %s\n",
|
|
|
|
|
name, OBJ_nid2ln(expected_nid),
|
|
|
|
|
nid == NID_undef ? "absent" : OBJ_nid2ln(nid));
|
2017-01-08 08:09:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-16 00:07:07 +08:00
|
|
|
static void print_ca_names(STACK_OF(X509_NAME) *names)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (names == NULL || sk_X509_NAME_num(names) == 0) {
|
2017-06-19 09:21:22 +08:00
|
|
|
TEST_note(" <empty>");
|
2017-03-16 00:07:07 +08:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < sk_X509_NAME_num(names); i++) {
|
2017-06-19 09:21:22 +08:00
|
|
|
X509_NAME_print_ex(bio_err, sk_X509_NAME_value(names, i), 4,
|
2017-03-16 00:07:07 +08:00
|
|
|
XN_FLAG_ONELINE);
|
2017-06-19 09:21:22 +08:00
|
|
|
BIO_puts(bio_err, "\n");
|
2017-03-16 00:07:07 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_ca_names(const char *name,
|
|
|
|
|
STACK_OF(X509_NAME) *expected_names,
|
|
|
|
|
STACK_OF(X509_NAME) *names)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (expected_names == NULL)
|
|
|
|
|
return 1;
|
|
|
|
|
if (names == NULL || sk_X509_NAME_num(names) == 0) {
|
2017-06-19 09:21:22 +08:00
|
|
|
if (TEST_int_eq(sk_X509_NAME_num(expected_names), 0))
|
2017-03-16 00:07:07 +08:00
|
|
|
return 1;
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
if (sk_X509_NAME_num(names) != sk_X509_NAME_num(expected_names))
|
|
|
|
|
goto err;
|
|
|
|
|
for (i = 0; i < sk_X509_NAME_num(names); i++) {
|
2017-06-19 09:21:22 +08:00
|
|
|
if (!TEST_int_eq(X509_NAME_cmp(sk_X509_NAME_value(names, i),
|
|
|
|
|
sk_X509_NAME_value(expected_names, i)),
|
|
|
|
|
0)) {
|
2017-03-16 00:07:07 +08:00
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
2017-06-19 09:21:22 +08:00
|
|
|
err:
|
|
|
|
|
TEST_info("%s: list mismatch", name);
|
|
|
|
|
TEST_note("Expected Names:");
|
2017-03-16 00:07:07 +08:00
|
|
|
print_ca_names(expected_names);
|
2017-06-19 09:21:22 +08:00
|
|
|
TEST_note("Received Names:");
|
2017-03-16 00:07:07 +08:00
|
|
|
print_ca_names(names);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-01 05:35:28 +08:00
|
|
|
static int check_tmp_key(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Tmp key", test_ctx->expected_tmp_key_type,
|
|
|
|
|
result->tmp_key_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_server_cert_type(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Server certificate", test_ctx->expected_server_cert_type,
|
|
|
|
|
result->server_cert_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_server_sign_hash(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Server signing hash", test_ctx->expected_server_sign_hash,
|
|
|
|
|
result->server_sign_hash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_server_sign_type(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Server signing", test_ctx->expected_server_sign_type,
|
|
|
|
|
result->server_sign_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_server_ca_names(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_ca_names("Server CA names",
|
|
|
|
|
test_ctx->expected_server_ca_names,
|
|
|
|
|
result->server_ca_names);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_client_cert_type(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Client certificate", test_ctx->expected_client_cert_type,
|
|
|
|
|
result->client_cert_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_client_sign_hash(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Client signing hash", test_ctx->expected_client_sign_hash,
|
|
|
|
|
result->client_sign_hash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int check_client_sign_type(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_nid("Client signing", test_ctx->expected_client_sign_type,
|
|
|
|
|
result->client_sign_type);
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-16 00:07:07 +08:00
|
|
|
static int check_client_ca_names(HANDSHAKE_RESULT *result,
|
|
|
|
|
SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
return check_ca_names("Client CA names",
|
|
|
|
|
test_ctx->expected_client_ca_names,
|
|
|
|
|
result->client_ca_names);
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-22 04:19:29 +08:00
|
|
|
static int check_cipher(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
|
|
|
|
{
|
|
|
|
|
if (test_ctx->expected_cipher == NULL)
|
|
|
|
|
return 1;
|
|
|
|
|
if (!TEST_ptr(result->cipher))
|
|
|
|
|
return 0;
|
|
|
|
|
if (!TEST_str_eq(test_ctx->expected_cipher,
|
|
|
|
|
result->cipher))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-17 22:14:30 +08:00
|
|
|
/*
|
|
|
|
|
* This could be further simplified by constructing an expected
|
|
|
|
|
* HANDSHAKE_RESULT, and implementing comparison methods for
|
|
|
|
|
* its fields.
|
|
|
|
|
*/
|
2016-07-05 02:16:14 +08:00
|
|
|
static int check_test(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
|
|
|
|
int ret = 1;
|
|
|
|
|
ret &= check_result(result, test_ctx);
|
|
|
|
|
ret &= check_alerts(result, test_ctx);
|
2016-07-05 02:16:14 +08:00
|
|
|
if (result->result == SSL_TEST_SUCCESS) {
|
2016-03-17 22:14:30 +08:00
|
|
|
ret &= check_protocol(result, test_ctx);
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
ret &= check_servername(result, test_ctx);
|
2016-06-10 06:39:22 +08:00
|
|
|
ret &= check_session_ticket(result, test_ctx);
|
2017-03-01 20:11:51 +08:00
|
|
|
ret &= check_compression(result, test_ctx);
|
Session resume broken switching contexts
When an SSL's context is swtiched from a ticket-enabled context to
a ticket-disabled context in the servername callback, no session-id
is generated, so the session can't be resumed.
If a servername callback changes the SSL_OP_NO_TICKET option, check
to see if it's changed to disable, and whether a session ticket is
expected (i.e. the client indicated ticket support and the SSL had
tickets enabled at the time), and whether we already have a previous
session (i.e. s->hit is set).
In this case, clear the ticket-expected flag, remove any ticket data
and generate a session-id in the session.
If the SSL hit (resumed) and switched to a ticket-disabled context,
assume that the resumption was via session-id, and don't bother to
update the session.
Before this fix, the updated unit-tests in 06-sni-ticket.conf would
fail test #4 (server1 = SNI, server2 = no SNI).
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Paul Dale <paul.dale@oracle.com>
(Merged from https://github.com/openssl/openssl/pull/1529)
2016-09-01 20:40:54 +08:00
|
|
|
ret &= check_session_id(result, test_ctx);
|
2016-07-05 02:16:14 +08:00
|
|
|
ret &= (result->session_ticket_do_not_call == 0);
|
2016-07-31 18:42:04 +08:00
|
|
|
#ifndef OPENSSL_NO_NEXTPROTONEG
|
2016-07-05 02:16:14 +08:00
|
|
|
ret &= check_npn(result, test_ctx);
|
2016-07-31 18:42:04 +08:00
|
|
|
#endif
|
2015-12-22 04:19:29 +08:00
|
|
|
ret &= check_cipher(result, test_ctx);
|
2016-08-05 23:17:00 +08:00
|
|
|
ret &= check_alpn(result, test_ctx);
|
2017-03-16 01:25:55 +08:00
|
|
|
ret &= check_session_ticket_app_data(result, test_ctx);
|
2016-07-06 01:06:23 +08:00
|
|
|
ret &= check_resumption(result, test_ctx);
|
2017-01-08 08:09:08 +08:00
|
|
|
ret &= check_tmp_key(result, test_ctx);
|
2017-01-09 03:30:41 +08:00
|
|
|
ret &= check_server_cert_type(result, test_ctx);
|
2017-01-13 23:20:42 +08:00
|
|
|
ret &= check_server_sign_hash(result, test_ctx);
|
2017-01-27 23:06:16 +08:00
|
|
|
ret &= check_server_sign_type(result, test_ctx);
|
2017-04-01 05:35:28 +08:00
|
|
|
ret &= check_server_ca_names(result, test_ctx);
|
2017-01-09 03:30:41 +08:00
|
|
|
ret &= check_client_cert_type(result, test_ctx);
|
2017-01-13 23:20:42 +08:00
|
|
|
ret &= check_client_sign_hash(result, test_ctx);
|
2017-01-27 23:06:16 +08:00
|
|
|
ret &= check_client_sign_type(result, test_ctx);
|
2017-03-16 00:07:07 +08:00
|
|
|
ret &= check_client_ca_names(result, test_ctx);
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
}
|
2016-03-17 22:14:30 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-11-04 23:06:12 +08:00
|
|
|
static int test_handshake(int idx)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
2016-04-05 20:29:06 +08:00
|
|
|
int ret = 0;
|
2016-07-06 01:06:23 +08:00
|
|
|
SSL_CTX *server_ctx = NULL, *server2_ctx = NULL, *client_ctx = NULL,
|
2016-07-21 20:04:00 +08:00
|
|
|
*resume_server_ctx = NULL, *resume_client_ctx = NULL;
|
2016-03-17 22:14:30 +08:00
|
|
|
SSL_TEST_CTX *test_ctx = NULL;
|
2016-07-05 02:16:14 +08:00
|
|
|
HANDSHAKE_RESULT *result = NULL;
|
2016-11-04 23:06:12 +08:00
|
|
|
char test_app[MAX_TESTCASE_NAME_LENGTH];
|
|
|
|
|
|
|
|
|
|
BIO_snprintf(test_app, sizeof(test_app), "test-%d", idx);
|
2016-03-17 22:14:30 +08:00
|
|
|
|
2016-11-04 23:06:12 +08:00
|
|
|
test_ctx = SSL_TEST_CTX_create(conf, test_app);
|
2017-03-22 12:27:55 +08:00
|
|
|
if (!TEST_ptr(test_ctx))
|
2016-06-03 23:49:04 +08:00
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
#ifndef OPENSSL_NO_DTLS
|
|
|
|
|
if (test_ctx->method == SSL_TEST_METHOD_DTLS) {
|
2020-04-03 22:40:00 +08:00
|
|
|
server_ctx = SSL_CTX_new_with_libctx(libctx, NULL, DTLS_server_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(server_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2016-07-21 22:29:48 +08:00
|
|
|
if (test_ctx->extra.server.servername_callback !=
|
|
|
|
|
SSL_TEST_SERVERNAME_CB_NONE) {
|
2020-04-03 22:40:00 +08:00
|
|
|
if (!TEST_ptr(server2_ctx =
|
|
|
|
|
SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
DTLS_server_method())))
|
2017-06-22 12:00:55 +08:00
|
|
|
goto err;
|
2016-06-20 23:20:25 +08:00
|
|
|
}
|
2020-04-03 22:40:00 +08:00
|
|
|
client_ctx = SSL_CTX_new_with_libctx(libctx, NULL, DTLS_client_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(client_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2016-07-06 01:06:23 +08:00
|
|
|
if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_RESUME) {
|
2020-04-03 22:40:00 +08:00
|
|
|
resume_server_ctx = SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
DTLS_server_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(resume_server_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2020-04-03 22:40:00 +08:00
|
|
|
resume_client_ctx = SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
DTLS_client_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(resume_client_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2017-06-22 12:00:55 +08:00
|
|
|
if (!TEST_ptr(resume_server_ctx)
|
|
|
|
|
|| !TEST_ptr(resume_client_ctx))
|
|
|
|
|
goto err;
|
2016-07-06 01:06:23 +08:00
|
|
|
}
|
2016-06-03 23:49:04 +08:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if (test_ctx->method == SSL_TEST_METHOD_TLS) {
|
2020-04-03 22:40:00 +08:00
|
|
|
server_ctx = SSL_CTX_new_with_libctx(libctx, NULL, TLS_server_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(server_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2016-07-21 22:29:48 +08:00
|
|
|
/* SNI on resumption isn't supported/tested yet. */
|
|
|
|
|
if (test_ctx->extra.server.servername_callback !=
|
|
|
|
|
SSL_TEST_SERVERNAME_CB_NONE) {
|
2020-04-03 22:40:00 +08:00
|
|
|
if (!TEST_ptr(server2_ctx =
|
|
|
|
|
SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
TLS_server_method())))
|
2017-06-22 12:00:55 +08:00
|
|
|
goto err;
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(server2_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2016-06-20 23:20:25 +08:00
|
|
|
}
|
2020-04-03 22:40:00 +08:00
|
|
|
client_ctx = SSL_CTX_new_with_libctx(libctx, NULL, TLS_client_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(client_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2016-07-06 01:06:23 +08:00
|
|
|
|
|
|
|
|
if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_RESUME) {
|
2020-04-03 22:40:00 +08:00
|
|
|
resume_server_ctx = SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
TLS_server_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(resume_server_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2020-04-03 22:40:00 +08:00
|
|
|
resume_client_ctx = SSL_CTX_new_with_libctx(libctx, NULL,
|
|
|
|
|
TLS_client_method());
|
2018-12-10 03:53:05 +08:00
|
|
|
if (!TEST_true(SSL_CTX_set_max_proto_version(resume_client_ctx, 0)))
|
2018-03-19 16:08:06 +08:00
|
|
|
goto err;
|
2017-06-22 12:00:55 +08:00
|
|
|
if (!TEST_ptr(resume_server_ctx)
|
|
|
|
|
|| !TEST_ptr(resume_client_ctx))
|
|
|
|
|
goto err;
|
2016-07-06 01:06:23 +08:00
|
|
|
}
|
2016-06-03 23:49:04 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-15 18:02:25 +08:00
|
|
|
#ifdef OPENSSL_NO_AUTOLOAD_CONFIG
|
|
|
|
|
if (!TEST_true(OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL)))
|
|
|
|
|
goto err;
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-06-22 12:00:55 +08:00
|
|
|
if (!TEST_ptr(server_ctx)
|
|
|
|
|
|| !TEST_ptr(client_ctx)
|
|
|
|
|
|| !TEST_int_gt(CONF_modules_load(conf, test_app, 0), 0))
|
|
|
|
|
goto err;
|
2016-03-17 22:14:30 +08:00
|
|
|
|
|
|
|
|
if (!SSL_CTX_config(server_ctx, "server")
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
|| !SSL_CTX_config(client_ctx, "client")) {
|
2016-03-17 22:14:30 +08:00
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-20 23:20:25 +08:00
|
|
|
if (server2_ctx != NULL && !SSL_CTX_config(server2_ctx, "server2"))
|
|
|
|
|
goto err;
|
2016-07-06 01:06:23 +08:00
|
|
|
if (resume_server_ctx != NULL
|
|
|
|
|
&& !SSL_CTX_config(resume_server_ctx, "resume-server"))
|
|
|
|
|
goto err;
|
2016-07-21 20:04:00 +08:00
|
|
|
if (resume_client_ctx != NULL
|
|
|
|
|
&& !SSL_CTX_config(resume_client_ctx, "resume-client"))
|
|
|
|
|
goto err;
|
2016-06-20 23:20:25 +08:00
|
|
|
|
2016-07-06 01:06:23 +08:00
|
|
|
result = do_handshake(server_ctx, server2_ctx, client_ctx,
|
2016-07-21 20:04:00 +08:00
|
|
|
resume_server_ctx, resume_client_ctx, test_ctx);
|
2016-03-17 22:14:30 +08:00
|
|
|
|
2017-07-04 11:44:52 +08:00
|
|
|
if (result != NULL)
|
|
|
|
|
ret = check_test(result, test_ctx);
|
2016-03-17 22:14:30 +08:00
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
CONF_modules_unload(0);
|
|
|
|
|
SSL_CTX_free(server_ctx);
|
Fix session ticket and SNI
When session tickets are used, it's possible that SNI might swtich the
SSL_CTX on an SSL. Normally, this is not a problem, because the
initial_ctx/session_ctx are used for all session ticket/id processes.
However, when the SNI callback occurs, it's possible that the callback
may update the options in the SSL from the SSL_CTX, and this could
cause SSL_OP_NO_TICKET to be set. If this occurs, then two bad things
can happen:
1. The session ticket TLSEXT may not be written when the ticket expected
flag is set. The state machine transistions to writing the ticket, and
the client responds with an error as its not expecting a ticket.
2. When creating the session ticket, if the ticket key cb returns 0
the crypto/hmac contexts are not initialized, and the code crashes when
trying to encrypt the session ticket.
To fix 1, if the ticket TLSEXT is not written out, clear the expected
ticket flag.
To fix 2, consider a return of 0 from the ticket key cb a recoverable
error, and write a 0 length ticket and continue. The client-side code
can explicitly handle this case.
Fix these two cases, and add unit test code to validate ticket behavior.
Reviewed-by: Emilia Käsper <emilia@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1098)
2016-05-13 06:16:52 +08:00
|
|
|
SSL_CTX_free(server2_ctx);
|
2016-03-17 22:14:30 +08:00
|
|
|
SSL_CTX_free(client_ctx);
|
2016-07-06 01:06:23 +08:00
|
|
|
SSL_CTX_free(resume_server_ctx);
|
2016-07-21 20:04:00 +08:00
|
|
|
SSL_CTX_free(resume_client_ctx);
|
2016-03-17 22:14:30 +08:00
|
|
|
SSL_TEST_CTX_free(test_ctx);
|
2016-07-05 02:16:14 +08:00
|
|
|
HANDSHAKE_RESULT_free(result);
|
2016-03-17 22:14:30 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-08 00:03:19 +08:00
|
|
|
OPT_TEST_DECLARE_USAGE("conf_file modulename [fips_conf_file]\n")
|
2018-08-16 10:36:01 +08:00
|
|
|
|
2017-07-18 09:48:27 +08:00
|
|
|
int setup_tests(void)
|
2016-03-17 22:14:30 +08:00
|
|
|
{
|
|
|
|
|
long num_tests;
|
2020-04-03 22:40:00 +08:00
|
|
|
const char *modulename;
|
2016-03-17 22:14:30 +08:00
|
|
|
|
2020-01-30 23:30:17 +08:00
|
|
|
if (!test_skip_common_options()) {
|
|
|
|
|
TEST_error("Error parsing test options\n");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-18 09:48:27 +08:00
|
|
|
if (!TEST_ptr(conf = NCONF_new(NULL))
|
2017-06-22 12:00:55 +08:00
|
|
|
/* argv[1] should point to the test conf file */
|
2017-07-18 09:48:27 +08:00
|
|
|
|| !TEST_int_gt(NCONF_load(conf, test_get_argument(0), NULL), 0)
|
2017-06-22 12:00:55 +08:00
|
|
|
|| !TEST_int_ne(NCONF_get_number_e(conf, NULL, "num_tests",
|
|
|
|
|
&num_tests), 0))
|
2017-07-18 09:48:27 +08:00
|
|
|
return 0;
|
2016-03-17 22:14:30 +08:00
|
|
|
|
2020-04-03 22:40:00 +08:00
|
|
|
if (!TEST_ptr(modulename = test_get_argument(1)))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2020-04-07 23:22:49 +08:00
|
|
|
if (strcmp(modulename, "none") != 0) {
|
2020-04-08 00:03:19 +08:00
|
|
|
const char *configfile = test_get_argument(2);
|
|
|
|
|
|
2020-04-07 23:22:49 +08:00
|
|
|
defctxnull = OSSL_PROVIDER_load(NULL, "null");
|
|
|
|
|
libctx = OPENSSL_CTX_new();
|
|
|
|
|
if (!TEST_ptr(libctx))
|
|
|
|
|
return 0;
|
2020-04-03 22:40:00 +08:00
|
|
|
|
2020-04-08 00:03:19 +08:00
|
|
|
if (configfile != NULL
|
|
|
|
|
&& !TEST_true(OPENSSL_CTX_load_config(libctx, configfile)))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2020-04-07 23:22:49 +08:00
|
|
|
thisprov = OSSL_PROVIDER_load(libctx, modulename);
|
|
|
|
|
if (!TEST_ptr(thisprov))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-04-03 22:40:00 +08:00
|
|
|
|
2017-07-18 09:48:27 +08:00
|
|
|
ADD_ALL_TESTS(test_handshake, (int)num_tests);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2016-03-17 22:14:30 +08:00
|
|
|
|
2017-07-18 09:48:27 +08:00
|
|
|
void cleanup_tests(void)
|
|
|
|
|
{
|
2016-11-07 23:53:15 +08:00
|
|
|
NCONF_free(conf);
|
2020-04-03 22:40:00 +08:00
|
|
|
OSSL_PROVIDER_unload(defctxnull);
|
|
|
|
|
OSSL_PROVIDER_unload(thisprov);
|
|
|
|
|
OPENSSL_CTX_free(libctx);
|
2016-03-17 22:14:30 +08:00
|
|
|
}
|
