* options.h, getkey.c (merge_selfsigs_subkey), gpg.c (main), sig-check.c
[gnupg.git] / g10 / mainproc.c
index 5a12225..7c13921 100644 (file)
@@ -1,6 +1,6 @@
 /* mainproc.c - handle packets
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
- *               2004 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ *               2005 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -16,7 +16,8 @@
  *
  * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 #include <config.h>
@@ -94,7 +95,7 @@ release_list( CTX c )
     release_kbnode( c->list );
     while( c->pkenc_list ) {
        struct kidlist_item *tmp = c->pkenc_list->next;
-       m_free( c->pkenc_list );
+       xfree( c->pkenc_list );
        c->pkenc_list = tmp;
     }
     c->pkenc_list = NULL;
@@ -103,7 +104,7 @@ release_list( CTX c )
     c->last_was_session_key = 0;
     c->pipemode.op = 0;
     c->pipemode.stop_now = 0;
-    m_free(c->dek); c->dek = NULL;
+    xfree(c->dek); c->dek = NULL;
 }
 
 
@@ -241,41 +242,41 @@ add_signature( CTX c, PACKET *pkt )
 static int
 symkey_decrypt_seskey( DEK *dek, byte *seskey, size_t slen )
 {
-    CIPHER_HANDLE hd;
-    int n;
+  CIPHER_HANDLE hd;
 
-    if ( slen < 17 || slen > 33 ) {
-        log_error ( _("weird size for an encrypted session key (%d)\n"),
-                   (int)slen);
-        return G10ERR_BAD_KEY;
+  if(slen < 17 || slen > 33)
+    {
+      log_error ( _("weird size for an encrypted session key (%d)\n"),
+                 (int)slen);
+      return G10ERR_BAD_KEY;
     }
-    hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
-    cipher_setkey( hd, dek->key, dek->keylen );
-    cipher_setiv( hd, NULL, 0 );
-    cipher_decrypt( hd, seskey, seskey, slen );
-    cipher_close( hd );
-    /* check first byte (the cipher algo) */
-    if(check_cipher_algo(seskey[0]))
-      {
-       /* There is no way to tell the difference here between a bad
-          passphrase and a cipher algorithm that we don't have. */
-       log_error(_("bad passphrase or unknown cipher algorithm (%d)\n"),
-                 seskey[0]);
-       if(seskey[0]==CIPHER_ALGO_IDEA)
-         idea_cipher_warn(0);
-       return G10ERR_PASSPHRASE;
-      }
-    n = cipher_get_keylen (seskey[0]) / 8;
-    if (n > DIM(dek->key))
-         BUG ();
-    /* now we replace the dek components with the real session key
-       to decrypt the contents of the sequencing packet. */
-    dek->keylen = cipher_get_keylen( seskey[0] ) / 8;
-    dek->algo = seskey[0];
-    memcpy( dek->key, seskey + 1, dek->keylen );
-    /*log_hexdump( "thekey", dek->key, dek->keylen );*/
-
-    return 0;
+
+  hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
+  cipher_setkey( hd, dek->key, dek->keylen );
+  cipher_setiv( hd, NULL, 0 );
+  cipher_decrypt( hd, seskey, seskey, slen );
+  cipher_close( hd );
+
+  /* now we replace the dek components with the real session key to
+     decrypt the contents of the sequencing packet. */
+
+  dek->keylen=slen-1;
+  dek->algo=seskey[0];
+
+  if(dek->keylen > DIM(dek->key))
+    BUG ();
+
+  /* This is not completely accurate, since a bad passphrase may have
+     resulted in a garbage algorithm byte, but it's close enough since
+     a bogus byte here will fail later. */
+  if(dek->algo==CIPHER_ALGO_IDEA)
+    idea_cipher_warn(0);
+
+  memcpy(dek->key, seskey + 1, dek->keylen);
+
+  /*log_hexdump( "thekey", dek->key, dek->keylen );*/
+
+  return 0;
 }   
 
 static void
@@ -304,25 +305,49 @@ proc_symkey_enc( CTX c, PACKET *pkt )
        else
          log_error(_("encrypted with unknown algorithm %d\n"), algo );
 
