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