main.c

   1 /*
   2  * Driver for /dev/crypto device (aka CryptoDev)
   3  *
   4  * Copyright (c) 2004 Michal Ludvig <mludvig@logix.net.nz>, SuSE Labs
   5  * Copyright (c) 2009,2010 Nikos Mavrogiannopoulos <nmav@gnutls.org>
   6  *
   7  * This file is part of linux cryptodev.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23  */
  24
  25 /*
  26  * Device /dev/crypto provides an interface for
  27  * accessing kernel CryptoAPI algorithms (ciphers,
  28  * hashes) from userspace programs.
  29  *
  30  * /dev/crypto interface was originally introduced in
  31  * OpenBSD and this module attempts to keep the API.
  32  *
  33  */
  34 #include <crypto/hash.h>
  35 #include <linux/crypto.h>
  36 #include <linux/mm.h>
  37 #include <linux/highmem.h>
  38 #include <linux/ioctl.h>
  39 #include <linux/random.h>
  40 #include <linux/syscalls.h>
  41 #include <linux/pagemap.h>
  42 #include <linux/poll.h>
  43 #include <linux/uaccess.h>
  44 #include <crypto/cryptodev.h>
  45 #include <crypto/scatterwalk.h>
  46 #include <linux/scatterlist.h>
  47 #include "cryptodev_int.h"
  48 #include "zc.h"
  49 #include "cryptlib.h"
  50 #include "version.h"
  51
  52 /* This file contains the traditional operations of encryption
  53  * and hashing of /dev/crypto.
  54  */
  55
  56 static int
  57 hash_n_crypt(struct csession *ses_ptr, struct crypt_op *cop,
  58                 struct scatterlist *src_sg, struct scatterlist *dst_sg,
  59                 uint32_t len)
  60 {
  61         int ret;
  62
  63         /* Always hash before encryption and after decryption. Maybe
  64          * we should introduce a flag to switch... TBD later on.
  65          */
  66         if (cop->op == COP_ENCRYPT) {
  67                 if (ses_ptr->hdata.init != 0) {
  68                         ret = cryptodev_hash_update(&ses_ptr->hdata,
  69                                                         src_sg, len);
  70                         if (unlikely(ret))
  71                                 goto out_err;
  72                 }
  73                 if (ses_ptr->cdata.init != 0) {
  74                         ret = cryptodev_cipher_encrypt(&ses_ptr->cdata,
  75                                                         src_sg, dst_sg, len);
  76
  77                         if (unlikely(ret))
  78                                 goto out_err;
  79                 }
  80         } else {
  81                 if (ses_ptr->cdata.init != 0) {
  82                         ret = cryptodev_cipher_decrypt(&ses_ptr->cdata,
  83                                                         src_sg, dst_sg, len);
  84
  85                         if (unlikely(ret))
  86                                 goto out_err;
  87                 }
  88
  89                 if (ses_ptr->hdata.init != 0) {
  90                         ret = cryptodev_hash_update(&ses_ptr->hdata,
  91                                                                 dst_sg, len);
  92                         if (unlikely(ret))
  93                                 goto out_err;
  94                 }
  95         }
  96         return 0;
  97 out_err:
  98         dprintk(0, KERN_ERR, "CryptoAPI failure: %d\n", ret);
  99         return ret;
 100 }
 101
 102 /* This is the main crypto function - feed it with plaintext
 103    and get a ciphertext (or vice versa :-) */
 104 static int
 105 __crypto_run_std(struct csession *ses_ptr, struct crypt_op *cop)
 106 {
 107         char *data;
 108         char __user *src, *dst;
 109         struct scatterlist sg;
 110         size_t nbytes, bufsize;
 111         int ret = 0;
 112
 113         nbytes = cop->len;
 114         data = (char *)__get_free_page(GFP_KERNEL);
 115
 116         if (unlikely(!data))
 117                 return -ENOMEM;
 118
 119         bufsize = PAGE_SIZE < nbytes ? PAGE_SIZE : nbytes;
 120
 121         src = cop->src;
 122         dst = cop->dst;
 123
 124         while (nbytes > 0) {
 125                 size_t current_len = nbytes > bufsize ? bufsize : nbytes;
 126
 127                 if (unlikely(copy_from_user(data, src, current_len))) {
 128                         ret = -EFAULT;
 129                         break;
 130                 }
 131
 132                 sg_init_one(&sg, data, current_len);
 133
 134                 ret = hash_n_crypt(ses_ptr, cop, &sg, &sg, current_len);
 135
 136                 if (unlikely(ret))
 137                         break;
 138
 139                 if (ses_ptr->cdata.init != 0) {
 140                         if (unlikely(copy_to_user(dst, data, current_len))) {
 141                                 ret = -EFAULT;
 142                                 break;
 143                         }
 144                 }
 145
 146                 dst += current_len;
 147                 nbytes -= current_len;
 148                 src += current_len;
 149         }
 150
 151         free_page((unsigned long)data);
 152         return ret;
 153 }
 154
 155
 156
 157 /* This is the main crypto function - zero-copy edition */
 158 static int
 159 __crypto_run_zc(struct csession *ses_ptr, struct kernel_crypt_op *kcop)
 160 {
 161         struct scatterlist *src_sg, *dst_sg;
 162         struct crypt_op *cop = &kcop->cop;
 163         int ret = 0, pagecount;
 164
 165         ret = get_userbuf(ses_ptr, cop->src, cop->len, cop->dst, cop->len,
 166                           kcop->task, kcop->mm, &src_sg, &dst_sg, &pagecount);
 167         if (unlikely(ret)) {
 168                 dprintk(1, KERN_ERR, "Error getting user pages. "
 169                                         "Falling back to non zero copy.\n");
 170                 return __crypto_run_std(ses_ptr, cop);
 171         }
 172
 173         ret = hash_n_crypt(ses_ptr, cop, src_sg, dst_sg, cop->len);
 174
 175         release_user_pages(ses_ptr->pages, pagecount);
 176         return ret;
 177 }
 178
 179 int crypto_run(struct fcrypt *fcr, struct kernel_crypt_op *kcop)
 180 {
 181         struct csession *ses_ptr;
 182         struct crypt_op *cop = &kcop->cop;
 183         int ret;
 184
 185         if (unlikely(cop->op != COP_ENCRYPT && cop->op != COP_DECRYPT)) {
 186                 dprintk(1, KERN_DEBUG, "invalid operation op=%u\n", cop->op);
 187                 return -EINVAL;
 188         }
 189
 190         /* this also enters ses_ptr->sem */
 191         ses_ptr = crypto_get_session_by_sid(fcr, cop->ses);
 192         if (unlikely(!ses_ptr)) {
 193                 dprintk(1, KERN_ERR, "invalid session ID=0x%08X\n", cop->ses);
 194                 return -EINVAL;
 195         }
 196
 197         if (ses_ptr->hdata.init != 0 && !(cop->flags & (COP_FLAG_UPDATE | COP_FLAG_FINAL))) {
 198                 ret = cryptodev_hash_reset(&ses_ptr->hdata);
 199                 if (unlikely(ret)) {
 200                         dprintk(1, KERN_ERR,
 201                                 "error in cryptodev_hash_reset()\n");
 202                         goto out_unlock;
 203                 }
 204         }
 205
 206         if (ses_ptr->cdata.init != 0) {
 207                 int blocksize = ses_ptr->cdata.blocksize;
 208
 209                 if (unlikely(cop->len % blocksize)) {
 210                         dprintk(1, KERN_ERR,
 211                                 "data size (%u) isn't a multiple "
 212                                 "of block size (%u)\n",
 213                                 cop->len, blocksize);
 214                         ret = -EINVAL;
 215                         goto out_unlock;
 216                 }
 217
 218                 cryptodev_cipher_set_iv(&ses_ptr->cdata, kcop->iv,
 219                                 min(ses_ptr->cdata.ivsize, kcop->ivlen));
 220         }
 221
 222         if (likely(cop->len)) {
 223                 if (cop->flags & COP_FLAG_NO_ZC)
 224                         ret = __crypto_run_std(ses_ptr, &kcop->cop);
 225                 else
 226                         ret = __crypto_run_zc(ses_ptr, kcop);
 227                 if (unlikely(ret))
 228                         goto out_unlock;
 229         }
 230
 231         if (ses_ptr->cdata.init != 0) {
 232                 cryptodev_cipher_get_iv(&ses_ptr->cdata, kcop->iv,
 233                                 min(ses_ptr->cdata.ivsize, kcop->ivlen));
 234         }
 235
 236         if (ses_ptr->hdata.init != 0 &&
 237                 ((cop->flags & COP_FLAG_FINAL) ||
 238                    (!(cop->flags & COP_FLAG_UPDATE) || cop->len == 0))) {
 239
 240                 ret = cryptodev_hash_final(&ses_ptr->hdata, kcop->hash_output);
 241                 if (unlikely(ret)) {
 242                         dprintk(0, KERN_ERR, "CryptoAPI failure: %d\n", ret);
 243                         goto out_unlock;
 244                 }
 245                 kcop->digestsize = ses_ptr->hdata.digestsize;
 246         }
 247
 248 out_unlock:
 249         crypto_put_session(ses_ptr);
 250         return ret;
 251 }