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