+       if(check_digest_algo(enc->s2k.hash_algo))
+         {
+           log_error(_("passphrase generated with unknown digest"
+                       " algorithm %d\n"),enc->s2k.hash_algo);
+           s=NULL;
+         }
+
        c->last_was_session_key = 2;
        if(!s || opt.list_only)
          goto leave;
 
        if(opt.override_session_key)
          {
-           c->dek = m_alloc_clear( sizeof *c->dek );
+           c->dek = xmalloc_clear( sizeof *c->dek );
            if(get_override_session_key(c->dek, opt.override_session_key))
              {
-               m_free(c->dek);
+               xfree(c->dek);
                c->dek = NULL;
              }
          }
        else
          {
-           c->dek=passphrase_to_dek(NULL, 0, algo, &enc->s2k, 0, NULL, NULL);
+            int canceled;
+
+           c->dek = passphrase_to_dek (NULL, 0, algo, &enc->s2k, 0,
+                                        NULL, &canceled);
+            if (canceled)
+              {
+                /* For unknown reasons passphrase_to_dek does only
+                   return NULL if a new passphrase has been requested
+                   and has not been repeated correctly.  Thus even
+                   with a cancel requested (by means of the gpg-agent)
+                   it won't return NULL but an empty passphrase.  We
+                   take the most conservative approach for now and
+                   work around it right here. */
+                xfree (c->dek);
+                c->dek = NULL;
+              }
 
            if(c->dek)
              {
+               c->dek->symmetric=1;
+
                /* FIXME: This doesn't work perfectly if a symmetric
                   key comes before a public key in the message - if
                   the user doesn't know the passphrase, then there is
@@ -335,7 +360,7 @@ proc_symkey_enc( CTX c, PACKET *pkt )
                    if(symkey_decrypt_seskey(c->dek, enc->seskey,
                                             enc->seskeylen))
                      {
-                       m_free(c->dek);
+                       xfree(c->dek);
                        c->dek=NULL;
                      }
                  }
@@ -376,10 +401,10 @@ proc_pubkey_enc( CTX c, PACKET *pkt )
        /* It does not make much sense to store the session key in
         * secure memory because it has already been passed on the
         * command line and the GCHQ knows about it */
-       c->dek = m_alloc_clear( sizeof *c->dek );
+       c->dek = xmalloc_clear( sizeof *c->dek );
        result = get_override_session_key ( c->dek, opt.override_session_key );
        if ( result ) {
-           m_free(c->dek); c->dek = NULL;
+           xfree(c->dek); c->dek = NULL;
        }
     }
     else if( is_ELGAMAL(enc->pubkey_algo)
@@ -391,10 +416,10 @@ proc_pubkey_enc( CTX c, PACKET *pkt )
            if( opt.list_only )
                result = -1;
            else {
-               c->dek = m_alloc_secure_clear( sizeof *c->dek );
+               c->dek = xmalloc_secure_clear( sizeof *c->dek );
                if( (result = get_session_key( enc, c->dek )) ) {
                    /* error: delete the DEK */
-                   m_free(c->dek); c->dek = NULL;
+                   xfree(c->dek); c->dek = NULL;
                }
            }
        }
@@ -409,7 +434,7 @@ proc_pubkey_enc( CTX c, PACKET *pkt )
     else
       {
         /* store it for later display */
-       struct kidlist_item *x = m_alloc( sizeof *x );
+       struct kidlist_item *x = xmalloc( sizeof *x );
        x->kid[0] = enc->keyid[0];
        x->kid[1] = enc->keyid[1];
        x->pubkey_algo = enc->pubkey_algo;
@@ -443,23 +468,20 @@ print_pkenc_list( struct kidlist_item *list, int failed )
             continue;
 
         algstr = pubkey_algo_to_string( list->pubkey_algo );
-        pk = m_alloc_clear( sizeof *pk );
+        pk = xmalloc_clear( sizeof *pk );
 
        if( !algstr )
            algstr = "[?]";
        pk->pubkey_algo = list->pubkey_algo;
        if( !get_pubkey( pk, list->kid ) )
          {
-           size_t n;
            char *p;
            log_info( _("encrypted with %u-bit %s key, ID %s, created %s\n"),
                      nbits_from_pk( pk ), algstr, keystr_from_pk(pk),
                      strtimestamp(pk->timestamp) );
-           fputs("      \"", log_stream() );
-           p = get_user_id( list->kid, &n );
-           print_utf8_string2 ( log_stream(), p, n, '"' );
-           m_free(p);
-           fputs("\"\n", log_stream() );
+           p=get_user_id_native(list->kid);
+           fprintf(log_stream(),_("      \"%s\"\n"),p);
+           xfree(p);
          }
        else
          log_info(_("encrypted with %s key, ID %s\n"),
@@ -508,11 +530,11 @@ proc_encrypted( CTX c, PACKET *pkt )
 
        if(opt.override_session_key)
          {
-           c->dek = m_alloc_clear( sizeof *c->dek );
+           c->dek = xmalloc_clear( sizeof *c->dek );
            result=get_override_session_key(c->dek, opt.override_session_key);
            if(result)
              {
-               m_free(c->dek);
+               xfree(c->dek);
                c->dek = NULL;
              }
          }
@@ -568,11 +590,11 @@ proc_encrypted( CTX c, PACKET *pkt )
        if(opt.show_session_key)
          {
            int i;
-           char *buf = m_alloc ( c->dek->keylen*2 + 20 );
+           char *buf = xmalloc ( c->dek->keylen*2 + 20 );
            sprintf ( buf, "%d:", c->dek->algo );
            for(i=0; i < c->dek->keylen; i++ )
              sprintf(buf+strlen(buf), "%02X", c->dek->key[i] );
-           log_info( "session key: \"%s\"\n", buf );
+           log_info( "session key: `%s'\n", buf );
            write_status_text ( STATUS_SESSION_KEY, buf );
          }
     }
@@ -587,14 +609,13 @@ proc_encrypted( CTX c, PACKET *pkt )
        /* Hmmm: does this work when we have encrypted using multiple
         * ways to specify the session key (symmmetric and PK)*/
     }
-    m_free(c->dek); c->dek = NULL;
+    xfree(c->dek); c->dek = NULL;
     free_packet(pkt);
     c->last_was_session_key = 0;
     write_status( STATUS_END_DECRYPTION );
 }
 
 
