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