xref: /qemu/crypto/block.c (revision abff1abf) 
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.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 #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 static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
119         size_t headerlen, void *opaque, Error **errp)
120 {
121     size_t *headerlenp = opaque;
122 
123     /* Stash away the payload size */
124     *headerlenp = headerlen;
125     return 0;
126 }
127 
128 
129 static ssize_t qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
130         size_t offset, const uint8_t *buf, size_t buflen,
131         void *opaque, Error **errp)
132 {
133     /* Discard the bytes, we're not actually writing to an image */
134     return buflen;
135 }
136 
137 
138 bool
139 qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
140                                        const char *optprefix,
141                                        size_t *len,
142                                        Error **errp)
143 {
144     /* Fake LUKS creation in order to determine the payload size */
145     g_autoptr(QCryptoBlock) crypto =
146         qcrypto_block_create(create_opts, optprefix,
147                              qcrypto_block_headerlen_hdr_init_func,
148                              qcrypto_block_headerlen_hdr_write_func,
149                              len, errp);
150     return crypto != NULL;
151 }
152 
153 int qcrypto_block_amend_options(QCryptoBlock *block,
154                                 QCryptoBlockReadFunc readfunc,
155                                 QCryptoBlockWriteFunc writefunc,
156                                 void *opaque,
157                                 QCryptoBlockAmendOptions *options,
158                                 bool force,
159                                 Error **errp)
160 {
161     if (options->format != block->format) {
162         error_setg(errp,
163                    "Cannot amend encryption format");
164         return -1;
165     }
166 
167     if (!block->driver->amend) {
168         error_setg(errp,
169                    "Crypto format %s doesn't support format options amendment",
170                    QCryptoBlockFormat_str(block->format));
171         return -1;
172     }
173 
174     return block->driver->amend(block,
175                                 readfunc,
176                                 writefunc,
177                                 opaque,
178                                 options,
179                                 force,
180                                 errp);
181 }
182 
183 QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
184                                          Error **errp)
185 {
186     QCryptoBlockInfo *info = g_new0(QCryptoBlockInfo, 1);
187 
188     info->format = block->format;
189 
190     if (block->driver->get_info &&
191         block->driver->get_info(block, info, errp) < 0) {
192         g_free(info);
193         return NULL;
194     }
195 
196     return info;
197 }
198 
199 
200 int qcrypto_block_decrypt(QCryptoBlock *block,
201                           uint64_t offset,
202                           uint8_t *buf,
203                           size_t len,
204                           Error **errp)
205 {
206     return block->driver->decrypt(block, offset, buf, len, errp);
207 }
208 
209 
210 int qcrypto_block_encrypt(QCryptoBlock *block,
211                           uint64_t offset,
212                           uint8_t *buf,
213                           size_t len,
214                           Error **errp)
215 {
216     return block->driver->encrypt(block, offset, buf, len, errp);
217 }
218 
219 
220 QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
221 {
222     /* Ciphers should be accessed through pop/push method to be thread-safe.
223      * Better, they should not be accessed externally at all (note, that
224      * pop/push are static functions)
225      * This function is used only in test with one thread (it's safe to skip
226      * pop/push interface), so it's enough to assert it here:
227      */
228     assert(block->n_ciphers <= 1);
229     return block->ciphers ? block->ciphers[0] : NULL;
230 }
231 
232 
233 static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
234 {
235     QCryptoCipher *cipher;
236 
237     qemu_mutex_lock(&block->mutex);
238 
239     assert(block->n_free_ciphers > 0);
240     block->n_free_ciphers--;
241     cipher = block->ciphers[block->n_free_ciphers];
242 
243     qemu_mutex_unlock(&block->mutex);
244 
245     return cipher;
246 }
247 
248 
249 static void qcrypto_block_push_cipher(QCryptoBlock *block,
250                                       QCryptoCipher *cipher)
251 {
252     qemu_mutex_lock(&block->mutex);
253 
254     assert(block->n_free_ciphers < block->n_ciphers);
255     block->ciphers[block->n_free_ciphers] = cipher;
256     block->n_free_ciphers++;
257 
258     qemu_mutex_unlock(&block->mutex);
259 }
260 
261 
262 int qcrypto_block_init_cipher(QCryptoBlock *block,
263                               QCryptoCipherAlgorithm alg,
264                               QCryptoCipherMode mode,
265                               const uint8_t *key, size_t nkey,
266                               size_t n_threads, Error **errp)
267 {
268     size_t i;
269 
270     assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
271 
272     block->ciphers = g_new0(QCryptoCipher *, n_threads);
273 
274     for (i = 0; i < n_threads; i++) {
275         block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
276         if (!block->ciphers[i]) {
277             qcrypto_block_free_cipher(block);
278             return -1;
279         }
280         block->n_ciphers++;
281         block->n_free_ciphers++;
282     }
283 
284     return 0;
285 }
286 
287 
288 void qcrypto_block_free_cipher(QCryptoBlock *block)
289 {
290     size_t i;
291 
292     if (!block->ciphers) {
293         return;
294     }
295 
296     assert(block->n_ciphers == block->n_free_ciphers);
297 
298     for (i = 0; i < block->n_ciphers; i++) {
299         qcrypto_cipher_free(block->ciphers[i]);
300     }
301 
302     g_free(block->ciphers);
303     block->ciphers = NULL;
304     block->n_ciphers = block->n_free_ciphers = 0;
305 }
306 
307 QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
308 {
309     /* ivgen should be accessed under mutex. However, this function is used only
310      * in test with one thread, so it's enough to assert it here:
311      */
312     assert(block->n_ciphers <= 1);
313     return block->ivgen;
314 }
315 
316 
317 QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
318 {
319     return block->kdfhash;
320 }
321 
322 
323 uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
324 {
325     return block->payload_offset;
326 }
327 
328 
329 uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
330 {
331     return block->sector_size;
332 }
333 
334 
335 void qcrypto_block_free(QCryptoBlock *block)
336 {
337     if (!block) {
338         return;
339     }
340 
341     block->driver->cleanup(block);
342 
343     qcrypto_block_free_cipher(block);
344     qcrypto_ivgen_free(block->ivgen);
345     qemu_mutex_destroy(&block->mutex);
346     g_free(block);
347 }
348 
349 
350 typedef int (*QCryptoCipherEncDecFunc)(QCryptoCipher *cipher,
351                                         const void *in,
352                                         void *out,
353                                         size_t len,
354                                         Error **errp);
355 
356 static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher,
357                                           size_t niv,
358                                           QCryptoIVGen *ivgen,
359                                           QemuMutex *ivgen_mutex,
360                                           int sectorsize,
361                                           uint64_t offset,
362                                           uint8_t *buf,
363                                           size_t len,
364                                           QCryptoCipherEncDecFunc func,
365                                           Error **errp)
366 {
367     g_autofree uint8_t *iv = niv ? g_new0(uint8_t, niv) : NULL;
368     int ret = -1;
369     uint64_t startsector = offset / sectorsize;
370 
371     assert(QEMU_IS_ALIGNED(offset, sectorsize));
372     assert(QEMU_IS_ALIGNED(len, sectorsize));
373 
374     while (len > 0) {
375         size_t nbytes;
376         if (niv) {
377             if (ivgen_mutex) {
378                 qemu_mutex_lock(ivgen_mutex);
379             }
380             ret = qcrypto_ivgen_calculate(ivgen, startsector, iv, niv, errp);
381             if (ivgen_mutex) {
382                 qemu_mutex_unlock(ivgen_mutex);
383             }
384 
385             if (ret < 0) {
386                 return -1;
387             }
388 
389             if (qcrypto_cipher_setiv(cipher,
390                                      iv, niv,
391                                      errp) < 0) {
392                 return -1;
393             }
394         }
395 
396         nbytes = len > sectorsize ? sectorsize : len;
397         if (func(cipher, buf, buf, nbytes, errp) < 0) {
398             return -1;
399         }
400 
401         startsector++;
402         buf += nbytes;
403         len -= nbytes;
404     }
405 
406     return 0;
407 }
408 
409 
410 int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
411                                         size_t niv,
412                                         QCryptoIVGen *ivgen,
413                                         int sectorsize,
414                                         uint64_t offset,
415                                         uint8_t *buf,
416                                         size_t len,
417                                         Error **errp)
418 {
419     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
420                                           offset, buf, len,
421                                           qcrypto_cipher_decrypt, errp);
422 }
423 
424 
425 int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
426                                         size_t niv,
427                                         QCryptoIVGen *ivgen,
428                                         int sectorsize,
429                                         uint64_t offset,
430                                         uint8_t *buf,
431                                         size_t len,
432                                         Error **errp)
433 {
434     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
435                                           offset, buf, len,
436                                           qcrypto_cipher_encrypt, errp);
437 }
438 
439 int qcrypto_block_decrypt_helper(QCryptoBlock *block,
440                                  int sectorsize,
441                                  uint64_t offset,
442                                  uint8_t *buf,
443                                  size_t len,
444                                  Error **errp)
445 {
446     int ret;
447     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
448 
449     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
450                                          &block->mutex, sectorsize, offset, buf,
451                                          len, qcrypto_cipher_decrypt, errp);
452 
453     qcrypto_block_push_cipher(block, cipher);
454 
455     return ret;
456 }
457 
458 int qcrypto_block_encrypt_helper(QCryptoBlock *block,
459                                  int sectorsize,
460                                  uint64_t offset,
461                                  uint8_t *buf,
462                                  size_t len,
463                                  Error **errp)
464 {
465     int ret;
466     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
467 
468     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
469                                          &block->mutex, sectorsize, offset, buf,
470                                          len, qcrypto_cipher_encrypt, errp);
471 
472     qcrypto_block_push_cipher(block, cipher);
473 
474     return ret;
475 }
476