gpg: Use only OpenPGP public key algo ids and add the EdDSA algo id.
[gnupg.git] / g10 / misc.c
1 /* misc.c - miscellaneous functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2009, 2010 Free Software Foundation, Inc.
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 <unistd.h>
26 #include <errno.h>
27 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
28 #include <asm/sysinfo.h>
29 #include <asm/unistd.h>
30 #endif
31 #ifdef HAVE_SETRLIMIT
32 #include <time.h>
33 #include <sys/time.h>
34 #include <sys/resource.h>
35 #endif
36 #ifdef ENABLE_SELINUX_HACKS
37 #include <sys/stat.h>
38 #endif
39
40 #ifdef HAVE_W32_SYSTEM
41 #include <time.h>
42 #include <process.h>
43 #include <windows.h>
44 #include <shlobj.h>
45 #ifndef CSIDL_APPDATA
46 #define CSIDL_APPDATA 0x001a
47 #endif
48 #ifndef CSIDL_LOCAL_APPDATA
49 #define CSIDL_LOCAL_APPDATA 0x001c
50 #endif
51 #ifndef CSIDL_FLAG_CREATE
52 #define CSIDL_FLAG_CREATE 0x8000
53 #endif
54 #endif /*HAVE_W32_SYSTEM*/
55
56 #include "gpg.h"
57 #ifdef HAVE_W32_SYSTEM
58 # include "status.h"
59 #endif /*HAVE_W32_SYSTEM*/
60 #include "util.h"
61 #include "main.h"
62 #include "photoid.h"
63 #include "options.h"
64 #include "call-agent.h"
65 #include "i18n.h"
66
67 #include <assert.h>
68
69 static int
70 string_count_chr (const char *string, int c)
71 {
72   int count;
73
74   for (count=0; *string; string++ )
75     if ( *string == c )
76       count++;
77   return count;
78 }
79
80
81
82 #ifdef ENABLE_SELINUX_HACKS
83 /* A object and a global variable to keep track of files marked as
84    secured. */
85 struct secured_file_item
86 {
87   struct secured_file_item *next;
88   ino_t ino;
89   dev_t dev;
90 };
91 static struct secured_file_item *secured_files;
92 #endif /*ENABLE_SELINUX_HACKS*/
93
94
95
96
97 /* For the sake of SELinux we want to restrict access through gpg to
98    certain files we keep under our own control.  This function
99    registers such a file and is_secured_file may then be used to
100    check whether a file has ben registered as secured. */
101 void
102 register_secured_file (const char *fname)
103 {
104 #ifdef ENABLE_SELINUX_HACKS
105   struct stat buf;
106   struct secured_file_item *sf;
107
108   /* Note that we stop immediatley if something goes wrong here. */
109   if (stat (fname, &buf))
110     log_fatal (_("fstat of '%s' failed in %s: %s\n"), fname,
111                "register_secured_file", strerror (errno));
112 /*   log_debug ("registering '%s' i=%lu.%lu\n", fname, */
113 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
114   for (sf=secured_files; sf; sf = sf->next)
115     {
116       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
117         return; /* Already registered.  */
118     }
119
120   sf = xmalloc (sizeof *sf);
121   sf->ino = buf.st_ino;
122   sf->dev = buf.st_dev;
123   sf->next = secured_files;
124   secured_files = sf;
125 #else /*!ENABLE_SELINUX_HACKS*/
126   (void)fname;
127 #endif /*!ENABLE_SELINUX_HACKS*/
128 }
129
130 /* Remove a file registered as secure. */
131 void
132 unregister_secured_file (const char *fname)
133 {
134 #ifdef ENABLE_SELINUX_HACKS
135   struct stat buf;
136   struct secured_file_item *sf, *sfprev;
137
138   if (stat (fname, &buf))
139     {
140       log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
141                  "unregister_secured_file", strerror (errno));
142       return;
143     }
144 /*   log_debug ("unregistering '%s' i=%lu.%lu\n", fname,  */
145 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
146   for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
147     {
148       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
149         {
150           if (sfprev)
151             sfprev->next = sf->next;
152           else
153             secured_files = sf->next;
154           xfree (sf);
155           return;
156         }
157     }
158 #else /*!ENABLE_SELINUX_HACKS*/
159   (void)fname;
160 #endif /*!ENABLE_SELINUX_HACKS*/
161 }
162
163 /* Return true if FD is corresponds to a secured file.  Using -1 for
164    FS is allowed and will return false. */
165 int
166 is_secured_file (int fd)
167 {
168 #ifdef ENABLE_SELINUX_HACKS
169   struct stat buf;
170   struct secured_file_item *sf;
171
172   if (fd == -1)
173     return 0; /* No file descriptor so it can't be secured either.  */
174
175   /* Note that we print out a error here and claim that a file is
176      secure if something went wrong. */
177   if (fstat (fd, &buf))
178     {
179       log_error (_("fstat(%d) failed in %s: %s\n"), fd,
180                  "is_secured_file", strerror (errno));
181       return 1;
182     }
183 /*   log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
184 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
185   for (sf=secured_files; sf; sf = sf->next)
186     {
187       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
188         return 1; /* Yes.  */
189     }
190 #else /*!ENABLE_SELINUX_HACKS*/
191   (void)fd;
192 #endif /*!ENABLE_SELINUX_HACKS*/
193   return 0; /* No. */
194 }
195
196 /* Return true if FNAME is corresponds to a secured file.  Using NULL,
197    "" or "-" for FS is allowed and will return false. This function is
198    used before creating a file, thus it won't fail if the file does
199    not exist. */
200 int
201 is_secured_filename (const char *fname)
202 {
203 #ifdef ENABLE_SELINUX_HACKS
204   struct stat buf;
205   struct secured_file_item *sf;
206
207   if (iobuf_is_pipe_filename (fname) || !*fname)
208     return 0;
209
210   /* Note that we print out a error here and claim that a file is
211      secure if something went wrong. */
212   if (stat (fname, &buf))
213     {
214       if (errno == ENOENT || errno == EPERM || errno == EACCES)
215         return 0;
216       log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
217                  "is_secured_filename", strerror (errno));
218       return 1;
219     }
220 /*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
221 /*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
222   for (sf=secured_files; sf; sf = sf->next)
223     {
224       if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
225         return 1; /* Yes.  */
226     }
227 #else /*!ENABLE_SELINUX_HACKS*/
228   (void)fname;
229 #endif /*!ENABLE_SELINUX_HACKS*/
230   return 0; /* No. */
231 }
232
233
234
235 u16
236 checksum_u16( unsigned n )
237 {
238     u16 a;
239
240     a  = (n >> 8) & 0xff;
241     a += n & 0xff;
242     return a;
243 }
244
245
246 u16
247 checksum( byte *p, unsigned n )
248 {
249     u16 a;
250
251     for(a=0; n; n-- )
252         a += *p++;
253     return a;
254 }
255
256 u16
257 checksum_mpi (gcry_mpi_t a)
258 {
259   u16 csum;
260   byte *buffer;
261   size_t nbytes;
262
263   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
264     BUG ();
265   /* Fixme: For numbers not in secure memory we should use a stack
266    * based buffer and only allocate a larger one if mpi_print returns
267    * an error. */
268   buffer = (gcry_is_secure(a)?
269             gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
270   if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
271     BUG ();
272   csum = checksum (buffer, nbytes);
273   xfree (buffer);
274   return csum;
275 }
276
277 u32
278 buffer_to_u32( const byte *buffer )
279 {
280     unsigned long a;
281     a =  *buffer << 24;
282     a |= buffer[1] << 16;
283     a |= buffer[2] << 8;
284     a |= buffer[3];
285     return a;
286 }
287
288 void
289 print_pubkey_algo_note( int algo )
290 {
291   if(algo >= 100 && algo <= 110)
292     {
293       static int warn=0;
294       if(!warn)
295         {
296           warn=1;
297           log_info (_("WARNING: using experimental public key algorithm %s\n"),
298                     openpgp_cipher_algo_name (algo));
299         }
300     }
301   else if (algo == 20)
302     {
303       log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
304     }
305 }
306
307 void
308 print_cipher_algo_note( int algo )
309 {
310   if(algo >= 100 && algo <= 110)
311     {
312       static int warn=0;
313       if(!warn)
314         {
315           warn=1;
316           log_info (_("WARNING: using experimental cipher algorithm %s\n"),
317                     openpgp_cipher_algo_name (algo));
318         }
319     }
320 }
321
322 void
323 print_digest_algo_note( int algo )
324 {
325   if(algo >= 100 && algo <= 110)
326     {
327       static int warn=0;
328       if(!warn)
329         {
330           warn=1;
331           log_info (_("WARNING: using experimental digest algorithm %s\n"),
332                     gcry_md_algo_name (algo));
333         }
334     }
335   else if(algo==DIGEST_ALGO_MD5)
336     log_info (_("WARNING: digest algorithm %s is deprecated\n"),
337               gcry_md_algo_name (algo));
338 }
339
340
341 /* Map OpenPGP algo numbers to those used by Libgcrypt.  We need to do
342    this for algorithms we implemented in Libgcrypt after they become
343    part of OpenPGP.  */
344 int
345 map_cipher_openpgp_to_gcry (int algo)
346 {
347   switch (algo)
348     {
349     case CIPHER_ALGO_CAMELLIA128: return 310;
350     case CIPHER_ALGO_CAMELLIA192: return 311;
351     case CIPHER_ALGO_CAMELLIA256: return 312;
352     default: return algo;
353     }
354 }
355
356 /* The inverse fucntion of above.  */
357 static int
358 map_cipher_gcry_to_openpgp (int algo)
359 {
360   switch (algo)
361     {
362     case 310: return CIPHER_ALGO_CAMELLIA128;
363     case 311: return CIPHER_ALGO_CAMELLIA192;
364     case 312: return CIPHER_ALGO_CAMELLIA256;
365     default: return algo;
366     }
367 }
368
369 /* Map Gcrypt public key algorithm numbers to those used by OpenPGP.
370    FIXME: This mapping is used at only two places - we should get rid
371    of it.  */
372 int
373 map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
374 {
375   switch (algo)
376     {
377     case GCRY_PK_ECDSA:  return PUBKEY_ALGO_ECDSA;
378     case GCRY_PK_ECDH:   return PUBKEY_ALGO_ECDH;
379     default: return algo < 110 ? algo : 0;
380     }
381 }
382
383
384 /* Return the block length of an OpenPGP cipher algorithm.  */
385 int
386 openpgp_cipher_blocklen (int algo)
387 {
388   /* We use the numbers from OpenPGP to be sure that we get the right
389      block length.  This is so that the packet parsing code works even
390      for unknown algorithms (for which we assume 8 due to tradition).
391
392      NOTE: If you change the the returned blocklen above 16, check
393      the callers because they may use a fixed size buffer of that
394      size. */
395   switch (algo)
396     {
397     case 7: case 8: case 9: /* AES */
398     case 10: /* Twofish */
399     case 11: case 12: case 13: /* Camellia */
400       return 16;
401
402     default:
403       return 8;
404     }
405 }
406
407 /****************
408  * Wrapper around the libgcrypt function with additonal checks on
409  * the OpenPGP contraints for the algo ID.
410  */
411 int
412 openpgp_cipher_test_algo( int algo )
413 {
414   /* (5 and 6 are marked reserved by rfc4880.)  */
415   if ( algo < 0 || algo > 110 || algo == 5 || algo == 6 )
416     return gpg_error (GPG_ERR_CIPHER_ALGO);
417
418   return gcry_cipher_test_algo (map_cipher_openpgp_to_gcry (algo));
419 }
420
421 /* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
422    string representation of the algorithm name.  For unknown algorithm
423    IDs this function returns "?".  */
424 const char *
425 openpgp_cipher_algo_name (int algo)
426 {
427   return gnupg_cipher_algo_name (map_cipher_openpgp_to_gcry (algo));
428 }
429
430
431 /* Return 0 if ALGO is a supported OpenPGP public key algorithm.  */
432 int
433 openpgp_pk_test_algo (pubkey_algo_t algo)
434 {
435   return openpgp_pk_test_algo2 (algo, 0);
436 }
437
438
439 /* Return 0 if ALGO is a supported OpenPGP public key algorithm and
440    allows the usage USE.  */
441 int
442 openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
443 {
444   enum gcry_pk_algos ga = 0;
445   size_t use_buf = use;
446
447   switch (algo)
448     {
449     case PUBKEY_ALGO_RSA:       ga = GCRY_PK_RSA;   break;
450     case PUBKEY_ALGO_RSA_E:     ga = GCRY_PK_RSA_E; break;
451     case PUBKEY_ALGO_RSA_S:     ga = GCRY_PK_RSA_S; break;
452     case PUBKEY_ALGO_ELGAMAL_E: ga = GCRY_PK_ELG;   break;
453     case PUBKEY_ALGO_DSA:       ga = GCRY_PK_DSA;   break;
454
455     case PUBKEY_ALGO_ECDH:
456     case PUBKEY_ALGO_ECDSA:
457     case PUBKEY_ALGO_EDDSA:     ga = GCRY_PK_ECC;   break;
458
459     case PUBKEY_ALGO_ELGAMAL:
460       /* Dont't allow type 20 keys unless in rfc2440 mode.  */
461       if (RFC2440)
462         ga = GCRY_PK_ELG;
463       break;
464     }
465   if (!ga)
466     return gpg_error (GPG_ERR_PUBKEY_ALGO);
467
468   /* No check whether Libgcrypt has support for the algorithm.  */
469   return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
470 }
471
472
473 int
474 openpgp_pk_algo_usage ( int algo )
475 {
476     int use = 0;
477
478     /* They are hardwired in gpg 1.0. */
479     switch ( algo ) {
480       case PUBKEY_ALGO_RSA:
481           use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
482                  | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
483           break;
484       case PUBKEY_ALGO_RSA_E:
485       case PUBKEY_ALGO_ECDH:
486           use = PUBKEY_USAGE_ENC;
487           break;
488       case PUBKEY_ALGO_RSA_S:
489           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
490           break;
491       case PUBKEY_ALGO_ELGAMAL:
492           if (RFC2440)
493              use = PUBKEY_USAGE_ENC;
494           break;
495       case PUBKEY_ALGO_ELGAMAL_E:
496           use = PUBKEY_USAGE_ENC;
497           break;
498       case PUBKEY_ALGO_DSA:
499           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
500           break;
501       case PUBKEY_ALGO_ECDSA:
502       case PUBKEY_ALGO_EDDSA:
503           use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
504       default:
505           break;
506     }
507     return use;
508 }
509
510 /* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
511    string representation of the algorithm name.  For unknown algorithm
512    IDs this function returns "?".  */
513 const char *
514 openpgp_pk_algo_name (pubkey_algo_t algo)
515 {
516   switch (algo)
517     {
518     case PUBKEY_ALGO_RSA:
519     case PUBKEY_ALGO_RSA_E:
520     case PUBKEY_ALGO_RSA_S:     return "RSA";
521     case PUBKEY_ALGO_ELGAMAL:
522     case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
523     case PUBKEY_ALGO_DSA:       return "DSA";
524     case PUBKEY_ALGO_ECDH:
525     case PUBKEY_ALGO_ECDSA:
526     case PUBKEY_ALGO_EDDSA:     return "ECC";
527     }
528   return "?";
529 }
530
531
532 int
533 openpgp_md_test_algo( int algo )
534 {
535   /* Note: If the list of actual supported OpenPGP algorithms changes,
536      make sure that our hard coded values at
537      print_status_begin_signing() gets updated. */
538   /* 4, 5, 6, 7 are defined by rfc2440 but will be removed from the
539      next revision of the standard.  */
540   if (algo < 0 || algo > 110 || (algo >= 4 && algo <= 7))
541     return gpg_error (GPG_ERR_DIGEST_ALGO);
542   return gcry_md_test_algo (algo);
543 }
544
545
546 /* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
547    string representation of the algorithm name.  For unknown algorithm
548    IDs this function returns "?".  */
549 const char *
550 openpgp_md_algo_name (int algo)
551 {
552   if (algo < 0 || algo > 110)
553     return "?";
554   return gcry_md_algo_name (algo);
555 }
556
557
558 static unsigned long
559 get_signature_count (PKT_public_key *pk)
560 {
561 #ifdef ENABLE_CARD_SUPPORT
562   struct agent_card_info_s info;
563
564   (void)pk;
565   if (!agent_scd_getattr ("SIG-COUNTER",&info))
566     return info.sig_counter;
567   else
568     return 0;
569 #else
570   (void)pk;
571   return 0;
572 #endif
573 }
574
575 /* Expand %-strings.  Returns a string which must be xfreed.  Returns
576    NULL if the string cannot be expanded (too large). */
577 char *
578 pct_expando(const char *string,struct expando_args *args)
579 {
580   const char *ch=string;
581   int idx=0,maxlen=0,done=0;
582   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
583   char *ret=NULL;
584
585   if(args->pk)
586     keyid_from_pk(args->pk,pk_keyid);
587
588   if(args->pksk)
589     keyid_from_pk (args->pksk, sk_keyid);
590
591   /* This is used so that %k works in photoid command strings in
592      --list-secret-keys (which of course has a sk, but no pk). */
593   if(!args->pk && args->pksk)
594     keyid_from_pk (args->pksk, pk_keyid);
595
596   while(*ch!='\0')
597     {
598       if(!done)
599         {
600           /* 8192 is way bigger than we'll need here */
601           if(maxlen>=8192)
602             goto fail;
603
604           maxlen+=1024;
605           ret=xrealloc(ret,maxlen);
606         }
607
608       done=0;
609
610       if(*ch=='%')
611         {
612           switch(*(ch+1))
613             {
614             case 's': /* short key id */
615               if(idx+8<maxlen)
616                 {
617                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
618                   idx+=8;
619                   done=1;
620                 }
621               break;
622
623             case 'S': /* long key id */
624               if(idx+16<maxlen)
625                 {
626                   sprintf(&ret[idx],"%08lX%08lX",
627                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
628                   idx+=16;
629                   done=1;
630                 }
631               break;
632
633             case 'k': /* short key id */
634               if(idx+8<maxlen)
635                 {
636                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
637                   idx+=8;
638                   done=1;
639                 }
640               break;
641
642             case 'K': /* long key id */
643               if(idx+16<maxlen)
644                 {
645                   sprintf(&ret[idx],"%08lX%08lX",
646                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
647                   idx+=16;
648                   done=1;
649                 }
650               break;
651
652             case 'c': /* signature count from card, if any. */
653               if(idx+10<maxlen)
654                 {
655                   sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
656                   idx+=strlen(&ret[idx]);
657                   done=1;
658                 }
659               break;
660
661             case 'p': /* primary pk fingerprint of a sk */
662             case 'f': /* pk fingerprint */
663             case 'g': /* sk fingerprint */
664               {
665                 byte array[MAX_FINGERPRINT_LEN];
666                 size_t len;
667                 int i;
668
669                 if((*(ch+1))=='p' && args->pksk)
670                   {
671                     if(args->pksk->flags.primary)
672                       fingerprint_from_pk (args->pksk, array, &len);
673                     else if (args->pksk->main_keyid[0]
674                              || args->pksk->main_keyid[1])
675                       {
676                         /* FIXME: Document teh code and check whether
677                            it is still needed.  */
678                         PKT_public_key *pk=
679                           xmalloc_clear(sizeof(PKT_public_key));
680
681                         if (!get_pubkey_fast (pk,args->pksk->main_keyid))
682                           fingerprint_from_pk (pk, array, &len);
683                         else
684                           memset (array, 0, (len=MAX_FINGERPRINT_LEN));
685                         free_public_key (pk);
686                       }
687                     else
688                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
689                   }
690                 else if((*(ch+1))=='f' && args->pk)
691                   fingerprint_from_pk (args->pk, array, &len);
692                 else if((*(ch+1))=='g' && args->pksk)
693                   fingerprint_from_pk (args->pksk, array, &len);
694                 else
695                   memset(array,0,(len=MAX_FINGERPRINT_LEN));
696
697                 if(idx+(len*2)<maxlen)
698                   {
699                     for(i=0;i<len;i++)
700                       {
701                         sprintf(&ret[idx],"%02X",array[i]);
702                         idx+=2;
703                       }
704                     done=1;
705                   }
706               }
707               break;
708
709             case 'v': /* validity letters */
710               if(args->validity_info && idx+1<maxlen)
711                 {
712                   ret[idx++]=args->validity_info;
713                   ret[idx]='\0';
714                   done=1;
715                 }
716               break;
717
718               /* The text string types */
719             case 't':
720             case 'T':
721             case 'V':
722               {
723                 const char *str=NULL;
724
725                 switch(*(ch+1))
726                   {
727                   case 't': /* e.g. "jpg" */
728                     str=image_type_to_string(args->imagetype,0);
729                     break;
730
731                   case 'T': /* e.g. "image/jpeg" */
732                     str=image_type_to_string(args->imagetype,2);
733                     break;
734
735                   case 'V': /* e.g. "full", "expired", etc. */
736                     str=args->validity_string;
737                     break;
738                   }
739
740                 if(str && idx+strlen(str)<maxlen)
741                   {
742                     strcpy(&ret[idx],str);
743                     idx+=strlen(str);
744                     done=1;
745                   }
746               }
747               break;
748
749             case '%':
750               if(idx+1<maxlen)
751                 {
752                   ret[idx++]='%';
753                   ret[idx]='\0';
754                   done=1;
755                 }
756               break;
757
758               /* Any unknown %-keys (like %i, %o, %I, and %O) are
759                  passed through for later expansion.  Note this also
760                  handles the case where the last character in the
761                  string is a '%' - the terminating \0 will end up here
762                  and properly terminate the string. */
763             default:
764               if(idx+2<maxlen)
765                 {
766                   ret[idx++]='%';
767                   ret[idx++]=*(ch+1);
768                   ret[idx]='\0';
769                   done=1;
770                 }
771               break;
772               }
773
774           if(done)
775             ch++;
776         }
777       else
778         {
779           if(idx+1<maxlen)
780             {
781               ret[idx++]=*ch;
782               ret[idx]='\0';
783               done=1;
784             }
785         }
786
787       if(done)
788         ch++;
789     }
790
791   return ret;
792
793  fail:
794   xfree(ret);
795   return NULL;
796 }
797
798 void
799 deprecated_warning(const char *configname,unsigned int configlineno,
800                    const char *option,const char *repl1,const char *repl2)
801 {
802   if(configname)
803     {
804       if(strncmp("--",option,2)==0)
805         option+=2;
806
807       if(strncmp("--",repl1,2)==0)
808         repl1+=2;
809
810       log_info(_("%s:%d: deprecated option \"%s\"\n"),
811                configname,configlineno,option);
812     }
813   else
814     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
815
816   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
817 }
818
819
820 void
821 deprecated_command (const char *name)
822 {
823   log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
824            name);
825 }
826
827
828 void
829 obsolete_option (const char *configname, unsigned int configlineno,
830                  const char *name)
831 {
832   if(configname)
833     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
834               configname, configlineno, name);
835   else
836     log_info (_("WARNING: \"%s\" is an obsolete option - it has no effect\n"),
837               name);
838 }
839
840
841 /*
842  * Wrapper around gcry_cipher_map_name to provide a fallback using the
843  * "Sn" syntax as used by the preference strings.
844  */
845 int
846 string_to_cipher_algo (const char *string)
847 {
848   int val;
849
850   val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
851   if (!val && string && (string[0]=='S' || string[0]=='s'))
852     {
853       char *endptr;
854
855       string++;
856       val = strtol (string, &endptr, 10);
857       if (!*string || *endptr || openpgp_cipher_test_algo (val))
858         val = 0;
859     }
860
861   return val;
862 }
863
864 /*
865  * Wrapper around gcry_md_map_name to provide a fallback using the
866  * "Hn" syntax as used by the preference strings.
867  */
868 int
869 string_to_digest_algo (const char *string)
870 {
871   int val;
872
873   val = gcry_md_map_name (string);
874   if (!val && string && (string[0]=='H' || string[0]=='h'))
875     {
876       char *endptr;
877
878       string++;
879       val = strtol (string, &endptr, 10);
880       if (!*string || *endptr || openpgp_md_test_algo (val))
881         val = 0;
882     }
883
884   return val;
885 }
886
887
888
889 const char *
890 compress_algo_to_string(int algo)
891 {
892   const char *s=NULL;
893
894   switch(algo)
895     {
896     case COMPRESS_ALGO_NONE:
897       s=_("Uncompressed");
898       break;
899
900     case COMPRESS_ALGO_ZIP:
901       s="ZIP";
902       break;
903
904     case COMPRESS_ALGO_ZLIB:
905       s="ZLIB";
906       break;
907
908 #ifdef HAVE_BZIP2
909     case COMPRESS_ALGO_BZIP2:
910       s="BZIP2";
911       break;
912 #endif
913     }
914
915   return s;
916 }
917
918 int
919 string_to_compress_algo(const char *string)
920 {
921   /* TRANSLATORS: See doc/TRANSLATE about this string. */
922   if(match_multistr(_("uncompressed|none"),string))
923     return 0;
924   else if(ascii_strcasecmp(string,"uncompressed")==0)
925     return 0;
926   else if(ascii_strcasecmp(string,"none")==0)
927     return 0;
928   else if(ascii_strcasecmp(string,"zip")==0)
929     return 1;
930   else if(ascii_strcasecmp(string,"zlib")==0)
931     return 2;
932 #ifdef HAVE_BZIP2
933   else if(ascii_strcasecmp(string,"bzip2")==0)
934     return 3;
935 #endif
936   else if(ascii_strcasecmp(string,"z0")==0)
937     return 0;
938   else if(ascii_strcasecmp(string,"z1")==0)
939     return 1;
940   else if(ascii_strcasecmp(string,"z2")==0)
941     return 2;
942 #ifdef HAVE_BZIP2
943   else if(ascii_strcasecmp(string,"z3")==0)
944     return 3;
945 #endif
946   else
947     return -1;
948 }
949
950 int
951 check_compress_algo(int algo)
952 {
953   switch (algo)
954     {
955     case 0: return 0;
956 #ifdef HAVE_ZIP
957     case 1:
958     case 2: return 0;
959 #endif
960 #ifdef HAVE_BZIP2
961     case 3: return 0;
962 #endif
963     default: return G10ERR_COMPR_ALGO;
964     }
965 }
966
967 int
968 default_cipher_algo(void)
969 {
970   if(opt.def_cipher_algo)
971     return opt.def_cipher_algo;
972   else if(opt.personal_cipher_prefs)
973     return opt.personal_cipher_prefs[0].value;
974   else
975     return opt.s2k_cipher_algo;
976 }
977
978 /* There is no default_digest_algo function, but see
979    sign.c:hash_for() */
980
981 int
982 default_compress_algo(void)
983 {
984   if(opt.compress_algo!=-1)
985     return opt.compress_algo;
986   else if(opt.personal_compress_prefs)
987     return opt.personal_compress_prefs[0].value;
988   else
989     return DEFAULT_COMPRESS_ALGO;
990 }
991
992 const char *
993 compliance_option_string(void)
994 {
995   char *ver="???";
996
997   switch(opt.compliance)
998     {
999     case CO_GNUPG:   return "--gnupg";
1000     case CO_RFC4880: return "--openpgp";
1001     case CO_RFC2440: return "--rfc2440";
1002     case CO_RFC1991: return "--rfc1991";
1003     case CO_PGP2:    return "--pgp2";
1004     case CO_PGP6:    return "--pgp6";
1005     case CO_PGP7:    return "--pgp7";
1006     case CO_PGP8:    return "--pgp8";
1007     }
1008
1009   return ver;
1010 }
1011
1012 void
1013 compliance_failure(void)
1014 {
1015   char *ver="???";
1016
1017   switch(opt.compliance)
1018     {
1019     case CO_GNUPG:
1020       ver="GnuPG";
1021       break;
1022
1023     case CO_RFC4880:
1024       ver="OpenPGP";
1025       break;
1026
1027     case CO_RFC2440:
1028       ver="OpenPGP (older)";
1029       break;
1030
1031     case CO_RFC1991:
1032       ver="old PGP";
1033       break;
1034
1035     case CO_PGP2:
1036       ver="PGP 2.x";
1037       break;
1038
1039     case CO_PGP6:
1040       ver="PGP 6.x";
1041       break;
1042
1043     case CO_PGP7:
1044       ver="PGP 7.x";
1045       break;
1046
1047     case CO_PGP8:
1048       ver="PGP 8.x";
1049       break;
1050     }
1051
1052   log_info(_("this message may not be usable by %s\n"),ver);
1053   opt.compliance=CO_GNUPG;
1054 }
1055
1056 /* Break a string into successive option pieces.  Accepts single word
1057    options and key=value argument options. */
1058 char *
1059 optsep(char **stringp)
1060 {
1061   char *tok,*end;
1062
1063   tok=*stringp;
1064   if(tok)
1065     {
1066       end=strpbrk(tok," ,=");
1067       if(end)
1068         {
1069           int sawequals=0;
1070           char *ptr=end;
1071
1072           /* what we need to do now is scan along starting with *end,
1073              If the next character we see (ignoring spaces) is an =
1074              sign, then there is an argument. */
1075
1076           while(*ptr)
1077             {
1078               if(*ptr=='=')
1079                 sawequals=1;
1080               else if(*ptr!=' ')
1081                 break;
1082               ptr++;
1083             }
1084
1085           /* There is an argument, so grab that too.  At this point,
1086              ptr points to the first character of the argument. */
1087           if(sawequals)
1088             {
1089               /* Is it a quoted argument? */
1090               if(*ptr=='"')
1091                 {
1092                   ptr++;
1093                   end=strchr(ptr,'"');
1094                   if(end)
1095                     end++;
1096                 }
1097               else
1098                 end=strpbrk(ptr," ,");
1099             }
1100
1101           if(end && *end)
1102             {
1103               *end='\0';
1104               *stringp=end+1;
1105             }
1106           else
1107             *stringp=NULL;
1108         }
1109       else
1110         *stringp=NULL;
1111     }
1112
1113   return tok;
1114 }
1115
1116 /* Breaks an option value into key and value.  Returns NULL if there
1117    is no value.  Note that "string" is modified to remove the =value
1118    part. */
1119 char *
1120 argsplit(char *string)
1121 {
1122   char *equals,*arg=NULL;
1123
1124   equals=strchr(string,'=');
1125   if(equals)
1126     {
1127       char *quote,*space;
1128
1129       *equals='\0';
1130       arg=equals+1;
1131
1132       /* Quoted arg? */
1133       quote=strchr(arg,'"');
1134       if(quote)
1135         {
1136           arg=quote+1;
1137
1138           quote=strchr(arg,'"');
1139           if(quote)
1140             *quote='\0';
1141         }
1142       else
1143         {
1144           size_t spaces;
1145
1146           /* Trim leading spaces off of the arg */
1147           spaces=strspn(arg," ");
1148           arg+=spaces;
1149         }
1150
1151       /* Trim tailing spaces off of the tag */
1152       space=strchr(string,' ');
1153       if(space)
1154         *space='\0';
1155     }
1156
1157   return arg;
1158 }
1159
1160 /* Return the length of the initial token, leaving off any
1161    argument. */
1162 static size_t
1163 optlen(const char *s)
1164 {
1165   char *end=strpbrk(s," =");
1166
1167   if(end)
1168     return end-s;
1169   else
1170     return strlen(s);
1171 }
1172
1173 int
1174 parse_options(char *str,unsigned int *options,
1175               struct parse_options *opts,int noisy)
1176 {
1177   char *tok;
1178
1179   if (str && !strcmp (str, "help"))
1180     {
1181       int i,maxlen=0;
1182
1183       /* Figure out the longest option name so we can line these up
1184          neatly. */
1185       for(i=0;opts[i].name;i++)
1186         if(opts[i].help && maxlen<strlen(opts[i].name))
1187           maxlen=strlen(opts[i].name);
1188
1189       for(i=0;opts[i].name;i++)
1190         if(opts[i].help)
1191           printf("%s%*s%s\n",opts[i].name,
1192                  maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
1193
1194       g10_exit(0);
1195     }
1196
1197   while((tok=optsep(&str)))
1198     {
1199       int i,rev=0;
1200       char *otok=tok;
1201
1202       if(tok[0]=='\0')
1203         continue;
1204
1205       if(ascii_strncasecmp("no-",tok,3)==0)
1206         {
1207           rev=1;
1208           tok+=3;
1209         }
1210
1211       for(i=0;opts[i].name;i++)
1212         {
1213           size_t toklen=optlen(tok);
1214
1215           if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
1216             {
1217               /* We have a match, but it might be incomplete */
1218               if(toklen!=strlen(opts[i].name))
1219                 {
1220                   int j;
1221
1222                   for(j=i+1;opts[j].name;j++)
1223                     {
1224                       if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
1225                         {
1226                           if(noisy)
1227                             log_info(_("ambiguous option '%s'\n"),otok);
1228                           return 0;
1229                         }
1230                     }
1231                 }
1232
1233               if(rev)
1234                 {
1235                   *options&=~opts[i].bit;
1236                   if(opts[i].value)
1237                     *opts[i].value=NULL;
1238                 }
1239               else
1240                 {
1241                   *options|=opts[i].bit;
1242                   if(opts[i].value)
1243                     *opts[i].value=argsplit(tok);
1244                 }
1245               break;
1246             }
1247         }
1248
1249       if(!opts[i].name)
1250         {
1251           if(noisy)
1252             log_info(_("unknown option '%s'\n"),otok);
1253           return 0;
1254         }
1255     }
1256
1257   return 1;
1258 }
1259
1260
1261 /* Check whether the string has characters not valid in an RFC-822
1262    address.  To cope with OpenPGP we ignore non-ascii characters
1263    so that for example umlauts are legal in an email address.  An
1264    OpenPGP user ID must be utf-8 encoded but there is no strict
1265    requirement for RFC-822.  Thus to avoid IDNA encoding we put the
1266    address verbatim as utf-8 into the user ID under the assumption
1267    that mail programs handle IDNA at a lower level and take OpenPGP
1268    user IDs as utf-8.  Note that we can't do an utf-8 encoding
1269    checking here because in keygen.c this function is called with the
1270    native encoding and native to utf-8 encoding is only done  later.  */
1271 int
1272 has_invalid_email_chars (const char *s)
1273 {
1274   int at_seen=0;
1275   const char *valid_chars=
1276     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1277
1278   for ( ; *s; s++ )
1279     {
1280       if ( (*s & 0x80) )
1281         continue; /* We only care about ASCII.  */
1282       if ( *s == '@' )
1283         at_seen=1;
1284       else if ( !at_seen && !(strchr (valid_chars, *s)
1285                               || strchr ("!#$%&'*+/=?^`{|}~", *s)))
1286         return 1;
1287       else if ( at_seen && !strchr( valid_chars, *s ) )
1288         return 1;
1289     }
1290   return 0;
1291 }
1292
1293
1294 /* Check whether NAME represents a valid mailbox according to
1295    RFC822. Returns true if so. */
1296 int
1297 is_valid_mailbox (const char *name)
1298 {
1299   return !( !name
1300             || !*name
1301             || has_invalid_email_chars (name)
1302             || string_count_chr (name,'@') != 1
1303             || *name == '@'
1304             || name[strlen(name)-1] == '@'
1305             || name[strlen(name)-1] == '.'
1306             || strstr (name, "..") );
1307 }
1308
1309
1310 /* Similar to access(2), but uses PATH to find the file. */
1311 int
1312 path_access(const char *file,int mode)
1313 {
1314   char *envpath;
1315   int ret=-1;
1316
1317   envpath=getenv("PATH");
1318
1319   if(!envpath
1320 #ifdef HAVE_DRIVE_LETTERS
1321      || (((file[0]>='A' && file[0]<='Z')
1322           || (file[0]>='a' && file[0]<='z'))
1323          && file[1]==':')
1324 #else
1325      || file[0]=='/'
1326 #endif
1327      )
1328     return access(file,mode);
1329   else
1330     {
1331       /* At least as large as, but most often larger than we need. */
1332       char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
1333       char *split,*item,*path=xstrdup(envpath);
1334
1335       split=path;
1336
1337       while((item=strsep(&split,PATHSEP_S)))
1338         {
1339           strcpy(buffer,item);
1340           strcat(buffer,"/");
1341           strcat(buffer,file);
1342           ret=access(buffer,mode);
1343           if(ret==0)
1344             break;
1345         }
1346
1347       xfree(path);
1348       xfree(buffer);
1349     }
1350
1351   return ret;
1352 }
1353
1354
1355 \f
1356 /* Return the number of public key parameters as used by OpenPGP.  */
1357 int
1358 pubkey_get_npkey (pubkey_algo_t algo)
1359 {
1360   switch (algo)
1361     {
1362     case PUBKEY_ALGO_RSA:
1363     case PUBKEY_ALGO_RSA_E:
1364     case PUBKEY_ALGO_RSA_S:     return 2;
1365     case PUBKEY_ALGO_ELGAMAL_E: return 3;
1366     case PUBKEY_ALGO_DSA:       return 4;
1367     case PUBKEY_ALGO_ECDH:      return 3;
1368     case PUBKEY_ALGO_ECDSA:     return 2;
1369     case PUBKEY_ALGO_ELGAMAL:   return 3;
1370     case PUBKEY_ALGO_EDDSA:     return 2;
1371     }
1372   return 0;
1373 }
1374
1375
1376 /* Return the number of secret key parameters as used by OpenPGP.  */
1377 int
1378 pubkey_get_nskey (pubkey_algo_t algo)
1379 {
1380   switch (algo)
1381     {
1382     case PUBKEY_ALGO_RSA:
1383     case PUBKEY_ALGO_RSA_E:
1384     case PUBKEY_ALGO_RSA_S:     return 6;
1385     case PUBKEY_ALGO_ELGAMAL_E: return 4;
1386     case PUBKEY_ALGO_DSA:       return 5;
1387     case PUBKEY_ALGO_ECDH:      return 4;
1388     case PUBKEY_ALGO_ECDSA:     return 3;
1389     case PUBKEY_ALGO_ELGAMAL:   return 4;
1390     case PUBKEY_ALGO_EDDSA:     return 3;
1391     }
1392   return 0;
1393 }
1394
1395 /* Temporary helper. */
1396 int
1397 pubkey_get_nsig (pubkey_algo_t algo)
1398 {
1399   switch (algo)
1400     {
1401     case PUBKEY_ALGO_RSA:
1402     case PUBKEY_ALGO_RSA_E:
1403     case PUBKEY_ALGO_RSA_S:     return 1;
1404     case PUBKEY_ALGO_ELGAMAL_E: return 0;
1405     case PUBKEY_ALGO_DSA:       return 2;
1406     case PUBKEY_ALGO_ECDH:      return 0;
1407     case PUBKEY_ALGO_ECDSA:     return 2;
1408     case PUBKEY_ALGO_ELGAMAL:   return 2;
1409     case PUBKEY_ALGO_EDDSA:     return 2;
1410     }
1411   return 0;
1412 }
1413
1414
1415 /* Temporary helper. */
1416 int
1417 pubkey_get_nenc (pubkey_algo_t algo)
1418 {
1419   switch (algo)
1420     {
1421     case PUBKEY_ALGO_RSA:
1422     case PUBKEY_ALGO_RSA_E:
1423     case PUBKEY_ALGO_RSA_S:     return 1;
1424     case PUBKEY_ALGO_ELGAMAL_E: return 2;
1425     case PUBKEY_ALGO_DSA:       return 0;
1426     case PUBKEY_ALGO_ECDH:      return 2;
1427     case PUBKEY_ALGO_ECDSA:     return 0;
1428     case PUBKEY_ALGO_ELGAMAL:   return 2;
1429     case PUBKEY_ALGO_EDDSA:     return 0;
1430     }
1431   return 0;
1432 }
1433
1434
1435 /* Temporary helper. */
1436 unsigned int
1437 pubkey_nbits( int algo, gcry_mpi_t *key )
1438 {
1439     int rc, nbits;
1440     gcry_sexp_t sexp;
1441
1442     if( algo == PUBKEY_ALGO_DSA ) {
1443         rc = gcry_sexp_build ( &sexp, NULL,
1444                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
1445                                   key[0], key[1], key[2], key[3] );
1446     }
1447     else if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E ) {
1448         rc = gcry_sexp_build ( &sexp, NULL,
1449                               "(public-key(elg(p%m)(g%m)(y%m)))",
1450                                   key[0], key[1], key[2] );
1451     }
1452     else if( is_RSA (algo) ) {
1453         rc = gcry_sexp_build ( &sexp, NULL,
1454                               "(public-key(rsa(n%m)(e%m)))",
1455                                   key[0], key[1] );
1456     }
1457     else if (algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
1458              || algo == PUBKEY_ALGO_EDDSA) {
1459         char *curve = openpgp_oid_to_str (key[0]);
1460         if (!curve)
1461           rc = gpg_error_from_syserror ();
1462         else
1463           {
1464             rc = gcry_sexp_build (&sexp, NULL,
1465                                   "(public-key(ecc(curve%s)(q%m)))",
1466                                   curve, key[1]);
1467             xfree (curve);
1468           }
1469     }
1470     else
1471         return 0;
1472
1473     if ( rc )
1474         BUG ();
1475
1476     nbits = gcry_pk_get_nbits( sexp );
1477     gcry_sexp_release( sexp );
1478     return nbits;
1479 }
1480
1481
1482
1483 int
1484 mpi_print (estream_t fp, gcry_mpi_t a, int mode)
1485 {
1486   int n=0;
1487
1488   if (!a)
1489     return es_fprintf (fp, "[MPI_NULL]");
1490   if (!mode)
1491     {
1492       unsigned int n1;
1493       n1 = gcry_mpi_get_nbits(a);
1494       n += es_fprintf (fp, "[%u bits]", n1);
1495     }
1496   else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
1497     {
1498       unsigned int nbits;
1499       unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
1500       if (!p)
1501         n += es_fprintf (fp, "[invalid opaque value]");
1502       else
1503         {
1504           nbits = (nbits + 7)/8;
1505           for (; nbits; nbits--, p++)
1506             n += es_fprintf (fp, "%02X", *p);
1507         }
1508     }
1509   else
1510     {
1511       unsigned char *buffer;
1512
1513       if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buffer, NULL, a))
1514         BUG ();
1515       es_fputs (buffer, fp);
1516       n += strlen (buffer);
1517       gcry_free (buffer);
1518     }
1519   return n;
1520 }
1521
1522
1523 /* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
1524    i.e.  04 <x> <y> */
1525 unsigned int
1526 ecdsa_qbits_from_Q (unsigned int qbits)
1527 {
1528   if ((qbits%8) > 3)
1529     {
1530       log_error (_("ECDSA public key is expected to be in SEC encoding "
1531                    "multiple of 8 bits\n"));
1532       return 0;
1533     }
1534   qbits -= qbits%8;
1535   qbits /= 2;
1536   return qbits;
1537 }