d2f87a7779
To wit, |RetryAsync| and |CheckIdempotentError|. This helps with creating a separate binary to perform split handshakes. Separate handshake utilities Change-Id: I81d0bc38f58e7e1a92b58bf09407452b345213b4 Reviewed-on: https://boringssl-review.googlesource.com/29346 Commit-Queue: Matt Braithwaite <mab@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org> Reviewed-by: David Benjamin <davidben@google.com>
113 lines
3.8 KiB
C++
113 lines
3.8 KiB
C++
/* Copyright (c) 2018, Google Inc.
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
|
|
|
|
#include "handshake_util.h"
|
|
|
|
#include <assert.h>
|
|
|
|
#include <functional>
|
|
|
|
#include "async_bio.h"
|
|
#include "packeted_bio.h"
|
|
#include "test_config.h"
|
|
#include "test_state.h"
|
|
|
|
#include <openssl/ssl.h>
|
|
|
|
bool RetryAsync(SSL *ssl, int ret) {
|
|
// No error; don't retry.
|
|
if (ret >= 0) {
|
|
return false;
|
|
}
|
|
|
|
TestState *test_state = GetTestState(ssl);
|
|
assert(GetTestConfig(ssl)->async);
|
|
|
|
if (test_state->packeted_bio != nullptr &&
|
|
PacketedBioAdvanceClock(test_state->packeted_bio)) {
|
|
// The DTLS retransmit logic silently ignores write failures. So the test
|
|
// may progress, allow writes through synchronously.
|
|
AsyncBioEnforceWriteQuota(test_state->async_bio, false);
|
|
int timeout_ret = DTLSv1_handle_timeout(ssl);
|
|
AsyncBioEnforceWriteQuota(test_state->async_bio, true);
|
|
|
|
if (timeout_ret < 0) {
|
|
fprintf(stderr, "Error retransmitting.\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// See if we needed to read or write more. If so, allow one byte through on
|
|
// the appropriate end to maximally stress the state machine.
|
|
switch (SSL_get_error(ssl, ret)) {
|
|
case SSL_ERROR_WANT_READ:
|
|
AsyncBioAllowRead(test_state->async_bio, 1);
|
|
return true;
|
|
case SSL_ERROR_WANT_WRITE:
|
|
AsyncBioAllowWrite(test_state->async_bio, 1);
|
|
return true;
|
|
case SSL_ERROR_WANT_CHANNEL_ID_LOOKUP: {
|
|
bssl::UniquePtr<EVP_PKEY> pkey =
|
|
LoadPrivateKey(GetTestConfig(ssl)->send_channel_id);
|
|
if (!pkey) {
|
|
return false;
|
|
}
|
|
test_state->channel_id = std::move(pkey);
|
|
return true;
|
|
}
|
|
case SSL_ERROR_WANT_X509_LOOKUP:
|
|
test_state->cert_ready = true;
|
|
return true;
|
|
case SSL_ERROR_PENDING_SESSION:
|
|
test_state->session = std::move(test_state->pending_session);
|
|
return true;
|
|
case SSL_ERROR_PENDING_CERTIFICATE:
|
|
test_state->early_callback_ready = true;
|
|
return true;
|
|
case SSL_ERROR_WANT_PRIVATE_KEY_OPERATION:
|
|
test_state->private_key_retries++;
|
|
return true;
|
|
case SSL_ERROR_WANT_CERTIFICATE_VERIFY:
|
|
test_state->custom_verify_ready = true;
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int CheckIdempotentError(const char *name, SSL *ssl,
|
|
std::function<int()> func) {
|
|
int ret = func();
|
|
int ssl_err = SSL_get_error(ssl, ret);
|
|
uint32_t err = ERR_peek_error();
|
|
if (ssl_err == SSL_ERROR_SSL || ssl_err == SSL_ERROR_ZERO_RETURN) {
|
|
int ret2 = func();
|
|
int ssl_err2 = SSL_get_error(ssl, ret2);
|
|
uint32_t err2 = ERR_peek_error();
|
|
if (ret != ret2 || ssl_err != ssl_err2 || err != err2) {
|
|
fprintf(stderr, "Repeating %s did not replay the error.\n", name);
|
|
char buf[256];
|
|
ERR_error_string_n(err, buf, sizeof(buf));
|
|
fprintf(stderr, "Wanted: %d %d %s\n", ret, ssl_err, buf);
|
|
ERR_error_string_n(err2, buf, sizeof(buf));
|
|
fprintf(stderr, "Got: %d %d %s\n", ret2, ssl_err2, buf);
|
|
// runner treats exit code 90 as always failing. Otherwise, it may
|
|
// accidentally consider the result an expected protocol failure.
|
|
exit(90);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|