Differential D33007 Diff 100017 tests/sys/kern/ktls_test.c

Changeset View

Standalone View

tests/sys/kern/ktls_test.c

Show First 20 Lines • Show All 811 Lines • ▼ Show 20 Lines	encrypt_tls_12_aead(struct tls_enable *en, uint8_t record_type, uint64_t seqno,
ATF_REQUIRE(aead_encrypt(tls_EVP_CIPHER(en), en->cipher_key, nonce,		ATF_REQUIRE(aead_encrypt(tls_EVP_CIPHER(en), en->cipher_key, nonce,
&aad, sizeof(aad), src, (char *)dst + hdr_len, len,		&aad, sizeof(aad), src, (char *)dst + hdr_len, len,
(char *)dst + hdr_len + len, mac_len));		(char *)dst + hdr_len + len, mac_len));

return (record_len);		return (record_len);
}		}

static size_t		static size_t
		encrypt_tls_13_aead(struct tls_enable *en, uint8_t record_type, uint64_t seqno,
		const void src, size_t len, void dst, size_t padding)
		{
		struct tls_record_layer *hdr;
		struct tls_aead_data_13 aad;
		char nonce[12];
		char *buf;
		size_t hdr_len, mac_len, record_len;

		hdr = dst;

		hdr_len = tls_header_len(en);
		mac_len = tls_mac_len(en);
		record_len = hdr_len + len + 1 + padding + mac_len;

		hdr->tls_type = TLS_RLTYPE_APP;
		hdr->tls_vmajor = TLS_MAJOR_VER_ONE;
		hdr->tls_vminor = TLS_MINOR_VER_TWO;
		hdr->tls_length = htons(record_len - sizeof(*hdr));

		tls_13_aad(en, hdr, seqno, &aad);
		tls_13_nonce(en, seqno, nonce);

		/*
		* Have to use a temporary buffer for the input so that the record
		* type can be appended.
		*/
		buf = malloc(len + 1 + padding);
		memcpy(buf, src, len);
		buf[len] = record_type;
		memset(buf + len + 1, 0, padding);

		ATF_REQUIRE(aead_encrypt(tls_EVP_CIPHER(en), en->cipher_key, nonce,
		&aad, sizeof(aad), buf, (char *)dst + hdr_len, len + 1 + padding,
		(char *)dst + hdr_len + len + 1 + padding, mac_len));

		free(buf);

		return (record_len);
		}

		static size_t
encrypt_tls_aead(struct tls_enable *en, uint8_t record_type, uint64_t seqno,		encrypt_tls_aead(struct tls_enable *en, uint8_t record_type, uint64_t seqno,
const void src, size_t len, void dst, size_t avail)		const void src, size_t len, void dst, size_t avail, size_t padding)
{		{
size_t record_len;		size_t record_len;

record_len = tls_header_len(en) + len + tls_trailer_len(en);		record_len = tls_header_len(en) + len + padding + tls_trailer_len(en);
ATF_REQUIRE(record_len <= avail);		ATF_REQUIRE(record_len <= avail);

ATF_REQUIRE(encrypt_tls_12_aead(en, record_type, seqno, src, len,		if (en->tls_vminor == TLS_MINOR_VER_TWO) {
dst) == record_len);		ATF_REQUIRE(padding == 0);
		ATF_REQUIRE(encrypt_tls_12_aead(en, record_type, seqno, src,
		len, dst) == record_len);
		} else
		ATF_REQUIRE(encrypt_tls_13_aead(en, record_type, seqno, src,
		len, dst, padding) == record_len);

return (record_len);		return (record_len);
}		}

static size_t		static size_t
encrypt_tls_record(struct tls_enable *en, uint8_t record_type, uint64_t seqno,		encrypt_tls_record(struct tls_enable *en, uint8_t record_type, uint64_t seqno,
const void src, size_t len, void dst, size_t avail)		const void src, size_t len, void dst, size_t avail, size_t padding)
{		{
return (encrypt_tls_aead(en, record_type, seqno, src, len, dst, avail));		return (encrypt_tls_aead(en, record_type, seqno, src, len, dst, avail,
		padding));
}		}

