g10/sign.c

   1 /* sign.c - sign data
   2  *      Copyright (C) 1998 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNUPG.
   5  *
   6  * GNUPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GNUPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <assert.h>
  27
  28 #include "options.h"
  29 #include "packet.h"
  30 #include "errors.h"
  31 #include "iobuf.h"
  32 #include "keydb.h"
  33 #include "memory.h"
  34 #include "util.h"
  35 #include "main.h"
  36 #include "filter.h"
  37 #include "ttyio.h"
  38 #include "trustdb.h"
  39 #include "i18n.h"
  40
  41
  42 static int
  43 do_sign( PKT_secret_key *sk, PKT_signature *sig,
  44          MD_HANDLE md, int digest_algo )
  45 {
  46     MPI frame;
  47     byte *dp;
  48     int rc;
  49
  50     if( is_RSA(sk->pubkey_algo) )
  51         do_not_use_RSA();
  52
  53     if( !digest_algo )
  54         digest_algo = md_get_algo(md);
  55
  56     dp = md_read( md, digest_algo );
  57     sig->digest_algo = digest_algo;
  58     sig->digest_start[0] = dp[0];
  59     sig->digest_start[1] = dp[1];
  60     frame = encode_md_value( sk->pubkey_algo, md,
  61                              digest_algo, mpi_get_nbits(sk->skey[0]));
  62     rc = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
  63     mpi_free(frame);
  64     if( rc )
  65         log_error(_("signing failed: %s\n"), g10_errstr(rc) );
  66     else {
  67         if( opt.verbose ) {
  68             char *ustr = get_user_id_string( sig->keyid );
  69             log_info(_("%s signature from: %s\n"),
  70                       pubkey_algo_to_string(sk->pubkey_algo), ustr );
  71             m_free(ustr);
  72         }
  73     }
  74     return rc;
  75 }
  76
  77
  78
  79 int
  80 complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
  81 {
  82     int rc=0;
  83
  84     if( !(rc=check_secret_key( sk, 0 )) )
  85         rc = do_sign( sk, sig, md, 0 );
  86
  87     /* fixme: should we check whether the signature is okay?
  88      * maybe by using an option */
  89
  90     return rc;
  91 }
  92
  93 static int
  94 hash_for(int pubkey_algo )
  95 {
  96     if( opt.def_digest_algo )
  97         return opt.def_digest_algo;
  98     if( pubkey_algo == PUBKEY_ALGO_DSA )
  99         return DIGEST_ALGO_SHA1;
 100     if( pubkey_algo == PUBKEY_ALGO_RSA )
 101         return DIGEST_ALGO_MD5;
 102     return DEFAULT_DIGEST_ALGO;
 103 }
 104
 105 static int
 106 only_old_style( SK_LIST sk_list )
 107 {
 108     SK_LIST sk_rover = NULL;
 109     int old_style = 0;
 110
 111     /* if there are only old style capable key we use the old sytle */
 112     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 113         PKT_secret_key *sk = sk_rover->sk;
 114         if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
 115             old_style = 1;
 116         else
 117             return 0;
 118     }
 119     return old_style;
 120 }
 121
 122
 123
 124 /****************
 125  * Sign the files whose names are in FILENAME.
 126  * If DETACHED has the value true,
 127  * make a detached signature.  If FILENAMES->d is NULL read from stdin
 128  * and ignore the detached mode.  Sign the file with all secret keys
 129  * which can be taken from LOCUSR, if this is NULL, use the default one
 130  * If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
 131  * signed data for these users.
 132  * If OUTFILE is not NULL; this file is used for output and the function
 133  * does not ask for overwrite permission; output is then always
 134  * uncompressed, non-armored and in binary mode.
 135  */
 136 int
 137 sign_file( STRLIST filenames, int detached, STRLIST locusr,
 138            int encrypt, STRLIST remusr, const char *outfile )
 139 {
 140     const char *fname;
 141     armor_filter_context_t afx;
 142     compress_filter_context_t zfx;
 143     md_filter_context_t mfx;
 144     text_filter_context_t tfx;
 145     encrypt_filter_context_t efx;
 146     IOBUF inp = NULL, out = NULL;
 147     PACKET pkt;
 148     PKT_plaintext *pt = NULL;
 149     u32 filesize;
 150     int rc = 0;
 151     PK_LIST pk_list = NULL;
 152     SK_LIST sk_list = NULL;
 153     SK_LIST sk_rover = NULL;
 154     int multifile = 0;
 155     int old_style = opt.rfc1991;
 156     int compr_algo = -1; /* unknown */
 157
 158
 159     memset( &afx, 0, sizeof afx);
 160     memset( &zfx, 0, sizeof zfx);
 161     memset( &mfx, 0, sizeof mfx);
 162     memset( &tfx, 0, sizeof tfx);
 163     memset( &efx, 0, sizeof efx);
 164     init_packet( &pkt );
 165
 166     if( filenames ) {
 167         fname = filenames->d;
 168         multifile = !!filenames->next;
 169     }
 170     else
 171         fname = NULL;
 172
 173     if( fname && filenames->next && (!detached || encrypt) )
 174         log_bug("multiple files can only be detached signed");
 175
 176     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
 177         goto leave;
 178     if( !old_style )
 179         old_style = only_old_style( sk_list );
 180
 181     if( encrypt ) {
 182         if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )) )
 183             goto leave;
 184         if( !old_style )
 185             compr_algo = select_algo_from_prefs( pk_list, PREFTYPE_COMPR );
 186     }
 187
 188     /* prepare iobufs */
 189     if( multifile )  /* have list of filenames */
 190         inp = NULL; /* we do it later */
 191     else if( !(inp = iobuf_open(fname)) ) {
 192         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
 193                                         strerror(errno) );
 194         rc = G10ERR_OPEN_FILE;
 195         goto leave;
 196     }
 197
 198     if( outfile ) {
 199         if( !(out = iobuf_create( outfile )) ) {
 200             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
 201             rc = G10ERR_CREATE_FILE;
 202             goto leave;
 203         }
 204         else if( opt.verbose )
 205             log_info(_("writing to '%s'\n"), outfile );
 206     }
 207     else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
 208         goto leave;
 209
 210     /* prepare to calculate the MD over the input */
 211     if( opt.textmode && !outfile )
 212         iobuf_push_filter( inp, text_filter, &tfx );
 213     mfx.md = md_open(0, 0);
 214
 215     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 216         PKT_secret_key *sk = sk_rover->sk;
 217         md_enable(mfx.md, hash_for(sk->pubkey_algo));
 218     }
 219
 220     if( !multifile )
 221         iobuf_push_filter( inp, md_filter, &mfx );
 222
 223     if( detached && !encrypt && !opt.rfc1991 )
 224         afx.what = 2;
 225
 226     if( opt.armor && !outfile  )
 227         iobuf_push_filter( out, armor_filter, &afx );
 228   #ifdef ENABLE_COMMENT_PACKETS
 229     else {
 230         write_comment( out, "#created by GNUPG v" VERSION " ("
 231                                             PRINTABLE_OS_NAME ")");
 232         if( opt.comment_string )
 233             write_comment( out, opt.comment_string );
 234     }
 235   #endif
 236     if( encrypt ) {
 237         efx.pk_list = pk_list;
 238         /* fixme: set efx.cfx.datalen if known */
 239         iobuf_push_filter( out, encrypt_filter, &efx );
 240     }
 241
 242     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
 243         if( !compr_algo )
 244             ; /* don't use compression */
 245         else {
 246             if( old_style || compr_algo == 1 )
 247                 zfx.algo = 1;
 248             iobuf_push_filter( out, compress_filter, &zfx );
 249         }
 250     }
 251
 252     if( !detached && !old_style ) {
 253         int skcount=0;
 254         /* loop over the secret certificates and build headers
 255          * The specs now say that the data should be bracket by
 256          * the onepass-sig and signature-packet; so we must build it
 257          * here in reverse order */
 258         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
 259             skcount++;
 260         for( ; skcount; skcount-- ) {
 261             PKT_secret_key *sk;
 262             PKT_onepass_sig *ops;
 263             int i = 0;
 264
 265             for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
 266                 if( ++i == skcount )
 267                     break;
 268
 269             sk = sk_rover->sk;
 270             ops = m_alloc_clear( sizeof *ops );
 271             ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
 272             ops->digest_algo = hash_for(sk->pubkey_algo);
 273             ops->pubkey_algo = sk->pubkey_algo;
 274             keyid_from_sk( sk, ops->keyid );
 275             ops->last = skcount == 1;
 276
 277             init_packet(&pkt);
 278             pkt.pkttype = PKT_ONEPASS_SIG;
 279             pkt.pkt.onepass_sig = ops;
 280             rc = build_packet( out, &pkt );
 281             free_packet( &pkt );
 282             if( rc ) {
 283                 log_error("build onepass_sig packet failed: %s\n",
 284                                                         g10_errstr(rc));
 285                 goto leave;
 286             }
 287         }
 288     }
 289
 290     /* setup the inner packet */
 291     if( detached ) {
 292         if( multifile ) {
 293             STRLIST sl;
 294
 295             if( opt.verbose )
 296                 log_info(_("signing:") );
 297             /* must walk reverse trough this list */
 298             for( sl = strlist_last(filenames); sl;
 299                         sl = strlist_prev( filenames, sl ) ) {
 300                 if( !(inp = iobuf_open(sl->d)) ) {
 301                     log_error(_("can't open %s: %s\n"),
 302                                             sl->d, strerror(errno) );
 303                     rc = G10ERR_OPEN_FILE;
 304                     goto leave;
 305                 }
 306                 if( opt.verbose )
 307                     fprintf(stderr, " '%s'", sl->d );
 308                 iobuf_push_filter( inp, md_filter, &mfx );
 309                 while( iobuf_get(inp) != -1 )
 310                     ;
 311                 iobuf_close(inp); inp = NULL;
 312             }
 313             if( opt.verbose )
 314                 putc( '\n', stderr );
 315         }
 316         else {
 317             /* read, so that the filter can calculate the digest */
 318             while( iobuf_get(inp) != -1 )
 319                 ;
 320         }
 321     }
 322     else {
 323         if( fname || opt.set_filename ) {
 324             char *s = make_basename( opt.set_filename ? opt.set_filename : fname );
 325             pt = m_alloc( sizeof *pt + strlen(s) - 1 );
 326             pt->namelen = strlen(s);
 327             memcpy(pt->name, s, pt->namelen );
 328             m_free(s);
 329         }
 330         else { /* no filename */
 331             pt = m_alloc( sizeof *pt - 1 );
 332             pt->namelen = 0;
 333         }
 334         if( fname ) {
 335             if( !(filesize = iobuf_get_filelength(inp)) )
 336                 log_info(_("WARNING: '%s' is an empty file\n"), fname );
 337
 338             /* because the text_filter modifies the length of the
 339              * data, it is not possible to know the used length
 340              * without a double read of the file - to avoid that
 341              * we simple use partial length packets.
 342              * FIXME: We have to do the double read when opt.rfc1991
 343              *        is active.
 344              */
 345             if( opt.textmode && !outfile )
 346                 filesize = 0;
 347         }
 348         else
 349             filesize = 0; /* stdin */
 350         pt->timestamp = make_timestamp();
 351         pt->mode = opt.textmode && !outfile ? 't':'b';
 352         pt->len = filesize;
 353         pt->new_ctb = !pt->len && !opt.rfc1991;
 354         pt->buf = inp;
 355         pkt.pkttype = PKT_PLAINTEXT;
 356         pkt.pkt.plaintext = pt;
 357         /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
 358         if( (rc = build_packet( out, &pkt )) )
 359             log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
 360         pt->buf = NULL;
 361     }
 362
 363     /* loop over the secret certificates */
 364     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 365         PKT_secret_key *sk;
 366         PKT_signature *sig;
 367         MD_HANDLE md;
 368
 369         sk = sk_rover->sk;
 370
 371         /* build the signature packet */
 372         /* fixme: this code is partly duplicated in make_keysig_packet */
 373         sig = m_alloc_clear( sizeof *sig );
 374         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
 375         keyid_from_sk( sk, sig->keyid );
 376         sig->digest_algo = hash_for(sk->pubkey_algo);
 377         sig->pubkey_algo = sk->pubkey_algo;
 378         sig->timestamp = make_timestamp();
 379         sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
 380
 381         md = md_copy( mfx.md );
 382
 383         if( sig->version >= 4 ) {
 384             build_sig_subpkt_from_sig( sig );
 385             md_putc( md, sig->version );
 386         }
 387         md_putc( md, sig->sig_class );
 388         if( sig->version < 4 ) {
 389             u32 a = sig->timestamp;
 390             md_putc( md, (a >> 24) & 0xff );
 391             md_putc( md, (a >> 16) & 0xff );
 392             md_putc( md, (a >>  8) & 0xff );
 393             md_putc( md,  a        & 0xff );
 394         }
 395         else {
 396             byte buf[6];
 397             size_t n;
 398
 399             md_putc( md, sig->pubkey_algo );
 400             md_putc( md, sig->digest_algo );
 401             if( sig->hashed_data ) {
 402                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
 403                 md_write( md, sig->hashed_data, n+2 );
 404                 n += 6;
 405             }
 406             else
 407                 n = 6;
 408             /* add some magic */
 409             buf[0] = sig->version;
 410             buf[1] = 0xff;
 411             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
 412             buf[3] = n >> 16;
 413             buf[4] = n >>  8;
 414             buf[5] = n;
 415             md_write( md, buf, 6 );
 416
 417         }
 418         md_final( md );
 419
 420         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
 421         md_close( md );
 422
 423         if( !rc ) { /* and write it */
 424             init_packet(&pkt);
 425             pkt.pkttype = PKT_SIGNATURE;
 426             pkt.pkt.signature = sig;
 427             rc = build_packet( out, &pkt );
 428             free_packet( &pkt );
 429             if( rc )
 430                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
 431         }
 432         if( rc )
 433             goto leave;
 434     }
 435
 436
 437   leave:
 438     if( rc )
 439         iobuf_cancel(out);
 440     else
 441         iobuf_close(out);
 442     iobuf_close(inp);
 443     md_close( mfx.md );
 444     release_sk_list( sk_list );
 445     release_pk_list( pk_list );
 446     return rc;
 447 }
 448
 449
 450
 451 /****************
 452  * Note: We do not calculate the hash over the last CR,LF
 453  */
 454 static int
 455 write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
 456 {
 457     int c;
 458     int lastlf = 1;
 459     int state = 0;
 460
 461     if( opt.not_dash_escaped ) {
 462         lastlf = 0;
 463         while( (c = iobuf_get(inp)) != -1 ) {
 464             md_putc(md, c );
 465             iobuf_put( out, c );
 466             lastlf = c;
 467         }
 468         if( lastlf != '\n' ) {
 469             /* add a missing trailing LF */
 470             md_putc(md, '\n' );
 471             iobuf_put( out, '\n' );
 472         }
 473
 474         return 0;
 475     }
 476
 477     while( (c = iobuf_get(inp)) != -1 ) {
 478         /* Note: We don't escape "From " because the MUA should cope with it */
 479         if( lastlf ) {
 480             if( c == '-' ) {
 481                 iobuf_put( out, c );
 482                 iobuf_put( out, ' ' );
 483             }
 484         }
 485
 486       again:
 487         switch( state ) {
 488           case 0:
 489             if( c == '\r' )
 490                 state = 1;
 491             else
 492                 md_putc(md, c );
 493             break;
 494           case 1:
 495             if( c == '\n' )
 496                 state = 2;
 497             else {
 498                 md_putc(md, '\r');
 499                 state = 0;
 500                 goto again;
 501             }
 502             break;
 503           case 2:
 504             md_putc(md, '\r');
 505             md_putc(md, '\n');
 506             state = 0;
 507             goto again;
 508           default: BUG();
 509         }
 510         iobuf_put( out, c );
 511         lastlf = c == '\n';
 512     }
 513     if( state == 1 )
 514         md_putc(md, '\r');
 515     if( !lastlf )
 516         iobuf_put( out, '\n' );
 517
 518     return 0; /* fixme: add error handling */
 519 }
 520
 521
 522 /****************
 523  * make a clear signature. note that opt.armor is not needed
 524  */
 525 int
 526 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
 527 {
 528     armor_filter_context_t afx;
 529     text_filter_context_t tfx;
 530     MD_HANDLE textmd = NULL;
 531     IOBUF inp = NULL, out = NULL;
 532     PACKET pkt;
 533     int rc = 0;
 534     SK_LIST sk_list = NULL;
 535     SK_LIST sk_rover = NULL;
 536     int old_style = opt.rfc1991;
 537     int only_md5 = 0;
 538
 539     memset( &afx, 0, sizeof afx);
 540     memset( &tfx, 0, sizeof tfx);
 541     init_packet( &pkt );
 542
 543     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
 544         goto leave;
 545     if( !old_style )
 546         old_style = only_old_style( sk_list );
 547
 548     /* prepare iobufs */
 549     if( !(inp = iobuf_open(fname)) ) {
 550         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
 551                                         strerror(errno) );
 552         rc = G10ERR_OPEN_FILE;
 553         goto leave;
 554     }
 555
 556     if( outfile ) {
 557         if( !(out = iobuf_create( outfile )) ) {
 558             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
 559             rc = G10ERR_CREATE_FILE;
 560             goto leave;
 561         }
 562         else if( opt.verbose )
 563             log_info(_("writing to '%s'\n"), outfile );
 564     }
 565     else if( (rc = open_outfile( fname, 1, &out )) )
 566         goto leave;
 567
 568     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
 569
 570     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 571         PKT_secret_key *sk = sk_rover->sk;
 572         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
 573             only_md5 = 1;
 574         else {
 575             only_md5 = 0;
 576             break;
 577         }
 578     }
 579
 580     if( old_style || only_md5 )
 581         iobuf_writestr(out, "\n" );
 582     else {
 583         const char *s;
 584         int any = 0;
 585
 586         iobuf_writestr(out, "Hash: " );
 587         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 588             PKT_secret_key *sk = sk_rover->sk;
 589             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
 590             if( s ) {
 591                 if( any )
 592                     iobuf_put(out, ',' );
 593                 iobuf_writestr(out, s );
 594                 any = 1;
 595             }
 596         }
 597         assert(any);
 598         iobuf_writestr(out, "\n" );
 599         if( opt.not_dash_escaped )
 600             iobuf_writestr( out,
 601                 "NotDashEscaped: You need GnuPG to verify this message\n" );
 602         iobuf_writestr(out, "\n" );
 603     }
 604
 605
 606     textmd = md_open(0, 0);
 607     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 608         PKT_secret_key *sk = sk_rover->sk;
 609         md_enable(textmd, hash_for(sk->pubkey_algo));
 610     }
 611     if( !opt.not_dash_escaped )
 612         iobuf_push_filter( inp, text_filter, &tfx );
 613     rc = write_dash_escaped( inp, out, textmd );
 614     if( rc )
 615         goto leave;
 616
 617     afx.what = 2;
 618     iobuf_push_filter( out, armor_filter, &afx );
 619
 620     /* loop over the secret certificates */
 621     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 622         PKT_secret_key *sk;
 623         PKT_signature *sig;
 624         MD_HANDLE md;
 625
 626         sk = sk_rover->sk;
 627
 628         /* build the signature packet */
 629         /* fixme: this code is duplicated above */
 630         sig = m_alloc_clear( sizeof *sig );
 631         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
 632         keyid_from_sk( sk, sig->keyid );
 633         sig->digest_algo = hash_for(sk->pubkey_algo);
 634         sig->pubkey_algo = sk->pubkey_algo;
 635         sig->timestamp = make_timestamp();
 636         sig->sig_class = 0x01;
 637
 638         md = md_copy( textmd );
 639         if( sig->version >= 4 ) {
 640             build_sig_subpkt_from_sig( sig );
 641             md_putc( md, sig->version );
 642         }
 643         md_putc( md, sig->sig_class );
 644         if( sig->version < 4 ) {
 645             u32 a = sig->timestamp;
 646             md_putc( md, (a >> 24) & 0xff );
 647             md_putc( md, (a >> 16) & 0xff );
 648             md_putc( md, (a >>  8) & 0xff );
 649             md_putc( md,  a        & 0xff );
 650         }
 651         else {
 652             byte buf[6];
 653             size_t n;
 654
 655             md_putc( md, sig->pubkey_algo );
 656             md_putc( md, sig->digest_algo );
 657             if( sig->hashed_data ) {
 658                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
 659                 md_write( md, sig->hashed_data, n+2 );
 660                 n += 6;
 661             }
 662             else
 663                 n = 6;
 664             /* add some magic */
 665             buf[0] = sig->version;
 666             buf[1] = 0xff;
 667             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
 668             buf[3] = n >> 16;
 669             buf[4] = n >>  8;
 670             buf[5] = n;
 671             md_write( md, buf, 6 );
 672
 673         }
 674         md_final( md );
 675
 676         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
 677         md_close( md );
 678
 679         if( !rc ) { /* and write it */
 680             init_packet(&pkt);
 681             pkt.pkttype = PKT_SIGNATURE;
 682             pkt.pkt.signature = sig;
 683             rc = build_packet( out, &pkt );
 684             free_packet( &pkt );
 685             if( rc )
 686                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
 687         }
 688         if( rc )
 689             goto leave;
 690     }
 691
 692
 693   leave:
 694     if( rc )
 695         iobuf_cancel(out);
 696     else
 697         iobuf_close(out);
 698     iobuf_close(inp);
 699     md_close( textmd );
 700     release_sk_list( sk_list );
 701     return rc;
 702 }
 703
 704
 705 /****************
 706  * Create a signature packet for the given public key certificate
 707  * and the user id and return it in ret_sig. User signature class SIGCLASS
 708  * user-id is not used (and may be NULL if sigclass is 0x20)
 709  * If digest_algo is 0 the function selects an appropriate one.
 710  */
 711 int
 712 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
 713                     PKT_user_id *uid, PKT_public_key *subpk,
 714                     PKT_secret_key *sk,
 715                     int sigclass, int digest_algo,
 716                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
 717                    )
 718 {
 719     PKT_signature *sig;
 720     int rc=0;
 721     MD_HANDLE md;
 722
 723     assert( (sigclass >= 0x10 && sigclass <= 0x13)
 724             || sigclass == 0x20 || sigclass == 0x18 );
 725     if( !digest_algo ) {
 726         switch( sk->pubkey_algo ) {
 727           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
 728           case PUBKEY_ALGO_RSA_S:
 729           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
 730           default:              digest_algo = DIGEST_ALGO_RMD160; break;
 731         }
 732     }
 733     md = md_open( digest_algo, 0 );
 734
 735     /* hash the public key certificate and the user id */
 736     hash_public_key( md, pk );
 737     if( sigclass == 0x18 ) { /* subkey binding */
 738         hash_public_key( md, subpk );
 739     }
 740     else if( sigclass != 0x20 ) {
 741         if( sk->version >=4 ) {
 742             byte buf[5];
 743             buf[0] = 0xb4;            /* indicates a userid packet */
 744             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
 745             buf[2] = uid->len >> 16;
 746             buf[3] = uid->len >>  8;
 747             buf[4] = uid->len;
 748             md_write( md, buf, 5 );
 749         }
 750         md_write( md, uid->name, uid->len );
 751     }
 752     /* and make the signature packet */
 753     sig = m_alloc_clear( sizeof *sig );
 754     sig->version = sk->version;
 755     keyid_from_sk( sk, sig->keyid );
 756     sig->pubkey_algo = sk->pubkey_algo;
 757     sig->digest_algo = digest_algo;
 758     sig->timestamp = make_timestamp();
 759     sig->sig_class = sigclass;
 760     if( sig->version >= 4 )
 761         build_sig_subpkt_from_sig( sig );
 762
 763     if( sig->version >= 4 && mksubpkt )
 764         rc = (*mksubpkt)( sig, opaque );
 765
 766     if( !rc ) {
 767         if( sig->version >= 4 )
 768             md_putc( md, sig->version );
 769         md_putc( md, sig->sig_class );
 770         if( sig->version < 4 ) {
 771             u32 a = sig->timestamp;
 772             md_putc( md, (a >> 24) & 0xff );
 773             md_putc( md, (a >> 16) & 0xff );
 774             md_putc( md, (a >>  8) & 0xff );
 775             md_putc( md,  a        & 0xff );
 776         }
 777         else {
 778             byte buf[6];
 779             size_t n;
 780
 781             md_putc( md, sig->pubkey_algo );
 782             md_putc( md, sig->digest_algo );
 783             if( sig->hashed_data ) {
 784                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
 785                 md_write( md, sig->hashed_data, n+2 );
 786                 n += 6;
 787             }
 788             else
 789                 n = 6;
 790             /* add some magic */
 791             buf[0] = sig->version;
 792             buf[1] = 0xff;
 793             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
 794             buf[3] = n >> 16;
 795             buf[4] = n >>  8;
 796             buf[5] = n;
 797             md_write( md, buf, 6 );
 798
 799         }
 800         md_final(md);
 801
 802         rc = complete_sig( sig, sk, md );
 803     }
 804
 805     md_close( md );
 806     if( rc )
 807         free_seckey_enc( sig );
 808     else
 809         *ret_sig = sig;
 810     return rc;
 811 }
 812
 813