See ChangeLog: Wed Oct 4 13:16:18 CEST 2000 Werner Koch
[gnupg.git] / g10 / sign.c
index 0fac451..bdc5b8a 100644 (file)
@@ -1,5 +1,5 @@
 /* sign.c - sign data
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <errno.h>
 #include <assert.h>
 
+#include <gcrypt.h>
 #include "options.h"
 #include "packet.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "keydb.h"
-#include "memory.h"
 #include "util.h"
 #include "main.h"
 #include "filter.h"
 #include "ttyio.h"
 #include "trustdb.h"
+#include "status.h"
 #include "i18n.h"
 
 
+#define ENABLE_BETTER_PGP2_COMPAT 1
+
+#ifdef HAVE_DOSISH_SYSTEM
+  #define LF "\r\n"
+#else
+  #define LF "\n"
+#endif
+
+/****************
+ * 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 ) {
+       rc = gcry_sexp_build ( &s_skey, NULL,
+                             "(private-key(dsa(p%m)(q%m)(g%m)(y%m)(x%m)))",
+                                 skey[0], skey[1], skey[2], skey[3], skey[4] );
+    }
+    else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
+       rc = gcry_sexp_build ( &s_skey, NULL,
+                             "(private-key(elg(p%m)(g%m)(y%m)(x%m)))",
+                                 skey[0], skey[1], skey[2], skey[3] );
+    }
+    else
+       return GPGERR_PUBKEY_ALGO;
+
+    if ( rc )
+       BUG ();
+
+    /* put hash into a S-Exp s_hash */
+    if ( gcry_sexp_build( &s_hash, NULL, "%m", hash ) )
+       BUG ();
+
+    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_nth_mpi( list, 1, 0 );
+       assert( data[0] );
+       gcry_sexp_release (list);
+
+       list = gcry_sexp_find_token( s_sig, "s" , 0 );
+       assert( list );
+       data[1] = gcry_sexp_nth_mpi( list, 1, 0 );
+       assert( data[1] );
+       gcry_sexp_release (list);
+    }
+
+
+    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 = gcry_xmalloc( 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
 do_sign( PKT_secret_key *sk, PKT_signature *sig,
-        MD_HANDLE md, int digest_algo )
+        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 );
+       if( !opt.ignore_time_conflict )
+           return GPGERR_TIME_CONFLICT;
+    }
+
+
     print_pubkey_algo_note(sk->pubkey_algo);
 
     if( !digest_algo )
-       digest_algo = md_get_algo(md);
+       digest_algo = gcry_md_get_algo(md);
 
     print_digest_algo_note( digest_algo );
-    dp = md_read( md, 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 = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
-    mpi_free(frame);
+                            digest_algo, gcry_mpi_get_nbits(sk->skey[0]), 0 );
+    rc = pk_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
+    mpi_release(frame);
     if( rc )
-       log_error(_("signing failed: %s\n"), g10_errstr(rc) );
+       log_error(_("signing failed: %s\n"), gpg_errstr(rc) );
     else {
        if( opt.verbose ) {
            char *ustr = get_user_id_string( sig->keyid );
            log_info(_("%s signature from: %s\n"),
-                     pubkey_algo_to_string(sk->pubkey_algo), ustr );
-           m_free(ustr);
+                     gcry_pk_algo_name(sk->pubkey_algo), ustr );
+           gcry_free(ustr);
        }
     }
     return rc;
