tls: RX path for ktls

Add rx path for tls software implementation.

recvmsg, splice_read, and poll implemented.

An additional sockopt TLS_RX is added, with the same interface as
TLS_TX.  Either TLX_RX or TLX_TX may be provided separately, or
together (with two different setsockopt calls with appropriate keys).

Control messages are passed via CMSG in a similar way to transmit.
If no cmsg buffer is passed, then only application data records
will be passed to userspace, and EIO is returned for other types of
alerts.

EBADMSG is passed for decryption errors, and EMSGSIZE is passed for
framing too big, and EBADMSG for framing too small (matching openssl
semantics). EINVAL is returned for TLS versions that do not match the
original setsockopt call.  All are unrecoverable.

strparser is used to parse TLS framing.   Decryption is done directly
in to userspace buffers if they are large enough to support it, otherwise
sk_cow_data is called (similar to ipsec), and buffers are decrypted in
place and copied.  splice_read always decrypts in place, since no
buffers are provided to decrypt in to.

sk_poll is overridden, and only returns POLLIN if a full TLS message is
received.  Otherwise we wait for strparser to finish reading a full frame.
Actual decryption is only done during recvmsg or splice_read calls.

Signed-off-by: Dave Watson <davejwatson@fb.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 52 insertions, 10 deletions

diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index c405beeda765..6f5c1146da4a 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -54,12 +54,15 @@ enum {
 enum {
         TLS_BASE,
         TLS_SW_TX,
+        TLS_SW_RX,
+        TLS_SW_RXTX,
         TLS_NUM_CONFIG,
 };
 
 static struct proto *saved_tcpv6_prot;
 static DEFINE_MUTEX(tcpv6_prot_mutex);
 static struct proto tls_prots[TLS_NUM_PROTS][TLS_NUM_CONFIG];
+static struct proto_ops tls_sw_proto_ops;
 
 static inline void update_sk_prot(struct sock *sk, struct tls_context *ctx)
 {
@@ -261,9 +264,14 @@ static void tls_sk_proto_close(struct sock *sk, long timeout)
 
         kfree(ctx->tx.rec_seq);
         kfree(ctx->tx.iv);
+        kfree(ctx->rx.rec_seq);
+        kfree(ctx->rx.iv);
 
-        if (ctx->conf == TLS_SW_TX)
-                tls_sw_free_tx_resources(sk);
+        if (ctx->conf == TLS_SW_TX ||
+            ctx->conf == TLS_SW_RX ||
+            ctx->conf == TLS_SW_RXTX) {
+                tls_sw_free_resources(sk);
+        }
 
 skip_tx_cleanup:
         release_sock(sk);
@@ -365,8 +373,8 @@ static int tls_getsockopt(struct sock *sk, int level, int optname,
         return do_tls_getsockopt(sk, optname, optval, optlen);
 }
 
-static int do_tls_setsockopt_tx(struct sock *sk, char __user *optval,
-                                unsigned int optlen)
+static int do_tls_setsockopt_conf(struct sock *sk, char __user *optval,
+                                  unsigned int optlen, int tx)
 {
         struct tls_crypto_info *crypto_info;
         struct tls_context *ctx = tls_get_ctx(sk);
@@ -378,7 +386,11 @@ static int do_tls_setsockopt_tx(struct sock *sk, char __user *optval,
                 goto out;
         }
 
-        crypto_info = &ctx->crypto_send;
+        if (tx)
+                crypto_info = &ctx->crypto_send;
+        else
+                crypto_info = &ctx->crypto_recv;
+
         /* Currently we don't support set crypto info more than one time */
         if (TLS_CRYPTO_INFO_READY(crypto_info)) {
                 rc = -EBUSY;
@@ -417,15 +429,31 @@ static int do_tls_setsockopt_tx(struct sock *sk, char __user *optval,
         }
 
         /* currently SW is default, we will have ethtool in future */
-        rc = tls_set_sw_offload(sk, ctx);
-        conf = TLS_SW_TX;
+        if (tx) {
+                rc = tls_set_sw_offload(sk, ctx, 1);
+                if (ctx->conf == TLS_SW_RX)
+                        conf = TLS_SW_RXTX;
+                else
+                        conf = TLS_SW_TX;
+        } else {
+                rc = tls_set_sw_offload(sk, ctx, 0);
+                if (ctx->conf == TLS_SW_TX)
+                        conf = TLS_SW_RXTX;
+                else
+                        conf = TLS_SW_RX;
+        }
+
         if (rc)
                 goto err_crypto_info;
 
         ctx->conf = conf;
         update_sk_prot(sk, ctx);
-        ctx->sk_write_space = sk->sk_write_space;
-        sk->sk_write_space = tls_write_space;
+        if (tx) {
+                ctx->sk_write_space = sk->sk_write_space;
+                sk->sk_write_space = tls_write_space;
+        } else {
+                sk->sk_socket->ops = &tls_sw_proto_ops;
+        }
         goto out;
 
 err_crypto_info:
@@ -441,8 +469,10 @@ static int do_tls_setsockopt(struct sock *sk, int optname,
 
         switch (optname) {
         case TLS_TX:
+        case TLS_RX:
                 lock_sock(sk);
-                rc = do_tls_setsockopt_tx(sk, optval, optlen);
+                rc = do_tls_setsockopt_conf(sk, optval, optlen,
+                                            optname == TLS_TX);
                 release_sock(sk);
                 break;
         default:
@@ -473,6 +503,14 @@ static void build_protos(struct proto *prot, struct proto *base)
         prot[TLS_SW_TX] = prot[TLS_BASE];
         prot[TLS_SW_TX].sendmsg         = tls_sw_sendmsg;
         prot[TLS_SW_TX].sendpage        = tls_sw_sendpage;
+
+        prot[TLS_SW_RX] = prot[TLS_BASE];
+        prot[TLS_SW_RX].recvmsg         = tls_sw_recvmsg;
+        prot[TLS_SW_RX].close           = tls_sk_proto_close;
+
+        prot[TLS_SW_RXTX] = prot[TLS_SW_TX];
+        prot[TLS_SW_RXTX].recvmsg       = tls_sw_recvmsg;
+        prot[TLS_SW_RXTX].close         = tls_sk_proto_close;
 }
 
 static int tls_init(struct sock *sk)
@@ -531,6 +569,10 @@ static int __init tls_register(void)
 {
         build_protos(tls_prots[TLSV4], &tcp_prot);
 
+        tls_sw_proto_ops = inet_stream_ops;
+        tls_sw_proto_ops.poll = tls_sw_poll;
+        tls_sw_proto_ops.splice_read = tls_sw_splice_read;
+
         tcp_register_ulp(&tcp_tls_ulp_ops);
 
         return 0;