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 /*- 30 * Copyright (c) 2003 Jason Wright 31 * Copyright (c) 2003, 2004 Theo de Raadt 32 * All rights reserved. 33 * 34 * Permission to use, copy, modify, and distribute this software for any 35 * purpose with or without fee is hereby granted, provided that the above 36 * copyright notice and this permission notice appear in all copies. 37 * 38 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 39 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 40 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 41 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 42 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 43 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 44 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 45 */ 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/module.h> 51 #include <sys/malloc.h> 52 #include <sys/libkern.h> 53 #include <sys/pcpu.h> 54 #include <sys/uio.h> 55 #include <machine/fpu.h> 56 57 #include <opencrypto/cryptodev.h> 58 #include <crypto/rijndael/rijndael.h> 59 60 #include <crypto/via/padlock.h> 61 62 #define PADLOCK_ROUND_COUNT_AES128 10 63 #define PADLOCK_ROUND_COUNT_AES192 12 64 #define PADLOCK_ROUND_COUNT_AES256 14 65 66 #define PADLOCK_ALGORITHM_TYPE_AES 0 67 68 #define PADLOCK_KEY_GENERATION_HW 0 69 #define PADLOCK_KEY_GENERATION_SW 1 70 71 #define PADLOCK_DIRECTION_ENCRYPT 0 72 #define PADLOCK_DIRECTION_DECRYPT 1 73 74 #define PADLOCK_KEY_SIZE_128 0 75 #define PADLOCK_KEY_SIZE_192 1 76 #define PADLOCK_KEY_SIZE_256 2 77 78 MALLOC_DECLARE(M_PADLOCK); 79 80 static __inline void 81 padlock_cbc(void *in, void *out, size_t count, void *key, union padlock_cw *cw, 82 void *iv) 83 { 84 /* The .byte line is really VIA C3 "xcrypt-cbc" instruction */ 85 __asm __volatile( 86 "pushf \n\t" 87 "popf \n\t" 88 "rep \n\t" 89 ".byte 0x0f, 0xa7, 0xd0" 90 : "+a" (iv), "+c" (count), "+D" (out), "+S" (in) 91 : "b" (key), "d" (cw) 92 : "cc", "memory" 93 ); 94 } 95 96 static void 97 padlock_cipher_key_setup(struct padlock_session *ses, const void *key, int klen) 98 { 99 union padlock_cw *cw; 100 int i; 101 102 cw = &ses->ses_cw; 103 if (cw->cw_key_generation == PADLOCK_KEY_GENERATION_SW) { 104 /* Build expanded keys for both directions */ 105 rijndaelKeySetupEnc(ses->ses_ekey, key, klen * 8); 106 rijndaelKeySetupDec(ses->ses_dkey, key, klen * 8); 107 for (i = 0; i < 4 * (RIJNDAEL_MAXNR + 1); i++) { 108 ses->ses_ekey[i] = ntohl(ses->ses_ekey[i]); 109 ses->ses_dkey[i] = ntohl(ses->ses_dkey[i]); 110 } 111 } else { 112 bcopy(key, ses->ses_ekey, klen); 113 bcopy(key, ses->ses_dkey, klen); 114 } 115 } 116 117 int 118 padlock_cipher_setup(struct padlock_session *ses, 119 const struct crypto_session_params *csp) 120 { 121 union padlock_cw *cw; 122 123 if (csp->csp_cipher_klen != 16 && csp->csp_cipher_klen != 24 && 124 csp->csp_cipher_klen != 32) { 125 return (EINVAL); 126 } 127 128 cw = &ses->ses_cw; 129 bzero(cw, sizeof(*cw)); 130 cw->cw_algorithm_type = PADLOCK_ALGORITHM_TYPE_AES; 131 cw->cw_key_generation = PADLOCK_KEY_GENERATION_SW; 132 cw->cw_intermediate = 0; 133 switch (csp->csp_cipher_klen * 8) { 134 case 128: 135 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES128; 136 cw->cw_key_size = PADLOCK_KEY_SIZE_128; 137 #ifdef HW_KEY_GENERATION 138 /* This doesn't buy us much, that's why it is commented out. */ 139 cw->cw_key_generation = PADLOCK_KEY_GENERATION_HW; 140 #endif 141 break; 142 case 192: 143 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES192; 144 cw->cw_key_size = PADLOCK_KEY_SIZE_192; 145 break; 146 case 256: 147 cw->cw_round_count = PADLOCK_ROUND_COUNT_AES256; 148 cw->cw_key_size = PADLOCK_KEY_SIZE_256; 149 break; 150 } 151 if (csp->csp_cipher_key != NULL) { 152 padlock_cipher_key_setup(ses, csp->csp_cipher_key, 153 csp->csp_cipher_klen); 154 } 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 cryptop *crp, int *allocated) 165 { 166 u_char *addr; 167 168 addr = crypto_contiguous_subsegment(crp, crp->crp_payload_start, 169 crp->crp_payload_length); 170 if (((uintptr_t)addr & 0xf) == 0) { /* 16 bytes aligned? */ 171 *allocated = 0; 172 return (addr); 173 } 174 175 *allocated = 1; 176 addr = malloc(crp->crp_payload_length + 16, M_PADLOCK, M_NOWAIT); 177 return (addr); 178 } 179 180 int 181 padlock_cipher_process(struct padlock_session *ses, struct cryptop *crp, 182 const struct crypto_session_params *csp) 183 { 184 union padlock_cw *cw; 185 struct thread *td; 186 u_char *buf, *abuf; 187 uint32_t *key; 188 uint8_t iv[AES_BLOCK_LEN] __aligned(16); 189 int allocated; 190 191 buf = padlock_cipher_alloc(crp, &allocated); 192 if (buf == NULL) 193 return (ENOMEM); 194 /* Buffer has to be 16 bytes aligned. */ 195 abuf = PADLOCK_ALIGN(buf); 196 197 if (crp->crp_cipher_key != NULL) { 198 padlock_cipher_key_setup(ses, crp->crp_cipher_key, 199 csp->csp_cipher_klen); 200 } 201 202 cw = &ses->ses_cw; 203 cw->cw_filler0 = 0; 204 cw->cw_filler1 = 0; 205 cw->cw_filler2 = 0; 206 cw->cw_filler3 = 0; 207 208 crypto_read_iv(crp, iv); 209 210 if (CRYPTO_OP_IS_ENCRYPT(crp->crp_op)) { 211 cw->cw_direction = PADLOCK_DIRECTION_ENCRYPT; 212 key = ses->ses_ekey; 213 } else { 214 cw->cw_direction = PADLOCK_DIRECTION_DECRYPT; 215 key = ses->ses_dkey; 216 } 217 218 if (allocated) { 219 crypto_copydata(crp, crp->crp_payload_start, 220 crp->crp_payload_length, abuf); 221 } 222 223 td = curthread; 224 fpu_kern_enter(td, NULL, FPU_KERN_NORMAL | FPU_KERN_NOCTX); 225 padlock_cbc(abuf, abuf, crp->crp_payload_length / AES_BLOCK_LEN, key, 226 cw, iv); 227 fpu_kern_leave(td, NULL); 228 229 if (allocated) { 230 crypto_copyback(crp, crp->crp_payload_start, 231 crp->crp_payload_length, abuf); 232 233 zfree(buf, M_PADLOCK); 234 } 235 return (0); 236 } 237