gpg: Remove the extra prompt for Curve25519.
[gnupg.git] / g10 / armor.c
index 2003ce3..98fb105 100644 (file)
@@ -1,12 +1,12 @@
 /* armor.c - Armor flter
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
- *               2004 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+ *               2007 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * 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
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -15,8 +15,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -27,9 +26,9 @@
 #include <assert.h>
 #include <ctype.h>
 
-#include "errors.h"
+#include "gpg.h"
+#include "status.h"
 #include "iobuf.h"
-#include "memory.h"
 #include "util.h"
 #include "filter.h"
 #include "packet.h"
 #include "status.h"
 #include "i18n.h"
 
-#ifdef HAVE_DOSISH_SYSTEM
-#define LF "\r\n"
-#else
-#define LF "\n"
-#endif
-
 #define MAX_LINELEN 20000
 
 #define CRCINIT 0xB704CE
@@ -119,6 +112,53 @@ static char *tail_strings[] = {
 };
 
 
+static int armor_filter ( void *opaque, int control,
+                          iobuf_t chain, byte *buf, size_t *ret_len);
+
+
+
+\f
+/* Create a new context for armor filters.  */
+armor_filter_context_t *
+new_armor_context (void)
+{
+  armor_filter_context_t *afx;
+
+  afx = xcalloc (1, sizeof *afx);
+  afx->refcount = 1;
+
+  return afx;
+}
+
+/* Release an armor filter context.  Passing NULL is explicitly
+   allowed and a no-op.  */
+void
+release_armor_context (armor_filter_context_t *afx)
+{
+  if (!afx)
+    return;
+  assert (afx->refcount);
+  if ( --afx->refcount )
+    return;
+  xfree (afx);
+}
+
+/* Push the armor filter onto the iobuf stream IOBUF.  */
+int
+push_armor_filter (armor_filter_context_t *afx, iobuf_t iobuf)
+{
+  int rc;
+
+  afx->refcount++;
+  rc = iobuf_push_filter (iobuf, armor_filter, afx);
+  if (rc)
+    afx->refcount--;
+  return rc;
+}
+
+
+
+
 
 static void
 initialize(void)
@@ -153,36 +193,77 @@ initialize(void)
 
 /****************
  * Check whether this is an armored file or not See also
- * parse-packet.c for details on this code For unknown historic
- * reasons we use a string here but only the first byte will be used.
+ * parse-packet.c for details on this code.
  * Returns: True if it seems to be armored
  */
 static int
 is_armored( const byte *buf )
 {
-    int ctb, pkttype;
+  int ctb, pkttype;
+  int indeterminate_length_allowed;
 
     ctb = *buf;
     if( !(ctb & 0x80) )
-       return 1; /* invalid packet: assume it is armored */
+      /* The most significant bit of the CTB must be set.  Since it is
+         cleared, this is not a binary OpenPGP message.  Assume it is
+         armored.  */
+      return 1;
+
     pkttype =  ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
     switch( pkttype ) {
-      case PKT_MARKER:
+      case PKT_PUBKEY_ENC:
+      case PKT_SIGNATURE:
       case PKT_SYMKEY_ENC:
       case PKT_ONEPASS_SIG:
-      case PKT_PUBLIC_KEY:
       case PKT_SECRET_KEY:
-      case PKT_PUBKEY_ENC:
-      case PKT_SIGNATURE:
-      case PKT_COMMENT:
-      case PKT_OLD_COMMENT:
-      case PKT_PLAINTEXT:
+      case PKT_PUBLIC_KEY:
+      case PKT_SECRET_SUBKEY:
+      case PKT_MARKER:
+      case PKT_RING_TRUST:
+      case PKT_USER_ID:
+      case PKT_PUBLIC_SUBKEY:
+      case PKT_ATTRIBUTE:
+      case PKT_MDC:
+       indeterminate_length_allowed = 0;
+        break;
+
       case PKT_COMPRESSED:
       case PKT_ENCRYPTED:
-       return 0; /* seems to be a regular packet: not armored */
+      case PKT_ENCRYPTED_MDC:
+      case PKT_PLAINTEXT:
+      case PKT_OLD_COMMENT:
+      case PKT_COMMENT:
+      case PKT_GPG_CONTROL:
+       indeterminate_length_allowed = 1;
+        break;
+
+      default:
+        /* Invalid packet type.  */
+        return 1;
     }
 
-    return 1;
+    if (! indeterminate_length_allowed)
+      /* It is only legal to use an indeterminate length with a few
+         packet types.  If a packet uses an indeterminate length, but
+         that is not allowed, then the data is not valid binary
+         OpenPGP data.  */
+      {
+        int new_format;
+        int indeterminate_length;
+
+        new_format = !! (ctb & (1 << 6));
+        if (new_format)
+          indeterminate_length = (buf[1] >= 224 && buf[1] < 255);
+        else
+          indeterminate_length = (ctb & 3) == 3;
+
+        if (indeterminate_length)
+          return 1;
+      }
+
+    /* The first CTB seems legit.  It is probably not armored
+       data.  */
+    return 0;
 }
 
 
