- removed, since we use pluto asn1 stuff
This commit is contained in:
parent
9d7597bb12
commit
1ab689ee60
|
@ -1,24 +0,0 @@
|
|||
# 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 $@ $<
|
|
@ -1,74 +0,0 @@
|
|||
/**
|
||||
* @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"},
|
||||
};
|
|
@ -1,172 +0,0 @@
|
|||
/**
|
||||
* @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_ */
|
|
@ -1,502 +0,0 @@
|
|||
/**
|
||||
* @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 <string.h>
|
||||
|
||||
#include "der_decoder.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 = chunk_clone(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 = chunk_clone(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);
|
||||
free(this);
|
||||
}
|
||||
|
||||
/*
|
||||
* Described in header.
|
||||
*/
|
||||
der_decoder_t *der_decoder_create(asn1_rule_t *rules)
|
||||
{
|
||||
private_der_decoder_t *this = malloc_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);
|
||||
}
|
|
@ -1,79 +0,0 @@
|
|||
/**
|
||||
* @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_ */
|
|
@ -1,217 +0,0 @@
|
|||
/**
|
||||
* @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 <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)
|
||||
{
|
||||
free(this);
|
||||
}
|
||||
|
||||
/*
|
||||
* Described in header.
|
||||
*/
|
||||
der_encoder_t *der_encoder_create(asn1_rule_t *rules)
|
||||
{
|
||||
private_der_encoder_t *this = malloc_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 = logger_manager>logger_manager->get_logger(logger_manager>logger_manager, DER_DECODER);
|
||||
|
||||
return &(this->public);
|
||||
}
|
|
@ -1,60 +0,0 @@
|
|||
/**
|
||||
* @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_ */
|
Loading…
Reference in New Issue