g13: Require a confirmation before g13 is used for DM-Crypt.
[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 <http://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 inbetween.  */
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 /* Check whether the block device DEVNAME is used by device mapper.
76    Returns: 0 if the device is good and not yet used by DM.  */
77 static gpg_error_t
78 check_blockdev (const char *devname)
79 {
80   gpg_error_t err;
81   struct stat sb;
82   unsigned int devmajor, devminor;
83   char *result = NULL;
84   char **lines = NULL;
85   char **fields = NULL;
86   int lno, count;
87
88   if (stat (devname, &sb))
89     {
90       err = gpg_error_from_syserror ();
91       log_error ("error stating '%s': %s\n", devname, gpg_strerror (err));
92       return err;
93     }
94   if (!S_ISBLK (sb.st_mode))
95     {
96       err = gpg_error (GPG_ERR_ENOTBLK);
97       log_error ("can't use '%s': %s\n", devname, gpg_strerror (err));
98       return err;
99     }
100   devmajor = major (sb.st_rdev);
101   devminor = minor (sb.st_rdev);
102
103   {
104     const char *argv[2];
105
106     argv[0] = "deps";
107     argv[1] = NULL;
108     err = gnupg_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
109   }
110   if (err)
111     {
112       log_error ("error running '%s' to search for '%s': %s\n",
113                  "dmsetup deps", devname, gpg_strerror (err));
114       goto leave;
115     }
116   lines = strsplit (result, '\n', 0, NULL);
117   if (!lines)
118     {
119       err = gpg_error_from_syserror ();
120       goto leave;
121     }
122   if (lines[0] && !strcmp (lines[0], "No devices found"))
123     ;
124   else
125     {
126       for (lno=0; lines[lno]; lno++)
127         {
128           unsigned int xmajor, xminor;
129
130           if (!*lines[lno])
131             continue;
132           xfree (fields);
133           fields = strsplit (lines[lno], ':', 0, &count);
134           if (!fields)
135             {
136               err = gpg_error_from_syserror ();
137               goto leave;
138             }
139           if (count < 3
140               || sscanf (fields[2], " (%u,%u)", &xmajor, &xminor) != 2)
141             {
142               log_error ("error running '%s' to search for '%s': %s\n",
143                          "dmsetup deps", devname, "unexpected output");
144               err = gpg_error (GPG_ERR_INV_VALUE);
145               goto leave;
146             }
147
148           if (xmajor == devmajor && xminor == devminor)
149             {
150               log_error ("device '%s' (%u:%u) already used by device mapper\n",
151                          devname, devmajor, devminor);
152               err = gpg_error (GPG_ERR_EBUSY);
153               goto leave;
154             }
155         }
156     }
157
158
159  leave:
160   xfree (fields);
161   xfree (lines);
162   xfree (result);
163   return err;
164 }
165
166
167 /* Return a malloced buffer with the prefix of the setup area.  This
168    is the data written right before the encrypted keyblob.  Return NULL
169    on error and sets ERRNO.  */
170 static void *
171 mk_setup_area_prefix (size_t *r_length)
172 {
173   unsigned char *packet;
174   size_t setuparealen;
175
176   packet = xtrymalloc (32);
177   if (!packet)
178     return NULL;
179   *r_length = 32;
180
181   setuparealen = SETUP_AREA_SECTORS * SECTOR_SIZE;
182
183   packet[0] = (0xc0|61); /* CTB for the private packet type 0x61.  */
184   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
185   packet[2] = 0;
186   packet[3] = 0;
187   packet[4] = 0;
188   packet[5] = 26;
189   memcpy (packet+6, "GnuPG/G13", 10); /* Packet subtype.  */
190   packet[16] = 1;   /* G13 packet format version.  */
191   packet[17] = 0;   /* Reserved.  */
192   packet[18] = 0;   /* Reserved.  */
193   packet[19] = 1;   /* OS Flag = Linux  */
194   packet[20] = (setuparealen >> 24);  /* Total length of header.  */
195   packet[21] = (setuparealen >> 16);
196   packet[22] = (setuparealen >> 8);
197   packet[23] = (setuparealen);
198   packet[24] = HEADER_SETUP_AREA_COPIES;
199   packet[25] = FOOTER_SETUP_AREA_COPIES;
200   packet[26] = 0;   /* Reserved.  */
201   packet[27] = 0;   /* Reserved.  */
202   packet[28] = 0;   /* Reserved.  */
203   packet[29] = 0;   /* Reserved.  */
204   packet[30] = 0;   /* Reserved.  */
205   packet[31] = 0;   /* Reserved.  */
206
207   return packet;
208 }
209
210
211 /* Create a new g13 styloe DM-Crypt container on devoce DEVNAME.  */
212 gpg_error_t
213 sh_dmcrypt_create_container (ctrl_t ctrl, const char *devname, estream_t devfp)
214 {
215   gpg_error_t err;
216   char *header_space;
217   size_t header_space_size, header_space_used;
218   size_t paddinglen;
219   char *targetname = NULL;
220   size_t nread;
221   char *p;
222   char hexkey[16*2+1];
223   char *table = NULL;
224   unsigned long long nblocks;
225   char *result = NULL;
226   unsigned char twobyte[2];
227   membuf_t keyblob;
228   void  *keyblob_buf = NULL;
229   size_t keyblob_len;
230   size_t n;
231   const char *s;
232   unsigned char *packet;
233   int copy;
234
235   if (!ctrl->devti)
236     return gpg_error (GPG_ERR_INV_ARG);
237
238   g13_syshelp_i_know_what_i_am_doing ();
239
240   header_space_size = SETUP_AREA_SECTORS * SECTOR_SIZE;
241   header_space = xtrymalloc (header_space_size);
242   if (!header_space)
243     return gpg_error_from_syserror ();
244
245   /* Start building the keyblob.  */
246   init_membuf (&keyblob, 512);
247   append_tuple (&keyblob, KEYBLOB_TAG_BLOBVERSION, "\x01", 1);
248   n = CONTTYPE_DM_CRYPT;
249   twobyte[0] = (n >> 8);
250   twobyte[1] = n;
251   append_tuple (&keyblob, KEYBLOB_TAG_CONTTYPE, twobyte, 2);
252   {
253     gnupg_isotime_t tbuf;
254
255     gnupg_get_isotime (tbuf);
256     append_tuple (&keyblob, KEYBLOB_TAG_CREATED, tbuf, strlen (tbuf));
257   }
258
259   /* Rewind device stream.  */
260   if (es_fseeko (devfp, 0, SEEK_SET))
261     {
262       err = gpg_error_from_syserror ();
263       log_error ("error seeking to begin of '%s': %s\n",
264                  devname, gpg_strerror (err));
265       goto leave;
266     }
267   es_clearerr (devfp);
268
269   /* Extra check that the device is empty.  */
270   if (es_read (devfp, header_space, header_space_size, &nread))
271     err = gpg_error_from_syserror ();
272   else if (nread != header_space_size)
273     err = gpg_error (GPG_ERR_TOO_SHORT);
274   else
275     err = 0;
276   if (err)
277     {
278       log_error ("error reading header space of '%s': %s\n",
279                  devname, gpg_strerror (err));
280       goto leave;
281     }
282   for (p=header_space; nread && !*p; nread--, p++)
283     ;
284   if (nread)
285     {
286       log_error ("header space of '%s' already used - use %s to override\n",
287                  devname, "--force");
288       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
289       goto leave;
290     }
291
292   /* Check that the device is not used by device mapper. */
293   err = check_blockdev (devname);
294   if (err)
295     goto leave;
296
297   /* Compute the number of blocks.  */
298   err = sh_blockdev_getsz (devname, &nblocks);
299   if (err)
300     {
301       log_error ("error getting size of '%s': %s\n",
302                  devname, gpg_strerror (err));
303       goto leave;
304     }
305   if (nblocks <= HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS)
306     {
307       log_error ("device '%s' is too small (min=%d blocks)\n",
308                  devname,
309                  HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS);
310       err = gpg_error (GPG_ERR_TOO_SHORT);
311       goto leave;
312     }
313   append_tuple_uint (&keyblob, KEYBLOB_TAG_CONT_NSEC, nblocks);
314   nblocks -= HEADER_SECTORS + FOOTER_SECTORS;
315   append_tuple_uint (&keyblob, KEYBLOB_TAG_ENC_NSEC, nblocks);
316   append_tuple_uint (&keyblob, KEYBLOB_TAG_ENC_OFF, HEADER_SECTORS);
317
318   /* Device mapper needs a name for the device: Take it from the label
319      or use "0".  */
320   targetname = strconcat ("g13-", ctrl->client.uname, "-",
321                           ctrl->devti->label? ctrl->devti->label : "0",
322                           NULL);
323   if (!targetname)
324     {
325       err = gpg_error_from_syserror ();
326       goto leave;
327     }
328
329   /* Create the key.  */
330   {
331     char key[16];
332     gcry_randomize (key, sizeof key, GCRY_STRONG_RANDOM);
333     append_tuple (&keyblob, KEYBLOB_TAG_ENCKEY, key, sizeof key);
334     bin2hex (key, 16, hexkey);
335     wipememory (key, 16);
336     /* Add a 2*(4+16) byte filler to conceal the fact that we use
337        AES-128.  If we ever want to switch to 256 bit we can resize
338        that filler to keep the keyblob at the same size.  */
339     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
340     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
341   }
342
343   /* Build dmcrypt table. */
344   s = "aes-cbc-essiv:sha256";
345   append_tuple (&keyblob, KEYBLOB_TAG_ALGOSTR, s, strlen (s));
346   table = es_bsprintf ("0 %llu crypt %s %s 0 %s %d",
347                        nblocks, s, hexkey, devname, HEADER_SECTORS);
348   if (!table)
349     {
350       err = gpg_error_from_syserror ();
351       goto leave;
352     }
353   wipememory (hexkey, sizeof hexkey);
354
355   /* Add a copy of the setup area prefix to the keyblob.  */
356   p = mk_setup_area_prefix (&n);
357   if (!p)
358     {
359       err = gpg_error_from_syserror ();
360       goto leave;
361     }
362   append_tuple (&keyblob, KEYBLOB_TAG_HDRCOPY, p, n);
363   assert (n < header_space_size);
364   memcpy (header_space, p, n);
365   header_space_used = n;
366
367   /* Turn the keyblob into a buffer and callback to encrypt it.  */
368   keyblob_buf = get_membuf (&keyblob, &keyblob_len);
369   if (!keyblob_buf)
370     {
371       err = gpg_error_from_syserror ();
372       goto leave;
373     }
374   err = sh_encrypt_keyblob (ctrl, keyblob_buf, keyblob_len, &p, &n);
375   if (err)
376     {
377       log_error ("encrypting the keyblob failed: %s\n", gpg_strerror (err));
378       goto leave;
379     }
380   log_debug ("plain setuparea=%p %zu bytes\n", keyblob_buf, keyblob_len);
381   wipememory (keyblob_buf, keyblob_len);
382   xfree (keyblob_buf);
383   keyblob_buf = NULL;
384
385   log_debug ("encry setuparea=%p %zu bytes\n", p, n);
386   if (n >= header_space_size || (header_space_used + n) >= header_space_size)
387     {
388       err = gpg_error (GPG_ERR_TOO_LARGE);
389       log_error ("setup area would overflow: %s\n", gpg_strerror (err));
390       goto leave;
391     }
392   memcpy (header_space + header_space_used, p, n);
393   header_space_used += n;
394
395   /* Write the padding.  */
396   packet = header_space + header_space_used;
397   paddinglen = header_space_size - header_space_used;
398   if (paddinglen < 16)
399     {
400       err = gpg_error (GPG_ERR_TOO_LARGE);
401       log_error ("setup area too short for padding: %s\n", gpg_strerror (err));
402       goto leave;
403     }
404   packet[0] = (0xc0|61); /* CTB for Private packet type 0x61.  */
405   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
406   packet[2] = (paddinglen-6) >> 24;
407   packet[3] = (paddinglen-6) >> 16;
408   packet[4] = (paddinglen-6) >> 8;
409   packet[5] = (paddinglen-6);
410   packet += 6;
411   paddinglen -= 6;
412   header_space_used += 6;
413   for ( ;paddinglen >= 10;
414         paddinglen -= 10, packet += 10, header_space_used += 10)
415     memcpy (packet, "GnuPG/PAD", 10);
416   for ( ;paddinglen; paddinglen--, packet++, header_space_used++)
417     *packet = 0;
418
419   if (header_space_used != header_space_size)
420     BUG ();
421
422   /* Create the container.  */
423   {
424     const char *argv[3];
425
426     argv[0] = "create";
427     argv[1] = targetname;
428     argv[2] = NULL;
429     log_debug ("now running \"dmsetup create %s\"\n", targetname);
430     log_debug ("  with table='%s'\"\n", table);
431     err = gnupg_exec_tool ("/sbin/dmsetup", argv, table, &result, NULL);
432   }
433   if (err)
434     {
435       log_error ("error running dmsetup for '%s': %s\n",
436                  devname, gpg_strerror (err));
437       goto leave;
438     }
439   if (result && *result)
440     log_debug ("dmsetup result: %s\n", result);
441
442   /* Write the setup area.  */
443   if (es_fseeko (devfp, 0, SEEK_SET))
444     {
445       err = gpg_error_from_syserror ();
446       log_error ("error seeking to begin of '%s': %s\n",
447                  devname, gpg_strerror (err));
448       goto leave;
449     }
450   es_clearerr (devfp);
451
452   for (copy = 0; copy < HEADER_SETUP_AREA_COPIES; copy++)
453     {
454       size_t nwritten;
455
456       if (es_write (devfp, header_space, header_space_size, &nwritten))
457         {
458           err = gpg_error_from_syserror ();
459           break;
460         }
461       else if (nwritten != header_space_size)
462         {
463           err = gpg_error (GPG_ERR_TOO_SHORT);
464           break;
465         }
466     }
467   if (err)
468     {
469       log_error ("error writing header space copy %d of '%s': %s\n",
470                  copy, devname, gpg_strerror (err));
471       goto leave;
472     }
473
474   if (es_fseeko (devfp,
475                  (- header_space_size * FOOTER_SETUP_AREA_COPIES), SEEK_END))
476     {
477       err = gpg_error_from_syserror ();
478       log_error ("error seeking to end of '%s': %s\n",
479                  devname, gpg_strerror (err));
480       goto leave;
481     }
482   es_clearerr (devfp);
483
484   for (copy = 0; copy < FOOTER_SETUP_AREA_COPIES; copy++)
485     {
486       size_t nwritten;
487
488       if (es_write (devfp, header_space, header_space_size, &nwritten))
489         {
490           err = gpg_error_from_syserror ();
491           break;
492         }
493       else if (nwritten != header_space_size)
494         {
495           err = gpg_error (GPG_ERR_TOO_SHORT);
496           break;
497         }
498     }
499   if (!err && es_fflush (devfp))
500     err = gpg_error_from_syserror ();
501   if (err)
502     {
503       log_error ("error writing footer space copy %d of '%s': %s\n",
504                  copy, devname, gpg_strerror (err));
505       goto leave;
506     }
507
508  leave:
509   wipememory (hexkey, sizeof hexkey);
510   if (table)
511     {
512       wipememory (table, strlen (table));
513       xfree (table);
514     }
515   if (keyblob_buf)
516     {
517       wipememory (keyblob_buf, keyblob_len);
518       xfree (keyblob_buf);
519     }
520   xfree (get_membuf (&keyblob, NULL));
521   xfree (targetname);
522   xfree (result);
523   xfree (header_space);
524   return err;
525 }
526
527
528 /* Mount a DM-Crypt congtainer on device DEVNAME taking keys and other
529  * meta data from KEYBLOB.  */
530 gpg_error_t
531 sh_dmcrypt_mount_container (ctrl_t ctrl, const char *devname,
532                             tupledesc_t keyblob)
533 {
534   gpg_error_t err;
535   char *targetname = NULL;
536   char hexkey[16*2+1];
537   char *table = NULL;
538   unsigned long long nblocks, nblocks2;
539   char *result = NULL;
540   size_t n;
541   const char *s;
542   const char *algostr;
543   size_t algostrlen;
544
545   if (!ctrl->devti)
546     return gpg_error (GPG_ERR_INV_ARG);
547
548   g13_syshelp_i_know_what_i_am_doing ();
549
550   /* Check that the device is not yet used by device mapper. */
551   err = check_blockdev (devname);
552   if (err)
553     goto leave;
554
555   /* Compute the number of blocks and compare them to the value
556      provided as meta data.  */
557   err = sh_blockdev_getsz (devname, &nblocks);
558   if (err)
559     {
560       log_error ("error getting size of '%s': %s\n",
561                  devname, gpg_strerror (err));
562       goto leave;
563     }
564   err = find_tuple_uint (keyblob, KEYBLOB_TAG_CONT_NSEC, &nblocks2);
565   if (err)
566     {
567       log_error ("error getting size from keyblob: %s\n", gpg_strerror (err));
568       goto leave;
569     }
570   if (nblocks != nblocks2)
571     {
572       log_error ("inconsistent size of container: expected==%llu got=%llu\n",
573                  nblocks2, nblocks);
574       err = gpg_error (GPG_ERR_INV_DATA);
575       goto leave;
576     }
577   if (nblocks <= HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS)
578     {
579       log_error ("device '%s' is too small (min=%d blocks)\n",
580                  devname,
581                  HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS);
582       err = gpg_error (GPG_ERR_TOO_SHORT);
583       goto leave;
584     }
585   nblocks -= HEADER_SECTORS + FOOTER_SECTORS;
586   err = find_tuple_uint (keyblob, KEYBLOB_TAG_ENC_NSEC, &nblocks2);
587   if (err)
588     {
589       log_error ("error getting enc size from keyblob: %s\n",
590                  gpg_strerror (err));
591       goto leave;
592     }
593   if (nblocks != nblocks2)
594     {
595       log_error ("inconsistent size of enc data: expected==%llu got=%llu\n",
596                  nblocks2, nblocks);
597       err = gpg_error (GPG_ERR_INV_DATA);
598       goto leave;
599     }
600   /* Check that the offset is consistent.  */
601   err = find_tuple_uint (keyblob, KEYBLOB_TAG_ENC_OFF, &nblocks2);
602   if (err)
603     {
604       log_error ("error getting enc offset from keyblob: %s\n",
605                  gpg_strerror (err));
606       goto leave;
607     }
608   if (nblocks2 != HEADER_SECTORS)
609     {
610       log_error ("inconsistent offset of enc data: expected==%llu got=%d\n",
611                  nblocks2, HEADER_SECTORS);
612       err = gpg_error (GPG_ERR_INV_DATA);
613       goto leave;
614     }
615
616   /* Device mapper needs a name for the device: Take it from the label
617      or use "0".  */
618   targetname = strconcat ("g13-", ctrl->client.uname, "-",
619                           ctrl->devti->label? ctrl->devti->label : "0",
620                           NULL);
621   if (!targetname)
622     {
623       err = gpg_error_from_syserror ();
624       goto leave;
625     }
626
627   /* Get the algorithm string.  */
628   algostr = find_tuple (keyblob, KEYBLOB_TAG_ALGOSTR, &algostrlen);
629   if (!algostr || algostrlen > 100)
630     {
631       log_error ("algo string not found in keyblob or too long\n");
632       err = gpg_error (GPG_ERR_INV_DATA);
633       goto leave;
634     }
635
636   /* Get the key.  */
637   s = find_tuple (keyblob, KEYBLOB_TAG_ENCKEY, &n);
638   if (!s || n != 16)
639     {
640       if (!s)
641         log_error ("no key found in keyblob\n");
642       else
643         log_error ("unexpected size of key (%zu)\n", n);
644       err = gpg_error (GPG_ERR_INV_KEYLEN);
645       goto leave;
646     }
647   bin2hex (s, 16, hexkey);
648
649   /* Build dmcrypt table. */
650   table = es_bsprintf ("0 %llu crypt %.*s %s 0 %s %d",
651                        nblocks, (int)algostrlen, algostr,
652                        hexkey, devname, HEADER_SECTORS);
653   wipememory (hexkey, sizeof hexkey);
654   if (!table)
655     {
656       err = gpg_error_from_syserror ();
657       goto leave;
658     }
659
660   /* Load the table.  */
661   {
662     const char *argv[3];
663
664     argv[0] = "create";
665     argv[1] = targetname;
666     argv[2] = NULL;
667     log_debug ("now running \"dmsetup create %s\"\n", targetname);
668     err = gnupg_exec_tool ("/sbin/dmsetup", argv, table, &result, NULL);
669   }
670   if (err)
671     {
672       log_error ("error running dmsetup for '%s': %s\n",
673                  devname, gpg_strerror (err));
674       goto leave;
675     }
676   if (result && *result)
677     log_debug ("dmsetup result: %s\n", result);
678
679
680  leave:
681   wipememory (hexkey, sizeof hexkey);
682   if (table)
683     {
684       wipememory (table, strlen (table));
685       xfree (table);
686     }
687   xfree (targetname);
688   xfree (result);
689   return err;
690 }