Adjust for changed macro names in libgpg-error master.
[gnupg.git] / g10 / misc.c
index 76faa49..9016d27 100644 (file)
@@ -16,7 +16,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, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 
 #include "gpg.h"
 #ifdef HAVE_W32_SYSTEM
-# include "status.h"
+# include "../common/status.h"
 #endif /*HAVE_W32_SYSTEM*/
-#include "util.h"
+#include "../common/util.h"
 #include "main.h"
 #include "photoid.h"
 #include "options.h"
 #include "call-agent.h"
-#include "i18n.h"
-
-#include <assert.h>
-
-static int
-string_count_chr (const char *string, int c)
-{
-  int count;
-
-  for (count=0; *string; string++ )
-    if ( *string == c )
-      count++;
-  return count;
-}
-
+#include "../common/i18n.h"
+#include "../common/zb32.h"
 
 
 #ifdef ENABLE_SELINUX_HACKS
@@ -109,7 +96,7 @@ register_secured_file (const char *fname)
   struct stat buf;
   struct secured_file_item *sf;
 
-  /* Note that we stop immediatley if something goes wrong here. */
+  /* Note that we stop immediately if something goes wrong here. */
   if (stat (fname, &buf))
     log_fatal (_("fstat of '%s' failed in %s: %s\n"), fname,
                "register_secured_file", strerror (errno));
@@ -278,16 +265,6 @@ checksum_mpi (gcry_mpi_t a)
   return csum;
 }
 
-u32
-buffer_to_u32( const byte *buffer )
-{
-    unsigned long a;
-    a =  *buffer << 24;
-    a |= buffer[1] << 16;
-    a |= buffer[2] << 8;
-    a |= buffer[3];
-    return a;
-}
 
 void
 print_pubkey_algo_note (pubkey_algo_t algo)
@@ -298,12 +275,14 @@ print_pubkey_algo_note (pubkey_algo_t algo)
       if(!warn)
        {
          warn=1;
+          es_fflush (es_stdout);
          log_info (_("WARNING: using experimental public key algorithm %s\n"),
                    openpgp_pk_algo_name (algo));
        }
     }
   else if (algo == PUBKEY_ALGO_ELGAMAL)
     {
+      es_fflush (es_stdout);
       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
     }
 }
@@ -317,6 +296,7 @@ print_cipher_algo_note (cipher_algo_t algo)
       if(!warn)
        {
          warn=1;
+          es_fflush (es_stdout);
          log_info (_("WARNING: using experimental cipher algorithm %s\n"),
                     openpgp_cipher_algo_name (algo));
        }
@@ -326,37 +306,102 @@ print_cipher_algo_note (cipher_algo_t algo)
 void
 print_digest_algo_note (digest_algo_t algo)
 {
+  const enum gcry_md_algos galgo = map_md_openpgp_to_gcry (algo);
+  const struct weakhash *weak;
+
   if(algo >= 100 && algo <= 110)
     {
       static int warn=0;
       if(!warn)
        {
          warn=1;
+          es_fflush (es_stdout);
          log_info (_("WARNING: using experimental digest algorithm %s\n"),
-                    gcry_md_algo_name (algo));
+                    gcry_md_algo_name (galgo));
        }
     }
-  else if(algo==DIGEST_ALGO_MD5)
-    log_info (_("WARNING: digest algorithm %s is deprecated\n"),
-              gcry_md_algo_name (algo));
+  else
+      for (weak = opt.weak_digests; weak != NULL; weak = weak->next)
+        if (weak->algo == galgo)
+          {
+            es_fflush (es_stdout);
+            log_info (_("WARNING: digest algorithm %s is deprecated\n"),
+                      gcry_md_algo_name (galgo));
+          }
 }
 
 
 void
