See ChangeLog: Mon Nov 15 21:36:02 CET 1999 Werner Koch
[gnupg.git] / g10 / sign.c
index 0cbcbd3..d278945 100644 (file)
@@ -1,14 +1,14 @@
 /* sign.c - sign data
- *     Copyright (c) 1997 by Werner Koch (dd9jn)
+ *     Copyright (C) 1998 Free Software Foundation, Inc.
  *
- * This file is part of G10.
+ * This file is part of GnuPG.
  *
- * G10 is free software; you can redistribute it and/or modify
+ * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- * G10 is distributed in the hope that it will be useful,
+ * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <assert.h>
 
+#include <gcrypt.h>
 #include "options.h"
 #include "packet.h"
 #include "errors.h"
 #include "main.h"
 #include "filter.h"
 #include "ttyio.h"
+#include "trustdb.h"
+#include "i18n.h"
 
 
+/****************
+ * Emulate our old PK interface here - sometime in the future we might
+ * change the internal design to directly fit to libgcrypt.
+ */
+static int
+pk_sign( int algo, MPI *data, MPI hash, MPI *skey )
+{
+    GCRY_SEXP s_sig, s_hash, s_skey, list;
+    int rc;
+
+    /* make a sexp from skey */
+    if( algo == GCRY_PK_DSA ) {
+        s_skey = SEXP_CONS( SEXP_NEW( "private-key", 0 ),
+                         gcry_sexp_vlist( SEXP_NEW( "dsa", 3 ),
+                         gcry_sexp_new_name_mpi( "p", skey[0] ),
+                         gcry_sexp_new_name_mpi( "q", skey[1] ),
+                         gcry_sexp_new_name_mpi( "g", skey[2] ),
+                         gcry_sexp_new_name_mpi( "y", skey[3] ),
+                         gcry_sexp_new_name_mpi( "x", skey[4] ),
+                         NULL ));
+    }
+    else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
+       s_skey = SEXP_CONS( SEXP_NEW( "private-key", 0 ),
+                         gcry_sexp_vlist( SEXP_NEW( "elg", 3 ),
+                         gcry_sexp_new_name_mpi( "p", skey[0] ),
+                         gcry_sexp_new_name_mpi( "g", skey[1] ),
+                         gcry_sexp_new_name_mpi( "y", skey[2] ),
+                         gcry_sexp_new_name_mpi( "x", skey[3] ),
+                         NULL ));
+    }
+    else
+       return G10ERR_PUBKEY_ALGO;
+
+    /* put hash into a S-Exp s_hash */
+    s_hash = gcry_sexp_new_mpi( hash );
+
+    rc = gcry_pk_sign( &s_sig, s_hash, s_skey );
+    gcry_sexp_release( s_hash );
+    gcry_sexp_release( s_skey );
+
+    if( rc )
+       ;
+    else {
+       list = gcry_sexp_find_token( s_sig, "r" , 0 );
+       assert( list );
+       data[0] = gcry_sexp_cdr_mpi( list, 0 );
+       assert( data[0] );
+       list = gcry_sexp_find_token( s_sig, "s" , 0 );
+       assert( list );
+       data[1] = gcry_sexp_cdr_mpi( list, 0 );
+       assert( data[1] );
+    }
+
+
+    gcry_sexp_release( s_sig );
+    return rc;
+}
 
+/****************
+ * Create a notation.  It is assumed that the stings in STRLIST
+ * are already checked to contain only printable data and have a valid
+ * NAME=VALUE format.
+ */
+static void
+mk_notation_and_policy( PKT_signature *sig )
+{
+    const char *string, *s;
+    byte *buf;
+    unsigned n1, n2;
+
+    /* notation data */
+    if( opt.notation_data && sig->version < 4 )
+       log_info("can't put notation data into v3 signatures\n");
+    else if( opt.notation_data ) {
+       STRLIST nd = opt.notation_data;
+
+       for( ; nd; nd = nd->next )  {
+           string = nd->d;
+           s = strchr( string, '=' );
+           if( !s )
+               BUG(); /* we have already parsed this */
+           n1 = s - string;
+           s++;
+           n2 = strlen(s);
+           buf = m_alloc( 8 + n1 + n2 );
+           buf[0] = 0x80; /* human readable */
+           buf[1] = buf[2] = buf[3] = 0;
+           buf[4] = n1 >> 8;
+           buf[5] = n1;
+           buf[6] = n2 >> 8;
+           buf[7] = n2;
+           memcpy(buf+8, string, n1 );
+           memcpy(buf+8+n1, s, n2 );
+           build_sig_subpkt( sig, SIGSUBPKT_NOTATION
+                             | ((nd->flags & 1)? SIGSUBPKT_FLAG_CRITICAL:0),
+                             buf, 8+n1+n2 );
+       }
+    }
+
+    /* set policy URL */
+    if( (s=opt.set_policy_url) ) {
+       if( *s == '!' )
+           build_sig_subpkt( sig, SIGSUBPKT_POLICY | SIGSUBPKT_FLAG_CRITICAL,
+                             s+1, strlen(s+1) );
+       else
+           build_sig_subpkt( sig, SIGSUBPKT_POLICY, s, strlen(s) );
+    }
+}
 
 
 static int
-complete_sig( PKT_signature *sig, PKT_secret_cert *skc, MD_HANDLE md )
+do_sign( PKT_secret_key *sk, PKT_signature *sig,
+        GCRY_MD_HD md, int digest_algo )
+{
+    MPI frame;
+    byte *dp;
+    int rc;
+
+    if( sk->timestamp > sig->timestamp ) {
+       ulong d = sk->timestamp - sig->timestamp;
+       log_info( d==1 ? _("key has been created %lu second "
+                          "in future (time warp or clock problem)\n")
+                      : _("key has been created %lu seconds "
+                          "in future (time warp or clock problem)\n"), d );
+       return G10ERR_TIME_CONFLICT;
+    }
+
+
+    print_pubkey_algo_note(sk->pubkey_algo);
+
+    if( !digest_algo )
+       digest_algo = gcry_md_get_algo(md);
+
+    print_digest_algo_note( digest_algo );
+    dp = gcry_md_read( md, digest_algo );
+    sig->digest_algo = digest_algo;
+    sig->digest_start[0] = dp[0];
+    sig->digest_start[1] = dp[1];
+    frame = encode_md_value( sk->pubkey_algo, md,
+                            digest_algo, mpi_get_nbits(sk->skey[0]));
+    rc = pk_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
+    mpi_free(frame);
+    if( rc )
+       log_error(_("signing failed: %s\n"), g10_errstr(rc) );
+    else {
+       if( opt.verbose ) {
+           char *ustr = get_user_id_string( sig->keyid );
+           log_info(_("%s signature from: %s\n"),
+                     gcry_pk_algo_name(sk->pubkey_algo), ustr );
+           m_free(ustr);
+       }
+    }
+    return rc;
+}
+
+
+
+int
+complete_sig( PKT_signature *sig, PKT_secret_key *sk, GCRY_MD_HD md )
 {
     int rc=0;
 
-    if( (rc=check_secret_key( skc )) )
-       ;
-    else if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
-       g10_elg_sign( skc, sig, md, 0 );
-    else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
-       g10_rsa_sign( skc, sig, md, 0 );
-    else
-       BUG();
+    if( !(rc=check_secret_key( sk, 0 )) )
+       rc = do_sign( sk, sig, md, 0 );
 
-    /* fixme: should we check wether the signature is okay? */
+    /* fixme: should we check whether the signature is okay?
+     * maybe by using an option */
 
     return rc;
 }
 
