releases/4.14.69/crypto-vmx-fix-sleep-in-atomic-bugs.patch

   1 From 0522236d4f9c5ab2e79889cb020d1acbe5da416e Mon Sep 17 00:00:00 2001
   2 From: Ondrej Mosnacek <omosnace@redhat.com>
   3 Date: Wed, 22 Aug 2018 08:26:31 +0200
   4 Subject: crypto: vmx - Fix sleep-in-atomic bugs
   5
   6 From: Ondrej Mosnacek <omosnace@redhat.com>
   7
   8 commit 0522236d4f9c5ab2e79889cb020d1acbe5da416e upstream.
   9
  10 This patch fixes sleep-in-atomic bugs in AES-CBC and AES-XTS VMX
  11 implementations. The problem is that the blkcipher_* functions should
  12 not be called in atomic context.
  13
  14 The bugs can be reproduced via the AF_ALG interface by trying to
  15 encrypt/decrypt sufficiently large buffers (at least 64 KiB) using the
  16 VMX implementations of 'cbc(aes)' or 'xts(aes)'. Such operations then
  17 trigger BUG in crypto_yield():
  18
  19 [  891.863680] BUG: sleeping function called from invalid context at include/crypto/algapi.h:424
  20 [  891.864622] in_atomic(): 1, irqs_disabled(): 0, pid: 12347, name: kcapi-enc
  21 [  891.864739] 1 lock held by kcapi-enc/12347:
  22 [  891.864811]  #0: 00000000f5d42c46 (sk_lock-AF_ALG){+.+.}, at: skcipher_recvmsg+0x50/0x530
  23 [  891.865076] CPU: 5 PID: 12347 Comm: kcapi-enc Not tainted 4.19.0-0.rc0.git3.1.fc30.ppc64le #1
  24 [  891.865251] Call Trace:
  25 [  891.865340] [c0000003387578c0] [c000000000d67ea4] dump_stack+0xe8/0x164 (unreliable)
  26 [  891.865511] [c000000338757910] [c000000000172a58] ___might_sleep+0x2f8/0x310
  27 [  891.865679] [c000000338757990] [c0000000006bff74] blkcipher_walk_done+0x374/0x4a0
  28 [  891.865825] [c0000003387579e0] [d000000007e73e70] p8_aes_cbc_encrypt+0x1c8/0x260 [vmx_crypto]
  29 [  891.865993] [c000000338757ad0] [c0000000006c0ee0] skcipher_encrypt_blkcipher+0x60/0x80
  30 [  891.866128] [c000000338757b10] [c0000000006ec504] skcipher_recvmsg+0x424/0x530
  31 [  891.866283] [c000000338757bd0] [c000000000b00654] sock_recvmsg+0x74/0xa0
  32 [  891.866403] [c000000338757c10] [c000000000b00f64] ___sys_recvmsg+0xf4/0x2f0
  33 [  891.866515] [c000000338757d90] [c000000000b02bb8] __sys_recvmsg+0x68/0xe0
  34 [  891.866631] [c000000338757e30] [c00000000000bbe4] system_call+0x5c/0x70
  35
  36 Fixes: 8c755ace357c ("crypto: vmx - Adding CBC routines for VMX module")
  37 Fixes: c07f5d3da643 ("crypto: vmx - Adding support for XTS")
  38 Cc: stable@vger.kernel.org
  39 Signed-off-by: Ondrej Mosnacek <omosnace@redhat.com>
  40 Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
  41 Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  42
  43 ---
  44  drivers/crypto/vmx/aes_cbc.c |   30 ++++++++++++++----------------
  45  drivers/crypto/vmx/aes_xts.c |   21 ++++++++++++++-------
  46  2 files changed, 28 insertions(+), 23 deletions(-)
  47
  48 --- a/drivers/crypto/vmx/aes_cbc.c
  49 +++ b/drivers/crypto/vmx/aes_cbc.c
  50 @@ -107,24 +107,23 @@ static int p8_aes_cbc_encrypt(struct blk
  51                 ret = crypto_skcipher_encrypt(req);
  52                 skcipher_request_zero(req);
  53         } else {
  54 -               preempt_disable();
  55 -               pagefault_disable();
  56 -               enable_kernel_vsx();
  57 -
  58                 blkcipher_walk_init(&walk, dst, src, nbytes);
  59                 ret = blkcipher_walk_virt(desc, &walk);
  60                 while ((nbytes = walk.nbytes)) {
  61 +                       preempt_disable();
  62 +                       pagefault_disable();
  63 +                       enable_kernel_vsx();
  64                         aes_p8_cbc_encrypt(walk.src.virt.addr,
  65                                            walk.dst.virt.addr,
  66                                            nbytes & AES_BLOCK_MASK,
  67                                            &ctx->enc_key, walk.iv, 1);
  68 +                       disable_kernel_vsx();
  69 +                       pagefault_enable();
  70 +                       preempt_enable();
  71 +
  72                         nbytes &= AES_BLOCK_SIZE - 1;
  73                         ret = blkcipher_walk_done(desc, &walk, nbytes);
  74                 }
  75 -
  76 -               disable_kernel_vsx();
  77 -               pagefault_enable();
  78 -               preempt_enable();
  79         }
  80
  81         return ret;
  82 @@ -147,24 +146,23 @@ static int p8_aes_cbc_decrypt(struct blk
  83                 ret = crypto_skcipher_decrypt(req);
  84                 skcipher_request_zero(req);
  85         } else {
  86 -               preempt_disable();
  87 -               pagefault_disable();
  88 -               enable_kernel_vsx();
  89 -
  90                 blkcipher_walk_init(&walk, dst, src, nbytes);
  91                 ret = blkcipher_walk_virt(desc, &walk);
  92                 while ((nbytes = walk.nbytes)) {
  93 +                       preempt_disable();
  94 +                       pagefault_disable();
  95 +                       enable_kernel_vsx();
  96                         aes_p8_cbc_encrypt(walk.src.virt.addr,
  97                                            walk.dst.virt.addr,
  98                                            nbytes & AES_BLOCK_MASK,
  99                                            &ctx->dec_key, walk.iv, 0);
 100 +                       disable_kernel_vsx();
 101 +                       pagefault_enable();
 102 +                       preempt_enable();
 103 +
 104                         nbytes &= AES_BLOCK_SIZE - 1;
 105                         ret = blkcipher_walk_done(desc, &walk, nbytes);
 106                 }
 107 -
 108 -               disable_kernel_vsx();
 109 -               pagefault_enable();
 110 -               preempt_enable();
 111         }
 112
 113         return ret;
 114 --- a/drivers/crypto/vmx/aes_xts.c
 115 +++ b/drivers/crypto/vmx/aes_xts.c
 116 @@ -116,32 +116,39 @@ static int p8_aes_xts_crypt(struct blkci
 117                 ret = enc? crypto_skcipher_encrypt(req) : crypto_skcipher_decrypt(req);
 118                 skcipher_request_zero(req);
 119         } else {
 120 +               blkcipher_walk_init(&walk, dst, src, nbytes);
 121 +
 122 +               ret = blkcipher_walk_virt(desc, &walk);
 123 +
 124                 preempt_disable();
 125                 pagefault_disable();
 126                 enable_kernel_vsx();
 127
 128 -               blkcipher_walk_init(&walk, dst, src, nbytes);
 129 -
 130 -               ret = blkcipher_walk_virt(desc, &walk);
 131                 iv = walk.iv;
 132                 memset(tweak, 0, AES_BLOCK_SIZE);
 133                 aes_p8_encrypt(iv, tweak, &ctx->tweak_key);
 134
 135 +               disable_kernel_vsx();
 136 +               pagefault_enable();
 137 +               preempt_enable();
 138 +
 139                 while ((nbytes = walk.nbytes)) {
 140 +                       preempt_disable();
 141 +                       pagefault_disable();
 142 +                       enable_kernel_vsx();
 143                         if (enc)
 144                                 aes_p8_xts_encrypt(walk.src.virt.addr, walk.dst.virt.addr,
 145                                                 nbytes & AES_BLOCK_MASK, &ctx->enc_key, NULL, tweak);
 146                         else
 147                                 aes_p8_xts_decrypt(walk.src.virt.addr, walk.dst.virt.addr,
 148                                                 nbytes & AES_BLOCK_MASK, &ctx->dec_key, NULL, tweak);
 149 +                       disable_kernel_vsx();
 150 +                       pagefault_enable();
 151 +                       preempt_enable();
 152
 153                         nbytes &= AES_BLOCK_SIZE - 1;
 154                         ret = blkcipher_walk_done(desc, &walk, nbytes);
 155                 }
 156 -
 157 -               disable_kernel_vsx();
 158 -               pagefault_enable();
 159 -               preempt_enable();
 160         }
 161         return ret;
 162  }