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