dm_target_crypt - fix logic for xts support
[dragonfly.git] / sys / dev / disk / dm / dm_target_crypt.c
1 /*
2  * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Alex Hornung <ahornung@gmail.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 /*
36  * This file implements initial version of device-mapper crypt target.
37  */
38 #include <sys/types.h>
39 #include <sys/param.h>
40 #include <sys/endian.h>
41
42 #include <sys/bio.h>
43 #include <sys/buf.h>
44 #include <sys/malloc.h>
45 #include <sys/md5.h>
46 #include <sys/vnode.h>
47 #include <crypto/sha1.h>
48 #include <crypto/sha2/sha2.h>
49 #include <opencrypto/cryptodev.h>
50 #include <opencrypto/rmd160.h>
51 #include <machine/cpufunc.h>
52
53 #include "dm.h"
54 MALLOC_DEFINE(M_DMCRYPT, "dm_crypt", "Device Mapper Target Crypt");
55
56 struct target_crypt_config;
57
58 typedef void dispatch_t(void *);
59 typedef void ivgen_t(struct target_crypt_config *, u_int8_t *, size_t, off_t,
60     void *);
61
62 typedef int ivgen_ctor_t(struct target_crypt_config *, char *, void **);
63 typedef int ivgen_dtor_t(struct target_crypt_config *, void *);
64
65 struct iv_generator {
66         const char      *name;
67         ivgen_ctor_t    *ctor;
68         ivgen_dtor_t    *dtor;
69         ivgen_t         *gen_iv;
70 };
71
72 struct essiv_ivgen_priv {
73         struct cryptoini        crypto_session;
74         struct objcache *crp_crd_cache;
75         u_int64_t       crypto_sid;
76         size_t          keyhash_len;
77         u_int8_t        crypto_keyhash[SHA512_DIGEST_LENGTH];
78 };
79
80 typedef struct target_crypt_config {
81         size_t  params_len;
82         dm_pdev_t *pdev;
83         char    *status_str;
84         int     crypto_alg;
85         int     crypto_klen;
86         u_int8_t        crypto_key[512>>3];
87         
88         u_int64_t       crypto_sid;
89         u_int64_t       block_offset;
90         u_int64_t       iv_offset;
91         SHA512_CTX      essivsha512_ctx;
92
93         struct cryptoini        crypto_session;
94
95         struct iv_generator     *ivgen;
96         void    *ivgen_priv;
97 } dm_target_crypt_config_t;
98
99 struct dmtc_helper {
100         caddr_t free_addr;
101         caddr_t orig_buf;
102         caddr_t data_buf;
103 };
104
105 static void dmtc_crypto_dispatch(void *arg);
106 static void dmtc_crypto_read_start(dm_target_crypt_config_t *priv,
107                                 struct bio *bio);
108 static void dmtc_crypto_write_start(dm_target_crypt_config_t *priv,
109                                 struct bio *bio);
110 static void dmtc_bio_read_done(struct bio *bio);
111 static void dmtc_bio_write_done(struct bio *bio);
112 static int dmtc_crypto_cb_read_done(struct cryptop *crp);
113 static int dmtc_crypto_cb_write_done(struct cryptop *crp);
114
115 static ivgen_ctor_t     essiv_ivgen_ctor;
116 static ivgen_dtor_t     essiv_ivgen_dtor;
117 static ivgen_t          essiv_ivgen;
118 static ivgen_t          plain_ivgen;
119
120 static struct iv_generator ivgens[] = {
121         { .name = "essiv", .ctor = essiv_ivgen_ctor, .dtor = essiv_ivgen_dtor,
122             .gen_iv = essiv_ivgen },
123         { .name = "plain", .ctor = NULL, .dtor = NULL, .gen_iv = plain_ivgen },
124         { NULL, NULL, NULL, NULL }
125 };
126
127 struct objcache_malloc_args essiv_ivgen_malloc_args = {
128                 2*sizeof(void *) + (sizeof(struct cryptodesc) +
129                 sizeof(struct cryptop)), M_DMCRYPT };
130
131 /*
132  * Overwrite private information (in buf) to avoid leaking it
133  */
134 static void
135 dmtc_crypto_clear(void *buf, size_t len)
136 {
137         memset(buf, 0xFF, len);
138         bzero(buf, len);
139 }
140
141 /*
142  * ESSIV IV Generator Routines
143  */
144 static int 
145 essiv_ivgen_ctor(struct target_crypt_config *priv, char *iv_hash, void **p_ivpriv)
146 {
147         struct essiv_ivgen_priv *ivpriv;
148         u_int8_t crypto_keyhash[SHA512_DIGEST_LENGTH];
149         unsigned int klen;
150         int error;
151
152         klen = (priv->crypto_klen >> 3);
153
154         if (iv_hash == NULL)
155                 return EINVAL;
156
157         if (!strcmp(iv_hash, "sha1")) {
158                 SHA1_CTX ctx;
159
160                 if (klen != SHA1_RESULTLEN)
161                         return EINVAL;
162
163                 SHA1Init(&ctx);
164                 SHA1Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
165                 SHA1Final(crypto_keyhash, &ctx);
166         } else if (!strcmp(iv_hash, "sha256")) {
167                 SHA256_CTX ctx;
168
169                 if (klen != SHA256_DIGEST_LENGTH)
170                         return EINVAL;
171
172                 SHA256_Init(&ctx);
173                 SHA256_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
174                 SHA256_Final(crypto_keyhash, &ctx);
175         } else if (!strcmp(iv_hash, "sha384")) {
176                 SHA384_CTX ctx;
177
178                 if (klen != SHA384_DIGEST_LENGTH)
179                         return EINVAL;
180
181                 SHA384_Init(&ctx);
182                 SHA384_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
183                 SHA384_Final(crypto_keyhash, &ctx);
184         } else if (!strcmp(iv_hash, "sha512")) {
185                 SHA512_CTX ctx;
186
187                 if (klen != SHA512_DIGEST_LENGTH)
188                         return EINVAL;
189
190                 SHA512_Init(&ctx);
191                 SHA512_Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
192                 SHA512_Final(crypto_keyhash, &ctx);
193         } else if (!strcmp(iv_hash, "md5")) {
194                 MD5_CTX ctx;
195
196                 if (klen != MD5_DIGEST_LENGTH)
197                         return EINVAL;
198
199                 MD5Init(&ctx);
200                 MD5Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
201                 MD5Final(crypto_keyhash, &ctx);
202         } else if (!strcmp(iv_hash, "rmd160") ||
203                    !strcmp(iv_hash, "ripemd160")) {
204                 RMD160_CTX ctx;
205
206                 if (klen != (160/8))
207                         return EINVAL;
208
209                 RMD160Init(&ctx);
210                 RMD160Update(&ctx, priv->crypto_key, priv->crypto_klen>>3);
211                 RMD160Final(crypto_keyhash, &ctx);
212         } else {
213                 return EINVAL;
214         }
215
216         ivpriv = kmalloc(sizeof(struct essiv_ivgen_priv), M_DMCRYPT,
217             M_WAITOK | M_ZERO);
218         memcpy(ivpriv->crypto_keyhash, crypto_keyhash, sizeof(crypto_keyhash));
219         ivpriv->keyhash_len = sizeof(crypto_keyhash);
220         dmtc_crypto_clear(crypto_keyhash, sizeof(crypto_keyhash));
221
222         ivpriv->crypto_session.cri_alg = priv->crypto_alg;
223         ivpriv->crypto_session.cri_key = (u_int8_t *)ivpriv->crypto_keyhash;
224         ivpriv->crypto_session.cri_klen = priv->crypto_klen;
225         ivpriv->crypto_session.cri_mlen = 0;
226         ivpriv->crypto_session.cri_next = NULL;
227
228         error = crypto_newsession(&ivpriv->crypto_sid,
229                                   &ivpriv->crypto_session,
230                                   CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_HARDWARE);
231         if (error) {
232                 kprintf("dm_target_crypt: Error during crypto_newsession "
233                         "for essiv_ivgen, error = %d\n",
234                         error);
235                 dmtc_crypto_clear(ivpriv->crypto_keyhash, ivpriv->keyhash_len);
236                 kfree(ivpriv, M_DMCRYPT);
237                 return ENOTSUP;
238         }
239
240         ivpriv->crp_crd_cache = objcache_create(
241             "dmcrypt-essiv-cache", 0, 0,
242             NULL, NULL, NULL,
243             objcache_malloc_alloc,
244             objcache_malloc_free,
245             &essiv_ivgen_malloc_args );
246
247         *p_ivpriv = ivpriv;
248         return 0;
249 }
250
251 static int 
252 essiv_ivgen_dtor(struct target_crypt_config *priv, void *arg)
253 {
254         struct essiv_ivgen_priv *ivpriv;
255
256         ivpriv = (struct essiv_ivgen_priv *)arg;
257         KKASSERT(ivpriv != NULL);
258
259         crypto_freesession(ivpriv->crypto_sid);
260
261         objcache_destroy(ivpriv->crp_crd_cache);
262
263         dmtc_crypto_clear(ivpriv->crypto_keyhash, ivpriv->keyhash_len);
264         kfree(ivpriv, M_DMCRYPT);
265
266         return 0;
267 }
268
269 static int
270 essiv_ivgen_done(struct cryptop *crp)
271 {
272         struct essiv_ivgen_priv *ivpriv;
273         void *free_addr;
274         void *opaque;
275
276         if (crp->crp_etype == EAGAIN)
277                 return crypto_dispatch(crp);
278
279         if (crp->crp_etype != 0) {
280                 kprintf("dm_target_crypt: essiv_ivgen_done, "
281                         "crp->crp_etype = %d\n", crp->crp_etype);
282         }
283
284         free_addr = crp->crp_opaque;
285         /*
286          * In-memory structure is:
287          * |  ivpriv  |  opaque  |     crp     |      crd      |
288          * | (void *) | (void *) |   (cryptop) |  (cryptodesc) |
289          */
290         ivpriv = *((struct essiv_ivgen_priv **)crp->crp_opaque);
291         crp->crp_opaque += sizeof(void *);
292         opaque = *((void **)crp->crp_opaque);
293         
294         objcache_put(ivpriv->crp_crd_cache, free_addr);
295         dmtc_crypto_dispatch(opaque);
296         return 0;
297 }
298
299 static void
300 essiv_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv,
301             size_t iv_len, off_t sector, void *opaque)
302 {
303         struct essiv_ivgen_priv *ivpriv;
304         struct cryptodesc *crd;
305         struct cryptop *crp;
306         caddr_t space, alloc_addr;
307         int error;
308
309         ivpriv = priv->ivgen_priv;
310         KKASSERT(ivpriv != NULL);
311
312         /*
313          * In-memory structure is:
314          * |  ivpriv  |  opaque  |     crp     |      crd      |
315          * | (void *) | (void *) |   (cryptop) |  (cryptodesc) |
316          */
317         alloc_addr = space = objcache_get(ivpriv->crp_crd_cache, M_WAITOK);
318         *((struct essiv_ivgen_priv **)space) = ivpriv;
319         space += sizeof(void *);
320         *((void **)space) = opaque;
321         space += sizeof(void *);
322         crp = (struct cryptop *)space;
323         space += sizeof(struct cryptop);
324         crd = (struct cryptodesc *)space;
325
326         bzero(iv, iv_len);
327         bzero(crd, sizeof(struct cryptodesc));
328         bzero(crp, sizeof(struct cryptop));
329         *((off_t *)iv) = htole64(sector + priv->iv_offset);
330         crp->crp_buf = (caddr_t)iv;
331
332         crp->crp_sid = ivpriv->crypto_sid;
333         crp->crp_ilen = crp->crp_olen = iv_len;
334
335         crp->crp_opaque = alloc_addr;
336
337         crp->crp_callback = essiv_ivgen_done;
338
339         crp->crp_desc = crd;
340         crp->crp_etype = 0;
341         crp->crp_flags = CRYPTO_F_CBIFSYNC | CRYPTO_F_REL | CRYPTO_F_BATCH;
342
343         crd->crd_alg = priv->crypto_alg;
344 #if 0
345         crd->crd_key = (caddr_t)priv->crypto_keyhash;
346         crd->crd_klen = priv->crypto_klen;
347 #endif
348
349         bzero(crd->crd_iv, sizeof(crd->crd_iv));
350
351         crd->crd_skip = 0;
352         crd->crd_len = iv_len;
353         crd->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
354         crd->crd_flags |= CRD_F_ENCRYPT;
355         crd->crd_next = NULL;
356
357         error = crypto_dispatch(crp);
358         if (error)
359                 kprintf("dm_target_crypt: essiv_ivgen, error = %d\n", error);
360 }
361
362
363 static void
364 plain_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv,
365             size_t iv_len, off_t sector, void *opaque)
366 {
367         bzero(iv, iv_len);
368         *((uint32_t *)iv) = htole32((uint32_t)(sector + priv->iv_offset));
369         dmtc_crypto_dispatch(opaque);
370 }
371
372
373 #if 0
374 static void
375 geli_ivgen(dm_target_crypt_config_t *priv, u_int8_t *iv,
376            size_t iv_len, off_t sector, void *opaque)
377 {
378
379         SHA512_CTX      ctx512;
380         u_int8_t        md[SHA512_DIGEST_LENGTH]; /* Max. Digest Size */
381
382         memcpy(&ctx512, &priv->essivsha512_ctx, sizeof(SHA512_CTX));
383         SHA512_Update(&ctx512, (u_int8_t*)&sector, sizeof(off_t));
384         SHA512_Final(md, &ctx512);
385
386         memcpy(iv, md, iv_len);
387         dmtc_crypto_dispatch(opaque);
388 }
389 #endif
390
391 #ifdef DM_TARGET_MODULE
392 /*
393  * Every target can be compiled directly to dm driver or as a
394  * separate module this part of target is used for loading targets
395  * to dm driver.
396  * Target can be unloaded from kernel only if there are no users of
397  * it e.g. there are no devices which uses that target.
398  */
399 #include <sys/kernel.h>
400 #include <sys/module.h>
401
402 static int
403 dm_target_crypt_modcmd(modcmd_t cmd, void *arg)
404 {
405         dm_target_t *dmt;
406         int r;
407         dmt = NULL;
408
409         switch (cmd) {
410         case MODULE_CMD_INIT:
411                 if ((dmt = dm_target_lookup("crypt")) != NULL) {
412                         dm_target_unbusy(dmt);
413                         return EEXIST;
414                 }
415                 dmt = dm_target_alloc("crypt");
416
417                 dmt->version[0] = 1;
418                 dmt->version[1] = 0;
419                 dmt->version[2] = 0;
420                 strlcpy(dmt->name, "crypt", DM_MAX_TYPE_NAME);
421                 dmt->init = &dm_target_crypt_init;
422                 dmt->status = &dm_target_crypt_status;
423                 dmt->strategy = &dm_target_crypt_strategy;
424                 dmt->deps = &dm_target_crypt_deps;
425                 dmt->destroy = &dm_target_crypt_destroy;
426                 dmt->upcall = &dm_target_crypt_upcall;
427
428                 r = dm_target_insert(dmt);
429
430                 break;
431
432         case MODULE_CMD_FINI:
433                 r = dm_target_rem("crypt");
434                 break;
435
436         case MODULE_CMD_STAT:
437                 return ENOTTY;
438
439         default:
440                 return ENOTTY;
441         }
442
443         return r;
444 }
445
446 #endif
447
448 /*
449  * Init function called from dm_table_load_ioctl.
450  * cryptsetup actually passes us this:
451  * aes-cbc-essiv:sha256 7997f8af... 0 /dev/ad0s0a 8
452  */
453 static int
454 hex2key(char *hex, size_t key_len, u_int8_t *key)
455 {
456         char hex_buf[3];
457         size_t key_idx;
458
459         hex_buf[2] = 0;
460         for (key_idx = 0; key_idx < key_len; ++key_idx) {
461                 hex_buf[0] = *hex++;
462                 hex_buf[1] = *hex++;
463                 key[key_idx] = (u_int8_t)strtoul(hex_buf, NULL, 16);
464         }
465         hex_buf[0] = 0;
466         hex_buf[1] = 0;
467
468         return 0;
469 }
470
471 int
472 dm_target_crypt_init(dm_dev_t * dmv, void **target_config, char *params)
473 {
474         dm_target_crypt_config_t *priv;
475         size_t len;
476         char **ap, *args[5];
477         char *crypto_alg, *crypto_mode, *iv_mode, *iv_opt, *key, *dev;
478         char *status_str;
479         int i, argc, klen, error;
480         uint64_t iv_offset, block_offset;
481
482         if (params == NULL)
483                 return EINVAL;
484
485         len = strlen(params) + 1;
486         argc = 0;
487
488         status_str = kstrdup(params, M_DMCRYPT);
489         /*
490          * Parse a string, containing tokens delimited by white space,
491          * into an argument vector
492          */
493         for (ap = args; ap < &args[5] &&
494             (*ap = strsep(&params, " \t")) != NULL;) {
495                 if (**ap != '\0') {
496                         argc++;
497                         ap++;
498                 }
499         }
500
501         if (argc != 5) {
502                 kprintf("dm_target_crypt: not enough arguments, "
503                         "need exactly 5\n");
504                 kfree(status_str, M_DMCRYPT);
505                 return ENOMEM; /* XXX */
506         }
507
508         crypto_alg = strsep(&args[0], "-");
509         crypto_mode = strsep(&args[0], "-");
510         iv_opt = strsep(&args[0], "-");
511         iv_mode = strsep(&iv_opt, ":");
512         key = args[1];
513         iv_offset = strtouq(args[2], NULL, 0);
514         dev = args[3];
515         block_offset = strtouq(args[4], NULL, 0);
516         /* bits / 8 = bytes, 1 byte = 2 hexa chars, so << 2 */
517         klen = strlen(key) << 2;
518
519         kprintf("dm_target_crypt - new: dev=%s, crypto_alg=%s, crypto_mode=%s, "
520                 "iv_mode=%s, iv_opt=%s, key=%s, iv_offset=%ju, "
521                 "block_offset=%ju\n",
522                 dev, crypto_alg, crypto_mode, iv_mode, iv_opt, key, iv_offset,
523                 block_offset);
524
525         priv = kmalloc(sizeof(dm_target_crypt_config_t), M_DMCRYPT, M_WAITOK);
526         if (priv == NULL) {
527                 kprintf("dm_target_crypt: could not allocate memory\n");
528                 kfree(status_str, M_DMCRYPT);
529                 return ENOMEM;
530         }
531
532         /* Insert dmp to global pdev list */
533         if ((priv->pdev = dm_pdev_insert(dev)) == NULL) {
534                 kprintf("dm_target_crypt: dm_pdev_insert failed\n");
535                 kfree(status_str, M_DMCRYPT);
536                 return ENOENT;
537         }
538
539         if ((strcmp(crypto_mode, "cbc") != 0) &&
540             !((strcmp(crypto_mode, "xts") == 0) && (strcmp(crypto_alg, "aes") == 0)))
541         {
542                 kprintf("dm_target_crypt: only support 'cbc' chaining mode"
543                     " and aes-xts, invalid mode '%s-%s'\n",
544                     crypto_alg, crypto_mode);
545                 goto notsup;
546         }
547
548         if (!strcmp(crypto_alg, "aes")) {
549                 if (!strcmp(crypto_mode, "xts")) {
550                         priv->crypto_alg = CRYPTO_AES_XTS;
551                         if (klen != 256 && klen != 512)
552                                 goto notsup;
553                 } else if (!strcmp(crypto_mode, "cbc")) {
554                         priv->crypto_alg = CRYPTO_AES_CBC;
555                         if (klen != 128 && klen != 192 && klen != 256)
556                                 goto notsup;
557                 } else {
558                         goto notsup;
559                 }
560                 priv->crypto_klen = klen;
561         } else if (!strcmp(crypto_alg, "blowfish")) {
562                 priv->crypto_alg = CRYPTO_BLF_CBC;
563                 if (klen < 128 || klen > 448 || (klen % 8) != 0)
564                         goto notsup;
565                 priv->crypto_klen = klen;
566         } else if (!strcmp(crypto_alg, "3des") ||
567                    !strncmp(crypto_alg, "des3", 4)) {
568                 priv->crypto_alg = CRYPTO_3DES_CBC;
569                 if (klen != 168)
570                         goto notsup;
571                 priv->crypto_klen = 168;
572         } else if (!strcmp(crypto_alg, "camellia")) {
573                 priv->crypto_alg = CRYPTO_CAMELLIA_CBC;
574                 if (klen != 128 && klen != 192 && klen != 256)
575                         goto notsup;
576                 priv->crypto_klen = klen;
577         } else if (!strcmp(crypto_alg, "skipjack")) {
578                 priv->crypto_alg = CRYPTO_SKIPJACK_CBC;
579                 if (klen != 80)
580                         goto notsup;
581                 priv->crypto_klen = 80;
582         } else if (!strcmp(crypto_alg, "cast5")) {
583                 priv->crypto_alg = CRYPTO_CAST_CBC;
584                 if (klen != 128)
585                         goto notsup;
586                 priv->crypto_klen = 128;
587         } else if (!strcmp(crypto_alg, "null")) {
588                 priv->crypto_alg = CRYPTO_NULL_CBC;
589                 if (klen != 128)
590                         goto notsup;
591                 priv->crypto_klen = 128;
592         } else {
593                 kprintf("dm_target_crypt: Unsupported crypto algorithm: %s\n",
594                         crypto_alg);
595                 goto notsup;
596         }
597
598         /* Save length of param string */
599         priv->params_len = len;
600         priv->block_offset = block_offset;
601         priv->iv_offset = iv_offset - block_offset;
602
603         *target_config = priv;
604
605         dmv->dev_type = DM_CRYPTO_DEV;
606
607         error = hex2key(key, priv->crypto_klen >> 3,
608                         (u_int8_t *)priv->crypto_key);
609
610         if (error) {
611                 kprintf("dm_target_crypt: hex2key failed, "
612                         "invalid key format\n");
613                 goto notsup;
614         }
615
616         /* Handle cmd */
617         for(i = 0; ivgens[i].name != NULL; i++) {
618                 if (!strcmp(iv_mode, ivgens[i].name))
619                         break;
620         }
621
622         if (ivgens[i].name == NULL) {
623                 kprintf("dm_target_crypt: iv_mode='%s' unsupported\n",
624                         iv_mode);       
625                 goto notsup;
626         }
627
628         /* Call our ivgen constructor */
629         if (ivgens[i].ctor != NULL) {
630                 error = ivgens[i].ctor(priv, iv_opt,
631                     &priv->ivgen_priv);
632                 if (error) {
633                         kprintf("dm_target_crypt: ctor for '%s' failed\n",
634                             ivgens[i].name);
635                         goto notsup;
636                 }
637         }
638
639         priv->ivgen = &ivgens[i];
640
641         priv->crypto_session.cri_alg = priv->crypto_alg;
642         priv->crypto_session.cri_key = (u_int8_t *)priv->crypto_key;
643         priv->crypto_session.cri_klen = priv->crypto_klen;
644         priv->crypto_session.cri_mlen = 0;
645         priv->crypto_session.cri_next = NULL;
646
647         error = crypto_newsession(&priv->crypto_sid,
648                                   &priv->crypto_session,
649                                   CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_HARDWARE);
650         if (error) {
651                 kprintf("dm_target_crypt: Error during crypto_newsession, "
652                         "error = %d\n",
653                         error);
654                 goto notsup;
655         }
656
657         priv->status_str = status_str;
658         return 0;
659
660 notsup:
661         kprintf("dm_target_crypt: ENOTSUP\n");
662         kfree(status_str, M_DMCRYPT);
663         return ENOTSUP;
664 }
665
666 /* Status routine called to get params string. */
667 char *
668 dm_target_crypt_status(void *target_config)
669 {
670         dm_target_crypt_config_t *priv;
671         char *params;
672
673         priv = target_config;
674
675         /* caller expects use of M_DM */
676         params = kmalloc(DM_MAX_PARAMS_SIZE, M_DM, M_WAITOK);
677
678         ksnprintf(params, DM_MAX_PARAMS_SIZE, "%s",
679             priv->status_str);
680
681         return params;
682 }
683
684 int
685 dm_target_crypt_destroy(dm_table_entry_t * table_en)
686 {
687         dm_target_crypt_config_t *priv;
688
689         /*
690          * Disconnect the crypt config before unbusying the target.
691          */
692         priv = table_en->target_config;
693         if (priv == NULL)
694                 return 0;
695         table_en->target_config = NULL;
696         dm_pdev_decr(priv->pdev);
697
698         dm_target_unbusy(table_en->target);
699
700         /*
701          * Clean up the crypt config
702          *
703          * Overwrite the private information before freeing memory to
704          * avoid leaking it.
705          */
706         dmtc_crypto_clear(priv->status_str, strlen(priv->status_str));
707         kfree(priv->status_str, M_DMCRYPT);
708
709         crypto_freesession(priv->crypto_sid);
710
711         if (priv->ivgen->dtor != NULL) {
712                 priv->ivgen->dtor(priv, priv->ivgen_priv);
713         }
714
715         dmtc_crypto_clear(priv, sizeof(dm_target_crypt_config_t));
716         kfree(priv, M_DMCRYPT);
717
718         return 0;
719 }
720
721 int
722 dm_target_crypt_deps(dm_table_entry_t * table_en, prop_array_t prop_array)
723 {
724         dm_target_crypt_config_t *priv;
725         struct vattr va;
726
727         int error;
728
729         if (table_en->target_config == NULL)
730                 return ENOENT;
731
732         priv = table_en->target_config;
733
734         if ((error = VOP_GETATTR(priv->pdev->pdev_vnode, &va)) != 0)
735                 return error;
736
737         prop_array_add_uint64(prop_array,
738                               (uint64_t)makeudev(va.va_rmajor, va.va_rminor));
739
740         return 0;
741 }
742
743 /* Unsupported for this target. */
744 int
745 dm_target_crypt_upcall(dm_table_entry_t * table_en, struct buf * bp)
746 {
747         return 0;
748 }
749
750 /************************************************************************
751  *                      STRATEGY SUPPORT FUNCTIONS                      *
752  ************************************************************************
753  *
754  * READ PATH:   doio -> bio_read_done -> crypto_work -> crypto_cb_read_done
755  * WRITE PATH:  crypto_work -> crypto_cb_write_done -> doio -> bio_write_done
756  */
757
758 /*
759  * Wrapper around crypto_dispatch() to match dispatch_t type
760  */
761 static void
762 dmtc_crypto_dispatch(void *arg)
763 {
764         struct cryptop *crp;
765
766         crp = (struct cryptop *)arg;
767         KKASSERT(crp != NULL);
768         crypto_dispatch(crp);
769 }
770  
771 /*
772  * Start IO operation, called from dmstrategy routine.
773  */
774 int
775 dm_target_crypt_strategy(dm_table_entry_t *table_en, struct buf *bp)
776 {
777         struct bio *bio;
778
779         dm_target_crypt_config_t *priv;
780         priv = table_en->target_config;
781
782         /* Get rid of stuff we can't really handle */
783         if ((bp->b_cmd == BUF_CMD_READ) || (bp->b_cmd == BUF_CMD_WRITE)) {
784                 if (((bp->b_bcount % DEV_BSIZE) != 0) || (bp->b_bcount == 0)) {
785                         kprintf("dm_target_crypt_strategy: can't really "
786                                 "handle bp->b_bcount = %d\n",
787                                 bp->b_bcount);
788                         bp->b_error = EINVAL;
789                         bp->b_flags |= B_ERROR | B_INVAL;
790                         biodone(&bp->b_bio1);
791                         return 0;
792                 }
793         }
794
795         switch (bp->b_cmd) {
796         case BUF_CMD_READ:
797                 bio = push_bio(&bp->b_bio1);
798                 bio->bio_offset = bp->b_bio1.bio_offset +
799                                   priv->block_offset * DEV_BSIZE;
800                 bio->bio_caller_info1.ptr = priv;
801                 bio->bio_done = dmtc_bio_read_done;
802                 vn_strategy(priv->pdev->pdev_vnode, bio);
803                 break;
804         case BUF_CMD_WRITE:
805                 bio = push_bio(&bp->b_bio1);
806                 bio->bio_offset = bp->b_bio1.bio_offset +
807                                   priv->block_offset * DEV_BSIZE;
808                 bio->bio_caller_info1.ptr = priv;
809                 dmtc_crypto_write_start(priv, bio);
810                 break;
811         default:
812                 vn_strategy(priv->pdev->pdev_vnode, &bp->b_bio1);
813                 break;
814         }
815         return 0;
816 }
817
818 /*
819  * STRATEGY READ PATH PART 1/3 (after read BIO completes)
820  */
821 static void
822 dmtc_bio_read_done(struct bio *bio)
823 {
824         struct bio *obio;
825
826         dm_target_crypt_config_t *priv;
827
828         /*
829          * If a read error occurs we shortcut the operation, otherwise
830          * go on to stage 2.
831          */
832         if (bio->bio_buf->b_flags & B_ERROR) {
833                 obio = pop_bio(bio);
834                 biodone(obio);
835         } else {
836                 priv = bio->bio_caller_info1.ptr;
837                 dmtc_crypto_read_start(priv, bio);
838         }
839 }
840
841 /*
842  * STRATEGY READ PATH PART 2/3
843  */
844 static void
845 dmtc_crypto_read_start(dm_target_crypt_config_t *priv, struct bio *bio)
846 {
847         struct dmtc_helper *dmtc;
848         struct cryptodesc *crd;
849         struct cryptop *crp;
850         struct cryptoini *cri;
851         int i, bytes, sectors, sz;
852         off_t isector;
853         u_char *ptr, *space;
854
855         cri = &priv->crypto_session;
856
857         /*
858          * Note: b_resid no good after read I/O, it will be 0, use
859          *       b_bcount.
860          */
861         bytes = bio->bio_buf->b_bcount;
862         isector = bio->bio_offset / DEV_BSIZE;  /* ivgen salt base? */
863         sectors = bytes / DEV_BSIZE;            /* Number of sectors */
864         sz = sectors * (sizeof(*crp) + sizeof(*crd));
865
866         /*
867          * For reads with bogus page we can't decrypt in place as stuff
868          * can get ripped out from under us.
869          *
870          * XXX actually it looks like we can, and in any case the initial
871          * read already completed and threw crypted data into the buffer
872          * cache buffer.  Disable for now.
873          */
874 #if 0
875         if (bio->bio_buf->b_flags & B_HASBOGUS) {
876                 space = kmalloc(sizeof(struct dmtc_helper) + sz + bytes,
877                                 M_DMCRYPT, M_WAITOK);
878                 dmtc = (struct dmtc_helper *)space;
879                 dmtc->free_addr = space;
880                 space += sizeof(struct dmtc_helper);
881                 dmtc->orig_buf = NULL;
882                 dmtc->data_buf = space + sz;
883                 memcpy(dmtc->data_buf, bio->bio_buf->b_data, bytes);
884         } else
885 #endif
886         {
887                 space = kmalloc(sizeof(struct dmtc_helper) + sz,
888                                 M_DMCRYPT, M_WAITOK);
889                 dmtc = (struct dmtc_helper *)space;
890                 dmtc->free_addr = space;
891                 space += sizeof(struct dmtc_helper);
892                 dmtc->orig_buf = NULL;
893                 dmtc->data_buf = bio->bio_buf->b_data;
894         }
895         bio->bio_caller_info2.ptr = dmtc;
896         bio->bio_buf->b_error = 0;
897
898         /*
899          * Load crypto descriptors (crp/crd loop)
900          */
901         bzero(space, sz);
902         ptr = space;
903         bio->bio_caller_info3.value = sectors;
904         cpu_sfence();
905 #if 0
906         kprintf("Read, bytes = %d (b_bcount), "
907                 "sectors = %d (bio = %p, b_cmd = %d)\n",
908                 bytes, sectors, bio, bio->bio_buf->b_cmd);
909 #endif
910         for (i = 0; i < sectors; i++) {
911                 crp = (struct cryptop *)ptr;
912                 ptr += sizeof(*crp);
913                 crd = (struct cryptodesc *)ptr;
914                 ptr += sizeof (*crd);
915
916                 crp->crp_buf = dmtc->data_buf + i * DEV_BSIZE;
917
918                 crp->crp_sid = priv->crypto_sid;
919                 crp->crp_ilen = crp->crp_olen = DEV_BSIZE;
920
921                 crp->crp_opaque = (void *)bio;
922
923                 crp->crp_callback = dmtc_crypto_cb_read_done;
924                 crp->crp_desc = crd;
925                 crp->crp_etype = 0;
926                 crp->crp_flags = CRYPTO_F_CBIFSYNC | CRYPTO_F_REL |
927                                  CRYPTO_F_BATCH;
928
929                 crd->crd_alg = priv->crypto_alg;
930 #if 0
931                 crd->crd_key = (caddr_t)priv->crypto_key;
932                 crd->crd_klen = priv->crypto_klen;
933 #endif
934
935                 crd->crd_skip = 0;
936                 crd->crd_len = DEV_BSIZE /* XXX */;
937                 crd->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
938                 crd->crd_next = NULL;
939
940                 crd->crd_flags &= ~CRD_F_ENCRYPT;
941
942                 /*
943                  * Note: last argument is used to generate salt(?) and is
944                  *       a 64 bit value, but the original code passed an
945                  *       int.  Changing it now will break pre-existing
946                  *       crypt volumes.
947                  */
948                 priv->ivgen->gen_iv(priv, crd->crd_iv, sizeof(crd->crd_iv),
949                                     isector + i, crp);
950         }
951 }
952
953 /*
954  * STRATEGY READ PATH PART 3/3
955  */
956 static int
957 dmtc_crypto_cb_read_done(struct cryptop *crp)
958 {
959         struct dmtc_helper *dmtc;
960         struct bio *bio, *obio;
961         int n;
962
963         if (crp->crp_etype == EAGAIN)
964                 return crypto_dispatch(crp);
965
966         bio = (struct bio *)crp->crp_opaque;
967         KKASSERT(bio != NULL);
968
969         /*
970          * Cumulative error
971          */
972         if (crp->crp_etype) {
973                 kprintf("dm_target_crypt: dmtc_crypto_cb_read_done "
974                         "crp_etype = %d\n",
975                         crp->crp_etype);
976                 bio->bio_buf->b_error = crp->crp_etype;
977         }
978
979         /*
980          * On the last chunk of the decryption we do any required copybacks
981          * and complete the I/O.
982          */
983         n = atomic_fetchadd_int(&bio->bio_caller_info3.value, -1);
984 #if 0
985         kprintf("dmtc_crypto_cb_read_done %p, n = %d\n", bio, n);
986 #endif
987
988         if (n == 1) {
989                 /*
990                  * For the B_HASBOGUS case we didn't decrypt in place,
991                  * so we need to copy stuff back into the buf.
992                  *
993                  * (disabled for now).
994                  */
995                 dmtc = bio->bio_caller_info2.ptr;
996                 if (bio->bio_buf->b_error) {
997                         bio->bio_buf->b_flags |= B_ERROR;
998                 }
999 #if 0
1000                 else if (bio->bio_buf->b_flags & B_HASBOGUS) {
1001                         memcpy(bio->bio_buf->b_data, dmtc->data_buf,
1002                                bio->bio_buf->b_bcount);
1003                 }
1004 #endif
1005                 kfree(dmtc->free_addr, M_DMCRYPT);
1006                 obio = pop_bio(bio);
1007                 biodone(obio);
1008         }
1009         return 0;
1010 }
1011 /* END OF STRATEGY READ SECTION */
1012
1013 /*
1014  * STRATEGY WRITE PATH PART 1/3
1015  */
1016 static void
1017 dmtc_crypto_write_start(dm_target_crypt_config_t *priv, struct bio *bio)
1018 {
1019         struct dmtc_helper *dmtc;
1020         struct cryptodesc *crd;
1021         struct cryptop *crp;
1022         struct cryptoini *cri;
1023         int i, bytes, sectors, sz;
1024         off_t isector;
1025         u_char *ptr, *space;
1026
1027         cri = &priv->crypto_session;
1028
1029         /*
1030          * Use b_bcount for consistency
1031          */
1032         bytes = bio->bio_buf->b_bcount;
1033
1034         isector = bio->bio_offset / DEV_BSIZE;  /* ivgen salt base? */
1035         sectors = bytes / DEV_BSIZE;            /* Number of sectors */
1036         sz = sectors * (sizeof(*crp) + sizeof(*crd));
1037
1038         /*
1039          * For writes and reads with bogus page don't decrypt in place.
1040          */
1041         space = kmalloc(sizeof(struct dmtc_helper) + sz + bytes,
1042                         M_DMCRYPT, M_WAITOK);
1043         dmtc = (struct dmtc_helper *)space;
1044         dmtc->free_addr = space;
1045         space += sizeof(struct dmtc_helper);
1046         memcpy(space + sz, bio->bio_buf->b_data, bytes);
1047
1048         bio->bio_caller_info2.ptr = dmtc;
1049         bio->bio_buf->b_error = 0;
1050
1051         dmtc->orig_buf = bio->bio_buf->b_data;
1052         dmtc->data_buf = space + sz;
1053
1054         /*
1055          * Load crypto descriptors (crp/crd loop)
1056          */
1057         bzero(space, sz);
1058         ptr = space;
1059         bio->bio_caller_info3.value = sectors;
1060         cpu_sfence();
1061 #if 0
1062         kprintf("Write, bytes = %d (b_bcount), "
1063                 "sectors = %d (bio = %p, b_cmd = %d)\n",
1064                 bytes, sectors, bio, bio->bio_buf->b_cmd);
1065 #endif
1066         for (i = 0; i < sectors; i++) {
1067                 crp = (struct cryptop *)ptr;
1068                 ptr += sizeof(*crp);
1069                 crd = (struct cryptodesc *)ptr;
1070                 ptr += sizeof (*crd);
1071
1072                 crp->crp_buf = dmtc->data_buf + i * DEV_BSIZE;
1073
1074                 crp->crp_sid = priv->crypto_sid;
1075                 crp->crp_ilen = crp->crp_olen = DEV_BSIZE;
1076
1077                 crp->crp_opaque = (void *)bio;
1078
1079                 crp->crp_callback = dmtc_crypto_cb_write_done;
1080                 crp->crp_desc = crd;
1081                 crp->crp_etype = 0;
1082                 crp->crp_flags = CRYPTO_F_CBIFSYNC | CRYPTO_F_REL |
1083                                  CRYPTO_F_BATCH;
1084
1085                 crd->crd_alg = priv->crypto_alg;
1086 #if 0
1087                 crd->crd_key = (caddr_t)priv->crypto_key;
1088                 crd->crd_klen = priv->crypto_klen;
1089 #endif
1090
1091                 crd->crd_skip = 0;
1092                 crd->crd_len = DEV_BSIZE /* XXX */;
1093                 crd->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_IV_PRESENT;
1094                 crd->crd_next = NULL;
1095
1096                 crd->crd_flags |= CRD_F_ENCRYPT;
1097
1098                 /*
1099                  * Note: last argument is used to generate salt(?) and is
1100                  *       a 64 bit value, but the original code passed an
1101                  *       int.  Changing it now will break pre-existing
1102                  *       crypt volumes.
1103                  */
1104                 priv->ivgen->gen_iv(priv, crd->crd_iv, sizeof(crd->crd_iv),
1105                                     isector + i, crp);
1106         }
1107 }
1108
1109 /*
1110  * STRATEGY WRITE PATH PART 2/3
1111  */
1112 static int
1113 dmtc_crypto_cb_write_done(struct cryptop *crp)
1114 {
1115         struct dmtc_helper *dmtc;
1116         dm_target_crypt_config_t *priv;
1117         struct bio *bio, *obio;
1118         int n;
1119
1120         if (crp->crp_etype == EAGAIN)
1121                 return crypto_dispatch(crp);
1122
1123         bio = (struct bio *)crp->crp_opaque;
1124         KKASSERT(bio != NULL);
1125
1126         /*
1127          * Cumulative error
1128          */
1129         if (crp->crp_etype != 0) {
1130                 kprintf("dm_target_crypt: dmtc_crypto_cb_write_done "
1131                         "crp_etype = %d\n",
1132                 crp->crp_etype);
1133                 bio->bio_buf->b_error = crp->crp_etype;
1134         }
1135
1136         /*
1137          * On the last chunk of the encryption we issue the write
1138          */
1139         n = atomic_fetchadd_int(&bio->bio_caller_info3.value, -1);
1140 #if 0
1141         kprintf("dmtc_crypto_cb_write_done %p, n = %d\n", bio, n);
1142 #endif
1143
1144         if (n == 1) {
1145                 dmtc = bio->bio_caller_info2.ptr;
1146                 priv = (dm_target_crypt_config_t *)bio->bio_caller_info1.ptr;
1147
1148                 if (bio->bio_buf->b_error) {
1149                         bio->bio_buf->b_flags |= B_ERROR;
1150                         kfree(dmtc->free_addr, M_DMCRYPT);
1151                         obio = pop_bio(bio);
1152                         biodone(obio);
1153                 } else {
1154                         dmtc->orig_buf = bio->bio_buf->b_data;
1155                         bio->bio_buf->b_data = dmtc->data_buf;
1156                         bio->bio_done = dmtc_bio_write_done;
1157                         vn_strategy(priv->pdev->pdev_vnode, bio);
1158                 }
1159         }
1160         return 0;
1161 }
1162
1163 /*
1164  * STRATEGY WRITE PATH PART 3/3
1165  */
1166 static void
1167 dmtc_bio_write_done(struct bio *bio)
1168 {
1169         struct dmtc_helper *dmtc;
1170         struct bio *obio;
1171
1172         dmtc = bio->bio_caller_info2.ptr;
1173         bio->bio_buf->b_data = dmtc->orig_buf;
1174         kfree(dmtc->free_addr, M_DMCRYPT);
1175         obio = pop_bio(bio);
1176         biodone(obio);
1177 }
1178 /* END OF STRATEGY WRITE SECTION */