-print_md5_rejected_note (void)
+print_digest_rejected_note (enum gcry_md_algos algo)
 {
-  static int shown;
-
-  if (!shown)
+  struct weakhash* weak;
+  int show = 1;
+  for (weak = opt.weak_digests; weak; weak = weak->next)
+    if (weak->algo == algo)
+      {
+        if (weak->rejection_shown)
+          show = 0;
+        else
+          weak->rejection_shown = 1;
+        break;
+      }
+
+  if (show)
     {
+      es_fflush (es_stdout);
       log_info
         (_("Note: signatures using the %s algorithm are rejected\n"),
-         "MD5");
-      shown = 1;
+         gcry_md_algo_name(algo));
     }
 }
 
 
+/* Print a message
+ *  "(reported error: %s)\n
+ * in verbose mode to further explain an error.  If the error code has
+ * the value IGNORE_EC no message is printed.  A message is also not
+ * printed if ERR is 0.  */
+void
+print_reported_error (gpg_error_t err, gpg_err_code_t ignore_ec)
+{
+  if (!opt.verbose)
+    return;
+
+  if (!gpg_err_code (err))
+    ;
+  else if (gpg_err_code (err) == ignore_ec)
+    ;
+  else if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
+    log_info (_("(reported error: %s)\n"),
+              gpg_strerror (err));
+  else
+    log_info (_("(reported error: %s <%s>)\n"),
+              gpg_strerror (err), gpg_strsource (err));
+
+}
+
+
+/* Print a message
+ *   "(further info: %s)\n
+ * in verbose mode to further explain an error.  That message is
+ * intended to help debug a problem and should not be translated.
+ */
+void
+print_further_info (const char *format, ...)
+{
+  va_list arg_ptr;
+
+  if (!opt.verbose)
+    return;
+
+  log_info (_("(further info: "));
+  va_start (arg_ptr, format);
+  log_logv (GPGRT_LOGLVL_CONT, format, arg_ptr);
+  va_end (arg_ptr);
+  log_printf (")\n");
+}
+
+
 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
    this for algorithms we implemented in Libgcrypt after they become
    part of OpenPGP.  */
@@ -428,8 +473,8 @@ map_cipher_openpgp_to_gcry (cipher_algo_t algo)
 #else
     case CIPHER_ALGO_CAMELLIA256: return 0;
 #endif
+    default: return 0;
     }
-  return 0;
 }
 
 /* The inverse function of above.  */
@@ -464,7 +509,7 @@ map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
     {
     case GCRY_PK_ECDSA:  return PUBKEY_ALGO_ECDSA;
     case GCRY_PK_ECDH:   return PUBKEY_ALGO_ECDH;
-    default: return algo < 110 ? algo : 0;
+    default: return algo < 110 ? (pubkey_algo_t)algo : 0;
     }
 }
 
@@ -477,7 +522,7 @@ openpgp_cipher_blocklen (cipher_algo_t algo)
      block length.  This is so that the packet parsing code works even
      for unknown algorithms (for which we assume 8 due to tradition).
 
-     NOTE: If you change the the returned blocklen above 16, check
+     NOTE: If you change the returned blocklen above 16, check
      the callers because they may use a fixed size buffer of that
      size. */
   switch (algo)
@@ -497,7 +542,7 @@ openpgp_cipher_blocklen (cipher_algo_t algo)
 }
 
 /****************
- * Wrapper around the libgcrypt function with additonal checks on
+ * Wrapper around the libgcrypt function with additional checks on
  * the OpenPGP contraints for the algo ID.
  */
 int
@@ -520,7 +565,6 @@ openpgp_cipher_algo_name (cipher_algo_t algo)
 {
   switch (algo)
     {
-    case CIPHER_ALGO_NONE:        break;
     case CIPHER_ALGO_IDEA:        return "IDEA";
     case CIPHER_ALGO_3DES:       return "3DES";
     case CIPHER_ALGO_CAST5:      return "CAST5";
@@ -532,8 +576,9 @@ openpgp_cipher_algo_name (cipher_algo_t algo)
     case CIPHER_ALGO_CAMELLIA128: return "CAMELLIA128";
     case CIPHER_ALGO_CAMELLIA192: return "CAMELLIA192";
     case CIPHER_ALGO_CAMELLIA256: return "CAMELLIA256";
+    case CIPHER_ALGO_NONE:
+    default: return "?";
     }
-  return "?";
 }
 
 
