g10/export.c

   1 /* export.c
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
   3  *               2003  Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it 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  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <assert.h>
  28
  29 #include "options.h"
  30 #include "packet.h"
  31 #include "errors.h"
  32 #include "keydb.h"
  33 #include "memory.h"
  34 #include "util.h"
  35 #include "main.h"
  36 #include "i18n.h"
  37
  38 static int do_export( STRLIST users, int secret, unsigned int options );
  39 static int do_export_stream( iobuf_t out, STRLIST users, int secret,
  40                              KBNODE *keyblock_out, unsigned int options,
  41                              int *any );
  42 static int build_sexp (iobuf_t out, PACKET *pkt, int *indent);
  43
  44 int
  45 parse_export_options(char *str,unsigned int *options)
  46 {
  47   struct parse_options export_opts[]=
  48     {
  49       {"include-non-rfc",EXPORT_INCLUDE_NON_RFC},
  50       {"include-local-sigs",EXPORT_INCLUDE_LOCAL_SIGS},
  51       {"include-attributes",EXPORT_INCLUDE_ATTRIBUTES},
  52       {"include-sensitive-revkeys",EXPORT_INCLUDE_SENSITIVE_REVKEYS},
  53       {"sexp-format",EXPORT_SEXP_FORMAT},
  54       {NULL,0}
  55       /* add tags for include revoked and disabled? */
  56     };
  57
  58   return parse_options(str,options,export_opts);
  59 }
  60
  61 /****************
  62  * Export the public keys (to standard out or --output).
  63  * Depending on opt.armor the output is armored.
  64  * options are defined in main.h.
  65  * If USERS is NULL, the complete ring will be exported.  */
  66 int
  67 export_pubkeys( STRLIST users, unsigned int options )
  68 {
  69     return do_export( users, 0, options );
  70 }
  71
  72 /****************
  73  * Export to an already opened stream; return -1 if no keys have
  74  * been exported
  75  */
  76 int
  77 export_pubkeys_stream( iobuf_t out, STRLIST users,
  78                        KBNODE *keyblock_out, unsigned int options )
  79 {
  80     int any, rc;
  81
  82     rc = do_export_stream( out, users, 0, keyblock_out, options, &any );
  83     if( !rc && !any )
  84         rc = -1;
  85     return rc;
  86 }
  87
  88 int
  89 export_seckeys( STRLIST users )
  90 {
  91   /* Use only relevant options for the secret key. */
  92   unsigned int options = (opt.export_options & EXPORT_SEXP_FORMAT);
  93   return do_export (users, 1, options);
  94 }
  95
  96 int
  97 export_secsubkeys( STRLIST users )
  98 {
  99   /* Use only relevant options for the secret key. */
 100   unsigned int options = (opt.export_options & EXPORT_SEXP_FORMAT);
 101   return do_export( users, 2, options);
 102 }
 103
 104 static int
 105 do_export (STRLIST users, int secret, unsigned int options)
 106 {
 107   iobuf_t out = NULL;
 108   int any, rc;
 109   armor_filter_context_t afx;
 110   compress_filter_context_t zfx;
 111
 112   memset (&afx, 0, sizeof afx);
 113   memset (&zfx, 0, sizeof zfx);
 114
 115   rc = open_outfile (NULL, 0, &out);
 116   if (rc)
 117     return rc;
 118
 119   if (!(options & EXPORT_SEXP_FORMAT))
 120     {
 121       if (opt.armor)
 122         {
 123           afx.what = secret?5:1;
 124           iobuf_push_filter( out, armor_filter, &afx );
 125         }
 126       if (opt.compress_keys && opt.compress)
 127         iobuf_push_filter( out, compress_filter, &zfx );
 128     }
 129   rc = do_export_stream (out, users, secret, NULL, options, &any );
 130
 131   if (rc || !any)
 132     iobuf_cancel (out);
 133   else
 134     iobuf_close (out);
 135   return rc;
 136 }
 137
 138
 139 /* If keyblock_out is non-NULL, AND the exit code is zero, then it
 140    contains a pointer to the first keyblock found and exported.  No
 141    other keyblocks are exported.  The caller must free it. */
 142 static int
 143 do_export_stream( iobuf_t out, STRLIST users, int secret,
 144                   KBNODE *keyblock_out, unsigned int options, int *any )
 145 {
 146     int rc = 0;
 147     PACKET pkt;
 148     KBNODE keyblock = NULL;
 149     KBNODE kbctx, node;
 150     size_t ndesc, descindex;
 151     KEYDB_SEARCH_DESC *desc = NULL;
 152     KEYDB_HANDLE kdbhd;
 153     STRLIST sl;
 154     int indent = 0;
 155
 156     *any = 0;
 157     init_packet( &pkt );
 158     kdbhd = keydb_new (secret);
 159
 160     if (!users) {
 161         ndesc = 1;
 162         desc = xcalloc (1, ndesc * sizeof *desc);
 163         desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
 164     }
 165     else {
 166         for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
 167             ;
 168         desc = xmalloc ( ndesc * sizeof *desc);
 169
 170         for (ndesc=0, sl=users; sl; sl = sl->next) {
 171             if (classify_user_id (sl->d, desc+ndesc))
 172                 ndesc++;
 173             else
 174                 log_error (_("key `%s' not found: %s\n"),
 175                            sl->d, gpg_strerror (GPG_ERR_INV_USER_ID));
 176         }
 177
 178         /* it would be nice to see which of the given users did
 179            actually match one in the keyring.  To implement this we
 180            need to have a found flag for each entry in desc and to set
 181            this we must check all those entries after a match to mark
 182            all matched one - currently we stop at the first match.  To
 183            do this we need an extra flag to enable this feature so */
 184     }
 185
 186     while (!(rc = keydb_search2 (kdbhd, desc, ndesc, &descindex))) {
 187         int sha1_warned=0,skip_until_subkey=0;
 188         u32 sk_keyid[2];
 189
 190         if (!users)
 191             desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
 192
 193         /* read the keyblock */
 194         rc = keydb_get_keyblock (kdbhd, &keyblock );
 195         if( rc ) {
 196             log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
 197             goto leave;
 198         }
 199
 200         /* do not export keys which are incompatible with rfc2440 */
 201         if( !(options&EXPORT_INCLUDE_NON_RFC) &&
 202             (node = find_kbnode( keyblock, PKT_PUBLIC_KEY )) ) {
 203             PKT_public_key *pk = node->pkt->pkt.public_key;
 204             if( pk->version == 3 && pk->pubkey_algo > 3 ) {
 205                 log_info(_("key %08lX: not a rfc2440 key - skipped\n"),
 206                               (ulong)keyid_from_pk( pk, NULL) );
 207                 continue;
 208             }
 209         }
 210
 211         node=find_kbnode( keyblock, PKT_SECRET_KEY );
 212         if(node)
 213           {
 214             PKT_secret_key *sk=node->pkt->pkt.secret_key;
 215
 216             keyid_from_sk(sk,sk_keyid);
 217
 218             /* we can't apply GNU mode 1001 on an unprotected key */
 219             if( secret == 2 && !sk->is_protected )
 220               {
 221                 log_info(_("key %08lX: not protected - skipped\n"),
 222                          (ulong)sk_keyid[1]);
 223                 continue;
 224               }
 225
 226             /* no v3 keys with GNU mode 1001 */
 227             if( secret == 2 && sk->version == 3 )
 228               {
 229                 log_info(_("key %08lX: PGP 2.x style key - skipped\n"),
 230                          (ulong)sk_keyid[1]);
 231                 continue;
 232               }
 233           }
 234
 235         /* and write it */
 236         for( kbctx=NULL; (node = walk_kbnode( keyblock, &kbctx, 0 )); ) {
 237             if( skip_until_subkey )
 238               {
 239                 if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY
 240                    || node->pkt->pkttype==PKT_SECRET_SUBKEY)
 241                   skip_until_subkey=0;
 242                 else
 243                   continue;
 244               }
 245
 246             /* don't export any comment packets but those in the
 247              * secret keyring */
 248             if( !secret && node->pkt->pkttype == PKT_COMMENT )
 249                 continue;
 250
 251             /* make sure that ring_trust packets never get exported */
 252             if (node->pkt->pkttype == PKT_RING_TRUST)
 253               continue;
 254
 255             /* If exact is set, then we only export what was requested
 256                (plus the primary key, if the user didn't specifically
 257                request it) */
 258             if(desc[descindex].exact
 259                && (node->pkt->pkttype==PKT_PUBLIC_SUBKEY
 260                    || node->pkt->pkttype==PKT_SECRET_SUBKEY))
 261               {
 262                 u32 kid[2];
 263                 byte fpr[MAX_FINGERPRINT_LEN];
 264                 size_t fprlen;
 265
 266                 switch(desc[descindex].mode)
 267                   {
 268                   case KEYDB_SEARCH_MODE_SHORT_KID:
 269                   case KEYDB_SEARCH_MODE_LONG_KID:
 270                     if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
 271                       keyid_from_pk(node->pkt->pkt.public_key,kid);
 272                     else
 273                       keyid_from_sk(node->pkt->pkt.secret_key,kid);
 274                     break;
 275
 276                   case KEYDB_SEARCH_MODE_FPR16:
 277                   case KEYDB_SEARCH_MODE_FPR20:
 278                   case KEYDB_SEARCH_MODE_FPR:
 279                     if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
 280                       fingerprint_from_pk(node->pkt->pkt.public_key,
 281                                           fpr,&fprlen);
 282                     else
 283                       fingerprint_from_sk(node->pkt->pkt.secret_key,
 284                                           fpr,&fprlen);
 285                     break;
 286
 287                   default:
 288                     break;
 289                   }
 290
 291                 switch(desc[descindex].mode)
 292                   {
 293                   case KEYDB_SEARCH_MODE_SHORT_KID:
 294                     if (desc[descindex].u.kid[1] != kid[1])
 295                       skip_until_subkey=1;
 296                     break;
 297                   case KEYDB_SEARCH_MODE_LONG_KID:
 298                     if (desc[descindex].u.kid[0] != kid[0]
 299                         || desc[descindex].u.kid[1] != kid[1])
 300                       skip_until_subkey=1;
 301                     break;
 302                   case KEYDB_SEARCH_MODE_FPR16:
 303                     if (memcmp (desc[descindex].u.fpr, fpr, 16))
 304                       skip_until_subkey=1;
 305                     break;
 306                   case KEYDB_SEARCH_MODE_FPR20:
 307                   case KEYDB_SEARCH_MODE_FPR:
 308                     if (memcmp (desc[descindex].u.fpr, fpr, 20))
 309                       skip_until_subkey=1;
 310                     break;
 311                   default:
 312                     break;
 313                   }
 314
 315                 if(skip_until_subkey)
 316                   continue;
 317               }
 318
 319             if( node->pkt->pkttype == PKT_SIGNATURE ) {
 320               /* do not export packets which are marked as not exportable */
 321               if( !(options&EXPORT_INCLUDE_LOCAL_SIGS) &&
 322                   !node->pkt->pkt.signature->flags.exportable )
 323                 continue; /* not exportable */
 324
 325               /* Do not export packets with a "sensitive" revocation
 326                  key unless the user wants us to.  Note that we do
 327                  export these when issuing the actual revocation (see
 328                  revoke.c). */
 329               if( !(options&EXPORT_INCLUDE_SENSITIVE_REVKEYS) &&
 330                   node->pkt->pkt.signature->revkey ) {
 331                 int i;
 332
 333                 for(i=0;i<node->pkt->pkt.signature->numrevkeys;i++)
 334                   if(node->pkt->pkt.signature->revkey[i]->class & 0x40)
 335                     break;
 336
 337                 if(i<node->pkt->pkt.signature->numrevkeys)
 338                   continue;
 339               }
 340             }
 341
 342             /* Don't export attribs? */
 343             if( !(options&EXPORT_INCLUDE_ATTRIBUTES) &&
 344                 node->pkt->pkttype == PKT_USER_ID &&
 345                 node->pkt->pkt.user_id->attrib_data ) {
 346               /* Skip until we get to something that is not an attrib
 347                  or a signature on an attrib */
 348               while(kbctx->next && kbctx->next->pkt->pkttype==PKT_SIGNATURE) {
 349                 kbctx=kbctx->next;
 350               }
 351
 352               continue;
 353             }
 354
 355             if( secret == 2 && node->pkt->pkttype == PKT_SECRET_KEY ) {
 356                 /* we don't want to export the secret parts of the
 357                  * primary key, this is done by using GNU protection mode 1001
 358                  */
 359                 int save_mode = node->pkt->pkt.secret_key->protect.s2k.mode;
 360                 node->pkt->pkt.secret_key->protect.s2k.mode = 1001;
 361                 if ((options&EXPORT_SEXP_FORMAT))
 362                   rc = build_sexp (out, node->pkt, &indent);
 363                 else
 364                   rc = build_packet (out, node->pkt);
 365                 node->pkt->pkt.secret_key->protect.s2k.mode = save_mode;
 366             }
 367             else {
 368               /* Warn the user if the secret key or any of the secret
 369                  subkeys are protected with SHA1 and we have
 370                  simple_sk_checksum set. */
 371               if(!sha1_warned && opt.simple_sk_checksum &&
 372                  (node->pkt->pkttype==PKT_SECRET_KEY ||
 373                   node->pkt->pkttype==PKT_SECRET_SUBKEY) &&
 374                  node->pkt->pkt.secret_key->protect.sha1chk)
 375                 {
 376                   /* I hope this warning doesn't confuse people. */
 377                   log_info(_("WARNING: secret key %08lX does not have a "
 378                              "simple SK checksum\n"),(ulong)sk_keyid[1]);
 379
 380                   sha1_warned=1;
 381                 }
 382
 383                 if ((options&EXPORT_SEXP_FORMAT))
 384                   rc = build_sexp (out, node->pkt, &indent);
 385                 else
 386                   rc = build_packet (out, node->pkt);
 387             }
 388
 389             if( rc ) {
 390                 log_error("build_packet(%d) failed: %s\n",
 391                             node->pkt->pkttype, gpg_strerror (rc) );
 392                 goto leave;
 393             }
 394         }
 395         if ((options&EXPORT_SEXP_FORMAT) && indent)
 396           {
 397             for (; indent; indent--)
 398               iobuf_put (out, ')');
 399             iobuf_put (out, '\n');
 400           }
 401
 402         ++*any;
 403         if(keyblock_out)
 404           {
 405             *keyblock_out=keyblock;
 406             break;
 407           }
 408     }
 409     if ((options&EXPORT_SEXP_FORMAT) && indent)
 410       {
 411         for (; indent; indent--)
 412           iobuf_put (out, ')');
 413         iobuf_put (out, '\n');
 414       }
 415     if( rc == -1 )
 416         rc = 0;
 417
 418   leave:
 419     xfree (desc);
 420     keydb_release (kdbhd);
 421     if(rc || keyblock_out==NULL)
 422       release_kbnode( keyblock );
 423     if( !*any )
 424         log_info(_("WARNING: nothing exported\n"));
 425     return rc;
 426 }
 427
 428
 429 static int
 430 write_sexp_line (iobuf_t out, int *indent, const char *text)
 431 {
 432   int i;
 433
 434   for (i=0; i < *indent; i++)
 435     iobuf_put (out, ' ');
 436   iobuf_writestr (out, text);
 437   return 0;
 438 }
 439
 440 static int
 441 write_sexp_keyparm (iobuf_t out, int *indent, const char *name, gcry_mpi_t a)
 442 {
 443   int rc;
 444   unsigned char *buffer;
 445
 446   write_sexp_line (out, indent, "(");
 447   iobuf_writestr (out, name);
 448   iobuf_writestr (out, " #");
 449
 450   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a);
 451   assert (!rc);
 452   iobuf_writestr (out, buffer);
 453   iobuf_writestr (out, "#)");
 454   gcry_free (buffer);
 455   return 0;
 456 }
 457
 458 static int
 459 build_sexp_seckey (iobuf_t out, PACKET *pkt, int *indent)
 460 {
 461   PKT_secret_key *sk = pkt->pkt.secret_key;
 462   char tmpbuf[100];
 463
 464   if (pkt->pkttype == PKT_SECRET_KEY)
 465     {
 466       iobuf_writestr (out, "(openpgp-key\n");
 467       (*indent)++;
 468     }
 469   else
 470     {
 471       iobuf_writestr (out, " (subkey\n");
 472       (*indent)++;
 473     }
 474   (*indent)++;
 475   write_sexp_line (out, indent, "(private-key\n");
 476   (*indent)++;
 477   if (is_RSA (sk->pubkey_algo) && !sk->is_protected)
 478     {
 479       write_sexp_line (out, indent, "(rsa\n");
 480       (*indent)++;
 481       write_sexp_keyparm (out, indent, "n", sk->skey[0]); iobuf_put (out,'\n');
 482       write_sexp_keyparm (out, indent, "e", sk->skey[1]); iobuf_put (out,'\n');
 483       write_sexp_keyparm (out, indent, "d", sk->skey[2]); iobuf_put (out,'\n');
 484       write_sexp_keyparm (out, indent, "p", sk->skey[3]); iobuf_put (out,'\n');
 485       write_sexp_keyparm (out, indent, "q", sk->skey[4]); iobuf_put (out,'\n');
 486       write_sexp_keyparm (out, indent, "u", sk->skey[5]);
 487       iobuf_put (out,')'); iobuf_put (out,'\n');
 488       (*indent)--;
 489     }
 490   else if (sk->pubkey_algo == PUBKEY_ALGO_DSA && !sk->is_protected)
 491     {
 492       write_sexp_line (out, indent, "(dsa\n");
 493       (*indent)++;
 494       write_sexp_keyparm (out, indent, "p", sk->skey[0]); iobuf_put (out,'\n');
 495       write_sexp_keyparm (out, indent, "q", sk->skey[1]); iobuf_put (out,'\n');
 496       write_sexp_keyparm (out, indent, "g", sk->skey[2]); iobuf_put (out,'\n');
 497       write_sexp_keyparm (out, indent, "y", sk->skey[3]); iobuf_put (out,'\n');
 498       write_sexp_keyparm (out, indent, "x", sk->skey[4]);
 499       iobuf_put (out,')'); iobuf_put (out,'\n');
 500       (*indent)--;
 501     }
 502   else if (is_ELGAMAL (sk->pubkey_algo) && !sk->is_protected)
 503     {
 504       write_sexp_line (out, indent, "(elg\n");
 505       (*indent)++;
 506       write_sexp_keyparm (out, indent, "p", sk->skey[0]); iobuf_put (out,'\n');
 507       write_sexp_keyparm (out, indent, "g", sk->skey[2]); iobuf_put (out,'\n');
 508       write_sexp_keyparm (out, indent, "y", sk->skey[3]); iobuf_put (out,'\n');
 509       write_sexp_keyparm (out, indent, "x", sk->skey[4]);
 510       iobuf_put (out,')'); iobuf_put (out,'\n');
 511       (*indent)--;
 512     }
 513   write_sexp_line (out, indent,  "(attrib\n"); (*indent)++;
 514   sprintf (tmpbuf, "(created \"%lu\"", (unsigned long)sk->timestamp);
 515   write_sexp_line (out, indent, tmpbuf);
 516   iobuf_put (out,')'); (*indent)--; /* close created */
 517   iobuf_put (out,')'); (*indent)--; /* close attrib */
 518   iobuf_put (out,')'); (*indent)--; /* close private-key */
 519   if (pkt->pkttype != PKT_SECRET_KEY)
 520     iobuf_put (out,')'), (*indent)--; /* close subkey */
 521   iobuf_put (out,'\n');
 522
 523   return 0;
 524 }
 525
 526
 527 /* For some packet types we write them in a S-Exp like format.  This is
 528    still EXPERIMENTAL and subject to change. */
 529 static int
 530 build_sexp (iobuf_t out, PACKET *pkt, int *indent)
 531 {
 532   int rc;
 533
 534   switch (pkt->pkttype)
 535     {
 536     case PKT_SECRET_KEY:
 537     case PKT_SECRET_SUBKEY:
 538       rc = build_sexp_seckey (out, pkt, indent);
 539       break;
 540     default:
 541       rc = 0;
 542       break;
 543     }
 544   return rc;
 545 }
 546