tests: Silence output of some tests.
[gnupg.git] / g13 / keyblob.c
1 /* keyblob.c - Keyblob parser and builder.
2  * Copyright (C) 2009 Free Software Foundation, Inc.
3  * Copyright (C) 2015-2016 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <sys/stat.h>
28 #include <assert.h>
29
30 #include "g13.h"
31 #include "i18n.h"
32 #include "mount.h"
33
34 #include "keyblob.h"
35 #include "../common/sysutils.h"
36 #include "../common/call-gpg.h"
37 #include "host2net.h"
38
39
40 /* Parse the header prefix and return the length of the entire header.  */
41 static gpg_error_t
42 parse_header (const char *filename,
43               const unsigned char *packet, size_t packetlen,
44               size_t *r_headerlen)
45 {
46   unsigned int len;
47
48   if (packetlen != 32)
49     return gpg_error (GPG_ERR_BUG);
50
51   len = buf32_to_uint (packet+2);
52   if (packet[0] != (0xc0|61) || len < 26
53       || memcmp (packet+6, "GnuPG/G13", 10))
54     {
55       log_error ("file '%s' is not valid container\n", filename);
56       return gpg_error (GPG_ERR_INV_OBJ);
57     }
58   if (packet[16] != 1)
59     {
60       log_error ("unknown version %u of container '%s'\n",
61                  (unsigned int)packet[16], filename);
62       return gpg_error (GPG_ERR_INV_OBJ);
63     }
64   if (packet[17] || packet[18]
65       || packet[26] || packet[27] || packet[28] || packet[29]
66       || packet[30] || packet[31])
67     log_info ("WARNING: unknown meta information in '%s'\n", filename);
68   if (packet[19])
69     log_info ("WARNING: OS flag is not supported in '%s'\n", filename);
70   if (packet[24] > 1 )
71     log_info ("Note: meta data copies in '%s' are ignored\n", filename);
72
73   len = buf32_to_uint (packet+20);
74
75   /* Do a basic sanity check on the length.  */
76   if (len < 32 || len > 1024*1024)
77     {
78       log_error ("bad length given in container '%s'\n", filename);
79       return gpg_error (GPG_ERR_INV_OBJ);
80     }
81
82   *r_headerlen = len;
83   return 0;
84 }
85
86
87 /* Read the prefix of the keyblob and do some basic parsing.  On
88    success returns an open estream file at R_FP and the length of the
89    header at R_HEADERLEN.  */
90 static gpg_error_t
91 read_keyblob_prefix (const char *filename, estream_t *r_fp, size_t *r_headerlen)
92 {
93   gpg_error_t err;
94   estream_t fp;
95   unsigned char packet[32];
96
97   *r_fp = NULL;
98
99   fp = es_fopen (filename, "rb");
100   if (!fp)
101     {
102       err = gpg_error_from_syserror ();
103       log_error ("error reading '%s': %s\n", filename, gpg_strerror (err));
104       return err;
105     }
106
107   /* Read the header.  It is defined as 32 bytes thus we read it in one go.  */
108   if (es_fread (packet, 32, 1, fp) != 1)
109     {
110       err = gpg_error_from_syserror ();
111       log_error ("error reading the header of '%s': %s\n",
112                  filename, gpg_strerror (err));
113       es_fclose (fp);
114       return err;
115     }
116
117   err = parse_header (filename, packet, 32, r_headerlen);
118   if (err)
119     es_fclose (fp);
120   else
121     *r_fp = fp;
122
123   return err;
124 }
125
126
127 \f
128 /*
129  * Test whether the container with name FILENAME is a suitable G13
130  * container.  This function may even be called on a mounted
131  * container.
132  */
133 gpg_error_t
134 g13_is_container (ctrl_t ctrl, const char *filename)
135 {
136   gpg_error_t err;
137   estream_t fp = NULL;
138   size_t dummy;
139
140   (void)ctrl;
141
142   /* Read just the prefix of the header.  */
143   err = read_keyblob_prefix (filename, &fp, &dummy);
144   if (!err)
145     es_fclose (fp);
146   return err;
147 }
148
149
150 /*
151  * Read the keyblob at FILENAME.  The caller should have acquired a
152  * lockfile and checked that the file exists.
153  */
154 gpg_error_t
155 g13_keyblob_read (const char *filename,
156                   void **r_enckeyblob, size_t *r_enckeybloblen)
157 {
158   gpg_error_t err;
159   estream_t fp = NULL;
160   size_t headerlen = 0;
161   size_t msglen;
162   void *msg = NULL;
163
164   *r_enckeyblob = NULL;
165   *r_enckeybloblen = 0;
166
167   err = read_keyblob_prefix (filename, &fp, &headerlen);
168   if (err)
169     goto leave;
170
171   if (opt.verbose)
172     log_info ("header length of '%s' is %zu\n", filename, headerlen);
173
174   /* Read everything including the padding.  We should eventually do a
175      regular OpenPGP parsing to detect the padding packet and pass
176      only the actual used OpenPGP data to the engine.  This is in
177      particular required when supporting CMS which will be
178      encapsulated in an OpenPGP packet.  */
179   assert (headerlen >= 32);
180   msglen = headerlen - 32;
181   if (!msglen)
182     {
183       err = gpg_error (GPG_ERR_NO_DATA);
184       goto leave;
185     }
186   msg = xtrymalloc (msglen);
187   if (!msglen)
188     {
189       err = gpg_error_from_syserror ();
190       goto leave;
191     }
192   if (es_fread (msg, msglen, 1, fp) != 1)
193     {
194       err = gpg_error_from_syserror ();
195       log_error ("error reading keyblob of '%s': %s\n",
196                  filename, gpg_strerror (err));
197       goto leave;
198     }
199
200   *r_enckeyblob = msg;
201   msg = NULL;
202   *r_enckeybloblen = msglen;
203
204  leave:
205   xfree (msg);
206   es_fclose (fp);
207
208   return err;
209 }
210
211
212 /*
213  * Decrypt the keyblob (ENCKEYBLOB,ENCKEYBLOBLEN) and store the result
214  * at (R_KEYBLOB, R_KEYBLOBLEN).  Returns 0 on success or an error
215  * code.  On error R_KEYBLOB is set to NULL.
216  */
217 gpg_error_t
218 g13_keyblob_decrypt (ctrl_t ctrl, const void *enckeyblob, size_t enckeybloblen,
219                      void **r_keyblob, size_t *r_keybloblen)
220 {
221   gpg_error_t err;
222
223   /* FIXME:  For now we only implement OpenPGP.  */
224   err = gpg_decrypt_blob (ctrl, opt.gpg_program, opt.gpg_arguments,
225                           enckeyblob, enckeybloblen,
226                           r_keyblob, r_keybloblen);
227
228   return err;
229 }