+static int
+hash_for(int pubkey_algo )
+{
+    if( opt.def_digest_algo )
+       return opt.def_digest_algo;
+    if( pubkey_algo == GCRY_PK_DSA )
+       return DIGEST_ALGO_SHA1;
+    if( pubkey_algo == GCRY_PK_RSA )
+       return DIGEST_ALGO_MD5;
+    return DEFAULT_DIGEST_ALGO;
+}
 
+static int
+only_old_style( SK_LIST sk_list )
+{
+    SK_LIST sk_rover = NULL;
+    int old_style = 0;
+
+    /* if there are only old style capable key we use the old sytle */
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk = sk_rover->sk;
+       if( sk->pubkey_algo == GCRY_PK_RSA && sk->version < 4 )
+           old_style = 1;
+       else
+           return 0;
+    }
+    return old_style;
+}
 
 
 
@@ -90,10 +269,13 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     PKT_plaintext *pt = NULL;
     u32 filesize;
     int rc = 0;
-    PKC_LIST pkc_list = NULL;
-    SKC_LIST skc_list = NULL;
-    SKC_LIST skc_rover = NULL;
+    PK_LIST pk_list = NULL;
+    SK_LIST sk_list = NULL;
+    SK_LIST sk_rover = NULL;
     int multifile = 0;
+    int old_style = opt.rfc1991;
+    int compr_algo = -1; /* unknown */
+
 
     memset( &afx, 0, sizeof afx);
     memset( &zfx, 0, sizeof zfx);
@@ -112,11 +294,16 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     if( fname && filenames->next && (!detached || encrypt) )
        log_bug("multiple files can only be detached signed");
 
-    if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
+    if( (rc=build_sk_list( locusr, &sk_list, 1, GCRY_PK_USAGE_SIGN )) )
        goto leave;
+    if( !old_style )
+       old_style = only_old_style( sk_list );
+
     if( encrypt ) {
-       if( (rc=build_pkc_list( remusr, &pkc_list )) )
+       if( (rc=build_pk_list( remusr, &pk_list, GCRY_PK_USAGE_ENCR )) )
            goto leave;
+       if( !old_style )
+           compr_algo = select_algo_from_prefs( pk_list, PREFTYPE_COMPR );
     }
 
     /* prepare iobufs */
@@ -131,62 +318,98 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
 
     if( outfile ) {
        if( !(out = iobuf_create( outfile )) ) {
-           log_error("can't create %s: %s\n", outfile, strerror(errno) );
+           log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
            rc = G10ERR_CREATE_FILE;
            goto leave;
        }
        else if( opt.verbose )
-           log_info("writing to '%s'\n", outfile );
+           log_info(_("writing to `%s'\n"), outfile );
     }
-    else if( !(out = open_outfile( fname, opt.armor? 1: detached? 2:0 )) ) {
-       rc = G10ERR_CREATE_FILE;
+    else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
        goto leave;
-    }
 
     /* prepare to calculate the MD over the input */
     if( opt.textmode && !outfile )
        iobuf_push_filter( inp, text_filter, &tfx );
-    mfx.md = md_open(DIGEST_ALGO_RMD160, 0);
+    if( !(mfx.md = gcry_md_open(0, 0)))
+       BUG();
+
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk = sk_rover->sk;
+       gcry_md_enable(mfx.md, hash_for(sk->pubkey_algo));
+    }
+
     if( !multifile )
        iobuf_push_filter( inp, md_filter, &mfx );
 
+    if( detached && !encrypt && !opt.rfc1991 )
+       afx.what = 2;
+
     if( opt.armor && !outfile  )
        iobuf_push_filter( out, armor_filter, &afx );
