gpg: Initialize the primary key when generating a key.
[gnupg.git] / g10 / plaintext.c
1 /* plaintext.c -  process plaintext packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2009, 2010 Free Software Foundation, Inc.
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 <assert.h>
27 #include <sys/types.h>
28 #ifdef HAVE_DOSISH_SYSTEM
29 # include <fcntl.h> /* for setmode() */
30 #endif
31
32 #include "gpg.h"
33 #include "util.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "ttyio.h"
37 #include "filter.h"
38 #include "main.h"
39 #include "status.h"
40 #include "i18n.h"
41
42
43 /* Get the output filename.  On success, the actual filename that is
44    used is set in *FNAMEP and a filepointer is returned in *FP.
45
46    EMBEDDED_NAME AND EMBEDDED_NAMELEN are normally stored in a
47    plaintext packet.  EMBEDDED_NAMELEN should not include any NUL
48    terminator (EMBEDDED_NAME does not need to be NUL terminated).
49
50    DATA is the iobuf containing the input data.  We just use it to get
51    the input file's filename.
52
53    On success, the caller is responsible for calling xfree on *FNAMEP
54    and calling es_close on *FPP.  */
55 gpg_error_t
56 get_output_file (const byte *embedded_name, int embedded_namelen,
57                  iobuf_t data, char **fnamep, estream_t *fpp)
58 {
59   gpg_error_t err = 0;
60   char *fname = NULL;
61   estream_t fp = NULL;
62   int nooutput = 0;
63
64   /* Create the filename as C string.  */
65   if (opt.outfp)
66     {
67       fname = xtrystrdup ("[FP]");
68       if (!fname)
69         {
70           err = gpg_error_from_syserror ();
71           goto leave;
72         }
73     }
74   else if (opt.outfile)
75     {
76       fname = xtrystrdup (opt.outfile);
77       if (!fname)
78         {
79           err = gpg_error_from_syserror ();
80           goto leave;
81         }
82     }
83   else if (embedded_namelen == 8 && !memcmp (embedded_name, "_CONSOLE", 8))
84     {
85       log_info (_("data not saved; use option \"--output\" to save it\n"));
86       nooutput = 1;
87     }
88   else if (!opt.flags.use_embedded_filename)
89     {
90       if (data)
91         fname = make_outfile_name (iobuf_get_real_fname (data));
92       if (!fname)
93         fname = ask_outfile_name (embedded_name, embedded_namelen);
94       if (!fname)
95         {
96           err = gpg_error (GPG_ERR_GENERAL);    /* Can't create file. */
97           goto leave;
98         }
99     }
100   else
101     fname = utf8_to_native (embedded_name, embedded_namelen, 0);
102
103   if (nooutput)
104     ;
105   else if (opt.outfp)
106     {
107       fp = opt.outfp;
108       es_set_binary (fp);
109     }
110   else if (iobuf_is_pipe_filename (fname) || !*fname)
111     {
112       /* No filename or "-" given; write to stdout. */
113       fp = es_stdout;
114       es_set_binary (fp);
115     }
116   else
117     {
118       while (!overwrite_filep (fname))
119         {
120           char *tmp = ask_outfile_name (NULL, 0);
121           if (!tmp || !*tmp)
122             {
123               xfree (tmp);
124               /* FIXME: Below used to be GPG_ERR_CREATE_FILE */
125               err = gpg_error (GPG_ERR_GENERAL);
126               goto leave;
127             }
128           xfree (fname);
129           fname = tmp;
130         }
131     }
132
133 #ifndef __riscos__
134   if (opt.outfp && is_secured_file (es_fileno (opt.outfp)))
135     {
136       err = gpg_error (GPG_ERR_EPERM);
137       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
138       goto leave;
139     }
140   else if (fp || nooutput)
141     ;
142   else if (is_secured_filename (fname))
143     {
144       gpg_err_set_errno (EPERM);
145       err = gpg_error_from_syserror ();
146       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
147       goto leave;
148     }
149   else if (!(fp = es_fopen (fname, "wb")))
150     {
151       err = gpg_error_from_syserror ();
152       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
153       goto leave;
154     }
155 #else /* __riscos__ */
156   /* If no output filename was given, i.e. we constructed it, convert
157      all '.' in fname to '/' but not vice versa as we don't create
158      directories! */
159   if (!opt.outfile)
160     for (c = 0; fname[c]; ++c)
161       if (fname[c] == '.')
162         fname[c] = '/';
163
164   if (fp || nooutput)
165     ;
166   else
167     {
168       /* Note: riscos stuff is not expected to work anymore.  If we
169          want to port it again to riscos we should do most of the suff
170          in estream.  FIXME: Consider to remove all riscos special
171          cases.  */
172       fp = fopen (fname, "wb");
173       if (!fp)
174         {
175           log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
176           err = GPG_ERR_CREATE_FILE;
177           if (errno == 106)
178             log_info ("Do output file and input file have the same name?\n");
179           goto leave;
180         }
181
182       /* If there's a ,xxx extension in the embedded filename,
183          use that, else check whether the user input (in fname)
184          has a ,xxx appended, then use that in preference */
185       if ((c = riscos_get_filetype_from_string (embedded_name,
186                                                 embedded_namelen)) != -1)
187         filetype = c;
188       if ((c = riscos_get_filetype_from_string (fname, strlen (fname))) != -1)
189         filetype = c;
190       riscos_set_filetype_by_number (fname, filetype);
191     }
192 #endif /* __riscos__ */
193
194  leave:
195   if (err)
196     {
197       if (fp && fp != es_stdout && fp != opt.outfp)
198         es_fclose (fp);
199       xfree (fname);
200       return err;
201     }
202
203   *fnamep = fname;
204   *fpp = fp;
205   return 0;
206 }
207
208 /* Handle a plaintext packet.  If MFX is not NULL, update the MDs
209  * Note: We should have used the filter stuff here, but we have to add
210  * some easy mimic to set a read limit, so we calculate only the bytes
211  * from the plaintext.  */
212 int
213 handle_plaintext (PKT_plaintext * pt, md_filter_context_t * mfx,
214                   int nooutput, int clearsig)
215 {
216   char *fname = NULL;
217   estream_t fp = NULL;
218   static off_t count = 0;
219   int err = 0;
220   int c;
221   int convert = (pt->mode == 't' || pt->mode == 'u');
222 #ifdef __riscos__
223   int filetype = 0xfff;
224 #endif
225
226   /* Let people know what the plaintext info is. This allows the
227      receiving program to try and do something different based on the
228      format code (say, recode UTF-8 to local). */
229   if (!nooutput && is_status_enabled ())
230     {
231       char status[50];
232
233       /* Better make sure that stdout has been flushed in case the
234          output will be written to it.  This is to make sure that no
235          not-yet-flushed stuff will be written after the plaintext
236          status message.  */
237       es_fflush (es_stdout);
238
239       snprintf (status, sizeof status,
240                 "%X %lu ", (byte) pt->mode, (ulong) pt->timestamp);
241       write_status_text_and_buffer (STATUS_PLAINTEXT,
242                                     status, pt->name, pt->namelen, 0);
243
244       if (!pt->is_partial)
245         {
246           snprintf (status, sizeof status, "%lu", (ulong) pt->len);
247           write_status_text (STATUS_PLAINTEXT_LENGTH, status);
248         }
249     }
250
251   if (! nooutput)
252     {
253       err = get_output_file (pt->name, pt->namelen, pt->buf, &fname, &fp);
254       if (err)
255         goto leave;
256     }
257
258   if (!pt->is_partial)
259     {
260       /* We have an actual length (which might be zero). */
261
262       if (clearsig)
263         {
264           log_error ("clearsig encountered while not expected\n");
265           err = gpg_error (GPG_ERR_UNEXPECTED);
266           goto leave;
267         }
268
269       if (convert) /* Text mode.  */
270         {
271           for (; pt->len; pt->len--)
272             {
273               if ((c = iobuf_get (pt->buf)) == -1)
274                 {
275                   err = gpg_error_from_syserror ();
276                   log_error ("problem reading source (%u bytes remaining)\n",
277                              (unsigned) pt->len);
278                   goto leave;
279                 }
280               if (mfx->md)
281                 gcry_md_putc (mfx->md, c);
282 #ifndef HAVE_DOSISH_SYSTEM
283               if (c == '\r')    /* convert to native line ending */
284                 continue;       /* fixme: this hack might be too simple */
285 #endif
286               if (fp)
287                 {
288                   if (opt.max_output && (++count) > opt.max_output)
289                     {
290                       log_error ("error writing to '%s': %s\n",
291                                  fname, "exceeded --max-output limit\n");
292                       err = gpg_error (GPG_ERR_TOO_LARGE);
293                       goto leave;
294                     }
295                   else if (es_putc (c, fp) == EOF)
296                     {
297                       if (es_ferror (fp))
298                         err = gpg_error_from_syserror ();
299                       else
300                         err = gpg_error (GPG_ERR_EOF);
301                       log_error ("error writing to '%s': %s\n",
302                                  fname, gpg_strerror (err));
303                       goto leave;
304                     }
305                 }
306             }
307         }
308       else  /* Binary mode.  */
309         {
310           byte *buffer = xmalloc (32768);
311           while (pt->len)
312             {
313               int len = pt->len > 32768 ? 32768 : pt->len;
314               len = iobuf_read (pt->buf, buffer, len);
315               if (len == -1)
316                 {
317                   err = gpg_error_from_syserror ();
318                   log_error ("problem reading source (%u bytes remaining)\n",
319                              (unsigned) pt->len);
320                   xfree (buffer);
321                   goto leave;
322                 }
323               if (mfx->md)
324                 gcry_md_write (mfx->md, buffer, len);
325               if (fp)
326                 {
327                   if (opt.max_output && (count += len) > opt.max_output)
328                     {
329                       log_error ("error writing to '%s': %s\n",
330                                  fname, "exceeded --max-output limit\n");
331                       err = gpg_error (GPG_ERR_TOO_LARGE);
332                       xfree (buffer);
333                       goto leave;
334                     }
335                   else if (es_fwrite (buffer, 1, len, fp) != len)
336                     {
337                       err = gpg_error_from_syserror ();
338                       log_error ("error writing to '%s': %s\n",
339                                  fname, gpg_strerror (err));
340                       xfree (buffer);
341                       goto leave;
342                     }
343                 }
344               pt->len -= len;
345             }
346           xfree (buffer);
347         }
348     }
349   else if (!clearsig)
350     {
351       if (convert)
352         {                       /* text mode */
353           while ((c = iobuf_get (pt->buf)) != -1)
354             {
355               if (mfx->md)
356                 gcry_md_putc (mfx->md, c);
357 #ifndef HAVE_DOSISH_SYSTEM
358               if (convert && c == '\r')
359                 continue;       /* fixme: this hack might be too simple */
360 #endif
361               if (fp)
362                 {
363                   if (opt.max_output && (++count) > opt.max_output)
364                     {
365                       log_error ("Error writing to '%s': %s\n",
366                                  fname, "exceeded --max-output limit\n");
367                       err = gpg_error (GPG_ERR_TOO_LARGE);
368                       goto leave;
369                     }
370                   else if (es_putc (c, fp) == EOF)
371                     {
372                       if (es_ferror (fp))
373                         err = gpg_error_from_syserror ();
374                       else
375                         err = gpg_error (GPG_ERR_EOF);
376                       log_error ("error writing to '%s': %s\n",
377                                  fname, gpg_strerror (err));
378                       goto leave;
379                     }
380                 }
381             }
382         }
383       else
384         {                       /* binary mode */
385           byte *buffer;
386           int eof_seen = 0;
387
388           buffer = xtrymalloc (32768);
389           if (!buffer)
390             {
391               err = gpg_error_from_syserror ();
392               goto leave;
393             }
394
395           while (!eof_seen)
396             {
397               /* Why do we check for len < 32768:
398                * If we won't, we would practically read 2 EOFs but
399                * the first one has already popped the block_filter
400                * off and therefore we don't catch the boundary.
401                * So, always assume EOF if iobuf_read returns less bytes
402                * then requested */
403               int len = iobuf_read (pt->buf, buffer, 32768);
404               if (len == -1)
405                 break;
406               if (len < 32768)
407                 eof_seen = 1;
408               if (mfx->md)
409                 gcry_md_write (mfx->md, buffer, len);
410               if (fp)
411                 {
412                   if (opt.max_output && (count += len) > opt.max_output)
413                     {
414                       log_error ("error writing to '%s': %s\n",
415                                  fname, "exceeded --max-output limit\n");
416                       err = gpg_error (GPG_ERR_TOO_LARGE);
417                       xfree (buffer);
418                       goto leave;
419                     }
420                   else if (es_fwrite (buffer, 1, len, fp) != len)
421                     {
422                       err = gpg_error_from_syserror ();
423                       log_error ("error writing to '%s': %s\n",
424                                  fname, gpg_strerror (err));
425                       xfree (buffer);
426                       goto leave;
427                     }
428                 }
429             }
430           xfree (buffer);
431         }
432       pt->buf = NULL;
433     }
434   else /* Clear text signature - don't hash the last CR,LF.   */
435     {
436       int state = 0;
437
438       while ((c = iobuf_get (pt->buf)) != -1)
439         {
440           if (fp)
441             {
442               if (opt.max_output && (++count) > opt.max_output)
443                 {
444                   log_error ("error writing to '%s': %s\n",
445                              fname, "exceeded --max-output limit\n");
446                   err = gpg_error (GPG_ERR_TOO_LARGE);
447                   goto leave;
448                 }
449               else if (es_putc (c, fp) == EOF)
450                 {
451                   err = gpg_error_from_syserror ();
452                   log_error ("error writing to '%s': %s\n",
453                              fname, gpg_strerror (err));
454                   goto leave;
455                 }
456             }
457           if (!mfx->md)
458             continue;
459           if (state == 2)
460             {
461               gcry_md_putc (mfx->md, '\r');
462               gcry_md_putc (mfx->md, '\n');
463               state = 0;
464             }
465           if (!state)
466             {
467               if (c == '\r')
468                 state = 1;
469               else if (c == '\n')
470                 state = 2;
471               else
472                 gcry_md_putc (mfx->md, c);
473             }
474           else if (state == 1)
475             {
476               if (c == '\n')
477                 state = 2;
478               else
479                 {
480                   gcry_md_putc (mfx->md, '\r');
481                   if (c == '\r')
482                     state = 1;
483                   else
484                     {
485                       state = 0;
486                       gcry_md_putc (mfx->md, c);
487                     }
488                 }
489             }
490         }
491       pt->buf = NULL;
492     }
493
494   if (fp && fp != es_stdout && fp != opt.outfp && es_fclose (fp))
495     {
496       err = gpg_error_from_syserror ();
497       log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
498       fp = NULL;
499       goto leave;
500     }
501   fp = NULL;
502
503  leave:
504   /* Make sure that stdout gets flushed after the plaintext has been
505      handled.  This is for extra security as we do a flush anyway
506      before checking the signature.  */
507   if (es_fflush (es_stdout))
508     {
509       /* We need to check the return code to detect errors like disk
510          full for short plaintexts.  See bug#1207.  Checking return
511          values is a good idea in any case.  */
512       if (!err)
513         err = gpg_error_from_syserror ();
514       log_error ("error flushing '%s': %s\n", "[stdout]",
515                  gpg_strerror (err));
516     }
517
518   if (fp && fp != es_stdout && fp != opt.outfp)
519     es_fclose (fp);
520   xfree (fname);
521   return err;
522 }
523
524
525 static void
526 do_hash (gcry_md_hd_t md, gcry_md_hd_t md2, IOBUF fp, int textmode)
527 {
528   text_filter_context_t tfx;
529   int c;
530
531   if (textmode)
532     {
533       memset (&tfx, 0, sizeof tfx);
534       iobuf_push_filter (fp, text_filter, &tfx);
535     }
536   if (md2)
537     {                           /* work around a strange behaviour in pgp2 */
538       /* It seems that at least PGP5 converts a single CR to a CR,LF too */
539       int lc = -1;
540       while ((c = iobuf_get (fp)) != -1)
541         {
542           if (c == '\n' && lc == '\r')
543             gcry_md_putc (md2, c);
544           else if (c == '\n')
545             {
546               gcry_md_putc (md2, '\r');
547               gcry_md_putc (md2, c);
548             }
549           else if (c != '\n' && lc == '\r')
550             {
551               gcry_md_putc (md2, '\n');
552               gcry_md_putc (md2, c);
553             }
554           else
555             gcry_md_putc (md2, c);
556
557           if (md)
558             gcry_md_putc (md, c);
559           lc = c;
560         }
561     }
562   else
563     {
564       while ((c = iobuf_get (fp)) != -1)
565         {
566           if (md)
567             gcry_md_putc (md, c);
568         }
569     }
570 }
571
572
573 /****************
574  * Ask for the detached datafile and calculate the digest from it.
575  * INFILE is the name of the input file.
576  */
577 int
578 ask_for_detached_datafile (gcry_md_hd_t md, gcry_md_hd_t md2,
579                            const char *inname, int textmode)
580 {
581   progress_filter_context_t *pfx;
582   char *answer = NULL;
583   IOBUF fp;
584   int rc = 0;
585
586   pfx = new_progress_context ();
587   fp = open_sigfile (inname, pfx);      /* Open default file. */
588
589   if (!fp && !opt.batch)
590     {
591       int any = 0;
592       tty_printf (_("Detached signature.\n"));
593       do
594         {
595           char *name;
596
597           xfree (answer);
598           tty_enable_completion (NULL);
599           name = cpr_get ("detached_signature.filename",
600                           _("Please enter name of data file: "));
601           tty_disable_completion ();
602           cpr_kill_prompt ();
603           answer = make_filename (name, (void *) NULL);
604           xfree (name);
605
606           if (any && !*answer)
607             {
608               rc = gpg_error (GPG_ERR_GENERAL); /*G10ERR_READ_FILE */
609               goto leave;
610             }
611           fp = iobuf_open (answer);
612           if (fp && is_secured_file (iobuf_get_fd (fp)))
613             {
614               iobuf_close (fp);
615               fp = NULL;
616               gpg_err_set_errno (EPERM);
617             }
618           if (!fp && errno == ENOENT)
619             {
620               tty_printf ("No such file, try again or hit enter to quit.\n");
621               any++;
622             }
623           else if (!fp)
624             {
625               rc = gpg_error_from_syserror ();
626               log_error (_("can't open '%s': %s\n"), answer,
627                          strerror (errno));
628               goto leave;
629             }
630         }
631       while (!fp);
632     }
633
634   if (!fp)
635     {
636       if (opt.verbose)
637         log_info (_("reading stdin ...\n"));
638       fp = iobuf_open (NULL);
639       assert (fp);
640     }
641   do_hash (md, md2, fp, textmode);
642   iobuf_close (fp);
643
644 leave:
645   xfree (answer);
646   release_progress_context (pfx);
647   return rc;
648 }
649
650
651
652 /* Hash the given files and append the hash to hash contexts MD and
653  * MD2.  If FILES is NULL, stdin is hashed.  */
654 int
655 hash_datafiles (gcry_md_hd_t md, gcry_md_hd_t md2, strlist_t files,
656                 const char *sigfilename, int textmode)
657 {
658   progress_filter_context_t *pfx;
659   IOBUF fp;
660   strlist_t sl;
661
662   pfx = new_progress_context ();
663
664   if (!files)
665     {
666       /* Check whether we can open the signed material.  We avoid
667          trying to open a file if run in batch mode.  This assumed
668          data file for a sig file feature is just a convenience thing
669          for the command line and the user needs to read possible
670          warning messages. */
671       if (!opt.batch)
672         {
673           fp = open_sigfile (sigfilename, pfx);
674           if (fp)
675             {
676               do_hash (md, md2, fp, textmode);
677               iobuf_close (fp);
678               release_progress_context (pfx);
679               return 0;
680             }
681         }
682       log_error (_("no signed data\n"));
683       release_progress_context (pfx);
684       return gpg_error (GPG_ERR_NO_DATA);
685     }
686
687
688   for (sl = files; sl; sl = sl->next)
689     {
690       fp = iobuf_open (sl->d);
691       if (fp && is_secured_file (iobuf_get_fd (fp)))
692         {
693           iobuf_close (fp);
694           fp = NULL;
695           gpg_err_set_errno (EPERM);
696         }
697       if (!fp)
698         {
699           int rc = gpg_error_from_syserror ();
700           log_error (_("can't open signed data '%s'\n"),
701                      print_fname_stdin (sl->d));
702           release_progress_context (pfx);
703           return rc;
704         }
705       handle_progress (pfx, fp, sl->d);
706       do_hash (md, md2, fp, textmode);
707       iobuf_close (fp);
708     }
709
710   release_progress_context (pfx);
711   return 0;
712 }
713
714
715 /* Hash the data from file descriptor DATA_FD and append the hash to hash
716    contexts MD and MD2.  */
717 int
718 hash_datafile_by_fd (gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
719                      int textmode)
720 {
721   progress_filter_context_t *pfx = new_progress_context ();
722   iobuf_t fp;
723
724   if (is_secured_file (data_fd))
725     {
726       fp = NULL;
727       gpg_err_set_errno (EPERM);
728     }
729   else
730     fp = iobuf_fdopen_nc (data_fd, "rb");
731
732   if (!fp)
733     {
734       int rc = gpg_error_from_syserror ();
735       log_error (_("can't open signed data fd=%d: %s\n"),
736                  data_fd, strerror (errno));
737       release_progress_context (pfx);
738       return rc;
739     }
740
741   handle_progress (pfx, fp, NULL);
742
743   do_hash (md, md2, fp, textmode);
744
745   iobuf_close (fp);
746
747   release_progress_context (pfx);
748   return 0;
749 }
750
751
752 /* Set up a plaintext packet with the appropriate filename.  If there
753    is a --set-filename, use it (it's already UTF8).  If there is a
754    regular filename, UTF8-ize it if necessary.  If there is no
755    filenames at all, set the field empty. */
756
757 PKT_plaintext *
758 setup_plaintext_name (const char *filename, IOBUF iobuf)
759 {
760   PKT_plaintext *pt;
761
762   if ((filename && !iobuf_is_pipe_filename (filename))
763        || (opt.set_filename && !iobuf_is_pipe_filename (opt.set_filename)))
764     {
765       char *s;
766
767       if (opt.set_filename)
768         s = make_basename (opt.set_filename, iobuf_get_real_fname (iobuf));
769       else if (filename && !opt.flags.utf8_filename)
770         {
771           char *tmp = native_to_utf8 (filename);
772           s = make_basename (tmp, iobuf_get_real_fname (iobuf));
773           xfree (tmp);
774         }
775       else
776         s = make_basename (filename, iobuf_get_real_fname (iobuf));
777
778       pt = xmalloc (sizeof *pt + strlen (s) - 1);
779       pt->namelen = strlen (s);
780       memcpy (pt->name, s, pt->namelen);
781       xfree (s);
782     }
783   else
784     {
785       /* no filename */
786       pt = xmalloc (sizeof *pt - 1);
787       pt->namelen = 0;
788     }
789
790   return pt;
791 }