The first a bug in pax and should be commited to FBSD, too.
[dragonfly.git] / contrib / isc-dhcp / minires / ns_verify.c
1 /*
2  * Copyright (c) 1999-2001 by Internet Software Consortium, Inc.
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
9  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
10  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
11  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
13  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
14  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
15  * SOFTWARE.
16  */
17
18 #ifndef lint
19 static const char rcsid[] = "$Id: ns_verify.c,v 1.5.2.2 2002/02/19 19:23:31 mellon Exp $";
20 #endif
21
22 #define time(x)         trace_mr_time (x)
23
24 /* Import. */
25
26 #include <sys/types.h>
27 #include <sys/param.h>
28
29 #include <netinet/in.h>
30 #include <arpa/inet.h>
31 #include <sys/socket.h>
32
33 #include <errno.h>
34 #include <netdb.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <unistd.h>
39 #include <time.h>
40
41 #include "minires/minires.h"
42 #include "arpa/nameser.h"
43 #include <isc-dhcp/dst.h>
44
45 time_t trace_mr_time (time_t *);
46
47 /* Private. */
48
49 #define BOUNDS_CHECK(ptr, count) \
50         do { \
51                 if ((ptr) + (count) > eom) { \
52                         return (NS_TSIG_ERROR_FORMERR); \
53                 } \
54         } while (0)
55
56 /* Public. */
57
58 u_char *
59 ns_find_tsig(u_char *msg, u_char *eom) {
60         HEADER *hp = (HEADER *)msg;
61         int n, type;
62         u_char *cp = msg, *start;
63         isc_result_t status;
64
65         if (msg == NULL || eom == NULL || msg > eom)
66                 return (NULL);
67
68         if (cp + HFIXEDSZ >= eom)
69                 return (NULL);
70
71         if (hp->arcount == 0)
72                 return (NULL);
73
74         cp += HFIXEDSZ;
75
76         status = ns_skiprr(cp, eom, ns_s_qd, ntohs(hp->qdcount), &n);
77         if (status != ISC_R_SUCCESS)
78                 return (NULL);
79         cp += n;
80
81         status = ns_skiprr(cp, eom, ns_s_an, ntohs(hp->ancount), &n);
82         if (status != ISC_R_SUCCESS)
83                 return (NULL);
84         cp += n;
85
86         status = ns_skiprr(cp, eom, ns_s_ns, ntohs(hp->nscount), &n);
87         if (status != ISC_R_SUCCESS)
88                 return (NULL);
89         cp += n;
90
91         status = ns_skiprr(cp, eom, ns_s_ar, ntohs(hp->arcount) - 1, &n);
92         if (status != ISC_R_SUCCESS)
93                 return (NULL);
94         cp += n;
95
96         start = cp;
97         n = dn_skipname(cp, eom);
98         if (n < 0)
99                 return (NULL);
100         cp += n;
101         if (cp + INT16SZ >= eom)
102                 return (NULL);
103
104         GETSHORT(type, cp);
105         if (type != ns_t_tsig)
106                 return (NULL);
107         return (start);
108 }
109
110 /* ns_verify
111  * Parameters:
112  *      statp           res stuff
113  *      msg             received message
114  *      msglen          length of message
115  *      key             tsig key used for verifying.
116  *      querysig        (response), the signature in the query
117  *      querysiglen     (response), the length of the signature in the query
118  *      sig             (query), a buffer to hold the signature
119  *      siglen          (query), input - length of signature buffer
120  *                               output - length of signature
121  *
122  * Errors:
123  *      - bad input (-1)
124  *      - invalid dns message (NS_TSIG_ERROR_FORMERR)
125  *      - TSIG is not present (NS_TSIG_ERROR_NO_TSIG)
126  *      - key doesn't match (-ns_r_badkey)
127  *      - TSIG verification fails with BADKEY (-ns_r_badkey)
128  *      - TSIG verification fails with BADSIG (-ns_r_badsig)
129  *      - TSIG verification fails with BADTIME (-ns_r_badtime)
130  *      - TSIG verification succeeds, error set to BAKEY (ns_r_badkey)
131  *      - TSIG verification succeeds, error set to BADSIG (ns_r_badsig)
132  *      - TSIG verification succeeds, error set to BADTIME (ns_r_badtime)
133  */
134 isc_result_t
135 ns_verify(u_char *msg, unsigned *msglen, void *k,
136           const u_char *querysig, unsigned querysiglen,
137           u_char *sig, unsigned *siglen, time_t *timesigned, int nostrip)
138 {
139         HEADER *hp = (HEADER *)msg;
140         DST_KEY *key = (DST_KEY *)k;
141         u_char *cp = msg, *eom;
142         char name[MAXDNAME], alg[MAXDNAME];
143         u_char *recstart, *rdatastart;
144         u_char *sigstart, *otherstart;
145         unsigned n;
146         int error;
147         u_int16_t type, length;
148         u_int16_t fudge, sigfieldlen, id, otherfieldlen;
149
150         dst_init();
151         if (msg == NULL || msglen == NULL || *msglen < 0)
152                 return ISC_R_INVALIDARG;
153
154         eom = msg + *msglen;
155
156         recstart = ns_find_tsig(msg, eom);
157         if (recstart == NULL)
158                 return ISC_R_NO_TSIG;
159
160         cp = recstart;
161
162         /* Read the key name. */
163         n = dn_expand(msg, eom, cp, name, MAXDNAME);
164         if (n < 0)
165                 return ISC_R_FORMERR;
166         cp += n;
167
168         /* Read the type. */
169         BOUNDS_CHECK(cp, 2*INT16SZ + INT32SZ + INT16SZ);
170         GETSHORT(type, cp);
171         if (type != ns_t_tsig)
172                 return ISC_R_NO_TSIG;
173
174         /* Skip the class and TTL, save the length. */
175         cp += INT16SZ + INT32SZ;
176         GETSHORT(length, cp);
177         if (eom - cp != length)
178                 return ISC_R_FORMERR;
179
180         /* Read the algorithm name. */
181         rdatastart = cp;
182         n = dn_expand(msg, eom, cp, alg, MAXDNAME);
183         if (n < 0)
184                 return ISC_R_FORMERR;
185         if (ns_samename(alg, NS_TSIG_ALG_HMAC_MD5) != 1)
186                 return ISC_R_INVALIDKEY;
187         cp += n;
188
189         /* Read the time signed and fudge. */
190         BOUNDS_CHECK(cp, INT16SZ + INT32SZ + INT16SZ);
191         cp += INT16SZ;
192         GETLONG((*timesigned), cp);
193         GETSHORT(fudge, cp);
194
195         /* Read the signature. */
196         BOUNDS_CHECK(cp, INT16SZ);
197         GETSHORT(sigfieldlen, cp);
198         BOUNDS_CHECK(cp, sigfieldlen);
199         sigstart = cp;
200         cp += sigfieldlen;
201
202         /* Read the original id and error. */
203         BOUNDS_CHECK(cp, 2*INT16SZ);
204         GETSHORT(id, cp);
205         GETSHORT(error, cp);
206
207         /* Parse the other data. */
208         BOUNDS_CHECK(cp, INT16SZ);
209         GETSHORT(otherfieldlen, cp);
210         BOUNDS_CHECK(cp, otherfieldlen);
211         otherstart = cp;
212         cp += otherfieldlen;
213
214         if (cp != eom)
215                 return ISC_R_FORMERR;
216
217         /* Verify that the key used is OK. */
218         if (key != NULL) {
219                 if (key->dk_alg != KEY_HMAC_MD5)
220                         return ISC_R_INVALIDKEY;
221                 if (error != ns_r_badsig && error != ns_r_badkey) {
222                         if (ns_samename(key->dk_key_name, name) != 1)
223                                 return ISC_R_INVALIDKEY;
224                 }
225         }
226
227         hp->arcount = htons(ntohs(hp->arcount) - 1);
228
229         /*
230          * Do the verification.
231          */
232
233         if (key != NULL && error != ns_r_badsig && error != ns_r_badkey) {
234                 void *ctx;
235                 u_char buf[MAXDNAME];
236
237                 /* Digest the query signature, if this is a response. */
238                 dst_verify_data(SIG_MODE_INIT, key, &ctx, NULL, 0, NULL, 0);
239                 if (querysiglen > 0 && querysig != NULL) {
240                         u_int16_t len_n = htons(querysiglen);
241                         dst_verify_data(SIG_MODE_UPDATE, key, &ctx,
242                                         (u_char *)&len_n, INT16SZ, NULL, 0);
243                         dst_verify_data(SIG_MODE_UPDATE, key, &ctx,
244                                         querysig, querysiglen, NULL, 0);
245                 }
246                 
247                 /* Digest the message. */
248                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx, msg,
249                                 (unsigned)(recstart - msg), NULL, 0);
250
251                 /* Digest the key name. */
252                 n = ns_name_ntol(recstart, buf, sizeof(buf));
253                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx, buf, n, NULL, 0);
254
255                 /* Digest the class and TTL. */
256                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx,
257                                 recstart + dn_skipname(recstart, eom) + INT16SZ,
258                                 INT16SZ + INT32SZ, NULL, 0);
259
260                 /* Digest the algorithm. */
261                 n = ns_name_ntol(rdatastart, buf, sizeof(buf));
262                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx, buf, n, NULL, 0);
263
264                 /* Digest the time signed and fudge. */
265                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx,
266                                 rdatastart + dn_skipname(rdatastart, eom),
267                                 INT16SZ + INT32SZ + INT16SZ, NULL, 0);
268
269                 /* Digest the error and other data. */
270                 dst_verify_data(SIG_MODE_UPDATE, key, &ctx,
271                                 otherstart - INT16SZ - INT16SZ,
272                                 (unsigned)otherfieldlen + INT16SZ + INT16SZ,
273                                 NULL, 0);
274
275                 n = dst_verify_data(SIG_MODE_FINAL, key, &ctx, NULL, 0,
276                                     sigstart, sigfieldlen);
277
278                 if (n < 0)
279                         return ISC_R_BADSIG;
280
281                 if (sig != NULL && siglen != NULL) {
282                         if (*siglen < sigfieldlen)
283                                 return ISC_R_NOSPACE;
284                         memcpy(sig, sigstart, sigfieldlen);
285                         *siglen = sigfieldlen;
286                 }
287         } else {
288                 if (sigfieldlen > 0)
289                         return ISC_R_FORMERR;
290                 if (sig != NULL && siglen != NULL)
291                         *siglen = 0;
292         }
293
294         /* Reset the counter, since we still need to check for badtime. */
295         hp->arcount = htons(ntohs(hp->arcount) + 1);
296
297         /* Verify the time. */
298         if (abs((*timesigned) - time(NULL)) > fudge)
299                 return ISC_R_BADTIME;
300
301         if (nostrip == 0) {
302                 *msglen = recstart - msg;
303                 hp->arcount = htons(ntohs(hp->arcount) - 1);
304         }
305
306         if (error != NOERROR)
307                 return ns_rcode_to_isc (error);
308
309         return ISC_R_SUCCESS;
310 }
311
312 #if 0
313 isc_result_t
314 ns_verify_tcp_init(void *k, const u_char *querysig, unsigned querysiglen,
315                    ns_tcp_tsig_state *state)
316 {
317         dst_init();
318         if (state == NULL || k == NULL || querysig == NULL || querysiglen < 0)
319                 return ISC_R_INVALIDARG;
320         state->counter = -1;
321         state->key = k;
322         if (state->key->dk_alg != KEY_HMAC_MD5)
323                 return ISC_R_BADKEY;
324         if (querysiglen > sizeof(state->sig))
325                 return ISC_R_NOSPACE;
326         memcpy(state->sig, querysig, querysiglen);
327         state->siglen = querysiglen;
328         return ISC_R_SUCCESS;
329 }
330
331 isc_result_t
332 ns_verify_tcp(u_char *msg, unsigned *msglen, ns_tcp_tsig_state *state,
333               int required)
334 {
335         HEADER *hp = (HEADER *)msg;
336         u_char *recstart, *rdatastart, *sigstart;
337         unsigned sigfieldlen, otherfieldlen;
338         u_char *cp, *eom = msg + *msglen, *cp2;
339         char name[MAXDNAME], alg[MAXDNAME];
340         u_char buf[MAXDNAME];
341         int n, type, length, fudge, id, error;
342         time_t timesigned;
343
344         if (msg == NULL || msglen == NULL || state == NULL)
345                 return ISC_R_INVALIDARG;
346
347         state->counter++;
348         if (state->counter == 0)
349                 return (ns_verify(msg, msglen, state->key,
350                                   state->sig, state->siglen,
351                                   state->sig, &state->siglen, &timesigned, 0));
352
353         if (state->siglen > 0) {
354                 u_int16_t siglen_n = htons(state->siglen);
355
356                 dst_verify_data(SIG_MODE_INIT, state->key, &state->ctx,
357                                 NULL, 0, NULL, 0);
358                 dst_verify_data(SIG_MODE_UPDATE, state->key, &state->ctx,
359                                 (u_char *)&siglen_n, INT16SZ, NULL, 0);
360                 dst_verify_data(SIG_MODE_UPDATE, state->key, &state->ctx,
361                                 state->sig, state->siglen, NULL, 0);
362                 state->siglen = 0;
363         }
364
365         cp = recstart = ns_find_tsig(msg, eom);
366
367         if (recstart == NULL) {
368                 if (required)
369                         return ISC_R_NO_TSIG;
370                 dst_verify_data(SIG_MODE_UPDATE, state->key, &state->ctx,
371                                 msg, *msglen, NULL, 0);
372                 return ISC_R_SUCCESS;
373         }
374
375         hp->arcount = htons(ntohs(hp->arcount) - 1);
376         dst_verify_data(SIG_MODE_UPDATE, state->key, &state->ctx,
377                         msg, (unsigned)(recstart - msg), NULL, 0);
378         
379         /* Read the key name. */
380         n = dn_expand(msg, eom, cp, name, MAXDNAME);
381         if (n < 0)
382                 return ISC_R_FORMERR;
383         cp += n;
384
385         /* Read the type. */
386         BOUNDS_CHECK(cp, 2*INT16SZ + INT32SZ + INT16SZ);
387         GETSHORT(type, cp);
388         if (type != ns_t_tsig)
389                 return ISC_R_NO_TSIG;
390
391         /* Skip the class and TTL, save the length. */
392         cp += INT16SZ + INT32SZ;
393         GETSHORT(length, cp);
394         if (eom - cp != length)
395                 return ISC_R_FORMERR;
396
397         /* Read the algorithm name. */
398         rdatastart = cp;
399         n = dn_expand(msg, eom, cp, alg, MAXDNAME);
400         if (n < 0)
401                 return ISC_R_FORMERR;
402         if (ns_samename(alg, NS_TSIG_ALG_HMAC_MD5) != 1)
403                 return ISC_R_BADKEY;
404         cp += n;
405
406         /* Verify that the key used is OK. */
407         if ((ns_samename(state->key->dk_key_name, name) != 1 ||
408              state->key->dk_alg != KEY_HMAC_MD5))
409                 return ISC_R_BADKEY;
410
411         /* Read the time signed and fudge. */
412         BOUNDS_CHECK(cp, INT16SZ + INT32SZ + INT16SZ);
413         cp += INT16SZ;
414         GETLONG(timesigned, cp);
415         GETSHORT(fudge, cp);
416
417         /* Read the signature. */
418         BOUNDS_CHECK(cp, INT16SZ);
419         GETSHORT(sigfieldlen, cp);
420         BOUNDS_CHECK(cp, sigfieldlen);
421         sigstart = cp;
422         cp += sigfieldlen;
423
424         /* Read the original id and error. */
425         BOUNDS_CHECK(cp, 2*INT16SZ);
426         GETSHORT(id, cp);
427         GETSHORT(error, cp);
428
429         /* Parse the other data. */
430         BOUNDS_CHECK(cp, INT16SZ);
431         GETSHORT(otherfieldlen, cp);
432         BOUNDS_CHECK(cp, otherfieldlen);
433         cp += otherfieldlen;
434
435         if (cp != eom)
436                 return ISC_R_FORMERR;
437
438         /*
439          * Do the verification.
440          */
441
442         /* Digest the time signed and fudge. */
443         cp2 = buf;
444         PUTSHORT(0, cp2);       /* Top 16 bits of time. */
445         PUTLONG(timesigned, cp2);
446         PUTSHORT(NS_TSIG_FUDGE, cp2);
447
448         dst_verify_data(SIG_MODE_UPDATE, state->key, &state->ctx,
449                         buf, (unsigned)(cp2 - buf), NULL, 0);
450
451         n = dst_verify_data(SIG_MODE_FINAL, state->key, &state->ctx, NULL, 0,
452                             sigstart, sigfieldlen);
453         if (n < 0)
454                 return ISC_R_BADSIG;
455
456         if (sigfieldlen > sizeof(state->sig))
457                 return ISC_R_BADSIG;
458
459         if (sigfieldlen > sizeof(state->sig))
460                 return ISC_R_NOSPACE;
461
462         memcpy(state->sig, sigstart, sigfieldlen);
463         state->siglen = sigfieldlen;
464
465         /* Verify the time. */
466         if (abs(timesigned - time(NULL)) > fudge)
467                 return ISC_R_BADTIME;
468
469         *msglen = recstart - msg;
470
471         if (error != NOERROR)
472                 return ns_rcode_to_isc (error);
473
474         return ISC_R_SUCCESS;
475 }
476 #endif