63251ad725ecc4e1d683c004262c3ce978ff4fa3
[gpgme.git] / tests / gpg / t-keylist-sig.c
1 /* t-keylist-sig.c - Regression test.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2003 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 General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (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    General Public License for more details.
16  
17    You should have received a copy of the GNU General Public License
18    along with GPGME; if not, write to the Free Software Foundation,
19    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24
25 #include <gpgme.h>
26
27 \f
28 #define fail_if_err(err)                                        \
29   do                                                            \
30     {                                                           \
31       if (err)                                                  \
32         {                                                       \
33           fprintf (stderr, "%s:%d: gpgme_error_t %s\n",         \
34                    __FILE__, __LINE__, gpgme_strerror (err));   \
35           exit (1);                                             \
36         }                                                       \
37     }                                                           \
38   while (0)
39
40
41 struct
42 {
43   char *fpr;
44   char *sec_keyid;
45   struct
46   {
47     char *name;
48     char *comment;
49     char *email;
50     struct
51     {
52       gpgme_pubkey_algo_t algo;
53       char *keyid;
54       char *name;
55       char *comment;
56       char *email;
57       int class;
58       int exportable;
59     } sig;
60   } uid[3];  
61 }
62 keys[] =
63   {
64     { "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
65       { { "Alfa Test", "demo key", "alfa@example.net",
66           { GPGME_PK_DSA, "2D727CC768697734",
67             "Alfa Test", "demo key", "alfa@example.net", 19, 1 } },
68         { "Alpha Test", "demo key", "alpha@example.net",
69           { GPGME_PK_DSA, "2D727CC768697734",
70             "Alfa Test", "demo key", "alfa@example.net", 19, 1 } },
71         { "Alice", "demo key", NULL,
72           { GPGME_PK_DSA, "2D727CC768697734",
73             "Alfa Test", "demo key", "alfa@example.net", 19, 1 } } } },
74     { NULL }
75   };
76
77 int 
78 main (int argc, char **argv)
79 {
80   gpgme_error_t err;
81   gpgme_ctx_t ctx;
82   gpgme_key_t key;
83   gpgme_keylist_result_t result;
84   int mode;
85   int i = 0;
86
87   err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
88   fail_if_err (err);
89
90   err = gpgme_new (&ctx);
91   fail_if_err (err);
92
93   mode  = gpgme_get_keylist_mode (ctx);
94   mode |= GPGME_KEYLIST_MODE_SIGS;
95   err = gpgme_set_keylist_mode (ctx, mode);
96   fail_if_err (err);
97
98   err = gpgme_op_keylist_start (ctx, "Alpha", 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       /* Global key flags.  */
110       if (key->revoked)
111         {
112           fprintf (stderr, "Key unexpectedly revoked\n");
113           exit (1);
114         }
115       if (key->expired)
116         {
117           fprintf (stderr, "Key unexpectedly expired\n");
118           exit (1);
119         }
120       if (key->disabled)
121         {
122           fprintf (stderr, "Key unexpectedly disabled\n");
123           exit (1);
124         }
125       if (key->invalid)
126         {
127           fprintf (stderr, "Key unexpectedly invalid\n");
128           exit (1);
129         }
130       if (!key->can_encrypt)
131         {
132           fprintf (stderr, "Key unexpectedly unusable for encryption\n");
133           exit (1);
134         }
135       if (!key->can_sign)
136         {
137           fprintf (stderr, "Key unexpectedly unusable for signing\n");
138           exit (1);
139         }
140       if (!key->can_certify)
141         {
142           fprintf (stderr, "Key unexpectedly unusable for certifications\n");
143           exit (1);
144         }
145       if (key->secret)
146         {
147           fprintf (stderr, "Key unexpectedly secret\n");
148           exit (1);
149         }
150       if (key->protocol != GPGME_PROTOCOL_OpenPGP)
151         {
152           fprintf (stderr, "Key has unexpected protocol: %s\n",
153                    gpgme_get_protocol_name (key->protocol));
154           exit (1);
155         }
156       if (key->issuer_serial)
157         {
158           fprintf (stderr, "Key unexpectedly carries issuer serial: %s\n",
159                    key->issuer_serial);
160           exit (1);
161         }
162       if (key->issuer_name)
163         {
164           fprintf (stderr, "Key unexpectedly carries issuer name: %s\n",
165                    key->issuer_name);
166           exit (1);
167         }
168       if (key->chain_id)
169         {
170           fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
171                    key->chain_id);
172           exit (1);
173         }
174       if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
175         {
176           fprintf (stderr, "Key has unexpected owner trust: %i\n",
177                    key->owner_trust);
178           exit (1);
179         }
180       if (!key->subkeys || !key->subkeys->next || key->subkeys->next->next)
181         {
182           fprintf (stderr, "Key has unexpected number of subkeys\n");
183           exit (1);
184         }
185
186       /* Primary key.  */
187       if (key->subkeys->revoked)
188         {
189           fprintf (stderr, "Primary key unexpectedly revoked\n");
190           exit (1);
191         }
192       if (key->subkeys->expired)
193         {
194           fprintf (stderr, "Primary key unexpectedly expired\n");
195           exit (1);
196         }
197       if (key->subkeys->disabled)
198         {
199           fprintf (stderr, "Primary key unexpectedly disabled\n");
200           exit (1);
201         }
202       if (key->subkeys->invalid)
203         {
204           fprintf (stderr, "Primary key unexpectedly invalid\n");
205           exit (1);
206         }
207       if (key->subkeys->can_encrypt)
208         {
209           fprintf (stderr, "Primary key unexpectedly usable for encryption\n");
210           exit (1);
211         }
212       if (!key->subkeys->can_sign)
213         {
214           fprintf (stderr, "Primary key unexpectedly unusable for signing\n");
215           exit (1);
216         }
217       if (!key->subkeys->can_certify)
218         {
219           fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
220           exit (1);
221         }
222       if (key->subkeys->secret)
223         {
224           fprintf (stderr, "Primary key unexpectedly secret\n");
225           exit (1);
226         }
227       if (key->subkeys->pubkey_algo != GPGME_PK_DSA)
228         {
229           fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
230                    gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
231           exit (1);
232         }
233       if (key->subkeys->length != 1024)
234         {
235           fprintf (stderr, "Primary key has unexpected length: %i\n",
236                    key->subkeys->length);
237           exit (1);
238         }
239       if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
240         {
241           fprintf (stderr, "Primary key has unexpected key ID: %s\n",
242                    key->subkeys->keyid);
243           exit (1);
244         }
245       if (strcmp (key->subkeys->fpr, keys[i].fpr))
246         {
247           fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
248                    key->subkeys->fpr);
249           exit (1);
250         }
251       if (key->subkeys->expires)
252         {
253           fprintf (stderr, "Primary key unexpectedly expires: %lu\n",
254                    key->subkeys->expires);
255           exit (1);
256         }
257
258       /* Secondary key.  */
259       if (key->subkeys->next->revoked)
260         {
261           fprintf (stderr, "Secondary key unexpectedly revoked\n");
262           exit (1);
263         }
264       if (key->subkeys->next->expired)
265         {
266           fprintf (stderr, "Secondary key unexpectedly expired\n");
267           exit (1);
268         }
269       if (key->subkeys->next->disabled)
270         {
271           fprintf (stderr, "Secondary key unexpectedly disabled\n");
272           exit (1);
273         }
274       if (key->subkeys->next->invalid)
275         {
276           fprintf (stderr, "Secondary key unexpectedly invalid\n");
277           exit (1);
278         }
279       if (!key->subkeys->next->can_encrypt)
280         {
281           fprintf (stderr, "Secondary key unexpectedly unusable for encryption\n");
282           exit (1);
283         }
284       if (key->subkeys->next->can_sign)
285         {
286           fprintf (stderr, "Secondary key unexpectedly usable for signing\n");
287           exit (1);
288         }
289       if (key->subkeys->next->can_certify)
290         {
291           fprintf (stderr, "Secondary key unexpectedly usable for certifications\n");
292           exit (1);
293         }
294       if (key->subkeys->next->secret)
295         {
296           fprintf (stderr, "Secondary key unexpectedly secret\n");
297           exit (1);
298         }
299       if (key->subkeys->next->pubkey_algo != GPGME_PK_ELG_E)
300         {
301           fprintf (stderr, "Secondary key has unexpected public key algo: %s\n",
302                    gpgme_pubkey_algo_name (key->subkeys->next->pubkey_algo));
303           exit (1);
304         }
305       if (key->subkeys->next->length != 1024)
306         {
307           fprintf (stderr, "Secondary key has unexpected length: %i\n",
308                    key->subkeys->next->length);
309           exit (1);
310         }
311       if (strcmp (key->subkeys->next->keyid, keys[i].sec_keyid))
312         {
313           fprintf (stderr, "Secondary key has unexpected key ID: %s\n",
314                    key->subkeys->next->keyid);
315           exit (1);
316         }
317       if (key->subkeys->next->fpr)
318         {
319           fprintf (stderr, "Secondary key has unexpectedly a fingerprint: %s\n",
320                    key->subkeys->next->fpr);
321           exit (1);
322         }
323       if (key->subkeys->next->expires)
324         {
325           fprintf (stderr, "Secondary key unexpectedly expires: %lu\n",
326                    key->subkeys->next->expires);
327           exit (1);
328         }
329
330       /* FIXME: The below test will crash if we want to check for a
331          name, comment or email that doesn't exist in the key's user
332          IDs.  */
333       if (!((!keys[i].uid[0].name && !key->uids)
334             || (keys[i].uid[0].name && !keys[i].uid[1].name
335                 && key->uids && !key->uids->next)
336             || (keys[i].uid[0].name && keys[i].uid[1].name
337                 && !keys[i].uid[2].name
338                 && key->uids && key->uids->next && !key->uids->next->next)
339             || (keys[i].uid[0].name && keys[i].uid[1].name
340                 && keys[i].uid[2].name
341                 && key->uids && key->uids->next && key->uids->next->next
342                 && !key->uids->next->next->next)))
343           {
344             fprintf (stderr, "Key has unexpected number of user IDs\n");
345             exit (1);
346           }
347       if (key->uids && key->uids->revoked)
348         {
349           fprintf (stderr, "First user ID unexpectedly revoked\n");
350           exit (1);
351         }
352       if (key->uids && key->uids->invalid)
353         {
354           fprintf (stderr, "First user ID unexpectedly invalid\n");
355           exit (1);
356         }
357       if (key->uids && key->uids->validity != GPGME_VALIDITY_UNKNOWN)
358         {
359           fprintf (stderr, "First user ID has unexpectedly validity: %i\n",
360                    key->uids->validity);
361           exit (1);
362         }
363       if (keys[i].uid[0].name
364           && strcmp (keys[i].uid[0].name, key->uids->name))
365         {
366           fprintf (stderr, "Unexpected name in first user ID: %s\n",
367                    key->uids->name);
368           exit (1);
369         }
370       if (keys[i].uid[0].comment
371           && strcmp (keys[i].uid[0].comment, key->uids->comment))
372         {
373           fprintf (stderr, "Unexpected comment in first user ID: %s\n",
374                    key->uids->comment);
375           exit (1);
376         }
377       if (keys[i].uid[0].email
378           && strcmp (keys[i].uid[0].email, key->uids->email))
379         {
380           fprintf (stderr, "Unexpected email in first user ID: %s\n",
381                    key->uids->email);
382           exit (1);
383         }
384       if (key->uids && (!key->uids->signatures || key->uids->signatures->next))
385         {
386           fprintf (stderr, "First user ID unexpected number of signatures\n");
387           exit (1);
388         }
389       if (keys[i].uid[0].sig.algo != key->uids->signatures->pubkey_algo)
390         {
391           fprintf (stderr, "Unexpected algorithm in first user ID sig: %s\n",
392                    gpgme_pubkey_algo_name (key->uids->signatures->pubkey_algo));
393           exit (1);
394         }
395       if (strcmp (keys[i].uid[0].sig.keyid, key->uids->signatures->keyid))
396         {
397           fprintf (stderr, "Unexpected key ID in first user ID sig: %s\n",
398                    key->uids->signatures->keyid);
399           exit (1);
400         }
401       if (strcmp (keys[i].uid[0].sig.name, key->uids->signatures->name))
402         {
403           fprintf (stderr, "Unexpected name in first user ID sig: %s\n",
404                    key->uids->signatures->name);
405           exit (1);
406         }
407       if (strcmp (keys[i].uid[0].sig.comment, key->uids->signatures->comment))
408         {
409           fprintf (stderr, "Unexpected comment in first user ID sig: %s\n",
410                    key->uids->signatures->comment);
411           exit (1);
412         }
413       if (strcmp (keys[i].uid[0].sig.email, key->uids->signatures->email))
414         {
415           fprintf (stderr, "Unexpected email in first user ID sig: %s\n",
416                    key->uids->signatures->email);
417           exit (1);
418         }
419       if (keys[i].uid[0].sig.class != key->uids->signatures->class)
420         {
421           fprintf (stderr, "Unexpected class in first user ID sig: %i\n",
422                    key->uids->signatures->class);
423           exit (1);
424         }
425       if (keys[i].uid[0].sig.exportable != key->uids->signatures->exportable)
426         {
427           fprintf (stderr, "Unexpected exportable stat in first user ID sig: %i\n",
428                    key->uids->signatures->exportable);
429           exit (1);
430         }
431
432       if (key->uids && key->uids->next && key->uids->next->revoked)
433         {
434           fprintf (stderr, "Second user ID unexpectedly revoked\n");
435           exit (1);
436         }
437       if (key->uids && key->uids->next && key->uids->next->invalid)
438         {
439           fprintf (stderr, "Second user ID unexpectedly invalid\n");
440           exit (1);
441         }
442       if (key->uids && key->uids->next
443           && key->uids->next->validity != GPGME_VALIDITY_UNKNOWN)
444         {
445           fprintf (stderr, "Second user ID has unexpectedly validity: %i\n",
446                    key->uids->next->validity);
447           exit (1);
448         }
449       if (keys[i].uid[1].name
450           && strcmp (keys[i].uid[1].name, key->uids->next->name))
451         {
452           fprintf (stderr, "Unexpected name in second user ID: %s\n",
453                    key->uids->next->name);
454           exit (1);
455         }
456       if (keys[i].uid[1].comment
457           && strcmp (keys[i].uid[1].comment, key->uids->next->comment))
458         {
459           fprintf (stderr, "Unexpected comment in second user ID: %s\n",
460                    key->uids->next->comment);
461           exit (1);
462         }
463       if (keys[i].uid[1].email
464           && strcmp (keys[i].uid[1].email, key->uids->next->email))
465         {
466           fprintf (stderr, "Unexpected email in second user ID: %s\n",
467                    key->uids->next->email);
468           exit (1);
469         }
470       if (key->uids && (!key->uids->next->signatures || key->uids->next->signatures->next))
471         {
472           fprintf (stderr, "Second user ID unexpected number of signatures\n");
473           exit (1);
474         }
475       if (keys[i].uid[1].sig.algo != key->uids->next->signatures->pubkey_algo)
476         {
477           fprintf (stderr, "Unexpected algorithm in second user ID sig: %s\n",
478                    gpgme_pubkey_algo_name (key->uids->next->signatures->pubkey_algo));
479           exit (1);
480         }
481       if (strcmp (keys[i].uid[1].sig.keyid, key->uids->next->signatures->keyid))
482         {
483           fprintf (stderr, "Unexpected key ID in second user ID sig: %s\n",
484                    key->uids->next->signatures->keyid);
485           exit (1);
486         }
487       if (strcmp (keys[i].uid[1].sig.name, key->uids->next->signatures->name))
488         {
489           fprintf (stderr, "Unexpected name in second user ID sig: %s\n",
490                    key->uids->next->signatures->name);
491           exit (1);
492         }
493       if (strcmp (keys[i].uid[1].sig.comment, key->uids->next->signatures->comment))
494         {
495           fprintf (stderr, "Unexpected comment in second user ID sig: %s\n",
496                    key->uids->next->signatures->comment);
497           exit (1);
498         }
499       if (strcmp (keys[i].uid[1].sig.email, key->uids->next->signatures->email))
500         {
501           fprintf (stderr, "Unexpected email in second user ID sig: %s\n",
502                    key->uids->next->signatures->email);
503           exit (1);
504         }
505       if (keys[i].uid[1].sig.class != key->uids->next->signatures->class)
506         {
507           fprintf (stderr, "Unexpected class in second user ID sig: %i\n",
508                    key->uids->next->signatures->class);
509           exit (1);
510         }
511       if (keys[i].uid[1].sig.exportable != key->uids->next->signatures->exportable)
512         {
513           fprintf (stderr, "Unexpected exportable stat in second user ID sig: %i\n",
514                    key->uids->next->signatures->exportable);
515           exit (1);
516         }
517
518       if (key->uids && key->uids->next && key->uids->next->next
519           && key->uids->next->next->revoked)
520         {
521           fprintf (stderr, "Third user ID unexpectedly revoked\n");
522           exit (1);
523         }
524       if (key->uids && key->uids->next && key->uids->next->next
525           && key->uids->next->next->invalid)
526         {
527           fprintf (stderr, "Third user ID unexpectedly invalid\n");
528           exit (1);
529         }
530       if (key->uids && key->uids->next && key->uids->next->next
531           && key->uids->next->next->validity != GPGME_VALIDITY_UNKNOWN)
532         {
533           fprintf (stderr, "Third user ID has unexpectedly validity: %i\n",
534                    key->uids->next->next->validity);
535           exit (1);
536         }
537       if (keys[i].uid[2].name
538           && strcmp (keys[i].uid[2].name, key->uids->next->next->name))
539         {
540           fprintf (stderr, "Unexpected name in third user ID: %s\n",
541                    key->uids->next->next->name);
542           exit (1);
543         }
544       if (keys[i].uid[2].comment
545           && strcmp (keys[i].uid[2].comment, key->uids->next->next->comment))
546         {
547           fprintf (stderr, "Unexpected comment in third user ID: %s\n",
548                    key->uids->next->next->comment);
549           exit (1);
550         }
551       if (keys[i].uid[2].email
552           && strcmp (keys[i].uid[2].email, key->uids->next->next->email))
553         {
554           fprintf (stderr, "Unexpected email in third user ID: %s\n",
555                    key->uids->next->next->email);
556           exit (1);
557         }
558       if (key->uids && (!key->uids->next->next->signatures
559                         || key->uids->next->next->signatures->next))
560         {
561           fprintf (stderr, "Third user ID unexpected number of signatures\n");
562           exit (1);
563         }
564       if (keys[i].uid[2].sig.algo != key->uids->next->next->signatures->pubkey_algo)
565         {
566           fprintf (stderr, "Unexpected algorithm in third user ID sig: %s\n",
567                    gpgme_pubkey_algo_name (key->uids->next->next->signatures->pubkey_algo));
568           exit (1);
569         }
570       if (strcmp (keys[i].uid[2].sig.keyid, key->uids->next->next->signatures->keyid))
571         {
572           fprintf (stderr, "Unexpected key ID in third user ID sig: %s\n",
573                    key->uids->next->next->signatures->keyid);
574           exit (1);
575         }
576       if (strcmp (keys[i].uid[2].sig.name, key->uids->next->next->signatures->name))
577         {
578           fprintf (stderr, "Unexpected name in third user ID sig: %s\n",
579                    key->uids->next->next->signatures->name);
580           exit (1);
581         }
582       if (strcmp (keys[i].uid[2].sig.comment, key->uids->next->next->signatures->comment))
583         {
584           fprintf (stderr, "Unexpected comment in third user ID sig: %s\n",
585                    key->uids->next->next->signatures->comment);
586           exit (1);
587         }
588       if (strcmp (keys[i].uid[2].sig.email, key->uids->next->next->signatures->email))
589         {
590           fprintf (stderr, "Unexpected email in third user ID sig: %s\n",
591                    key->uids->next->next->signatures->email);
592           exit (1);
593         }
594       if (keys[i].uid[2].sig.class != key->uids->next->next->signatures->class)
595         {
596           fprintf (stderr, "Unexpected class in third user ID sig: %i\n",
597                    key->uids->next->next->signatures->class);
598           exit (1);
599         }
600       if (keys[i].uid[2].sig.exportable != key->uids->next->next->signatures->exportable)
601         {
602           fprintf (stderr, "Unexpected exportable stat in third user ID sig: %i\n",
603                    key->uids->next->next->signatures->exportable);
604           exit (1);
605         }
606
607
608
609
610
611       gpgme_key_unref (key);
612       i++;
613     }
614   if (err != GPGME_EOF)
615     fail_if_err (err);
616   err = gpgme_op_keylist_end (ctx);
617   fail_if_err (err);
618
619   result = gpgme_op_keylist_result (ctx);
620   if (result->truncated)
621     {
622       fprintf (stderr, "Key listing unexpectedly truncated\n");
623       exit (1);
624     }
625
626   if (keys[i].fpr)
627     {
628       fprintf (stderr, "Less keys returned than expected\n");
629       exit (1);
630     }
631
632   gpgme_release (ctx);
633   return 0;
634 }