-
 static void
 proc_plaintext( CTX c, PACKET *pkt )
 {
@@ -615,45 +636,62 @@ proc_plaintext( CTX c, PACKET *pkt )
      * See: Russ Allbery's mail 1999-02-09
      */
     any = clearsig = only_md5 = 0;
-    for(n=c->list; n; n = n->next ) {
-       if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
-           if( n->pkt->pkt.onepass_sig->digest_algo ) {
+    for(n=c->list; n; n = n->next )
+      {
+       if( n->pkt->pkttype == PKT_ONEPASS_SIG )
+         {
+           /* For the onepass signature case */
+           if( n->pkt->pkt.onepass_sig->digest_algo )
+             {
                md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
                if( !any && n->pkt->pkt.onepass_sig->digest_algo
-                                                     == DIGEST_ALGO_MD5 )
-                   only_md5 = 1;
+                   == DIGEST_ALGO_MD5 )
+                 only_md5 = 1;
                else
-                   only_md5 = 0;
+                 only_md5 = 0;
                any = 1;
-           }
+             }
            if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
-               only_md5 = 0;
-       }
+             only_md5 = 0;
+         }
        else if( n->pkt->pkttype == PKT_GPG_CONTROL
                  && n->pkt->pkt.gpg_control->control
-                    == CTRLPKT_CLEARSIGN_START ) {
+                == CTRLPKT_CLEARSIGN_START )
+         {
+           /* For the clearsigned message case */
             size_t datalen = n->pkt->pkt.gpg_control->datalen;
             const byte *data = n->pkt->pkt.gpg_control->data;
 
             /* check that we have at least the sigclass and one hash */
             if ( datalen < 2 )
-                log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n"); 
+             log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n"); 
             /* Note that we don't set the clearsig flag for not-dash-escaped
              * documents */
             clearsig = (*data == 0x01);
             for( data++, datalen--; datalen; datalen--, data++ )
-                md_enable( c->mfx.md, *data );
+             md_enable( c->mfx.md, *data );
             any = 1;
-            break;  /* no pass signature pakets are expected */
-        }
-    }
+            break;  /* no pass signature packets are expected */
+         }
+       else if(n->pkt->pkttype==PKT_SIGNATURE)
+         {
+           /* For the SIG+LITERAL case that PGP used to use. */
+           md_enable( c->mfx.md, n->pkt->pkt.signature->digest_algo );
+           any=1;
+         }
+      }
 