@@ -591,11 +636,14 @@ openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
       if (RFC2440)
         ga = GCRY_PK_ELG;
       break;
+
+    default:
+      break;
     }
   if (!ga)
     return gpg_error (GPG_ERR_PUBKEY_ALGO);
 
-  /* No check whether Libgcrypt has support for the algorithm.  */
+  /* Now check whether Libgcrypt has support for the algorithm.  */
   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
 }
 
@@ -654,8 +702,8 @@ openpgp_pk_algo_name (pubkey_algo_t algo)
     case PUBKEY_ALGO_ECDH:      return "ECDH";
     case PUBKEY_ALGO_ECDSA:     return "ECDSA";
     case PUBKEY_ALGO_EDDSA:     return "EDDSA";
+    default: return "?";
     }
-  return "?";
 }
 
 
@@ -686,11 +734,7 @@ map_md_openpgp_to_gcry (digest_algo_t algo)
     case DIGEST_ALGO_SHA224: return 0;
 #endif
 
-#ifdef GPG_USE_SHA256
     case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
-#else
-    case DIGEST_ALGO_SHA256: return 0;
-#endif
 
 #ifdef GPG_USE_SHA384
     case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
@@ -703,8 +747,8 @@ map_md_openpgp_to_gcry (digest_algo_t algo)
 #else
     case DIGEST_ALGO_SHA512: return 0;
 #endif
+    default: return 0;
     }
-  return 0;
 }
 
 
@@ -863,23 +907,25 @@ pct_expando(const char *string,struct expando_args *args)
                }
              break;
 
-           case 'p': /* primary pk fingerprint of a sk */
-           case 'f': /* pk fingerprint */
-           case 'g': /* sk fingerprint */
+           case 'f': /* Fingerprint of key being signed */
+           case 'p': /* Fingerprint of the primary key making the signature. */
+           case 'g': /* Fingerprint of the key making the signature.  */
              {
                byte array[MAX_FINGERPRINT_LEN];
                size_t len;
                int i;
 
-               if((*(ch+1))=='p' && args->pksk)
+               if ((*(ch+1))=='f' && args->pk)
+                 fingerprint_from_pk (args->pk, array, &len);
+               else if ((*(ch+1))=='p' && args->pksk)
                  {
                    if(args->pksk->flags.primary)
                      fingerprint_from_pk (args->pksk, array, &len);
                    else if (args->pksk->main_keyid[0]
                              || args->pksk->main_keyid[1])
                      {
-                        /* FIXME: Document teh code and check whether
-                           it is still needed.  */
+                        /* Not the primary key: Find the fingerprint
+                           of the primary key.  */
                        PKT_public_key *pk=
                          xmalloc_clear(sizeof(PKT_public_key));
 
@@ -889,11 +935,9 @@ pct_expando(const char *string,struct expando_args *args)
                          memset (array, 0, (len=MAX_FINGERPRINT_LEN));
                        free_public_key (pk);
                      }
-                   else
+                   else /* Oops: info about the primary key missing.  */
                      memset(array,0,(len=MAX_FINGERPRINT_LEN));
                  }
-               else if((*(ch+1))=='f' && args->pk)
-                 fingerprint_from_pk (args->pk, array, &len);
                else if((*(ch+1))=='g' && args->pksk)
                  fingerprint_from_pk (args->pksk, array, &len);
                else
@@ -1031,19 +1075,6 @@ deprecated_command (const char *name)
 
 
 void
-obsolete_option (const char *configname, unsigned int configlineno,
-                 const char *name)
-{
-  if(configname)
-    log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
-              configname, configlineno, name);
-  else
-    log_info (_("WARNING: \"%s%s\" is an obsolete option - it has no effect\n"),
-              "--", name);
-}
-
-
-void
 obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
                           const char *name)
 {
@@ -1090,7 +1121,7 @@ string_to_digest_algo (const char *string)
 {
   int val;
 
-  /* FIXME: We should make use of our wrapper fucntion and not assume
+  /* FIXME: We should make use of our wrapper function and not assume
      that there is a 1 to 1 mapping between OpenPGP and Libgcrypt.  */
   val = gcry_md_map_name (string);
   if (!val && string && (string[0]=='H' || string[0]=='h'))
@@ -1182,7 +1213,7 @@ check_compress_algo(int algo)
 #ifdef HAVE_BZIP2
     case 3: return 0;
 #endif
-    default: return G10ERR_COMPR_ALGO;
+    default: return GPG_ERR_COMPR_ALGO;
     }
 }
 
