diff options
author | Martin Willi <martin@strongswan.org> | 2006-04-05 12:10:50 +0000 |
---|---|---|
committer | Martin Willi <martin@strongswan.org> | 2006-04-05 12:10:50 +0000 |
commit | 6862128151fb78f63685a8da5575783c426d64a7 (patch) | |
tree | 75920a6688ed5654fb917ecccc1e0e469480fd1f /Source/lib/asn1 | |
parent | 3dbbbf3e16366b0da33b29bbc1a4ba9a976e43a0 (diff) | |
download | strongswan-6862128151fb78f63685a8da5575783c426d64a7.tar.bz2 strongswan-6862128151fb78f63685a8da5575783c426d64a7.tar.xz |
../svn-commit.tmp
Diffstat (limited to 'Source/lib/asn1')
-rw-r--r-- | Source/lib/asn1/Makefile.asn1 | 24 | ||||
-rw-r--r-- | Source/lib/asn1/asn1.c | 74 | ||||
-rw-r--r-- | Source/lib/asn1/asn1.h | 172 | ||||
-rw-r--r-- | Source/lib/asn1/der_decoder.c | 502 | ||||
-rw-r--r-- | Source/lib/asn1/der_decoder.h | 79 | ||||
-rw-r--r-- | Source/lib/asn1/der_encoder.c | 218 | ||||
-rw-r--r-- | Source/lib/asn1/der_encoder.h | 60 |
7 files changed, 1129 insertions, 0 deletions
diff --git a/Source/lib/asn1/Makefile.asn1 b/Source/lib/asn1/Makefile.asn1 new file mode 100644 index 000000000..51ac17e3c --- /dev/null +++ b/Source/lib/asn1/Makefile.asn1 @@ -0,0 +1,24 @@ +# Copyright (C) 2005 Jan Hutter, Martin Willi +# Hochschule fuer Technik Rapperswil +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# + +ASN1_DIR= $(LIB_DIR)asn1/ + + +LIB_OBJS+= $(BUILD_DIR)asn1.o +$(BUILD_DIR)asn1.o : $(ASN1_DIR)asn1.c $(ASN1_DIR)asn1.h + $(CC) $(CFLAGS) -c -o $@ $< + +LIB_OBJS+= $(BUILD_DIR)der_decoder.o +$(BUILD_DIR)der_decoder.o : $(ASN1_DIR)der_decoder.c $(ASN1_DIR)der_decoder.h + $(CC) $(CFLAGS) -c -o $@ $<
\ No newline at end of file diff --git a/Source/lib/asn1/asn1.c b/Source/lib/asn1/asn1.c new file mode 100644 index 000000000..01952386c --- /dev/null +++ b/Source/lib/asn1/asn1.c @@ -0,0 +1,74 @@ +/** + * @file asn1.c + * + * @brief String mappings for asn1.h + * + */ + +/* + * Copyright (C) 2006 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include "asn1.h" + +mapping_t asn1_type_m[] = { + {ASN1_END, "ASN1_END"}, + {ASN1_BOOLEAN, "ASN1_BOOLEAN"}, + {ASN1_INTEGER, "ASN1_INTEGER"}, + {ASN1_BITSTRING, "ASN1_BITSTRING"}, + {ASN1_OCTETSTRING, "ASN1_OCTETSTRING"}, + {ASN1_NULL, "ASN1_NULL"}, + {ASN1_OID, "ASN1_OID"}, + {ASN1_ENUMERATED, "ASN1_ENUMERATED"}, + {ASN1_UTF8STRING, "ASN1_UTF8STRING"}, + {ASN1_NUMERICSTRING, "ASN1_NUMERICSTRING"}, + {ASN1_PRINTABLESTRING, "ASN1_PRINTABLESTRING"}, + {ASN1_T61STRING, "ASN1_T61STRING"}, + {ASN1_VIDEOTEXSTRING, "ASN1_VIDEOTEXSTRING"}, + {ASN1_IA5STRING, "ASN1_IA5STRING"}, + {ASN1_UTCTIME, "ASN1_UTCTIME"}, + {ASN1_GENERALIZEDTIME, "ASN1_GENERALIZEDTIME"}, + {ASN1_GRAPHICSTRING, "ASN1_GRAPHICSTRING"}, + {ASN1_VISIBLESTRING, "ASN1_VISIBLESTRING"}, + {ASN1_GENERALSTRING, "ASN1_GENERALSTRING"}, + {ASN1_UNIVERSALSTRING, "ASN1_UNIVERSALSTRING"}, + {ASN1_BMPSTRING, "ASN1_BMPSTRING"}, + {ASN1_CONSTRUCTED, "ASN1_CONSTRUCTED"}, + {ASN1_SEQUENCE, "ASN1_SEQUENCE"}, + {ASN1_SET, "ASN1_SET"}, + {ASN1_TAG_E_0, "ASN1_TAG_E_0"}, + {ASN1_TAG_E_1, "ASN1_TAG_E_1"}, + {ASN1_TAG_E_2, "ASN1_TAG_E_2"}, + {ASN1_TAG_E_3, "ASN1_TAG_E_3"}, + {ASN1_TAG_E_4, "ASN1_TAG_E_4"}, + {ASN1_TAG_E_5, "ASN1_TAG_E_5"}, + {ASN1_TAG_E_6, "ASN1_TAG_E_6"}, + {ASN1_TAG_E_7, "ASN1_TAG_E_7"}, + {ASN1_TAG_I_0, "ASN1_TAG_I_0"}, + {ASN1_TAG_I_1, "ASN1_TAG_I_1"}, + {ASN1_TAG_I_2, "ASN1_TAG_I_2"}, + {ASN1_TAG_I_3, "ASN1_TAG_I_3"}, + {ASN1_TAG_I_4, "ASN1_TAG_I_4"}, + {ASN1_TAG_I_5, "ASN1_TAG_I_5"}, + {ASN1_TAG_I_6, "ASN1_TAG_I_6"}, + {ASN1_TAG_I_7, "ASN1_TAG_I_7"}, + {ASN1_CHOICE, "ASN1_CHOICE"}, +}; + +mapping_t asn1_flag_m[] = { + {ASN1_OPTIONAL, "ASN1_OPTIONAL"}, + {ASN1_DEFAULT, "ASN1_DEFAULT"}, + {ASN1_MPZ, "ASN1_MPZ"}, + {ASN1_OF, "ASN1_OF"}, +}; diff --git a/Source/lib/asn1/asn1.h b/Source/lib/asn1/asn1.h new file mode 100644 index 000000000..894f048d2 --- /dev/null +++ b/Source/lib/asn1/asn1.h @@ -0,0 +1,172 @@ +/** + * @file asn1.h + * + * @brief Definition of asn1_rule_t and other ASN1 stuff. + * + */ + +/* + * Copyright (C) 2006 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#ifndef ASN1_H_ +#define ASN1_H_ + +#include <types.h> + +typedef enum asn1_type_t asn1_type_t; + +/** + * @brief Real and some special ASN1 types. + * + * @ingroup asn1 + */ +enum asn1_type_t { + /** + * End of a sequence, set, choice + */ + ASN1_END = 0x00, + ASN1_BOOLEAN = 0x01, + ASN1_INTEGER = 0x02, + ASN1_BITSTRING = 0x03, + ASN1_OCTETSTRING = 0x04, + ASN1_NULL = 0x05, + ASN1_OID = 0x06, + ASN1_ENUMERATED = 0x0A, + ASN1_UTF8STRING = 0x0C, + ASN1_NUMERICSTRING = 0x12, + ASN1_PRINTABLESTRING = 0x13, + ASN1_T61STRING = 0x14, + ASN1_VIDEOTEXSTRING = 0x15, + ASN1_IA5STRING = 0x16, + ASN1_UTCTIME = 0x17, + ASN1_GENERALIZEDTIME = 0x18, + ASN1_GRAPHICSTRING = 0x19, + ASN1_VISIBLESTRING = 0x1A, + ASN1_GENERALSTRING = 0x1B, + ASN1_UNIVERSALSTRING = 0x1C, + ASN1_BMPSTRING = 0x1E, + ASN1_CONSTRUCTED = 0x20, + ASN1_SEQUENCE = 0x30, + ASN1_SET = 0x31, + /** + * EXCPLICIT tags + */ + ASN1_TAG_E_0 = 0xA0, + ASN1_TAG_E_1 = 0xA1, + ASN1_TAG_E_2 = 0xA2, + ASN1_TAG_E_3 = 0xA3, + ASN1_TAG_E_4 = 0xA4, + ASN1_TAG_E_5 = 0xA5, + ASN1_TAG_E_6 = 0xA6, + ASN1_TAG_E_7 = 0xA7, + /** + * IMPLICIT tags + */ + ASN1_TAG_I_0 = 0x80, + ASN1_TAG_I_1 = 0x81, + ASN1_TAG_I_2 = 0x82, + ASN1_TAG_I_3 = 0x83, + ASN1_TAG_I_4 = 0x84, + ASN1_TAG_I_5 = 0x85, + ASN1_TAG_I_6 = 0x86, + ASN1_TAG_I_7 = 0x87, + /** + * Begin of a choice + */ + ASN1_CHOICE = 0xFE, + /** + * ANY type + */ + ASN1_ANY = 0xFF, +}; + +/** + * String mappings for asn1_type_t + */ +extern mapping_t asn1_type_m[]; + + +typedef enum asn1_flag_t asn1_flag_t; + +/** + * @brief Flags used to build ASN1 rules. + * + * @ingroup asn1 + */ +enum asn1_flag_t { + /** + * Field is optional + */ + ASN1_OPTIONAL = 0x01, + /** + * Field has a default value and is therefore optional + */ + ASN1_DEFAULT = 0x02, + /** + * Convert this INTEGER to an mpz_t + */ + ASN1_MPZ = 0x04, + /** + * SEQUENCE or SET OF + */ + ASN1_OF = 0x08, + /** + * Parse this Sequence in a RAW chunk too. + * Used for crypto calculations... + */ + ASN1_RAW = 0x10, +}; + +/** + * String mappings for asn1_flag_t + */ +extern mapping_t asn1_flag_m[]; + + +typedef struct asn1_rule_t asn1_rule_t; + +/** + * @brief Single rule of a complet ruleset. + * + * This rule containing a type, flags and additional + * data allow modellation of complex ASN1 structures and + * allow their en- and decoding... + * + * @ingroup asn1 + */ +struct asn1_rule_t { + /** + * ASN1 type + */ + asn1_type_t type; + /** + * implicit or explicit tag, if any + */ + asn1_flag_t flags; + /** + * offset of data in structure + */ + u_int data_offset; + /** + * offset to a boolean, which says if optional + * data is available at data_offset. Used if + * flags & ASN1_OPTIONAL. + * default value, used if flags & ASN1_DEFAULT + */ + u_int additional; +}; + + +#endif /* ASN1_H_ */ diff --git a/Source/lib/asn1/der_decoder.c b/Source/lib/asn1/der_decoder.c new file mode 100644 index 000000000..f9a8425c1 --- /dev/null +++ b/Source/lib/asn1/der_decoder.c @@ -0,0 +1,502 @@ +/** + * @file der_decoder.c + * + * @brief Implementation of der_decoder_t. + */ + +/* + * Copyright (C) 2000-2004 Andreas Steffen + * Copyright (C) 2006 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * Some parts taken over from pluto/asn1.c + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include <gmp.h> + +#include "der_decoder.h" + +#include <utils/allocator.h> +#include <daemon.h> + + + +typedef struct private_der_decoder_t private_der_decoder_t; + +/** + * Private data of a der_decoder_t object. + */ +struct private_der_decoder_t { + /** + * Public interface for this signer. + */ + der_decoder_t public; + + /** + * Rule which was just processed + */ + asn1_rule_t *rule; + + /** + * First rule of the whole ruleset + */ + asn1_rule_t *first_rule; + + /** + * Output data struct + */ + void *output; + + /** + * Complex things like this need a logger ;-) + */ + logger_t *logger; +}; + +status_t read_hdr(private_der_decoder_t *this, chunk_t *data); + +/** + * Read a sequence from data, parse its contents recursivly + */ +status_t read_sequence(private_der_decoder_t *this, chunk_t data) +{ + status_t status; + asn1_rule_t *next_rule; + + while(TRUE) + { + next_rule = this->rule + 1; + if (next_rule->type == ASN1_END) + { + this->rule++; + break; + } + status = read_hdr(this, &data); + if (status != SUCCESS) + { + return status; + } + } + + this->logger->log(this->logger, CONTROL|LEVEL2, "Sequence end"); + return SUCCESS; +} + +/** + * Read choice of data, parse if one of the choosable types arise + */ +status_t read_choice(private_der_decoder_t *this, chunk_t *data) +{ + status_t status = PARSE_ERROR; + asn1_rule_t *next_rule; + bool found = FALSE; + + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "Choice data", *data); + + while(TRUE) + { + next_rule = this->rule + 1; + if (next_rule->type == ASN1_END) + { + this->rule++; + return status; + } + if (!found && *(data->ptr) == next_rule->type) + { + found = TRUE; + status = read_hdr(this, data); + } + else + { + this->rule++; + } + } + this->logger->log(this->logger, CONTROL|LEVEL2, "Choice end"); + return status; +} + +/** + * Read a utc or generalized time + */ +status_t read_time(private_der_decoder_t *this, chunk_t data) +{ + struct tm t; + time_t tz_offset; + u_char *eot = NULL; + const char* format; + time_t *result = (time_t*)((u_int8_t*)this->output + this->rule->data_offset); + + /* TODO: Test it */ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "TIME", data); + + if ((eot = memchr(data.ptr, 'Z', data.len)) != NULL) + { + /* Zulu time with a zero time zone offset */ + tz_offset = 0; + } + else if ((eot = memchr(data.ptr, '+', data.len)) != NULL) + { + int tz_hour, tz_min; + + sscanf(eot+1, "%2d%2d", &tz_hour, &tz_min); + /* positive time zone offset */ + tz_offset = 3600*tz_hour + 60*tz_min; + } + else if ((eot = memchr(data.ptr, '-', data.len)) != NULL) + { + int tz_hour, tz_min; + + sscanf(eot+1, "%2d%2d", &tz_hour, &tz_min); + /* negative time zone offset */ + tz_offset = -3600*tz_hour - 60*tz_min; + } + else + { + /* error in time format */ + return PARSE_ERROR; + } + + if (this->rule->type == ASN1_UTCTIME) + { + format = "%2d%2d%2d%2d%2d"; + } + else + { + format = "%4d%2d%2d%2d%2d"; + } + + sscanf(data.ptr, format, &t.tm_year, &t.tm_mon, &t.tm_mday, &t.tm_hour, &t.tm_min); + + /* is there a seconds field? */ + if ((eot - data.ptr) == ((this->rule->type == ASN1_UTCTIME)?12:14)) + { + sscanf(eot-2, "%2d", &t.tm_sec); + } + else + { + t.tm_sec = 0; + } + + /* representation of year */ + if (t.tm_year >= 1900) + { + t.tm_year -= 1900; + } + else if (t.tm_year >= 100) + { + return PARSE_ERROR; + } + else if (t.tm_year < 50) + { + t.tm_year += 100; + } + + /* representation of month 0..11*/ + t.tm_mon--; + + /* set daylight saving time to off */ + t.tm_isdst = 0; + + /* compensate timezone */ + + *result = mktime(&t) - timezone - tz_offset; + return SUCCESS; +} + +/** + * Read an integer as u_int or as mpz_t + */ +status_t read_int(private_der_decoder_t *this, chunk_t data) +{ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_INTEGER", data); + + if (this->rule->flags & ASN1_MPZ) + { + mpz_t *mpz = (mpz_t*)((u_int8_t*)this->output + this->rule->data_offset); + mpz_import(*mpz, data.len, 1, 1, 1, 0, data.ptr); + } + else + { + u_int *integ = (u_int*)((u_int8_t*)this->output + this->rule->data_offset); + + *integ = 0; + while (data.len-- > 0) + { + *integ = 256 * (*integ) + *data.ptr++; + } + } + return SUCCESS; +} + +/** + * Read boolean value + */ +status_t read_bool(private_der_decoder_t *this, chunk_t data) +{ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_BOOLEAN", data); + + bool *boolean = (u_int*)((u_int8_t*)this->output + this->rule->data_offset); + + *boolean = *data.ptr; + + return SUCCESS; +} + +/** + * Read an OID + */ +status_t read_oid(private_der_decoder_t *this, chunk_t data) +{ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_OID", data); + /* TODO: OID parsing stuff */ + return SUCCESS; +} + +/** + * Read a bitstring + */ +status_t read_bitstring(private_der_decoder_t *this, chunk_t data) +{ + /* TODO: cleanly determine amount of unused bits */ + + /* skip "unused-bits-in-following-byte"-byte */ + data.ptr += 1; + data.len -= 1; + + if (data.len < 1) + { + return FAILED; + } + + chunk_t *chunk = (chunk_t*)((u_int8_t*)this->output + this->rule->data_offset); + + *chunk = allocator_clone_chunk(data); + + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_BITSTRING", data); + return SUCCESS; +} + +/** + * Read any type which appears in a chunk + */ +status_t read_any(private_der_decoder_t *this, chunk_t data) +{ + chunk_t *chunk = (chunk_t*)((u_int8_t*)this->output + this->rule->data_offset); + + *chunk = allocator_clone_chunk(data); + + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_ANY", data); + return SUCCESS; +} + +/** + * Read the length field of a type + */ +u_int32_t read_length(chunk_t *data) +{ + u_int8_t n; + size_t len; + + if (data->len < 1) + { + return -1; + } + + /* read first octet of length field */ + n = *data->ptr; + data->ptr++; data->len--; + + if ((n & 0x80) == 0) + { + /* single length octet */ + return n; + } + + /* composite length, determine number of length octets */ + n &= 0x7f; + + if (n > data->len) + { + /* length longer than available bytes */ + return -1; + } + + if (n > sizeof(len)) + { + /* larger than size_t can hold */ + return -1; + } + + len = 0; + while (n-- > 0) + { + len = 256 * len + *data->ptr; + data->ptr++; data->len--; + } + return len; +} + +/** + * Read the next field + */ +status_t read_hdr(private_der_decoder_t *this, chunk_t *data) +{ + chunk_t inner; + /* TODO: Redo this that an average mid-european can understand it */ + +beginning: + /* advance to the next rule */ + this->rule++; + + this->logger->log(this->logger, CONTROL|LEVEL2, "reading rule %d %s", + this->rule - this->first_rule, + mapping_find(asn1_type_m, this->rule->type)); + + switch (this->rule->type) + { + case ASN1_END: + /* ignore, handled outside */ + return SUCCESS; + case ASN1_CHOICE: + /* CHOICE has no type/length */ + break; + default: + /* anything else has type/length */ + if (data->len == 0) + { + goto beginning; + } + this->logger->log_chunk(this->logger, CONTROL|LEVEL3, "reading from:", *data); + + /* read type, advance in data */ + if (this->rule->type != ASN1_ANY && *(data->ptr) != this->rule->type) + { + if (this->rule->flags & ASN1_OPTIONAL) + { + goto beginning; + } + if (this->rule->flags & ASN1_DEFAULT) + { + goto beginning; + } + this->logger->log(this->logger, CONTROL|LEVEL2, "Bad byte found: %x, %x expected", + *data->ptr, this->rule->type); + return PARSE_ERROR; + } + data->ptr++; + data->len--; + + /* read length, advance in data */ + inner.len = read_length(data); + if (inner.len == -1) + { + this->logger->log(this->logger, CONTROL|LEVEL2, "Error reading length"); + return PARSE_ERROR; + } + this->logger->log(this->logger, CONTROL|LEVEL2, "Length is %d", inner.len); + inner.ptr = data->ptr; + + /* advance in data, at the size of the inner */ + data->ptr += inner.len; + data->len -= inner.len; + } + + /* process inner */ + while (TRUE) + { + switch (this->rule->type) + { + case ASN1_INTEGER: + return read_int(this, inner); + case ASN1_BOOLEAN: + return read_bool(this, inner); + case ASN1_SEQUENCE: + case ASN1_SET: + return read_sequence(this, inner); + case ASN1_TAG_E_0: + case ASN1_TAG_E_1: + case ASN1_TAG_E_2: + case ASN1_TAG_E_3: + case ASN1_TAG_E_4: + case ASN1_TAG_E_5: + case ASN1_TAG_E_6: + case ASN1_TAG_E_7: + return read_hdr(this, &inner); + case ASN1_TAG_I_0: + case ASN1_TAG_I_1: + case ASN1_TAG_I_2: + case ASN1_TAG_I_3: + case ASN1_TAG_I_4: + case ASN1_TAG_I_5: + case ASN1_TAG_I_6: + case ASN1_TAG_I_7: + this->rule++; + continue; + case ASN1_OID: + return read_oid(this, inner); + case ASN1_CHOICE: + return read_choice(this, data); + case ASN1_NULL: + return SUCCESS; + case ASN1_ANY: + return read_any(this, inner); + case ASN1_UTCTIME: + return read_time(this, inner); + case ASN1_GENERALIZEDTIME: + return read_time(this, inner); + case ASN1_BITSTRING: + return read_bitstring(this, inner); + case ASN1_OCTETSTRING: + return read_any(this, inner); + default: + return NOT_SUPPORTED; + } + } +} + +/** + * Implements der_decoder_t.decode + */ +status_t decode(private_der_decoder_t *this, chunk_t input, void *output) +{ + this->rule = this->first_rule - 1; + this->output = output; + /* start parsing recursivly */ + return read_hdr(this, &input); +} + +/** + * Implementation of der_decoder.destroy. + */ +static void destroy(private_der_decoder_t *this) +{ + this->logger->destroy(this->logger); + allocator_free(this); +} + +/* + * Described in header. + */ +der_decoder_t *der_decoder_create(asn1_rule_t *rules) +{ + private_der_decoder_t *this = allocator_alloc_thing(private_der_decoder_t); + + /* public functions */ + this->public.decode = (status_t (*) (der_decoder_t*,chunk_t,void*))decode; + this->public.destroy = (void (*) (der_decoder_t*))destroy; + + this->first_rule = rules; + this->logger = logger_create("[DERDC]", CONTROL, FALSE, NULL); + + return &(this->public); +} diff --git a/Source/lib/asn1/der_decoder.h b/Source/lib/asn1/der_decoder.h new file mode 100644 index 000000000..68731b5d9 --- /dev/null +++ b/Source/lib/asn1/der_decoder.h @@ -0,0 +1,79 @@ +/** + * @file der_decoder.h + * + * @brief Interface of der_decoder_t. + * + */ + +/* + * Copyright (C) 2006 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#ifndef DER_DECODER_H_ +#define DER_DECODER_H_ + +#include <types.h> +#include <asn1/asn1.h> + +typedef struct der_decoder_t der_decoder_t; + +/** + * @brief Decode ASN1 DER encoded chunks. + * + * @b Constructors: + * - der_decoder_create() + * + * @todo A lot. + * + * @ingroup asn1 + */ +struct der_decoder_t { + + /** + * @brief Decode a chunk of bytes to a data structure + * + * @param der_decoder calling object + * @param input chunk of data to decode + * @param output data structure where decoded data is written + * @return + * - PARSE_ERROR + * - FAILED + * - NOT_SUPPORTED + * - or SUCCESS sometimes + */ + status_t (*decode) (der_decoder_t *this, chunk_t input, void *output); + + /** + * @brief Destroys a der_decoder object. + * + * @param der_decoder calling object + */ + void (*destroy) (der_decoder_t *this); +}; + + +/** + * @brief Create a der_decoder instance. + * + * The instance needs ASN1 rules to know how to decode + * data... + * + * @param rules set of ASN1 coding rules + * @return der_decoder_t object + * + * @ingroup ans1 + */ +der_decoder_t * der_decoder_create(asn1_rule_t* rules); + +#endif /* DER_DECODER_H_ */ diff --git a/Source/lib/asn1/der_encoder.c b/Source/lib/asn1/der_encoder.c new file mode 100644 index 000000000..07beb5891 --- /dev/null +++ b/Source/lib/asn1/der_encoder.c @@ -0,0 +1,218 @@ +/** + * @file der_encoder.c + * + * @brief Implementation of der_encoder_t. + */ + +/* + * Copyright (C) 2005 Jan Hutter, Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#include <gmp.h> + +#include "der_encoder.h" + +#include <utils/allocator.h> +#include <daemon.h> + + + +typedef struct private_der_encoder_t private_der_encoder_t; + +/** + * Private data of a der_encoder_t object. + */ +struct private_der_encoder_t { + /** + * Public interface for this signer. + */ + der_encoder_t public; + + asn1_rule_t *rule; + + asn1_rule_t *first_rule; + + void *output; + + logger_t *logger; +}; + +static status_t read_hdr(private_der_encoder_t *this, chunk_t *data); + +static status_t read_sequence(private_der_encoder_t *this, chunk_t data) +{ + while (this->rule->type != ASN1_END) + { + read_hdr(this, &data); + } + return SUCCESS; +} + + +static status_t read_int(private_der_encoder_t *this, chunk_t data) +{ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_INTEGER", data); + u_int *integ = (u_int*)((u_int8_t*)this->output + this->rule->data_offset); + + *integ = 0; + while (data.len-- > 0) + { + *integ = 256 * (*integ) + *data.ptr++; + } + return SUCCESS; +} + +static status_t read_mpz(private_der_encoder_t *this, chunk_t data) +{ + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "ASN1_INTEGER as mpz", data); + mpz_t *mpz = (mpz_t*)((u_int8_t*)this->output + this->rule->data_offset); + + mpz_import(*mpz, data.len, 1, 1, 1, 0, data.ptr); + return SUCCESS; +} + +static u_int32_t read_length(chunk_t *data) +{ + u_int8_t n; + size_t len; + + /* read first octet of length field */ + n = *data->ptr++; + + if ((n & 0x80) == 0) + { + /* single length octet */ + return n; + } + + /* composite length, determine number of length octets */ + n &= 0x7f; + + if (n > data->len) + { + /* length longer than available bytes */ + return -1; + } + + if (n > sizeof(len)) + { + /* larger than size_t can hold */ + return -1; + } + + len = 0; + while (n-- > 0) + { + len = 256 * len + *data->ptr++; + } + return len; +} + +static status_t read_hdr(private_der_encoder_t *this, chunk_t *data) +{ + chunk_t inner; + + /* advance to the next rule */ + this->rule++; + + if (this->rule->type == ASN1_END) + { + return SUCCESS; + } + + this->logger->log(this->logger, CONTROL|LEVEL2, "reading header of rule %s", + mapping_find(asn1_type_m, this->rule->type)); + + this->logger->log_chunk(this->logger, CONTROL|LEVEL2, "reading from:", *data); + + /* read type, advance in data */ + if (*(data->ptr) != this->rule->type) + { + this->logger->log(this->logger, CONTROL|LEVEL2, "Bad byte found (%x)", *data->ptr); + return PARSE_ERROR; + } + data->ptr++; + data->len--; + + /* read length, advance in data */ + inner.len = read_length(data); + if (inner.len == -1) + { + this->logger->log(this->logger, CONTROL|LEVEL2, "Error reading length"); + return PARSE_ERROR; + } + this->logger->log(this->logger, CONTROL|LEVEL2, "Length is %d", + inner.len); + inner.ptr = data->ptr; + + /* advance in data */ + data->ptr += inner.len; + data->len -= inner.len; + + /* process inner */ + switch (this->rule->type) + { + case ASN1_INTEGER: + if (this->rule->flags & ASN1_MPZ) + { + read_mpz(this, inner); + } + else + { + read_int(this, inner); + } + break; + case ASN1_SEQUENCE: + read_sequence(this, inner); + break; + default: + break; + } + + return SUCCESS; +} + + + +static status_t decode(private_der_encoder_t *this, chunk_t input, void *output) +{ + this->rule = this->first_rule - 1; + this->output = output; + return read_hdr(this, &input); +} + +/** + * Implementation of der_encoder.destroy. + */ +static void destroy(private_der_encoder_t *this) +{ + allocator_free(this); +} + +/* + * Described in header. + */ +der_encoder_t *der_encoder_create(asn1_rule_t *rules) +{ + private_der_encoder_t *this = allocator_alloc_thing(private_der_encoder_t); + + /* public functions */ + this->public.decode = (status_t (*) (der_encoder_t*,chunk_t,void*))decode; + this->public.destroy = (void (*) (der_encoder_t*))destroy; + + this->first_rule = rules; + this->logger = charon->logger_manager->get_logger(charon->logger_manager, DER_DECODER); + + return &(this->public); +} diff --git a/Source/lib/asn1/der_encoder.h b/Source/lib/asn1/der_encoder.h new file mode 100644 index 000000000..ee4443eb8 --- /dev/null +++ b/Source/lib/asn1/der_encoder.h @@ -0,0 +1,60 @@ +/** + * @file der_encoder.h + * + * @brief Interface of der_encoder_t. + * + */ + +/* + * Copyright (C) 2006 Martin Willi + * Hochschule fuer Technik Rapperswil + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + */ + +#ifndef DER_ENCODER_H_ +#define DER_ENCODER_H_ + +#include <types.h> + +typedef struct der_encoder_t der_encoder_t; + +/** + * @brief Decode der_encoded bytes to usable structures. + * + * @b Constructors: + * - der_encoder_create() + * + * @ingroup asn1 + */ +struct der_encoder_t { + + status_t encode(der_encoder_t *this, void *input, chunk_t output); + + /** + * @brief Destroys a der_encoder object. + * + * @param der_encoder calling object + */ + void (*destroy) (der_encoder_t *this); +}; + + +/** + * @brief Create a der_encoder instance. + * + * @return der_encoder_t object + * + * @ingroup ans1 + */ +der_encoder_t * der_encoder_create(asn1_rule_t *rules); + +#endif /* DER_ENCODER_H_ */ |