common: Change simple_query to ignore status messages.
[gnupg.git] / kbx / keybox-search.c
1 /* keybox-search.c - Search operations
2  * Copyright (C) 2001, 2002, 2003, 2004, 2012,
3  *               2013 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 <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <errno.h>
27
28 #include "keybox-defs.h"
29 #include <gcrypt.h>
30 #include "host2net.h"
31 #include "mbox-util.h"
32
33 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
34                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
35 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
36
37
38 struct sn_array_s {
39     int snlen;
40     unsigned char *sn;
41 };
42
43
44 #define get32(a) buf32_to_ulong ((a))
45 #define get16(a) buf16_to_ulong ((a))
46
47
48 static inline unsigned int
49 blob_get_blob_flags (KEYBOXBLOB blob)
50 {
51   const unsigned char *buffer;
52   size_t length;
53
54   buffer = _keybox_get_blob_image (blob, &length);
55   if (length < 8)
56     return 0; /* oops */
57
58   return get16 (buffer + 6);
59 }
60
61
62 /* Return the first keyid from the blob.  Returns true if
63    available.  */
64 static int
65 blob_get_first_keyid (KEYBOXBLOB blob, u32 *kid)
66 {
67   const unsigned char *buffer;
68   size_t length, nkeys, keyinfolen;
69
70   buffer = _keybox_get_blob_image (blob, &length);
71   if (length < 48)
72     return 0; /* blob too short */
73
74   nkeys = get16 (buffer + 16);
75   keyinfolen = get16 (buffer + 18);
76   if (!nkeys || keyinfolen < 28)
77     return 0; /* invalid blob */
78
79   kid[0] = get32 (buffer + 32);
80   kid[1] = get32 (buffer + 36);
81
82   return 1;
83 }
84
85
86 /* Return information on the flag WHAT within the blob BUFFER,LENGTH.
87    Return the offset and the length (in bytes) of the flag in
88    FLAGOFF,FLAG_SIZE. */
89 gpg_err_code_t
90 _keybox_get_flag_location (const unsigned char *buffer, size_t length,
91                            int what, size_t *flag_off, size_t *flag_size)
92 {
93   size_t pos;
94   size_t nkeys, keyinfolen;
95   size_t nuids, uidinfolen;
96   size_t nserial;
97   size_t nsigs, siginfolen, siginfooff;
98
99   switch (what)
100     {
101     case KEYBOX_FLAG_BLOB:
102       if (length < 8)
103         return GPG_ERR_INV_OBJ;
104       *flag_off = 6;
105       *flag_size = 2;
106       break;
107
108     case KEYBOX_FLAG_OWNERTRUST:
109     case KEYBOX_FLAG_VALIDITY:
110     case KEYBOX_FLAG_CREATED_AT:
111     case KEYBOX_FLAG_SIG_INFO:
112       if (length < 20)
113         return GPG_ERR_INV_OBJ;
114       /* Key info. */
115       nkeys = get16 (buffer + 16);
116       keyinfolen = get16 (buffer + 18 );
117       if (keyinfolen < 28)
118         return GPG_ERR_INV_OBJ;
119       pos = 20 + keyinfolen*nkeys;
120       if (pos+2 > length)
121         return GPG_ERR_INV_OBJ; /* Out of bounds. */
122       /* Serial number. */
123       nserial = get16 (buffer+pos);
124       pos += 2 + nserial;
125       if (pos+4 > length)
126         return GPG_ERR_INV_OBJ; /* Out of bounds. */
127       /* User IDs. */
128       nuids = get16 (buffer + pos); pos += 2;
129       uidinfolen = get16 (buffer + pos); pos += 2;
130       if (uidinfolen < 12 )
131         return GPG_ERR_INV_OBJ;
132       pos += uidinfolen*nuids;
133       if (pos+4 > length)
134         return GPG_ERR_INV_OBJ ; /* Out of bounds. */
135       /* Signature info. */
136       siginfooff = pos;
137       nsigs = get16 (buffer + pos); pos += 2;
138       siginfolen = get16 (buffer + pos); pos += 2;
139       if (siginfolen < 4 )
140         return GPG_ERR_INV_OBJ;
141       pos += siginfolen*nsigs;
142       if (pos+1+1+2+4+4+4+4 > length)
143         return GPG_ERR_INV_OBJ ; /* Out of bounds. */
144       *flag_size = 1;
145       *flag_off = pos;
146       switch (what)
147         {
148         case KEYBOX_FLAG_VALIDITY:
149           *flag_off += 1;
150           break;
151         case KEYBOX_FLAG_CREATED_AT:
152           *flag_size = 4;
153           *flag_off += 1+2+4+4+4;
154           break;
155         case KEYBOX_FLAG_SIG_INFO:
156           *flag_size = siginfolen * nsigs;
157           *flag_off = siginfooff;
158           break;
159         default:
160           break;
161         }
162       break;
163
164     default:
165       return GPG_ERR_INV_FLAG;
166     }
167   return 0;
168 }
169
170
171
172 /* Return one of the flags WHAT in VALUE from the blob BUFFER of
173    LENGTH bytes.  Return 0 on success or an raw error code. */
174 static gpg_err_code_t
175 get_flag_from_image (const unsigned char *buffer, size_t length,
176                      int what, unsigned int *value)
177 {
178   gpg_err_code_t ec;
179   size_t pos, size;
180
181   *value = 0;
182   ec = _keybox_get_flag_location (buffer, length, what, &pos, &size);
183   if (!ec)
184     switch (size)
185       {
186       case 1: *value = buffer[pos]; break;
187       case 2: *value = get16 (buffer + pos); break;
188       case 4: *value = get32 (buffer + pos); break;
189       default: ec = GPG_ERR_BUG; break;
190       }
191
192   return ec;
193 }
194
195
196 static int
197 blob_cmp_sn (KEYBOXBLOB blob, const unsigned char *sn, int snlen)
198 {
199   const unsigned char *buffer;
200   size_t length;
201   size_t pos, off;
202   size_t nkeys, keyinfolen;
203   size_t nserial;
204
205   buffer = _keybox_get_blob_image (blob, &length);
206   if (length < 40)
207     return 0; /* blob too short */
208
209   /*keys*/
210   nkeys = get16 (buffer + 16);
211   keyinfolen = get16 (buffer + 18 );
212   if (keyinfolen < 28)
213     return 0; /* invalid blob */
214   pos = 20 + keyinfolen*nkeys;
215   if (pos+2 > length)
216     return 0; /* out of bounds */
217
218   /*serial*/
219   nserial = get16 (buffer+pos);
220   off = pos + 2;
221   if (off+nserial > length)
222     return 0; /* out of bounds */
223
224   return nserial == snlen && !memcmp (buffer+off, sn, snlen);
225 }
226
227
228 /* Returns 0 if not found or the number of the key which was found.
229    For X.509 this is always 1, for OpenPGP this is 1 for the primary
230    key and 2 and more for the subkeys.  */
231 static int
232 blob_cmp_fpr (KEYBOXBLOB blob, const unsigned char *fpr)
233 {
234   const unsigned char *buffer;
235   size_t length;
236   size_t pos, off;
237   size_t nkeys, keyinfolen;
238   int idx;
239
240   buffer = _keybox_get_blob_image (blob, &length);
241   if (length < 40)
242     return 0; /* blob too short */
243
244   /*keys*/
245   nkeys = get16 (buffer + 16);
246   keyinfolen = get16 (buffer + 18 );
247   if (keyinfolen < 28)
248     return 0; /* invalid blob */
249   pos = 20;
250   if (pos + keyinfolen*nkeys > length)
251     return 0; /* out of bounds */
252
253   for (idx=0; idx < nkeys; idx++)
254     {
255       off = pos + idx*keyinfolen;
256       if (!memcmp (buffer + off, fpr, 20))
257         return idx+1; /* found */
258     }
259   return 0; /* not found */
260 }
261
262 static int
263 blob_cmp_fpr_part (KEYBOXBLOB blob, const unsigned char *fpr,
264                    int fproff, int fprlen)
265 {
266   const unsigned char *buffer;
267   size_t length;
268   size_t pos, off;
269   size_t nkeys, keyinfolen;
270   int idx;
271
272   buffer = _keybox_get_blob_image (blob, &length);
273   if (length < 40)
274     return 0; /* blob too short */
275
276   /*keys*/
277   nkeys = get16 (buffer + 16);
278   keyinfolen = get16 (buffer + 18 );
279   if (keyinfolen < 28)
280     return 0; /* invalid blob */
281   pos = 20;
282   if (pos + keyinfolen*nkeys > length)
283     return 0; /* out of bounds */
284
285   for (idx=0; idx < nkeys; idx++)
286     {
287       off = pos + idx*keyinfolen;
288       if (!memcmp (buffer + off + fproff, fpr, fprlen))
289         return idx+1; /* found */
290     }
291   return 0; /* not found */
292 }
293
294
295 static int
296 blob_cmp_name (KEYBOXBLOB blob, int idx,
297                const char *name, size_t namelen, int substr, int x509)
298 {
299   const unsigned char *buffer;
300   size_t length;
301   size_t pos, off, len;
302   size_t nkeys, keyinfolen;
303   size_t nuids, uidinfolen;
304   size_t nserial;
305
306   buffer = _keybox_get_blob_image (blob, &length);
307   if (length < 40)
308     return 0; /* blob too short */
309
310   /*keys*/
311   nkeys = get16 (buffer + 16);
312   keyinfolen = get16 (buffer + 18 );
313   if (keyinfolen < 28)
314     return 0; /* invalid blob */
315   pos = 20 + keyinfolen*nkeys;
316   if (pos+2 > length)
317     return 0; /* out of bounds */
318
319   /*serial*/
320   nserial = get16 (buffer+pos);
321   pos += 2 + nserial;
322   if (pos+4 > length)
323     return 0; /* out of bounds */
324
325   /* user ids*/
326   nuids = get16 (buffer + pos);  pos += 2;
327   uidinfolen = get16 (buffer + pos);  pos += 2;
328   if (uidinfolen < 12 /* should add a: || nuidinfolen > MAX_UIDINFOLEN */)
329     return 0; /* invalid blob */
330   if (pos + uidinfolen*nuids > length)
331     return 0; /* out of bounds */
332
333   if (idx < 0)
334     { /* Compare all names.  Note that for X.509 we start with index 1
335          so to skip the issuer at index 0.  */
336       for (idx = !!x509; idx < nuids; idx++)
337         {
338           size_t mypos = pos;
339
340           mypos += idx*uidinfolen;
341           off = get32 (buffer+mypos);
342           len = get32 (buffer+mypos+4);
343           if (off+len > length)
344             return 0; /* error: better stop here out of bounds */
345           if (len < 1)
346             continue; /* empty name */
347           if (substr)
348             {
349               if (ascii_memcasemem (buffer+off, len, name, namelen))
350                 return idx+1; /* found */
351             }
352           else
353             {
354               if (len == namelen && !memcmp (buffer+off, name, len))
355                 return idx+1; /* found */
356             }
357         }
358     }
359   else
360     {
361       if (idx > nuids)
362         return 0; /* no user ID with that idx */
363       pos += idx*uidinfolen;
364       off = get32 (buffer+pos);
365       len = get32 (buffer+pos+4);
366       if (off+len > length)
367         return 0; /* out of bounds */
368       if (len < 1)
369         return 0; /* empty name */
370
371       if (substr)
372         {
373           if (ascii_memcasemem (buffer+off, len, name, namelen))
374             return idx+1; /* found */
375         }
376       else
377         {
378           if (len == namelen && !memcmp (buffer+off, name, len))
379             return idx+1; /* found */
380         }
381     }
382   return 0; /* not found */
383 }
384
385
386 /* Compare all email addresses of the subject.  With SUBSTR given as
387    True a substring search is done in the mail address.  The X509 flag
388    indicated whether the search is done on an X.509 blob.  */
389 static int
390 blob_cmp_mail (KEYBOXBLOB blob, const char *name, size_t namelen, int substr,
391                int x509)
392 {
393   const unsigned char *buffer;
394   size_t length;
395   size_t pos, off, len;
396   size_t nkeys, keyinfolen;
397   size_t nuids, uidinfolen;
398   size_t nserial;
399   int idx;
400
401   /* fixme: this code is common to blob_cmp_mail */
402   buffer = _keybox_get_blob_image (blob, &length);
403   if (length < 40)
404     return 0; /* blob too short */
405
406   /*keys*/
407   nkeys = get16 (buffer + 16);
408   keyinfolen = get16 (buffer + 18 );
409   if (keyinfolen < 28)
410     return 0; /* invalid blob */
411   pos = 20 + keyinfolen*nkeys;
412   if (pos+2 > length)
413     return 0; /* out of bounds */
414
415   /*serial*/
416   nserial = get16 (buffer+pos);
417   pos += 2 + nserial;
418   if (pos+4 > length)
419     return 0; /* out of bounds */
420
421   /* user ids*/
422   nuids = get16 (buffer + pos);  pos += 2;
423   uidinfolen = get16 (buffer + pos);  pos += 2;
424   if (uidinfolen < 12 /* should add a: || nuidinfolen > MAX_UIDINFOLEN */)
425     return 0; /* invalid blob */
426   if (pos + uidinfolen*nuids > length)
427     return 0; /* out of bounds */
428
429   if (namelen < 1)
430     return 0;
431
432   /* Note that for X.509 we start at index 1 because index 0 is used
433      for the issuer name.  */
434   for (idx=!!x509 ;idx < nuids; idx++)
435     {
436       size_t mypos = pos;
437       size_t mylen;
438
439       mypos += idx*uidinfolen;
440       off = get32 (buffer+mypos);
441       len = get32 (buffer+mypos+4);
442       if (off+len > length)
443         return 0; /* error: better stop here - out of bounds */
444       if (x509)
445         {
446           if (len < 2 || buffer[off] != '<')
447             continue; /* empty name or trailing 0 not stored */
448           len--; /* one back */
449           if ( len < 3 || buffer[off+len] != '>')
450             continue; /* not a proper email address */
451           off++;
452           len--;
453         }
454       else /* OpenPGP.  */
455         {
456           /* We need to forward to the mailbox part.  */
457           mypos = off;
458           mylen = len;
459           for ( ; len && buffer[off] != '<'; len--, off++)
460             ;
461           if (len < 2 || buffer[off] != '<')
462             {
463               /* Mailbox not explicitly given or too short.  Restore
464                  OFF and LEN and check whether the entire string
465                  resembles a mailbox without the angle brackets.  */
466               off = mypos;
467               len = mylen;
468               if (!is_valid_mailbox_mem (buffer+off, len))
469                 continue; /* Not a mail address. */
470             }
471           else /* Seems to be standard user id with mail address.  */
472             {
473               off++; /* Point to first char of the mail address.  */
474               len--;
475               /* Search closing '>'.  */
476               for (mypos=off; len && buffer[mypos] != '>'; len--, mypos++)
477                 ;
478               if (!len || buffer[mypos] != '>' || off == mypos)
479                 continue; /* Not a proper mail address.  */
480               len = mypos - off;
481             }
482
483         }
484
485       if (substr)
486         {
487           if (ascii_memcasemem (buffer+off, len, name, namelen))
488             return idx+1; /* found */
489         }
490       else
491         {
492           if (len == namelen && !ascii_memcasecmp (buffer+off, name, len))
493             return idx+1; /* found */
494         }
495     }
496   return 0; /* not found */
497 }
498
499
500 #ifdef KEYBOX_WITH_X509
501 /* Return true if the key in BLOB matches the 20 bytes keygrip GRIP.
502    We don't have the keygrips as meta data, thus we need to parse the
503    certificate. Fixme: We might want to return proper error codes
504    instead of failing a search for invalid certificates etc.  */
505 static int
506 blob_x509_has_grip (KEYBOXBLOB blob, const unsigned char *grip)
507 {
508   int rc;
509   const unsigned char *buffer;
510   size_t length;
511   size_t cert_off, cert_len;
512   ksba_reader_t reader = NULL;
513   ksba_cert_t cert = NULL;
514   ksba_sexp_t p = NULL;
515   gcry_sexp_t s_pkey;
516   unsigned char array[20];
517   unsigned char *rcp;
518   size_t n;
519
520   buffer = _keybox_get_blob_image (blob, &length);
521   if (length < 40)
522     return 0; /* Too short. */
523   cert_off = get32 (buffer+8);
524   cert_len = get32 (buffer+12);
525   if (cert_off+cert_len > length)
526     return 0; /* Too short.  */
527
528   rc = ksba_reader_new (&reader);
529   if (rc)
530     return 0; /* Problem with ksba. */
531   rc = ksba_reader_set_mem (reader, buffer+cert_off, cert_len);
532   if (rc)
533     goto failed;
534   rc = ksba_cert_new (&cert);
535   if (rc)
536     goto failed;
537   rc = ksba_cert_read_der (cert, reader);
538   if (rc)
539     goto failed;
540   p = ksba_cert_get_public_key (cert);
541   if (!p)
542     goto failed;
543   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
544   if (!n)
545     goto failed;
546   rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)p, n);
547   if (rc)
548     {
549       gcry_sexp_release (s_pkey);
550       goto failed;
551     }
552   rcp = gcry_pk_get_keygrip (s_pkey, array);
553   gcry_sexp_release (s_pkey);
554   if (!rcp)
555     goto failed; /* Can't calculate keygrip. */
556
557   xfree (p);
558   ksba_cert_release (cert);
559   ksba_reader_release (reader);
560   return !memcmp (array, grip, 20);
561  failed:
562   xfree (p);
563   ksba_cert_release (cert);
564   ksba_reader_release (reader);
565   return 0;
566 }
567 #endif /*KEYBOX_WITH_X509*/
568
569
570 \f
571 /*
572   The has_foo functions are used as helpers for search
573 */
574 static inline int
575 has_short_kid (KEYBOXBLOB blob, u32 lkid)
576 {
577   unsigned char buf[4];
578   buf[0] = lkid >> 24;
579   buf[1] = lkid >> 16;
580   buf[2] = lkid >> 8;
581   buf[3] = lkid;
582   return blob_cmp_fpr_part (blob, buf, 16, 4);
583 }
584
585 static inline int
586 has_long_kid (KEYBOXBLOB blob, u32 mkid, u32 lkid)
587 {
588   unsigned char buf[8];
589   buf[0] = mkid >> 24;
590   buf[1] = mkid >> 16;
591   buf[2] = mkid >> 8;
592   buf[3] = mkid;
593   buf[4] = lkid >> 24;
594   buf[5] = lkid >> 16;
595   buf[6] = lkid >> 8;
596   buf[7] = lkid;
597   return blob_cmp_fpr_part (blob, buf, 12, 8);
598 }
599
600 static inline int
601 has_fingerprint (KEYBOXBLOB blob, const unsigned char *fpr)
602 {
603   return blob_cmp_fpr (blob, fpr);
604 }
605
606 static inline int
607 has_keygrip (KEYBOXBLOB blob, const unsigned char *grip)
608 {
609 #ifdef KEYBOX_WITH_X509
610   if (blob_get_type (blob) == KEYBOX_BLOBTYPE_X509)
611     return blob_x509_has_grip (blob, grip);
612 #else
613   (void)blob;
614   (void)grip;
615 #endif
616   return 0;
617 }
618
619
620 static inline int
621 has_issuer (KEYBOXBLOB blob, const char *name)
622 {
623   size_t namelen;
624
625   return_val_if_fail (name, 0);
626
627   if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
628     return 0;
629
630   namelen = strlen (name);
631   return blob_cmp_name (blob, 0 /* issuer */, name, namelen, 0, 1);
632 }
633
634 static inline int
635 has_issuer_sn (KEYBOXBLOB blob, const char *name,
636                const unsigned char *sn, int snlen)
637 {
638   size_t namelen;
639
640   return_val_if_fail (name, 0);
641   return_val_if_fail (sn, 0);
642
643   if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
644     return 0;
645
646   namelen = strlen (name);
647
648   return (blob_cmp_sn (blob, sn, snlen)
649           && blob_cmp_name (blob, 0 /* issuer */, name, namelen, 0, 1));
650 }
651
652 static inline int
653 has_sn (KEYBOXBLOB blob, const unsigned char *sn, int snlen)
654 {
655   return_val_if_fail (sn, 0);
656
657   if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
658     return 0;
659   return blob_cmp_sn (blob, sn, snlen);
660 }
661
662 static inline int
663 has_subject (KEYBOXBLOB blob, const char *name)
664 {
665   size_t namelen;
666
667   return_val_if_fail (name, 0);
668
669   if (blob_get_type (blob) != KEYBOX_BLOBTYPE_X509)
670     return 0;
671
672   namelen = strlen (name);
673   return blob_cmp_name (blob, 1 /* subject */, name, namelen, 0, 1);
674 }
675
676
677 static inline int
678 has_username (KEYBOXBLOB blob, const char *name, int substr)
679 {
680   size_t namelen;
681   int btype;
682
683   return_val_if_fail (name, 0);
684
685   btype = blob_get_type (blob);
686   if (btype != KEYBOX_BLOBTYPE_PGP && btype != KEYBOX_BLOBTYPE_X509)
687     return 0;
688
689   namelen = strlen (name);
690   return blob_cmp_name (blob, -1 /* all subject/user names */, name,
691                         namelen, substr, (btype == KEYBOX_BLOBTYPE_X509));
692 }
693
694
695 static inline int
696 has_mail (KEYBOXBLOB blob, const char *name, int substr)
697 {
698   size_t namelen;
699   int btype;
700
701   return_val_if_fail (name, 0);
702
703   btype = blob_get_type (blob);
704   if (btype != KEYBOX_BLOBTYPE_PGP && btype != KEYBOX_BLOBTYPE_X509)
705     return 0;
706
707   if (btype == KEYBOX_BLOBTYPE_PGP && *name == '<')
708     name++; /* Hack to remove the leading '<' for gpg.  */
709
710   namelen = strlen (name);
711   if (namelen && name[namelen-1] == '>')
712     namelen--;
713   return blob_cmp_mail (blob, name, namelen, substr,
714                         (btype == KEYBOX_BLOBTYPE_X509));
715 }
716
717
718 static void
719 release_sn_array (struct sn_array_s *array, size_t size)
720 {
721   size_t n;
722
723   for (n=0; n < size; n++)
724     xfree (array[n].sn);
725   xfree (array);
726 }
727
728 \f
729 /*
730
731   The search API
732
733 */
734
735 gpg_error_t
736 keybox_search_reset (KEYBOX_HANDLE hd)
737 {
738   if (!hd)
739     return gpg_error (GPG_ERR_INV_VALUE);
740
741   if (hd->found.blob)
742     {
743       _keybox_release_blob (hd->found.blob);
744       hd->found.blob = NULL;
745     }
746
747   if (hd->fp)
748     {
749       fclose (hd->fp);
750       hd->fp = NULL;
751     }
752   hd->error = 0;
753   hd->eof = 0;
754   return 0;
755 }
756
757
758 /* Note: When in ephemeral mode the search function does visit all
759    blobs but in standard mode, blobs flagged as ephemeral are ignored.
760    If WANT_BLOBTYPE is not 0 only blobs of this type are considered.
761    The value at R_SKIPPED is updated by the number of skipped long
762    records (counts PGP and X.509). */
763 gpg_error_t
764 keybox_search (KEYBOX_HANDLE hd, KEYBOX_SEARCH_DESC *desc, size_t ndesc,
765                keybox_blobtype_t want_blobtype,
766                size_t *r_descindex, unsigned long *r_skipped)
767 {
768   gpg_error_t rc;
769   size_t n;
770   int need_words, any_skip;
771   KEYBOXBLOB blob = NULL;
772   struct sn_array_s *sn_array = NULL;
773   int pk_no, uid_no;
774
775   if (!hd)
776     return gpg_error (GPG_ERR_INV_VALUE);
777
778   /* clear last found result */
779   if (hd->found.blob)
780     {
781       _keybox_release_blob (hd->found.blob);
782       hd->found.blob = NULL;
783     }
784
785   if (hd->error)
786     return hd->error; /* still in error state */
787   if (hd->eof)
788     return -1; /* still EOF */
789
790   /* figure out what information we need */
791   need_words = any_skip = 0;
792   for (n=0; n < ndesc; n++)
793     {
794       switch (desc[n].mode)
795         {
796         case KEYDB_SEARCH_MODE_WORDS:
797           need_words = 1;
798           break;
799         case KEYDB_SEARCH_MODE_FIRST:
800           /* always restart the search in this mode */
801           keybox_search_reset (hd);
802           break;
803         default:
804           break;
805         }
806       if (desc[n].skipfnc)
807         any_skip = 1;
808       if (desc[n].snlen == -1 && !sn_array)
809         {
810           sn_array = xtrycalloc (ndesc, sizeof *sn_array);
811           if (!sn_array)
812             return (hd->error = gpg_error_from_syserror ());
813         }
814     }
815
816   (void)need_words;  /* Not yet implemented.  */
817
818   if (!hd->fp)
819     {
820       hd->fp = fopen (hd->kb->fname, "rb");
821       if (!hd->fp)
822         {
823           hd->error = gpg_error_from_syserror ();
824           xfree (sn_array);
825           return hd->error;
826         }
827     }
828
829   /* Kludge: We need to convert an SN given as hexstring to its binary
830      representation - in some cases we are not able to store it in the
831      search descriptor, because due to the way we use it, it is not
832      possible to free allocated memory. */
833   if (sn_array)
834     {
835       const unsigned char *s;
836       int i, odd;
837       size_t snlen;
838
839       for (n=0; n < ndesc; n++)
840         {
841           if (!desc[n].sn)
842             ;
843           else if (desc[n].snlen == -1)
844             {
845               unsigned char *sn;
846
847               s = desc[n].sn;
848               for (i=0; *s && *s != '/'; s++, i++)
849                 ;
850               odd = (i & 1);
851               snlen = (i+1)/2;
852               sn_array[n].sn = xtrymalloc (snlen);
853               if (!sn_array[n].sn)
854                 {
855                   hd->error = gpg_error_from_syserror ();
856                   release_sn_array (sn_array, n);
857                   return hd->error;
858                 }
859               sn_array[n].snlen = snlen;
860               sn = sn_array[n].sn;
861               s = desc[n].sn;
862               if (odd)
863                 {
864                   *sn++ = xtoi_1 (s);
865                   s++;
866                 }
867               for (; *s && *s != '/';  s += 2)
868                 *sn++ = xtoi_2 (s);
869             }
870           else
871             {
872               const unsigned char *sn;
873
874               sn = desc[n].sn;
875               snlen = desc[n].snlen;
876               sn_array[n].sn = xtrymalloc (snlen);
877               if (!sn_array[n].sn)
878                 {
879                   hd->error = gpg_error_from_syserror ();
880                   release_sn_array (sn_array, n);
881                   return hd->error;
882                 }
883               sn_array[n].snlen = snlen;
884               memcpy (sn_array[n].sn, sn, snlen);
885             }
886         }
887     }
888
889
890   pk_no = uid_no = 0;
891   for (;;)
892     {
893       unsigned int blobflags;
894       int blobtype;
895
896       _keybox_release_blob (blob); blob = NULL;
897       rc = _keybox_read_blob (&blob, hd->fp);
898       if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
899           && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
900         {
901           ++*r_skipped;
902           continue; /* Skip too large records.  */
903         }
904
905       if (rc)
906         break;
907
908       blobtype = blob_get_type (blob);
909       if (blobtype == KEYBOX_BLOBTYPE_HEADER)
910         continue;
911       if (want_blobtype && blobtype != want_blobtype)
912         continue;
913
914       blobflags = blob_get_blob_flags (blob);
915       if (!hd->ephemeral && (blobflags & 2))
916         continue; /* Not in ephemeral mode but blob is flagged ephemeral.  */
917
918       for (n=0; n < ndesc; n++)
919         {
920           switch (desc[n].mode)
921             {
922             case KEYDB_SEARCH_MODE_NONE:
923               never_reached ();
924               break;
925             case KEYDB_SEARCH_MODE_EXACT:
926               uid_no = has_username (blob, desc[n].u.name, 0);
927               if (uid_no)
928                 goto found;
929               break;
930             case KEYDB_SEARCH_MODE_MAIL:
931               uid_no = has_mail (blob, desc[n].u.name, 0);
932               if (uid_no)
933                 goto found;
934               break;
935             case KEYDB_SEARCH_MODE_MAILSUB:
936               uid_no = has_mail (blob, desc[n].u.name, 1);
937               if (uid_no)
938                 goto found;
939               break;
940             case KEYDB_SEARCH_MODE_SUBSTR:
941               uid_no =  has_username (blob, desc[n].u.name, 1);
942               if (uid_no)
943                 goto found;
944               break;
945             case KEYDB_SEARCH_MODE_MAILEND:
946             case KEYDB_SEARCH_MODE_WORDS:
947               /* not yet implemented */
948               break;
949             case KEYDB_SEARCH_MODE_ISSUER:
950               if (has_issuer (blob, desc[n].u.name))
951                 goto found;
952               break;
953             case KEYDB_SEARCH_MODE_ISSUER_SN:
954               if (has_issuer_sn (blob, desc[n].u.name,
955                                  sn_array? sn_array[n].sn : desc[n].sn,
956                                  sn_array? sn_array[n].snlen : desc[n].snlen))
957                 goto found;
958               break;
959             case KEYDB_SEARCH_MODE_SN:
960               if (has_sn (blob, sn_array? sn_array[n].sn : desc[n].sn,
961                                 sn_array? sn_array[n].snlen : desc[n].snlen))
962                 goto found;
963               break;
964             case KEYDB_SEARCH_MODE_SUBJECT:
965               if (has_subject (blob, desc[n].u.name))
966                 goto found;
967               break;
968             case KEYDB_SEARCH_MODE_SHORT_KID:
969               pk_no = has_short_kid (blob, desc[n].u.kid[1]);
970               if (pk_no)
971                 goto found;
972               break;
973             case KEYDB_SEARCH_MODE_LONG_KID:
974               pk_no = has_long_kid (blob, desc[n].u.kid[0], desc[n].u.kid[1]);
975               if (pk_no)
976                 goto found;
977               break;
978             case KEYDB_SEARCH_MODE_FPR:
979             case KEYDB_SEARCH_MODE_FPR20:
980               pk_no = has_fingerprint (blob, desc[n].u.fpr);
981               if (pk_no)
982                 goto found;
983               break;
984             case KEYDB_SEARCH_MODE_KEYGRIP:
985               if (has_keygrip (blob, desc[n].u.grip))
986                 goto found;
987               break;
988             case KEYDB_SEARCH_MODE_FIRST:
989               goto found;
990               break;
991             case KEYDB_SEARCH_MODE_NEXT:
992               goto found;
993               break;
994             default:
995               rc = gpg_error (GPG_ERR_INV_VALUE);
996               goto found;
997             }
998         }
999       continue;
1000     found:
1001       /* Record which DESC we matched on.  Note this value is only
1002          meaningful if this function returns with no errors. */
1003       if(r_descindex)
1004         *r_descindex = n;
1005       for (n=any_skip?0:ndesc; n < ndesc; n++)
1006         {
1007           u32 kid[2];
1008
1009           if (desc[n].skipfnc
1010               && blob_get_first_keyid (blob, kid)
1011               && desc[n].skipfnc (desc[n].skipfncvalue, kid, uid_no))
1012                 break;
1013         }
1014       if (n == ndesc)
1015         break; /* got it */
1016     }
1017
1018   if (!rc)
1019     {
1020       hd->found.blob = blob;
1021       hd->found.pk_no = pk_no;
1022       hd->found.uid_no = uid_no;
1023     }
1024   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF)
1025     {
1026       _keybox_release_blob (blob);
1027       hd->eof = 1;
1028     }
1029   else
1030     {
1031       _keybox_release_blob (blob);
1032       hd->error = rc;
1033     }
1034
1035   if (sn_array)
1036     release_sn_array (sn_array, ndesc);
1037
1038   return rc;
1039 }
1040
1041
1042
1043 \f
1044 /*
1045    Functions to return a certificate or a keyblock.  To be used after
1046    a successful search operation.
1047 */
1048
1049
1050 /* Return the last found keyblock.  Returns 0 on success and stores a
1051    new iobuf at R_IOBUF and a signature status vector at R_SIGSTATUS
1052    in that case.  R_UID_NO and R_PK_NO are used to retun the number of
1053    the key or user id which was matched the search criteria; if not
1054    known they are set to 0. */
1055 gpg_error_t
1056 keybox_get_keyblock (KEYBOX_HANDLE hd, iobuf_t *r_iobuf,
1057                      int *r_pk_no, int *r_uid_no, u32 **r_sigstatus)
1058 {
1059   gpg_error_t err;
1060   const unsigned char *buffer, *p;
1061   size_t length;
1062   size_t image_off, image_len;
1063   size_t siginfo_off, siginfo_len;
1064   u32 *sigstatus, n, n_sigs, sigilen;
1065
1066   *r_iobuf = NULL;
1067   *r_sigstatus = NULL;
1068
1069   if (!hd)
1070     return gpg_error (GPG_ERR_INV_VALUE);
1071   if (!hd->found.blob)
1072     return gpg_error (GPG_ERR_NOTHING_FOUND);
1073
1074   if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_PGP)
1075     return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
1076
1077   buffer = _keybox_get_blob_image (hd->found.blob, &length);
1078   if (length < 40)
1079     return gpg_error (GPG_ERR_TOO_SHORT);
1080   image_off = get32 (buffer+8);
1081   image_len = get32 (buffer+12);
1082   if (image_off+image_len > length)
1083     return gpg_error (GPG_ERR_TOO_SHORT);
1084
1085   err = _keybox_get_flag_location (buffer, length, KEYBOX_FLAG_SIG_INFO,
1086                                    &siginfo_off, &siginfo_len);
1087   if (err)
1088     return err;
1089   n_sigs  = get16 (buffer + siginfo_off);
1090   sigilen = get16 (buffer + siginfo_off + 2);
1091   p = buffer + siginfo_off + 4;
1092   sigstatus = xtrymalloc ((1+n_sigs) * sizeof *sigstatus);
1093   if (!sigstatus)
1094     return gpg_error_from_syserror ();
1095   sigstatus[0] = n_sigs;
1096   for (n=1; n <= n_sigs; n++, p += sigilen)
1097     sigstatus[n] = get32 (p);
1098
1099   *r_pk_no  = hd->found.pk_no;
1100   *r_uid_no = hd->found.uid_no;
1101   *r_sigstatus = sigstatus;
1102   *r_iobuf = iobuf_temp_with_content (buffer+image_off, image_len);
1103   return 0;
1104 }
1105
1106
1107 #ifdef KEYBOX_WITH_X509
1108 /*
1109   Return the last found cert.  Caller must free it.
1110  */
1111 int
1112 keybox_get_cert (KEYBOX_HANDLE hd, ksba_cert_t *r_cert)
1113 {
1114   const unsigned char *buffer;
1115   size_t length;
1116   size_t cert_off, cert_len;
1117   ksba_reader_t reader = NULL;
1118   ksba_cert_t cert = NULL;
1119   int rc;
1120
1121   if (!hd)
1122     return gpg_error (GPG_ERR_INV_VALUE);
1123   if (!hd->found.blob)
1124     return gpg_error (GPG_ERR_NOTHING_FOUND);
1125
1126   if (blob_get_type (hd->found.blob) != KEYBOX_BLOBTYPE_X509)
1127     return gpg_error (GPG_ERR_WRONG_BLOB_TYPE);
1128
1129   buffer = _keybox_get_blob_image (hd->found.blob, &length);
1130   if (length < 40)
1131     return gpg_error (GPG_ERR_TOO_SHORT);
1132   cert_off = get32 (buffer+8);
1133   cert_len = get32 (buffer+12);
1134   if (cert_off+cert_len > length)
1135     return gpg_error (GPG_ERR_TOO_SHORT);
1136
1137   rc = ksba_reader_new (&reader);
1138   if (rc)
1139     return rc;
1140   rc = ksba_reader_set_mem (reader, buffer+cert_off, cert_len);
1141   if (rc)
1142     {
1143       ksba_reader_release (reader);
1144       /* fixme: need to map the error codes */
1145       return gpg_error (GPG_ERR_GENERAL);
1146     }
1147
1148   rc = ksba_cert_new (&cert);
1149   if (rc)
1150     {
1151       ksba_reader_release (reader);
1152       return rc;
1153     }
1154
1155   rc = ksba_cert_read_der (cert, reader);
1156   if (rc)
1157     {
1158       ksba_cert_release (cert);
1159       ksba_reader_release (reader);
1160       /* fixme: need to map the error codes */
1161       return gpg_error (GPG_ERR_GENERAL);
1162     }
1163
1164   *r_cert = cert;
1165   ksba_reader_release (reader);
1166   return 0;
1167 }
1168
1169 #endif /*KEYBOX_WITH_X509*/
1170
1171 /* Return the flags named WHAT at the address of VALUE. IDX is used
1172    only for certain flags and should be 0 if not required. */
1173 int
1174 keybox_get_flags (KEYBOX_HANDLE hd, int what, int idx, unsigned int *value)
1175 {
1176   const unsigned char *buffer;
1177   size_t length;
1178   gpg_err_code_t ec;
1179
1180   (void)idx; /* Not yet used.  */
1181
1182   if (!hd)
1183     return gpg_error (GPG_ERR_INV_VALUE);
1184   if (!hd->found.blob)
1185     return gpg_error (GPG_ERR_NOTHING_FOUND);
1186
1187   buffer = _keybox_get_blob_image (hd->found.blob, &length);
1188   ec = get_flag_from_image (buffer, length, what, value);
1189   return ec? gpg_error (ec):0;
1190 }
1191
1192 off_t
1193 keybox_offset (KEYBOX_HANDLE hd)
1194 {
1195   if (!hd->fp)
1196     return 0;
1197   return ftello (hd->fp);
1198 }
1199
1200 gpg_error_t
1201 keybox_seek (KEYBOX_HANDLE hd, off_t offset)
1202 {
1203   int err;
1204
1205   if (hd->error)
1206     return hd->error; /* still in error state */
1207
1208   if (! hd->fp)
1209     {
1210       if (offset == 0)
1211         /* No need to open the file.  An unopened file is effectively at
1212            offset 0.  */
1213         return 0;
1214
1215       hd->fp = fopen (hd->kb->fname, "rb");
1216       if (!hd->fp)
1217         {
1218           hd->error = gpg_error_from_syserror ();
1219           return hd->error;
1220         }
1221     }
1222
1223   err = fseeko (hd->fp, offset, SEEK_SET);
1224   hd->error = gpg_error_from_errno (err);
1225
1226   return hd->error;
1227 }