sys/dev/crypto/padlock/padlock_cipher.c

   1 /*-
   2  * Copyright (c) 2005-2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * Copyright (c) 2004 Mark R V Murray
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /*      $OpenBSD: via.c,v 1.3 2004/06/15 23:36:55 deraadt Exp $ */
  29 /*      $FreeBSD: src/sys/crypto/via/padlock_cipher.c,v 1.5 2006/09/15 10:44:55 pjd Exp $ */
  30 /*-
  31  * Copyright (c) 2003 Jason Wright
  32  * Copyright (c) 2003, 2004 Theo de Raadt
  33  * All rights reserved.
  34  *
  35  * Permission to use, copy, modify, and distribute this software for any
  36  * purpose with or without fee is hereby granted, provided that the above
  37  * copyright notice and this permission notice appear in all copies.
  38  *
  39  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  40  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  41  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  42  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  43  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  44  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  45  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  46  */
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/kernel.h>
  51 #include <sys/module.h>
  52 #include <sys/malloc.h>
  53 #include <sys/libkern.h>
  54 #include <sys/uio.h>
  55
  56 #include <opencrypto/cryptodev.h>
  57 #include <crypto/rijndael/rijndael.h>
  58
  59 #include <dev/crypto/padlock/padlock.h>
  60
  61 #define PADLOCK_ROUND_COUNT_AES128      10
  62 #define PADLOCK_ROUND_COUNT_AES192      12
  63 #define PADLOCK_ROUND_COUNT_AES256      14
  64
  65 #define PADLOCK_ALGORITHM_TYPE_AES      0
  66
  67 #define PADLOCK_KEY_GENERATION_HW       0
  68 #define PADLOCK_KEY_GENERATION_SW       1
  69
  70 #define PADLOCK_DIRECTION_ENCRYPT       0
  71 #define PADLOCK_DIRECTION_DECRYPT       1
  72
  73 #define PADLOCK_KEY_SIZE_128    0
  74 #define PADLOCK_KEY_SIZE_192    1
  75 #define PADLOCK_KEY_SIZE_256    2
  76
  77 MALLOC_DECLARE(M_PADLOCK);
  78
  79 static __inline void
  80 padlock_cbc(void *in, void *out, size_t count, void *key, union padlock_cw *cw,
  81     void *iv)
  82 {
  83         /* The .byte line is really VIA C3 "xcrypt-cbc" instruction */
  84         __asm __volatile(
  85                 "pushf                          \n\t"
  86                 "popf                           \n\t"
  87                 "rep                            \n\t"
  88                 ".byte  0x0f, 0xa7, 0xd0"
  89                         : "+a" (iv), "+c" (count), "+D" (out), "+S" (in)
  90                         : "b" (key), "d" (cw)
  91                         : "cc", "memory"
  92                 );
  93 }
  94
  95 static void
  96 padlock_cipher_key_setup(struct padlock_session *ses, caddr_t key, int klen)
  97 {
  98         union padlock_cw *cw;
  99         int i;
 100
 101         cw = &ses->ses_cw;
 102         if (cw->cw_key_generation == PADLOCK_KEY_GENERATION_SW) {
 103                 /* Build expanded keys for both directions */
 104                 rijndaelKeySetupEnc(ses->ses_ekey, key, klen);
 105                 rijndaelKeySetupDec(ses->ses_dkey, key, klen);
 106                 for (i = 0; i < 4 * (RIJNDAEL_MAXNR + 1); i++) {
 107                         ses->ses_ekey[i] = ntohl(ses->ses_ekey[i]);
 108                         ses->ses_dkey[i] = ntohl(ses->ses_dkey[i]);
 109                 }
 110         } else {
 111                 bcopy(key, ses->ses_ekey, klen);
 112                 bcopy(key, ses->ses_dkey, klen);
 113         }
 114 }
 115
 116 int
 117 padlock_cipher_setup(struct padlock_session *ses, struct cryptoini *encini)
 118 {
 119         union padlock_cw *cw;
 120
 121         if (encini->cri_klen != 128 && encini->cri_klen != 192 &&
 122             encini->cri_klen != 256) {
 123                 return (EINVAL);
 124         }
 125
 126         cw = &ses->ses_cw;
 127         bzero(cw, sizeof(*cw));
 128         cw->cw_algorithm_type = PADLOCK_ALGORITHM_TYPE_AES;
 129         cw->cw_key_generation = PADLOCK_KEY_GENERATION_SW;
 130         cw->cw_intermediate = 0;
 131         switch (encini->cri_klen) {
 132         case 128:
 133                 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES128;
 134                 cw->cw_key_size = PADLOCK_KEY_SIZE_128;
 135 #ifdef HW_KEY_GENERATION
 136                 /* This doesn't buy us much, that's why it is commented out. */
 137                 cw->cw_key_generation = PADLOCK_KEY_GENERATION_HW;
 138 #endif
 139                 break;
 140         case 192:
 141                 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES192;
 142                 cw->cw_key_size = PADLOCK_KEY_SIZE_192;
 143                 break;
 144         case 256:
 145                 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES256;
 146                 cw->cw_key_size = PADLOCK_KEY_SIZE_256;
 147                 break;
 148         }
 149         if (encini->cri_key != NULL) {
 150                 padlock_cipher_key_setup(ses, encini->cri_key,
 151                     encini->cri_klen);
 152         }
 153
 154         karc4rand(ses->ses_iv, sizeof(ses->ses_iv));
 155         return (0);
 156 }
 157
 158 /*
 159  * Function checks if the given buffer is already 16 bytes aligned.
 160  * If it is there is no need to allocate new buffer.
 161  * If it isn't, new buffer is allocated.
 162  */
 163 static u_char *
 164 padlock_cipher_alloc(struct cryptodesc *enccrd, struct cryptop *crp,
 165     int *allocated)
 166 {
 167         u_char *addr;
 168
 169         if (crp->crp_flags & CRYPTO_F_IMBUF)
 170                 goto alloc;
 171         else {
 172                 if (crp->crp_flags & CRYPTO_F_IOV) {
 173                         struct uio *uio;
 174                         struct iovec *iov;
 175
 176                         uio = (struct uio *)crp->crp_buf;
 177                         if (uio->uio_iovcnt != 1)
 178                                 goto alloc;
 179                         iov = uio->uio_iov;
 180                         addr = (u_char *)iov->iov_base + enccrd->crd_skip;
 181                 } else {
 182                         addr = (u_char *)crp->crp_buf;
 183                 }
 184                 if (((uintptr_t)addr & 0xf) != 0) /* 16 bytes aligned? */
 185                         goto alloc;
 186                 *allocated = 0;
 187                 return (addr);
 188         }
 189 alloc:
 190         *allocated = 1;
 191         addr = kmalloc(enccrd->crd_len + 16, M_PADLOCK, M_NOWAIT);
 192         return (addr);
 193 }
 194
 195 int
 196 padlock_cipher_process(struct padlock_session *ses, struct cryptodesc *enccrd,
 197     struct cryptop *crp)
 198 {
 199         union padlock_cw *cw;
 200         u_char *buf, *abuf;
 201         uint32_t *key;
 202         int allocated;
 203
 204         buf = padlock_cipher_alloc(enccrd, crp, &allocated);
 205         if (buf == NULL)
 206                 return (ENOMEM);
 207         /* Buffer has to be 16 bytes aligned. */
 208         abuf = PADLOCK_ALIGN(buf);
 209
 210         if ((enccrd->crd_flags & CRD_F_KEY_EXPLICIT) != 0) {
 211                 padlock_cipher_key_setup(ses, enccrd->crd_key,
 212                     enccrd->crd_klen);
 213         }
 214
 215         cw = &ses->ses_cw;
 216         cw->cw_filler0 = 0;
 217         cw->cw_filler1 = 0;
 218         cw->cw_filler2 = 0;
 219         cw->cw_filler3 = 0;
 220         if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) {
 221                 cw->cw_direction = PADLOCK_DIRECTION_ENCRYPT;
 222                 key = ses->ses_ekey;
 223                 if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0)
 224                         bcopy(enccrd->crd_iv, ses->ses_iv, AES_BLOCK_LEN);
 225
 226                 if ((enccrd->crd_flags & CRD_F_IV_PRESENT) == 0) {
 227                         crypto_copyback(crp->crp_flags, crp->crp_buf,
 228                             enccrd->crd_inject, AES_BLOCK_LEN, ses->ses_iv);
 229                 }
 230         } else {
 231                 cw->cw_direction = PADLOCK_DIRECTION_DECRYPT;
 232                 key = ses->ses_dkey;
 233                 if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0)
 234                         bcopy(enccrd->crd_iv, ses->ses_iv, AES_BLOCK_LEN);
 235                 else {
 236                         crypto_copydata(crp->crp_flags, crp->crp_buf,
 237                             enccrd->crd_inject, AES_BLOCK_LEN, ses->ses_iv);
 238                 }
 239         }
 240
 241         if (allocated) {
 242                 crypto_copydata(crp->crp_flags, crp->crp_buf, enccrd->crd_skip,
 243                     enccrd->crd_len, abuf);
 244         }
 245
 246         padlock_cbc(abuf, abuf, enccrd->crd_len / AES_BLOCK_LEN, key, cw,
 247             ses->ses_iv);
 248
 249         if (allocated) {
 250                 crypto_copyback(crp->crp_flags, crp->crp_buf, enccrd->crd_skip,
 251                     enccrd->crd_len, abuf);
 252         }
 253
 254         /* copy out last block for use as next session IV */
 255         if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) {
 256                 crypto_copydata(crp->crp_flags, crp->crp_buf,
 257                     enccrd->crd_skip + enccrd->crd_len - AES_BLOCK_LEN,
 258                     AES_BLOCK_LEN, ses->ses_iv);
 259         }
 260
 261         if (allocated) {
 262                 bzero(buf, enccrd->crd_len + 16);
 263                 kfree(buf, M_PADLOCK);
 264         }
 265         return (0);
 266 }