-    if( !any && !opt.skip_verify ) {
-       /* no onepass sig packet: enable all standard algos */
+    if( !any && !opt.skip_verify )
+      {
+       /* This is for the old GPG LITERAL+SIG case.  It's not legal
+          according to 2440, so hopefully it won't come up that
+          often.  There is no good way to specify what algorithms to
+          use in that case, so these three are the historical
+          answer. */
        md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
        md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
        md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
-    }
+      }
     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
        /* This is a kludge to work around a bug in pgp2.  It does only
         * catch those mails which are armored.  To catch the non-armored
@@ -920,9 +958,17 @@ list_node( CTX c, KBNODE node )
          {
            /* of subkey */
            if( pk->is_revoked )
-             printf(" %s",_("[revoked] "));
+             {
+               printf(" [");
+               printf(_("revoked: %s"),revokestr_from_pk(pk));
+               printf("]");
+             }
            else if( pk->expiredate )
-             printf(_(" [expires: %s]"), expirestr_from_pk( pk ) );
+             {
+               printf(" [");
+               printf(_("expires: %s"),expirestr_from_pk(pk));
+               printf("]");
+             }
          }
 
        if( !any )
@@ -1068,7 +1114,7 @@ list_node( CTX c, KBNODE node )
        else if( !opt.fast_list_mode ) {
            p = get_user_id( sig->keyid, &n );
            print_string( stdout, p, n, opt.with_colons );
-           m_free(p);
+           xfree(p);
        }
        if( opt.with_colons )
            printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
@@ -1084,11 +1130,11 @@ int
 proc_packets( void *anchor, IOBUF a )
 {
     int rc;
-    CTX c = m_alloc_clear( sizeof *c );
+    CTX c = xmalloc_clear( sizeof *c );
 
     c->anchor = anchor;
     rc = do_proc_packets( c, a );
-    m_free( c );
+    xfree( c );
     return rc;
 }
 