@@ -77,7 +205,7 @@ do_sign( PKT_secret_key *sk, PKT_signature *sig,
 
 
 int
-complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
+complete_sig( PKT_signature *sig, PKT_secret_key *sk, GCRY_MD_HD md )
 {
     int rc=0;
 
@@ -91,14 +219,14 @@ complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
 }
 
 static int
-hash_for(int pubkey_algo )
+hash_for(int pubkey_algo, int packet_version )
 {
     if( opt.def_digest_algo )
        return opt.def_digest_algo;
-    if( pubkey_algo == PUBKEY_ALGO_DSA )
-       return DIGEST_ALGO_SHA1;
-    if( pubkey_algo == PUBKEY_ALGO_RSA )
-       return DIGEST_ALGO_MD5;
+    if( pubkey_algo == GCRY_PK_DSA )
+       return GCRY_MD_SHA1;
+    if( pubkey_algo == GCRY_PK_RSA && packet_version < 4 )
+       return GCRY_MD_MD5;
     return DEFAULT_DIGEST_ALGO;
 }
 
@@ -111,7 +239,7 @@ only_old_style( SK_LIST sk_list )
     /* 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 == PUBKEY_ALGO_RSA && sk->version < 4 )
+       if( sk->pubkey_algo == GCRY_PK_RSA && sk->version < 4 )
            old_style = 1;
        else
            return 0;
@@ -120,6 +248,113 @@ only_old_style( SK_LIST sk_list )
 }
 
 
+static void
+print_status_sig_created ( PKT_secret_key *sk, PKT_signature *sig, int what )
+{
+    byte array[MAX_FINGERPRINT_LEN], *p;
+    char buf[100+MAX_FINGERPRINT_LEN*2];
+    size_t i, n;
+
+    sprintf(buf, "%c %d %d %02x %lu ",
+           what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
+           (ulong)sig->timestamp );
+
+    fingerprint_from_sk( sk, array, &n );
+    p = buf + strlen(buf);
+    for(i=0; i < n ; i++ )
+       sprintf(p+2*i, "%02X", array[i] );
+
+    write_status_text( STATUS_SIG_CREATED, buf );
+}
+
+static int
+write_one_signature( IOBUF out, PKT_secret_key *sk, int old_style,
+                     const char *outfile,
+                     GCRY_MD_HD datamd,
+                     int sig_class,
+                     int status_char )
+{
+    PKT_signature *sig;
+    GCRY_MD_HD md;
+    int rc;
+
+    /* build the signature packet */
+    /* fixme: this code is partly duplicated in make_keysig_packet */
+    sig = gcry_xcalloc( 1, sizeof *sig );
+    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, sk->version);
+    sig->pubkey_algo = sk->pubkey_algo;
+    sig->timestamp = make_timestamp();
+    sig->sig_class = sig_class;
+
+    md = gcry_md_copy( datamd );
+    if( !md )
+        BUG();
+    if( sig->version >= 4 ) {
+        build_sig_subpkt_from_sig( sig );
+        gcry_md_putc( md, sig->version );
+    }
+    
+    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, sk->version) );
+    gcry_md_close( md );
+    /* Hmmm: Do we release sig in case of rc != 0? */
+    
+    if( !rc ) { /* and write it */
+        PACKET pkt;
+
+        init_packet(&pkt);
+        pkt.pkttype = PKT_SIGNATURE;
+        pkt.pkt.signature = sig;
+        rc = build_packet( out, &pkt );
+        if( !rc && is_status_enabled() ) {
+            print_status_sig_created ( sk, sig, status_char );       
+        }
+        free_packet( &pkt );
+        if( rc )
+            log_error("build signature packet failed: %s\n", gpg_errstr(rc) );
+    }
+
+    return rc;
+}
+
 
 /****************
  * Sign the files whose names are in FILENAME.
@@ -173,13 +408,13 @@ 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_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
+    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_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )) )
+       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 );
@@ -191,14 +426,14 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     else if( !(inp = iobuf_open(fname)) ) {
        log_error("can't open %s: %s\n", fname? fname: "[stdin]",
                                        strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
+       rc = GPGERR_OPEN_FILE;
        goto leave;
     }
 
     if( outfile ) {
        if( !(out = iobuf_create( outfile )) ) {
            log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
-           rc = G10ERR_CREATE_FILE;
+           rc = GPGERR_CREATE_FILE;
            goto leave;
        }
        else if( opt.verbose )
@@ -210,11 +445,12 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     /* prepare to calculate the MD over the input */
     if( opt.textmode && !outfile )
        iobuf_push_filter( inp, text_filter, &tfx );
