LCOV - code coverage report
Current view: top level - tests - run-decrypt.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 163 0.0 %
Date: 2018-11-14 16:53:58 Functions: 0 4 0.0 %

          Line data    Source code
       1             : /* run-decrypt.c  - Helper to perform a verify operation
       2             :    Copyright (C) 2009 g10 Code GmbH
       3             :                  2016 by Bundesamt für Sicherheit in der Informationstechnik
       4             :                  Software engineering by Intevation GmbH
       5             : 
       6             :    This file is part of GPGME.
       7             : 
       8             :    GPGME is free software; you can redistribute it and/or modify it
       9             :    under the terms of the GNU Lesser General Public License as
      10             :    published by the Free Software Foundation; either version 2.1 of
      11             :    the License, or (at your option) any later version.
      12             : 
      13             :    GPGME is distributed in the hope that it will be useful, but
      14             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :    Lesser General Public License for more details.
      17             : 
      18             :    You should have received a copy of the GNU Lesser General Public
      19             :    License along with this program; if not, see <https://www.gnu.org/licenses/>.
      20             : */
      21             : 
      22             : /* We need to include config.h so that we know whether we are building
      23             :    with large file system (LFS) support. */
      24             : #ifdef HAVE_CONFIG_H
      25             : #include <config.h>
      26             : #endif
      27             : 
      28             : #include <stdlib.h>
      29             : #include <stdio.h>
      30             : #include <string.h>
      31             : 
      32             : #include <gpgme.h>
      33             : 
      34             : #define PGM "run-decrypt"
      35             : 
      36             : #include "run-support.h"
      37             : 
      38             : 
      39             : static int verbose;
      40             : 
      41             : static gpg_error_t
      42           0 : status_cb (void *opaque, const char *keyword, const char *value)
      43             : {
      44             :   (void)opaque;
      45           0 :   fprintf (stderr, "status_cb: %s %s\n", keyword, value);
      46           0 :   return 0;
      47             : }
      48             : 
      49             : 
      50             : static void
      51           0 : print_result (gpgme_decrypt_result_t result)
      52             : {
      53             :   gpgme_recipient_t recp;
      54           0 :   int count = 0;
      55             : 
      56           0 :   printf ("Original file name .: %s\n", nonnull(result->file_name));
      57           0 :   printf ("Wrong key usage ....: %s\n", result->wrong_key_usage? "yes":"no");
      58           0 :   printf ("Legacy w/o MDC ... .: %s\n", result->legacy_cipher_nomdc?"yes":"no");
      59           0 :   printf ("Compliance de-vs ...: %s\n", result->is_de_vs? "yes":"no");
      60           0 :   printf ("MIME flag ..........: %s\n", result->is_mime? "yes":"no");
      61           0 :   printf ("Unsupported algo ...: %s\n", nonnull(result->unsupported_algorithm));
      62           0 :   printf ("Session key ........: %s\n", nonnull (result->session_key));
      63           0 :   printf ("Symmetric algorithm : %s\n", result->symkey_algo);
      64             : 
      65           0 :   for (recp = result->recipients; recp && recp->next; recp = recp->next)
      66             :     {
      67           0 :       printf ("Recipient ...: %d\n", count++);
      68           0 :       printf ("  status ....: %s\n", gpgme_strerror (recp->status));
      69           0 :       printf ("  keyid .....: %s\n", nonnull (recp->keyid));
      70           0 :       printf ("  algo ......: %s\n",
      71             :               gpgme_pubkey_algo_name (recp->pubkey_algo));
      72             :     }
      73           0 : }
      74             : 
      75             : 
      76             : static int
      77           0 : show_usage (int ex)
      78             : {
      79           0 :   fputs ("usage: " PGM " [options] FILE\n\n"
      80             :          "Options:\n"
      81             :          "  --verbose        run in verbose mode\n"
      82             :          "  --status         print status lines from the backend\n"
      83             :          "  --openpgp        use the OpenPGP protocol (default)\n"
      84             :          "  --cms            use the CMS protocol\n"
      85             :          "  --export-session-key            show the session key\n"
      86             :          "  --override-session-key STRING   use STRING as session key\n"
      87             :          "  --request-origin STRING         use STRING as request origin\n"
      88             :          "  --no-symkey-cache               disable the use of that cache\n"
      89             :          "  --ignore-mdc-error              allow decryption of legacy data\n"
      90             :          "  --unwrap         remove only the encryption layer\n"
      91             :          "  --diagnostics    print diagnostics\n"
      92             :          , stderr);
      93           0 :   exit (ex);
      94             : }
      95             : 
      96             : 
      97             : int
      98           0 : main (int argc, char **argv)
      99             : {
     100           0 :   int last_argc = -1;
     101             :   gpgme_error_t err;
     102             :   gpgme_ctx_t ctx;
     103           0 :   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
     104           0 :   gpgme_decrypt_flags_t flags = 0;
     105           0 :   FILE *fp_in = NULL;
     106           0 :   gpgme_data_t in = NULL;
     107           0 :   gpgme_data_t out = NULL;
     108             :   gpgme_decrypt_result_t result;
     109           0 :   int print_status = 0;
     110           0 :   int export_session_key = 0;
     111           0 :   const char *override_session_key = NULL;
     112           0 :   const char *request_origin = NULL;
     113           0 :   int no_symkey_cache = 0;
     114           0 :   int ignore_mdc_error = 0;
     115           0 :   int raw_output = 0;
     116           0 :   int diagnostics = 0;
     117             : 
     118           0 :   if (argc)
     119           0 :     { argc--; argv++; }
     120             : 
     121           0 :   while (argc && last_argc != argc )
     122             :     {
     123           0 :       last_argc = argc;
     124           0 :       if (!strcmp (*argv, "--"))
     125             :         {
     126           0 :           argc--; argv++;
     127           0 :           break;
     128             :         }
     129           0 :       else if (!strcmp (*argv, "--help"))
     130           0 :         show_usage (0);
     131           0 :       else if (!strcmp (*argv, "--verbose"))
     132             :         {
     133           0 :           verbose = 1;
     134           0 :           argc--; argv++;
     135             :         }
     136           0 :       else if (!strcmp (*argv, "--status"))
     137             :         {
     138           0 :           print_status = 1;
     139           0 :           argc--; argv++;
     140             :         }
     141           0 :       else if (!strcmp (*argv, "--openpgp"))
     142             :         {
     143           0 :           protocol = GPGME_PROTOCOL_OpenPGP;
     144           0 :           argc--; argv++;
     145             :         }
     146           0 :       else if (!strcmp (*argv, "--cms"))
     147             :         {
     148           0 :           protocol = GPGME_PROTOCOL_CMS;
     149           0 :           argc--; argv++;
     150             :         }
     151           0 :       else if (!strcmp (*argv, "--export-session-key"))
     152             :         {
     153           0 :           export_session_key = 1;
     154           0 :           argc--; argv++;
     155             :         }
     156           0 :       else if (!strcmp (*argv, "--override-session-key"))
     157             :         {
     158           0 :           argc--; argv++;
     159           0 :           if (!argc)
     160           0 :             show_usage (1);
     161           0 :           override_session_key = *argv;
     162           0 :           argc--; argv++;
     163             :         }
     164           0 :       else if (!strcmp (*argv, "--request-origin"))
     165             :         {
     166           0 :           argc--; argv++;
     167           0 :           if (!argc)
     168           0 :             show_usage (1);
     169           0 :           request_origin = *argv;
     170           0 :           argc--; argv++;
     171             :         }
     172           0 :       else if (!strcmp (*argv, "--no-symkey-cache"))
     173             :         {
     174           0 :           no_symkey_cache = 1;
     175           0 :           argc--; argv++;
     176             :         }
     177           0 :       else if (!strcmp (*argv, "--ignore-mdc-error"))
     178             :         {
     179           0 :           ignore_mdc_error = 1;
     180           0 :           argc--; argv++;
     181             :         }
     182           0 :       else if (!strcmp (*argv, "--diagnostics"))
     183             :         {
     184           0 :           diagnostics = 1;
     185           0 :           argc--; argv++;
     186             :         }
     187           0 :       else if (!strcmp (*argv, "--unwrap"))
     188             :         {
     189           0 :           flags |= GPGME_DECRYPT_UNWRAP;
     190           0 :           raw_output = 1;
     191           0 :           argc--; argv++;
     192             :         }
     193           0 :       else if (!strncmp (*argv, "--", 2))
     194           0 :         show_usage (1);
     195             : 
     196             :     }
     197             : 
     198           0 :   if (argc < 1 || argc > 2)
     199           0 :     show_usage (1);
     200             : 
     201           0 :   fp_in = fopen (argv[0], "rb");
     202           0 :   if (!fp_in)
     203             :     {
     204           0 :       err = gpgme_error_from_syserror ();
     205           0 :       fprintf (stderr, PGM ": can't open `%s': %s\n",
     206             :                argv[0], gpgme_strerror (err));
     207           0 :       exit (1);
     208             :     }
     209             : 
     210           0 :   init_gpgme (protocol);
     211             : 
     212           0 :   err = gpgme_new (&ctx);
     213           0 :   fail_if_err (err);
     214           0 :   gpgme_set_protocol (ctx, protocol);
     215           0 :   if (print_status)
     216             :     {
     217           0 :       gpgme_set_status_cb (ctx, status_cb, NULL);
     218           0 :       gpgme_set_ctx_flag (ctx, "full-status", "1");
     219             :     }
     220           0 :   if (export_session_key)
     221             :     {
     222           0 :       err = gpgme_set_ctx_flag (ctx, "export-session-key", "1");
     223           0 :       if (err)
     224             :         {
     225           0 :           fprintf (stderr, PGM ": error requesting exported session key: %s\n",
     226             :                    gpgme_strerror (err));
     227           0 :           exit (1);
     228             :         }
     229             :     }
     230           0 :   if (override_session_key)
     231             :     {
     232           0 :       err = gpgme_set_ctx_flag (ctx, "override-session-key",
     233             :                                 override_session_key);
     234           0 :       if (err)
     235             :         {
     236           0 :           fprintf (stderr, PGM ": error setting overriding session key: %s\n",
     237             :                    gpgme_strerror (err));
     238           0 :           exit (1);
     239             :         }
     240             :     }
     241             : 
     242           0 :   if (request_origin)
     243             :     {
     244           0 :       err = gpgme_set_ctx_flag (ctx, "request-origin", request_origin);
     245           0 :       if (err)
     246             :         {
     247           0 :           fprintf (stderr, PGM ": error setting request_origin: %s\n",
     248             :                    gpgme_strerror (err));
     249           0 :           exit (1);
     250             :         }
     251             :     }
     252             : 
     253           0 :   if (no_symkey_cache)
     254             :     {
     255           0 :       err = gpgme_set_ctx_flag (ctx, "no-symkey-cache", "1");
     256           0 :       if (err)
     257             :         {
     258           0 :           fprintf (stderr, PGM ": error setting no-symkey-cache: %s\n",
     259             :                    gpgme_strerror (err));
     260           0 :           exit (1);
     261             :         }
     262             :     }
     263             : 
     264           0 :   if (ignore_mdc_error)
     265             :     {
     266           0 :       err = gpgme_set_ctx_flag (ctx, "ignore-mdc-error", "1");
     267           0 :       if (err)
     268             :         {
     269           0 :           fprintf (stderr, PGM ": error setting ignore-mdc-error: %s\n",
     270             :                    gpgme_strerror (err));
     271           0 :           exit (1);
     272             :         }
     273             :     }
     274             : 
     275           0 :   err = gpgme_data_new_from_stream (&in, fp_in);
     276           0 :   if (err)
     277             :     {
     278           0 :       fprintf (stderr, PGM ": error allocating data object: %s\n",
     279             :                gpgme_strerror (err));
     280           0 :       exit (1);
     281             :     }
     282             : 
     283           0 :   err = gpgme_data_new (&out);
     284           0 :   if (err)
     285             :     {
     286           0 :       fprintf (stderr, PGM ": error allocating data object: %s\n",
     287             :                gpgme_strerror (err));
     288           0 :       exit (1);
     289             :     }
     290             : 
     291           0 :   err = gpgme_op_decrypt_ext (ctx, flags, in, out);
     292           0 :   result = gpgme_op_decrypt_result (ctx);
     293             : 
     294           0 :   if (diagnostics)
     295             :     {
     296             :       gpgme_data_t diag;
     297             :       gpgme_error_t diag_err;
     298             : 
     299           0 :       gpgme_data_new (&diag);
     300           0 :       diag_err = gpgme_op_getauditlog (ctx, diag, GPGME_AUDITLOG_DIAG);
     301           0 :       if (diag_err)
     302             :         {
     303           0 :           fprintf (stderr, PGM ": getting diagnostics failed: %s\n",
     304             :                    gpgme_strerror (diag_err));
     305             :         }
     306             :       else
     307             :         {
     308           0 :           fputs ("Begin Diagnostics:\n", stdout);
     309           0 :           print_data (diag);
     310           0 :           fputs ("End Diagnostics.\n", stdout);
     311             :         }
     312           0 :       gpgme_data_release (diag);
     313             :     }
     314             : 
     315           0 :   if (err)
     316             :     {
     317           0 :       fprintf (stderr, PGM ": decrypt failed: %s\n", gpgme_strerror (err));
     318           0 :       if (result)
     319           0 :         print_result (result);
     320           0 :       exit (1);
     321             :     }
     322           0 :   if (result)
     323             :     {
     324           0 :       if (!raw_output)
     325           0 :         print_result (result);
     326           0 :       if (!raw_output)
     327           0 :         fputs ("Begin Output:\n", stdout);
     328           0 :       print_data (out);
     329           0 :       if (!raw_output)
     330           0 :         fputs ("End Output.\n", stdout);
     331             :     }
     332             : 
     333           0 :   gpgme_data_release (out);
     334           0 :   gpgme_data_release (in);
     335             : 
     336           0 :   gpgme_release (ctx);
     337           0 :   return 0;
     338             : }

Generated by: LCOV version 1.13