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 }