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