denozord/strongswan-ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- x509 certificate loading with pluto asn1 code

Browse Source 
- x509 needs a lot more attention!
This commit is contained in:
Martin Willi
2006-04-19 11:40:48 +00:00
parent 4a93d6bafd
commit ec6582ccaa
24 changed files with 1953 additions and 3066 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/charon.kdevelop
+1 -1
View File
@@ -14,7 +14,7 @@
<directoryradio>executable</directoryradio>
</run>
<general>
<activedir></activedir>
<activedir/>
</general>
</kdevcustomproject>
<kdevdebugger>
Source/charon/daemon.c
+1 -1
View File
@@ -266,7 +266,7 @@ void signal_handler(int signal)
logger->log(logger, ERROR, " %s", strings[i]);
}
free (strings);
/* kill ourselve the hard way, anything other may result in more SIGSEGVs*/
logger->log(logger, ERROR, "Killing ourself hard after SIGSEGV");
kill(getpid(), SIGKILL);
}
Source/charon/threads/stroke_interface.c
+4 -4
View File
@@ -36,7 +36,7 @@
#include <stroke.h>
#include <types.h>
#include <daemon.h>
#include <crypto/certificate.h>
#include <crypto/x509.h>
#include <queues/jobs/initiate_ike_sa_job.h>
@@ -280,7 +280,7 @@ static void stroke_add_conn(private_stroke_t *this, stroke_msg_t *msg)
host_t *my_host, *other_host, *my_subnet, *other_subnet;
proposal_t *proposal;
traffic_selector_t *my_ts, *other_ts;
certificate_t *my_cert, *other_cert;
x509_t *my_cert, *other_cert;
rsa_private_key_t *private_key = NULL;
rsa_public_key_t *public_key = NULL;
@@ -419,7 +419,7 @@ static void stroke_add_conn(private_stroke_t *this, stroke_msg_t *msg)
chdir(CERTIFICATE_DIR);
my_cert = certificate_create_from_file(msg->add_conn.me.cert);
my_cert = x509_create_from_file(msg->add_conn.me.cert);
if (my_cert == NULL)
{
this->stroke_logger->log(this->stroke_logger, ERROR, "loading own certificate \"%s%s\" failed",
@@ -442,7 +442,7 @@ static void stroke_add_conn(private_stroke_t *this, stroke_msg_t *msg)
}
my_cert->destroy(my_cert);
}
other_cert = certificate_create_from_file(msg->add_conn.other.cert);
other_cert = x509_create_from_file(msg->add_conn.other.cert);
public_key = NULL;
if (other_cert == NULL)
{
Source/lib/Makefile.lib
-1
View File
@@ -25,4 +25,3 @@ $(BUILD_DIR)definitions.o : $(LIB_DIR)definitions.c $(LIB_DIR)definitions.h
include $(MAIN_DIR)lib/crypto/Makefile.transforms
include $(MAIN_DIR)lib/utils/Makefile.utils
include $(MAIN_DIR)lib/asn1/Makefile.asn1
include $(MAIN_DIR)lib/asn1-pluto/Makefile.asn1
Source/lib/asn1/Makefile.asn1
+3 -3
View File
@@ -12,14 +12,14 @@
# for more details.
#
ASN1_DIR= $(LIB_DIR)asn1-pluto/
ASN1_DIR= $(LIB_DIR)asn1/
LIB_OBJS+= $(BUILD_DIR)oid.o
$(BUILD_DIR)oid.o : $(ASN1_DIR)oid.c $(ASN1_DIR)oid.h
$(CC) $(CFLAGS) -c -o $@ $<
LIB_OBJS+= $(BUILD_DIR)asn1-pluto.o
$(BUILD_DIR)asn1-pluto.o : $(ASN1_DIR)asn1-pluto.c $(ASN1_DIR)asn1-pluto.h
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)pem.o
$(BUILD_DIR)pem.o : $(ASN1_DIR)pem.c $(ASN1_DIR)pem.h
Source/lib/asn1/asn1.c
+1 -1
View File
@@ -17,7 +17,7 @@
#include <string.h>
#include <time.h>
#include "asn1-pluto.h"
#include "asn1.h"
#include "oid.h"
#include <utils/logger_manager.h>
Source/lib/asn1/asn1.h
+9 -10
View File
@@ -23,15 +23,14 @@
/* Defines some primitive ASN1 types */
typedef enum {
ASN1_EOC = 0x00,
ASN1_BOOLEAN = 0x01,
ASN1_INTEGER = 0x02,
ASN1_EOC = 0x00,
ASN1_BOOLEAN = 0x01,
ASN1_INTEGER = 0x02,
ASN1_BIT_STRING = 0x03,
ASN1_OCTET_STRING = 0x04,
ASN1_NULL = 0x05,
ASN1_OID = 0x06,
ASN1_NULL = 0x05,
ASN1_OID = 0x06,
ASN1_ENUMERATED = 0x0A,
ASN1_UTF8STRING = 0x0C,
ASN1_NUMERICSTRING = 0x12,
@@ -39,7 +38,7 @@ typedef enum {
ASN1_T61STRING = 0x14,
ASN1_VIDEOTEXSTRING = 0x15,
ASN1_IA5STRING = 0x16,
ASN1_UTCTIME = 0x17,
ASN1_UTCTIME = 0x17,
ASN1_GENERALIZEDTIME = 0x18,
ASN1_GRAPHICSTRING = 0x19,
ASN1_VISIBLESTRING = 0x1A,
@@ -49,9 +48,9 @@ typedef enum {
ASN1_CONSTRUCTED = 0x20,
ASN1_SEQUENCE = 0x30,
ASN1_SEQUENCE = 0x30,
ASN1_SET = 0x31,
ASN1_SET = 0x31,
ASN1_CONTEXT_S_0 = 0x80,
ASN1_CONTEXT_S_1 = 0x81,
@@ -99,7 +98,7 @@ typedef struct {
bool implicit;
u_int level0;
u_int loopAddr[ASN1_MAX_LEVEL+1];
chunk_t blobs[ASN1_MAX_LEVEL+2];
chunk_t blobs[ASN1_MAX_LEVEL+2];
} asn1_ctx_t;
/* some common prefabricated ASN.1 constants */
Source/lib/asn1/x509.c
-2237
View File
File diff suppressed because it is too large Load Diff
Source/lib/asn1/x509.h
-138
View File
@@ -1,138 +0,0 @@
/* Support of X.509 certificates
* Copyright (C) 2000 Andreas Hess, Patric Lichtsteiner, Roger Wegmann
* Copyright (C) 2001 Marco Bertossa, Andreas Schleiss
* Copyright (C) 2002 Mario Strasser
* Copyright (C) 2000-2004 Andreas Steffen, Zuercher Hochschule Winterthur
*
* 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.
*
* RCSID $Id: x509.h,v 1.10 2005/12/06 22:52:44 as Exp $
*/
#ifndef _X509_H
#define _X509_H
#include "pkcs1.h"
#include "id.h"
/* Definition of generalNames kinds */
typedef enum {
GN_OTHER_NAME = 0,
GN_RFC822_NAME = 1,
GN_DNS_NAME = 2,
GN_X400_ADDRESS = 3,
GN_DIRECTORY_NAME = 4,
GN_EDI_PARTY_NAME = 5,
GN_URI = 6,
GN_IP_ADDRESS = 7,
GN_REGISTERED_ID = 8
} generalNames_t;
/* access structure for a GeneralName */
typedef struct generalName generalName_t;
struct generalName {
generalName_t *next;
generalNames_t kind;
chunk_t name;
};
/* access structure for an X.509v3 certificate */
typedef struct x509cert x509cert_t;
struct x509cert {
x509cert_t *next;
time_t installed;
int count;
bool smartcard;
u_char authority_flags;
chunk_t certificate;
chunk_t tbsCertificate;
u_int version;
chunk_t serialNumber;
/* signature */
int sigAlg;
chunk_t issuer;
/* validity */
time_t notBefore;
time_t notAfter;
chunk_t subject;
/* subjectPublicKeyInfo */
enum pubkey_alg subjectPublicKeyAlgorithm;
chunk_t subjectPublicKey;
chunk_t modulus;
chunk_t publicExponent;
/* issuerUniqueID */
/* subjectUniqueID */
/* v3 extensions */
/* extension */
/* extension */
/* extnID */
/* critical */
/* extnValue */
bool isCA;
bool isOcspSigner; /* ocsp */
chunk_t subjectKeyID;
chunk_t authKeyID;
chunk_t authKeySerialNumber;
chunk_t accessLocation; /* ocsp */
generalName_t *subjectAltName;
generalName_t *crlDistributionPoints;
/* signatureAlgorithm */
int algorithm;
chunk_t signature;
};
/* used for initialization */
extern const x509cert_t empty_x509cert;
extern bool same_serial(chunk_t a, chunk_t b);
extern bool same_keyid(chunk_t a, chunk_t b);
extern bool same_dn(chunk_t a, chunk_t b);
extern bool match_dn(chunk_t a, chunk_t b, int *wildcards);
extern bool same_x509cert(const x509cert_t *a, const x509cert_t *b);
extern void hex_str(chunk_t bin, chunk_t *str);
extern int dn_count_wildcards(chunk_t dn);
extern int dntoa(char *dst, size_t dstlen, chunk_t dn);
extern int dntoa_or_null(char *dst, size_t dstlen, chunk_t dn
, const char* null_dn);
extern err_t atodn(char *src, chunk_t *dn);
extern void gntoid(struct id *id, const generalName_t *gn);
extern void compute_subjectKeyID(x509cert_t *cert, chunk_t subjectKeyID);
extern void select_x509cert_id(x509cert_t *cert, struct id *end_id);
extern bool parse_x509cert(chunk_t blob, u_int level0, x509cert_t *cert);
extern time_t parse_time(chunk_t blob, int level0);
extern void parse_authorityKeyIdentifier(chunk_t blob, int level0
, chunk_t *authKeyID, chunk_t *authKeySerialNumber);
extern chunk_t get_directoryName(chunk_t blob, int level, bool implicit);
extern err_t check_validity(const x509cert_t *cert, time_t *until);
extern bool check_signature(chunk_t tbs, chunk_t sig, int digest_alg
, int enc_alg, const x509cert_t *issuer_cert);
extern bool verify_x509cert(const x509cert_t *cert, bool strict, time_t *until);
extern x509cert_t* add_x509cert(x509cert_t *cert);
extern x509cert_t* get_x509cert(chunk_t issuer, chunk_t serial, chunk_t keyid
, x509cert_t* chain);
extern void build_x509cert(x509cert_t *cert, const RSA_public_key_t *cert_key
, const RSA_private_key_t *signer_key);
extern chunk_t build_subjectAltNames(generalName_t *subjectAltNames);
extern void share_x509cert(x509cert_t *cert);
extern void release_x509cert(x509cert_t *cert);
extern void free_x509cert(x509cert_t *cert);
extern void store_x509certs(x509cert_t **firstcert, bool strict);
extern void list_x509cert_chain(const char *caption, x509cert_t* cert
, u_char auth_flags, bool utc);
extern void list_x509_end_certs(bool utc);
extern void free_generalNames(generalName_t* gn, bool free_name);
#endif /* _X509_H */
Source/lib/crypto/Makefile.transforms
+2 -2
View File
@@ -32,6 +32,6 @@ LIB_OBJS+= $(BUILD_DIR)prf_plus.o
$(BUILD_DIR)prf_plus.o : $(CRYPTO_DIR)prf_plus.c $(CRYPTO_DIR)prf_plus.h
$(CC) $(CFLAGS) -c -o $@ $<
LIB_OBJS+= $(BUILD_DIR)certificate.o
$(BUILD_DIR)certificate.o : $(CRYPTO_DIR)certificate.c $(CRYPTO_DIR)certificate.h
LIB_OBJS+= $(BUILD_DIR)x509.o
$(BUILD_DIR)x509.o : $(CRYPTO_DIR)x509.c $(CRYPTO_DIR)x509.h
$(CC) $(CFLAGS) -c -o $@ $<
Source/lib/crypto/certificate.c
-231
View File
@@ -1,231 +0,0 @@
/**
* @file certificate.c
*
* @brief Implementation of certificate_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.
*/
#include <gmp.h>
#include <sys/stat.h>
#include <unistd.h>
#include "certificate.h"
#include <daemon.h>
#include <asn1/der_decoder.h>
typedef struct private_certificate_t private_certificate_t;
/**
* Private data of a certificate_t object.
*/
struct private_certificate_t {
/**
* Public interface for this signer.
*/
certificate_t public;
u_int version;
u_int serial;
chunk_t sign_alg;
time_t not_before;
time_t not_after;
chunk_t pubkey;
chunk_t pubkey_alg;
bool has_issuer_uid;
chunk_t issuer_uid;
bool has_subject_uid;
chunk_t subject_uid;
chunk_t tbs_cert;
chunk_t signature;
rsa_public_key_t *public_key;
};
#define OSET(x) offsetof(private_certificate_t, x)
/**
* Rules for de-/encoding of a certificate from/in ASN1
*/
static asn1_rule_t certificate_rules[] = {
{ASN1_SEQUENCE, 0, 0, 0 }, /* certificate */
{ ASN1_SEQUENCE, ASN1_RAW, OSET(tbs_cert), 0 }, /* tbsCertificate */
{ ASN1_TAG_E_0, ASN1_DEFAULT, OSET(version), 0 }, /* EXPLICIT */
{ ASN1_INTEGER, ASN1_DEFAULT, OSET(version), 0 }, /* version DEFAULT v1(0) */
{ ASN1_INTEGER, 0, OSET(serial), 0 }, /* serialNumber */
{ ASN1_SEQUENCE, 0, 0, 0 }, /* signature */
{ ASN1_OID, 0, OSET(sign_alg), 0 }, /* algorithm-oid */
{ ASN1_NULL, 0, 0, 0 }, /* parameters */
{ ASN1_END, 0, 0, 0 }, /* signature */
{ ASN1_SEQUENCE, ASN1_OF, 0, 0 }, /* issuer */
// { ASN1_SET, ASN1_OF, 0, 0, }, /* RelativeDistinguishedName */
// { ASN1_SEQUENCE, 0, 0, 0, }, /* AttributeTypeAndValue */
// { ASN1_OID, 0, 0, 0 }, /* AttributeType */
// { ASN1_ANY, 0, 0, 0 }, /* AttributeValue */
// { ASN1_END, 0, 0, 0 }, /* AttributeTypeAndValue */
// { ASN1_END, 0, 0, 0 }, /* RelativeDistinguishedName */
{ ASN1_END, 0, 0, 0 }, /* issuer */
{ ASN1_SEQUENCE, 0, 0, 0 }, /* validity */
{ ASN1_CHOICE, 0, 0, 0 }, /* notBefore */
{ ASN1_UTCTIME, 0, OSET(not_before), 0 }, /* utcTime */
{ ASN1_GENERALIZEDTIME, 0, OSET(not_before), 0 }, /* generalTime */
{ ASN1_END, 0, 0, 0 }, /* notBefore */
{ ASN1_CHOICE, 0, 0, 0 }, /* notAfter */
{ ASN1_UTCTIME, 0, OSET(not_after), 0 }, /* utcTime */
{ ASN1_GENERALIZEDTIME, 0, OSET(not_after), 0 }, /* generalTime */
{ ASN1_END, 0, 0, 0 }, /* notAfter */
{ ASN1_END, 0, 0, 0 }, /* validity */
{ ASN1_SEQUENCE, ASN1_OF, 0, 0 }, /* subject */
// { ASN1_SET, ASN1_OF, 0, 0, }, /* RelativeDistinguishedName */
// { ASN1_SEQUENCE, 0, 0, 0, }, /* AttributeTypeAndValue */
// { ASN1_OID, 0, 0, 0 }, /* AttributeType */
// { ASN1_ANY, 0, 0, 0 }, /* AttributeValue */
// { ASN1_END, 0, 0, 0 }, /* AttributeTypeAndValue */
// { ASN1_END, 0, 0, 0 }, /* RelativeDistinguishedName */
{ ASN1_END, 0, 0, 0 }, /* subject */
{ ASN1_SEQUENCE, 0, 0, 0 }, /* subjectPublicKeyInfo */
{ ASN1_SEQUENCE, 0, 0, 0 }, /* algorithm */
{ ASN1_OID, 0, OSET(pubkey_alg), 0 }, /* algorithm-oid */
{ ASN1_NULL, 0, 0, 0 }, /* parameters */
{ ASN1_END, 0, 0, 0 }, /* algorithm */
{ ASN1_BITSTRING, 0, OSET(pubkey), 0 }, /* subjectPublicKey */
{ ASN1_END, 0, 0, 0 }, /* subjectPublicKeyInfo */
{ ASN1_TAG_I_1, ASN1_OPTIONAL, 0, OSET(has_issuer_uid)}, /* IMPLICIT */
{ ASN1_BITSTRING, ASN1_OPTIONAL, OSET(issuer_uid), 0 }, /* issuerUniqueID OPTIONAL */
{ ASN1_TAG_I_2, ASN1_OPTIONAL, 0, OSET(has_subject_uid)},/* IMPLICIT */
{ ASN1_BITSTRING, ASN1_OPTIONAL, OSET(subject_uid), 0 }, /* subjectUniqueID OPTIONAL */
{ ASN1_TAG_E_3, ASN1_OPTIONAL, 0, 0 }, /* EXPLICIT */
{ ASN1_SEQUENCE, ASN1_OF|ASN1_OPTIONAL, 0, 0 }, /* extensions OPTIONAL */
// { ASN1_SEQUENCE, 0, 0, 0, }, /* extension */
// { ASN1_OID, 0, 0, 0 }, /* extnID */
// { ASN1_BOOLEAN, ASN1_DEFAULT, 0, FALSE }, /* critical */
// { ASN1_OCTETSTRING, 0, 0, 0, }, /* extnValue */
// { ASN1_END, 0, 0, 0, }, /* extension */
{ ASN1_END, 0, 0, 0, }, /* extensions */
{ ASN1_END, 0, 0, 0 }, /* tbsCertificate */
{ ASN1_SEQUENCE, 0, 0, 0 }, /* signatureAlgorithm */
{ ASN1_OID, 0, OSET(sign_alg), 0 }, /* algorithm-oid */
{ ASN1_NULL, 0, 0, 0 }, /* parameters */
{ ASN1_END, 0, 0, 0 }, /* signatureAlgorithm */
{ ASN1_BITSTRING, 0, OSET(signature), 0 }, /* signatureValue */
{ASN1_END, 0, 0, 0 }, /* certificate */
};
/**
* Implementation of certificate.get_public_key.
*/
static rsa_public_key_t *get_public_key(private_certificate_t *this)
{
return this->public_key->clone(this->public_key);
}
/**
* Implementation of certificate.destroy.
*/
static void destroy(private_certificate_t *this)
{
this->public_key->destroy(this->public_key);
free(this->pubkey.ptr);
free(this->signature.ptr);
free(this->tbs_cert.ptr);
free(this);
}
/*
* Described in header.
*/
certificate_t *certificate_create_from_chunk(chunk_t chunk)
{
private_certificate_t *this = malloc_thing(private_certificate_t);
der_decoder_t *dd;
/* public functions */
this->public.get_public_key = (rsa_public_key_t *(*) (certificate_t*))get_public_key;
this->public.destroy = (void (*) (certificate_t*))destroy;
/* initialize */
this->pubkey = CHUNK_INITIALIZER;
this->signature = CHUNK_INITIALIZER;
this->tbs_cert = CHUNK_INITIALIZER;
dd = der_decoder_create(certificate_rules);
if (dd->decode(dd, chunk, this) != SUCCESS)
{
free(this);
dd->destroy(dd);
return NULL;
}
dd->destroy(dd);
this->public_key = rsa_public_key_create_from_chunk(this->pubkey);
if (this->public_key == NULL)
{
free(this->pubkey.ptr);
free(this);
return NULL;
}
return &this->public;
}
/*
* Described in header.
*/
certificate_t *certificate_create_from_file(char *filename)
{
struct stat stb;
FILE *file;
char *buffer;
chunk_t chunk;
if (stat(filename, &stb) == -1)
{
return NULL;
}
buffer = alloca(stb.st_size);
file = fopen(filename, "r");
if (file == NULL)
{
return NULL;
}
if (fread(buffer, stb.st_size, 1, file) == -1)
{
fclose(file);
return NULL;
}
fclose(file);
chunk.ptr = buffer;
chunk.len = stb.st_size;
return certificate_create_from_chunk(chunk);
}
Source/lib/crypto/certificate.h
-80
View File
@@ -1,80 +0,0 @@
/**
* @file certificate.h
*
* @brief Interface of certificate_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 CERTIFICATE_H_
#define CERTIFICATE_H_
#include <types.h>
#include <definitions.h>
#include <crypto/rsa/rsa_public_key.h>
#include <utils/identification.h>
#include <utils/iterator.h>
typedef struct certificate_t certificate_t;
/**
* @brief X509 certificate.
*
* @b Constructors:
* - certificate_create_from_chunk()
*
* @ingroup transforms
*/
struct certificate_t {
/**
* @brief Get the RSA public key from the certificate.
*
* @param this calling object
* @return public_key
*/
rsa_public_key_t *(*get_public_key) (certificate_t *this);
identification_t *(*get_issuer) (certificate_t *this);
identification_t *(*get_subject) (certificate_t *this);
iterator_t *(*create_subjectaltname_iter) (certificate_t *this);
iterator_t *(*create_issueraltname_iter) (certificate_t *this);
bool (*belongs_to) (certificate_t *this, identification_t *subject);
bool (*issued_by) (certificate_t *this, identification_t *issuer);
bool (*validate) (certificate_t *this, rsa_public_key_t *signer);
/**
* @brief Destroys the private key.
*
* @param this private key to destroy
*/
void (*destroy) (certificate_t *this);
};
/**
* @brief Read a certificate from a blob.
*
* @return created certificate_t.
*
* @ingroup transforms
*/
certificate_t *certificate_create_from_chunk(chunk_t chunk);
certificate_t *certificate_create_from_file(char *filename);
#endif /* CERTIFICATE_H_ */
Source/lib/crypto/rsa/rsa_private_key.c
+46 -109
View File
@@ -28,13 +28,7 @@
#include "rsa_private_key.h"
#include <daemon.h>
#ifdef NEW_ASN1
# include <asn1/asn1.h>
# include <asn1/der_decoder.h>
#else
# include <asn1-pluto/asn1-pluto.h>
#endif
#include <asn1/asn1.h>
/*
* Oids for hash algorithms are defined in
@@ -143,41 +137,8 @@ struct private_rsa_private_key_t {
};
#ifdef NEW_ASN1
/**
* Rules for de-/encoding of a private key from/in ASN1
*/
static asn1_rule_t rsa_private_key_rules[] = {
{ASN1_SEQUENCE, 0, 0, 0},
{ ASN1_INTEGER, 0, offsetof(private_rsa_private_key_t, version), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, n), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, e), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, d), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, p), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, q), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, exp1), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, exp2), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_private_key_t, coeff), 0},
{ASN1_END, 0, 0, 0},
};
#else
struct {
const char *name;
size_t offset;
} RSA_private_field[] = {
{ "Modulus", offsetof(private_rsa_private_key_t, n) },
{ "PublicExponent", offsetof(private_rsa_private_key_t, e) },
{ "PrivateExponent", offsetof(private_rsa_private_key_t, d) },
{ "Prime1", offsetof(private_rsa_private_key_t, p) },
{ "Prime2", offsetof(private_rsa_private_key_t, q) },
{ "Exponent1", offsetof(private_rsa_private_key_t, exp1) },
{ "Exponent2", offsetof(private_rsa_private_key_t, exp2) },
{ "Coefficient", offsetof(private_rsa_private_key_t, coeff) },
};
/* ASN.1 definition of a PKCS#1 RSA private key */
static const asn1Object_t privkeyObjects[] = {
static const asn1Object_t privkey_objects[] = {
{ 0, "RSAPrivateKey", ASN1_SEQUENCE, ASN1_NONE }, /* 0 */
{ 1, "version", ASN1_INTEGER, ASN1_BODY }, /* 1 */
{ 1, "modulus", ASN1_INTEGER, ASN1_BODY }, /* 2 */
@@ -197,13 +158,16 @@ static const asn1Object_t privkeyObjects[] = {
{ 1, "end opt or loop", ASN1_EOC, ASN1_END } /* 15 */
};
#define PKCS1_PRIV_KEY_VERSION 1
#define PKCS1_PRIV_KEY_MODULUS 2
#define PKCS1_PRIV_KEY_PUB_EXP 3
#define PKCS1_PRIV_KEY_COEFF 9
#define PKCS1_PRIV_KEY_ROOF 16
#endif
#define PRIV_KEY_VERSION 1
#define PRIV_KEY_MODULUS 2
#define PRIV_KEY_PUB_EXP 3
#define PRIV_KEY_PRIV_EXP 4
#define PRIV_KEY_PRIME1 5
#define PRIV_KEY_PRIME2 6
#define PRIV_KEY_EXP1 7
#define PRIV_KEY_EXP2 8
#define PRIV_KEY_COEFF 9
#define PRIV_KEY_ROOF 16
static private_rsa_private_key_t *rsa_private_key_create_empty();
@@ -628,7 +592,6 @@ rsa_private_key_t *rsa_private_key_create(size_t key_size)
return NULL;
}
mpz_init(t);
mpz_init(n);
mpz_init(d);
@@ -636,7 +599,6 @@ rsa_private_key_t *rsa_private_key_create(size_t key_size)
mpz_init(exp2);
mpz_init(coeff);
/* Swapping Primes so p is larger then q */
if (mpz_cmp(p, q) < 0)
{
@@ -692,48 +654,6 @@ rsa_private_key_t *rsa_private_key_create(size_t key_size)
return &this->public;
}
#ifdef NEW_ASN1
/*
* see header
*/
rsa_private_key_t *rsa_private_key_create_from_chunk(chunk_t chunk)
{
private_rsa_private_key_t *this;
der_decoder_t *dd;
status_t status;
this = rsa_private_key_create_empty();
mpz_init(this->n);
mpz_init(this->e);
mpz_init(this->p);
mpz_init(this->q);
mpz_init(this->d);
mpz_init(this->exp1);
mpz_init(this->exp2);
mpz_init(this->coeff);
dd = der_decoder_create(rsa_private_key_rules);
status = dd->decode(dd, chunk, this);
dd->destroy(dd);
if (status != SUCCESS)
{
destroy(this);
return NULL;
}
this->k = (mpz_sizeinbase(this->n, 2) + 7) / 8;
if (check(this) != SUCCESS)
{
destroy(this);
return NULL;
}
else
{
return &this->public;
}
}
#else
/*
* see header
*/
@@ -758,28 +678,46 @@ rsa_private_key_t *rsa_private_key_create_from_chunk(chunk_t blob)
asn1_init(&ctx, blob, 0, FALSE);
while (objectID < PKCS1_PRIV_KEY_ROOF)
while (objectID < PRIV_KEY_ROOF)
{
if (!extract_object(privkeyObjects, &objectID, &object, &level, &ctx))
if (!extract_object(privkey_objects, &objectID, &object, &level, &ctx))
{
destroy(this);
return FALSE;
}
if (objectID == PKCS1_PRIV_KEY_VERSION)
switch (objectID)
{
if (object.len > 0 && *object.ptr != 0)
{
destroy(this);
return NULL;
}
}
else if (objectID >= PKCS1_PRIV_KEY_MODULUS &&
objectID <= PKCS1_PRIV_KEY_COEFF)
{
mpz_t *u = (mpz_t *) ((char *)this
+ RSA_private_field[objectID - PKCS1_PRIV_KEY_MODULUS].offset);
mpz_import(*u, object.len, 1, 1, 1, 0, object.ptr);
case PRIV_KEY_VERSION:
if (object.len > 0 && *object.ptr != 0)
{
destroy(this);
return NULL;
}
break;
case PRIV_KEY_MODULUS:
mpz_import(this->n, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_PUB_EXP:
mpz_import(this->e, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_PRIV_EXP:
mpz_import(this->d, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_PRIME1:
mpz_import(this->p, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_PRIME2:
mpz_import(this->q, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_EXP1:
mpz_import(this->exp1, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_EXP2:
mpz_import(this->exp2, object.len, 1, 1, 1, 0, object.ptr);
break;
case PRIV_KEY_COEFF:
mpz_import(this->coeff, object.len, 1, 1, 1, 0, object.ptr);
break;
}
objectID++;
}
@@ -796,7 +734,6 @@ rsa_private_key_t *rsa_private_key_create_from_chunk(chunk_t blob)
return &this->public;
}
}
#endif
/*
* see header
Source/lib/crypto/rsa/rsa_public_key.c
+37 -48
View File
@@ -29,7 +29,7 @@
#include <daemon.h>
#include <crypto/hashers/hasher.h>
#include <asn1/der_decoder.h>
#include <asn1/asn1.h>
/*
* For simplicity,
@@ -75,6 +75,17 @@ u_int8_t sha512_oid[] = {
0x00,0x04,0x40
};
/* ASN.1 definition public key */
static const asn1Object_t pubkey_objects[] = {
{ 0, "RSAPublicKey", ASN1_SEQUENCE, ASN1_OBJ }, /* 0 */
{ 1, "modulus", ASN1_INTEGER, ASN1_BODY }, /* 1 */
{ 1, "publicExponent", ASN1_INTEGER, ASN1_BODY }, /* 2 */
};
#define PUB_KEY_RSA_PUBLIC_KEY 0
#define PUB_KEY_MODULUS 1
#define PUB_KEY_EXPONENT 2
#define PUB_KEY_ROOF 3
typedef struct private_rsa_public_key_t private_rsa_public_key_t;
@@ -139,29 +150,6 @@ struct rsa_public_key_info_t {
chunk_t public_key;
};
/**
* Rules for de-/encoding of a public key from/in ASN1
*/
static asn1_rule_t rsa_public_key_rules[] = {
{ASN1_SEQUENCE, 0, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_public_key_t, n), 0},
{ ASN1_INTEGER, ASN1_MPZ, offsetof(private_rsa_public_key_t, e), 0},
{ASN1_END, 0, 0, 0},
};
/**
* Rules for de-/encoding of a PublicKeyInfo from/in ASN1
*/
static asn1_rule_t rsa_public_key_info_rules[] = {
{ASN1_SEQUENCE, 0, 0, 0},
{ ASN1_SEQUENCE, 0, 0, 0},
{ ASN1_OID, 0, offsetof(rsa_public_key_info_t, algorithm_oid), 0},
{ ASN1_NULL, 0, 0, 0},
{ ASN1_END, 0, 0, 0},
{ ASN1_BITSTRING, 0, offsetof(rsa_public_key_info_t, public_key), 0},
{ASN1_END, 0, 0, 0},
};
private_rsa_public_key_t *rsa_public_key_create_empty();
/**
@@ -398,24 +386,39 @@ private_rsa_public_key_t *rsa_public_key_create_empty()
/*
* See header
*/
rsa_public_key_t *rsa_public_key_create_from_chunk(chunk_t chunk)
rsa_public_key_t *rsa_public_key_create_from_chunk(chunk_t blob)
{
der_decoder_t *dd;
status_t status;
asn1_ctx_t ctx;
chunk_t object;
u_int level;
int objectID = 0;
private_rsa_public_key_t *this;
this = rsa_public_key_create_empty();
mpz_init(this->n);
mpz_init(this->e);
dd = der_decoder_create(rsa_public_key_rules);
status = dd->decode(dd, chunk, this);
dd->destroy(dd);
if (status != SUCCESS)
asn1_init(&ctx, blob, 0, FALSE);
while (objectID < PUB_KEY_ROOF)
{
destroy(this);
return NULL;
if (!extract_object(pubkey_objects, &objectID, &object, &level, &ctx))
{
destroy(this);
return FALSE;
}
switch (objectID)
{
case PUB_KEY_MODULUS:
mpz_import(this->n, object.len, 1, 1, 1, 0, object.ptr);
break;
case PUB_KEY_EXPONENT:
mpz_import(this->e, object.len, 1, 1, 1, 0, object.ptr);
break;
}
objectID++;
}
this->k = (mpz_sizeinbase(this->n, 2) + 7) / 8;
return &this->public;
}
@@ -429,10 +432,6 @@ rsa_public_key_t *rsa_public_key_create_from_file(char *filename)
FILE *file;
char *buffer;
chunk_t chunk;
rsa_public_key_info_t key_info = {CHUNK_INITIALIZER, CHUNK_INITIALIZER};
der_decoder_t *dd;
status_t status;
rsa_public_key_t *public_key = NULL;
if (stat(filename, &stb) == -1)
{
@@ -455,15 +454,5 @@ rsa_public_key_t *rsa_public_key_create_from_file(char *filename)
chunk.ptr = buffer;
chunk.len = stb.st_size;
/* parse public key info first */
dd = der_decoder_create(rsa_public_key_info_rules);
status = dd->decode(dd, chunk, &key_info);
dd->destroy(dd);
chunk_free(&key_info.algorithm_oid);
if (status == SUCCESS)
{
public_key = rsa_public_key_create_from_chunk(chunk);
}
chunk_free(&key_info.public_key);
return public_key;
return rsa_public_key_create_from_chunk(chunk);
}
Source/lib/crypto/x509.c
Executable
+1691
View File
File diff suppressed because it is too large Load Diff
Source/lib/crypto/x509.h
Executable
+128
View File
@@ -0,0 +1,128 @@
/**
* @file x509.h
*
* @brief Interface of x509_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 X509_H_
#define X509_H_
#include <types.h>
#include <definitions.h>
#include <crypto/rsa/rsa_public_key.h>
#include <utils/identification.h>
#include <utils/iterator.h>
typedef struct x509_t x509_t;
/**
* @brief X509 certificate.
*
* @b Constructors:
* - x509_create_from_chunk()
* - x509_create_from_file()
*
* @todo more code cleanup needed!
* @todo fix unimplemented functions...
* @todo handle memory management
*
* @ingroup transforms
*/
struct x509_t {
/**
* @brief Get the RSA public key from the certificate.
*
* @param this calling object
* @return public_key
*/
rsa_public_key_t *(*get_public_key) (x509_t *this);
/**
* @brief Get the certificate issuers ID.
*
* @todo implement!
*/
identification_t *(*get_issuer) (x509_t *this);
/**
* @brief Get the subjects ID.
*
* @todo implement!
*/
identification_t *(*get_subject) (x509_t *this);
/**
* @brief Check if a certificate is valid.
*
* This function uses the issuers public key to verify
* the validity of a certificate.
*
* @todo implement!
*/
bool (*verify) (x509_t *this, rsa_public_key_t *signer);
/**
* @brief Get the key identifier of the public key.
*
* @todo implement!
*/
chunk_t (*get_subject_key_identifier) (x509_t *this);
/**
* @brief Compare two certificates.
*
* Comparison is done via the certificates signature.
*
* @param this first cert for compare
* @param other second cert for compare
* @return TRUE if signature is equal
*/
bool (*equals) (x509_t *this, x509_t *other);
/**
* @brief Destroys the certificate.
*
* @param this certificate to destroy
*/
void (*destroy) (x509_t *this);
};
/**
* @brief Read a x509 certificate from a DER encoded blob.
*
* @param chunk chunk containing DER encoded data
* @return created x509_t certificate, or NULL if invalid.
*
* @ingroup transforms
*/
x509_t *x509_create_from_chunk(chunk_t chunk);
/**
* @brief Read a x509 certificate from a DER encoded file.
*
* @param filename file containing DER encoded data
* @return created x509_t certificate, or NULL if invalid.
*
* @ingroup transforms
*/
x509_t *x509_create_from_file(char *filename);
#endif /* X509_H_ */
Source/lib/types.c
+13 -1
View File
@@ -87,13 +87,25 @@ chunk_t chunk_alloc(size_t bytes)
return new_chunk;
}
/**
* Described in header.
*/
bool chunk_equals(chunk_t a, chunk_t b)
{
if (a.ptr == NULL || b.ptr == NULL ||
a.len != b.len ||
memcmp(a.ptr, b.ptr, a.len) != 0)
{
return FALSE;
}
return TRUE;
}
/**
* Described in header.
*/
void *clalloc(void * pointer, size_t size)
{
void *data;
data = malloc(size);
Source/lib/types.h
+13 -7
View File
@@ -31,6 +31,13 @@
#include <definitions.h>
/**
* General purpose boolean type.
*/
typedef int bool;
#define FALSE 0
#define TRUE 1
typedef enum status_t status_t;
/**
@@ -165,17 +172,16 @@ void chunk_free(chunk_t *chunk);
*/
chunk_t chunk_alloc(size_t bytes);
/**
* Compare two chunks for equality,
* NULL chunks are never equal.
*/
bool chunk_equals(chunk_t a, chunk_t b);
/**
* Clone a data to a newly allocated buffer
*/
void *clalloc(void *pointer, size_t size);
/**
* General purpose boolean type.
*/
typedef int bool;
#define FALSE 0
#define TRUE 1
#endif /*TYPES_H_*/
Source/testing/Makefile.testcases
+1 -6
View File
@@ -130,15 +130,10 @@ TEST_OBJS+= $(BUILD_DIR)child_sa_test.o
$(BUILD_DIR)child_sa_test.o : $(TESTCASES_DIR)child_sa_test.c $(TESTCASES_DIR)child_sa_test.h
$(CC) $(CFLAGS) -c -o $@ $<
TEST_OBJS+= $(BUILD_DIR)der_decoder_test.o
$(BUILD_DIR)der_decoder_test.o : $(TESTCASES_DIR)der_decoder_test.c $(TESTCASES_DIR)der_decoder_test.h
$(CC) $(CFLAGS) -c -o $@ $<
TEST_OBJS+= $(BUILD_DIR)certificate_test.o
$(BUILD_DIR)certificate_test.o : $(TESTCASES_DIR)certificate_test.c $(TESTCASES_DIR)certificate_test.h
$(CC) $(CFLAGS) -c -o $@ $<
TEST_OBJS+= $(BUILD_DIR)leak_detective_test.o
$(BUILD_DIR)leak_detective_test.o : $(TESTCASES_DIR)leak_detective_test.c $(TESTCASES_DIR)leak_detective_test.h
$(CC) $(CFLAGS) -c -o $@ $<
$(CC) $(CFLAGS) -c -o $@ $<
Source/testing/certificate_test.c
+1 -1
View File
@@ -86,7 +86,7 @@ void test_certificate(protected_tester_t *tester)
{
chunk_t certificate = {certificate_buffer, sizeof(certificate_buffer)};
certificate_t *cert = certificate_create_from_chunk(certificate);
x509_t *cert = x509_create_from_chunk(certificate);
//certificate_t *cert = certificate_create_from_file("myCert.der");
Source/testing/der_decoder_test.c
-139
View File
@@ -1,139 +0,0 @@
/**
* @file der_decoder_test.c
*
* @brief Tests for the der_decoder_t class.
*
*/
/*
* 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 "der_decoder_test.h"
#include <daemon.h>
#include <asn1/der_decoder.h>
#include <utils/logger.h>
static char private_key_buffer[] = {
0x30,0x82,0x04,0xa2,0x02,0x00,0x02,0x82,0x01,0x01,0x00,0x9b,0x28,0x10,0x02,0xd2,
0x43,0x5b,0x2b,0x7c,0x81,0xce,0x2b,0x77,0xb4,0xbf,0x5f,0x2a,0x9a,0x96,0xc9,0xa4,
0xd7,0xbb,0xb3,0xfb,0xc1,0x8a,0xad,0xbe,0x21,0x4e,0xd7,0x15,0xc4,0x8c,0x0a,0x88,
0x5b,0x02,0xa9,0xcd,0x2e,0xee,0xd3,0x5e,0xb9,0xfd,0x27,0x0b,0xdb,0xf6,0xe7,0xb7,
0x39,0xc1,0xfa,0x34,0x3f,0xa7,0xe4,0x04,0xaf,0xa8,0xc2,0x36,0x4e,0xf5,0x0c,0xf1,
0x9b,0x92,0x26,0x32,0x20,0xdb,0x04,0xf5,0xb8,0x2e,0xf5,0xfc,0x47,0xd3,0x2a,0xa1,
0x2d,0x5b,0x68,0x2c,0x5e,0xc6,0xc9,0x35,0x57,0x7b,0x65,0x17,0xd7,0x5d,0x10,0x5c,
0x51,0xfb,0xcb,0x95,0xd1,0x17,0x42,0xa9,0xfd,0xd1,0xc4,0x32,0x1f,0x13,0xf2,0xeb,
0x6b,0x91,0x01,0xe9,0x89,0x19,0x3a,0x2b,0x6d,0xae,0x91,0x27,0xe2,0x5e,0x06,0x5b,
0x99,0xfb,0x20,0x3c,0xc4,0x92,0x20,0xc4,0x68,0x24,0x6b,0x74,0xdc,0x6d,0xf7,0xa8,
0x10,0x1b,0xdf,0x20,0xed,0x4e,0x90,0x0e,0x3d,0xf6,0xef,0x3a,0x94,0x8b,0x12,0x61,
0xac,0xed,0x95,0xbc,0xe2,0xed,0xb9,0x22,0xc2,0xdd,0xc7,0x19,0x68,0x09,0x14,0x71,
0xb0,0x37,0xf7,0xbd,0x65,0x11,0x31,0x9d,0x89,0x6e,0x21,0xcf,0x60,0xc1,0x8d,0xbe,
0x31,0x96,0xd2,0xdd,0x0e,0x20,0x38,0x07,0xd5,0xea,0xda,0xc8,0x9a,0x47,0x5b,0x05,
0xce,0x7d,0xf7,0x4e,0xcd,0xbb,0x89,0xdd,0x46,0x16,0x8f,0x39,0x9d,0x32,0x19,0xaf,
0x6e,0xc4,0xb3,0x6c,0x79,0x5a,0x70,0x11,0x8f,0xe2,0x75,0x33,0x09,0xc8,0xf6,0xd7,
0x40,0x25,0xe7,0xa3,0xf0,0x6f,0x9a,0xdb,0x35,0x74,0xc1,0x02,0x03,0x01,0x00,0x01,
0x02,0x82,0x01,0x00,0x12,0x42,0x38,0x58,0x21,0xfc,0x51,0x34,0xa0,0x8b,0x4f,0x58,
0x28,0x2c,0x7a,0x14,0xd8,0x98,0xfb,0xee,0x5b,0x85,0x69,0x0e,0x63,0x83,0x16,0xd9,
0xc9,0x5f,0xcc,0x12,0x5d,0xa5,0x15,0x41,0xd6,0xb8,0x0c,0x6b,0xda,0x67,0x3a,0x83,
0x09,0xf3,0xb8,0x89,0xd4,0x1d,0xc7,0x99,0x8f,0x23,0x59,0xe3,0x78,0x2b,0x41,0x8b,
0xab,0x78,0x2c,0x7e,0x3b,0xbb,0xe0,0xf4,0x96,0xa8,0xd3,0x1d,0xc6,0xea,0x67,0x91,
0x2c,0x30,0x1c,0xe9,0x4f,0xb8,0xa2,0xc3,0x5d,0x2c,0xf9,0x99,0x1c,0x6c,0xee,0xd7,
0x16,0x28,0x3c,0x5a,0x32,0x35,0xb8,0x3a,0xf3,0xa7,0xa6,0x35,0x02,0xba,0xbf,0x67,
0xab,0x44,0xe1,0x09,0x9b,0x48,0x5d,0xa5,0x9e,0xf4,0xb7,0xf4,0xd1,0xfc,0x68,0x9e,
0x98,0x26,0x69,0x28,0xcc,0x19,0x75,0xf2,0x61,0x0e,0x23,0xeb,0xf9,0x6d,0x2c,0x2b,
0x01,0x3f,0x4d,0x18,0x41,0xc5,0x31,0x9d,0x1c,0x20,0x81,0x4e,0x38,0x92,0xd5,0xbb,
0xd7,0xe7,0x49,0x0c,0x3a,0xf3,0x8f,0x9e,0xf0,0xb3,0x32,0x1e,0xa7,0x77,0xe8,0x9c,
0xf3,0xce,0x88,0x66,0xcc,0xe8,0x16,0xbb,0xfd,0xbc,0x62,0xc7,0xc3,0xeb,0x0a,0xf5,
0xd8,0x53,0x02,0x6c,0x45,0xcb,0x1d,0xa3,0x96,0xfb,0xa5,0x26,0x18,0x7f,0x04,0x9f,
0x80,0x4a,0xdb,0x3b,0x74,0xcf,0x0d,0x45,0xf4,0xd5,0x49,0xe9,0x27,0x54,0x9c,0x57,
0x92,0x48,0x78,0x52,0xb6,0x40,0x89,0x3f,0xf3,0x95,0x06,0x3d,0x90,0xab,0xa0,0x8a,
0xc7,0x54,0xf1,0x63,0xcf,0xa6,0xd2,0x83,0x1e,0x69,0x54,0xe0,0x77,0x2c,0x9e,0x3a,
0x4f,0xdd,0x14,0x6d,0x02,0x81,0x81,0x00,0xd9,0x40,0x76,0x90,0x7c,0xe7,0x3b,0xa3,
0x59,0x23,0x14,0x6b,0xf3,0x5f,0x6e,0x6b,0x82,0x34,0xf6,0xbd,0x3e,0xfb,0x65,0xac,
0x2f,0x46,0xd5,0x6e,0x9b,0xb8,0x62,0x80,0xc3,0x0c,0xa9,0xa6,0x00,0xd6,0xb8,0x1c,
0x12,0x8d,0x4d,0xd0,0x64,0x29,0x4c,0xac,0x38,0xe8,0x6c,0xe4,0x82,0x02,0x4e,0x10,
0xd5,0x39,0x19,0x29,0x0c,0x58,0x3f,0x68,0xa0,0x11,0x0e,0x11,0x74,0x22,0x2b,0x7e,
0xc2,0xa7,0x88,0xe3,0x33,0xe8,0xb4,0x50,0x6e,0x0c,0x54,0xc5,0x3f,0xb7,0x16,0xcb,
0x39,0xed,0x23,0xd0,0x66,0x26,0x57,0xf9,0xcb,0xc9,0xac,0xe2,0xa4,0xb8,0xba,0xd8,
0xd2,0x1f,0x4a,0xed,0x73,0x89,0xda,0x42,0x27,0x5a,0x26,0x30,0x33,0xc8,0x42,0x2a,
0x3d,0xc5,0xf3,0xc2,0x29,0x3d,0x58,0x67,0x02,0x81,0x81,0x00,0xb6,0xd4,0x61,0x05,
0x49,0xcb,0xf4,0x29,0x8a,0x22,0xd3,0xa3,0x7c,0x9c,0xd2,0x07,0xa4,0x66,0xe4,0x36,
0xfa,0x5e,0xf6,0x64,0xb7,0x59,0x74,0x2f,0x36,0x6d,0x12,0xd0,0xc9,0x4d,0xf8,0xd1,
0xba,0xd1,0xee,0xd2,0x78,0xcd,0x51,0x69,0x33,0x6a,0x03,0xff,0xc2,0x35,0x1d,0x0d,
0x9c,0x0a,0x87,0x5e,0x09,0xa3,0x23,0x4c,0xab,0xc3,0x4c,0x4a,0x1c,0xa4,0xc5,0xe2,
0x70,0x42,0x1c,0xcf,0xea,0x79,0xfb,0xb9,0x87,0x67,0x4d,0xc3,0xfc,0xcc,0x86,0x9d,
0xfa,0xea,0x99,0xa5,0x1b,0xc1,0x96,0xf4,0x79,0x4d,0x66,0x12,0x8f,0x90,0x98,0xb4,
0xa1,0x3b,0xd6,0x2f,0x64,0xb4,0x5f,0x8f,0x47,0x7f,0x43,0xa5,0x6d,0xeb,0x06,0x58,
0xfb,0x04,0x9e,0xef,0xaf,0x88,0x35,0x88,0xa1,0x15,0x30,0x97,0x02,0x81,0x80,0x59,
0xbe,0xe0,0x7b,0xc5,0xad,0x3c,0x1c,0xb9,0x98,0xdd,0x39,0xce,0xfa,0xd0,0x41,0x87,
0x33,0x5b,0xee,0x47,0x93,0x50,0xa7,0xf5,0x8b,0xbc,0x65,0x89,0xdc,0x7c,0x8c,0x96,
0x86,0xa7,0x9a,0x54,0xe4,0x5e,0x7f,0xf2,0x45,0xff,0x2c,0x24,0x04,0x4f,0x91,0x21,
0x9d,0x1a,0x46,0xb7,0x52,0x3e,0x6f,0x83,0xb5,0xa7,0xa8,0x26,0x5a,0x5a,0x2f,0x5d,
0x58,0x4e,0x48,0x75,0x82,0x1c,0x17,0xac,0x4f,0xcb,0x23,0x98,0x70,0xfb,0xf3,0xf1,
0xd2,0x14,0x3e,0xbb,0x98,0x65,0xc9,0x24,0x2f,0xcb,0x48,0xae,0xba,0x0e,0x43,0xb9,
0xa4,0xa1,0x4f,0xab,0x1e,0x48,0xc9,0x82,0xdb,0xbc,0x77,0x24,0xf0,0x80,0x82,0x2d,
0x81,0x77,0x1f,0x18,0x75,0x14,0xa8,0x20,0x86,0xa2,0xb0,0xc5,0x9a,0x7a,0xe7,0x02,
0x81,0x80,0x1b,0x6d,0xb1,0x40,0x81,0xd9,0xbf,0x3f,0x9c,0x21,0xad,0x6e,0x91,0x7b,
0x55,0x67,0x20,0x1a,0xef,0x91,0xef,0xed,0xdf,0x39,0x2c,0xe8,0x96,0xad,0x9e,0x94,
0xae,0x85,0xf4,0x2d,0x66,0x6e,0xd0,0x80,0x3e,0x3c,0x05,0x33,0x88,0x4b,0x28,0x13,
0x77,0x96,0x1f,0x24,0xa8,0xbf,0x29,0xf1,0xca,0x6d,0x29,0x34,0xf8,0x4e,0xc0,0x56,
0x04,0x53,0xfa,0x08,0x1e,0x47,0xe2,0x5f,0x88,0xc3,0x08,0x82,0x54,0x69,0x79,0x0e,
0xde,0x73,0xd0,0xb1,0x3e,0x60,0xe5,0x0b,0xdd,0x11,0x10,0x20,0xf2,0xec,0xaa,0x66,
0x1a,0x32,0x1e,0xa7,0xaa,0xc1,0x2e,0x8f,0x33,0x8a,0xd8,0xa8,0xd6,0xcd,0x40,0x04,
0xaf,0xb9,0x59,0xcc,0x30,0x9f,0x98,0xc9,0x10,0xaf,0x14,0xbe,0x72,0x89,0x94,0xe1,
0x00,0xf1,0x02,0x81,0x81,0x00,0xd6,0xac,0x26,0xd2,0x42,0x5b,0x16,0xa9,0x39,0x02,
0x63,0x76,0xa4,0xf5,0x40,0x3a,0xde,0xfa,0xea,0xd8,0xd3,0x12,0xee,0x44,0x00,0xfe,
0xcb,0xa1,0x78,0x18,0xaa,0xa7,0x08,0xea,0x5e,0x36,0x52,0x28,0x0d,0x02,0x5a,0x9e,
0x2d,0xc1,0x22,0x29,0x08,0x4f,0xed,0xff,0xa9,0xa6,0x08,0x8d,0x77,0xa4,0x5c,0xae,
0xa7,0x8a,0x19,0x90,0xc2,0x12,0xc8,0x0f,0xb8,0x24,0xb5,0xba,0x45,0x2f,0xa6,0xc2,
0x10,0x4c,0x0d,0x7e,0xf2,0xfd,0x11,0x26,0x16,0x34,0xbe,0x08,0x25,0x41,0x8b,0xcc,
0x60,0xe7,0x02,0x3e,0x6a,0x54,0x05,0x80,0x66,0x2d,0x55,0x06,0xe6,0xbe,0x9b,0x15,
0x9d,0xd3,0x5d,0xc4,0x6b,0x3f,0x74,0xa6,0x24,0xbc,0x7f,0x13,0xdf,0xe3,0x51,0x86,
0x64,0x0f,0x1d,0x1f,0xf2,0x1e,
};
asn1_rule_t private_key_rules[] = {
{ASN1_SEQUENCE, 0, 0, 0},
{ ASN1_INTEGER, 0, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ ASN1_INTEGER, ASN1_MPZ, 0, 0},
{ASN1_END, 0, 0, 0},
};
/**
* Described in header.
*/
void test_der_decoder(protected_tester_t *tester)
{
chunk_t private_key = {private_key_buffer, sizeof(private_key_buffer)};
der_decoder_t *dd = der_decoder_create(private_key_rules);
dd->decode(dd, private_key, NULL);
dd->destroy(dd);
}
Source/testing/der_decoder_test.h
-42
View File
@@ -1,42 +0,0 @@
/**
* @file der_decoder_test.h
*
* @brief Tests for the der_decoder_t class.
*
*/
/*
* 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_TEST_H_
#define DER_DECODER_TEST_H_
#include <utils/tester.h>
/**
* @brief Test function used to test the der_decoder_t functionality.
*
* @param tester associated protected_tester_t object
*
* @ingroup testcases
*/
void test_der_decoder(protected_tester_t *tester);
#endif /* DER_DECODER_TEST_H_ */
Source/testing/rsa_test.c
+1 -1
View File
@@ -137,7 +137,7 @@ void test_rsa(protected_tester_t *tester)
{
rsa_private_key_t *private_key;
rsa_public_key_t *public_key;
certificate_t *certificate;
x509_t *certificate;
chunk_t data, signature;
chunk_t der_private_key = {private_key_buffer, sizeof(private_key_buffer)};
chunk_t der_public_key = {public_key_buffer, sizeof(public_key_buffer)};
Source/testing/testcases.c
+1 -3
View File
@@ -61,7 +61,6 @@
#include "rsa_test.h"
#include "kernel_interface_test.h"
#include "child_sa_test.h"
#include "der_decoder_test.h"
#include "certificate_test.h"
#include "leak_detective_test.h"
@@ -130,7 +129,6 @@ test_t proposal_test = {test_proposal, "proposal_t test"};
test_t rsa_test = {test_rsa, "RSA private/public key test"};
test_t kernel_interface_test = {test_kernel_interface, "Kernel Interface"};
test_t child_sa_test = {test_child_sa, "Child SA"};
test_t der_decoder_test = {test_der_decoder, "DER decoder"};
test_t certificate_test = {test_certificate, "X509 Certificate"};
test_t leak_detective_test = {test_leak_detective, "LEAK detective"};
@@ -255,7 +253,7 @@ int main()
tester_t *tester = tester_create(test_output, FALSE);
//tester->perform_tests(tester,all_tests);
tester->perform_test(tester,&leak_detective_test);
tester->perform_test(tester,&certificate_test);
tester->destroy(tester);