Started with keybox implementation by basing it on code from the GnuPG
[gnupg.git] / kbx / keybox-search.c
1 /* keybox-search.c - Search operations
2  *      Copyright (C) 2001 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25
26 #include "keybox-defs.h"
27
28
29 /****************
30  * Check whether the given fingerprint (20 bytes) is in the
31  * given keyblob.  fpr is always 20 bytes.
32  * Return: 0 = found
33  *         -1 = not found
34           other = error  (fixme: do not always reurn gpgerr_general)
35  */
36 int
37 keybox_blob_has_fpr ( KEYBOXBLOB blob, const byte *fpr )
38 {
39     ulong n, nkeys, keyinfolen;
40     const byte *p, *pend;
41     byte *buffer = blob->blob;
42     size_t buflen = blob->bloblen;
43
44     if ( buflen < 40 )
45         return GPGERR_GENERAL; /* blob too short */
46     n = get32( buffer );
47     if ( n > buflen )
48         return GPGERR_GENERAL; /* blob larger than announced length */
49     buflen = n;  /* ignore trailing stuff */
50     pend = buffer + n - 1;
51
52     if ( buffer[4] != 2 )
53         return GPGERR_GENERAL; /* invalid blob type */
54     if ( buffer[5] != 1 )
55         return GPGERR_GENERAL; /* invalid blob format version */
56
57     nkeys = get16( buffer + 16 );
58     keyinfolen = get16( buffer + 18 );
59     p = buffer + 20;
60     for(n=0; n < nkeys; n++, p += keyinfolen ) {
61         if ( p+20 > pend )
62             return GPGERR_GENERAL; /* blob shorter than required */
63         if (!memcmp ( p, fpr, 20 ) )
64             return 0; /* found */
65     }
66     return -1;
67 }
68
69 /****************
70  * Check whether the given keyID (20 bytes) is in the
71  * given keyblob.
72  * Return: 0 = found
73  *         -1 = not found
74           other = error  (fixme: do not always return gpgerr_general)
75  */
76 int
77 keybox_blob_has_kid ( KEYBOXBLOB blob, const byte *keyidbuf, size_t keyidlen )
78 {
79     ulong n, nkeys, keyinfolen, off;
80     const byte *p, *pend;
81     byte *buffer = blob->blob;
82     size_t buflen = blob->bloblen;
83
84     if ( buflen < 40 )
85         return GPGERR_GENERAL; /* blob too short */
86     n = get32( buffer );
87     if ( n > buflen )
88         return GPGERR_GENERAL; /* blob larger than announced length */
89     buflen = n;  /* ignore trailing stuff */
90     pend = buffer + n - 1;
91
92     if ( buffer[4] != 2 )
93         return GPGERR_GENERAL; /* invalid blob type */
94     if ( buffer[5] != 1 )
95         return GPGERR_GENERAL; /* invalid blob format version */
96
97     nkeys = get16( buffer + 16 );
98     keyinfolen = get16( buffer + 18 );
99     p = buffer + 20;
100     for(n=0; n < nkeys; n++, p += keyinfolen ) {
101         if ( p+24 > pend )
102             return GPGERR_GENERAL; /* blob shorter than required */
103         off = get32 ( p + 20 );
104         if (keyidlen < 8 ) /* actually keyidlen may either be 4 or 8 */
105             off +=4;
106         if ( off+keyidlen > buflen )
107             return GPGERR_GENERAL; /* offset out of bounds */
108         if ( !memcmp ( buffer+off, keyidbuf, keyidlen ) )
109             return 0; /* found */
110     }
111     return -1;
112 }
113
114
115
116 int
117 keybox_blob_has_uid ( KEYBOXBLOB blob,
118                    int (*cmp)(const byte *, size_t, void *), void *opaque )
119 {
120     ulong n, nuids, uidinfolen, off, len;
121     const byte *p, *pend;
122     byte *buffer = blob->blob;
123     size_t buflen = blob->bloblen;
124
125     if ( buflen < 40 )
126         return GPGERR_GENERAL; /* blob too short */
127     n = get32( buffer );
128     if ( n > buflen )
129         return GPGERR_GENERAL; /* blob larger than announced length */
130     buflen = n;  /* ignore trailing stuff */
131     pend = buffer + n - 1;
132
133     if ( buffer[4] != 2 )
134         return GPGERR_GENERAL; /* invalid blob type */
135     if ( buffer[5] != 1 )
136         return GPGERR_GENERAL; /* invalid blob format version */
137
138     p = buffer + 20 + get16( buffer + 16 ) * get16( buffer + 18 );
139     if ( p+4 > pend )
140         return GPGERR_GENERAL; /* blob shorter than required */
141
142     nuids = get16( p ); p+= 2;
143     uidinfolen = get16( p ); p+=2;
144     for(n=0; n < nuids; n++, p += uidinfolen ) {
145         if ( p+8 > pend )
146             return GPGERR_GENERAL; /* blob shorter than required */
147         off = get32 ( p );
148         len = get32 ( p + 4 );
149         if ( off+len > buflen )
150             return GPGERR_GENERAL; /* offset out of bounds */
151         if ( (*cmp) ( buffer+off, len, opaque ) )
152             return 0; /* found */
153     }
154
155     return -1;
156 }
157
158