source: rtems-libbsd/ipsec-tools/src/racoon/isakmp_frag.c @ 8645c9d7

5-freebsd-12
Last change on this file since 8645c9d7 was 8645c9d7, checked in by Christian Mauderer <christian.mauderer@…>, on Jun 6, 2018 at 9:11:52 AM

ipsec-tools: Apply patches from FreeBSD ports.

Source: https://svnweb.freebsd.org/ports/head/security/ipsec-tools/files/ revision 468617.

  • Property mode set to 100644
File size: 8.8 KB
Line 
1/*      $NetBSD: isakmp_frag.c,v 1.7 2017/07/23 05:40:27 christos Exp $ */
2
3/* Id: isakmp_frag.c,v 1.4 2004/11/13 17:31:36 manubsd Exp */
4
5/*
6 * Copyright (C) 2004 Emmanuel Dreyfus
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the project nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include "config.h"
35
36#include <sys/types.h>
37#include <sys/param.h>
38#include <sys/socket.h>
39#include <sys/queue.h>
40
41#include <netinet/in.h>
42#include <arpa/inet.h>
43
44#include <openssl/md5.h> 
45
46#include <stdlib.h>
47#include <stdio.h>
48#include <fcntl.h>
49#include <string.h>
50#include <errno.h>
51#if TIME_WITH_SYS_TIME
52# include <sys/time.h>
53# include <time.h>
54#else
55# if HAVE_SYS_TIME_H
56#  include <sys/time.h>
57# else
58#  include <time.h>
59# endif
60#endif
61#include <netdb.h>
62#ifdef HAVE_UNISTD_H
63#include <unistd.h>
64#endif
65#include <ctype.h>
66
67#include "var.h"
68#include "misc.h"
69#include "vmbuf.h"
70#include "plog.h"
71#include "sockmisc.h"
72#include "schedule.h"
73#include "debug.h"
74
75#include "isakmp_var.h"
76#include "isakmp.h"
77#include "handler.h"
78#include "isakmp_frag.h"
79#include "strnames.h"
80
81int
82isakmp_sendfrags(iph1, buf) 
83        struct ph1handle *iph1;
84        vchar_t *buf;
85{
86        struct isakmp *hdr;
87        struct isakmp_frag *fraghdr;
88        caddr_t data;
89        caddr_t sdata;
90        size_t datalen;
91        size_t max_datalen;
92        size_t fraglen;
93        vchar_t *frag;
94        unsigned int trailer;
95        unsigned int fragnum = 0;
96        size_t len;
97        int etype;
98
99        /*
100         * Catch the exchange type for later: the fragments and the
101         * fragmented packet must have the same exchange type.
102         */
103        hdr = (struct isakmp *)buf->v;
104        etype = hdr->etype;
105
106        /*
107         * We want to send a a packet smaller than ISAKMP_FRAG_MAXLEN
108         * First compute the maximum data length that will fit in it
109         */
110        max_datalen = ISAKMP_FRAG_MAXLEN - 
111            (sizeof(*hdr) + sizeof(*fraghdr) + sizeof(trailer));
112
113        sdata = buf->v;
114        len = buf->l;
115
116        while (len > 0) {
117                fragnum++;
118
119                if (len > max_datalen)
120                        datalen = max_datalen;
121                else
122                        datalen = len;
123
124                fraglen = sizeof(*hdr) 
125                        + sizeof(*fraghdr) 
126                        + datalen;
127
128                if ((frag = vmalloc(fraglen)) == NULL) {
129                        plog(LLV_ERROR, LOCATION, NULL, 
130                            "Cannot allocate memory\n");
131                        return -1;
132                }
133
134                set_isakmp_header1(frag, iph1, ISAKMP_NPTYPE_FRAG);
135                hdr = (struct isakmp *)frag->v;
136                hdr->etype = etype;
137
138                fraghdr = (struct isakmp_frag *)(hdr + 1);
139                fraghdr->unknown0 = htons(0);
140                fraghdr->len = htons(fraglen - sizeof(*hdr));
141                fraghdr->unknown1 = htons(1);
142                fraghdr->index = fragnum;
143                if (len == datalen)
144                        fraghdr->flags = ISAKMP_FRAG_LAST;
145                else
146                        fraghdr->flags = 0;
147
148                data = (caddr_t)(fraghdr + 1);
149                memcpy(data, sdata, datalen);
150
151                if (isakmp_send(iph1, frag) < 0) {
152                        plog(LLV_ERROR, LOCATION, NULL, "isakmp_send failed\n");
153                        return -1;
154                }
155
156                vfree(frag);
157
158                len -= datalen;
159                sdata += datalen;
160        }
161               
162        return fragnum;
163}
164
165unsigned int 
166vendorid_frag_cap(gen)
167        struct isakmp_gen *gen;
168{
169        int *hp;
170
171        hp = (int *)(gen + 1);
172
173        return ntohl(hp[MD5_DIGEST_LENGTH / sizeof(*hp)]);
174}
175
176static int 
177isakmp_frag_insert(struct ph1handle *iph1, struct isakmp_frag_item *item)
178{
179        struct isakmp_frag_item *pitem = NULL;
180        struct isakmp_frag_item *citem = iph1->frag_chain;
181
182        /* no frag yet, just insert at beginning of list */
183        if (iph1->frag_chain == NULL) {
184                iph1->frag_chain = item;
185                return 0;
186        }
187
188        do {
189                /* duplicate fragment number, abort (CVE-2016-10396) */
190                if (citem->frag_num == item->frag_num)
191                        return -1;
192
193                /* need to insert before current item */
194                if (citem->frag_num > item->frag_num) {
195                        if (pitem != NULL)
196                                pitem->frag_next = item;
197                        else
198                                /* insert at the beginning of the list  */
199                                iph1->frag_chain = item;
200                        item->frag_next = citem;
201                        return 0;
202                }
203
204                pitem = citem;
205                citem = citem->frag_next;
206        } while (citem != NULL);
207
208        /* we reached the end of the list, insert */
209        pitem->frag_next = item;
210        return 0;
211}
212
213int 
214isakmp_frag_extract(iph1, msg)
215        struct ph1handle *iph1;
216        vchar_t *msg;
217{
218        struct isakmp *isakmp;
219        struct isakmp_frag *frag;
220        struct isakmp_frag_item *item;
221        vchar_t *buf;
222        size_t len;
223        int last_frag = 0;
224        char *data;
225        int i;
226
227        if (msg->l < sizeof(*isakmp) + sizeof(*frag)) {
228                plog(LLV_ERROR, LOCATION, NULL, "Message too short\n");
229                return -1;
230        }
231
232        isakmp = (struct isakmp *)msg->v;
233        frag = (struct isakmp_frag *)(isakmp + 1);
234
235        /*
236         * frag->len is the frag payload data plus the frag payload header,
237         * whose size is sizeof(*frag)
238         */
239        if (msg->l < sizeof(*isakmp) + ntohs(frag->len) ||
240            ntohs(frag->len) < sizeof(*frag) + 1) {
241                plog(LLV_ERROR, LOCATION, NULL, "Fragment too short\n");
242                return -1;
243        }
244
245        if ((buf = vmalloc(ntohs(frag->len) - sizeof(*frag))) == NULL) {
246                plog(LLV_ERROR, LOCATION, NULL, "Cannot allocate memory\n");
247                return -1;
248        }
249
250        if ((item = racoon_malloc(sizeof(*item))) == NULL) {
251                plog(LLV_ERROR, LOCATION, NULL, "Cannot allocate memory\n");
252                vfree(buf);
253                return -1;
254        }
255
256        data = (char *)(frag + 1);
257        memcpy(buf->v, data, buf->l);
258
259        item->frag_num = frag->index;
260        item->frag_last = (frag->flags & ISAKMP_FRAG_LAST);
261        item->frag_next = NULL;
262        item->frag_packet = buf;
263
264        /* Check for the last frag before inserting the new item in the chain */
265        if (item->frag_last) {
266                /* if we have the last fragment, indices must match */
267                if (iph1->frag_last_index != 0 &&
268                    item->frag_last != iph1->frag_last_index) {
269                        plog(LLV_ERROR, LOCATION, NULL,
270                             "Repeated last fragment index mismatch\n");
271                        racoon_free(item);
272                        vfree(buf);
273                        return -1;
274                }
275
276                last_frag = iph1->frag_last_index = item->frag_num;
277        }
278
279        /* insert fragment into chain */
280        if (isakmp_frag_insert(iph1, item) == -1) {
281                plog(LLV_ERROR, LOCATION, NULL,
282                    "Repeated fragment index mismatch\n");
283                racoon_free(item);
284                vfree(buf);
285                return -1;
286        }
287
288        /* If we saw the last frag, check if the chain is complete
289         * we have a sorted list now, so just walk through */
290        if (last_frag != 0) {
291                item = iph1->frag_chain;
292                for (i = 1; i <= last_frag; i++) {
293                        if (item->frag_num != i)
294                                break;
295                        item = item->frag_next;
296                        if (item == NULL) /* Not found */
297                                break;
298                }
299
300                if (i > last_frag) /* It is complete */
301                        return 1;
302        }
303               
304        return 0;
305}
306
307vchar_t *
308isakmp_frag_reassembly(iph1)
309        struct ph1handle *iph1;
310{
311        struct isakmp_frag_item *item;
312        size_t len = 0;
313        vchar_t *buf = NULL;
314        int frag_count = 0;
315        int i;
316        char *data;
317
318        if ((item = iph1->frag_chain) == NULL) {
319                plog(LLV_ERROR, LOCATION, NULL, "No fragment to reassemble\n");
320                goto out;
321        }
322
323        do {
324                frag_count++;
325                len += item->frag_packet->l;
326                item = item->frag_next;
327        } while (item != NULL);
328       
329        if ((buf = vmalloc(len)) == NULL) {
330                plog(LLV_ERROR, LOCATION, NULL, "Cannot allocate memory\n");
331                goto out;
332        }
333        data = buf->v;
334
335        item = iph1->frag_chain;
336        for (i = 1; i <= frag_count; i++) {
337                if (item->frag_num != i) {
338                        plog(LLV_ERROR, LOCATION, NULL, 
339                            "Missing fragment #%d\n", i);
340                        vfree(buf);
341                        buf = NULL;
342                        goto out;
343                }
344                memcpy(data, item->frag_packet->v, item->frag_packet->l);
345                data += item->frag_packet->l;
346                item = item->frag_next;
347        }
348
349out:
350        item = iph1->frag_chain;               
351        do {
352                struct isakmp_frag_item *next_item;
353
354                next_item = item->frag_next;
355
356                vfree(item->frag_packet);
357                racoon_free(item);
358
359                item = next_item;
360        } while (item != NULL);
361
362        iph1->frag_chain = NULL;
363
364        return buf;
365}
366
367vchar_t *
368isakmp_frag_addcap(buf, cap)
369        vchar_t *buf;
370        int cap;
371{
372        int *capp;
373        size_t len;
374
375        /* If the capability has not been added, add room now */
376        len = buf->l;
377        if (len == MD5_DIGEST_LENGTH) {
378                if ((buf = vrealloc(buf, len + sizeof(cap))) == NULL) {
379                        plog(LLV_ERROR, LOCATION, NULL, 
380                            "Cannot allocate memory\n");
381                        return NULL;
382                }
383                capp = (int *)(buf->v + len);
384                *capp = htonl(0);
385        }
386
387        capp = (int *)(buf->v + MD5_DIGEST_LENGTH);
388        *capp |= htonl(cap);
389
390        return buf;
391}
392
Note: See TracBrowser for help on using the repository browser.