2010-06-09 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / src / key.c
1 /* key.c - Key objects.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004 g10 Code GmbH
4
5    This file is part of GPGME.
6  
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11    
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 #if HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <errno.h>
29
30 #include "util.h"
31 #include "ops.h"
32 #include "sema.h"
33
34 \f
35 /* Protects all reference counters in keys.  All other accesses to a
36    key are read only.  */
37 DEFINE_STATIC_LOCK (key_ref_lock);
38
39
40 /* Create a new key.  */
41 gpgme_error_t
42 _gpgme_key_new (gpgme_key_t *r_key)
43 {
44   gpgme_key_t key;
45
46   key = calloc (1, sizeof *key);
47   if (!key)
48     return gpg_error_from_errno (errno);
49   key->_refs = 1;
50
51   *r_key = key;
52   return 0;
53 }
54
55
56 gpgme_error_t
57 _gpgme_key_add_subkey (gpgme_key_t key, gpgme_subkey_t *r_subkey)
58 {
59   gpgme_subkey_t subkey;
60
61   subkey = calloc (1, sizeof *subkey);
62   if (!subkey)
63     return gpg_error_from_errno (errno);
64   subkey->keyid = subkey->_keyid;
65   subkey->_keyid[16] = '\0';
66
67   if (!key->subkeys)
68     key->subkeys = subkey;
69   if (key->_last_subkey)
70     key->_last_subkey->next = subkey;
71   key->_last_subkey = subkey;
72
73   *r_subkey = subkey;
74   return 0;
75 }
76
77
78 static char *
79 set_user_id_part (char *tail, const char *buf, size_t len)
80 {
81   while (len && (buf[len - 1] == ' ' || buf[len - 1] == '\t')) 
82     len--;
83   for (; len; len--)
84     *tail++ = *buf++;
85   *tail++ = 0;
86   return tail;
87 }
88
89
90 static void
91 parse_user_id (char *src, char **name, char **email,
92                char **comment, char *tail)
93 {
94   const char *start = NULL;
95   int in_name = 0;
96   int in_email = 0;
97   int in_comment = 0;
98
99   while (*src)
100     {
101       if (in_email)
102         {
103           if (*src == '<')
104             /* Not legal but anyway.  */
105             in_email++;
106           else if (*src == '>')
107             {
108               if (!--in_email && !*email)
109                 {
110                   *email = tail;
111                   tail = set_user_id_part (tail, start, src - start);
112                 }
113             }
114         }
115       else if (in_comment)
116         {
117           if (*src == '(')
118             in_comment++;
119           else if (*src == ')')
120             {
121               if (!--in_comment && !*comment)
122                 {
123                   *comment = tail;
124                   tail = set_user_id_part (tail, start, src - start);
125                 }
126             }
127         }
128       else if (*src == '<')
129         {
130           if (in_name)
131             {
132               if (!*name)
133                 {
134                   *name = tail;
135                   tail = set_user_id_part (tail, start, src - start);
136                 }
137               in_name = 0;
138             }
139           in_email = 1;
140           start = src + 1;
141         }
142       else if (*src == '(')
143         {
144           if (in_name)
145             {
146               if (!*name)
147                 {
148                   *name = tail;
149                   tail = set_user_id_part (tail, start, src - start);
150                 }
151               in_name = 0;
152             }
153           in_comment = 1;
154           start = src + 1;
155         }
156       else if (!in_name && *src != ' ' && *src != '\t')
157         {
158           in_name = 1;
159           start = src;
160         }    
161       src++;
162     }
163  
164   if (in_name)
165     {
166       if (!*name)
167         {
168           *name = tail;
169           tail = set_user_id_part (tail, start, src - start);
170         }
171     }
172  
173   /* Let unused parts point to an EOS.  */
174   tail--;
175   if (!*name)
176     *name = tail;
177   if (!*email)
178     *email = tail;
179   if (!*comment)
180     *comment = tail;
181 }
182
183
184 static void
185 parse_x509_user_id (char *src, char **name, char **email,
186                     char **comment, char *tail)
187 {
188   if (*src == '<' && src[strlen (src) - 1] == '>')
189     *email = src;
190   
191   /* Let unused parts point to an EOS.  */
192   tail--;
193   if (!*name)
194     *name = tail;
195   if (!*email)
196     *email = tail;
197   if (!*comment)
198     *comment = tail;
199 }
200
201
202 /* Take a name from the --with-colon listing, remove certain escape
203    sequences sequences and put it into the list of UIDs.  */
204 gpgme_error_t
205 _gpgme_key_append_name (gpgme_key_t key, const char *src, int convert)
206 {
207   gpgme_user_id_t uid;
208   char *dst;
209   int src_len = strlen (src);
210
211   assert (key);
212   /* We can malloc a buffer of the same length, because the converted
213      string will never be larger. Actually we allocate it twice the
214      size, so that we are able to store the parsed stuff there too.  */
215   uid = malloc (sizeof (*uid) + 2 * src_len + 3);
216   if (!uid)
217     return gpg_error_from_errno (errno);
218   memset (uid, 0, sizeof *uid);
219
220   uid->uid = ((char *) uid) + sizeof (*uid);
221   dst = uid->uid;
222   if (convert)
223     _gpgme_decode_c_string (src, &dst, src_len + 1);
224   else
225     memcpy (dst, src, src_len + 1);
226
227   dst += strlen (dst) + 1;
228   if (key->protocol == GPGME_PROTOCOL_CMS)
229     parse_x509_user_id (uid->uid, &uid->name, &uid->email,
230                         &uid->comment, dst);
231   else
232     parse_user_id (uid->uid, &uid->name, &uid->email,
233                    &uid->comment, dst);
234
235   if (!key->uids)
236     key->uids = uid;
237   if (key->_last_uid)
238     key->_last_uid->next = uid;
239   key->_last_uid = uid;
240
241   return 0;
242 }
243
244
245 gpgme_key_sig_t
246 _gpgme_key_add_sig (gpgme_key_t key, char *src)
247 {
248   int src_len = src ? strlen (src) : 0;
249   gpgme_user_id_t uid;
250   gpgme_key_sig_t sig;
251
252   assert (key); /* XXX */
253
254   uid = key->_last_uid;
255   assert (uid); /* XXX */
256
257   /* We can malloc a buffer of the same length, because the converted
258      string will never be larger.  Actually we allocate it twice the
259      size, so that we are able to store the parsed stuff there too.  */
260   sig = malloc (sizeof (*sig) + 2 * src_len + 3);
261   if (!sig)
262     return NULL;
263   memset (sig, 0, sizeof *sig);
264
265   sig->keyid = sig->_keyid;
266   sig->_keyid[16] = '\0';
267   sig->uid = ((char *) sig) + sizeof (*sig);
268
269   if (src)
270     {
271       char *dst = sig->uid;
272       _gpgme_decode_c_string (src, &dst, src_len + 1);
273       dst += strlen (dst) + 1;
274       if (key->protocol == GPGME_PROTOCOL_CMS)
275         parse_x509_user_id (sig->uid, &sig->name, &sig->email,
276                             &sig->comment, dst);
277       else
278         parse_user_id (sig->uid, &sig->name, &sig->email,
279                        &sig->comment, dst);
280     }
281   else
282     sig->uid = '\0';
283
284   if (!uid->signatures)
285     uid->signatures = sig;
286   if (uid->_last_keysig)
287     uid->_last_keysig->next = sig;
288   uid->_last_keysig = sig;
289
290   return sig;
291 }
292
293 \f
294 /* Acquire a reference to KEY.  */
295 void
296 gpgme_key_ref (gpgme_key_t key)
297 {
298   LOCK (key_ref_lock);
299   key->_refs++;
300   UNLOCK (key_ref_lock);
301 }
302
303
304 /* gpgme_key_unref releases the key object.  Note, that this function
305    may not do an actual release if there are other shallow copies of
306    the objects.  You have to call this function for every newly
307    created key object as well as for every gpgme_key_ref() done on the
308    key object.  */
309 void
310 gpgme_key_unref (gpgme_key_t key)
311 {
312   gpgme_user_id_t uid;
313   gpgme_subkey_t subkey;
314
315   if (!key)
316     return;
317
318   LOCK (key_ref_lock);
319   assert (key->_refs > 0);
320   if (--key->_refs)
321     {
322       UNLOCK (key_ref_lock);
323       return;
324     }
325   UNLOCK (key_ref_lock);
326
327   subkey = key->subkeys;
328   while (subkey)
329     {
330       gpgme_subkey_t next = subkey->next;
331       if (subkey->fpr)
332         free (subkey->fpr);
333       if (subkey->card_number)
334         free (subkey->card_number);
335       free (subkey);
336       subkey = next;
337     }
338
339   uid = key->uids;
340   while (uid)
341     {
342       gpgme_user_id_t next_uid = uid->next;
343       gpgme_key_sig_t keysig = uid->signatures;
344
345       while (keysig)
346         {
347           gpgme_key_sig_t next_keysig = keysig->next;
348           gpgme_sig_notation_t notation = keysig->notations;
349
350           while (notation)
351             {
352               gpgme_sig_notation_t next_notation = notation->next;
353
354               _gpgme_sig_notation_free (notation);
355               notation = next_notation;
356             }
357
358           free (keysig);
359           keysig = next_keysig;
360         }
361       free (uid);
362       uid = next_uid;
363     }
364   
365   if (key->issuer_serial)
366     free (key->issuer_serial);
367   if (key->issuer_name)
368     free (key->issuer_name);
369
370   if (key->chain_id)
371     free (key->chain_id);
372
373   free (key);
374 }
375
376 \f
377 /* Support functions.  */
378
379 /* Create a dummy key to specify an email address.  */
380 gpgme_error_t
381 gpgme_key_from_uid (gpgme_key_t *r_key, const char *name)
382 {
383   gpgme_error_t err;
384   gpgme_key_t key;
385
386   *r_key = NULL;
387   err = _gpgme_key_new (&key);
388   if (err)
389     return err;
390
391   /* Note: protocol doesn't matter if only email is provided.  */
392   err = _gpgme_key_append_name (key, name, 0);
393   if (err)
394     gpgme_key_unref (key);
395   else
396     *r_key = key;
397
398   return err;
399 }
400
401
402 \f
403 /* Compatibility interfaces.  */
404
405 void
406 gpgme_key_release (gpgme_key_t key)
407 {
408   gpgme_key_unref (key);
409 }
410
411
412 static const char *
413 otrust_to_string (int otrust)
414 {
415   switch (otrust)
416     {
417     case GPGME_VALIDITY_NEVER:
418       return "n";
419
420     case GPGME_VALIDITY_MARGINAL:
421       return "m";
422
423     case GPGME_VALIDITY_FULL:
424       return "f";
425
426     case GPGME_VALIDITY_ULTIMATE:
427       return "u";
428
429     default:
430       return "?";
431     }
432 }
433
434
435 static const char *
436 validity_to_string (int validity)
437 {
438   switch (validity)
439     {
440     case GPGME_VALIDITY_UNDEFINED:
441       return "q";
442
443     case GPGME_VALIDITY_NEVER:
444       return "n";
445
446     case GPGME_VALIDITY_MARGINAL:
447       return "m";
448
449     case GPGME_VALIDITY_FULL:
450       return "f";
451
452     case GPGME_VALIDITY_ULTIMATE:
453       return "u";
454
455     case GPGME_VALIDITY_UNKNOWN:
456     default:
457       return "?";
458     }
459 }
460
461
462 static const char *
463 capabilities_to_string (gpgme_subkey_t subkey)
464 {
465   static const char *const strings[8] =
466     {
467       "",
468       "c",
469       "s",
470       "sc",
471       "e",
472       "ec",
473       "es",
474       "esc"
475     };
476   return strings[(!!subkey->can_encrypt << 2)
477                  | (!!subkey->can_sign << 1)
478                  | (!!subkey->can_certify)];
479 }
480
481
482 /* Return the value of the attribute WHAT of ITEM, which has to be
483    representable by a string.  */
484 const char *
485 gpgme_key_get_string_attr (gpgme_key_t key, _gpgme_attr_t what,
486                            const void *reserved, int idx)
487 {
488   gpgme_subkey_t subkey;
489   gpgme_user_id_t uid;
490   int i;
491
492   if (!key || reserved || idx < 0)
493     return NULL;
494
495   /* Select IDXth subkey.  */
496   subkey = key->subkeys;
497   for (i = 0; i < idx; i++)
498     {
499       subkey = subkey->next;
500       if (!subkey)
501         break;
502     }
503
504   /* Select the IDXth user ID.  */
505   uid = key->uids;
506   for (i = 0; i < idx; i++)
507     {
508       uid = uid->next;
509       if (!uid)
510         break;
511     }
512
513   switch (what)
514     {
515     case GPGME_ATTR_KEYID:
516       return subkey ? subkey->keyid : NULL;
517
518     case GPGME_ATTR_FPR:
519       return subkey ? subkey->fpr : NULL;
520
521     case GPGME_ATTR_ALGO:    
522       return subkey ? gpgme_pubkey_algo_name (subkey->pubkey_algo) : NULL;
523
524     case GPGME_ATTR_TYPE:
525       return key->protocol == GPGME_PROTOCOL_CMS ? "X.509" : "PGP";
526
527     case GPGME_ATTR_OTRUST:
528       return otrust_to_string (key->owner_trust);
529
530     case GPGME_ATTR_USERID:  
531       return uid ? uid->uid : NULL;
532
533     case GPGME_ATTR_NAME:   
534       return uid ? uid->name : NULL;
535
536     case GPGME_ATTR_EMAIL:
537       return uid ? uid->email : NULL;
538
539     case GPGME_ATTR_COMMENT:
540       return uid ? uid->comment : NULL;
541
542     case GPGME_ATTR_VALIDITY:
543       return uid ? validity_to_string (uid->validity) : NULL;
544
545     case GPGME_ATTR_KEY_CAPS:    
546       return subkey ? capabilities_to_string (subkey) : NULL;
547
548     case GPGME_ATTR_SERIAL:
549       return key->issuer_serial;
550
551     case GPGME_ATTR_ISSUER:
552       return idx ? NULL : key->issuer_name;
553
554     case GPGME_ATTR_CHAINID:
555       return key->chain_id;
556
557     default:
558       return NULL;
559     }
560 }
561
562
563 unsigned long
564 gpgme_key_get_ulong_attr (gpgme_key_t key, _gpgme_attr_t what,
565                           const void *reserved, int idx)
566 {
567   gpgme_subkey_t subkey;
568   gpgme_user_id_t uid;
569   int i;
570
571   if (!key || reserved || idx < 0)
572     return 0;
573
574   /* Select IDXth subkey.  */
575   subkey = key->subkeys;
576   for (i = 0; i < idx; i++)
577     {
578       subkey = subkey->next;
579       if (!subkey)
580         break;
581     }
582
583   /* Select the IDXth user ID.  */
584   uid = key->uids;
585   for (i = 0; i < idx; i++)
586     {
587       uid = uid->next;
588       if (!uid)
589         break;
590     }
591
592   switch (what)
593     {
594     case GPGME_ATTR_ALGO:
595       return subkey ? (unsigned long) subkey->pubkey_algo : 0;
596
597     case GPGME_ATTR_LEN:
598       return subkey ? (unsigned long) subkey->length : 0;
599
600     case GPGME_ATTR_TYPE:
601       return key->protocol == GPGME_PROTOCOL_CMS ? 1 : 0;
602
603     case GPGME_ATTR_CREATED:
604       return (subkey && subkey->timestamp >= 0)
605         ? (unsigned long) subkey->timestamp : 0;
606
607     case GPGME_ATTR_EXPIRE: 
608       return (subkey && subkey->expires >= 0)
609         ? (unsigned long) subkey->expires : 0;
610
611     case GPGME_ATTR_VALIDITY:
612       return uid ? uid->validity : 0;
613
614     case GPGME_ATTR_OTRUST:
615       return key->owner_trust;
616
617     case GPGME_ATTR_IS_SECRET:
618       return !!key->secret;
619
620     case GPGME_ATTR_KEY_REVOKED:
621       return subkey ? subkey->revoked : 0;
622
623     case GPGME_ATTR_KEY_INVALID:
624       return subkey ? subkey->invalid : 0;
625
626     case GPGME_ATTR_KEY_EXPIRED:
627       return subkey ? subkey->expired : 0;
628
629     case GPGME_ATTR_KEY_DISABLED:
630       return subkey ? subkey->disabled : 0;
631
632     case GPGME_ATTR_UID_REVOKED:
633       return uid ? uid->revoked : 0;
634
635     case GPGME_ATTR_UID_INVALID:
636       return uid ? uid->invalid : 0;
637
638     case GPGME_ATTR_CAN_ENCRYPT:
639       return key->can_encrypt;
640
641     case GPGME_ATTR_CAN_SIGN:
642       return key->can_sign;
643
644     case GPGME_ATTR_CAN_CERTIFY:
645       return key->can_certify;
646
647     default:
648       return 0;
649     }
650 }
651
652
653 static gpgme_key_sig_t
654 get_keysig (gpgme_key_t key, int uid_idx, int idx)
655 {
656   gpgme_user_id_t uid;
657   gpgme_key_sig_t sig;
658
659   if (!key || uid_idx < 0 || idx < 0)
660     return NULL;
661
662   uid = key->uids;
663   while (uid && uid_idx > 0)
664     {
665       uid = uid->next;
666       uid_idx--;
667     }
668   if (!uid)
669     return NULL;
670
671   sig = uid->signatures;
672   while (sig && idx > 0)
673     {
674       sig = sig->next;
675       idx--;
676     }
677   return sig;
678 }
679
680
681 const char *
682 gpgme_key_sig_get_string_attr (gpgme_key_t key, int uid_idx,
683                                _gpgme_attr_t what,
684                                const void *reserved, int idx)
685 {
686   gpgme_key_sig_t certsig = get_keysig (key, uid_idx, idx);
687
688   if (!certsig || reserved)
689     return NULL;
690
691   switch (what)
692     {
693     case GPGME_ATTR_KEYID:
694       return certsig->keyid;
695
696     case GPGME_ATTR_ALGO:    
697       return gpgme_pubkey_algo_name (certsig->pubkey_algo);
698
699     case GPGME_ATTR_USERID:
700       return certsig->uid;
701
702     case GPGME_ATTR_NAME:   
703       return certsig->name;
704
705     case GPGME_ATTR_EMAIL:
706       return certsig->email;
707
708     case GPGME_ATTR_COMMENT:
709       return certsig->comment;
710    
711     default:
712       return NULL;
713     }
714 }
715
716
717 unsigned long
718 gpgme_key_sig_get_ulong_attr (gpgme_key_t key, int uid_idx, _gpgme_attr_t what,
719                               const void *reserved, int idx)
720 {
721   gpgme_key_sig_t certsig = get_keysig (key, uid_idx, idx);
722
723   if (!certsig || reserved)
724     return 0;
725
726   switch (what)
727     {
728     case GPGME_ATTR_ALGO:    
729       return (unsigned long) certsig->pubkey_algo;
730
731     case GPGME_ATTR_CREATED: 
732       return certsig->timestamp < 0 ? 0L : (unsigned long) certsig->timestamp;
733
734     case GPGME_ATTR_EXPIRE: 
735       return certsig->expires < 0 ? 0L : (unsigned long) certsig->expires;
736
737     case GPGME_ATTR_KEY_REVOKED:
738       return certsig->revoked;
739
740     case GPGME_ATTR_KEY_INVALID:
741       return certsig->invalid;
742
743     case GPGME_ATTR_KEY_EXPIRED:
744       return certsig->expired;
745
746     case GPGME_ATTR_SIG_CLASS:
747       return certsig->sig_class;
748
749     case GPGME_ATTR_SIG_STATUS:
750       return certsig->status;
751
752     default:
753       return 0;
754     }
755 }