-    write_comment( out, "#created by G10 v" VERSION " ("
+  #ifdef ENABLE_COMMENT_PACKETS
+    else {
+       write_comment( out, "#created by GNUPG v" VERSION " ("
                                            PRINTABLE_OS_NAME ")");
-    if( opt.compress && !outfile )
-       iobuf_push_filter( out, compress_filter, &zfx );
-
+       if( opt.comment_string )
+           write_comment( out, opt.comment_string );
+    }
+  #endif
     if( encrypt ) {
-       efx.pkc_list = pkc_list;
+       efx.pk_list = pk_list;
        /* fixme: set efx.cfx.datalen if known */
        iobuf_push_filter( out, encrypt_filter, &efx );
     }
 
-    /* loop over the secret certificates and build headers */
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       PKT_secret_cert *skc;
-       PKT_onepass_sig *ops;
-
-       skc = skc_rover->skc;
-       ops = m_alloc_clear( sizeof *ops );
-       ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
-       ops->digest_algo = DIGEST_ALGO_RMD160;
-       ops->pubkey_algo = skc->pubkey_algo;
-       keyid_from_skc( skc, ops->keyid );
-       ops->last = !skc_rover->next;
-
-       init_packet(&pkt);
-       pkt.pkttype = PKT_ONEPASS_SIG;
-       pkt.pkt.onepass_sig = ops;
-       rc = build_packet( out, &pkt );
-       free_packet( &pkt );
-       if( rc ) {
-           log_error("build onepass_sig packet failed: %s\n", g10_errstr(rc));
-           goto leave;
+    if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
+       if( !compr_algo )
+           ; /* don't use compression */
+       else {
+           if( old_style
+               || compr_algo == 1
+               || (compr_algo == -1 && !encrypt) )
+               zfx.algo = 1; /* use the non optional algorithm */
+           iobuf_push_filter( out, compress_filter, &zfx );
        }
     }
 
+    if( !detached && !old_style ) {
+       int skcount=0;
+       /* loop over the secret certificates and build headers
+        * The specs now say that the data should be bracket by
+        * the onepass-sig and signature-packet; so we must build it
+        * here in reverse order */
+       for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
+           skcount++;
+       for( ; skcount; skcount-- ) {
+           PKT_secret_key *sk;
+           PKT_onepass_sig *ops;
+           int i = 0;
+
+           for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
+               if( ++i == skcount )
+                   break;
+
+           sk = sk_rover->sk;
+           ops = m_alloc_clear( sizeof *ops );
+           ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
+           ops->digest_algo = hash_for(sk->pubkey_algo);
+           ops->pubkey_algo = sk->pubkey_algo;
+           keyid_from_sk( sk, ops->keyid );
+           ops->last = skcount == 1;
+
+           init_packet(&pkt);
+           pkt.pkttype = PKT_ONEPASS_SIG;
+           pkt.pkt.onepass_sig = ops;
+           rc = build_packet( out, &pkt );
+           free_packet( &pkt );
+           if( rc ) {
+               log_error("build onepass_sig packet failed: %s\n",
+                                                       g10_errstr(rc));
+               goto leave;
+           }
+       }
+    }
 
     /* setup the inner packet */
     if( detached ) {
@@ -194,17 +417,18 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
            STRLIST sl;
 
            if( opt.verbose )
-               log_info("signing:" );
+               log_info(_("signing:") );
            /* must walk reverse trough this list */
            for( sl = strlist_last(filenames); sl;
                        sl = strlist_prev( filenames, sl ) ) {
                if( !(inp = iobuf_open(sl->d)) ) {
-                   log_error("can't open %s: %s\n", sl->d, strerror(errno) );
+                   log_error(_("can't open %s: %s\n"),
+                                           sl->d, strerror(errno) );
                    rc = G10ERR_OPEN_FILE;
                    goto leave;
                }
                if( opt.verbose )
-                   fprintf(stderr, " '%s'", sl->d );
+                   fprintf(stderr, " `%s'", sl->d );
                iobuf_push_filter( inp, md_filter, &mfx );
                while( iobuf_get(inp) != -1 )
                    ;
@@ -220,73 +444,142 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
        }
     }
     else {
+       if (!opt.no_literal) {
+           if( fname || opt.set_filename ) {
+               char *s = make_basename( opt.set_filename ? opt.set_filename : fname );
+               pt = m_alloc( sizeof *pt + strlen(s) - 1 );
+               pt->namelen = strlen(s);
+               memcpy(pt->name, s, pt->namelen );
+               m_free(s);
+           }
+           else { /* no filename */
+               pt = m_alloc( sizeof *pt - 1 );
+               pt->namelen = 0;
+           }
+       }
+
        if( fname ) {
-           pt = m_alloc( sizeof *pt + strlen(fname) - 1 );
-           pt->namelen = strlen(fname);
-           memcpy(pt->name, fname, pt->namelen );
            if( !(filesize = iobuf_get_filelength(inp)) )
-               log_info("warning: '%s' is an empty file\n", fname );
+               log_info(_("WARNING: `%s' is an empty file\n"), fname );
+
+           /* because the text_filter modifies the length of the
+            * data, it is not possible to know the used length
+            * without a double read of the file - to avoid that
+            * we simple use partial length packets.
+            */
+           if( opt.textmode && !outfile )
+               filesize = 0;
        }
-       else { /* no filename */
-           pt = m_alloc( sizeof *pt - 1 );
-           pt->namelen = 0;
-           filesize = 0; /* stdin */
+       else
+           filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
+
+       if (!opt.no_literal) {
+           pt->timestamp = make_timestamp();
+           pt->mode = opt.textmode && !outfile ? 't':'b';
+           pt->len = filesize;
+           pt->new_ctb = !pt->len && !opt.rfc1991;
+           pt->buf = inp;
+           pkt.pkttype = PKT_PLAINTEXT;
+           pkt.pkt.plaintext = pt;
+           /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
+           if( (rc = build_packet( out, &pkt )) )
+               log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
+           pt->buf = NULL;
+       }
+       else {
+           byte copy_buffer[4096];
+           int  bytes_copied;
+           while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
+               if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
+                   rc = G10ERR_WRITE_FILE;
+                   log_error("copying input to output failed: %s\n", g10_errstr(rc));
+                   break;
+               }
+           memset(copy_buffer, 0, 4096); /* burn buffer */
        }
-       pt->timestamp = make_timestamp();
-       pt->mode = opt.textmode && !outfile ? 't':'b';
-       pt->len = filesize;
-       pt->buf = inp;
-       pkt.pkttype = PKT_PLAINTEXT;
-       pkt.pkt.plaintext = pt;
-       /*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
-       if( (rc = build_packet( out, &pkt )) )
-           log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
-       pt->buf = NULL;
     }
 
+    /* catch errors from above blocks */
+    if (rc)
+       goto leave;
+
     /* loop over the secret certificates */
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       PKT_secret_cert *skc;
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk;
        PKT_signature *sig;
-       MD_HANDLE md;
+       GCRY_MD_HD md;
 
-       skc = skc_rover->skc;
+       sk = sk_rover->sk;
 
        /* build the signature packet */
+       /* fixme: this code is partly duplicated in make_keysig_packet */
        sig = m_alloc_clear( sizeof *sig );
-       sig->pubkey_algo = skc->pubkey_algo;
+       sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
+       keyid_from_sk( sk, sig->keyid );
+       sig->digest_algo = hash_for(sk->pubkey_algo);
+       sig->pubkey_algo = sk->pubkey_algo;
        sig->timestamp = make_timestamp();
        sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
 
-       md = md_copy( mfx.md );
-       md_putc( md, sig->sig_class );
-       {   u32 a = sig->timestamp;
-           md_putc( md, (a >> 24) & 0xff );
-           md_putc( md, (a >> 16) & 0xff );
-           md_putc( md, (a >>  8) & 0xff );
-           md_putc( md,  a        & 0xff );
+       md = gcry_md_copy( mfx.md );
+
+       if( sig->version >= 4 ) {
+           build_sig_subpkt_from_sig( sig );
+           gcry_md_putc( md, sig->version );
        }
-       md_final( md );
 
-       if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
-           g10_elg_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
-       else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
-           g10_rsa_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
-       else
-           BUG();
-
-       md_close( md );
-
-       /* and write it */
-       init_packet(&pkt);
-       pkt.pkttype = PKT_SIGNATURE;
-       pkt.pkt.signature = sig;
-       rc = build_packet( out, &pkt );
-       free_packet( &pkt );
-       if( rc ) {
-           log_error("build signature packet failed: %s\n", g10_errstr(rc) );
-           goto leave;
+       mk_notation_and_policy( sig );
+
+       gcry_md_putc( md, sig->sig_class );
+       if( sig->version < 4 ) {
+           u32 a = sig->timestamp;
+           gcry_md_putc( md, (a >> 24) & 0xff );
+           gcry_md_putc( md, (a >> 16) & 0xff );
+           gcry_md_putc( md, (a >>  8) & 0xff );
+           gcry_md_putc( md,  a        & 0xff );
+       }
+       else {
+           byte buf[6];
+           size_t n;
+
+           gcry_md_putc( md, sig->pubkey_algo );
+           gcry_md_putc( md, sig->digest_algo );
+           if( sig->hashed_data ) {
+               n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
+               gcry_md_write( md, sig->hashed_data, n+2 );
+               n += 6;
+           }
+           else {
+               gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
+               gcry_md_putc( md, 0 );
+               n = 6;
+           }
+           /* add some magic */
+           buf[0] = sig->version;
+           buf[1] = 0xff;
+           buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
+           buf[3] = n >> 16;
+           buf[4] = n >>  8;
+           buf[5] = n;
+           gcry_md_write( md, buf, 6 );
+
+       }
+       gcry_md_final( md );
+
+       rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
+       gcry_md_close( md );
+
+       if( !rc ) { /* and write it */
+           init_packet(&pkt);
+           pkt.pkttype = PKT_SIGNATURE;
+           pkt.pkt.signature = sig;
+           rc = build_packet( out, &pkt );
+           free_packet( &pkt );
+           if( rc )
+               log_error("build signature packet failed: %s\n", g10_errstr(rc) );
        }
+       if( rc )
+           goto leave;
     }
 
 
@@ -296,72 +589,37 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     else
        iobuf_close(out);
     iobuf_close(inp);
-    md_close( mfx.md );
-    release_skc_list( skc_list );
-    release_pkc_list( pkc_list );
+    gcry_md_close( mfx.md );
+    release_sk_list( sk_list );
+    release_pk_list( pk_list );
     return rc;
 }
 
 
 
 /****************
- * note: we do not count empty lines at the beginning
- */
-static int
-write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
-{
-    int c;
-    int lastlf = 1;
-    int skip_empty = 1;
-
-    while( (c = iobuf_get(inp)) != -1 ) {
-       /* Note: We don't escape "From " because the MUA should cope with it */
-       if( lastlf ) {
-           if( c == '-' ) {
-               iobuf_put( out, c );
-               iobuf_put( out, ' ' );
-               skip_empty = 0;
-           }
-           else if( skip_empty && c == '\r' )
-               skip_empty = 2;
-           else
-               skip_empty = 0;
-       }
-
-       if( !skip_empty )
-           md_putc(md, c );
-       iobuf_put( out, c );
-       lastlf = c == '\n';
-       if( skip_empty == 2 )
-           skip_empty = lastlf ? 0 : 1;
-    }
-    return 0; /* fixme: add error handling */
-}
-
-
-/****************
  * make a clear signature. note that opt.armor is not needed
  */
 int
 clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
 {
     armor_filter_context_t afx;
-    compress_filter_context_t zfx;
-    text_filter_context_t tfx;
-    MD_HANDLE textmd = NULL;
+    GCRY_MD_HD textmd = NULL;
     IOBUF inp = NULL, out = NULL;
     PACKET pkt;
     int rc = 0;
-    SKC_LIST skc_list = NULL;
-    SKC_LIST skc_rover = NULL;
+    SK_LIST sk_list = NULL;
+    SK_LIST sk_rover = NULL;
+    int old_style = opt.rfc1991;
+    int only_md5 = 0;
 
     memset( &afx, 0, sizeof afx);
-    memset( &zfx, 0, sizeof zfx);
-    memset( &tfx, 0, sizeof tfx);
     init_packet( &pkt );
 
-    if( (rc=build_skc_list( locusr, &skc_list, 1 )) )
+    if( (rc=build_sk_list( locusr, &sk_list, 1, GCRY_PK_USAGE_SIGN )) )
        goto leave;
+    if( !old_style )
+       old_style = only_old_style( sk_list );
 
     /* prepare iobufs */
     if( !(inp = iobuf_open(fname)) ) {
@@ -373,600 +631,161 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
 
     if( outfile ) {
        if( !(out = iobuf_create( outfile )) ) {
-           log_error("can't create %s: %s\n", outfile, strerror(errno) );
+           log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
            rc = G10ERR_CREATE_FILE;
            goto leave;
        }
        else if( opt.verbose )
-           log_info("writing to '%s'\n", outfile );
+           log_info(_("writing to `%s'\n"), outfile );
     }
-    else if( !(out = open_outfile( fname, 1 )) ) {
-       rc = G10ERR_CREATE_FILE;
+    else if( (rc = open_outfile( fname, 1, &out )) )
        goto leave;
+
+    iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
+
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk = sk_rover->sk;
+       if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
+           only_md5 = 1;
+       else {
+           only_md5 = 0;
+           break;
+       }
     }
 
-    iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n"
-                       "Hash: RIPEMD160\n\n" );
+    if( old_style && only_md5 )
+       iobuf_writestr(out, "\n" );
+    else {
+       int any = 0;
+       byte hashs_seen[256];
+
+       memset( hashs_seen, 0, sizeof hashs_seen );
+       iobuf_writestr(out, "Hash: " );
+       for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+           PKT_secret_key *sk = sk_rover->sk;
+           int i = hash_for(sk->pubkey_algo);
+
+           if( !hashs_seen[ i & 0xff ] ) {
+               if( !openpgp_md_test_algo( i ) ) {
+                   hashs_seen[ i & 0xff ] = 1;
+                   if( any )
+                       iobuf_put(out, ',' );
+                   iobuf_writestr(out, gcry_md_algo_name( i ) );
+                   any = 1;
+               }
+           }
+       }
+       assert(any);
+       iobuf_writestr(out, "\n" );
+       if( opt.not_dash_escaped )
+           iobuf_writestr( out,
+               "NotDashEscaped: You need GnuPG to verify this message\n" );
+       iobuf_writestr(out, "\n" );
+    }
 
-    textmd = md_open(DIGEST_ALGO_RMD160, 0);
-    iobuf_push_filter( inp, text_filter, &tfx );
-    rc = write_dash_escaped( inp, out, textmd );
-    if( rc )
-       goto leave;
 
-    iobuf_writestr(out, "\n" );
+    if( !(textmd = gcry_md_open(0, 0)) )
+       BUG();
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk = sk_rover->sk;
+       gcry_md_enable(textmd, hash_for(sk->pubkey_algo));
+    }
+    /*md_start_debug( textmd, "sign" );*/
+    copy_clearsig_text( out, inp, textmd,
+                       !opt.not_dash_escaped, opt.escape_from, old_style );
+    /* fixme: check for read errors */
+
+    /* now write the armor */
     afx.what = 2;
     iobuf_push_filter( out, armor_filter, &afx );
 
     /* loop over the secret certificates */
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       PKT_secret_cert *skc;
+    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
+       PKT_secret_key *sk;
        PKT_signature *sig;
-       MD_HANDLE md;
+       GCRY_MD_HD md;
 
-       skc = skc_rover->skc;
+       sk = sk_rover->sk;
 
        /* build the signature packet */
+       /* fixme: this code is duplicated above */
        sig = m_alloc_clear( sizeof *sig );
-       sig->pubkey_algo = skc->pubkey_algo;
+       sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
+       keyid_from_sk( sk, sig->keyid );
+       sig->digest_algo = hash_for(sk->pubkey_algo);
+       sig->pubkey_algo = sk->pubkey_algo;
        sig->timestamp = make_timestamp();
        sig->sig_class = 0x01;
 
-       md = md_copy( textmd );
-       md_putc( md, sig->sig_class );
-       {   u32 a = sig->timestamp;
-           md_putc( md, (a >> 24) & 0xff );
-           md_putc( md, (a >> 16) & 0xff );
-           md_putc( md, (a >>  8) & 0xff );
-           md_putc( md,  a        & 0xff );
-       }
-       md_final( md );
-
-       if( sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL )
-           g10_elg_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
-       else if( sig->pubkey_algo == PUBKEY_ALGO_RSA )
-           g10_rsa_sign( skc, sig, md, DIGEST_ALGO_RMD160 );
-       else
-           BUG();
-
-       md_close( md );
-
-       /* and write it */
-       init_packet(&pkt);
-       pkt.pkttype = PKT_SIGNATURE;
-       pkt.pkt.signature = sig;
-       rc = build_packet( out, &pkt );
-       free_packet( &pkt );
-       if( rc ) {
-           log_error("build signature packet failed: %s\n", g10_errstr(rc) );
-           goto leave;
-       }
-    }
-
-
-  leave:
-    if( rc )
-       iobuf_cancel(out);
-    else
-       iobuf_close(out);
-    iobuf_close(inp);
-    md_close( textmd );
-    release_skc_list( skc_list );
-    return rc;
-}
-
-
-
-
-static void
-show_fingerprint( PKT_public_cert *pkc )
-{
-    byte *array, *p;
-    size_t i, n;
-
-    p = array = fingerprint_from_pkc( pkc, &n );
-    tty_printf("             Fingerprint:");
-    if( n == 20 ) {
-       for(i=0; i < n ; i++, i++, p += 2 ) {
-           if( i == 10 )
-               tty_printf(" ");
-           tty_printf(" %02X%02X", *p, p[1] );
+       md = gcry_md_copy( textmd );
+       if( sig->version >= 4 ) {
+           build_sig_subpkt_from_sig( sig );
+           gcry_md_putc( md, sig->version );
        }
-    }
-    else {
-       for(i=0; i < n ; i++, p++ ) {
-           if( i && !(i%8) )
-               tty_printf(" ");
-           tty_printf(" %02X", *p );
-       }
-    }
-    tty_printf("\n");
-    m_free(array);
-}
-
-
-/****************
- * Ask wether the user is willing to sign the key. Return true if so.
- */
-static int
-sign_it_p( PKT_public_cert *pkc, PKT_user_id *uid )
-{
-    char *answer;
-    int yes;
-
-    tty_printf("\nAre you really sure that you want so sign this key:\n\n"
-              "%4u%c/%08lX %s ",
-             nbits_from_pkc( pkc ),
-             pubkey_letter( pkc->pubkey_algo ),
-             (ulong)keyid_from_pkc( pkc, NULL ),
-             datestr_from_pkc( pkc )               );
-    tty_print_string( uid->name, uid->len );
-    tty_printf("\n");
-    show_fingerprint(pkc);
-    tty_printf("\n");
-    answer = tty_get("Sign this key? ");
-    tty_kill_prompt();
-    yes = answer_is_yes(answer);
-    m_free(answer);
-    return yes;
-}
 
+       mk_notation_and_policy( sig );
 
-/****************
- * Check the keysigs and set the flags to indicate errors.
- * Usage of nodes flag bits:
- * Bit 0 = bad signature
- *     1 = no public key
- *     2 = other error
- * Returns true if error found.
- */
-static int
-check_all_keysigs( KBNODE keyblock )
-{
-    KBNODE kbctx;
-    KBNODE node;
-    int rc;
-    int inv_sigs = 0;
-    int no_key = 0;
-    int oth_err = 0;
-
-    for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
-       if( node->pkt->pkttype == PKT_SIGNATURE
-           && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
-           PKT_signature *sig = node->pkt->pkt.signature;
-           int sigrc;
-
-           tty_printf("sig");
-           switch( (rc = check_key_signature( keyblock, node,NULL)) ) {
-             case 0:                node->flag = 0; sigrc = '!'; break;
-             case G10ERR_BAD_SIGN:  inv_sigs++; node->flag = 1; sigrc = '-'; break;
-             case G10ERR_NO_PUBKEY: no_key++;   node->flag = 2; sigrc = '?'; break;
-             default:               oth_err++;  node->flag = 4; sigrc = '%'; break;
-           }
-           tty_printf("%c       %08lX %s   ",
-                   sigrc, sig->keyid[1], datestr_from_sig(sig));
-           if( sigrc == '%' )
-               tty_printf("[%s] ", g10_errstr(rc) );
-           else if( sigrc == '?' )
-               ;
-           else {
-               size_t n;
-               char *p = get_user_id( sig->keyid, &n );
-               tty_print_string( p, n > 40? 40 : n );
-               m_free(p);
-           }
-           tty_printf("\n");
-           /* FIXME: update the trustdb */
+       gcry_md_putc( md, sig->sig_class );
+       if( sig->version < 4 ) {
+           u32 a = sig->timestamp;
+           gcry_md_putc( md, (a >> 24) & 0xff );
+           gcry_md_putc( md, (a >> 16) & 0xff );
+           gcry_md_putc( md, (a >>  8) & 0xff );
+           gcry_md_putc( md,  a        & 0xff );
        }
-    }
-    if( inv_sigs )
-       tty_printf("%d bad signatures\n", inv_sigs );
-    if( no_key )
-       tty_printf("No public key for %d signatures\n", no_key );
-    if( oth_err )
-       tty_printf("%d signatures not checked due to errors\n", oth_err );
-    return inv_sigs || no_key || oth_err;
-}
-
-
-/****************
- * Ask and remove invalid signatures are to be removed.
- */
-static int
-remove_keysigs( KBNODE keyblock, u32 *keyid, int all )
-{
-    KBNODE kbctx;
-    KBNODE node;
-    char *answer;
-    int yes;
-    int count;
-
-    count = 0;
-    for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
-       if( ((node->flag & 7) || all )
-           && node->pkt->pkttype == PKT_SIGNATURE
-           && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
-           PKT_signature *sig = node->pkt->pkt.signature;
-
-           if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
-               /* fixme: skip self-sig */
+       else {
+           byte buf[6];
+           size_t n;
+
+           gcry_md_putc( md, sig->pubkey_algo );
+           gcry_md_putc( md, sig->digest_algo );
+           if( sig->hashed_data ) {
+               n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
+               gcry_md_write( md, sig->hashed_data, n+2 );
+               n += 6;
            }
-
-           tty_printf("\n \"%08lX %s   ",
-                       sig->keyid[1], datestr_from_sig(sig));
-           if( node->flag & 6 )
-               tty_printf("[User name not available] ");
            else {
-               size_t n;
-               char *p = get_user_id( sig->keyid, &n );
-               tty_print_string( p, n );
-               m_free(p);
+               gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
+               gcry_md_putc( md, 0 );
+               n = 6;
            }
-           tty_printf("\"\n");
-           if( node->flag & 1 )
-               tty_printf("This is a BAD signature!\n");
-           else if( node->flag & 2 )
-               tty_printf("Public key not available.\n");
-           else if( node->flag & 4 )
-               tty_printf("The signature could not be checked!\n");
-
-           if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
-               continue; /* do not remove self-signatures */
-
-           answer = tty_get("\nRemove this signature? ");
-           tty_kill_prompt();
-           if( answer_is_yes(answer) ) {
-               node->flag |= 128;     /* use bit 7 to mark this node */
-               count++;
-           }
-           m_free(answer);
-       }
-    }
-
-    if( !count )
-       return 0; /* nothing to remove */
-    answer = tty_get("Do you really want to remove the selected signatures? ");
-    tty_kill_prompt();
-    yes = answer_is_yes(answer);
-    m_free(answer);
-    if( !yes )
-       return 0;
-
-    for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 1)) ; ) {
-       if( node->flag & 128)
-           delete_kbnode(node );
-    }
-
-    return 1;
-}
-
-
-/****************
- * This functions signs the key of USERNAME with all users listed in
- * LOCUSR. If LOCUSR is NULL the default secret certificate will
- * be used.  This works on all keyrings, so there is no armor or
- * compress stuff here.
- */
-int
-sign_key( const char *username, STRLIST locusr )
-{
-    md_filter_context_t mfx;
-    int rc = 0;
-    SKC_LIST skc_list = NULL;
-    SKC_LIST skc_rover = NULL;
-    KBNODE keyblock = NULL;
-    KBNODE kbctx, node;
-    KBPOS kbpos;
-    PKT_public_cert *pkc;
-    u32 pkc_keyid[2];
-    char *answer;
-
-    memset( &mfx, 0, sizeof mfx);
-
-    /* search the userid */
-    rc = find_keyblock_byname( &kbpos, username );
-    if( rc ) {
-       log_error("user '%s' not found\n", username );
-       goto leave;
-    }
-
-    /* build a list of all signators */
-    rc=build_skc_list( locusr, &skc_list, 0 );
-    if( rc )
-       goto leave;
-
-
-    /* read the keyblock */
-    rc = read_keyblock( &kbpos, &keyblock );
-    if( rc ) {
-       log_error("error reading the certificate: %s\n", g10_errstr(rc) );
-       goto leave;
-    }
-
-    /* get the keyid from the keyblock */
-    node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
-    if( !node ) {
-       log_error("Oops; public key not found anymore!\n");
-       rc = G10ERR_GENERAL;
-       goto leave;
-    }
+           /* add some magic */
+           buf[0] = sig->version;
+           buf[1] = 0xff;
+           buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
+           buf[3] = n >> 16;
+           buf[4] = n >>  8;
+           buf[5] = n;
+           gcry_md_write( md, buf, 6 );
 
-    pkc = node->pkt->pkt.public_cert;
-    keyid_from_pkc( pkc, pkc_keyid );
-    log_info("Checking signatures of this public key certificate:\n");
-    tty_printf("pub  %4u%c/%08lX %s   ",
-             nbits_from_pkc( pkc ),
-             pubkey_letter( pkc->pubkey_algo ),
-             pkc_keyid[1], datestr_from_pkc(pkc) );
-    {
-       size_t n;
-       char *p = get_user_id( pkc_keyid, &n );
-       tty_print_string( p, n > 40? 40 : n );
-       m_free(p);
-       tty_printf("\n");
-    }
-
-    clear_kbnode_flags( keyblock );
-    if( check_all_keysigs( keyblock ) ) {
-       if( !opt.batch ) {
-           /* ask wether we really should do anything */
-           answer = tty_get("To you want to remove some of the invalid sigs? ");
-           tty_kill_prompt();
-           if( answer_is_yes(answer) )
-               remove_keysigs( keyblock, pkc_keyid, 0 );
-           m_free(answer);
        }
-    }
-
-    /* check wether we have already signed it */
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       u32 akeyid[2];
-
-       keyid_from_skc( skc_rover->skc, akeyid );
-       for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
-           if( node->pkt->pkttype == PKT_SIGNATURE
-               && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
-               if( akeyid[0] == node->pkt->pkt.signature->keyid[0]
-                   && akeyid[1] == node->pkt->pkt.signature->keyid[1] ) {
-                   log_info("Already signed by keyid %08lX\n",
-                                                       (ulong)akeyid[1] );
-                   skc_rover->mark = 1;
-               }
-           }
+       gcry_md_final( md );
+
+       rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
+       gcry_md_close( md );
+
+       if( !rc ) { /* and write it */
+           init_packet(&pkt);
+           pkt.pkttype = PKT_SIGNATURE;
+           pkt.pkt.signature = sig;
+           rc = build_packet( out, &pkt );
+           free_packet( &pkt );
+           if( rc )
+               log_error("build signature packet failed: %s\n", g10_errstr(rc) );
        }
-    }
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       if( !skc_rover->mark )
-           break;
-    }
-    if( !skc_rover ) {
-       log_info("Nothing to sign\n");
-       goto leave;
-    }
-
-    /* Loop over all signers and all user ids and sign */
-    for( skc_rover = skc_list; skc_rover; skc_rover = skc_rover->next ) {
-       if( skc_rover->mark )
-           continue;
-       for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
-           if( node->pkt->pkttype == PKT_USER_ID ) {
-               if( sign_it_p( pkc, node->pkt->pkt.user_id ) ) {
-                   PACKET *pkt;
-                   PKT_signature *sig;
-
-                   rc = make_keysig_packet( &sig, pkc,
-                                                  node->pkt->pkt.user_id,
-                                                  skc_rover->skc,
-                                                  0x10,
-                                                  DIGEST_ALGO_RMD160 );
-                   if( rc ) {
-                       log_error("make_keysig_packet failed: %s\n", g10_errstr(rc));
-                       goto leave;
-                   }
-
-                   pkt = m_alloc_clear( sizeof *pkt );
-                   pkt->pkttype = PKT_SIGNATURE;
-                   pkt->pkt.signature = sig;
-                   insert_kbnode( node, new_kbnode(pkt), PKT_USER_ID );
-               }
-           }
-       }
-    }
-
-    rc = update_keyblock( &kbpos, keyblock );
-    if( rc ) {
-       log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
-       goto leave;
-    }
-
-  leave:
-    release_kbnode( keyblock );
-    release_skc_list( skc_list );
-    md_close( mfx.md );
-    return rc;
-}
-
-
-
-int
-edit_keysigs( const char *username )
-{
-    int rc = 0;
-    KBNODE keyblock = NULL;
-    KBNODE node;
-    KBPOS kbpos;
-    PKT_public_cert *pkc;
-    u32 pkc_keyid[2];
-
-    /* search the userid */
-    rc = find_keyblock_byname( &kbpos, username );
-    if( rc ) {
-       log_error("%s: user not found\n", username );
-       goto leave;
-    }
-
-    /* read the keyblock */
-    rc = read_keyblock( &kbpos, &keyblock );
-    if( rc ) {
-       log_error("%s: certificate read problem: %s\n", username, g10_errstr(rc) );
-       goto leave;
-    }
-
-    /* get the keyid from the keyblock */
-    node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
-    if( !node ) {
-       log_error("Oops; public key not found anymore!\n");
-       rc = G10ERR_GENERAL;
-       goto leave;
-    }
-
-    pkc = node->pkt->pkt.public_cert;
-    keyid_from_pkc( pkc, pkc_keyid );
-    log_info("Checking signatures of this public key certificate:\n");
-    tty_printf("pub  %4u%c/%08lX %s   ",
-             nbits_from_pkc( pkc ),
-             pubkey_letter( pkc->pubkey_algo ),
-             pkc_keyid[1], datestr_from_pkc(pkc) );
-    {
-       size_t n;
-       char *p = get_user_id( pkc_keyid, &n );
-       tty_print_string( p, n > 40? 40 : n );
-       m_free(p);
-       tty_printf("\n");
-    }
-
-    clear_kbnode_flags( keyblock );
-    check_all_keysigs( keyblock );
-    if( remove_keysigs( keyblock, pkc_keyid, 1 ) ) {
-       rc = update_keyblock( &kbpos, keyblock );
-       if( rc ) {
-           log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
+       if( rc )
            goto leave;
-       }
-    }
-
-  leave:
-    release_kbnode( keyblock );
-    return rc;
-}
-
-
-int
-change_passphrase( const char *username )
-{
-    int rc = 0;
-    KBNODE keyblock = NULL;
-    KBNODE node;
-    KBPOS kbpos;
-    PKT_secret_cert *skc;
-    u32 skc_keyid[2];
-    char *answer;
-    int changed=0;
-
-    /* search the userid */
-    rc = find_secret_keyblock_byname( &kbpos, username );
-    if( rc ) {
-       log_error("secret key for user '%s' not found\n", username );
-       goto leave;
-    }
-
-    /* read the keyblock */
-    rc = read_keyblock( &kbpos, &keyblock );
-    if( rc ) {
-       log_error("error reading the certificate: %s\n", g10_errstr(rc) );
-       goto leave;
-    }
-
-    /* get the keyid from the keyblock */
-    node = find_kbnode( keyblock, PKT_SECRET_CERT );
-    if( !node ) {
-       log_error("Oops; secret key not found anymore!\n");
-       rc = G10ERR_GENERAL;
-       goto leave;
     }
 
-    skc = node->pkt->pkt.secret_cert;
-    keyid_from_skc( skc, skc_keyid );
-    tty_printf("sec  %4u%c/%08lX %s   ",
-             nbits_from_skc( skc ),
-             pubkey_letter( skc->pubkey_algo ),
-             skc_keyid[1], datestr_from_skc(skc) );
-    {
-       size_t n;
-       char *p = get_user_id( skc_keyid, &n );
-       tty_print_string( p, n );
-       m_free(p);
-       tty_printf("\n");
-    }
-
-    clear_kbnode_flags( keyblock );
-    switch( is_secret_key_protected( skc ) ) {
-      case -1:
-       rc = G10ERR_PUBKEY_ALGO;
-       break;
-      case 0:
-       tty_printf("This key is not protected.\n");
-       break;
-      default:
-       tty_printf("Key is protected.\n");
-       rc = check_secret_key( skc );
-       break;
-    }
-
-    if( rc )
-       tty_printf("Can't edit this key: %s\n", g10_errstr(rc));
-    else {
-       DEK *dek = m_alloc_secure( sizeof *dek );
-
-       tty_printf( "Enter the new passphrase for this secret key.\n\n" );
-
-       for(;;) {
-           dek->algo = CIPHER_ALGO_BLOWFISH;
-           rc = make_dek_from_passphrase( dek , 2 );
-           if( rc == -1 ) {
-               rc = 0;
-               tty_printf( "You don't want a passphrase -"
-                           " this is probably a *bad* idea!\n\n");
-               answer = tty_get("Do you really want to do this? ");
-               tty_kill_prompt();
-               if( answer_is_yes(answer) )
-                   changed++;
-               m_free(answer);
-               break;
-           }
-           else if( rc == G10ERR_PASSPHRASE ) {
-               tty_printf("passphrase not correctly repeated; try again.\n");
-           }
-           else if( rc ) {
-               m_free(dek); dek = NULL;
-               log_error("Error getting the passphrase: %s\n", g10_errstr(rc));
-               break;
-           }
-           else { /* okay */
-               skc->d.elg.protect_algo = CIPHER_ALGO_BLOWFISH;
-               randomize_buffer(skc->d.elg.protect.blowfish.iv, 8, 1);
-               rc = protect_secret_key( skc, dek );
-               if( rc )
-                   log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
-               else
-                   changed++;
-               break;
-           }
-       }
-       m_free(dek);
-    }
-
-
-    if( changed ) {
-       rc = update_keyblock( &kbpos, keyblock );
-       if( rc ) {
-           log_error("update_keyblock failed: %s\n", g10_errstr(rc) );
-           goto leave;
-       }
-    }
 
   leave:
-    release_kbnode( keyblock );
+    if( rc )
+       iobuf_cancel(out);
+    else
+       iobuf_close(out);
+    iobuf_close(inp);
+    gcry_md_close( textmd );
+    release_sk_list( sk_list );
     return rc;
 }
 
