doc/
[gpgme.git] / tests / gpg / t-keylist.c
1 /* t-keylist.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 #include "t-support.h"
28
29 \f
30 struct
31 {
32   char *fpr;
33   char *sec_keyid;
34   struct
35   {
36     char *name;
37     char *comment;
38     char *email;
39   } uid[3];
40 }
41 keys[] =
42   {
43     { "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
44       { { "Alfa Test", "demo key", "alfa@example.net" },
45         { "Alpha Test", "demo key", "alpha@example.net" },
46         { "Alice", "demo key", NULL } } },
47     { "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
48       { { "Charlie Test", "demo key", "charlie@example.net" } } },
49     { "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
50       { { "Echelon", "demo key", NULL },
51         { "Echo Test", "demo key", "echo@example.net" },
52         { "Eve", "demo key", NULL } } },
53     { "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
54       { { "Golf Test", "demo key", "golf@example.net" } } },
55     { "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
56       { { "India Test", "demo key", "india@example.net" } } },
57     { "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
58       { { "Kilo Test", "demo key", "kilo@example.net" } } },
59     { "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
60       { { "Bob", "demo key", NULL },
61         { "Bravo Test", "demo key", "bravo@example.net" } } },
62     { "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
63       { { "Delta Test", "demo key", "delta@example.net" } } },
64     { "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
65       { { "Foxtrot Test", "demo key", "foxtrot@example.net" } } },
66     { "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
67       { { "Hotel Test", "demo key", "hotel@example.net" } } },
68     { "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
69       { { "Juliet Test", "demo key", "juliet@example.net" } } },
70     { "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
71       { { "Lima Test", "demo key", "lima@example.net" } } },
72     { "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
73       { { "Mallory", "demo key", NULL },
74         { "Mike Test", "demo key", "mike@example.net" } } },
75     { "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
76       { { "November Test", "demo key", "november@example.net" } } },
77     { "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
78       { { "Oscar Test", "demo key", "oscar@example.net" } } },
79     { "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
80       { { "Papa test", "demo key", "papa@example.net" } } },
81     { "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
82       { { "Quebec Test", "demo key", "quebec@example.net" } } },
83     { "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
84       { { "Romeo Test", "demo key", "romeo@example.net" } } },
85     { "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
86       { { "Sierra Test", "demo key", "sierra@example.net" } } },
87     { "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
88       { { "Tango Test", "demo key", "tango@example.net" } } },
89     { "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
90       { { "Uniform Test", "demo key", "uniform@example.net" } } },
91     { "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
92       { { "Victor Test", "demo key", "victor@example.org" } } },
93     { "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
94       { { "Whisky Test", "demo key", "whisky@example.net" } } },
95     { "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
96       { { "XRay Test", "demo key", "xray@example.net" } } },
97     { "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
98       { { "Yankee Test", "demo key", "yankee@example.net" } } },
99     { "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
100       { { "Zulu Test", "demo key", "zulu@example.net" } } },
101     { "ADAB7FCC1F4DE2616ECFA402AF82244F9CD9FD55", "087DD7E0381701C4",
102       { { "Joe Random Hacker", "test key with passphrase \"x\"",
103           "joe@setq.org" } } },
104     { NULL }
105   };
106
107 int 
108 main (int argc, char **argv)
109 {
110   gpgme_error_t err;
111   gpgme_ctx_t ctx;
112   gpgme_key_t key;
113   gpgme_keylist_result_t result;
114   int i = 0;
115
116   err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
117   fail_if_err (err);
118
119   err = gpgme_new (&ctx);
120   fail_if_err (err);
121
122   err = gpgme_op_keylist_start (ctx, NULL, 0);
123   fail_if_err (err);
124     
125   while (!(err = gpgme_op_keylist_next (ctx, &key)))
126     {
127       if (!keys[i].fpr)
128         {
129           fprintf (stderr, "More keys returned than expected\n");
130           exit (1);
131         }
132
133       /* Global key flags.  */
134       if (key->revoked)
135         {
136           fprintf (stderr, "Key unexpectedly revoked\n");
137           exit (1);
138         }
139       if (key->expired)
140         {
141           fprintf (stderr, "Key unexpectedly expired\n");
142           exit (1);
143         }
144       if (key->disabled)
145         {
146           fprintf (stderr, "Key unexpectedly disabled\n");
147           exit (1);
148         }
149       if (key->invalid)
150         {
151           fprintf (stderr, "Key unexpectedly invalid\n");
152           exit (1);
153         }
154       if (!key->can_encrypt)
155         {
156           fprintf (stderr, "Key unexpectedly unusable for encryption\n");
157           exit (1);
158         }
159       if (!key->can_sign)
160         {
161           fprintf (stderr, "Key unexpectedly unusable for signing\n");
162           exit (1);
163         }
164       if (!key->can_certify)
165         {
166           fprintf (stderr, "Key unexpectedly unusable for certifications\n");
167           exit (1);
168         }
169       if (key->secret)
170         {
171           fprintf (stderr, "Key unexpectedly secret\n");
172           exit (1);
173         }
174       if (key->protocol != GPGME_PROTOCOL_OpenPGP)
175         {
176           fprintf (stderr, "Key has unexpected protocol: %s\n",
177                    gpgme_get_protocol_name (key->protocol));
178           exit (1);
179         }
180       if (key->issuer_serial)
181         {
182           fprintf (stderr, "Key unexpectedly carries issuer serial: %s\n",
183                    key->issuer_serial);
184           exit (1);
185         }
186       if (key->issuer_name)
187         {
188           fprintf (stderr, "Key unexpectedly carries issuer name: %s\n",
189                    key->issuer_name);
190           exit (1);
191         }
192       if (key->chain_id)
193         {
194           fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
195                    key->chain_id);
196           exit (1);
197         }
198       if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
199         {
200           fprintf (stderr, "Key has unexpected owner trust: %i\n",
201                    key->owner_trust);
202           exit (1);
203         }
204       if (!key->subkeys || !key->subkeys->next || key->subkeys->next->next)
205         {
206           fprintf (stderr, "Key has unexpected number of subkeys\n");
207           exit (1);
208         }
209
210       /* Primary key.  */
211       if (key->subkeys->revoked)
212         {
213           fprintf (stderr, "Primary key unexpectedly revoked\n");
214           exit (1);
215         }
216       if (key->subkeys->expired)
217         {
218           fprintf (stderr, "Primary key unexpectedly expired\n");
219           exit (1);
220         }
221       if (key->subkeys->disabled)
222         {
223           fprintf (stderr, "Primary key unexpectedly disabled\n");
224           exit (1);
225         }
226       if (key->subkeys->invalid)
227         {
228           fprintf (stderr, "Primary key unexpectedly invalid\n");
229           exit (1);
230         }
231       if (key->subkeys->can_encrypt)
232         {
233           fprintf (stderr, "Primary key unexpectedly usable for encryption\n");
234           exit (1);
235         }
236       if (!key->subkeys->can_sign)
237         {
238           fprintf (stderr, "Primary key unexpectedly unusable for signing\n");
239           exit (1);
240         }
241       if (!key->subkeys->can_certify)
242         {
243           fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
244           exit (1);
245         }
246       if (key->subkeys->secret)
247         {
248           fprintf (stderr, "Primary key unexpectedly secret\n");
249           exit (1);
250         }
251       if (key->subkeys->pubkey_algo != GPGME_PK_DSA)
252         {
253           fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
254                    gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
255           exit (1);
256         }
257       if (key->subkeys->length != 1024)
258         {
259           fprintf (stderr, "Primary key has unexpected length: %i\n",
260                    key->subkeys->length);
261           exit (1);
262         }
263       if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
264         {
265           fprintf (stderr, "Primary key has unexpected key ID: %s\n",
266                    key->subkeys->keyid);
267           exit (1);
268         }
269       if (strcmp (key->subkeys->fpr, keys[i].fpr))
270         {
271           fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
272                    key->subkeys->fpr);
273           exit (1);
274         }
275       if (key->subkeys->expires)
276         {
277           fprintf (stderr, "Primary key unexpectedly expires: %lu\n",
278                    key->subkeys->expires);
279           exit (1);
280         }
281
282       /* Secondary key.  */
283       if (key->subkeys->next->revoked)
284         {
285           fprintf (stderr, "Secondary key unexpectedly revoked\n");
286           exit (1);
287         }
288       if (key->subkeys->next->expired)
289         {
290           fprintf (stderr, "Secondary key unexpectedly expired\n");
291           exit (1);
292         }
293       if (key->subkeys->next->disabled)
294         {
295           fprintf (stderr, "Secondary key unexpectedly disabled\n");
296           exit (1);
297         }
298       if (key->subkeys->next->invalid)
299         {
300           fprintf (stderr, "Secondary key unexpectedly invalid\n");
301           exit (1);
302         }
303       if (!key->subkeys->next->can_encrypt)
304         {
305           fprintf (stderr, "Secondary key unexpectedly unusable for encryption\n");
306           exit (1);
307         }
308       if (key->subkeys->next->can_sign)
309         {
310           fprintf (stderr, "Secondary key unexpectedly usable for signing\n");
311           exit (1);
312         }
313       if (key->subkeys->next->can_certify)
314         {
315           fprintf (stderr, "Secondary key unexpectedly usable for certifications\n");
316           exit (1);
317         }
318       if (key->subkeys->next->secret)
319         {
320           fprintf (stderr, "Secondary key unexpectedly secret\n");
321           exit (1);
322         }
323       if (key->subkeys->next->pubkey_algo != GPGME_PK_ELG_E)
324         {
325           fprintf (stderr, "Secondary key has unexpected public key algo: %s\n",
326                    gpgme_pubkey_algo_name (key->subkeys->next->pubkey_algo));
327           exit (1);
328         }
329       if (key->subkeys->next->length != 1024)
330         {
331           fprintf (stderr, "Secondary key has unexpected length: %i\n",
332                    key->subkeys->next->length);
333           exit (1);
334         }
335       if (strcmp (key->subkeys->next->keyid, keys[i].sec_keyid))
336         {
337           fprintf (stderr, "Secondary key has unexpected key ID: %s\n",
338                    key->subkeys->next->keyid);
339           exit (1);
340         }
341       if (key->subkeys->next->fpr)
342         {
343           fprintf (stderr, "Secondary key has unexpectedly a fingerprint: %s\n",
344                    key->subkeys->next->fpr);
345           exit (1);
346         }
347       if (key->subkeys->next->expires)
348         {
349           fprintf (stderr, "Secondary key unexpectedly expires: %lu\n",
350                    key->subkeys->next->expires);
351           exit (1);
352         }
353
354       /* FIXME: The below test will crash if we want to check for a
355          name, comment or email that doesn't exist in the key's user
356          IDs.  */
357       if (!((!keys[i].uid[0].name && !key->uids)
358             || (keys[i].uid[0].name && !keys[i].uid[1].name
359                 && key->uids && !key->uids->next)
360             || (keys[i].uid[0].name && keys[i].uid[1].name
361                 && !keys[i].uid[2].name
362                 && key->uids && key->uids->next && !key->uids->next->next)
363             || (keys[i].uid[0].name && keys[i].uid[1].name
364                 && keys[i].uid[2].name
365                 && key->uids && key->uids->next && key->uids->next->next
366                 && !key->uids->next->next->next)))
367           {
368             fprintf (stderr, "Key has unexpected number of user IDs\n");
369             exit (1);
370           }
371       if (key->uids && key->uids->revoked)
372         {
373           fprintf (stderr, "First user ID unexpectedly revoked\n");
374           exit (1);
375         }
376       if (key->uids && key->uids->invalid)
377         {
378           fprintf (stderr, "First user ID unexpectedly invalid\n");
379           exit (1);
380         }
381       if (key->uids && key->uids->validity != GPGME_VALIDITY_UNKNOWN)
382         {
383           fprintf (stderr, "First user ID has unexpectedly validity: %i\n",
384                    key->uids->validity);
385           exit (1);
386         }
387       if (key->uids && key->uids->signatures)
388         {
389           fprintf (stderr, "First user ID unexpectedly signed\n");
390           exit (1);
391         }
392       if (keys[i].uid[0].name
393           && strcmp (keys[i].uid[0].name, key->uids->name))
394         {
395           fprintf (stderr, "Unexpected name in first user ID: %s\n",
396                    key->uids->name);
397           exit (1);
398         }
399       if (keys[i].uid[0].comment
400           && strcmp (keys[i].uid[0].comment, key->uids->comment))
401         {
402           fprintf (stderr, "Unexpected comment in first user ID: %s\n",
403                    key->uids->comment);
404           exit (1);
405         }
406       if (keys[i].uid[0].email
407           && strcmp (keys[i].uid[0].email, key->uids->email))
408         {
409           fprintf (stderr, "Unexpected email in first user ID: %s\n",
410                    key->uids->email);
411           exit (1);
412         }
413       if (key->uids && key->uids->next && key->uids->next->revoked)
414         {
415           fprintf (stderr, "Second user ID unexpectedly revoked\n");
416           exit (1);
417         }
418       if (key->uids && key->uids->next && key->uids->next->invalid)
419         {
420           fprintf (stderr, "Second user ID unexpectedly invalid\n");
421           exit (1);
422         }
423       if (key->uids && key->uids->next
424           && key->uids->next->validity != GPGME_VALIDITY_UNKNOWN)
425         {
426           fprintf (stderr, "Second user ID has unexpectedly validity: %i\n",
427                    key->uids->next->validity);
428           exit (1);
429         }
430       if (key->uids && key->uids->next && key->uids->next->signatures)
431         {
432           fprintf (stderr, "Second user ID unexpectedly signed\n");
433           exit (1);
434         }
435       if (keys[i].uid[1].name
436           && strcmp (keys[i].uid[1].name, key->uids->next->name))
437         {
438           fprintf (stderr, "Unexpected name in second user ID: %s\n",
439                    key->uids->next->name);
440           exit (1);
441         }
442       if (keys[i].uid[1].comment
443           && strcmp (keys[i].uid[1].comment, key->uids->next->comment))
444         {
445           fprintf (stderr, "Unexpected comment in second user ID: %s\n",
446                    key->uids->next->comment);
447           exit (1);
448         }
449       if (keys[i].uid[1].email
450           && strcmp (keys[i].uid[1].email, key->uids->next->email))
451         {
452           fprintf (stderr, "Unexpected email in second user ID: %s\n",
453                    key->uids->next->email);
454           exit (1);
455         }
456       if (key->uids && key->uids->next && key->uids->next->next
457           && key->uids->next->next->revoked)
458         {
459           fprintf (stderr, "Third user ID unexpectedly revoked\n");
460           exit (1);
461         }
462       if (key->uids && key->uids->next && key->uids->next->next
463           && key->uids->next->next->invalid)
464         {
465           fprintf (stderr, "Third user ID unexpectedly invalid\n");
466           exit (1);
467         }
468       if (key->uids && key->uids->next && key->uids->next->next
469           && key->uids->next->next->validity != GPGME_VALIDITY_UNKNOWN)
470         {
471           fprintf (stderr, "Third user ID has unexpectedly validity: %i\n",
472                    key->uids->next->next->validity);
473           exit (1);
474         }
475       if (key->uids && key->uids->next && key->uids->next->next
476           && key->uids->next->next->signatures)
477         {
478           fprintf (stderr, "Third user ID unexpectedly signed\n");
479           exit (1);
480         }
481       if (keys[i].uid[2].name
482           && strcmp (keys[i].uid[2].name, key->uids->next->next->name))
483         {
484           fprintf (stderr, "Unexpected name in third user ID: %s\n",
485                    key->uids->next->next->name);
486           exit (1);
487         }
488       if (keys[i].uid[2].comment
489           && strcmp (keys[i].uid[2].comment, key->uids->next->next->comment))
490         {
491           fprintf (stderr, "Unexpected comment in third user ID: %s\n",
492                    key->uids->next->next->comment);
493           exit (1);
494         }
495       if (keys[i].uid[2].email
496           && strcmp (keys[i].uid[2].email, key->uids->next->next->email))
497         {
498           fprintf (stderr, "Unexpected email in third user ID: %s\n",
499                    key->uids->next->next->email);
500           exit (1);
501         }
502
503       gpgme_key_unref (key);
504       i++;
505     }
506   if (gpg_err_code (err) != GPG_ERR_EOF)
507     fail_if_err (err);
508   err = gpgme_op_keylist_end (ctx);
509   fail_if_err (err);
510
511   result = gpgme_op_keylist_result (ctx);
512   if (result->truncated)
513     {
514       fprintf (stderr, "Key listing unexpectedly truncated\n");
515       exit (1);
516     }
517
518   if (keys[i].fpr)
519     {
520       fprintf (stderr, "Less keys returned than expected\n");
521       exit (1);
522     }
523
524   gpgme_release (ctx);
525   return 0;
526 }