[newlib-cygwin] Add kernel-side support for in-kernel TLS.

[newlib-cygwin] Add kernel-side support for in-kernel TLS.

[Sebastian Huber]

https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;h=1b356361196fe3095717c91b669976bb91e998ec

commit 1b356361196fe3095717c91b669976bb91e998ec
Author: jhb <jhb@FreeBSD.org>
Date:   Tue Aug 27 00:01:56 2019 +0000

    Add kernel-side support for in-kernel TLS.
    
    KTLS adds support for in-kernel framing and encryption of Transport
    Layer Security (1.0-1.2) data on TCP sockets.  KTLS only supports
    offload of TLS for transmitted data.  Key negotation must still be
    performed in userland.  Once completed, transmit session keys for a
    connection are provided to the kernel via a new TCP_TXTLS_ENABLE
    socket option.  All subsequent data transmitted on the socket is
    placed into TLS frames and encrypted using the supplied keys.
    
    Any data written to a KTLS-enabled socket via write(2), aio_write(2),
    or sendfile(2) is assumed to be application data and is encoded in TLS
    frames with an application data type.  Individual records can be sent
    with a custom type (e.g. handshake messages) via sendmsg(2) with a new
    control message (TLS_SET_RECORD_TYPE) specifying the record type.
    
    At present, rekeying is not supported though the in-kernel framework
    should support rekeying.
    
    KTLS makes use of the recently added unmapped mbufs to store TLS
    frames in the socket buffer.  Each TLS frame is described by a single
    ext_pgs mbuf.  The ext_pgs structure contains the header of the TLS
    record (and trailer for encrypted records) as well as references to
    the associated TLS session.
    
    KTLS supports two primary methods of encrypting TLS frames: software
    TLS and ifnet TLS.
    
    Software TLS marks mbufs holding socket data as not ready via
    M_NOTREADY similar to sendfile(2) when TLS framing information is
    added to an unmapped mbuf in ktls_frame().  ktls_enqueue() is then
    called to schedule TLS frames for encryption.  In the case of
    sendfile_iodone() calls ktls_enqueue() instead of pru_ready() leaving
    the mbufs marked M_NOTREADY until encryption is completed.  For other
    writes (vn_sendfile when pages are available, write(2), etc.), the
    PRUS_NOTREADY is set when invoking pru_send() along with invoking
    ktls_enqueue().
    
    A pool of worker threads (the "KTLS" kernel process) encrypts TLS
    frames queued via ktls_enqueue().  Each TLS frame is temporarily
    mapped using the direct map and passed to a software encryption
    backend to perform the actual encryption.
    
    (Note: The use of PHYS_TO_DMAP could be replaced with sf_bufs if
    someone wished to make this work on architectures without a direct
    map.)
    
    KTLS supports pluggable software encryption backends.  Internally,
    Netflix uses proprietary pure-software backends.  This commit includes
    a simple backend in a new ktls_ocf.ko module that uses the kernel's
    OpenCrypto framework to provide AES-GCM encryption of TLS frames.  As
    a result, software TLS is now a bit of a misnomer as it can make use
    of hardware crypto accelerators.
    
    Once software encryption has finished, the TLS frame mbufs are marked
    ready via pru_ready().  At this point, the encrypted data appears as
    regular payload to the TCP stack stored in unmapped mbufs.
    
    ifnet TLS permits a NIC to offload the TLS encryption and TCP
    segmentation.  In this mode, a new send tag type (IF_SND_TAG_TYPE_TLS)
    is allocated on the interface a socket is routed over and associated
    with a TLS session.  TLS records for a TLS session using ifnet TLS are
    not marked M_NOTREADY but are passed down the stack unencrypted.  The
    ip_output_send() and ip6_output_send() helper functions that apply
    send tags to outbound IP packets verify that the send tag of the TLS
    record matches the outbound interface.  If so, the packet is tagged
    with the TLS send tag and sent to the interface.  The NIC device
    driver must recognize packets with the TLS send tag and schedule them
    for TLS encryption and TCP segmentation.  If the the outbound
    interface does not match the interface in the TLS send tag, the packet
    is dropped.  In addition, a task is scheduled to refresh the TLS send
    tag for the TLS session.  If a new TLS send tag cannot be allocated,
    the connection is dropped.  If a new TLS send tag is allocated,
    however, subsequent packets will be tagged with the correct TLS send
    tag.  (This latter case has been tested by configuring both ports of a
    Chelsio T6 in a lagg and failing over from one port to another.  As
    the connections migrated to the new port, new TLS send tags were
    allocated for the new port and connections resumed without being
    dropped.)
    
    ifnet TLS can be enabled and disabled on supported network interfaces
    via new '[-]txtls[46]' options to ifconfig(8).  ifnet TLS is supported
    across both vlan devices and lagg interfaces using failover, lacp with
    flowid enabled, or lacp with flowid enabled.
    
    Applications may request the current KTLS mode of a connection via a
    new TCP_TXTLS_MODE socket option.  They can also use this socket
    option to toggle between software and ifnet TLS modes.
    
    In addition, a testing tool is available in tools/tools/switch_tls.
    This is modeled on tcpdrop and uses similar syntax.  However, instead
    of dropping connections, -s is used to force KTLS connections to
    switch to software TLS and -i is used to switch to ifnet TLS.
    
    Various sysctls and counters are available under the kern.ipc.tls
    sysctl node.  The kern.ipc.tls.enable node must be set to true to
    enable KTLS (it is off by default).  The use of unmapped mbufs must
    also be enabled via kern.ipc.mb_use_ext_pgs to enable KTLS.
    
    KTLS is enabled via the KERN_TLS kernel option.
    
    This patch is the culmination of years of work by several folks
    including Scott Long and Randall Stewart for the original design and
    implementation; Drew Gallatin for several optimizations including the
    use of ext_pgs mbufs, the M_NOTREADY mechanism for TLS records
    awaiting software encryption, and pluggable software crypto backends;
    and John Baldwin for modifications to support hardware TLS offload.
    
    Reviewed by:	gallatin, hselasky, rrs
    Obtained from:	Netflix
    Sponsored by:	Netflix, Chelsio Communications
    Differential Revision:	https://reviews.freebsd.org/D21277