@@ -1098,7 +1144,7 @@ int
 proc_signature_packets( void *anchor, IOBUF a,
                        STRLIST signedfiles, const char *sigfilename )
 {
-    CTX c = m_alloc_clear( sizeof *c );
+    CTX c = xmalloc_clear( sizeof *c );
     int rc;
 
     c->anchor = anchor;
@@ -1106,20 +1152,20 @@ proc_signature_packets( void *anchor, IOBUF a,
     c->signed_data = signedfiles;
     c->sigfilename = sigfilename;
     rc = do_proc_packets( c, a );
-    m_free( c );
+    xfree( c );
     return rc;
 }
 
 int
 proc_encryption_packets( void *anchor, IOBUF a )
 {
-    CTX c = m_alloc_clear( sizeof *c );
+    CTX c = xmalloc_clear( sizeof *c );
     int rc;
 
     c->anchor = anchor;
     c->encrypt_only = 1;
     rc = do_proc_packets( c, a );
-    m_free( c );
+    xfree( c );
     return rc;
 }
 
@@ -1127,7 +1173,7 @@ proc_encryption_packets( void *anchor, IOBUF a )
 int
 do_proc_packets( CTX c, IOBUF a )
 {
-    PACKET *pkt = m_alloc( sizeof *pkt );
+    PACKET *pkt = xmalloc( sizeof *pkt );
     int rc=0;
     int any_data=0;
     int newpkt;
@@ -1139,7 +1185,7 @@ do_proc_packets( CTX c, IOBUF a )
        if( rc ) {
            free_packet(pkt);
             /* stop processing when an invalid packet has been encountered
-             * but don't do so when we are doing a --list-packet. */
+             * but don't do so when we are doing a --list-packets. */
            if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
                break;
            continue;
@@ -1235,7 +1281,7 @@ do_proc_packets( CTX c, IOBUF a )
        if( newpkt == -1 )
            ;
        else if( newpkt ) {
-           pkt = m_alloc( sizeof *pkt );
+           pkt = xmalloc( sizeof *pkt );
            init_packet(pkt);
        }
        else
@@ -1257,14 +1303,94 @@ do_proc_packets( CTX c, IOBUF a )
 
   leave:
     release_list( c );
-    m_free(c->dek);
+    xfree(c->dek);
     free_packet( pkt );
-    m_free( pkt );
+    xfree( pkt );
     free_md_filter_context( &c->mfx );
     return rc;
 }
 
 
+/* Helper for pka_uri_from_sig to parse the to-be-verified address out
+   of the notation data. */
+static pka_info_t *
+get_pka_address (PKT_signature *sig)
+{
+  const unsigned char *p;
+  size_t len, n1, n2;
+  int seq = 0;
+  pka_info_t *pka = NULL;
+
+  while ((p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION,
+                               &len, &seq, NULL)))
+    {
+      if (len < 8)
+        continue; /* Notation packet is too short. */
+      n1 = (p[4]<<8)|p[5];
+      n2 = (p[6]<<8)|p[7];
+      if (8 + n1 + n2 != len)
+        continue; /* Length fields of notation packet are inconsistent. */
+      p += 8;
+      if (n1 != 21 || memcmp (p, "pka-address@gnupg.org", 21))
+        continue; /* Not the notation we want. */
+      p += n1;
+      if (n2 < 3)
+        continue; /* Impossible email address. */
+
+      if (pka)
+        break; /* For now we only use the first valid PKA notation. In
+                  future we might want to keep additional PKA
+                  notations in a linked list. */
+
+      pka = xmalloc (sizeof *pka + n2);
+      pka->valid = 0;
+      pka->checked = 0;
+      pka->uri = NULL;
+      memcpy (pka->email, p, n2);
+      pka->email[n2] = 0;
+
+      if (!is_valid_mailbox (pka->email))
+        {
+          /* We don't accept invalid mail addresses. */
+          xfree (pka);
+          pka = NULL;
+        }
+    }
+
+  return pka;
+}
+
+
+/* Return the URI from a DNS PKA record.  If this record has already
+   be retrieved for the signature we merely return it; if not we go
+   out and try to get that DNS record. */
+static const char *
+pka_uri_from_sig (PKT_signature *sig)
+{
+  if (!sig->flags.pka_tried)
+    {
+      assert (!sig->pka_info);
+      sig->flags.pka_tried = 1;
+      sig->pka_info = get_pka_address (sig);
+      if (sig->pka_info)
+        {
+          char *uri;
+
+          uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
+          if (uri)
+            {
+              sig->pka_info->valid = 1;
+              if (!*uri)
+                xfree (uri);
+              else
+                sig->pka_info->uri = uri;
+            }
+        }
+    }
+  return sig->pka_info? sig->pka_info->uri : NULL;
+}
+
+
 static int
 check_sig_and_print( CTX c, KBNODE node )
 {
@@ -1345,15 +1471,8 @@ check_sig_and_print( CTX c, KBNODE node )
               keystr(sig->keyid));
 
     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
-    if( rc == G10ERR_NO_PUBKEY && opt.keyserver
-       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
-      {
-       if( keyserver_import_keyid ( sig->keyid )==0 )
-         rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
-      }
 
-    /* If the key still isn't found, try to inform the user where it
-       can be found. */
+    /* If the key isn't found, check for a preferred keyserver */
 
     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
       {
@@ -1368,11 +1487,77 @@ check_sig_and_print( CTX c, KBNODE node )
               page, but "from" if it is located on a keyserver.  I'm
               not going to even try to make two strings here :) */
            log_info(_("Key available at: ") );
-           print_string( log_stream(), p, n, 0 );
+           print_utf8_string( log_stream(), p, n );
            putc( '\n', log_stream() );
+
+           if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
+              && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
+             {
+               struct keyserver_spec *spec;
+
+               spec=parse_preferred_keyserver(sig);
+               if(spec)
+                 {
+                   int res;
+
+                   glo_ctrl.in_auto_key_retrieve++;
+                   res=keyserver_import_keyid(sig->keyid,spec);
+                   glo_ctrl.in_auto_key_retrieve--;
+                   if(!res)
+                     rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
+                   free_keyserver_spec(spec);
+
+                   if(!rc)
+                     break;
+                 }
+             }
          }
       }
 