-    mfx.md = md_open(0, 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;
-       md_enable(mfx.md, hash_for(sk->pubkey_algo));
+       gcry_md_enable(mfx.md, hash_for(sk->pubkey_algo, sk->version ));
     }
 
     if( !multifile )
@@ -239,16 +475,20 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
        iobuf_push_filter( out, encrypt_filter, &efx );
     }
 
+    /* Select a compress algorithm */
     if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
        if( !compr_algo )
            ; /* don't use compression */
        else {
-           if( old_style || compr_algo == 1 )
-               zfx.algo = 1;
+           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 );
        }
     }
 
+    /* Build one-pass signature packets when needed */
     if( !detached && !old_style ) {
        int skcount=0;
        /* loop over the secret certificates and build headers
@@ -267,9 +507,9 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
                    break;
 
            sk = sk_rover->sk;
-           ops = m_alloc_clear( sizeof *ops );
+           ops = gcry_xcalloc( 1, sizeof *ops );
            ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
-           ops->digest_algo = hash_for(sk->pubkey_algo);
+           ops->digest_algo = hash_for(sk->pubkey_algo, sk->version);
            ops->pubkey_algo = sk->pubkey_algo;
            keyid_from_sk( sk, ops->keyid );
            ops->last = skcount == 1;
@@ -281,7 +521,7 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
            free_packet( &pkt );
            if( rc ) {
                log_error("build onepass_sig packet failed: %s\n",
-                                                       g10_errstr(rc));
+                                                       gpg_errstr(rc));
                goto leave;
            }
        }
@@ -289,6 +529,8 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
 
     /* setup the inner packet */
     if( detached ) {
+        /* this is pretty much the same for old and new PGP.  So no
+         * need to cope with different packet ordering */
        if( multifile ) {
            STRLIST sl;
 
@@ -300,7 +542,7 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
                if( !(inp = iobuf_open(sl->d)) ) {
                    log_error(_("can't open %s: %s\n"),
                                            sl->d, strerror(errno) );
-                   rc = G10ERR_OPEN_FILE;
+                   rc = GPGERR_OPEN_FILE;
                    goto leave;
                }
                if( opt.verbose )
@@ -320,117 +562,79 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
        }
     }
     else {
-       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;
+        /* get the filename to be stored into the literal datapacket */
+       if (!opt.no_literal) {
+           if( fname || opt.set_filename ) {
+               char *s = make_basename( opt.set_filename ?
+                                         opt.set_filename : fname );
+               pt = gcry_xmalloc( sizeof *pt + strlen(s) - 1 );
+               pt->namelen = strlen(s);
+               memcpy(pt->name, s, pt->namelen );
+               gcry_free(s);
+           }
+           else { /* no filename */
+               pt = gcry_xmalloc( sizeof *pt - 1 );
+               pt->namelen = 0;
+           }
        }
+
        if( fname ) {
            if( !(filesize = iobuf_get_filelength(inp)) )
                log_info(_("WARNING: `%s' is an empty file\n"), fname );
+            /* we can't yet encode the length of very large files,
+             * so we switch to partial length encoding in this case */
+            if ( filesize >= IOBUF_FILELENGTH_LIMIT )
+                filesize = 0;
 
-           /* because the text_filter modifies the length of the
+           /* 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.
-            * FIXME: We have to do the double read when opt.rfc1991
-            *        is active.
             */
            if( opt.textmode && !outfile )
                filesize = 0;
        }
        else
-           filesize = 0; /* stdin */
-       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;
-    }
-
-    /* loop over the secret certificates */
-    for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
-       PKT_secret_key *sk;
-       PKT_signature *sig;
-       MD_HANDLE md;
-
-       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->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 );
-
-       if( sig->version >= 4 ) {
-           build_sig_subpkt_from_sig( sig );
-           md_putc( md, sig->version );
-       }
-       md_putc( md, sig->sig_class );
-       if( sig->version < 4 ) {
-           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 );
+           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",
+                          gpg_errstr(rc) );
+           pt->buf = NULL;
        }
        else {
-           byte buf[6];
-           size_t n;
-
-           md_putc( md, sig->pubkey_algo );
-           md_putc( md, sig->digest_algo );
-           if( sig->hashed_data ) {
-               n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
-               md_write( md, sig->hashed_data, n+2 );
-               n += 6;
-           }
-           else
-               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;
-           md_write( md, buf, 6 );
-
+           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 = GPGERR_WRITE_FILE;
+                   log_error("copying input to output failed: %s\n",
+                              gpg_errstr(rc));
+                   break;
+               }
+           memset(copy_buffer, 0, 4096); /* burn buffer */
        }
