xref: /freebsd/sys/crypto/via/padlock_cipher.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
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/cdefs.h>
48 __FBSDID("$FreeBSD$");
49 
50 #include <sys/param.h>
51 #include <sys/systm.h>
52 #include <sys/kernel.h>
53 #include <sys/module.h>
54 #include <sys/malloc.h>
55 #include <sys/libkern.h>
56 #include <sys/uio.h>
57 
58 #include <opencrypto/cryptodev.h>
59 #include <crypto/rijndael/rijndael.h>
60 
61 #include <crypto/via/padlock.h>
62 
63 #define	PADLOCK_ROUND_COUNT_AES128	10
64 #define	PADLOCK_ROUND_COUNT_AES192	12
65 #define	PADLOCK_ROUND_COUNT_AES256	14
66 
67 #define	PADLOCK_ALGORITHM_TYPE_AES	0
68 
69 #define	PADLOCK_KEY_GENERATION_HW	0
70 #define	PADLOCK_KEY_GENERATION_SW	1
71 
72 #define	PADLOCK_DIRECTION_ENCRYPT	0
73 #define	PADLOCK_DIRECTION_DECRYPT	1
74 
75 #define	PADLOCK_KEY_SIZE_128	0
76 #define	PADLOCK_KEY_SIZE_192	1
77 #define	PADLOCK_KEY_SIZE_256	2
78 
79 MALLOC_DECLARE(M_PADLOCK);
80 
81 static __inline void
82 padlock_cbc(void *in, void *out, size_t count, void *key, union padlock_cw *cw,
83     void *iv)
84 {
85 #ifdef __GNUCLIKE_ASM
86 	/* The .byte line is really VIA C3 "xcrypt-cbc" instruction */
87 	__asm __volatile(
88 		"pushf				\n\t"
89 		"popf				\n\t"
90 		"rep				\n\t"
91 		".byte	0x0f, 0xa7, 0xd0"
92 			: "+a" (iv), "+c" (count), "+D" (out), "+S" (in)
93 			: "b" (key), "d" (cw)
94 			: "cc", "memory"
95 		);
96 #endif
97 }
98 
99 static void
100 padlock_cipher_key_setup(struct padlock_session *ses, caddr_t key, int klen)
101 {
102 	union padlock_cw *cw;
103 	int i;
104 
105 	cw = &ses->ses_cw;
106 	if (cw->cw_key_generation == PADLOCK_KEY_GENERATION_SW) {
107 		/* Build expanded keys for both directions */
108 		rijndaelKeySetupEnc(ses->ses_ekey, key, klen);
109 		rijndaelKeySetupDec(ses->ses_dkey, key, klen);
110 		for (i = 0; i < 4 * (RIJNDAEL_MAXNR + 1); i++) {
111 			ses->ses_ekey[i] = ntohl(ses->ses_ekey[i]);
112 			ses->ses_dkey[i] = ntohl(ses->ses_dkey[i]);
113 		}
114 	} else {
115 		bcopy(key, ses->ses_ekey, klen);
116 		bcopy(key, ses->ses_dkey, klen);
117 	}
118 }
119 
120 int
121 padlock_cipher_setup(struct padlock_session *ses, struct cryptoini *encini)
122 {
123 	union padlock_cw *cw;
124 
125 	if (encini->cri_klen != 128 && encini->cri_klen != 192 &&
126 	    encini->cri_klen != 256) {
127 		return (EINVAL);
128 	}
129 
130 	cw = &ses->ses_cw;
131 	bzero(cw, sizeof(*cw));
132 	cw->cw_algorithm_type = PADLOCK_ALGORITHM_TYPE_AES;
133 	cw->cw_key_generation = PADLOCK_KEY_GENERATION_SW;
134 	cw->cw_intermediate = 0;
135 	switch (encini->cri_klen) {
136 	case 128:
137 		cw->cw_round_count = PADLOCK_ROUND_COUNT_AES128;
138 		cw->cw_key_size = PADLOCK_KEY_SIZE_128;
139 #ifdef HW_KEY_GENERATION
140 		/* This doesn't buy us much, that's why it is commented out. */
141 		cw->cw_key_generation = PADLOCK_KEY_GENERATION_HW;
142 #endif
143 		break;
144 	case 192:
145 		cw->cw_round_count = PADLOCK_ROUND_COUNT_AES192;
146 		cw->cw_key_size = PADLOCK_KEY_SIZE_192;
147 		break;
148 	case 256:
149 		cw->cw_round_count = PADLOCK_ROUND_COUNT_AES256;
150 		cw->cw_key_size = PADLOCK_KEY_SIZE_256;
151 		break;
152 	}
153 	if (encini->cri_key != NULL) {
154 		padlock_cipher_key_setup(ses, encini->cri_key,
155 		    encini->cri_klen);
156 	}
157 
158 	arc4rand(ses->ses_iv, sizeof(ses->ses_iv), 0);
159 	return (0);
160 }
161 
162 /*
163  * Function checks if the given buffer is already 16 bytes aligned.
164  * If it is there is no need to allocate new buffer.
165  * If it isn't, new buffer is allocated.
166  */
167 static u_char *
168 padlock_cipher_alloc(struct cryptodesc *enccrd, struct cryptop *crp,
169     int *allocated)
170 {
171 	u_char *addr;
172 
173 	if (crp->crp_flags & CRYPTO_F_IMBUF)
174 		goto alloc;
175 	else {
176 		if (crp->crp_flags & CRYPTO_F_IOV) {
177 			struct uio *uio;
178 			struct iovec *iov;
179 
180 			uio = (struct uio *)crp->crp_buf;
181 			if (uio->uio_iovcnt != 1)
182 				goto alloc;
183 			iov = uio->uio_iov;
184 			addr = (u_char *)iov->iov_base + enccrd->crd_skip;
185 		} else {
186 			addr = (u_char *)crp->crp_buf;
187 		}
188 		if (((uintptr_t)addr & 0xf) != 0) /* 16 bytes aligned? */
189 			goto alloc;
190 		*allocated = 0;
191 		return (addr);
192 	}
193 alloc:
194 	*allocated = 1;
195 	addr = malloc(enccrd->crd_len + 16, M_PADLOCK, M_NOWAIT);
196 	return (addr);
197 }
198 
199 int
200 padlock_cipher_process(struct padlock_session *ses, struct cryptodesc *enccrd,
201     struct cryptop *crp)
202 {
203 	union padlock_cw *cw;
204 	u_char *buf, *abuf;
205 	uint32_t *key;
206 	int allocated;
207 
208 	buf = padlock_cipher_alloc(enccrd, crp, &allocated);
209 	if (buf == NULL)
210 		return (ENOMEM);
211 	/* Buffer has to be 16 bytes aligned. */
212 	abuf = PADLOCK_ALIGN(buf);
213 
214 	if ((enccrd->crd_flags & CRD_F_KEY_EXPLICIT) != 0) {
215 		padlock_cipher_key_setup(ses, enccrd->crd_key,
216 		    enccrd->crd_klen);
217 	}
218 
219 	cw = &ses->ses_cw;
220 	cw->cw_filler0 = 0;
221 	cw->cw_filler1 = 0;
222 	cw->cw_filler2 = 0;
223 	cw->cw_filler3 = 0;
224 	if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) {
225 		cw->cw_direction = PADLOCK_DIRECTION_ENCRYPT;
226 		key = ses->ses_ekey;
227 		if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0)
228 			bcopy(enccrd->crd_iv, ses->ses_iv, AES_BLOCK_LEN);
229 
230 		if ((enccrd->crd_flags & CRD_F_IV_PRESENT) == 0) {
231 			crypto_copyback(crp->crp_flags, crp->crp_buf,
232 			    enccrd->crd_inject, AES_BLOCK_LEN, ses->ses_iv);
233 		}
234 	} else {
235 		cw->cw_direction = PADLOCK_DIRECTION_DECRYPT;
236 		key = ses->ses_dkey;
237 		if ((enccrd->crd_flags & CRD_F_IV_EXPLICIT) != 0)
238 			bcopy(enccrd->crd_iv, ses->ses_iv, AES_BLOCK_LEN);
239 		else {
240 			crypto_copydata(crp->crp_flags, crp->crp_buf,
241 			    enccrd->crd_inject, AES_BLOCK_LEN, ses->ses_iv);
242 		}
243 	}
244 
245 	if (allocated) {
246 		crypto_copydata(crp->crp_flags, crp->crp_buf, enccrd->crd_skip,
247 		    enccrd->crd_len, abuf);
248 	}
249 
250 	padlock_cbc(abuf, abuf, enccrd->crd_len / AES_BLOCK_LEN, key, cw,
251 	    ses->ses_iv);
252 
253 	if (allocated) {
254 		crypto_copyback(crp->crp_flags, crp->crp_buf, enccrd->crd_skip,
255 		    enccrd->crd_len, abuf);
256 	}
257 
258 	/* copy out last block for use as next session IV */
259 	if ((enccrd->crd_flags & CRD_F_ENCRYPT) != 0) {
260 		crypto_copydata(crp->crp_flags, crp->crp_buf,
261 		    enccrd->crd_skip + enccrd->crd_len - AES_BLOCK_LEN,
262 		    AES_BLOCK_LEN, ses->ses_iv);
263 	}
264 
265 	if (allocated) {
266 		bzero(buf, enccrd->crd_len + 16);
267 		free(buf, M_PADLOCK);
268 	}
269 	return (0);
270 }
271