@@ -975,41 +794,109 @@ change_passphrase( const char *username )
  * Create a signature packet for the given public key certificate
  * and the user id and return it in ret_sig. User signature class SIGCLASS
  * user-id is not used (and may be NULL if sigclass is 0x20)
+ * If digest_algo is 0 the function selects an appropriate one.
  */
 int
-make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
-                   PKT_user_id *uid, PKT_secret_cert *skc,
-                   int sigclass, int digest_algo )
+make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
+                   PKT_user_id *uid, PKT_public_key *subpk,
+                   PKT_secret_key *sk,
+                   int sigclass, int digest_algo,
+                   int (*mksubpkt)(PKT_signature *, void *), void *opaque
+                  )
 {
     PKT_signature *sig;
     int rc=0;
-    MD_HANDLE md;
-
-    assert( (sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x20 );
-    md = md_open( digest_algo, 0 );
+    GCRY_MD_HD md;
+
+    assert( (sigclass >= 0x10 && sigclass <= 0x13)
+           || sigclass == 0x20 || sigclass == 0x18
+           || sigclass == 0x30 || sigclass == 0x28 );
+    if( !digest_algo ) {
+       switch( sk->pubkey_algo ) {
+         case GCRY_PK_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
+         case GCRY_PK_RSA_S:
+         case GCRY_PK_RSA: digest_algo = DIGEST_ALGO_MD5; break;
+         default:              digest_algo = DIGEST_ALGO_RMD160; break;
+       }
+    }
+    if( !(md = gcry_md_open( digest_algo, 0 )))
+       BUG();
 
     /* hash the public key certificate and the user id */
-    hash_public_cert( md, pkc );
-    if( sigclass != 0x20 )
-       md_write( md, uid->name, uid->len );
+    hash_public_key( md, pk );
+    if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
+       hash_public_key( md, subpk );
+    }
+    else if( sigclass != 0x20 ) {
+       if( sk->version >=4 ) {
+           byte buf[5];
+           buf[0] = 0xb4;            /* indicates a userid packet */
+           buf[1] = uid->len >> 24;  /* always use 4 length bytes */
+           buf[2] = uid->len >> 16;
+           buf[3] = uid->len >>  8;
+           buf[4] = uid->len;
+           gcry_md_write( md, buf, 5 );
+       }
+       gcry_md_write( md, uid->name, uid->len );
+    }
     /* and make the signature packet */
     sig = m_alloc_clear( sizeof *sig );
-    sig->pubkey_algo = skc->pubkey_algo;
+    sig->version = sk->version;
+    keyid_from_sk( sk, sig->keyid );
+    sig->pubkey_algo = sk->pubkey_algo;
+    sig->digest_algo = digest_algo;
     sig->timestamp = make_timestamp();
     sig->sig_class = sigclass;
+    if( sig->version >= 4 )
+       build_sig_subpkt_from_sig( sig );
+
+    if( sig->version >= 4 && mksubpkt )
+       rc = (*mksubpkt)( sig, opaque );
+
+    if( !rc ) {
+       mk_notation_and_policy( sig );
+       if( sig->version >= 4 )
+           gcry_md_putc( md, sig->version );
+       gcry_md_putc( md, sig->sig_class );
+       if( sig->version < 4 ) {
+           u32 a = sig->timestamp;
+           gcry_md_putc( md, (a >> 24) & 0xff );
+           gcry_md_putc( md, (a >> 16) & 0xff );
+           gcry_md_putc( md, (a >>  8) & 0xff );
+           gcry_md_putc( md,  a        & 0xff );
+       }
+       else {
+           byte buf[6];
+           size_t n;
+
+           gcry_md_putc( md, sig->pubkey_algo );
+           gcry_md_putc( md, sig->digest_algo );
+           if( sig->hashed_data ) {
+               n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
+               gcry_md_write( md, sig->hashed_data, n+2 );
+               n += 6;
+           }
+           else {
+               gcry_md_putc( md, 0 );  /* always hash the length of the subpacket*/
+               gcry_md_putc( md, 0 );
+               n = 6;
+           }
+           /* add some magic */
+           buf[0] = sig->version;
+           buf[1] = 0xff;
+           buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
+           buf[3] = n >> 16;
+           buf[4] = n >>  8;
+           buf[5] = n;
+           gcry_md_write( md, buf, 6 );
 
-    md_putc( md, sig->sig_class );
-    {  u32 a = sig->timestamp;
-       md_putc( md, (a >> 24) & 0xff );
-       md_putc( md, (a >> 16) & 0xff );
-       md_putc( md, (a >>  8) & 0xff );
-       md_putc( md,  a        & 0xff );
-    }
-    md_final(md);
+       }
+       gcry_md_final(md);
 
-    rc = complete_sig( sig, skc, md );
+       rc = complete_sig( sig, sk, md );
+    }
 
-    md_close( md );
+    gcry_md_close( md );
     if( rc )
        free_seckey_enc( sig );
     else
@@ -1017,3 +904,4 @@ make_keysig_packet( PKT_signature **ret_sig, PKT_public_cert *pkc,
     return rc;
 }
 
+