aboutsummaryrefslogtreecommitdiffstats
path: root/Source/lib/asn1
diff options
context:
space:
mode:
authorMartin Willi <martin@strongswan.org>2006-04-05 12:10:50 +0000
committerMartin Willi <martin@strongswan.org>2006-04-05 12:10:50 +0000
commit6862128151fb78f63685a8da5575783c426d64a7 (patch)
tree75920a6688ed5654fb917ecccc1e0e469480fd1f /Source/lib/asn1
parent3dbbbf3e16366b0da33b29bbc1a4ba9a976e43a0 (diff)
downloadstrongswan-6862128151fb78f63685a8da5575783c426d64a7.tar.bz2
strongswan-6862128151fb78f63685a8da5575783c426d64a7.tar.xz
../svn-commit.tmp
Diffstat (limited to 'Source/lib/asn1')
-rw-r--r--Source/lib/asn1/Makefile.asn124
-rw-r--r--Source/lib/asn1/asn1.c74
-rw-r--r--Source/lib/asn1/asn1.h172
-rw-r--r--Source/lib/asn1/der_decoder.c502
-rw-r--r--Source/lib/asn1/der_decoder.h79
-rw-r--r--Source/lib/asn1/der_encoder.c218
-rw-r--r--Source/lib/asn1/der_encoder.h60
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_ */