padlock - get rid of __GNUCLIKE_ASM #ifdefs
[dragonfly.git] / sys / crypto / via / padlock_cipher.c
CommitLineData
42ee1e6b
SW
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 <crypto/via/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
77MALLOC_DECLARE(M_PADLOCK);
78
79static __inline void
80padlock_cbc(void *in, void *out, size_t count, void *key, union padlock_cw *cw,
81 void *iv)
82{
42ee1e6b
SW
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 );
42ee1e6b
SW
93}
94
95static void
96padlock_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
116int
117padlock_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
54734da1 154 karc4rand(ses->ses_iv, sizeof(ses->ses_iv));
42ee1e6b
SW
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 */
163static u_char *
164padlock_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 }
189alloc:
190 *allocated = 1;
54734da1 191 addr = kmalloc(enccrd->crd_len + 16, M_PADLOCK, M_NOWAIT);
42ee1e6b
SW
192 return (addr);
193}
194
195int
196padlock_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);
54734da1 263 kfree(buf, M_PADLOCK);
42ee1e6b
SW
264 }
265 return (0);
266}