Restore the key files.
[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, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
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   char *fpr;
40   int secret;
41   long timestamp;
42   long expires;
43   char *issuer_serial;
44   char *issuer_name;
45   char *chain_id;
46   char *uid;
47   gpgme_validity_t validity;
48   unsigned int key_length;
49 }
50 keys[] =
51   {
52     { "3CF405464F66ED4A7DF45BBDD1E4282E33BDB76E", 1, 1007372198, 1038908198, "00",
53       "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=D\xc3\xbcsseldorf,C=DE",
54       "3CF405464F66ED4A7DF45BBDD1E4282E33BDB76E",
55       "CN=test cert 1,OU=Aegypten Project,O=g10 Code GmbH,L=D\xc3\xbcsseldorf,C=DE",
56       GPGME_VALIDITY_ULTIMATE, 1024
57     },
58     { "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD", 0, 909684190, 1009821790, "01",
59       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
60       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
61       "O=Deutsches Forschungsnetz,C=DE",
62       "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD",
63       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
64       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
65       "O=Deutsches Forschungsnetz,C=DE",
66       GPGME_VALIDITY_NEVER, 2048
67     },
68     { "2C8F3C356AB761CB3674835B792CDA52937F9285", 0, 973183644, 1009735200, "15",
69       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
70       "CN=DFN Top Level Certification Authority,OU=DFN-PCA,"
71       "O=Deutsches Forschungsnetz,C=DE",
72       "DFA56FB5FC41E3A8921F77AD1622EEFD9152A5AD",
73       "1.2.840.113549.1.9.1=#63657274696679407063612E64666E2E6465,"
74       "CN=DFN Server Certification Authority,OU=DFN-PCA,"
75       "O=Deutsches Forschungsnetz,C=DE",
76       GPGME_VALIDITY_UNKNOWN, 2048
77     },
78     { NULL }
79   };
80
81
82 int 
83 main (int argc, char **argv)
84 {
85   gpgme_error_t err;
86   gpgme_ctx_t ctx;
87   gpgme_key_t key;
88   gpgme_keylist_result_t result;
89   int i = 0;
90
91   init_gpgme (GPGME_PROTOCOL_CMS);
92
93   err = gpgme_new (&ctx);
94   fail_if_err (err);
95   gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
96
97   err = gpgme_op_keylist_start (ctx, NULL, 0);
98   fail_if_err (err);
99     
100   while (!(err = gpgme_op_keylist_next (ctx, &key)))
101     {
102       if (!keys[i].fpr)
103         {
104           fprintf (stderr, "More keys returned than expected\n");
105           exit (1);
106         }
107
108       /* Global key flags.  */
109       if (key->revoked)
110         {
111           fprintf (stderr, "Key unexpectedly revoked\n");
112           exit (1);
113         }
114       if (key->expired)
115         {
116           fprintf (stderr, "Key unexpectedly expired\n");
117           exit (1);
118         }
119       if (key->disabled)
120         {
121           fprintf (stderr, "Key unexpectedly disabled\n");
122           exit (1);
123         }
124       if (key->invalid)
125         {
126           fprintf (stderr, "Key unexpectedly invalid\n");
127           exit (1);
128         }
129       if (key->can_encrypt != keys[i].secret)
130         {
131           fprintf (stderr, "Key unexpectedly%s usable for encryption\n",
132                    key->can_encrypt ? "" : " not");
133           exit (1);
134         }
135       if (key->can_sign != keys[i].secret)
136         {
137           fprintf (stderr, "Key unexpectedly%s usable for signing\n",
138                    key->can_sign ? "" : " not");
139           exit (1);
140         }
141       if (!key->can_certify)
142         {
143           fprintf (stderr, "Key unexpectedly unusable for certifications\n");
144           exit (1);
145         }
146       if (key->secret != keys[i].secret)
147         {
148           fprintf (stderr, "Key unexpectedly%s secret\n",
149                    key->secret ? "" : " not");
150           exit (1);
151         }
152       if (key->protocol != GPGME_PROTOCOL_CMS)
153         {
154           fprintf (stderr, "Key has unexpected protocol: %s\n",
155                    gpgme_get_protocol_name (key->protocol));
156           exit (1);
157         }
158       if (!key->issuer_serial)
159         {
160           fprintf (stderr, "Key unexpectedly misses issuer serial\n");
161           exit (1);
162         }
163       if (strcmp (key->issuer_serial, keys[i].issuer_serial))
164         {
165           fprintf (stderr, "Key has unexpected issuer serial: %s\n",
166                    key->issuer_serial);
167           exit (1);
168         }
169       if (!key->issuer_name)
170         {
171           fprintf (stderr, "Key unexpectedly misses issuer name\n");
172           exit (1);
173         }
174       if (strcmp (key->issuer_name, keys[i].issuer_name))
175         {
176           fprintf (stderr, "Key has unexpected issuer name: %s\n",
177                    key->issuer_name);
178           exit (1);
179         }
180       if (key->chain_id && !keys[i].chain_id)
181         {
182           fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
183                    key->chain_id);
184           exit (1);
185         }
186       if (!key->chain_id && keys[i].chain_id)
187         {
188           fprintf (stderr, "Key unexpectedly carries no chain ID\n");
189           exit (1);
190         }
191       if (key->chain_id && strcmp (key->chain_id, keys[i].chain_id))
192         {
193           fprintf (stderr, "Key carries unexpected chain ID: %s\n",
194                    key->chain_id);
195           exit (1);
196         }
197       if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
198         {
199           fprintf (stderr, "Key has unexpected owner trust: %i\n",
200                    key->owner_trust);
201           exit (1);
202         }
203       if (!key->subkeys || key->subkeys->next)
204         {
205           fprintf (stderr, "Key has unexpected number of subkeys\n");
206           exit (1);
207         }
208
209       /* Primary key.  */
210       if (key->subkeys->revoked)
211         {
212           fprintf (stderr, "Primary key unexpectedly revoked\n");
213           exit (1);
214         }
215       if (key->subkeys->expired)
216         {
217           fprintf (stderr, "Primary key unexpectedly expired\n");
218           exit (1);
219         }
220       if (key->subkeys->disabled)
221         {
222           fprintf (stderr, "Primary key unexpectedly disabled\n");
223           exit (1);
224         }
225       if (key->subkeys->invalid)
226         {
227           fprintf (stderr, "Primary key unexpectedly invalid\n");
228           exit (1);
229         }
230       if (key->subkeys->can_encrypt != keys[i].secret)
231         {
232           fprintf (stderr, "Key unexpectedly%s usable for encryption\n",
233                    key->subkeys->can_encrypt ? "" : " not");
234           exit (1);
235         }
236       if (key->subkeys->can_sign != keys[i].secret)
237         {
238           fprintf (stderr, "Key unexpectedly%s usable for signing\n",
239                    key->subkeys->can_sign ? "" : " not");
240           exit (1);
241         }
242       if (!key->subkeys->can_certify)
243         {
244           fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
245           exit (1);
246         }
247       if (key->subkeys->secret)
248         {
249           fprintf (stderr, "Primary key unexpectedly secret\n");
250           exit (1);
251         }
252       if (key->subkeys->pubkey_algo != GPGME_PK_RSA)
253         {
254           fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
255                    gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
256           exit (1);
257         }
258       if (key->subkeys->length != keys[i].key_length)
259         {
260           fprintf (stderr, "Primary key has unexpected length: %i\n",
261                    key->subkeys->length);
262           exit (1);
263         }
264       if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
265         {
266           fprintf (stderr, "Primary key has unexpected key ID: %s\n",
267                    key->subkeys->keyid);
268           exit (1);
269         }
270       if (strcmp (key->subkeys->fpr, keys[i].fpr))
271         {
272           fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
273                    key->subkeys->fpr);
274           exit (1);
275         }
276       if (key->subkeys->timestamp != keys[i].timestamp)
277         {
278           fprintf (stderr, "Primary key unexpected timestamp: %lu\n",
279                    key->subkeys->timestamp);
280           exit (1);
281         }
282       if (key->subkeys->expires != keys[i].expires)
283         {
284           fprintf (stderr, "Primary key unexpectedly expires: %lu\n",
285                    key->subkeys->expires);
286           exit (1);
287         }
288
289       if (!key->uids || key->uids->next)
290         {
291           fprintf (stderr, "Key has unexpected number of user IDs\n");
292           exit (1);
293         }
294       if (key->uids->revoked)
295         {
296           fprintf (stderr, "User ID unexpectedly revoked\n");
297           exit (1);
298         }
299       if (key->uids->invalid)
300         {
301           fprintf (stderr, "User ID unexpectedly invalid\n");
302           exit (1);
303         }
304       if (key->uids->validity != keys[i].validity)
305         {
306           fprintf (stderr, "User ID unexpectedly validity: %i\n",
307                    key->uids->validity);
308           exit (1);
309         }
310       if (key->uids->signatures)
311         {
312           fprintf (stderr, "User ID unexpectedly signed\n");
313           exit (1);
314         }
315       if (!key->uids->name || key->uids->name[0])
316         {
317           fprintf (stderr, "Unexpected name in user ID: %s\n",
318                    key->uids->name);
319           exit (1);
320         }
321       if (!key->uids->comment || key->uids->comment[0])
322         {
323           fprintf (stderr, "Unexpected comment in user ID: %s\n",
324                    key->uids->comment);
325           exit (1);
326         }
327       if (!key->uids->email || key->uids->email[0])
328         {
329           fprintf (stderr, "Unexpected email in user ID: %s\n",
330                    key->uids->email);
331           exit (1);
332         }
333       if (!key->uids->uid || strcmp (key->uids->uid, keys[i].uid))
334         {
335           fprintf (stderr, "Unexpected uid in user ID: %s\n",
336                    key->uids->uid);
337           exit (1);
338         }
339
340       gpgme_key_unref (key);
341       i++;
342     }
343   if (gpg_err_code (err) != GPG_ERR_EOF)
344     fail_if_err (err);
345   err = gpgme_op_keylist_end (ctx);
346   fail_if_err (err);
347
348   result = gpgme_op_keylist_result (ctx);
349   if (result->truncated)
350     {
351       fprintf (stderr, "Key listing unexpectedly truncated\n");
352       exit (1);
353     }
354
355   if (keys[i].fpr)
356     {
357       fprintf (stderr, "Less keys returned than expected\n");
358       exit (1);
359     }
360
361   gpgme_release (ctx);
362   return 0;
363 }