g10/misc.c

   1 /* misc.c -  miscellaneous functions
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
   3  *               2003 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 2 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, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <assert.h>
  29 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
  30 #include <asm/sysinfo.h>
  31 #include <asm/unistd.h>
  32 #endif
  33 #ifdef HAVE_SETRLIMIT
  34 #include <time.h>
  35 #include <sys/time.h>
  36 #include <sys/resource.h>
  37 #endif
  38
  39 #include "gpg.h"
  40 #include "util.h"
  41 #include "main.h"
  42 #include "photoid.h"
  43 #include "options.h"
  44 #include "i18n.h"
  45
  46 #define MAX_EXTERN_MPI_BITS 16384
  47
  48
  49 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
  50 static int
  51 setsysinfo(unsigned long op, void *buffer, unsigned long size,
  52                      int *start, void *arg, unsigned long flag)
  53 {
  54     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
  55 }
  56
  57 void
  58 trap_unaligned(void)
  59 {
  60     unsigned int buf[2];
  61
  62     buf[0] = SSIN_UACPROC;
  63     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
  64     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
  65 }
  66 #else
  67 void
  68 trap_unaligned(void)
  69 {  /* dummy */
  70 }
  71 #endif
  72
  73
  74 int
  75 disable_core_dumps()
  76 {
  77 #ifdef HAVE_DOSISH_SYSTEM
  78     return 0;
  79 #else
  80 #ifdef HAVE_SETRLIMIT
  81     struct rlimit limit;
  82
  83     limit.rlim_cur = 0;
  84     limit.rlim_max = 0;
  85     if( !setrlimit( RLIMIT_CORE, &limit ) )
  86         return 0;
  87     if( errno != EINVAL && errno != ENOSYS )
  88         log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
  89 #endif
  90     return 1;
  91 #endif
  92 }
  93
  94
  95
  96 u16
  97 checksum_u16( unsigned n )
  98 {
  99     u16 a;
 100
 101     a  = (n >> 8) & 0xff;
 102     a += n & 0xff;
 103     return a;
 104 }
 105
 106
 107 u16
 108 checksum( byte *p, unsigned n )
 109 {
 110     u16 a;
 111
 112     for(a=0; n; n-- )
 113         a += *p++;
 114     return a;
 115 }
 116
 117 u16
 118 checksum_mpi( gcry_mpi_t a )
 119 {
 120   int rc;
 121   u16 csum;
 122   byte *buffer;
 123   size_t nbytes;
 124
 125   rc = gcry_mpi_print( GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a );
 126   if (rc)
 127     BUG ();
 128   /* fixme: for numbers not in secure memory we should use a stack
 129    * based buffer and only allocate a larger one if mpi_print return
 130    * an error */
 131   buffer = gcry_is_secure(a)? gcry_xmalloc_secure(nbytes):gcry_xmalloc(nbytes);
 132   rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a );
 133   if (rc)
 134     BUG ();
 135   csum = checksum (buffer, nbytes );
 136   xfree (buffer );
 137   return csum;
 138 }
 139
 140 u32
 141 buffer_to_u32( const byte *buffer )
 142 {
 143     unsigned long a;
 144     a =  *buffer << 24;
 145     a |= buffer[1] << 16;
 146     a |= buffer[2] << 8;
 147     a |= buffer[3];
 148     return a;
 149 }
 150
 151
 152 static void
 153 no_exp_algo(void)
 154 {
 155     static int did_note = 0;
 156
 157     if( !did_note ) {
 158         did_note = 1;
 159         log_info(_("Experimental algorithms should not be used!\n"));
 160     }
 161 }
 162
 163 void
 164 print_pubkey_algo_note( int algo )
 165 {
 166     if( algo >= 100 && algo <= 110 )
 167         no_exp_algo();
 168 }
 169
 170 void
 171 print_cipher_algo_note( int algo )
 172 {
 173     if( algo >= 100 && algo <= 110 )
 174         no_exp_algo();
 175     else if(    algo == CIPHER_ALGO_3DES
 176              || algo == CIPHER_ALGO_CAST5
 177              || algo == CIPHER_ALGO_BLOWFISH
 178              || algo == CIPHER_ALGO_TWOFISH
 179              || algo == CIPHER_ALGO_RIJNDAEL
 180              || algo == CIPHER_ALGO_RIJNDAEL192
 181              || algo == CIPHER_ALGO_RIJNDAEL256
 182            )
 183         ;
 184     else {
 185         static int did_note = 0;
 186
 187         if( !did_note ) {
 188             did_note = 1;
 189             log_info(_("this cipher algorithm is deprecated; "
 190                        "please use a more standard one!\n"));
 191         }
 192     }
 193 }
 194
 195 void
 196 print_digest_algo_note( int algo )
 197 {
 198     if( algo >= 100 && algo <= 110 )
 199         no_exp_algo();
 200 }
 201
 202
 203 /* Return a string which is used as a kind of process ID */
 204 const byte *
 205 get_session_marker( size_t *rlen )
 206 {
 207     static byte marker[SIZEOF_UNSIGNED_LONG*2];
 208     static int initialized;
 209
 210     if ( !initialized ) {
 211         volatile ulong aa, bb; /* we really want the uninitialized value */
 212         ulong a, b;
 213
 214         initialized = 1;
 215         /* also this marker is guessable it is not easy to use this
 216          * for a faked control packet because an attacker does not
 217          * have enough control about the time the verification does
 218          * take place.  Of course, we can add just more random but
 219          * than we need the random generator even for verification
 220          * tasks - which does not make sense. */
 221         a = aa ^ (ulong)getpid();
 222         b = bb ^ (ulong)time(NULL);
 223         memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
 224         memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
 225     }
 226     *rlen = sizeof(marker);
 227     return marker;
 228 }
 229
 230 /****************
 231  * Wrapper around the libgcrypt function with addional checks on
 232  * openPGP contraints for the algo ID.
 233  */
 234 int
 235 openpgp_cipher_test_algo( int algo )
 236 {
 237     if( algo < 0 || algo > 110 )
 238         return GPG_ERR_CIPHER_ALGO;
 239     return gcry_cipher_test_algo (algo);
 240 }
 241
 242 int
 243 openpgp_pk_test_algo( int algo, unsigned int usage_flags )
 244 {
 245   size_t value = usage_flags;
 246
 247   if (algo == GCRY_PK_ELG_E)
 248     algo = GCRY_PK_ELG;
 249 #ifdef __GNUC__
 250 #warning need to handle the usage here?
 251 #endif
 252   if (algo < 0 || algo > 110)
 253     return GPG_ERR_PUBKEY_ALGO;
 254   return gcry_pk_algo_info (algo, GCRYCTL_TEST_ALGO, NULL, &value);
 255 }
 256
 257 int
 258 openpgp_pk_algo_usage ( int algo )
 259 {
 260     int use = 0;
 261
 262     /* they are hardwired in gpg 1.0 */
 263     switch ( algo ) {
 264       case PUBKEY_ALGO_RSA:
 265           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
 266           break;
 267       case PUBKEY_ALGO_RSA_E:
 268           use = PUBKEY_USAGE_ENC;
 269           break;
 270       case PUBKEY_ALGO_RSA_S:
 271           use = PUBKEY_USAGE_SIG;
 272           break;
 273       case PUBKEY_ALGO_ELGAMAL_E:
 274           use = PUBKEY_USAGE_ENC;
 275           break;
 276       case PUBKEY_ALGO_DSA:
 277           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
 278           break;
 279       case PUBKEY_ALGO_ELGAMAL:
 280           use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH;
 281           break;
 282       default:
 283           break;
 284     }
 285     return use;
 286 }
 287
 288 int
 289 openpgp_md_test_algo( int algo )
 290 {
 291     if( algo < 0 || algo > 110 )
 292         return GPG_ERR_DIGEST_ALGO;
 293     return gcry_md_test_algo (algo);
 294 }
 295
 296 int
 297 openpgp_md_map_name (const char *string)
 298 {
 299   int i = gcry_md_map_name (string);
 300
 301   if (!i && (string[0]=='H' || string[0]=='h'))
 302     { /* Didn't find it, so try the Hx format */
 303       long val;
 304       char *endptr;
 305
 306       string++;
 307
 308       val=strtol(string,&endptr,10);
 309       if (*string!='\0' && *endptr=='\0' && !openpgp_md_test_algo(val))
 310         i = val;
 311     }
 312   return i < 0 || i > 110? 0 : i;
 313 }
 314
 315 int
 316 openpgp_cipher_map_name (const char *string)
 317 {
 318   int i = gcry_cipher_map_name (string);
 319
 320   if (!i && (string[0]=='S' || string[0]=='s'))
 321     { /* Didn't find it, so try the Sx format */
 322       long val;
 323       char *endptr;
 324
 325       string++;
 326
 327       val=strtol(string,&endptr,10);
 328       if (*string!='\0' && *endptr=='\0' && !openpgp_cipher_test_algo(val))
 329         i = val;
 330     }
 331   return i < 0 || i > 110? 0 : i;
 332 }
 333
 334 int
 335 openpgp_pk_map_name (const char *string)
 336 {
 337   int i = gcry_pk_map_name (string);
 338   return i < 0 || i > 110? 0 : i;
 339 }
 340
 341 #ifdef USE_IDEA
 342 /* Special warning for the IDEA cipher */
 343 void
 344 idea_cipher_warn(int show)
 345 {
 346   static int warned=0;
 347
 348   if(!warned || show)
 349     {
 350       log_info(_("the IDEA cipher plugin is not present\n"));
 351       log_info(_("please see http://www.gnupg.org/why-not-idea.html "
 352                  "for more information\n"));
 353       warned=1;
 354     }
 355 }
 356 #endif
 357
 358 /* Expand %-strings.  Returns a string which must be m_freed.  Returns
 359    NULL if the string cannot be expanded (too large). */
 360 char *
 361 pct_expando(const char *string,struct expando_args *args)
 362 {
 363   const char *ch=string;
 364   int idx=0,maxlen=0,done=0;
 365   u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
 366   char *ret=NULL;
 367
 368   if(args->pk)
 369     keyid_from_pk(args->pk,pk_keyid);
 370
 371   if(args->sk)
 372     keyid_from_sk(args->sk,sk_keyid);
 373
 374   /* This is used so that %k works in photoid command strings in
 375      --list-secret-keys (which of course has a sk, but no pk). */
 376   if(!args->pk && args->sk)
 377     keyid_from_sk(args->sk,pk_keyid);
 378
 379   while(*ch!='\0')
 380     {
 381       char *str=NULL;
 382
 383       if(!done)
 384         {
 385           /* 8192 is way bigger than we'll need here */
 386           if(maxlen>=8192)
 387             goto fail;
 388
 389           maxlen+=1024;
 390           ret= xrealloc(ret,maxlen);
 391         }
 392
 393       done=0;
 394
 395       if(*ch=='%')
 396         {
 397           switch(*(ch+1))
 398             {
 399             case 's': /* short key id */
 400               if(idx+8<maxlen)
 401                 {
 402                   sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
 403                   idx+=8;
 404                   done=1;
 405                 }
 406               break;
 407
 408             case 'S': /* long key id */
 409               if(idx+16<maxlen)
 410                 {
 411                   sprintf(&ret[idx],"%08lX%08lX",
 412                           (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
 413                   idx+=16;
 414                   done=1;
 415                 }
 416               break;
 417
 418             case 'k': /* short key id */
 419               if(idx+8<maxlen)
 420                 {
 421                   sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
 422                   idx+=8;
 423                   done=1;
 424                 }
 425               break;
 426
 427             case 'K': /* long key id */
 428               if(idx+16<maxlen)
 429                 {
 430                   sprintf(&ret[idx],"%08lX%08lX",
 431                           (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
 432                   idx+=16;
 433                   done=1;
 434                 }
 435               break;
 436
 437             case 'p': /* primary pk fingerprint of a sk */
 438             case 'f': /* pk fingerprint */
 439             case 'g': /* sk fingerprint */
 440               {
 441                 byte array[MAX_FINGERPRINT_LEN];
 442                 size_t len;
 443                 int i;
 444
 445                 if( ch[1]=='p' && args->sk)
 446                   {
 447                     if(args->sk->is_primary)
 448                       fingerprint_from_sk(args->sk,array,&len);
 449                     else if(args->sk->main_keyid[0] || args->sk->main_keyid[1])
 450                       {
 451                         PKT_public_key *pk= xcalloc(1, sizeof(PKT_public_key));
 452
 453                         if(get_pubkey_fast(pk,args->sk->main_keyid)==0)
 454                           fingerprint_from_pk(pk,array,&len);
 455                         else
 456                           memset(array,0,(len=MAX_FINGERPRINT_LEN));
 457                         free_public_key(pk);
 458                       }
 459                     else
 460                       memset(array,0,(len=MAX_FINGERPRINT_LEN));
 461                   }
 462                 else if( ch[1]=='f' && args->pk)
 463                   fingerprint_from_pk(args->pk,array,&len);
 464                 else if( ch[1]=='g' && args->sk)
 465                   fingerprint_from_sk(args->sk,array,&len);
 466                 else
 467                   memset(array, 0, (len=MAX_FINGERPRINT_LEN));
 468
 469                 if(idx+(len*2)<maxlen)
 470                   {
 471                     for(i=0;i<len;i++)
 472                       {
 473                         sprintf(&ret[idx],"%02X",array[i]);
 474                         idx+=2;
 475                       }
 476                     done=1;
 477                   }
 478               }
 479               break;
 480
 481             case 't': /* e.g. "jpg" */
 482               str=image_type_to_string(args->imagetype,0);
 483               /* fall through */
 484
 485             case 'T': /* e.g. "image/jpeg" */
 486               if(str==NULL)
 487                 str=image_type_to_string(args->imagetype,2);
 488
 489               if(idx+strlen(str)<maxlen)
 490                 {
 491                   strcpy(&ret[idx],str);
 492                   idx+=strlen(str);
 493                   done=1;
 494                 }
 495               break;
 496
 497             case '%':
 498               if(idx+1<maxlen)
 499                 {
 500                   ret[idx++]='%';
 501                   ret[idx]='\0';
 502                   done=1;
 503                 }
 504               break;
 505
 506               /* Any unknown %-keys (like %i, %o, %I, and %O) are
 507                  passed through for later expansion.  Note this also
 508                  handles the case where the last character in the
 509                  string is a '%' - the terminating \0 will end up here
 510                  and properly terminate the string. */
 511             default:
 512               if(idx+2<maxlen)
 513                 {
 514                   ret[idx++]='%';
 515                   ret[idx++]=*(ch+1);
 516                   ret[idx]='\0';
 517                   done=1;
 518                 }
 519               break;
 520               }
 521
 522           if(done)
 523             ch++;
 524         }
 525       else
 526         {
 527           if(idx+1<maxlen)
 528             {
 529               ret[idx++]=*ch;
 530               ret[idx]='\0';
 531               done=1;
 532             }
 533         }
 534
 535       if(done)
 536         ch++;
 537     }
 538
 539   return ret;
 540
 541  fail:
 542   xfree (ret);
 543   return NULL;
 544 }
 545
 546 int
 547 hextobyte( const char *s )
 548 {
 549     int c;
 550
 551     if( *s >= '0' && *s <= '9' )
 552         c = 16 * (*s - '0');
 553     else if( *s >= 'A' && *s <= 'F' )
 554         c = 16 * (10 + *s - 'A');
 555     else if( *s >= 'a' && *s <= 'f' )
 556         c = 16 * (10 + *s - 'a');
 557     else
 558         return -1;
 559     s++;
 560     if( *s >= '0' && *s <= '9' )
 561         c += *s - '0';
 562     else if( *s >= 'A' && *s <= 'F' )
 563         c += 10 + *s - 'A';
 564     else if( *s >= 'a' && *s <= 'f' )
 565         c += 10 + *s - 'a';
 566     else
 567         return -1;
 568     return c;
 569 }
 570
 571 void
 572 deprecated_warning(const char *configname,unsigned int configlineno,
 573                    const char *option,const char *repl1,const char *repl2)
 574 {
 575   if(configname)
 576     {
 577       if(strncmp("--",option,2)==0)
 578         option+=2;
 579
 580       if(strncmp("--",repl1,2)==0)
 581         repl1+=2;
 582
 583       log_info(_("%s:%d: deprecated option \"%s\"\n"),
 584                configname,configlineno,option);
 585     }
 586   else
 587     log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
 588
 589   log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
 590 }
 591
 592 const char *
 593 compress_algo_to_string(int algo)
 594 {
 595   const char *s="?";
 596
 597   switch(algo)
 598     {
 599     case 0:
 600       s="Uncompressed";
 601       break;
 602
 603     case 1:
 604       s="ZIP";
 605       break;
 606
 607     case 2:
 608       s="ZLIB";
 609       break;
 610     }
 611
 612   return s;
 613 }
 614
 615 int
 616 string_to_compress_algo(const char *string)
 617 {
 618   if(ascii_strcasecmp(string,"uncompressed")==0)
 619     return 0;
 620   else if(ascii_strcasecmp(string,"zip")==0)
 621     return 1;
 622   else if(ascii_strcasecmp(string,"zlib")==0)
 623     return 2;
 624   else if(ascii_strcasecmp(string,"z0")==0)
 625     return 0;
 626   else if(ascii_strcasecmp(string,"z1")==0)
 627     return 1;
 628   else if(ascii_strcasecmp(string,"z2")==0)
 629     return 2;
 630   else
 631     return -1;
 632 }
 633
 634 int
 635 check_compress_algo(int algo)
 636 {
 637   if(algo>=0 && algo<=2)
 638     return 0;
 639
 640   return GPG_ERR_COMPR_ALGO;
 641 }
 642
 643 int
 644 default_cipher_algo(void)
 645 {
 646   if(opt.def_cipher_algo)
 647     return opt.def_cipher_algo;
 648   else if(opt.personal_cipher_prefs)
 649     return opt.personal_cipher_prefs[0].value;
 650   else
 651     return opt.s2k_cipher_algo;
 652 }
 653
 654 /* There is no default_digest_algo function, but see
 655    sign.c:hash_for */
 656
 657 int
 658 default_compress_algo(void)
 659 {
 660   if(opt.def_compress_algo!=-1)
 661     return opt.def_compress_algo;
 662   else if(opt.personal_compress_prefs)
 663     return opt.personal_compress_prefs[0].value;
 664   else
 665     return DEFAULT_COMPRESS_ALGO;
 666 }
 667
 668 const char *
 669 compliance_option_string(void)
 670 {
 671   switch(opt.compliance)
 672     {
 673     case CO_RFC2440:
 674       return "--openpgp";
 675     case CO_PGP2:
 676       return "--pgp2";
 677     case CO_PGP6:
 678       return "--pgp6";
 679     case CO_PGP7:
 680       return "--pgp7";
 681     case CO_PGP8:
 682       return "--pgp8";
 683     default:
 684       return "???";
 685     }
 686 }
 687
 688 static const char *
 689 compliance_string(void)
 690 {
 691   switch(opt.compliance)
 692     {
 693     case CO_RFC2440:
 694       return "OpenPGP";
 695     case CO_PGP2:
 696       return "PGP 2.x";
 697     case CO_PGP6:
 698       return "PGP 6.x";
 699     case CO_PGP7:
 700       return "PGP 7.x";
 701     case CO_PGP8:
 702       return "PGP 8.x";
 703     default:
 704       return "???";
 705     }
 706 }
 707
 708 void
 709 compliance_failure(void)
 710 {
 711   log_info(_("this message may not be usable by %s\n"),compliance_string());
 712   opt.compliance=CO_GNUPG;
 713 }
 714
 715 int
 716 parse_options(char *str,unsigned int *options,struct parse_options *opts)
 717 {
 718   char *tok;
 719
 720   while((tok=strsep(&str," ,")))
 721     {
 722       int i,rev=0;
 723
 724       if(tok[0]=='\0')
 725         continue;
 726
 727       if(ascii_strncasecmp("no-",tok,3)==0)
 728         {
 729           rev=1;
 730           tok+=3;
 731         }
 732
 733       for(i=0;opts[i].name;i++)
 734         {
 735           if(ascii_strcasecmp(opts[i].name,tok)==0)
 736             {
 737               if(rev)
 738                 *options&=~opts[i].bit;
 739               else
 740                 *options|=opts[i].bit;
 741               break;
 742             }
 743         }
 744
 745       if(!opts[i].name)
 746         return 0;
 747     }
 748
 749   return 1;
 750 }
 751
 752
 753
 754 /* Temporary helper. */
 755 int
 756 pubkey_get_npkey( int algo )
 757 {
 758   size_t n;
 759
 760   if (algo == GCRY_PK_ELG_E)
 761     algo = GCRY_PK_ELG;
 762   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NPKEY, NULL, &n))
 763     n = 0;
 764   return n;
 765 }
 766
 767 /* Temporary helper. */
 768 int
 769 pubkey_get_nskey( int algo )
 770 {
 771   size_t n;
 772
 773   if (algo == GCRY_PK_ELG_E)
 774     algo = GCRY_PK_ELG;
 775   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSKEY, NULL, &n ))
 776     n = 0;
 777   return n;
 778 }
 779
 780 /* Temporary helper. */
 781 int
 782 pubkey_get_nsig( int algo )
 783 {
 784   size_t n;
 785
 786   if (algo == GCRY_PK_ELG_E)
 787     algo = GCRY_PK_ELG;
 788   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NSIGN, NULL, &n))
 789     n = 0;
 790   return n;
 791 }
 792
 793 /* Temporary helper. */
 794 int
 795 pubkey_get_nenc( int algo )
 796 {
 797   size_t n;
 798
 799   if (algo == GCRY_PK_ELG_E)
 800     algo = GCRY_PK_ELG;
 801   if (gcry_pk_algo_info( algo, GCRYCTL_GET_ALGO_NENCR, NULL, &n ))
 802     n = 0;
 803   return n;
 804 }
 805
 806
 807 /* Temporary helper. */
 808 unsigned int
 809 pubkey_nbits( int algo, gcry_mpi_t *key )
 810 {
 811     int rc, nbits;
 812     gcry_sexp_t sexp;
 813
 814     if( algo == GCRY_PK_DSA ) {
 815         rc = gcry_sexp_build ( &sexp, NULL,
 816                               "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
 817                                   key[0], key[1], key[2], key[3] );
 818     }
 819     else if( algo == GCRY_PK_ELG || algo == GCRY_PK_ELG_E ) {
 820         rc = gcry_sexp_build ( &sexp, NULL,
 821                               "(public-key(elg(p%m)(g%m)(y%m)))",
 822                                   key[0], key[1], key[2] );
 823     }
 824     else if( algo == GCRY_PK_RSA ) {
 825         rc = gcry_sexp_build ( &sexp, NULL,
 826                               "(public-key(rsa(n%m)(e%m)))",
 827                                   key[0], key[1] );
 828     }
 829     else
 830         return 0;
 831
 832     if ( rc )
 833         BUG ();
 834
 835     nbits = gcry_pk_get_nbits( sexp );
 836     gcry_sexp_release( sexp );
 837     return nbits;
 838 }
 839
 840 \f
 841 /* MPI helper functions. */
 842
 843
 844 /****************
 845  * write an mpi to out.
 846  */
 847 int
 848 mpi_write( iobuf_t out, gcry_mpi_t a )
 849 {
 850     char buffer[(MAX_EXTERN_MPI_BITS+7)/8];
 851     size_t nbytes;
 852     int rc;
 853
 854     nbytes = (MAX_EXTERN_MPI_BITS+7)/8;
 855     rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, &nbytes, a );
 856     if( !rc )
 857         rc = iobuf_write( out, buffer, nbytes );
 858
 859     return rc;
 860 }
 861
 862 /****************
 863  * Writyeg a MPI to out, but in this case it is an opaque one,
 864  * s used vor v3 protected keys.
 865  */
 866 int
 867 mpi_write_opaque( iobuf_t out, gcry_mpi_t a )
 868 {
 869     size_t nbytes, nbits;
 870     int rc;
 871     char *p;
 872
 873     assert( gcry_mpi_get_flag( a, GCRYMPI_FLAG_OPAQUE ) );
 874     p = gcry_mpi_get_opaque( a, &nbits );
 875     nbytes = (nbits+7) / 8;
 876     iobuf_put( out, nbits >> 8 );
 877     iobuf_put( out, nbits );
 878     rc = iobuf_write( out, p, nbytes );
 879     return rc;
 880 }
 881
 882
 883 /****************
 884  * Read an external representation of an mpi and return the MPI
 885  * The external format is a 16 bit unsigned value stored in network byte order,
 886  * giving the number of bits for the following integer. The integer is stored
 887  * with MSB first (left padded with zeroes to align on a byte boundary).
 888  */
 889 gcry_mpi_t
 890 mpi_read(iobuf_t inp, unsigned int *ret_nread, int secure)
 891 {
 892     int c, c1, c2, i;
 893     unsigned int nbits, nbytes, nread=0;
 894     gcry_mpi_t a = NULL;
 895     byte *buf = NULL;
 896     byte *p;
 897
 898     if( (c = c1 = iobuf_get(inp)) == -1 )
 899         goto leave;
 900     nbits = c << 8;
 901     if( (c = c2 = iobuf_get(inp)) == -1 )
 902         goto leave;
 903     nbits |= c;
 904     if( nbits > MAX_EXTERN_MPI_BITS ) {
 905         log_error("mpi too large (%u bits)\n", nbits);
 906         goto leave;
 907     }
 908     nread = 2;
 909     nbytes = (nbits+7) / 8;
 910     buf = secure? gcry_xmalloc_secure( nbytes+2 ) : gcry_xmalloc( nbytes+2 );
 911     p = buf;
 912     p[0] = c1;
 913     p[1] = c2;
 914     for( i=0 ; i < nbytes; i++ ) {
 915         p[i+2] = iobuf_get(inp) & 0xff;
 916         nread++;
 917     }
 918     nread += nbytes;
 919     if( gcry_mpi_scan( &a, GCRYMPI_FMT_PGP, buf, nread, &nread ) )
 920         a = NULL;
 921
 922   leave:
 923     gcry_free(buf);
 924     if( nread > *ret_nread )
 925         log_bug("mpi larger than packet");
 926     else
 927         *ret_nread = nread;
 928     return a;
 929 }
 930
 931 /****************
 932  * Same as mpi_read but the value is stored as an opaque MPI.
 933  * This function is used to read encrypted MPI of v3 packets.
 934  */
 935 gcry_mpi_t
 936 mpi_read_opaque(iobuf_t inp, unsigned *ret_nread )
 937 {
 938     int c, c1, c2, i;
 939     unsigned nbits, nbytes, nread=0;
 940     gcry_mpi_t a = NULL;
 941     byte *buf = NULL;
 942     byte *p;
 943
 944     if( (c = c1 = iobuf_get(inp)) == -1 )
 945         goto leave;
 946     nbits = c << 8;
 947     if( (c = c2 = iobuf_get(inp)) == -1 )
 948         goto leave;
 949     nbits |= c;
 950     if( nbits > MAX_EXTERN_MPI_BITS ) {
 951         log_error("mpi too large (%u bits)\n", nbits);
 952         goto leave;
 953     }
 954     nread = 2;
 955     nbytes = (nbits+7) / 8;
 956     buf = gcry_xmalloc( nbytes );
 957     p = buf;
 958     for( i=0 ; i < nbytes; i++ ) {
 959         p[i] = iobuf_get(inp) & 0xff;
 960     }
 961     nread += nbytes;
 962     a = gcry_mpi_set_opaque(NULL, buf, nbits );
 963     buf = NULL;
 964
 965   leave:
 966     gcry_free(buf);
 967     if( nread > *ret_nread )
 968         log_bug("mpi larger than packet");
 969     else
 970         *ret_nread = nread;
 971     return a;
 972 }
 973
 974
 975 int
 976 mpi_print( FILE *fp, gcry_mpi_t a, int mode )
 977 {
 978     int n=0;
 979
 980     if( !a )
 981         return fprintf(fp, "[MPI_NULL]");
 982     if( !mode ) {
 983         unsigned int n1;
 984         n1 = gcry_mpi_get_nbits(a);
 985         n += fprintf(fp, "[%u bits]", n1);
 986     }
 987     else {
 988         int rc;
 989         unsigned char *buffer;
 990
 991         rc = gcry_mpi_aprint( GCRYMPI_FMT_HEX, &buffer, NULL, a );
 992         assert( !rc );
 993         fputs( buffer, fp );
 994         n += strlen(buffer);
 995         gcry_free( buffer );
 996     }
 997     return n;
 998 }
 999
1000