common/private-keys.c

   1 /* private-keys.c - Parser and writer for the extended private key format.
   2  *      Copyright (C) 2016 g10 Code GmbH
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * This file is free software; you can redistribute it and/or modify
   7  * it under the terms of either
   8  *
   9  *   - the GNU Lesser General Public License as published by the Free
  10  *     Software Foundation; either version 3 of the License, or (at
  11  *     your option) any later version.
  12  *
  13  * or
  14  *
  15  *   - the GNU General Public License as published by the Free
  16  *     Software Foundation; either version 2 of the License, or (at
  17  *     your option) any later version.
  18  *
  19  * or both in parallel, as here.
  20  *
  21  * GnuPG is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  28  */
  29
  30 #include <config.h>
  31 #include <assert.h>
  32 #include <gcrypt.h>
  33 #include <gpg-error.h>
  34 #include <string.h>
  35
  36 #include "private-keys.h"
  37 #include "mischelp.h"
  38 #include "strlist.h"
  39 #include "util.h"
  40
  41 struct private_key_container
  42 {
  43   struct private_key_entry *first;
  44   struct private_key_entry *last;
  45 };
  46
  47
  48 struct private_key_entry
  49 {
  50   struct private_key_entry *prev;
  51   struct private_key_entry *next;
  52
  53   /* The name.  Comments and blank lines have NAME set to NULL.  */
  54   char *name;
  55
  56   /* The value as stored in the file.  We store it when when we parse
  57      a file so that we can reproduce it.  */
  58   strlist_t raw_value;
  59
  60   /* The decoded value.  */
  61   char *value;
  62 };
  63
  64
  65 /* Helper */
  66 static inline gpg_error_t
  67 my_error_from_syserror (void)
  68 {
  69   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
  70 }
  71
  72
  73 \f
  74
  75 /* Allocation and deallocation.  */
  76
  77 /* Allocate a private key container structure.  */
  78 pkc_t
  79 pkc_new (void)
  80 {
  81   return xtrycalloc (1, sizeof (struct private_key_container));
  82 }
  83
  84
  85 static void
  86 pke_release (pke_t entry)
  87 {
  88   if (entry == NULL)
  89     return;
  90
  91   xfree (entry->name);
  92   if (entry->value)
  93     wipememory (entry->value, strlen (entry->value));
  94   xfree (entry->value);
  95   free_strlist_wipe (entry->raw_value);
  96   xfree (entry);
  97 }
  98
  99
 100 /* Release a private key container structure.  */
 101 void
 102 pkc_release (pkc_t pk)
 103 {
 104   pke_t e, next;
 105
 106   if (pk == NULL)
 107     return;
 108
 109   for (e = pk->first; e; e = next)
 110     {
 111       next = e->next;
 112       pke_release (e);
 113     }
 114
 115   xfree (pk);
 116 }
 117
 118 \f
 119
 120 /* Dealing with names and values.  */
 121
 122 /* Check whether the given name is valid.  Valid names start with a
 123    letter, end with a colon, and contain only alphanumeric characters
 124    and the hyphen.  */
 125 static int
 126 valid_name (const char *name)
 127 {
 128   size_t i, len = strlen (name);
 129
 130   if (! alphap (name) || len == 0 || name[len - 1] != ':')
 131     return 0;
 132
 133   for (i = 1; i < len - 1; i++)
 134     if (! alnump (&name[i]) && name[i] != '-')
 135       return 0;
 136
 137   return 1;
 138 }
 139
 140
 141 /* Makes sure that ENTRY has a RAW_VALUE.  */
 142 static gpg_error_t
 143 assert_raw_value (pke_t entry)
 144 {
 145   gpg_error_t err = 0;
 146   size_t len, offset;
 147 #define LINELEN 70
 148   char buf[LINELEN+3];
 149
 150   if (entry->raw_value)
 151     return 0;
 152
 153   len = strlen (entry->value);
 154   offset = 0;
 155   while (len)
 156     {
 157       size_t amount, linelen = LINELEN;
 158
 159       /* On the first line we need to subtract space for the name.  */
 160       if (entry->raw_value == NULL && strlen (entry->name) < linelen)
 161         linelen -= strlen (entry->name);
 162
 163       /* See if the rest of the value fits in this line.  */
 164       if (len <= linelen)
 165         amount = len;
 166       else
 167         {
 168           size_t i;
 169
 170           /* Find a suitable space to break on.  */
 171           for (i = linelen - 1; linelen - i < 30 && linelen - i > offset; i--)
 172             if (ascii_isspace (entry->value[i]))
 173               break;
 174
 175           if (ascii_isspace (entry->value[i]))
 176             {
 177               /* Found one.  */
 178               amount = i;
 179             }
 180           else
 181             {
 182               /* Just induce a hard break.  */
 183               amount = linelen;
 184             }
 185         }
 186
 187       snprintf (buf, sizeof buf, " %.*s\n", (int) amount,
 188                 &entry->value[offset]);
 189       if (append_to_strlist_try (&entry->raw_value, buf) == NULL)
 190         {
 191           err = my_error_from_syserror ();
 192           goto leave;
 193         }
 194
 195       offset += amount;
 196       len -= amount;
 197     }
 198
 199  leave:
 200   if (err)
 201     {
 202       free_strlist_wipe (entry->raw_value);
 203       entry->raw_value = NULL;
 204     }
 205
 206   return err;
 207 #undef LINELEN
 208 }
 209
 210
 211 /* Computes the length of the value encoded as continuation.  If
 212    *SWALLOW_WS is set, all whitespace at the beginning of S is
 213    swallowed.  If START is given, a pointer to the beginning of the
 214    value is stored there.  */
 215 static size_t
 216 continuation_length (const char *s, int *swallow_ws, const char **start)
 217 {
 218   size_t len;
 219
 220   if (*swallow_ws)
 221     {
 222       /* The previous line was a blank line and we inserted a newline.
 223          Swallow all whitespace at the beginning of this line.  */
 224       while (ascii_isspace (*s))
 225         s++;
 226     }
 227   else
 228     {
 229       /* Iff a continuation starts with more than one space, it
 230          encodes a space.  */
 231       if (ascii_isspace (*s))
 232         s++;
 233     }
 234
 235   /* Strip whitespace at the end.  */
 236   len = strlen (s);
 237   while (len > 0 && ascii_isspace (s[len-1]))
 238     len--;
 239
 240   if (len == 0)
 241     {
 242       /* Blank lines encode newlines.  */
 243       len = 1;
 244       s = "\n";
 245       *swallow_ws = 1;
 246     }
 247   else
 248     *swallow_ws = 0;
 249
 250   if (start)
 251     *start = s;
 252
 253   return len;
 254 }
 255
 256
 257 /* Makes sure that ENTRY has a VALUE.  */
 258 static gpg_error_t
 259 assert_value (pke_t entry)
 260 {
 261   size_t len;
 262   int swallow_ws;
 263   strlist_t s;
 264   char *p;
 265
 266   if (entry->value)
 267     return 0;
 268
 269   len = 0;
 270   swallow_ws = 0;
 271   for (s = entry->raw_value; s; s = s->next)
 272     len += continuation_length (s->d, &swallow_ws, NULL);
 273
 274   /* Add one for the terminating zero.  */
 275   len += 1;
 276
 277   entry->value = p = xtrymalloc (len);
 278   if (entry->value == NULL)
 279     return my_error_from_syserror ();
 280
 281   swallow_ws = 0;
 282   for (s = entry->raw_value; s; s = s->next)
 283     {
 284       const char *start;
 285       size_t l = continuation_length (s->d, &swallow_ws, &start);
 286
 287       memcpy (p, start, l);
 288       p += l;
 289     }
 290
 291   *p++ = 0;
 292   assert (p - entry->value == len);
 293
 294   return 0;
 295 }
 296
 297
 298 /* Get the name.  */
 299 char *
 300 pke_name (pke_t pke)
 301 {
 302   return pke->name;
 303 }
 304
 305
 306 /* Get the value.  */
 307 char *
 308 pke_value (pke_t pke)
 309 {
 310   if (assert_value (pke))
 311     return NULL;
 312   return pke->value;
 313 }
 314
 315 \f
 316
 317 /* Adding and modifying values.  */
 318
 319 /* Add (NAME, VALUE, RAW_VALUE) to PK.  NAME may be NULL for comments
 320    and blank lines.  At least one of VALUE and RAW_VALUE must be
 321    given.  If PRESERVE_ORDER is not given, entries with the same name
 322    are grouped.  NAME, VALUE and RAW_VALUE is consumed.  */
 323 static gpg_error_t
 324 _pkc_add (pkc_t pk, char *name, char *value, strlist_t raw_value,
 325           int preserve_order)
 326 {
 327   gpg_error_t err = 0;
 328   pke_t e;
 329
 330   assert (value || raw_value);
 331
 332   if (name && ! valid_name (name))
 333     {
 334       err = gpg_error (GPG_ERR_INV_NAME);
 335       goto leave;
 336     }
 337
 338   if (name && ascii_strcasecmp (name, "Key:") == 0 && pkc_lookup (pk, "Key:"))
 339     {
 340       err = gpg_error (GPG_ERR_INV_NAME);
 341       goto leave;
 342     }
 343
 344   e = xtrycalloc (1, sizeof *e);
 345   if (e == NULL)
 346     {
 347       err = my_error_from_syserror ();
 348       goto leave;
 349     }
 350
 351   e->name = name;
 352   e->value = value;
 353   e->raw_value = raw_value;
 354
 355   if (pk->first)
 356     {
 357       pke_t last;
 358
 359       if (preserve_order || name == NULL)
 360         last = pk->last;
 361       else
 362         {
 363           /* See if there is already an entry with NAME.  */
 364           last = pkc_lookup (pk, name);
 365
 366           /* If so, find the last in that block.  */
 367           if (last)
 368             {
 369               while (last->next)
 370                 {
 371                   pke_t next = last->next;
 372
 373                   if (next->name && ascii_strcasecmp (next->name, name) == 0)
 374                     last = next;
 375                   else
 376                     break;
 377                 }
 378             }
 379           else /* Otherwise, just find the last entry.  */
 380             last = pk->last;
 381         }
 382
 383       if (last->next)
 384         {
 385           e->prev = last;
 386           e->next = last->next;
 387           last->next = e;
 388           e->next->prev = e;
 389         }
 390       else
 391         {
 392           e->prev = last;
 393           last->next = e;
 394           pk->last = e;
 395         }
 396     }
 397   else
 398     pk->first = pk->last = e;
 399
 400  leave:
 401   if (err)
 402     {
 403       xfree (name);
 404       if (value)
 405         wipememory (value, strlen (value));
 406       xfree (value);
 407       free_strlist_wipe (raw_value);
 408     }
 409
 410   return err;
 411 }
 412
 413
 414 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
 415    is not updated but the new entry is appended.  */
 416 gpg_error_t
 417 pkc_add (pkc_t pk, const char *name, const char *value)
 418 {
 419   char *k, *v;
 420
 421   k = xtrystrdup (name);
 422   if (k == NULL)
 423     return my_error_from_syserror ();
 424
 425   v = xtrystrdup (value);
 426   if (v == NULL)
 427     {
 428       xfree (k);
 429       return my_error_from_syserror ();
 430     }
 431
 432   return _pkc_add (pk, k, v, NULL, 0);
 433 }
 434
 435
 436 /* Add (NAME, VALUE) to PK.  If an entry with NAME already exists, it
 437    is updated with VALUE.  If multiple entries with NAME exist, the
 438    first entry is updated.  */
 439 gpg_error_t
 440 pkc_set (pkc_t pk, const char *name, const char *value)
 441 {
 442   pke_t e;
 443
 444   if (! valid_name (name))
 445     return GPG_ERR_INV_NAME;
 446
 447   e = pkc_lookup (pk, name);
 448   if (e)
 449     {
 450       char *v;
 451
 452       v = xtrystrdup (value);
 453       if (v == NULL)
 454         return my_error_from_syserror ();
 455
 456       free_strlist_wipe (e->raw_value);
 457       e->raw_value = NULL;
 458       if (e->value)
 459         wipememory (e->value, strlen (e->value));
 460       xfree (e->value);
 461       e->value = v;
 462
 463       return 0;
 464     }
 465   else
 466     return pkc_add (pk, name, value);
 467 }
 468
 469
 470 /* Delete the given entry from PK.  */
 471 void
 472 pkc_delete (pkc_t pk, pke_t entry)
 473 {
 474   if (entry->prev)
 475     entry->prev->next = entry->next;
 476   else
 477     pk->first = entry->next;
 478
 479   if (entry->next)
 480     entry->next->prev = entry->prev;
 481   else
 482     pk->last = entry->prev;
 483
 484   pke_release (entry);
 485 }
 486
 487 \f
 488
 489 /* Lookup and iteration.  */
 490
 491 /* Get the first non-comment entry.  */
 492 pke_t
 493 pkc_first (pkc_t pk)
 494 {
 495   pke_t entry;
 496   for (entry = pk->first; entry; entry = entry->next)
 497     if (entry->name)
 498       return entry;
 499   return NULL;
 500 }
 501
 502
 503 /* Get the first entry with the given name.  */
 504 pke_t
 505 pkc_lookup (pkc_t pk, const char *name)
 506 {
 507   pke_t entry;
 508   for (entry = pk->first; entry; entry = entry->next)
 509     if (entry->name && ascii_strcasecmp (entry->name, name) == 0)
 510       return entry;
 511   return NULL;
 512 }
 513
 514
 515 /* Get the next non-comment entry.  */
 516 pke_t
 517 pke_next (pke_t entry)
 518 {
 519   for (entry = entry->next; entry; entry = entry->next)
 520     if (entry->name)
 521       return entry;
 522   return NULL;
 523 }
 524
 525
 526 /* Get the next entry with the given name.  */
 527 pke_t
 528 pke_next_value (pke_t entry, const char *name)
 529 {
 530   for (entry = entry->next; entry; entry = entry->next)
 531     if (entry->name && ascii_strcasecmp (entry->name, name) == 0)
 532       return entry;
 533   return NULL;
 534 }
 535
 536 \f
 537
 538 /* Private key handling.  */
 539
 540 /* Get the private key.  */
 541 gpg_error_t
 542 pkc_get_private_key (pkc_t pk, gcry_sexp_t *retsexp)
 543 {
 544   gpg_error_t err;
 545   pke_t e;
 546
 547   e = pkc_lookup (pk, "Key:");
 548   if (e == NULL)
 549     return gpg_error (GPG_ERR_MISSING_KEY);
 550
 551   err = assert_value (e);
 552   if (err)
 553     return err;
 554
 555   return gcry_sexp_sscan (retsexp, NULL, e->value, strlen (e->value));
 556 }
 557
 558
 559 /* Set the private key.  */
 560 gpg_error_t
 561 pkc_set_private_key (pkc_t pk, gcry_sexp_t sexp)
 562 {
 563   gpg_error_t err;
 564   char *raw, *clean, *p;
 565   size_t len, i;
 566
 567   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
 568
 569   raw = xtrymalloc (len);
 570   if (raw == NULL)
 571     return my_error_from_syserror ();
 572
 573   clean = xtrymalloc (len);
 574   if (clean == NULL)
 575     {
 576       xfree (raw);
 577       return my_error_from_syserror ();
 578     }
 579
 580   gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, raw, len);
 581
 582   /* Strip any whitespace at the end.  */
 583   i = strlen (raw) - 1;
 584   while (i && ascii_isspace (raw[i]))
 585     {
 586       raw[i] = 0;
 587       i--;
 588     }
 589
 590   /* Replace any newlines with spaces, remove superfluous whitespace.  */
 591   len = strlen (raw);
 592   for (p = clean, i = 0; i < len; i++)
 593     {
 594       char c = raw[i];
 595
 596       /* Collapse contiguous and superfluous spaces.  */
 597       if (ascii_isspace (c) && i > 0
 598           && (ascii_isspace (raw[i-1]) || raw[i-1] == '(' || raw[i-1] == ')'))
 599         continue;
 600
 601       if (c == '\n')
 602         c = ' ';
 603
 604       *p++ = c;
 605     }
 606   *p = 0;
 607
 608   err = pkc_set (pk, "Key:", clean);
 609   xfree (raw);
 610   xfree (clean);
 611   return err;
 612 }
 613
 614 \f
 615
 616 /* Parsing and serialization.  */
 617
 618 /* Parse STREAM and return a newly allocated private key container
 619    structure in RESULT.  If ERRLINEP is given, the line number the
 620    parser was last considering is stored there.  */
 621 gpg_error_t
 622 pkc_parse (pkc_t *result, int *errlinep, estream_t stream)
 623 {
 624   gpg_error_t err = 0;
 625   gpgrt_ssize_t len;
 626   char *buf = NULL;
 627   size_t buf_len = 0;
 628   char *name = NULL;
 629   strlist_t raw_value = NULL;
 630
 631
 632   *result = pkc_new ();
 633   if (*result == NULL)
 634     return my_error_from_syserror ();
 635
 636   if (errlinep)
 637     *errlinep = 0;
 638   while ((len = es_read_line (stream, &buf, &buf_len, NULL)))
 639     {
 640       char *p;
 641       if (errlinep)
 642         *errlinep += 1;
 643
 644       /* Skip any whitespace.  */
 645       for (p = buf; *p && ascii_isspace (*p); p++)
 646         /* Do nothing.  */;
 647
 648       if (name && (spacep (buf) || *p == 0))
 649         {
 650           /* A continuation.  */
 651           if (append_to_strlist_try (&raw_value, buf) == NULL)
 652             {
 653               err = my_error_from_syserror ();
 654               goto leave;
 655             }
 656           continue;
 657         }
 658
 659       /* No continuation.  Add the current entry if any.  */
 660       if (raw_value)
 661         {
 662           err = _pkc_add (*result, name, NULL, raw_value, 1);
 663           if (err)
 664             goto leave;
 665         }
 666
 667       /* And prepare for the next one.  */
 668       name = NULL;
 669       raw_value = NULL;
 670
 671       if (*p != 0 && *p != '#')
 672         {
 673           char *colon, *value, tmp;
 674
 675           colon = strchr (buf, ':');
 676           if (colon == NULL)
 677             {
 678               err = gpg_error (GPG_ERR_INV_VALUE);
 679               goto leave;
 680             }
 681
 682           value = colon + 1;
 683           tmp = *value;
 684           *value = 0;
 685           name = xtrystrdup (p);
 686           *value = tmp;
 687
 688           if (name == NULL)
 689             {
 690               err = my_error_from_syserror ();
 691               goto leave;
 692             }
 693
 694           if (append_to_strlist_try (&raw_value, value) == NULL)
 695             {
 696               err = my_error_from_syserror ();
 697               goto leave;
 698             }
 699           continue;
 700         }
 701
 702       if (append_to_strlist_try (&raw_value, buf) == NULL)
 703         {
 704           err = my_error_from_syserror ();
 705           goto leave;
 706         }
 707     }
 708
 709   /* Add the final entry.  */
 710   if (raw_value)
 711     err = _pkc_add (*result, name, NULL, raw_value, 1);
 712
 713  leave:
 714   gpgrt_free (buf);
 715   if (err)
 716     {
 717       pkc_release (*result);
 718       *result = NULL;
 719     }
 720
 721   return err;
 722 }
 723
 724
 725 /* Write a representation of PK to STREAM.  */
 726 gpg_error_t
 727 pkc_write (pkc_t pk, estream_t stream)
 728 {
 729   gpg_error_t err;
 730   pke_t entry;
 731   strlist_t s;
 732
 733   for (entry = pk->first; entry; entry = entry->next)
 734     {
 735       if (entry->name)
 736         es_fputs (entry->name, stream);
 737
 738       err = assert_raw_value (entry);
 739       if (err)
 740         return err;
 741
 742       for (s = entry->raw_value; s; s = s->next)
 743         es_fputs (s->d, stream);
 744
 745       if (es_ferror (stream))
 746         return my_error_from_syserror ();
 747     }
 748
 749   return 0;
 750 }