@@ -1211,23 +1242,6 @@ default_compress_algo(void)
     return DEFAULT_COMPRESS_ALGO;
 }
 
-const char *
-compliance_option_string(void)
-{
-  char *ver="???";
-
-  switch(opt.compliance)
-    {
-    case CO_GNUPG:   return "--gnupg";
-    case CO_RFC4880: return "--openpgp";
-    case CO_RFC2440: return "--rfc2440";
-    case CO_PGP6:    return "--pgp6";
-    case CO_PGP7:    return "--pgp7";
-    case CO_PGP8:    return "--pgp8";
-    }
-
-  return ver;
-}
 
 void
 compliance_failure(void)
@@ -1259,6 +1273,10 @@ compliance_failure(void)
     case CO_PGP8:
       ver="PGP 8.x";
       break;
+
+    case CO_DE_VS:
+      ver="DE-VS applications";
+      break;
     }
 
   log_info(_("this message may not be usable by %s\n"),ver);
@@ -1400,8 +1418,8 @@ parse_options(char *str,unsigned int *options,
 
       for(i=0;opts[i].name;i++)
         if(opts[i].help)
-         printf("%s%*s%s\n",opts[i].name,
-                maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
+         es_printf("%s%*s%s\n",opts[i].name,
+                    maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
 
       g10_exit(0);
     }
@@ -1470,69 +1488,6 @@ parse_options(char *str,unsigned int *options,
 }
 
 
-/* Check whether the string has characters not valid in an RFC-822
-   address.  To cope with OpenPGP we ignore non-ascii characters
-   so that for example umlauts are legal in an email address.  An
-   OpenPGP user ID must be utf-8 encoded but there is no strict
-   requirement for RFC-822.  Thus to avoid IDNA encoding we put the
-   address verbatim as utf-8 into the user ID under the assumption
-   that mail programs handle IDNA at a lower level and take OpenPGP
-   user IDs as utf-8.  Note that we can't do an utf-8 encoding
-   checking here because in keygen.c this function is called with the
-   native encoding and native to utf-8 encoding is only done  later.  */
-int
-has_invalid_email_chars (const char *s)
-{
-  int at_seen=0;
-  const char *valid_chars=
-    "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-  for ( ; *s; s++ )
-    {
-      if ( (*s & 0x80) )
-        continue; /* We only care about ASCII.  */
-      if ( *s == '@' )
-        at_seen=1;
-      else if ( !at_seen && !(strchr (valid_chars, *s)
-                              || strchr ("!#$%&'*+/=?^`{|}~", *s)))
-        return 1;
-      else if ( at_seen && !strchr( valid_chars, *s ) )
-        return 1;
-    }
-  return 0;
-}
-
-
-/* Check whether NAME represents a valid mailbox according to
-   RFC822. Returns true if so. */
-int
-is_valid_mailbox (const char *name)
-{
-  return !( !name
-            || !*name
-            || has_invalid_email_chars (name)
-            || string_count_chr (name,'@') != 1
-            || *name == '@'
-            || name[strlen(name)-1] == '@'
-            || name[strlen(name)-1] == '.'
-            || strstr (name, "..") );
-}
-
-
-/* Check whether UID is a valid standard user id of the form
-     "Heinrich Heine <heinrichh@duesseldorf.de>"
-   and return true if this is the case. */
-int
-is_valid_user_id (const char *uid)
-{
-  if (!uid || !*uid)
-    return 0;
-
-  return 1;
-}
-
-
-
 /* Similar to access(2), but uses PATH to find the file. */
 int
 path_access(const char *file,int mode)
@@ -1594,8 +1549,8 @@ pubkey_get_npkey (pubkey_algo_t algo)
     case PUBKEY_ALGO_ECDSA:     return 2;
     case PUBKEY_ALGO_ELGAMAL:   return 3;
     case PUBKEY_ALGO_EDDSA:     return 2;
+    default: return 0;
     }
-  return 0;
 }
 
 