@@ -234,7 +315,7 @@ parse_hash_header( const char *line )
        return 0; /* too short or too long */
     if( memcmp( line, "Hash:", 5 ) )
        return 0; /* invalid header */
-    s = line+5;
+
     for(s=line+5;;s=s2) {
        for(; *s && (*s==' ' || *s == '\t'); s++ )
            ;
@@ -246,14 +327,14 @@ parse_hash_header( const char *line )
            found |= 1;
        else if( !strncmp( s, "SHA1", s2-s ) )
            found |= 2;
-       else if( !strncmp( s, "MD5", s2-s ) )
-           found |= 4;
-       else if( !strncmp( s, "SHA256", s2-s ) )
+       else if( !strncmp( s, "SHA224", s2-s ) )
            found |= 8;
-       else if( !strncmp( s, "SHA384", s2-s ) )
+       else if( !strncmp( s, "SHA256", s2-s ) )
            found |= 16;
-       else if( !strncmp( s, "SHA512", s2-s ) )
+       else if( !strncmp( s, "SHA384", s2-s ) )
            found |= 32;
+       else if( !strncmp( s, "SHA512", s2-s ) )
+           found |= 64;
        else
            return 0;
        for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
@@ -266,7 +347,19 @@ parse_hash_header( const char *line )
     return found;
 }
 
+/* Returns true if this is a valid armor tag as per RFC-2440bis-21. */
+static int
+is_armor_tag(const char *line)
+{
+  if(strncmp(line,"Version",7)==0
+     || strncmp(line,"Comment",7)==0
+     || strncmp(line,"MessageID",9)==0
+     || strncmp(line,"Hash",4)==0
+     || strncmp(line,"Charset",7)==0)
+    return 1;
 
+  return 0;
+}
 
 /****************
  * Check whether this is a armor line.
@@ -291,17 +384,25 @@ is_armor_header( byte *line, unsigned len )
     save_p = p;
     p += 5;
 
-    /* Some mail programs on Windows seem to add spaces to the end of
-       the line.  This becomes strict if --openpgp is set. */
-
-    if(!RFC2440)
-      while(*p==' ')
+    /* Some Windows environments seem to add whitespace to the end of
+       the line, so we strip it here.  This becomes strict if
+       --rfc2440 is set since 2440 reads "The header lines, therefore,
+       MUST start at the beginning of a line, and MUST NOT have text
+       following them on the same line."  It is unclear whether "text"
+       refers to all text or just non-whitespace text.  4880 clarified
+       this was only non-whitespace text. */
+
+    if(RFC2440)
+      {
+       if( *p == '\r' )
+         p++;
+       if( *p == '\n' )
+         p++;
+      }
+    else
+      while(*p==' ' || *p=='\r' || *p=='\n' || *p=='\t')
        p++;
 
-    if( *p == '\r' )
-       p++;
-    if( *p == '\n' )
-       p++;
     if( *p )
        return -1; /* garbage after dashes */
     save_c = *save_p; *save_p = 0;
@@ -333,38 +434,68 @@ parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
     int hashes=0;
     unsigned int len2;
 
-    len2 = check_trailing_ws( line, len );
+    len2 = length_sans_trailing_ws ( line, len );
     if( !len2 ) {
         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
        return 0; /* WS only: same as empty line */
     }
