net: tls: Add tls 1.3 support

TLS 1.3 has minor changes from TLS 1.2 at the record layer.

* Header now hardcodes the same version and application content type in
  the header.
* The real content type is appended after the data, before encryption (or
  after decryption).
* The IV is xored with the sequence number, instead of concatinating four
  bytes of IV with the explicit IV.
* Zero-padding:  No exlicit length is given, we search backwards from the
  end of the decrypted data for the first non-zero byte, which is the
  content type.  Currently recv supports reading zero-padding, but there
  is no way for send to add zero padding.

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

4 files changed, 101 insertions, 26 deletions

diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c
index d753e362d2d9..7ee9008b2187 100644
--- a/net/tls/tls_device.c
+++ b/net/tls/tls_device.c
@@ -257,7 +257,8 @@ static int tls_push_record(struct sock *sk,
         tls_fill_prepend(ctx,
                          skb_frag_address(frag),
                          record->len - ctx->tx.prepend_size,
-                         record_type);
+                         record_type,
+                         ctx->crypto_send.info.version);
 
         /* HW doesn't care about the data in the tag, because it fills it. */
         dummy_tag_frag.page = skb_frag_page(frag);
@@ -270,7 +271,7 @@ static int tls_push_record(struct sock *sk,
         spin_unlock_irq(&offload_ctx->lock);
         offload_ctx->open_record = NULL;
         set_bit(TLS_PENDING_CLOSED_RECORD, &ctx->flags);
-        tls_advance_record_sn(sk, &ctx->tx);
+        tls_advance_record_sn(sk, &ctx->tx, ctx->crypto_send.info.version);
 
         for (i = 0; i < record->num_frags; i++) {
                 frag = &record->frags[i];
diff --git a/net/tls/tls_device_fallback.c b/net/tls/tls_device_fallback.c
index 450a6dbc5a88..54c3a758f2a7 100644
--- a/net/tls/tls_device_fallback.c
+++ b/net/tls/tls_device_fallback.c
@@ -73,7 +73,8 @@ static int tls_enc_record(struct aead_request *aead_req,
         len -= TLS_CIPHER_AES_GCM_128_IV_SIZE;
 
         tls_make_aad(aad, len - TLS_CIPHER_AES_GCM_128_TAG_SIZE,
-                     (char *)&rcd_sn, sizeof(rcd_sn), buf[0]);
+                (char *)&rcd_sn, sizeof(rcd_sn), buf[0],
+                TLS_1_2_VERSION);
 
         memcpy(iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE, buf + TLS_HEADER_SIZE,
                TLS_CIPHER_AES_GCM_128_IV_SIZE);
diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index 0f028cfdf835..d1c2fd9a3f63 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -463,7 +463,8 @@ static int do_tls_setsockopt_conf(struct sock *sk, char __user *optval,
         }
 
         /* check version */
-        if (crypto_info->version != TLS_1_2_VERSION) {
+        if (crypto_info->version != TLS_1_2_VERSION &&
+            crypto_info->version != TLS_1_3_VERSION) {
                 rc = -ENOTSUPP;
                 goto err_crypto_info;
         }
diff --git a/net/tls/tls_sw.c b/net/tls/tls_sw.c
index 34f3523f668e..06d7ae97b929 100644
--- a/net/tls/tls_sw.c
+++ b/net/tls/tls_sw.c
@@ -120,6 +120,34 @@ static int skb_nsg(struct sk_buff *skb, int offset, int len)
         return __skb_nsg(skb, offset, len, 0);
 }
 
+static int padding_length(struct tls_sw_context_rx *ctx,
+                          struct tls_context *tls_ctx, struct sk_buff *skb)
+{
+        struct strp_msg *rxm = strp_msg(skb);
+        int sub = 0;
+
+        /* Determine zero-padding length */
+        if (tls_ctx->crypto_recv.info.version == TLS_1_3_VERSION) {
+                char content_type = 0;
+                int err;
+                int back = 17;
+
+                while (content_type == 0) {
+                        if (back > rxm->full_len)
+                                return -EBADMSG;
+                        err = skb_copy_bits(skb,
+                                            rxm->offset + rxm->full_len - back,
+                                            &content_type, 1);
+                        if (content_type)
+                                break;
+                        sub++;
+                        back++;
+                }
+                ctx->control = content_type;
+        }
+        return sub;
+}
+
 static void tls_decrypt_done(struct crypto_async_request *req, int err)
 {
         struct aead_request *aead_req = (struct aead_request *)req;
@@ -142,7 +170,7 @@ static void tls_decrypt_done(struct crypto_async_request *req, int err)
                 tls_err_abort(skb->sk, err);
         } else {
                 struct strp_msg *rxm = strp_msg(skb);
-
+                rxm->full_len -= padding_length(ctx, tls_ctx, skb);
                 rxm->offset += tls_ctx->rx.prepend_size;
                 rxm->full_len -= tls_ctx->rx.overhead_size;
         }
@@ -448,6 +476,8 @@ static int tls_do_encryption(struct sock *sk,
         int rc;
 
         memcpy(rec->iv_data, tls_ctx->tx.iv, sizeof(rec->iv_data));
+        xor_iv_with_seq(tls_ctx->crypto_send.info.version, rec->iv_data,
+                        tls_ctx->tx.rec_seq);
 
         sge->offset += tls_ctx->tx.prepend_size;
         sge->length -= tls_ctx->tx.prepend_size;
@@ -483,7 +513,8 @@ static int tls_do_encryption(struct sock *sk,
 
         /* Unhook the record from context if encryption is not failure */
         ctx->open_rec = NULL;
-        tls_advance_record_sn(sk, &tls_ctx->tx);
+        tls_advance_record_sn(sk, &tls_ctx->tx,
+                              tls_ctx->crypto_send.info.version);
         return rc;
 }
 
@@ -640,7 +671,17 @@ static int tls_push_record(struct sock *sk, int flags,
 
         i = msg_pl->sg.end;
         sk_msg_iter_var_prev(i);
-        sg_mark_end(sk_msg_elem(msg_pl, i));
+
+        rec->content_type = record_type;
+        if (tls_ctx->crypto_send.info.version == TLS_1_3_VERSION) {
+                /* Add content type to end of message.  No padding added */
+                sg_set_buf(&rec->sg_content_type, &rec->content_type, 1);
+                sg_mark_end(&rec->sg_content_type);
+                sg_chain(msg_pl->sg.data, msg_pl->sg.end + 1,
+                         &rec->sg_content_type);
+        } else {
+                sg_mark_end(sk_msg_elem(msg_pl, i));
+        }
 
         i = msg_pl->sg.start;
         sg_chain(rec->sg_aead_in, 2, rec->inplace_crypto ?
@@ -653,18 +694,22 @@ static int tls_push_record(struct sock *sk, int flags,
         i = msg_en->sg.start;
         sg_chain(rec->sg_aead_out, 2, &msg_en->sg.data[i]);
 
-        tls_make_aad(rec->aad_space, msg_pl->sg.size,
+        tls_make_aad(rec->aad_space, msg_pl->sg.size + tls_ctx->tx.tail_size,
                      tls_ctx->tx.rec_seq, tls_ctx->tx.rec_seq_size,
-                     record_type);
+                     record_type,
+                     tls_ctx->crypto_send.info.version);
 
         tls_fill_prepend(tls_ctx,
                          page_address(sg_page(&msg_en->sg.data[i])) +
-                         msg_en->sg.data[i].offset, msg_pl->sg.size,
-                         record_type);
+                         msg_en->sg.data[i].offset,
+                         msg_pl->sg.size + tls_ctx->tx.tail_size,
+                         record_type,
+                         tls_ctx->crypto_send.info.version);
 
         tls_ctx->pending_open_record_frags = false;
 
-        rc = tls_do_encryption(sk, tls_ctx, ctx, req, msg_pl->sg.size, i);
+        rc = tls_do_encryption(sk, tls_ctx, ctx, req,
+                               msg_pl->sg.size + tls_ctx->tx.tail_size, i);
         if (rc < 0) {
                 if (rc != -EINPROGRESS) {
                         tls_err_abort(sk, EBADMSG);
@@ -1292,7 +1337,8 @@ static int decrypt_internal(struct sock *sk, struct sk_buff *skb,
         u8 *aad, *iv, *mem = NULL;
         struct scatterlist *sgin = NULL;
         struct scatterlist *sgout = NULL;
-        const int data_len = rxm->full_len - tls_ctx->rx.overhead_size;
+        const int data_len = rxm->full_len - tls_ctx->rx.overhead_size +
+                tls_ctx->rx.tail_size;
 
         if (*zc && (out_iov || out_sg)) {
                 if (out_iov)
@@ -1343,12 +1389,20 @@ static int decrypt_internal(struct sock *sk, struct sk_buff *skb,
                 kfree(mem);
                 return err;
         }
-        memcpy(iv, tls_ctx->rx.iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE);
+        if (tls_ctx->crypto_recv.info.version == TLS_1_3_VERSION)
+                memcpy(iv, tls_ctx->rx.iv, crypto_aead_ivsize(ctx->aead_recv));
+        else
+                memcpy(iv, tls_ctx->rx.iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE);
+
+        xor_iv_with_seq(tls_ctx->crypto_recv.info.version, iv,
+                        tls_ctx->rx.rec_seq);
 
         /* Prepare AAD */
-        tls_make_aad(aad, rxm->full_len - tls_ctx->rx.overhead_size,
+        tls_make_aad(aad, rxm->full_len - tls_ctx->rx.overhead_size +
+                     tls_ctx->rx.tail_size,
                      tls_ctx->rx.rec_seq, tls_ctx->rx.rec_seq_size,
-                     ctx->control);
+                     ctx->control,
+                     tls_ctx->crypto_recv.info.version);
 
         /* Prepare sgin */
         sg_init_table(sgin, n_sgin);
@@ -1405,6 +1459,7 @@ static int decrypt_skb_update(struct sock *sk, struct sk_buff *skb,
 {
         struct tls_context *tls_ctx = tls_get_ctx(sk);
         struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
+        int version = tls_ctx->crypto_recv.info.version;
         struct strp_msg *rxm = strp_msg(skb);
         int err = 0;
 
@@ -1417,13 +1472,17 @@ static int decrypt_skb_update(struct sock *sk, struct sk_buff *skb,
                 err = decrypt_internal(sk, skb, dest, NULL, chunk, zc, async);
                 if (err < 0) {
                         if (err == -EINPROGRESS)
-                                tls_advance_record_sn(sk, &tls_ctx->rx);
+                                tls_advance_record_sn(sk, &tls_ctx->rx,
+                                                      version);
 
                         return err;
                 }
+
+                rxm->full_len -= padding_length(ctx, tls_ctx, skb);
+
                 rxm->offset += tls_ctx->rx.prepend_size;
                 rxm->full_len -= tls_ctx->rx.overhead_size;
-                tls_advance_record_sn(sk, &tls_ctx->rx);
+                tls_advance_record_sn(sk, &tls_ctx->rx, version);
                 ctx->decrypted = true;
                 ctx->saved_data_ready(sk);
         } else {
@@ -1611,7 +1670,8 @@ int tls_sw_recvmsg(struct sock *sk,
                 to_decrypt = rxm->full_len - tls_ctx->rx.overhead_size;
 
                 if (to_decrypt <= len && !is_kvec && !is_peek &&
-                    ctx->control == TLS_RECORD_TYPE_DATA)
+                    ctx->control == TLS_RECORD_TYPE_DATA &&
+                    tls_ctx->crypto_recv.info.version != TLS_1_3_VERSION)
                         zc = true;
 
                 err = decrypt_skb_update(sk, skb, &msg->msg_iter,
@@ -1835,9 +1895,12 @@ static int tls_read_size(struct strparser *strp, struct sk_buff *skb)
 
         data_len = ((header[4] & 0xFF) | (header[3] << 8));
 
-        cipher_overhead = tls_ctx->rx.tag_size + tls_ctx->rx.iv_size;
+        cipher_overhead = tls_ctx->rx.tag_size;
+        if (tls_ctx->crypto_recv.info.version != TLS_1_3_VERSION)
+                cipher_overhead += tls_ctx->rx.iv_size;
 
-        if (data_len > TLS_MAX_PAYLOAD_SIZE + cipher_overhead) {
+        if (data_len > TLS_MAX_PAYLOAD_SIZE + cipher_overhead +
+            tls_ctx->rx.tail_size) {
                 ret = -EMSGSIZE;
                 goto read_failure;
         }
@@ -1846,12 +1909,12 @@ static int tls_read_size(struct strparser *strp, struct sk_buff *skb)
                 goto read_failure;
         }
 
-        if (header[1] != TLS_VERSION_MINOR(tls_ctx->crypto_recv.info.version) ||
-            header[2] != TLS_VERSION_MAJOR(tls_ctx->crypto_recv.info.version)) {
+        /* Note that both TLS1.3 and TLS1.2 use TLS_1_2 version here */
+        if (header[1] != TLS_1_2_VERSION_MINOR ||
+            header[2] != TLS_1_2_VERSION_MAJOR) {
                 ret = -EINVAL;
                 goto read_failure;
         }
-
 #ifdef CONFIG_TLS_DEVICE
         handle_device_resync(strp->sk, TCP_SKB_CB(skb)->seq + rxm->offset,
                              *(u64*)tls_ctx->rx.rec_seq);
@@ -2100,10 +2163,19 @@ int tls_set_sw_offload(struct sock *sk, struct tls_context *ctx, int tx)
                 goto free_priv;
         }
 
-        cctx->aad_size = TLS_AAD_SPACE_SIZE;
+        if (crypto_info->version == TLS_1_3_VERSION) {
+                nonce_size = 0;
+                cctx->aad_size = TLS_HEADER_SIZE;
+                cctx->tail_size = 1;
+        } else {
+                cctx->aad_size = TLS_AAD_SPACE_SIZE;
+                cctx->tail_size = 0;
+        }
+
         cctx->prepend_size = TLS_HEADER_SIZE + nonce_size;
         cctx->tag_size = tag_size;
-        cctx->overhead_size = cctx->prepend_size + cctx->tag_size;
+        cctx->overhead_size = cctx->prepend_size + cctx->tag_size +
+                cctx->tail_size;
         cctx->iv_size = iv_size;
         cctx->iv = kmalloc(iv_size + TLS_CIPHER_AES_GCM_128_SALT_SIZE,
                            GFP_KERNEL);