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