-    len = len2;
-    line[len2] = 0;
+
+    /*
+      This is fussy.  The spec says that a header line is delimited
+      with a colon-space pair.  This means that a line such as
+      "Comment: " (with nothing else) is actually legal as an empty
+      string comment.  However, email and cut-and-paste being what it
+      is, that trailing space may go away.  Therefore, we accept empty
+      headers delimited with only a colon.  --rfc2440, as always,
+      makes this strict and enforces the colon-space pair. -dms
+    */
 
     p = strchr( line, ':');
-    if( !p || !p[1] ) {
-       log_error(_("invalid armor header: "));
-       print_string( stderr, line, len, 0 );
-       putc('\n', stderr);
+    if( !p || (RFC2440 && p[1]!=' ')
+       || (!RFC2440 && p[1]!=' ' && p[1]!='\n' && p[1]!='\r'))
+      {
+       log_error (_("invalid armor header: "));
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
        return -1;
-    }
+      }
+
+    /* Chop off the whitespace we detected before */
+    len=len2;
+    line[len2]='\0';
 
     if( opt.verbose ) {
        log_info(_("armor header: "));
-       print_string( stderr, line, len, 0 );
-       putc('\n', stderr);
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
     }
 
-    if( afx->in_cleartext ) {
+    if( afx->in_cleartext )
+      {
        if( (hashes=parse_hash_header( line )) )
-           afx->hashes |= hashes;
+         afx->hashes |= hashes;
        else if( strlen(line) > 15 && !memcmp( line, "NotDashEscaped:", 15 ) )
-           afx->not_dash_escaped = 1;
-       else {
+         afx->not_dash_escaped = 1;
+       else
+         {
            log_error(_("invalid clearsig header\n"));
            return -1;
-       }
-    }
+         }
+      }
+    else if(!is_armor_tag(line))
+      {
+       /* Section 6.2: "Unknown keys should be reported to the user,
+          but OpenPGP should continue to process the message."  Note
+          that in a clearsigned message this applies to the signature
+          part (i.e. "BEGIN PGP SIGNATURE") and not the signed data
+          ("BEGIN PGP SIGNED MESSAGE").  The only key allowed in the
+          signed data section is "Hash". */
+
+       log_info(_("unknown armor header: "));
+       es_write_sanitized (log_get_stream (), line, len, NULL, NULL);
+       log_printf ("\n");
+      }
+
     return 1;
 }
 
@@ -414,7 +545,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
            if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
                if( afx->in_cleartext ) {
                    log_error(_("nested clear text signatures\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = gpg_error (GPG_ERR_INV_ARMOR);
                }
                afx->in_cleartext = 1;
            }
@@ -430,9 +561,9 @@ check_input( armor_filter_context_t *afx, IOBUF a )
        } while( !maxlen );
     }
 
