g13: First chunk of code to support dm-crypt.
[gnupg.git] / g13 / sh-dmcrypt.c
1 /* sh-dmcrypt.c - The DM-Crypt part for g13-syshelp
2  * Copyright (C) 2015 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 "utils.h"
37 #include "keyblob.h"
38
39 /* The standard disk block size (logical).  */
40 #define SECTOR_SIZE 512
41
42 /* The physical block size used by modern devices.  */
43 #define PHY_SECTOR_SIZE  (SECTOR_SIZE*8)  /* 4 KiB */
44
45 /* The length of the crypto setup area in sectors.  16 KiB is a nice
46    multiple of a modern block size and should be sufficient for all
47    kind of extra public key encryption packet.  */
48 #define SETUP_AREA_SECTORS 32  /* 16 KiB */
49
50 /* The number of header block copies stored at the begin and end of
51    the device.  */
52 #define HEADER_SETUP_AREA_COPIES 2
53 #define FOOTER_SETUP_AREA_COPIES 2
54
55 /* The length in blocks of the space we put at the start and at the
56    end of the device.  This space is used to store N copies of the
57    setup area for the actual encrypted container inbetween.  */
58 #define HEADER_SECTORS (SETUP_AREA_SECTORS * HEADER_SETUP_AREA_COPIES)
59 #define FOOTER_SECTORS (SETUP_AREA_SECTORS * FOOTER_SETUP_AREA_COPIES)
60
61 /* Minimim size of the encrypted space in blocks.  This is more or
62    less an arbitrary value.  */
63 #define MIN_ENCRYPTED_SPACE 32
64
65 /* Some consistency checks for the above constants.  */
66 #if (PHY_SECTOR_SIZE % SECTOR_SIZE)
67 # error the physical secotor size should be a multiple of 512
68 #endif
69 #if ((SETUP_AREA_SECTORS*SECTOR_SIZE) % PHY_SECTOR_SIZE)
70 # error The setup area size should be a multiple of the phy. sector size.
71 #endif
72
73
74 /* Check whether the block device DEVNAME is used by device mapper.
75    Returns: 0 if the device is good and not yet used by DM.  */
76 static gpg_error_t
77 check_blockdev (const char *devname)
78 {
79   gpg_error_t err;
80   struct stat sb;
81   unsigned int devmajor, devminor;
82   char *result = NULL;
83   char **lines = NULL;
84   char **fields = NULL;
85   int lno, count;
86
87   if (stat (devname, &sb))
88     {
89       err = gpg_error_from_syserror ();
90       log_error ("error stating '%s': %s\n", devname, gpg_strerror (err));
91       return err;
92     }
93   if (!S_ISBLK (sb.st_mode))
94     {
95       err = gpg_error (GPG_ERR_ENOTBLK);
96       log_error ("can't use '%s': %s\n", devname, gpg_strerror (err));
97       return err;
98     }
99   devmajor = major (sb.st_rdev);
100   devminor = minor (sb.st_rdev);
101
102   {
103     const char *argv[2];
104
105     argv[0] = "deps";
106     argv[1] = NULL;
107     err = sh_exec_tool ("/sbin/dmsetup", argv, NULL, &result, NULL);
108   }
109   if (err)
110     {
111       log_error ("error running '%s' to search for '%s': %s\n",
112                  "dmsetup deps", devname, gpg_strerror (err));
113       goto leave;
114     }
115   lines = strsplit (result, '\n', 0, NULL);
116   if (!lines)
117     {
118       err = gpg_error_from_syserror ();
119       goto leave;
120     }
121   if (lines[0] && !strcmp (lines[0], "No devices found"))
122     ;
123   else
124     {
125       for (lno=0; lines[lno]; lno++)
126         {
127           unsigned int xmajor, xminor;
128
129           if (!*lines[lno])
130             continue;
131           xfree (fields);
132           fields = strsplit (lines[lno], ':', 0, &count);
133           if (!fields)
134             {
135               err = gpg_error_from_syserror ();
136               goto leave;
137             }
138           if (count < 3
139               || sscanf (fields[2], " (%u,%u)", &xmajor, &xminor) != 2)
140             {
141               log_error ("error running '%s' to search for '%s': %s\n",
142                          "dmsetup deps", devname, "unexpected output");
143               err = gpg_error (GPG_ERR_INV_VALUE);
144               goto leave;
145             }
146
147           if (xmajor == devmajor && xminor == devminor)
148             {
149               log_error ("device '%s' (%u:%u) already used by device mapper\n",
150                          devname, devmajor, devminor);
151               err = gpg_error (GPG_ERR_EBUSY);
152               goto leave;
153             }
154         }
155     }
156
157
158  leave:
159   xfree (fields);
160   xfree (lines);
161   xfree (result);
162   return err;
163 }
164
165
166 /* Return a malloced buffer with the prefix of the setup area.  This
167    is the data written right before the encrypted keyblob.  Return NULL
168    on error and sets ERRNO.  */
169 static void *
170 mk_setup_area_prefix (size_t *r_length)
171 {
172   unsigned char *packet;
173   size_t setuparealen;
174
175   packet = xtrymalloc (32);
176   if (!packet)
177     return NULL;
178   *r_length = 32;
179
180   setuparealen = SETUP_AREA_SECTORS * SECTOR_SIZE;
181
182   packet[0] = (0xc0|61); /* CTB for the private packet type 0x61.  */
183   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
184   packet[2] = 0;
185   packet[3] = 0;
186   packet[4] = 0;
187   packet[5] = 26;
188   memcpy (packet+6, "GnuPG/G13", 10); /* Packet subtype.  */
189   packet[16] = 1;   /* G13 packet format version.  */
190   packet[17] = 0;   /* Reserved.  */
191   packet[18] = 0;   /* Reserved.  */
192   packet[19] = 1;   /* OS Flag = Linux  */
193   packet[20] = (setuparealen >> 24);  /* Total length of header.  */
194   packet[21] = (setuparealen >> 16);
195   packet[22] = (setuparealen >> 8);
196   packet[23] = (setuparealen);
197   packet[24] = HEADER_SETUP_AREA_COPIES;
198   packet[25] = FOOTER_SETUP_AREA_COPIES;
199   packet[26] = 0;   /* Reserved.  */
200   packet[27] = 0;   /* Reserved.  */
201   packet[28] = 0;   /* Reserved.  */
202   packet[29] = 0;   /* Reserved.  */
203   packet[30] = 0;   /* Reserved.  */
204   packet[31] = 0;   /* Reserved.  */
205
206   return packet;
207 }
208
209
210 gpg_error_t
211 sh_dmcrypt_create_container (ctrl_t ctrl, const char *devname, estream_t devfp)
212 {
213   gpg_error_t err;
214   char *header_space;
215   char *targetname = NULL;
216   size_t nread;
217   char *p;
218   char hexkey[16*2+1];
219   char *table = NULL;
220   unsigned long long nblocks;
221   char *result = NULL;
222   unsigned char twobyte[2];
223   membuf_t keyblob;
224   void  *keyblob_buf = NULL;
225   size_t keyblob_len;
226   size_t n;
227   const char *s;
228
229   if (!ctrl->devti)
230     return gpg_error (GPG_ERR_INV_ARG);
231
232   header_space = xtrymalloc (HEADER_SECTORS * SECTOR_SIZE);
233   if (!header_space)
234     return gpg_error_from_syserror ();
235
236   /* Start building the keyblob.  */
237   init_membuf (&keyblob, 512);
238   append_tuple (&keyblob, KEYBLOB_TAG_BLOBVERSION, "\x01", 1);
239   n = CONTTYPE_DM_CRYPT;
240   twobyte[0] = (n >> 8);
241   twobyte[1] = n;
242   append_tuple (&keyblob, KEYBLOB_TAG_CONTTYPE, twobyte, 2);
243   {
244     gnupg_isotime_t tbuf;
245
246     gnupg_get_isotime (tbuf);
247     append_tuple (&keyblob, KEYBLOB_TAG_CREATED, tbuf, strlen (tbuf));
248   }
249
250   /* Rewind out stream.  */
251   if (es_fseeko (devfp, 0, SEEK_SET))
252     {
253       err = gpg_error_from_syserror ();
254       log_error ("error seeking to begin of '%s': %s\n",
255                  devname, gpg_strerror (err));
256       goto leave;
257     }
258   es_clearerr (devfp);
259
260   /* Extra check that the device is empty.  */
261   if (es_read (devfp, header_space, HEADER_SECTORS * SECTOR_SIZE, &nread))
262     err = gpg_error_from_syserror ();
263   else if (nread != HEADER_SECTORS * SECTOR_SIZE)
264     err = gpg_error (GPG_ERR_TOO_SHORT);
265   else
266     err = 0;
267   if (err)
268     {
269       log_error ("error reading header space of '%s': %s\n",
270                  devname, gpg_strerror (err));
271       goto leave;
272     }
273   for (p=header_space; nread && !*p; nread--, p++)
274     ;
275   if (nread)
276     {
277       log_error ("header space of '%s' already used - use %s to override\n",
278                  devname, "--force");
279       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
280       goto leave;
281     }
282
283   /* Check that the device is not used by device mapper. */
284   err = check_blockdev (devname);
285   if (err)
286     goto leave;
287
288   /* Compute the number of blocks.  */
289   err = sh_blockdev_getsz (devname, &nblocks);
290   if (err)
291     {
292       log_error ("error getting size of '%s': %s\n",
293                  devname, gpg_strerror (err));
294       goto leave;
295     }
296   if (nblocks <= HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS)
297     {
298       log_error ("device '%s' is too small (min=%d blocks)\n",
299                  devname,
300                  HEADER_SECTORS + MIN_ENCRYPTED_SPACE + FOOTER_SECTORS);
301       err = gpg_error (GPG_ERR_TOO_SHORT);
302       goto leave;
303     }
304   nblocks -= HEADER_SECTORS + FOOTER_SECTORS;
305
306   /* Device mapper needs a name for the device: Take it from the label
307      or use "0".  */
308   targetname = strconcat ("g13-", ctrl->client.uname, "-",
309                           ctrl->devti->label? ctrl->devti->label : "0",
310                           NULL);
311   if (!targetname)
312     {
313       err = gpg_error_from_syserror ();
314       goto leave;
315     }
316
317   /* Create the key.  */
318   {
319     char key[16];
320     gcry_randomize (key, sizeof key, GCRY_STRONG_RANDOM);
321     append_tuple (&keyblob, KEYBLOB_TAG_ENCKEY, key, sizeof key);
322     bin2hex (key, 16, hexkey);
323     wipememory (key, 16);
324     /* Add a 2*(4+16) byte filler to conceal the fact that we use
325        AES-128.  If we ever want to switch to 256 bit we can resize
326        that filler to keep the keyblob at the same size.  */
327     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
328     append_tuple (&keyblob, KEYBLOB_TAG_FILLER, key, sizeof key);
329   }
330
331   /* Build dmcrypt table. */
332   s = "aes-cbc-essiv:sha256";
333   append_tuple (&keyblob, KEYBLOB_TAG_ALGOSTR, s, strlen (s));
334   table = es_bsprintf ("0 %llu crypt %s %s 0 %s %d",
335                        nblocks, s, hexkey, devname, HEADER_SECTORS);
336   if (!table)
337     {
338       err = gpg_error_from_syserror ();
339       goto leave;
340     }
341   wipememory (hexkey, sizeof hexkey);
342
343   /* Add a copy of the setup area prefix to the keyblob.  */
344   p = mk_setup_area_prefix (&n);
345   if (!p)
346     {
347       err = gpg_error_from_syserror ();
348       goto leave;
349     }
350   append_tuple (&keyblob, KEYBLOB_TAG_HDRCOPY, p, n);
351
352   /* Turn the keyblob into a buffer and callback to encrypt it.  */
353   keyblob_buf = get_membuf (&keyblob, &keyblob_len);
354   if (!keyblob_buf)
355     {
356       err = gpg_error_from_syserror ();
357       goto leave;
358     }
359   err = sh_encrypt_keyblob (ctrl, keyblob_buf, keyblob_len, &p, &n);
360   if (err)
361     {
362       log_error ("encrypting the keyblob failed: %s\n", gpg_strerror (err));
363       goto leave;
364     }
365   wipememory (keyblob_buf, keyblob_len);
366   xfree (keyblob_buf);
367   keyblob_buf = NULL;
368
369   /* Create the container.  */
370   /* { */
371   /*   const char *argv[3]; */
372
373   /*   argv[0] = "create"; */
374   /*   argv[1] = targetname; */
375   /*   argv[2] = NULL; */
376   /*   err = sh_exec_tool ("/sbin/dmsetup", argv, table, &result, NULL); */
377   /* } */
378   /* if (err) */
379   /*   { */
380   /*     log_error ("error running dmsetup for '%s': %s\n", */
381   /*                devname, gpg_strerror (err)); */
382   /*     goto leave; */
383   /*   } */
384   /* log_debug ("dmsetup result: %s\n", result); */
385
386   /* Write the setup area.  */
387
388
389  leave:
390   wipememory (hexkey, sizeof hexkey);
391   if (table)
392     {
393       wipememory (table, strlen (table));
394       xfree (table);
395     }
396   if (keyblob_buf)
397     {
398       wipememory (keyblob_buf, keyblob_len);
399       xfree (keyblob_buf);
400     }
401   xfree (get_membuf (&keyblob, NULL));
402   xfree (targetname);
403   xfree (result);
404   xfree (header_space);
405   return err;
406 }