-       md_final( md );
+    }
 
-       rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
-       md_close( md );
+    /* catch errors from above */
+    if (rc)
+       goto leave;
 
-       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;
+    /* write all the signature packets */
+    for( sk_rover = sk_list; sk_rover && !rc ; sk_rover = sk_rover->next ) {
+        rc = write_one_signature( out, sk_rover->sk,
+                                  old_style, outfile, mfx.md,
+                                  opt.textmode && !outfile? 0x01 : 0x00,
+                                  detached ? 'D':'S' );
     }
 
 
@@ -440,123 +644,23 @@ sign_file( STRLIST filenames, int detached, STRLIST locusr,
     else
        iobuf_close(out);
     iobuf_close(inp);
-    md_close( mfx.md );
+    gcry_md_close( mfx.md );
     release_sk_list( sk_list );
     release_pk_list( pk_list );
+    /* FIXME: Did we release the efx.cfx.dek ? */
     return rc;
 }
 
 
 
 /****************
- * Note: We do not calculate the hash over the last CR,LF
- */
-static int
-write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
-{
-    int c;
-    int lastlf = 1;
-    int state = 0;
-
-    if( opt.not_dash_escaped ) {
-       lastlf = 0;
-       while( (c = iobuf_get(inp)) != -1 ) {
-           md_putc(md, c );
-           iobuf_put( out, c );
-           lastlf = c;
-       }
-       if( lastlf != '\n' ) {
-           /* add a missing trailing LF */
-           md_putc(md, '\n' );
-           iobuf_put( out, '\n' );
-       }
-
-       return 0;
-    }
-
-    while( (c = iobuf_get(inp)) != -1 ) {
-       if( lastlf ) {
-           if( c == '-' ) {
-               iobuf_put( out, c );
-               iobuf_put( out, ' ' );
-           }
-           else if( c == 'F' && opt.escape_from ) {
-               int i;
-
-               if( state >= 1 )
-                   md_putc(md, '\r');
-               if( state >= 2 )
-                   md_putc(md, '\n');
-               state = 0;
-
-               for( i=1; i < 5 && (c = iobuf_get(inp)) != -1; i++ ) {
-                   if( "From "[i] != c )
-                       break;
-               }
-               if( i < 5 ) {
-                   iobuf_write( out, "From", i );
-                   md_write( md, "From", i );
-                   if( c == -1 )
-                       break;
-               }
-               else {
-                   iobuf_writestr( out, "- From" );
-                   md_write( md, "From", 4 );
-               }
-           }
-       }
-
-      again:
-       switch( state ) {
-         case 0:
-           if( c == '\r' )
-               state = 1;
-           else
-               md_putc(md, c );
-           break;
-         case 1:
-           if( c == '\n' )
-               state = 2;
-           else {
-               md_putc(md, '\r');
-               state = 0;
-               goto again;
-           }
-           break;
-         case 2:
-           md_putc(md, '\r');
-           md_putc(md, '\n');
-           state = 0;
-           goto again;
-         default: BUG();
-       }
-       iobuf_put( out, c );
-       lastlf = c == '\n';
-    }
-    if( state == 1 )
-       md_putc(md, '\r');
-    else if( state == 2 ) {  /* file ended with a new line */
-       md_putc(md, '\r');
-       md_putc(md, '\n');
-       iobuf_put( out, '\n');
-    }
-
-    if( !lastlf )
-       iobuf_put( out, '\n' );
-
-    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;
-    text_filter_context_t tfx;
-    MD_HANDLE textmd = NULL;
+    GCRY_MD_HD textmd = NULL;
     IOBUF inp = NULL, out = NULL;
     PACKET pkt;
     int rc = 0;
@@ -566,10 +670,9 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
     int only_md5 = 0;
 
     memset( &afx, 0, sizeof afx);
-    memset( &tfx, 0, sizeof tfx);
     init_packet( &pkt );
 
-    if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
+    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 );
@@ -578,14 +681,14 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
     if( !(inp = iobuf_open(fname)) ) {
        log_error("can't open %s: %s\n", fname? fname: "[stdin]",
                                        strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
+       rc = GPGERR_OPEN_FILE;
        goto leave;
     }
 
     if( outfile ) {
        if( !(out = iobuf_create( outfile )) ) {
            log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
-           rc = G10ERR_CREATE_FILE;
+           rc = GPGERR_CREATE_FILE;
            goto leave;
        }
        else if( opt.verbose )
@@ -594,11 +697,11 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
     else if( (rc = open_outfile( fname, 1, &out )) )
        goto leave;
 
-    iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
+    iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
 
     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 )
+       if( hash_for(sk->pubkey_algo, sk->version) == GCRY_MD_MD5 )
            only_md5 = 1;
        else {
            only_md5 = 0;
@@ -606,21 +709,26 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
        }
     }
 
