![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / encoding|
Return to parser.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / encoding |
1.1 misho 1: /*
2: * Copyright (C) 2005-2009 Martin Willi
3: * Copyright (C) 2005 Jan Hutter
4: * HSR Hochschule fuer Technik Rapperswil
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #include <stdlib.h>
18: #include <string.h>
19:
20: #include "parser.h"
21:
22: #include <library.h>
23: #include <daemon.h>
24: #include <collections/linked_list.h>
25: #include <encoding/payloads/encodings.h>
26: #include <encoding/payloads/payload.h>
27: #include <encoding/payloads/sa_payload.h>
28: #include <encoding/payloads/proposal_substructure.h>
29: #include <encoding/payloads/transform_substructure.h>
30: #include <encoding/payloads/transform_attribute.h>
31: #include <encoding/payloads/ke_payload.h>
32: #include <encoding/payloads/nonce_payload.h>
33: #include <encoding/payloads/id_payload.h>
34: #include <encoding/payloads/notify_payload.h>
35: #include <encoding/payloads/encrypted_payload.h>
36: #include <encoding/payloads/auth_payload.h>
37: #include <encoding/payloads/cert_payload.h>
38: #include <encoding/payloads/certreq_payload.h>
39: #include <encoding/payloads/ts_payload.h>
40: #include <encoding/payloads/delete_payload.h>
41: #include <encoding/payloads/vendor_id_payload.h>
42: #include <encoding/payloads/cp_payload.h>
43: #include <encoding/payloads/configuration_attribute.h>
44: #include <encoding/payloads/eap_payload.h>
45: #include <encoding/payloads/unknown_payload.h>
46:
47:
48: typedef struct private_parser_t private_parser_t;
49:
50: /**
51: * Private data stored in a context.
52: *
53: * Contains pointers and counters to store current state.
54: */
55: struct private_parser_t {
56: /**
57: * Public members, see parser_t.
58: */
59: parser_t public;
60:
61: /**
62: * major IKE version
63: */
64: uint8_t major_version;
65:
66: /**
67: * Current bit for reading in input data.
68: */
69: uint8_t bit_pos;
70:
71: /**
72: * Current byte for reading in input data.
73: */
74: uint8_t *byte_pos;
75:
76: /**
77: * Input data to parse.
78: */
79: uint8_t *input;
80:
81: /**
82: * Roof of input, used for length-checking.
83: */
84: uint8_t *input_roof;
85:
86: /**
87: * Set of encoding rules for this parsing session.
88: */
89: encoding_rule_t *rules;
90: };
91:
92: /**
93: * Log invalid length error
94: */
95: static bool short_input(private_parser_t *this, int number)
96: {
97: DBG1(DBG_ENC, " not enough input to parse rule %d %N",
98: number, encoding_type_names, this->rules[number].type);
99: return FALSE;
100: }
101:
102: /**
103: * Log unaligned rules
104: */
105: static bool bad_bitpos(private_parser_t *this, int number)
106: {
107: DBG1(DBG_ENC, " found rule %d %N on bitpos %d",
108: number, encoding_type_names, this->rules[number].type, this->bit_pos);
109: return FALSE;
110: }
111:
112: /**
113: * Parse a 4-Bit unsigned integer from the current parsing position.
114: */
115: static bool parse_uint4(private_parser_t *this, int rule_number,
116: uint8_t *output_pos)
117: {
118: if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
119: {
120: return short_input(this, rule_number);
121: }
122: switch (this->bit_pos)
123: {
124: case 0:
125: if (output_pos)
126: {
127: *output_pos = *(this->byte_pos) >> 4;
128: }
129: this->bit_pos = 4;
130: break;
131: case 4:
132: if (output_pos)
133: {
134: *output_pos = *(this->byte_pos) & 0x0F;
135: }
136: this->bit_pos = 0;
137: this->byte_pos++;
138: break;
139: default:
140: return bad_bitpos(this, rule_number);
141: }
142: if (output_pos)
143: {
144: DBG3(DBG_ENC, " => %hhu", *output_pos);
145: }
146: return TRUE;
147: }
148:
149: /**
150: * Parse a 8-Bit unsigned integer from the current parsing position.
151: */
152: static bool parse_uint8(private_parser_t *this, int rule_number,
153: uint8_t *output_pos)
154: {
155: if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
156: {
157: return short_input(this, rule_number);
158: }
159: if (this->bit_pos)
160: {
161: return bad_bitpos(this, rule_number);
162: }
163: if (output_pos)
164: {
165: *output_pos = *(this->byte_pos);
166: DBG3(DBG_ENC, " => %hhu", *output_pos);
167: }
168: this->byte_pos++;
169: return TRUE;
170: }
171:
172: /**
173: * Parse a 15-Bit unsigned integer from the current parsing position.
174: */
175: static bool parse_uint15(private_parser_t *this, int rule_number,
176: uint16_t *output_pos)
177: {
178: if (this->byte_pos + sizeof(uint16_t) > this->input_roof)
179: {
180: return short_input(this, rule_number);
181: }
182: if (this->bit_pos != 1)
183: {
184: return bad_bitpos(this, rule_number);
185: }
186: if (output_pos)
187: {
188: memcpy(output_pos, this->byte_pos, sizeof(uint16_t));
189: *output_pos = ntohs(*output_pos) & ~0x8000;
190: DBG3(DBG_ENC, " => %hu", *output_pos);
191: }
192: this->byte_pos += sizeof(uint16_t);
193: this->bit_pos = 0;
194: return TRUE;
195: }
196:
197: /**
198: * Parse a 16-Bit unsigned integer from the current parsing position.
199: */
200: static bool parse_uint16(private_parser_t *this, int rule_number,
201: uint16_t *output_pos)
202: {
203: if (this->byte_pos + sizeof(uint16_t) > this->input_roof)
204: {
205: return short_input(this, rule_number);
206: }
207: if (this->bit_pos)
208: {
209: return bad_bitpos(this, rule_number);
210: }
211: if (output_pos)
212: {
213: memcpy(output_pos, this->byte_pos, sizeof(uint16_t));
214: *output_pos = ntohs(*output_pos);
215: DBG3(DBG_ENC, " => %hu", *output_pos);
216: }
217: this->byte_pos += sizeof(uint16_t);
218: return TRUE;
219: }
220: /**
221: * Parse a 32-Bit unsigned integer from the current parsing position.
222: */
223: static bool parse_uint32(private_parser_t *this, int rule_number,
224: uint32_t *output_pos)
225: {
226: if (this->byte_pos + sizeof(uint32_t) > this->input_roof)
227: {
228: return short_input(this, rule_number);
229: }
230: if (this->bit_pos)
231: {
232: return bad_bitpos(this, rule_number);
233: }
234: if (output_pos)
235: {
236: memcpy(output_pos, this->byte_pos, sizeof(uint32_t));
237: *output_pos = ntohl(*output_pos);
238: DBG3(DBG_ENC, " => %u", *output_pos);
239: }
240: this->byte_pos += sizeof(uint32_t);
241: return TRUE;
242: }
243:
244: /**
245: * Parse a given amount of bytes and writes them to a specific location
246: */
247: static bool parse_bytes(private_parser_t *this, int rule_number,
248: uint8_t *output_pos, int bytes)
249: {
250: if (this->byte_pos + bytes > this->input_roof)
251: {
252: return short_input(this, rule_number);
253: }
254: if (this->bit_pos)
255: {
256: return bad_bitpos(this, rule_number);
257: }
258: if (output_pos)
259: {
260: memcpy(output_pos, this->byte_pos, bytes);
261: DBG3(DBG_ENC, " %b", output_pos, bytes);
262: }
263: this->byte_pos += bytes;
264: return TRUE;
265: }
266:
267: /**
268: * Parse a single Bit from the current parsing position
269: */
270: static bool parse_bit(private_parser_t *this, int rule_number,
271: bool *output_pos)
272: {
273: if (this->byte_pos + sizeof(uint8_t) > this->input_roof)
274: {
275: return short_input(this, rule_number);
276: }
277: if (output_pos)
278: {
279: uint8_t mask;
280: mask = 0x01 << (7 - this->bit_pos);
281: *output_pos = *this->byte_pos & mask;
282:
283: if (*output_pos)
284: { /* set to a "clean", comparable true */
285: *output_pos = TRUE;
286: }
287: DBG3(DBG_ENC, " => %d", *output_pos);
288: }
289: this->bit_pos = (this->bit_pos + 1) % 8;
290: if (this->bit_pos == 0)
291: {
292: this->byte_pos++;
293: }
294: return TRUE;
295: }
296:
297: /**
298: * Parse substructures in a list.
299: */
300: static bool parse_list(private_parser_t *this, int rule_number,
301: linked_list_t **output_pos, payload_type_t payload_type, int length)
302: {
303: linked_list_t *list = *output_pos;
304:
305: if (length < 0)
306: {
307: return short_input(this, rule_number);
308: }
309: if (this->bit_pos)
310: {
311: return bad_bitpos(this, rule_number);
312: }
313: while (length > 0)
314: {
315: uint8_t *pos_before = this->byte_pos;
316: payload_t *payload;
317:
318: DBG2(DBG_ENC, " %d bytes left, parsing recursively %N",
319: length, payload_type_names, payload_type);
320:
321: if (this->public.parse_payload(&this->public, payload_type,
322: &payload) != SUCCESS)
323: {
324: DBG1(DBG_ENC, " parsing of a %N substructure failed",
325: payload_type_names, payload_type);
326: return FALSE;
327: }
328: list->insert_last(list, payload);
329: length -= this->byte_pos - pos_before;
330: }
331: if (length != 0)
332: { /* must yield exactly to zero */
333: DBG1(DBG_ENC, " length of %N substructure list invalid",
334: payload_type_names, payload_type);
335: return FALSE;
336: }
337: *output_pos = list;
338: return TRUE;
339: }
340:
341: /**
342: * Parse data from current parsing position in a chunk.
343: */
344: static bool parse_chunk(private_parser_t *this, int rule_number,
345: chunk_t *output_pos, int length)
346: {
347: if (this->byte_pos + length > this->input_roof)
348: {
349: return short_input(this, rule_number);
350: }
351: if (this->bit_pos)
352: {
353: return bad_bitpos(this, rule_number);
354: }
355: if (output_pos)
356: {
357: *output_pos = chunk_alloc(length);
358: memcpy(output_pos->ptr, this->byte_pos, length);
359: DBG3(DBG_ENC, " %b", output_pos->ptr, length);
360: }
361: this->byte_pos += length;
362: return TRUE;
363: }
364:
365: METHOD(parser_t, parse_payload, status_t,
366: private_parser_t *this, payload_type_t payload_type, payload_t **payload)
367: {
368: payload_t *pld;
369: void *output;
370: int payload_length = 0, spi_size = 0, attribute_length = 0, header_length;
371: uint16_t ts_type = 0;
372: bool attribute_format = FALSE;
373: int rule_number, rule_count;
374: encoding_rule_t *rule;
375:
376: /* create instance of the payload to parse */
377: if (payload_is_known(payload_type, this->major_version))
378: {
379: pld = payload_create(payload_type);
380: }
381: else
382: {
383: pld = (payload_t*)unknown_payload_create(payload_type);
384: }
385:
386: DBG2(DBG_ENC, "parsing %N payload, %d bytes left",
387: payload_type_names, payload_type, this->input_roof - this->byte_pos);
388:
389: DBG3(DBG_ENC, "parsing payload from %b",
390: this->byte_pos, (u_int)(this->input_roof - this->byte_pos));
391:
392: /* base pointer for output, avoids casting in every rule */
393: output = pld;
394: /* parse the payload with its own rules */
395: rule_count = pld->get_encoding_rules(pld, &this->rules);
396: for (rule_number = 0; rule_number < rule_count; rule_number++)
397: {
398: /* update header length for each rule, as it is dynamic (SPIs) */
399: header_length = pld->get_header_length(pld);
400:
401: rule = &(this->rules[rule_number]);
402: DBG2(DBG_ENC, " parsing rule %d %N",
403: rule_number, encoding_type_names, rule->type);
404: switch ((int)rule->type)
405: {
406: case U_INT_4:
407: {
408: if (!parse_uint4(this, rule_number, output + rule->offset))
409: {
410: pld->destroy(pld);
411: return PARSE_ERROR;
412: }
413: break;
414: }
415: case U_INT_8:
416: case RESERVED_BYTE:
417: {
418: if (!parse_uint8(this, rule_number, output + rule->offset))
419: {
420: pld->destroy(pld);
421: return PARSE_ERROR;
422: }
423: break;
424: }
425: case U_INT_16:
426: {
427: if (!parse_uint16(this, rule_number, output + rule->offset))
428: {
429: pld->destroy(pld);
430: return PARSE_ERROR;
431: }
432: break;
433: }
434: case U_INT_32:
435: case HEADER_LENGTH:
436: {
437: if (!parse_uint32(this, rule_number, output + rule->offset))
438: {
439: pld->destroy(pld);
440: return PARSE_ERROR;
441: }
442: break;
443: }
444: case IKE_SPI:
445: {
446: if (!parse_bytes(this, rule_number, output + rule->offset, 8))
447: {
448: pld->destroy(pld);
449: return PARSE_ERROR;
450: }
451: break;
452: }
453: case RESERVED_BIT:
454: case FLAG:
455: {
456: if (!parse_bit(this, rule_number, output + rule->offset))
457: {
458: pld->destroy(pld);
459: return PARSE_ERROR;
460: }
461: break;
462: }
463: case PAYLOAD_LENGTH:
464: {
465: if (!parse_uint16(this, rule_number, output + rule->offset))
466: {
467: pld->destroy(pld);
468: return PARSE_ERROR;
469: }
470: /* parsed u_int16 should be aligned */
471: payload_length = *(uint16_t*)(output + rule->offset);
472: /* all payloads must have at least 4 bytes header */
473: if (payload_length < 4)
474: {
475: pld->destroy(pld);
476: return PARSE_ERROR;
477: }
478: break;
479: }
480: case SPI_SIZE:
481: {
482: if (!parse_uint8(this, rule_number, output + rule->offset))
483: {
484: pld->destroy(pld);
485: return PARSE_ERROR;
486: }
487: spi_size = *(uint8_t*)(output + rule->offset);
488: break;
489: }
490: case SPI:
491: {
492: if (!parse_chunk(this, rule_number, output + rule->offset,
493: spi_size))
494: {
495: pld->destroy(pld);
496: return PARSE_ERROR;
497: }
498: break;
499: }
500: case PAYLOAD_LIST + PLV2_PROPOSAL_SUBSTRUCTURE:
501: case PAYLOAD_LIST + PLV1_PROPOSAL_SUBSTRUCTURE:
502: case PAYLOAD_LIST + PLV2_TRANSFORM_SUBSTRUCTURE:
503: case PAYLOAD_LIST + PLV1_TRANSFORM_SUBSTRUCTURE:
504: case PAYLOAD_LIST + PLV2_TRANSFORM_ATTRIBUTE:
505: case PAYLOAD_LIST + PLV1_TRANSFORM_ATTRIBUTE:
506: case PAYLOAD_LIST + PLV2_CONFIGURATION_ATTRIBUTE:
507: case PAYLOAD_LIST + PLV1_CONFIGURATION_ATTRIBUTE:
508: case PAYLOAD_LIST + PLV2_TRAFFIC_SELECTOR_SUBSTRUCTURE:
509: {
510: if (payload_length < header_length ||
511: !parse_list(this, rule_number, output + rule->offset,
512: rule->type - PAYLOAD_LIST,
513: payload_length - header_length))
514: {
515: pld->destroy(pld);
516: return PARSE_ERROR;
517: }
518: break;
519: }
520: case CHUNK_DATA:
521: {
522: if (payload_length < header_length ||
523: !parse_chunk(this, rule_number, output + rule->offset,
524: payload_length - header_length))
525: {
526: pld->destroy(pld);
527: return PARSE_ERROR;
528: }
529: break;
530: }
531: case ENCRYPTED_DATA:
532: {
533: if (!parse_chunk(this, rule_number, output + rule->offset,
534: this->input_roof - this->byte_pos))
535: {
536: pld->destroy(pld);
537: return PARSE_ERROR;
538: }
539: break;
540: }
541: case ATTRIBUTE_FORMAT:
542: {
543: if (!parse_bit(this, rule_number, output + rule->offset))
544: {
545: pld->destroy(pld);
546: return PARSE_ERROR;
547: }
548: attribute_format = *(bool*)(output + rule->offset);
549: break;
550: }
551: case ATTRIBUTE_TYPE:
552: {
553: if (!parse_uint15(this, rule_number, output + rule->offset))
554: {
555: pld->destroy(pld);
556: return PARSE_ERROR;
557: }
558: break;
559: }
560: case ATTRIBUTE_LENGTH:
561: {
562: if (!parse_uint16(this, rule_number, output + rule->offset))
563: {
564: pld->destroy(pld);
565: return PARSE_ERROR;
566: }
567: attribute_length = *(uint16_t*)(output + rule->offset);
568: break;
569: }
570: case ATTRIBUTE_LENGTH_OR_VALUE:
571: {
572: if (!parse_uint16(this, rule_number, output + rule->offset))
573: {
574: pld->destroy(pld);
575: return PARSE_ERROR;
576: }
577: attribute_length = *(uint16_t*)(output + rule->offset);
578: break;
579: }
580: case ATTRIBUTE_VALUE:
581: {
582: if (attribute_format == FALSE &&
583: !parse_chunk(this, rule_number, output + rule->offset,
584: attribute_length))
585: {
586: pld->destroy(pld);
587: return PARSE_ERROR;
588: }
589: break;
590: }
591: case TS_TYPE:
592: {
593: if (!parse_uint8(this, rule_number, output + rule->offset))
594: {
595: pld->destroy(pld);
596: return PARSE_ERROR;
597: }
598: ts_type = *(uint8_t*)(output + rule->offset);
599: break;
600: }
601: case ADDRESS:
602: {
603: int address_length = (ts_type == TS_IPV4_ADDR_RANGE) ? 4 : 16;
604:
605: if (!parse_chunk(this, rule_number, output + rule->offset,
606: address_length))
607: {
608: pld->destroy(pld);
609: return PARSE_ERROR;
610: }
611: break;
612: }
613: default:
614: {
615: DBG1(DBG_ENC, " no rule to parse rule %d %N",
616: rule_number, encoding_type_names, rule->type);
617: pld->destroy(pld);
618: return PARSE_ERROR;
619: }
620: }
621: /* process next rule */
622: rule++;
623: }
624:
625: *payload = pld;
626: DBG2(DBG_ENC, "parsing %N payload finished",
627: payload_type_names, payload_type);
628: return SUCCESS;
629: }
630:
631: METHOD(parser_t, get_remaining_byte_count, int,
632: private_parser_t *this)
633: {
634: return this->input_roof - this->byte_pos;
635: }
636:
637: METHOD(parser_t, reset_context, void,
638: private_parser_t *this)
639: {
640: this->byte_pos = this->input;
641: this->bit_pos = 0;
642: }
643:
644: METHOD(parser_t, set_major_version, void,
645: private_parser_t *this, uint8_t major_version)
646: {
647: this->major_version = major_version;
648: }
649:
650: METHOD(parser_t, destroy, void,
651: private_parser_t *this)
652: {
653: free(this);
654: }
655:
656: /*
657: * Described in header.
658: */
659: parser_t *parser_create(chunk_t data)
660: {
661: private_parser_t *this;
662:
663: INIT(this,
664: .public = {
665: .parse_payload = _parse_payload,
666: .reset_context = _reset_context,
667: .set_major_version = _set_major_version,
668: .get_remaining_byte_count = _get_remaining_byte_count,
669: .destroy = _destroy,
670: },
671: .input = data.ptr,
672: .byte_pos = data.ptr,
673: .input_roof = data.ptr + data.len,
674: );
675:
676: return &this->public;
677: }
678: