tests/qapi/doc-good.json: Prepare for qapi-doc Sphinx extension
[qemu.git] / crypto / cipher-gcrypt.c.inc
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 #ifdef CONFIG_QEMU_PRIVATE_XTS
22 #include "crypto/xts.h"
23 #endif
24
25 #include <gcrypt.h>
26
27 bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
28                              QCryptoCipherMode mode)
29 {
30     switch (alg) {
31     case QCRYPTO_CIPHER_ALG_DES_RFB:
32     case QCRYPTO_CIPHER_ALG_3DES:
33     case QCRYPTO_CIPHER_ALG_AES_128:
34     case QCRYPTO_CIPHER_ALG_AES_192:
35     case QCRYPTO_CIPHER_ALG_AES_256:
36     case QCRYPTO_CIPHER_ALG_CAST5_128:
37     case QCRYPTO_CIPHER_ALG_SERPENT_128:
38     case QCRYPTO_CIPHER_ALG_SERPENT_192:
39     case QCRYPTO_CIPHER_ALG_SERPENT_256:
40     case QCRYPTO_CIPHER_ALG_TWOFISH_128:
41     case QCRYPTO_CIPHER_ALG_TWOFISH_256:
42         break;
43     default:
44         return false;
45     }
46
47     switch (mode) {
48     case QCRYPTO_CIPHER_MODE_ECB:
49     case QCRYPTO_CIPHER_MODE_CBC:
50     case QCRYPTO_CIPHER_MODE_XTS:
51     case QCRYPTO_CIPHER_MODE_CTR:
52         return true;
53     default:
54         return false;
55     }
56 }
57
58 typedef struct QCryptoCipherGcrypt {
59     QCryptoCipher base;
60     gcry_cipher_hd_t handle;
61     size_t blocksize;
62 #ifdef CONFIG_QEMU_PRIVATE_XTS
63     gcry_cipher_hd_t tweakhandle;
64     uint8_t iv[XTS_BLOCK_SIZE];
65 #endif
66 } QCryptoCipherGcrypt;
67
68
69 static void qcrypto_gcrypt_ctx_free(QCryptoCipher *cipher)
70 {
71     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
72
73     gcry_cipher_close(ctx->handle);
74     g_free(ctx);
75 }
76
77 static int qcrypto_gcrypt_encrypt(QCryptoCipher *cipher, const void *in,
78                                   void *out, size_t len, Error **errp)
79 {
80     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
81     gcry_error_t err;
82
83     if (len & (ctx->blocksize - 1)) {
84         error_setg(errp, "Length %zu must be a multiple of block size %zu",
85                    len, ctx->blocksize);
86         return -1;
87     }
88
89     err = gcry_cipher_encrypt(ctx->handle, out, len, in, len);
90     if (err != 0) {
91         error_setg(errp, "Cannot encrypt data: %s", gcry_strerror(err));
92         return -1;
93     }
94
95     return 0;
96 }
97
98
99 static int qcrypto_gcrypt_decrypt(QCryptoCipher *cipher, const void *in,
100                                   void *out, size_t len, Error **errp)
101 {
102     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
103     gcry_error_t err;
104
105     if (len & (ctx->blocksize - 1)) {
106         error_setg(errp, "Length %zu must be a multiple of block size %zu",
107                    len, ctx->blocksize);
108         return -1;
109     }
110
111     err = gcry_cipher_decrypt(ctx->handle, out, len, in, len);
112     if (err != 0) {
113         error_setg(errp, "Cannot decrypt data: %s",
114                    gcry_strerror(err));
115         return -1;
116     }
117
118     return 0;
119 }
120
121 static int qcrypto_gcrypt_setiv(QCryptoCipher *cipher,
122                                 const uint8_t *iv, size_t niv,
123                                 Error **errp)
124 {
125     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
126     gcry_error_t err;
127
128     if (niv != ctx->blocksize) {
129         error_setg(errp, "Expected IV size %zu not %zu",
130                    ctx->blocksize, niv);
131         return -1;
132     }
133
134     gcry_cipher_reset(ctx->handle);
135     err = gcry_cipher_setiv(ctx->handle, iv, niv);
136     if (err != 0) {
137         error_setg(errp, "Cannot set IV: %s", gcry_strerror(err));
138         return -1;
139     }
140
141     return 0;
142 }
143
144 static int qcrypto_gcrypt_ctr_setiv(QCryptoCipher *cipher,
145                                     const uint8_t *iv, size_t niv,
146                                     Error **errp)
147 {
148     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
149     gcry_error_t err;
150
151     if (niv != ctx->blocksize) {
152         error_setg(errp, "Expected IV size %zu not %zu",
153                    ctx->blocksize, niv);
154         return -1;
155     }
156
157     err = gcry_cipher_setctr(ctx->handle, iv, niv);
158     if (err != 0) {
159         error_setg(errp, "Cannot set Counter: %s", gcry_strerror(err));
160         return -1;
161     }
162
163     return 0;
164 }
165
166
167 static const struct QCryptoCipherDriver qcrypto_gcrypt_driver = {
168     .cipher_encrypt = qcrypto_gcrypt_encrypt,
169     .cipher_decrypt = qcrypto_gcrypt_decrypt,
170     .cipher_setiv = qcrypto_gcrypt_setiv,
171     .cipher_free = qcrypto_gcrypt_ctx_free,
172 };
173
174 static const struct QCryptoCipherDriver qcrypto_gcrypt_ctr_driver = {
175     .cipher_encrypt = qcrypto_gcrypt_encrypt,
176     .cipher_decrypt = qcrypto_gcrypt_decrypt,
177     .cipher_setiv = qcrypto_gcrypt_ctr_setiv,
178     .cipher_free = qcrypto_gcrypt_ctx_free,
179 };
180
181 #ifdef CONFIG_QEMU_PRIVATE_XTS
182 static void qcrypto_gcrypt_xts_ctx_free(QCryptoCipher *cipher)
183 {
184     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
185
186     gcry_cipher_close(ctx->tweakhandle);
187     qcrypto_gcrypt_ctx_free(cipher);
188 }
189
190 static void qcrypto_gcrypt_xts_wrape(const void *ctx, size_t length,
191                                      uint8_t *dst, const uint8_t *src)
192 {
193     gcry_error_t err;
194     err = gcry_cipher_encrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
195     g_assert(err == 0);
196 }
197
198 static void qcrypto_gcrypt_xts_wrapd(const void *ctx, size_t length,
199                                      uint8_t *dst, const uint8_t *src)
200 {
201     gcry_error_t err;
202     err = gcry_cipher_decrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
203     g_assert(err == 0);
204 }
205
206 static int qcrypto_gcrypt_xts_encrypt(QCryptoCipher *cipher, const void *in,
207                                       void *out, size_t len, Error **errp)
208 {
209     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
210
211     if (len & (ctx->blocksize - 1)) {
212         error_setg(errp, "Length %zu must be a multiple of block size %zu",
213                    len, ctx->blocksize);
214         return -1;
215     }
216
217     xts_encrypt(ctx->handle, ctx->tweakhandle,
218                 qcrypto_gcrypt_xts_wrape, qcrypto_gcrypt_xts_wrapd,
219                 ctx->iv, len, out, in);
220     return 0;
221 }
222
223 static int qcrypto_gcrypt_xts_decrypt(QCryptoCipher *cipher, const void *in,
224                                       void *out, size_t len, Error **errp)
225 {
226     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
227
228     if (len & (ctx->blocksize - 1)) {
229         error_setg(errp, "Length %zu must be a multiple of block size %zu",
230                    len, ctx->blocksize);
231         return -1;
232     }
233
234     xts_decrypt(ctx->handle, ctx->tweakhandle,
235                 qcrypto_gcrypt_xts_wrape, qcrypto_gcrypt_xts_wrapd,
236                 ctx->iv, len, out, in);
237     return 0;
238 }
239
240 static int qcrypto_gcrypt_xts_setiv(QCryptoCipher *cipher,
241                                     const uint8_t *iv, size_t niv,
242                                     Error **errp)
243 {
244     QCryptoCipherGcrypt *ctx = container_of(cipher, QCryptoCipherGcrypt, base);
245
246     if (niv != ctx->blocksize) {
247         error_setg(errp, "Expected IV size %zu not %zu",
248                    ctx->blocksize, niv);
249         return -1;
250     }
251
252     memcpy(ctx->iv, iv, niv);
253     return 0;
254 }
255
256 static const struct QCryptoCipherDriver qcrypto_gcrypt_xts_driver = {
257     .cipher_encrypt = qcrypto_gcrypt_xts_encrypt,
258     .cipher_decrypt = qcrypto_gcrypt_xts_decrypt,
259     .cipher_setiv = qcrypto_gcrypt_xts_setiv,
260     .cipher_free = qcrypto_gcrypt_xts_ctx_free,
261 };
262 #endif /* CONFIG_QEMU_PRIVATE_XTS */
263
264
265 static QCryptoCipher *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
266                                              QCryptoCipherMode mode,
267                                              const uint8_t *key,
268                                              size_t nkey,
269                                              Error **errp)
270 {
271     QCryptoCipherGcrypt *ctx;
272     const QCryptoCipherDriver *drv;
273     gcry_error_t err;
274     int gcryalg, gcrymode;
275
276     if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
277         return NULL;
278     }
279
280     switch (alg) {
281     case QCRYPTO_CIPHER_ALG_DES_RFB:
282         gcryalg = GCRY_CIPHER_DES;
283         break;
284     case QCRYPTO_CIPHER_ALG_3DES:
285         gcryalg = GCRY_CIPHER_3DES;
286         break;
287     case QCRYPTO_CIPHER_ALG_AES_128:
288         gcryalg = GCRY_CIPHER_AES128;
289         break;
290     case QCRYPTO_CIPHER_ALG_AES_192:
291         gcryalg = GCRY_CIPHER_AES192;
292         break;
293     case QCRYPTO_CIPHER_ALG_AES_256:
294         gcryalg = GCRY_CIPHER_AES256;
295         break;
296     case QCRYPTO_CIPHER_ALG_CAST5_128:
297         gcryalg = GCRY_CIPHER_CAST5;
298         break;
299     case QCRYPTO_CIPHER_ALG_SERPENT_128:
300         gcryalg = GCRY_CIPHER_SERPENT128;
301         break;
302     case QCRYPTO_CIPHER_ALG_SERPENT_192:
303         gcryalg = GCRY_CIPHER_SERPENT192;
304         break;
305     case QCRYPTO_CIPHER_ALG_SERPENT_256:
306         gcryalg = GCRY_CIPHER_SERPENT256;
307         break;
308     case QCRYPTO_CIPHER_ALG_TWOFISH_128:
309         gcryalg = GCRY_CIPHER_TWOFISH128;
310         break;
311     case QCRYPTO_CIPHER_ALG_TWOFISH_256:
312         gcryalg = GCRY_CIPHER_TWOFISH;
313         break;
314     default:
315         error_setg(errp, "Unsupported cipher algorithm %s",
316                    QCryptoCipherAlgorithm_str(alg));
317         return NULL;
318     }
319
320     drv = &qcrypto_gcrypt_driver;
321     switch (mode) {
322     case QCRYPTO_CIPHER_MODE_ECB:
323         gcrymode = GCRY_CIPHER_MODE_ECB;
324         break;
325     case QCRYPTO_CIPHER_MODE_XTS:
326 #ifdef CONFIG_QEMU_PRIVATE_XTS
327         drv = &qcrypto_gcrypt_xts_driver;
328         gcrymode = GCRY_CIPHER_MODE_ECB;
329 #else
330         gcrymode = GCRY_CIPHER_MODE_XTS;
331 #endif
332         break;
333     case QCRYPTO_CIPHER_MODE_CBC:
334         gcrymode = GCRY_CIPHER_MODE_CBC;
335         break;
336     case QCRYPTO_CIPHER_MODE_CTR:
337         drv = &qcrypto_gcrypt_ctr_driver;
338         gcrymode = GCRY_CIPHER_MODE_CTR;
339         break;
340     default:
341         error_setg(errp, "Unsupported cipher mode %s",
342                    QCryptoCipherMode_str(mode));
343         return NULL;
344     }
345
346     ctx = g_new0(QCryptoCipherGcrypt, 1);
347     ctx->base.driver = drv;
348
349     err = gcry_cipher_open(&ctx->handle, gcryalg, gcrymode, 0);
350     if (err != 0) {
351         error_setg(errp, "Cannot initialize cipher: %s",
352                    gcry_strerror(err));
353         goto error;
354     }
355     ctx->blocksize = gcry_cipher_get_algo_blklen(gcryalg);
356
357 #ifdef CONFIG_QEMU_PRIVATE_XTS
358     if (mode == QCRYPTO_CIPHER_MODE_XTS) {
359         if (ctx->blocksize != XTS_BLOCK_SIZE) {
360             error_setg(errp,
361                        "Cipher block size %zu must equal XTS block size %d",
362                        ctx->blocksize, XTS_BLOCK_SIZE);
363             goto error;
364         }
365         err = gcry_cipher_open(&ctx->tweakhandle, gcryalg, gcrymode, 0);
366         if (err != 0) {
367             error_setg(errp, "Cannot initialize cipher: %s",
368                        gcry_strerror(err));
369             goto error;
370         }
371     }
372 #endif
373
374     if (alg == QCRYPTO_CIPHER_ALG_DES_RFB) {
375         /* We're using standard DES cipher from gcrypt, so we need
376          * to munge the key so that the results are the same as the
377          * bizarre RFB variant of DES :-)
378          */
379         uint8_t *rfbkey = qcrypto_cipher_munge_des_rfb_key(key, nkey);
380         err = gcry_cipher_setkey(ctx->handle, rfbkey, nkey);
381         g_free(rfbkey);
382     } else {
383 #ifdef CONFIG_QEMU_PRIVATE_XTS
384         if (mode == QCRYPTO_CIPHER_MODE_XTS) {
385             nkey /= 2;
386             err = gcry_cipher_setkey(ctx->tweakhandle, key + nkey, nkey);
387             if (err != 0) {
388                 error_setg(errp, "Cannot set key: %s", gcry_strerror(err));
389                 goto error;
390             }
391         }
392 #endif
393         err = gcry_cipher_setkey(ctx->handle, key, nkey);
394     }
395     if (err != 0) {
396         error_setg(errp, "Cannot set key: %s", gcry_strerror(err));
397         goto error;
398     }
399
400     return &ctx->base;
401
402  error:
403 #ifdef CONFIG_QEMU_PRIVATE_XTS
404     gcry_cipher_close(ctx->tweakhandle);
405 #endif
406     gcry_cipher_close(ctx->handle);
407     g_free(ctx);
408     return NULL;
409 }