LCOV - code coverage report
Current view: top level - g10 - keyid.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 218 371 58.8 %
Date: 2016-11-29 15:00:56 Functions: 25 37 67.6 %

          Line data    Source code
       1             : /* keyid.c - key ID and fingerprint handling
       2             :  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
       3             :  *               2004, 2006, 2010 Free Software Foundation, Inc.
       4             :  * Copyright (C) 2014 Werner Koch
       5             :  * Copyright (C) 2016 g10 Code GmbH
       6             :  *
       7             :  * This file is part of GnuPG.
       8             :  *
       9             :  * GnuPG is free software; you can redistribute it and/or modify
      10             :  * it under the terms of the GNU General Public License as published by
      11             :  * the Free Software Foundation; either version 3 of the License, or
      12             :  * (at your option) any later version.
      13             :  *
      14             :  * GnuPG is distributed in the hope that it will be useful,
      15             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :  * GNU General Public License for more details.
      18             :  *
      19             :  * You should have received a copy of the GNU General Public License
      20             :  * along with this program; if not, see <https://www.gnu.org/licenses/>.
      21             :  */
      22             : 
      23             : #include <config.h>
      24             : #include <stdio.h>
      25             : #include <stdlib.h>
      26             : #include <string.h>
      27             : #include <errno.h>
      28             : #include <time.h>
      29             : 
      30             : #include "gpg.h"
      31             : #include "util.h"
      32             : #include "main.h"
      33             : #include "packet.h"
      34             : #include "options.h"
      35             : #include "keydb.h"
      36             : #include "i18n.h"
      37             : #include "rmd160.h"
      38             : #include "host2net.h"
      39             : 
      40             : 
      41             : #define KEYID_STR_SIZE 19
      42             : 
      43             : #ifdef HAVE_UNSIGNED_TIME_T
      44             : # define IS_INVALID_TIME_T(a) ((a) == (time_t)(-1))
      45             : #else
      46             :   /* Error or 32 bit time_t and value after 2038-01-19.  */
      47             : # define IS_INVALID_TIME_T(a) ((a) < 0)
      48             : #endif
      49             : 
      50             : 
      51             : /* Return a letter describing the public key algorithms.  */
      52             : int
      53           0 : pubkey_letter( int algo )
      54             : {
      55           0 :   switch (algo)
      56             :     {
      57           0 :     case PUBKEY_ALGO_RSA:       return 'R' ;
      58           0 :     case PUBKEY_ALGO_RSA_E:     return 'r' ;
      59           0 :     case PUBKEY_ALGO_RSA_S:     return 's' ;
      60           0 :     case PUBKEY_ALGO_ELGAMAL_E: return 'g' ;
      61           0 :     case PUBKEY_ALGO_ELGAMAL:   return 'G' ;
      62           0 :     case PUBKEY_ALGO_DSA:       return 'D' ;
      63           0 :     case PUBKEY_ALGO_ECDH:      return 'e' ;    /* ECC DH (encrypt only) */
      64           0 :     case PUBKEY_ALGO_ECDSA:     return 'E' ;    /* ECC DSA (sign only)   */
      65           0 :     case PUBKEY_ALGO_EDDSA:     return 'E' ;    /* ECC EdDSA (sign only) */
      66           0 :     default: return '?';
      67             :     }
      68             : }
      69             : 
      70             : /* Return a string describing the public key algorithm and the
      71             :    keysize.  For elliptic curves the functions prints the name of the
      72             :    curve because the keysize is a property of the curve.  The string
      73             :    is copied to the supplied buffer up a length of BUFSIZE-1.
      74             :    Examples for the output are:
      75             : 
      76             :    "rsa2048"  - RSA with 2048 bit
      77             :    "elg1024"  - Elgamal with 1024 bit
      78             :    "ed25519"  - ECC using the curve Ed25519.
      79             :    "E_1.2.3.4"  - ECC using the unsupported curve with OID "1.2.3.4".
      80             :    "E_1.3.6.1.4.1.11591.2.12242973" ECC with a bogus OID.
      81             :    "unknown_N"  - Unknown OpenPGP algorithm N.
      82             : 
      83             :    If the option --legacy-list-mode is active, the output use the
      84             :    legacy format:
      85             : 
      86             :    "2048R" - RSA with 2048 bit
      87             :    "1024g" - Elgamal with 1024 bit
      88             :    "256E"  - ECDSA using a curve with 256 bit
      89             : 
      90             :    The macro PUBKEY_STRING_SIZE may be used to allocate a buffer with
      91             :    a suitable size.*/
      92             : char *
      93          44 : pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize)
      94             : {
      95          44 :   const char *prefix = NULL;
      96             : 
      97          44 :   if (opt.legacy_list_mode)
      98             :     {
      99           0 :       snprintf (buffer, bufsize, "%4u%c",
     100           0 :                 nbits_from_pk (pk), pubkey_letter (pk->pubkey_algo));
     101           0 :       return buffer;
     102             :     }
     103             : 
     104          44 :   switch (pk->pubkey_algo)
     105             :     {
     106             :     case PUBKEY_ALGO_RSA:
     107             :     case PUBKEY_ALGO_RSA_E:
     108          15 :     case PUBKEY_ALGO_RSA_S:     prefix = "rsa"; break;
     109          14 :     case PUBKEY_ALGO_ELGAMAL_E: prefix = "elg"; break;
     110          15 :     case PUBKEY_ALGO_DSA:       prefix = "dsa"; break;
     111           0 :     case PUBKEY_ALGO_ELGAMAL:   prefix = "xxx"; break;
     112             :     case PUBKEY_ALGO_ECDH:
     113             :     case PUBKEY_ALGO_ECDSA:
     114           0 :     case PUBKEY_ALGO_EDDSA:     prefix = "";    break;
     115             :     }
     116             : 
     117          44 :   if (prefix && *prefix)
     118          44 :     snprintf (buffer, bufsize, "%s%u", prefix, nbits_from_pk (pk));
     119           0 :   else if (prefix)
     120             :     {
     121           0 :       char *curve = openpgp_oid_to_str (pk->pkey[0]);
     122           0 :       const char *name = openpgp_oid_to_curve (curve, 0);
     123             : 
     124           0 :       if (name)
     125           0 :         snprintf (buffer, bufsize, "%s", name);
     126           0 :       else if (curve)
     127           0 :         snprintf (buffer, bufsize, "E_%s", curve);
     128             :       else
     129           0 :         snprintf (buffer, bufsize, "E_error");
     130           0 :       xfree (curve);
     131             :     }
     132             :   else
     133           0 :     snprintf (buffer, bufsize, "unknown_%u", (unsigned int)pk->pubkey_algo);
     134             : 
     135          44 :   return buffer;
     136             : }
     137             : 
     138             : 
     139             : /* Hash a public key.  This function is useful for v4 fingerprints and
     140             :    for v3 or v4 key signing. */
     141             : void
     142       10148 : hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
     143             : {
     144       10148 :   unsigned int n = 6;
     145             :   unsigned int nn[PUBKEY_MAX_NPKEY];
     146             :   byte *pp[PUBKEY_MAX_NPKEY];
     147             :   int i;
     148             :   unsigned int nbits;
     149             :   size_t nbytes;
     150       10148 :   int npkey = pubkey_get_npkey (pk->pubkey_algo);
     151             : 
     152             :   /* FIXME: We can avoid the extra malloc by calling only the first
     153             :      mpi_print here which computes the required length and calling the
     154             :      real mpi_print only at the end.  The speed advantage would only be
     155             :      for ECC (opaque MPIs) or if we could implement an mpi_print
     156             :      variant with a callback handler to do the hashing.  */
     157       10148 :   if (npkey==0 && pk->pkey[0]
     158           0 :       && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
     159             :     {
     160           0 :       pp[0] = gcry_mpi_get_opaque (pk->pkey[0], &nbits);
     161           0 :       nn[0] = (nbits+7)/8;
     162           0 :       n+=nn[0];
     163             :     }
     164             :   else
     165             :     {
     166       40169 :       for (i=0; i < npkey; i++ )
     167             :         {
     168       30021 :           if (!pk->pkey[i])
     169             :             {
     170             :               /* This case may only happen if the parsing of the MPI
     171             :                  failed but the key was anyway created.  May happen
     172             :                  during "gpg KEYFILE".  */
     173           0 :               pp[i] = NULL;
     174           0 :               nn[i] = 0;
     175             :             }
     176       30021 :           else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
     177             :             {
     178             :               const void *p;
     179             : 
     180         945 :               p = gcry_mpi_get_opaque (pk->pkey[i], &nbits);
     181         945 :               pp[i] = xmalloc ((nbits+7)/8);
     182         945 :               if (p)
     183         945 :                 memcpy (pp[i], p, (nbits+7)/8);
     184             :               else
     185           0 :                 pp[i] = NULL;
     186         945 :               nn[i] = (nbits+7)/8;
     187         945 :               n += nn[i];
     188             :             }
     189             :           else
     190             :             {
     191       29076 :               if (gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0,
     192             :                                   &nbytes, pk->pkey[i]))
     193           0 :                 BUG ();
     194       29076 :               pp[i] = xmalloc (nbytes);
     195       29076 :               if (gcry_mpi_print (GCRYMPI_FMT_PGP, pp[i], nbytes,
     196             :                                   &nbytes, pk->pkey[i]))
     197           0 :                 BUG ();
     198       29076 :               nn[i] = nbytes;
     199       29076 :               n += nn[i];
     200             :             }
     201             :         }
     202             :     }
     203             : 
     204       10148 :   gcry_md_putc ( md, 0x99 );     /* ctb */
     205             :   /* What does it mean if n is greater than than 0xFFFF ? */
     206       10148 :   gcry_md_putc ( md, n >> 8 );   /* 2 byte length header */
     207       10148 :   gcry_md_putc ( md, n );
     208       10148 :   gcry_md_putc ( md, pk->version );
     209             : 
     210       10148 :   gcry_md_putc ( md, pk->timestamp >> 24 );
     211       10148 :   gcry_md_putc ( md, pk->timestamp >> 16 );
     212       10148 :   gcry_md_putc ( md, pk->timestamp >>  8 );
     213       10148 :   gcry_md_putc ( md, pk->timestamp       );
     214             : 
     215       10148 :   gcry_md_putc ( md, pk->pubkey_algo );
     216             : 
     217       10148 :   if(npkey==0 && pk->pkey[0]
     218           0 :      && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
     219             :     {
     220           0 :       if (pp[0])
     221           0 :         gcry_md_write (md, pp[0], nn[0]);
     222             :     }
     223             :   else
     224             :     {
     225       40169 :       for(i=0; i < npkey; i++ )
     226             :         {
     227       30021 :           if (pp[i])
     228       30021 :             gcry_md_write ( md, pp[i], nn[i] );
     229       30021 :           xfree(pp[i]);
     230             :         }
     231             :     }
     232       10148 : }
     233             : 
     234             : 
     235             : static gcry_md_hd_t
     236        8638 : do_fingerprint_md( PKT_public_key *pk )
     237             : {
     238             :   gcry_md_hd_t md;
     239             : 
     240        8638 :   if (gcry_md_open (&md, DIGEST_ALGO_SHA1, 0))
     241           0 :     BUG ();
     242        8638 :   hash_public_key(md,pk);
     243        8638 :   gcry_md_final( md );
     244             : 
     245        8638 :   return md;
     246             : }
     247             : 
     248             : 
     249             : /* fixme: Check whether we can replace this function or if not
     250             :    describe why we need it.  */
     251             : u32
     252           0 : v3_keyid (gcry_mpi_t a, u32 *ki)
     253             : {
     254             :   byte *buffer, *p;
     255             :   size_t nbytes;
     256             : 
     257           0 :   if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &nbytes, a ))
     258           0 :     BUG ();
     259             :   /* fixme: allocate it on the stack */
     260           0 :   buffer = xmalloc (nbytes);
     261           0 :   if (gcry_mpi_print( GCRYMPI_FMT_USG, buffer, nbytes, NULL, a ))
     262           0 :     BUG ();
     263           0 :   if (nbytes < 8) /* oops */
     264           0 :     ki[0] = ki[1] = 0;
     265             :   else
     266             :     {
     267           0 :       p = buffer + nbytes - 8;
     268           0 :       ki[0] = buf32_to_u32 (p);
     269           0 :       p += 4;
     270           0 :       ki[1] = buf32_to_u32 (p);
     271             :     }
     272           0 :   xfree (buffer);
     273           0 :   return ki[1];
     274             : }
     275             : 
     276             : 
     277             : /* Return PK's keyid.  The memory is owned by PK.  */
     278             : u32 *
     279         800 : pk_keyid (PKT_public_key *pk)
     280             : {
     281         800 :   keyid_from_pk (pk, NULL);
     282             : 
     283             :   /* Uncomment this for help tracking down bugs related to keyid or
     284             :      main_keyid not being set correctly.  */
     285             : #if 0
     286             :   if (! (pk->main_keyid[0] || pk->main_keyid[1]))
     287             :     log_bug ("pk->main_keyid not set!\n");
     288             :   if (keyid_cmp (pk->keyid, pk->main_keyid) == 0
     289             :       && ! pk->flags.primary)
     290             :     log_bug ("keyid and main_keyid are the same, but primary flag not set!\n");
     291             :   if (keyid_cmp (pk->keyid, pk->main_keyid) != 0
     292             :       && pk->flags.primary)
     293             :     log_bug ("keyid and main_keyid are different, but primary flag set!\n");
     294             : #endif
     295             : 
     296         800 :   return pk->keyid;
     297             : }
     298             : 
     299             : /* Return the keyid of the primary key associated with PK.  The memory
     300             :    is owned by PK.  */
     301             : u32 *
     302        3231 : pk_main_keyid (PKT_public_key *pk)
     303             : {
     304             :   /* Uncomment this for help tracking down bugs related to keyid or
     305             :      main_keyid not being set correctly.  */
     306             : #if 0
     307             :   if (! (pk->main_keyid[0] || pk->main_keyid[1]))
     308             :     log_bug ("pk->main_keyid not set!\n");
     309             : #endif
     310             : 
     311        3231 :   return pk->main_keyid;
     312             : }
     313             : 
     314             : /* Copy the keyid in SRC to DEST and return DEST.  */
     315             : u32 *
     316           3 : keyid_copy (u32 *dest, const u32 *src)
     317             : {
     318           3 :   dest[0] = src[0];
     319           3 :   dest[1] = src[1];
     320           3 :   return dest;
     321             : }
     322             : 
     323             : char *
     324        1312 : format_keyid (u32 *keyid, int format, char *buffer, int len)
     325             : {
     326             :   char tmp[KEYID_STR_SIZE];
     327        1312 :   if (! buffer)
     328             :     {
     329           0 :       buffer = tmp;
     330           0 :       len = sizeof (tmp);
     331             :     }
     332             : 
     333        1312 :   if (format == KF_DEFAULT)
     334           0 :     format = opt.keyid_format;
     335        1312 :   if (format == KF_DEFAULT)
     336           0 :     format = KF_NONE;
     337             : 
     338        1312 :   switch (format)
     339             :     {
     340             :     case KF_NONE:
     341           0 :       if (len)
     342           0 :         *buffer = 0;
     343           0 :       break;
     344             : 
     345             :     case KF_SHORT:
     346           0 :       snprintf (buffer, len, "%08lX", (ulong)keyid[1]);
     347           0 :       break;
     348             : 
     349             :     case KF_LONG:
     350        1312 :       snprintf (buffer, len, "%08lX%08lX", (ulong)keyid[0], (ulong)keyid[1]);
     351        1312 :       break;
     352             : 
     353             :     case KF_0xSHORT:
     354           0 :       snprintf (buffer, len, "0x%08lX", (ulong)keyid[1]);
     355           0 :       break;
     356             : 
     357             :     case KF_0xLONG:
     358           0 :       snprintf (buffer, len, "0x%08lX%08lX", (ulong)keyid[0],(ulong)keyid[1]);
     359           0 :       break;
     360             : 
     361             :     default:
     362           0 :       BUG();
     363             :     }
     364             : 
     365        1312 :   if (buffer == tmp)
     366           0 :     return xstrdup (buffer);
     367        1312 :   return buffer;
     368             : }
     369             : 
     370             : size_t
     371          51 : keystrlen(void)
     372             : {
     373          51 :   int format = opt.keyid_format;
     374          51 :   if (format == KF_DEFAULT)
     375           1 :     format = KF_NONE;
     376             : 
     377          51 :   switch(format)
     378             :     {
     379             :     case KF_NONE:
     380          51 :       return 0;
     381             : 
     382             :     case KF_SHORT:
     383           0 :       return 8;
     384             : 
     385             :     case KF_LONG:
     386           0 :       return 16;
     387             : 
     388             :     case KF_0xSHORT:
     389           0 :       return 10;
     390             : 
     391             :     case KF_0xLONG:
     392           0 :       return 18;
     393             : 
     394             :     default:
     395           0 :       BUG();
     396             :     }
     397             : }
     398             : 
     399             : 
     400             : const char *
     401        1293 : keystr (u32 *keyid)
     402             : {
     403             :   static char keyid_str[KEYID_STR_SIZE];
     404        1293 :   int format = opt.keyid_format;
     405             : 
     406        1293 :   if (format == KF_DEFAULT)
     407           1 :     format = KF_NONE;
     408        1293 :   if (format == KF_NONE)
     409        1293 :     format = KF_LONG;
     410             : 
     411        1293 :   return format_keyid (keyid, format, keyid_str, sizeof (keyid_str));
     412             : }
     413             : 
     414             : /* This function returns the key id of the main and possible the
     415             :  * subkey as one string.  It is used by error messages.  */
     416             : const char *
     417           0 : keystr_with_sub (u32 *main_kid, u32 *sub_kid)
     418             : {
     419             :   static char buffer[KEYID_STR_SIZE+1+KEYID_STR_SIZE];
     420             :   char *p;
     421           0 :   int format = opt.keyid_format;
     422             : 
     423           0 :   if (format == KF_NONE)
     424           0 :     format = KF_LONG;
     425             : 
     426           0 :   format_keyid (main_kid, format, buffer, KEYID_STR_SIZE);
     427           0 :   if (sub_kid)
     428             :     {
     429           0 :       p = buffer + strlen (buffer);
     430           0 :       *p++ = '/';
     431           0 :       format_keyid (sub_kid, format, p, KEYID_STR_SIZE);
     432             :     }
     433           0 :   return buffer;
     434             : }
     435             : 
     436             : 
     437             : const char *
     438         303 : keystr_from_pk(PKT_public_key *pk)
     439             : {
     440         303 :   keyid_from_pk(pk,NULL);
     441             : 
     442         303 :   return keystr(pk->keyid);
     443             : }
     444             : 
     445             : 
     446             : const char *
     447           0 : keystr_from_pk_with_sub (PKT_public_key *main_pk, PKT_public_key *sub_pk)
     448             : {
     449           0 :   keyid_from_pk (main_pk, NULL);
     450           0 :   if (sub_pk)
     451           0 :     keyid_from_pk (sub_pk, NULL);
     452             : 
     453           0 :   return keystr_with_sub (main_pk->keyid, sub_pk? sub_pk->keyid:NULL);
     454             : }
     455             : 
     456             : 
     457             : /* Return PK's key id as a string using the default format.  PK owns
     458             :    the storage.  */
     459             : const char *
     460           0 : pk_keyid_str (PKT_public_key *pk)
     461             : {
     462           0 :   return keystr (pk_keyid (pk));
     463             : }
     464             : 
     465             : 
     466             : const char *
     467           0 : keystr_from_desc(KEYDB_SEARCH_DESC *desc)
     468             : {
     469           0 :   switch(desc->mode)
     470             :     {
     471             :     case KEYDB_SEARCH_MODE_LONG_KID:
     472             :     case KEYDB_SEARCH_MODE_SHORT_KID:
     473           0 :       return keystr(desc->u.kid);
     474             : 
     475             :     case KEYDB_SEARCH_MODE_FPR20:
     476             :       {
     477             :         u32 keyid[2];
     478             : 
     479           0 :         keyid[0] = buf32_to_u32 (desc->u.fpr+12);
     480           0 :         keyid[1] = buf32_to_u32 (desc->u.fpr+16);
     481           0 :         return keystr(keyid);
     482             :       }
     483             : 
     484             :     case KEYDB_SEARCH_MODE_FPR16:
     485           0 :       return "?v3 fpr?";
     486             : 
     487             :     default:
     488           0 :       BUG();
     489             :     }
     490             : }
     491             : 
     492             : 
     493             : /*
     494             :  * Get the keyid from the public key and put it into keyid
     495             :  * if this is not NULL. Return the 32 low bits of the keyid.
     496             :  */
     497             : u32
     498       13961 : keyid_from_pk (PKT_public_key *pk, u32 *keyid)
     499             : {
     500             :   u32 lowbits;
     501             :   u32 dummy_keyid[2];
     502             : 
     503       13961 :   if (!keyid)
     504        1140 :     keyid = dummy_keyid;
     505             : 
     506       13961 :   if( pk->keyid[0] || pk->keyid[1] )
     507             :     {
     508       10420 :       keyid[0] = pk->keyid[0];
     509       10420 :       keyid[1] = pk->keyid[1];
     510       10420 :       lowbits = keyid[1];
     511             :     }
     512             :   else
     513             :     {
     514             :       const byte *dp;
     515             :       gcry_md_hd_t md;
     516             : 
     517        3541 :       md = do_fingerprint_md(pk);
     518        3541 :       if(md)
     519             :         {
     520        3541 :           dp = gcry_md_read ( md, 0 );
     521        3541 :           keyid[0] = buf32_to_u32 (dp+12);
     522        3541 :           keyid[1] = buf32_to_u32 (dp+16);
     523        3541 :           lowbits = keyid[1];
     524        3541 :           gcry_md_close (md);
     525        3541 :           pk->keyid[0] = keyid[0];
     526        3541 :           pk->keyid[1] = keyid[1];
     527             :         }
     528             :       else
     529           0 :         pk->keyid[0]=pk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
     530             :     }
     531             : 
     532       13961 :   return lowbits;
     533             : }
     534             : 
     535             : 
     536             : /*
     537             :  * Get the keyid from the fingerprint.  This function is simple for most
     538             :  * keys, but has to do a keylookup for old stayle keys.
     539             :  */
     540             : u32
     541          29 : keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
     542             : {
     543             :   u32 dummy_keyid[2];
     544             : 
     545          29 :   if( !keyid )
     546           0 :     keyid = dummy_keyid;
     547             : 
     548          29 :   if (fprint_len != 20)
     549             :     {
     550             :       /* This is special as we have to lookup the key first.  */
     551             :       PKT_public_key pk;
     552             :       int rc;
     553             : 
     554           0 :       memset (&pk, 0, sizeof pk);
     555           0 :       rc = get_pubkey_byfprint (&pk, NULL, fprint, fprint_len);
     556           0 :       if( rc )
     557             :         {
     558           0 :           log_error("Oops: keyid_from_fingerprint: no pubkey\n");
     559           0 :           keyid[0] = 0;
     560           0 :           keyid[1] = 0;
     561             :         }
     562             :       else
     563           0 :         keyid_from_pk (&pk, keyid);
     564             :     }
     565             :   else
     566             :     {
     567          29 :       const byte *dp = fprint;
     568          29 :       keyid[0] = buf32_to_u32 (dp+12);
     569          29 :       keyid[1] = buf32_to_u32 (dp+16);
     570             :     }
     571             : 
     572          29 :   return keyid[1];
     573             : }
     574             : 
     575             : 
     576             : u32
     577           0 : keyid_from_sig (PKT_signature *sig, u32 *keyid)
     578             : {
     579           0 :   if( keyid )
     580             :     {
     581           0 :       keyid[0] = sig->keyid[0];
     582           0 :       keyid[1] = sig->keyid[1];
     583             :     }
     584           0 :   return sig->keyid[1];
     585             : }
     586             : 
     587             : 
     588             : byte *
     589         795 : namehash_from_uid (PKT_user_id *uid)
     590             : {
     591         795 :   if (!uid->namehash)
     592             :     {
     593         700 :       uid->namehash = xmalloc (20);
     594             : 
     595         700 :       if (uid->attrib_data)
     596           0 :         rmd160_hash_buffer (uid->namehash, uid->attrib_data, uid->attrib_len);
     597             :       else
     598         700 :         rmd160_hash_buffer (uid->namehash, uid->name, uid->len);
     599             :     }
     600             : 
     601         795 :   return uid->namehash;
     602             : }
     603             : 
     604             : 
     605             : /*
     606             :  * Return the number of bits used in PK.
     607             :  */
     608             : unsigned int
     609         964 : nbits_from_pk (PKT_public_key *pk)
     610             : {
     611         964 :     return pubkey_nbits (pk->pubkey_algo, pk->pkey);
     612             : }
     613             : 
     614             : 
     615             : static const char *
     616          52 : mk_datestr (char *buffer, time_t atime)
     617             : {
     618             :   struct tm *tp;
     619             : 
     620          52 :   if (IS_INVALID_TIME_T (atime))
     621           0 :     strcpy (buffer, "????" "-??" "-??"); /* Mark this as invalid. */
     622             :   else
     623             :     {
     624          52 :       tp = gmtime (&atime);
     625         156 :       sprintf (buffer,"%04d-%02d-%02d",
     626         104 :                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
     627             :     }
     628          52 :   return buffer;
     629             : }
     630             : 
     631             : 
     632             : /*
     633             :  * return a string with the creation date of the pk
     634             :  * Note: this is alloced in a static buffer.
     635             :  *    Format is: yyyy-mm-dd
     636             :  */
     637             : const char *
     638          44 : datestr_from_pk (PKT_public_key *pk)
     639             : {
     640             :   static char buffer[11+5];
     641          44 :   time_t atime = pk->timestamp;
     642             : 
     643          44 :   return mk_datestr (buffer, atime);
     644             : }
     645             : 
     646             : 
     647             : const char *
     648           0 : datestr_from_sig (PKT_signature *sig )
     649             : {
     650             :   static char buffer[11+5];
     651           0 :   time_t atime = sig->timestamp;
     652             : 
     653           0 :   return mk_datestr (buffer, atime);
     654             : }
     655             : 
     656             : 
     657             : const char *
     658           8 : expirestr_from_pk (PKT_public_key *pk)
     659             : {
     660             :   static char buffer[11+5];
     661             :   time_t atime;
     662             : 
     663           8 :   if (!pk->expiredate)
     664           0 :     return _("never     ");
     665           8 :   atime = pk->expiredate;
     666           8 :   return mk_datestr (buffer, atime);
     667             : }
     668             : 
     669             : 
     670             : const char *
     671           0 : expirestr_from_sig (PKT_signature *sig)
     672             : {
     673             :   static char buffer[11+5];
     674             :   time_t atime;
     675             : 
     676           0 :   if (!sig->expiredate)
     677           0 :     return _("never     ");
     678           0 :   atime=sig->expiredate;
     679           0 :   return mk_datestr (buffer, atime);
     680             : }
     681             : 
     682             : 
     683             : const char *
     684           0 : revokestr_from_pk( PKT_public_key *pk )
     685             : {
     686             :   static char buffer[11+5];
     687             :   time_t atime;
     688             : 
     689           0 :   if(!pk->revoked.date)
     690           0 :     return _("never     ");
     691           0 :   atime=pk->revoked.date;
     692           0 :   return mk_datestr (buffer, atime);
     693             : }
     694             : 
     695             : 
     696             : const char *
     697          44 : usagestr_from_pk (PKT_public_key *pk, int fill)
     698             : {
     699             :   static char buffer[10];
     700          44 :   int i = 0;
     701          44 :   unsigned int use = pk->pubkey_usage;
     702             : 
     703          44 :   if ( use & PUBKEY_USAGE_SIG )
     704          27 :     buffer[i++] = 'S';
     705             : 
     706          44 :   if ( use & PUBKEY_USAGE_CERT )
     707          25 :     buffer[i++] = 'C';
     708             : 
     709          44 :   if ( use & PUBKEY_USAGE_ENC )
     710          18 :     buffer[i++] = 'E';
     711             : 
     712          44 :   if ( (use & PUBKEY_USAGE_AUTH) )
     713           2 :     buffer[i++] = 'A';
     714             : 
     715          88 :   while (fill && i < 4)
     716           0 :     buffer[i++] = ' ';
     717             : 
     718          44 :   buffer[i] = 0;
     719          44 :   return buffer;
     720             : }
     721             : 
     722             : 
     723             : const char *
     724         428 : colon_strtime (u32 t)
     725             : {
     726             :   static char buf[20];
     727             : 
     728         428 :   if (!t)
     729         159 :     return "";
     730         269 :   snprintf (buf, sizeof buf, "%lu", (ulong)t);
     731         269 :   return buf;
     732             : }
     733             : 
     734             : const char *
     735         212 : colon_datestr_from_pk (PKT_public_key *pk)
     736             : {
     737             :   static char buf[20];
     738             : 
     739         212 :   snprintf (buf, sizeof buf, "%lu", (ulong)pk->timestamp);
     740         212 :   return buf;
     741             : }
     742             : 
     743             : 
     744             : const char *
     745           0 : colon_datestr_from_sig (PKT_signature *sig)
     746             : {
     747             :   static char buf[20];
     748             : 
     749           0 :   snprintf (buf, sizeof buf, "%lu", (ulong)sig->timestamp);
     750           0 :   return buf;
     751             : }
     752             : 
     753             : const char *
     754           0 : colon_expirestr_from_sig (PKT_signature *sig)
     755             : {
     756             :   static char buf[20];
     757             : 
     758           0 :   if (!sig->expiredate)
     759           0 :     return "";
     760             : 
     761           0 :   snprintf (buf, sizeof buf,"%lu", (ulong)sig->expiredate);
     762           0 :   return buf;
     763             : }
     764             : 
     765             : 
     766             : /*
     767             :  * Return a byte array with the fingerprint for the given PK/SK
     768             :  * The length of the array is returned in ret_len. Caller must free
     769             :  * the array or provide an array of length MAX_FINGERPRINT_LEN.
     770             :  */
     771             : byte *
     772        5097 : fingerprint_from_pk (PKT_public_key *pk, byte *array, size_t *ret_len)
     773             : {
     774             :   const byte *dp;
     775             :   size_t len;
     776             :   gcry_md_hd_t md;
     777             : 
     778        5097 :   md = do_fingerprint_md(pk);
     779        5097 :   dp = gcry_md_read( md, 0 );
     780        5097 :   len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
     781        5097 :   log_assert( len <= MAX_FINGERPRINT_LEN );
     782        5097 :   if (!array)
     783           0 :     array = xmalloc ( len );
     784        5097 :   memcpy (array, dp, len );
     785        5097 :   pk->keyid[0] = buf32_to_u32 (dp+12);
     786        5097 :   pk->keyid[1] = buf32_to_u32 (dp+16);
     787        5097 :   gcry_md_close( md);
     788             : 
     789        5097 :   if (ret_len)
     790        1349 :     *ret_len = len;
     791        5097 :   return array;
     792             : }
     793             : 
     794             : 
     795             : /* Return an allocated buffer with the fingerprint of PK formatted as
     796             :    a plain hexstring.  If BUFFER is NULL the result is a malloc'd
     797             :    string.  If BUFFER is not NULL the result will be copied into this
     798             :    buffer.  In the latter case BUFLEN describes the length of the
     799             :    buffer; if this is too short the function terminates the process.
     800             :    Returns a malloc'ed string or BUFFER.  A suitable length for BUFFER
     801             :    is (2*MAX_FINGERPRINT_LEN + 1). */
     802             : char *
     803         589 : hexfingerprint (PKT_public_key *pk, char *buffer, size_t buflen)
     804             : {
     805             :   unsigned char fpr[MAX_FINGERPRINT_LEN];
     806             :   size_t len;
     807             : 
     808         589 :   fingerprint_from_pk (pk, fpr, &len);
     809         589 :   if (!buffer)
     810         272 :     buffer = xmalloc (2 * len + 1);
     811         317 :   else if (buflen < 2*len+1)
     812           0 :     log_fatal ("%s: buffer too short (%zu)\n", __func__, buflen);
     813         589 :   bin2hex (fpr, len, buffer);
     814         589 :   return buffer;
     815             : }
     816             : 
     817             : 
     818             : /* Pretty print a hex fingerprint.  If BUFFER is NULL the result is a
     819             :    malloc'd string.  If BUFFER is not NULL the result will be copied
     820             :    into this buffer.  In the latter case BUFLEN describes the length
     821             :    of the buffer; if this is too short the function terminates the
     822             :    process.  Returns a malloc'ed string or BUFFER.  A suitable length
     823             :    for BUFFER is (MAX_FORMATTED_FINGERPRINT_LEN + 1).  */
     824             : char *
     825         132 : format_hexfingerprint (const char *fingerprint, char *buffer, size_t buflen)
     826             : {
     827         132 :   int hexlen = strlen (fingerprint);
     828             :   int space;
     829             :   int i, j;
     830             : 
     831         132 :   if (hexlen == 40)  /* v4 fingerprint */
     832             :     {
     833         132 :       space = (/* The characters and the NUL.  */
     834             :                40 + 1
     835             :                /* After every fourth character, we add a space (except
     836             :                   the last).  */
     837             :                + 40 / 4 - 1
     838             :                /* Half way through we add a second space.  */
     839             :                + 1);
     840             :     }
     841             :   else  /* Other fingerprint versions - print as is.  */
     842             :     {
     843           0 :       space = hexlen + 1;
     844             :     }
     845             : 
     846         132 :   if (!buffer)
     847         108 :     buffer = xmalloc (space);
     848          24 :   else if (buflen < space)
     849           0 :     log_fatal ("%s: buffer too short (%zu)\n", __func__, buflen);
     850             : 
     851         132 :   if (hexlen == 40)  /* v4 fingerprint */
     852             :     {
     853        5412 :       for (i = 0, j = 0; i < 40; i ++)
     854             :         {
     855        5280 :           if (i && i % 4 == 0)
     856        1188 :             buffer[j ++] = ' ';
     857        5280 :           if (i == 40 / 2)
     858         132 :             buffer[j ++] = ' ';
     859             : 
     860        5280 :           buffer[j ++] = fingerprint[i];
     861             :         }
     862         132 :       buffer[j ++] = 0;
     863         132 :       log_assert (j == space);
     864             :     }
     865             :   else
     866             :     {
     867           0 :       strcpy (buffer, fingerprint);
     868             :     }
     869             : 
     870         132 :   return buffer;
     871             : }
     872             : 
     873             : 
     874             : 
     875             : /* Return the so called KEYGRIP which is the SHA-1 hash of the public
     876             :    key parameters expressed as an canoncial encoded S-Exp.  ARRAY must
     877             :    be 20 bytes long.  Returns 0 on success or an error code.  */
     878             : gpg_error_t
     879        2107 : keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
     880             : {
     881             :   gpg_error_t err;
     882             :   gcry_sexp_t s_pkey;
     883             : 
     884        2107 :   if (DBG_PACKET)
     885           0 :     log_debug ("get_keygrip for public key\n");
     886             : 
     887        2107 :   switch (pk->pubkey_algo)
     888             :     {
     889             :     case GCRY_PK_DSA:
     890         494 :       err = gcry_sexp_build (&s_pkey, NULL,
     891             :                              "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
     892             :                              pk->pkey[0], pk->pkey[1],
     893             :                              pk->pkey[2], pk->pkey[3]);
     894         494 :       break;
     895             : 
     896             :     case GCRY_PK_ELG:
     897             :     case GCRY_PK_ELG_E:
     898        1064 :       err = gcry_sexp_build (&s_pkey, NULL,
     899             :                              "(public-key(elg(p%m)(g%m)(y%m)))",
     900             :                              pk->pkey[0], pk->pkey[1], pk->pkey[2]);
     901        1064 :       break;
     902             : 
     903             :     case GCRY_PK_RSA:
     904             :     case GCRY_PK_RSA_S:
     905             :     case GCRY_PK_RSA_E:
     906         359 :       err = gcry_sexp_build (&s_pkey, NULL,
     907             :                              "(public-key(rsa(n%m)(e%m)))",
     908             :                              pk->pkey[0], pk->pkey[1]);
     909         359 :       break;
     910             : 
     911             :     case PUBKEY_ALGO_EDDSA:
     912             :     case PUBKEY_ALGO_ECDSA:
     913             :     case PUBKEY_ALGO_ECDH:
     914             :       {
     915         190 :         char *curve = openpgp_oid_to_str (pk->pkey[0]);
     916         190 :         if (!curve)
     917           0 :           err = gpg_error_from_syserror ();
     918             :         else
     919             :           {
     920         569 :             err = gcry_sexp_build (&s_pkey, NULL,
     921         190 :                                    pk->pubkey_algo == PUBKEY_ALGO_EDDSA?
     922         189 :                                    "(public-key(ecc(curve%s)(flags eddsa)(q%m)))":
     923         189 :                                    (pk->pubkey_algo == PUBKEY_ALGO_ECDH
     924         117 :                                     && openpgp_oid_is_cv25519 (pk->pkey[0]))?
     925             :                                    "(public-key(ecc(curve%s)(flags djb-tweak)(q%m)))":
     926             :                                    "(public-key(ecc(curve%s)(q%m)))",
     927             :                                    curve, pk->pkey[1]);
     928         190 :             xfree (curve);
     929             :           }
     930             :       }
     931         190 :       break;
     932             : 
     933             :     default:
     934           0 :       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
     935           0 :       break;
     936             :     }
     937             : 
     938        2107 :   if (err)
     939           0 :     return err;
     940             : 
     941        2107 :   if (!gcry_pk_get_keygrip (s_pkey, array))
     942             :     {
     943           0 :       log_info ("error computing keygrip\n");
     944           0 :       memset (array, 0, 20);
     945           0 :       err = gpg_error (GPG_ERR_GENERAL);
     946             :     }
     947             :   else
     948             :     {
     949        2107 :       if (DBG_PACKET)
     950           0 :         log_printhex ("keygrip=", array, 20);
     951             :       /* FIXME: Save the keygrip in PK.  */
     952             :     }
     953        2107 :   gcry_sexp_release (s_pkey);
     954             : 
     955        2107 :   return err;
     956             : }
     957             : 
     958             : 
     959             : /* Store an allocated buffer with the keygrip of PK encoded as a
     960             :    hexstring at r_GRIP.  Returns 0 on success.  */
     961             : gpg_error_t
     962        1239 : hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip)
     963             : {
     964             :   gpg_error_t err;
     965             :   unsigned char grip[20];
     966             : 
     967        1239 :   *r_grip = NULL;
     968        1239 :   err = keygrip_from_pk (pk, grip);
     969        1239 :   if (!err)
     970             :     {
     971        1239 :       char * buf = xtrymalloc (20*2+1);
     972        1239 :       if (!buf)
     973           0 :         err = gpg_error_from_syserror ();
     974             :       else
     975             :         {
     976        1239 :           bin2hex (grip, 20, buf);
     977        1239 :           *r_grip = buf;
     978             :         }
     979             :     }
     980        1239 :   return err;
     981             : }

Generated by: LCOV version 1.11