static void		static void
test_ktls_transmit_app_data(struct tls_enable *en, uint64_t seqno, size_t len)		test_ktls_transmit_app_data(struct tls_enable *en, uint64_t seqno, size_t len)
{		{
struct kevent ev;		struct kevent ev;
struct tls_record_layer *hdr;		struct tls_record_layer *hdr;
char plaintext, decrypted, *outbuf;		char plaintext, decrypted, *outbuf;
▲ Show 20 Lines • Show All 269 Lines • ▼ Show 20 Lines	ktls_receive_tls_record(struct tls_enable *en, int fd, uint8_t record_type,
ATF_REQUIRE(cmsg != NULL);		ATF_REQUIRE(cmsg != NULL);
ATF_REQUIRE(cmsg->cmsg_level == IPPROTO_TCP);		ATF_REQUIRE(cmsg->cmsg_level == IPPROTO_TCP);
ATF_REQUIRE(cmsg->cmsg_type == TLS_GET_RECORD);		ATF_REQUIRE(cmsg->cmsg_type == TLS_GET_RECORD);
ATF_REQUIRE(cmsg->cmsg_len == CMSG_LEN(sizeof(*tgr)));		ATF_REQUIRE(cmsg->cmsg_len == CMSG_LEN(sizeof(*tgr)));

tgr = (struct tls_get_record *)CMSG_DATA(cmsg);		tgr = (struct tls_get_record *)CMSG_DATA(cmsg);
ATF_REQUIRE(tgr->tls_type == record_type);		ATF_REQUIRE(tgr->tls_type == record_type);
ATF_REQUIRE(tgr->tls_vmajor == en->tls_vmajor);		ATF_REQUIRE(tgr->tls_vmajor == en->tls_vmajor);
		/* XXX: Not sure if this is what OpenSSL expects? */
		if (en->tls_vminor == TLS_MINOR_VER_THREE)
		ATF_REQUIRE(tgr->tls_vminor == TLS_MINOR_VER_TWO);
		else
ATF_REQUIRE(tgr->tls_vminor == en->tls_vminor);		ATF_REQUIRE(tgr->tls_vminor == en->tls_vminor);
ATF_REQUIRE(tgr->tls_length == htons(rv));		ATF_REQUIRE(tgr->tls_length == htons(rv));

return (rv);		return (rv);
}		}

static void		static void
test_ktls_receive_app_data(struct tls_enable *en, uint64_t seqno, size_t len)		test_ktls_receive_app_data(struct tls_enable *en, uint64_t seqno, size_t len,
		size_t padding)
{		{
struct kevent ev;		struct kevent ev;
char plaintext, received, *outbuf;		char plaintext, received, *outbuf;
size_t outbuf_cap, outbuf_len, outbuf_sent, received_len, todo, written;		size_t outbuf_cap, outbuf_len, outbuf_sent, received_len, todo, written;
ssize_t rv;		ssize_t rv;
int kq, sockets[2];		int kq, sockets[2];

plaintext = alloc_buffer(len);		plaintext = alloc_buffer(len);
Show All 24 Lines	while (received_len != len) {
switch (ev.filter) {		switch (ev.filter) {
case EVFILT_WRITE:		case EVFILT_WRITE:
/*		/*
* Compose the next TLS record to send.		* Compose the next TLS record to send.
*/		*/
if (outbuf_len == 0) {		if (outbuf_len == 0) {
ATF_REQUIRE(written < len);		ATF_REQUIRE(written < len);
todo = len - written;		todo = len - written;
if (todo > TLS_MAX_MSG_SIZE_V10_2)		if (todo > TLS_MAX_MSG_SIZE_V10_2 - padding)
todo = TLS_MAX_MSG_SIZE_V10_2;		todo = TLS_MAX_MSG_SIZE_V10_2 - padding;
outbuf_len = encrypt_tls_record(en,		outbuf_len = encrypt_tls_record(en,
TLS_RLTYPE_APP, seqno, plaintext + written,		TLS_RLTYPE_APP, seqno, plaintext + written,
todo, outbuf, outbuf_cap);		todo, outbuf, outbuf_cap, padding);
outbuf_sent = 0;		outbuf_sent = 0;
written += todo;		written += todo;
seqno++;		seqno++;
}		}

/*		/*
* Try to write the remainder of the current		* Try to write the remainder of the current
* TLS record.		* TLS record.
Show All 39 Lines
}		}

#define TLS_10_TESTS(M) \		#define TLS_10_TESTS(M) \
M(aes128_cbc_1_0_sha1, CRYPTO_AES_CBC, 128 / 8, \		M(aes128_cbc_1_0_sha1, CRYPTO_AES_CBC, 128 / 8, \
CRYPTO_SHA1_HMAC) \		CRYPTO_SHA1_HMAC) \
M(aes256_cbc_1_0_sha1, CRYPTO_AES_CBC, 256 / 8, \		M(aes256_cbc_1_0_sha1, CRYPTO_AES_CBC, 256 / 8, \
CRYPTO_SHA1_HMAC)		CRYPTO_SHA1_HMAC)

#define TLS_12_TESTS(M) \
M(aes128_gcm_1_2, CRYPTO_AES_NIST_GCM_16, 128 / 8, 0, \
TLS_MINOR_VER_TWO) \
M(aes256_gcm_1_2, CRYPTO_AES_NIST_GCM_16, 256 / 8, 0, \
TLS_MINOR_VER_TWO) \
M(chacha20_poly1305_1_2, CRYPTO_CHACHA20_POLY1305, 256 / 8, 0, \
TLS_MINOR_VER_TWO)

#define TLS_13_TESTS(M) \		#define TLS_13_TESTS(M) \
M(aes128_gcm_1_3, CRYPTO_AES_NIST_GCM_16, 128 / 8, 0, \		M(aes128_gcm_1_3, CRYPTO_AES_NIST_GCM_16, 128 / 8, 0, \
TLS_MINOR_VER_THREE) \		TLS_MINOR_VER_THREE) \
M(aes256_gcm_1_3, CRYPTO_AES_NIST_GCM_16, 256 / 8, 0, \		M(aes256_gcm_1_3, CRYPTO_AES_NIST_GCM_16, 256 / 8, 0, \
TLS_MINOR_VER_THREE) \		TLS_MINOR_VER_THREE) \
M(chacha20_poly1305_1_3, CRYPTO_CHACHA20_POLY1305, 256 / 8, 0, \		M(chacha20_poly1305_1_3, CRYPTO_CHACHA20_POLY1305, 256 / 8, 0, \
TLS_MINOR_VER_THREE)		TLS_MINOR_VER_THREE)

▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Lines	M(aes128_cbc_1_3_sha384, CRYPTO_AES_CBC, 128 / 8, \
CRYPTO_SHA2_384_HMAC, TLS_MINOR_VER_THREE)		CRYPTO_SHA2_384_HMAC, TLS_MINOR_VER_THREE)

/*		/*
* Ensure that invalid cipher suites are rejected for transmit.		* Ensure that invalid cipher suites are rejected for transmit.
*/		*/
INVALID_CIPHER_SUITES(GEN_INVALID_TRANSMIT_TEST);		INVALID_CIPHER_SUITES(GEN_INVALID_TRANSMIT_TEST);

#define GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		#define GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, name, len) \		auth_alg, minor, name, len, padding) \
ATF_TC_WITHOUT_HEAD(ktls_receive_##cipher_name##_##name); \		ATF_TC_WITHOUT_HEAD(ktls_receive_##cipher_name##_##name); \
ATF_TC_BODY(ktls_receive_##cipher_name##_##name, tc) \		ATF_TC_BODY(ktls_receive_##cipher_name##_##name, tc) \
{ \		{ \
struct tls_enable en; \		struct tls_enable en; \
uint64_t seqno; \		uint64_t seqno; \
\		\
ATF_REQUIRE_KTLS(); \		ATF_REQUIRE_KTLS(); \
seqno = random(); \		seqno = random(); \
build_tls_enable(cipher_alg, key_size, auth_alg, minor, seqno, \		build_tls_enable(cipher_alg, key_size, auth_alg, minor, seqno, \
&en); \		&en); \
test_ktls_receive_app_data(&en, seqno, len); \		test_ktls_receive_app_data(&en, seqno, len, padding); \
free_tls_enable(&en); \		free_tls_enable(&en); \
}		}

#define ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		#define ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, name) \		auth_alg, minor, name) \
ATF_TP_ADD_TC(tp, ktls_receive_##cipher_name##_##name);		ATF_TP_ADD_TC(tp, ktls_receive_##cipher_name##_##name);

#define GEN_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, auth_alg, \		#define GEN_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, auth_alg, \
minor) \		minor) \
GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, short, 64) \		auth_alg, minor, short, 64, 0) \
GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, long, 64 * 1024)		auth_alg, minor, long, 64 * 1024, 0)

#define ADD_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, auth_alg, \		#define ADD_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, auth_alg, \
minor) \		minor) \
ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, short) \		auth_alg, minor, short) \
ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \		ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
auth_alg, minor, long)		auth_alg, minor, long)

