linux-user, s390x: add syscall table generation support
[qemu.git] / crypto / cipher-gcrypt.c
1 /*
2 * QEMU Crypto cipher libgcrypt algorithms
3 *
4 * Copyright (c) 2015 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "qemu/osdep.h"
22 #ifdef CONFIG_QEMU_PRIVATE_XTS
23 #include "crypto/xts.h"
24 #endif
25 #include "cipherpriv.h"
26
27 #include <gcrypt.h>
28
29
30 bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
31 QCryptoCipherMode mode)
32 {
33 switch (alg) {
34 case QCRYPTO_CIPHER_ALG_DES_RFB:
35 case QCRYPTO_CIPHER_ALG_3DES:
36 case QCRYPTO_CIPHER_ALG_AES_128:
37 case QCRYPTO_CIPHER_ALG_AES_192:
38 case QCRYPTO_CIPHER_ALG_AES_256:
39 case QCRYPTO_CIPHER_ALG_CAST5_128:
40 case QCRYPTO_CIPHER_ALG_SERPENT_128:
41 case QCRYPTO_CIPHER_ALG_SERPENT_192:
42 case QCRYPTO_CIPHER_ALG_SERPENT_256:
43 case QCRYPTO_CIPHER_ALG_TWOFISH_128:
44 case QCRYPTO_CIPHER_ALG_TWOFISH_256:
45 break;
46 default:
47 return false;
48 }
49
50 switch (mode) {
51 case QCRYPTO_CIPHER_MODE_ECB:
52 case QCRYPTO_CIPHER_MODE_CBC:
53 case QCRYPTO_CIPHER_MODE_XTS:
54 case QCRYPTO_CIPHER_MODE_CTR:
55 return true;
56 default:
57 return false;
58 }
59 }
60
61 typedef struct QCryptoCipherGcrypt QCryptoCipherGcrypt;
62 struct QCryptoCipherGcrypt {
63 gcry_cipher_hd_t handle;
64 size_t blocksize;
65 #ifdef CONFIG_QEMU_PRIVATE_XTS
66 gcry_cipher_hd_t tweakhandle;
67 /* Initialization vector or Counter */
68 uint8_t *iv;
69 #endif
70 };
71
72 static void
73 qcrypto_gcrypt_cipher_free_ctx(QCryptoCipherGcrypt *ctx,
74 QCryptoCipherMode mode)
75 {
76 if (!ctx) {
77 return;
78 }
79
80 gcry_cipher_close(ctx->handle);
81 #ifdef CONFIG_QEMU_PRIVATE_XTS
82 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
83 gcry_cipher_close(ctx->tweakhandle);
84 }
85 g_free(ctx->iv);
86 #endif
87 g_free(ctx);
88 }
89
90
91 static QCryptoCipherGcrypt *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
92 QCryptoCipherMode mode,
93 const uint8_t *key,
94 size_t nkey,
95 Error **errp)
96 {
97 QCryptoCipherGcrypt *ctx;
98 gcry_error_t err;
99 int gcryalg, gcrymode;
100
101 switch (mode) {
102 case QCRYPTO_CIPHER_MODE_ECB:
103 gcrymode = GCRY_CIPHER_MODE_ECB;
104 break;
105 case QCRYPTO_CIPHER_MODE_XTS:
106 #ifdef CONFIG_QEMU_PRIVATE_XTS
107 gcrymode = GCRY_CIPHER_MODE_ECB;
108 #else
109 gcrymode = GCRY_CIPHER_MODE_XTS;
110 #endif
111 break;
112 case QCRYPTO_CIPHER_MODE_CBC:
113 gcrymode = GCRY_CIPHER_MODE_CBC;
114 break;
115 case QCRYPTO_CIPHER_MODE_CTR:
116 gcrymode = GCRY_CIPHER_MODE_CTR;
117 break;
118 default:
119 error_setg(errp, "Unsupported cipher mode %s",
120 QCryptoCipherMode_str(mode));
121 return NULL;
122 }
123
124 if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
125 return NULL;
126 }
127
128 switch (alg) {
129 case QCRYPTO_CIPHER_ALG_DES_RFB:
130 gcryalg = GCRY_CIPHER_DES;
131 break;
132
133 case QCRYPTO_CIPHER_ALG_3DES:
134 gcryalg = GCRY_CIPHER_3DES;
135 break;
136
137 case QCRYPTO_CIPHER_ALG_AES_128:
138 gcryalg = GCRY_CIPHER_AES128;
139 break;
140
141 case QCRYPTO_CIPHER_ALG_AES_192:
142 gcryalg = GCRY_CIPHER_AES192;
143 break;
144
145 case QCRYPTO_CIPHER_ALG_AES_256:
146 gcryalg = GCRY_CIPHER_AES256;
147 break;
148
149 case QCRYPTO_CIPHER_ALG_CAST5_128:
150 gcryalg = GCRY_CIPHER_CAST5;
151 break;
152
153 case QCRYPTO_CIPHER_ALG_SERPENT_128:
154 gcryalg = GCRY_CIPHER_SERPENT128;
155 break;
156
157 case QCRYPTO_CIPHER_ALG_SERPENT_192:
158 gcryalg = GCRY_CIPHER_SERPENT192;
159 break;
160
161 case QCRYPTO_CIPHER_ALG_SERPENT_256:
162 gcryalg = GCRY_CIPHER_SERPENT256;
163 break;
164
165 case QCRYPTO_CIPHER_ALG_TWOFISH_128:
166 gcryalg = GCRY_CIPHER_TWOFISH128;
167 break;
168
169 case QCRYPTO_CIPHER_ALG_TWOFISH_256:
170 gcryalg = GCRY_CIPHER_TWOFISH;
171 break;
172
173 default:
174 error_setg(errp, "Unsupported cipher algorithm %s",
175 QCryptoCipherAlgorithm_str(alg));
176 return NULL;
177 }
178
179 ctx = g_new0(QCryptoCipherGcrypt, 1);
180
181 err = gcry_cipher_open(&ctx->handle, gcryalg, gcrymode, 0);
182 if (err != 0) {
183 error_setg(errp, "Cannot initialize cipher: %s",
184 gcry_strerror(err));
185 goto error;
186 }
187 #ifdef CONFIG_QEMU_PRIVATE_XTS
188 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
189 err = gcry_cipher_open(&ctx->tweakhandle, gcryalg, gcrymode, 0);
190 if (err != 0) {
191 error_setg(errp, "Cannot initialize cipher: %s",
192 gcry_strerror(err));
193 goto error;
194 }
195 }
196 #endif
197
198 if (alg == QCRYPTO_CIPHER_ALG_DES_RFB) {
199 /* We're using standard DES cipher from gcrypt, so we need
200 * to munge the key so that the results are the same as the
201 * bizarre RFB variant of DES :-)
202 */
203 uint8_t *rfbkey = qcrypto_cipher_munge_des_rfb_key(key, nkey);
204 err = gcry_cipher_setkey(ctx->handle, rfbkey, nkey);
205 g_free(rfbkey);
206 ctx->blocksize = 8;
207 } else {
208 #ifdef CONFIG_QEMU_PRIVATE_XTS
209 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
210 nkey /= 2;
211 err = gcry_cipher_setkey(ctx->handle, key, nkey);
212 if (err != 0) {
213 error_setg(errp, "Cannot set key: %s",
214 gcry_strerror(err));
215 goto error;
216 }
217 err = gcry_cipher_setkey(ctx->tweakhandle, key + nkey, nkey);
218 } else {
219 #endif
220 err = gcry_cipher_setkey(ctx->handle, key, nkey);
221 #ifdef CONFIG_QEMU_PRIVATE_XTS
222 }
223 #endif
224 if (err != 0) {
225 error_setg(errp, "Cannot set key: %s",
226 gcry_strerror(err));
227 goto error;
228 }
229 switch (alg) {
230 case QCRYPTO_CIPHER_ALG_AES_128:
231 case QCRYPTO_CIPHER_ALG_AES_192:
232 case QCRYPTO_CIPHER_ALG_AES_256:
233 case QCRYPTO_CIPHER_ALG_SERPENT_128:
234 case QCRYPTO_CIPHER_ALG_SERPENT_192:
235 case QCRYPTO_CIPHER_ALG_SERPENT_256:
236 case QCRYPTO_CIPHER_ALG_TWOFISH_128:
237 case QCRYPTO_CIPHER_ALG_TWOFISH_256:
238 ctx->blocksize = 16;
239 break;
240 case QCRYPTO_CIPHER_ALG_3DES:
241 case QCRYPTO_CIPHER_ALG_CAST5_128:
242 ctx->blocksize = 8;
243 break;
244 default:
245 g_assert_not_reached();
246 }
247 }
248
249 #ifdef CONFIG_QEMU_PRIVATE_XTS
250 if (mode == QCRYPTO_CIPHER_MODE_XTS) {
251 if (ctx->blocksize != XTS_BLOCK_SIZE) {
252 error_setg(errp,
253 "Cipher block size %zu must equal XTS block size %d",
254 ctx->blocksize, XTS_BLOCK_SIZE);
255 goto error;
256 }
257 ctx->iv = g_new0(uint8_t, ctx->blocksize);
258 }
259 #endif
260
261 return ctx;
262
263 error:
264 qcrypto_gcrypt_cipher_free_ctx(ctx, mode);
265 return NULL;
266 }
267
268
269 static void
270 qcrypto_gcrypt_cipher_ctx_free(QCryptoCipher *cipher)
271 {
272 qcrypto_gcrypt_cipher_free_ctx(cipher->opaque, cipher->mode);
273 }
274
275
276 #ifdef CONFIG_QEMU_PRIVATE_XTS
277 static void qcrypto_gcrypt_xts_encrypt(const void *ctx,
278 size_t length,
279 uint8_t *dst,
280 const uint8_t *src)
281 {
282 gcry_error_t err;
283 err = gcry_cipher_encrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
284 g_assert(err == 0);
285 }
286
287 static void qcrypto_gcrypt_xts_decrypt(const void *ctx,
288 size_t length,
289 uint8_t *dst,
290 const uint8_t *src)
291 {
292 gcry_error_t err;
293 err = gcry_cipher_decrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
294 g_assert(err == 0);
295 }
296 #endif
297
298 static int
299 qcrypto_gcrypt_cipher_encrypt(QCryptoCipher *cipher,
300 const void *in,
301 void *out,
302 size_t len,
303 Error **errp)
304 {
305 QCryptoCipherGcrypt *ctx = cipher->opaque;
306 gcry_error_t err;
307
308 if (len % ctx->blocksize) {
309 error_setg(errp, "Length %zu must be a multiple of block size %zu",
310 len, ctx->blocksize);
311 return -1;
312 }
313
314 #ifdef CONFIG_QEMU_PRIVATE_XTS
315 if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
316 xts_encrypt(ctx->handle, ctx->tweakhandle,
317 qcrypto_gcrypt_xts_encrypt,
318 qcrypto_gcrypt_xts_decrypt,
319 ctx->iv, len, out, in);
320 return 0;
321 }
322 #endif
323
324 err = gcry_cipher_encrypt(ctx->handle,
325 out, len,
326 in, len);
327 if (err != 0) {
328 error_setg(errp, "Cannot encrypt data: %s",
329 gcry_strerror(err));
330 return -1;
331 }
332
333 return 0;
334 }
335
336
337 static int
338 qcrypto_gcrypt_cipher_decrypt(QCryptoCipher *cipher,
339 const void *in,
340 void *out,
341 size_t len,
342 Error **errp)
343 {
344 QCryptoCipherGcrypt *ctx = cipher->opaque;
345 gcry_error_t err;
346
347 if (len % ctx->blocksize) {
348 error_setg(errp, "Length %zu must be a multiple of block size %zu",
349 len, ctx->blocksize);
350 return -1;
351 }
352
353 #ifdef CONFIG_QEMU_PRIVATE_XTS
354 if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
355 xts_decrypt(ctx->handle, ctx->tweakhandle,
356 qcrypto_gcrypt_xts_encrypt,
357 qcrypto_gcrypt_xts_decrypt,
358 ctx->iv, len, out, in);
359 return 0;
360 }
361 #endif
362
363 err = gcry_cipher_decrypt(ctx->handle,
364 out, len,
365 in, len);
366 if (err != 0) {
367 error_setg(errp, "Cannot decrypt data: %s",
368 gcry_strerror(err));
369 return -1;
370 }
371
372 return 0;
373 }
374
375 static int
376 qcrypto_gcrypt_cipher_setiv(QCryptoCipher *cipher,
377 const uint8_t *iv, size_t niv,
378 Error **errp)
379 {
380 QCryptoCipherGcrypt *ctx = cipher->opaque;
381 gcry_error_t err;
382
383 if (niv != ctx->blocksize) {
384 error_setg(errp, "Expected IV size %zu not %zu",
385 ctx->blocksize, niv);
386 return -1;
387 }
388
389 #ifdef CONFIG_QEMU_PRIVATE_XTS
390 if (ctx->iv) {
391 memcpy(ctx->iv, iv, niv);
392 return 0;
393 }
394 #endif
395
396 if (cipher->mode == QCRYPTO_CIPHER_MODE_CTR) {
397 err = gcry_cipher_setctr(ctx->handle, iv, niv);
398 if (err != 0) {
399 error_setg(errp, "Cannot set Counter: %s",
400 gcry_strerror(err));
401 return -1;
402 }
403 } else {
404 gcry_cipher_reset(ctx->handle);
405 err = gcry_cipher_setiv(ctx->handle, iv, niv);
406 if (err != 0) {
407 error_setg(errp, "Cannot set IV: %s",
408 gcry_strerror(err));
409 return -1;
410 }
411 }
412
413 return 0;
414 }
415
416
417 static struct QCryptoCipherDriver qcrypto_cipher_lib_driver = {
418 .cipher_encrypt = qcrypto_gcrypt_cipher_encrypt,
419 .cipher_decrypt = qcrypto_gcrypt_cipher_decrypt,
420 .cipher_setiv = qcrypto_gcrypt_cipher_setiv,
421 .cipher_free = qcrypto_gcrypt_cipher_ctx_free,
422 };