-    if( old_style || only_md5 )
+    if( old_style && only_md5 )
        iobuf_writestr(out, "\n" );
     else {
-       const char *s;
        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;
-           s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
-           if( s ) {
-               if( any )
-                   iobuf_put(out, ',' );
-               iobuf_writestr(out, s );
-               any = 1;
+           int i = hash_for(sk->pubkey_algo, sk->version);
+
+           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);
@@ -632,101 +740,38 @@ clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
     }
 
 
-    textmd = md_open(0, 0);
+    textmd = gcry_md_open(0, 0);
+    if( !textmd )
+       BUG();
     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
        PKT_secret_key *sk = sk_rover->sk;
-       md_enable(textmd, hash_for(sk->pubkey_algo));
+       gcry_md_enable(textmd, hash_for(sk->pubkey_algo, sk->version));
     }
-    md_start_debug( textmd, "create" );
-    if( !opt.not_dash_escaped )
-       iobuf_push_filter( inp, text_filter, &tfx );
-    rc = write_dash_escaped( inp, out, textmd );
-    if( rc )
-       goto leave;
+    if ( DBG_HASHING )
+       gcry_md_start_debug( textmd, "clearsign" );
+    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( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
-       PKT_secret_key *sk;
-       PKT_signature *sig;
-       MD_HANDLE md;
-
-       sk = sk_rover->sk;
-
-       /* build the signature packet */
-       /* fixme: this code is duplicated above */
-       sig = m_alloc_clear( sizeof *sig );
-       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 );
-       if( sig->version >= 4 ) {
-           build_sig_subpkt_from_sig( sig );
-           md_putc( md, sig->version );
-       }
-       md_putc( md, sig->sig_class );
-       if( sig->version < 4 ) {
-           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 );
-       }
-       else {
-           byte buf[6];
-           size_t n;
-
-           md_putc( md, sig->pubkey_algo );
-           md_putc( md, sig->digest_algo );
-           if( sig->hashed_data ) {
-               n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
-               md_write( md, sig->hashed_data, n+2 );
-               n += 6;
-           }
-           else
-               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;
-           md_write( md, buf, 6 );
-
-       }
-       md_final( md );
-
-       rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
-       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;
+    /* write all the signature packets */
+    for( sk_rover = sk_list; sk_rover && !rc ; sk_rover = sk_rover->next ) {
+        rc = write_one_signature( out, sk_rover->sk,
+                                  old_style, outfile, textmd,
+                                  0x01,
+                                  'C' );
     }
 
