LCOV - code coverage report
Current view: top level - g10 - keygen.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 627 2349 26.7 %
Date: 2016-09-12 12:29:17 Functions: 39 73 53.4 %

          Line data    Source code
       1             : /* keygen.c - Generate a key pair
       2             :  * Copyright (C) 1998-2007, 2009-2011  Free Software Foundation, Inc.
       3             :  * Copyright (C) 2014, 2015, 2016  Werner Koch
       4             :  *
       5             :  * This file is part of GnuPG.
       6             :  *
       7             :  * GnuPG is free software; you can redistribute it and/or modify
       8             :  * it under the terms of the GNU General Public License as published by
       9             :  * the Free Software Foundation; either version 3 of the License, or
      10             :  * (at your option) any later version.
      11             :  *
      12             :  * GnuPG is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  * GNU General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU General Public License
      18             :  * along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <string.h>
      25             : #include <ctype.h>
      26             : #include <errno.h>
      27             : #include <sys/types.h>
      28             : #include <sys/stat.h>
      29             : #include <unistd.h>
      30             : 
      31             : #include "gpg.h"
      32             : #include "util.h"
      33             : #include "main.h"
      34             : #include "packet.h"
      35             : #include "ttyio.h"
      36             : #include "options.h"
      37             : #include "keydb.h"
      38             : #include "trustdb.h"
      39             : #include "status.h"
      40             : #include "i18n.h"
      41             : #include "keyserver-internal.h"
      42             : #include "call-agent.h"
      43             : #include "pkglue.h"
      44             : #include "../common/shareddefs.h"
      45             : #include "host2net.h"
      46             : #include "mbox-util.h"
      47             : 
      48             : 
      49             : /* The default algorithms.  If you change them remember to change them
      50             :    also in gpg.c:gpgconf_list.  You should also check that the value
      51             :    is inside the bounds enforced by ask_keysize and gen_xxx.  */
      52             : #define DEFAULT_STD_ALGO       PUBKEY_ALGO_RSA
      53             : #define DEFAULT_STD_KEYSIZE    2048
      54             : #define DEFAULT_STD_KEYUSE     (PUBKEY_USAGE_CERT|PUBKEY_USAGE_SIG)
      55             : #define DEFAULT_STD_CURVE      NULL
      56             : #define DEFAULT_STD_SUBALGO    PUBKEY_ALGO_RSA
      57             : #define DEFAULT_STD_SUBKEYSIZE 2048
      58             : #define DEFAULT_STD_SUBKEYUSE  PUBKEY_USAGE_ENC
      59             : #define DEFAULT_STD_SUBCURVE   NULL
      60             : 
      61             : /* Flag bits used during key generation.  */
      62             : #define KEYGEN_FLAG_NO_PROTECTION 1
      63             : #define KEYGEN_FLAG_TRANSIENT_KEY 2
      64             : 
      65             : /* Maximum number of supported algorithm preferences.  */
      66             : #define MAX_PREFS 30
      67             : 
      68             : enum para_name {
      69             :   pKEYTYPE,
      70             :   pKEYLENGTH,
      71             :   pKEYCURVE,
      72             :   pKEYUSAGE,
      73             :   pSUBKEYTYPE,
      74             :   pSUBKEYLENGTH,
      75             :   pSUBKEYCURVE,
      76             :   pSUBKEYUSAGE,
      77             :   pAUTHKEYTYPE,
      78             :   pNAMEREAL,
      79             :   pNAMEEMAIL,
      80             :   pNAMECOMMENT,
      81             :   pPREFERENCES,
      82             :   pREVOKER,
      83             :   pUSERID,
      84             :   pCREATIONDATE,
      85             :   pKEYCREATIONDATE, /* Same in seconds since epoch.  */
      86             :   pEXPIREDATE,
      87             :   pKEYEXPIRE, /* in n seconds */
      88             :   pSUBKEYEXPIRE, /* in n seconds */
      89             :   pPASSPHRASE,
      90             :   pSERIALNO,
      91             :   pCARDBACKUPKEY,
      92             :   pHANDLE,
      93             :   pKEYSERVER
      94             : };
      95             : 
      96             : struct para_data_s {
      97             :     struct para_data_s *next;
      98             :     int lnr;
      99             :     enum para_name key;
     100             :     union {
     101             :         u32 expire;
     102             :         u32 creation;
     103             :         unsigned int usage;
     104             :         struct revocation_key revkey;
     105             :         char value[1];
     106             :     } u;
     107             : };
     108             : 
     109             : struct output_control_s
     110             : {
     111             :   int lnr;
     112             :   int dryrun;
     113             :   unsigned int keygen_flags;
     114             :   int use_files;
     115             :   struct {
     116             :     char  *fname;
     117             :     char  *newfname;
     118             :     IOBUF stream;
     119             :     armor_filter_context_t *afx;
     120             :   } pub;
     121             : };
     122             : 
     123             : 
     124             : struct opaque_data_usage_and_pk {
     125             :     unsigned int usage;
     126             :     PKT_public_key *pk;
     127             : };
     128             : 
     129             : 
     130             : static int prefs_initialized = 0;
     131             : static byte sym_prefs[MAX_PREFS];
     132             : static int nsym_prefs;
     133             : static byte hash_prefs[MAX_PREFS];
     134             : static int nhash_prefs;
     135             : static byte zip_prefs[MAX_PREFS];
     136             : static int nzip_prefs;
     137             : static int mdc_available,ks_modify;
     138             : 
     139             : static gpg_error_t parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
     140             :                                      const char *algostr, const char *usagestr,
     141             :                                      const char *expirestr,
     142             :                                      int *r_algo, unsigned int *r_usage,
     143             :                                      u32 *r_expire,
     144             :                                      unsigned int *r_nbits, char **r_curve);
     145             : static void do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
     146             :                                  struct output_control_s *outctrl, int card );
     147             : static int write_keyblock (iobuf_t out, kbnode_t node);
     148             : static gpg_error_t gen_card_key (int algo, int keyno, int is_primary,
     149             :                                  kbnode_t pub_root,
     150             :                                  u32 *timestamp, u32 expireval);
     151             : 
     152             : 
     153             : static void
     154           2 : print_status_key_created (int letter, PKT_public_key *pk, const char *handle)
     155             : {
     156             :   byte array[MAX_FINGERPRINT_LEN], *s;
     157             :   char *buf, *p;
     158             :   size_t i, n;
     159             : 
     160           2 :   if (!handle)
     161           2 :     handle = "";
     162             : 
     163           2 :   buf = xmalloc (MAX_FINGERPRINT_LEN*2+31 + strlen (handle) + 1);
     164             : 
     165           2 :   p = buf;
     166           2 :   if (letter || pk)
     167             :     {
     168           2 :       *p++ = letter;
     169           2 :       if (pk)
     170             :         {
     171           2 :           *p++ = ' ';
     172           2 :           fingerprint_from_pk (pk, array, &n);
     173           2 :           s = array;
     174          42 :           for (i=0; i < n ; i++, s++, p += 2)
     175          40 :             sprintf (p, "%02X", *s);
     176             :         }
     177             :     }
     178           2 :   if (*handle)
     179             :     {
     180           0 :       *p++ = ' ';
     181           0 :       for (i=0; handle[i] && i < 100; i++)
     182           0 :         *p++ = isspace ((unsigned int)handle[i])? '_':handle[i];
     183             :     }
     184           2 :   *p = 0;
     185           2 :   write_status_text ((letter || pk)?STATUS_KEY_CREATED:STATUS_KEY_NOT_CREATED,
     186             :                      buf);
     187           2 :   xfree (buf);
     188           2 : }
     189             : 
     190             : static void
     191           0 : print_status_key_not_created (const char *handle)
     192             : {
     193           0 :   print_status_key_created (0, NULL, handle);
     194           0 : }
     195             : 
     196             : 
     197             : 
     198             : static void
     199           2 : write_uid( KBNODE root, const char *s )
     200             : {
     201           2 :     PACKET *pkt = xmalloc_clear(sizeof *pkt );
     202           2 :     size_t n = strlen(s);
     203             : 
     204           2 :     pkt->pkttype = PKT_USER_ID;
     205           2 :     pkt->pkt.user_id = xmalloc_clear (sizeof *pkt->pkt.user_id + n);
     206           2 :     pkt->pkt.user_id->len = n;
     207           2 :     pkt->pkt.user_id->ref = 1;
     208           2 :     strcpy(pkt->pkt.user_id->name, s);
     209           2 :     add_kbnode( root, new_kbnode( pkt ) );
     210           2 : }
     211             : 
     212             : static void
     213           3 : do_add_key_flags (PKT_signature *sig, unsigned int use)
     214             : {
     215             :     byte buf[1];
     216             : 
     217           3 :     buf[0] = 0;
     218             : 
     219             :     /* The spec says that all primary keys MUST be able to certify. */
     220           3 :     if(sig->sig_class!=0x18)
     221           2 :       buf[0] |= 0x01;
     222             : 
     223           3 :     if (use & PUBKEY_USAGE_SIG)
     224           2 :       buf[0] |= 0x02;
     225           3 :     if (use & PUBKEY_USAGE_ENC)
     226           2 :         buf[0] |= 0x04 | 0x08;
     227           3 :     if (use & PUBKEY_USAGE_AUTH)
     228           1 :         buf[0] |= 0x20;
     229             : 
     230           3 :     build_sig_subpkt (sig, SIGSUBPKT_KEY_FLAGS, buf, 1);
     231           3 : }
     232             : 
     233             : 
     234             : int
     235           3 : keygen_add_key_expire (PKT_signature *sig, void *opaque)
     236             : {
     237           3 :   PKT_public_key *pk = opaque;
     238             :   byte buf[8];
     239             :   u32  u;
     240             : 
     241           3 :   if (pk->expiredate)
     242             :     {
     243           3 :       if (pk->expiredate > pk->timestamp)
     244           3 :         u = pk->expiredate - pk->timestamp;
     245             :       else
     246           0 :         u = 1;
     247             : 
     248           3 :       buf[0] = (u >> 24) & 0xff;
     249           3 :       buf[1] = (u >> 16) & 0xff;
     250           3 :       buf[2] = (u >>      8) & 0xff;
     251           3 :       buf[3] = u & 0xff;
     252           3 :       build_sig_subpkt (sig, SIGSUBPKT_KEY_EXPIRE, buf, 4);
     253             :     }
     254             :   else
     255             :     {
     256             :       /* Make sure we don't leave a key expiration subpacket lying
     257             :          around */
     258           0 :       delete_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE);
     259             :     }
     260             : 
     261           3 :   return 0;
     262             : }
     263             : 
     264             : 
     265             : /* Add the key usage (i.e. key flags) in SIG from the public keys
     266             :  * pubkey_usage field.  OPAQUE has the public key.  */
     267             : int
     268           0 : keygen_add_key_flags (PKT_signature *sig, void *opaque)
     269             : {
     270           0 :   PKT_public_key *pk = opaque;
     271             : 
     272           0 :   do_add_key_flags (sig, pk->pubkey_usage);
     273           0 :   return 0;
     274             : }
     275             : 
     276             : 
     277             : static int
     278           1 : keygen_add_key_flags_and_expire (PKT_signature *sig, void *opaque)
     279             : {
     280           1 :   struct opaque_data_usage_and_pk *oduap = opaque;
     281             : 
     282           1 :   do_add_key_flags (sig, oduap->usage);
     283           1 :   return keygen_add_key_expire (sig, oduap->pk);
     284             : }
     285             : 
     286             : 
     287             : static int
     288          24 : set_one_pref (int val, int type, const char *item, byte *buf, int *nbuf)
     289             : {
     290             :     int i;
     291             : 
     292          62 :     for (i=0; i < *nbuf; i++ )
     293          38 :       if (buf[i] == val)
     294             :         {
     295           0 :           log_info (_("preference '%s' duplicated\n"), item);
     296           0 :           return -1;
     297             :         }
     298             : 
     299          24 :     if (*nbuf >= MAX_PREFS)
     300             :       {
     301           0 :         if(type==1)
     302           0 :           log_info(_("too many cipher preferences\n"));
     303           0 :         else if(type==2)
     304           0 :           log_info(_("too many digest preferences\n"));
     305           0 :         else if(type==3)
     306           0 :           log_info(_("too many compression preferences\n"));
     307             :         else
     308           0 :           BUG();
     309             : 
     310           0 :         return -1;
     311             :       }
     312             : 
     313          24 :     buf[(*nbuf)++] = val;
     314          24 :     return 0;
     315             : }
     316             : 
     317             : /*
     318             :  * Parse the supplied string and use it to set the standard
     319             :  * preferences.  The string may be in a form like the one printed by
     320             :  * "pref" (something like: "S10 S3 H3 H2 Z2 Z1") or the actual
     321             :  * cipher/hash/compress names.  Use NULL to set the default
     322             :  * preferences.  Returns: 0 = okay
     323             :  */
     324             : int
     325           2 : keygen_set_std_prefs (const char *string,int personal)
     326             : {
     327             :     byte sym[MAX_PREFS], hash[MAX_PREFS], zip[MAX_PREFS];
     328           2 :     int nsym=0, nhash=0, nzip=0, val, rc=0;
     329           2 :     int mdc=1, modify=0; /* mdc defaults on, modify defaults off. */
     330             :     char dummy_string[20*4+1]; /* Enough for 20 items. */
     331             : 
     332           2 :     if (!string || !ascii_strcasecmp (string, "default"))
     333             :       {
     334           4 :         if (opt.def_preference_list)
     335           0 :           string=opt.def_preference_list;
     336             :         else
     337             :           {
     338           2 :             int any_compress = 0;
     339           2 :             dummy_string[0]='\0';
     340             : 
     341             :             /* The rationale why we use the order AES256,192,128 is
     342             :                for compatibility reasons with PGP.  If gpg would
     343             :                define AES128 first, we would get the somewhat
     344             :                confusing situation:
     345             : 
     346             :                  gpg -r pgpkey -r gpgkey  ---gives--> AES256
     347             :                  gpg -r gpgkey -r pgpkey  ---gives--> AES
     348             : 
     349             :                Note that by using --personal-cipher-preferences it is
     350             :                possible to prefer AES128.
     351             :             */
     352             : 
     353             :             /* Make sure we do not add more than 15 items here, as we
     354             :                could overflow the size of dummy_string.  We currently
     355             :                have at most 12. */
     356           2 :             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES256) )
     357           2 :               strcat(dummy_string,"S9 ");
     358           2 :             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES192) )
     359           2 :               strcat(dummy_string,"S8 ");
     360           2 :             if ( !openpgp_cipher_test_algo (CIPHER_ALGO_AES) )
     361           2 :               strcat(dummy_string,"S7 ");
     362           2 :             strcat(dummy_string,"S2 "); /* 3DES */
     363             : 
     364             :             /* The default hash algo order is:
     365             :                  SHA-256, SHA-384, SHA-512, SHA-224, SHA-1.
     366             :              */
     367           2 :             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA256))
     368           2 :               strcat (dummy_string, "H8 ");
     369             : 
     370           2 :             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA384))
     371           2 :               strcat (dummy_string, "H9 ");
     372             : 
     373           2 :             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA512))
     374           2 :               strcat (dummy_string, "H10 ");
     375             : 
     376           2 :             if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
     377           2 :               strcat (dummy_string, "H11 ");
     378             : 
     379           2 :             strcat (dummy_string, "H2 "); /* SHA-1 */
     380             : 
     381           2 :             if(!check_compress_algo(COMPRESS_ALGO_ZLIB))
     382             :               {
     383           2 :                 strcat(dummy_string,"Z2 ");
     384           2 :                 any_compress = 1;
     385             :               }
     386             : 
     387           2 :             if(!check_compress_algo(COMPRESS_ALGO_BZIP2))
     388             :               {
     389           2 :                 strcat(dummy_string,"Z3 ");
     390           2 :                 any_compress = 1;
     391             :               }
     392             : 
     393           2 :             if(!check_compress_algo(COMPRESS_ALGO_ZIP))
     394             :               {
     395           2 :                 strcat(dummy_string,"Z1 ");
     396           2 :                 any_compress = 1;
     397             :               }
     398             : 
     399             :             /* In case we have no compress algo at all, declare that
     400             :                we prefer no compresssion.  */
     401           2 :             if (!any_compress)
     402           0 :               strcat(dummy_string,"Z0 ");
     403             : 
     404             :             /* Remove the trailing space.  */
     405           2 :             if (*dummy_string && dummy_string[strlen (dummy_string)-1] == ' ')
     406           2 :               dummy_string[strlen (dummy_string)-1] = 0;
     407             : 
     408           2 :             string=dummy_string;
     409             :           }
     410             :       }
     411           0 :     else if (!ascii_strcasecmp (string, "none"))
     412           0 :         string = "";
     413             : 
     414           2 :     if(strlen(string))
     415             :       {
     416             :         char *dup, *tok, *prefstring;
     417             : 
     418           2 :         dup = prefstring = xstrdup (string); /* need a writable string! */
     419             : 
     420          28 :         while((tok=strsep(&prefstring," ,")))
     421             :           {
     422          24 :             if((val=string_to_cipher_algo (tok)))
     423             :               {
     424           8 :                 if(set_one_pref(val,1,tok,sym,&nsym))
     425           0 :                   rc=-1;
     426             :               }
     427          16 :             else if((val=string_to_digest_algo (tok)))
     428             :               {
     429          10 :                 if(set_one_pref(val,2,tok,hash,&nhash))
     430           0 :                   rc=-1;
     431             :               }
     432           6 :             else if((val=string_to_compress_algo(tok))>-1)
     433             :               {
     434           6 :                 if(set_one_pref(val,3,tok,zip,&nzip))
     435           0 :                   rc=-1;
     436             :               }
     437           0 :             else if (ascii_strcasecmp(tok,"mdc")==0)
     438           0 :               mdc=1;
     439           0 :             else if (ascii_strcasecmp(tok,"no-mdc")==0)
     440           0 :               mdc=0;
     441           0 :             else if (ascii_strcasecmp(tok,"ks-modify")==0)
     442           0 :               modify=1;
     443           0 :             else if (ascii_strcasecmp(tok,"no-ks-modify")==0)
     444           0 :               modify=0;
     445             :             else
     446             :               {
     447           0 :                 log_info (_("invalid item '%s' in preference string\n"),tok);
     448           0 :                 rc=-1;
     449             :               }
     450             :           }
     451             : 
     452           2 :         xfree (dup);
     453             :       }
     454             : 
     455           2 :     if(!rc)
     456             :       {
     457           2 :         if(personal)
     458             :           {
     459           0 :             if(personal==PREFTYPE_SYM)
     460             :               {
     461           0 :                 xfree(opt.personal_cipher_prefs);
     462             : 
     463           0 :                 if(nsym==0)
     464           0 :                   opt.personal_cipher_prefs=NULL;
     465             :                 else
     466             :                   {
     467             :                     int i;
     468             : 
     469           0 :                     opt.personal_cipher_prefs=
     470           0 :                       xmalloc(sizeof(prefitem_t *)*(nsym+1));
     471             : 
     472           0 :                     for (i=0; i<nsym; i++)
     473             :                       {
     474           0 :                         opt.personal_cipher_prefs[i].type = PREFTYPE_SYM;
     475           0 :                         opt.personal_cipher_prefs[i].value = sym[i];
     476             :                       }
     477             : 
     478           0 :                     opt.personal_cipher_prefs[i].type = PREFTYPE_NONE;
     479           0 :                     opt.personal_cipher_prefs[i].value = 0;
     480             :                   }
     481             :               }
     482           0 :             else if(personal==PREFTYPE_HASH)
     483             :               {
     484           0 :                 xfree(opt.personal_digest_prefs);
     485             : 
     486           0 :                 if(nhash==0)
     487           0 :                   opt.personal_digest_prefs=NULL;
     488             :                 else
     489             :                   {
     490             :                     int i;
     491             : 
     492           0 :                     opt.personal_digest_prefs=
     493           0 :                       xmalloc(sizeof(prefitem_t *)*(nhash+1));
     494             : 
     495           0 :                     for (i=0; i<nhash; i++)
     496             :                       {
     497           0 :                         opt.personal_digest_prefs[i].type = PREFTYPE_HASH;
     498           0 :                         opt.personal_digest_prefs[i].value = hash[i];
     499             :                       }
     500             : 
     501           0 :                     opt.personal_digest_prefs[i].type = PREFTYPE_NONE;
     502           0 :                     opt.personal_digest_prefs[i].value = 0;
     503             :                   }
     504             :               }
     505           0 :             else if(personal==PREFTYPE_ZIP)
     506             :               {
     507           0 :                 xfree(opt.personal_compress_prefs);
     508             : 
     509           0 :                 if(nzip==0)
     510           0 :                   opt.personal_compress_prefs=NULL;
     511             :                 else
     512             :                   {
     513             :                     int i;
     514             : 
     515           0 :                     opt.personal_compress_prefs=
     516           0 :                       xmalloc(sizeof(prefitem_t *)*(nzip+1));
     517             : 
     518           0 :                     for (i=0; i<nzip; i++)
     519             :                       {
     520           0 :                         opt.personal_compress_prefs[i].type = PREFTYPE_ZIP;
     521           0 :                         opt.personal_compress_prefs[i].value = zip[i];
     522             :                       }
     523             : 
     524           0 :                     opt.personal_compress_prefs[i].type = PREFTYPE_NONE;
     525           0 :                     opt.personal_compress_prefs[i].value = 0;
     526             :                   }
     527             :               }
     528             :           }
     529             :         else
     530             :           {
     531           2 :             memcpy (sym_prefs,  sym,  (nsym_prefs=nsym));
     532           2 :             memcpy (hash_prefs, hash, (nhash_prefs=nhash));
     533           2 :             memcpy (zip_prefs,  zip,  (nzip_prefs=nzip));
     534           2 :             mdc_available = mdc;
     535           2 :             ks_modify = modify;
     536           2 :             prefs_initialized = 1;
     537             :           }
     538             :       }
     539             : 
     540           2 :     return rc;
     541             : }
     542             : 
     543             : /* Return a fake user ID containing the preferences.  Caller must
     544             :    free. */
     545             : PKT_user_id *
     546           0 : keygen_get_std_prefs(void)
     547             : {
     548           0 :   int i,j=0;
     549           0 :   PKT_user_id *uid=xmalloc_clear(sizeof(PKT_user_id));
     550             : 
     551           0 :   if(!prefs_initialized)
     552           0 :     keygen_set_std_prefs(NULL,0);
     553             : 
     554           0 :   uid->ref=1;
     555             : 
     556           0 :   uid->prefs=xmalloc((sizeof(prefitem_t *)*
     557             :                       (nsym_prefs+nhash_prefs+nzip_prefs+1)));
     558             : 
     559           0 :   for(i=0;i<nsym_prefs;i++,j++)
     560             :     {
     561           0 :       uid->prefs[j].type=PREFTYPE_SYM;
     562           0 :       uid->prefs[j].value=sym_prefs[i];
     563             :     }
     564             : 
     565           0 :   for(i=0;i<nhash_prefs;i++,j++)
     566             :     {
     567           0 :       uid->prefs[j].type=PREFTYPE_HASH;
     568           0 :       uid->prefs[j].value=hash_prefs[i];
     569             :     }
     570             : 
     571           0 :   for(i=0;i<nzip_prefs;i++,j++)
     572             :     {
     573           0 :       uid->prefs[j].type=PREFTYPE_ZIP;
     574           0 :       uid->prefs[j].value=zip_prefs[i];
     575             :     }
     576             : 
     577           0 :   uid->prefs[j].type=PREFTYPE_NONE;
     578           0 :   uid->prefs[j].value=0;
     579             : 
     580           0 :   uid->flags.mdc=mdc_available;
     581           0 :   uid->flags.ks_modify=ks_modify;
     582             : 
     583           0 :   return uid;
     584             : }
     585             : 
     586             : static void
     587           2 : add_feature_mdc (PKT_signature *sig,int enabled)
     588             : {
     589             :     const byte *s;
     590             :     size_t n;
     591             :     int i;
     592             :     char *buf;
     593             : 
     594           2 :     s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES, &n );
     595             :     /* Already set or cleared */
     596           2 :     if (s && n &&
     597           0 :         ((enabled && (s[0] & 0x01)) || (!enabled && !(s[0] & 0x01))))
     598           2 :       return;
     599             : 
     600           2 :     if (!s || !n) { /* create a new one */
     601           2 :         n = 1;
     602           2 :         buf = xmalloc_clear (n);
     603             :     }
     604             :     else {
     605           0 :         buf = xmalloc (n);
     606           0 :         memcpy (buf, s, n);
     607             :     }
     608             : 
     609           2 :     if(enabled)
     610           2 :       buf[0] |= 0x01; /* MDC feature */
     611             :     else
     612           0 :       buf[0] &= ~0x01;
     613             : 
     614             :     /* Are there any bits set? */
     615           2 :     for(i=0;i<n;i++)
     616           2 :       if(buf[i]!=0)
     617           2 :         break;
     618             : 
     619           2 :     if(i==n)
     620           0 :       delete_sig_subpkt (sig->hashed, SIGSUBPKT_FEATURES);
     621             :     else
     622           2 :       build_sig_subpkt (sig, SIGSUBPKT_FEATURES, buf, n);
     623             : 
     624           2 :     xfree (buf);
     625             : }
     626             : 
     627             : static void
     628           2 : add_keyserver_modify (PKT_signature *sig,int enabled)
     629             : {
     630             :   const byte *s;
     631             :   size_t n;
     632             :   int i;
     633             :   char *buf;
     634             : 
     635             :   /* The keyserver modify flag is a negative flag (i.e. no-modify) */
     636           2 :   enabled=!enabled;
     637             : 
     638           2 :   s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS, &n );
     639             :   /* Already set or cleared */
     640           2 :   if (s && n &&
     641           0 :       ((enabled && (s[0] & 0x80)) || (!enabled && !(s[0] & 0x80))))
     642           2 :     return;
     643             : 
     644           2 :   if (!s || !n) { /* create a new one */
     645           2 :     n = 1;
     646           2 :     buf = xmalloc_clear (n);
     647             :   }
     648             :   else {
     649           0 :     buf = xmalloc (n);
     650           0 :     memcpy (buf, s, n);
     651             :   }
     652             : 
     653           2 :   if(enabled)
     654           2 :     buf[0] |= 0x80; /* no-modify flag */
     655             :   else
     656           0 :     buf[0] &= ~0x80;
     657             : 
     658             :   /* Are there any bits set? */
     659           2 :   for(i=0;i<n;i++)
     660           2 :     if(buf[i]!=0)
     661           2 :       break;
     662             : 
     663           2 :   if(i==n)
     664           0 :     delete_sig_subpkt (sig->hashed, SIGSUBPKT_KS_FLAGS);
     665             :   else
     666           2 :     build_sig_subpkt (sig, SIGSUBPKT_KS_FLAGS, buf, n);
     667             : 
     668           2 :   xfree (buf);
     669             : }
     670             : 
     671             : 
     672             : int
     673           2 : keygen_upd_std_prefs (PKT_signature *sig, void *opaque)
     674             : {
     675             :   (void)opaque;
     676             : 
     677           2 :   if (!prefs_initialized)
     678           0 :     keygen_set_std_prefs (NULL, 0);
     679             : 
     680           2 :   if (nsym_prefs)
     681           2 :     build_sig_subpkt (sig, SIGSUBPKT_PREF_SYM, sym_prefs, nsym_prefs);
     682             :   else
     683             :     {
     684           0 :       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_SYM);
     685           0 :       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_SYM);
     686             :     }
     687             : 
     688           2 :   if (nhash_prefs)
     689           2 :     build_sig_subpkt (sig, SIGSUBPKT_PREF_HASH, hash_prefs, nhash_prefs);
     690             :   else
     691             :     {
     692           0 :       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_HASH);
     693           0 :       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_HASH);
     694             :     }
     695             : 
     696           2 :   if (nzip_prefs)
     697           2 :     build_sig_subpkt (sig, SIGSUBPKT_PREF_COMPR, zip_prefs, nzip_prefs);
     698             :   else
     699             :     {
     700           0 :       delete_sig_subpkt (sig->hashed, SIGSUBPKT_PREF_COMPR);
     701           0 :       delete_sig_subpkt (sig->unhashed, SIGSUBPKT_PREF_COMPR);
     702             :     }
     703             : 
     704             :   /* Make sure that the MDC feature flag is set if needed.  */
     705           2 :   add_feature_mdc (sig,mdc_available);
     706           2 :   add_keyserver_modify (sig,ks_modify);
     707           2 :   keygen_add_keyserver_url(sig,NULL);
     708             : 
     709           2 :   return 0;
     710             : }
     711             : 
     712             : 
     713             : /****************
     714             :  * Add preference to the self signature packet.
     715             :  * This is only called for packets with version > 3.
     716             :  */
     717             : int
     718           2 : keygen_add_std_prefs (PKT_signature *sig, void *opaque)
     719             : {
     720           2 :   PKT_public_key *pk = opaque;
     721             : 
     722           2 :   do_add_key_flags (sig, pk->pubkey_usage);
     723           2 :   keygen_add_key_expire (sig, opaque );
     724           2 :   keygen_upd_std_prefs (sig, opaque);
     725           2 :   keygen_add_keyserver_url (sig,NULL);
     726             : 
     727           2 :   return 0;
     728             : }
     729             : 
     730             : int
     731           4 : keygen_add_keyserver_url(PKT_signature *sig, void *opaque)
     732             : {
     733           4 :   const char *url=opaque;
     734             : 
     735           4 :   if(!url)
     736           4 :     url=opt.def_keyserver_url;
     737             : 
     738           4 :   if(url)
     739           0 :     build_sig_subpkt(sig,SIGSUBPKT_PREF_KS,url,strlen(url));
     740             :   else
     741           4 :     delete_sig_subpkt (sig->hashed,SIGSUBPKT_PREF_KS);
     742             : 
     743           4 :   return 0;
     744             : }
     745             : 
     746             : int
     747           0 : keygen_add_notations(PKT_signature *sig,void *opaque)
     748             : {
     749             :   struct notation *notation;
     750             : 
     751             :   /* We always start clean */
     752           0 :   delete_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION);
     753           0 :   delete_sig_subpkt(sig->unhashed,SIGSUBPKT_NOTATION);
     754           0 :   sig->flags.notation=0;
     755             : 
     756           0 :   for(notation=opaque;notation;notation=notation->next)
     757           0 :     if(!notation->flags.ignore)
     758             :       {
     759             :         unsigned char *buf;
     760             :         unsigned int n1,n2;
     761             : 
     762           0 :         n1=strlen(notation->name);
     763           0 :         if(notation->altvalue)
     764           0 :           n2=strlen(notation->altvalue);
     765           0 :         else if(notation->bdat)
     766           0 :           n2=notation->blen;
     767             :         else
     768           0 :           n2=strlen(notation->value);
     769             : 
     770           0 :         buf = xmalloc( 8 + n1 + n2 );
     771             : 
     772             :         /* human readable or not */
     773           0 :         buf[0] = notation->bdat?0:0x80;
     774           0 :         buf[1] = buf[2] = buf[3] = 0;
     775           0 :         buf[4] = n1 >> 8;
     776           0 :         buf[5] = n1;
     777           0 :         buf[6] = n2 >> 8;
     778           0 :         buf[7] = n2;
     779           0 :         memcpy(buf+8, notation->name, n1 );
     780           0 :         if(notation->altvalue)
     781           0 :           memcpy(buf+8+n1, notation->altvalue, n2 );
     782           0 :         else if(notation->bdat)
     783           0 :           memcpy(buf+8+n1, notation->bdat, n2 );
     784             :         else
     785           0 :           memcpy(buf+8+n1, notation->value, n2 );
     786           0 :         build_sig_subpkt( sig, SIGSUBPKT_NOTATION |
     787           0 :                           (notation->flags.critical?SIGSUBPKT_FLAG_CRITICAL:0),
     788           0 :                           buf, 8+n1+n2 );
     789           0 :         xfree(buf);
     790             :       }
     791             : 
     792           0 :   return 0;
     793             : }
     794             : 
     795             : int
     796           0 : keygen_add_revkey (PKT_signature *sig, void *opaque)
     797             : {
     798           0 :   struct revocation_key *revkey = opaque;
     799             :   byte buf[2+MAX_FINGERPRINT_LEN];
     800             : 
     801           0 :   buf[0] = revkey->class;
     802           0 :   buf[1] = revkey->algid;
     803           0 :   memcpy (&buf[2], revkey->fpr, MAX_FINGERPRINT_LEN);
     804             : 
     805           0 :   build_sig_subpkt (sig, SIGSUBPKT_REV_KEY, buf, 2+MAX_FINGERPRINT_LEN);
     806             : 
     807             :   /* All sigs with revocation keys set are nonrevocable.  */
     808           0 :   sig->flags.revocable = 0;
     809           0 :   buf[0] = 0;
     810           0 :   build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
     811             : 
     812           0 :   parse_revkeys (sig);
     813             : 
     814           0 :   return 0;
     815             : }
     816             : 
     817             : 
     818             : 
     819             : /* Create a back-signature.  If TIMESTAMP is not NULL, use it for the
     820             :    signature creation time.  */
     821             : gpg_error_t
     822           0 : make_backsig (PKT_signature *sig, PKT_public_key *pk,
     823             :               PKT_public_key *sub_pk, PKT_public_key *sub_psk,
     824             :               u32 timestamp, const char *cache_nonce)
     825             : {
     826             :   gpg_error_t err;
     827             :   PKT_signature *backsig;
     828             : 
     829           0 :   cache_public_key (sub_pk);
     830             : 
     831           0 :   err = make_keysig_packet (&backsig, pk, NULL, sub_pk, sub_psk, 0x19,
     832             :                             0, timestamp, 0, NULL, NULL, cache_nonce);
     833           0 :   if (err)
     834           0 :     log_error ("make_keysig_packet failed for backsig: %s\n",
     835             :                gpg_strerror (err));
     836             :   else
     837             :     {
     838             :       /* Get it into a binary packed form. */
     839           0 :       IOBUF backsig_out = iobuf_temp();
     840             :       PACKET backsig_pkt;
     841             : 
     842           0 :       init_packet (&backsig_pkt);
     843           0 :       backsig_pkt.pkttype = PKT_SIGNATURE;
     844           0 :       backsig_pkt.pkt.signature = backsig;
     845           0 :       err = build_packet (backsig_out, &backsig_pkt);
     846           0 :       free_packet (&backsig_pkt);
     847           0 :       if (err)
     848           0 :         log_error ("build_packet failed for backsig: %s\n", gpg_strerror (err));
     849             :       else
     850             :         {
     851           0 :           size_t pktlen = 0;
     852           0 :           byte *buf = iobuf_get_temp_buffer (backsig_out);
     853             : 
     854             :           /* Remove the packet header. */
     855           0 :           if(buf[0]&0x40)
     856             :             {
     857           0 :               if (buf[1] < 192)
     858             :                 {
     859           0 :                   pktlen = buf[1];
     860           0 :                   buf += 2;
     861             :                 }
     862           0 :               else if(buf[1] < 224)
     863             :                 {
     864           0 :                   pktlen = (buf[1]-192)*256;
     865           0 :                   pktlen += buf[2]+192;
     866           0 :                   buf += 3;
     867             :                 }
     868           0 :               else if (buf[1] == 255)
     869             :                 {
     870           0 :                   pktlen = buf32_to_size_t (buf+2);
     871           0 :                   buf += 6;
     872             :                 }
     873             :               else
     874           0 :                 BUG ();
     875             :             }
     876             :           else
     877             :             {
     878           0 :               int mark = 1;
     879             : 
     880           0 :               switch (buf[0]&3)
     881             :                 {
     882             :                 case 3:
     883           0 :                   BUG ();
     884             :                   break;
     885             : 
     886             :                 case 2:
     887           0 :                   pktlen  = (size_t)buf[mark++] << 24;
     888           0 :                   pktlen |= buf[mark++] << 16;
     889             : 
     890             :                 case 1:
     891           0 :                   pktlen |= buf[mark++] << 8;
     892             : 
     893             :                 case 0:
     894           0 :                   pktlen |= buf[mark++];
     895             :                 }
     896             : 
     897           0 :               buf += mark;
     898             :             }
     899             : 
     900             :           /* Now make the binary blob into a subpacket.  */
     901           0 :           build_sig_subpkt (sig, SIGSUBPKT_SIGNATURE, buf, pktlen);
     902             : 
     903           0 :           iobuf_close (backsig_out);
     904             :         }
     905             :     }
     906             : 
     907           0 :   return err;
     908             : }
     909             : 
     910             : 
     911             : /* Write a direct key signature to the first key in ROOT using the key
     912             :    PSK.  REVKEY is describes the direct key signature and TIMESTAMP is
     913             :    the timestamp to set on the signature.  */
     914             : static gpg_error_t
     915           0 : write_direct_sig (KBNODE root, PKT_public_key *psk,
     916             :                   struct revocation_key *revkey, u32 timestamp,
     917             :                   const char *cache_nonce)
     918             : {
     919             :   gpg_error_t err;
     920             :   PACKET *pkt;
     921             :   PKT_signature *sig;
     922             :   KBNODE node;
     923             :   PKT_public_key *pk;
     924             : 
     925           0 :   if (opt.verbose)
     926           0 :     log_info (_("writing direct signature\n"));
     927             : 
     928             :   /* Get the pk packet from the pub_tree. */
     929           0 :   node = find_kbnode (root, PKT_PUBLIC_KEY);
     930           0 :   if (!node)
     931           0 :     BUG ();
     932           0 :   pk = node->pkt->pkt.public_key;
     933             : 
     934             :   /* We have to cache the key, so that the verification of the
     935             :      signature creation is able to retrieve the public key.  */
     936           0 :   cache_public_key (pk);
     937             : 
     938             :   /* Make the signature.  */
     939           0 :   err = make_keysig_packet (&sig, pk, NULL,NULL, psk, 0x1F,
     940             :                             0, timestamp, 0,
     941             :                             keygen_add_revkey, revkey, cache_nonce);
     942           0 :   if (err)
     943             :     {
     944           0 :       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err) );
     945           0 :       return err;
     946             :     }
     947             : 
     948           0 :   pkt = xmalloc_clear (sizeof *pkt);
     949           0 :   pkt->pkttype = PKT_SIGNATURE;
     950           0 :   pkt->pkt.signature = sig;
     951           0 :   add_kbnode (root, new_kbnode (pkt));
     952           0 :   return err;
     953             : }
     954             : 
     955             : 
     956             : 
     957             : /* Write a self-signature to the first user id in ROOT using the key
     958             :    PSK.  USE and TIMESTAMP give the extra data we need for the
     959             :    signature.  */
     960             : static gpg_error_t
     961           2 : write_selfsigs (KBNODE root, PKT_public_key *psk,
     962             :                 unsigned int use, u32 timestamp, const char *cache_nonce)
     963             : {
     964             :   gpg_error_t err;
     965             :   PACKET *pkt;
     966             :   PKT_signature *sig;
     967             :   PKT_user_id *uid;
     968             :   KBNODE node;
     969             :   PKT_public_key *pk;
     970             : 
     971           2 :   if (opt.verbose)
     972           0 :     log_info (_("writing self signature\n"));
     973             : 
     974             :   /* Get the uid packet from the list. */
     975           2 :   node = find_kbnode (root, PKT_USER_ID);
     976           2 :   if (!node)
     977           0 :     BUG(); /* No user id packet in tree.  */
     978           2 :   uid = node->pkt->pkt.user_id;
     979             : 
     980             :   /* Get the pk packet from the pub_tree. */
     981           2 :   node = find_kbnode (root, PKT_PUBLIC_KEY);
     982           2 :   if (!node)
     983           0 :     BUG();
     984           2 :   pk = node->pkt->pkt.public_key;
     985             : 
     986             :   /* The usage has not yet been set - do it now. */
     987           2 :   pk->pubkey_usage = use;
     988             : 
     989             :   /* We have to cache the key, so that the verification of the
     990             :      signature creation is able to retrieve the public key.  */
     991           2 :   cache_public_key (pk);
     992             : 
     993             :   /* Make the signature.  */
     994           2 :   err = make_keysig_packet (&sig, pk, uid, NULL, psk, 0x13,
     995             :                             0, timestamp, 0,
     996             :                             keygen_add_std_prefs, pk, cache_nonce);
     997           2 :   if (err)
     998             :     {
     999           0 :       log_error ("make_keysig_packet failed: %s\n", gpg_strerror (err));
    1000           0 :       return err;
    1001             :     }
    1002             : 
    1003           2 :   pkt = xmalloc_clear (sizeof *pkt);
    1004           2 :   pkt->pkttype = PKT_SIGNATURE;
    1005           2 :   pkt->pkt.signature = sig;
    1006           2 :   add_kbnode (root, new_kbnode (pkt));
    1007             : 
    1008           2 :   return err;
    1009             : }
    1010             : 
    1011             : 
    1012             : /* Write the key binding signature.  If TIMESTAMP is not NULL use the
    1013             :    signature creation time.  PRI_PSK is the key use for signing.
    1014             :    SUB_PSK is a key used to create a back-signature; that one is only
    1015             :    used if USE has the PUBKEY_USAGE_SIG capability.  */
    1016             : static int
    1017           1 : write_keybinding (KBNODE root, PKT_public_key *pri_psk, PKT_public_key *sub_psk,
    1018             :                   unsigned int use, u32 timestamp, const char *cache_nonce)
    1019             : {
    1020             :   gpg_error_t err;
    1021             :   PACKET *pkt;
    1022             :   PKT_signature *sig;
    1023             :   KBNODE node;
    1024             :   PKT_public_key *pri_pk, *sub_pk;
    1025             :   struct opaque_data_usage_and_pk oduap;
    1026             : 
    1027           1 :   if (opt.verbose)
    1028           0 :     log_info(_("writing key binding signature\n"));
    1029             : 
    1030             :   /* Get the primary pk packet from the tree.  */
    1031           1 :   node = find_kbnode (root, PKT_PUBLIC_KEY);
    1032           1 :   if (!node)
    1033           0 :     BUG();
    1034           1 :   pri_pk = node->pkt->pkt.public_key;
    1035             : 
    1036             :   /* We have to cache the key, so that the verification of the
    1037             :    * signature creation is able to retrieve the public key.  */
    1038           1 :   cache_public_key (pri_pk);
    1039             : 
    1040             :   /* Find the last subkey. */
    1041           1 :   sub_pk = NULL;
    1042           6 :   for (node = root; node; node = node->next )
    1043             :     {
    1044           5 :       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
    1045           1 :         sub_pk = node->pkt->pkt.public_key;
    1046             :     }
    1047           1 :   if (!sub_pk)
    1048           0 :     BUG();
    1049             : 
    1050             :   /* Make the signature.  */
    1051           1 :   oduap.usage = use;
    1052           1 :   oduap.pk = sub_pk;
    1053           1 :   err = make_keysig_packet (&sig, pri_pk, NULL, sub_pk, pri_psk, 0x18,
    1054             :                             0, timestamp, 0,
    1055             :                             keygen_add_key_flags_and_expire, &oduap,
    1056             :                             cache_nonce);
    1057           1 :   if (err)
    1058             :     {
    1059           0 :       log_error ("make_keysig_packeto failed: %s\n", gpg_strerror (err));
    1060           0 :       return err;
    1061             :     }
    1062             : 
    1063             :   /* Make a backsig.  */
    1064           1 :   if (use & PUBKEY_USAGE_SIG)
    1065             :     {
    1066           0 :       err = make_backsig (sig, pri_pk, sub_pk, sub_psk, timestamp, cache_nonce);
    1067           0 :       if (err)
    1068           0 :         return err;
    1069             :     }
    1070             : 
    1071           1 :   pkt = xmalloc_clear ( sizeof *pkt );
    1072           1 :   pkt->pkttype = PKT_SIGNATURE;
    1073           1 :   pkt->pkt.signature = sig;
    1074           1 :   add_kbnode (root, new_kbnode (pkt) );
    1075           1 :   return err;
    1076             : }
    1077             : 
    1078             : 
    1079             : static gpg_error_t
    1080           0 : ecckey_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp, int algo)
    1081             : {
    1082             :   gpg_error_t err;
    1083             :   gcry_sexp_t list, l2;
    1084             :   char *curve;
    1085             :   int i;
    1086             :   const char *oidstr;
    1087             :   unsigned int nbits;
    1088             : 
    1089           0 :   array[0] = NULL;
    1090           0 :   array[1] = NULL;
    1091           0 :   array[2] = NULL;
    1092             : 
    1093           0 :   list = gcry_sexp_find_token (sexp, "public-key", 0);
    1094           0 :   if (!list)
    1095           0 :     return gpg_error (GPG_ERR_INV_OBJ);
    1096           0 :   l2 = gcry_sexp_cadr (list);
    1097           0 :   gcry_sexp_release (list);
    1098           0 :   list = l2;
    1099           0 :   if (!list)
    1100           0 :     return gpg_error (GPG_ERR_NO_OBJ);
    1101             : 
    1102           0 :   l2 = gcry_sexp_find_token (list, "curve", 0);
    1103           0 :   if (!l2)
    1104             :     {
    1105           0 :       err = gpg_error (GPG_ERR_NO_OBJ);
    1106           0 :       goto leave;
    1107             :     }
    1108           0 :   curve = gcry_sexp_nth_string (l2, 1);
    1109           0 :   if (!curve)
    1110             :     {
    1111           0 :       err = gpg_error (GPG_ERR_NO_OBJ);
    1112           0 :       goto leave;
    1113             :     }
    1114           0 :   gcry_sexp_release (l2);
    1115           0 :   oidstr = openpgp_curve_to_oid (curve, &nbits);
    1116           0 :   if (!oidstr)
    1117             :     {
    1118             :       /* That can't happen because we used one of the curves
    1119             :          gpg_curve_to_oid knows about.  */
    1120           0 :       err = gpg_error (GPG_ERR_INV_OBJ);
    1121           0 :       goto leave;
    1122             :     }
    1123           0 :   err = openpgp_oid_from_str (oidstr, &array[0]);
    1124           0 :   if (err)
    1125           0 :     goto leave;
    1126             : 
    1127           0 :   l2 = gcry_sexp_find_token (list, "q", 0);
    1128           0 :   if (!l2)
    1129             :     {
    1130           0 :       err = gpg_error (GPG_ERR_NO_OBJ);
    1131           0 :       goto leave;
    1132             :     }
    1133           0 :   array[1] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
    1134           0 :   gcry_sexp_release (l2);
    1135           0 :   if (!array[1])
    1136             :     {
    1137           0 :       err = gpg_error (GPG_ERR_INV_OBJ);
    1138           0 :       goto leave;
    1139             :     }
    1140           0 :   gcry_sexp_release (list);
    1141             : 
    1142           0 :   if (algo == PUBKEY_ALGO_ECDH)
    1143             :     {
    1144           0 :       array[2] = pk_ecdh_default_params (nbits);
    1145           0 :       if (!array[2])
    1146             :         {
    1147           0 :           err = gpg_error_from_syserror ();
    1148           0 :           goto leave;
    1149             :         }
    1150             :     }
    1151             : 
    1152             :  leave:
    1153           0 :   if (err)
    1154             :     {
    1155           0 :       for (i=0; i < 3; i++)
    1156             :         {
    1157           0 :           gcry_mpi_release (array[i]);
    1158           0 :           array[i] = NULL;
    1159             :         }
    1160             :     }
    1161           0 :   return err;
    1162             : }
    1163             : 
    1164             : 
    1165             : /* Extract key parameters from SEXP and store them in ARRAY.  ELEMS is
    1166             :    a string where each character denotes a parameter name.  TOPNAME is
    1167             :    the name of the top element above the elements.  */
    1168             : static int
    1169           3 : key_from_sexp (gcry_mpi_t *array, gcry_sexp_t sexp,
    1170             :                const char *topname, const char *elems)
    1171             : {
    1172             :   gcry_sexp_t list, l2;
    1173             :   const char *s;
    1174             :   int i, idx;
    1175           3 :   int rc = 0;
    1176             : 
    1177           3 :   list = gcry_sexp_find_token (sexp, topname, 0);
    1178           3 :   if (!list)
    1179           0 :     return gpg_error (GPG_ERR_INV_OBJ);
    1180           3 :   l2 = gcry_sexp_cadr (list);
    1181           3 :   gcry_sexp_release (list);
    1182           3 :   list = l2;
    1183           3 :   if (!list)
    1184           0 :     return gpg_error (GPG_ERR_NO_OBJ);
    1185             : 
    1186          12 :   for (idx=0,s=elems; *s; s++, idx++)
    1187             :     {
    1188           9 :       l2 = gcry_sexp_find_token (list, s, 1);
    1189           9 :       if (!l2)
    1190             :         {
    1191           0 :           rc = gpg_error (GPG_ERR_NO_OBJ); /* required parameter not found */
    1192           0 :           goto leave;
    1193             :         }
    1194           9 :       array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
    1195           9 :       gcry_sexp_release (l2);
    1196           9 :       if (!array[idx])
    1197             :         {
    1198           0 :           rc = gpg_error (GPG_ERR_INV_OBJ); /* required parameter invalid */
    1199           0 :           goto leave;
    1200             :         }
    1201             :     }
    1202           3 :   gcry_sexp_release (list);
    1203             : 
    1204             :  leave:
    1205           3 :   if (rc)
    1206             :     {
    1207           0 :       for (i=0; i<idx; i++)
    1208             :         {
    1209           0 :           gcry_mpi_release (array[i]);
    1210           0 :           array[i] = NULL;
    1211             :         }
    1212           0 :       gcry_sexp_release (list);
    1213             :     }
    1214           3 :   return rc;
    1215             : }
    1216             : 
    1217             : 
    1218             : /* Create a keyblock using the given KEYGRIP.  ALGO is the OpenPGP
    1219             :    algorithm of that keygrip.  */
    1220             : static int
    1221           0 : do_create_from_keygrip (ctrl_t ctrl, int algo, const char *hexkeygrip,
    1222             :                         kbnode_t pub_root, u32 timestamp, u32 expireval,
    1223             :                         int is_subkey)
    1224             : {
    1225             :   int err;
    1226             :   PACKET *pkt;
    1227             :   PKT_public_key *pk;
    1228             :   gcry_sexp_t s_key;
    1229             :   const char *algoelem;
    1230             : 
    1231           0 :   if (hexkeygrip[0] == '&')
    1232           0 :     hexkeygrip++;
    1233             : 
    1234           0 :   switch (algo)
    1235             :     {
    1236           0 :     case PUBKEY_ALGO_RSA:       algoelem = "ne"; break;
    1237           0 :     case PUBKEY_ALGO_DSA:       algoelem = "pqgy"; break;
    1238           0 :     case PUBKEY_ALGO_ELGAMAL_E: algoelem = "pgy"; break;
    1239             :     case PUBKEY_ALGO_ECDH:
    1240           0 :     case PUBKEY_ALGO_ECDSA:     algoelem = ""; break;
    1241           0 :     case PUBKEY_ALGO_EDDSA:     algoelem = ""; break;
    1242           0 :     default: return gpg_error (GPG_ERR_INTERNAL);
    1243             :     }
    1244             : 
    1245             : 
    1246             :   /* Ask the agent for the public key matching HEXKEYGRIP.  */
    1247             :   {
    1248             :     unsigned char *public;
    1249             : 
    1250           0 :     err = agent_readkey (ctrl, 0, hexkeygrip, &public);
    1251           0 :     if (err)
    1252           0 :       return err;
    1253           0 :     err = gcry_sexp_sscan (&s_key, NULL,
    1254             :                            public, gcry_sexp_canon_len (public, 0, NULL, NULL));
    1255           0 :     xfree (public);
    1256           0 :     if (err)
    1257           0 :       return err;
    1258             :   }
    1259             : 
    1260             :   /* Build a public key packet.  */
    1261           0 :   pk = xtrycalloc (1, sizeof *pk);
    1262           0 :   if (!pk)
    1263             :     {
    1264           0 :       err = gpg_error_from_syserror ();
    1265           0 :       gcry_sexp_release (s_key);
    1266           0 :       return err;
    1267             :     }
    1268             : 
    1269           0 :   pk->timestamp = timestamp;
    1270           0 :   pk->version = 4;
    1271           0 :   if (expireval)
    1272           0 :     pk->expiredate = pk->timestamp + expireval;
    1273           0 :   pk->pubkey_algo = algo;
    1274             : 
    1275           0 :   if (algo == PUBKEY_ALGO_ECDSA
    1276           0 :       || algo == PUBKEY_ALGO_EDDSA
    1277           0 :       || algo == PUBKEY_ALGO_ECDH )
    1278           0 :     err = ecckey_from_sexp (pk->pkey, s_key, algo);
    1279             :   else
    1280           0 :     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
    1281           0 :   if (err)
    1282             :     {
    1283           0 :       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
    1284           0 :       gcry_sexp_release (s_key);
    1285           0 :       free_public_key (pk);
    1286           0 :       return err;
    1287             :     }
    1288           0 :   gcry_sexp_release (s_key);
    1289             : 
    1290           0 :   pkt = xtrycalloc (1, sizeof *pkt);
    1291           0 :   if (!pkt)
    1292             :     {
    1293           0 :       err = gpg_error_from_syserror ();
    1294           0 :       free_public_key (pk);
    1295           0 :       return err;
    1296             :     }
    1297             : 
    1298           0 :   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
    1299           0 :   pkt->pkt.public_key = pk;
    1300           0 :   add_kbnode (pub_root, new_kbnode (pkt));
    1301             : 
    1302           0 :   return 0;
    1303             : }
    1304             : 
    1305             : 
    1306             : /* Common code for the key generation function gen_xxx.  */
    1307             : static int
    1308           3 : common_gen (const char *keyparms, int algo, const char *algoelem,
    1309             :             kbnode_t pub_root, u32 timestamp, u32 expireval, int is_subkey,
    1310             :             int keygen_flags, const char *passphrase,
    1311             :             char **cache_nonce_addr, char **passwd_nonce_addr)
    1312             : {
    1313             :   int err;
    1314             :   PACKET *pkt;
    1315             :   PKT_public_key *pk;
    1316             :   gcry_sexp_t s_key;
    1317             : 
    1318           3 :   err = agent_genkey (NULL, cache_nonce_addr, passwd_nonce_addr, keyparms,
    1319           3 :                       !!(keygen_flags & KEYGEN_FLAG_NO_PROTECTION),
    1320             :                       passphrase,
    1321             :                       &s_key);
    1322           3 :   if (err)
    1323             :     {
    1324           0 :       log_error ("agent_genkey failed: %s\n", gpg_strerror (err) );
    1325           0 :       return err;
    1326             :     }
    1327             : 
    1328           3 :   pk = xtrycalloc (1, sizeof *pk);
    1329           3 :   if (!pk)
    1330             :     {
    1331           0 :       err = gpg_error_from_syserror ();
    1332           0 :       gcry_sexp_release (s_key);
    1333           0 :       return err;
    1334             :     }
    1335             : 
    1336           3 :   pk->timestamp = timestamp;
    1337           3 :   pk->version = 4;
    1338           3 :   if (expireval)
    1339           3 :     pk->expiredate = pk->timestamp + expireval;
    1340           3 :   pk->pubkey_algo = algo;
    1341             : 
    1342           3 :   if (algo == PUBKEY_ALGO_ECDSA
    1343           3 :       || algo == PUBKEY_ALGO_EDDSA
    1344           3 :       || algo == PUBKEY_ALGO_ECDH )
    1345           0 :     err = ecckey_from_sexp (pk->pkey, s_key, algo);
    1346             :   else
    1347           3 :     err = key_from_sexp (pk->pkey, s_key, "public-key", algoelem);
    1348           3 :   if (err)
    1349             :     {
    1350           0 :       log_error ("key_from_sexp failed: %s\n", gpg_strerror (err) );
    1351           0 :       gcry_sexp_release (s_key);
    1352           0 :       free_public_key (pk);
    1353           0 :       return err;
    1354             :     }
    1355           3 :   gcry_sexp_release (s_key);
    1356             : 
    1357           3 :   pkt = xtrycalloc (1, sizeof *pkt);
    1358           3 :   if (!pkt)
    1359             :     {
    1360           0 :       err = gpg_error_from_syserror ();
    1361           0 :       free_public_key (pk);
    1362           0 :       return err;
    1363             :     }
    1364             : 
    1365           3 :   pkt->pkttype = is_subkey ? PKT_PUBLIC_SUBKEY : PKT_PUBLIC_KEY;
    1366           3 :   pkt->pkt.public_key = pk;
    1367           3 :   add_kbnode (pub_root, new_kbnode (pkt));
    1368             : 
    1369           3 :   return 0;
    1370             : }
    1371             : 
    1372             : 
    1373             : /*
    1374             :  * Generate an Elgamal key.
    1375             :  */
    1376             : static int
    1377           1 : gen_elg (int algo, unsigned int nbits, KBNODE pub_root,
    1378             :          u32 timestamp, u32 expireval, int is_subkey,
    1379             :          int keygen_flags, const char *passphrase,
    1380             :          char **cache_nonce_addr, char **passwd_nonce_addr)
    1381             : {
    1382             :   int err;
    1383             :   char *keyparms;
    1384             :   char nbitsstr[35];
    1385             : 
    1386           1 :   log_assert (is_ELGAMAL (algo));
    1387             : 
    1388           1 :   if (nbits < 1024)
    1389             :     {
    1390           0 :       nbits = 2048;
    1391           0 :       log_info (_("keysize invalid; using %u bits\n"), nbits );
    1392             :     }
    1393           1 :   else if (nbits > 4096)
    1394             :     {
    1395           0 :       nbits = 4096;
    1396           0 :       log_info (_("keysize invalid; using %u bits\n"), nbits );
    1397             :     }
    1398             : 
    1399           1 :   if ((nbits % 32))
    1400             :     {
    1401           0 :       nbits = ((nbits + 31) / 32) * 32;
    1402           0 :       log_info (_("keysize rounded up to %u bits\n"), nbits );
    1403             :     }
    1404             : 
    1405             :   /* Note that we use transient-key only if no-protection has also
    1406             :      been enabled.  */
    1407           1 :   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
    1408           2 :   keyparms = xtryasprintf ("(genkey(%s(nbits %zu:%s)%s))",
    1409             :                            algo == GCRY_PK_ELG_E ? "openpgp-elg" :
    1410           0 :                            algo == GCRY_PK_ELG   ? "elg" : "x-oops" ,
    1411             :                            strlen (nbitsstr), nbitsstr,
    1412           1 :                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1413           1 :                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1414             :                            "(transient-key)" : "" );
    1415           1 :   if (!keyparms)
    1416           0 :     err = gpg_error_from_syserror ();
    1417             :   else
    1418             :     {
    1419           1 :       err = common_gen (keyparms, algo, "pgy",
    1420             :                         pub_root, timestamp, expireval, is_subkey,
    1421             :                         keygen_flags, passphrase,
    1422             :                         cache_nonce_addr, passwd_nonce_addr);
    1423           1 :       xfree (keyparms);
    1424             :     }
    1425             : 
    1426           1 :   return err;
    1427             : }
    1428             : 
    1429             : 
    1430             : /*
    1431             :  * Generate an DSA key
    1432             :  */
    1433             : static gpg_error_t
    1434           1 : gen_dsa (unsigned int nbits, KBNODE pub_root,
    1435             :          u32 timestamp, u32 expireval, int is_subkey,
    1436             :          int keygen_flags, const char *passphrase,
    1437             :          char **cache_nonce_addr, char **passwd_nonce_addr)
    1438             : {
    1439             :   int err;
    1440             :   unsigned int qbits;
    1441             :   char *keyparms;
    1442             :   char nbitsstr[35];
    1443             :   char qbitsstr[35];
    1444             : 
    1445           1 :   if (nbits < 768)
    1446             :     {
    1447           0 :       nbits = 2048;
    1448           0 :       log_info(_("keysize invalid; using %u bits\n"), nbits );
    1449             :     }
    1450           1 :   else if ( nbits > 3072 )
    1451             :     {
    1452           0 :       nbits = 3072;
    1453           0 :       log_info(_("keysize invalid; using %u bits\n"), nbits );
    1454             :     }
    1455             : 
    1456           1 :   if( (nbits % 64) )
    1457             :     {
    1458           0 :       nbits = ((nbits + 63) / 64) * 64;
    1459           0 :       log_info(_("keysize rounded up to %u bits\n"), nbits );
    1460             :     }
    1461             : 
    1462             :   /* To comply with FIPS rules we round up to the next value unless in
    1463             :      expert mode.  */
    1464           1 :   if (!opt.expert && nbits > 1024 && (nbits % 1024))
    1465             :     {
    1466           0 :       nbits = ((nbits + 1023) / 1024) * 1024;
    1467           0 :       log_info(_("keysize rounded up to %u bits\n"), nbits );
    1468             :     }
    1469             : 
    1470             :   /*
    1471             :     Figure out a q size based on the key size.  FIPS 180-3 says:
    1472             : 
    1473             :     L = 1024, N = 160
    1474             :     L = 2048, N = 224
    1475             :     L = 2048, N = 256
    1476             :     L = 3072, N = 256
    1477             : 
    1478             :     2048/256 is an odd pair since there is also a 2048/224 and
    1479             :     3072/256.  Matching sizes is not a very exact science.
    1480             : 
    1481             :     We'll do 256 qbits for nbits over 2047, 224 for nbits over 1024
    1482             :     but less than 2048, and 160 for 1024 (DSA1).
    1483             :   */
    1484             : 
    1485           1 :   if (nbits > 2047)
    1486           0 :     qbits = 256;
    1487           1 :   else if ( nbits > 1024)
    1488           0 :     qbits = 224;
    1489             :   else
    1490           1 :     qbits = 160;
    1491             : 
    1492           1 :   if (qbits != 160 )
    1493           0 :     log_info (_("WARNING: some OpenPGP programs can't"
    1494             :                 " handle a DSA key with this digest size\n"));
    1495             : 
    1496           1 :   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
    1497           1 :   snprintf (qbitsstr, sizeof qbitsstr, "%u", qbits);
    1498           2 :   keyparms = xtryasprintf ("(genkey(dsa(nbits %zu:%s)(qbits %zu:%s)%s))",
    1499             :                            strlen (nbitsstr), nbitsstr,
    1500             :                            strlen (qbitsstr), qbitsstr,
    1501           1 :                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1502           1 :                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1503             :                            "(transient-key)" : "" );
    1504           1 :   if (!keyparms)
    1505           0 :     err = gpg_error_from_syserror ();
    1506             :   else
    1507             :     {
    1508           1 :       err = common_gen (keyparms, PUBKEY_ALGO_DSA, "pqgy",
    1509             :                         pub_root, timestamp, expireval, is_subkey,
    1510             :                         keygen_flags, passphrase,
    1511             :                         cache_nonce_addr, passwd_nonce_addr);
    1512           1 :       xfree (keyparms);
    1513             :     }
    1514             : 
    1515           1 :   return err;
    1516             : }
    1517             : 
    1518             : 
    1519             : 
    1520             : /*
    1521             :  * Generate an ECC key
    1522             :  */
    1523             : static gpg_error_t
    1524           0 : gen_ecc (int algo, const char *curve, kbnode_t pub_root,
    1525             :          u32 timestamp, u32 expireval, int is_subkey,
    1526             :          int keygen_flags, const char *passphrase,
    1527             :          char **cache_nonce_addr, char **passwd_nonce_addr)
    1528             : {
    1529             :   gpg_error_t err;
    1530             :   char *keyparms;
    1531             : 
    1532           0 :   log_assert (algo == PUBKEY_ALGO_ECDSA
    1533             :               || algo == PUBKEY_ALGO_EDDSA
    1534             :               || algo == PUBKEY_ALGO_ECDH);
    1535             : 
    1536           0 :   if (!curve || !*curve)
    1537           0 :     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
    1538             : 
    1539             :   /* Note that we use the "comp" flag with EdDSA to request the use of
    1540             :      a 0x40 compression prefix octet.  */
    1541           0 :   if (algo == PUBKEY_ALGO_EDDSA)
    1542           0 :     keyparms = xtryasprintf
    1543             :       ("(genkey(ecc(curve %zu:%s)(flags eddsa comp%s)))",
    1544             :        strlen (curve), curve,
    1545           0 :        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1546           0 :          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1547             :         " transient-key" : ""));
    1548           0 :   else if (algo == PUBKEY_ALGO_ECDH && !strcmp (curve, "Curve25519"))
    1549           0 :     keyparms = xtryasprintf
    1550             :       ("(genkey(ecc(curve %zu:%s)(flags djb-tweak comp%s)))",
    1551             :        strlen (curve), curve,
    1552           0 :        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1553           0 :          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1554             :         " transient-key" : ""));
    1555             :   else
    1556           0 :     keyparms = xtryasprintf
    1557             :       ("(genkey(ecc(curve %zu:%s)(flags nocomp%s)))",
    1558             :        strlen (curve), curve,
    1559           0 :        (((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1560           0 :          && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1561             :         " transient-key" : ""));
    1562             : 
    1563           0 :   if (!keyparms)
    1564           0 :     err = gpg_error_from_syserror ();
    1565             :   else
    1566             :     {
    1567           0 :       err = common_gen (keyparms, algo, "",
    1568             :                         pub_root, timestamp, expireval, is_subkey,
    1569             :                         keygen_flags, passphrase,
    1570             :                         cache_nonce_addr, passwd_nonce_addr);
    1571           0 :       xfree (keyparms);
    1572             :     }
    1573             : 
    1574           0 :   return err;
    1575             : }
    1576             : 
    1577             : 
    1578             : /*
    1579             :  * Generate an RSA key.
    1580             :  */
    1581             : static int
    1582           1 : gen_rsa (int algo, unsigned int nbits, KBNODE pub_root,
    1583             :          u32 timestamp, u32 expireval, int is_subkey,
    1584             :          int keygen_flags, const char *passphrase,
    1585             :          char **cache_nonce_addr, char **passwd_nonce_addr)
    1586             : {
    1587             :   int err;
    1588             :   char *keyparms;
    1589             :   char nbitsstr[35];
    1590           1 :   const unsigned maxsize = (opt.flags.large_rsa ? 8192 : 4096);
    1591             : 
    1592           1 :   log_assert (is_RSA(algo));
    1593             : 
    1594           1 :   if (!nbits)
    1595           0 :     nbits = DEFAULT_STD_KEYSIZE;
    1596             : 
    1597           1 :   if (nbits < 1024)
    1598             :     {
    1599           0 :       nbits = 2048;
    1600           0 :       log_info (_("keysize invalid; using %u bits\n"), nbits );
    1601             :     }
    1602           1 :   else if (nbits > maxsize)
    1603             :     {
    1604           0 :       nbits = maxsize;
    1605           0 :       log_info (_("keysize invalid; using %u bits\n"), nbits );
    1606             :     }
    1607             : 
    1608           1 :   if ((nbits % 32))
    1609             :     {
    1610           0 :       nbits = ((nbits + 31) / 32) * 32;
    1611           0 :       log_info (_("keysize rounded up to %u bits\n"), nbits );
    1612             :     }
    1613             : 
    1614           1 :   snprintf (nbitsstr, sizeof nbitsstr, "%u", nbits);
    1615           2 :   keyparms = xtryasprintf ("(genkey(rsa(nbits %zu:%s)%s))",
    1616             :                            strlen (nbitsstr), nbitsstr,
    1617           1 :                            ((keygen_flags & KEYGEN_FLAG_TRANSIENT_KEY)
    1618           1 :                             && (keygen_flags & KEYGEN_FLAG_NO_PROTECTION))?
    1619             :                            "(transient-key)" : "" );
    1620           1 :   if (!keyparms)
    1621           0 :     err = gpg_error_from_syserror ();
    1622             :   else
    1623             :     {
    1624           1 :       err = common_gen (keyparms, algo, "ne",
    1625             :                         pub_root, timestamp, expireval, is_subkey,
    1626             :                         keygen_flags, passphrase,
    1627             :                         cache_nonce_addr, passwd_nonce_addr);
    1628           1 :       xfree (keyparms);
    1629             :     }
    1630             : 
    1631           1 :   return err;
    1632             : }
    1633             : 
    1634             : 
    1635             : /****************
    1636             :  * check valid days:
    1637             :  * return 0 on error or the multiplier
    1638             :  */
    1639             : static int
    1640         133 : check_valid_days( const char *s )
    1641             : {
    1642         133 :     if( !digitp(s) )
    1643           0 :         return 0;
    1644         133 :     for( s++; *s; s++)
    1645           0 :         if( !digitp(s) )
    1646             :             break;
    1647         133 :     if( !*s )
    1648         133 :         return 1;
    1649           0 :     if( s[1] )
    1650           0 :         return 0; /* e.g. "2323wc" */
    1651           0 :     if( *s == 'd' || *s == 'D' )
    1652           0 :         return 1;
    1653           0 :     if( *s == 'w' || *s == 'W' )
    1654           0 :         return 7;
    1655           0 :     if( *s == 'm' || *s == 'M' )
    1656           0 :         return 30;
    1657           0 :     if( *s == 'y' || *s == 'Y' )
    1658           0 :         return 365;
    1659           0 :     return 0;
    1660             : }
    1661             : 
    1662             : 
    1663             : static void
    1664           0 : print_key_flags(int flags)
    1665             : {
    1666           0 :   if(flags&PUBKEY_USAGE_SIG)
    1667           0 :     tty_printf("%s ",_("Sign"));
    1668             : 
    1669           0 :   if(flags&PUBKEY_USAGE_CERT)
    1670           0 :     tty_printf("%s ",_("Certify"));
    1671             : 
    1672           0 :   if(flags&PUBKEY_USAGE_ENC)
    1673           0 :     tty_printf("%s ",_("Encrypt"));
    1674             : 
    1675           0 :   if(flags&PUBKEY_USAGE_AUTH)
    1676           0 :     tty_printf("%s ",_("Authenticate"));
    1677           0 : }
    1678             : 
    1679             : 
    1680             : /* Ask for the key flags and return them.  CURRENT gives the current
    1681             :  * usage which should normally be given as 0. */
    1682             : unsigned int
    1683           0 : ask_key_flags (int algo, int subkey, unsigned int current)
    1684             : {
    1685             :   /* TRANSLATORS: Please use only plain ASCII characters for the
    1686             :      translation.  If this is not possible use single digits.  The
    1687             :      string needs to 8 bytes long. Here is a description of the
    1688             :      functions:
    1689             : 
    1690             :        s = Toggle signing capability
    1691             :        e = Toggle encryption capability
    1692             :        a = Toggle authentication capability
    1693             :        q = Finish
    1694             :   */
    1695           0 :   const char *togglers = _("SsEeAaQq");
    1696           0 :   char *answer = NULL;
    1697             :   const char *s;
    1698           0 :   unsigned int possible = openpgp_pk_algo_usage(algo);
    1699             : 
    1700           0 :   if ( strlen(togglers) != 8 )
    1701             :     {
    1702           0 :       tty_printf ("NOTE: Bad translation at %s:%d. "
    1703             :                   "Please report.\n", __FILE__, __LINE__);
    1704           0 :       togglers = "11223300";
    1705             :     }
    1706             : 
    1707             :   /* Only primary keys may certify. */
    1708           0 :   if(subkey)
    1709           0 :     possible&=~PUBKEY_USAGE_CERT;
    1710             : 
    1711             :   /* Preload the current set with the possible set, minus
    1712             :      authentication if CURRENT has been given as 0.  If CURRENT has
    1713             :      been has non-zero we mask with all possible usages. */
    1714           0 :   if (current)
    1715           0 :     current &= possible;
    1716             :   else
    1717           0 :     current = (possible&~PUBKEY_USAGE_AUTH);
    1718             : 
    1719             :   for(;;)
    1720             :     {
    1721           0 :       tty_printf("\n");
    1722           0 :       tty_printf(_("Possible actions for a %s key: "),
    1723             :                  (algo == PUBKEY_ALGO_ECDSA
    1724           0 :                   || algo == PUBKEY_ALGO_EDDSA)
    1725           0 :                  ? "ECDSA/EdDSA" : openpgp_pk_algo_name (algo));
    1726           0 :       print_key_flags(possible);
    1727           0 :       tty_printf("\n");
    1728           0 :       tty_printf(_("Current allowed actions: "));
    1729           0 :       print_key_flags(current);
    1730           0 :       tty_printf("\n\n");
    1731             : 
    1732           0 :       if(possible&PUBKEY_USAGE_SIG)
    1733           0 :         tty_printf(_("   (%c) Toggle the sign capability\n"),
    1734           0 :                    togglers[0]);
    1735           0 :       if(possible&PUBKEY_USAGE_ENC)
    1736           0 :         tty_printf(_("   (%c) Toggle the encrypt capability\n"),
    1737           0 :                    togglers[2]);
    1738           0 :       if(possible&PUBKEY_USAGE_AUTH)
    1739           0 :         tty_printf(_("   (%c) Toggle the authenticate capability\n"),
    1740           0 :                    togglers[4]);
    1741             : 
    1742           0 :       tty_printf(_("   (%c) Finished\n"),togglers[6]);
    1743           0 :       tty_printf("\n");
    1744             : 
    1745           0 :       xfree(answer);
    1746           0 :       answer = cpr_get("keygen.flags",_("Your selection? "));
    1747           0 :       cpr_kill_prompt();
    1748             : 
    1749           0 :       if (*answer == '=')
    1750             :         {
    1751             :           /* Hack to allow direct entry of the capabilities.  */
    1752           0 :           current = 0;
    1753           0 :           for (s=answer+1; *s; s++)
    1754             :             {
    1755           0 :               if ((*s == 's' || *s == 'S') && (possible&PUBKEY_USAGE_SIG))
    1756           0 :                 current |= PUBKEY_USAGE_SIG;
    1757           0 :               else if ((*s == 'e' || *s == 'E') && (possible&PUBKEY_USAGE_ENC))
    1758           0 :                 current |= PUBKEY_USAGE_ENC;
    1759           0 :               else if ((*s == 'a' || *s == 'A') && (possible&PUBKEY_USAGE_AUTH))
    1760           0 :                 current |= PUBKEY_USAGE_AUTH;
    1761           0 :               else if (!subkey && *s == 'c')
    1762             :                 {
    1763             :                   /* Accept 'c' for the primary key because USAGE_CERT
    1764             :                      will will be set anyway.  This is for folks who
    1765             :                      want to experiment with a cert-only primary key.  */
    1766           0 :                   current |= PUBKEY_USAGE_CERT;
    1767             :                 }
    1768             :             }
    1769           0 :           break;
    1770             :         }
    1771           0 :       else if (strlen(answer)>1)
    1772           0 :         tty_printf(_("Invalid selection.\n"));
    1773           0 :       else if(*answer=='\0' || *answer==togglers[6] || *answer==togglers[7])
    1774             :         break;
    1775           0 :       else if((*answer==togglers[0] || *answer==togglers[1])
    1776           0 :               && possible&PUBKEY_USAGE_SIG)
    1777             :         {
    1778           0 :           if(current&PUBKEY_USAGE_SIG)
    1779           0 :             current&=~PUBKEY_USAGE_SIG;
    1780             :           else
    1781           0 :             current|=PUBKEY_USAGE_SIG;
    1782             :         }
    1783           0 :       else if((*answer==togglers[2] || *answer==togglers[3])
    1784           0 :               && possible&PUBKEY_USAGE_ENC)
    1785             :         {
    1786           0 :           if(current&PUBKEY_USAGE_ENC)
    1787           0 :             current&=~PUBKEY_USAGE_ENC;
    1788             :           else
    1789           0 :             current|=PUBKEY_USAGE_ENC;
    1790             :         }
    1791           0 :       else if((*answer==togglers[4] || *answer==togglers[5])
    1792           0 :               && possible&PUBKEY_USAGE_AUTH)
    1793             :         {
    1794           0 :           if(current&PUBKEY_USAGE_AUTH)
    1795           0 :             current&=~PUBKEY_USAGE_AUTH;
    1796             :           else
    1797           0 :             current|=PUBKEY_USAGE_AUTH;
    1798             :         }
    1799             :       else
    1800           0 :         tty_printf(_("Invalid selection.\n"));
    1801           0 :     }
    1802             : 
    1803           0 :   xfree(answer);
    1804             : 
    1805           0 :   return current;
    1806             : }
    1807             : 
    1808             : 
    1809             : /* Check whether we have a key for the key with HEXGRIP.  Returns 0 if
    1810             :    there is no such key or the OpenPGP algo number for the key.  */
    1811             : static int
    1812           0 : check_keygrip (ctrl_t ctrl, const char *hexgrip)
    1813             : {
    1814             :   gpg_error_t err;
    1815             :   unsigned char *public;
    1816             :   size_t publiclen;
    1817             :   const char *algostr;
    1818             : 
    1819           0 :   if (hexgrip[0] == '&')
    1820           0 :     hexgrip++;
    1821             : 
    1822           0 :   err = agent_readkey (ctrl, 0, hexgrip, &public);
    1823           0 :   if (err)
    1824           0 :     return 0;
    1825           0 :   publiclen = gcry_sexp_canon_len (public, 0, NULL, NULL);
    1826             : 
    1827           0 :   get_pk_algo_from_canon_sexp (public, publiclen, &algostr);
    1828           0 :   xfree (public);
    1829             : 
    1830             :   /* FIXME: Mapping of ECC algorithms is probably not correct. */
    1831           0 :   if (!algostr)
    1832           0 :     return 0;
    1833           0 :   else if (!strcmp (algostr, "rsa"))
    1834           0 :     return PUBKEY_ALGO_RSA;
    1835           0 :   else if (!strcmp (algostr, "dsa"))
    1836           0 :     return PUBKEY_ALGO_DSA;
    1837           0 :   else if (!strcmp (algostr, "elg"))
    1838           0 :     return PUBKEY_ALGO_ELGAMAL_E;
    1839           0 :   else if (!strcmp (algostr, "ecc"))
    1840           0 :     return PUBKEY_ALGO_ECDH;
    1841           0 :   else if (!strcmp (algostr, "ecdsa"))
    1842           0 :     return PUBKEY_ALGO_ECDSA;
    1843           0 :   else if (!strcmp (algostr, "eddsa"))
    1844           0 :     return PUBKEY_ALGO_EDDSA;
    1845             :   else
    1846           0 :     return 0;
    1847             : }
    1848             : 
    1849             : 
    1850             : 
    1851             : /* Ask for an algorithm.  The function returns the algorithm id to
    1852             :  * create. If ADDMODE is false the function won't show an option to
    1853             :  * create the primary and subkey combined and won't set R_USAGE
    1854             :  * either.  If a combined algorithm has been selected, the subkey
    1855             :  * algorithm is stored at R_SUBKEY_ALGO.  If R_KEYGRIP is given, the
    1856             :  * user has the choice to enter the keygrip of an existing key.  That
    1857             :  * keygrip is then stored at this address.  The caller needs to free
    1858             :  * it. */
    1859             : static int
    1860           0 : ask_algo (ctrl_t ctrl, int addmode, int *r_subkey_algo, unsigned int *r_usage,
    1861             :           char **r_keygrip)
    1862             : {
    1863           0 :   char *keygrip = NULL;
    1864           0 :   char *answer = NULL;
    1865             :   int algo;
    1866             :   int dummy_algo;
    1867             : 
    1868           0 :   if (!r_subkey_algo)
    1869           0 :     r_subkey_algo = &dummy_algo;
    1870             : 
    1871           0 :   tty_printf (_("Please select what kind of key you want:\n"));
    1872             : 
    1873             : #if GPG_USE_RSA
    1874           0 :   if (!addmode)
    1875           0 :     tty_printf (_("   (%d) RSA and RSA (default)\n"), 1 );
    1876             : #endif
    1877             : 
    1878           0 :   if (!addmode)
    1879           0 :     tty_printf (_("   (%d) DSA and Elgamal\n"), 2 );
    1880             : 
    1881           0 :   tty_printf (_("   (%d) DSA (sign only)\n"), 3 );
    1882             : #if GPG_USE_RSA
    1883           0 :   tty_printf (_("   (%d) RSA (sign only)\n"), 4 );
    1884             : #endif
    1885             : 
    1886           0 :   if (addmode)
    1887             :     {
    1888           0 :       tty_printf (_("   (%d) Elgamal (encrypt only)\n"), 5 );
    1889             : #if GPG_USE_RSA
    1890           0 :       tty_printf (_("   (%d) RSA (encrypt only)\n"), 6 );
    1891             : #endif
    1892             :     }
    1893           0 :   if (opt.expert)
    1894             :     {
    1895           0 :       tty_printf (_("   (%d) DSA (set your own capabilities)\n"), 7 );
    1896             : #if GPG_USE_RSA
    1897           0 :       tty_printf (_("   (%d) RSA (set your own capabilities)\n"), 8 );
    1898             : #endif
    1899             :     }
    1900             : 
    1901             : #if GPG_USE_ECDSA || GPG_USE_ECDH || GPG_USE_EDDSA
    1902           0 :   if (opt.expert && !addmode)
    1903           0 :     tty_printf (_("   (%d) ECC and ECC\n"), 9 );
    1904           0 :   if (opt.expert)
    1905           0 :     tty_printf (_("  (%d) ECC (sign only)\n"), 10 );
    1906           0 :   if (opt.expert)
    1907           0 :     tty_printf (_("  (%d) ECC (set your own capabilities)\n"), 11 );
    1908           0 :   if (opt.expert && addmode)
    1909           0 :     tty_printf (_("  (%d) ECC (encrypt only)\n"), 12 );
    1910             : #endif
    1911             : 
    1912           0 :   if (opt.expert && r_keygrip)
    1913           0 :     tty_printf (_("  (%d) Existing key\n"), 13 );
    1914             : 
    1915             :   for (;;)
    1916             :     {
    1917           0 :       *r_usage = 0;
    1918           0 :       *r_subkey_algo = 0;
    1919           0 :       xfree (answer);
    1920           0 :       answer = cpr_get ("keygen.algo", _("Your selection? "));
    1921           0 :       cpr_kill_prompt ();
    1922           0 :       algo = *answer? atoi (answer) : 1;
    1923           0 :       if ((algo == 1 || !strcmp (answer, "rsa+rsa")) && !addmode)
    1924             :         {
    1925           0 :           algo = PUBKEY_ALGO_RSA;
    1926           0 :           *r_subkey_algo = PUBKEY_ALGO_RSA;
    1927           0 :           break;
    1928             :         }
    1929           0 :       else if ((algo == 2 || !strcmp (answer, "dsa+elg")) && !addmode)
    1930             :         {
    1931           0 :           algo = PUBKEY_ALGO_DSA;
    1932           0 :           *r_subkey_algo = PUBKEY_ALGO_ELGAMAL_E;
    1933           0 :           break;
    1934             :         }
    1935           0 :       else if (algo == 3 || !strcmp (answer, "dsa"))
    1936             :         {
    1937           0 :           algo = PUBKEY_ALGO_DSA;
    1938           0 :           *r_usage = PUBKEY_USAGE_SIG;
    1939           0 :           break;
    1940             :         }
    1941           0 :       else if (algo == 4 || !strcmp (answer, "rsa/s"))
    1942             :         {
    1943           0 :           algo = PUBKEY_ALGO_RSA;
    1944           0 :           *r_usage = PUBKEY_USAGE_SIG;
    1945           0 :           break;
    1946             :         }
    1947           0 :       else if ((algo == 5 || !strcmp (answer, "elg")) && addmode)
    1948             :         {
    1949           0 :           algo = PUBKEY_ALGO_ELGAMAL_E;
    1950           0 :           *r_usage = PUBKEY_USAGE_ENC;
    1951           0 :           break;
    1952             :         }
    1953           0 :       else if ((algo == 6 || !strcmp (answer, "rsa/e")) && addmode)
    1954             :         {
    1955           0 :           algo = PUBKEY_ALGO_RSA;
    1956           0 :           *r_usage = PUBKEY_USAGE_ENC;
    1957           0 :           break;
    1958             :         }
    1959           0 :       else if ((algo == 7 || !strcmp (answer, "dsa/*")) && opt.expert)
    1960             :         {
    1961           0 :           algo = PUBKEY_ALGO_DSA;
    1962           0 :           *r_usage = ask_key_flags (algo, addmode, 0);
    1963           0 :           break;
    1964             :         }
    1965           0 :       else if ((algo == 8 || !strcmp (answer, "rsa/*")) && opt.expert)
    1966             :         {
    1967           0 :           algo = PUBKEY_ALGO_RSA;
    1968           0 :           *r_usage = ask_key_flags (algo, addmode, 0);
    1969           0 :           break;
    1970             :         }
    1971           0 :       else if ((algo == 9 || !strcmp (answer, "ecc+ecc"))
    1972           0 :                && opt.expert && !addmode)
    1973             :         {
    1974           0 :           algo = PUBKEY_ALGO_ECDSA;
    1975           0 :           *r_subkey_algo = PUBKEY_ALGO_ECDH;
    1976           0 :           break;
    1977             :         }
    1978           0 :       else if ((algo == 10 || !strcmp (answer, "ecc/s")) && opt.expert)
    1979             :         {
    1980           0 :           algo = PUBKEY_ALGO_ECDSA;
    1981           0 :           *r_usage = PUBKEY_USAGE_SIG;
    1982           0 :           break;
    1983             :         }
    1984           0 :       else if ((algo == 11 || !strcmp (answer, "ecc/*")) && opt.expert)
    1985             :         {
    1986           0 :           algo = PUBKEY_ALGO_ECDSA;
    1987           0 :           *r_usage = ask_key_flags (algo, addmode, 0);
    1988           0 :           break;
    1989             :         }
    1990           0 :       else if ((algo == 12 || !strcmp (answer, "ecc/e"))
    1991           0 :                && opt.expert && addmode)
    1992             :         {
    1993           0 :           algo = PUBKEY_ALGO_ECDH;
    1994           0 :           *r_usage = PUBKEY_USAGE_ENC;
    1995           0 :           break;
    1996             :         }
    1997           0 :       else if ((algo == 13 || !strcmp (answer, "keygrip"))
    1998           0 :                && opt.expert && r_keygrip)
    1999             :         {
    2000             :           for (;;)
    2001             :             {
    2002           0 :               xfree (answer);
    2003           0 :               answer = tty_get (_("Enter the keygrip: "));
    2004           0 :               tty_kill_prompt ();
    2005           0 :               trim_spaces (answer);
    2006           0 :               if (!*answer)
    2007             :                 {
    2008           0 :                   xfree (answer);
    2009           0 :                   answer = NULL;
    2010           0 :                   continue;
    2011             :                 }
    2012             : 
    2013           0 :               if (strlen (answer) != 40 &&
    2014           0 :                        !(answer[0] == '&' && strlen (answer+1) == 40))
    2015           0 :                 tty_printf
    2016           0 :                   (_("Not a valid keygrip (expecting 40 hex digits)\n"));
    2017           0 :               else if (!(algo = check_keygrip (ctrl, answer)) )
    2018           0 :                 tty_printf (_("No key with this keygrip\n"));
    2019             :               else
    2020           0 :                 break; /* Okay.  */
    2021           0 :             }
    2022           0 :           xfree (keygrip);
    2023           0 :           keygrip = answer;
    2024           0 :           answer = NULL;
    2025           0 :           *r_usage = ask_key_flags (algo, addmode, 0);
    2026           0 :           break;
    2027             :         }
    2028             :       else
    2029           0 :         tty_printf (_("Invalid selection.\n"));
    2030             : 
    2031           0 :     }
    2032             : 
    2033           0 :   xfree(answer);
    2034           0 :   if (r_keygrip)
    2035           0 :     *r_keygrip = keygrip;
    2036           0 :   return algo;
    2037             : }
    2038             : 
    2039             : 
    2040             : static void
    2041           0 : get_keysize_range (int algo,
    2042             :                    unsigned int *min, unsigned int *def, unsigned int *max)
    2043             : {
    2044           0 :   *min = 1024;
    2045           0 :   *def = DEFAULT_STD_KEYSIZE;
    2046           0 :   *max = 4096;
    2047             : 
    2048             :   /* Deviations from the standard values.  */
    2049           0 :   switch(algo)
    2050             :     {
    2051             :     case PUBKEY_ALGO_DSA:
    2052           0 :       *min = opt.expert? 768 : 1024;
    2053           0 :       *def=2048;
    2054           0 :       *max=3072;
    2055           0 :       break;
    2056             : 
    2057             :     case PUBKEY_ALGO_ECDSA:
    2058             :     case PUBKEY_ALGO_ECDH:
    2059           0 :       *min=256;
    2060           0 :       *def=256;
    2061           0 :       *max=521;
    2062           0 :       break;
    2063             : 
    2064             :     case PUBKEY_ALGO_EDDSA:
    2065           0 :       *min=255;
    2066           0 :       *def=255;
    2067           0 :       *max=441;
    2068           0 :       break;
    2069             :     }
    2070           0 : }
    2071             : 
    2072             : 
    2073             : /* Return a fixed up keysize depending on ALGO.  */
    2074             : static unsigned int
    2075           0 : fixup_keysize (unsigned int nbits, int algo, int silent)
    2076             : {
    2077           0 :   if (algo == PUBKEY_ALGO_DSA && (nbits % 64))
    2078             :     {
    2079           0 :       nbits = ((nbits + 63) / 64) * 64;
    2080           0 :       if (!silent)
    2081           0 :         tty_printf (_("rounded up to %u bits\n"), nbits);
    2082             :     }
    2083           0 :   else if (algo == PUBKEY_ALGO_EDDSA)
    2084             :     {
    2085           0 :       if (nbits != 255 && nbits != 441)
    2086             :         {
    2087           0 :           if (nbits < 256)
    2088           0 :             nbits = 255;
    2089             :           else
    2090           0 :             nbits = 441;
    2091           0 :           if (!silent)
    2092           0 :             tty_printf (_("rounded to %u bits\n"), nbits);
    2093             :         }
    2094             :     }
    2095           0 :   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA)
    2096             :     {
    2097           0 :       if (nbits != 256 && nbits != 384 && nbits != 521)
    2098             :         {
    2099           0 :           if (nbits < 256)
    2100           0 :             nbits = 256;
    2101           0 :           else if (nbits < 384)
    2102           0 :             nbits = 384;
    2103             :           else
    2104           0 :             nbits = 521;
    2105           0 :           if (!silent)
    2106           0 :             tty_printf (_("rounded to %u bits\n"), nbits);
    2107             :         }
    2108             :     }
    2109           0 :   else if ((nbits % 32))
    2110             :     {
    2111           0 :       nbits = ((nbits + 31) / 32) * 32;
    2112           0 :       if (!silent)
    2113           0 :         tty_printf (_("rounded up to %u bits\n"), nbits );
    2114             :     }
    2115             : 
    2116           0 :   return nbits;
    2117             : }
    2118             : 
    2119             : 
    2120             : /* Ask for the key size.  ALGO is the algorithm.  If PRIMARY_KEYSIZE
    2121             :    is not 0, the function asks for the size of the encryption
    2122             :    subkey. */
    2123             : static unsigned
    2124           0 : ask_keysize (int algo, unsigned int primary_keysize)
    2125             : {
    2126             :   unsigned int nbits;
    2127             :   unsigned int min, def, max;
    2128           0 :   int for_subkey = !!primary_keysize;
    2129           0 :   int autocomp = 0;
    2130             : 
    2131           0 :   get_keysize_range (algo, &min, &def, &max);
    2132             : 
    2133           0 :   if (primary_keysize && !opt.expert)
    2134             :     {
    2135             :       /* Deduce the subkey size from the primary key size.  */
    2136           0 :       if (algo == PUBKEY_ALGO_DSA && primary_keysize > 3072)
    2137           0 :         nbits = 3072; /* For performance reasons we don't support more
    2138             :                          than 3072 bit DSA.  However we won't see this
    2139             :                          case anyway because DSA can't be used as an
    2140             :                          encryption subkey ;-). */
    2141             :       else
    2142           0 :         nbits = primary_keysize;
    2143           0 :       autocomp = 1;
    2144           0 :       goto leave;
    2145             :     }
    2146             : 
    2147           0 :   tty_printf(_("%s keys may be between %u and %u bits long.\n"),
    2148             :              openpgp_pk_algo_name (algo), min, max);
    2149             : 
    2150             :   for (;;)
    2151             :     {
    2152             :       char *prompt, *answer;
    2153             : 
    2154           0 :       if (for_subkey)
    2155           0 :         prompt = xasprintf (_("What keysize do you want "
    2156             :                               "for the subkey? (%u) "), def);
    2157             :       else
    2158           0 :         prompt = xasprintf (_("What keysize do you want? (%u) "), def);
    2159           0 :       answer = cpr_get ("keygen.size", prompt);
    2160           0 :       cpr_kill_prompt ();
    2161           0 :       nbits = *answer? atoi (answer): def;
    2162           0 :       xfree(prompt);
    2163           0 :       xfree(answer);
    2164             : 
    2165           0 :       if(nbits<min || nbits>max)
    2166           0 :         tty_printf(_("%s keysizes must be in the range %u-%u\n"),
    2167             :                    openpgp_pk_algo_name (algo), min, max);
    2168             :       else
    2169             :         break;
    2170           0 :     }
    2171             : 
    2172           0 :   tty_printf (_("Requested keysize is %u bits\n"), nbits);
    2173             : 
    2174             :  leave:
    2175           0 :   nbits = fixup_keysize (nbits, algo, autocomp);
    2176           0 :   return nbits;
    2177             : }
    2178             : 
    2179             : 
    2180             : /* Ask for the curve.  ALGO is the selected algorithm which this
    2181             :    function may adjust.  Returns a malloced string with the name of
    2182             :    the curve.  BOTH tells that gpg creates a primary and subkey. */
    2183             : static char *
    2184           0 : ask_curve (int *algo, int *subkey_algo)
    2185             : {
    2186             :   /* NB: We always use a complete algo list so that we have stable
    2187             :      numbers in the menu regardless on how Gpg was configured.  */
    2188             :   struct {
    2189             :     const char *name;
    2190             :     int available;   /* Available in Libycrypt (runtime checked) */
    2191             :     int expert_only;
    2192             :     const char* eddsa_curve; /* Corresponding EdDSA curve.  */
    2193             :     const char *pretty_name;
    2194             :     int supported;   /* Supported by gpg.  */
    2195           0 :   } curves[] = {
    2196             : #if GPG_USE_ECDSA || GPG_USE_ECDH
    2197             : # define MY_USE_ECDSADH 1
    2198             : #else
    2199             : # define MY_USE_ECDSADH 0
    2200             : #endif
    2201             :     { "Curve25519",      0, 0, "Ed25519", "Curve 25519", GPG_USE_EDDSA  },
    2202             :     { "Curve448",        0, 1, "Ed448",   "Curve 448",   0/*reserved*/  },
    2203             :     { "NIST P-256",      0, 1, NULL, NULL,               MY_USE_ECDSADH },
    2204             :     { "NIST P-384",      0, 0, NULL, NULL,               MY_USE_ECDSADH },
    2205             :     { "NIST P-521",      0, 1, NULL, NULL,               MY_USE_ECDSADH },
    2206             :     { "brainpoolP256r1", 0, 1, NULL, "Brainpool P-256",  MY_USE_ECDSADH },
    2207             :     { "brainpoolP384r1", 0, 1, NULL, "Brainpool P-384",  MY_USE_ECDSADH },
    2208             :     { "brainpoolP512r1", 0, 1, NULL, "Brainpool P-512",  MY_USE_ECDSADH },
    2209             :     { "secp256k1",       0, 1, NULL, NULL,               MY_USE_ECDSADH },
    2210             :   };
    2211             : #undef MY_USE_ECDSADH
    2212             :   int idx;
    2213             :   char *answer;
    2214           0 :   char *result = NULL;
    2215             :   gcry_sexp_t keyparms;
    2216             : 
    2217           0 :   tty_printf (_("Please select which elliptic curve you want:\n"));
    2218             : 
    2219           0 :   keyparms = NULL;
    2220           0 :   for (idx=0; idx < DIM(curves); idx++)
    2221             :     {
    2222             :       int rc;
    2223             : 
    2224           0 :       curves[idx].available = 0;
    2225           0 :       if (!curves[idx].supported)
    2226           0 :         continue;
    2227           0 :       if (!opt.expert && curves[idx].expert_only)
    2228           0 :         continue;
    2229             : 
    2230             :       /* We need to switch from the ECDH name of the curve to the
    2231             :          EDDSA name of the curve if we want a signing key.  */
    2232           0 :       gcry_sexp_release (keyparms);
    2233           0 :       rc = gcry_sexp_build (&keyparms, NULL,
    2234             :                             "(public-key(ecc(curve %s)))",
    2235           0 :                             curves[idx].eddsa_curve? curves[idx].eddsa_curve
    2236             :                             /**/                   : curves[idx].name);
    2237           0 :       if (rc)
    2238           0 :         continue;
    2239           0 :       if (!gcry_pk_get_curve (keyparms, 0, NULL))
    2240           0 :         continue;
    2241           0 :       if (subkey_algo && curves[idx].eddsa_curve)
    2242             :         {
    2243             :           /* Both Curve 25519 (or 448) keys are to be created.  Check that
    2244             :              Libgcrypt also supports the real Curve25519 (or 448).  */
    2245           0 :           gcry_sexp_release (keyparms);
    2246           0 :           rc = gcry_sexp_build (&keyparms, NULL,
    2247             :                                 "(public-key(ecc(curve %s)))",
    2248             :                                  curves[idx].name);
    2249           0 :           if (rc)
    2250           0 :             continue;
    2251           0 :           if (!gcry_pk_get_curve (keyparms, 0, NULL))
    2252           0 :             continue;
    2253             :         }
    2254             : 
    2255           0 :       curves[idx].available = 1;
    2256           0 :       tty_printf ("   (%d) %s\n", idx + 1,
    2257           0 :                   curves[idx].pretty_name?
    2258             :                   curves[idx].pretty_name:curves[idx].name);
    2259             :     }
    2260           0 :   gcry_sexp_release (keyparms);
    2261             : 
    2262             : 
    2263             :   for (;;)
    2264             :     {
    2265           0 :       answer = cpr_get ("keygen.curve", _("Your selection? "));
    2266           0 :       cpr_kill_prompt ();
    2267           0 :       idx = *answer? atoi (answer) : 1;
    2268           0 :       if (*answer && !idx)
    2269             :         {
    2270             :           /* See whether the user entered the name of the curve.  */
    2271           0 :           for (idx=0; idx < DIM(curves); idx++)
    2272             :             {
    2273           0 :               if (!opt.expert && curves[idx].expert_only)
    2274           0 :                 continue;
    2275           0 :               if (!stricmp (curves[idx].name, answer)
    2276           0 :                   || (curves[idx].pretty_name
    2277           0 :                       && !stricmp (curves[idx].pretty_name, answer)))
    2278             :                 break;
    2279             :             }
    2280           0 :           if (idx == DIM(curves))
    2281           0 :             idx = -1;
    2282             :         }
    2283             :       else
    2284           0 :         idx--;
    2285           0 :       xfree(answer);
    2286           0 :       answer = NULL;
    2287           0 :       if (idx < 0 || idx >= DIM (curves) || !curves[idx].available)
    2288           0 :         tty_printf (_("Invalid selection.\n"));
    2289             :       else
    2290             :         {
    2291             :           /* If the user selected a signing algorithm and Curve25519
    2292             :              we need to set the algo to EdDSA and update the curve name. */
    2293           0 :           if ((*algo == PUBKEY_ALGO_ECDSA || *algo == PUBKEY_ALGO_EDDSA)
    2294           0 :               && curves[idx].eddsa_curve)
    2295             :             {
    2296           0 :               if (subkey_algo && *subkey_algo == PUBKEY_ALGO_ECDSA)
    2297           0 :                 *subkey_algo = PUBKEY_ALGO_EDDSA;
    2298           0 :               *algo = PUBKEY_ALGO_EDDSA;
    2299           0 :               result = xstrdup (curves[idx].eddsa_curve);
    2300             :             }
    2301             :           else
    2302           0 :             result = xstrdup (curves[idx].name);
    2303           0 :           break;
    2304             :         }
    2305           0 :     }
    2306             : 
    2307           0 :   if (!result)
    2308           0 :     result = xstrdup (curves[0].name);
    2309             : 
    2310           0 :   return result;
    2311             : }
    2312             : 
    2313             : 
    2314             : /****************
    2315             :  * Parse an expire string and return its value in seconds.
    2316             :  * Returns (u32)-1 on error.
    2317             :  * This isn't perfect since scan_isodatestr returns unix time, and
    2318             :  * OpenPGP actually allows a 32-bit time *plus* a 32-bit offset.
    2319             :  * Because of this, we only permit setting expirations up to 2106, but
    2320             :  * OpenPGP could theoretically allow up to 2242.  I think we'll all
    2321             :  * just cope for the next few years until we get a 64-bit time_t or
    2322             :  * similar.
    2323             :  */
    2324             : u32
    2325         133 : parse_expire_string( const char *string )
    2326             : {
    2327             :   int mult;
    2328             :   u32 seconds;
    2329         133 :   u32 abs_date = 0;
    2330         133 :   u32 curtime = make_timestamp ();
    2331             :   time_t tt;
    2332             : 
    2333         133 :   if (!*string)
    2334           0 :     seconds = 0;
    2335         133 :   else if (!strncmp (string, "seconds=", 8))
    2336           0 :     seconds = atoi (string+8);
    2337         133 :   else if ((abs_date = scan_isodatestr(string))
    2338           0 :            && (abs_date+86400/2) > curtime)
    2339           0 :     seconds = (abs_date+86400/2) - curtime;
    2340         133 :   else if ((tt = isotime2epoch (string)) != (time_t)(-1))
    2341           0 :     seconds = (u32)tt - curtime;
    2342         133 :   else if ((mult = check_valid_days (string)))
    2343         133 :     seconds = atoi (string) * 86400L * mult;
    2344             :   else
    2345           0 :     seconds = (u32)(-1);
    2346             : 
    2347         133 :   return seconds;
    2348             : }
    2349             : 
    2350             : /* Parsean Creation-Date string which is either "1986-04-26" or
    2351             :    "19860426T042640".  Returns 0 on error. */
    2352             : static u32
    2353           0 : parse_creation_string (const char *string)
    2354             : {
    2355             :   u32 seconds;
    2356             : 
    2357           0 :   if (!*string)
    2358           0 :     seconds = 0;
    2359           0 :   else if ( !strncmp (string, "seconds=", 8) )
    2360           0 :     seconds = atoi (string+8);
    2361           0 :   else if ( !(seconds = scan_isodatestr (string)))
    2362             :     {
    2363           0 :       time_t tmp = isotime2epoch (string);
    2364           0 :       seconds = (tmp == (time_t)(-1))? 0 : tmp;
    2365             :     }
    2366           0 :   return seconds;
    2367             : }
    2368             : 
    2369             : 
    2370             : /* object == 0 for a key, and 1 for a sig */
    2371             : u32
    2372           0 : ask_expire_interval(int object,const char *def_expire)
    2373             : {
    2374             :     u32 interval;
    2375             :     char *answer;
    2376             : 
    2377           0 :     switch(object)
    2378             :       {
    2379             :       case 0:
    2380           0 :         if(def_expire)
    2381           0 :           BUG();
    2382           0 :         tty_printf(_("Please specify how long the key should be valid.\n"
    2383             :                      "         0 = key does not expire\n"
    2384             :                      "      <n>  = key expires in n days\n"
    2385             :                      "      <n>w = key expires in n weeks\n"
    2386             :                      "      <n>m = key expires in n months\n"
    2387             :                      "      <n>y = key expires in n years\n"));
    2388           0 :         break;
    2389             : 
    2390             :       case 1:
    2391           0 :         if(!def_expire)
    2392           0 :           BUG();
    2393           0 :         tty_printf(_("Please specify how long the signature should be valid.\n"
    2394             :                      "         0 = signature does not expire\n"
    2395             :                      "      <n>  = signature expires in n days\n"
    2396             :                      "      <n>w = signature expires in n weeks\n"
    2397             :                      "      <n>m = signature expires in n months\n"
    2398             :                      "      <n>y = signature expires in n years\n"));
    2399           0 :         break;
    2400             : 
    2401             :       default:
    2402           0 :         BUG();
    2403             :       }
    2404             : 
    2405             :     /* Note: The elgamal subkey for DSA has no expiration date because
    2406             :      * it must be signed with the DSA key and this one has the expiration
    2407             :      * date */
    2408             : 
    2409           0 :     answer = NULL;
    2410             :     for(;;)
    2411             :       {
    2412             :         u32 curtime;
    2413             : 
    2414           0 :         xfree(answer);
    2415           0 :         if(object==0)
    2416           0 :           answer = cpr_get("keygen.valid",_("Key is valid for? (0) "));
    2417             :         else
    2418             :           {
    2419             :             char *prompt;
    2420             : 
    2421             : #define PROMPTSTRING _("Signature is valid for? (%s) ")
    2422             :             /* This will actually end up larger than necessary because
    2423             :                of the 2 bytes for '%s' */
    2424           0 :             prompt=xmalloc(strlen(PROMPTSTRING)+strlen(def_expire)+1);
    2425           0 :             sprintf(prompt,PROMPTSTRING,def_expire);
    2426             : #undef PROMPTSTRING
    2427             : 
    2428           0 :             answer = cpr_get("siggen.valid",prompt);
    2429           0 :             xfree(prompt);
    2430             : 
    2431           0 :             if(*answer=='\0')
    2432           0 :               answer=xstrdup(def_expire);
    2433             :           }
    2434           0 :         cpr_kill_prompt();
    2435           0 :         trim_spaces(answer);
    2436           0 :         curtime = make_timestamp ();
    2437           0 :         interval = parse_expire_string( answer );
    2438           0 :         if( interval == (u32)-1 )
    2439             :           {
    2440           0 :             tty_printf(_("invalid value\n"));
    2441           0 :             continue;
    2442             :           }
    2443             : 
    2444           0 :         if( !interval )
    2445             :           {
    2446           0 :             tty_printf((object==0)
    2447             :                        ? _("Key does not expire at all\n")
    2448             :                        : _("Signature does not expire at all\n"));
    2449             :           }
    2450             :         else
    2451             :           {
    2452           0 :             tty_printf(object==0
    2453             :                        ? _("Key expires at %s\n")
    2454             :                        : _("Signature expires at %s\n"),
    2455             :                        asctimestamp((ulong)(curtime + interval) ) );
    2456             : #if SIZEOF_TIME_T <= 4 && !defined (HAVE_UNSIGNED_TIME_T)
    2457             :             if ( (time_t)((ulong)(curtime+interval)) < 0 )
    2458             :               tty_printf (_("Your system can't display dates beyond 2038.\n"
    2459             :                             "However, it will be correctly handled up to"
    2460             :                             " 2106.\n"));
    2461             :             else
    2462             : #endif /*SIZEOF_TIME_T*/
    2463           0 :               if ( (time_t)((unsigned long)(curtime+interval)) < curtime )
    2464             :                 {
    2465           0 :                   tty_printf (_("invalid value\n"));
    2466           0 :                   continue;
    2467             :                 }
    2468             :           }
    2469             : 
    2470           0 :         if( cpr_enabled() || cpr_get_answer_is_yes("keygen.valid.okay",
    2471           0 :                                                    _("Is this correct? (y/N) ")) )
    2472             :           break;
    2473           0 :       }
    2474             : 
    2475           0 :     xfree(answer);
    2476           0 :     return interval;
    2477             : }
    2478             : 
    2479             : u32
    2480           0 : ask_expiredate()
    2481             : {
    2482           0 :     u32 x = ask_expire_interval(0,NULL);
    2483           0 :     return x? make_timestamp() + x : 0;
    2484             : }
    2485             : 
    2486             : 
    2487             : 
    2488             : static PKT_user_id *
    2489           0 : uid_from_string (const char *string)
    2490             : {
    2491             :   size_t n;
    2492             :   PKT_user_id *uid;
    2493             : 
    2494           0 :   n = strlen (string);
    2495           0 :   uid = xmalloc_clear (sizeof *uid + n);
    2496           0 :   uid->len = n;
    2497           0 :   strcpy (uid->name, string);
    2498           0 :   uid->ref = 1;
    2499           0 :   return uid;
    2500             : }
    2501             : 
    2502             : 
    2503             : /* Return true if the user id UID already exists in the keyblock.  */
    2504             : static int
    2505           0 : uid_already_in_keyblock (kbnode_t keyblock, const char *uid)
    2506             : {
    2507           0 :   PKT_user_id *uidpkt = uid_from_string (uid);
    2508             :   kbnode_t node;
    2509           0 :   int result = 0;
    2510             : 
    2511           0 :   for (node=keyblock; node && !result; node=node->next)
    2512           0 :     if (!is_deleted_kbnode (node)
    2513           0 :         && node->pkt->pkttype == PKT_USER_ID
    2514           0 :         && !cmp_user_ids (uidpkt, node->pkt->pkt.user_id))
    2515           0 :       result = 1;
    2516           0 :   free_user_id (uidpkt);
    2517           0 :   return result;
    2518             : }
    2519             : 
    2520             : 
    2521             : /* Ask for a user ID.  With a MODE of 1 an extra help prompt is
    2522             :    printed for use during a new key creation.  If KEYBLOCK is not NULL
    2523             :    the function prevents the creation of an already existing user
    2524             :    ID.  IF FULL is not set some prompts are not shown.  */
    2525             : static char *
    2526           0 : ask_user_id (int mode, int full, KBNODE keyblock)
    2527             : {
    2528             :     char *answer;
    2529             :     char *aname, *acomment, *amail, *uid;
    2530             : 
    2531           0 :     if ( !mode )
    2532             :       {
    2533             :         /* TRANSLATORS: This is the new string telling the user what
    2534             :            gpg is now going to do (i.e. ask for the parts of the user
    2535             :            ID).  Note that if you do not translate this string, a
    2536             :            different string will be used, which might still have
    2537             :            a correct translation.  */
    2538           0 :         const char *s1 =
    2539             :           N_("\n"
    2540             :              "GnuPG needs to construct a user ID to identify your key.\n"
    2541             :              "\n");
    2542           0 :         const char *s2 = _(s1);
    2543             : 
    2544           0 :         if (!strcmp (s1, s2))
    2545             :           {
    2546             :             /* There is no translation for the string thus we to use
    2547             :                the old info text.  gettext has no way to tell whether
    2548             :                a translation is actually available, thus we need to
    2549             :                to compare again. */
    2550             :             /* TRANSLATORS: This string is in general not anymore used
    2551             :                but you should keep your existing translation.  In case
    2552             :                the new string is not translated this old string will
    2553             :                be used. */
    2554           0 :             const char *s3 = N_("\n"
    2555             : "You need a user ID to identify your key; "
    2556             :                                         "the software constructs the user ID\n"
    2557             : "from the Real Name, Comment and Email Address in this form:\n"
    2558             : "    \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n\n");
    2559           0 :             const char *s4 = _(s3);
    2560           0 :             if (strcmp (s3, s4))
    2561           0 :               s2 = s3; /* A translation exists - use it. */
    2562             :           }
    2563           0 :         tty_printf ("%s", s2) ;
    2564             :       }
    2565           0 :     uid = aname = acomment = amail = NULL;
    2566             :     for(;;) {
    2567             :         char *p;
    2568           0 :         int fail=0;
    2569             : 
    2570           0 :         if( !aname ) {
    2571             :             for(;;) {
    2572           0 :                 xfree(aname);
    2573           0 :                 aname = cpr_get("keygen.name",_("Real name: "));
    2574           0 :                 trim_spaces(aname);
    2575           0 :                 cpr_kill_prompt();
    2576             : 
    2577           0 :                 if( opt.allow_freeform_uid )
    2578           0 :                     break;
    2579             : 
    2580           0 :                 if( strpbrk( aname, "<>" ) )
    2581             :                   {
    2582           0 :                     tty_printf(_("Invalid character in name\n"));
    2583           0 :                     tty_printf(_("The characters '%s' and '%s' may not "
    2584             :                                  "appear in name\n"), "<", ">");
    2585             :                   }
    2586           0 :                 else if( digitp(aname) )
    2587           0 :                     tty_printf(_("Name may not start with a digit\n"));
    2588           0 :                 else if (*aname && strlen (aname) < 5)
    2589             :                   {
    2590           0 :                     tty_printf(_("Name must be at least 5 characters long\n"));
    2591             :                     /* However, we allow an empty name.  */
    2592             :                   }
    2593             :                 else
    2594             :                     break;
    2595           0 :             }
    2596             :         }
    2597           0 :         if( !amail ) {
    2598             :             for(;;) {
    2599           0 :                 xfree(amail);
    2600           0 :                 amail = cpr_get("keygen.email",_("Email address: "));
    2601           0 :                 trim_spaces(amail);
    2602           0 :                 cpr_kill_prompt();
    2603           0 :                 if( !*amail || opt.allow_freeform_uid )
    2604             :                     break;   /* no email address is okay */
    2605           0 :                 else if ( !is_valid_mailbox (amail) )
    2606           0 :                     tty_printf(_("Not a valid email address\n"));
    2607             :                 else
    2608           0 :                     break;
    2609           0 :             }
    2610             :         }
    2611           0 :         if (!acomment) {
    2612           0 :           if (full) {
    2613             :             for(;;) {
    2614           0 :                 xfree(acomment);
    2615           0 :                 acomment = cpr_get("keygen.comment",_("Comment: "));
    2616           0 :                 trim_spaces(acomment);
    2617           0 :                 cpr_kill_prompt();
    2618           0 :                 if( !*acomment )
    2619           0 :                     break;   /* no comment is okay */
    2620           0 :                 else if( strpbrk( acomment, "()" ) )
    2621           0 :                     tty_printf(_("Invalid character in comment\n"));
    2622             :                 else
    2623           0 :                     break;
    2624           0 :             }
    2625             :           }
    2626             :           else {
    2627           0 :             xfree (acomment);
    2628           0 :             acomment = xstrdup ("");
    2629             :           }
    2630             :         }
    2631             : 
    2632             : 
    2633           0 :         xfree(uid);
    2634           0 :         uid = p = xmalloc(strlen(aname)+strlen(amail)+strlen(acomment)+12+10);
    2635           0 :         if (!*aname && *amail && !*acomment && !random_is_faked ())
    2636             :           { /* Empty name and comment but with mail address.  Use
    2637             :                simplified form with only the non-angle-bracketed mail
    2638             :                address.  */
    2639           0 :             p = stpcpy (p, amail);
    2640             :           }
    2641             :         else
    2642             :           {
    2643           0 :             p = stpcpy (p, aname );
    2644           0 :             if (*acomment)
    2645           0 :               p = stpcpy(stpcpy(stpcpy(p," ("), acomment),")");
    2646           0 :             if (*amail)
    2647           0 :               p = stpcpy(stpcpy(stpcpy(p," <"), amail),">");
    2648             :           }
    2649             : 
    2650             :         /* Append a warning if the RNG is switched into fake mode.  */
    2651           0 :         if ( random_is_faked ()  )
    2652           0 :           strcpy(p, " (insecure!)" );
    2653             : 
    2654             :         /* print a note in case that UTF8 mapping has to be done */
    2655           0 :         for(p=uid; *p; p++ ) {
    2656           0 :             if( *p & 0x80 ) {
    2657           0 :                 tty_printf(_("You are using the '%s' character set.\n"),
    2658             :                            get_native_charset() );
    2659           0 :                 break;
    2660             :             }
    2661             :         }
    2662             : 
    2663           0 :         tty_printf(_("You selected this USER-ID:\n    \"%s\"\n\n"), uid);
    2664             : 
    2665           0 :         if( !*amail && !opt.allow_freeform_uid
    2666           0 :             && (strchr( aname, '@' ) || strchr( acomment, '@'))) {
    2667           0 :             fail = 1;
    2668           0 :             tty_printf(_("Please don't put the email address "
    2669             :                          "into the real name or the comment\n") );
    2670             :         }
    2671             : 
    2672           0 :         if (!fail && keyblock)
    2673             :           {
    2674           0 :             if (uid_already_in_keyblock (keyblock, uid))
    2675             :               {
    2676           0 :                 tty_printf (_("Such a user ID already exists on this key!\n"));
    2677           0 :                 fail = 1;
    2678             :               }
    2679             :           }
    2680             : 
    2681             :         for(;;) {
    2682             :             /* TRANSLATORS: These are the allowed answers in
    2683             :                lower and uppercase.  Below you will find the matching
    2684             :                string which should be translated accordingly and the
    2685             :                letter changed to match the one in the answer string.
    2686             : 
    2687             :                  n = Change name
    2688             :                  c = Change comment
    2689             :                  e = Change email
    2690             :                  o = Okay (ready, continue)
    2691             :                  q = Quit
    2692             :              */
    2693           0 :             const char *ansstr = _("NnCcEeOoQq");
    2694             : 
    2695           0 :             if( strlen(ansstr) != 10 )
    2696           0 :                 BUG();
    2697           0 :             if( cpr_enabled() ) {
    2698           0 :                 answer = xstrdup (ansstr + (fail?8:6));
    2699           0 :                 answer[1] = 0;
    2700             :             }
    2701           0 :             else if (full) {
    2702           0 :                 answer = cpr_get("keygen.userid.cmd", fail?
    2703             :                   _("Change (N)ame, (C)omment, (E)mail or (Q)uit? ") :
    2704             :                   _("Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "));
    2705           0 :                 cpr_kill_prompt();
    2706             :             }
    2707             :             else {
    2708           0 :                 answer = cpr_get("keygen.userid.cmd", fail?
    2709             :                   _("Change (N)ame, (E)mail, or (Q)uit? ") :
    2710             :                   _("Change (N)ame, (E)mail, or (O)kay/(Q)uit? "));
    2711           0 :                 cpr_kill_prompt();
    2712             :             }
    2713           0 :             if( strlen(answer) > 1 )
    2714             :                 ;
    2715           0 :             else if( *answer == ansstr[0] || *answer == ansstr[1] ) {
    2716           0 :                 xfree(aname); aname = NULL;
    2717           0 :                 break;
    2718             :             }
    2719           0 :             else if( *answer == ansstr[2] || *answer == ansstr[3] ) {
    2720           0 :                 xfree(acomment); acomment = NULL;
    2721           0 :                 break;
    2722             :             }
    2723           0 :             else if( *answer == ansstr[4] || *answer == ansstr[5] ) {
    2724           0 :                 xfree(amail); amail = NULL;
    2725           0 :                 break;
    2726             :             }
    2727           0 :             else if( *answer == ansstr[6] || *answer == ansstr[7] ) {
    2728           0 :                 if( fail ) {
    2729           0 :                     tty_printf(_("Please correct the error first\n"));
    2730             :                 }
    2731             :                 else {
    2732           0 :                     xfree(aname); aname = NULL;
    2733           0 :                     xfree(acomment); acomment = NULL;
    2734           0 :                     xfree(amail); amail = NULL;
    2735           0 :                     break;
    2736             :                 }
    2737             :             }
    2738           0 :             else if( *answer == ansstr[8] || *answer == ansstr[9] ) {
    2739           0 :                 xfree(aname); aname = NULL;
    2740           0 :                 xfree(acomment); acomment = NULL;
    2741           0 :                 xfree(amail); amail = NULL;
    2742           0 :                 xfree(uid); uid = NULL;
    2743           0 :                 break;
    2744             :             }
    2745           0 :             xfree(answer);
    2746           0 :         }
    2747           0 :         xfree(answer);
    2748           0 :         if (!amail && !acomment)
    2749           0 :             break;
    2750           0 :         xfree(uid); uid = NULL;
    2751           0 :     }
    2752           0 :     if( uid ) {
    2753           0 :         char *p = native_to_utf8( uid );
    2754           0 :         xfree( uid );
    2755           0 :         uid = p;
    2756             :     }
    2757           0 :     return uid;
    2758             : }
    2759             : 
    2760             : 
    2761             : /* Basic key generation.  Here we divert to the actual generation
    2762             :    routines based on the requested algorithm.  */
    2763             : static int
    2764           3 : do_create (int algo, unsigned int nbits, const char *curve, KBNODE pub_root,
    2765             :            u32 timestamp, u32 expiredate, int is_subkey,
    2766             :            int keygen_flags, const char *passphrase,
    2767             :            char **cache_nonce_addr, char **passwd_nonce_addr)
    2768             : {
    2769             :   gpg_error_t err;
    2770             : 
    2771             :   /* Fixme: The entropy collecting message should be moved to a
    2772             :      libgcrypt progress handler.  */
    2773           3 :   if (!opt.batch)
    2774           0 :     tty_printf (_(
    2775             : "We need to generate a lot of random bytes. It is a good idea to perform\n"
    2776             : "some other action (type on the keyboard, move the mouse, utilize the\n"
    2777             : "disks) during the prime generation; this gives the random number\n"
    2778             : "generator a better chance to gain enough entropy.\n") );
    2779             : 
    2780           3 :   if (algo == PUBKEY_ALGO_ELGAMAL_E)
    2781           1 :     err = gen_elg (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
    2782             :                    keygen_flags, passphrase,
    2783             :                    cache_nonce_addr, passwd_nonce_addr);
    2784           2 :   else if (algo == PUBKEY_ALGO_DSA)
    2785           1 :     err = gen_dsa (nbits, pub_root, timestamp, expiredate, is_subkey,
    2786             :                    keygen_flags, passphrase,
    2787             :                    cache_nonce_addr, passwd_nonce_addr);
    2788           1 :   else if (algo == PUBKEY_ALGO_ECDSA
    2789           1 :            || algo == PUBKEY_ALGO_EDDSA
    2790           1 :            || algo == PUBKEY_ALGO_ECDH)
    2791           0 :     err = gen_ecc (algo, curve, pub_root, timestamp, expiredate, is_subkey,
    2792             :                    keygen_flags, passphrase,
    2793             :                    cache_nonce_addr, passwd_nonce_addr);
    2794           1 :   else if (algo == PUBKEY_ALGO_RSA)
    2795           1 :     err = gen_rsa (algo, nbits, pub_root, timestamp, expiredate, is_subkey,
    2796             :                    keygen_flags, passphrase,
    2797             :                    cache_nonce_addr, passwd_nonce_addr);
    2798             :   else
    2799           0 :     BUG();
    2800             : 
    2801           3 :   return err;
    2802             : }
    2803             : 
    2804             : 
    2805             : /* Generate a new user id packet or return NULL if canceled.  If
    2806             :    KEYBLOCK is not NULL the function prevents the creation of an
    2807             :    already existing user ID.  If UIDSTR is not NULL the user is not
    2808             :    asked but UIDSTR is used to create the user id packet; if the user
    2809             :    id already exists NULL is returned.  UIDSTR is expected to be utf-8
    2810             :    encoded and should have already been checked for a valid length
    2811             :    etc.  */
    2812             : PKT_user_id *
    2813           0 : generate_user_id (KBNODE keyblock, const char *uidstr)
    2814             : {
    2815             :   PKT_user_id *uid;
    2816             :   char *p;
    2817             : 
    2818           0 :   if (uidstr)
    2819             :     {
    2820           0 :       if (uid_already_in_keyblock (keyblock, uidstr))
    2821           0 :         return NULL;  /* Already exists.  */
    2822           0 :       uid = uid_from_string (uidstr);
    2823             :     }
    2824             :   else
    2825             :     {
    2826           0 :       p = ask_user_id (1, 1, keyblock);
    2827           0 :       if (!p)
    2828           0 :         return NULL;  /* Canceled. */
    2829           0 :       uid = uid_from_string (p);
    2830           0 :       xfree (p);
    2831             :     }
    2832           0 :   return uid;
    2833             : }
    2834             : 
    2835             : 
    2836             : /* Append R to the linked list PARA.  */
    2837             : static void
    2838           6 : append_to_parameter (struct para_data_s *para, struct para_data_s *r)
    2839             : {
    2840           6 :   log_assert (para);
    2841          59 :   while (para->next)
    2842          47 :     para = para->next;
    2843           6 :   para->next = r;
    2844           6 : }
    2845             : 
    2846             : /* Release the parameter list R.  */
    2847             : static void
    2848           4 : release_parameter_list (struct para_data_s *r)
    2849             : {
    2850             :   struct para_data_s *r2;
    2851             : 
    2852          25 :   for (; r ; r = r2)
    2853             :     {
    2854          21 :       r2 = r->next;
    2855          21 :       if (r->key == pPASSPHRASE && *r->u.value)
    2856           0 :         wipememory (r->u.value, strlen (r->u.value));
    2857          21 :       xfree (r);
    2858             :     }
    2859           4 : }
    2860             : 
    2861             : static struct para_data_s *
    2862          61 : get_parameter( struct para_data_s *para, enum para_name key )
    2863             : {
    2864             :     struct para_data_s *r;
    2865             : 
    2866          61 :     for( r = para; r && r->key != key; r = r->next )
    2867             :         ;
    2868          61 :     return r;
    2869             : }
    2870             : 
    2871             : static const char *
    2872          19 : get_parameter_value( struct para_data_s *para, enum para_name key )
    2873             : {
    2874          19 :     struct para_data_s *r = get_parameter( para, key );
    2875          19 :     return (r && *r->u.value)? r->u.value : NULL;
    2876             : }
    2877             : 
    2878             : 
    2879             : /* This is similar to get_parameter_value but also returns the empty
    2880             :    string.  This is required so that quick_generate_keypair can use an
    2881             :    empty Passphrase to specify no-protection.  */
    2882             : static const char *
    2883           3 : get_parameter_passphrase (struct para_data_s *para)
    2884             : {
    2885           3 :   struct para_data_s *r = get_parameter (para, pPASSPHRASE);
    2886           3 :   return r ? r->u.value : NULL;
    2887             : }
    2888             : 
    2889             : 
    2890             : static int
    2891           8 : get_parameter_algo( struct para_data_s *para, enum para_name key,
    2892             :                     int *r_default)
    2893             : {
    2894             :   int i;
    2895           8 :   struct para_data_s *r = get_parameter( para, key );
    2896             : 
    2897           8 :   if (r_default)
    2898           3 :     *r_default = 0;
    2899             : 
    2900           8 :   if (!r)
    2901           0 :     return -1;
    2902             : 
    2903             :   /* Note that we need to handle the ECC algorithms specified as
    2904             :      strings directly because Libgcrypt folds them all to ECC.  */
    2905           8 :   if (!ascii_strcasecmp (r->u.value, "default"))
    2906             :     {
    2907             :       /* Note: If you change this default algo, remember to change it
    2908             :          also in gpg.c:gpgconf_list.  */
    2909           0 :       i = DEFAULT_STD_ALGO;
    2910           0 :       if (r_default)
    2911           0 :         *r_default = 1;
    2912             :     }
    2913           8 :   else if (digitp (r->u.value))
    2914           0 :     i = atoi( r->u.value );
    2915           8 :   else if (!strcmp (r->u.value, "ELG-E")
    2916           8 :            || !strcmp (r->u.value, "ELG"))
    2917           2 :     i = PUBKEY_ALGO_ELGAMAL_E;
    2918           6 :   else if (!ascii_strcasecmp (r->u.value, "EdDSA"))
    2919           0 :     i = PUBKEY_ALGO_EDDSA;
    2920           6 :   else if (!ascii_strcasecmp (r->u.value, "ECDSA"))
    2921           0 :     i = PUBKEY_ALGO_ECDSA;
    2922           6 :   else if (!ascii_strcasecmp (r->u.value, "ECDH"))
    2923           0 :     i = PUBKEY_ALGO_ECDH;
    2924             :   else
    2925           6 :     i = map_pk_gcry_to_openpgp (gcry_pk_map_name (r->u.value));
    2926             : 
    2927           8 :   if (i == PUBKEY_ALGO_RSA_E || i == PUBKEY_ALGO_RSA_S)
    2928           0 :     i = 0; /* we don't want to allow generation of these algorithms */
    2929           8 :   return i;
    2930             : }
    2931             : 
    2932             : 
    2933             : /* Parse a usage string.  The usage keywords "auth", "sign", "encr"
    2934             :  * may be elimited by space, tab, or comma.  On error -1 is returned
    2935             :  * instead of the usage flags/  */
    2936             : static int
    2937           1 : parse_usagestr (const char *usagestr)
    2938             : {
    2939             :   gpg_error_t err;
    2940           1 :   char **tokens = NULL;
    2941             :   const char *s;
    2942             :   int i;
    2943           1 :   unsigned int use = 0;
    2944             : 
    2945           1 :   tokens = strtokenize (usagestr, " \t,");
    2946           1 :   if (!tokens)
    2947             :     {
    2948           0 :       err = gpg_error_from_syserror ();
    2949           0 :       log_error ("strtokenize failed: %s\n", gpg_strerror (err));
    2950           0 :       return -1;
    2951             :     }
    2952             : 
    2953           3 :   for (i=0; (s = tokens[i]); i++)
    2954             :     {
    2955           2 :       if (!*s)
    2956             :         ;
    2957           2 :       else if (!ascii_strcasecmp (s, "sign"))
    2958           1 :         use |= PUBKEY_USAGE_SIG;
    2959           1 :       else if (!ascii_strcasecmp (s, "encrypt")
    2960           0 :                 || !ascii_strcasecmp (s, "encr"))
    2961           1 :         use |= PUBKEY_USAGE_ENC;
    2962           0 :       else if (!ascii_strcasecmp (s, "auth"))
    2963           0 :         use |= PUBKEY_USAGE_AUTH;
    2964           0 :       else if (!ascii_strcasecmp (s, "cert"))
    2965           0 :         use |= PUBKEY_USAGE_CERT;
    2966             :       else
    2967             :         {
    2968           0 :           xfree (tokens);
    2969           0 :           return -1; /* error */
    2970             :         }
    2971             :     }
    2972             : 
    2973           1 :   xfree (tokens);
    2974           1 :   return use;
    2975             : }
    2976             : 
    2977             : 
    2978             : /*
    2979             :  * Parse the usage parameter and set the keyflags.  Returns -1 on
    2980             :  * error, 0 for no usage given or 1 for usage available.
    2981             :  */
    2982             : static int
    2983           3 : parse_parameter_usage (const char *fname,
    2984             :                        struct para_data_s *para, enum para_name key)
    2985             : {
    2986           3 :   struct para_data_s *r = get_parameter( para, key );
    2987             :   int i;
    2988             : 
    2989           3 :   if (!r)
    2990           2 :     return 0; /* none (this is an optional parameter)*/
    2991             : 
    2992           1 :   i = parse_usagestr (r->u.value);
    2993           1 :   if (i == -1)
    2994             :     {
    2995           0 :       log_error ("%s:%d: invalid usage list\n", fname, r->lnr );
    2996           0 :       return -1; /* error */
    2997             :     }
    2998             : 
    2999           1 :   r->u.usage = i;
    3000           1 :   return 1;
    3001             : }
    3002             : 
    3003             : 
    3004             : static int
    3005           2 : parse_revocation_key (const char *fname,
    3006             :                       struct para_data_s *para, enum para_name key)
    3007             : {
    3008           2 :   struct para_data_s *r = get_parameter( para, key );
    3009             :   struct revocation_key revkey;
    3010             :   char *pn;
    3011             :   int i;
    3012             : 
    3013           2 :   if( !r )
    3014           2 :     return 0; /* none (this is an optional parameter) */
    3015             : 
    3016           0 :   pn = r->u.value;
    3017             : 
    3018           0 :   revkey.class=0x80;
    3019           0 :   revkey.algid=atoi(pn);
    3020           0 :   if(!revkey.algid)
    3021           0 :     goto fail;
    3022             : 
    3023             :   /* Skip to the fpr */
    3024           0 :   while(*pn && *pn!=':')
    3025           0 :     pn++;
    3026             : 
    3027           0 :   if(*pn!=':')
    3028           0 :     goto fail;
    3029             : 
    3030           0 :   pn++;
    3031             : 
    3032           0 :   for(i=0;i<MAX_FINGERPRINT_LEN && *pn;i++,pn+=2)
    3033             :     {
    3034           0 :       int c=hextobyte(pn);
    3035           0 :       if(c==-1)
    3036           0 :         goto fail;
    3037             : 
    3038           0 :       revkey.fpr[i]=c;
    3039             :     }
    3040             : 
    3041             :   /* skip to the tag */
    3042           0 :   while(*pn && *pn!='s' && *pn!='S')
    3043           0 :     pn++;
    3044             : 
    3045           0 :   if(ascii_strcasecmp(pn,"sensitive")==0)
    3046           0 :     revkey.class|=0x40;
    3047             : 
    3048           0 :   memcpy(&r->u.revkey,&revkey,sizeof(struct revocation_key));
    3049             : 
    3050           0 :   return 0;
    3051             : 
    3052             :   fail:
    3053           0 :   log_error("%s:%d: invalid revocation key\n", fname, r->lnr );
    3054           0 :   return -1; /* error */
    3055             : }
    3056             : 
    3057             : 
    3058             : static u32
    3059          13 : get_parameter_u32( struct para_data_s *para, enum para_name key )
    3060             : {
    3061          13 :   struct para_data_s *r = get_parameter( para, key );
    3062             : 
    3063          13 :   if( !r )
    3064           2 :     return 0;
    3065          11 :   if( r->key == pKEYCREATIONDATE )
    3066           0 :     return r->u.creation;
    3067          11 :   if( r->key == pKEYEXPIRE || r->key == pSUBKEYEXPIRE )
    3068           3 :     return r->u.expire;
    3069           8 :   if( r->key == pKEYUSAGE || r->key == pSUBKEYUSAGE )
    3070           5 :     return r->u.usage;
    3071             : 
    3072           3 :   return (unsigned int)strtoul( r->u.value, NULL, 10 );
    3073             : }
    3074             : 
    3075             : static unsigned int
    3076           8 : get_parameter_uint( struct para_data_s *para, enum para_name key )
    3077             : {
    3078           8 :     return get_parameter_u32( para, key );
    3079             : }
    3080             : 
    3081             : static struct revocation_key *
    3082           2 : get_parameter_revkey( struct para_data_s *para, enum para_name key )
    3083             : {
    3084           2 :     struct para_data_s *r = get_parameter( para, key );
    3085           2 :     return r? &r->u.revkey : NULL;
    3086             : }
    3087             : 
    3088             : static int
    3089           2 : proc_parameter_file (ctrl_t ctrl, struct para_data_s *para, const char *fname,
    3090             :                      struct output_control_s *outctrl, int card )
    3091             : {
    3092             :   struct para_data_s *r;
    3093             :   const char *s1, *s2, *s3;
    3094             :   size_t n;
    3095             :   char *p;
    3096           2 :   int is_default = 0;
    3097           2 :   int have_user_id = 0;
    3098             :   int err, algo;
    3099             : 
    3100             :   /* Check that we have all required parameters. */
    3101           2 :   r = get_parameter( para, pKEYTYPE );
    3102           2 :   if(r)
    3103             :     {
    3104           2 :       algo = get_parameter_algo (para, pKEYTYPE, &is_default);
    3105           2 :       if (openpgp_pk_test_algo2 (algo, PUBKEY_USAGE_SIG))
    3106             :         {
    3107           0 :           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
    3108           0 :           return -1;
    3109             :         }
    3110             :     }
    3111             :   else
    3112             :     {
    3113           0 :       log_error ("%s: no Key-Type specified\n",fname);
    3114           0 :       return -1;
    3115             :     }
    3116             : 
    3117           2 :   err = parse_parameter_usage (fname, para, pKEYUSAGE);
    3118           2 :   if (!err)
    3119             :     {
    3120             :       /* Default to algo capabilities if key-usage is not provided and
    3121             :          no default algorithm has been requested.  */
    3122           1 :       r = xmalloc_clear(sizeof(*r));
    3123           1 :       r->key = pKEYUSAGE;
    3124           2 :       r->u.usage = (is_default
    3125           1 :                     ? (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG)
    3126           1 :                     : openpgp_pk_algo_usage(algo));
    3127           1 :       append_to_parameter (para, r);
    3128             :     }
    3129           1 :   else if (err == -1)
    3130           0 :     return -1;
    3131             :   else
    3132             :     {
    3133           1 :       r = get_parameter (para, pKEYUSAGE);
    3134           1 :       if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
    3135             :         {
    3136           0 :           log_error ("%s:%d: specified Key-Usage not allowed for algo %d\n",
    3137             :                      fname, r->lnr, algo);
    3138           0 :           return -1;
    3139             :         }
    3140             :     }
    3141             : 
    3142           2 :   is_default = 0;
    3143           2 :   r = get_parameter( para, pSUBKEYTYPE );
    3144           2 :   if(r)
    3145             :     {
    3146           1 :       algo = get_parameter_algo (para, pSUBKEYTYPE, &is_default);
    3147           1 :       if (openpgp_pk_test_algo (algo))
    3148             :         {
    3149           0 :           log_error ("%s:%d: invalid algorithm\n", fname, r->lnr );
    3150           0 :           return -1;
    3151             :         }
    3152             : 
    3153           1 :       err = parse_parameter_usage (fname, para, pSUBKEYUSAGE);
    3154           1 :       if (!err)
    3155             :         {
    3156             :           /* Default to algo capabilities if subkey-usage is not
    3157             :              provided */
    3158           1 :           r = xmalloc_clear (sizeof(*r));
    3159           1 :           r->key = pSUBKEYUSAGE;
    3160           2 :           r->u.usage = (is_default
    3161           1 :                         ? PUBKEY_USAGE_ENC
    3162           1 :                         : openpgp_pk_algo_usage (algo));
    3163           1 :           append_to_parameter (para, r);
    3164             :         }
    3165           0 :       else if (err == -1)
    3166           0 :         return -1;
    3167             :       else
    3168             :         {
    3169           0 :           r = get_parameter (para, pSUBKEYUSAGE);
    3170           0 :           if (r && (r->u.usage & ~openpgp_pk_algo_usage (algo)))
    3171             :             {
    3172           0 :               log_error ("%s:%d: specified Subkey-Usage not allowed"
    3173             :                          " for algo %d\n", fname, r->lnr, algo);
    3174           0 :               return -1;
    3175             :             }
    3176             :         }
    3177             :     }
    3178             : 
    3179             : 
    3180           2 :   if( get_parameter_value( para, pUSERID ) )
    3181           0 :     have_user_id=1;
    3182             :   else
    3183             :     {
    3184             :       /* create the formatted user ID */
    3185           2 :       s1 = get_parameter_value( para, pNAMEREAL );
    3186           2 :       s2 = get_parameter_value( para, pNAMECOMMENT );
    3187           2 :       s3 = get_parameter_value( para, pNAMEEMAIL );
    3188           2 :       if( s1 || s2 || s3 )
    3189             :         {
    3190           2 :           n = (s1?strlen(s1):0) + (s2?strlen(s2):0) + (s3?strlen(s3):0);
    3191           2 :           r = xmalloc_clear( sizeof *r + n + 20 );
    3192           2 :           r->key = pUSERID;
    3193           2 :           p = r->u.value;
    3194           2 :           if( s1 )
    3195           2 :             p = stpcpy(p, s1 );
    3196           2 :           if( s2 )
    3197           2 :             p = stpcpy(stpcpy(stpcpy(p," ("), s2 ),")");
    3198           2 :           if( s3 )
    3199           2 :             p = stpcpy(stpcpy(stpcpy(p," <"), s3 ),">");
    3200           2 :           append_to_parameter (para, r);
    3201           2 :           have_user_id=1;
    3202             :         }
    3203             :     }
    3204             : 
    3205           2 :   if(!have_user_id)
    3206             :     {
    3207           0 :       log_error("%s: no User-ID specified\n",fname);
    3208           0 :       return -1;
    3209             :     }
    3210             : 
    3211             :   /* Set preferences, if any. */
    3212           2 :   keygen_set_std_prefs(get_parameter_value( para, pPREFERENCES ), 0);
    3213             : 
    3214             :   /* Set keyserver, if any. */
    3215           2 :   s1=get_parameter_value( para, pKEYSERVER );
    3216           2 :   if(s1)
    3217             :     {
    3218             :       struct keyserver_spec *spec;
    3219             : 
    3220           0 :       spec = parse_keyserver_uri (s1, 1);
    3221           0 :       if(spec)
    3222             :         {
    3223           0 :           free_keyserver_spec(spec);
    3224           0 :           opt.def_keyserver_url=s1;
    3225             :         }
    3226             :       else
    3227             :         {
    3228           0 :           r = get_parameter (para, pKEYSERVER);
    3229           0 :           log_error("%s:%d: invalid keyserver url\n", fname, r->lnr );
    3230           0 :           return -1;
    3231             :         }
    3232             :     }
    3233             : 
    3234             :   /* Set revoker, if any. */
    3235           2 :   if (parse_revocation_key (fname, para, pREVOKER))
    3236           0 :     return -1;
    3237             : 
    3238             : 
    3239             :   /* Make KEYCREATIONDATE from Creation-Date.  */
    3240           2 :   r = get_parameter (para, pCREATIONDATE);
    3241           2 :   if (r && *r->u.value)
    3242             :     {
    3243             :       u32 seconds;
    3244             : 
    3245           0 :       seconds = parse_creation_string (r->u.value);
    3246           0 :       if (!seconds)
    3247             :         {
    3248           0 :           log_error ("%s:%d: invalid creation date\n", fname, r->lnr );
    3249           0 :           return -1;
    3250             :         }
    3251           0 :       r->u.creation = seconds;
    3252           0 :       r->key = pKEYCREATIONDATE;  /* Change that entry. */
    3253             :     }
    3254             : 
    3255             :   /* Make KEYEXPIRE from Expire-Date.  */
    3256           2 :   r = get_parameter( para, pEXPIREDATE );
    3257           2 :   if( r && *r->u.value )
    3258             :     {
    3259             :       u32 seconds;
    3260             : 
    3261           2 :       seconds = parse_expire_string( r->u.value );
    3262           2 :       if( seconds == (u32)-1 )
    3263             :         {
    3264           0 :           log_error("%s:%d: invalid expire date\n", fname, r->lnr );
    3265           0 :           return -1;
    3266             :         }
    3267           2 :       r->u.expire = seconds;
    3268           2 :       r->key = pKEYEXPIRE;  /* change hat entry */
    3269             :       /* also set it for the subkey */
    3270           2 :       r = xmalloc_clear( sizeof *r + 20 );
    3271           2 :       r->key = pSUBKEYEXPIRE;
    3272           2 :       r->u.expire = seconds;
    3273           2 :       append_to_parameter (para, r);
    3274             :     }
    3275             : 
    3276           2 :   do_generate_keypair (ctrl, para, outctrl, card );
    3277           2 :   return 0;
    3278             : }
    3279             : 
    3280             : 
    3281             : /****************
    3282             :  * Kludge to allow non interactive key generation controlled
    3283             :  * by a parameter file.
    3284             :  * Note, that string parameters are expected to be in UTF-8
    3285             :  */
    3286             : static void
    3287           2 : read_parameter_file (ctrl_t ctrl, const char *fname )
    3288             : {
    3289             :     static struct { const char *name;
    3290             :                     enum para_name key;
    3291             :     } keywords[] = {
    3292             :         { "Key-Type",       pKEYTYPE},
    3293             :         { "Key-Length",     pKEYLENGTH },
    3294             :         { "Key-Curve",      pKEYCURVE },
    3295             :         { "Key-Usage",      pKEYUSAGE },
    3296             :         { "Subkey-Type",    pSUBKEYTYPE },
    3297             :         { "Subkey-Length",  pSUBKEYLENGTH },
    3298             :         { "Subkey-Curve",   pSUBKEYCURVE },
    3299             :         { "Subkey-Usage",   pSUBKEYUSAGE },
    3300             :         { "Name-Real",      pNAMEREAL },
    3301             :         { "Name-Email",     pNAMEEMAIL },
    3302             :         { "Name-Comment",   pNAMECOMMENT },
    3303             :         { "Expire-Date",    pEXPIREDATE },
    3304             :         { "Creation-Date",  pCREATIONDATE },
    3305             :         { "Passphrase",     pPASSPHRASE },
    3306             :         { "Preferences",    pPREFERENCES },
    3307             :         { "Revoker",        pREVOKER },
    3308             :         { "Handle",         pHANDLE },
    3309             :         { "Keyserver",      pKEYSERVER },
    3310             :         { NULL, 0 }
    3311             :     };
    3312             :     IOBUF fp;
    3313             :     byte *line;
    3314             :     unsigned int maxlen, nline;
    3315             :     char *p;
    3316             :     int lnr;
    3317           2 :     const char *err = NULL;
    3318             :     struct para_data_s *para, *r;
    3319             :     int i;
    3320             :     struct output_control_s outctrl;
    3321             : 
    3322           2 :     memset( &outctrl, 0, sizeof( outctrl ) );
    3323           2 :     outctrl.pub.afx = new_armor_context ();
    3324             : 
    3325           2 :     if( !fname || !*fname)
    3326           2 :       fname = "-";
    3327             : 
    3328           2 :     fp = iobuf_open (fname);
    3329           2 :     if (fp && is_secured_file (iobuf_get_fd (fp)))
    3330             :       {
    3331           0 :         iobuf_close (fp);
    3332           0 :         fp = NULL;
    3333           0 :         gpg_err_set_errno (EPERM);
    3334             :       }
    3335           2 :     if (!fp) {
    3336           0 :       log_error (_("can't open '%s': %s\n"), fname, strerror(errno) );
    3337           2 :       return;
    3338             :     }
    3339           2 :     iobuf_ioctl (fp, IOBUF_IOCTL_NO_CACHE, 1, NULL);
    3340             : 
    3341           2 :     lnr = 0;
    3342           2 :     err = NULL;
    3343           2 :     para = NULL;
    3344           2 :     maxlen = 1024;
    3345           2 :     line = NULL;
    3346          25 :     while ( iobuf_read_line (fp, &line, &nline, &maxlen) ) {
    3347             :         char *keyword, *value;
    3348             : 
    3349          21 :         lnr++;
    3350          21 :         if( !maxlen ) {
    3351           0 :             err = "line too long";
    3352           0 :             break;
    3353             :         }
    3354          21 :         for( p = line; isspace(*(byte*)p); p++ )
    3355             :             ;
    3356          21 :         if( !*p || *p == '#' )
    3357           0 :             continue;
    3358          21 :         keyword = p;
    3359          21 :         if( *keyword == '%' ) {
    3360           6 :             for( ; !isspace(*(byte*)p); p++ )
    3361             :                 ;
    3362           6 :             if( *p )
    3363           6 :                 *p++ = 0;
    3364           6 :             for( ; isspace(*(byte*)p); p++ )
    3365             :                 ;
    3366           6 :             value = p;
    3367           6 :             trim_trailing_ws( value, strlen(value) );
    3368           6 :             if( !ascii_strcasecmp( keyword, "%echo" ) )
    3369           0 :                 log_info("%s\n", value );
    3370           6 :             else if( !ascii_strcasecmp( keyword, "%dry-run" ) )
    3371           0 :                 outctrl.dryrun = 1;
    3372           6 :             else if( !ascii_strcasecmp( keyword, "%ask-passphrase" ) )
    3373             :               ; /* Dummy for backward compatibility. */
    3374           6 :             else if( !ascii_strcasecmp( keyword, "%no-ask-passphrase" ) )
    3375             :               ; /* Dummy for backward compatibility. */
    3376           6 :             else if( !ascii_strcasecmp( keyword, "%no-protection" ) )
    3377           2 :                 outctrl.keygen_flags |= KEYGEN_FLAG_NO_PROTECTION;
    3378           4 :             else if( !ascii_strcasecmp( keyword, "%transient-key" ) )
    3379           2 :                 outctrl.keygen_flags |= KEYGEN_FLAG_TRANSIENT_KEY;
    3380           2 :             else if( !ascii_strcasecmp( keyword, "%commit" ) ) {
    3381           2 :                 outctrl.lnr = lnr;
    3382           2 :                 if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
    3383           0 :                   print_status_key_not_created
    3384             :                     (get_parameter_value (para, pHANDLE));
    3385           2 :                 release_parameter_list( para );
    3386           2 :                 para = NULL;
    3387             :             }
    3388           0 :             else if( !ascii_strcasecmp( keyword, "%pubring" ) ) {
    3389           0 :                 if( outctrl.pub.fname && !strcmp( outctrl.pub.fname, value ) )
    3390             :                     ; /* still the same file - ignore it */
    3391             :                 else {
    3392           0 :                     xfree( outctrl.pub.newfname );
    3393           0 :                     outctrl.pub.newfname = xstrdup( value );
    3394           0 :                     outctrl.use_files = 1;
    3395             :                 }
    3396             :             }
    3397           0 :             else if( !ascii_strcasecmp( keyword, "%secring" ) ) {
    3398             :               /* Ignore this command.  */
    3399             :             }
    3400             :             else
    3401           0 :                 log_info("skipping control '%s' (%s)\n", keyword, value );
    3402             : 
    3403             : 
    3404           6 :             continue;
    3405             :         }
    3406             : 
    3407             : 
    3408          15 :         if( !(p = strchr( p, ':' )) || p == keyword ) {
    3409           0 :             err = "missing colon";
    3410           0 :             break;
    3411             :         }
    3412          15 :         if( *p )
    3413          15 :             *p++ = 0;
    3414          15 :         for( ; isspace(*(byte*)p); p++ )
    3415             :             ;
    3416          15 :         if( !*p ) {
    3417           0 :             err = "missing argument";
    3418           0 :             break;
    3419             :         }
    3420          15 :         value = p;
    3421          15 :         trim_trailing_ws( value, strlen(value) );
    3422             : 
    3423         105 :         for(i=0; keywords[i].name; i++ ) {
    3424         105 :             if( !ascii_strcasecmp( keywords[i].name, keyword ) )
    3425          15 :                 break;
    3426             :         }
    3427          15 :         if( !keywords[i].name ) {
    3428           0 :             err = "unknown keyword";
    3429           0 :             break;
    3430             :         }
    3431          15 :         if( keywords[i].key != pKEYTYPE && !para ) {
    3432           0 :             err = "parameter block does not start with \"Key-Type\"";
    3433           0 :             break;
    3434             :         }
    3435             : 
    3436          15 :         if( keywords[i].key == pKEYTYPE && para ) {
    3437           0 :             outctrl.lnr = lnr;
    3438           0 :             if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
    3439           0 :               print_status_key_not_created
    3440             :                 (get_parameter_value (para, pHANDLE));
    3441           0 :             release_parameter_list( para );
    3442           0 :             para = NULL;
    3443             :         }
    3444             :         else {
    3445          64 :             for( r = para; r; r = r->next ) {
    3446          49 :                 if( r->key == keywords[i].key )
    3447           0 :                     break;
    3448             :             }
    3449          15 :             if( r ) {
    3450           0 :                 err = "duplicate keyword";
    3451           0 :                 break;
    3452             :             }
    3453             :         }
    3454          15 :         r = xmalloc_clear( sizeof *r + strlen( value ) );
    3455          15 :         r->lnr = lnr;
    3456          15 :         r->key = keywords[i].key;
    3457          15 :         strcpy( r->u.value, value );
    3458          15 :         r->next = para;
    3459          15 :         para = r;
    3460             :     }
    3461           2 :     if( err )
    3462           0 :         log_error("%s:%d: %s\n", fname, lnr, err );
    3463           2 :     else if( iobuf_error (fp) ) {
    3464           0 :         log_error("%s:%d: read error\n", fname, lnr);
    3465             :     }
    3466           2 :     else if( para ) {
    3467           0 :         outctrl.lnr = lnr;
    3468           0 :         if (proc_parameter_file (ctrl, para, fname, &outctrl, 0 ))
    3469           0 :           print_status_key_not_created (get_parameter_value (para, pHANDLE));
    3470             :     }
    3471             : 
    3472           2 :     if( outctrl.use_files ) { /* close open streams */
    3473           0 :         iobuf_close( outctrl.pub.stream );
    3474             : 
    3475             :         /* Must invalidate that ugly cache to actually close it.  */
    3476           0 :         if (outctrl.pub.fname)
    3477           0 :           iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
    3478           0 :                        0, (char*)outctrl.pub.fname);
    3479             : 
    3480           0 :         xfree( outctrl.pub.fname );
    3481           0 :         xfree( outctrl.pub.newfname );
    3482             :     }
    3483             : 
    3484           2 :     xfree (line);
    3485           2 :     release_parameter_list( para );
    3486           2 :     iobuf_close (fp);
    3487           2 :     release_armor_context (outctrl.pub.afx);
    3488             : }
    3489             : 
    3490             : 
    3491             : /* Helper for quick_generate_keypair.  */
    3492             : static struct para_data_s *
    3493           0 : quickgen_set_para (struct para_data_s *para, int for_subkey,
    3494             :                    int algo, int nbits, const char *curve, unsigned int use)
    3495             : {
    3496             :   struct para_data_s *r;
    3497             : 
    3498           0 :   r = xmalloc_clear (sizeof *r + 30);
    3499           0 :   r->key = for_subkey? pSUBKEYUSAGE :  pKEYUSAGE;
    3500           0 :   if (use)
    3501           0 :     snprintf (r->u.value, 30, "%s%s%s%s",
    3502           0 :               (use & PUBKEY_USAGE_ENC)?  "encr " : "",
    3503           0 :               (use & PUBKEY_USAGE_SIG)?  "sign " : "",
    3504           0 :               (use & PUBKEY_USAGE_AUTH)? "auth " : "",
    3505           0 :               (use & PUBKEY_USAGE_CERT)? "cert " : "");
    3506             :   else
    3507           0 :     strcpy (r->u.value, for_subkey ? "encr" : "sign");
    3508           0 :   r->next = para;
    3509           0 :   para = r;
    3510           0 :   r = xmalloc_clear (sizeof *r + 20);
    3511           0 :   r->key = for_subkey? pSUBKEYTYPE : pKEYTYPE;
    3512           0 :   snprintf (r->u.value, 20, "%d", algo);
    3513           0 :   r->next = para;
    3514           0 :   para = r;
    3515             : 
    3516           0 :   if (curve)
    3517             :     {
    3518           0 :       r = xmalloc_clear (sizeof *r + strlen (curve));
    3519           0 :       r->key = for_subkey? pSUBKEYCURVE : pKEYCURVE;
    3520           0 :       strcpy (r->u.value, curve);
    3521           0 :       r->next = para;
    3522           0 :       para = r;
    3523             :     }
    3524             :   else
    3525             :     {
    3526           0 :       r = xmalloc_clear (sizeof *r + 20);
    3527           0 :       r->key = for_subkey? pSUBKEYLENGTH : pKEYLENGTH;
    3528           0 :       sprintf (r->u.value, "%u", nbits);
    3529           0 :       r->next = para;
    3530           0 :       para = r;
    3531             :     }
    3532             : 
    3533           0 :   return para;
    3534             : }
    3535             : 
    3536             : 
    3537             : /*
    3538             :  * Unattended generation of a standard key.
    3539             :  */
    3540             : void
    3541           0 : quick_generate_keypair (ctrl_t ctrl, const char *uid, const char *algostr,
    3542             :                         const char *usagestr, const char *expirestr)
    3543             : {
    3544             :   gpg_error_t err;
    3545           0 :   struct para_data_s *para = NULL;
    3546             :   struct para_data_s *r;
    3547             :   struct output_control_s outctrl;
    3548             :   int use_tty;
    3549             : 
    3550           0 :   memset (&outctrl, 0, sizeof outctrl);
    3551             : 
    3552           0 :   use_tty = (!opt.batch && !opt.answer_yes
    3553           0 :              && !*algostr && !*usagestr && !*expirestr
    3554           0 :              && !cpr_enabled ()
    3555           0 :              && gnupg_isatty (fileno (stdin))
    3556           0 :              && gnupg_isatty (fileno (stdout))
    3557           0 :              && gnupg_isatty (fileno (stderr)));
    3558             : 
    3559           0 :   r = xmalloc_clear (sizeof *r + strlen (uid));
    3560           0 :   r->key = pUSERID;
    3561           0 :   strcpy (r->u.value, uid);
    3562           0 :   r->next = para;
    3563           0 :   para = r;
    3564             : 
    3565           0 :   uid = trim_spaces (r->u.value);
    3566           0 :   if (!*uid || (!opt.allow_freeform_uid && !is_valid_user_id (uid)))
    3567             :     {
    3568           0 :       log_error (_("Key generation failed: %s\n"),
    3569             :                  gpg_strerror (GPG_ERR_INV_USER_ID));
    3570           0 :       goto leave;
    3571             :     }
    3572             : 
    3573             :   /* If gpg is directly used on the console ask whether a key with the
    3574             :      given user id shall really be created.  */
    3575           0 :   if (use_tty)
    3576             :     {
    3577           0 :       tty_printf (_("About to create a key for:\n    \"%s\"\n\n"), uid);
    3578           0 :       if (!cpr_get_answer_is_yes_def ("quick_keygen.okay",
    3579           0 :                                       _("Continue? (Y/n) "), 1))
    3580           0 :         goto leave;
    3581             :     }
    3582             : 
    3583             :   /* Check whether such a user ID already exists.  */
    3584             :   {
    3585             :     KEYDB_HANDLE kdbhd;
    3586             :     KEYDB_SEARCH_DESC desc;
    3587             : 
    3588           0 :     memset (&desc, 0, sizeof desc);
    3589           0 :     desc.mode = KEYDB_SEARCH_MODE_EXACT;
    3590           0 :     desc.u.name = uid;
    3591             : 
    3592           0 :     kdbhd = keydb_new ();
    3593           0 :     if (!kdbhd)
    3594           0 :       goto leave;
    3595             : 
    3596           0 :     err = keydb_search (kdbhd, &desc, 1, NULL);
    3597           0 :     keydb_release (kdbhd);
    3598           0 :     if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
    3599             :       {
    3600           0 :         log_info (_("A key for \"%s\" already exists\n"), uid);
    3601           0 :         if (opt.answer_yes)
    3602             :           ;
    3603           0 :         else if (!use_tty
    3604           0 :                  || !cpr_get_answer_is_yes_def ("quick_keygen.force",
    3605           0 :                                                 _("Create anyway? (y/N) "), 0))
    3606             :           {
    3607           0 :             log_inc_errorcount ();  /* we used log_info */
    3608           0 :             goto leave;
    3609             :           }
    3610           0 :         log_info (_("creating anyway\n"));
    3611             :       }
    3612             :   }
    3613             : 
    3614             : 
    3615           0 :   if (!strcmp (algostr, "test-default"))
    3616             :     {
    3617           0 :       para = quickgen_set_para (para, 0, PUBKEY_ALGO_EDDSA, 0, "Ed25519", 0);
    3618           0 :       para = quickgen_set_para (para, 1, PUBKEY_ALGO_ECDH,  0, "Curve25519", 0);
    3619             :     }
    3620           0 :   else if (*algostr || *usagestr || *expirestr)
    3621           0 :     {
    3622             :       /* Extended unattended mode.  Creates only the primary key. */
    3623             :       int algo;
    3624             :       unsigned int use;
    3625             :       u32 expire;
    3626             :       unsigned int nbits;
    3627             :       char *curve;
    3628             : 
    3629           0 :       err = parse_algo_usage_expire (ctrl, 0, algostr, usagestr, expirestr,
    3630             :                                      &algo, &use, &expire, &nbits, &curve);
    3631           0 :       if (err)
    3632             :         {
    3633           0 :           log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
    3634           0 :           goto leave;
    3635             :         }
    3636             : 
    3637           0 :       para = quickgen_set_para (para, 0, algo, nbits, curve, use);
    3638           0 :       r = xmalloc_clear (sizeof *r + 20);
    3639           0 :       r->key = pKEYEXPIRE;
    3640           0 :       r->u.expire = expire;
    3641           0 :       r->next = para;
    3642           0 :       para = r;
    3643             :     }
    3644             :   else
    3645             :     {
    3646           0 :       para = quickgen_set_para (para, 0,
    3647             :                                 DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
    3648             :                                 DEFAULT_STD_CURVE, 0);
    3649           0 :       para = quickgen_set_para (para, 1,
    3650             :                                 DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
    3651             :                                 DEFAULT_STD_SUBCURVE, 0);
    3652             :     }
    3653             : 
    3654             :   /* If the pinentry loopback mode is not and we have a static
    3655             :      passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
    3656             :      mode), we use that passphrase for the new key.  */
    3657           0 :   if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
    3658           0 :       && have_static_passphrase ())
    3659             :     {
    3660           0 :       const char *s = get_static_passphrase ();
    3661             : 
    3662           0 :       r = xmalloc_clear (sizeof *r + strlen (s));
    3663           0 :       r->key = pPASSPHRASE;
    3664           0 :       strcpy (r->u.value, s);
    3665           0 :       r->next = para;
    3666           0 :       para = r;
    3667             :     }
    3668             : 
    3669           0 :   proc_parameter_file (ctrl, para, "[internal]", &outctrl, 0);
    3670             : 
    3671             :  leave:
    3672           0 :   release_parameter_list (para);
    3673           0 : }
    3674             : 
    3675             : 
    3676             : /*
    3677             :  * Generate a keypair (fname is only used in batch mode) If
    3678             :  * CARD_SERIALNO is not NULL the function will create the keys on an
    3679             :  * OpenPGP Card.  If CARD_BACKUP_KEY has been set and CARD_SERIALNO is
    3680             :  * NOT NULL, the encryption key for the card is generated on the host,
    3681             :  * imported to the card and a backup file created by gpg-agent.  If
    3682             :  * FULL is not set only the basic prompts are used (except for batch
    3683             :  * mode).
    3684             :  */
    3685             : void
    3686           2 : generate_keypair (ctrl_t ctrl, int full, const char *fname,
    3687             :                   const char *card_serialno, int card_backup_key)
    3688             : {
    3689             :   unsigned int nbits;
    3690           2 :   char *uid = NULL;
    3691             :   int algo;
    3692             :   unsigned int use;
    3693           2 :   int both = 0;
    3694             :   u32 expire;
    3695           2 :   struct para_data_s *para = NULL;
    3696             :   struct para_data_s *r;
    3697             :   struct output_control_s outctrl;
    3698             : 
    3699             : #ifndef ENABLE_CARD_SUPPORT
    3700             :   (void)card_backup_key;
    3701             : #endif
    3702             : 
    3703           2 :   memset( &outctrl, 0, sizeof( outctrl ) );
    3704             : 
    3705           2 :   if (opt.batch && card_serialno)
    3706             :     {
    3707             :       /* We don't yet support unattended key generation. */
    3708           0 :       log_error (_("can't do this in batch mode\n"));
    3709           0 :       return;
    3710             :     }
    3711             : 
    3712           2 :   if (opt.batch)
    3713             :     {
    3714           2 :       read_parameter_file (ctrl, fname);
    3715           2 :       return;
    3716             :     }
    3717             : 
    3718           0 :   if (card_serialno)
    3719             :     {
    3720             : #ifdef ENABLE_CARD_SUPPORT
    3721           0 :       r = xcalloc (1, sizeof *r + strlen (card_serialno) );
    3722           0 :       r->key = pSERIALNO;
    3723           0 :       strcpy( r->u.value, card_serialno);
    3724           0 :       r->next = para;
    3725           0 :       para = r;
    3726             : 
    3727           0 :       algo = PUBKEY_ALGO_RSA;
    3728             : 
    3729           0 :       r = xcalloc (1, sizeof *r + 20 );
    3730           0 :       r->key = pKEYTYPE;
    3731           0 :       sprintf( r->u.value, "%d", algo );
    3732           0 :       r->next = para;
    3733           0 :       para = r;
    3734           0 :       r = xcalloc (1, sizeof *r + 20 );
    3735           0 :       r->key = pKEYUSAGE;
    3736           0 :       strcpy (r->u.value, "sign");
    3737           0 :       r->next = para;
    3738           0 :       para = r;
    3739             : 
    3740           0 :       r = xcalloc (1, sizeof *r + 20 );
    3741           0 :       r->key = pSUBKEYTYPE;
    3742           0 :       sprintf( r->u.value, "%d", algo );
    3743           0 :       r->next = para;
    3744           0 :       para = r;
    3745           0 :       r = xcalloc (1, sizeof *r + 20 );
    3746           0 :       r->key = pSUBKEYUSAGE;
    3747           0 :       strcpy (r->u.value, "encrypt");
    3748           0 :       r->next = para;
    3749           0 :       para = r;
    3750             : 
    3751           0 :       r = xcalloc (1, sizeof *r + 20 );
    3752           0 :       r->key = pAUTHKEYTYPE;
    3753           0 :       sprintf( r->u.value, "%d", algo );
    3754           0 :       r->next = para;
    3755           0 :       para = r;
    3756             : 
    3757           0 :       if (card_backup_key)
    3758             :         {
    3759           0 :           r = xcalloc (1, sizeof *r + 1);
    3760           0 :           r->key = pCARDBACKUPKEY;
    3761           0 :           strcpy (r->u.value, "1");
    3762           0 :           r->next = para;
    3763           0 :           para = r;
    3764             :         }
    3765             : #endif /*ENABLE_CARD_SUPPORT*/
    3766             :     }
    3767           0 :   else if (full)  /* Full featured key generation.  */
    3768             :     {
    3769             :       int subkey_algo;
    3770           0 :       char *curve = NULL;
    3771             : 
    3772             :       /* Fixme: To support creating a primary key by keygrip we better
    3773             :          also define the keyword for the parameter file.  Note that
    3774             :          the subkey case will never be asserted if a keygrip has been
    3775             :          given.  */
    3776           0 :       algo = ask_algo (ctrl, 0, &subkey_algo, &use, NULL);
    3777           0 :       if (subkey_algo)
    3778             :         {
    3779             :           /* Create primary and subkey at once.  */
    3780           0 :           both = 1;
    3781           0 :           if (algo == PUBKEY_ALGO_ECDSA
    3782           0 :               || algo == PUBKEY_ALGO_EDDSA
    3783           0 :               || algo == PUBKEY_ALGO_ECDH)
    3784             :             {
    3785           0 :               curve = ask_curve (&algo, &subkey_algo);
    3786           0 :               r = xmalloc_clear( sizeof *r + 20 );
    3787           0 :               r->key = pKEYTYPE;
    3788           0 :               sprintf( r->u.value, "%d", algo);
    3789           0 :               r->next = para;
    3790           0 :               para = r;
    3791           0 :               nbits = 0;
    3792           0 :               r = xmalloc_clear (sizeof *r + strlen (curve));
    3793           0 :               r->key = pKEYCURVE;
    3794           0 :               strcpy (r->u.value, curve);
    3795           0 :               r->next = para;
    3796           0 :               para = r;
    3797             :             }
    3798             :           else
    3799             :             {
    3800           0 :               r = xmalloc_clear( sizeof *r + 20 );
    3801           0 :               r->key = pKEYTYPE;
    3802           0 :               sprintf( r->u.value, "%d", algo);
    3803           0 :               r->next = para;
    3804           0 :               para = r;
    3805           0 :               nbits = ask_keysize (algo, 0);
    3806           0 :               r = xmalloc_clear( sizeof *r + 20 );
    3807           0 :               r->key = pKEYLENGTH;
    3808           0 :               sprintf( r->u.value, "%u", nbits);
    3809           0 :               r->next = para;
    3810           0 :               para = r;
    3811             :             }
    3812           0 :           r = xmalloc_clear( sizeof *r + 20 );
    3813           0 :           r->key = pKEYUSAGE;
    3814           0 :           strcpy( r->u.value, "sign" );
    3815           0 :           r->next = para;
    3816           0 :           para = r;
    3817             : 
    3818           0 :           r = xmalloc_clear( sizeof *r + 20 );
    3819           0 :           r->key = pSUBKEYTYPE;
    3820           0 :           sprintf( r->u.value, "%d", subkey_algo);
    3821           0 :           r->next = para;
    3822           0 :           para = r;
    3823           0 :           r = xmalloc_clear( sizeof *r + 20 );
    3824           0 :           r->key = pSUBKEYUSAGE;
    3825           0 :           strcpy( r->u.value, "encrypt" );
    3826           0 :           r->next = para;
    3827           0 :           para = r;
    3828             : 
    3829           0 :           if (algo == PUBKEY_ALGO_ECDSA
    3830           0 :               || algo == PUBKEY_ALGO_EDDSA
    3831           0 :               || algo == PUBKEY_ALGO_ECDH)
    3832             :             {
    3833           0 :               if (algo == PUBKEY_ALGO_EDDSA
    3834           0 :                   && subkey_algo == PUBKEY_ALGO_ECDH)
    3835             :                 {
    3836             :                   /* Need to switch to a different curve for the
    3837             :                      encryption key.  */
    3838           0 :                   xfree (curve);
    3839           0 :                   curve = xstrdup ("Curve25519");
    3840             :                 }
    3841           0 :               r = xmalloc_clear (sizeof *r + strlen (curve));
    3842           0 :               r->key = pSUBKEYCURVE;
    3843           0 :               strcpy (r->u.value, curve);
    3844           0 :               r->next = para;
    3845           0 :               para = r;
    3846             :             }
    3847             :         }
    3848             :       else /* Create only a single key.  */
    3849             :         {
    3850             :           /* For ECC we need to ask for the curve before storing the
    3851             :              algo because ask_curve may change the algo.  */
    3852           0 :           if (algo == PUBKEY_ALGO_ECDSA
    3853           0 :               || algo == PUBKEY_ALGO_EDDSA
    3854           0 :               || algo == PUBKEY_ALGO_ECDH)
    3855             :             {
    3856           0 :               curve = ask_curve (&algo, NULL);
    3857           0 :               r = xmalloc_clear (sizeof *r + strlen (curve));
    3858           0 :               r->key = pKEYCURVE;
    3859           0 :               strcpy (r->u.value, curve);
    3860           0 :               r->next = para;
    3861           0 :               para = r;
    3862             :             }
    3863             : 
    3864           0 :           r = xmalloc_clear( sizeof *r + 20 );
    3865           0 :           r->key = pKEYTYPE;
    3866           0 :           sprintf( r->u.value, "%d", algo );
    3867           0 :           r->next = para;
    3868           0 :           para = r;
    3869             : 
    3870           0 :           if (use)
    3871             :             {
    3872           0 :               r = xmalloc_clear( sizeof *r + 25 );
    3873           0 :               r->key = pKEYUSAGE;
    3874           0 :               sprintf( r->u.value, "%s%s%s",
    3875           0 :                        (use & PUBKEY_USAGE_SIG)? "sign ":"",
    3876           0 :                        (use & PUBKEY_USAGE_ENC)? "encrypt ":"",
    3877           0 :                        (use & PUBKEY_USAGE_AUTH)? "auth":"" );
    3878           0 :               r->next = para;
    3879           0 :               para = r;
    3880             :             }
    3881           0 :           nbits = 0;
    3882             :         }
    3883             : 
    3884           0 :       if (algo == PUBKEY_ALGO_ECDSA
    3885           0 :           || algo == PUBKEY_ALGO_EDDSA
    3886           0 :           || algo == PUBKEY_ALGO_ECDH)
    3887             :         {
    3888             :           /* The curve has already been set.  */
    3889             :         }
    3890             :       else
    3891             :         {
    3892           0 :           nbits = ask_keysize (both? subkey_algo : algo, nbits);
    3893           0 :           r = xmalloc_clear( sizeof *r + 20 );
    3894           0 :           r->key = both? pSUBKEYLENGTH : pKEYLENGTH;
    3895           0 :           sprintf( r->u.value, "%u", nbits);
    3896           0 :           r->next = para;
    3897           0 :           para = r;
    3898             :         }
    3899             : 
    3900           0 :       xfree (curve);
    3901             :     }
    3902             :   else /* Default key generation.  */
    3903             :     {
    3904           0 :       tty_printf ( _("Note: Use \"%s %s\""
    3905             :                      " for a full featured key generation dialog.\n"),
    3906             : #if USE_GPG2_HACK
    3907             :                    GPG_NAME "2"
    3908             : #else
    3909             :                    GPG_NAME
    3910             : #endif
    3911             :                    , "--full-gen-key" );
    3912           0 :       para = quickgen_set_para (para, 0,
    3913             :                                 DEFAULT_STD_ALGO, DEFAULT_STD_KEYSIZE,
    3914             :                                 DEFAULT_STD_CURVE, 0);
    3915           0 :       para = quickgen_set_para (para, 1,
    3916             :                                 DEFAULT_STD_SUBALGO, DEFAULT_STD_SUBKEYSIZE,
    3917             :                                 DEFAULT_STD_SUBCURVE, 0);
    3918             :     }
    3919             : 
    3920             : 
    3921           0 :   expire = full? ask_expire_interval (0, NULL) : 0;
    3922           0 :   r = xcalloc (1, sizeof *r + 20);
    3923           0 :   r->key = pKEYEXPIRE;
    3924           0 :   r->u.expire = expire;
    3925           0 :   r->next = para;
    3926           0 :   para = r;
    3927           0 :   r = xcalloc (1, sizeof *r + 20);
    3928           0 :   r->key = pSUBKEYEXPIRE;
    3929           0 :   r->u.expire = expire;
    3930           0 :   r->next = para;
    3931           0 :   para = r;
    3932             : 
    3933           0 :   uid = ask_user_id (0, full, NULL);
    3934           0 :   if (!uid)
    3935             :     {
    3936           0 :       log_error(_("Key generation canceled.\n"));
    3937           0 :       release_parameter_list( para );
    3938           0 :       return;
    3939             :     }
    3940           0 :   r = xcalloc (1, sizeof *r + strlen (uid));
    3941           0 :   r->key = pUSERID;
    3942           0 :   strcpy (r->u.value, uid);
    3943           0 :   r->next = para;
    3944           0 :   para = r;
    3945             : 
    3946           0 :   proc_parameter_file (ctrl, para, "[internal]", &outctrl, !!card_serialno);
    3947           0 :   release_parameter_list (para);
    3948             : }
    3949             : 
    3950             : 
    3951             : /* Create and delete a dummy packet to start off a list of kbnodes. */
    3952             : static void
    3953           2 : start_tree(KBNODE *tree)
    3954             : {
    3955             :   PACKET *pkt;
    3956             : 
    3957           2 :   pkt=xmalloc_clear(sizeof(*pkt));
    3958           2 :   pkt->pkttype=PKT_NONE;
    3959           2 :   *tree=new_kbnode(pkt);
    3960           2 :   delete_kbnode(*tree);
    3961           2 : }
    3962             : 
    3963             : 
    3964             : /* Write the *protected* secret key to the file.  */
    3965             : static gpg_error_t
    3966           0 : card_write_key_to_backup_file (PKT_public_key *sk, const char *backup_dir)
    3967             : {
    3968           0 :   gpg_error_t err = 0;
    3969             :   int rc;
    3970             :   char keyid_buffer[2 * 8 + 1];
    3971             :   char name_buffer[50];
    3972             :   char *fname;
    3973             :   IOBUF fp;
    3974             :   mode_t oldmask;
    3975           0 :   PACKET *pkt = NULL;
    3976             : 
    3977           0 :   format_keyid (pk_keyid (sk), KF_LONG, keyid_buffer, sizeof (keyid_buffer));
    3978           0 :   snprintf (name_buffer, sizeof name_buffer, "sk_%s.gpg", keyid_buffer);
    3979             : 
    3980           0 :   fname = make_filename (backup_dir, name_buffer, NULL);
    3981             :   /* Note that the umask call is not anymore needed because
    3982             :      iobuf_create now takes care of it.  However, it does not harm
    3983             :      and thus we keep it.  */
    3984           0 :   oldmask = umask (077);
    3985           0 :   if (is_secured_filename (fname))
    3986             :     {
    3987           0 :       fp = NULL;
    3988           0 :       gpg_err_set_errno (EPERM);
    3989             :     }
    3990             :   else
    3991           0 :     fp = iobuf_create (fname, 1);
    3992           0 :   umask (oldmask);
    3993           0 :   if (!fp)
    3994             :     {
    3995           0 :       err = gpg_error_from_syserror ();
    3996           0 :       log_error (_("can't create backup file '%s': %s\n"), fname, strerror (errno) );
    3997           0 :       goto leave;
    3998             :     }
    3999             : 
    4000           0 :   pkt = xcalloc (1, sizeof *pkt);
    4001           0 :   pkt->pkttype = PKT_SECRET_KEY;
    4002           0 :   pkt->pkt.secret_key = sk;
    4003             : 
    4004           0 :   rc = build_packet (fp, pkt);
    4005           0 :   if (rc)
    4006             :     {
    4007           0 :       log_error ("build packet failed: %s\n", gpg_strerror (rc));
    4008           0 :       iobuf_cancel (fp);
    4009             :     }
    4010             :   else
    4011             :     {
    4012             :       char *fprbuf;
    4013             : 
    4014           0 :       iobuf_close (fp);
    4015           0 :       iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char*)fname);
    4016           0 :       log_info (_("Note: backup of card key saved to '%s'\n"), fname);
    4017             : 
    4018           0 :       fprbuf = hexfingerprint (sk, NULL, 0);
    4019           0 :       write_status_text_and_buffer (STATUS_BACKUP_KEY_CREATED, fprbuf,
    4020             :                                     fname, strlen (fname), 0);
    4021           0 :       xfree (fprbuf);
    4022             :     }
    4023             : 
    4024             :  leave:
    4025           0 :   xfree (pkt);
    4026           0 :   xfree (fname);
    4027           0 :   return err;
    4028             : }
    4029             : 
    4030             : 
    4031             : /* Store key to card and make a backup file in OpenPGP format.  */
    4032             : static gpg_error_t
    4033           0 : card_store_key_with_backup (ctrl_t ctrl, PKT_public_key *sub_psk,
    4034             :                             const char *backup_dir)
    4035             : {
    4036             :   PKT_public_key *sk;
    4037             :   gnupg_isotime_t timestamp;
    4038             :   gpg_error_t err;
    4039             :   char *hexgrip;
    4040             :   int rc;
    4041             :   struct agent_card_info_s info;
    4042           0 :   gcry_cipher_hd_t cipherhd = NULL;
    4043           0 :   char *cache_nonce = NULL;
    4044           0 :   void *kek = NULL;
    4045             :   size_t keklen;
    4046             : 
    4047           0 :   sk = copy_public_key (NULL, sub_psk);
    4048           0 :   if (!sk)
    4049           0 :     return gpg_error_from_syserror ();
    4050             : 
    4051           0 :   epoch2isotime (timestamp, (time_t)sk->timestamp);
    4052           0 :   err = hexkeygrip_from_pk (sk, &hexgrip);
    4053           0 :   if (err)
    4054           0 :     return err;
    4055             : 
    4056           0 :   memset(&info, 0, sizeof (info));
    4057           0 :   rc = agent_scd_getattr ("SERIALNO", &info);
    4058           0 :   if (rc)
    4059           0 :     return (gpg_error_t)rc;
    4060             : 
    4061           0 :   rc = agent_keytocard (hexgrip, 2, 1, info.serialno, timestamp);
    4062           0 :   xfree (info.serialno);
    4063           0 :   if (rc)
    4064             :     {
    4065           0 :       err = (gpg_error_t)rc;
    4066           0 :       goto leave;
    4067             :     }
    4068             : 
    4069           0 :   err = agent_keywrap_key (ctrl, 1, &kek, &keklen);
    4070           0 :   if (err)
    4071             :     {
    4072           0 :       log_error ("error getting the KEK: %s\n", gpg_strerror (err));
    4073           0 :       goto leave;
    4074             :     }
    4075             : 
    4076           0 :   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
    4077             :                           GCRY_CIPHER_MODE_AESWRAP, 0);
    4078           0 :   if (!err)
    4079           0 :     err = gcry_cipher_setkey (cipherhd, kek, keklen);
    4080           0 :   if (err)
    4081             :     {
    4082           0 :       log_error ("error setting up an encryption context: %s\n",
    4083             :                  gpg_strerror (err));
    4084           0 :       goto leave;
    4085             :     }
    4086             : 
    4087           0 :   err = receive_seckey_from_agent (ctrl, cipherhd, 0,
    4088             :                                    &cache_nonce, hexgrip, sk);
    4089           0 :   if (err)
    4090             :     {
    4091           0 :       log_error ("error getting secret key from agent: %s\n",
    4092             :                  gpg_strerror (err));
    4093           0 :       goto leave;
    4094             :     }
    4095             : 
    4096           0 :   err = card_write_key_to_backup_file (sk, backup_dir);
    4097           0 :   if (err)
    4098           0 :     log_error ("writing card key to backup file: %s\n", gpg_strerror (err));
    4099             :   else
    4100             :     /* Remove secret key data in agent side.  */
    4101           0 :     agent_scd_learn (NULL, 1);
    4102             : 
    4103             :  leave:
    4104           0 :   xfree (cache_nonce);
    4105           0 :   gcry_cipher_close (cipherhd);
    4106           0 :   xfree (kek);
    4107           0 :   xfree (hexgrip);
    4108           0 :   free_public_key (sk);
    4109           0 :   return err;
    4110             : }
    4111             : 
    4112             : 
    4113             : static void
    4114           2 : do_generate_keypair (ctrl_t ctrl, struct para_data_s *para,
    4115             :                      struct output_control_s *outctrl, int card)
    4116             : {
    4117             :   gpg_error_t err;
    4118           2 :   KBNODE pub_root = NULL;
    4119             :   const char *s;
    4120           2 :   PKT_public_key *pri_psk = NULL;
    4121           2 :   PKT_public_key *sub_psk = NULL;
    4122             :   struct revocation_key *revkey;
    4123           2 :   int did_sub = 0;
    4124             :   u32 timestamp;
    4125           2 :   char *cache_nonce = NULL;
    4126             : 
    4127           2 :   if (outctrl->dryrun)
    4128             :     {
    4129           0 :       log_info("dry-run mode - key generation skipped\n");
    4130           0 :       return;
    4131             :     }
    4132             : 
    4133           2 :   if ( outctrl->use_files )
    4134             :     {
    4135           0 :       if ( outctrl->pub.newfname )
    4136             :         {
    4137           0 :           iobuf_close(outctrl->pub.stream);
    4138           0 :           outctrl->pub.stream = NULL;
    4139           0 :           if (outctrl->pub.fname)
    4140           0 :             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE,
    4141           0 :                          0, (char*)outctrl->pub.fname);
    4142           0 :           xfree( outctrl->pub.fname );
    4143           0 :           outctrl->pub.fname =  outctrl->pub.newfname;
    4144           0 :           outctrl->pub.newfname = NULL;
    4145             : 
    4146           0 :           if (is_secured_filename (outctrl->pub.fname) )
    4147             :             {
    4148           0 :               outctrl->pub.stream = NULL;
    4149           0 :               gpg_err_set_errno (EPERM);
    4150             :             }
    4151             :           else
    4152           0 :             outctrl->pub.stream = iobuf_create (outctrl->pub.fname, 0);
    4153           0 :           if (!outctrl->pub.stream)
    4154             :             {
    4155           0 :               log_error(_("can't create '%s': %s\n"), outctrl->pub.newfname,
    4156           0 :                         strerror(errno) );
    4157           0 :               return;
    4158             :             }
    4159           0 :           if (opt.armor)
    4160             :             {
    4161           0 :               outctrl->pub.afx->what = 1;
    4162           0 :               push_armor_filter (outctrl->pub.afx, outctrl->pub.stream);
    4163             :             }
    4164             :         }
    4165           0 :       log_assert( outctrl->pub.stream );
    4166           0 :       if (opt.verbose)
    4167           0 :         log_info (_("writing public key to '%s'\n"), outctrl->pub.fname );
    4168             :     }
    4169             : 
    4170             : 
    4171             :   /* We create the packets as a tree of kbnodes.  Because the
    4172             :      structure we create is known in advance we simply generate a
    4173             :      linked list.  The first packet is a dummy packet which we flag as
    4174             :      deleted.  The very first packet must always be a KEY packet.  */
    4175             : 
    4176           2 :   start_tree (&pub_root);
    4177             : 
    4178           2 :   timestamp = get_parameter_u32 (para, pKEYCREATIONDATE);
    4179           2 :   if (!timestamp)
    4180           2 :     timestamp = make_timestamp ();
    4181             : 
    4182             :   /* Note that, depending on the backend (i.e. the used scdaemon
    4183             :      version), the card key generation may update TIMESTAMP for each
    4184             :      key.  Thus we need to pass TIMESTAMP to all signing function to
    4185             :      make sure that the binding signature is done using the timestamp
    4186             :      of the corresponding (sub)key and not that of the primary key.
    4187             :      An alternative implementation could tell the signing function the
    4188             :      node of the subkey but that is more work than just to pass the
    4189             :      current timestamp.  */
    4190             : 
    4191           2 :   if (!card)
    4192           4 :     err = do_create (get_parameter_algo( para, pKEYTYPE, NULL ),
    4193             :                      get_parameter_uint( para, pKEYLENGTH ),
    4194             :                      get_parameter_value (para, pKEYCURVE),
    4195             :                      pub_root,
    4196             :                      timestamp,
    4197             :                      get_parameter_u32( para, pKEYEXPIRE ), 0,
    4198           2 :                      outctrl->keygen_flags,
    4199             :                      get_parameter_passphrase (para),
    4200             :                      &cache_nonce, NULL);
    4201             :   else
    4202           0 :     err = gen_card_key (PUBKEY_ALGO_RSA, 1, 1, pub_root,
    4203             :                         &timestamp,
    4204             :                         get_parameter_u32 (para, pKEYEXPIRE));
    4205             : 
    4206             :   /* Get the pointer to the generated public key packet.  */
    4207           2 :   if (!err)
    4208             :     {
    4209           2 :       pri_psk = pub_root->next->pkt->pkt.public_key;
    4210           2 :       log_assert (pri_psk);
    4211             : 
    4212             :       /* Make sure a few fields are correctly set up before going
    4213             :          further.  */
    4214           2 :       pri_psk->flags.primary = 1;
    4215           2 :       keyid_from_pk (pri_psk, NULL);
    4216             :       /* We don't use pk_keyid to get keyid, because it also asserts
    4217             :          that main_keyid is set!  */
    4218           2 :       keyid_copy (pri_psk->main_keyid, pri_psk->keyid);
    4219             :     }
    4220             : 
    4221           2 :   if (!err && (revkey = get_parameter_revkey (para, pREVOKER)))
    4222           0 :     err = write_direct_sig (pub_root, pri_psk, revkey, timestamp, cache_nonce);
    4223             : 
    4224           2 :   if (!err && (s = get_parameter_value (para, pUSERID)))
    4225             :     {
    4226           2 :       write_uid (pub_root, s );
    4227           2 :       err = write_selfsigs (pub_root, pri_psk,
    4228             :                             get_parameter_uint (para, pKEYUSAGE), timestamp,
    4229             :                             cache_nonce);
    4230             :     }
    4231             : 
    4232             :   /* Write the auth key to the card before the encryption key.  This
    4233             :      is a partial workaround for a PGP bug (as of this writing, all
    4234             :      versions including 8.1), that causes it to try and encrypt to
    4235             :      the most recent subkey regardless of whether that subkey is
    4236             :      actually an encryption type.  In this case, the auth key is an
    4237             :      RSA key so it succeeds. */
    4238             : 
    4239           2 :   if (!err && card && get_parameter (para, pAUTHKEYTYPE))
    4240             :     {
    4241           0 :       err = gen_card_key (PUBKEY_ALGO_RSA, 3, 0, pub_root,
    4242             :                           &timestamp,
    4243             :                           get_parameter_u32 (para, pKEYEXPIRE));
    4244           0 :       if (!err)
    4245           0 :         err = write_keybinding (pub_root, pri_psk, NULL,
    4246             :                                 PUBKEY_USAGE_AUTH, timestamp, cache_nonce);
    4247             :     }
    4248             : 
    4249           2 :   if (!err && get_parameter (para, pSUBKEYTYPE))
    4250             :     {
    4251           1 :       sub_psk = NULL;
    4252           1 :       s = NULL;
    4253           1 :       if (!card || (s = get_parameter_value (para, pCARDBACKUPKEY)))
    4254             :         {
    4255           2 :           err = do_create (get_parameter_algo (para, pSUBKEYTYPE, NULL),
    4256             :                            get_parameter_uint (para, pSUBKEYLENGTH),
    4257             :                            get_parameter_value (para, pSUBKEYCURVE),
    4258             :                            pub_root,
    4259             :                            timestamp,
    4260             :                            get_parameter_u32 (para, pSUBKEYEXPIRE), 1,
    4261           1 :                            s ? KEYGEN_FLAG_NO_PROTECTION : outctrl->keygen_flags,
    4262             :                            get_parameter_passphrase (para),
    4263             :                            &cache_nonce, NULL);
    4264             :           /* Get the pointer to the generated public subkey packet.  */
    4265           2 :           if (!err)
    4266             :             {
    4267             :               kbnode_t node;
    4268             : 
    4269           6 :               for (node = pub_root; node; node = node->next)
    4270           5 :                 if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
    4271           1 :                   sub_psk = node->pkt->pkt.public_key;
    4272           1 :               log_assert (sub_psk);
    4273             : 
    4274           1 :               if (s)
    4275           0 :                 err = card_store_key_with_backup (ctrl,
    4276             :                                                   sub_psk, gnupg_homedir ());
    4277             :             }
    4278             :         }
    4279             :       else
    4280             :         {
    4281           0 :           err = gen_card_key (PUBKEY_ALGO_RSA, 2, 0, pub_root, &timestamp,
    4282             :                               get_parameter_u32 (para, pKEYEXPIRE));
    4283             :         }
    4284             : 
    4285           1 :       if (!err)
    4286           1 :         err = write_keybinding (pub_root, pri_psk, sub_psk,
    4287             :                                 get_parameter_uint (para, pSUBKEYUSAGE),
    4288             :                                 timestamp, cache_nonce);
    4289           1 :       did_sub = 1;
    4290             :     }
    4291             : 
    4292           2 :   if (!err && outctrl->use_files)  /* Direct write to specified files.  */
    4293             :     {
    4294           0 :       err = write_keyblock (outctrl->pub.stream, pub_root);
    4295           0 :       if (err)
    4296           0 :         log_error ("can't write public key: %s\n", gpg_strerror (err));
    4297             :     }
    4298           2 :   else if (!err) /* Write to the standard keyrings.  */
    4299             :     {
    4300             :       KEYDB_HANDLE pub_hd;
    4301             : 
    4302           2 :       pub_hd = keydb_new ();
    4303           2 :       if (!pub_hd)
    4304           0 :         err = gpg_error_from_syserror ();
    4305             :       else
    4306             :         {
    4307           2 :           err = keydb_locate_writable (pub_hd);
    4308           2 :           if (err)
    4309           0 :             log_error (_("no writable public keyring found: %s\n"),
    4310             :                        gpg_strerror (err));
    4311             :         }
    4312             : 
    4313           2 :       if (!err && opt.verbose)
    4314             :         {
    4315           0 :           log_info (_("writing public key to '%s'\n"),
    4316             :                     keydb_get_resource_name (pub_hd));
    4317             :         }
    4318             : 
    4319           2 :       if (!err)
    4320             :         {
    4321           2 :           err = keydb_insert_keyblock (pub_hd, pub_root);
    4322           2 :           if (err)
    4323           0 :             log_error (_("error writing public keyring '%s': %s\n"),
    4324             :                        keydb_get_resource_name (pub_hd), gpg_strerror (err));
    4325             :         }
    4326             : 
    4327           2 :       keydb_release (pub_hd);
    4328             : 
    4329           2 :       if (!err)
    4330             :         {
    4331             :           int no_enc_rsa;
    4332             :           PKT_public_key *pk;
    4333             : 
    4334           4 :           no_enc_rsa = ((get_parameter_algo (para, pKEYTYPE, NULL)
    4335             :                          == PUBKEY_ALGO_RSA)
    4336           1 :                         && get_parameter_uint (para, pKEYUSAGE)
    4337           4 :                         && !((get_parameter_uint (para, pKEYUSAGE)
    4338           1 :                               & PUBKEY_USAGE_ENC)) );
    4339             : 
    4340           2 :           pk = find_kbnode (pub_root, PKT_PUBLIC_KEY)->pkt->pkt.public_key;
    4341             : 
    4342           2 :           keyid_from_pk (pk, pk->main_keyid);
    4343           2 :           register_trusted_keyid (pk->main_keyid);
    4344             : 
    4345           2 :           update_ownertrust (pk, ((get_ownertrust (pk) & ~TRUST_MASK)
    4346             :                                   | TRUST_ULTIMATE ));
    4347             : 
    4348           2 :           gen_standard_revoke (pk, cache_nonce);
    4349             : 
    4350             :           /* Get rid of the first empty packet.  */
    4351           2 :           commit_kbnode (&pub_root);
    4352             : 
    4353           2 :           if (!opt.batch)
    4354             :             {
    4355           0 :               tty_printf (_("public and secret key created and signed.\n") );
    4356           0 :               tty_printf ("\n");
    4357           0 :               merge_keys_and_selfsig (pub_root);
    4358           0 :               list_keyblock_direct (ctrl, pub_root, 0, 1, 1, 1);
    4359             :             }
    4360             : 
    4361             : 
    4362           2 :           if (!opt.batch
    4363           0 :               && (get_parameter_algo (para, pKEYTYPE, NULL) == PUBKEY_ALGO_DSA
    4364           0 :                   || no_enc_rsa )
    4365           0 :               && !get_parameter (para, pSUBKEYTYPE) )
    4366             :             {
    4367           0 :               tty_printf(_("Note that this key cannot be used for "
    4368             :                            "encryption.  You may want to use\n"
    4369             :                            "the command \"--edit-key\" to generate a "
    4370             :                            "subkey for this purpose.\n") );
    4371             :             }
    4372             :         }
    4373             :     }
    4374             : 
    4375           2 :   if (err)
    4376             :     {
    4377           0 :       if (opt.batch)
    4378           0 :         log_error ("key generation failed: %s\n", gpg_strerror (err) );
    4379             :       else
    4380           0 :         tty_printf (_("Key generation failed: %s\n"), gpg_strerror (err) );
    4381           0 :       write_status_error (card? "card_key_generate":"key_generate", err);
    4382           0 :       print_status_key_not_created ( get_parameter_value (para, pHANDLE) );
    4383             :     }
    4384             :   else
    4385             :     {
    4386           4 :       PKT_public_key *pk = find_kbnode (pub_root,
    4387           2 :                                         PKT_PUBLIC_KEY)->pkt->pkt.public_key;
    4388           2 :       print_status_key_created (did_sub? 'B':'P', pk,
    4389             :                                 get_parameter_value (para, pHANDLE));
    4390             :     }
    4391             : 
    4392           2 :   release_kbnode (pub_root);
    4393           2 :   xfree (cache_nonce);
    4394             : }
    4395             : 
    4396             : 
    4397             : static gpg_error_t
    4398           0 : parse_algo_usage_expire (ctrl_t ctrl, int for_subkey,
    4399             :                          const char *algostr, const char *usagestr,
    4400             :                          const char *expirestr,
    4401             :                          int *r_algo, unsigned int *r_usage, u32 *r_expire,
    4402             :                          unsigned int *r_nbits, char **r_curve)
    4403             : {
    4404             :   int algo;
    4405             :   unsigned int use, nbits;
    4406             :   u32 expire;
    4407             :   int wantuse;
    4408             :   unsigned int min, def, max;
    4409           0 :   const char *curve = NULL;
    4410           0 :   int eccalgo = 0;
    4411             : 
    4412           0 :   *r_curve = NULL;
    4413             : 
    4414           0 :   nbits = 0;
    4415             :   /* Parse the algo string.  */
    4416           0 :   if (!algostr || !*algostr
    4417           0 :       || !strcmp (algostr, "default") || !strcmp (algostr, "-"))
    4418             :     {
    4419           0 :       algo = for_subkey? DEFAULT_STD_SUBALGO : DEFAULT_STD_ALGO;
    4420           0 :       use = for_subkey?  DEFAULT_STD_SUBKEYUSE : DEFAULT_STD_KEYUSE;
    4421           0 :       nbits = for_subkey?DEFAULT_STD_SUBKEYSIZE : DEFAULT_STD_KEYSIZE;
    4422             :     }
    4423           0 :   else if (*algostr == '&' && strlen (algostr) == 41)
    4424             :     {
    4425             :       /* Take algo from existing key.  */
    4426           0 :       algo = check_keygrip (ctrl, algostr+1);
    4427             :       /* FIXME: We need the curve name as well.  */
    4428           0 :       return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
    4429             :     }
    4430           0 :   else if (!strncmp (algostr, "rsa", 3))
    4431             :     {
    4432           0 :       algo = PUBKEY_ALGO_RSA;
    4433           0 :       use = for_subkey? DEFAULT_STD_SUBKEYUSE : DEFAULT_STD_KEYUSE;
    4434           0 :       if (algostr[3])
    4435           0 :         nbits = atoi (algostr + 3);
    4436             :     }
    4437           0 :   else if (!strncmp (algostr, "elg", 3))
    4438             :     {
    4439           0 :       algo = PUBKEY_ALGO_ELGAMAL_E;
    4440           0 :       use = PUBKEY_USAGE_ENC;
    4441           0 :       if (algostr[3])
    4442           0 :         nbits = atoi (algostr + 3);
    4443             :     }
    4444           0 :   else if (!strncmp (algostr, "dsa", 3))
    4445             :     {
    4446           0 :       algo = PUBKEY_ALGO_DSA;
    4447           0 :       use = PUBKEY_USAGE_SIG;
    4448           0 :       if (algostr[3])
    4449           0 :         nbits = atoi (algostr + 3);
    4450             :     }
    4451           0 :   else if ((curve = openpgp_is_curve_supported (algostr, &algo)))
    4452             :     {
    4453           0 :       if (!algo)
    4454             :         {
    4455           0 :           algo = PUBKEY_ALGO_ECDH; /* Default ECC algorithm.  */
    4456           0 :           eccalgo = 1;  /* Remember - we may need to fix it up.  */
    4457             :         }
    4458             : 
    4459           0 :       if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_EDDSA)
    4460           0 :         use = PUBKEY_USAGE_SIG;
    4461             :       else
    4462           0 :         use = PUBKEY_USAGE_ENC;
    4463             :     }
    4464             :   else
    4465           0 :     return gpg_error (GPG_ERR_INV_CURVE);
    4466             : 
    4467             :   /* Parse the usage string.  */
    4468           0 :   if (!usagestr || !*usagestr
    4469           0 :       || !strcmp (usagestr, "default") || !strcmp (usagestr, "-"))
    4470             :     ; /* Keep default usage */
    4471           0 :   else if ((wantuse = parse_usagestr (usagestr)) != -1)
    4472             :     {
    4473           0 :       use = wantuse;
    4474           0 :       if (eccalgo && !(use & PUBKEY_USAGE_ENC))
    4475           0 :         algo = PUBKEY_ALGO_ECDSA; /* Switch from ECDH to ECDSA.  */
    4476             :     }
    4477             :   else
    4478           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    4479             : 
    4480             :   /* Make sure a primary key has the CERT usage.  */
    4481           0 :   if (!for_subkey)
    4482           0 :     use |= PUBKEY_USAGE_CERT;
    4483             : 
    4484             :   /* Check that usage is possible.  */
    4485           0 :   if (/**/((use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH|PUBKEY_USAGE_CERT))
    4486           0 :            && !pubkey_get_nsig (algo))
    4487           0 :        || ((use & PUBKEY_USAGE_ENC)
    4488           0 :            && !pubkey_get_nenc (algo))
    4489           0 :        || (for_subkey && (use & PUBKEY_USAGE_CERT)))
    4490           0 :     return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
    4491             : 
    4492             :   /* Parse the expire string.  */
    4493           0 :   if (!expirestr || !*expirestr || !strcmp (expirestr, "none")
    4494           0 :       || !strcmp (expirestr, "never") || !strcmp (expirestr, "-"))
    4495           0 :     expire = 0;
    4496             :   else
    4497           0 :     expire = parse_expire_string (expirestr);
    4498           0 :   if (expire == (u32)-1 )
    4499           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    4500             : 
    4501             :   /* Make sure the keysize is in the allowed range.  */
    4502           0 :   get_keysize_range (algo, &min, &def, &max);
    4503           0 :   if (!nbits)
    4504           0 :     nbits = def;
    4505           0 :   else if (nbits < min)
    4506           0 :     nbits = min;
    4507           0 :   else if (nbits > max)
    4508           0 :     nbits = max;
    4509             : 
    4510           0 :   nbits = fixup_keysize (nbits, algo, 1);
    4511             : 
    4512           0 :   if (curve)
    4513             :     {
    4514           0 :       *r_curve = xtrystrdup (curve);
    4515           0 :       if (!*r_curve)
    4516           0 :         return gpg_error_from_syserror ();
    4517             :     }
    4518           0 :   *r_algo = algo;
    4519           0 :   *r_usage = use;
    4520           0 :   *r_expire = expire;
    4521           0 :   *r_nbits = nbits;
    4522           0 :   return 0;
    4523             : }
    4524             : 
    4525             : 
    4526             : /* Add a new subkey to an existing key.  Returns 0 if a new key has
    4527             :    been generated and put into the keyblocks.  If any of ALGOSTR,
    4528             :    USAGESTR, or EXPIRESTR is NULL interactive mode is used. */
    4529             : gpg_error_t
    4530           0 : generate_subkeypair (ctrl_t ctrl, kbnode_t keyblock, const char *algostr,
    4531             :                      const char *usagestr, const char *expirestr)
    4532             : {
    4533           0 :   gpg_error_t err = 0;
    4534             :   int interactive;
    4535             :   kbnode_t node;
    4536           0 :   PKT_public_key *pri_psk = NULL;
    4537           0 :   PKT_public_key *sub_psk = NULL;
    4538             :   int algo;
    4539             :   unsigned int use;
    4540             :   u32 expire;
    4541           0 :   unsigned int nbits = 0;
    4542           0 :   char *curve = NULL;
    4543             :   u32 cur_time;
    4544           0 :   char *key_from_hexgrip = NULL;
    4545           0 :   char *hexgrip = NULL;
    4546           0 :   char *serialno = NULL;
    4547           0 :   char *cache_nonce = NULL;
    4548           0 :   char *passwd_nonce = NULL;
    4549             : 
    4550           0 :   interactive = (!algostr || !usagestr || !expirestr);
    4551             : 
    4552             :   /* Break out the primary key.  */
    4553           0 :   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
    4554           0 :   if (!node)
    4555             :     {
    4556           0 :       log_error ("Oops; primary key missing in keyblock!\n");
    4557           0 :       err = gpg_error (GPG_ERR_BUG);
    4558           0 :       goto leave;
    4559             :     }
    4560           0 :   pri_psk = node->pkt->pkt.public_key;
    4561             : 
    4562           0 :   cur_time = make_timestamp ();
    4563             : 
    4564           0 :   if (pri_psk->timestamp > cur_time)
    4565             :     {
    4566           0 :       ulong d = pri_psk->timestamp - cur_time;
    4567           0 :       log_info ( d==1 ? _("key has been created %lu second "
    4568             :                           "in future (time warp or clock problem)\n")
    4569             :                  : _("key has been created %lu seconds "
    4570             :                      "in future (time warp or clock problem)\n"), d );
    4571           0 :       if (!opt.ignore_time_conflict)
    4572             :         {
    4573           0 :           err = gpg_error (GPG_ERR_TIME_CONFLICT);
    4574           0 :           goto leave;
    4575             :         }
    4576             :     }
    4577             : 
    4578           0 :   if (pri_psk->version < 4)
    4579             :     {
    4580           0 :       log_info (_("Note: creating subkeys for v3 keys "
    4581             :                   "is not OpenPGP compliant\n"));
    4582           0 :       err = gpg_error (GPG_ERR_CONFLICT);
    4583           0 :       goto leave;
    4584             :     }
    4585             : 
    4586           0 :   err = hexkeygrip_from_pk (pri_psk, &hexgrip);
    4587           0 :   if (err)
    4588           0 :     goto leave;
    4589           0 :   if (agent_get_keyinfo (NULL, hexgrip, &serialno, NULL))
    4590             :     {
    4591           0 :       if (interactive)
    4592           0 :         tty_printf (_("Secret parts of primary key are not available.\n"));
    4593             :       else
    4594           0 :         log_info (  _("Secret parts of primary key are not available.\n"));
    4595           0 :       err = gpg_error (GPG_ERR_NO_SECKEY);
    4596           0 :       goto leave;
    4597             :     }
    4598           0 :   if (serialno)
    4599             :     {
    4600           0 :       if (interactive)
    4601           0 :         tty_printf (_("Secret parts of primary key are stored on-card.\n"));
    4602             :       else
    4603           0 :         log_info (  _("Secret parts of primary key are stored on-card.\n"));
    4604             :     }
    4605             : 
    4606           0 :   if (interactive)
    4607             :     {
    4608           0 :       algo = ask_algo (ctrl, 1, NULL, &use, &key_from_hexgrip);
    4609           0 :       log_assert (algo);
    4610             : 
    4611           0 :       if (key_from_hexgrip)
    4612           0 :         nbits = 0;
    4613           0 :       else if (algo == PUBKEY_ALGO_ECDSA
    4614           0 :                || algo == PUBKEY_ALGO_EDDSA
    4615           0 :                || algo == PUBKEY_ALGO_ECDH)
    4616           0 :         curve = ask_curve (&algo, NULL);
    4617             :       else
    4618           0 :         nbits = ask_keysize (algo, 0);
    4619             : 
    4620           0 :       expire = ask_expire_interval (0, NULL);
    4621           0 :       if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.sub.okay",
    4622           0 :                                                    _("Really create? (y/N) ")))
    4623             :         {
    4624           0 :           err = gpg_error (GPG_ERR_CANCELED);
    4625           0 :           goto leave;
    4626             :         }
    4627             :     }
    4628             :   else /* Unattended mode.  */
    4629             :     {
    4630           0 :       err = parse_algo_usage_expire (ctrl, 1, algostr, usagestr, expirestr,
    4631             :                                      &algo, &use, &expire, &nbits, &curve);
    4632           0 :       if (err)
    4633           0 :         goto leave;
    4634             :     }
    4635             : 
    4636             :   /* Verify the passphrase now so that we get a cache item for the
    4637             :    * primary key passphrase.  The agent also returns a passphrase
    4638             :    * nonce, which we can use to set the passphrase for the subkey to
    4639             :    * that of the primary key.  */
    4640             :   {
    4641           0 :     char *desc = gpg_format_keydesc (pri_psk, FORMAT_KEYDESC_NORMAL, 1);
    4642           0 :     err = agent_passwd (ctrl, hexgrip, desc, 1 /*=verify*/,
    4643             :                         &cache_nonce, &passwd_nonce);
    4644           0 :     xfree (desc);
    4645             :   }
    4646             : 
    4647             :   /* Start creation.  */
    4648           0 :   if (key_from_hexgrip)
    4649             :     {
    4650           0 :       err = do_create_from_keygrip (ctrl, algo, key_from_hexgrip,
    4651             :                                     keyblock, cur_time, expire, 1);
    4652             :     }
    4653             :   else
    4654             :     {
    4655             :       const char *passwd;
    4656             : 
    4657             :       /* If the pinentry loopback mode is not and we have a static
    4658             :          passphrase (i.e. set with --passphrase{,-fd,-file} while in batch
    4659             :          mode), we use that passphrase for the new subkey.  */
    4660           0 :       if (opt.pinentry_mode != PINENTRY_MODE_LOOPBACK
    4661           0 :           && have_static_passphrase ())
    4662           0 :         passwd = get_static_passphrase ();
    4663             :       else
    4664           0 :         passwd = NULL;
    4665             : 
    4666           0 :       err = do_create (algo, nbits, curve,
    4667             :                        keyblock, cur_time, expire, 1, 0,
    4668             :                        passwd, &cache_nonce, &passwd_nonce);
    4669             :     }
    4670           0 :   if (err)
    4671           0 :     goto leave;
    4672             : 
    4673             :   /* Get the pointer to the generated public subkey packet.  */
    4674           0 :   for (node = keyblock; node; node = node->next)
    4675           0 :     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
    4676           0 :       sub_psk = node->pkt->pkt.public_key;
    4677             : 
    4678             :   /* Write the binding signature.  */
    4679           0 :   err = write_keybinding (keyblock, pri_psk, sub_psk, use, cur_time,
    4680             :                           cache_nonce);
    4681           0 :   if (err)
    4682           0 :     goto leave;
    4683             : 
    4684           0 :   print_status_key_created ('S', sub_psk, NULL);
    4685             : 
    4686             : 
    4687             :  leave:
    4688           0 :   xfree (key_from_hexgrip);
    4689           0 :   xfree (curve);
    4690           0 :   xfree (hexgrip);
    4691           0 :   xfree (serialno);
    4692           0 :   xfree (cache_nonce);
    4693           0 :   xfree (passwd_nonce);
    4694           0 :   if (err)
    4695           0 :     log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
    4696           0 :   return err;
    4697             : }
    4698             : 
    4699             : 
    4700             : #ifdef ENABLE_CARD_SUPPORT
    4701             : /* Generate a subkey on a card. */
    4702             : gpg_error_t
    4703           0 : generate_card_subkeypair (kbnode_t pub_keyblock,
    4704             :                           int keyno, const char *serialno)
    4705             : {
    4706           0 :   gpg_error_t err = 0;
    4707             :   kbnode_t node;
    4708           0 :   PKT_public_key *pri_pk = NULL;
    4709             :   int algo;
    4710             :   unsigned int use;
    4711             :   u32 expire;
    4712             :   u32 cur_time;
    4713           0 :   struct para_data_s *para = NULL;
    4714           0 :   PKT_public_key *sub_pk = NULL;
    4715             : 
    4716           0 :   log_assert (keyno >= 1 && keyno <= 3);
    4717             : 
    4718           0 :   para = xtrycalloc (1, sizeof *para + strlen (serialno) );
    4719           0 :   if (!para)
    4720             :     {
    4721           0 :       err = gpg_error_from_syserror ();
    4722           0 :       goto leave;
    4723             :     }
    4724           0 :   para->key = pSERIALNO;
    4725           0 :   strcpy (para->u.value, serialno);
    4726             : 
    4727             :   /* Break out the primary secret key */
    4728           0 :   node = find_kbnode (pub_keyblock, PKT_PUBLIC_KEY);
    4729           0 :   if (!node)
    4730             :     {
    4731           0 :       log_error ("Oops; publkic key lost!\n");
    4732           0 :       err = gpg_error (GPG_ERR_INTERNAL);
    4733           0 :       goto leave;
    4734             :     }
    4735           0 :   pri_pk = node->pkt->pkt.public_key;
    4736             : 
    4737           0 :   cur_time = make_timestamp();
    4738           0 :   if (pri_pk->timestamp > cur_time)
    4739             :     {
    4740           0 :       ulong d = pri_pk->timestamp - cur_time;
    4741           0 :       log_info (d==1 ? _("key has been created %lu second "
    4742             :                          "in future (time warp or clock problem)\n")
    4743             :                      : _("key has been created %lu seconds "
    4744             :                          "in future (time warp or clock problem)\n"), d );
    4745           0 :         if (!opt.ignore_time_conflict)
    4746             :           {
    4747           0 :             err = gpg_error (GPG_ERR_TIME_CONFLICT);
    4748           0 :             goto leave;
    4749             :           }
    4750             :     }
    4751             : 
    4752           0 :   if (pri_pk->version < 4)
    4753             :     {
    4754           0 :       log_info (_("Note: creating subkeys for v3 keys "
    4755             :                   "is not OpenPGP compliant\n"));
    4756           0 :       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
    4757           0 :       goto leave;
    4758             :     }
    4759             : 
    4760           0 :   algo = PUBKEY_ALGO_RSA;
    4761           0 :   expire = ask_expire_interval (0, NULL);
    4762           0 :   if (keyno == 1)
    4763           0 :     use = PUBKEY_USAGE_SIG;
    4764           0 :   else if (keyno == 2)
    4765           0 :     use = PUBKEY_USAGE_ENC;
    4766             :   else
    4767           0 :     use = PUBKEY_USAGE_AUTH;
    4768           0 :   if (!cpr_enabled() && !cpr_get_answer_is_yes("keygen.cardsub.okay",
    4769           0 :                                                _("Really create? (y/N) ")))
    4770             :     {
    4771           0 :       err = gpg_error (GPG_ERR_CANCELED);
    4772           0 :       goto leave;
    4773             :     }
    4774             : 
    4775             :   /* Note, that depending on the backend, the card key generation may
    4776             :      update CUR_TIME.  */
    4777           0 :   err = gen_card_key (algo, keyno, 0, pub_keyblock, &cur_time, expire);
    4778             :   /* Get the pointer to the generated public subkey packet.  */
    4779           0 :   if (!err)
    4780             :     {
    4781           0 :       for (node = pub_keyblock; node; node = node->next)
    4782           0 :         if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
    4783           0 :           sub_pk = node->pkt->pkt.public_key;
    4784           0 :       log_assert (sub_pk);
    4785           0 :       err = write_keybinding (pub_keyblock, pri_pk, sub_pk,
    4786             :                               use, cur_time, NULL);
    4787             :     }
    4788             : 
    4789             :  leave:
    4790           0 :   if (err)
    4791           0 :     log_error (_("Key generation failed: %s\n"), gpg_strerror (err) );
    4792             :   else
    4793           0 :     print_status_key_created ('S', sub_pk, NULL);
    4794           0 :   release_parameter_list (para);
    4795           0 :   return err;
    4796             : }
    4797             : #endif /* !ENABLE_CARD_SUPPORT */
    4798             : 
    4799             : /*
    4800             :  * Write a keyblock to an output stream
    4801             :  */
    4802             : static int
    4803           0 : write_keyblock( IOBUF out, KBNODE node )
    4804             : {
    4805           0 :   for( ; node ; node = node->next )
    4806             :     {
    4807           0 :       if(!is_deleted_kbnode(node))
    4808             :         {
    4809           0 :           int rc = build_packet( out, node->pkt );
    4810           0 :           if( rc )
    4811             :             {
    4812           0 :               log_error("build_packet(%d) failed: %s\n",
    4813           0 :                         node->pkt->pkttype, gpg_strerror (rc) );
    4814           0 :               return rc;
    4815             :             }
    4816             :         }
    4817             :     }
    4818             : 
    4819           0 :   return 0;
    4820             : }
    4821             : 
    4822             : 
    4823             : /* Note that timestamp is an in/out arg. */
    4824             : static gpg_error_t
    4825           0 : gen_card_key (int algo, int keyno, int is_primary, kbnode_t pub_root,
    4826             :               u32 *timestamp, u32 expireval)
    4827             : {
    4828             : #ifdef ENABLE_CARD_SUPPORT
    4829             :   gpg_error_t err;
    4830             :   struct agent_card_genkey_s info;
    4831             :   PACKET *pkt;
    4832             :   PKT_public_key *pk;
    4833             : 
    4834           0 :   if (algo != PUBKEY_ALGO_RSA)
    4835           0 :     return gpg_error (GPG_ERR_PUBKEY_ALGO);
    4836             : 
    4837           0 :   pk = xtrycalloc (1, sizeof *pk );
    4838           0 :   if (!pk)
    4839           0 :     return gpg_error_from_syserror ();
    4840           0 :   pkt = xtrycalloc (1, sizeof *pkt);
    4841           0 :   if (!pkt)
    4842             :     {
    4843           0 :       xfree (pk);
    4844           0 :       return gpg_error_from_syserror ();
    4845             :     }
    4846             : 
    4847             :   /* Note: SCD knows the serialnumber, thus there is no point in passing it.  */
    4848           0 :   err = agent_scd_genkey (&info, keyno, 1, NULL, *timestamp);
    4849             :   /*  The code below is not used because we force creation of
    4850             :    *  the a card key (3rd arg).
    4851             :    * if (gpg_err_code (rc) == GPG_ERR_EEXIST)
    4852             :    *   {
    4853             :    *     tty_printf ("\n");
    4854             :    *     log_error ("WARNING: key does already exists!\n");
    4855             :    *     tty_printf ("\n");
    4856             :    *     if ( cpr_get_answer_is_yes( "keygen.card.replace_key",
    4857             :    *                                 _("Replace existing key? ")))
    4858             :    *       rc = agent_scd_genkey (&info, keyno, 1);
    4859             :    *   }
    4860             :   */
    4861           0 :   if (!err && (!info.n || !info.e))
    4862             :     {
    4863           0 :       log_error ("communication error with SCD\n");
    4864           0 :       gcry_mpi_release (info.n);
    4865           0 :       gcry_mpi_release (info.e);
    4866           0 :       err =  gpg_error (GPG_ERR_GENERAL);
    4867             :     }
    4868           0 :   if (err)
    4869             :     {
    4870           0 :       log_error ("key generation failed: %s\n", gpg_strerror (err));
    4871           0 :       xfree (pkt);
    4872           0 :       xfree (pk);
    4873           0 :       return err;
    4874             :     }
    4875             : 
    4876             :   /* Send the learn command so that the agent creates a shadow key for
    4877             :      card key.  We need to do that now so that we are able to create
    4878             :      the self-signatures. */
    4879           0 :   err = agent_scd_learn (NULL, 0);
    4880           0 :   if (err)
    4881             :     {
    4882             :       /* Oops: Card removed during generation.  */
    4883           0 :       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
    4884           0 :       xfree (pkt);
    4885           0 :       xfree (pk);
    4886           0 :       return err;
    4887             :     }
    4888             : 
    4889           0 :   if (*timestamp != info.created_at)
    4890           0 :     log_info ("NOTE: the key does not use the suggested creation date\n");
    4891           0 :   *timestamp = info.created_at;
    4892             : 
    4893           0 :   pk->timestamp = info.created_at;
    4894           0 :   pk->version = 4;
    4895           0 :   if (expireval)
    4896           0 :     pk->expiredate = pk->timestamp + expireval;
    4897           0 :   pk->pubkey_algo = algo;
    4898           0 :   pk->pkey[0] = info.n;
    4899           0 :   pk->pkey[1] = info.e;
    4900             : 
    4901           0 :   pkt->pkttype = is_primary ? PKT_PUBLIC_KEY : PKT_PUBLIC_SUBKEY;
    4902           0 :   pkt->pkt.public_key = pk;
    4903           0 :   add_kbnode (pub_root, new_kbnode (pkt));
    4904             : 
    4905           0 :   return 0;
    4906             : #else
    4907             :   (void)algo;
    4908             :   (void)keyno;
    4909             :   (void)is_primary;
    4910             :   (void)pub_root;
    4911             :   (void)timestamp;
    4912             :   (void)expireval;
    4913             :   return gpg_error (GPG_ERR_NOT_SUPPORTED);
    4914             : #endif /*!ENABLE_CARD_SUPPORT*/
    4915             : }

Generated by: LCOV version 1.11