json: Fix t-decrypt-verify.out for GnuPG >= 2.3.
[gpgme.git] / tests / gpgsm / t-keylist.c
1 /* t-keylist.c  - regression test
2  * Copyright (C) 2000 Werner Koch (dd9jn)
3  * Copyright (C) 2001, 2003, 2004 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * GPGME is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <https://gnu.org/licenses/>.
19  * SPDX-License-Identifier: LGPL-2.1-or-later
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 #include "t-support.h"
35
36 \f
37 struct
38 {
39   const char *fpr;
40   int secret;
41   long timestamp;
42   long expires;
43   const char *issuer_serial;
44   const char *issuer_name;
45   const char *chain_id;
46   const char *uid;
47   const char *email;
48   gpgme_validity_t validity;
49   unsigned int key_length;
50 }
51 keys[] =
52   {
53     { "3CF405464F66ED4A7DF45BBDD1E4282E33BDB76E", 1, 1007372198, 1038908198, "00",
54       "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=D\xc3\xbcsseldorf,C=DE",
55       "3CF405464F66ED4A7DF45BBDD1E4282E33BDB76E",
56       "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=D\xc3\xbcsseldorf,C=DE",
57       NULL, GPGME_VALIDITY_ULTIMATE, 1024
58     },
59     { "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD", 0, 909684190, 1009821790, "01",
60       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
61       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
62       "O=Deutsches Forschungsnetz,C=DE",
63       "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD",
64       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
65       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
66       "O=Deutsches Forschungsnetz,C=DE",
67       "<certify@pca.dfn.de>", GPGME_VALIDITY_NEVER, 2048
68     },
69     { "2C8F3C356AB761CB3674835B792CDA52937F9285", 0, 973183644, 1009735200, "15",
70       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
71       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
72       "O=Deutsches Forschungsnetz,C=DE",
73       "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD",
74       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
75       "CN=DFN Server Certification Authority,OU=DFN-PCA,"
76       "O=Deutsches Forschungsnetz,C=DE",
77       "<certify@pca.dfn.de>", GPGME_VALIDITY_UNKNOWN, 2048
78     },
79     { NULL }
80   };
81
82
83 int
84 main (void)
85 {
86   gpgme_error_t err;
87   gpgme_ctx_t ctx;
88   gpgme_key_t key;
89   gpgme_keylist_result_t result;
90   int i = 0;
91
92   init_gpgme (GPGME_PROTOCOL_CMS);
93
94   err = gpgme_new (&ctx);
95   fail_if_err (err);
96   gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
97
98   err = gpgme_op_keylist_start (ctx, NULL, 0);
99   fail_if_err (err);
100
101   while (!(err = gpgme_op_keylist_next (ctx, &key)))
102     {
103       if (!keys[i].fpr)
104         {
105           fprintf (stderr, "More keys returned than expected\n");
106           exit (1);
107         }
108
109       if (strcmp (key->subkeys->fpr, keys[i].fpr))
110         {
111           fprintf (stderr, "Warning: Skipping unknown key %s\n",
112                    key->subkeys->fpr);
113           gpgme_key_unref (key);
114           continue;
115         }
116       else
117         printf ("Checking key %s\n", key->subkeys->fpr);
118
119       /* Global key flags.  */
120       if (key->revoked)
121         {
122           fprintf (stderr, "Key unexpectedly revoked\n");
123           exit (1);
124         }
125       if (key->expired)
126         {
127           fprintf (stderr, "Key unexpectedly expired\n");
128           exit (1);
129         }
130       if (key->disabled)
131         {
132           fprintf (stderr, "Key unexpectedly disabled\n");
133           exit (1);
134         }
135       if (key->invalid)
136         {
137           fprintf (stderr, "Key unexpectedly invalid\n");
138           exit (1);
139         }
140       if (key->can_encrypt != keys[i].secret)
141         {
142           fprintf (stderr, "Key unexpectedly%s usable for encryption\n",
143                    key->can_encrypt ? "" : " not");
144           exit (1);
145         }
146       if (key->can_sign != keys[i].secret)
147         {
148           fprintf (stderr, "Key unexpectedly%s usable for signing\n",
149                    key->can_sign ? "" : " not");
150           exit (1);
151         }
152       if (!key->can_certify)
153         {
154           fprintf (stderr, "Key unexpectedly unusable for certifications\n");
155           exit (1);
156         }
157       if (key->secret != keys[i].secret)
158         {
159           fprintf (stderr, "Key unexpectedly%s secret\n",
160                    key->secret ? "" : " not");
161           exit (1);
162         }
163       if (key->protocol != GPGME_PROTOCOL_CMS)
164         {
165           fprintf (stderr, "Key has unexpected protocol: %s\n",
166                    gpgme_get_protocol_name (key->protocol));
167           exit (1);
168         }
169       if (!key->issuer_serial)
170         {
171           fprintf (stderr, "Key unexpectedly misses issuer serial\n");
172           exit (1);
173         }
174       if (strcmp (key->issuer_serial, keys[i].issuer_serial))
175         {
176           fprintf (stderr, "Key has unexpected issuer serial: %s\n",
177                    key->issuer_serial);
178           exit (1);
179         }
180       if (!key->issuer_name)
181         {
182           fprintf (stderr, "Key unexpectedly misses issuer name\n");
183           exit (1);
184         }
185       if (strcmp (key->issuer_name, keys[i].issuer_name))
186         {
187           fprintf (stderr, "Key has unexpected issuer name: %s\n",
188                    key->issuer_name);
189           exit (1);
190         }
191       if (key->chain_id && !keys[i].chain_id)
192         {
193           fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
194                    key->chain_id);
195           exit (1);
196         }
197       if (!key->chain_id && keys[i].chain_id)
198         {
199           fprintf (stderr, "Key unexpectedly carries no chain ID\n");
200           exit (1);
201         }
202       if (key->chain_id && strcmp (key->chain_id, keys[i].chain_id))
203         {
204           fprintf (stderr, "Key carries unexpected chain ID: %s\n",
205                    key->chain_id);
206           exit (1);
207         }
208       if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
209         {
210           fprintf (stderr, "Key has unexpected owner trust: %i\n",
211                    key->owner_trust);
212           exit (1);
213         }
214       if (!key->subkeys || key->subkeys->next)
215         {
216           fprintf (stderr, "Key has unexpected number of subkeys\n");
217           exit (1);
218         }
219
220       /* Primary key.  */
221       if (key->subkeys->revoked)
222         {
223           fprintf (stderr, "Primary key unexpectedly revoked\n");
224           exit (1);
225         }
226       if (key->subkeys->expired)
227         {
228           fprintf (stderr, "Primary key unexpectedly expired\n");
229           exit (1);
230         }
231       if (key->subkeys->disabled)
232         {
233           fprintf (stderr, "Primary key unexpectedly disabled\n");
234           exit (1);
235         }
236       if (key->subkeys->invalid)
237         {
238           fprintf (stderr, "Primary key unexpectedly invalid\n");
239           exit (1);
240         }
241       if (key->subkeys->can_encrypt != keys[i].secret)
242         {
243           fprintf (stderr, "Key unexpectedly%s usable for encryption\n",
244                    key->subkeys->can_encrypt ? "" : " not");
245           exit (1);
246         }
247       if (key->subkeys->can_sign != keys[i].secret)
248         {
249           fprintf (stderr, "Key unexpectedly%s usable for signing\n",
250                    key->subkeys->can_sign ? "" : " not");
251           exit (1);
252         }
253       if (!key->subkeys->can_certify)
254         {
255           fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
256           exit (1);
257         }
258       if (key->subkeys->secret != keys[i].secret)
259         {
260           fprintf (stderr, "Primary Key unexpectedly%s secret\n",
261                    key->secret ? "" : " not");
262           exit (1);
263         }
264       if (key->subkeys->pubkey_algo != GPGME_PK_RSA)
265         {
266           fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
267                    gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
268           exit (1);
269         }
270       if (key->subkeys->length != keys[i].key_length)
271         {
272           fprintf (stderr, "Primary key has unexpected length: %i\n",
273                    key->subkeys->length);
274           exit (1);
275         }
276       if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
277         {
278           fprintf (stderr, "Primary key has unexpected key ID: %s\n",
279                    key->subkeys->keyid);
280           exit (1);
281         }
282       if (strcmp (key->subkeys->fpr, keys[i].fpr))
283         {
284           fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
285                    key->subkeys->fpr);
286           exit (1);
287         }
288       if (key->subkeys->timestamp != keys[i].timestamp)
289         {
290           fprintf (stderr, "Primary key unexpected timestamp: %lu\n",
291                    key->subkeys->timestamp);
292           exit (1);
293         }
294       if (key->subkeys->expires != keys[i].expires)
295         {
296           fprintf (stderr, "Primary key unexpectedly expires: %lu\n",
297                    key->subkeys->expires);
298           exit (1);
299         }
300
301       /* Be tolerant against a missing email (ie, older gpgsm versions).  */
302       if (!key->uids || (key->uids->next && !keys[i].email))
303         {
304           fprintf (stderr, "Key has unexpected number of user IDs\n");
305           exit (1);
306         }
307       if (key->uids->revoked)
308         {
309           fprintf (stderr, "User ID unexpectedly revoked\n");
310           exit (1);
311         }
312       if (key->uids->invalid)
313         {
314           fprintf (stderr, "User ID unexpectedly invalid\n");
315           exit (1);
316         }
317       if (key->uids->validity != keys[i].validity)
318         {
319           fprintf (stderr, "User ID unexpectedly validity: %i\n",
320                    key->uids->validity);
321           exit (1);
322         }
323       if (key->uids->signatures)
324         {
325           fprintf (stderr, "User ID unexpectedly signed\n");
326           exit (1);
327         }
328       if (!key->uids->name || key->uids->name[0])
329         {
330           fprintf (stderr, "Unexpected name in user ID: %s\n",
331                    key->uids->name);
332           exit (1);
333         }
334       if (!key->uids->comment || key->uids->comment[0])
335         {
336           fprintf (stderr, "Unexpected comment in user ID: %s\n",
337                    key->uids->comment);
338           exit (1);
339         }
340       if (!key->uids->email || key->uids->email[0])
341         {
342           fprintf (stderr, "Unexpected email in user ID: %s\n",
343                    key->uids->email);
344           exit (1);
345         }
346       if (!key->uids->uid || strcmp (key->uids->uid, keys[i].uid))
347         {
348           fprintf (stderr, "Unexpected uid in user ID: %s\n",
349                    key->uids->uid);
350           exit (1);
351         }
352       if (key->uids->next && strcmp (key->uids->next->uid, keys[i].email))
353         {
354           fprintf (stderr, "Unexpected email in user ID: %s\n",
355                    key->uids->next->uid);
356           exit (1);
357         }
358       if (key->uids->next && strcmp (key->uids->next->uid, keys[i].email))
359         {
360           fprintf (stderr, "Unexpected email in user ID: %s\n",
361                    key->uids->next->uid);
362           exit (1);
363         }
364
365
366
367       gpgme_key_unref (key);
368       i++;
369     }
370   if (gpgme_err_code (err) != GPG_ERR_EOF)
371     fail_if_err (err);
372   err = gpgme_op_keylist_end (ctx);
373   fail_if_err (err);
374
375   result = gpgme_op_keylist_result (ctx);
376   if (result->truncated)
377     {
378       fprintf (stderr, "Key listing unexpectedly truncated\n");
379       exit (1);
380     }
381
382   if (keys[i].fpr)
383     {
384       fprintf (stderr, "Less keys returned than expected\n");
385       exit (1);
386     }
387
388   gpgme_release (ctx);
389   return 0;
390 }