/*		/*
* For each supported cipher suite, run two receive tests:		* For each supported cipher suite, run two receive tests:
*		*
* - a short test which sends 64 bytes of application data (likely as		* - a short test which sends 64 bytes of application data (likely as
* a single TLS record)		* a single TLS record)
*		*
* - a long test which sends 64KB of application data (split across		* - a long test which sends 64KB of application data (split across
* multiple TLS records)		* multiple TLS records)
*		*
* Note that receive is currently only supported for TLS 1.2 AEAD		* Note that receive is currently only supported for TLS 1.2 AEAD
* cipher suites.		* cipher suites.
*/		*/
TLS_12_TESTS(GEN_RECEIVE_TESTS);		AES_GCM_TESTS(GEN_RECEIVE_TESTS);
		CHACHA20_TESTS(GEN_RECEIVE_TESTS);

		#define GEN_PADDING_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, \
		auth_alg, minor) \
		GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
		auth_alg, minor, short_padded, 64, 16) \
		GEN_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
		auth_alg, minor, long_padded, 64 * 1024, 15)

		#define ADD_PADDING_RECEIVE_TESTS(cipher_name, cipher_alg, key_size, \
		auth_alg, minor) \
		ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
		auth_alg, minor, short_padded) \
		ADD_RECEIVE_APP_DATA_TEST(cipher_name, cipher_alg, key_size, \
		auth_alg, minor, long_padded)

		/*
		* For TLS 1.3 cipher suites, run two additional receive tests which
		* use add padding to each record.
		*/
		TLS_13_TESTS(GEN_PADDING_RECEIVE_TESTS);