-
   leave:
     if( rc )
        iobuf_cancel(out);
     else
        iobuf_close(out);
     iobuf_close(inp);
-    md_close( textmd );
+    gcry_md_close( textmd );
     release_sk_list( sk_list );
     return rc;
 }
@@ -748,23 +793,25 @@ make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
 {
     PKT_signature *sig;
     int rc=0;
-    MD_HANDLE md;
+    GCRY_MD_HD md;
 
     assert( (sigclass >= 0x10 && sigclass <= 0x13)
-           || sigclass == 0x20 || sigclass == 0x18 );
+           || sigclass == 0x20 || sigclass == 0x18
+           || sigclass == 0x30 || sigclass == 0x28 );
     if( !digest_algo ) {
        switch( sk->pubkey_algo ) {
-         case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
-         case PUBKEY_ALGO_RSA_S:
-         case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
-         default:              digest_algo = DIGEST_ALGO_RMD160; break;
+         case GCRY_PK_DSA: digest_algo = GCRY_MD_SHA1; break;
+         case GCRY_PK_RSA_S:
+         case GCRY_PK_RSA: digest_algo = GCRY_MD_MD5; break;
+         default:              digest_algo = GCRY_MD_RMD160; break;
        }
     }
-    md = md_open( digest_algo, 0 );
+    if( !(md = gcry_md_open( digest_algo, 0 )))
+       BUG();
 
     /* hash the public key certificate and the user id */
     hash_public_key( md, pk );
-    if( sigclass == 0x18 ) { /* subkey binding */
+    if( sigclass == 0x18 || sigclass == 0x28 ) { /* subkey binding/revocation*/
        hash_public_key( md, subpk );
     }
     else if( sigclass != 0x20 ) {
@@ -775,12 +822,12 @@ make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
            buf[2] = uid->len >> 16;
            buf[3] = uid->len >>  8;
            buf[4] = uid->len;
-           md_write( md, buf, 5 );
+           gcry_md_write( md, buf, 5 );
        }
-       md_write( md, uid->name, uid->len );
+       gcry_md_write( md, uid->name, uid->len );
     }
     /* and make the signature packet */
-    sig = m_alloc_clear( sizeof *sig );
+    sig = gcry_xcalloc( 1, sizeof *sig );
     sig->version = sk->version;
     keyid_from_sk( sk, sig->keyid );
     sig->pubkey_algo = sk->pubkey_algo;
@@ -794,29 +841,33 @@ make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
        rc = (*mksubpkt)( sig, opaque );
 
     if( !rc ) {
+       mk_notation_and_policy( sig );
        if( sig->version >= 4 )
-           md_putc( md, sig->version );
-       md_putc( md, sig->sig_class );
+           gcry_md_putc( md, sig->version );
+       gcry_md_putc( md, sig->sig_class );
        if( sig->version < 4 ) {
            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 );
+           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;
 
-           md_putc( md, sig->pubkey_algo );
-           md_putc( md, sig->digest_algo );
+           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];
-               md_write( md, sig->hashed_data, n+2 );
+               gcry_md_write( md, sig->hashed_data, n+2 );
                n += 6;
            }
-           else
+           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;
@@ -824,15 +875,15 @@ make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
            buf[3] = n >> 16;
            buf[4] = n >>  8;
            buf[5] = n;
-           md_write( md, buf, 6 );
+           gcry_md_write( md, buf, 6 );
 
        }
-       md_final(md);
+       gcry_md_final(md);
 
        rc = complete_sig( sig, sk, md );
     }
 
-    md_close( md );
+    gcry_md_close( md );
     if( rc )
        free_seckey_enc( sig );
     else