Python bindings examples: PEP8 conpliance
[gpgme.git] / tests / run-decrypt.c
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 status_cb (void *opaque, const char *keyword, const char *value)
43 {
44   (void)opaque;
45   fprintf (stderr, "status_cb: %s %s\n", keyword, value);
46   return 0;
47 }
48
49
50 static void
51 print_result (gpgme_decrypt_result_t result)
52 {
53   gpgme_recipient_t recp;
54   int count = 0;
55
56   printf ("Original file name .: %s\n", nonnull(result->file_name));
57   printf ("Wrong key usage ....: %s\n", result->wrong_key_usage? "yes":"no");
58   printf ("Legacy w/o MDC ... .: %s\n", result->legacy_cipher_nomdc?"yes":"no");
59   printf ("Compliance de-vs ...: %s\n", result->is_de_vs? "yes":"no");
60   printf ("MIME flag ..........: %s\n", result->is_mime? "yes":"no");
61   printf ("Unsupported algo ...: %s\n", nonnull(result->unsupported_algorithm));
62   printf ("Session key ........: %s\n", nonnull (result->session_key));
63   printf ("Symmetric algorithm : %s\n", result->symkey_algo);
64
65   for (recp = result->recipients; recp && recp->next; recp = recp->next)
66     {
67       printf ("Recipient ...: %d\n", count++);
68       printf ("  status ....: %s\n", gpgme_strerror (recp->status));
69       printf ("  keyid .....: %s\n", nonnull (recp->keyid));
70       printf ("  algo ......: %s\n",
71               gpgme_pubkey_algo_name (recp->pubkey_algo));
72     }
73 }
74
75
76 static int
77 show_usage (int ex)
78 {
79   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   exit (ex);
94 }
95
96
97 int
98 main (int argc, char **argv)
99 {
100   int last_argc = -1;
101   gpgme_error_t err;
102   gpgme_ctx_t ctx;
103   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
104   gpgme_decrypt_flags_t flags = 0;
105   FILE *fp_in = NULL;
106   gpgme_data_t in = NULL;
107   gpgme_data_t out = NULL;
108   gpgme_decrypt_result_t result;
109   int print_status = 0;
110   int export_session_key = 0;
111   const char *override_session_key = NULL;
112   const char *request_origin = NULL;
113   int no_symkey_cache = 0;
114   int ignore_mdc_error = 0;
115   int raw_output = 0;
116   int diagnostics = 0;
117
118   if (argc)
119     { argc--; argv++; }
120
121   while (argc && last_argc != argc )
122     {
123       last_argc = argc;
124       if (!strcmp (*argv, "--"))
125         {
126           argc--; argv++;
127           break;
128         }
129       else if (!strcmp (*argv, "--help"))
130         show_usage (0);
131       else if (!strcmp (*argv, "--verbose"))
132         {
133           verbose = 1;
134           argc--; argv++;
135         }
136       else if (!strcmp (*argv, "--status"))
137         {
138           print_status = 1;
139           argc--; argv++;
140         }
141       else if (!strcmp (*argv, "--openpgp"))
142         {
143           protocol = GPGME_PROTOCOL_OpenPGP;
144           argc--; argv++;
145         }
146       else if (!strcmp (*argv, "--cms"))
147         {
148           protocol = GPGME_PROTOCOL_CMS;
149           argc--; argv++;
150         }
151       else if (!strcmp (*argv, "--export-session-key"))
152         {
153           export_session_key = 1;
154           argc--; argv++;
155         }
156       else if (!strcmp (*argv, "--override-session-key"))
157         {
158           argc--; argv++;
159           if (!argc)
160             show_usage (1);
161           override_session_key = *argv;
162           argc--; argv++;
163         }
164       else if (!strcmp (*argv, "--request-origin"))
165         {
166           argc--; argv++;
167           if (!argc)
168             show_usage (1);
169           request_origin = *argv;
170           argc--; argv++;
171         }
172       else if (!strcmp (*argv, "--no-symkey-cache"))
173         {
174           no_symkey_cache = 1;
175           argc--; argv++;
176         }
177       else if (!strcmp (*argv, "--ignore-mdc-error"))
178         {
179           ignore_mdc_error = 1;
180           argc--; argv++;
181         }
182       else if (!strcmp (*argv, "--diagnostics"))
183         {
184           diagnostics = 1;
185           argc--; argv++;
186         }
187       else if (!strcmp (*argv, "--unwrap"))
188         {
189           flags |= GPGME_DECRYPT_UNWRAP;
190           raw_output = 1;
191           argc--; argv++;
192         }
193       else if (!strncmp (*argv, "--", 2))
194         show_usage (1);
195
196     }
197
198   if (argc < 1 || argc > 2)
199     show_usage (1);
200
201   fp_in = fopen (argv[0], "rb");
202   if (!fp_in)
203     {
204       err = gpgme_error_from_syserror ();
205       fprintf (stderr, PGM ": can't open `%s': %s\n",
206                argv[0], gpgme_strerror (err));
207       exit (1);
208     }
209
210   init_gpgme (protocol);
211
212   err = gpgme_new (&ctx);
213   fail_if_err (err);
214   gpgme_set_protocol (ctx, protocol);
215   if (print_status)
216     {
217       gpgme_set_status_cb (ctx, status_cb, NULL);
218       gpgme_set_ctx_flag (ctx, "full-status", "1");
219     }
220   if (export_session_key)
221     {
222       err = gpgme_set_ctx_flag (ctx, "export-session-key", "1");
223       if (err)
224         {
225           fprintf (stderr, PGM ": error requesting exported session key: %s\n",
226                    gpgme_strerror (err));
227           exit (1);
228         }
229     }
230   if (override_session_key)
231     {
232       err = gpgme_set_ctx_flag (ctx, "override-session-key",
233                                 override_session_key);
234       if (err)
235         {
236           fprintf (stderr, PGM ": error setting overriding session key: %s\n",
237                    gpgme_strerror (err));
238           exit (1);
239         }
240     }
241
242   if (request_origin)
243     {
244       err = gpgme_set_ctx_flag (ctx, "request-origin", request_origin);
245       if (err)
246         {
247           fprintf (stderr, PGM ": error setting request_origin: %s\n",
248                    gpgme_strerror (err));
249           exit (1);
250         }
251     }
252
253   if (no_symkey_cache)
254     {
255       err = gpgme_set_ctx_flag (ctx, "no-symkey-cache", "1");
256       if (err)
257         {
258           fprintf (stderr, PGM ": error setting no-symkey-cache: %s\n",
259                    gpgme_strerror (err));
260           exit (1);
261         }
262     }
263
264   if (ignore_mdc_error)
265     {
266       err = gpgme_set_ctx_flag (ctx, "ignore-mdc-error", "1");
267       if (err)
268         {
269           fprintf (stderr, PGM ": error setting ignore-mdc-error: %s\n",
270                    gpgme_strerror (err));
271           exit (1);
272         }
273     }
274
275   err = gpgme_data_new_from_stream (&in, fp_in);
276   if (err)
277     {
278       fprintf (stderr, PGM ": error allocating data object: %s\n",
279                gpgme_strerror (err));
280       exit (1);
281     }
282
283   err = gpgme_data_new (&out);
284   if (err)
285     {
286       fprintf (stderr, PGM ": error allocating data object: %s\n",
287                gpgme_strerror (err));
288       exit (1);
289     }
290
291   err = gpgme_op_decrypt_ext (ctx, flags, in, out);
292   result = gpgme_op_decrypt_result (ctx);
293
294   if (diagnostics)
295     {
296       gpgme_data_t diag;
297       gpgme_error_t diag_err;
298
299       gpgme_data_new (&diag);
300       diag_err = gpgme_op_getauditlog (ctx, diag, GPGME_AUDITLOG_DIAG);
301       if (diag_err)
302         {
303           fprintf (stderr, PGM ": getting diagnostics failed: %s\n",
304                    gpgme_strerror (diag_err));
305         }
306       else
307         {
308           fputs ("Begin Diagnostics:\n", stdout);
309           print_data (diag);
310           fputs ("End Diagnostics.\n", stdout);
311         }
312       gpgme_data_release (diag);
313     }
314
315   if (err)
316     {
317       fprintf (stderr, PGM ": decrypt failed: %s\n", gpgme_strerror (err));
318       if (result)
319         print_result (result);
320       exit (1);
321     }
322   if (result)
323     {
324       if (!raw_output)
325         print_result (result);
326       if (!raw_output)
327         fputs ("Begin Output:\n", stdout);
328       print_data (out);
329       if (!raw_output)
330         fputs ("End Output.\n", stdout);
331     }
332
333   gpgme_data_release (out);
334   gpgme_data_release (in);
335
336   gpgme_release (ctx);
337   return 0;
338 }