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