@@ -1614,8 +1569,8 @@ pubkey_get_nskey (pubkey_algo_t algo)
     case PUBKEY_ALGO_ECDSA:     return 3;
     case PUBKEY_ALGO_ELGAMAL:   return 4;
     case PUBKEY_ALGO_EDDSA:     return 3;
+    default: return 0;
     }
-  return 0;
 }
 
 /* Temporary helper. */
@@ -1633,8 +1588,8 @@ pubkey_get_nsig (pubkey_algo_t algo)
     case PUBKEY_ALGO_ECDSA:     return 2;
     case PUBKEY_ALGO_ELGAMAL:   return 2;
     case PUBKEY_ALGO_EDDSA:     return 2;
+    default: return 0;
     }
-  return 0;
 }
 
 
@@ -1653,8 +1608,8 @@ pubkey_get_nenc (pubkey_algo_t algo)
     case PUBKEY_ALGO_ECDSA:     return 0;
     case PUBKEY_ALGO_ELGAMAL:   return 2;
     case PUBKEY_ALGO_EDDSA:     return 0;
+    default: return 0;
     }
-  return 0;
 }
 
 
@@ -1717,7 +1672,8 @@ pubkey_nbits( int algo, gcry_mpi_t *key )
 int
 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
 {
-  int n=0;
+  int n = 0;
+  size_t nwritten;
 
   if (!a)
     return es_fprintf (fp, "[MPI_NULL]");
@@ -1735,19 +1691,19 @@ mpi_print (estream_t fp, gcry_mpi_t a, int mode)
         n += es_fprintf (fp, "[invalid opaque value]");
       else
         {
-          nbits = (nbits + 7)/8;
-          for (; nbits; nbits--, p++)
-            n += es_fprintf (fp, "%02X", *p);
+          if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
+            n += nwritten;
         }
     }
   else
     {
       unsigned char *buffer;
+      size_t buflen;
 
-      if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
+      if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
         BUG ();
-      es_fputs (buffer, fp);
-      n += strlen (buffer);
+      if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
+        n += nwritten;
       gcry_free (buffer);
     }
   return n;
@@ -1769,3 +1725,33 @@ ecdsa_qbits_from_Q (unsigned int qbits)
   qbits /= 2;
   return qbits;
 }
+
+
+/* Ignore signatures and certifications made over certain digest
+ * algorithms by default, MD5 is considered weak.  This allows users
+ * to deprecate support for other algorithms as well.
+ */
+void
+additional_weak_digest (const char* digestname)
+{
+  struct weakhash *weak = NULL;
+  const enum gcry_md_algos algo = string_to_digest_algo(digestname);
+
+  if (algo == GCRY_MD_NONE)
+    {
+      log_error (_("unknown weak digest '%s'\n"), digestname);
+      return;
+    }
+
+  /* Check to ensure it's not already present.  */
+  for (weak = opt.weak_digests; weak; weak = weak->next)
+    if (algo == weak->algo)
+      return;
+
+  /* Add it to the head of the list.  */
+  weak = xmalloc(sizeof(*weak));
+  weak->algo = algo;
+  weak->rejection_shown = 0;
+  weak->next = opt.weak_digests;
+  opt.weak_digests = weak;
+}