g13: Include sys/sysmacros.h if available.
[gnupg.git] / g13 / sh-dmcrypt.c
1 /* sh-dmcrypt.c - The DM-Crypt part for g13-syshelp
2  * Copyright (C) 2015, 2016 Werner Koch
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stdarg.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <sys/types.h>
28 #ifdef HAVE_SYS_SYSMACROS_H
29 # include <sys/sysmacros.h>
30 #endif
31 #ifdef HAVE_STAT
32 # include <sys/stat.h>
33 #endif
34 #include <unistd.h>
35
36 #include "g13-syshelp.h"
37 #include <assuan.h>
38 #include "../common/i18n.h"
39 #include "g13tuple.h"
40 #include "../common/exectool.h"
41 #include "keyblob.h"
42
43 /* The standard disk block size (logical).  */
44 #define SECTOR_SIZE 512
45
46 /* The physical block size used by modern devices.  */
47 #define PHY_SECTOR_SIZE  (SECTOR_SIZE*8)  /* 4 KiB */
48
49 /* The length of the crypto setup area in sectors.  16 KiB is a nice
50    multiple of a modern block size and should be sufficient for all
51    kind of extra public key encryption packets.  */
52 #define SETUP_AREA_SECTORS 32  /* 16 KiB */
53
54 /* The number of header block copies stored at the begin and end of
55    the device.  */
56 #define HEADER_SETUP_AREA_COPIES 2
57 #define FOOTER_SETUP_AREA_COPIES 2
58
59 /* The length in blocks of the space we put at the start and at the
60    end of the device.  This space is used to store N copies of the
61    setup area for the actual encrypted container in between.  */
62 #define HEADER_SECTORS (SETUP_AREA_SECTORS * HEADER_SETUP_AREA_COPIES)
63 #define FOOTER_SECTORS (SETUP_AREA_SECTORS * FOOTER_SETUP_AREA_COPIES)
64
65 /* Minimim size of the encrypted space in blocks.  This is more or
66    less an arbitrary value.  */
67 #define MIN_ENCRYPTED_SPACE 32
68
69 /* Some consistency checks for the above constants.  */
70 #if (PHY_SECTOR_SIZE % SECTOR_SIZE)
71 # error the physical secotor size should be a multiple of 512
72 #endif
73 #if ((SETUP_AREA_SECTORS*SECTOR_SIZE) % PHY_SECTOR_SIZE)
74 # error The setup area size should be a multiple of the phy. sector size.
75 #endif
76
77
78 /*
79  * Check whether the block device DEVNAME is used by device mapper.
80  * If EXPECT_BUSY is set no error message is printed if the device is
81  * busy.  Returns: 0 if the device is good and not yet used by DM.
82  */
83 static gpg_error_t
84 check_blockdev (const char *devname, int expect_busy)
85 {
86   gpg_error_t err;
87   struct stat sb;
88   unsigned int devmajor, devminor;
89   char *result = NULL;
90   char **lines = NULL;
91   char **fields = NULL;
92   int lno, count;
93
94   if (stat (devname, &sb))
95     {
96       err = gpg_error_from_syserror ();
97       log_error ("error stating '%s': %s\n", devname, gpg_strerror (err));
98       return err;
99     }
100   if (!S_ISBLK (sb.st_mode))
101     {
102       err = gpg_error (GPG_ERR_ENOTBLK);
103       log_error ("can't use '%s': %s\n", devname, gpg_strerror (err));
104       return err;
105     }
106   devmajor = major (sb.st_rdev);
107   devminor = minor (sb.st_rdev);
108
109   {
110     const char *argv[2];
111
112     argv[0] = "deps";
113     argv[1] = NULL;
114     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
115   }
116   if (err)
117     {
118       log_error ("error running '%s' to search for '%s': %s\n",
119                  "dmsetup deps", devname, gpg_strerror (err));
120       goto leave;
121     }
122   lines = strsplit (result, '\n', 0, NULL);
123   if (!lines)
124     {
125       err = gpg_error_from_syserror ();
126       goto leave;
127     }
128   if (lines[0] && !strcmp (lines[0], "No devices found"))
129     ;
130   else
131     {
132       for (lno=0; lines[lno]; lno++)
133         {
134           unsigned int xmajor, xminor;
135
136           if (!*lines[lno])
137             continue;
138           xfree (fields);
139           fields = strsplit (lines[lno], ':', 0, &count);
140           if (!fields)
141             {
142               err = gpg_error_from_syserror ();
143               goto leave;
144             }
145           if (count < 3
146               || sscanf (fields[2], " (%u,%u)", &xmajor, &xminor) != 2)
147             {
148               log_error ("error running '%s' to search for '%s': %s\n",
149                          "dmsetup deps", devname, "unexpected output");
150               err = gpg_error (GPG_ERR_INV_VALUE);
151               goto leave;
152             }
153
154           if (xmajor == devmajor && xminor == devminor)
155             {
156               if (!expect_busy)
157                 log_error ("device '%s' (%u:%u)"
158                            " already in use by device mapper\n",
159                            devname, devmajor, devminor);
160               err = gpg_error (GPG_ERR_EBUSY);
161               goto leave;
162             }
163         }
164     }
165
166
167  leave:
168   xfree (fields);
169   xfree (lines);
170   xfree (result);
171   return err;
172 }
173
174
175 /* Return a malloced buffer with the prefix of the setup area.  This
176    is the data written right before the encrypted keyblob.  Return NULL
177    on error and sets ERRNO.  */
178 static void *
179 mk_setup_area_prefix (size_t *r_length)
180 {
181   unsigned char *packet;
182   size_t setuparealen;
183
184   packet = xtrymalloc (32);
185   if (!packet)
186     return NULL;
187   *r_length = 32;
188
189   setuparealen = SETUP_AREA_SECTORS * SECTOR_SIZE;
190
191   packet[0] = (0xc0|61); /* CTB for the private packet type 0x61.  */
192   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
193   packet[2] = 0;
194   packet[3] = 0;
195   packet[4] = 0;
196   packet[5] = 26;
197   memcpy (packet+6, "GnuPG/G13", 10); /* Packet subtype.  */
198   packet[16] = 1;   /* G13 packet format version.  */
199   packet[17] = 0;   /* Reserved.  */
200   packet[18] = 0;   /* Reserved.  */
201   packet[19] = 1;   /* OS Flag = Linux  */
202   packet[20] = (setuparealen >> 24);  /* Total length of header.  */
203   packet[21] = (setuparealen >> 16);
204   packet[22] = (setuparealen >> 8);
205   packet[23] = (setuparealen);
206   packet[24] = HEADER_SETUP_AREA_COPIES;
207   packet[25] = FOOTER_SETUP_AREA_COPIES;
208   packet[26] = 0;   /* Reserved.  */
209   packet[27] = 0;   /* Reserved.  */
210   packet[28] = 0;   /* Reserved.  */
211   packet[29] = 0;   /* Reserved.  */
212   packet[30] = 0;   /* Reserved.  */
213   packet[31] = 0;   /* Reserved.  */
214
215   return packet;
216 }
217
218
219 /* Create a new g13 styloe DM-Crypt container on devoce DEVNAME.  */
220 gpg_error_t
221 sh_dmcrypt_create_container (ctrl_t ctrl, const char *devname, estream_t devfp)
222 {
223   gpg_error_t err;
224   char *header_space;
225   size_t header_space_size, header_space_used;
226   size_t paddinglen;
227   char *targetname = NULL;
228   size_t nread;
229   char *p;
230   char hexkey[16*2+1];
231   char *table = NULL;
232   unsigned long long nblocks;
233   char *result = NULL;
234   unsigned char twobyte[2];
235   membuf_t keyblob;
236   void  *keyblob_buf = NULL;
237   size_t keyblob_len;
238   size_t n;
239   const char *s;
240   unsigned char *packet;
241   int copy;
242
243   if (!ctrl->devti)
244     return gpg_error (GPG_ERR_INV_ARG);
245
246   g13_syshelp_i_know_what_i_am_doing ();
247
248   header_space_size = SETUP_AREA_SECTORS * SECTOR_SIZE;
249   header_space = xtrymalloc (header_space_size);
250   if (!header_space)
251     return gpg_error_from_syserror ();
252
253   /* Start building the keyblob.  */
254   init_membuf (&keyblob, 512);
255   append_tuple (&keyblob, KEYBLOB_TAG_BLOBVERSION, "\x01", 1);
256   n = CONTTYPE_DM_CRYPT;
257   twobyte[0] = (n >> 8);
258   twobyte[1] = n;
259   append_tuple (&keyblob, KEYBLOB_TAG_CONTTYPE, twobyte, 2);
260   {
261     gnupg_isotime_t tbuf;
262
263     gnupg_get_isotime (tbuf);
264     append_tuple (&keyblob, KEYBLOB_TAG_CREATED, tbuf, strlen (tbuf));
265   }
266
267   /* Rewind device stream.  */
268   if (es_fseeko (devfp, 0, SEEK_SET))
269     {
270       err = gpg_error_from_syserror ();
271       log_error ("error seeking to begin of '%s': %s\n",
272                  devname, gpg_strerror (err));
273       goto leave;
274     }
275   es_clearerr (devfp);
276
277   /* Extra check that the device is empty.  */
278   if (es_read (devfp, header_space, header_space_size, &nread))
279     err = gpg_error_from_syserror ();
280   else if (nread != header_space_size)
281     err = gpg_error (GPG_ERR_TOO_SHORT);
282   else
283     err = 0;
284   if (err)
285     {
286       log_error ("error reading header space of '%s': %s\n",
287                  devname, gpg_strerror (err));
288       goto leave;
289     }
290   for (p=header_space; nread && !*p; nread--, p++)
291     ;
292   if (nread)
293     {
294       log_error ("header space of '%s' already used - use %s to override\n",
295                  devname, "--force");
296       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
297       goto leave;
298     }
299
300   /* Check that the device is not used by device mapper. */
301   err = check_blockdev (devname, 0);
302   if (err)
303     goto leave;
304
305   /* Compute the number of blocks.  */
306   err = sh_blockdev_getsz (devname, &nblocks);
307   if (err)
308     {
309       log_error ("error getting size of '%s': %s\n",
310                  devname, gpg_strerror (err));
311       goto leave;
312     }
313   if (nblocks <= HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS)
314     {
315       log_error ("device '%s' is too small (min=%d blocks)\n",
316                  devname,
317                  HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS);
318       err = gpg_error (GPG_ERR_TOO_SHORT);
319       goto leave;
320     }
321   append_tuple_uint (&keyblob, KEYBLOB_TAG_CONT_NSEC, nblocks);
322   nblocks -= HEADER_SECTORS + FOOTER_SECTORS;
323   append_tuple_uint (&keyblob, KEYBLOB_TAG_ENC_NSEC, nblocks);
324   append_tuple_uint (&keyblob, KEYBLOB_TAG_ENC_OFF, HEADER_SECTORS);
325
326   /* Device mapper needs a name for the device: Take it from the label
327      or use "0".  */
328   targetname = strconcat ("g13-", ctrl->client.uname, "-",
329                           ctrl->devti->label? ctrl->devti->label : "0",
330                           NULL);
331   if (!targetname)
332     {
333       err = gpg_error_from_syserror ();
334       goto leave;
335     }
336
337   /* Create the key.  */
338   {
339     char key[16];
340     gcry_randomize (key, sizeof key, GCRY_STRONG_RANDOM);
341     append_tuple (&keyblob, KEYBLOB_TAG_ENCKEY, key, sizeof key);
342     bin2hex (key, 16, hexkey);
343     wipememory (key, 16);
344     /* Add a 2*(4+16) byte filler to conceal the fact that we use
345        AES-128.  If we ever want to switch to 256 bit we can resize
346        that filler to keep the keyblob at the same size.  */
347     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
348     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
349   }
350
351   /* Build dmcrypt table. */
352   s = "aes-cbc-essiv:sha256";
353   append_tuple (&keyblob, KEYBLOB_TAG_ALGOSTR, s, strlen (s));
354   table = es_bsprintf ("0 %llu crypt %s %s 0 %s %d",
355                        nblocks, s, hexkey, devname, HEADER_SECTORS);
356   if (!table)
357     {
358       err = gpg_error_from_syserror ();
359       goto leave;
360     }
361   wipememory (hexkey, sizeof hexkey);
362
363   /* Add a copy of the setup area prefix to the keyblob.  */
364   p = mk_setup_area_prefix (&n);
365   if (!p)
366     {
367       err = gpg_error_from_syserror ();
368       goto leave;
369     }
370   append_tuple (&keyblob, KEYBLOB_TAG_HDRCOPY, p, n);
371   assert (n < header_space_size);
372   memcpy (header_space, p, n);
373   header_space_used = n;
374
375   /* Turn the keyblob into a buffer and callback to encrypt it.  */
376   keyblob_buf = get_membuf (&keyblob, &keyblob_len);
377   if (!keyblob_buf)
378     {
379       err = gpg_error_from_syserror ();
380       goto leave;
381     }
382   err = sh_encrypt_keyblob (ctrl, keyblob_buf, keyblob_len, &p, &n);
383   if (err)
384     {
385       log_error ("encrypting the keyblob failed: %s\n", gpg_strerror (err));
386       goto leave;
387     }
388   log_debug ("plain setuparea=%p %zu bytes\n", keyblob_buf, keyblob_len);
389   wipememory (keyblob_buf, keyblob_len);
390   xfree (keyblob_buf);
391   keyblob_buf = NULL;
392
393   log_debug ("encry setuparea=%p %zu bytes\n", p, n);
394   if (n >= header_space_size || (header_space_used + n) >= header_space_size)
395     {
396       err = gpg_error (GPG_ERR_TOO_LARGE);
397       log_error ("setup area would overflow: %s\n", gpg_strerror (err));
398       goto leave;
399     }
400   memcpy (header_space + header_space_used, p, n);
401   header_space_used += n;
402
403   /* Write the padding.  */
404   packet = header_space + header_space_used;
405   paddinglen = header_space_size - header_space_used;
406   if (paddinglen < 16)
407     {
408       err = gpg_error (GPG_ERR_TOO_LARGE);
409       log_error ("setup area too short for padding: %s\n", gpg_strerror (err));
410       goto leave;
411     }
412   packet[0] = (0xc0|61); /* CTB for Private packet type 0x61.  */
413   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
414   packet[2] = (paddinglen-6) >> 24;
415   packet[3] = (paddinglen-6) >> 16;
416   packet[4] = (paddinglen-6) >> 8;
417   packet[5] = (paddinglen-6);
418   packet += 6;
419   paddinglen -= 6;
420   header_space_used += 6;
421   for ( ;paddinglen >= 10;
422         paddinglen -= 10, packet += 10, header_space_used += 10)
423     memcpy (packet, "GnuPG/PAD", 10);
424   for ( ;paddinglen; paddinglen--, packet++, header_space_used++)
425     *packet = 0;
426
427   if (header_space_used != header_space_size)
428     BUG ();
429
430   /* Create the container.  */
431   {
432     const char *argv[3];
433
434     argv[0] = "create";
435     argv[1] = targetname;
436     argv[2] = NULL;
437     log_debug ("now running \"dmsetup create %s\"\n", targetname);
438     log_debug ("  with table='%s'\"\n", table);
439     err = gnupg_exec_tool ("/sbin/dmsetup", argv, table, &result, NULL);
440   }
441   if (err)
442     {
443       log_error ("error running dmsetup for '%s': %s\n",
444                  devname, gpg_strerror (err));
445       goto leave;
446     }
447   if (result && *result)
448     log_debug ("dmsetup result: %s\n", result);
449
450   /* Write the setup area.  */
451   if (es_fseeko (devfp, 0, SEEK_SET))
452     {
453       err = gpg_error_from_syserror ();
454       log_error ("error seeking to begin of '%s': %s\n",
455                  devname, gpg_strerror (err));
456       goto leave;
457     }
458   es_clearerr (devfp);
459
460   for (copy = 0; copy < HEADER_SETUP_AREA_COPIES; copy++)
461     {
462       size_t nwritten;
463
464       if (es_write (devfp, header_space, header_space_size, &nwritten))
465         {
466           err = gpg_error_from_syserror ();
467           break;
468         }
469       else if (nwritten != header_space_size)
470         {
471           err = gpg_error (GPG_ERR_TOO_SHORT);
472           break;
473         }
474     }
475   if (err)
476     {
477       log_error ("error writing header space copy %d of '%s': %s\n",
478                  copy, devname, gpg_strerror (err));
479       goto leave;
480     }
481
482   if (es_fseeko (devfp,
483                  (- header_space_size * FOOTER_SETUP_AREA_COPIES), SEEK_END))
484     {
485       err = gpg_error_from_syserror ();
486       log_error ("error seeking to end of '%s': %s\n",
487                  devname, gpg_strerror (err));
488       goto leave;
489     }
490   es_clearerr (devfp);
491
492   for (copy = 0; copy < FOOTER_SETUP_AREA_COPIES; copy++)
493     {
494       size_t nwritten;
495
496       if (es_write (devfp, header_space, header_space_size, &nwritten))
497         {
498           err = gpg_error_from_syserror ();
499           break;
500         }
501       else if (nwritten != header_space_size)
502         {
503           err = gpg_error (GPG_ERR_TOO_SHORT);
504           break;
505         }
506     }
507   if (!err && es_fflush (devfp))
508     err = gpg_error_from_syserror ();
509   if (err)
510     {
511       log_error ("error writing footer space copy %d of '%s': %s\n",
512                  copy, devname, gpg_strerror (err));
513       goto leave;
514     }
515
516  leave:
517   wipememory (hexkey, sizeof hexkey);
518   if (table)
519     {
520       wipememory (table, strlen (table));
521       xfree (table);
522     }
523   if (keyblob_buf)
524     {
525       wipememory (keyblob_buf, keyblob_len);
526       xfree (keyblob_buf);
527     }
528   xfree (get_membuf (&keyblob, NULL));
529   xfree (targetname);
530   xfree (result);
531   xfree (header_space);
532   return err;
533 }
534
535
536 /* Mount a DM-Crypt container on device DEVNAME taking keys and other
537  * meta data from KEYBLOB.  */
538 gpg_error_t
539 sh_dmcrypt_mount_container (ctrl_t ctrl, const char *devname,
540                             tupledesc_t keyblob)
541 {
542   gpg_error_t err;
543   char *targetname_abs = NULL;
544   const char *targetname;
545   char hexkey[16*2+1];
546   char *table = NULL;
547   unsigned long long nblocks, nblocks2;
548   char *result = NULL;
549   size_t n;
550   const char *s;
551   const char *algostr;
552   size_t algostrlen;
553
554   if (!ctrl->devti)
555     return gpg_error (GPG_ERR_INV_ARG);
556
557   g13_syshelp_i_know_what_i_am_doing ();
558
559   /* Check that the device is not yet used by device mapper. */
560   err = check_blockdev (devname, 0);
561   if (err)
562     goto leave;
563
564   /* Compute the number of blocks and compare them to the value
565      provided as meta data.  */
566   err = sh_blockdev_getsz (devname, &nblocks);
567   if (err)
568     {
569       log_error ("error getting size of '%s': %s\n",
570                  devname, gpg_strerror (err));
571       goto leave;
572     }
573   err = find_tuple_uint (keyblob, KEYBLOB_TAG_CONT_NSEC, &nblocks2);
574   if (err)
575     {
576       log_error ("error getting size from keyblob: %s\n", gpg_strerror (err));
577       goto leave;
578     }
579   if (nblocks != nblocks2)
580     {
581       log_error ("inconsistent size of container: expected==%llu got=%llu\n",
582                  nblocks2, nblocks);
583       err = gpg_error (GPG_ERR_INV_DATA);
584       goto leave;
585     }
586   if (nblocks <= HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS)
587     {
588       log_error ("device '%s' is too small (min=%d blocks)\n",
589                  devname,
590                  HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS);
591       err = gpg_error (GPG_ERR_TOO_SHORT);
592       goto leave;
593     }
594   nblocks -= HEADER_SECTORS + FOOTER_SECTORS;
595   err = find_tuple_uint (keyblob, KEYBLOB_TAG_ENC_NSEC, &nblocks2);
596   if (err)
597     {
598       log_error ("error getting enc size from keyblob: %s\n",
599                  gpg_strerror (err));
600       goto leave;
601     }
602   if (nblocks != nblocks2)
603     {
604       log_error ("inconsistent size of enc data: expected==%llu got=%llu\n",
605                  nblocks2, nblocks);
606       err = gpg_error (GPG_ERR_INV_DATA);
607       goto leave;
608     }
609   /* Check that the offset is consistent.  */
610   err = find_tuple_uint (keyblob, KEYBLOB_TAG_ENC_OFF, &nblocks2);
611   if (err)
612     {
613       log_error ("error getting enc offset from keyblob: %s\n",
614                  gpg_strerror (err));
615       goto leave;
616     }
617   if (nblocks2 != HEADER_SECTORS)
618     {
619       log_error ("inconsistent offset of enc data: expected==%llu got=%d\n",
620                  nblocks2, HEADER_SECTORS);
621       err = gpg_error (GPG_ERR_INV_DATA);
622       goto leave;
623     }
624
625   /* Device mapper needs a name for the device: Take it from the label
626      or use "0".  */
627   targetname_abs = strconcat ("/dev/mapper/",
628                               "g13-", ctrl->client.uname, "-",
629                               ctrl->devti->label? ctrl->devti->label : "0",
630                               NULL);
631   if (!targetname_abs)
632     {
633       err = gpg_error_from_syserror ();
634       goto leave;
635     }
636   targetname = strrchr (targetname_abs, '/');
637   if (!targetname)
638     BUG ();
639   targetname++;
640
641   /* Get the algorithm string.  */
642   algostr = find_tuple (keyblob, KEYBLOB_TAG_ALGOSTR, &algostrlen);
643   if (!algostr || algostrlen > 100)
644     {
645       log_error ("algo string not found in keyblob or too long\n");
646       err = gpg_error (GPG_ERR_INV_DATA);
647       goto leave;
648     }
649
650   /* Get the key.  */
651   s = find_tuple (keyblob, KEYBLOB_TAG_ENCKEY, &n);
652   if (!s || n != 16)
653     {
654       if (!s)
655         log_error ("no key found in keyblob\n");
656       else
657         log_error ("unexpected size of key (%zu)\n", n);
658       err = gpg_error (GPG_ERR_INV_KEYLEN);
659       goto leave;
660     }
661   bin2hex (s, 16, hexkey);
662
663   /* Build dmcrypt table. */
664   table = es_bsprintf ("0 %llu crypt %.*s %s 0 %s %d",
665                        nblocks, (int)algostrlen, algostr,
666                        hexkey, devname, HEADER_SECTORS);
667   wipememory (hexkey, sizeof hexkey);
668   if (!table)
669     {
670       err = gpg_error_from_syserror ();
671       goto leave;
672     }
673
674   /* Load the table.  */
675   {
676     const char *argv[3];
677
678     argv[0] = "create";
679     argv[1] = targetname;
680     argv[2] = NULL;
681     log_debug ("now running \"dmsetup create %s\"\n", targetname);
682     err = gnupg_exec_tool ("/sbin/dmsetup", argv, table, &result, NULL);
683   }
684   if (err)
685     {
686       log_error ("error running dmsetup for '%s': %s\n",
687                  devname, gpg_strerror (err));
688       goto leave;
689     }
690   if (result && *result)
691     log_debug ("dmsetup result: %s\n", result);
692   xfree (result);
693   result = NULL;
694
695   /* Mount if a mountpoint has been given.  */
696   if (ctrl->devti->mountpoint)
697     {
698       const char *argv[3];
699
700       argv[0] = targetname_abs;
701       argv[1] = ctrl->devti->mountpoint;
702       argv[2] = NULL;
703       log_debug ("now running \"mount %s %s\"\n",
704                  targetname_abs, ctrl->devti->mountpoint);
705       err = gnupg_exec_tool ("/bin/mount", argv, NULL, &result, NULL);
706       if (err)
707         {
708           log_error ("error running mount: %s\n", gpg_strerror (err));
709           goto leave;
710         }
711       if (result && *result)  /* (We should not see output to stdout).  */
712         log_info ("WARNING: mount returned data on stdout! (%s)\n", result);
713     }
714
715
716  leave:
717   wipememory (hexkey, sizeof hexkey);
718   if (table)
719     {
720       wipememory (table, strlen (table));
721       xfree (table);
722     }
723   xfree (targetname_abs);
724   xfree (result);
725   return err;
726 }
727
728
729 /* Unmount a DM-Crypt container on device DEVNAME and wipe the keys.  */
730 gpg_error_t
731 sh_dmcrypt_umount_container (ctrl_t ctrl, const char *devname)
732 {
733   gpg_error_t err;
734   char *targetname_abs = NULL;
735   char *result = NULL;
736
737   if (!ctrl->devti)
738     return gpg_error (GPG_ERR_INV_ARG);
739
740   g13_syshelp_i_know_what_i_am_doing ();
741
742   /* Check that the device is used by device mapper. */
743   err = check_blockdev (devname, 1);
744   if (gpg_err_code (err) != GPG_ERR_EBUSY)
745     {
746       log_error ("device '%s' is not used by the device mapper: %s\n",
747                  devname, gpg_strerror (err));
748       goto leave;
749     }
750
751   /* Fixme: Check that this is really a g13 partition.  */
752
753   /* Device mapper needs a name for the device: Take it from the label
754      or use "0".  */
755   targetname_abs = strconcat ("/dev/mapper/",
756                               "g13-", ctrl->client.uname, "-",
757                               ctrl->devti->label? ctrl->devti->label : "0",
758                               NULL);
759   if (!targetname_abs)
760     {
761       err = gpg_error_from_syserror ();
762       goto leave;
763     }
764
765   /* Run the regular umount command.  */
766   {
767     const char *argv[2];
768
769     argv[0] = targetname_abs;
770     argv[1] = NULL;
771     log_debug ("now running \"umount %s\"\n", targetname_abs);
772     err = gnupg_exec_tool ("/bin/umount", argv, NULL, &result, NULL);
773   }
774   if (err)
775     {
776       log_error ("error running umount: %s\n", gpg_strerror (err));
777       if (1)
778         {
779           /* Try to show some info about processes using the partition. */
780           const char *argv[3];
781
782           argv[0] = "-mv";
783           argv[1] = targetname_abs;
784           argv[2] = NULL;
785           gnupg_exec_tool ("/bin/fuser", argv, NULL, &result, NULL);
786         }
787       goto leave;
788     }
789   if (result && *result)  /* (We should not see output to stdout).  */
790     log_info ("WARNING: umount returned data on stdout! (%s)\n", result);
791   xfree (result);
792   result = NULL;
793
794   /* Run the dmsetup remove command.  */
795   {
796     const char *argv[3];
797
798     argv[0] = "remove";
799     argv[1] = targetname_abs;
800     argv[2] = NULL;
801     log_debug ("now running \"dmsetup remove %s\"\n", targetname_abs);
802     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
803   }
804   if (err)
805     {
806       log_error ("error running \"dmsetup remove %s\": %s\n",
807                  targetname_abs, gpg_strerror (err));
808       goto leave;
809     }
810   if (result && *result)
811     log_debug ("dmsetup result: %s\n", result);
812   xfree (result);
813   result = NULL;
814
815  leave:
816   xfree (targetname_abs);
817   xfree (result);
818   return err;
819 }
820
821
822 /* Suspend a DM-Crypt container on device DEVNAME and wipe the keys.  */
823 gpg_error_t
824 sh_dmcrypt_suspend_container (ctrl_t ctrl, const char *devname)
825 {
826   gpg_error_t err;
827   char *targetname_abs = NULL;
828   const char *targetname;
829   char *result = NULL;
830
831   if (!ctrl->devti)
832     return gpg_error (GPG_ERR_INV_ARG);
833
834   g13_syshelp_i_know_what_i_am_doing ();
835
836   /* Check that the device is used by device mapper. */
837   err = check_blockdev (devname, 1);
838   if (gpg_err_code (err) != GPG_ERR_EBUSY)
839     {
840       log_error ("device '%s' is not used by the device mapper: %s\n",
841                  devname, gpg_strerror (err));
842       goto leave;
843     }
844
845   /* Fixme: Check that this is really a g13 partition.  */
846
847   /* Device mapper needs a name for the device: Take it from the label
848      or use "0".  */
849   targetname_abs = strconcat ("/dev/mapper/",
850                               "g13-", ctrl->client.uname, "-",
851                               ctrl->devti->label? ctrl->devti->label : "0",
852                               NULL);
853   if (!targetname_abs)
854     {
855       err = gpg_error_from_syserror ();
856       goto leave;
857     }
858   targetname = strrchr (targetname_abs, '/');
859   if (!targetname)
860     BUG ();
861   targetname++;
862
863   /* Send the suspend command.  */
864   {
865     const char *argv[3];
866
867     argv[0] = "suspend";
868     argv[1] = targetname;
869     argv[2] = NULL;
870     log_debug ("now running \"dmsetup suspend %s\"\n", targetname);
871     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
872   }
873   if (err)
874     {
875       log_error ("error running \"dmsetup suspend %s\": %s\n",
876                  targetname, gpg_strerror (err));
877       goto leave;
878     }
879   if (result && *result)
880     log_debug ("dmsetup result: %s\n", result);
881   xfree (result);
882   result = NULL;
883
884   /* Send the wipe key command.  */
885   {
886     const char *argv[5];
887
888     argv[0] = "message";
889     argv[1] = targetname;
890     argv[2] = "0";
891     argv[3] = "key wipe";
892     argv[4] = NULL;
893     log_debug ("now running \"dmsetup message %s 0 key wipe\"\n", targetname);
894     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
895   }
896   if (err)
897     {
898       log_error ("error running \"dmsetup message %s 0 key wipe\": %s\n",
899                  targetname, gpg_strerror (err));
900       goto leave;
901     }
902   if (result && *result)
903     log_debug ("dmsetup result: %s\n", result);
904   xfree (result);
905   result = NULL;
906
907
908  leave:
909   xfree (targetname_abs);
910   xfree (result);
911   return err;
912 }
913
914
915 /* Resume a DM-Crypt container on device DEVNAME taking keys and other
916  * meta data from KEYBLOB.  */
917 gpg_error_t
918 sh_dmcrypt_resume_container (ctrl_t ctrl, const char *devname,
919                              tupledesc_t keyblob)
920 {
921   gpg_error_t err;
922   char *targetname_abs = NULL;
923   const char *targetname;
924   char hexkey[8+16*2+1]; /* 8 is used to prepend "key set ".  */
925   char *table = NULL;
926   char *result = NULL;
927   size_t n;
928   const char *s;
929   const char *algostr;
930   size_t algostrlen;
931
932   if (!ctrl->devti)
933     return gpg_error (GPG_ERR_INV_ARG);
934
935   g13_syshelp_i_know_what_i_am_doing ();
936
937   /* Check that the device is used by device mapper. */
938   err = check_blockdev (devname, 1);
939   if (gpg_err_code (err) != GPG_ERR_EBUSY)
940     {
941       log_error ("device '%s' is not used by the device mapper: %s\n",
942                  devname, gpg_strerror (err));
943       goto leave;
944     }
945
946   /* Device mapper needs a name for the device: Take it from the label
947      or use "0".  */
948   targetname_abs = strconcat ("/dev/mapper/",
949                               "g13-", ctrl->client.uname, "-",
950                               ctrl->devti->label? ctrl->devti->label : "0",
951                               NULL);
952   if (!targetname_abs)
953     {
954       err = gpg_error_from_syserror ();
955       goto leave;
956     }
957   targetname = strrchr (targetname_abs, '/');
958   if (!targetname)
959     BUG ();
960   targetname++;
961
962   /* Get the algorithm string.  */
963   algostr = find_tuple (keyblob, KEYBLOB_TAG_ALGOSTR, &algostrlen);
964   if (!algostr || algostrlen > 100)
965     {
966       log_error ("algo string not found in keyblob or too long\n");
967       err = gpg_error (GPG_ERR_INV_DATA);
968       goto leave;
969     }
970
971   /* Get the key.  */
972   s = find_tuple (keyblob, KEYBLOB_TAG_ENCKEY, &n);
973   if (!s || n != 16)
974     {
975       if (!s)
976         log_error ("no key found in keyblob\n");
977       else
978         log_error ("unexpected size of key (%zu)\n", n);
979       err = gpg_error (GPG_ERR_INV_KEYLEN);
980       goto leave;
981     }
982   strcpy (hexkey, "key set ");
983   bin2hex (s, 16, hexkey+8);
984
985   /* Send the key */
986   {
987     const char *argv[4];
988
989     argv[0] = "message";
990     argv[1] = targetname;
991     argv[2] = "0";
992     argv[3] = NULL;
993     log_debug ("now running \"dmsetup message %s 0 [key set]\"\n", targetname);
994     err = gnupg_exec_tool ("/sbin/dmsetup", argv, hexkey, &result, NULL);
995   }
996   wipememory (hexkey, sizeof hexkey);
997   if (err)
998     {
999       log_error ("error running \"dmsetup message %s 0 [key set]\": %s\n",
1000                  devname, gpg_strerror (err));
1001       goto leave;
1002     }
1003   if (result && *result)
1004     log_debug ("dmsetup result: %s\n", result);
1005   xfree (result);
1006   result = NULL;
1007
1008   /* Send the resume command. */
1009   {
1010     const char *argv[3];
1011
1012     argv[0] = "resume";
1013     argv[1] = targetname;
1014     argv[2] = NULL;
1015     log_debug ("now running \"dmsetup resume %s\"\n", targetname);
1016     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
1017   }
1018   if (err)
1019     {
1020       log_error ("error running \"dmsetup resume %s\": %s\n",
1021                  targetname, gpg_strerror (err));
1022       goto leave;
1023     }
1024   if (result && *result)
1025     log_debug ("dmsetup result: %s\n", result);
1026   xfree (result);
1027   result = NULL;
1028
1029  leave:
1030   wipememory (hexkey, sizeof hexkey);
1031   if (table)
1032     {
1033       wipememory (table, strlen (table));
1034       xfree (table);
1035     }
1036   xfree (targetname_abs);
1037   xfree (result);
1038   return err;
1039 }