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