qxl: check release info object
[qemu.git] / crypto / block.c
1 /*
2 * QEMU Crypto block device 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 #include "qapi/error.h"
23 #include "blockpriv.h"
24 #include "block-qcow.h"
25 #include "block-luks.h"
26
27 static const QCryptoBlockDriver *qcrypto_block_drivers[] = {
28 [Q_CRYPTO_BLOCK_FORMAT_QCOW] = &qcrypto_block_driver_qcow,
29 [Q_CRYPTO_BLOCK_FORMAT_LUKS] = &qcrypto_block_driver_luks,
30 };
31
32
33 bool qcrypto_block_has_format(QCryptoBlockFormat format,
34 const uint8_t *buf,
35 size_t len)
36 {
37 const QCryptoBlockDriver *driver;
38
39 if (format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
40 !qcrypto_block_drivers[format]) {
41 return false;
42 }
43
44 driver = qcrypto_block_drivers[format];
45
46 return driver->has_format(buf, len);
47 }
48
49
50 QCryptoBlock *qcrypto_block_open(QCryptoBlockOpenOptions *options,
51 const char *optprefix,
52 QCryptoBlockReadFunc readfunc,
53 void *opaque,
54 unsigned int flags,
55 size_t n_threads,
56 Error **errp)
57 {
58 QCryptoBlock *block = g_new0(QCryptoBlock, 1);
59
60 block->format = options->format;
61
62 if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
63 !qcrypto_block_drivers[options->format]) {
64 error_setg(errp, "Unsupported block driver %s",
65 QCryptoBlockFormat_str(options->format));
66 g_free(block);
67 return NULL;
68 }
69
70 block->driver = qcrypto_block_drivers[options->format];
71
72 if (block->driver->open(block, options, optprefix,
73 readfunc, opaque, flags, n_threads, errp) < 0)
74 {
75 g_free(block);
76 return NULL;
77 }
78
79 qemu_mutex_init(&block->mutex);
80
81 return block;
82 }
83
84
85 QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
86 const char *optprefix,
87 QCryptoBlockInitFunc initfunc,
88 QCryptoBlockWriteFunc writefunc,
89 void *opaque,
90 Error **errp)
91 {
92 QCryptoBlock *block = g_new0(QCryptoBlock, 1);
93
94 block->format = options->format;
95
96 if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
97 !qcrypto_block_drivers[options->format]) {
98 error_setg(errp, "Unsupported block driver %s",
99 QCryptoBlockFormat_str(options->format));
100 g_free(block);
101 return NULL;
102 }
103
104 block->driver = qcrypto_block_drivers[options->format];
105
106 if (block->driver->create(block, options, optprefix, initfunc,
107 writefunc, opaque, errp) < 0) {
108 g_free(block);
109 return NULL;
110 }
111
112 qemu_mutex_init(&block->mutex);
113
114 return block;
115 }
116
117
118 QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
119 Error **errp)
120 {
121 QCryptoBlockInfo *info = g_new0(QCryptoBlockInfo, 1);
122
123 info->format = block->format;
124
125 if (block->driver->get_info &&
126 block->driver->get_info(block, info, errp) < 0) {
127 g_free(info);
128 return NULL;
129 }
130
131 return info;
132 }
133
134
135 int qcrypto_block_decrypt(QCryptoBlock *block,
136 uint64_t offset,
137 uint8_t *buf,
138 size_t len,
139 Error **errp)
140 {
141 return block->driver->decrypt(block, offset, buf, len, errp);
142 }
143
144
145 int qcrypto_block_encrypt(QCryptoBlock *block,
146 uint64_t offset,
147 uint8_t *buf,
148 size_t len,
149 Error **errp)
150 {
151 return block->driver->encrypt(block, offset, buf, len, errp);
152 }
153
154
155 QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
156 {
157 /* Ciphers should be accessed through pop/push method to be thread-safe.
158 * Better, they should not be accessed externally at all (note, that
159 * pop/push are static functions)
160 * This function is used only in test with one thread (it's safe to skip
161 * pop/push interface), so it's enough to assert it here:
162 */
163 assert(block->n_ciphers <= 1);
164 return block->ciphers ? block->ciphers[0] : NULL;
165 }
166
167
168 static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
169 {
170 QCryptoCipher *cipher;
171
172 qemu_mutex_lock(&block->mutex);
173
174 assert(block->n_free_ciphers > 0);
175 block->n_free_ciphers--;
176 cipher = block->ciphers[block->n_free_ciphers];
177
178 qemu_mutex_unlock(&block->mutex);
179
180 return cipher;
181 }
182
183
184 static void qcrypto_block_push_cipher(QCryptoBlock *block,
185 QCryptoCipher *cipher)
186 {
187 qemu_mutex_lock(&block->mutex);
188
189 assert(block->n_free_ciphers < block->n_ciphers);
190 block->ciphers[block->n_free_ciphers] = cipher;
191 block->n_free_ciphers++;
192
193 qemu_mutex_unlock(&block->mutex);
194 }
195
196
197 int qcrypto_block_init_cipher(QCryptoBlock *block,
198 QCryptoCipherAlgorithm alg,
199 QCryptoCipherMode mode,
200 const uint8_t *key, size_t nkey,
201 size_t n_threads, Error **errp)
202 {
203 size_t i;
204
205 assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
206
207 block->ciphers = g_new0(QCryptoCipher *, n_threads);
208
209 for (i = 0; i < n_threads; i++) {
210 block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
211 if (!block->ciphers[i]) {
212 qcrypto_block_free_cipher(block);
213 return -1;
214 }
215 block->n_ciphers++;
216 block->n_free_ciphers++;
217 }
218
219 return 0;
220 }
221
222
223 void qcrypto_block_free_cipher(QCryptoBlock *block)
224 {
225 size_t i;
226
227 if (!block->ciphers) {
228 return;
229 }
230
231 assert(block->n_ciphers == block->n_free_ciphers);
232
233 for (i = 0; i < block->n_ciphers; i++) {
234 qcrypto_cipher_free(block->ciphers[i]);
235 }
236
237 g_free(block->ciphers);
238 block->ciphers = NULL;
239 block->n_ciphers = block->n_free_ciphers = 0;
240 }
241
242 QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
243 {
244 /* ivgen should be accessed under mutex. However, this function is used only
245 * in test with one thread, so it's enough to assert it here:
246 */
247 assert(block->n_ciphers <= 1);
248 return block->ivgen;
249 }
250
251
252 QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
253 {
254 return block->kdfhash;
255 }
256
257
258 uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
259 {
260 return block->payload_offset;
261 }
262
263
264 uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
265 {
266 return block->sector_size;
267 }
268
269
270 void qcrypto_block_free(QCryptoBlock *block)
271 {
272 if (!block) {
273 return;
274 }
275
276 block->driver->cleanup(block);
277
278 qcrypto_block_free_cipher(block);
279 qcrypto_ivgen_free(block->ivgen);
280 qemu_mutex_destroy(&block->mutex);
281 g_free(block);
282 }
283
284
285 typedef int (*QCryptoCipherEncDecFunc)(QCryptoCipher *cipher,
286 const void *in,
287 void *out,
288 size_t len,
289 Error **errp);
290
291 static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher,
292 size_t niv,
293 QCryptoIVGen *ivgen,
294 QemuMutex *ivgen_mutex,
295 int sectorsize,
296 uint64_t offset,
297 uint8_t *buf,
298 size_t len,
299 QCryptoCipherEncDecFunc func,
300 Error **errp)
301 {
302 uint8_t *iv;
303 int ret = -1;
304 uint64_t startsector = offset / sectorsize;
305
306 assert(QEMU_IS_ALIGNED(offset, sectorsize));
307 assert(QEMU_IS_ALIGNED(len, sectorsize));
308
309 iv = niv ? g_new0(uint8_t, niv) : NULL;
310
311 while (len > 0) {
312 size_t nbytes;
313 if (niv) {
314 if (ivgen_mutex) {
315 qemu_mutex_lock(ivgen_mutex);
316 }
317 ret = qcrypto_ivgen_calculate(ivgen, startsector, iv, niv, errp);
318 if (ivgen_mutex) {
319 qemu_mutex_unlock(ivgen_mutex);
320 }
321
322 if (ret < 0) {
323 goto cleanup;
324 }
325
326 if (qcrypto_cipher_setiv(cipher,
327 iv, niv,
328 errp) < 0) {
329 goto cleanup;
330 }
331 }
332
333 nbytes = len > sectorsize ? sectorsize : len;
334 if (func(cipher, buf, buf, nbytes, errp) < 0) {
335 goto cleanup;
336 }
337
338 startsector++;
339 buf += nbytes;
340 len -= nbytes;
341 }
342
343 ret = 0;
344 cleanup:
345 g_free(iv);
346 return ret;
347 }
348
349
350 int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
351 size_t niv,
352 QCryptoIVGen *ivgen,
353 int sectorsize,
354 uint64_t offset,
355 uint8_t *buf,
356 size_t len,
357 Error **errp)
358 {
359 return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
360 offset, buf, len,
361 qcrypto_cipher_decrypt, errp);
362 }
363
364
365 int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
366 size_t niv,
367 QCryptoIVGen *ivgen,
368 int sectorsize,
369 uint64_t offset,
370 uint8_t *buf,
371 size_t len,
372 Error **errp)
373 {
374 return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
375 offset, buf, len,
376 qcrypto_cipher_encrypt, errp);
377 }
378
379 int qcrypto_block_decrypt_helper(QCryptoBlock *block,
380 int sectorsize,
381 uint64_t offset,
382 uint8_t *buf,
383 size_t len,
384 Error **errp)
385 {
386 int ret;
387 QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
388
389 ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
390 &block->mutex, sectorsize, offset, buf,
391 len, qcrypto_cipher_decrypt, errp);
392
393 qcrypto_block_push_cipher(block, cipher);
394
395 return ret;
396 }
397
398 int qcrypto_block_encrypt_helper(QCryptoBlock *block,
399 int sectorsize,
400 uint64_t offset,
401 uint8_t *buf,
402 size_t len,
403 Error **errp)
404 {
405 int ret;
406 QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
407
408 ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
409 &block->mutex, sectorsize, offset, buf,
410 len, qcrypto_cipher_encrypt, errp);
411
412 qcrypto_block_push_cipher(block, cipher);
413
414 return ret;
415 }