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