Diff:
---
 newlib/libc/sys/rtems/include/net/if.h      |  3 +++
 newlib/libc/sys/rtems/include/netinet/tcp.h | 14 +++++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/newlib/libc/sys/rtems/include/net/if.h b/newlib/libc/sys/rtems/include/net/if.h
index a60374d..a5539bd 100644
--- a/newlib/libc/sys/rtems/include/net/if.h
+++ b/newlib/libc/sys/rtems/include/net/if.h
@@ -247,6 +247,8 @@ struct if_data {
 #define	IFCAP_TXRTLMT		0x1000000 /* hardware supports TX rate limiting */
 #define	IFCAP_HWRXTSTMP		0x2000000 /* hardware rx timestamping */
 #define	IFCAP_NOMAP		0x4000000 /* can TX unmapped mbufs */
+#define	IFCAP_TXTLS4		0x8000000 /* can do TLS encryption and segmentation for TCP */
+#define	IFCAP_TXTLS6		0x10000000 /* can do TLS encryption and segmentation for TCP6 */
 
 #define IFCAP_HWCSUM_IPV6	(IFCAP_RXCSUM_IPV6 | IFCAP_TXCSUM_IPV6)
 
@@ -254,6 +256,7 @@ struct if_data {
 #define	IFCAP_TSO	(IFCAP_TSO4 | IFCAP_TSO6)
 #define	IFCAP_WOL	(IFCAP_WOL_UCAST | IFCAP_WOL_MCAST | IFCAP_WOL_MAGIC)
 #define	IFCAP_TOE	(IFCAP_TOE4 | IFCAP_TOE6)
+#define	IFCAP_TXTLS	(IFCAP_TXTLS4 | IFCAP_TXTLS6)
 
 #define	IFCAP_CANTCHANGE	(IFCAP_NETMAP)
 
diff --git a/newlib/libc/sys/rtems/include/netinet/tcp.h b/newlib/libc/sys/rtems/include/netinet/tcp.h
index 37cf35c..bce1d59 100644
--- a/newlib/libc/sys/rtems/include/netinet/tcp.h
+++ b/newlib/libc/sys/rtems/include/netinet/tcp.h
@@ -29,7 +29,7 @@
  * SUCH DAMAGE.
  *
  *	@(#)tcp.h	8.1 (Berkeley) 6/10/93
- * $FreeBSD: head/sys/netinet/tcp.h 334804 2018-06-07 18:18:13Z rrs $
+ * $FreeBSD: head/sys/netinet/tcp.h 351522 2019-08-27 00:01:56Z jhb $
  */
 
 #ifndef _NETINET_TCP_H_
@@ -174,6 +174,8 @@ struct tcphdr {
 #define	TCP_LOGDUMP	37	/* dump connection log events to device */
 #define	TCP_LOGDUMPID	38	/* dump events from connections with same ID to
 				   device */
+#define	TCP_TXTLS_ENABLE 39	/* TLS framing and encryption for transmit */
+#define	TCP_TXTLS_MODE	40	/* Transmit TLS mode */
 #define	TCP_CONGESTION	64	/* get/set congestion control algorithm */
 #define	TCP_CCALGOOPT	65	/* get/set cc algorithm specific options */
 #define TCP_DELACK  	72	/* socket option for delayed ack */
@@ -350,4 +352,14 @@ struct tcp_function_set {
 	uint32_t pcbcnt;
 };
 
+/* TLS modes for TCP_TXTLS_MODE */
+#define	TCP_TLS_MODE_NONE	0
+#define	TCP_TLS_MODE_SW		1
+#define	TCP_TLS_MODE_IFNET	2
+
+/*
+ * TCP Control message types
+ */
+#define	TLS_SET_RECORD_TYPE	1
+
 #endif /* !_NETINET_TCP_H_ */