gpgconf: New command --apply-profile.
[gnupg.git] / tools / wks-receive.c
1 /* wks-receive.c - Receive a WKS mail
2  * Copyright (C) 2016 g10 Code GmbH
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 <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include "util.h"
26 #include "ccparray.h"
27 #include "exectool.h"
28 #include "gpg-wks.h"
29 #include "rfc822parse.h"
30 #include "mime-parser.h"
31
32
33 /* Limit of acceptable signed data.  */
34 #define MAX_SIGNEDDATA 10000
35
36 /* Limit of acceptable signature.  */
37 #define MAX_SIGNATURE 10000
38
39 /* Limit of acceptable encrypted data.  */
40 #define MAX_ENCRYPTED 100000
41
42 /* Data for a received object.  */
43 struct receive_ctx_s
44 {
45   mime_parser_t parser;
46   estream_t encrypted;
47   estream_t plaintext;
48   estream_t signeddata;
49   estream_t signature;
50   estream_t key_data;
51   estream_t wkd_data;
52   unsigned int collect_key_data:1;
53   unsigned int collect_wkd_data:1;
54   unsigned int draft_version_2:1;  /* This is a draft version 2 request.  */
55   unsigned int multipart_mixed_seen:1;
56 };
57 typedef struct receive_ctx_s *receive_ctx_t;
58
59
60
61 static void
62 decrypt_data_status_cb (void *opaque, const char *keyword, char *args)
63 {
64   receive_ctx_t ctx = opaque;
65   (void)ctx;
66   if (DBG_CRYPTO)
67     log_debug ("gpg status: %s %s\n", keyword, args);
68 }
69
70
71 /* Decrypt the collected data.  */
72 static void
73 decrypt_data (receive_ctx_t ctx)
74 {
75   gpg_error_t err;
76   ccparray_t ccp;
77   const char **argv;
78   int c;
79
80   es_rewind (ctx->encrypted);
81
82   if (!ctx->plaintext)
83     ctx->plaintext = es_fopenmem (0, "w+b");
84   if (!ctx->plaintext)
85     {
86       err = gpg_error_from_syserror ();
87       log_error ("error allocating space for plaintext: %s\n",
88                  gpg_strerror (err));
89       return;
90     }
91
92   ccparray_init (&ccp, 0);
93
94   ccparray_put (&ccp, "--no-options");
95   /* We limit the output to 64 KiB to avoid DoS using compression
96    * tricks.  A regular client will anyway only send a minimal key;
97    * that is one w/o key signatures and attribute packets.  */
98   ccparray_put (&ccp, "--max-output=0xf0000"); /*FIXME: Change s/F/1/ */
99   ccparray_put (&ccp, "--batch");
100   if (opt.verbose)
101     ccparray_put (&ccp, "--verbose");
102   ccparray_put (&ccp, "--always-trust");
103   ccparray_put (&ccp, "--decrypt");
104   ccparray_put (&ccp, "--");
105
106   ccparray_put (&ccp, NULL);
107   argv = ccparray_get (&ccp, NULL);
108   if (!argv)
109     {
110       err = gpg_error_from_syserror ();
111       goto leave;
112     }
113   err = gnupg_exec_tool_stream (opt.gpg_program, argv, ctx->encrypted,
114                                 NULL, ctx->plaintext,
115                                 decrypt_data_status_cb, ctx);
116   if (err)
117     {
118       log_error ("decryption failed: %s\n", gpg_strerror (err));
119       goto leave;
120     }
121
122   if (DBG_CRYPTO)
123     {
124       es_rewind (ctx->plaintext);
125       log_debug ("plaintext: '");
126       while ((c = es_getc (ctx->plaintext)) != EOF)
127         log_printf ("%c", c);
128       log_printf ("'\n");
129     }
130   es_rewind (ctx->plaintext);
131
132  leave:
133   xfree (argv);
134 }
135
136
137 static void
138 verify_signature_status_cb (void *opaque, const char *keyword, char *args)
139 {
140   receive_ctx_t ctx = opaque;
141   (void)ctx;
142   if (DBG_CRYPTO)
143     log_debug ("gpg status: %s %s\n", keyword, args);
144 }
145
146 /* Verify the signed data.  */
147 static void
148 verify_signature (receive_ctx_t ctx)
149 {
150   gpg_error_t err;
151   ccparray_t ccp;
152   const char **argv;
153
154   log_assert (ctx->signeddata);
155   log_assert (ctx->signature);
156   es_rewind (ctx->signeddata);
157   es_rewind (ctx->signature);
158
159   ccparray_init (&ccp, 0);
160
161   ccparray_put (&ccp, "--no-options");
162   ccparray_put (&ccp, "--batch");
163   if (opt.verbose)
164     ccparray_put (&ccp, "--verbose");
165   ccparray_put (&ccp, "--enable-special-filenames");
166   ccparray_put (&ccp, "--status-fd=2");
167   ccparray_put (&ccp, "--always-trust"); /* To avoid trustdb checks.  */
168   ccparray_put (&ccp, "--verify");
169   ccparray_put (&ccp, "--");
170   ccparray_put (&ccp, "-&@INEXTRA@");
171   ccparray_put (&ccp, "-");
172
173   ccparray_put (&ccp, NULL);
174   argv = ccparray_get (&ccp, NULL);
175   if (!argv)
176     {
177       err = gpg_error_from_syserror ();
178       goto leave;
179     }
180   err = gnupg_exec_tool_stream (opt.gpg_program, argv, ctx->signeddata,
181                                 ctx->signature, NULL,
182                                 verify_signature_status_cb, ctx);
183   if (err)
184     {
185       log_error ("verification failed: %s\n", gpg_strerror (err));
186       goto leave;
187     }
188
189   log_debug ("Fixme: Verification result is not used\n");
190
191  leave:
192   xfree (argv);
193 }
194
195
196 static gpg_error_t
197 collect_encrypted (void *cookie, const char *data)
198 {
199   receive_ctx_t ctx = cookie;
200
201   if (!ctx->encrypted)
202     if (!(ctx->encrypted = es_fopenmem (MAX_ENCRYPTED, "w+b,samethread")))
203       return gpg_error_from_syserror ();
204   if (data)
205     es_fputs (data, ctx->encrypted);
206
207   if (es_ferror (ctx->encrypted))
208     return gpg_error_from_syserror ();
209
210   if (!data)
211     {
212       decrypt_data (ctx);
213     }
214
215   return 0;
216 }
217
218
219 static gpg_error_t
220 collect_signeddata (void *cookie, const char *data)
221 {
222   receive_ctx_t ctx = cookie;
223
224   if (!ctx->signeddata)
225     if (!(ctx->signeddata = es_fopenmem (MAX_SIGNEDDATA, "w+b,samethread")))
226       return gpg_error_from_syserror ();
227   if (data)
228     es_fputs (data, ctx->signeddata);
229
230   if (es_ferror (ctx->signeddata))
231     return gpg_error_from_syserror ();
232   return 0;
233 }
234
235 static gpg_error_t
236 collect_signature (void *cookie, const char *data)
237 {
238   receive_ctx_t ctx = cookie;
239
240   if (!ctx->signature)
241     if (!(ctx->signature = es_fopenmem (MAX_SIGNATURE, "w+b,samethread")))
242       return gpg_error_from_syserror ();
243   if (data)
244     es_fputs (data, ctx->signature);
245
246   if (es_ferror (ctx->signature))
247     return gpg_error_from_syserror ();
248
249   if (!data)
250     {
251       verify_signature (ctx);
252     }
253
254   return 0;
255 }
256
257
258 static gpg_error_t
259 new_part (void *cookie, const char *mediatype, const char *mediasubtype)
260 {
261   receive_ctx_t ctx = cookie;
262   gpg_error_t err = 0;
263
264   ctx->collect_key_data = 0;
265   ctx->collect_wkd_data = 0;
266
267   if (!strcmp (mediatype, "application")
268       && !strcmp (mediasubtype, "pgp-keys"))
269     {
270       log_info ("new '%s/%s' message part\n", mediatype, mediasubtype);
271       if (ctx->key_data)
272         {
273           log_error ("we already got a key - ignoring this part\n");
274           err = gpg_error (GPG_ERR_FALSE);
275         }
276       else
277         {
278           rfc822parse_t msg = mime_parser_rfc822parser (ctx->parser);
279           if (msg)
280             {
281               char *value;
282               size_t valueoff;
283
284               value = rfc822parse_get_field (msg, "Wks-Draft-Version",
285                                              -1, &valueoff);
286               if (value)
287                 {
288                   if (atoi(value+valueoff) >= 2 )
289                     ctx->draft_version_2 = 1;
290                   free (value);
291                 }
292             }
293
294           ctx->key_data = es_fopenmem (0, "w+b");
295           if (!ctx->key_data)
296             {
297               err = gpg_error_from_syserror ();
298               log_error ("error allocating space for key: %s\n",
299                          gpg_strerror (err));
300             }
301           else
302             {
303               ctx->collect_key_data = 1;
304               err = gpg_error (GPG_ERR_TRUE); /* We want the part decoded.  */
305             }
306         }
307     }
308   else if (!strcmp (mediatype, "application")
309            && !strcmp (mediasubtype, "vnd.gnupg.wks"))
310     {
311       log_info ("new '%s/%s' message part\n", mediatype, mediasubtype);
312       if (ctx->wkd_data)
313         {
314           log_error ("we already got a wkd part - ignoring this part\n");
315           err = gpg_error (GPG_ERR_FALSE);
316         }
317       else
318         {
319           ctx->wkd_data = es_fopenmem (0, "w+b");
320           if (!ctx->wkd_data)
321             {
322               err = gpg_error_from_syserror ();
323               log_error ("error allocating space for key: %s\n",
324                          gpg_strerror (err));
325             }
326           else
327             {
328               ctx->collect_wkd_data = 1;
329               err = gpg_error (GPG_ERR_TRUE); /* We want the part decoded.  */
330             }
331         }
332     }
333   else if (!strcmp (mediatype, "multipart")
334            && !strcmp (mediasubtype, "mixed"))
335     {
336       ctx->multipart_mixed_seen = 1;
337     }
338   else if (!strcmp (mediatype, "text"))
339     {
340       /* Check that we receive a text part only after a
341        * application/mixed.  This is actually a too simple test and we
342        * should eventually employ a strict MIME structure check.  */
343       if (!ctx->multipart_mixed_seen)
344         err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
345     }
346   else
347     {
348       log_error ("unexpected '%s/%s' message part\n", mediatype, mediasubtype);
349       err = gpg_error (GPG_ERR_FALSE); /* We do not want the part.  */
350     }
351
352   return err;
353 }
354
355
356 static gpg_error_t
357 part_data (void *cookie, const void *data, size_t datalen)
358 {
359   receive_ctx_t ctx = cookie;
360
361   if (data)
362     {
363       if (DBG_MIME)
364         log_debug ("part_data: '%.*s'\n", (int)datalen, (const char*)data);
365       if (ctx->collect_key_data)
366         {
367           if (es_write (ctx->key_data, data, datalen, NULL)
368               || es_fputs ("\n", ctx->key_data))
369             return gpg_error_from_syserror ();
370         }
371       if (ctx->collect_wkd_data)
372         {
373           if (es_write (ctx->wkd_data, data, datalen, NULL)
374               || es_fputs ("\n", ctx->wkd_data))
375             return gpg_error_from_syserror ();
376         }
377     }
378   else
379     {
380       if (DBG_MIME)
381         log_debug ("part_data: finished\n");
382       ctx->collect_key_data = 0;
383       ctx->collect_wkd_data = 0;
384     }
385   return 0;
386 }
387
388
389 /* Receive a WKS mail from FP and process it accordingly.  On success
390  * the RESULT_CB is called with the mediatype and a stream with the
391  * decrypted data. */
392 gpg_error_t
393 wks_receive (estream_t fp,
394              gpg_error_t (*result_cb)(void *opaque,
395                                       const char *mediatype,
396                                       estream_t data,
397                                       unsigned int flags),
398              void *cb_data)
399 {
400   gpg_error_t err;
401   receive_ctx_t ctx;
402   mime_parser_t parser;
403   estream_t plaintext = NULL;
404   int c;
405   unsigned int flags = 0;
406
407   ctx = xtrycalloc (1, sizeof *ctx);
408   if (!ctx)
409     return gpg_error_from_syserror ();
410
411   err = mime_parser_new (&parser, ctx);
412   if (err)
413     goto leave;
414   if (DBG_PARSER)
415     mime_parser_set_verbose (parser, 1);
416   mime_parser_set_new_part (parser, new_part);
417   mime_parser_set_part_data (parser, part_data);
418   mime_parser_set_collect_encrypted (parser, collect_encrypted);
419   mime_parser_set_collect_signeddata (parser, collect_signeddata);
420   mime_parser_set_collect_signature (parser, collect_signature);
421
422   ctx->parser = parser;
423
424   err = mime_parser_parse (parser, fp);
425   if (err)
426     goto leave;
427
428   if (ctx->key_data)
429     log_info ("key data found\n");
430   if (ctx->wkd_data)
431     log_info ("wkd data found\n");
432   if (ctx->draft_version_2)
433     {
434       log_info ("draft version 2 requested\n");
435       flags |= WKS_RECEIVE_DRAFT2;
436     }
437
438   if (ctx->plaintext)
439     {
440       if (opt.verbose)
441         log_info ("parsing decrypted message\n");
442       plaintext = ctx->plaintext;
443       ctx->plaintext = NULL;
444       if (ctx->encrypted)
445         es_rewind (ctx->encrypted);
446       if (ctx->signeddata)
447         es_rewind (ctx->signeddata);
448       if (ctx->signature)
449         es_rewind (ctx->signature);
450       err = mime_parser_parse (parser, plaintext);
451       if (err)
452         return err;
453     }
454
455   if (!ctx->key_data && !ctx->wkd_data)
456     {
457       log_error ("no suitable data found in the message\n");
458       err = gpg_error (GPG_ERR_NO_DATA);
459       goto leave;
460     }
461
462   if (ctx->key_data)
463     {
464       if (DBG_MIME)
465         {
466           es_rewind (ctx->key_data);
467           log_debug ("Key: '");
468           log_printf ("\n");
469           while ((c = es_getc (ctx->key_data)) != EOF)
470             log_printf ("%c", c);
471           log_printf ("'\n");
472         }
473       if (result_cb)
474         {
475           es_rewind (ctx->key_data);
476           err = result_cb (cb_data, "application/pgp-keys",
477                            ctx->key_data, flags);
478           if (err)
479             goto leave;
480         }
481     }
482   if (ctx->wkd_data)
483     {
484       if (DBG_MIME)
485         {
486           es_rewind (ctx->wkd_data);
487           log_debug ("WKD: '");
488           log_printf ("\n");
489           while ((c = es_getc (ctx->wkd_data)) != EOF)
490             log_printf ("%c", c);
491           log_printf ("'\n");
492         }
493       if (result_cb)
494         {
495           es_rewind (ctx->wkd_data);
496           err = result_cb (cb_data, "application/vnd.gnupg.wks",
497                            ctx->wkd_data, flags);
498           if (err)
499             goto leave;
500         }
501     }
502
503
504  leave:
505   es_fclose (plaintext);
506   mime_parser_release (parser);
507   ctx->parser = NULL;
508   es_fclose (ctx->encrypted);
509   es_fclose (ctx->plaintext);
510   es_fclose (ctx->signeddata);
511   es_fclose (ctx->signature);
512   es_fclose (ctx->key_data);
513   es_fclose (ctx->wkd_data);
514   xfree (ctx);
515   return err;
516 }