-    /* parse the header lines */
+    /* Parse the header lines.  */
     while(len) {
-       /* read the next line (skip all truncated lines) */
+       /* Read the next line (skip all truncated lines). */
        do {
            maxlen = MAX_LINELEN;
            afx->buffer_len = iobuf_read_line( a, &afx->buffer,
@@ -443,8 +574,8 @@ check_input( armor_filter_context_t *afx, IOBUF a )
 
        i = parse_header_line( afx, line, len );
        if( i <= 0 ) {
-           if( i )
-               rc = G10ERR_INVALID_ARMOR;
+           if (i && RFC2440)
+               rc = GPG_ERR_INV_ARMOR;
            break;
        }
     }
@@ -518,15 +649,64 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
        }
        if( !maxlen )
            afx->truncated++;
-       if( !afx->not_dash_escaped ) {
-           int crlf;
-           p = afx->buffer;
-           n = afx->buffer_len;
-           crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
 
-           /* PGP2 does not treat a tab as white space character */
-           afx->buffer_len = trim_trailing_chars( p, n,
-                                        afx->pgp2mode ? " \r\n" : " \t\r\n");
+       p = afx->buffer;
+       n = afx->buffer_len;
+
+       /* Armor header or dash-escaped line? */
+       if(p[0]=='-')
+         {
+           /* 2440bis-10: When reversing dash-escaping, an
+              implementation MUST strip the string "- " if it occurs
+              at the beginning of a line, and SHOULD warn on "-" and
+              any character other than a space at the beginning of a
+              line.  */
+
+           if(p[1]==' ' && !afx->not_dash_escaped)
+             {
+               /* It's a dash-escaped line, so skip over the
+                  escape. */
+               afx->buffer_pos = 2;
+             }
+           else if(p[1]=='-' && p[2]=='-' && p[3]=='-' && p[4]=='-')
+             {
+               /* Five dashes in a row mean it's probably armor
+                  header. */
+               int type = is_armor_header( p, n );
+               if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
+                 ; /* this is okay */
+               else
+                 {
+                   if( type != BEGIN_SIGNATURE )
+                     {
+                       log_info(_("unexpected armor: "));
+                       es_write_sanitized (log_get_stream (), p, n,
+                                            NULL, NULL);
+                       log_printf ("\n");
+                     }
+
+                   lastline = 1;
+                   rc = -1;
+                 }
+             }
+           else if(!afx->not_dash_escaped)
+             {
+               /* Bad dash-escaping. */
+               log_info (_("invalid dash escaped line: "));
+               es_write_sanitized (log_get_stream (), p, n, NULL, NULL);
+               log_printf ("\n");
+             }
+         }
+
+       /* Now handle the end-of-line canonicalization */
+       if( !afx->not_dash_escaped )
+         {
+           int crlf = n > 1 && p[n-2] == '\r' && p[n-1]=='\n';
+
+           afx->buffer_len=
+             trim_trailing_chars( &p[afx->buffer_pos], n-afx->buffer_pos,
+                                  " \t\r\n");
+           afx->buffer_len+=afx->buffer_pos;
            /* the buffer is always allocated with enough space to append
             * the removed [CR], LF and a Nul
             * The reason for this complicated procedure is to keep at least
@@ -538,39 +718,10 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
             * faked packet could do the job).
             */
            if( crlf )
-               afx->buffer[afx->buffer_len++] = '\r';
+             afx->buffer[afx->buffer_len++] = '\r';
            afx->buffer[afx->buffer_len++] = '\n';
-           afx->buffer[afx->buffer_len] = 0;
-       }
-       p = afx->buffer;
-       n = afx->buffer_len;
-
-       if( n > 2 && *p == '-' ) {
-           /* check for dash escaped or armor header */
-           if( p[1] == ' ' && !afx->not_dash_escaped ) {
-               /* issue a warning if it is not regular encoded */
-               if( p[2] != '-' && !( n > 6 && !memcmp(p+2, "From ", 5))) {
-                   log_info(_("invalid dash escaped line: "));
-                   print_string( stderr, p, n, 0 );
-                   putc('\n', stderr);
-               }
-               afx->buffer_pos = 2; /* skip */
-           }
-           else if( n >= 15 &&  p[1] == '-' && p[2] == '-' && p[3] == '-' ) {
-               int type = is_armor_header( p, n );
-               if( afx->not_dash_escaped && type != BEGIN_SIGNATURE )
-                   ; /* this is okay */
-               else {
-                   if( type != BEGIN_SIGNATURE ) {
-                       log_info(_("unexpected armor:"));
-                       print_string( stderr, p, n, 0 );
-                       putc('\n', stderr);
-                   }
-                   lastline = 1;
-                   rc = -1;
-               }
-           }
-       }
+           afx->buffer[afx->buffer_len] = '\0';
+         }
     }
 
     if( lastline ) { /* write last (ending) length header */
@@ -625,10 +776,10 @@ fake_packet( armor_filter_context_t *afx, IOBUF a,
 static int
 invalid_crc(void)
 {
-    if ( opt.ignore_crc_error )
-        return 0;
-    log_inc_errorcount();
-    return G10ERR_INVALID_ARMOR;
+  if ( opt.ignore_crc_error )
+    return 0;
+  log_inc_errorcount();
+  return gpg_error (GPG_ERR_INV_ARMOR);
 }
 
 
@@ -641,7 +792,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
     int checkcrc=0;
     int rc = 0;
     size_t n = 0;
-    int  idx, i;
+    int  idx, i, onlypad=0;
     u32 crc;
 
     crc = afx->crc;
@@ -686,13 +837,34 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
                }
            }
 