+
+    /* If the preferred keyserver thing above didn't work, our second
+       try is to use the URI from a DNS PKA record. */
+    if ( rc == G10ERR_NO_PUBKEY 
+         && (opt.keyserver_options.options&KEYSERVER_AUTO_PKA_RETRIEVE))
+      {
+        const char *uri = pka_uri_from_sig (sig);
+        
+        if (uri)
+          {
+            /* FIXME: We might want to locate the key using the
+               fingerprint instead of the keyid. */
+            int res;
+            struct keyserver_spec *spec;
+            
+            spec = parse_keyserver_uri (uri, 0, NULL, 0);
+            if (spec)
+              {
+                glo_ctrl.in_auto_key_retrieve++;
+                res = keyserver_import_keyid (sig->keyid, spec);
+                glo_ctrl.in_auto_key_retrieve--;
+                free_keyserver_spec (spec);
+                if (!res)
+                  rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
+              }
+          }
+      }
+
+
+    /* If the preferred keyserver thing above didn't work and we got
+       no information from the DNS PKA, this is a third try. */
+
+    if( rc == G10ERR_NO_PUBKEY && opt.keyserver
+       && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
+      {
+       int res;
+
+       glo_ctrl.in_auto_key_retrieve++;
+       res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
+       glo_ctrl.in_auto_key_retrieve--;
+       if(!res)
+         rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
+      }
+
     if( !rc || rc == G10ERR_BAD_SIGN ) {
        KBNODE un, keyblock;
        int count=0, statno;
@@ -1397,6 +1582,7 @@ check_sig_and_print( CTX c, KBNODE node )
 
         /* find and print the primary user ID */
        for( un=keyblock; un; un = un->next ) {
+           char *p;
            int valid;
            if(un->pkt->pkttype==PKT_PUBLIC_KEY)
              {
@@ -1430,19 +1616,28 @@ check_sig_and_print( CTX c, KBNODE node )
                                           un->pkt->pkt.user_id->len, 
                                           -1 );
 
-            log_info(rc? _("BAD signature from \"")
-                       : sig->flags.expired ? _("Expired signature from \"")
-                      : _("Good signature from \""));
-           print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
-                                            un->pkt->pkt.user_id->len );
-           if(opt.verify_options&VERIFY_SHOW_VALIDITY)
-             fprintf(log_stream(),"\" [%s]\n",trust_value_to_string(valid));
+           p=utf8_to_native(un->pkt->pkt.user_id->name,
+                            un->pkt->pkt.user_id->len,0);
+
+           if(rc)
+             log_info(_("BAD signature from \"%s\""),p);
+           else if(sig->flags.expired)
+             log_info(_("Expired signature from \"%s\""),p);
+           else
+             log_info(_("Good signature from \"%s\""),p);
+
+           xfree(p);
+
+           if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
+             fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
            else
-             fputs("\"\n", log_stream() );
+             fputs("\n", log_stream() );
             count++;
        }
        if( !count ) {  /* just in case that we have no valid textual
                            userid */
+           char *p;
+
            /* Try for an invalid textual userid */
             for( un=keyblock; un; un = un->next ) {
                 if( un->pkt->pkttype == PKT_USER_ID &&
@@ -1466,22 +1661,30 @@ check_sig_and_print( CTX c, KBNODE node )
                                           un? un->pkt->pkt.user_id->len:3, 
                                           -1 );
 
-            log_info(rc? _("BAD signature from \"")
-                       : sig->flags.expired ? _("Expired signature from \"")
-                      : _("Good signature from \""));
-            if (opt.trust_model!=TM_ALWAYS && un) {
-                fputs(_("[uncertain]"), log_stream() );
+           if(un)
+             p=utf8_to_native(un->pkt->pkt.user_id->name,
+                               un->pkt->pkt.user_id->len,0);
+           else
+             p=xstrdup("[?]");
+
+           if(rc)
+             log_info(_("BAD signature from \"%s\""),p);
+           else if(sig->flags.expired)
+             log_info(_("Expired signature from \"%s\""),p);
+           else
+             log_info(_("Good signature from \"%s\""),p);
+            if (opt.trust_model!=TM_ALWAYS && un)
+             {
                 putc(' ', log_stream() );
-            }
-            print_utf8_string( log_stream(),
-                               un? un->pkt->pkt.user_id->name:"[?]",
-                               un? un->pkt->pkt.user_id->len:3 );
-           fputs("\"\n", log_stream() );
+                fputs(_("[uncertain]"), log_stream() );
+             }
+           fputs("\n", log_stream() );
        }
 
         /* If we have a good signature and already printed 
          * the primary user ID, print all the other user IDs */
         if ( count && !rc ) {
+           char *p;
             for( un=keyblock; un; un = un->next ) {
                 if( un->pkt->pkttype != PKT_USER_ID )
                     continue;
@@ -1503,11 +1706,12 @@ check_sig_and_print( CTX c, KBNODE node )
                                  un->pkt->pkt.user_id->numattribs,pk,NULL);
                  }
 
-               log_info(    _("                aka \""));
-                print_utf8_string( log_stream(), un->pkt->pkt.user_id->name,
-                                                 un->pkt->pkt.user_id->len );
+               p=utf8_to_native(un->pkt->pkt.user_id->name,
+                                un->pkt->pkt.user_id->len,0);
+               log_info(_("                aka \"%s\""),p);
+               xfree(p);
 
-               if(opt.verify_options&VERIFY_SHOW_VALIDITY)
+               if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
                  {
                    const char *valid;
                    if(un->pkt->pkt.user_id->is_revoked)
@@ -1518,10 +1722,10 @@ check_sig_and_print( CTX c, KBNODE node )
                      valid=trust_value_to_string(get_validity(pk,
                                                               un->pkt->
                                                               pkt.user_id));
-                   fprintf(log_stream(),"\" [%s]\n",valid);
+                   fprintf(log_stream()," [%s]\n",valid);
                  }
                else
-                 fputs("\"\n", log_stream() );
+                 fputs("\n", log_stream() );
             }
        }
        release_kbnode( keyblock );
