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     print_pubkey_algo_note(sk->pubkey_algo);
  51
  52     if( !digest_algo )
  53         digest_algo = md_get_algo(md);
  54
  55     print_digest_algo_note( digest_algo );
  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         if( lastlf ) {
 479             if( c == '-' ) {
 480                 iobuf_put( out, c );
 481                 iobuf_put( out, ' ' );
 482             }
 483             else if( c == 'F' && opt.escape_from ) {
 484                 int i;
 485
 486                 if( state >= 1 )
 487                     md_putc(md, '\r');
 488                 if( state >= 2 )
 489                     md_putc(md, '\n');
 490                 state = 0;
 491
 492                 for( i=1; i < 5 && (c = iobuf_get(inp)) != -1; i++ ) {
 493                     if( "From "[i] != c )
 494                         break;
 495                 }
 496                 if( i < 5 ) {
 497                     iobuf_write( out, "From", i );
 498                     md_write( md, "From", i );
 499                     if( c == -1 )
 500                         break;
 501                 }
 502                 else {
 503                     iobuf_writestr( out, "- From" );
 504                     md_write( md, "From", 4 );
 505                 }
 506             }
 507         }
 508
 509       again:
 510         switch( state ) {
 511           case 0:
 512             if( c == '\r' )
 513                 state = 1;
 514             else
 515                 md_putc(md, c );
 516             break;
 517           case 1:
 518             if( c == '\n' )
 519                 state = 2;
 520             else {
 521                 md_putc(md, '\r');
 522                 state = 0;
 523                 goto again;
 524             }
 525             break;
 526           case 2:
 527             md_putc(md, '\r');
 528             md_putc(md, '\n');
 529             state = 0;
 530             goto again;
 531           default: BUG();
 532         }
 533         iobuf_put( out, c );
 534         lastlf = c == '\n';
 535     }
 536     if( state == 1 )
 537         md_putc(md, '\r');
 538     else if( state == 2 ) {  /* file ended with a new line */
 539         md_putc(md, '\r');
 540         md_putc(md, '\n');
 541         iobuf_put( out, '\n');
 542     }
 543
 544     if( !lastlf )
 545         iobuf_put( out, '\n' );
 546
 547     return 0; /* fixme: add error handling */
 548 }
 549
 550
 551 /****************
 552  * make a clear signature. note that opt.armor is not needed
 553  */
 554 int
 555 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
 556 {
 557     armor_filter_context_t afx;
 558     text_filter_context_t tfx;
 559     MD_HANDLE textmd = NULL;
 560     IOBUF inp = NULL, out = NULL;
 561     PACKET pkt;
 562     int rc = 0;
 563     SK_LIST sk_list = NULL;
 564     SK_LIST sk_rover = NULL;
 565     int old_style = opt.rfc1991;
 566     int only_md5 = 0;
 567
 568     memset( &afx, 0, sizeof afx);
 569     memset( &tfx, 0, sizeof tfx);
 570     init_packet( &pkt );
 571
 572     if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
 573         goto leave;
 574     if( !old_style )
 575         old_style = only_old_style( sk_list );
 576
 577     /* prepare iobufs */
 578     if( !(inp = iobuf_open(fname)) ) {
 579         log_error("can't open %s: %s\n", fname? fname: "[stdin]",
 580                                         strerror(errno) );
 581         rc = G10ERR_OPEN_FILE;
 582         goto leave;
 583     }
 584
 585     if( outfile ) {
 586         if( !(out = iobuf_create( outfile )) ) {
 587             log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
 588             rc = G10ERR_CREATE_FILE;
 589             goto leave;
 590         }
 591         else if( opt.verbose )
 592             log_info(_("writing to '%s'\n"), outfile );
 593     }
 594     else if( (rc = open_outfile( fname, 1, &out )) )
 595         goto leave;
 596
 597     iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
 598
 599     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 600         PKT_secret_key *sk = sk_rover->sk;
 601         if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
 602             only_md5 = 1;
 603         else {
 604             only_md5 = 0;
 605             break;
 606         }
 607     }
 608
 609     if( old_style || only_md5 )
 610         iobuf_writestr(out, "\n" );
 611     else {
 612         const char *s;
 613         int any = 0;
 614
 615         iobuf_writestr(out, "Hash: " );
 616         for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 617             PKT_secret_key *sk = sk_rover->sk;
 618             s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
 619             if( s ) {
 620                 if( any )
 621                     iobuf_put(out, ',' );
 622                 iobuf_writestr(out, s );
 623                 any = 1;
 624             }
 625         }
 626         assert(any);
 627         iobuf_writestr(out, "\n" );
 628         if( opt.not_dash_escaped )
 629             iobuf_writestr( out,
 630                 "NotDashEscaped: You need GnuPG to verify this message\n" );
 631         iobuf_writestr(out, "\n" );
 632     }
 633
 634
 635     textmd = md_open(0, 0);
 636     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 637         PKT_secret_key *sk = sk_rover->sk;
 638         md_enable(textmd, hash_for(sk->pubkey_algo));
 639     }
 640     /*md_start_debug( textmd, "create" );*/
 641     if( !opt.not_dash_escaped )
 642         iobuf_push_filter( inp, text_filter, &tfx );
 643     rc = write_dash_escaped( inp, out, textmd );
 644     if( rc )
 645         goto leave;
 646
 647     afx.what = 2;
 648     iobuf_push_filter( out, armor_filter, &afx );
 649
 650     /* loop over the secret certificates */
 651     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
 652         PKT_secret_key *sk;
 653         PKT_signature *sig;
 654         MD_HANDLE md;
 655
 656         sk = sk_rover->sk;
 657
 658         /* build the signature packet */
 659         /* fixme: this code is duplicated above */
 660         sig = m_alloc_clear( sizeof *sig );
 661         sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
 662         keyid_from_sk( sk, sig->keyid );
 663         sig->digest_algo = hash_for(sk->pubkey_algo);
 664         sig->pubkey_algo = sk->pubkey_algo;
 665         sig->timestamp = make_timestamp();
 666         sig->sig_class = 0x01;
 667
 668         md = md_copy( textmd );
 669         if( sig->version >= 4 ) {
 670             build_sig_subpkt_from_sig( sig );
 671             md_putc( md, sig->version );
 672         }
 673         md_putc( md, sig->sig_class );
 674         if( sig->version < 4 ) {
 675             u32 a = sig->timestamp;
 676             md_putc( md, (a >> 24) & 0xff );
 677             md_putc( md, (a >> 16) & 0xff );
 678             md_putc( md, (a >>  8) & 0xff );
 679             md_putc( md,  a        & 0xff );
 680         }
 681         else {
 682             byte buf[6];
 683             size_t n;
 684
 685             md_putc( md, sig->pubkey_algo );
 686             md_putc( md, sig->digest_algo );
 687             if( sig->hashed_data ) {
 688                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
 689                 md_write( md, sig->hashed_data, n+2 );
 690                 n += 6;
 691             }
 692             else
 693                 n = 6;
 694             /* add some magic */
 695             buf[0] = sig->version;
 696             buf[1] = 0xff;
 697             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
 698             buf[3] = n >> 16;
 699             buf[4] = n >>  8;
 700             buf[5] = n;
 701             md_write( md, buf, 6 );
 702
 703         }
 704         md_final( md );
 705
 706         rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
 707         md_close( md );
 708
 709         if( !rc ) { /* and write it */
 710             init_packet(&pkt);
 711             pkt.pkttype = PKT_SIGNATURE;
 712             pkt.pkt.signature = sig;
 713             rc = build_packet( out, &pkt );
 714             free_packet( &pkt );
 715             if( rc )
 716                 log_error("build signature packet failed: %s\n", g10_errstr(rc) );
 717         }
 718         if( rc )
 719             goto leave;
 720     }
 721
 722
 723   leave:
 724     if( rc )
 725         iobuf_cancel(out);
 726     else
 727         iobuf_close(out);
 728     iobuf_close(inp);
 729     md_close( textmd );
 730     release_sk_list( sk_list );
 731     return rc;
 732 }
 733
 734
 735 /****************
 736  * Create a signature packet for the given public key certificate
 737  * and the user id and return it in ret_sig. User signature class SIGCLASS
 738  * user-id is not used (and may be NULL if sigclass is 0x20)
 739  * If digest_algo is 0 the function selects an appropriate one.
 740  */
 741 int
 742 make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
 743                     PKT_user_id *uid, PKT_public_key *subpk,
 744                     PKT_secret_key *sk,
 745                     int sigclass, int digest_algo,
 746                     int (*mksubpkt)(PKT_signature *, void *), void *opaque
 747                    )
 748 {
 749     PKT_signature *sig;
 750     int rc=0;
 751     MD_HANDLE md;
 752
 753     assert( (sigclass >= 0x10 && sigclass <= 0x13)
 754             || sigclass == 0x20 || sigclass == 0x18 );
 755     if( !digest_algo ) {
 756         switch( sk->pubkey_algo ) {
 757           case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
 758           case PUBKEY_ALGO_RSA_S:
 759           case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
 760           default:              digest_algo = DIGEST_ALGO_RMD160; break;
 761         }
 762     }
 763     md = md_open( digest_algo, 0 );
 764
 765     /* hash the public key certificate and the user id */
 766     hash_public_key( md, pk );
 767     if( sigclass == 0x18 ) { /* subkey binding */
 768         hash_public_key( md, subpk );
 769     }
 770     else if( sigclass != 0x20 ) {
 771         if( sk->version >=4 ) {
 772             byte buf[5];
 773             buf[0] = 0xb4;            /* indicates a userid packet */
 774             buf[1] = uid->len >> 24;  /* always use 4 length bytes */
 775             buf[2] = uid->len >> 16;
 776             buf[3] = uid->len >>  8;
 777             buf[4] = uid->len;
 778             md_write( md, buf, 5 );
 779         }
 780         md_write( md, uid->name, uid->len );
 781     }
 782     /* and make the signature packet */
 783     sig = m_alloc_clear( sizeof *sig );
 784     sig->version = sk->version;
 785     keyid_from_sk( sk, sig->keyid );
 786     sig->pubkey_algo = sk->pubkey_algo;
 787     sig->digest_algo = digest_algo;
 788     sig->timestamp = make_timestamp();
 789     sig->sig_class = sigclass;
 790     if( sig->version >= 4 )
 791         build_sig_subpkt_from_sig( sig );
 792
 793     if( sig->version >= 4 && mksubpkt )
 794         rc = (*mksubpkt)( sig, opaque );
 795
 796     if( !rc ) {
 797         if( sig->version >= 4 )
 798             md_putc( md, sig->version );
 799         md_putc( md, sig->sig_class );
 800         if( sig->version < 4 ) {
 801             u32 a = sig->timestamp;
 802             md_putc( md, (a >> 24) & 0xff );
 803             md_putc( md, (a >> 16) & 0xff );
 804             md_putc( md, (a >>  8) & 0xff );
 805             md_putc( md,  a        & 0xff );
 806         }
 807         else {
 808             byte buf[6];
 809             size_t n;
 810
 811             md_putc( md, sig->pubkey_algo );
 812             md_putc( md, sig->digest_algo );
 813             if( sig->hashed_data ) {
 814                 n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
 815                 md_write( md, sig->hashed_data, n+2 );
 816                 n += 6;
 817             }
 818             else
 819                 n = 6;
 820             /* add some magic */
 821             buf[0] = sig->version;
 822             buf[1] = 0xff;
 823             buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
 824             buf[3] = n >> 16;
 825             buf[4] = n >>  8;
 826             buf[5] = n;
 827             md_write( md, buf, 6 );
 828
 829         }
 830         md_final(md);
 831
 832         rc = complete_sig( sig, sk, md );
 833     }
 834
 835     md_close( md );
 836     if( rc )
 837         free_seckey_enc( sig );
 838     else
 839         *ret_sig = sig;
 840     return rc;
 841 }
 842
 843