+            /* Occasionally a bug MTA will leave the = escaped as
+               =3D.  If the 4 characters following that are valid
+               Radix64 characters and they are following by a new
+               line, assume that this is the case and skip the
+               3D.  */
+            if (afx->buffer_pos + 6 < afx->buffer_len
+                && afx->buffer[afx->buffer_pos + 0] == '3'
+                && afx->buffer[afx->buffer_pos + 1] == 'D'
+                && asctobin[afx->buffer[afx->buffer_pos + 2]] != 255
+                && asctobin[afx->buffer[afx->buffer_pos + 3]] != 255
+                && asctobin[afx->buffer[afx->buffer_pos + 4]] != 255
+                && asctobin[afx->buffer[afx->buffer_pos + 5]] != 255
+                && afx->buffer[afx->buffer_pos + 6] == '\n')
+              {
+                afx->buffer_pos += 2;
+                afx->qp_detected = 1;
+              }
+
+           if (!n)
+             onlypad = 1;
+
            if( idx == 1 )
                buf[n++] = val;
            checkcrc++;
            break;
        }
        else if( (c = asctobin[(c2=c)]) == 255 ) {
-           log_error(_("invalid radix64 character %02x skipped\n"), c2);
+           log_error(_("invalid radix64 character %02X skipped\n"), c2);
            continue;
        }
        switch(idx) {
@@ -771,13 +943,17 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
            if( c == -1 ) {
                log_info(_("premature eof (in CRC)\n"));
                rc = invalid_crc();
-                           }
+           }
+           else if( idx == 0 ) {
+               /* No CRC at all is legal ("MAY") */
+               rc=0;
+           }
            else if( idx != 4 ) {
                log_info(_("malformed CRC\n"));
                rc = invalid_crc();
            }
            else if( mycrc != afx->crc ) {
-                log_info (_("CRC error; %06lx - %06lx\n"),
+                log_info (_("CRC error; %06lX - %06lX\n"),
                                    (ulong)afx->crc, (ulong)mycrc);
                 rc = invalid_crc();
            }
@@ -797,19 +973,19 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
                if( rc == -1 )
                    rc = 0;
                else if( rc == 2 ) {
-                   log_error(_("premature eof (in Trailer)\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   log_error(_("premature eof (in trailer)\n"));
+                   rc = GPG_ERR_INVALID_ARMOR;
                }
                else {
                    log_error(_("error in trailer line\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = GPG_ERR_INVALID_ARMOR;
                }
 #endif
            }
        }
     }
 
-    if( !n )
+    if( !n && !onlypad )
        rc = -1;
 
     *retn = n;
@@ -819,7 +995,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
 /****************
  * This filter is used to handle the armor stuff
  */
-int
+static int
 armor_filter( void *opaque, int control,
             IOBUF a, byte *buf, size_t *ret_len)
 {
@@ -862,7 +1038,7 @@ armor_filter( void *opaque, int control,
         /* We need some space for the faked packet.  The minmum
          * required size is the PARTIAL_CHUNK size plus a byte for the
          * length itself */
-       if( size < PARTIAL_CHUNK+1 ) 
+       if( size < PARTIAL_CHUNK+1 )
            BUG(); /* supplied buffer too short */
 
        if( afx->faked )
@@ -881,7 +1057,7 @@ armor_filter( void *opaque, int control,
                unsigned int hashes = afx->hashes;
                 const byte *sesmark;
                 size_t sesmarklen;
-                
+
                 sesmark = get_session_marker( &sesmarklen );
                 if ( sesmarklen > 20 )
                     BUG();
@@ -889,47 +1065,41 @@ armor_filter( void *opaque, int control,
                /* the buffer is at least 15+n*15 bytes long, so it
                 * is easy to construct the packets */
 
-               hashes &= 1|2|4|8|16|32|64;
+               hashes &= 1|2|8|16|32|64;
                if( !hashes ) {
-                   hashes |= 4;  /* default to MD 5 */
-                   /* This is non-ideal since PGP 5-8 have the same
-                      end-of-line bugs as PGP 2. However, we only
-                      enable pgp2mode if there is no Hash: header. */
-                   if( opt.pgp2_workarounds )
-                       afx->pgp2mode = 1;
+                   hashes |= 2;  /* Default to SHA-1. */
                }
                n=0;
-                /* first a gpg control packet */
+                /* First a gpg control packet... */
                 buf[n++] = 0xff; /* new format, type 63, 1 length byte */
                 n++;   /* see below */
                 memcpy(buf+n, sesmark, sesmarklen ); n+= sesmarklen;
-                buf[n++] = CTRLPKT_CLEARSIGN_START; 
+                buf[n++] = CTRLPKT_CLEARSIGN_START;
                 buf[n++] = afx->not_dash_escaped? 0:1; /* sigclass */
                 if( hashes & 1 )
                     buf[n++] = DIGEST_ALGO_RMD160;
                 if( hashes & 2 )
                     buf[n++] = DIGEST_ALGO_SHA1;
-                if( hashes & 4 )
-                    buf[n++] = DIGEST_ALGO_MD5;
                 if( hashes & 8 )
-                    buf[n++] = DIGEST_ALGO_SHA256;
+                    buf[n++] = DIGEST_ALGO_SHA224;
                 if( hashes & 16 )
-                    buf[n++] = DIGEST_ALGO_SHA384;
+                    buf[n++] = DIGEST_ALGO_SHA256;
                 if( hashes & 32 )
+                    buf[n++] = DIGEST_ALGO_SHA384;
+                if( hashes & 64 )
                     buf[n++] = DIGEST_ALGO_SHA512;
                 buf[1] = n - 2;
 
-               /* followed by an invented plaintext packet.
+               /* ...followed by an invented plaintext packet.
                   Amusingly enough, this packet is not compliant with
                   2440 as the initial partial length is less than 512
                   bytes.  Of course, we'll accept it anyway ;) */
 
                buf[n++] = 0xCB; /* new packet format, type 11 */
-               buf[n++] = 0xE3; /* 2^3 */
+               buf[n++] = 0xE1; /* 2^1 == 2 bytes */
                buf[n++] = 't';  /* canonical text mode */
-               buf[n++] = 2;    /* namelength */
-               buf[n++] = 'i';  /* padding to get us to 2^3 bytes */
-               buf[n++] = 's';  /* this comment intentionally left blank */
+               buf[n++] = 0;    /* namelength */
+               buf[n++] = 0xE2; /* 2^2 == 4 more bytes */
                memset(buf+n, 0, 4); /* timestamp */
                n += 4;
            }
@@ -948,16 +1118,34 @@ armor_filter( void *opaque, int control,
     else if( control == IOBUFCTRL_FLUSH && !afx->cancel ) {
        if( !afx->status ) { /* write the header line */
            const char *s;
-           STRLIST comment=opt.comments;
+           strlist_t comment=opt.comments;
 
            if( afx->what >= DIM(head_strings) )
                log_bug("afx->what=%d", afx->what);
            iobuf_writestr(a, "-----");
            iobuf_writestr(a, head_strings[afx->what] );
-           iobuf_writestr(a, "-----" LF );
-           if( !opt.no_version )
-               iobuf_writestr(a, "Version: GnuPG v"  VERSION " ("
-                                             PRINTABLE_OS_NAME ")" LF );
+           iobuf_writestr(a, "-----" );
+           iobuf_writestr(a,afx->eol);
+           if (opt.emit_version)
+             {
+               iobuf_writestr (a, "Version: "GNUPG_NAME" v");
+                for (s=VERSION; *s && *s != '.'; s++)
+                  iobuf_writebyte (a, *s);
+                if (opt.emit_version > 1 && *s)
+                  {
+                    iobuf_writebyte (a, *s++);
+                    for (; *s && *s != '.'; s++)
+                      iobuf_writebyte (a, *s);
+                    if (opt.emit_version > 2)
+                      {
+                        for (; *s && *s != '-' && !spacep (s); s++)
+                          iobuf_writebyte (a, *s);
+                        if (opt.emit_version > 3)
+                          iobuf_writestr (a, " (" PRINTABLE_OS_NAME ")");
+                      }
+                  }
+               iobuf_writestr(a,afx->eol);
+             }
 
            /* write the comment strings */
            for(s=comment->d;comment;comment=comment->next,s=comment->d)
@@ -974,7 +1162,8 @@ armor_filter( void *opaque, int control,
                    else
                      iobuf_put(a, *s );
                  }
-               iobuf_writestr(a, LF );
+
+               iobuf_writestr(a,afx->eol);
              }
 
            if ( afx->hdrlines ) {
@@ -986,7 +1175,8 @@ armor_filter( void *opaque, int control,
                     iobuf_put(a, *s );
                 }
             }
-           iobuf_writestr(a, LF );
+
+           iobuf_writestr(a,afx->eol);
            afx->status++;
            afx->idx = 0;
            afx->idx2 = 0;
@@ -1015,10 +1205,11 @@ armor_filter( void *opaque, int control,
                iobuf_put(a, c);
                c = bintoasc[radbuf[2]&077];
                iobuf_put(a, c);
-               if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
-                   iobuf_writestr(a, LF );
+               if( ++idx2 >= (64/4) )
+                 { /* pgp doesn't like 72 here */
+                   iobuf_writestr(a,afx->eol);
                    idx2=0;
-               }
+                 }
            }
        }
        for(i=0; i < idx; i++ )
@@ -1027,10 +1218,23 @@ armor_filter( void *opaque, int control,
        afx->idx2 = idx2;
        afx->crc  = crc;
     }
-    else if( control == IOBUFCTRL_INIT ) {
+    else if( control == IOBUFCTRL_INIT )
+      {
        if( !is_initialized )
-           initialize();
-    }
+         initialize();
+
+       /* Figure out what we're using for line endings if the caller
+          didn't specify. */
+       if(afx->eol[0]==0)
+         {
+#ifdef HAVE_DOSISH_SYSTEM
+           afx->eol[0]='\r';
+           afx->eol[1]='\n';
+#else
+           afx->eol[0]='\n';
+#endif
+         }
+      }
     else if( control == IOBUFCTRL_CANCEL ) {
        afx->cancel = 1;
     }
@@ -1041,32 +1245,32 @@ armor_filter( void *opaque, int control,
            crc = afx->crc;
            idx = afx->idx;
            idx2 = afx->idx2;
-           for(i=0; i < idx; i++ )
-               radbuf[i] = afx->radbuf[i];
            if( idx ) {
-               c = bintoasc[(*radbuf>>2)&077];
+               c = bintoasc[(afx->radbuf[0]>>2)&077];
                iobuf_put(a, c);
                if( idx == 1 ) {
-                   c = bintoasc[((*radbuf << 4) & 060) & 077];
+                   c = bintoasc[((afx->radbuf[0] << 4) & 060) & 077];
                    iobuf_put(a, c);
                    iobuf_put(a, '=');
                    iobuf_put(a, '=');
                }
                else { /* 2 */
-                   c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
+                   c = bintoasc[(((afx->radbuf[0]<<4)&060)
+                                  |((afx->radbuf[1]>>4)&017))&077];
                    iobuf_put(a, c);
-                   c = bintoasc[((radbuf[1] << 2) & 074) & 077];
+                   c = bintoasc[((afx->radbuf[1] << 2) & 074) & 077];
                    iobuf_put(a, c);
                    iobuf_put(a, '=');
                }
-               if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
-                   iobuf_writestr(a, LF );
+               if( ++idx2 >= (64/4) )
+                 { /* pgp doesn't like 72 here */
+                   iobuf_writestr(a,afx->eol);
                    idx2=0;
-               }
+                 }
            }
            /* may need a linefeed */
            if( idx2 )
-               iobuf_writestr(a, LF );
+             iobuf_writestr(a,afx->eol);
            /* write the CRC */
            iobuf_put(a, '=');
            radbuf[0] = crc >>16;
@@ -1080,13 +1284,14 @@ armor_filter( void *opaque, int control,
            iobuf_put(a, c);
            c = bintoasc[radbuf[2]&077];
            iobuf_put(a, c);
-           iobuf_writestr(a, LF );
+           iobuf_writestr(a,afx->eol);
            /* and the the trailer */
            if( afx->what >= DIM(tail_strings) )
                log_bug("afx->what=%d", afx->what);
            iobuf_writestr(a, "-----");
            iobuf_writestr(a, tail_strings[afx->what] );
-           iobuf_writestr(a, "-----" LF );
+           iobuf_writestr(a, "-----" );
+           iobuf_writestr(a,afx->eol);
        }
        else if( !afx->any_data && !afx->inp_bypass ) {
            log_error(_("no valid OpenPGP data found.\n"));
@@ -1100,11 +1305,12 @@ armor_filter( void *opaque, int control,
        if( afx->qp_detected )
            log_error(_("quoted printable character in armor - "
                        "probably a buggy MTA has been used\n") );
-       m_free( afx->buffer );
+       xfree( afx->buffer );
        afx->buffer = NULL;
+        release_armor_context (afx);
     }
     else if( control == IOBUFCTRL_DESC )
-       *(char**)buf = "armor_filter";
+        mem2str (buf, "armor_filter", *ret_len);
     return rc;
 }
 
@@ -1117,7 +1323,7 @@ make_radix64_string( const byte *data, size_t len )
 {
     char *buffer, *p;
 
-    buffer = p = m_alloc( (len+2)/3*4 + 1 );
+    buffer = p = xmalloc( (len+2)/3*4 + 1 );
     for( ; len >= 3 ; len -= 3, data += 3 ) {
        *p++ = bintoasc[(data[0] >> 2) & 077];
        *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
@@ -1140,7 +1346,7 @@ make_radix64_string( const byte *data, size_t len )
 
 /***********************************************
  *  For the pipemode command we can't use the armor filter for various
- *  reasons, so we use this new unarmor_pump stuff to remove the armor 
+ *  reasons, so we use this new unarmor_pump stuff to remove the armor
  */
 
 enum unarmor_state_e {
@@ -1148,7 +1354,7 @@ enum unarmor_state_e {
     STA_bypass,
     STA_wait_newline,
     STA_wait_dash,
-    STA_first_dash, 
+    STA_first_dash,
     STA_compare_header,
     STA_found_header_wait_newline,
     STA_skip_header_lines,
@@ -1177,22 +1383,22 @@ unarmor_pump_new (void)
 
     if( !is_initialized )
         initialize();
-    x = m_alloc_clear (sizeof *x);
+    x = xmalloc_clear (sizeof *x);
     return x;
 }
 
 void
 unarmor_pump_release (UnarmorPump x)
 {
-    m_free (x);
+    xfree (x);
 }
 
-/* 
+/*
  * Get the next character from the ascii armor taken from the IOBUF
  * created earlier by unarmor_pump_new().
  * Return:  c = Character
  *        256 = ignore this value
- *         -1 = End of current armor 
+ *         -1 = End of current armor
  *         -2 = Premature EOF (not used)
  *         -3 = Invalid armor
  */
@@ -1203,9 +1409,9 @@ unarmor_pump (UnarmorPump x, int c)
 
     switch (x->state) {
       case STA_init:
-        { 
+        {
             byte tmp[1];
-            tmp[0] = c; 
+            tmp[0] = c;
             if ( is_armored (tmp) )
                 x->state = c == '-'? STA_first_dash : STA_wait_newline;
             else {
@@ -1228,10 +1434,10 @@ unarmor_pump (UnarmorPump x, int c)
         x->state = STA_compare_header;
       case STA_compare_header:
         if ( "-----BEGIN PGP SIGNATURE-----"[++x->pos] == c ) {
-            if ( x->pos == 28 ) 
+            if ( x->pos == 28 )
                 x->state = STA_found_header_wait_newline;
         }
-        else 
+        else
             x->state = c == '\n'? STA_wait_dash : STA_wait_newline;
         break;
       case STA_found_header_wait_newline:
@@ -1274,11 +1480,11 @@ unarmor_pump (UnarmorPump x, int c)
         {
             int c2;
             if( (c = asctobin[(c2=c)]) == 255 ) {
-                log_error(_("invalid radix64 character %02x skipped\n"), c2);
+                log_error(_("invalid radix64 character %02X skipped\n"), c2);
                 break;
             }
         }
-        
+
         switch(x->pos) {
           case 0:
             x->val = c << 2;
@@ -1311,7 +1517,7 @@ unarmor_pump (UnarmorPump x, int c)
         if( (c = asctobin[c]) == 255 ) {
             rval = -1; /* ready */
             if( x->crc != x->mycrc ) {
-                log_info (_("CRC error; %06lx - %06lx\n"),
+                log_info (_("CRC error; %06lX - %06lX\n"),
                           (ulong)x->crc, (ulong)x->mycrc);
                 if ( invalid_crc() )
                     rval = -3;
@@ -1319,7 +1525,7 @@ unarmor_pump (UnarmorPump x, int c)
             x->state = STA_ready; /* not sure whether this is correct */
             break;
         }
-        
+
         switch(x->pos) {
           case 0:
             x->val = c << 2;