svn commit: r536339 - in head/security/openssl: . files
Bernard Spil
brnrd at FreeBSD.org
Sat May 23 19:35:44 UTC 2020
Author: brnrd
Date: Sat May 23 19:35:43 2020
New Revision: 536339
URL: https://svnweb.freebsd.org/changeset/ports/536339
Log:
security/openssl: Add kernel TLS option
Submitted by: jhb at freebsd.org
Differential Revision: https://reviews.freebsd.org/D24274
Added:
head/security/openssl/files/extra-patch-ktls (contents, props changed)
Modified:
head/security/openssl/Makefile
head/security/openssl/pkg-plist
Modified: head/security/openssl/Makefile
==============================================================================
--- head/security/openssl/Makefile Sat May 23 19:34:53 2020 (r536338)
+++ head/security/openssl/Makefile Sat May 23 19:35:43 2020 (r536339)
@@ -40,11 +40,13 @@ OPTIONS_GROUP_OPTIMIZE= ASM SSE2 THREADS
OPTIONS_DEFINE_i386= I386
OPTIONS_GROUP_PROTOCOLS=NEXTPROTONEG SCTP SSL3 TLS1 TLS1_1 TLS1_2
-OPTIONS_DEFINE= ASYNC CT MAN3 RFC3779 SHARED ZLIB
+OPTIONS_DEFINE= ASYNC CT KTLS MAN3 RFC3779 SHARED ZLIB
OPTIONS_DEFAULT=ASM ASYNC CT GOST DES EC MAN3 MD4 NEXTPROTONEG RC2 RC4 \
RMD160 SCTP SHARED SSE2 THREADS TLS1 TLS1_1 TLS1_2
+OPTIONS_EXCLUDE=${${OSVERSION} < 1300042:?KTLS:}
+
OPTIONS_GROUP_OPTIMIZE_amd64= EC
.if ${MACHINE_ARCH} == "amd64"
@@ -66,6 +68,7 @@ GOST_DESC= GOST (Russian standard)
HASHES_DESC= Hash Function Support
I386_DESC= i386 (instead of i486+)
IDEA_DESC= International Data Encryption Algorithm
+KTLS_DESC= Kernel TLS offload
MAN3_DESC= Install API manpages (section 3, 7)
MD2_DESC= MD2 (obsolete)
MD4_DESC= MD4 (unsafe)
@@ -92,7 +95,7 @@ WEAK-SSL-CIPHERS_DESC= Weak cipher support (unsafe)
ZLIB_DESC= zlib compression support
# Upstream default disabled options
-.for _option in md2 rc5 sctp ssl3 zlib weak-ssl-ciphers
+.for _option in ktls md2 rc5 sctp ssl3 zlib weak-ssl-ciphers
${_option:tu}_CONFIGURE_ON= enable-${_option}
.endfor
@@ -108,6 +111,7 @@ TLS1_1_IMPLIES= TLS1_2
EC_CONFIGURE_ON= enable-ec_nistp_64_gcc_128
I386_CONFIGURE_ON= 386
+KTLS_EXTRA_PATCHES= ${FILESDIR}/extra-patch-ktls
MAN3_EXTRA_PATCHES_OFF= ${FILESDIR}/extra-patch-util_process__docs.pl
SHARED_MAKE_ENV= SHLIBVER=${OPENSSL_SHLIBVER}
SHARED_PLIST_SUB= SHLIBVER=${OPENSSL_SHLIBVER}
Added: head/security/openssl/files/extra-patch-ktls
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ head/security/openssl/files/extra-patch-ktls Sat May 23 19:35:43 2020 (r536339)
@@ -0,0 +1,2567 @@
+diff --git CHANGES CHANGES
+index f4230aaac0..3cc665f654 100644
+--- CHANGES
++++ CHANGES
+@@ -306,6 +306,11 @@
+ necessary to configure just to create a source distribution.
+ [Richard Levitte]
+
++ *) Added support for Linux Kernel TLS data-path. The Linux Kernel data-path
++ improves application performance by removing data copies and providing
++ applications with zero-copy system calls such as sendfile and splice.
++ [Boris Pismenny]
++
+ Changes between 1.1.1 and 1.1.1a [20 Nov 2018]
+
+ *) Timing vulnerability in DSA signature generation
+diff --git Configure Configure
+index 2e9efaa5f3..524b58cbb9 100755
+--- Configure
++++ Configure
+@@ -331,6 +331,7 @@ my @dtls = qw(dtls1 dtls1_2);
+ # For developers: keep it sorted alphabetically
+
+ my @disablables = (
++ "ktls",
+ "afalgeng",
+ "aria",
+ "asan",
+@@ -464,6 +465,7 @@ our %disabled = ( # "what" => "comment"
+ "weak-ssl-ciphers" => "default",
+ "zlib" => "default",
+ "zlib-dynamic" => "default",
++ "ktls" => "default",
+ );
+
+ # Note: => pair form used for aesthetics, not to truly make a hash table
+@@ -1567,6 +1569,33 @@ unless ($disabled{devcryptoeng}) {
+ }
+ }
+
++unless ($disabled{ktls}) {
++ $config{ktls}="";
++ if ($target =~ m/^linux/) {
++ my $usr = "/usr/$config{cross_compile_prefix}";
++ chop($usr);
++ if ($config{cross_compile_prefix} eq "") {
++ $usr = "/usr";
++ }
++ my $minver = (4 << 16) + (13 << 8) + 0;
++ my @verstr = split(" ",`cat $usr/include/linux/version.h | grep LINUX_VERSION_CODE`);
++
++ if ($verstr[2] < $minver) {
++ disable('too-old-kernel', 'ktls');
++ }
++ } elsif ($target =~ m/^BSD/) {
++ my $cc = $config{CROSS_COMPILE}.$config{CC};
++ system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
++ if ($? != 0) {
++ disable('too-old-freebsd', 'ktls');
++ }
++ } else {
++ disable('not-linux-or-freebsd', 'ktls');
++ }
++}
++
++push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
++
+ # Get the extra flags used when building shared libraries and modules. We
+ # do this late because some of them depend on %disabled.
+
+diff --git INSTALL INSTALL
+index 328ad2baf4..46735b8236 100644
+--- INSTALL
++++ INSTALL
+@@ -262,6 +262,15 @@
+ Don't build the AFALG engine. This option will be forced if
+ on a platform that does not support AFALG.
+
++ enable-ktls
++ Build with Kernel TLS support. This option will enable the
++ use of the Kernel TLS data-path, which can improve
++ performance and allow for the use of sendfile and splice
++ system calls on TLS sockets. The Kernel may use TLS
++ accelerators if any are available on the system.
++ This option will be forced off on systems that do not support
++ the Kernel TLS data-path.
++
+ enable-asan
+ Build with the Address sanitiser. This is a developer option
+ only. It may not work on all platforms and should never be
+diff --git apps/s_client.c apps/s_client.c
+index 26a6789d81..457e539b85 100644
+--- apps/s_client.c
++++ apps/s_client.c
+@@ -3262,6 +3262,12 @@ static void print_stuff(BIO *bio, SSL *s, int full)
+ BIO_printf(bio, "Expansion: %s\n",
+ expansion ? SSL_COMP_get_name(expansion) : "NONE");
+ #endif
++#ifndef OPENSSL_NO_KTLS
++ if (BIO_get_ktls_send(SSL_get_wbio(s)))
++ BIO_printf(bio_err, "Using Kernel TLS for sending\n");
++ if (BIO_get_ktls_recv(SSL_get_rbio(s)))
++ BIO_printf(bio_err, "Using Kernel TLS for receiving\n");
++#endif
+
+ #ifdef SSL_DEBUG
+ {
+diff --git apps/s_server.c apps/s_server.c
+index 0ba75999fd..ddc0b4bcd7 100644
+--- apps/s_server.c
++++ apps/s_server.c
+@@ -2923,6 +2923,12 @@ static void print_connection_info(SSL *con)
+ }
+ OPENSSL_free(exportedkeymat);
+ }
++#ifndef OPENSSL_NO_KTLS
++ if (BIO_get_ktls_send(SSL_get_wbio(con)))
++ BIO_printf(bio_err, "Using Kernel TLS for sending\n");
++ if (BIO_get_ktls_recv(SSL_get_rbio(con)))
++ BIO_printf(bio_err, "Using Kernel TLS for receiving\n");
++#endif
+
+ (void)BIO_flush(bio_s_out);
+ }
+diff --git crypto/bio/b_sock2.c crypto/bio/b_sock2.c
+index 335dfabc61..80ef348d92 100644
+--- crypto/bio/b_sock2.c
++++ crypto/bio/b_sock2.c
+@@ -12,6 +12,7 @@
+ #include <errno.h>
+
+ #include "bio_local.h"
++#include "internal/ktls.h"
+
+ #include <openssl/err.h>
+
+@@ -50,6 +51,17 @@ int BIO_socket(int domain, int socktype, int protocol, int options)
+ BIOerr(BIO_F_BIO_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
+ return INVALID_SOCKET;
+ }
++# ifndef OPENSSL_NO_KTLS
++ {
++ /*
++ * The new socket is created successfully regardless of ktls_enable.
++ * ktls_enable doesn't change any functionality of the socket, except
++ * changing the setsockopt to enable the processing of ktls_start.
++ * Thus, it is not a problem to call it for non-TLS sockets.
++ */
++ ktls_enable(sock);
++ }
++# endif
+
+ return sock;
+ }
+diff --git crypto/bio/bss_conn.c crypto/bio/bss_conn.c
+index dd43a40601..3def4550cb 100644
+--- crypto/bio/bss_conn.c
++++ crypto/bio/bss_conn.c
+@@ -11,6 +11,7 @@
+ #include <errno.h>
+
+ #include "bio_local.h"
++#include "internal/ktls.h"
+
+ #ifndef OPENSSL_NO_SOCK
+
+@@ -20,6 +21,9 @@ typedef struct bio_connect_st {
+ char *param_hostname;
+ char *param_service;
+ int connect_mode;
++# ifndef OPENSSL_NO_KTLS
++ unsigned char record_type;
++# endif
+
+ BIO_ADDRINFO *addr_first;
+ const BIO_ADDRINFO *addr_iter;
+@@ -311,7 +315,12 @@ static int conn_read(BIO *b, char *out, int outl)
+
+ if (out != NULL) {
+ clear_socket_error();
+- ret = readsocket(b->num, out, outl);
++# ifndef OPENSSL_NO_KTLS
++ if (BIO_get_ktls_recv(b))
++ ret = ktls_read_record(b->num, out, outl);
++ else
++# endif
++ ret = readsocket(b->num, out, outl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0) {
+ if (BIO_sock_should_retry(ret))
+@@ -336,7 +345,16 @@ static int conn_write(BIO *b, const char *in, int inl)
+ }
+
+ clear_socket_error();
+- ret = writesocket(b->num, in, inl);
++# ifndef OPENSSL_NO_KTLS
++ if (BIO_should_ktls_ctrl_msg_flag(b)) {
++ ret = ktls_send_ctrl_message(b->num, data->record_type, in, inl);
++ if (ret >= 0) {
++ ret = inl;
++ BIO_clear_ktls_ctrl_msg_flag(b);
++ }
++ } else
++# endif
++ ret = writesocket(b->num, in, inl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0) {
+ if (BIO_sock_should_retry(ret))
+@@ -352,6 +370,13 @@ static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
+ const char **pptr = NULL;
+ long ret = 1;
+ BIO_CONNECT *data;
++# ifndef OPENSSL_NO_KTLS
++# ifdef __FreeBSD__
++ struct tls_enable *crypto_info;
++# else
++ struct tls12_crypto_info_aes_gcm_128 *crypto_info;
++# endif
++# endif
+
+ data = (BIO_CONNECT *)b->ptr;
+
+@@ -500,6 +525,31 @@ static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
+ case BIO_CTRL_EOF:
+ ret = (b->flags & BIO_FLAGS_IN_EOF) != 0 ? 1 : 0;
+ break;
++# ifndef OPENSSL_NO_KTLS
++ case BIO_CTRL_SET_KTLS:
++# ifdef __FreeBSD__
++ crypto_info = (struct tls_enable *)ptr;
++# else
++ crypto_info = (struct tls12_crypto_info_aes_gcm_128 *)ptr;
++# endif
++ ret = ktls_start(b->num, crypto_info, sizeof(*crypto_info), num);
++ if (ret)
++ BIO_set_ktls_flag(b, num);
++ break;
++ case BIO_CTRL_GET_KTLS_SEND:
++ return BIO_should_ktls_flag(b, 1);
++ case BIO_CTRL_GET_KTLS_RECV:
++ return BIO_should_ktls_flag(b, 0);
++ case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG:
++ BIO_set_ktls_ctrl_msg_flag(b);
++ data->record_type = num;
++ ret = 0;
++ break;
++ case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG:
++ BIO_clear_ktls_ctrl_msg_flag(b);
++ ret = 0;
++ break;
++# endif
+ default:
+ ret = 0;
+ break;
+diff --git crypto/bio/bss_sock.c crypto/bio/bss_sock.c
+index 6251f3d46a..c879533fef 100644
+--- crypto/bio/bss_sock.c
++++ crypto/bio/bss_sock.c
+@@ -11,6 +11,7 @@
+ #include <errno.h>
+ #include "bio_local.h"
+ #include "internal/cryptlib.h"
++#include "internal/ktls.h"
+
+ #ifndef OPENSSL_NO_SOCK
+
+@@ -64,6 +65,17 @@ BIO *BIO_new_socket(int fd, int close_flag)
+ if (ret == NULL)
+ return NULL;
+ BIO_set_fd(ret, fd, close_flag);
++# ifndef OPENSSL_NO_KTLS
++ {
++ /*
++ * The new socket is created successfully regardless of ktls_enable.
++ * ktls_enable doesn't change any functionality of the socket, except
++ * changing the setsockopt to enable the processing of ktls_start.
++ * Thus, it is not a problem to call it for non-TLS sockets.
++ */
++ ktls_enable(fd);
++ }
++# endif
+ return ret;
+ }
+
+@@ -96,7 +108,12 @@ static int sock_read(BIO *b, char *out, int outl)
+
+ if (out != NULL) {
+ clear_socket_error();
+- ret = readsocket(b->num, out, outl);
++# ifndef OPENSSL_NO_KTLS
++ if (BIO_get_ktls_recv(b))
++ ret = ktls_read_record(b->num, out, outl);
++ else
++# endif
++ ret = readsocket(b->num, out, outl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0) {
+ if (BIO_sock_should_retry(ret))
+@@ -110,10 +127,20 @@ static int sock_read(BIO *b, char *out, int outl)
+
+ static int sock_write(BIO *b, const char *in, int inl)
+ {
+- int ret;
++ int ret = 0;
+
+ clear_socket_error();
+- ret = writesocket(b->num, in, inl);
++# ifndef OPENSSL_NO_KTLS
++ if (BIO_should_ktls_ctrl_msg_flag(b)) {
++ unsigned char record_type = (intptr_t)b->ptr;
++ ret = ktls_send_ctrl_message(b->num, record_type, in, inl);
++ if (ret >= 0) {
++ ret = inl;
++ BIO_clear_ktls_ctrl_msg_flag(b);
++ }
++ } else
++# endif
++ ret = writesocket(b->num, in, inl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0) {
+ if (BIO_sock_should_retry(ret))
+@@ -126,6 +153,13 @@ static long sock_ctrl(BIO *b, int cmd, long num, void *ptr)
+ {
+ long ret = 1;
+ int *ip;
++# ifndef OPENSSL_NO_KTLS
++# ifdef __FreeBSD__
++ struct tls_enable *crypto_info;
++# else
++ struct tls12_crypto_info_aes_gcm_128 *crypto_info;
++# endif
++# endif
+
+ switch (cmd) {
+ case BIO_C_SET_FD:
+@@ -153,6 +187,31 @@ static long sock_ctrl(BIO *b, int cmd, long num, void *ptr)
+ case BIO_CTRL_FLUSH:
+ ret = 1;
+ break;
++# ifndef OPENSSL_NO_KTLS
++ case BIO_CTRL_SET_KTLS:
++# ifdef __FreeBSD__
++ crypto_info = (struct tls_enable *)ptr;
++# else
++ crypto_info = (struct tls12_crypto_info_aes_gcm_128 *)ptr;
++# endif
++ ret = ktls_start(b->num, crypto_info, sizeof(*crypto_info), num);
++ if (ret)
++ BIO_set_ktls_flag(b, num);
++ break;
++ case BIO_CTRL_GET_KTLS_SEND:
++ return BIO_should_ktls_flag(b, 1);
++ case BIO_CTRL_GET_KTLS_RECV:
++ return BIO_should_ktls_flag(b, 0);
++ case BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG:
++ BIO_set_ktls_ctrl_msg_flag(b);
++ b->ptr = (void *)num;
++ ret = 0;
++ break;
++ case BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG:
++ BIO_clear_ktls_ctrl_msg_flag(b);
++ ret = 0;
++ break;
++# endif
+ case BIO_CTRL_EOF:
+ ret = (b->flags & BIO_FLAGS_IN_EOF) != 0 ? 1 : 0;
+ break;
+diff --git crypto/err/openssl.txt crypto/err/openssl.txt
+index 35512f9caf..426297da8b 100644
+--- crypto/err/openssl.txt
++++ crypto/err/openssl.txt
+@@ -1315,6 +1315,7 @@ SSL_F_SSL_RENEGOTIATE:516:SSL_renegotiate
+ SSL_F_SSL_RENEGOTIATE_ABBREVIATED:546:SSL_renegotiate_abbreviated
+ SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT:320:*
+ SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT:321:*
++SSL_F_SSL_SENDFILE:639:SSL_sendfile
+ SSL_F_SSL_SESSION_DUP:348:ssl_session_dup
+ SSL_F_SSL_SESSION_NEW:189:SSL_SESSION_new
+ SSL_F_SSL_SESSION_PRINT_FP:190:SSL_SESSION_print_fp
+diff --git crypto/evp/e_aes.c crypto/evp/e_aes.c
+index 405ddbf9bf..4640c7528a 100644
+--- crypto/evp/e_aes.c
++++ crypto/evp/e_aes.c
+@@ -2895,6 +2895,14 @@ static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr)
+ memcpy(ptr, c->buf, arg);
+ return 1;
+
++ case EVP_CTRL_GET_IV:
++ if (gctx->iv_gen != 1)
++ return 0;
++ if (gctx->ivlen != arg)
++ return 0;
++ memcpy(ptr, gctx->iv, arg);
++ return 1;
++
+ case EVP_CTRL_GCM_SET_IV_FIXED:
+ /* Special case: -1 length restores whole IV */
+ if (arg == -1) {
+diff --git doc/man3/BIO_ctrl.pod doc/man3/BIO_ctrl.pod
+index 60cd10883b..589338dd51 100644
+--- doc/man3/BIO_ctrl.pod
++++ doc/man3/BIO_ctrl.pod
+@@ -5,7 +5,8 @@
+ BIO_ctrl, BIO_callback_ctrl, BIO_ptr_ctrl, BIO_int_ctrl, BIO_reset,
+ BIO_seek, BIO_tell, BIO_flush, BIO_eof, BIO_set_close, BIO_get_close,
+ BIO_pending, BIO_wpending, BIO_ctrl_pending, BIO_ctrl_wpending,
+-BIO_get_info_callback, BIO_set_info_callback, BIO_info_cb
++BIO_get_info_callback, BIO_set_info_callback, BIO_info_cb, BIO_get_ktls_send,
++BIO_get_ktls_recv
+ - BIO control operations
+
+ =head1 SYNOPSIS
+@@ -34,6 +35,9 @@ BIO_get_info_callback, BIO_set_info_callback, BIO_info_cb
+ int BIO_get_info_callback(BIO *b, BIO_info_cb **cbp);
+ int BIO_set_info_callback(BIO *b, BIO_info_cb *cb);
+
++ int BIO_get_ktls_send(BIO *b);
++ int BIO_get_ktls_recv(BIO *b);
++
+ =head1 DESCRIPTION
+
+ BIO_ctrl(), BIO_callback_ctrl(), BIO_ptr_ctrl() and BIO_int_ctrl()
+@@ -72,6 +76,11 @@ Not all BIOs support these calls. BIO_ctrl_pending() and BIO_ctrl_wpending()
+ return a size_t type and are functions, BIO_pending() and BIO_wpending() are
+ macros which call BIO_ctrl().
+
++BIO_get_ktls_send() returns 1 if the BIO is using the Kernel TLS data-path for
++sending. Otherwise, it returns zero.
++BIO_get_ktls_recv() returns 1 if the BIO is using the Kernel TLS data-path for
++receiving. Otherwise, it returns zero.
++
+ =head1 RETURN VALUES
+
+ BIO_reset() normally returns 1 for success and 0 or -1 for failure. File
+@@ -92,6 +101,11 @@ BIO_get_close() returns the close flag value: BIO_CLOSE or BIO_NOCLOSE.
+ BIO_pending(), BIO_ctrl_pending(), BIO_wpending() and BIO_ctrl_wpending()
+ return the amount of pending data.
+
++BIO_get_ktls_send() returns 1 if the BIO is using the Kernel TLS data-path for
++sending. Otherwise, it returns zero.
++BIO_get_ktls_recv() returns 1 if the BIO is using the Kernel TLS data-path for
++receiving. Otherwise, it returns zero.
++
+ =head1 NOTES
+
+ BIO_flush(), because it can write data may return 0 or -1 indicating
+@@ -124,6 +138,11 @@ particular a return value of 0 can be returned if an operation is not
+ supported, if an error occurred, if EOF has not been reached and in
+ the case of BIO_seek() on a file BIO for a successful operation.
+
++=head1 HISTORY
++
++The BIO_get_ktls_send() and BIO_get_ktls_recv() functions were added in
++OpenSSL 3.0.0.
++
+ =head1 COPYRIGHT
+
+ Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
+diff --git doc/man3/SSL_CTX_set_mode.pod doc/man3/SSL_CTX_set_mode.pod
+index 387d1ec1ef..373b2aa0f2 100644
+--- doc/man3/SSL_CTX_set_mode.pod
++++ doc/man3/SSL_CTX_set_mode.pod
+@@ -114,6 +114,22 @@ enables this behaviour to allow interoperability with such broken
+ implementations. Please note that setting this option breaks interoperability
+ with correct implementations. This option only applies to DTLS over SCTP.
+
++=item SSL_MODE_NO_KTLS_TX
++
++Disable the use of the kernel TLS egress data-path.
++By default kernel TLS is enabled if it is supported by the negotiated ciphersuites
++and extensions and OpenSSL has been compiled with support for it.
++The kernel TLS data-path implements the record layer,
++and the crypto algorithm. The kernel will utilize the best hardware
++available for crypto. Using the kernel data-path should reduce the memory
++footprint of OpenSSL because no buffering is required. Also, the throughput
++should improve because data copy is avoided when user data is encrypted into
++kernel memory instead of the usual encrypt than copy to kernel.
++
++Kernel TLS might not support all the features of OpenSSL. For instance,
++renegotiation, and setting the maximum fragment size is not possible as of
++Linux 4.20.
++
+ =back
+
+ All modes are off by default except for SSL_MODE_AUTO_RETRY which is on by
+@@ -134,6 +150,7 @@ L<SSL_write(3)>, L<SSL_get_error(3)>
+ =head1 HISTORY
+
+ SSL_MODE_ASYNC was added in OpenSSL 1.1.0.
++SSL_MODE_NO_KTLS_TX was first added to OpenSSL 3.0.0.
+
+ =head1 COPYRIGHT
+
+diff --git doc/man3/SSL_write.pod doc/man3/SSL_write.pod
+index a76ffbb8fd..d7900fd87b 100644
+--- doc/man3/SSL_write.pod
++++ doc/man3/SSL_write.pod
+@@ -2,12 +2,13 @@
+
+ =head1 NAME
+
+-SSL_write_ex, SSL_write - write bytes to a TLS/SSL connection
++SSL_write_ex, SSL_write, SSL_sendfile - write bytes to a TLS/SSL connection
+
+ =head1 SYNOPSIS
+
+ #include <openssl/ssl.h>
+
++ ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags);
+ int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written);
+ int SSL_write(SSL *ssl, const void *buf, int num);
+
+@@ -17,6 +18,14 @@ SSL_write_ex() and SSL_write() write B<num> bytes from the buffer B<buf> into
+ the specified B<ssl> connection. On success SSL_write_ex() will store the number
+ of bytes written in B<*written>.
+
++SSL_sendfile() writes B<size> bytes from offset B<offset> in the file
++descriptor B<fd> to the specified SSL connection B<s>. This function provides
++efficient zero-copy semantics. SSL_sendfile() is available only when
++Kernel TLS is enabled, which can be checked by calling BIO_get_ktls_send().
++It is provided here to allow users to maintain the same interface.
++The meaning of B<flags> is platform dependent.
++Currently, under Linux it is ignored.
++
+ =head1 NOTES
+
+ In the paragraphs below a "write function" is defined as one of either
+@@ -104,17 +113,35 @@ You should instead call SSL_get_error() to find out if it's retryable.
+
+ =back
+
++For SSL_sendfile(), the following return values can occur:
++
++=over 4
++
++=item Z<>>= 0
++
++The write operation was successful, the return value is the number
++of bytes of the file written to the TLS/SSL connection.
++
++=item E<lt> 0
++
++The write operation was not successful, because either the connection was
++closed, an error occured or action must be taken by the calling process.
++Call SSL_get_error() with the return value to find out the reason.
++
++=back
++
+ =head1 SEE ALSO
+
+ L<SSL_get_error(3)>, L<SSL_read_ex(3)>, L<SSL_read(3)>
+ L<SSL_CTX_set_mode(3)>, L<SSL_CTX_new(3)>,
+ L<SSL_connect(3)>, L<SSL_accept(3)>
+-L<SSL_set_connect_state(3)>,
++L<SSL_set_connect_state(3)>, L<BIO_ctrl(3)>,
+ L<ssl(7)>, L<bio(7)>
+
+ =head1 HISTORY
+
+ The SSL_write_ex() function was added in OpenSSL 1.1.1.
++The SSL_sendfile() function was added in OpenSSL 3.0.0.
+
+ =head1 COPYRIGHT
+
+diff --git engines/e_afalg.c engines/e_afalg.c
+index 4b17228461..5ef3a8d457 100644
+--- engines/e_afalg.c
++++ engines/e_afalg.c
+@@ -407,7 +407,7 @@ static int afalg_start_cipher_sk(afalg_ctx *actx, const unsigned char *in,
+ size_t inl, const unsigned char *iv,
+ unsigned int enc)
+ {
+- struct msghdr msg = { 0 };
++ struct msghdr msg;
+ struct cmsghdr *cmsg;
+ struct iovec iov;
+ ssize_t sbytes;
+@@ -416,6 +416,7 @@ static int afalg_start_cipher_sk(afalg_ctx *actx, const unsigned char *in,
+ # endif
+ char cbuf[CMSG_SPACE(ALG_IV_LEN(ALG_AES_IV_LEN)) + CMSG_SPACE(ALG_OP_LEN)];
+
++ memset(&msg, 0, sizeof(msg));
+ memset(cbuf, 0, sizeof(cbuf));
+ msg.msg_control = cbuf;
+ msg.msg_controllen = sizeof(cbuf);
+diff --git include/internal/bio.h include/internal/bio.h
+index c343b27629..521b5fa219 100644
+--- include/internal/bio.h
++++ include/internal/bio.h
+@@ -7,6 +7,9 @@
+ * https://www.openssl.org/source/license.html
+ */
+
++#ifndef HEADER_INTERNAL_BIO_H
++# define HEADER_INTERNAL_BIO_H
++
+ #include <openssl/bio.h>
+
+ struct bio_method_st {
+@@ -31,3 +34,39 @@ void bio_cleanup(void);
+ /* Old style to new style BIO_METHOD conversion functions */
+ int bwrite_conv(BIO *bio, const char *data, size_t datal, size_t *written);
+ int bread_conv(BIO *bio, char *data, size_t datal, size_t *read);
++
++/* Changes to these internal BIOs must also update include/openssl/bio.h */
++# define BIO_CTRL_SET_KTLS 72
++# define BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG 74
++# define BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG 75
++
++/*
++ * This is used with socket BIOs:
++ * BIO_FLAGS_KTLS_TX means we are using ktls with this BIO for sending.
++ * BIO_FLAGS_KTLS_TX_CTRL_MSG means we are about to send a ctrl message next.
++ * BIO_FLAGS_KTLS_RX means we are using ktls with this BIO for receiving.
++ */
++# define BIO_FLAGS_KTLS_TX 0x800
++# define BIO_FLAGS_KTLS_TX_CTRL_MSG 0x1000
++# define BIO_FLAGS_KTLS_RX 0x2000
++
++/* KTLS related controls and flags */
++# define BIO_set_ktls_flag(b, is_tx) \
++ BIO_set_flags(b, (is_tx) ? BIO_FLAGS_KTLS_TX : BIO_FLAGS_KTLS_RX)
++# define BIO_should_ktls_flag(b, is_tx) \
++ BIO_test_flags(b, (is_tx) ? BIO_FLAGS_KTLS_TX : BIO_FLAGS_KTLS_RX)
++# define BIO_set_ktls_ctrl_msg_flag(b) \
++ BIO_set_flags(b, BIO_FLAGS_KTLS_TX_CTRL_MSG)
++# define BIO_should_ktls_ctrl_msg_flag(b) \
++ BIO_test_flags(b, BIO_FLAGS_KTLS_TX_CTRL_MSG)
++# define BIO_clear_ktls_ctrl_msg_flag(b) \
++ BIO_clear_flags(b, BIO_FLAGS_KTLS_TX_CTRL_MSG)
++
++# define BIO_set_ktls(b, keyblob, is_tx) \
++ BIO_ctrl(b, BIO_CTRL_SET_KTLS, is_tx, keyblob)
++# define BIO_set_ktls_ctrl_msg(b, record_type) \
++ BIO_ctrl(b, BIO_CTRL_SET_KTLS_TX_SEND_CTRL_MSG, record_type, NULL)
++# define BIO_clear_ktls_ctrl_msg(b) \
++ BIO_ctrl(b, BIO_CTRL_CLEAR_KTLS_TX_CTRL_MSG, 0, NULL)
++
++#endif
+diff --git include/internal/ktls.h include/internal/ktls.h
+new file mode 100644
+index 0000000000..209dff1689
+--- /dev/null
++++ include/internal/ktls.h
+@@ -0,0 +1,345 @@
++/*
++ * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
++ *
++ * Licensed under the Apache License 2.0 (the "License"). You may not use
++ * this file except in compliance with the License. You can obtain a copy
++ * in the file LICENSE in the source distribution or at
++ * https://www.openssl.org/source/license.html
++ */
++
++#ifndef OPENSSL_NO_KTLS
++# ifndef HEADER_INTERNAL_KTLS
++# define HEADER_INTERNAL_KTLS
++
++# if defined(__FreeBSD__)
++# include <sys/types.h>
++# include <sys/socket.h>
++# include <sys/ktls.h>
++# include <netinet/in.h>
++# include <netinet/tcp.h>
++# include <crypto/cryptodev.h>
++
++/*
++ * Only used by the tests in sslapitest.c.
++ */
++# define TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE 8
++
++/*
++ * FreeBSD does not require any additional steps to enable KTLS before
++ * setting keys.
++ */
++static ossl_inline int ktls_enable(int fd)
++{
++ return 1;
++}
++
++/*
++ * The TCP_TXTLS_ENABLE socket option marks the outgoing socket buffer
++ * as using TLS. If successful, then data sent using this socket will
++ * be encrypted and encapsulated in TLS records using the tls_en.
++ * provided here.
++ */
++static ossl_inline int ktls_start(int fd,
++ struct tls_enable *tls_en,
++ size_t len, int is_tx)
++{
++ if (is_tx)
++ return setsockopt(fd, IPPROTO_TCP, TCP_TXTLS_ENABLE,
++ tls_en, sizeof(*tls_en)) ? 0 : 1;
++ else
++ return 0;
++}
++
++/*
++ * Send a TLS record using the tls_en provided in ktls_start and use
++ * record_type instead of the default SSL3_RT_APPLICATION_DATA.
++ * When the socket is non-blocking, then this call either returns EAGAIN or
++ * the entire record is pushed to TCP. It is impossible to send a partial
++ * record using this control message.
++ */
++static ossl_inline int ktls_send_ctrl_message(int fd, unsigned char record_type,
++ const void *data, size_t length)
++{
++ struct msghdr msg = { 0 };
++ int cmsg_len = sizeof(record_type);
++ struct cmsghdr *cmsg;
++ char buf[CMSG_SPACE(cmsg_len)];
++ struct iovec msg_iov; /* Vector of data to send/receive into */
++
++ msg.msg_control = buf;
++ msg.msg_controllen = sizeof(buf);
++ cmsg = CMSG_FIRSTHDR(&msg);
++ cmsg->cmsg_level = IPPROTO_TCP;
++ cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
++ cmsg->cmsg_len = CMSG_LEN(cmsg_len);
++ *((unsigned char *)CMSG_DATA(cmsg)) = record_type;
++ msg.msg_controllen = cmsg->cmsg_len;
++
++ msg_iov.iov_base = (void *)data;
++ msg_iov.iov_len = length;
++ msg.msg_iov = &msg_iov;
++ msg.msg_iovlen = 1;
++
++ return sendmsg(fd, &msg, 0);
++}
++
++static ossl_inline int ktls_read_record(int fd, void *data, size_t length)
++{
++ return -1;
++}
++
++/*
++ * KTLS enables the sendfile system call to send data from a file over
++ * TLS.
++ */
++static ossl_inline ossl_ssize_t ktls_sendfile(int s, int fd, off_t off,
++ size_t size, int flags)
++{
++ off_t sbytes;
++ int ret;
++
++ ret = sendfile(fd, s, off, size, NULL, &sbytes, flags);
++ if (ret == -1) {
++ if (errno == EAGAIN && sbytes != 0)
++ return sbytes;
++ return -1;
++ }
++ return sbytes;
++}
++# endif /* __FreeBSD__ */
++
++# if defined(OPENSSL_SYS_LINUX)
++# include <linux/version.h>
++
++# define K_MAJ 4
++# define K_MIN1 13
++# define K_MIN2 0
++# if LINUX_VERSION_CODE < KERNEL_VERSION(K_MAJ, K_MIN1, K_MIN2)
++
++# ifndef PEDANTIC
++# warning "KTLS requires Kernel Headers >= 4.13.0"
++# warning "Skipping Compilation of KTLS"
++# endif
++
++# define TLS_TX 1
++# define TLS_RX 2
++
++# define TLS_CIPHER_AES_GCM_128 51
++# define TLS_CIPHER_AES_GCM_128_IV_SIZE 8
++# define TLS_CIPHER_AES_GCM_128_KEY_SIZE 16
++# define TLS_CIPHER_AES_GCM_128_SALT_SIZE 4
++# define TLS_CIPHER_AES_GCM_128_TAG_SIZE 16
++# define TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE 8
++
++# define TLS_SET_RECORD_TYPE 1
++
++struct tls_crypto_info {
++ unsigned short version;
++ unsigned short cipher_type;
++};
++
++struct tls12_crypto_info_aes_gcm_128 {
++ struct tls_crypto_info info;
++ unsigned char iv[TLS_CIPHER_AES_GCM_128_IV_SIZE];
++ unsigned char key[TLS_CIPHER_AES_GCM_128_KEY_SIZE];
++ unsigned char salt[TLS_CIPHER_AES_GCM_128_SALT_SIZE];
++ unsigned char rec_seq[TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE];
++};
++
++/* Dummy functions here */
++static ossl_inline int ktls_enable(int fd)
++{
++ return 0;
++}
++
++static ossl_inline int ktls_start(int fd,
++ struct tls12_crypto_info_aes_gcm_128
++ *crypto_info, size_t len, int is_tx)
++{
++ return 0;
++}
++
++static ossl_inline int ktls_send_ctrl_message(int fd, unsigned char record_type,
++ const void *data, size_t length)
++{
++ return -1;
++}
++
++static ossl_inline int ktls_read_record(int fd, void *data, size_t length)
++{
++ return -1;
++}
++
++static ossl_inline ossl_ssize_t ktls_sendfile(int s, int fd, off_t off, size_t size, int flags)
++{
++ return -1;
++}
++
++# else /* KERNEL_VERSION */
++
++# include <sys/sendfile.h>
++# include <netinet/tcp.h>
++# include <linux/tls.h>
++# include <linux/socket.h>
++# include "openssl/ssl3.h"
++# include "openssl/tls1.h"
++# include "openssl/evp.h"
++
++# ifndef SOL_TLS
++# define SOL_TLS 282
++# endif
++
++# ifndef TCP_ULP
++# define TCP_ULP 31
++# endif
++
++# ifndef TLS_RX
++# define TLS_RX 2
++# endif
++
++/*
++ * When successful, this socket option doesn't change the behaviour of the
++ * TCP socket, except changing the TCP setsockopt handler to enable the
++ * processing of SOL_TLS socket options. All other functionality remains the
++ * same.
++ */
++static ossl_inline int ktls_enable(int fd)
++{
++ return setsockopt(fd, SOL_TCP, TCP_ULP, "tls", sizeof("tls")) ? 0 : 1;
++}
++
++/*
++ * The TLS_TX socket option changes the send/sendmsg handlers of the TCP socket.
++ * If successful, then data sent using this socket will be encrypted and
++ * encapsulated in TLS records using the crypto_info provided here.
++ * The TLS_RX socket option changes the recv/recvmsg handlers of the TCP socket.
++ * If successful, then data received using this socket will be decrypted,
++ * authenticated and decapsulated using the crypto_info provided here.
++ */
++static ossl_inline int ktls_start(int fd,
++ struct tls12_crypto_info_aes_gcm_128
++ *crypto_info, size_t len, int is_tx)
++{
++ return setsockopt(fd, SOL_TLS, is_tx ? TLS_TX : TLS_RX,
++ crypto_info, sizeof(*crypto_info)) ? 0 : 1;
++}
++
++/*
++ * Send a TLS record using the crypto_info provided in ktls_start and use
++ * record_type instead of the default SSL3_RT_APPLICATION_DATA.
++ * When the socket is non-blocking, then this call either returns EAGAIN or
++ * the entire record is pushed to TCP. It is impossible to send a partial
++ * record using this control message.
++ */
++static ossl_inline int ktls_send_ctrl_message(int fd, unsigned char record_type,
++ const void *data, size_t length)
++{
++ struct msghdr msg;
++ int cmsg_len = sizeof(record_type);
++ struct cmsghdr *cmsg;
++ union {
++ struct cmsghdr hdr;
++ char buf[CMSG_SPACE(sizeof(unsigned char))];
++ } cmsgbuf;
++ struct iovec msg_iov; /* Vector of data to send/receive into */
++
++ memset(&msg, 0, sizeof(msg));
++ msg.msg_control = cmsgbuf.buf;
++ msg.msg_controllen = sizeof(cmsgbuf.buf);
++ cmsg = CMSG_FIRSTHDR(&msg);
++ cmsg->cmsg_level = SOL_TLS;
++ cmsg->cmsg_type = TLS_SET_RECORD_TYPE;
++ cmsg->cmsg_len = CMSG_LEN(cmsg_len);
++ *((unsigned char *)CMSG_DATA(cmsg)) = record_type;
++ msg.msg_controllen = cmsg->cmsg_len;
++
++ msg_iov.iov_base = (void *)data;
++ msg_iov.iov_len = length;
++ msg.msg_iov = &msg_iov;
++ msg.msg_iovlen = 1;
++
++ return sendmsg(fd, &msg, 0);
++}
++
++/*
++ * KTLS enables the sendfile system call to send data from a file over TLS.
++ * @flags are ignored on Linux. (placeholder for FreeBSD sendfile)
++ * */
++static ossl_inline ossl_ssize_t ktls_sendfile(int s, int fd, off_t off, size_t size, int flags)
++{
++ return sendfile(s, fd, &off, size);
++}
++
++# define K_MIN1_RX 17
++# if LINUX_VERSION_CODE < KERNEL_VERSION(K_MAJ, K_MIN1_RX, K_MIN2)
++
++# ifndef PEDANTIC
++# warning "KTLS requires Kernel Headers >= 4.17.0 for receiving"
++# warning "Skipping Compilation of KTLS receive data path"
++# endif
++
++static ossl_inline int ktls_read_record(int fd, void *data, size_t length)
++{
++ return -1;
++}
++
++# else
++
++/*
++ * Receive a TLS record using the crypto_info provided in ktls_start.
++ * The kernel strips the TLS record header, IV and authentication tag,
++ * returning only the plaintext data or an error on failure.
++ * We add the TLS record header here to satisfy routines in rec_layer_s3.c
++ */
++static ossl_inline int ktls_read_record(int fd, void *data, size_t length)
++{
++ struct msghdr msg;
++ struct cmsghdr *cmsg;
++ union {
++ struct cmsghdr hdr;
++ char buf[CMSG_SPACE(sizeof(unsigned char))];
++ } cmsgbuf;
++ struct iovec msg_iov;
++ int ret;
++ unsigned char *p = data;
++ const size_t prepend_length = SSL3_RT_HEADER_LENGTH;
++
++ if (length < prepend_length + EVP_GCM_TLS_TAG_LEN) {
++ errno = EINVAL;
++ return -1;
++ }
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-ports-head
mailing list