@@ -1539,14 +1743,16 @@ check_sig_and_print( CTX c, KBNODE node )
              show_keyserver_url(sig,0,2);
 
            if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
-             show_notation(sig,0,1,0);
+             show_notation(sig,0,1,
+                       ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
+                       ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
            else
              show_notation(sig,0,2,0);
          }
 
        if( !rc && is_status_enabled() ) {
            /* print a status response with the fingerprint */
-           PKT_public_key *vpk = m_alloc_clear( sizeof *vpk );
+           PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
 
            if( !get_pubkey( vpk, sig->keyid ) ) {
                byte array[MAX_FINGERPRINT_LEN], *p;
@@ -1574,7 +1780,7 @@ check_sig_and_print( CTX c, KBNODE node )
                    akid[0] = vpk->main_keyid[0];
                    akid[1] = vpk->main_keyid[1];
                    free_public_key (vpk);
-                   vpk = m_alloc_clear( sizeof *vpk );
+                   vpk = xmalloc_clear( sizeof *vpk );
                    if (get_pubkey (vpk, akid)) {
                      /* impossible error, we simply return a zeroed out fpr */
                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
@@ -1591,8 +1797,11 @@ check_sig_and_print( CTX c, KBNODE node )
            free_public_key( vpk );
        }
 
-       if( !rc )
+       if (!rc)
+          {
+            pka_uri_from_sig (sig); /* Make sure PKA info is available. */
            rc = check_signatures_trust( sig );
+          }
 
        if(sig->flags.expired)
          {