static void		static void
test_ktls_invalid_receive_cipher_suite(struct tls_enable *en)		test_ktls_invalid_receive_cipher_suite(struct tls_enable *en)
{		{
int sockets[2];		int sockets[2];

ATF_REQUIRE_MSG(socketpair_tcp(sockets), "failed to create sockets");		ATF_REQUIRE_MSG(socketpair_tcp(sockets), "failed to create sockets");

ATF_REQUIRE(setsockopt(sockets[1], IPPROTO_TCP, TCP_RXTLS_ENABLE, en,		ATF_REQUIRE(setsockopt(sockets[1], IPPROTO_TCP, TCP_RXTLS_ENABLE, en,
sizeof(*en)) == -1);		sizeof(*en)) == -1);
		ATF_REQUIRE(errno == EINVAL);

/*
* XXX: TLS 1.3 fails with ENOTSUP before checking for invalid
* ciphers.
*/
ATF_REQUIRE(errno == EINVAL \|\| errno == ENOTSUP);

ATF_REQUIRE(close(sockets[1]) == 0);		ATF_REQUIRE(close(sockets[1]) == 0);
ATF_REQUIRE(close(sockets[0]) == 0);		ATF_REQUIRE(close(sockets[0]) == 0);
}		}

#define GEN_INVALID_RECEIVE_TEST(name, cipher_alg, key_size, auth_alg, \		#define GEN_INVALID_RECEIVE_TEST(name, cipher_alg, key_size, auth_alg, \
minor) \		minor) \
ATF_TC_WITHOUT_HEAD(ktls_receive_invalid_##name); \		ATF_TC_WITHOUT_HEAD(ktls_receive_invalid_##name); \
ATF_TC_BODY(ktls_receive_invalid_##name, tc) \		ATF_TC_BODY(ktls_receive_invalid_##name, tc) \
Show All 22 Lines
test_ktls_unsupported_receive_cipher_suite(struct tls_enable *en)		test_ktls_unsupported_receive_cipher_suite(struct tls_enable *en)
{		{
int sockets[2];		int sockets[2];

ATF_REQUIRE_MSG(socketpair_tcp(sockets), "failed to create sockets");		ATF_REQUIRE_MSG(socketpair_tcp(sockets), "failed to create sockets");

ATF_REQUIRE(setsockopt(sockets[1], IPPROTO_TCP, TCP_RXTLS_ENABLE, en,		ATF_REQUIRE(setsockopt(sockets[1], IPPROTO_TCP, TCP_RXTLS_ENABLE, en,
sizeof(*en)) == -1);		sizeof(*en)) == -1);
ATF_REQUIRE(errno == EPROTONOSUPPORT \|\| errno == ENOTSUP);		ATF_REQUIRE(errno == EPROTONOSUPPORT);

ATF_REQUIRE(close(sockets[1]) == 0);		ATF_REQUIRE(close(sockets[1]) == 0);
ATF_REQUIRE(close(sockets[0]) == 0);		ATF_REQUIRE(close(sockets[0]) == 0);
}		}

#define GEN_UNSUPPORTED_RECEIVE_TEST(name, cipher_alg, key_size, \		#define GEN_UNSUPPORTED_RECEIVE_TEST(name, cipher_alg, key_size, \
auth_alg, minor) \		auth_alg, minor) \
ATF_TC_WITHOUT_HEAD(ktls_receive_unsupported_##name); \		ATF_TC_WITHOUT_HEAD(ktls_receive_unsupported_##name); \
Show All 14 Lines	#define ADD_UNSUPPORTED_RECEIVE_TEST(name, cipher_alg, key_size, \
auth_alg, minor) \		auth_alg, minor) \
ATF_TP_ADD_TC(tp, ktls_receive_unsupported_##name);		ATF_TP_ADD_TC(tp, ktls_receive_unsupported_##name);

/*		/*
* Ensure that valid cipher suites not supported for receive are		* Ensure that valid cipher suites not supported for receive are
* rejected.		* rejected.
*/		*/
AES_CBC_TESTS(GEN_UNSUPPORTED_RECEIVE_TEST);		AES_CBC_TESTS(GEN_UNSUPPORTED_RECEIVE_TEST);
TLS_13_TESTS(GEN_UNSUPPORTED_RECEIVE_TEST);

ATF_TP_ADD_TCS(tp)		ATF_TP_ADD_TCS(tp)
{		{
/* Transmit tests */		/* Transmit tests */
AES_CBC_TESTS(ADD_TRANSMIT_TESTS);		AES_CBC_TESTS(ADD_TRANSMIT_TESTS);
AES_GCM_TESTS(ADD_TRANSMIT_TESTS);		AES_GCM_TESTS(ADD_TRANSMIT_TESTS);
CHACHA20_TESTS(ADD_TRANSMIT_TESTS);		CHACHA20_TESTS(ADD_TRANSMIT_TESTS);
AES_CBC_TESTS(ADD_TRANSMIT_PADDING_TESTS);		AES_CBC_TESTS(ADD_TRANSMIT_PADDING_TESTS);
TLS_10_TESTS(ADD_TRANSMIT_EMPTY_FRAGMENT_TEST);		TLS_10_TESTS(ADD_TRANSMIT_EMPTY_FRAGMENT_TEST);
INVALID_CIPHER_SUITES(ADD_INVALID_TRANSMIT_TEST);		INVALID_CIPHER_SUITES(ADD_INVALID_TRANSMIT_TEST);

/* Receive tests */		/* Receive tests */
AES_CBC_TESTS(ADD_UNSUPPORTED_RECEIVE_TEST);		AES_CBC_TESTS(ADD_UNSUPPORTED_RECEIVE_TEST);
TLS_12_TESTS(ADD_RECEIVE_TESTS);		AES_GCM_TESTS(ADD_RECEIVE_TESTS);
TLS_13_TESTS(ADD_UNSUPPORTED_RECEIVE_TEST);		CHACHA20_TESTS(ADD_RECEIVE_TESTS);
		TLS_13_TESTS(ADD_PADDING_RECEIVE_TESTS);
INVALID_CIPHER_SUITES(ADD_INVALID_RECEIVE_TEST);		INVALID_CIPHER_SUITES(ADD_INVALID_RECEIVE_TEST);

return (atf_no_error());		return (atf_no_error());
}		}