Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2017-03-16' into staging
[qemu.git] / block / crypto.c
1 /*
2 * QEMU block full disk encryption
3 *
4 * Copyright (c) 2015-2016 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 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
23 #include "block/block_int.h"
24 #include "sysemu/block-backend.h"
25 #include "crypto/block.h"
26 #include "qapi/opts-visitor.h"
27 #include "qapi-visit.h"
28 #include "qapi/error.h"
29
30 #define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret"
31 #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg"
32 #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode"
33 #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg"
34 #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg"
35 #define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg"
36 #define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time"
37
38 typedef struct BlockCrypto BlockCrypto;
39
40 struct BlockCrypto {
41 QCryptoBlock *block;
42 };
43
44
45 static int block_crypto_probe_generic(QCryptoBlockFormat format,
46 const uint8_t *buf,
47 int buf_size,
48 const char *filename)
49 {
50 if (qcrypto_block_has_format(format, buf, buf_size)) {
51 return 100;
52 } else {
53 return 0;
54 }
55 }
56
57
58 static ssize_t block_crypto_read_func(QCryptoBlock *block,
59 size_t offset,
60 uint8_t *buf,
61 size_t buflen,
62 Error **errp,
63 void *opaque)
64 {
65 BlockDriverState *bs = opaque;
66 ssize_t ret;
67
68 ret = bdrv_pread(bs->file, offset, buf, buflen);
69 if (ret < 0) {
70 error_setg_errno(errp, -ret, "Could not read encryption header");
71 return ret;
72 }
73 return ret;
74 }
75
76
77 struct BlockCryptoCreateData {
78 const char *filename;
79 QemuOpts *opts;
80 BlockBackend *blk;
81 uint64_t size;
82 };
83
84
85 static ssize_t block_crypto_write_func(QCryptoBlock *block,
86 size_t offset,
87 const uint8_t *buf,
88 size_t buflen,
89 Error **errp,
90 void *opaque)
91 {
92 struct BlockCryptoCreateData *data = opaque;
93 ssize_t ret;
94
95 ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
96 if (ret < 0) {
97 error_setg_errno(errp, -ret, "Could not write encryption header");
98 return ret;
99 }
100 return ret;
101 }
102
103
104 static ssize_t block_crypto_init_func(QCryptoBlock *block,
105 size_t headerlen,
106 Error **errp,
107 void *opaque)
108 {
109 struct BlockCryptoCreateData *data = opaque;
110 int ret;
111
112 /* User provided size should reflect amount of space made
113 * available to the guest, so we must take account of that
114 * which will be used by the crypto header
115 */
116 data->size += headerlen;
117
118 qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
119 ret = bdrv_create_file(data->filename, data->opts, errp);
120 if (ret < 0) {
121 return -1;
122 }
123
124 data->blk = blk_new_open(data->filename, NULL, NULL,
125 BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
126 if (!data->blk) {
127 return -1;
128 }
129
130 return 0;
131 }
132
133
134 static QemuOptsList block_crypto_runtime_opts_luks = {
135 .name = "crypto",
136 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
137 .desc = {
138 {
139 .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
140 .type = QEMU_OPT_STRING,
141 .help = "ID of the secret that provides the encryption key",
142 },
143 { /* end of list */ }
144 },
145 };
146
147
148 static QemuOptsList block_crypto_create_opts_luks = {
149 .name = "crypto",
150 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
151 .desc = {
152 {
153 .name = BLOCK_OPT_SIZE,
154 .type = QEMU_OPT_SIZE,
155 .help = "Virtual disk size"
156 },
157 {
158 .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
159 .type = QEMU_OPT_STRING,
160 .help = "ID of the secret that provides the encryption key",
161 },
162 {
163 .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG,
164 .type = QEMU_OPT_STRING,
165 .help = "Name of encryption cipher algorithm",
166 },
167 {
168 .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE,
169 .type = QEMU_OPT_STRING,
170 .help = "Name of encryption cipher mode",
171 },
172 {
173 .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG,
174 .type = QEMU_OPT_STRING,
175 .help = "Name of IV generator algorithm",
176 },
177 {
178 .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG,
179 .type = QEMU_OPT_STRING,
180 .help = "Name of IV generator hash algorithm",
181 },
182 {
183 .name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG,
184 .type = QEMU_OPT_STRING,
185 .help = "Name of encryption hash algorithm",
186 },
187 {
188 .name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME,
189 .type = QEMU_OPT_NUMBER,
190 .help = "Time to spend in PBKDF in milliseconds",
191 },
192 { /* end of list */ }
193 },
194 };
195
196
197 static QCryptoBlockOpenOptions *
198 block_crypto_open_opts_init(QCryptoBlockFormat format,
199 QemuOpts *opts,
200 Error **errp)
201 {
202 Visitor *v;
203 QCryptoBlockOpenOptions *ret = NULL;
204 Error *local_err = NULL;
205
206 ret = g_new0(QCryptoBlockOpenOptions, 1);
207 ret->format = format;
208
209 v = opts_visitor_new(opts);
210
211 visit_start_struct(v, NULL, NULL, 0, &local_err);
212 if (local_err) {
213 goto out;
214 }
215
216 switch (format) {
217 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
218 visit_type_QCryptoBlockOptionsLUKS_members(
219 v, &ret->u.luks, &local_err);
220 break;
221
222 default:
223 error_setg(&local_err, "Unsupported block format %d", format);
224 break;
225 }
226 if (!local_err) {
227 visit_check_struct(v, &local_err);
228 }
229
230 visit_end_struct(v, NULL);
231
232 out:
233 if (local_err) {
234 error_propagate(errp, local_err);
235 qapi_free_QCryptoBlockOpenOptions(ret);
236 ret = NULL;
237 }
238 visit_free(v);
239 return ret;
240 }
241
242
243 static QCryptoBlockCreateOptions *
244 block_crypto_create_opts_init(QCryptoBlockFormat format,
245 QemuOpts *opts,
246 Error **errp)
247 {
248 Visitor *v;
249 QCryptoBlockCreateOptions *ret = NULL;
250 Error *local_err = NULL;
251
252 ret = g_new0(QCryptoBlockCreateOptions, 1);
253 ret->format = format;
254
255 v = opts_visitor_new(opts);
256
257 visit_start_struct(v, NULL, NULL, 0, &local_err);
258 if (local_err) {
259 goto out;
260 }
261
262 switch (format) {
263 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
264 visit_type_QCryptoBlockCreateOptionsLUKS_members(
265 v, &ret->u.luks, &local_err);
266 break;
267
268 default:
269 error_setg(&local_err, "Unsupported block format %d", format);
270 break;
271 }
272 if (!local_err) {
273 visit_check_struct(v, &local_err);
274 }
275
276 visit_end_struct(v, NULL);
277
278 out:
279 if (local_err) {
280 error_propagate(errp, local_err);
281 qapi_free_QCryptoBlockCreateOptions(ret);
282 ret = NULL;
283 }
284 visit_free(v);
285 return ret;
286 }
287
288
289 static int block_crypto_open_generic(QCryptoBlockFormat format,
290 QemuOptsList *opts_spec,
291 BlockDriverState *bs,
292 QDict *options,
293 int flags,
294 Error **errp)
295 {
296 BlockCrypto *crypto = bs->opaque;
297 QemuOpts *opts = NULL;
298 Error *local_err = NULL;
299 int ret = -EINVAL;
300 QCryptoBlockOpenOptions *open_opts = NULL;
301 unsigned int cflags = 0;
302
303 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
304 false, errp);
305 if (!bs->file) {
306 return -EINVAL;
307 }
308
309 opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
310 qemu_opts_absorb_qdict(opts, options, &local_err);
311 if (local_err) {
312 error_propagate(errp, local_err);
313 goto cleanup;
314 }
315
316 open_opts = block_crypto_open_opts_init(format, opts, errp);
317 if (!open_opts) {
318 goto cleanup;
319 }
320
321 if (flags & BDRV_O_NO_IO) {
322 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
323 }
324 crypto->block = qcrypto_block_open(open_opts,
325 block_crypto_read_func,
326 bs,
327 cflags,
328 errp);
329
330 if (!crypto->block) {
331 ret = -EIO;
332 goto cleanup;
333 }
334
335 bs->encrypted = true;
336 bs->valid_key = true;
337
338 ret = 0;
339 cleanup:
340 qapi_free_QCryptoBlockOpenOptions(open_opts);
341 return ret;
342 }
343
344
345 static int block_crypto_create_generic(QCryptoBlockFormat format,
346 const char *filename,
347 QemuOpts *opts,
348 Error **errp)
349 {
350 int ret = -EINVAL;
351 QCryptoBlockCreateOptions *create_opts = NULL;
352 QCryptoBlock *crypto = NULL;
353 struct BlockCryptoCreateData data = {
354 .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
355 BDRV_SECTOR_SIZE),
356 .opts = opts,
357 .filename = filename,
358 };
359
360 create_opts = block_crypto_create_opts_init(format, opts, errp);
361 if (!create_opts) {
362 return -1;
363 }
364
365 crypto = qcrypto_block_create(create_opts,
366 block_crypto_init_func,
367 block_crypto_write_func,
368 &data,
369 errp);
370
371 if (!crypto) {
372 ret = -EIO;
373 goto cleanup;
374 }
375
376 ret = 0;
377 cleanup:
378 qcrypto_block_free(crypto);
379 blk_unref(data.blk);
380 qapi_free_QCryptoBlockCreateOptions(create_opts);
381 return ret;
382 }
383
384 static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
385 {
386 BlockCrypto *crypto = bs->opaque;
387 size_t payload_offset =
388 qcrypto_block_get_payload_offset(crypto->block);
389
390 offset += payload_offset;
391
392 return bdrv_truncate(bs->file, offset);
393 }
394
395 static void block_crypto_close(BlockDriverState *bs)
396 {
397 BlockCrypto *crypto = bs->opaque;
398 qcrypto_block_free(crypto->block);
399 }
400
401
402 #define BLOCK_CRYPTO_MAX_SECTORS 32
403
404 static coroutine_fn int
405 block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num,
406 int remaining_sectors, QEMUIOVector *qiov)
407 {
408 BlockCrypto *crypto = bs->opaque;
409 int cur_nr_sectors; /* number of sectors in current iteration */
410 uint64_t bytes_done = 0;
411 uint8_t *cipher_data = NULL;
412 QEMUIOVector hd_qiov;
413 int ret = 0;
414 size_t payload_offset =
415 qcrypto_block_get_payload_offset(crypto->block) / 512;
416
417 qemu_iovec_init(&hd_qiov, qiov->niov);
418
419 /* Bounce buffer so we have a linear mem region for
420 * entire sector. XXX optimize so we avoid bounce
421 * buffer in case that qiov->niov == 1
422 */
423 cipher_data =
424 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
425 qiov->size));
426 if (cipher_data == NULL) {
427 ret = -ENOMEM;
428 goto cleanup;
429 }
430
431 while (remaining_sectors) {
432 cur_nr_sectors = remaining_sectors;
433
434 if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
435 cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
436 }
437
438 qemu_iovec_reset(&hd_qiov);
439 qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
440
441 ret = bdrv_co_readv(bs->file,
442 payload_offset + sector_num,
443 cur_nr_sectors, &hd_qiov);
444 if (ret < 0) {
445 goto cleanup;
446 }
447
448 if (qcrypto_block_decrypt(crypto->block,
449 sector_num,
450 cipher_data, cur_nr_sectors * 512,
451 NULL) < 0) {
452 ret = -EIO;
453 goto cleanup;
454 }
455
456 qemu_iovec_from_buf(qiov, bytes_done,
457 cipher_data, cur_nr_sectors * 512);
458
459 remaining_sectors -= cur_nr_sectors;
460 sector_num += cur_nr_sectors;
461 bytes_done += cur_nr_sectors * 512;
462 }
463
464 cleanup:
465 qemu_iovec_destroy(&hd_qiov);
466 qemu_vfree(cipher_data);
467
468 return ret;
469 }
470
471
472 static coroutine_fn int
473 block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num,
474 int remaining_sectors, QEMUIOVector *qiov)
475 {
476 BlockCrypto *crypto = bs->opaque;
477 int cur_nr_sectors; /* number of sectors in current iteration */
478 uint64_t bytes_done = 0;
479 uint8_t *cipher_data = NULL;
480 QEMUIOVector hd_qiov;
481 int ret = 0;
482 size_t payload_offset =
483 qcrypto_block_get_payload_offset(crypto->block) / 512;
484
485 qemu_iovec_init(&hd_qiov, qiov->niov);
486
487 /* Bounce buffer so we have a linear mem region for
488 * entire sector. XXX optimize so we avoid bounce
489 * buffer in case that qiov->niov == 1
490 */
491 cipher_data =
492 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
493 qiov->size));
494 if (cipher_data == NULL) {
495 ret = -ENOMEM;
496 goto cleanup;
497 }
498
499 while (remaining_sectors) {
500 cur_nr_sectors = remaining_sectors;
501
502 if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
503 cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
504 }
505
506 qemu_iovec_to_buf(qiov, bytes_done,
507 cipher_data, cur_nr_sectors * 512);
508
509 if (qcrypto_block_encrypt(crypto->block,
510 sector_num,
511 cipher_data, cur_nr_sectors * 512,
512 NULL) < 0) {
513 ret = -EIO;
514 goto cleanup;
515 }
516
517 qemu_iovec_reset(&hd_qiov);
518 qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
519
520 ret = bdrv_co_writev(bs->file,
521 payload_offset + sector_num,
522 cur_nr_sectors, &hd_qiov);
523 if (ret < 0) {
524 goto cleanup;
525 }
526
527 remaining_sectors -= cur_nr_sectors;
528 sector_num += cur_nr_sectors;
529 bytes_done += cur_nr_sectors * 512;
530 }
531
532 cleanup:
533 qemu_iovec_destroy(&hd_qiov);
534 qemu_vfree(cipher_data);
535
536 return ret;
537 }
538
539
540 static int64_t block_crypto_getlength(BlockDriverState *bs)
541 {
542 BlockCrypto *crypto = bs->opaque;
543 int64_t len = bdrv_getlength(bs->file->bs);
544
545 ssize_t offset = qcrypto_block_get_payload_offset(crypto->block);
546
547 len -= offset;
548
549 return len;
550 }
551
552
553 static int block_crypto_probe_luks(const uint8_t *buf,
554 int buf_size,
555 const char *filename) {
556 return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
557 buf, buf_size, filename);
558 }
559
560 static int block_crypto_open_luks(BlockDriverState *bs,
561 QDict *options,
562 int flags,
563 Error **errp)
564 {
565 return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
566 &block_crypto_runtime_opts_luks,
567 bs, options, flags, errp);
568 }
569
570 static int block_crypto_create_luks(const char *filename,
571 QemuOpts *opts,
572 Error **errp)
573 {
574 return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
575 filename, opts, errp);
576 }
577
578 static int block_crypto_get_info_luks(BlockDriverState *bs,
579 BlockDriverInfo *bdi)
580 {
581 BlockDriverInfo subbdi;
582 int ret;
583
584 ret = bdrv_get_info(bs->file->bs, &subbdi);
585 if (ret != 0) {
586 return ret;
587 }
588
589 bdi->unallocated_blocks_are_zero = false;
590 bdi->can_write_zeroes_with_unmap = false;
591 bdi->cluster_size = subbdi.cluster_size;
592
593 return 0;
594 }
595
596 static ImageInfoSpecific *
597 block_crypto_get_specific_info_luks(BlockDriverState *bs)
598 {
599 BlockCrypto *crypto = bs->opaque;
600 ImageInfoSpecific *spec_info;
601 QCryptoBlockInfo *info;
602
603 info = qcrypto_block_get_info(crypto->block, NULL);
604 if (!info) {
605 return NULL;
606 }
607 if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
608 qapi_free_QCryptoBlockInfo(info);
609 return NULL;
610 }
611
612 spec_info = g_new(ImageInfoSpecific, 1);
613 spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
614 spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
615 *spec_info->u.luks.data = info->u.luks;
616
617 /* Blank out pointers we've just stolen to avoid double free */
618 memset(&info->u.luks, 0, sizeof(info->u.luks));
619
620 qapi_free_QCryptoBlockInfo(info);
621
622 return spec_info;
623 }
624
625 BlockDriver bdrv_crypto_luks = {
626 .format_name = "luks",
627 .instance_size = sizeof(BlockCrypto),
628 .bdrv_probe = block_crypto_probe_luks,
629 .bdrv_open = block_crypto_open_luks,
630 .bdrv_close = block_crypto_close,
631 .bdrv_child_perm = bdrv_format_default_perms,
632 .bdrv_create = block_crypto_create_luks,
633 .bdrv_truncate = block_crypto_truncate,
634 .create_opts = &block_crypto_create_opts_luks,
635
636 .bdrv_co_readv = block_crypto_co_readv,
637 .bdrv_co_writev = block_crypto_co_writev,
638 .bdrv_getlength = block_crypto_getlength,
639 .bdrv_get_info = block_crypto_get_info_luks,
640 .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
641 };
642
643 static void block_crypto_init(void)
644 {
645 bdrv_register(&bdrv_crypto_luks);
646 }
647
648 block_init(block_crypto_init);