Moving charon to libcharon.
This commit is contained in:
Tobias Brunner
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* SSH agent signature creation and verification
|
||||
******************************************************************************/
|
||||
bool test_agent()
|
||||
{
|
||||
char *path;
|
||||
chunk_t sig, data = chunk_from_chars(0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08);
|
||||
private_key_t *private;
|
||||
public_key_t *public;
|
||||
|
||||
path = getenv("SSH_AUTH_SOCK");
|
||||
if (!path)
|
||||
{
|
||||
DBG1(DBG_CFG, "ssh-agent not found.");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
private = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
|
||||
BUILD_AGENT_SOCKET, path, BUILD_END);
|
||||
if (!private)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!private->sign(private, SIGN_RSA_EMSA_PKCS1_SHA1, data, &sig))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
public = private->get_public_key(private);
|
||||
if (!public)
|
||||
{
|
||||
return FALSE;;
|
||||
}
|
||||
if (!public->verify(public, SIGN_RSA_EMSA_PKCS1_SHA1, data, sig))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
free(sig.ptr);
|
||||
data.ptr[1] = 0x01; /* fake it */
|
||||
if (public->verify(public, SIGN_RSA_EMSA_PKCS1_SHA1, data, sig))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
private->destroy(private);
|
||||
public->destroy(public);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,140 @@
|
||||
/*
|
||||
* Copyright (C) 2007 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 <daemon.h>
|
||||
#include <library.h>
|
||||
#include <config/auth_cfg.h>
|
||||
|
||||
|
||||
static chunk_t certchunk = chunk_from_chars(
|
||||
0x30,0x82,0x02,0xfa,0x30,0x82,0x01,0xe2,0xa0,0x03,0x02,0x01,0x02,0x02,0x10,0x5a,
|
||||
0xf2,0x65,0xae,0x78,0xff,0x23,0xde,0xf7,0xa6,0xa3,0x94,0x8c,0x3f,0xa0,0xc1,0x30,
|
||||
0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x05,0x05,0x00,0x30,0x39,
|
||||
0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02,0x43,0x48,0x31,0x19,0x30,
|
||||
0x17,0x06,0x03,0x55,0x04,0x0a,0x13,0x10,0x4c,0x69,0x6e,0x75,0x78,0x20,0x73,0x74,
|
||||
0x72,0x6f,0x6e,0x67,0x53,0x77,0x61,0x6e,0x31,0x0f,0x30,0x0d,0x06,0x03,0x55,0x04,
|
||||
0x03,0x13,0x06,0x6d,0x61,0x72,0x74,0x69,0x6e,0x30,0x1e,0x17,0x0d,0x30,0x37,0x30,
|
||||
0x34,0x32,0x37,0x30,0x37,0x31,0x34,0x32,0x36,0x5a,0x17,0x0d,0x31,0x32,0x30,0x34,
|
||||
0x32,0x35,0x30,0x37,0x31,0x34,0x32,0x36,0x5a,0x30,0x39,0x31,0x0b,0x30,0x09,0x06,
|
||||
0x03,0x55,0x04,0x06,0x13,0x02,0x43,0x48,0x31,0x19,0x30,0x17,0x06,0x03,0x55,0x04,
|
||||
0x0a,0x13,0x10,0x4c,0x69,0x6e,0x75,0x78,0x20,0x73,0x74,0x72,0x6f,0x6e,0x67,0x53,
|
||||
0x77,0x61,0x6e,0x31,0x0f,0x30,0x0d,0x06,0x03,0x55,0x04,0x03,0x13,0x06,0x6d,0x61,
|
||||
0x72,0x74,0x69,0x6e,0x30,0x82,0x01,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,
|
||||
0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x82,0x01,0x0f,0x00,0x30,0x82,0x01,0x0a,
|
||||
0x02,0x82,0x01,0x01,0x00,0xd7,0xb9,0xba,0x4d,0xe2,0x3b,0x3d,0x35,0x7a,0x3f,0x88,
|
||||
0x67,0x95,0xe7,0xfd,0x9f,0xe9,0x0a,0x0d,0x79,0x3a,0x9e,0x21,0x8f,0xcb,0xe4,0x67,
|
||||
0x24,0xae,0x0c,0xda,0xb3,0xcc,0xec,0x36,0xb4,0xa8,0x4d,0xf1,0x3d,0xad,0xe4,0x8c,
|
||||
0x63,0x92,0x54,0xb7,0xb2,0x02,0xa2,0x00,0x62,0x8b,0x04,0xac,0xa0,0x17,0xad,0x17,
|
||||
0x9a,0x05,0x0d,0xd7,0xb3,0x08,0x02,0xc5,0x26,0xcf,0xdd,0x05,0x42,0xfc,0x13,0x6d,
|
||||
0x9f,0xb1,0xf3,0x4f,0x82,0x1d,0xef,0x01,0xc9,0x91,0xea,0x37,0x1b,0x79,0x28,0xfa,
|
||||
0xbf,0x9f,0xb3,0xeb,0x82,0x4f,0x10,0xc6,0x4b,0xa4,0x08,0xf7,0x8e,0xf2,0x00,0xea,
|
||||
0x04,0x97,0x80,0x9f,0x65,0x86,0xde,0x6b,0xc7,0xda,0x83,0xfc,0xad,0x4a,0xaf,0x52,
|
||||
0x8b,0x4d,0x33,0xee,0x49,0x87,0x2f,0x3b,0x60,0x45,0x66,0x8f,0xe6,0x89,0xcc,0xb1,
|
||||
0x92,0x02,0x17,0x2b,0x7b,0x8e,0x90,0x47,0x84,0x84,0x59,0x95,0x81,0xd8,0xe0,0xf3,
|
||||
0x87,0xe0,0x04,0x09,0xfd,0xcc,0x3a,0x21,0x34,0xfa,0xec,0xbe,0xf5,0x9c,0xcf,0x55,
|
||||
0x80,0x7b,0xe3,0x75,0x9d,0x36,0x68,0xab,0x83,0xe3,0xad,0x01,0x53,0x0d,0x8a,0x9a,
|
||||
0xa6,0xb0,0x15,0xc9,0xc5,0xf8,0x9b,0x51,0x32,0xcf,0x97,0x6c,0xfe,0x4a,0x56,0x3c,
|
||||
0xc8,0x8f,0x4a,0x70,0x23,0x4f,0xf6,0xf7,0xe6,0x9f,0x09,0xcd,0x8f,0xea,0x20,0x7d,
|
||||
0x34,0xc0,0xc5,0xc0,0x34,0x06,0x6f,0x8b,0xeb,0x04,0x54,0x3f,0x0e,0xcd,0xe2,0x85,
|
||||
0xab,0x94,0x3e,0x91,0x6c,0x18,0x6f,0x96,0x5d,0xf2,0x8b,0x10,0xe9,0x90,0x43,0xb0,
|
||||
0x61,0x52,0xac,0xcf,0x75,0x02,0x03,0x01,0x00,0x01,0x30,0x0d,0x06,0x09,0x2a,0x86,
|
||||
0x48,0x86,0xf7,0x0d,0x01,0x01,0x05,0x05,0x00,0x03,0x82,0x01,0x01,0x00,0x09,0x63,
|
||||
0x42,0xad,0xe5,0xa3,0xf6,0xc9,0x5d,0x08,0xf2,0x78,0x7b,0xeb,0x8a,0xef,0x50,0x00,
|
||||
0xc8,0xeb,0xe9,0x26,0x94,0xcb,0x84,0x10,0x7e,0x42,0x6b,0x86,0x38,0x57,0xa6,0x02,
|
||||
0x98,0x5a,0x2c,0x8f,0x44,0x32,0x1b,0x97,0x8c,0x7e,0x4b,0xd8,0xe8,0xe8,0x0f,0x4a,
|
||||
0xb9,0x31,0x9f,0xf6,0x9f,0x0e,0x67,0x26,0x05,0x2a,0x99,0x14,0x35,0x41,0x47,0x9a,
|
||||
0xfa,0x12,0x94,0x0b,0xe9,0x27,0x7c,0x71,0x20,0xd7,0x8d,0x3b,0x97,0x19,0x2d,0x15,
|
||||
0xff,0xa4,0xf3,0x89,0x8d,0x29,0x5f,0xf6,0x3f,0x93,0xaf,0x78,0x61,0xe4,0xe1,0x2e,
|
||||
0x75,0xc1,0x2c,0xc4,0x76,0x95,0x19,0xf8,0x37,0xdc,0xd8,0x00,0x7a,0x3c,0x0f,0x49,
|
||||
0x2e,0x88,0x09,0x16,0xb3,0x92,0x33,0xdf,0x77,0x83,0x4f,0xb5,0x9e,0x30,0x8c,0x48,
|
||||
0x1d,0xd8,0x84,0xfb,0xf1,0xb9,0xa0,0xbe,0x25,0xff,0x4c,0xeb,0xef,0x2b,0xcd,0xfa,
|
||||
0x0b,0x94,0x66,0x3b,0x28,0x08,0x3f,0x3a,0xda,0x41,0xd0,0x6b,0xab,0x5e,0xbb,0x8a,
|
||||
0x9f,0xdc,0x98,0x3e,0x59,0x37,0x48,0xbe,0x69,0xde,0x85,0x82,0xf2,0x53,0x8b,0xe4,
|
||||
0x44,0xe4,0x71,0x91,0x14,0x85,0x0e,0x1e,0x79,0xdd,0x62,0xf5,0xdc,0x25,0x89,0xab,
|
||||
0x50,0x5b,0xaa,0xae,0xe3,0x64,0x6a,0x23,0x34,0xd7,0x30,0xe2,0x2a,0xc8,0x81,0x0c,
|
||||
0xec,0xd2,0x31,0xc6,0x1e,0xb6,0xc0,0x57,0xd9,0xe1,0x14,0x06,0x9b,0xf8,0x51,0x69,
|
||||
0x47,0xf0,0x9c,0xcd,0x69,0xef,0x8e,0x5f,0x62,0xda,0x10,0xf7,0x3c,0x6d,0x0f,0x33,
|
||||
0xec,0x6f,0xfd,0x94,0x07,0x16,0x41,0x32,0x06,0xa4,0xe1,0x08,0x31,0x87,
|
||||
);
|
||||
|
||||
/*******************************************************************************
|
||||
* auth info test
|
||||
******************************************************************************/
|
||||
bool test_auth_cfg()
|
||||
{
|
||||
auth_cfg_t *auth = auth_cfg_create(), *auth2;
|
||||
certificate_t *c1, *c2;
|
||||
enumerator_t *enumerator;
|
||||
int round = 0;
|
||||
void *value;
|
||||
auth_rule_t type;
|
||||
|
||||
c1 = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
|
||||
BUILD_BLOB_ASN1_DER, certchunk,
|
||||
BUILD_END);
|
||||
if (!c1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
auth->add(auth, AUTH_RULE_SUBJECT_CERT, c1->get_ref(c1));
|
||||
c2 = auth->get(auth, AUTH_RULE_SUBJECT_CERT);
|
||||
if (!c2)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!c1->equals(c1, c2))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
enumerator = auth->create_enumerator(auth);
|
||||
while (enumerator->enumerate(enumerator, &type, &value))
|
||||
{
|
||||
round++;
|
||||
if (round == 1 && type == AUTH_RULE_SUBJECT_CERT && value == c1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
|
||||
auth2 = auth_cfg_create();
|
||||
auth2->add(auth2, AUTH_RULE_CA_CERT, c1->get_ref(c1));
|
||||
auth2->merge(auth2, auth, FALSE);
|
||||
|
||||
round = 0;
|
||||
enumerator = auth2->create_enumerator(auth2);
|
||||
while (enumerator->enumerate(enumerator, &type, &value))
|
||||
{
|
||||
round++;
|
||||
if (round == 1 && type == AUTH_RULE_CA_CERT && value == c1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (round == 2 && type == AUTH_RULE_SUBJECT_CERT && value == c1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
auth->destroy(auth);
|
||||
auth2->destroy(auth2);
|
||||
c1->destroy(c1);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
#include <credentials/certificates/x509.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* X509 certificate generation and parsing
|
||||
******************************************************************************/
|
||||
bool test_cert_x509()
|
||||
{
|
||||
private_key_t *ca_key, *peer_key;
|
||||
public_key_t *public;
|
||||
certificate_t *ca_cert, *peer_cert, *parsed;
|
||||
identification_t *issuer, *subject;
|
||||
u_int32_t serial = htonl(0);
|
||||
chunk_t encoding;
|
||||
|
||||
issuer = identification_create_from_string("CN=CA, OU=Test, O=strongSwan");
|
||||
subject = identification_create_from_string("CN=Peer, OU=Test, O=strongSwan");
|
||||
|
||||
ca_key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
|
||||
BUILD_KEY_SIZE, 1024, BUILD_END);
|
||||
peer_key = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
|
||||
BUILD_KEY_SIZE, 1024, BUILD_END);
|
||||
if (!ca_key)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
ca_cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
|
||||
BUILD_SIGNING_KEY, ca_key,
|
||||
BUILD_SUBJECT, issuer,
|
||||
BUILD_SERIAL, chunk_from_thing(serial),
|
||||
BUILD_X509_FLAG, X509_CA,
|
||||
BUILD_END);
|
||||
if (!ca_cert)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
encoding = ca_cert->get_encoding(ca_cert);
|
||||
parsed = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
|
||||
BUILD_BLOB_ASN1_DER, encoding,
|
||||
BUILD_END);
|
||||
chunk_free(&encoding);
|
||||
if (!parsed)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!parsed->issued_by(parsed, ca_cert))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
parsed->destroy(parsed);
|
||||
|
||||
serial = htonl(ntohl(serial) + 1);
|
||||
public = peer_key->get_public_key(peer_key);
|
||||
peer_cert = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
|
||||
BUILD_SIGNING_KEY, ca_key,
|
||||
BUILD_SIGNING_CERT, ca_cert,
|
||||
BUILD_PUBLIC_KEY, public,
|
||||
BUILD_SUBJECT, subject,
|
||||
BUILD_SERIAL, chunk_from_thing(serial),
|
||||
BUILD_END);
|
||||
public->destroy(public);
|
||||
if (!peer_cert)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
encoding = peer_cert->get_encoding(peer_cert);
|
||||
parsed = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
|
||||
BUILD_BLOB_ASN1_DER, encoding,
|
||||
BUILD_END);
|
||||
chunk_free(&encoding);
|
||||
if (!parsed)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!parsed->issued_by(parsed, ca_cert))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
parsed->destroy(parsed);
|
||||
|
||||
ca_cert->destroy(ca_cert);
|
||||
ca_key->destroy(ca_key);
|
||||
peer_cert->destroy(peer_cert);
|
||||
peer_key->destroy(peer_key);
|
||||
issuer->destroy(issuer);
|
||||
subject->destroy(subject);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* Base64 encoding/decoding test
|
||||
******************************************************************************/
|
||||
bool test_chunk_base64()
|
||||
{
|
||||
/* test vectors from RFC4648:
|
||||
*
|
||||
* BASE64("") = ""
|
||||
* BASE64("f") = "Zg=="
|
||||
* BASE64("fo") = "Zm8="
|
||||
* BASE64("foo") = "Zm9v"
|
||||
* BASE64("foob") = "Zm9vYg=="
|
||||
* BASE64("fooba") = "Zm9vYmE="
|
||||
* BASE64("foobar") = "Zm9vYmFy"
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
char *in;
|
||||
char *out;
|
||||
} testdata_t;
|
||||
|
||||
testdata_t test[] = {
|
||||
{"", ""},
|
||||
{"f", "Zg=="},
|
||||
{"fo", "Zm8="},
|
||||
{"foo", "Zm9v"},
|
||||
{"foob", "Zm9vYg=="},
|
||||
{"fooba", "Zm9vYmE="},
|
||||
{"foobar", "Zm9vYmFy"},
|
||||
};
|
||||
int i;
|
||||
|
||||
for (i = 0; i < countof(test); i++)
|
||||
{
|
||||
chunk_t out;
|
||||
|
||||
out = chunk_to_base64(chunk_create(test[i].in, strlen(test[i].in)), NULL);
|
||||
|
||||
if (!streq(out.ptr, test[i].out))
|
||||
{
|
||||
DBG1(DBG_CFG, "base64 conversion error - should %s, is %s",
|
||||
test[i].out, out.ptr);
|
||||
return FALSE;
|
||||
}
|
||||
free(out.ptr);
|
||||
}
|
||||
|
||||
for (i = 0; i < countof(test); i++)
|
||||
{
|
||||
chunk_t out;
|
||||
|
||||
out = chunk_from_base64(chunk_create(test[i].out, strlen(test[i].out)), NULL);
|
||||
|
||||
if (!strneq(out.ptr, test[i].in, out.len))
|
||||
{
|
||||
DBG1(DBG_CFG, "base64 conversion error - should %s, is %#B",
|
||||
test[i].in, &out);
|
||||
return FALSE;
|
||||
}
|
||||
free(out.ptr);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
/*
|
||||
* Copyright (C) 2007 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 <daemon.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netdb.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* curl get test
|
||||
******************************************************************************/
|
||||
|
||||
bool test_curl_get()
|
||||
{
|
||||
chunk_t chunk;
|
||||
|
||||
if (lib->fetcher->fetch(lib->fetcher, "http://www.strongswan.org",
|
||||
&chunk, FETCH_END) != SUCCESS)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
free(chunk.ptr);
|
||||
|
||||
if (lib->fetcher->fetch(lib->fetcher, "http://www.google.com",
|
||||
&chunk, FETCH_END) != SUCCESS)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
free(chunk.ptr);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,306 @@
|
||||
/*
|
||||
* Copyright (C) 2007 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 <utils/linked_list.h>
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* linked list remove test
|
||||
******************************************************************************/
|
||||
bool test_list_remove()
|
||||
{
|
||||
void *a = (void*)1, *b = (void*)2;
|
||||
linked_list_t *list;
|
||||
|
||||
list = linked_list_create();
|
||||
list->insert_last(list, a);
|
||||
if (list->remove(list, a, NULL) != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
list->insert_last(list, a);
|
||||
list->insert_first(list, a);
|
||||
list->insert_last(list, a);
|
||||
list->insert_last(list, b);
|
||||
if (list->remove(list, a, NULL) != 3)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (list->remove(list, a, NULL) != 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (list->get_count(list) != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (list->remove(list, b, NULL) != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (list->remove(list, b, NULL) != 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
list->destroy(list);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* Simple insert first/last and enumerate test
|
||||
******************************************************************************/
|
||||
bool test_enumerate()
|
||||
{
|
||||
int round, x;
|
||||
void *a = (void*)4, *b = (void*)3, *c = (void*)2, *d = (void*)5, *e = (void*)1;
|
||||
linked_list_t *list;
|
||||
enumerator_t *enumerator;
|
||||
|
||||
list = linked_list_create();
|
||||
|
||||
list->insert_last(list, a);
|
||||
list->insert_first(list, b);
|
||||
list->insert_first(list, c);
|
||||
list->insert_last(list, d);
|
||||
list->insert_first(list, e);
|
||||
|
||||
round = 1;
|
||||
enumerator = list->create_enumerator(list);
|
||||
while (enumerator->enumerate(enumerator, &x))
|
||||
{
|
||||
if (round != x)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
round++;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
|
||||
list->destroy(list);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* nested enumerator test
|
||||
******************************************************************************/
|
||||
|
||||
static bool bad_data;
|
||||
|
||||
static enumerator_t* create_inner(linked_list_t *outer, void *data)
|
||||
{
|
||||
if (data != (void*)101)
|
||||
{
|
||||
bad_data = TRUE;
|
||||
}
|
||||
return outer->create_enumerator(outer);
|
||||
}
|
||||
|
||||
|
||||
static void destroy_data(void *data)
|
||||
{
|
||||
if (data != (void*)101)
|
||||
{
|
||||
bad_data = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
bool test_enumerate_nested()
|
||||
{
|
||||
int round, x;
|
||||
void *a = (void*)1, *b = (void*)2, *c = (void*)3, *d = (void*)4, *e = (void*)5;
|
||||
linked_list_t *list, *l1, *l2, *l3;
|
||||
enumerator_t *enumerator;
|
||||
|
||||
bad_data = FALSE;
|
||||
list = linked_list_create();
|
||||
l1 = linked_list_create();
|
||||
l2 = linked_list_create();
|
||||
l3 = linked_list_create();
|
||||
list->insert_last(list, l1);
|
||||
list->insert_last(list, l2);
|
||||
list->insert_last(list, l3);
|
||||
|
||||
l1->insert_last(l1, a);
|
||||
l1->insert_last(l1, b);
|
||||
l3->insert_last(l3, c);
|
||||
l3->insert_last(l3, d);
|
||||
l3->insert_last(l3, e);
|
||||
|
||||
round = 1;
|
||||
enumerator = enumerator_create_nested(list->create_enumerator(list),
|
||||
(void*)create_inner, (void*)101, destroy_data);
|
||||
while (enumerator->enumerate(enumerator, &x))
|
||||
{
|
||||
if (round != x)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
round++;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
|
||||
list->destroy(list);
|
||||
l1->destroy(l1);
|
||||
l2->destroy(l2);
|
||||
l3->destroy(l3);
|
||||
return !bad_data;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* filtered enumerator test
|
||||
******************************************************************************/
|
||||
static bool filter(void *data, int *v, int *vo, int *w, int *wo,
|
||||
int *x, int *xo, int *y, int *yo, int *z, int *zo)
|
||||
{
|
||||
int val = *v;
|
||||
|
||||
*vo = val++;
|
||||
*wo = val++;
|
||||
*xo = val++;
|
||||
*yo = val++;
|
||||
*zo = val++;
|
||||
if (data != (void*)101)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
bool test_enumerate_filtered()
|
||||
{
|
||||
int round, v, w, x, y, z;
|
||||
void *a = (void*)1, *b = (void*)2, *c = (void*)3, *d = (void*)4, *e = (void*)5;
|
||||
linked_list_t *list;
|
||||
enumerator_t *enumerator;
|
||||
|
||||
bad_data = FALSE;
|
||||
list = linked_list_create();
|
||||
|
||||
list->insert_last(list, a);
|
||||
list->insert_last(list, b);
|
||||
list->insert_last(list, c);
|
||||
list->insert_last(list, d);
|
||||
list->insert_last(list, e);
|
||||
|
||||
round = 1;
|
||||
enumerator = enumerator_create_filter(list->create_enumerator(list),
|
||||
(void*)filter, (void*)101, destroy_data);
|
||||
while (enumerator->enumerate(enumerator, &v, &w, &x, &y, &z))
|
||||
{
|
||||
if (v != round || w != round + 1 || x != round + 2 ||
|
||||
y != round + 3 || z != round + 4)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
round++;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
|
||||
list->destroy(list);
|
||||
return !bad_data;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* token parser test
|
||||
******************************************************************************/
|
||||
|
||||
bool test_enumerate_token()
|
||||
{
|
||||
enumerator_t *enumerator;
|
||||
char *token;
|
||||
int i, num;
|
||||
struct {
|
||||
char *string;
|
||||
char *sep;
|
||||
char *trim;
|
||||
} tests1[] = {
|
||||
{"abc, cde, efg", ",", " "},
|
||||
{" abc 1:2 cde;3 4efg5. ", ":;.,", " 12345"},
|
||||
{"abc.cde,efg", ",.", ""},
|
||||
{" abc cde efg ", " ", " "},
|
||||
{"a'abc' c 'cde' cefg", " ", " abcd"},
|
||||
{"'abc' abc 'cde'd 'efg'", " ", " abcd"},
|
||||
}, tests2[] = {
|
||||
{"a, b, c", ",", " "},
|
||||
{"a,b,c", ",", " "},
|
||||
{" a 1:2 b;3 4c5. ", ":;.,", " 12345"},
|
||||
{"a.b,c", ",.", ""},
|
||||
{" a b c ", " ", " "},
|
||||
};
|
||||
|
||||
for (num = 0; num < countof(tests1); num++)
|
||||
{
|
||||
i = 0;
|
||||
enumerator = enumerator_create_token(tests1[num].string,
|
||||
tests1[num].sep, tests1[num].trim);
|
||||
while (enumerator->enumerate(enumerator, &token))
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0:
|
||||
if (!streq(token, "abc")) return FALSE;
|
||||
break;
|
||||
case 1:
|
||||
if (!streq(token, "cde")) return FALSE;
|
||||
break;
|
||||
case 2:
|
||||
if (!streq(token, "efg")) return FALSE;
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if (i != 3)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
}
|
||||
|
||||
for (num = 0; num < countof(tests2); num++)
|
||||
{
|
||||
i = 0;
|
||||
enumerator = enumerator_create_token(tests2[num].string,
|
||||
tests2[num].sep, tests2[num].trim);
|
||||
while (enumerator->enumerate(enumerator, &token))
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0:
|
||||
if (!streq(token, "a")) return FALSE;
|
||||
break;
|
||||
case 1:
|
||||
if (!streq(token, "b")) return FALSE;
|
||||
break;
|
||||
case 2:
|
||||
if (!streq(token, "c")) return FALSE;
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if (i != 3)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,249 @@
|
||||
/*
|
||||
* Copyright (C) 2009 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 <daemon.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* identification part enumeration test
|
||||
******************************************************************************/
|
||||
bool test_id_parts()
|
||||
{
|
||||
identification_t *id;
|
||||
enumerator_t *enumerator;
|
||||
id_part_t part;
|
||||
chunk_t data;
|
||||
int i = 0;
|
||||
|
||||
id = identification_create_from_string("C=CH, O=strongSwan, CN=tester");
|
||||
|
||||
enumerator = id->create_part_enumerator(id);
|
||||
while (enumerator->enumerate(enumerator, &part, &data))
|
||||
{
|
||||
switch (i++)
|
||||
{
|
||||
case 0:
|
||||
if (part != ID_PART_RDN_C ||
|
||||
!chunk_equals(data, chunk_create("CH", 2)))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
if (part != ID_PART_RDN_O ||
|
||||
!chunk_equals(data, chunk_create("strongSwan", 10)))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (part != ID_PART_RDN_CN ||
|
||||
!chunk_equals(data, chunk_create("tester", 6)))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
if (i < 3)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
id->destroy(id);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* identification contains_wildcards() test
|
||||
******************************************************************************/
|
||||
|
||||
static bool test_id_wildcards_has(char *string)
|
||||
{
|
||||
identification_t *id;
|
||||
bool contains;
|
||||
|
||||
id = identification_create_from_string(string);
|
||||
contains = id->contains_wildcards(id);
|
||||
id->destroy(id);
|
||||
return contains;
|
||||
}
|
||||
|
||||
bool test_id_wildcards()
|
||||
{
|
||||
if (!test_id_wildcards_has("C=*, O=strongSwan, CN=gw"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!test_id_wildcards_has("C=CH, O=strongSwan, CN=*"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_wildcards_has("C=**, O=a*, CN=*a"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!test_id_wildcards_has("*@strongswan.org"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!test_id_wildcards_has("*.strongswan.org"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* identification equals test
|
||||
******************************************************************************/
|
||||
|
||||
static bool test_id_equals_one(identification_t *a, char *b_str)
|
||||
{
|
||||
identification_t *b;
|
||||
bool equals;
|
||||
|
||||
b = identification_create_from_string(b_str);
|
||||
equals = a->equals(a, b);
|
||||
b->destroy(b);
|
||||
return equals;
|
||||
}
|
||||
|
||||
bool test_id_equals()
|
||||
{
|
||||
identification_t *a;
|
||||
chunk_t encoding, fuzzed;
|
||||
int i;
|
||||
|
||||
a = identification_create_from_string(
|
||||
"C=CH, [email protected], CN=martin");
|
||||
|
||||
if (!test_id_equals_one(a, "C=CH, [email protected], CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (!test_id_equals_one(a, "C=ch, [email protected], CN=Martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_equals_one(a, "C=CN, [email protected], CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_equals_one(a, "[email protected], C=CH, CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_equals_one(a, "[email protected], C=CH, CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
encoding = chunk_clone(a->get_encoding(a));
|
||||
a->destroy(a);
|
||||
|
||||
/* simple fuzzing, increment each byte of encoding */
|
||||
for (i = 0; i < encoding.len; i++)
|
||||
{
|
||||
if (i == 11 || i == 30 || i == 62)
|
||||
{ /* skip ASN.1 type fields, as equals() handles them graceful */
|
||||
continue;
|
||||
}
|
||||
fuzzed = chunk_clone(encoding);
|
||||
fuzzed.ptr[i]++;
|
||||
a = identification_create_from_encoding(ID_DER_ASN1_DN, fuzzed);
|
||||
if (test_id_equals_one(a, "C=CH, [email protected], CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
a->destroy(a);
|
||||
free(fuzzed.ptr);
|
||||
}
|
||||
|
||||
/* and decrement each byte of encoding */
|
||||
for (i = 0; i < encoding.len; i++)
|
||||
{
|
||||
if (i == 11 || i == 30 || i == 62)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
fuzzed = chunk_clone(encoding);
|
||||
fuzzed.ptr[i]--;
|
||||
a = identification_create_from_encoding(ID_DER_ASN1_DN, fuzzed);
|
||||
if (test_id_equals_one(a, "C=CH, [email protected], CN=martin"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
a->destroy(a);
|
||||
free(fuzzed.ptr);
|
||||
}
|
||||
free(encoding.ptr);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
* identification matches test
|
||||
******************************************************************************/
|
||||
|
||||
static id_match_t test_id_matches_one(identification_t *a, char *b_str)
|
||||
{
|
||||
identification_t *b;
|
||||
id_match_t match;
|
||||
|
||||
b = identification_create_from_string(b_str);
|
||||
match = a->matches(a, b);
|
||||
b->destroy(b);
|
||||
return match;
|
||||
}
|
||||
|
||||
bool test_id_matches()
|
||||
{
|
||||
identification_t *a;
|
||||
|
||||
a = identification_create_from_string(
|
||||
"C=CH, [email protected], CN=martin");
|
||||
|
||||
if (test_id_matches_one(a, "C=CH, [email protected], CN=martin")
|
||||
!= ID_MATCH_PERFECT)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=CH, E=*, CN=martin") != ID_MATCH_ONE_WILDCARD)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=CH, E=*, CN=*") != ID_MATCH_ONE_WILDCARD - 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=*, E=*, CN=*") != ID_MATCH_ONE_WILDCARD - 2)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=*, E=*, CN=*, O=BADInc") != ID_MATCH_NONE)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=*, E=*") != ID_MATCH_NONE)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (test_id_matches_one(a, "C=*, [email protected], CN=*") != ID_MATCH_NONE)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
a->destroy(a);
|
||||
return TRUE;
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
#include <utils/enumerator.h>
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* fetch public key from mediation database
|
||||
******************************************************************************/
|
||||
|
||||
bool test_med_db()
|
||||
{
|
||||
chunk_t found, keyid = chunk_from_chars(
|
||||
0xed,0x90,0xe6,0x4f,0xec,0xa2,0x1f,0x4b,
|
||||
0x68,0x97,0x99,0x24,0x22,0xe0,0xde,0x21,
|
||||
0xb9,0xd6,0x26,0x29
|
||||
);
|
||||
identification_t *id;
|
||||
enumerator_t *enumerator;
|
||||
public_key_t *public;
|
||||
auth_cfg_t *auth;
|
||||
bool good = FALSE;
|
||||
|
||||
id = identification_create_from_encoding(ID_KEY_ID, keyid);
|
||||
enumerator = charon->credentials->create_public_enumerator(
|
||||
charon->credentials, KEY_ANY, id, NULL);
|
||||
while (enumerator->enumerate(enumerator, &public, &auth))
|
||||
{
|
||||
good = public->get_fingerprint(public, KEY_ID_PUBKEY_SHA1, &found);
|
||||
if (good)
|
||||
{
|
||||
good = chunk_equals(id->get_encoding(id), found);
|
||||
}
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
id->destroy(id);
|
||||
return good;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <threading/mutex.h>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <sched.h>
|
||||
#include <pthread.h>
|
||||
|
||||
|
||||
static mutex_t *mutex;
|
||||
|
||||
static int locked = 0;
|
||||
|
||||
static bool failed = FALSE;
|
||||
|
||||
static pthread_barrier_t barrier;
|
||||
|
||||
static void* run(void* null)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* wait for all threads before getting in action */
|
||||
pthread_barrier_wait(&barrier);
|
||||
|
||||
for (i = 0; i < 100; i++)
|
||||
{
|
||||
mutex->lock(mutex);
|
||||
mutex->lock(mutex);
|
||||
mutex->lock(mutex);
|
||||
locked++;
|
||||
sched_yield();
|
||||
if (locked > 1)
|
||||
{
|
||||
failed = TRUE;
|
||||
}
|
||||
locked--;
|
||||
mutex->unlock(mutex);
|
||||
mutex->unlock(mutex);
|
||||
mutex->unlock(mutex);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#define THREADS 20
|
||||
|
||||
/*******************************************************************************
|
||||
* mutex test
|
||||
******************************************************************************/
|
||||
bool test_mutex()
|
||||
{
|
||||
int i;
|
||||
pthread_t threads[THREADS];
|
||||
|
||||
mutex = mutex_create(MUTEX_TYPE_RECURSIVE);
|
||||
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
mutex->lock(mutex);
|
||||
mutex->unlock(mutex);
|
||||
}
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
mutex->lock(mutex);
|
||||
}
|
||||
for (i = 0; i < 10; i++)
|
||||
{
|
||||
mutex->unlock(mutex);
|
||||
}
|
||||
|
||||
pthread_barrier_init(&barrier, NULL, THREADS);
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
pthread_create(&threads[i], NULL, run, NULL);
|
||||
}
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
pthread_join(threads[i], NULL);
|
||||
}
|
||||
pthread_barrier_destroy(&barrier);
|
||||
|
||||
mutex->destroy(mutex);
|
||||
|
||||
return !failed;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
#include <utils/enumerator.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* mysql simple test
|
||||
******************************************************************************/
|
||||
bool test_mysql()
|
||||
{
|
||||
database_t *db;
|
||||
char *txt = "I'm a superduper test";
|
||||
chunk_t data = chunk_from_chars(0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08);
|
||||
int row;
|
||||
chunk_t qdata;
|
||||
char *qtxt;
|
||||
bool good = FALSE;
|
||||
enumerator_t *enumerator;
|
||||
|
||||
db = lib->db->create(lib->db, "mysql://testuser:testpass@localhost/test");
|
||||
if (!db)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "CREATE TABLE test ("
|
||||
"id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
|
||||
"txt TEXT, data BLOB)") < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, &row, "INSERT INTO test (txt, data) VALUES (?,?)",
|
||||
DB_TEXT, txt, DB_BLOB, data) < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (row != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
enumerator = db->query(db, "SELECT txt, data FROM test WHERE id = ?",
|
||||
DB_INT, row,
|
||||
DB_TEXT, DB_BLOB);
|
||||
if (!enumerator)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
while (enumerator->enumerate(enumerator, &qtxt, &qdata))
|
||||
{
|
||||
if (good)
|
||||
{ /* only one row */
|
||||
good = FALSE;
|
||||
break;
|
||||
}
|
||||
if (streq(qtxt, txt) && chunk_equals(data, qdata))
|
||||
{
|
||||
good = TRUE;
|
||||
}
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
if (!good)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "DELETE FROM test WHERE id = ?", DB_INT, row) != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "DROP TABLE test") < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
db->destroy(db);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <time.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#include <library.h>
|
||||
|
||||
#define ALLOCS 1000
|
||||
#define THREADS 20
|
||||
|
||||
static void* testing(void *thread)
|
||||
{
|
||||
int i;
|
||||
host_t *addr[ALLOCS];
|
||||
identification_t *id[ALLOCS];
|
||||
|
||||
/* prepare identities */
|
||||
for (i = 0; i < ALLOCS; i++)
|
||||
{
|
||||
char buf[256];
|
||||
|
||||
snprintf(buf, sizeof(buf), "%d-%[email protected]", (uintptr_t)thread, i);
|
||||
id[i] = identification_create_from_string(buf);
|
||||
}
|
||||
|
||||
/* allocate addresses */
|
||||
for (i = 0; i < ALLOCS; i++)
|
||||
{
|
||||
addr[i] = lib->attributes->acquire_address(lib->attributes,
|
||||
"test", id[i], NULL);
|
||||
if (!addr[i])
|
||||
{
|
||||
return (void*)FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/* release addresses */
|
||||
for (i = 0; i < ALLOCS; i++)
|
||||
{
|
||||
lib->attributes->release_address(lib->attributes,
|
||||
"test", addr[i], id[i]);
|
||||
}
|
||||
|
||||
/* cleanup */
|
||||
for (i = 0; i < ALLOCS; i++)
|
||||
{
|
||||
addr[i]->destroy(addr[i]);
|
||||
id[i]->destroy(id[i]);
|
||||
}
|
||||
return (void*)TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* SQL pool performance test
|
||||
******************************************************************************/
|
||||
bool test_pool()
|
||||
{
|
||||
uintptr_t i;
|
||||
void *res;
|
||||
pthread_t thread[THREADS];
|
||||
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
if (pthread_create(&thread[i], NULL, (void*)testing, (void*)i) < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < THREADS; i++)
|
||||
{
|
||||
pthread_join(thread[i], &res);
|
||||
if (res == NULL)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
|
||||
/*******************************************************************************
|
||||
* RSA key generation and signature
|
||||
******************************************************************************/
|
||||
bool test_rsa_gen()
|
||||
{
|
||||
chunk_t data = chunk_from_chars(0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08);
|
||||
chunk_t sig, crypt, plain;
|
||||
private_key_t *private;
|
||||
public_key_t *public;
|
||||
u_int key_size;
|
||||
|
||||
for (key_size = 512; key_size <= 2048; key_size *= 2)
|
||||
{
|
||||
private = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, KEY_RSA,
|
||||
BUILD_KEY_SIZE, key_size, BUILD_END);
|
||||
if (!private)
|
||||
{
|
||||
DBG1(DBG_CFG, "generating %d bit RSA key failed");
|
||||
return FALSE;
|
||||
}
|
||||
public = private->get_public_key(private);
|
||||
if (!public)
|
||||
{
|
||||
DBG1(DBG_CFG, "generating public from private key failed");
|
||||
return FALSE;
|
||||
}
|
||||
if (!private->sign(private, SIGN_RSA_EMSA_PKCS1_SHA1, data, &sig))
|
||||
{
|
||||
DBG1(DBG_CFG, "creating RSA signature failed");
|
||||
return FALSE;
|
||||
}
|
||||
if (!public->verify(public, SIGN_RSA_EMSA_PKCS1_SHA1, data, sig))
|
||||
{
|
||||
DBG1(DBG_CFG, "verifying RSA signature failed");
|
||||
return FALSE;
|
||||
}
|
||||
sig.ptr[sig.len-1]++;
|
||||
if (public->verify(public, SIGN_RSA_EMSA_PKCS1_SHA1, data, sig))
|
||||
{
|
||||
DBG1(DBG_CFG, "verifying faked RSA signature succeeded!");
|
||||
return FALSE;
|
||||
}
|
||||
free(sig.ptr);
|
||||
if (!public->encrypt(public, data, &crypt))
|
||||
{
|
||||
DBG1(DBG_CFG, "encrypting data with RSA failed");
|
||||
return FALSE;
|
||||
}
|
||||
if (!private->decrypt(private, crypt, &plain))
|
||||
{
|
||||
DBG1(DBG_CFG, "decrypting data with RSA failed");
|
||||
return FALSE;
|
||||
}
|
||||
if (!chunk_equals(data, plain))
|
||||
{
|
||||
DBG1(DBG_CFG, "decrpyted data invalid, expected %B, got %B", &
|
||||
data, &plain);
|
||||
return FALSE;
|
||||
}
|
||||
chunk_clear(&crypt);
|
||||
chunk_clear(&plain);
|
||||
public->destroy(public);
|
||||
private->destroy(private);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
bool test_rsa_load_any()
|
||||
{
|
||||
chunk_t chunk = chunk_from_chars(
|
||||
0x30,0x82,0x01,0x20,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,
|
||||
0x01,0x05,0x00,0x03,0x82,0x01,0x0d,0x00,0x30,0x82,0x01,0x08,0x02,0x82,0x01,0x01,
|
||||
0x00,0xc6,0x68,0x99,0x1d,0xc8,0x06,0xdb,0xcf,0x1c,0x66,0xbb,0x91,0xc3,0xd4,0x10,
|
||||
0xb2,0x08,0xa9,0xc5,0x71,0x39,0x1c,0xbe,0x5b,0x1d,0xce,0xfd,0x1b,0xfa,0xec,0x04,
|
||||
0x89,0x9f,0x79,0xc8,0x46,0x00,0xd2,0x71,0xfb,0x22,0x16,0x52,0x2f,0xda,0xbf,0x0f,
|
||||
0xe7,0x16,0xb1,0xd7,0x6a,0xa5,0xa5,0xfc,0xee,0xff,0x84,0x4c,0x81,0x3f,0xab,0x84,
|
||||
0x0e,0xed,0x4a,0x26,0x59,0xd0,0x9b,0xb5,0xe1,0xec,0x61,0xc4,0xd3,0x15,0x4c,0x29,
|
||||
0x51,0xa0,0xde,0x33,0x07,0x58,0x6c,0x36,0x1b,0x18,0x61,0xd9,0x56,0x18,0x39,0x54,
|
||||
0x8b,0xd2,0xea,0x4e,0x87,0x28,0x58,0xb9,0x88,0x3d,0x30,0xbc,0xfc,0x6d,0xad,0xab,
|
||||
0x43,0x26,0x09,0x48,0x4e,0x6e,0x8a,0x8b,0x88,0xb3,0xf0,0x29,0x25,0x79,0xb6,0xb6,
|
||||
0x71,0x3c,0x93,0x59,0xd2,0x36,0x94,0xd5,0xfc,0xf3,0x62,0x2b,0x69,0xa3,0x7a,0x47,
|
||||
0x4e,0x53,0xa2,0x35,0x1b,0x26,0x89,0xaa,0x09,0xfd,0x56,0xd7,0x75,0x2a,0xd4,0x91,
|
||||
0xc0,0xf2,0x78,0xd7,0x05,0xca,0x12,0x1d,0xd9,0xd4,0x81,0x23,0xb2,0x3c,0x38,0xd9,
|
||||
0xb4,0xdc,0x21,0xe0,0xe5,0x2d,0xd4,0xbe,0x61,0x39,0x8a,0x46,0x90,0x46,0x73,0x31,
|
||||
0xba,0x48,0xbb,0x51,0xbb,0x91,0xd5,0x62,0xad,0xd1,0x53,0x5b,0x85,0xc9,0x1d,0xa7,
|
||||
0xf6,0xa0,0xe1,0x0e,0x6c,0x22,0x5d,0x29,0x9a,0xe7,0x0f,0xe8,0x0a,0x50,0xa7,0x19,
|
||||
0x11,0xc2,0x8b,0xe0,0x8a,0xfd,0x2b,0x94,0x31,0x7a,0x78,0x9c,0x9b,0x75,0x63,0x49,
|
||||
0xa9,0xe5,0x58,0xe6,0x3a,0x99,0xcb,0x2b,0xdd,0x0e,0xdc,0x7d,0x1b,0x98,0x80,0xc3,
|
||||
0x9f,0x02,0x01,0x23);
|
||||
public_key_t *public;
|
||||
|
||||
public = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_ANY,
|
||||
BUILD_BLOB_ASN1_DER, chunk,
|
||||
BUILD_END);
|
||||
if (!public || public->get_keysize(public) != 256)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
public->destroy(public);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright (C) 2008 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 <library.h>
|
||||
#include <daemon.h>
|
||||
#include <utils/enumerator.h>
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
|
||||
#define DBFILE "/tmp/strongswan-test.db"
|
||||
|
||||
/*******************************************************************************
|
||||
* sqlite simple test
|
||||
******************************************************************************/
|
||||
bool test_sqlite()
|
||||
{
|
||||
database_t *db;
|
||||
char *txt = "I'm a superduper test";
|
||||
chunk_t data = chunk_from_chars(0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08);
|
||||
int row;
|
||||
chunk_t qdata;
|
||||
char *qtxt;
|
||||
bool good = FALSE;
|
||||
enumerator_t *enumerator;
|
||||
|
||||
db = lib->db->create(lib->db, "sqlite://" DBFILE);
|
||||
if (!db)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "CREATE TABLE test (txt TEXT, data BLOB)") < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, &row, "INSERT INTO test (txt, data) VALUES (?,?)",
|
||||
DB_TEXT, txt, DB_BLOB, data) < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (row != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
enumerator = db->query(db, "SELECT txt, data FROM test WHERE oid = ?",
|
||||
DB_INT, row,
|
||||
DB_TEXT, DB_BLOB);
|
||||
if (!enumerator)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
while (enumerator->enumerate(enumerator, &qtxt, &qdata))
|
||||
{
|
||||
if (good)
|
||||
{ /* only one row */
|
||||
good = FALSE;
|
||||
break;
|
||||
}
|
||||
if (streq(qtxt, txt) && chunk_equals(data, qdata))
|
||||
{
|
||||
good = TRUE;
|
||||
}
|
||||
}
|
||||
enumerator->destroy(enumerator);
|
||||
if (!good)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "DELETE FROM test WHERE oid = ?", DB_INT, row) != 1)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
if (db->execute(db, NULL, "DROP TABLE test") < 0)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
db->destroy(db);
|
||||
unlink(DBFILE);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user