gpg: Auto-migrate existing secring.gpg.
[gnupg.git] / g13 / create.c
1 /* create.c - Create a new crypto container
2  * Copyright (C) 2009 Free Software Foundation, Inc.
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 <errno.h>
25 #include <unistd.h>
26 #include <sys/stat.h>
27 #include <assert.h>
28
29 #include "g13.h"
30 #include "i18n.h"
31 #include "create.h"
32
33 #include "keyblob.h"
34 #include "backend.h"
35 #include "utils.h"
36 #include "call-gpg.h"
37 #include "estream.h"
38
39 /* Create a new blob with all the session keys and other meta
40    information which are to be stored encrypted in the crypto
41    container header.  On success the malloced blob is stored at R_BLOB
42    and its length at R_BLOBLEN.  On error an error code is returned
43    and (R_BLOB,R_BLOBLEN) are set to (NULL,0).
44
45    The format of this blob is a sequence of tag-length-value tuples.
46    All tuples have this format:
47
48      2 byte TAG           Big endian unsigned integer (0..65535)
49                           described by the KEYBLOB_TAG_ constants.
50      2 byte LENGTH        Big endian unsigned integer (0..65535)
51                           giving the length of the value.
52      length bytes VALUE   The value described by the tag.
53
54    The first tag in a keyblob must be a BLOBVERSION.  The other tags
55    depend on the type of the container as described by the CONTTYPE
56    tag.  See keyblob.h for details.  */
57 static gpg_error_t
58 create_new_keyblob (ctrl_t ctrl, int is_detached,
59                     void **r_blob, size_t *r_bloblen)
60 {
61   gpg_error_t err;
62   unsigned char twobyte[2];
63   membuf_t mb;
64
65   *r_blob = NULL;
66   *r_bloblen = 0;
67
68   init_membuf_secure (&mb, 512);
69
70   append_tuple (&mb, KEYBLOB_TAG_BLOBVERSION, "\x01", 1);
71
72   twobyte[0] = (ctrl->conttype >> 8);
73   twobyte[1] = (ctrl->conttype);
74   append_tuple (&mb, KEYBLOB_TAG_CONTTYPE, twobyte, 2);
75   if (is_detached)
76     append_tuple (&mb, KEYBLOB_TAG_DETACHED, NULL, 0);
77
78   err = be_create_new_keys (ctrl->conttype, &mb);
79   if (err)
80     goto leave;
81
82   /* Just for testing.  */
83   append_tuple (&mb, KEYBLOB_TAG_FILLER, "filler", 6);
84
85   *r_blob = get_membuf (&mb, r_bloblen);
86   if (!*r_blob)
87     {
88       err = gpg_error_from_syserror ();
89       *r_bloblen = 0;
90     }
91   else
92     log_debug ("used keyblob size is %zu\n", *r_bloblen);
93
94  leave:
95   xfree (get_membuf (&mb, NULL));
96   return err;
97 }
98
99
100
101 /* Encrypt the keyblob (KEYBLOB,KEYBLOBLEN) and store the result at
102    (R_ENCBLOB, R_ENCBLOBLEN).  Returns 0 on success or an error code.
103    On error R_EKYBLOB is set to NULL.  Depending on the keys set in
104    CTRL the result is a single OpenPGP binary message, a single
105    special OpenPGP packet encapsulating a CMS message or a
106    concatenation of both with the CMS packet being the last.  */
107 static gpg_error_t
108 encrypt_keyblob (ctrl_t ctrl, void *keyblob, size_t keybloblen,
109                  strlist_t keys,
110                  void **r_encblob, size_t *r_encbloblen)
111 {
112   gpg_error_t err;
113
114   /* FIXME:  For now we only implement OpenPGP.  */
115   err = gpg_encrypt_blob (ctrl, keyblob, keybloblen, keys,
116                           r_encblob, r_encbloblen);
117
118   return err;
119 }
120
121
122 /* Write a new file under the name FILENAME with the keyblob and an
123    appropriate header.  This fucntion is called with a lock file in
124    place and after checking that the filename does not exists.  */
125 static gpg_error_t
126 write_keyblob (const char *filename,
127                const void *keyblob, size_t keybloblen)
128 {
129   gpg_error_t err;
130   estream_t fp;
131   unsigned char packet[32];
132   size_t headerlen, paddinglen;
133
134   fp = es_fopen (filename, "wbx");
135   if (!fp)
136     {
137       err = gpg_error_from_syserror ();
138       log_error ("error creating new container '%s': %s\n",
139                  filename, gpg_strerror (err));
140       return err;
141     }
142
143   /* Allow for an least 8 times larger keyblob to accommodate for
144      future key changes.  Round it up to 4096 byte. */
145   headerlen = ((32 + 8 * keybloblen + 16) + 4095) / 4096 * 4096;
146   paddinglen = headerlen - 32 - keybloblen;
147   assert (paddinglen >= 16);
148
149   packet[0] = (0xc0|61); /* CTB for the private packet type 0x61.  */
150   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
151   packet[2] = 0;
152   packet[3] = 0;
153   packet[4] = 0;
154   packet[5] = 26;
155   memcpy (packet+6, "GnuPG/G13", 10); /* Packet subtype.  */
156   packet[16] = 1;   /* G13 packet format version.  */
157   packet[17] = 0;   /* Reserved.  */
158   packet[18] = 0;   /* Reserved.  */
159   packet[19] = 0;   /* OS Flag.  */
160   packet[20] = (headerlen >> 24);  /* Total length of header.  */
161   packet[21] = (headerlen >> 16);
162   packet[22] = (headerlen >> 8);
163   packet[23] = (headerlen);
164   packet[24] = 1;   /* Number of header copies.  */
165   packet[25] = 0;   /* Number of header copies at the end.  */
166   packet[26] = 0;   /* Reserved.  */
167   packet[27] = 0;   /* Reserved.  */
168   packet[28] = 0;   /* Reserved.  */
169   packet[29] = 0;   /* Reserved.  */
170   packet[30] = 0;   /* Reserved.  */
171   packet[31] = 0;   /* Reserved.  */
172
173   if (es_fwrite (packet, 32, 1, fp) != 1)
174     goto writeerr;
175
176   if (es_fwrite (keyblob, keybloblen, 1, fp) != 1)
177     goto writeerr;
178
179   /* Write the padding.  */
180   packet[0] = (0xc0|61); /* CTB for Private packet type 0x61.  */
181   packet[1] = 0xff;      /* 5 byte length packet, value 20.  */
182   packet[2] = (paddinglen-6) >> 24;
183   packet[3] = (paddinglen-6) >> 16;
184   packet[4] = (paddinglen-6) >> 8;
185   packet[5] = (paddinglen-6);
186   memcpy (packet+6, "GnuPG/PAD", 10); /* Packet subtype.  */
187   if (es_fwrite (packet, 16, 1, fp) != 1)
188     goto writeerr;
189   memset (packet, 0, 32);
190   for (paddinglen-=16; paddinglen >= 32; paddinglen -= 32)
191     if (es_fwrite (packet, 32, 1, fp) != 1)
192       goto writeerr;
193   if (paddinglen)
194     if (es_fwrite (packet, paddinglen, 1, fp) != 1)
195       goto writeerr;
196
197   if (es_fclose (fp))
198     {
199       err = gpg_error_from_syserror ();
200       log_error ("error closing '%s': %s\n",
201                  filename, gpg_strerror (err));
202       remove (filename);
203       return err;
204     }
205
206   return 0;
207
208
209  writeerr:
210   err = gpg_error_from_syserror ();
211   log_error ("error writing header to '%s': %s\n",
212              filename, gpg_strerror (err));
213   es_fclose (fp);
214   remove (filename);
215   return err;
216 }
217
218
219
220 /* Create a new container under the name FILENAME and intialize it
221    using the current settings.  KEYS is a list of public keys to which
222    the container will be encrypted.  If the file already exists an
223    error is returned.  */
224 gpg_error_t
225 g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
226 {
227   gpg_error_t err;
228   dotlock_t lock;
229   void *keyblob = NULL;
230   size_t keybloblen;
231   void *enckeyblob = NULL;
232   size_t enckeybloblen;
233   char *detachedname = NULL;
234   int detachedisdir;
235   tupledesc_t tuples = NULL;
236   unsigned int dummy_rid;
237
238   if (!keys)
239     return gpg_error (GPG_ERR_NO_PUBKEY);
240
241   /* A quick check to see that no container with that name already
242      exists.  */
243   if (!access (filename, F_OK))
244     return gpg_error (GPG_ERR_EEXIST);
245
246   /* Take a lock and proceed with the creation.  If there is a lock we
247      immediately return an error because for creation it does not make
248      sense to wait.  */
249   lock = dotlock_create (filename, 0);
250   if (!lock)
251     return gpg_error_from_syserror ();
252   if (dotlock_take (lock, 0))
253     {
254       err = gpg_error_from_syserror ();
255       goto leave;
256     }
257   else
258     err = 0;
259
260   /* Check again that the file does not exist.  */
261   {
262       struct stat sb;
263
264       if (!stat (filename, &sb))
265         {
266           err = gpg_error (GPG_ERR_EEXIST);
267           goto leave;
268         }
269   }
270   /* And a possible detached file or directory may not exist either.  */
271   err = be_get_detached_name (ctrl->conttype, filename,
272                               &detachedname, &detachedisdir);
273   if (err)
274     goto leave;
275   if (detachedname)
276     {
277       struct stat sb;
278
279       if (!stat (detachedname, &sb))
280         {
281           err = gpg_error (GPG_ERR_EEXIST);
282           goto leave;
283         }
284     }
285
286   /* Create a new keyblob.  */
287   err = create_new_keyblob (ctrl, !!detachedname, &keyblob, &keybloblen);
288   if (err)
289     goto leave;
290
291   /* Encrypt that keyblob.  */
292   err = encrypt_keyblob (ctrl, keyblob, keybloblen, keys,
293                          &enckeyblob, &enckeybloblen);
294   if (err)
295     goto leave;
296
297   /* Put a copy of the keyblob into a tuple structure.  */
298   err = create_tupledesc (&tuples, keyblob, keybloblen);
299   if (err)
300     goto leave;
301   keyblob = NULL;
302   /* if (opt.verbose) */
303   /*   dump_keyblob (tuples); */
304
305   /* Write out the header, the encrypted keyblob and some padding. */
306   err = write_keyblob (filename, enckeyblob, enckeybloblen);
307   if (err)
308     goto leave;
309
310   /* Create and append the container.  FIXME: We should pass the
311      estream object in addition to the filename, so that the backend
312      can append the container to the g13 file.  */
313   err = be_create_container (ctrl, ctrl->conttype, filename, -1, tuples,
314                              &dummy_rid);
315
316
317  leave:
318   destroy_tupledesc (tuples);
319   xfree (detachedname);
320   xfree (enckeyblob);
321   xfree (keyblob);
322   dotlock_destroy (lock);
323
324   return err;
325 }