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

Rename diffie_hellman_t to key_exchange_t and change the interface etc.

Browse Source 
This makes it more generic so we can use it for QSKE methods.
This commit is contained in:
Tobias Brunner
2022-06-29 10:28:50 +02:00
parent ec95fd9b93
commit 3af7c6db87
130 changed files with 1379 additions and 1384 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libstrongswan/Android.mk
+1 -1
View File
@@ -15,7 +15,7 @@ crypto/prfs/prf.c crypto/prfs/mac_prf.c crypto/pkcs5.c \
crypto/rngs/rng.c crypto/rngs/rng_tester.c \
crypto/signers/signer.c \
crypto/signers/mac_signer.c crypto/crypto_factory.c crypto/crypto_tester.c \
crypto/diffie_hellman.c crypto/aead.c crypto/transform.c \
crypto/key_exchange.c crypto/aead.c crypto/transform.c \
crypto/iv/iv_gen.c crypto/iv/iv_gen_rand.c crypto/iv/iv_gen_seq.c \
crypto/iv/iv_gen_null.c crypto/kdfs/kdf.c \
crypto/xofs/xof.c crypto/xofs/xof_bitspender.c \
src/libstrongswan/Makefile.am
+2 -2
View File
@@ -13,7 +13,7 @@ crypto/prfs/prf.c crypto/prfs/mac_prf.c crypto/pkcs5.c \
crypto/rngs/rng.c crypto/rngs/rng_tester.c \
crypto/signers/signer.c \
crypto/signers/mac_signer.c crypto/crypto_factory.c crypto/crypto_tester.c \
crypto/diffie_hellman.c crypto/aead.c crypto/transform.c \
crypto/key_exchange.c crypto/aead.c crypto/transform.c \
crypto/iv/iv_gen.c crypto/iv/iv_gen_rand.c crypto/iv/iv_gen_seq.c \
crypto/iv/iv_gen_null.c crypto/kdfs/kdf.c \
crypto/xofs/xof.c crypto/xofs/xof_bitspender.c \
@@ -79,7 +79,7 @@ crypto/proposal/proposal_keywords.h crypto/proposal/proposal_keywords_static.h \
crypto/rngs/rng.h crypto/rngs/rng_tester.h \
crypto/prfs/prf.h crypto/prfs/mac_prf.h crypto/nonce_gen.h \
crypto/signers/signer.h crypto/signers/mac_signer.h \
crypto/crypto_factory.h crypto/crypto_tester.h crypto/diffie_hellman.h \
crypto/crypto_factory.h crypto/crypto_tester.h crypto/key_exchange.h \
crypto/aead.h crypto/transform.h crypto/pkcs5.h crypto/iv/iv_gen.h \
crypto/iv/iv_gen_rand.h crypto/iv/iv_gen_seq.h crypto/iv/iv_gen_null.h \
crypto/xofs/xof.h crypto/xofs/xof_bitspender.h crypto/xofs/mgf1.h \
src/libstrongswan/crypto/crypto_factory.c
+43 -47
View File
@@ -56,7 +56,7 @@ struct entry_t {
drbg_constructor_t create_drbg;
rng_constructor_t create_rng;
nonce_gen_constructor_t create_nonce_gen;
dh_constructor_t create_dh;
ke_constructor_t create_ke;
void *create;
};
};
@@ -124,9 +124,9 @@ struct private_crypto_factory_t {
linked_list_t *nonce_gens;
/**
* registered diffie hellman, as entry_t
* registered key exchange methods, as entry_t
*/
linked_list_t *dhs;
linked_list_t *kes;
/**
* test manager to test crypto algorithms
@@ -484,37 +484,33 @@ METHOD(crypto_factory_t, create_nonce_gen, nonce_gen_t*,
return nonce_gen;
}
METHOD(crypto_factory_t, create_dh, diffie_hellman_t*,
private_crypto_factory_t *this, diffie_hellman_group_t group, ...)
METHOD(crypto_factory_t, create_ke, key_exchange_t*,
private_crypto_factory_t *this, key_exchange_method_t method, ...)
{
enumerator_t *enumerator;
entry_t *entry;
va_list args;
chunk_t g = chunk_empty, p = chunk_empty;
diffie_hellman_t *diffie_hellman = NULL;
key_exchange_t *ke = NULL;
if (group == MODP_CUSTOM)
if (method == MODP_CUSTOM)
{
va_start(args, group);
g = va_arg(args, chunk_t);
p = va_arg(args, chunk_t);
va_end(args);
VA_ARGS_GET(method, g, p);
}
this->lock->read_lock(this->lock);
enumerator = this->dhs->create_enumerator(this->dhs);
enumerator = this->kes->create_enumerator(this->kes);
while (enumerator->enumerate(enumerator, &entry))
{
if (entry->algo == group)
if (entry->algo == method)
{
if (this->test_on_create && group != MODP_CUSTOM &&
!this->tester->test_dh(this->tester, group,
entry->create_dh, NULL, entry->plugin_name))
if (this->test_on_create && method != MODP_CUSTOM &&
!this->tester->test_ke(this->tester, method,
entry->create_ke, NULL, entry->plugin_name))
{
continue;
}
diffie_hellman = entry->create_dh(group, g, p);
if (diffie_hellman)
ke = entry->create_ke(method, g, p);
if (ke)
{
break;
}
@@ -522,7 +518,7 @@ METHOD(crypto_factory_t, create_dh, diffie_hellman_t*,
}
enumerator->destroy(enumerator);
this->lock->unlock(this->lock);
return diffie_hellman;
return ke;
}
/**
@@ -935,36 +931,36 @@ METHOD(crypto_factory_t, remove_nonce_gen, void,
this->lock->unlock(this->lock);
}
METHOD(crypto_factory_t, add_dh, bool,
private_crypto_factory_t *this, diffie_hellman_group_t group,
const char *plugin_name, dh_constructor_t create)
METHOD(crypto_factory_t, add_ke, bool,
private_crypto_factory_t *this, key_exchange_method_t group,
const char *plugin_name, ke_constructor_t create)
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_dh(this->tester, group, create,
this->tester->test_ke(this->tester, group, create,
this->bench ? &speed : NULL, plugin_name))
{
add_entry(this, this->dhs, group, plugin_name, 0, create);
add_entry(this, this->kes, group, plugin_name, 0, create);
return TRUE;
}
this->test_failures++;
return FALSE;
}
METHOD(crypto_factory_t, remove_dh, void,
private_crypto_factory_t *this, dh_constructor_t create)
METHOD(crypto_factory_t, remove_ke, void,
private_crypto_factory_t *this, ke_constructor_t create)
{
entry_t *entry;
enumerator_t *enumerator;
this->lock->write_lock(this->lock);
enumerator = this->dhs->create_enumerator(this->dhs);
enumerator = this->kes->create_enumerator(this->kes);
while (enumerator->enumerate(enumerator, &entry))
{
if (entry->create_dh == create)
if (entry->create_ke == create)
{
this->dhs->remove_at(this->dhs, enumerator);
this->kes->remove_at(this->kes, enumerator);
free(entry);
}
}
@@ -1190,11 +1186,11 @@ METHOD(crypto_factory_t, create_drbg_enumerator, enumerator_t*,
return create_enumerator(this, this->drbgs, drbg_filter);
}
CALLBACK(dh_filter, bool,
CALLBACK(ke_filter, bool,
void *n, enumerator_t *orig, va_list args)
{
entry_t *entry;
diffie_hellman_group_t *algo;
key_exchange_method_t *algo;
const char **plugin_name;
VA_ARGS_VGET(args, algo, plugin_name);
@@ -1208,10 +1204,10 @@ CALLBACK(dh_filter, bool,
return FALSE;
}
METHOD(crypto_factory_t, create_dh_enumerator, enumerator_t*,
METHOD(crypto_factory_t, create_ke_enumerator, enumerator_t*,
private_crypto_factory_t *this)
{
return create_enumerator(this, this->dhs, dh_filter);
return create_enumerator(this, this->kes, ke_filter);
}
CALLBACK(rng_filter, bool,
@@ -1283,8 +1279,8 @@ METHOD(crypto_factory_t, add_test_vector, void,
return this->tester->add_drbg_vector(this->tester, vector);
case RANDOM_NUMBER_GENERATOR:
return this->tester->add_rng_vector(this->tester, vector);
case DIFFIE_HELLMAN_GROUP:
return this->tester->add_dh_vector(this->tester, vector);
case KEY_EXCHANGE_METHOD:
return this->tester->add_ke_vector(this->tester, vector);
default:
DBG1(DBG_LIB, "%N test vectors not supported, ignored",
transform_type_names, type);
@@ -1354,9 +1350,9 @@ METHOD(enumerator_t, verify_enumerate, bool,
*valid = this->tester->test_rng(this->tester, entry->algo,
entry->create_rng, NULL, entry->plugin_name);
break;
case DIFFIE_HELLMAN_GROUP:
*valid = this->tester->test_dh(this->tester, entry->algo,
entry->create_dh, NULL, entry->plugin_name);
case KEY_EXCHANGE_METHOD:
*valid = this->tester->test_ke(this->tester, entry->algo,
entry->create_ke, NULL, entry->plugin_name);
break;
default:
return FALSE;
@@ -1410,8 +1406,8 @@ METHOD(crypto_factory_t, create_verify_enumerator, enumerator_t*,
case RANDOM_NUMBER_GENERATOR:
inner = this->rngs->create_enumerator(this->rngs);
break;
case DIFFIE_HELLMAN_GROUP:
inner = this->dhs->create_enumerator(this->dhs);
case KEY_EXCHANGE_METHOD:
inner = this->kes->create_enumerator(this->kes);
break;
default:
this->lock->unlock(this->lock);
@@ -1444,7 +1440,7 @@ METHOD(crypto_factory_t, destroy, void,
this->drbgs->destroy(this->drbgs);
this->rngs->destroy(this->rngs);
this->nonce_gens->destroy(this->nonce_gens);
this->dhs->destroy(this->dhs);
this->kes->destroy(this->kes);
this->tester->destroy(this->tester);
this->lock->destroy(this->lock);
free(this);
@@ -1469,7 +1465,7 @@ crypto_factory_t *crypto_factory_create()
.create_drbg = _create_drbg,
.create_rng = _create_rng,
.create_nonce_gen = _create_nonce_gen,
.create_dh = _create_dh,
.create_ke = _create_ke,
.add_crypter = _add_crypter,
.remove_crypter = _remove_crypter,
.add_aead = _add_aead,
@@ -1490,8 +1486,8 @@ crypto_factory_t *crypto_factory_create()
.remove_rng = _remove_rng,
.add_nonce_gen = _add_nonce_gen,
.remove_nonce_gen = _remove_nonce_gen,
.add_dh = _add_dh,
.remove_dh = _remove_dh,
.add_ke = _add_ke,
.remove_ke = _remove_ke,
.create_crypter_enumerator = _create_crypter_enumerator,
.create_aead_enumerator = _create_aead_enumerator,
.create_signer_enumerator = _create_signer_enumerator,
@@ -1500,7 +1496,7 @@ crypto_factory_t *crypto_factory_create()
.create_xof_enumerator = _create_xof_enumerator,
.create_kdf_enumerator = _create_kdf_enumerator,
.create_drbg_enumerator = _create_drbg_enumerator,
.create_dh_enumerator = _create_dh_enumerator,
.create_ke_enumerator = _create_ke_enumerator,
.create_rng_enumerator = _create_rng_enumerator,
.create_nonce_gen_enumerator = _create_nonce_gen_enumerator,
.add_test_vector = _add_test_vector,
@@ -1517,7 +1513,7 @@ crypto_factory_t *crypto_factory_create()
.drbgs = linked_list_create(),
.rngs = linked_list_create(),
.nonce_gens = linked_list_create(),
.dhs = linked_list_create(),
.kes = linked_list_create(),
.lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
.tester = crypto_tester_create(),
.test_on_add = lib->settings->get_bool(lib->settings,
src/libstrongswan/crypto/crypto_factory.h
+19 -19
View File
@@ -37,7 +37,7 @@ typedef struct crypto_factory_t crypto_factory_t;
#include <crypto/kdfs/kdf.h>
#include <crypto/drbgs/drbg.h>
#include <crypto/nonce_gen.h>
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
#include <crypto/transform.h>
#define CRYPTO_MAX_ALG_LINE 120 /* characters */
@@ -97,12 +97,12 @@ typedef rng_t* (*rng_constructor_t)(rng_quality_t quality);
typedef nonce_gen_t* (*nonce_gen_constructor_t)();
/**
* Constructor function for diffie hellman
* Constructor function for key exchange methods
*
* The DH constructor accepts additional arguments for:
* The key exchange method constructor accepts additional arguments for:
* - MODP_CUSTOM: chunk_t generator, chunk_t prime
*/
typedef diffie_hellman_t* (*dh_constructor_t)(diffie_hellman_group_t group, ...);
typedef key_exchange_t* (*ke_constructor_t)(key_exchange_method_t method, ...);
/**
* Handles crypto modules and creates instances.
@@ -207,15 +207,15 @@ struct crypto_factory_t {
nonce_gen_t* (*create_nonce_gen)(crypto_factory_t *this);
/**
* Create a diffie hellman instance.
* Create a key exchange method instance.
*
* Additional arguments are passed to the DH constructor.
* Additional arguments are passed to the key exchange method constructor.
*
* @param group diffie hellman group
* @return diffie_hellman_t instance, NULL if not supported
* @param method key exchange method
* @return key_exchange_t instance, NULL if not supported
*/
diffie_hellman_t* (*create_dh)(crypto_factory_t *this,
diffie_hellman_group_t group, ...);
key_exchange_t* (*create_ke)(crypto_factory_t *this,
key_exchange_method_t method, ...);
/**
* Register a crypter constructor.
@@ -402,22 +402,22 @@ struct crypto_factory_t {
nonce_gen_constructor_t create);
/**
* Register a diffie hellman constructor.
* Register a key exchange method constructor.
*
* @param group dh group to constructor
* @param method key exchange method to constructor
* @param plugin_name plugin that registered this algorithm
* @param create constructor function for that algorithm
* @return TRUE if registered, FALSE if test vector failed
*/
bool (*add_dh)(crypto_factory_t *this, diffie_hellman_group_t group,
const char *plugin_name, dh_constructor_t create);
bool (*add_ke)(crypto_factory_t *this, key_exchange_method_t method,
const char *plugin_name, ke_constructor_t create);
/**
* Unregister a diffie hellman constructor.
* Unregister a key exchange method constructor.
*
* @param create constructor function to unregister
*/
void (*remove_dh)(crypto_factory_t *this, dh_constructor_t create);
void (*remove_ke)(crypto_factory_t *this, ke_constructor_t create);
/**
* Create an enumerator over all registered crypter algorithms.
@@ -476,11 +476,11 @@ struct crypto_factory_t {
enumerator_t* (*create_drbg_enumerator)(crypto_factory_t *this);
/**
* Create an enumerator over all registered diffie hellman groups.
* Create an enumerator over all registered key exchange method.
*
* @return enumerator over diffie_hellman_group_t, plugin
* @return enumerator over key_exchange_method_t, plugin
*/
enumerator_t* (*create_dh_enumerator)(crypto_factory_t *this);
enumerator_t* (*create_ke_enumerator)(crypto_factory_t *this);
/**
* Create an enumerator over all registered random generators.
src/libstrongswan/crypto/crypto_tester.c
+41 -41
View File
@@ -85,9 +85,9 @@ struct private_crypto_tester_t {
linked_list_t *rng;
/**
* List of Diffie-Hellman test vectors
* List of key exchange method test vectors
*/
linked_list_t *dh;
linked_list_t *ke;
/**
* Is a test vector required to pass a test?
@@ -1649,13 +1649,13 @@ failure:
}
/**
* Benchmark a DH backend
* Benchmark a key exchange backend
*/
static u_int bench_dh(private_crypto_tester_t *this,
diffie_hellman_group_t group, dh_constructor_t create)
static u_int bench_ke(private_crypto_tester_t *this,
key_exchange_method_t method, ke_constructor_t create)
{
chunk_t pub = chunk_empty, shared = chunk_empty;
diffie_hellman_t *dh;
key_exchange_t *ke;
struct timespec start;
u_int runs;
@@ -1663,46 +1663,46 @@ static u_int bench_dh(private_crypto_tester_t *this,
start_timing(&start);
while (end_timing(&start) < this->bench_time)
{
dh = create(group);
if (!dh)
ke = create(method);
if (!ke)
{
return 0;
}
if (dh->get_my_public_value(dh, &pub) &&
dh->set_other_public_value(dh, pub) &&
dh->get_shared_secret(dh, &shared))
if (ke->get_public_key(ke, &pub) &&
ke->set_public_key(ke, pub) &&
ke->get_shared_secret(ke, &shared))
{
runs++;
}
chunk_free(&pub);
chunk_free(&shared);
dh->destroy(dh);
ke->destroy(ke);
}
return runs;
}
METHOD(crypto_tester_t, test_dh, bool,
private_crypto_tester_t *this, diffie_hellman_group_t group,
dh_constructor_t create, u_int *speed, const char *plugin_name)
METHOD(crypto_tester_t, test_ke, bool,
private_crypto_tester_t *this, key_exchange_method_t method,
ke_constructor_t create, u_int *speed, const char *plugin_name)
{
enumerator_t *enumerator;
dh_test_vector_t *v;
ke_test_vector_t *v;
bool failed = FALSE;
u_int tested = 0;
enumerator = this->dh->create_enumerator(this->dh);
enumerator = this->ke->create_enumerator(this->ke);
while (enumerator->enumerate(enumerator, &v))
{
diffie_hellman_t *a, *b;
key_exchange_t *a, *b;
chunk_t apub, bpub, asec, bsec;
if (v->group != group)
if (v->method != method)
{
continue;
}
a = create(group);
b = create(group);
a = create(method);
b = create(method);
if (!a || !b)
{
DESTROY_IF(a);
@@ -1710,11 +1710,11 @@ METHOD(crypto_tester_t, test_dh, bool,
failed = TRUE;
tested++;
DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
diffie_hellman_group_names, group, plugin_name);
key_exchange_method_names, method, plugin_name);
break;
}
if (!a->set_private_value || !b->set_private_value)
if (!a->set_private_key || !b->set_private_key)
{ /* does not support testing */
a->destroy(a);
b->destroy(b);
@@ -1725,23 +1725,23 @@ METHOD(crypto_tester_t, test_dh, bool,
apub = bpub = asec = bsec = chunk_empty;
if (!a->set_private_value(a, chunk_create(v->priv_a, v->priv_len)) ||
!b->set_private_value(b, chunk_create(v->priv_b, v->priv_len)))
if (!a->set_private_key(a, chunk_create(v->priv_a, v->priv_len)) ||
!b->set_private_key(b, chunk_create(v->priv_b, v->priv_len)))
{
goto failure;
}
if (!a->get_my_public_value(a, &apub) ||
if (!a->get_public_key(a, &apub) ||
!chunk_equals(apub, chunk_create(v->pub_a, v->pub_len)))
{
goto failure;
}
if (!b->get_my_public_value(b, &bpub) ||
if (!b->get_public_key(b, &bpub) ||
!chunk_equals(bpub, chunk_create(v->pub_b, v->pub_len)))
{
goto failure;
}
if (!a->set_other_public_value(a, bpub) ||
!b->set_other_public_value(b, apub))
if (!a->set_public_key(a, bpub) ||
!b->set_public_key(b, apub))
{
goto failure;
}
@@ -1767,7 +1767,7 @@ failure:
if (failed)
{
DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
diffie_hellman_group_names, group, plugin_name, get_name(v));
key_exchange_method_names, method, plugin_name, get_name(v));
break;
}
}
@@ -1776,21 +1776,21 @@ failure:
{
DBG1(DBG_LIB, "%s %N[%s]: no test vectors found / untestable",
this->required ? "disabled" : "enabled ",
diffie_hellman_group_names, group, plugin_name);
key_exchange_method_names, method, plugin_name);
return !this->required;
}
if (!failed)
{
if (speed)
{
*speed = bench_dh(this, group, create);
*speed = bench_ke(this, method, create);
DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
diffie_hellman_group_names, group, plugin_name, tested, *speed);
key_exchange_method_names, method, plugin_name, tested, *speed);
}
else
{
DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
diffie_hellman_group_names, group, plugin_name, tested);
key_exchange_method_names, method, plugin_name, tested);
}
}
return !failed;
@@ -1850,10 +1850,10 @@ METHOD(crypto_tester_t, add_rng_vector, void,
this->rng->insert_last(this->rng, vector);
}
METHOD(crypto_tester_t, add_dh_vector, void,
private_crypto_tester_t *this, dh_test_vector_t *vector)
METHOD(crypto_tester_t, add_ke_vector, void,
private_crypto_tester_t *this, ke_test_vector_t *vector)
{
this->dh->insert_last(this->dh, vector);
this->ke->insert_last(this->ke, vector);
}
METHOD(crypto_tester_t, destroy, void,
@@ -1868,7 +1868,7 @@ METHOD(crypto_tester_t, destroy, void,
this->kdf->destroy(this->kdf);
this->drbg->destroy(this->drbg);
this->rng->destroy(this->rng);
this->dh->destroy(this->dh);
this->ke->destroy(this->ke);
free(this);
}
@@ -1890,7 +1890,7 @@ crypto_tester_t *crypto_tester_create()
.test_kdf = _test_kdf,
.test_drbg = _test_drbg,
.test_rng = _test_rng,
.test_dh = _test_dh,
.test_ke = _test_ke,
.add_crypter_vector = _add_crypter_vector,
.add_aead_vector = _add_aead_vector,
.add_signer_vector = _add_signer_vector,
@@ -1900,7 +1900,7 @@ crypto_tester_t *crypto_tester_create()
.add_kdf_vector = _add_kdf_vector,
.add_drbg_vector = _add_drbg_vector,
.add_rng_vector = _add_rng_vector,
.add_dh_vector = _add_dh_vector,
.add_ke_vector = _add_ke_vector,
.destroy = _destroy,
},
.crypter = linked_list_create(),
@@ -1912,7 +1912,7 @@ crypto_tester_t *crypto_tester_create()
.kdf = linked_list_create(),
.drbg = linked_list_create(),
.rng = linked_list_create(),
.dh = linked_list_create(),
.ke = linked_list_create(),
.required = lib->settings->get_bool(lib->settings,
"%s.crypto_test.required", FALSE, lib->ns),
src/libstrongswan/crypto/crypto_tester.h
+17 -17
View File
@@ -37,7 +37,7 @@ typedef struct kdf_test_vector_t kdf_test_vector_t;
typedef struct kdf_test_args_t kdf_test_args_t;
typedef struct drbg_test_vector_t drbg_test_vector_t;
typedef struct rng_test_vector_t rng_test_vector_t;
typedef struct dh_test_vector_t dh_test_vector_t;
typedef struct ke_test_vector_t ke_test_vector_t;
struct crypter_test_vector_t {
/** encryption algorithm this vector tests */
@@ -182,20 +182,20 @@ struct rng_test_vector_t {
void *user;
};
struct dh_test_vector_t {
/** diffie hellman group to test */
diffie_hellman_group_t group;
/** private value of alice */
struct ke_test_vector_t {
/** key exchange method to test */
key_exchange_method_t method;
/** private key of alice */
u_char *priv_a;
/** private value of bob */
/** private key of bob */
u_char *priv_b;
/** length of private values */
/** length of private keys */
size_t priv_len;
/** expected public value of alice */
/** expected public key of alice */
u_char *pub_a;
/** expected public value of bob */
/** expected public key of bob */
u_char *pub_b;
/** size of public values */
/** size of public keys */
size_t pub_len;
/** expected shared secret */
u_char *shared;
@@ -318,15 +318,15 @@ struct crypto_tester_t {
rng_constructor_t create,
u_int *speed, const char *plugin_name);
/**
* Test a Diffie-Hellman implementation.
* Test a key exchange implementation.
*
* @param group group to test
* @param create constructor function for the DH backend
* @param speed speed test result, NULL to omit
* @param ke key exchange method to test
* @param create constructor function for the key exchange method
* @param speed speeed test result, NULL to omit
* @return TRUE if test passed
*/
bool (*test_dh)(crypto_tester_t *this, diffie_hellman_group_t group,
dh_constructor_t create,
bool (*test_ke)(crypto_tester_t *this, key_exchange_method_t ke,
ke_constructor_t create,
u_int *speed, const char *plugin_name);
/**
@@ -397,7 +397,7 @@ struct crypto_tester_t {
*
* @param vector pointer to test vector
*/
void (*add_dh_vector)(crypto_tester_t *this, dh_test_vector_t *vector);
void (*add_ke_vector)(crypto_tester_t *this, ke_test_vector_t *vector);
/**
* Destroy a crypto_tester_t.
src/libstrongswan/crypto/diffie_hellman.c → src/libstrongswan/crypto/key_exchange.c
+39 -39
View File
@@ -1,5 +1,5 @@
/*
* Copyright (C) 2010 Tobias Brunner
* Copyright (C) 2010-2019 Tobias Brunner
* Copyright (C) 2005-2010 Martin Willi
* Copyright (C) 2005 Jan Hutter
*
@@ -16,15 +16,15 @@
* for more details.
*/
#include "diffie_hellman.h"
#include "key_exchange.h"
ENUM_BEGIN(diffie_hellman_group_names, MODP_NONE, MODP_1024_BIT,
ENUM_BEGIN(key_exchange_method_names, MODP_NONE, MODP_1024_BIT,
"MODP_NONE",
"MODP_768",
"MODP_1024");
ENUM_NEXT(diffie_hellman_group_names, MODP_1536_BIT, MODP_1536_BIT, MODP_1024_BIT,
ENUM_NEXT(key_exchange_method_names, MODP_1536_BIT, MODP_1536_BIT, MODP_1024_BIT,
"MODP_1536");
ENUM_NEXT(diffie_hellman_group_names, MODP_2048_BIT, ECP_521_BIT, MODP_1536_BIT,
ENUM_NEXT(key_exchange_method_names, MODP_2048_BIT, ECP_521_BIT, MODP_1536_BIT,
"MODP_2048",
"MODP_3072",
"MODP_4096",
@@ -33,7 +33,7 @@ ENUM_NEXT(diffie_hellman_group_names, MODP_2048_BIT, ECP_521_BIT, MODP_1536_BIT,
"ECP_256",
"ECP_384",
"ECP_521");
ENUM_NEXT(diffie_hellman_group_names, MODP_1024_160, CURVE_448, ECP_521_BIT,
ENUM_NEXT(key_exchange_method_names, MODP_1024_160, CURVE_448, ECP_521_BIT,
"MODP_1024_160",
"MODP_2048_224",
"MODP_2048_256",
@@ -45,26 +45,26 @@ ENUM_NEXT(diffie_hellman_group_names, MODP_1024_160, CURVE_448, ECP_521_BIT,
"ECP_512_BP",
"CURVE_25519",
"CURVE_448");
ENUM_NEXT(diffie_hellman_group_names, MODP_NULL, MODP_NULL, CURVE_448,
ENUM_NEXT(key_exchange_method_names, MODP_NULL, MODP_NULL, CURVE_448,
"MODP_NULL");
ENUM_NEXT(diffie_hellman_group_names, NTRU_112_BIT, NTRU_256_BIT, MODP_NULL,
ENUM_NEXT(key_exchange_method_names, NTRU_112_BIT, NTRU_256_BIT, MODP_NULL,
"NTRU_112",
"NTRU_128",
"NTRU_192",
"NTRU_256");
ENUM_NEXT(diffie_hellman_group_names, NH_128_BIT, NH_128_BIT, NTRU_256_BIT,
ENUM_NEXT(key_exchange_method_names, NH_128_BIT, NH_128_BIT, NTRU_256_BIT,
"NEWHOPE_128");
ENUM_NEXT(diffie_hellman_group_names, MODP_CUSTOM, MODP_CUSTOM, NH_128_BIT,
ENUM_NEXT(key_exchange_method_names, MODP_CUSTOM, MODP_CUSTOM, NH_128_BIT,
"MODP_CUSTOM");
ENUM_END(diffie_hellman_group_names, MODP_CUSTOM);
ENUM_END(key_exchange_method_names, MODP_CUSTOM);
ENUM_BEGIN(diffie_hellman_group_names_short, MODP_NONE, MODP_1024_BIT,
ENUM_BEGIN(key_exchange_method_names_short, MODP_NONE, MODP_1024_BIT,
"modpnone",
"modp768",
"modp1024");
ENUM_NEXT(diffie_hellman_group_names_short, MODP_1536_BIT, MODP_1536_BIT, MODP_1024_BIT,
ENUM_NEXT(key_exchange_method_names_short, MODP_1536_BIT, MODP_1536_BIT, MODP_1024_BIT,
"modp1536");
ENUM_NEXT(diffie_hellman_group_names_short, MODP_2048_BIT, ECP_521_BIT, MODP_1536_BIT,
ENUM_NEXT(key_exchange_method_names_short, MODP_2048_BIT, ECP_521_BIT, MODP_1536_BIT,
"modp2048",
"modp3072",
"modp4096",
@@ -73,7 +73,7 @@ ENUM_NEXT(diffie_hellman_group_names_short, MODP_2048_BIT, ECP_521_BIT, MODP_153
"ecp256",
"ecp384",
"ecp521");
ENUM_NEXT(diffie_hellman_group_names_short, MODP_1024_160, CURVE_448, ECP_521_BIT,
ENUM_NEXT(key_exchange_method_names_short, MODP_1024_160, CURVE_448, ECP_521_BIT,
"modp1024s160",
"modp2048s224",
"modp2048s256",
@@ -85,27 +85,27 @@ ENUM_NEXT(diffie_hellman_group_names_short, MODP_1024_160, CURVE_448, ECP_521_BI
"ecp512bp",
"curve25519",
"curve448");
ENUM_NEXT(diffie_hellman_group_names_short, MODP_NULL, MODP_NULL, CURVE_448,
ENUM_NEXT(key_exchange_method_names_short, MODP_NULL, MODP_NULL, CURVE_448,
"modpnull");
ENUM_NEXT(diffie_hellman_group_names_short, NTRU_112_BIT, NTRU_256_BIT, MODP_NULL,
ENUM_NEXT(key_exchange_method_names_short, NTRU_112_BIT, NTRU_256_BIT, MODP_NULL,
"ntru112",
"ntru128",
"ntru192",
"ntru256");
ENUM_NEXT(diffie_hellman_group_names_short, NH_128_BIT, NH_128_BIT, NTRU_256_BIT,
ENUM_NEXT(key_exchange_method_names_short, NH_128_BIT, NH_128_BIT, NTRU_256_BIT,
"newhope128");
ENUM_NEXT(diffie_hellman_group_names_short, MODP_CUSTOM, MODP_CUSTOM, NH_128_BIT,
ENUM_NEXT(key_exchange_method_names_short, MODP_CUSTOM, MODP_CUSTOM, NH_128_BIT,
"modpcustom");
ENUM_END(diffie_hellman_group_names_short, MODP_CUSTOM);
ENUM_END(key_exchange_method_names_short, MODP_CUSTOM);
/**
* List of known diffie hellman group parameters.
* List of known Diffie-Hellman group parameters.
*/
static struct {
/* Public part of the struct */
diffie_hellman_params_t public;
/* The group identifier as specified in IKEv2 */
diffie_hellman_group_t group;
key_exchange_method_t group;
} dh_params[] = {
{
.group = MODP_768_BIT, .public = {
@@ -475,8 +475,8 @@ static struct {
},
};
/**
* See header.
/*
* Described in header
*/
void diffie_hellman_init()
{
@@ -500,16 +500,16 @@ void diffie_hellman_init()
}
}
/**
* Described in header.
/*
* Described in header
*/
diffie_hellman_params_t *diffie_hellman_get_params(diffie_hellman_group_t group)
diffie_hellman_params_t *diffie_hellman_get_params(key_exchange_method_t ke)
{
int i;
for (i = 0; i < countof(dh_params); i++)
{
if (dh_params[i].group == group)
if (dh_params[i].group == ke)
{
return &dh_params[i].public;
}
@@ -517,12 +517,12 @@ diffie_hellman_params_t *diffie_hellman_get_params(diffie_hellman_group_t group)
return NULL;
}
/**
* See header.
/*
* Described in header
*/
bool diffie_hellman_group_is_ec(diffie_hellman_group_t group)
bool key_exchange_is_ecdh(key_exchange_method_t ke)
{
switch (group)
switch (ke)
{
case ECP_256_BIT:
case ECP_384_BIT:
@@ -541,15 +541,15 @@ bool diffie_hellman_group_is_ec(diffie_hellman_group_t group)
}
}
/**
* See header.
/*
* Described in header
*/
bool diffie_hellman_verify_value(diffie_hellman_group_t group, chunk_t value)
bool key_exchange_verify_pubkey(key_exchange_method_t ke, chunk_t value)
{
diffie_hellman_params_t *params;
bool valid = FALSE;
switch (group)
switch (ke)
{
case MODP_768_BIT:
case MODP_1024_BIT:
@@ -562,7 +562,7 @@ bool diffie_hellman_verify_value(diffie_hellman_group_t group, chunk_t value)
case MODP_1024_160:
case MODP_2048_224:
case MODP_2048_256:
params = diffie_hellman_get_params(group);
params = diffie_hellman_get_params(ke);
if (params)
{
valid = value.len == params->prime.len;
@@ -610,12 +610,12 @@ bool diffie_hellman_verify_value(diffie_hellman_group_t group, chunk_t value)
case MODP_NONE:
/* fail */
break;
/* compile-warn unhandled groups, fail verification */
/* compile-warn unhandled methods, fail verification */
}
if (!valid)
{
DBG1(DBG_ENC, "invalid DH public value size (%zu bytes) for %N",
value.len, diffie_hellman_group_names, group);
value.len, key_exchange_method_names, ke);
}
return valid;
}
src/libstrongswan/crypto/diffie_hellman.h → src/libstrongswan/crypto/key_exchange.h
+49 -54
View File
@@ -1,5 +1,5 @@
/*
* Copyright (C) 2010 Tobias Brunner
* Copyright (C) 2010-2019 Tobias Brunner
* Copyright (C) 2005-2007 Martin Willi
* Copyright (C) 2005 Jan Hutter
*
@@ -17,21 +17,21 @@
*/
/**
* @defgroup diffie_hellman diffie_hellman
* @defgroup key_exchange key_exchange
* @{ @ingroup crypto
*/
#ifndef DIFFIE_HELLMAN_H_
#define DIFFIE_HELLMAN_H_
#ifndef KEY_EXCHANGE_H_
#define KEY_EXCHANGE_H_
typedef enum diffie_hellman_group_t diffie_hellman_group_t;
typedef struct diffie_hellman_t diffie_hellman_t;
typedef enum key_exchange_method_t key_exchange_method_t;
typedef struct key_exchange_t key_exchange_t;
typedef struct diffie_hellman_params_t diffie_hellman_params_t;
#include <library.h>
/**
* Diffie-Hellman group.
* Key exchange method.
*
* The modulus (or group) to use for a Diffie-Hellman calculation.
* See IKEv2 RFC 3.3.2 and RFC 3526.
@@ -40,7 +40,7 @@ typedef struct diffie_hellman_params_t diffie_hellman_params_t;
* ECC Brainpool groups are defined in RFC 6954.
* Curve25519 and Curve448 groups are defined in RFC 8031.
*/
enum diffie_hellman_group_t {
enum key_exchange_method_t {
MODP_NONE = 0,
MODP_768_BIT = 1,
MODP_1024_BIT = 2,
@@ -79,80 +79,75 @@ enum diffie_hellman_group_t {
};
/**
* enum name for diffie_hellman_group_t.
* enum name for key_exchange_method_t.
*/
extern enum_name_t *diffie_hellman_group_names;
extern enum_name_t *key_exchange_method_names;
/**
* enum names for diffie_hellman_group_t (matching proposal keywords).
* enum names for key_exchange_method_t (matching proposal keywords).
*/
extern enum_name_t *diffie_hellman_group_names_short;
extern enum_name_t *key_exchange_method_names_short;
/**
* Implementation of the Diffie-Hellman algorithm, as in RFC2631.
* Implementation of a key exchange algorithms (e.g. Diffie-Hellman).
*/
struct diffie_hellman_t {
struct key_exchange_t {
/**
* Returns the shared secret of this diffie hellman exchange.
* Returns the shared secret of this key exchange method.
*
* Space for returned secret is allocated and must be freed by the caller.
*
* @param secret shared secret will be written into this chunk
* @param secret shared secret (allocated)
* @return TRUE if shared secret computed successfully
*/
bool (*get_shared_secret)(diffie_hellman_t *this, chunk_t *secret)
bool (*get_shared_secret)(key_exchange_t *this, chunk_t *secret)
__attribute__((warn_unused_result));
/**
* Sets the public value of partner.
* Sets the public key from the peer.
*
* Chunk gets cloned and can be destroyed afterwards.
*
* @param value public value of partner
* @return TRUE if other public value verified and set
* @param value public key of peer
* @return TRUE if other public key verified and set
*/
bool (*set_other_public_value)(diffie_hellman_t *this, chunk_t value)
bool (*set_public_key)(key_exchange_t *this, chunk_t value)
__attribute__((warn_unused_result));
/**
* Gets the own public value to transmit.
* Gets the own public key to transmit.
*
* Space for returned chunk is allocated and must be freed by the caller.
*
* @param value public value of caller is stored at this location
* @return TRUE if public value retrieved
* @param value public key (allocated)
* @return TRUE if public key retrieved
*/
bool (*get_my_public_value) (diffie_hellman_t *this, chunk_t *value)
bool (*get_public_key)(key_exchange_t *this, chunk_t *value)
__attribute__((warn_unused_result));
/**
* Set an explicit own private value to use.
* Set an explicit own private key to use.
*
* Calling this method is usually not required, as the DH backend generates
* an appropriate private value itself. It is optional to implement, and
* used mostly for testing purposes.
* used mostly for testing purposes. The private key may be the actual key
* or a seed for a DRBG.
*
* @param value private value to set
* @param value private key value to set
*/
bool (*set_private_value)(diffie_hellman_t *this, chunk_t value)
bool (*set_private_key)(key_exchange_t *this, chunk_t value)
__attribute__((warn_unused_result));
/**
* Get the DH group used.
* Get the key exchange method used.
*
* @return DH group set in construction
* @return key exchange method set in construction
*/
diffie_hellman_group_t (*get_dh_group) (diffie_hellman_t *this);
key_exchange_method_t (*get_method)(key_exchange_t *this);
/**
* Destroys a diffie_hellman_t object.
* Destroys a key_exchange_t object.
*/
void (*destroy) (diffie_hellman_t *this);
void (*destroy)(key_exchange_t *this);
};
/**
* Parameters for a specific diffie hellman group.
* Parameters for a specific Diffie-Hellman group.
*/
struct diffie_hellman_params_t {
@@ -183,31 +178,31 @@ struct diffie_hellman_params_t {
void diffie_hellman_init();
/**
* Get the parameters associated with the specified diffie hellman group.
* Get the parameters associated with the specified Diffie-Hellman group.
*
* Before calling this method, use diffie_hellman_init() to initialize the
* DH group table. This is usually done by library_init().
*
* @param group DH group
* @param ke key exchange method (DH group)
* @return The parameters or NULL, if the group is not supported
*/
diffie_hellman_params_t *diffie_hellman_get_params(diffie_hellman_group_t group);
diffie_hellman_params_t *diffie_hellman_get_params(key_exchange_method_t ke);
/**
* Check if a given DH group is an ECDH group
* Check if a given key exchange method is an ECDH group.
*
* @param group group to check
* @return TRUE if group is an ECP group
* @param ke key exchange method to check
* @return TRUE if key exchange method is an ECP group
*/
bool diffie_hellman_group_is_ec(diffie_hellman_group_t group);
bool key_exchange_is_ecdh(key_exchange_method_t ke);
/**
* Check if a diffie hellman public value is valid for given group.
* Check if a public key is valid for given key exchange method.
*
* @param group group the value is used in
* @param value public DH value to check
* @return TRUE if value looks valid for group
* @param ke key exchange method
* @param value public key to check
* @return TRUE if value looks valid
*/
bool diffie_hellman_verify_value(diffie_hellman_group_t group, chunk_t value);
bool key_exchange_verify_pubkey(key_exchange_method_t ke, chunk_t value);
#endif /** DIFFIE_HELLMAN_H_ @}*/
#endif /** KEY_EXCHANGE_H_ @}*/
src/libstrongswan/crypto/proposal/proposal.c
+25 -25
View File
@@ -252,18 +252,18 @@ METHOD(proposal_t, get_algorithm, bool,
return found;
}
METHOD(proposal_t, has_dh_group, bool,
private_proposal_t *this, diffie_hellman_group_t group)
METHOD(proposal_t, has_ke_method, bool,
private_proposal_t *this, key_exchange_method_t ke)
{
bool found = FALSE, any = FALSE;
enumerator_t *enumerator;
uint16_t current;
enumerator = create_enumerator(this, DIFFIE_HELLMAN_GROUP);
enumerator = create_enumerator(this, KEY_EXCHANGE_METHOD);
while (enumerator->enumerate(enumerator, &current, NULL))
{
any = TRUE;
if (current == group)
if (current == ke)
{
found = TRUE;
break;
@@ -271,15 +271,15 @@ METHOD(proposal_t, has_dh_group, bool,
}
enumerator->destroy(enumerator);
if (!any && group == MODP_NONE)
if (!any && ke == MODP_NONE)
{
found = TRUE;
}
return found;
}
METHOD(proposal_t, promote_dh_group, bool,
private_proposal_t *this, diffie_hellman_group_t group)
METHOD(proposal_t, promote_ke_method, bool,
private_proposal_t *this, key_exchange_method_t method)
{
enumerator_t *enumerator;
entry_t *entry;
@@ -288,8 +288,8 @@ METHOD(proposal_t, promote_dh_group, bool,
enumerator = array_create_enumerator(this->transforms);
while (enumerator->enumerate(enumerator, &entry))
{
if (entry->type == DIFFIE_HELLMAN_GROUP &&
entry->alg == group)
if (entry->type == KEY_EXCHANGE_METHOD &&
entry->alg == method)
{
array_remove_at(this->transforms, enumerator);
found = TRUE;
@@ -300,8 +300,8 @@ METHOD(proposal_t, promote_dh_group, bool,
if (found)
{
entry_t entry = {
.type = DIFFIE_HELLMAN_GROUP,
.alg = group,
.type = KEY_EXCHANGE_METHOD,
.alg = method,
};
array_insert(this->transforms, ARRAY_HEAD, &entry);
}
@@ -319,7 +319,7 @@ static bool select_algo(private_proposal_t *this, proposal_t *other,
uint16_t alg1, alg2, ks1, ks2;
bool found = FALSE, optional = FALSE;
if (type == DIFFIE_HELLMAN_GROUP)
if (type == KEY_EXCHANGE_METHOD)
{
optional = this->protocol == PROTO_ESP || this->protocol == PROTO_AH;
}
@@ -408,7 +408,7 @@ static bool select_algos(private_proposal_t *this, proposal_t *other,
{
continue;
}
if (type == DIFFIE_HELLMAN_GROUP && (flags & PROPOSAL_SKIP_DH))
if (type == KEY_EXCHANGE_METHOD && (flags & PROPOSAL_SKIP_KE))
{
continue;
}
@@ -601,7 +601,7 @@ METHOD(proposal_t, clone_, proposal_t*,
{
continue;
}
if (entry->type == DIFFIE_HELLMAN_GROUP && (flags & PROPOSAL_SKIP_DH))
if (entry->type == KEY_EXCHANGE_METHOD && (flags & PROPOSAL_SKIP_KE))
{
continue;
}
@@ -696,13 +696,13 @@ static bool check_proposal(private_proposal_t *this)
e = array_create_enumerator(this->transforms);
while (e->enumerate(e, &entry))
{
if (entry->type == DIFFIE_HELLMAN_GROUP && !entry->alg)
if (entry->type == KEY_EXCHANGE_METHOD && !entry->alg)
{
array_remove_at(this->transforms, e);
}
}
e->destroy(e);
if (!get_algorithm(this, DIFFIE_HELLMAN_GROUP, NULL, NULL))
if (!get_algorithm(this, KEY_EXCHANGE_METHOD, NULL, NULL))
{
DBG1(DBG_CFG, "a DH group is mandatory in IKE proposals");
return FALSE;
@@ -943,8 +943,8 @@ proposal_t *proposal_create_v1(protocol_id_t protocol, uint8_t number,
.add_algorithm = _add_algorithm,
.create_enumerator = _create_enumerator,
.get_algorithm = _get_algorithm,
.has_dh_group = _has_dh_group,
.promote_dh_group = _promote_dh_group,
.has_ke_method = _has_ke_method,
.promote_ke_method = _promote_ke_method,
.select = _select_proposal,
.matches = _matches,
.get_protocol = _get_protocol,
@@ -983,7 +983,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
encryption_algorithm_t encryption;
integrity_algorithm_t integrity;
pseudo_random_function_t prf;
diffie_hellman_group_t group;
key_exchange_method_t group;
const char *plugin_name;
if (aead)
@@ -1175,7 +1175,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
enumerator->destroy(enumerator);
/* Round 1 adds ECC and NTRU algorithms with at least 128 bit security strength */
enumerator = lib->crypto->create_dh_enumerator(lib->crypto);
enumerator = lib->crypto->create_ke_enumerator(lib->crypto);
while (enumerator->enumerate(enumerator, &group, &plugin_name))
{
switch (group)
@@ -1192,7 +1192,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
case NTRU_192_BIT:
case NTRU_256_BIT:
case NH_128_BIT:
add_algorithm(this, DIFFIE_HELLMAN_GROUP, group, 0);
add_algorithm(this, KEY_EXCHANGE_METHOD, group, 0);
break;
default:
break;
@@ -1201,7 +1201,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
enumerator->destroy(enumerator);
/* Round 2 adds other algorithms with at least 128 bit security strength */
enumerator = lib->crypto->create_dh_enumerator(lib->crypto);
enumerator = lib->crypto->create_ke_enumerator(lib->crypto);
while (enumerator->enumerate(enumerator, &group, &plugin_name))
{
switch (group)
@@ -1210,7 +1210,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
case MODP_4096_BIT:
case MODP_6144_BIT:
case MODP_8192_BIT:
add_algorithm(this, DIFFIE_HELLMAN_GROUP, group, 0);
add_algorithm(this, KEY_EXCHANGE_METHOD, group, 0);
break;
default:
break;
@@ -1219,7 +1219,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
enumerator->destroy(enumerator);
/* Round 3 adds algorithms with less than 128 bit security strength */
enumerator = lib->crypto->create_dh_enumerator(lib->crypto);
enumerator = lib->crypto->create_ke_enumerator(lib->crypto);
while (enumerator->enumerate(enumerator, &group, &plugin_name))
{
switch (group)
@@ -1244,7 +1244,7 @@ static bool proposal_add_supported_ike(private_proposal_t *this, bool aead)
/* rarely used */
break;
case MODP_2048_BIT:
add_algorithm(this, DIFFIE_HELLMAN_GROUP, group, 0);
add_algorithm(this, KEY_EXCHANGE_METHOD, group, 0);
break;
default:
break;
src/libstrongswan/crypto/proposal/proposal.h
+10 -10
View File
@@ -35,7 +35,7 @@ typedef struct proposal_t proposal_t;
#include <crypto/transform.h>
#include <crypto/crypters/crypter.h>
#include <crypto/signers/signer.h>
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
/**
* Protocol ID of a proposal.
@@ -61,8 +61,8 @@ enum proposal_selection_flag_t {
PROPOSAL_PREFER_SUPPLIED = (1<<0),
/** Whether to skip and ignore algorithms from a private range. */
PROPOSAL_SKIP_PRIVATE = (1<<1),
/** Whether to skip and ignore diffie hellman groups. */
PROPOSAL_SKIP_DH = (1<<2),
/** Whether to skip and ignore key exchange methods. */
PROPOSAL_SKIP_KE = (1<<2),
};
/**
@@ -110,21 +110,21 @@ struct proposal_t {
uint16_t *alg, uint16_t *key_size);
/**
* Check if the proposal has a specific DH group.
* Check if the proposal has a specific key exchange method.
*
* @param group group to check for
* @param method key exchange method to check for
* @return TRUE if algorithm included
*/
bool (*has_dh_group)(proposal_t *this, diffie_hellman_group_t group);
bool (*has_ke_method)(proposal_t *this, key_exchange_method_t method);
/**
* Move the given DH group to the front of the list if it was contained in
* the proposal.
* Move the given key exchange method to the front of the list if it was
* contained in the proposal.
*
* @param group group to promote
* @param method key exchange method to promote
* @return TRUE if algorithm included
*/
bool (*promote_dh_group)(proposal_t *this, diffie_hellman_group_t group);
bool (*promote_ke_method)(proposal_t *this, key_exchange_method_t method);
/**
* Compare two proposals and select a matching subset.
src/libstrongswan/crypto/proposal/proposal_keywords_static.txt
+32 -32
View File
@@ -20,7 +20,7 @@
#include <crypto/transform.h>
#include <crypto/crypters/crypter.h>
#include <crypto/signers/signer.h>
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
%}
struct proposal_token {
@@ -149,36 +149,36 @@ prfmd5, PSEUDO_RANDOM_FUNCTION, PRF_HMAC_MD5, 0
prfaesxcbc, PSEUDO_RANDOM_FUNCTION, PRF_AES128_XCBC, 0
prfcamelliaxcbc, PSEUDO_RANDOM_FUNCTION, PRF_CAMELLIA128_XCBC, 0
prfaescmac, PSEUDO_RANDOM_FUNCTION, PRF_AES128_CMAC, 0
modpnone, DIFFIE_HELLMAN_GROUP, MODP_NONE, 0
modpnull, DIFFIE_HELLMAN_GROUP, MODP_NULL, 0
modp768, DIFFIE_HELLMAN_GROUP, MODP_768_BIT, 0
modp1024, DIFFIE_HELLMAN_GROUP, MODP_1024_BIT, 0
modp1536, DIFFIE_HELLMAN_GROUP, MODP_1536_BIT, 0
modp2048, DIFFIE_HELLMAN_GROUP, MODP_2048_BIT, 0
modp3072, DIFFIE_HELLMAN_GROUP, MODP_3072_BIT, 0
modp4096, DIFFIE_HELLMAN_GROUP, MODP_4096_BIT, 0
modp6144, DIFFIE_HELLMAN_GROUP, MODP_6144_BIT, 0
modp8192, DIFFIE_HELLMAN_GROUP, MODP_8192_BIT, 0
ecp192, DIFFIE_HELLMAN_GROUP, ECP_192_BIT, 0
ecp224, DIFFIE_HELLMAN_GROUP, ECP_224_BIT, 0
ecp256, DIFFIE_HELLMAN_GROUP, ECP_256_BIT, 0
ecp384, DIFFIE_HELLMAN_GROUP, ECP_384_BIT, 0
ecp521, DIFFIE_HELLMAN_GROUP, ECP_521_BIT, 0
modp1024s160, DIFFIE_HELLMAN_GROUP, MODP_1024_160, 0
modp2048s224, DIFFIE_HELLMAN_GROUP, MODP_2048_224, 0
modp2048s256, DIFFIE_HELLMAN_GROUP, MODP_2048_256, 0
ecp224bp, DIFFIE_HELLMAN_GROUP, ECP_224_BP, 0
ecp256bp, DIFFIE_HELLMAN_GROUP, ECP_256_BP, 0
ecp384bp, DIFFIE_HELLMAN_GROUP, ECP_384_BP, 0
ecp512bp, DIFFIE_HELLMAN_GROUP, ECP_512_BP, 0
curve25519, DIFFIE_HELLMAN_GROUP, CURVE_25519, 0
x25519, DIFFIE_HELLMAN_GROUP, CURVE_25519, 0
curve448, DIFFIE_HELLMAN_GROUP, CURVE_448, 0
x448, DIFFIE_HELLMAN_GROUP, CURVE_448, 0
ntru112, DIFFIE_HELLMAN_GROUP, NTRU_112_BIT, 0
ntru128, DIFFIE_HELLMAN_GROUP, NTRU_128_BIT, 0
ntru192, DIFFIE_HELLMAN_GROUP, NTRU_192_BIT, 0
ntru256, DIFFIE_HELLMAN_GROUP, NTRU_256_BIT, 0
newhope128, DIFFIE_HELLMAN_GROUP, NH_128_BIT, 0
modpnone, KEY_EXCHANGE_METHOD, MODP_NONE, 0
modpnull, KEY_EXCHANGE_METHOD, MODP_NULL, 0
modp768, KEY_EXCHANGE_METHOD, MODP_768_BIT, 0
modp1024, KEY_EXCHANGE_METHOD, MODP_1024_BIT, 0
modp1536, KEY_EXCHANGE_METHOD, MODP_1536_BIT, 0
modp2048, KEY_EXCHANGE_METHOD, MODP_2048_BIT, 0
modp3072, KEY_EXCHANGE_METHOD, MODP_3072_BIT, 0
modp4096, KEY_EXCHANGE_METHOD, MODP_4096_BIT, 0
modp6144, KEY_EXCHANGE_METHOD, MODP_6144_BIT, 0
modp8192, KEY_EXCHANGE_METHOD, MODP_8192_BIT, 0
ecp192, KEY_EXCHANGE_METHOD, ECP_192_BIT, 0
ecp224, KEY_EXCHANGE_METHOD, ECP_224_BIT, 0
ecp256, KEY_EXCHANGE_METHOD, ECP_256_BIT, 0
ecp384, KEY_EXCHANGE_METHOD, ECP_384_BIT, 0
ecp521, KEY_EXCHANGE_METHOD, ECP_521_BIT, 0
modp1024s160, KEY_EXCHANGE_METHOD, MODP_1024_160, 0
modp2048s224, KEY_EXCHANGE_METHOD, MODP_2048_224, 0
modp2048s256, KEY_EXCHANGE_METHOD, MODP_2048_256, 0
ecp224bp, KEY_EXCHANGE_METHOD, ECP_224_BP, 0
ecp256bp, KEY_EXCHANGE_METHOD, ECP_256_BP, 0
ecp384bp, KEY_EXCHANGE_METHOD, ECP_384_BP, 0
ecp512bp, KEY_EXCHANGE_METHOD, ECP_512_BP, 0
curve25519, KEY_EXCHANGE_METHOD, CURVE_25519, 0
x25519, KEY_EXCHANGE_METHOD, CURVE_25519, 0
curve448, KEY_EXCHANGE_METHOD, CURVE_448, 0
x448, KEY_EXCHANGE_METHOD, CURVE_448, 0
ntru112, KEY_EXCHANGE_METHOD, NTRU_112_BIT, 0
ntru128, KEY_EXCHANGE_METHOD, NTRU_128_BIT, 0
ntru192, KEY_EXCHANGE_METHOD, NTRU_192_BIT, 0
ntru256, KEY_EXCHANGE_METHOD, NTRU_256_BIT, 0
newhope128, KEY_EXCHANGE_METHOD, NH_128_BIT, 0
noesn, EXTENDED_SEQUENCE_NUMBERS, NO_EXT_SEQ_NUMBERS, 0
esn, EXTENDED_SEQUENCE_NUMBERS, EXT_SEQ_NUMBERS, 0
src/libstrongswan/crypto/transform.c
+3 -3
View File
@@ -23,7 +23,7 @@ ENUM_BEGIN(transform_type_names, ENCRYPTION_ALGORITHM, EXTENDED_SEQUENCE_NUMBERS
"ENCRYPTION_ALGORITHM",
"PSEUDO_RANDOM_FUNCTION",
"INTEGRITY_ALGORITHM",
"DIFFIE_HELLMAN_GROUP",
"KEY_EXCHANGE_METHOD",
"EXTENDED_SEQUENCE_NUMBERS");
ENUM_NEXT(transform_type_names, HASH_ALGORITHM, KEY_DERIVATION_FUNCTION,
EXTENDED_SEQUENCE_NUMBERS,
@@ -59,8 +59,8 @@ enum_name_t* transform_get_enum_names(transform_type_t type)
return pseudo_random_function_names;
case INTEGRITY_ALGORITHM:
return integrity_algorithm_names;
case DIFFIE_HELLMAN_GROUP:
return diffie_hellman_group_names;
case KEY_EXCHANGE_METHOD:
return key_exchange_method_names;
case EXTENDED_SEQUENCE_NUMBERS:
return extended_sequence_numbers_names;
case EXTENDED_OUTPUT_FUNCTION:
src/libstrongswan/crypto/transform.h
+1 -1
View File
@@ -33,7 +33,7 @@ enum transform_type_t {
ENCRYPTION_ALGORITHM = 1,
PSEUDO_RANDOM_FUNCTION = 2,
INTEGRITY_ALGORITHM = 3,
DIFFIE_HELLMAN_GROUP = 4,
KEY_EXCHANGE_METHOD = 4,
EXTENDED_SEQUENCE_NUMBERS = 5,
HASH_ALGORITHM = 256,
RANDOM_NUMBER_GENERATOR = 257,
src/libstrongswan/plugins/botan/botan_diffie_hellman.c
+15 -15
View File
@@ -49,7 +49,7 @@ struct private_botan_diffie_hellman_t {
/**
* Diffie Hellman group number
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* Private key
@@ -94,10 +94,10 @@ bool load_private_key(private_botan_diffie_hellman_t *this, chunk_t value)
return TRUE;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_botan_diffie_hellman_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -107,7 +107,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return botan_dh_key_derivation(this->dh_key, value, &this->shared_secret);
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_botan_diffie_hellman_t *this, chunk_t *value)
{
*value = chunk_empty;
@@ -129,14 +129,14 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_botan_diffie_hellman_t *this, chunk_t value)
{
chunk_clear(&this->shared_secret);
return load_private_key(this, value);
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_botan_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -147,13 +147,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_botan_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_botan_diffie_hellman_t *this)
{
botan_mp_destroy(this->p);
@@ -166,7 +166,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Generic internal constructor
*/
static botan_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
static botan_diffie_hellman_t *create_generic(key_exchange_method_t group,
chunk_t g, chunk_t p, size_t exp_len)
{
private_botan_diffie_hellman_t *this;
@@ -175,12 +175,12 @@ static botan_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
@@ -222,7 +222,7 @@ static botan_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
* Described in header.
*/
botan_diffie_hellman_t *botan_diffie_hellman_create(
diffie_hellman_group_t group, ...)
key_exchange_method_t group, ...)
{
diffie_hellman_params_t *params;
chunk_t g, p;
src/libstrongswan/plugins/botan/botan_diffie_hellman.h
+5 -5
View File
@@ -32,7 +32,7 @@
typedef struct botan_diffie_hellman_t botan_diffie_hellman_t;
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
/**
* Implementation of the Diffie-Hellman algorithm using Botan.
@@ -40,20 +40,20 @@ typedef struct botan_diffie_hellman_t botan_diffie_hellman_t;
struct botan_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new botan_diffie_hellman_t object.
*
* @param group Diffie Hellman group number to use
* @param group Diffie-Hellman group number to use
* @param ... expects generator and prime as chunk_t if MODP_CUSTOM
* @return botan_diffie_hellman_t object,
* NULL if not supported
*/
botan_diffie_hellman_t *botan_diffie_hellman_create(
diffie_hellman_group_t group, ...);
key_exchange_method_t group, ...);
#endif /** BOTAN_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/botan/botan_ec_diffie_hellman.c
+14 -14
View File
@@ -48,7 +48,7 @@ struct private_botan_ec_diffie_hellman_t {
/**
* Diffie Hellman group
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* EC curve name
@@ -66,10 +66,10 @@ struct private_botan_ec_diffie_hellman_t {
chunk_t shared_secret;
};
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_botan_ec_diffie_hellman_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -82,7 +82,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return botan_dh_key_derivation(this->key, value, &this->shared_secret);
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_botan_ec_diffie_hellman_t *this, chunk_t *value)
{
chunk_t pkey = chunk_empty;
@@ -104,7 +104,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_botan_ec_diffie_hellman_t *this, chunk_t value)
{
botan_mp_t scalar;
@@ -132,7 +132,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_botan_ec_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -143,13 +143,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_botan_ec_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_botan_ec_diffie_hellman_t *this)
{
botan_privkey_destroy(this->key);
@@ -161,19 +161,19 @@ METHOD(diffie_hellman_t, destroy, void,
* Described in header.
*/
botan_ec_diffie_hellman_t *botan_ec_diffie_hellman_create(
diffie_hellman_group_t group)
key_exchange_method_t group)
{
private_botan_ec_diffie_hellman_t *this;
botan_rng_t rng;
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/botan/botan_ec_diffie_hellman.h
+4 -4
View File
@@ -39,18 +39,18 @@ typedef struct botan_ec_diffie_hellman_t botan_ec_diffie_hellman_t;
struct botan_ec_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new botan_ec_diffie_hellman_t object.
*
* @param group EC Diffie Hellman group number to use
* @param group EC Diffie-Hellman group number to use
* @return botan_ec_diffie_hellman_t object, NULL if not supported
*/
botan_ec_diffie_hellman_t *botan_ec_diffie_hellman_create(
diffie_hellman_group_t group);
key_exchange_method_t group);
#endif /** BOTAN_EC_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/botan/botan_plugin.c
+22 -22
View File
@@ -74,33 +74,33 @@ METHOD(plugin_t, get_features, int,
#ifdef BOTAN_HAS_DIFFIE_HELLMAN
/* MODP DH groups */
PLUGIN_REGISTER(DH, botan_diffie_hellman_create),
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_REGISTER(KE, botan_diffie_hellman_create),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
#endif
#ifdef BOTAN_HAS_ECDH
/* EC DH groups */
PLUGIN_REGISTER(DH, botan_ec_diffie_hellman_create),
PLUGIN_PROVIDE(DH, ECP_256_BIT),
PLUGIN_PROVIDE(DH, ECP_384_BIT),
PLUGIN_PROVIDE(DH, ECP_521_BIT),
PLUGIN_PROVIDE(DH, ECP_256_BP),
PLUGIN_PROVIDE(DH, ECP_384_BP),
PLUGIN_PROVIDE(DH, ECP_512_BP),
PLUGIN_REGISTER(KE, botan_ec_diffie_hellman_create),
PLUGIN_PROVIDE(KE, ECP_256_BIT),
PLUGIN_PROVIDE(KE, ECP_384_BIT),
PLUGIN_PROVIDE(KE, ECP_521_BIT),
PLUGIN_PROVIDE(KE, ECP_256_BP),
PLUGIN_PROVIDE(KE, ECP_384_BP),
PLUGIN_PROVIDE(KE, ECP_512_BP),
#endif
#ifdef BOTAN_HAS_X25519
PLUGIN_REGISTER(DH, botan_x25519_create),
PLUGIN_PROVIDE(DH, CURVE_25519),
PLUGIN_REGISTER(KE, botan_x25519_create),
PLUGIN_PROVIDE(KE, CURVE_25519),
#endif
/* crypters */
src/libstrongswan/plugins/botan/botan_x25519.c
+13 -13
View File
@@ -42,7 +42,7 @@ struct private_diffie_hellman_t {
/**
* Public interface
*/
diffie_hellman_t public;
key_exchange_t public;
/**
* Private key
@@ -55,10 +55,10 @@ struct private_diffie_hellman_t {
chunk_t shared_secret;
};
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_diffie_hellman_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(CURVE_25519, value))
if (!key_exchange_verify_pubkey(CURVE_25519, value))
{
return FALSE;
}
@@ -68,7 +68,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return botan_dh_key_derivation(this->key, value, &this->shared_secret);
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_diffie_hellman_t *this, chunk_t *value)
{
value->len = 0;
@@ -88,7 +88,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_diffie_hellman_t *this, chunk_t value)
{
if (value.len != 32)
@@ -110,7 +110,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -121,13 +121,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_diffie_hellman_t *this)
{
return CURVE_25519;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_diffie_hellman_t *this)
{
botan_privkey_destroy(this->key);
@@ -138,7 +138,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header
*/
diffie_hellman_t *botan_x25519_create(diffie_hellman_group_t group)
key_exchange_t *botan_x25519_create(key_exchange_method_t ke)
{
private_diffie_hellman_t *this;
botan_rng_t rng;
@@ -146,10 +146,10 @@ diffie_hellman_t *botan_x25519_create(diffie_hellman_group_t group)
INIT(this,
.public = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
);
src/libstrongswan/plugins/botan/botan_x25519.h
+2 -2
View File
@@ -33,9 +33,9 @@
/**
* Creates a new X25519 implementation using Botan.
*
* @param group DH group, must be CURVE_25519
* @param ke key exchange method, must be CURVE_25519
* @return object, NULL if not supported
*/
diffie_hellman_t *botan_x25519_create(diffie_hellman_group_t group);
key_exchange_t *botan_x25519_create(key_exchange_method_t ke);
#endif /** BOTAN_X25519_H_ @}*/
src/libstrongswan/plugins/curve25519/curve25519_dh.c
+12 -12
View File
@@ -73,7 +73,7 @@ static bool generate_key(private_curve25519_dh_t *this)
return this->drv->set_key(this->drv, key);
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_curve25519_dh_t *this, chunk_t value)
{
if (value.len == CURVE25519_KEY_SIZE)
@@ -87,7 +87,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return FALSE;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_curve25519_dh_t *this, chunk_t *value)
{
u_char basepoint[CURVE25519_KEY_SIZE] = { 9 };
@@ -101,7 +101,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return FALSE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_curve25519_dh_t *this, chunk_t value)
{
if (value.len != CURVE25519_KEY_SIZE)
@@ -111,7 +111,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return this->drv->set_key(this->drv, value.ptr);
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_curve25519_dh_t *this, chunk_t *secret)
{
if (!this->computed)
@@ -122,13 +122,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_curve25519_dh_t *this)
{
return CURVE_25519;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_curve25519_dh_t *this)
{
this->drv->destroy(this->drv);
@@ -138,7 +138,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header.
*/
curve25519_dh_t *curve25519_dh_create(diffie_hellman_group_t group)
curve25519_dh_t *curve25519_dh_create(key_exchange_method_t group)
{
private_curve25519_dh_t *this;
@@ -149,12 +149,12 @@ curve25519_dh_t *curve25519_dh_create(diffie_hellman_group_t group)
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/curve25519/curve25519_dh.h
+3 -3
View File
@@ -32,9 +32,9 @@ typedef struct curve25519_dh_t curve25519_dh_t;
struct curve25519_dh_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
@@ -43,6 +43,6 @@ struct curve25519_dh_t {
* @param group DH group, CURVE_25519
* @return curve25519_dh_t object, NULL on error
*/
curve25519_dh_t *curve25519_dh_create(diffie_hellman_group_t group);
curve25519_dh_t *curve25519_dh_create(key_exchange_method_t group);
#endif /** CURVE25519_DH_H_ @}*/
src/libstrongswan/plugins/curve25519/curve25519_plugin.c
+2 -2
View File
@@ -47,8 +47,8 @@ METHOD(plugin_t, get_features, int,
{
static plugin_feature_t f[] = {
/* X25519 DH group */
PLUGIN_REGISTER(DH, curve25519_dh_create),
PLUGIN_PROVIDE(DH, CURVE_25519),
PLUGIN_REGISTER(KE, curve25519_dh_create),
PLUGIN_PROVIDE(KE, CURVE_25519),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
/* Ed25519 private/public keys */
PLUGIN_REGISTER(PRIVKEY, curve25519_private_key_load, TRUE),
src/libstrongswan/plugins/gcrypt/gcrypt_dh.c
+16 -16
View File
@@ -36,7 +36,7 @@ struct private_gcrypt_dh_t {
/**
* Diffie Hellman group number
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/*
* Generator value
@@ -74,13 +74,13 @@ struct private_gcrypt_dh_t {
size_t p_len;
};
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_gcrypt_dh_t *this, chunk_t value)
{
gcry_mpi_t p_min_1;
gcry_error_t err;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -139,14 +139,14 @@ static chunk_t export_mpi(gcry_mpi_t value, size_t len)
return chunk;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_gcrypt_dh_t *this, chunk_t *value)
{
*value = export_mpi(this->ya, this->p_len);
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_gcrypt_dh_t *this, chunk_t value)
{
gcry_error_t err;
@@ -164,7 +164,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return !err;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_gcrypt_dh_t *this, chunk_t *secret)
{
if (!this->zz)
@@ -175,13 +175,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_gcrypt_dh_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_gcrypt_dh_t *this)
{
gcry_mpi_release(this->p);
@@ -196,7 +196,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Generic internal constructor
*/
static gcrypt_dh_t *create_generic(diffie_hellman_group_t group, size_t exp_len,
static gcrypt_dh_t *create_generic(key_exchange_method_t group, size_t exp_len,
chunk_t g, chunk_t p)
{
private_gcrypt_dh_t *this;
@@ -206,12 +206,12 @@ static gcrypt_dh_t *create_generic(diffie_hellman_group_t group, size_t exp_len,
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
@@ -273,7 +273,7 @@ static gcrypt_dh_t *create_generic(diffie_hellman_group_t group, size_t exp_len,
/*
* Described in header.
*/
gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group)
gcrypt_dh_t *gcrypt_dh_create(key_exchange_method_t group)
{
diffie_hellman_params_t *params;
@@ -290,7 +290,7 @@ gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group)
/*
* Described in header.
*/
gcrypt_dh_t *gcrypt_dh_create_custom(diffie_hellman_group_t group, ...)
gcrypt_dh_t *gcrypt_dh_create_custom(key_exchange_method_t group, ...)
{
if (group == MODP_CUSTOM)
{
src/libstrongswan/plugins/gcrypt/gcrypt_dh.h
+4 -4
View File
@@ -32,9 +32,9 @@ typedef struct gcrypt_dh_t gcrypt_dh_t;
struct gcrypt_dh_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
@@ -43,7 +43,7 @@ struct gcrypt_dh_t {
* @param group Diffie Hellman group number to use
* @return gcrypt_dh_t object, NULL if not supported
*/
gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group);
gcrypt_dh_t *gcrypt_dh_create(key_exchange_method_t group);
/**
* Creates a new gcrypt_dh_t object for MODP_CUSTOM.
@@ -52,7 +52,7 @@ gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group);
* @param ... expects generator and prime as chunk_t
* @return gcrypt_dh_t object, NULL if not supported
*/
gcrypt_dh_t *gcrypt_dh_create_custom(diffie_hellman_group_t group, ...);
gcrypt_dh_t *gcrypt_dh_create_custom(key_exchange_method_t group, ...);
#endif /** GCRYPT_DH_H_ @}*/
src/libstrongswan/plugins/gcrypt/gcrypt_plugin.c
+14 -14
View File
@@ -106,20 +106,20 @@ METHOD(plugin_t, get_features, int,
PLUGIN_PROVIDE(HASHER, HASH_SHA384),
PLUGIN_PROVIDE(HASHER, HASH_SHA512),
/* MODP DH groups */
PLUGIN_REGISTER(DH, gcrypt_dh_create),
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_REGISTER(DH, gcrypt_dh_create_custom),
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_REGISTER(KE, gcrypt_dh_create),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
PLUGIN_REGISTER(KE, gcrypt_dh_create_custom),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
/* RSA private/public key loading */
PLUGIN_REGISTER(PUBKEY, gcrypt_rsa_public_key_load, TRUE),
PLUGIN_PROVIDE(PUBKEY, KEY_RSA),
src/libstrongswan/plugins/gmp/gmp_diffie_hellman.c
+16 -16
View File
@@ -41,7 +41,7 @@ struct private_gmp_diffie_hellman_t {
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/*
* Generator value.
@@ -84,12 +84,12 @@ struct private_gmp_diffie_hellman_t {
bool computed;
};
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_gmp_diffie_hellman_t *this, chunk_t value)
{
mpz_t p_min_1;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -149,7 +149,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return this->computed;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_gmp_diffie_hellman_t *this,chunk_t *value)
{
value->len = this->p_len;
@@ -161,7 +161,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_gmp_diffie_hellman_t *this, chunk_t value)
{
mpz_import(this->xa, value.len, 1, 1, 1, 0, value.ptr);
@@ -170,7 +170,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_gmp_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->computed)
@@ -186,13 +186,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_gmp_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_gmp_diffie_hellman_t *this)
{
mpz_clear(this->p);
@@ -207,7 +207,7 @@ METHOD(diffie_hellman_t, destroy, void,
/**
* Generic internal constructor
*/
static gmp_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
static gmp_diffie_hellman_t *create_generic(key_exchange_method_t group,
size_t exp_len, chunk_t g, chunk_t p)
{
private_gmp_diffie_hellman_t *this;
@@ -216,12 +216,12 @@ static gmp_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
@@ -273,7 +273,7 @@ static gmp_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
/*
* Described in header
*/
gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group)
gmp_diffie_hellman_t *gmp_diffie_hellman_create(key_exchange_method_t group)
{
diffie_hellman_params_t *params;
@@ -290,7 +290,7 @@ gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group)
* Described in header
*/
gmp_diffie_hellman_t *gmp_diffie_hellman_create_custom(
diffie_hellman_group_t group, ...)
key_exchange_method_t group, ...)
{
if (group == MODP_CUSTOM)
{
src/libstrongswan/plugins/gmp/gmp_diffie_hellman.h
+4 -4
View File
@@ -31,9 +31,9 @@ typedef struct gmp_diffie_hellman_t gmp_diffie_hellman_t;
struct gmp_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
@@ -42,7 +42,7 @@ struct gmp_diffie_hellman_t {
* @param group Diffie Hellman group number to use
* @return gmp_diffie_hellman_t object, NULL if not supported
*/
gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group);
gmp_diffie_hellman_t *gmp_diffie_hellman_create(key_exchange_method_t group);
/**
* Creates a new gmp_diffie_hellman_t object for MODP_CUSTOM.
@@ -52,7 +52,7 @@ gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group);
* @return gmp_diffie_hellman_t object, NULL if not supported
*/
gmp_diffie_hellman_t *gmp_diffie_hellman_create_custom(
diffie_hellman_group_t group, ...);
key_exchange_method_t group, ...);
#endif /** GMP_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/gmp/gmp_plugin.c
+14 -14
View File
@@ -43,31 +43,31 @@ METHOD(plugin_t, get_features, int,
{
static plugin_feature_t f[] = {
/* DH groups */
PLUGIN_REGISTER(DH, gmp_diffie_hellman_create),
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_REGISTER(KE, gmp_diffie_hellman_create),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_2048_256),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_1024_160),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
PLUGIN_REGISTER(DH, gmp_diffie_hellman_create_custom),
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_REGISTER(KE, gmp_diffie_hellman_create_custom),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
PLUGIN_DEPENDS(RNG, RNG_STRONG),
/* private/public keys */
PLUGIN_REGISTER(PRIVKEY, gmp_rsa_private_key_load, TRUE),
src/libstrongswan/plugins/newhope/newhope_ke.c
+13 -13
View File
@@ -23,7 +23,7 @@
#include <ntt_fft.h>
#include <ntt_fft_reduce.h>
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
#include <utils/debug.h>
static const int seed_len = 32; /* 256 bits */
@@ -278,7 +278,7 @@ static uint8_t* unpack_rec(private_newhope_ke_t *this, uint8_t *x)
return r;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_newhope_ke_t *this, chunk_t *value)
{
uint16_t n, q;
@@ -397,7 +397,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
}
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_newhope_ke_t *this, chunk_t *secret)
{
if (this->shared_secret.len == 0)
@@ -410,7 +410,7 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_newhope_ke_t *this, chunk_t value)
{
newhope_reconciliation_t * rec;
@@ -436,7 +436,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
if (value.len != poly_len + seed_len)
{
DBG1(DBG_LIB, "received %N KE payload of incorrect size",
diffie_hellman_group_names, NH_128_BIT);
key_exchange_method_names, NH_128_BIT);
return FALSE;
}
a_seed = chunk_create(value.ptr + poly_len, seed_len);
@@ -545,7 +545,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
if (value.len != poly_len + rec_len)
{
DBG1(DBG_LIB, "received %N KE payload of incorrect size",
diffie_hellman_group_names, NH_128_BIT);
key_exchange_method_names, NH_128_BIT);
return FALSE;
}
@@ -581,13 +581,13 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
}
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_newhope_ke_t *this)
{
return NH_128_BIT;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_newhope_ke_t *this)
{
chunk_clear(&this->shared_secret);
@@ -601,17 +601,17 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header.
*/
newhope_ke_t *newhope_ke_create(diffie_hellman_group_t group, chunk_t g, chunk_t p)
newhope_ke_t *newhope_ke_create(key_exchange_method_t ke, chunk_t g, chunk_t p)
{
private_newhope_ke_t *this;
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/newhope/newhope_ke.h
+4 -4
View File
@@ -32,20 +32,20 @@ typedef struct newhope_ke_t newhope_ke_t;
struct newhope_ke_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new newhope_ke_t object.
*
* @param group New Hope DH group number
* @param ke New Hope key exchange number
* @param g not used
* @param p not used
* @return newhope_ke_t object, NULL if not supported
*/
newhope_ke_t *newhope_ke_create(diffie_hellman_group_t group, chunk_t g, chunk_t p);
newhope_ke_t *newhope_ke_create(key_exchange_method_t ke, chunk_t g, chunk_t p);
#endif /** NEWHOPE_KE_H_ @}*/
src/libstrongswan/plugins/newhope/newhope_plugin.c
+2 -2
View File
@@ -42,8 +42,8 @@ METHOD(plugin_t, get_features, int,
private_newhope_plugin_t *this, plugin_feature_t *features[])
{
static plugin_feature_t f[] = {
PLUGIN_REGISTER(DH, newhope_ke_create),
PLUGIN_PROVIDE(DH, NH_128_BIT),
PLUGIN_REGISTER(KE, newhope_ke_create),
PLUGIN_PROVIDE(KE, NH_128_BIT),
PLUGIN_DEPENDS(XOF, XOF_SHAKE_128),
PLUGIN_DEPENDS(XOF, XOF_CHACHA20),
};
src/libstrongswan/plugins/newhope/tests/suites/test_newhope_ke.c
+24 -24
View File
@@ -27,7 +27,7 @@ const int count = 1000;
START_TEST(test_newhope_ke_good)
{
chunk_t i_msg, r_msg, i_shared_secret, r_shared_secret;
diffie_hellman_t *i_nh, *r_nh;
key_exchange_t *i_nh, *r_nh;
struct timespec start, stop;
int i;
@@ -35,24 +35,24 @@ START_TEST(test_newhope_ke_good)
for (i = 0; i < count; i++)
{
i_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
i_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(i_nh != NULL);
ck_assert(i_nh->get_dh_group(i_nh) == NH_128_BIT);
ck_assert(i_nh->get_method(i_nh) == NH_128_BIT);
ck_assert(i_nh->get_my_public_value(i_nh, &i_msg));
ck_assert(i_nh->get_public_key(i_nh, &i_msg));
ck_assert(i_msg.len = 1824);
r_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
r_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(r_nh != NULL);
ck_assert(r_nh->set_other_public_value(r_nh, i_msg));
ck_assert(r_nh->get_my_public_value(r_nh, &r_msg));
ck_assert(r_nh->set_public_key(r_nh, i_msg));
ck_assert(r_nh->get_public_key(r_nh, &r_msg));
ck_assert(r_msg.len == 2048);
ck_assert(r_nh->get_shared_secret(r_nh, &r_shared_secret));
ck_assert(r_shared_secret.len == 32);
ck_assert(i_nh->set_other_public_value(i_nh, r_msg));
ck_assert(i_nh->set_public_key(i_nh, r_msg));
ck_assert(i_nh->get_shared_secret(i_nh, &i_shared_secret));
ck_assert(i_shared_secret.len == 32);
ck_assert(chunk_equals(i_shared_secret, r_shared_secret));
@@ -77,26 +77,26 @@ END_TEST
START_TEST(test_newhope_ke_wrong)
{
chunk_t i_msg, r_msg, i_shared_secret, r_shared_secret;
diffie_hellman_t *i_nh, *r_nh;
key_exchange_t *i_nh, *r_nh;
i_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
i_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(i_nh != NULL);
ck_assert(i_nh->get_my_public_value(i_nh, &i_msg));
ck_assert(i_nh->get_public_key(i_nh, &i_msg));
r_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
r_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(r_nh != NULL);
ck_assert(r_nh->set_other_public_value(r_nh, i_msg));
ck_assert(r_nh->get_my_public_value(r_nh, &r_msg));
ck_assert(r_nh->set_public_key(r_nh, i_msg));
ck_assert(r_nh->get_public_key(r_nh, &r_msg));
/* destroy 1st instance of i_nh */
i_nh->destroy(i_nh);
chunk_free(&i_msg);
/* create 2nd instance of i_nh */
i_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
i_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(i_nh != NULL);
ck_assert(i_nh->get_my_public_value(i_nh, &i_msg));
ck_assert(i_nh->set_other_public_value(i_nh, r_msg));
ck_assert(i_nh->get_public_key(i_nh, &i_msg));
ck_assert(i_nh->set_public_key(i_nh, r_msg));
ck_assert(r_nh->get_shared_secret(r_nh, &r_shared_secret));
ck_assert(i_nh->get_shared_secret(i_nh, &i_shared_secret));
@@ -114,7 +114,7 @@ END_TEST
START_TEST(test_newhope_ke_fail_i)
{
diffie_hellman_t *i_nh;
key_exchange_t *i_nh;
char buf_ff[2048];
int i;
@@ -131,10 +131,10 @@ START_TEST(test_newhope_ke_fail_i)
for (i = 0; i < countof(r_msg); i++)
{
i_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
i_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(i_nh != NULL);
ck_assert(i_nh->get_my_public_value(i_nh, &i_msg));
ck_assert(!i_nh->set_other_public_value(i_nh, r_msg[i]));
ck_assert(i_nh->get_public_key(i_nh, &i_msg));
ck_assert(!i_nh->set_public_key(i_nh, r_msg[i]));
chunk_free(&i_msg);
i_nh->destroy(i_nh);
}
@@ -143,7 +143,7 @@ END_TEST
START_TEST(test_newhope_ke_fail_r)
{
diffie_hellman_t *r_nh;
key_exchange_t *r_nh;
char buf_ff[1824];
int i;
@@ -158,9 +158,9 @@ START_TEST(test_newhope_ke_fail_r)
for (i = 0; i < countof(i_msg); i++)
{
r_nh = lib->crypto->create_dh(lib->crypto, NH_128_BIT);
r_nh = lib->crypto->create_ke(lib->crypto, NH_128_BIT);
ck_assert(r_nh != NULL);
ck_assert(!r_nh->set_other_public_value(r_nh, i_msg[i]));
ck_assert(!r_nh->set_public_key(r_nh, i_msg[i]));
r_nh->destroy(r_nh);
}
}
src/libstrongswan/plugins/ntru/ntru_ke.c
+12 -12
View File
@@ -17,7 +17,7 @@
#include "ntru_private_key.h"
#include "ntru_public_key.h"
#include <crypto/diffie_hellman.h>
#include <crypto/key_exchange.h>
#include <crypto/drbgs/drbg.h>
#include <utils/debug.h>
@@ -55,7 +55,7 @@ struct private_ntru_ke_t {
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* NTRU Parameter Set
@@ -108,7 +108,7 @@ struct private_ntru_ke_t {
drbg_t *drbg;
};
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_ntru_ke_t *this, chunk_t *value)
{
*value = chunk_empty;
@@ -139,7 +139,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_ntru_ke_t *this, chunk_t *secret)
{
if (!this->computed || !this->shared_secret.len)
@@ -152,7 +152,7 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_ntru_ke_t *this, chunk_t value)
{
if (this->privkey)
@@ -218,13 +218,13 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return this->computed;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_ntru_ke_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_ntru_ke_t *this)
{
DESTROY_IF(this->privkey);
@@ -238,7 +238,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header.
*/
ntru_ke_t *ntru_ke_create(diffie_hellman_group_t group, chunk_t g, chunk_t p)
ntru_ke_t *ntru_ke_create(key_exchange_method_t group, chunk_t g, chunk_t p)
{
private_ntru_ke_t *this;
const ntru_param_set_id_t *param_sets;
@@ -311,11 +311,11 @@ ntru_ke_t *ntru_ke_create(diffie_hellman_group_t group, chunk_t g, chunk_t p)
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/ntru/ntru_ke.h
+3 -3
View File
@@ -30,9 +30,9 @@ typedef struct ntru_ke_t ntru_ke_t;
struct ntru_ke_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
@@ -43,7 +43,7 @@ struct ntru_ke_t {
* @param p not used
* @return ntru_ke_t object, NULL if not supported
*/
ntru_ke_t *ntru_ke_create(diffie_hellman_group_t group, chunk_t g, chunk_t p);
ntru_ke_t *ntru_ke_create(key_exchange_method_t group, chunk_t g, chunk_t p);
#endif /** NTRU_KE_H_ @}*/
src/libstrongswan/plugins/ntru/ntru_plugin.c
+5 -5
View File
@@ -40,20 +40,20 @@ METHOD(plugin_t, get_features, int,
private_ntru_plugin_t *this, plugin_feature_t *features[])
{
static plugin_feature_t f[] = {
PLUGIN_REGISTER(DH, ntru_ke_create),
PLUGIN_PROVIDE(DH, NTRU_112_BIT),
PLUGIN_REGISTER(KE, ntru_ke_create),
PLUGIN_PROVIDE(KE, NTRU_112_BIT),
PLUGIN_DEPENDS(RNG, RNG_TRUE),
PLUGIN_DEPENDS(SIGNER, AUTH_HMAC_SHA2_256_256),
PLUGIN_DEPENDS(XOF, XOF_MGF1_SHA1),
PLUGIN_PROVIDE(DH, NTRU_128_BIT),
PLUGIN_PROVIDE(KE, NTRU_128_BIT),
PLUGIN_DEPENDS(RNG, RNG_TRUE),
PLUGIN_DEPENDS(SIGNER, AUTH_HMAC_SHA2_256_256),
PLUGIN_DEPENDS(XOF, XOF_MGF1_SHA1),
PLUGIN_PROVIDE(DH, NTRU_192_BIT),
PLUGIN_PROVIDE(KE, NTRU_192_BIT),
PLUGIN_DEPENDS(RNG, RNG_TRUE),
PLUGIN_DEPENDS(SIGNER, AUTH_HMAC_SHA2_256_256),
PLUGIN_DEPENDS(XOF, XOF_MGF1_SHA256),
PLUGIN_PROVIDE(DH, NTRU_256_BIT),
PLUGIN_PROVIDE(KE, NTRU_256_BIT),
PLUGIN_DEPENDS(RNG, RNG_TRUE),
PLUGIN_DEPENDS(SIGNER, AUTH_HMAC_SHA2_256_256),
PLUGIN_DEPENDS(XOF, XOF_MGF1_SHA256),
src/libstrongswan/plugins/openssl/openssl_diffie_hellman.c
+15 -15
View File
@@ -54,7 +54,7 @@ struct private_openssl_diffie_hellman_t {
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
/**
@@ -84,13 +84,13 @@ struct private_openssl_diffie_hellman_t {
chunk_t shared_secret;
};
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_openssl_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_openssl_diffie_hellman_t *this, chunk_t *value)
{
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
@@ -115,7 +115,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
#endif
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_openssl_diffie_hellman_t *this, chunk_t *secret)
{
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
@@ -151,10 +151,10 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_openssl_diffie_hellman_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -204,7 +204,7 @@ static BIGNUM *calculate_public_key(BIGNUM *priv, const BIGNUM *g,
return pub;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_openssl_diffie_hellman_t *this, chunk_t value)
{
BIGNUM *priv, *g = NULL, *p = NULL, *pub = NULL;
@@ -254,7 +254,7 @@ error:
#else /* OPENSSL_VERSION_NUMBER */
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_openssl_diffie_hellman_t *this, chunk_t value)
{
BIGNUM *privkey;
@@ -274,7 +274,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
#endif /* OPENSSL_VERSION_NUMBER */
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_openssl_diffie_hellman_t *this)
{
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
@@ -292,7 +292,7 @@ METHOD(diffie_hellman_t, destroy, void,
* Described in header.
*/
openssl_diffie_hellman_t *openssl_diffie_hellman_create(
diffie_hellman_group_t group, ...)
key_exchange_method_t group, ...)
{
private_openssl_diffie_hellman_t *this;
BIGNUM *g, *p;
@@ -300,12 +300,12 @@ openssl_diffie_hellman_t *openssl_diffie_hellman_create(
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/openssl/openssl_diffie_hellman.h
+4 -4
View File
@@ -32,20 +32,20 @@ typedef struct openssl_diffie_hellman_t openssl_diffie_hellman_t;
struct openssl_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new openssl_diffie_hellman_t object.
*
* @param group Diffie Hellman group number to use
* @param group Diffie-Hellman group number to use
* @param ... expects generator and prime as chunk_t if MODP_CUSTOM
* @return openssl_diffie_hellman_t object, NULL if not supported
*/
openssl_diffie_hellman_t *openssl_diffie_hellman_create(
diffie_hellman_group_t group, ...);
key_exchange_method_t group, ...);
#endif /** OPENSSL_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/openssl/openssl_ec_diffie_hellman.c
+16 -16
View File
@@ -54,7 +54,7 @@ struct private_openssl_ec_diffie_hellman_t {
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* EC private (public) key
@@ -198,10 +198,10 @@ error:
}
#endif /* OPENSSL_VERSION_NUMBER < ... */
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_openssl_ec_diffie_hellman_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -232,7 +232,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_openssl_ec_diffie_hellman_t *this, chunk_t *value)
{
#if OPENSSL_VERSION_NUMBER < 0x1010000fL
@@ -253,7 +253,7 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
#endif
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_openssl_ec_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len &&
@@ -266,7 +266,7 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_openssl_ec_diffie_hellman_t *this)
{
return this->group;
@@ -275,7 +275,7 @@ METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
/*
* Described in header
*/
int openssl_ecdh_group_to_nid(diffie_hellman_group_t group)
int openssl_ecdh_group_to_nid(key_exchange_method_t group)
{
switch (group)
{
@@ -337,7 +337,7 @@ static bool ecp2chunk(EC_GROUP *group, EC_POINT *point, chunk_t *chunk)
return chunk->len;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_openssl_ec_diffie_hellman_t *this, chunk_t value)
{
BIGNUM *priv = NULL;
@@ -390,7 +390,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
#else /* OPENSSL_VERSION_NUMBER */
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_openssl_ec_diffie_hellman_t *this, chunk_t value)
{
EC_KEY *key = NULL;
@@ -430,7 +430,7 @@ error:
#endif /* OPENSSL_VERSION_NUMBER */
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_openssl_ec_diffie_hellman_t *this)
{
EC_GROUP_free(this->ec_group);
@@ -443,7 +443,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header
*/
openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(diffie_hellman_group_t group)
openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(key_exchange_method_t group)
{
private_openssl_ec_diffie_hellman_t *this;
int curve;
@@ -456,12 +456,12 @@ openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(diffie_hellman_gro
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/openssl/openssl_ec_diffie_hellman.h
+7 -6
View File
@@ -32,18 +32,19 @@ typedef struct openssl_ec_diffie_hellman_t openssl_ec_diffie_hellman_t;
struct openssl_ec_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new openssl_ec_diffie_hellman_t object.
*
* @param group EC Diffie Hellman group number to use
* @return openssl_ec_diffie_hellman_t object, NULL if not supported
* @param group EC Diffie-Hellman group number to use
* @return openssl_ec_diffie_hellman_t object, NULL if unsupported
*/
openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(diffie_hellman_group_t group);
openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(
key_exchange_method_t group);
/**
* Map ECDH groups to OpenSSL NIDs for the ECC curve.
@@ -51,6 +52,6 @@ openssl_ec_diffie_hellman_t *openssl_ec_diffie_hellman_create(diffie_hellman_gro
* @param group ECDH group
* @return NID for the curve
*/
int openssl_ecdh_group_to_nid(diffie_hellman_group_t group);
int openssl_ecdh_group_to_nid(key_exchange_method_t group);
#endif /** OPENSSL_EC_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/openssl/openssl_plugin.c
+28 -28
View File
@@ -326,7 +326,7 @@ METHOD(plugin_t, get_name, char*,
* Check if the given DH group is in the list of supported curves.
*/
static bool ecdh_group_supported(EC_builtin_curve *curves, size_t num_curves,
diffie_hellman_group_t group)
key_exchange_method_t group)
{
int j;
@@ -360,7 +360,7 @@ static void add_ecdh_features(plugin_feature_t *features,
for (i = 0; i < count; i++)
{
if (to_add[i].kind != FEATURE_PROVIDE ||
ecdh_group_supported(curves, num_curves, to_add[i].arg.dh_group))
ecdh_group_supported(curves, num_curves, to_add[i].arg.ke))
{
features[(*pos)++] = to_add[i];
}
@@ -528,19 +528,19 @@ METHOD(plugin_t, get_features, int,
#endif /* OPENSSL_VERSION_NUMBER */
#ifndef OPENSSL_NO_DH
/* MODP DH groups */
PLUGIN_REGISTER(DH, openssl_diffie_hellman_create),
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_REGISTER(KE, openssl_diffie_hellman_create),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
#endif
#ifndef OPENSSL_NO_RSA
/* RSA private/public key loading */
@@ -649,11 +649,11 @@ METHOD(plugin_t, get_features, int,
#endif
#endif /* OPENSSL_NO_ECDSA */
#if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_ECDH)
PLUGIN_REGISTER(DH, openssl_x_diffie_hellman_create),
PLUGIN_REGISTER(KE, openssl_x_diffie_hellman_create),
/* available since 1.1.0a, but we require 1.1.1 features */
PLUGIN_PROVIDE(DH, CURVE_25519),
PLUGIN_PROVIDE(KE, CURVE_25519),
/* available since 1.1.1 */
PLUGIN_PROVIDE(DH, CURVE_448),
PLUGIN_PROVIDE(KE, CURVE_448),
#endif /* OPENSSL_VERSION_NUMBER && !OPENSSL_NO_ECDH */
#if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(OPENSSL_NO_EC)
/* EdDSA private/public key loading */
@@ -686,17 +686,17 @@ METHOD(plugin_t, get_features, int,
static plugin_feature_t f_ecdh[] = {
#ifndef OPENSSL_NO_ECDH
/* EC DH groups */
PLUGIN_REGISTER(DH, openssl_ec_diffie_hellman_create),
PLUGIN_PROVIDE(DH, ECP_256_BIT),
PLUGIN_PROVIDE(DH, ECP_384_BIT),
PLUGIN_PROVIDE(DH, ECP_521_BIT),
PLUGIN_PROVIDE(DH, ECP_224_BIT),
PLUGIN_PROVIDE(DH, ECP_192_BIT),
PLUGIN_REGISTER(KE, openssl_ec_diffie_hellman_create),
PLUGIN_PROVIDE(KE, ECP_256_BIT),
PLUGIN_PROVIDE(KE, ECP_384_BIT),
PLUGIN_PROVIDE(KE, ECP_521_BIT),
PLUGIN_PROVIDE(KE, ECP_224_BIT),
PLUGIN_PROVIDE(KE, ECP_192_BIT),
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
PLUGIN_PROVIDE(DH, ECP_256_BP),
PLUGIN_PROVIDE(DH, ECP_384_BP),
PLUGIN_PROVIDE(DH, ECP_512_BP),
PLUGIN_PROVIDE(DH, ECP_224_BP),
PLUGIN_PROVIDE(KE, ECP_256_BP),
PLUGIN_PROVIDE(KE, ECP_384_BP),
PLUGIN_PROVIDE(KE, ECP_512_BP),
PLUGIN_PROVIDE(KE, ECP_224_BP),
#endif /* OPENSSL_VERSION_NUMBER */
#endif /* OPENSSL_NO_ECDH */
};
src/libstrongswan/plugins/openssl/openssl_x_diffie_hellman.c
+35 -35
View File
@@ -25,21 +25,21 @@
#include <utils/debug.h>
typedef struct private_diffie_hellman_t private_diffie_hellman_t;
typedef struct private_key_exchange_t private_key_exchange_t;
/**
* Private data
*/
struct private_diffie_hellman_t {
struct private_key_exchange_t {
/**
* Public interface.
*/
diffie_hellman_t public;
key_exchange_t public;
/**
* Diffie Hellman group number.
* Key exchange method.
*/
diffie_hellman_group_t group;
key_exchange_method_t ke;
/**
* Private (public) key
@@ -58,11 +58,11 @@ struct private_diffie_hellman_t {
};
/**
* Map a DH group to a key type
* Map a key exchange method to a key type
*/
static int map_key_type(diffie_hellman_group_t group)
static int map_key_type(key_exchange_method_t ke)
{
switch (group)
switch (ke)
{
case CURVE_25519:
return EVP_PKEY_X25519;
@@ -73,29 +73,29 @@ static int map_key_type(diffie_hellman_group_t group)
}
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
private_diffie_hellman_t *this, chunk_t value)
METHOD(key_exchange_t, set_public_key, bool,
private_key_exchange_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->ke, value))
{
return FALSE;
}
EVP_PKEY_free(this->pub);
this->pub = EVP_PKEY_new_raw_public_key(map_key_type(this->group), NULL,
this->pub = EVP_PKEY_new_raw_public_key(map_key_type(this->ke), NULL,
value.ptr, value.len);
if (!this->pub)
{
DBG1(DBG_LIB, "%N public value is malformed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->ke);
return FALSE;
}
chunk_clear(&this->shared_secret);
return TRUE;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
private_diffie_hellman_t *this, chunk_t *value)
METHOD(key_exchange_t, get_public_key, bool,
private_key_exchange_t *this, chunk_t *value)
{
size_t len;
@@ -114,11 +114,11 @@ METHOD(diffie_hellman_t, get_my_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
private_diffie_hellman_t *this, chunk_t value)
METHOD(key_exchange_t, set_private_key, bool,
private_key_exchange_t *this, chunk_t value)
{
EVP_PKEY_free(this->key);
this->key = EVP_PKEY_new_raw_private_key(map_key_type(this->group), NULL,
this->key = EVP_PKEY_new_raw_private_key(map_key_type(this->ke), NULL,
value.ptr, value.len);
if (!this->key)
{
@@ -127,28 +127,28 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
private_diffie_hellman_t *this, chunk_t *secret)
METHOD(key_exchange_t, get_shared_secret, bool,
private_key_exchange_t *this, chunk_t *secret)
{
if (!this->shared_secret.len &&
!openssl_compute_shared_key(this->key, this->pub, &this->shared_secret))
{
DBG1(DBG_LIB, "%N shared secret computation failed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->ke);
return FALSE;
}
*secret = chunk_clone(this->shared_secret);
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
private_diffie_hellman_t *this)
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_key_exchange_t *this)
{
return this->group;
return this->ke;
}
METHOD(diffie_hellman_t, destroy, void,
private_diffie_hellman_t *this)
METHOD(key_exchange_t, destroy, void,
private_key_exchange_t *this)
{
EVP_PKEY_free(this->key);
EVP_PKEY_free(this->pub);
@@ -159,13 +159,13 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header
*/
diffie_hellman_t *openssl_x_diffie_hellman_create(diffie_hellman_group_t group)
key_exchange_t *openssl_x_diffie_hellman_create(key_exchange_method_t ke)
{
private_diffie_hellman_t *this;
private_key_exchange_t *this;
EVP_PKEY_CTX *ctx = NULL;
EVP_PKEY *key = NULL;
switch (group)
switch (ke)
{
case CURVE_25519:
ctx = EVP_PKEY_CTX_new_id(NID_X25519, NULL);
@@ -182,7 +182,7 @@ diffie_hellman_t *openssl_x_diffie_hellman_create(diffie_hellman_group_t group)
EVP_PKEY_keygen(ctx, &key) <= 0)
{
DBG1(DBG_LIB, "generating key for %N failed",
diffie_hellman_group_names, group);
key_exchange_method_names, ke);
EVP_PKEY_CTX_free(ctx);
return NULL;
}
@@ -191,13 +191,13 @@ diffie_hellman_t *openssl_x_diffie_hellman_create(diffie_hellman_group_t group)
INIT(this,
.public = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
.group = group,
.ke = ke,
.key = key,
);
return &this->public;
src/libstrongswan/plugins/openssl/openssl_x_diffie_hellman.h
+3 -3
View File
@@ -27,12 +27,12 @@
#include <library.h>
/**
* Creates a new diffie_hellman_t object.
* Creates a new key_exchange_t object.
*
* @param group Diffie Hellman group number to use
* @param ke key exchange method to use
* @return object, NULL if not supported
*/
diffie_hellman_t *openssl_x_diffie_hellman_create(diffie_hellman_group_t group);
key_exchange_t *openssl_x_diffie_hellman_create(key_exchange_method_t ke);
#endif /** OPENSSL_X_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/pkcs11/pkcs11_dh.c
+17 -17
View File
@@ -46,9 +46,9 @@ struct private_pkcs11_dh_t {
CK_SESSION_HANDLE session;
/**
* Diffie Hellman group number.
* Diffie-Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* Handle for own private value
@@ -114,10 +114,10 @@ static bool derive_secret(private_pkcs11_dh_t *this, chunk_t other)
return TRUE;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_pkcs11_dh_t *this, chunk_t value)
{
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -149,14 +149,14 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return derive_secret(this, value);
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_pkcs11_dh_t *this, chunk_t *value)
{
*value = chunk_clone(this->pub_key);
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_pkcs11_dh_t *this, chunk_t *secret)
{
if (!this->secret.ptr)
@@ -167,13 +167,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_pkcs11_dh_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_pkcs11_dh_t *this)
{
this->lib->f->C_CloseSession(this->session);
@@ -316,7 +316,7 @@ static pkcs11_library_t *find_token(private_pkcs11_dh_t *this,
/**
* Generic internal constructor
*/
static private_pkcs11_dh_t *create_generic(diffie_hellman_group_t group,
static private_pkcs11_dh_t *create_generic(key_exchange_method_t group,
CK_MECHANISM_TYPE key,
CK_MECHANISM_TYPE derive)
{
@@ -324,11 +324,11 @@ static private_pkcs11_dh_t *create_generic(diffie_hellman_group_t group,
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
@@ -346,7 +346,7 @@ static private_pkcs11_dh_t *create_generic(diffie_hellman_group_t group,
return this;
}
static pkcs11_dh_t *create_ecp(diffie_hellman_group_t group, chunk_t ecparam)
static pkcs11_dh_t *create_ecp(key_exchange_method_t group, chunk_t ecparam)
{
private_pkcs11_dh_t *this = create_generic(group, CKM_EC_KEY_PAIR_GEN,
CKM_ECDH1_DERIVE);
@@ -367,7 +367,7 @@ static pkcs11_dh_t *create_ecp(diffie_hellman_group_t group, chunk_t ecparam)
/**
* Constructor for MODP DH
*/
static pkcs11_dh_t *create_modp(diffie_hellman_group_t group, size_t exp_len,
static pkcs11_dh_t *create_modp(key_exchange_method_t group, size_t exp_len,
chunk_t g, chunk_t p)
{
private_pkcs11_dh_t *this = create_generic(group, CKM_DH_PKCS_KEY_PAIR_GEN,
@@ -387,7 +387,7 @@ static pkcs11_dh_t *create_modp(diffie_hellman_group_t group, size_t exp_len,
/**
* Lookup the EC params for the given group.
*/
static chunk_t ecparams_lookup(diffie_hellman_group_t group)
static chunk_t ecparams_lookup(key_exchange_method_t group)
{
switch (group)
{
@@ -410,7 +410,7 @@ static chunk_t ecparams_lookup(diffie_hellman_group_t group)
/**
* Described in header.
*/
pkcs11_dh_t *pkcs11_dh_create(diffie_hellman_group_t group, ...)
pkcs11_dh_t *pkcs11_dh_create(key_exchange_method_t group, ...)
{
switch (group)
{
src/libstrongswan/plugins/pkcs11/pkcs11_dh.h
+4 -4
View File
@@ -32,19 +32,19 @@ typedef struct pkcs11_dh_t pkcs11_dh_t;
struct pkcs11_dh_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new pkcs11_dh_t object.
*
* @param group Diffie Hellman group number to use
* @param group Diffie-Hellman group number to use
* @param ... expects generator and prime as chunk_t if MODP_CUSTOM
* @return pkcs11_dh_t object, NULL if not supported
*/
pkcs11_dh_t *pkcs11_dh_create(diffie_hellman_group_t group, ...);
pkcs11_dh_t *pkcs11_dh_create(key_exchange_method_t group, ...);
#endif /** PKCS11_DH_H_ @}*/
src/libstrongswan/plugins/pkcs11/pkcs11_plugin.c
+19 -19
View File
@@ -197,27 +197,27 @@ METHOD(plugin_t, get_features, int,
PLUGIN_PROVIDE(HASHER, HASH_SHA512),
};
static plugin_feature_t f_dh[] = {
PLUGIN_REGISTER(DH, pkcs11_dh_create),
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_REGISTER(KE, pkcs11_dh_create),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
};
static plugin_feature_t f_ecdh[] = {
PLUGIN_REGISTER(DH, pkcs11_dh_create),
PLUGIN_PROVIDE(DH, ECP_192_BIT),
PLUGIN_PROVIDE(DH, ECP_224_BIT),
PLUGIN_PROVIDE(DH, ECP_256_BIT),
PLUGIN_PROVIDE(DH, ECP_384_BIT),
PLUGIN_PROVIDE(DH, ECP_521_BIT),
PLUGIN_REGISTER(KE, pkcs11_dh_create),
PLUGIN_PROVIDE(KE, ECP_192_BIT),
PLUGIN_PROVIDE(KE, ECP_224_BIT),
PLUGIN_PROVIDE(KE, ECP_256_BIT),
PLUGIN_PROVIDE(KE, ECP_384_BIT),
PLUGIN_PROVIDE(KE, ECP_521_BIT),
};
static plugin_feature_t f_rng[] = {
PLUGIN_REGISTER(RNG, pkcs11_rng_create),
src/libstrongswan/plugins/plugin_feature.c
+12 -12
View File
@@ -33,7 +33,7 @@ ENUM(plugin_feature_names, FEATURE_NONE, FEATURE_CUSTOM,
"XOF",
"KDF",
"DRBG",
"DH",
"KE",
"RNG",
"NONCE_GEN",
"PRIVKEY",
@@ -99,8 +99,8 @@ uint32_t plugin_feature_hash(plugin_feature_t *feature)
case FEATURE_DRBG:
data = chunk_from_thing(feature->arg.drbg);
break;
case FEATURE_DH:
data = chunk_from_thing(feature->arg.dh_group);
case FEATURE_KE:
data = chunk_from_thing(feature->arg.ke);
break;
case FEATURE_PRIVKEY:
data = chunk_from_thing(feature->arg.privkey);
@@ -178,8 +178,8 @@ bool plugin_feature_matches(plugin_feature_t *a, plugin_feature_t *b)
return a->arg.kdf == b->arg.kdf;
case FEATURE_DRBG:
return a->arg.drbg == b->arg.drbg;
case FEATURE_DH:
return a->arg.dh_group == b->arg.dh_group;
case FEATURE_KE:
return a->arg.ke == b->arg.ke;
case FEATURE_RNG:
return a->arg.rng_quality <= b->arg.rng_quality;
case FEATURE_NONCE_GEN:
@@ -239,7 +239,7 @@ bool plugin_feature_equals(plugin_feature_t *a, plugin_feature_t *b)
case FEATURE_XOF:
case FEATURE_KDF:
case FEATURE_DRBG:
case FEATURE_DH:
case FEATURE_KE:
case FEATURE_NONCE_GEN:
case FEATURE_RESOLVER:
case FEATURE_PRIVKEY:
@@ -347,9 +347,9 @@ char* plugin_feature_get_string(plugin_feature_t *feature)
return str;
}
break;
case FEATURE_DH:
case FEATURE_KE:
if (asprintf(&str, "%N:%N", plugin_feature_names, feature->type,
diffie_hellman_group_names, feature->arg.dh_group) > 0)
key_exchange_method_names, feature->arg.ke) > 0)
{
return str;
}
@@ -530,8 +530,8 @@ bool plugin_feature_load(plugin_t *plugin, plugin_feature_t *feature,
lib->crypto->add_drbg(lib->crypto, feature->arg.drbg,
name, reg->arg.reg.f);
break;
case FEATURE_DH:
lib->crypto->add_dh(lib->crypto, feature->arg.dh_group,
case FEATURE_KE:
lib->crypto->add_ke(lib->crypto, feature->arg.ke,
name, reg->arg.reg.f);
break;
case FEATURE_RNG:
@@ -635,8 +635,8 @@ bool plugin_feature_unload(plugin_t *plugin, plugin_feature_t *feature,
case FEATURE_DRBG:
lib->crypto->remove_drbg(lib->crypto, reg->arg.reg.f);
break;
case FEATURE_DH:
lib->crypto->remove_dh(lib->crypto, reg->arg.reg.f);
case FEATURE_KE:
lib->crypto->remove_ke(lib->crypto, reg->arg.reg.f);
break;
case FEATURE_RNG:
lib->crypto->remove_rng(lib->crypto, reg->arg.reg.f);
src/libstrongswan/plugins/plugin_feature.h
+6 -6
View File
@@ -116,8 +116,8 @@ struct plugin_feature_t {
FEATURE_KDF,
/** drbg_t */
FEATURE_DRBG,
/** diffie_hellman_t */
FEATURE_DH,
/** key_exchange_t */
FEATURE_KE,
/** rng_t */
FEATURE_RNG,
/** nonce_gen_t */
@@ -185,8 +185,8 @@ struct plugin_feature_t {
drbg_type_t drbg;
/** FEATURE_HASHER */
hash_algorithm_t hasher;
/** FEATURE_DH */
diffie_hellman_group_t dh_group;
/** FEATURE_KE */
key_exchange_method_t ke;
/** FEATURE_RNG */
rng_quality_t rng_quality;
/** FEATURE_PRIVKEY */
@@ -293,7 +293,7 @@ struct plugin_feature_t {
#define _PLUGIN_FEATURE_XOF(kind, alg) __PLUGIN_FEATURE(kind, XOF, .xof = alg)
#define _PLUGIN_FEATURE_KDF(kind, alg) __PLUGIN_FEATURE(kind, KDF, .kdf = alg)
#define _PLUGIN_FEATURE_DRBG(kind, type) __PLUGIN_FEATURE(kind, DRBG, .drbg = type)
#define _PLUGIN_FEATURE_DH(kind, group) __PLUGIN_FEATURE(kind, DH, .dh_group = group)
#define _PLUGIN_FEATURE_KE(kind, method) __PLUGIN_FEATURE(kind, KE, .ke = method)
#define _PLUGIN_FEATURE_RNG(kind, quality) __PLUGIN_FEATURE(kind, RNG, .rng_quality = quality)
#define _PLUGIN_FEATURE_NONCE_GEN(kind, ...) __PLUGIN_FEATURE(kind, NONCE_GEN, .custom = NULL)
#define _PLUGIN_FEATURE_PRIVKEY(kind, type) __PLUGIN_FEATURE(kind, PRIVKEY, .privkey = type)
@@ -328,7 +328,7 @@ struct plugin_feature_t {
#define _PLUGIN_FEATURE_REGISTER_XOF(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_KDF(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_DRBG(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_DH(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_KE(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_RNG(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_NONCE_GEN(type, f) __PLUGIN_FEATURE_REGISTER(type, f)
#define _PLUGIN_FEATURE_REGISTER_PRIVKEY(type, f, final) __PLUGIN_FEATURE_REGISTER_BUILDER(type, f, final)
src/libstrongswan/plugins/test_vectors/test_vectors.h
+23 -23
View File
@@ -352,26 +352,26 @@ TEST_VECTOR_RNG(rng_runs_1)
TEST_VECTOR_RNG(rng_runs_2)
TEST_VECTOR_RNG(rng_runs_3)
TEST_VECTOR_DH(modp768)
TEST_VECTOR_DH(modp1024)
TEST_VECTOR_DH(modp1536)
TEST_VECTOR_DH(modp2048)
TEST_VECTOR_DH(modp3072)
TEST_VECTOR_DH(modp4096)
TEST_VECTOR_DH(modp6144)
TEST_VECTOR_DH(modp8192)
TEST_VECTOR_DH(modp1024_160)
TEST_VECTOR_DH(modp2048_224)
TEST_VECTOR_DH(modp2048_256)
TEST_VECTOR_DH(ecp192)
TEST_VECTOR_DH(ecp224)
TEST_VECTOR_DH(ecp256)
TEST_VECTOR_DH(ecp384)
TEST_VECTOR_DH(ecp521)
TEST_VECTOR_DH(ecp224bp)
TEST_VECTOR_DH(ecp256bp)
TEST_VECTOR_DH(ecp384bp)
TEST_VECTOR_DH(ecp512bp)
TEST_VECTOR_DH(curve25519_1)
TEST_VECTOR_DH(curve25519_2)
TEST_VECTOR_DH(curve448_1)
TEST_VECTOR_KE(modp768)
TEST_VECTOR_KE(modp1024)
TEST_VECTOR_KE(modp1536)
TEST_VECTOR_KE(modp2048)
TEST_VECTOR_KE(modp3072)
TEST_VECTOR_KE(modp4096)
TEST_VECTOR_KE(modp6144)
TEST_VECTOR_KE(modp8192)
TEST_VECTOR_KE(modp1024_160)
TEST_VECTOR_KE(modp2048_224)
TEST_VECTOR_KE(modp2048_256)
TEST_VECTOR_KE(ecp192)
TEST_VECTOR_KE(ecp224)
TEST_VECTOR_KE(ecp256)
TEST_VECTOR_KE(ecp384)
TEST_VECTOR_KE(ecp521)
TEST_VECTOR_KE(ecp224bp)
TEST_VECTOR_KE(ecp256bp)
TEST_VECTOR_KE(ecp384bp)
TEST_VECTOR_KE(ecp512bp)
TEST_VECTOR_KE(curve25519_1)
TEST_VECTOR_KE(curve25519_2)
TEST_VECTOR_KE(curve448_1)
src/libstrongswan/plugins/test_vectors/test_vectors/curve25519.c
+4 -4
View File
@@ -19,8 +19,8 @@
/**
* From RFC 7748
*/
dh_test_vector_t curve25519_1 = {
.group = CURVE_25519, .priv_len = 32, .pub_len = 32, .shared_len = 32,
ke_test_vector_t curve25519_1 = {
.method = CURVE_25519, .priv_len = 32, .pub_len = 32, .shared_len = 32,
.priv_a = "\x77\x07\x6d\x0a\x73\x18\xa5\x7d\x3c\x16\xc1\x72\x51\xb2\x66\x45"
"\xdf\x4c\x2f\x87\xeb\xc0\x99\x2a\xb1\x77\xfb\xa5\x1d\xb9\x2c\x2a",
.priv_b = "\x5d\xab\x08\x7e\x62\x4a\x8a\x4b\x79\xe1\x7f\x8b\x83\x80\x0e\xe6"
@@ -36,8 +36,8 @@ dh_test_vector_t curve25519_1 = {
/**
* From RFC 8031
*/
dh_test_vector_t curve25519_2 = {
.group = CURVE_25519, .priv_len = 32, .pub_len = 32, .shared_len = 32,
ke_test_vector_t curve25519_2 = {
.method = CURVE_25519, .priv_len = 32, .pub_len = 32, .shared_len = 32,
.priv_a = "\x75\x1f\xb4\x30\x86\x55\xb4\x76\xb6\x78\x9b\x73\x25\xf9\xea\x8c"
"\xdd\xd1\x6a\x58\x53\x3f\xf6\xd9\xe6\x00\x09\x46\x4a\x5f\x9d\x94",
.priv_b = "\x0a\x54\x64\x52\x53\x29\x0d\x60\xdd\xad\xd0\xe0\x30\xba\xcd\x9e"
src/libstrongswan/plugins/test_vectors/test_vectors/curve448.c
+2 -2
View File
@@ -19,8 +19,8 @@
/**
* From RFC 7748
*/
dh_test_vector_t curve448_1 = {
.group = CURVE_448, .priv_len = 56, .pub_len = 56, .shared_len = 56,
ke_test_vector_t curve448_1 = {
.method = CURVE_448, .priv_len = 56, .pub_len = 56, .shared_len = 56,
.priv_a = "\x9a\x8f\x49\x25\xd1\x51\x9f\x57\x75\xcf\x46\xb0\x4b\x58\x00\xd4"
"\xee\x9e\xe8\xba\xe8\xbc\x55\x65\xd4\x98\xc2\x8d\xd9\xc9\xba\xf5"
"\x74\xa9\x41\x97\x44\x89\x73\x91\x00\x63\x82\xa6\xf1\x27\xab\x1d"
src/libstrongswan/plugins/test_vectors/test_vectors/ecp.c
+10 -10
View File
@@ -20,8 +20,8 @@
* Test vectors from RFC5114
*/
dh_test_vector_t ecp192 = {
.group = ECP_192_BIT, .priv_len = 24, .pub_len = 48, .shared_len = 24,
ke_test_vector_t ecp192 = {
.method = ECP_192_BIT, .priv_len = 24, .pub_len = 48, .shared_len = 24,
.priv_a = "\x32\x3f\xa3\x16\x9d\x8e\x9c\x65\x93\xf5\x94\x76\xbc\x14\x20\x00"
"\xab\x5b\xe0\xe2\x49\xc4\x34\x26",
.priv_b = "\x63\x1f\x95\xbb\x4a\x67\x63\x2c\x9c\x47\x6e\xee\x9a\xb6\x95\xab"
@@ -36,8 +36,8 @@ dh_test_vector_t ecp192 = {
"\xe5\xff\x4f\x83\x7f\x54\xfe\xbe",
};
dh_test_vector_t ecp224 = {
.group = ECP_224_BIT, .priv_len = 28, .pub_len = 56, .shared_len = 28,
ke_test_vector_t ecp224 = {
.method = ECP_224_BIT, .priv_len = 28, .pub_len = 56, .shared_len = 28,
.priv_a = "\xb5\x58\xeb\x6c\x28\x8d\xa7\x07\xbb\xb4\xf8\xfb\xae\x2a\xb9\xe9"
"\xcb\x62\xe3\xbc\x5c\x75\x73\xe2\x2e\x26\xd3\x7f",
.priv_b = "\xac\x3b\x1a\xdd\x3d\x97\x70\xe6\xf6\xa7\x08\xee\x9f\x3b\x8e\x0a"
@@ -54,8 +54,8 @@ dh_test_vector_t ecp224 = {
"\xd9\x6e\xcc\x3b\x6d\xc1\x71\x4a\x4e\xa9\x49\xfa",
};
dh_test_vector_t ecp256 = {
.group = ECP_256_BIT, .priv_len = 32, .pub_len = 64, .shared_len = 32,
ke_test_vector_t ecp256 = {
.method = ECP_256_BIT, .priv_len = 32, .pub_len = 64, .shared_len = 32,
.priv_a = "\x81\x42\x64\x14\x5f\x2f\x56\xf2\xe9\x6a\x8e\x33\x7a\x12\x84\x99"
"\x3f\xaf\x43\x2a\x5a\xbc\xe5\x9e\x86\x7b\x72\x91\xd5\x07\xa3\xaf",
.priv_b = "\x2c\xe1\x78\x8e\xc1\x97\xe0\x96\xdb\x95\xa2\x00\xcc\x0a\xb2\x6a"
@@ -72,8 +72,8 @@ dh_test_vector_t ecp256 = {
"\xf5\x81\x1e\x9d\xc8\xec\x8e\xea\x7f\x80\xd2\x1c\x82\x0c\x27\x88",
};
dh_test_vector_t ecp384 = {
.group = ECP_384_BIT, .priv_len = 48, .pub_len = 96, .shared_len = 48,
ke_test_vector_t ecp384 = {
.method = ECP_384_BIT, .priv_len = 48, .pub_len = 96, .shared_len = 48,
.priv_a = "\xd2\x73\x35\xea\x71\x66\x4a\xf2\x44\xdd\x14\xe9\xfd\x12\x60\x71"
"\x5d\xfd\x8a\x79\x65\x57\x1c\x48\xd7\x09\xee\x7a\x79\x62\xa1\x56"
"\xd7\x06\xa9\x0c\xbc\xb5\xdf\x29\x86\xf0\x5f\xea\xdb\x93\x76\xf1",
@@ -97,8 +97,8 @@ dh_test_vector_t ecp384 = {
"\x27\xaa\x8a\x45\x40\x88\x4c\x37\xde\x15\x9a\x58\x02\x8a\xbc\x0e",
};
dh_test_vector_t ecp521 = {
.group = ECP_521_BIT, .priv_len = 66, .pub_len = 132, .shared_len = 66,
ke_test_vector_t ecp521 = {
.method = ECP_521_BIT, .priv_len = 66, .pub_len = 132, .shared_len = 66,
.priv_a = "\x01\x13\xf8\x2d\xa8\x25\x73\x5e\x3d\x97\x27\x66\x83\xb2\xb7\x42"
"\x77\xba\xd2\x73\x35\xea\x71\x66\x4a\xf2\x43\x0c\xc4\xf3\x34\x59"
"\xb9\x66\x9e\xe7\x8b\x3f\xfb\x9b\x86\x83\x01\x5d\x34\x4d\xcb\xfe"
src/libstrongswan/plugins/test_vectors/test_vectors/ecpbp.c
+8 -8
View File
@@ -20,8 +20,8 @@
* Test vectors from RFC6923/RFC7027
*/
dh_test_vector_t ecp224bp = {
.group = ECP_224_BP, .priv_len = 28, .pub_len = 56, .shared_len = 28,
ke_test_vector_t ecp224bp = {
.method = ECP_224_BP, .priv_len = 28, .pub_len = 56, .shared_len = 28,
.priv_a = "\x7c\x4b\x7a\x2c\x8a\x4b\xad\x1f\xbb\x7d\x79\xcc\x09\x55\xdb\x7c"
"\x6a\x46\x60\xca\x64\xcc\x47\x78\x15\x9b\x49\x5e",
.priv_b = "\x63\x97\x6d\x4a\xae\x6c\xd0\xf6\xdd\x18\xde\xfe\xf5\x5d\x96\x56"
@@ -38,8 +38,8 @@ dh_test_vector_t ecp224bp = {
"\xdc\xcb\xe3\xb6\x5d\x0f\x96\x7d\xca\xb5\x74\xeb",
};
dh_test_vector_t ecp256bp = {
.group = ECP_256_BP, .priv_len = 32, .pub_len = 64, .shared_len = 32,
ke_test_vector_t ecp256bp = {
.method = ECP_256_BP, .priv_len = 32, .pub_len = 64, .shared_len = 32,
.priv_a = "\x81\xdb\x1e\xe1\x00\x15\x0f\xf2\xea\x33\x8d\x70\x82\x71\xbe\x38"
"\x30\x0c\xb5\x42\x41\xd7\x99\x50\xf7\x7b\x06\x30\x39\x80\x4f\x1d",
.priv_b = "\x55\xe4\x0b\xc4\x1e\x37\xe3\xe2\xad\x25\xc3\xc6\x65\x45\x11\xff"
@@ -56,8 +56,8 @@ dh_test_vector_t ecp256bp = {
"\xf9\x65\x56\xec\x91\xe6\xae\x79\x39\xbc\xe3\x1f\x3a\x18\xbf\x2b",
};
dh_test_vector_t ecp384bp = {
.group = ECP_384_BP, .priv_len = 48, .pub_len = 96, .shared_len = 48,
ke_test_vector_t ecp384bp = {
.method = ECP_384_BP, .priv_len = 48, .pub_len = 96, .shared_len = 48,
.priv_a = "\x1e\x20\xf5\xe0\x48\xa5\x88\x6f\x1f\x15\x7c\x74\xe9\x1b\xde\x2b"
"\x98\xc8\xb5\x2d\x58\xe5\x00\x3d\x57\x05\x3f\xc4\xb0\xbd\x65\xd6"
"\xf1\x5e\xb5\xd1\xee\x16\x10\xdf\x87\x07\x95\x14\x36\x27\xd0\x42",
@@ -81,8 +81,8 @@ dh_test_vector_t ecp384bp = {
"\xad\xf6\x40\x37\x15\xc3\x5d\x4f\xb2\xa5\x44\x4f\x57\x5d\x4f\x42",
};
dh_test_vector_t ecp512bp = {
.group = ECP_512_BP, .priv_len = 64, .pub_len = 128, .shared_len = 64,
ke_test_vector_t ecp512bp = {
.method = ECP_512_BP, .priv_len = 64, .pub_len = 128, .shared_len = 64,
.priv_a = "\x16\x30\x2f\xf0\xdb\xbb\x5a\x8d\x73\x3d\xab\x71\x41\xc1\xb4\x5a"
"\xcb\xc8\x71\x59\x39\x67\x7f\x6a\x56\x85\x0a\x38\xbd\x87\xbd\x59"
"\xb0\x9e\x80\x27\x96\x09\xff\x33\x3e\xb9\xd4\xc0\x61\x23\x1f\xb2"
src/libstrongswan/plugins/test_vectors/test_vectors/modp.c
+16 -16
View File
@@ -21,8 +21,8 @@
* these have been generated.
*/
dh_test_vector_t modp768 = {
.group = MODP_768_BIT, .priv_len = 32, .pub_len = 96, .shared_len = 96,
ke_test_vector_t modp768 = {
.method = MODP_768_BIT, .priv_len = 32, .pub_len = 96, .shared_len = 96,
.priv_a = "\x60\x91\xff\xc6\xde\x28\xc1\xcc\xc7\xc6\x5d\xa6\x11\xab\xfa\xe8"
"\x6a\x10\x74\xb2\x22\x43\xe3\x70\x6c\xb6\xde\x2f\xe2\x9d\x11\x42",
.priv_b = "\x76\xe0\x2f\xc3\xea\xbe\x6a\x0f\xce\xd6\xc3\x1e\x59\x45\xd1\x67"
@@ -47,8 +47,8 @@ dh_test_vector_t modp768 = {
"\x3d\xaa\xad\x22\xe8\x68\xb7\xe2\x50\x02\x9d\x30\x7e\xe5\x41\x48",
};
dh_test_vector_t modp1024 = {
.group = MODP_1024_BIT, .priv_len = 32, .pub_len = 128, .shared_len = 128,
ke_test_vector_t modp1024 = {
.method = MODP_1024_BIT, .priv_len = 32, .pub_len = 128, .shared_len = 128,
.priv_a = "\xe5\x3c\x20\x5d\xa0\xd8\xe4\xbf\xb4\x17\x49\x44\x32\x0f\xc6\xe4"
"\xea\x66\xfe\x44\xe3\xc9\x31\xac\x5d\xa1\x45\x0a\xea\x47\xeb\xcf",
.priv_b = "\x7f\x9a\xf7\x21\xeb\x7c\xd2\xa9\x00\xa3\x6e\x39\x9e\xbc\x5c\x65"
@@ -79,8 +79,8 @@ dh_test_vector_t modp1024 = {
"\x48\x02\xd7\x4a\x4f\x75\x3b\x29\x4a\x96\x50\x3f\x26\x05\xd3\xf1",
};
dh_test_vector_t modp1536 = {
.group = MODP_1536_BIT, .priv_len = 32, .pub_len = 192, .shared_len = 192,
ke_test_vector_t modp1536 = {
.method = MODP_1536_BIT, .priv_len = 32, .pub_len = 192, .shared_len = 192,
.priv_a = "\x22\xd9\xdc\xc7\x30\x79\x93\x6a\x85\x8c\x07\xaa\x85\xed\x07\xb3"
"\xd1\xe8\xb6\x70\xe7\xca\xaf\xa1\x92\x83\x76\x96\x07\x0f\xef\x29",
.priv_b = "\x32\x34\x74\xde\x77\x88\xe0\x03\x6b\x30\x95\x49\x56\x0b\x00\x0d"
@@ -123,8 +123,8 @@ dh_test_vector_t modp1536 = {
"\x38\x1b\x1e\x5b\x7a\xa5\xd0\x9a\xb6\x6b\x74\x99\x7c\xba\xed\x20",
};
dh_test_vector_t modp2048 = {
.group = MODP_2048_BIT, .priv_len = 48, .pub_len = 256, .shared_len = 256,
ke_test_vector_t modp2048 = {
.method = MODP_2048_BIT, .priv_len = 48, .pub_len = 256, .shared_len = 256,
.priv_a = "\xaf\x3b\xfd\x38\x62\xca\xa1\x17\x74\xce\x2b\x74\x84\x08\x07\xc1"
"\xde\x5c\xd6\xa7\x61\x9b\xb3\xa0\xc7\xaf\x39\xee\xda\xa6\xeb\x89"
"\xe2\xe9\xc1\x44\xb3\x62\x5b\x27\x31\x87\x9c\xb5\x8f\xa3\x76\x6d",
@@ -181,8 +181,8 @@ dh_test_vector_t modp2048 = {
"\xee\x9c\x12\x15\xdd\x23\x93\xde\x02\xf5\xc1\x76\x7f\x07\x0e\x28",
};
dh_test_vector_t modp3072 = {
.group = MODP_3072_BIT, .priv_len = 48, .pub_len = 384, .shared_len = 384,
ke_test_vector_t modp3072 = {
.method = MODP_3072_BIT, .priv_len = 48, .pub_len = 384, .shared_len = 384,
.priv_a = "\x51\xf8\xaa\xb6\x63\x20\x1e\xb2\x86\xba\xd2\x99\x32\xb2\xe5\x8a"
"\x92\x96\xbf\x2a\xa7\x78\x79\xcc\x8c\x64\x29\xd5\xa6\x68\xad\xf7"
"\x60\x57\xad\xc3\x77\xcc\x75\xfd\x86\x47\x96\xb8\xfa\x7b\x42\x8c",
@@ -263,8 +263,8 @@ dh_test_vector_t modp3072 = {
"\xdc\x87\x87\x5b\xe5\x88\xc0\xcd\xee\xee\xfd\x19\xcc\x4f\x1d\x40",
};
dh_test_vector_t modp4096 = {
.group = MODP_4096_BIT, .priv_len = 64, .pub_len = 512, .shared_len = 512,
ke_test_vector_t modp4096 = {
.method = MODP_4096_BIT, .priv_len = 64, .pub_len = 512, .shared_len = 512,
.priv_a = "\xab\x69\xbc\xe9\x61\xf9\x8a\xa9\xd5\x91\xe3\xfd\x9a\xbc\x46\xc8"
"\x0d\xde\x39\x02\x84\xf1\x91\x42\xe8\x81\x5a\xb0\x80\x54\x72\x2b"
"\xbd\x2e\x14\x1e\x27\x9e\xc7\xfd\x30\xaa\xfa\xca\x66\x40\x93\x73"
@@ -371,8 +371,8 @@ dh_test_vector_t modp4096 = {
"\x4f\xb9\x39\x02\x12\xb9\xb2\xa3\x5d\x4a\xfa\x17\xb3\xee\xc0\x8a",
};
dh_test_vector_t modp6144 = {
.group = MODP_6144_BIT, .priv_len = 64, .pub_len = 768, .shared_len = 768,
ke_test_vector_t modp6144 = {
.method = MODP_6144_BIT, .priv_len = 64, .pub_len = 768, .shared_len = 768,
.priv_a = "\xab\x36\xf0\x65\x7c\x4f\xba\xdc\x2a\x3b\x07\xed\xd1\xc8\xaf\xcb"
"\x42\xaf\xcd\x7f\xf9\x1c\x57\x01\x37\x25\x50\x0d\x89\x42\x9f\x34"
"\x79\x8f\x99\xf5\xde\x53\xd1\x08\x8f\xd9\xf6\x60\xa1\xa5\x2b\xe4"
@@ -527,8 +527,8 @@ dh_test_vector_t modp6144 = {
"\xb8\xd0\xeb\x41\xb6\x7c\xfb\x9d\x9d\xfd\x62\x0e\xb7\x99\xca\x17",
};
dh_test_vector_t modp8192 = {
.group = MODP_8192_BIT, .priv_len = 64, .pub_len = 1024, .shared_len = 1024,
ke_test_vector_t modp8192 = {
.method = MODP_8192_BIT, .priv_len = 64, .pub_len = 1024, .shared_len = 1024,
.priv_a = "\xa6\x48\x81\x47\x45\xfe\x1e\xd1\x98\x9b\x75\xba\x6d\xd5\x01\xe4"
"\x4e\x77\x6d\xc9\x97\xa0\xae\x27\x37\x64\x61\xb0\xee\x79\x65\x94"
"\xc2\xe6\xdb\x07\xe5\xf9\xd8\x7d\x94\x4d\x37\x01\x22\x38\xe5\x70"
src/libstrongswan/plugins/test_vectors/test_vectors/modpsub.c
+6 -6
View File
@@ -20,8 +20,8 @@
* Test vectors from RFC5114
*/
dh_test_vector_t modp1024_160 = {
.group = MODP_1024_160, .priv_len = 20, .pub_len = 128, .shared_len = 128,
ke_test_vector_t modp1024_160 = {
.method = MODP_1024_160, .priv_len = 20, .pub_len = 128, .shared_len = 128,
.priv_a = "\xB9\xA3\xB3\xAE\x8F\xEF\xC1\xA2\x93\x04\x96\x50\x70\x86\xF8\x45"
"\x5D\x48\x94\x3E",
.priv_b = "\x93\x92\xC9\xF9\xEB\x6A\x7A\x6A\x90\x22\xF7\xD8\x3E\x72\x23\xC6"
@@ -52,8 +52,8 @@ dh_test_vector_t modp1024_160 = {
"\x16\x7E\xCD\x91\x55\x41\x6F\x46\xF4\x08\xED\x31\xB6\x3C\x6E\x6D",
};
dh_test_vector_t modp2048_224 = {
.group = MODP_2048_224, .priv_len = 28, .pub_len = 256, .shared_len = 256,
ke_test_vector_t modp2048_224 = {
.method = MODP_2048_224, .priv_len = 28, .pub_len = 256, .shared_len = 256,
.priv_a = "\x22\xe6\x26\x01\xdb\xff\xd0\x67\x08\xa6\x80\xf7\x47\xf3\x61\xf7"
"\x6d\x8f\x4f\x72\x1a\x05\x48\xe4\x83\x29\x4b\x0c",
.priv_b = "\x4f\xf3\xbc\x96\xc7\xfc\x6a\x6d\x71\xd3\xb3\x63\x80\x0a\x7c\xdf"
@@ -108,8 +108,8 @@ dh_test_vector_t modp2048_224 = {
"\x7f\xcb\x51\x0b\x69\x98\xff\xd3\xaa\x6d\xe7\x3c\xf9\xf6\x38\x69",
};
dh_test_vector_t modp2048_256 = {
.group = MODP_2048_256, .priv_len = 32, .pub_len = 256, .shared_len = 256,
ke_test_vector_t modp2048_256 = {
.method = MODP_2048_256, .priv_len = 32, .pub_len = 256, .shared_len = 256,
.priv_a = "\x08\x81\x38\x2c\xdb\x87\x66\x0c\x6d\xc1\x3e\x61\x49\x38\xd5\xb9"
"\xc8\xb2\xf2\x48\x58\x1c\xc5\xe3\x1b\x35\x45\x43\x97\xfc\xe5\x0e",
.priv_b = "\x7d\x62\xa7\xe3\xef\x36\xde\x61\x7b\x13\xd1\xaf\xb8\x2c\x78\x0d"
src/libstrongswan/plugins/test_vectors/test_vectors_plugin.c
+10 -10
View File
@@ -29,7 +29,7 @@
#define TEST_VECTOR_KDF(x) extern kdf_test_vector_t x;
#define TEST_VECTOR_DRBG(x) extern drbg_test_vector_t x;
#define TEST_VECTOR_RNG(x) extern rng_test_vector_t x;
#define TEST_VECTOR_DH(x) extern dh_test_vector_t x;
#define TEST_VECTOR_KE(x) extern ke_test_vector_t x;
#include "test_vectors.h"
@@ -42,7 +42,7 @@
#undef TEST_VECTOR_KDF
#undef TEST_VECTOR_DRBG
#undef TEST_VECTOR_RNG
#undef TEST_VECTOR_DH
#undef TEST_VECTOR_KE
#define TEST_VECTOR_CRYPTER(x)
#define TEST_VECTOR_AEAD(x)
@@ -53,7 +53,7 @@
#define TEST_VECTOR_KDF(x)
#define TEST_VECTOR_DRBG(x)
#define TEST_VECTOR_RNG(x)
#define TEST_VECTOR_DH(x)
#define TEST_VECTOR_KE(x)
/* create test vector arrays */
#undef TEST_VECTOR_CRYPTER
@@ -128,13 +128,13 @@ static rng_test_vector_t *rng[] = {
#undef TEST_VECTOR_RNG
#define TEST_VECTOR_RNG(x)
#undef TEST_VECTOR_DH
#define TEST_VECTOR_DH(x) &x,
static dh_test_vector_t *dh[] = {
#undef TEST_VECTOR_KE
#define TEST_VECTOR_KE(x) &x,
static ke_test_vector_t *ke[] = {
#include "test_vectors.h"
};
#undef TEST_VECTOR_DH
#define TEST_VECTOR_DH(x)
#undef TEST_VECTOR_KE
#define TEST_VECTOR_KE(x)
typedef struct private_test_vectors_plugin_t private_test_vectors_plugin_t;
@@ -235,10 +235,10 @@ plugin_t *test_vectors_plugin_create()
lib->crypto->add_test_vector(lib->crypto,
RANDOM_NUMBER_GENERATOR, rng[i]);
}
for (i = 0; i < countof(dh); i++)
for (i = 0; i < countof(ke); i++)
{
lib->crypto->add_test_vector(lib->crypto,
DIFFIE_HELLMAN_GROUP, dh[i]);
KEY_EXCHANGE_METHOD, ke[i]);
}
return &this->public.plugin;
src/libstrongswan/plugins/wolfssl/wolfssl_diffie_hellman.c
+17 -17
View File
@@ -44,12 +44,12 @@ struct private_wolfssl_diffie_hellman_t {
wolfssl_diffie_hellman_t public;
/**
* Diffie Hellman group number.
* Diffie-Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* Diffie Hellman object
* Diffie-Hellman object
*/
DhKey dh;
@@ -74,14 +74,14 @@ struct private_wolfssl_diffie_hellman_t {
chunk_t shared_secret;
};
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_wolfssl_diffie_hellman_t *this, chunk_t *value)
{
*value = chunk_copy_pad(chunk_alloc(this->len), this->pub, 0x00);
return TRUE;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_wolfssl_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -92,12 +92,12 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_wolfssl_diffie_hellman_t *this, chunk_t value)
{
word32 len;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -115,7 +115,7 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_wolfssl_diffie_hellman_t *this, chunk_t value)
{
bool success = FALSE;
@@ -141,13 +141,13 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return success;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_wolfssl_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_wolfssl_diffie_hellman_t *this)
{
wc_FreeDhKey(&this->dh);
@@ -200,7 +200,7 @@ static int wolfssl_priv_key_size(int len)
/**
* Generic internal constructor
*/
static wolfssl_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
static wolfssl_diffie_hellman_t *create_generic(key_exchange_method_t group,
chunk_t g, chunk_t p)
{
private_wolfssl_diffie_hellman_t *this;
@@ -209,12 +209,12 @@ static wolfssl_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
@@ -263,7 +263,7 @@ static wolfssl_diffie_hellman_t *create_generic(diffie_hellman_group_t group,
* Described in header
*/
wolfssl_diffie_hellman_t *wolfssl_diffie_hellman_create(
diffie_hellman_group_t group, ...)
key_exchange_method_t group, ...)
{
diffie_hellman_params_t *params;
chunk_t g, p;
src/libstrongswan/plugins/wolfssl/wolfssl_diffie_hellman.h
+4 -4
View File
@@ -38,20 +38,20 @@ typedef struct wolfssl_diffie_hellman_t wolfssl_diffie_hellman_t;
struct wolfssl_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new wolfssl_diffie_hellman_t object.
*
* @param group Diffie Hellman group number to use
* @param group Diffie-Hellman group number to use
* @param ... expects generator and prime as chunk_t if MODP_CUSTOM
* @return wolfssl_diffie_hellman_t object, NULL if not supported
*/
wolfssl_diffie_hellman_t *wolfssl_diffie_hellman_create(
diffie_hellman_group_t group, ...);
key_exchange_method_t group, ...);
#endif /** WOLFSSL_PLUGIN_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/wolfssl/wolfssl_ec_diffie_hellman.c
+14 -14
View File
@@ -45,7 +45,7 @@ struct private_wolfssl_ec_diffie_hellman_t {
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* EC curve id for creating keys
@@ -169,12 +169,12 @@ static bool compute_shared_key(private_wolfssl_ec_diffie_hellman_t *this,
return success;
}
METHOD(diffie_hellman_t, set_other_public_value, bool,
METHOD(key_exchange_t, set_public_key, bool,
private_wolfssl_ec_diffie_hellman_t *this, chunk_t value)
{
ecc_point *pub_key;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -204,13 +204,13 @@ METHOD(diffie_hellman_t, set_other_public_value, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_my_public_value, bool,
METHOD(key_exchange_t, get_public_key, bool,
private_wolfssl_ec_diffie_hellman_t *this,chunk_t *value)
{
return ecp2chunk(this->keysize, &this->key.pubkey, value, FALSE);
}
METHOD(diffie_hellman_t, set_private_value, bool,
METHOD(key_exchange_t, set_private_key, bool,
private_wolfssl_ec_diffie_hellman_t *this, chunk_t value)
{
bool success = FALSE;
@@ -248,7 +248,7 @@ METHOD(diffie_hellman_t, set_private_value, bool,
return success;
}
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_wolfssl_ec_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -259,13 +259,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_wolfssl_ec_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_wolfssl_ec_diffie_hellman_t *this)
{
wc_ecc_free(&this->key);
@@ -276,19 +276,19 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header
*/
wolfssl_ec_diffie_hellman_t *wolfssl_ec_diffie_hellman_create(diffie_hellman_group_t group)
wolfssl_ec_diffie_hellman_t *wolfssl_ec_diffie_hellman_create(key_exchange_method_t group)
{
private_wolfssl_ec_diffie_hellman_t *this;
WC_RNG rng;
INIT(this,
.public = {
.dh = {
.ke = {
.get_shared_secret = _get_shared_secret,
.set_other_public_value = _set_other_public_value,
.get_my_public_value = _get_my_public_value,
.set_private_value = _set_private_value,
.get_dh_group = _get_dh_group,
.set_public_key = _set_public_key,
.get_public_key = _get_public_key,
.set_private_key = _set_private_key,
.get_method = _get_method,
.destroy = _destroy,
},
},
src/libstrongswan/plugins/wolfssl/wolfssl_ec_diffie_hellman.h
+4 -4
View File
@@ -38,19 +38,19 @@ typedef struct wolfssl_ec_diffie_hellman_t wolfssl_ec_diffie_hellman_t;
struct wolfssl_ec_diffie_hellman_t {
/**
* Implements diffie_hellman_t interface.
* Implements key_exchange_t interface.
*/
diffie_hellman_t dh;
key_exchange_t ke;
};
/**
* Creates a new wolfssl_ec_diffie_hellman_t object.
*
* @param group EC Diffie Hellman group number to use
* @param group EC Diffie-Hellman group number to use
* @return wolfssl_ec_diffie_hellman_t object, NULL if not
* supported
*/
wolfssl_ec_diffie_hellman_t *wolfssl_ec_diffie_hellman_create(
diffie_hellman_group_t group);
key_exchange_method_t group);
#endif /** WOLFSSL_PLUGIN_EC_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/plugins/wolfssl/wolfssl_plugin.c
+26 -26
View File
@@ -227,77 +227,77 @@ METHOD(plugin_t, get_features, int,
#endif
#ifdef HAVE_ECC_DHE
/* EC DH groups */
PLUGIN_REGISTER(DH, wolfssl_ec_diffie_hellman_create),
PLUGIN_REGISTER(KE, wolfssl_ec_diffie_hellman_create),
#if (!defined(NO_ECC256) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 256)
PLUGIN_PROVIDE(DH, ECP_256_BIT),
PLUGIN_PROVIDE(KE, ECP_256_BIT),
#endif
#if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 384)
PLUGIN_PROVIDE(DH, ECP_384_BIT),
PLUGIN_PROVIDE(KE, ECP_384_BIT),
#endif
#if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 521)
PLUGIN_PROVIDE(DH, ECP_521_BIT),
PLUGIN_PROVIDE(KE, ECP_521_BIT),
#endif
#if (defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 224)
PLUGIN_PROVIDE(DH, ECP_224_BIT),
PLUGIN_PROVIDE(KE, ECP_224_BIT),
#endif
#if (defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 192)
PLUGIN_PROVIDE(DH, ECP_192_BIT),
PLUGIN_PROVIDE(KE, ECP_192_BIT),
#endif
#ifdef HAVE_ECC_BRAINPOOL
#if (!defined(NO_ECC256) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 256)
PLUGIN_PROVIDE(DH, ECP_256_BP),
PLUGIN_PROVIDE(KE, ECP_256_BP),
#endif
#if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 384)
PLUGIN_PROVIDE(DH, ECP_384_BP),
PLUGIN_PROVIDE(KE, ECP_384_BP),
#endif
#if (defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 512)
PLUGIN_PROVIDE(DH, ECP_512_BP),
PLUGIN_PROVIDE(KE, ECP_512_BP),
#endif
#if (defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)) && \
(!defined(ECC_MIN_KEY_SZ) || ECC_MIN_KEY_SZ <= 224)
PLUGIN_PROVIDE(DH, ECP_224_BP),
PLUGIN_PROVIDE(KE, ECP_224_BP),
#endif
#endif
#endif /* HAVE_ECC_DHE */
#ifndef NO_DH
/* MODP DH groups */
PLUGIN_REGISTER(DH, wolfssl_diffie_hellman_create),
PLUGIN_REGISTER(KE, wolfssl_diffie_hellman_create),
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (3072 * 2)
PLUGIN_PROVIDE(DH, MODP_3072_BIT),
PLUGIN_PROVIDE(KE, MODP_3072_BIT),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (4096 * 2)
PLUGIN_PROVIDE(DH, MODP_4096_BIT),
PLUGIN_PROVIDE(KE, MODP_4096_BIT),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (6144 * 2)
PLUGIN_PROVIDE(DH, MODP_6144_BIT),
PLUGIN_PROVIDE(KE, MODP_6144_BIT),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (8192 * 2)
PLUGIN_PROVIDE(DH, MODP_8192_BIT),
PLUGIN_PROVIDE(KE, MODP_8192_BIT),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (2048 * 2)
PLUGIN_PROVIDE(DH, MODP_2048_BIT),
PLUGIN_PROVIDE(DH, MODP_2048_224),
PLUGIN_PROVIDE(DH, MODP_2048_256),
PLUGIN_PROVIDE(KE, MODP_2048_BIT),
PLUGIN_PROVIDE(KE, MODP_2048_224),
PLUGIN_PROVIDE(KE, MODP_2048_256),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (1536 * 2)
PLUGIN_PROVIDE(DH, MODP_1536_BIT),
PLUGIN_PROVIDE(KE, MODP_1536_BIT),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (1024 * 2)
PLUGIN_PROVIDE(DH, MODP_1024_BIT),
PLUGIN_PROVIDE(DH, MODP_1024_160),
PLUGIN_PROVIDE(KE, MODP_1024_BIT),
PLUGIN_PROVIDE(KE, MODP_1024_160),
#endif
#if !defined(USE_FAST_MATH) || FP_MAX_BITS >= (768 * 2)
PLUGIN_PROVIDE(DH, MODP_768_BIT),
PLUGIN_PROVIDE(KE, MODP_768_BIT),
#endif
PLUGIN_PROVIDE(DH, MODP_CUSTOM),
PLUGIN_PROVIDE(KE, MODP_CUSTOM),
#endif /* NO_DH */
#ifndef NO_RSA
/* RSA private/public key loading */
@@ -439,12 +439,12 @@ METHOD(plugin_t, get_features, int,
#endif /* HAVE_ECC_VERIFY */
#endif /* HAVE_ECC */
#if defined (HAVE_CURVE25519) || defined(HAVE_CURVE448)
PLUGIN_REGISTER(DH, wolfssl_x_diffie_hellman_create),
PLUGIN_REGISTER(KE, wolfssl_x_diffie_hellman_create),
#ifdef HAVE_CURVE25519
PLUGIN_PROVIDE(DH, CURVE_25519),
PLUGIN_PROVIDE(KE, CURVE_25519),
#endif
#ifdef HAVE_CURVE448
PLUGIN_PROVIDE(DH, CURVE_448),
PLUGIN_PROVIDE(KE, CURVE_448),
#endif
#endif /* HAVE_CURVE25519 || HAVE_CURVE448 */
#if defined(HAVE_ED25519) || defined(HAVE_ED448)
src/libstrongswan/plugins/wolfssl/wolfssl_x_diffie_hellman.c
+28 -27
View File
@@ -45,15 +45,16 @@ typedef struct private_diffie_hellman_t private_diffie_hellman_t;
* Private data
*/
struct private_diffie_hellman_t {
/**
* Public interface.
*/
diffie_hellman_t public;
key_exchange_t public;
/**
* Diffie Hellman group number.
*/
diffie_hellman_group_t group;
key_exchange_method_t group;
/**
* Private (public) key
@@ -75,14 +76,14 @@ struct private_diffie_hellman_t {
#ifdef HAVE_CURVE25519
METHOD(diffie_hellman_t, set_other_public_value_25519, bool,
METHOD(key_exchange_t, set_public_key_25519, bool,
private_diffie_hellman_t *this, chunk_t value)
{
word32 len = CURVE25519_KEYSIZE;
curve25519_key pub;
int ret;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -91,7 +92,7 @@ METHOD(diffie_hellman_t, set_other_public_value_25519, bool,
if (ret != 0)
{
DBG1(DBG_LIB, "%N public key initialization failed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
return FALSE;
}
@@ -100,7 +101,7 @@ METHOD(diffie_hellman_t, set_other_public_value_25519, bool,
if (ret != 0)
{
DBG1(DBG_LIB, "%N public value is malformed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
return FALSE;
}
@@ -110,7 +111,7 @@ METHOD(diffie_hellman_t, set_other_public_value_25519, bool,
this->shared_secret.ptr, &len, EC25519_LITTLE_ENDIAN) != 0)
{
DBG1(DBG_LIB, "%N shared secret computation failed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
chunk_clear(&this->shared_secret);
wc_curve25519_free(&pub);
return FALSE;
@@ -119,7 +120,7 @@ METHOD(diffie_hellman_t, set_other_public_value_25519, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_my_public_value_25519, bool,
METHOD(key_exchange_t, get_public_key_25519, bool,
private_diffie_hellman_t *this, chunk_t *value)
{
word32 len = CURVE25519_KEYSIZE;
@@ -134,7 +135,7 @@ METHOD(diffie_hellman_t, get_my_public_value_25519, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value_25519, bool,
METHOD(key_exchange_t, set_private_key_25519, bool,
private_diffie_hellman_t *this, chunk_t value)
{
curve25519_key pub;
@@ -167,14 +168,14 @@ METHOD(diffie_hellman_t, set_private_value_25519, bool,
#ifdef HAVE_CURVE448
METHOD(diffie_hellman_t, set_other_public_value_448, bool,
METHOD(key_exchange_t, set_public_key_448, bool,
private_diffie_hellman_t *this, chunk_t value)
{
word32 len = CURVE448_KEY_SIZE;
curve448_key pub;
int ret;
if (!diffie_hellman_verify_value(this->group, value))
if (!key_exchange_verify_pubkey(this->group, value))
{
return FALSE;
}
@@ -183,7 +184,7 @@ METHOD(diffie_hellman_t, set_other_public_value_448, bool,
if (ret != 0)
{
DBG1(DBG_LIB, "%N public key initialization failed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
return FALSE;
}
@@ -192,7 +193,7 @@ METHOD(diffie_hellman_t, set_other_public_value_448, bool,
if (ret != 0)
{
DBG1(DBG_LIB, "%N public value is malformed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
return FALSE;
}
@@ -202,7 +203,7 @@ METHOD(diffie_hellman_t, set_other_public_value_448, bool,
this->shared_secret.ptr, &len, EC448_LITTLE_ENDIAN) != 0)
{
DBG1(DBG_LIB, "%N shared secret computation failed",
diffie_hellman_group_names, this->group);
key_exchange_method_names, this->group);
chunk_clear(&this->shared_secret);
wc_curve448_free(&pub);
return FALSE;
@@ -211,7 +212,7 @@ METHOD(diffie_hellman_t, set_other_public_value_448, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_my_public_value_448, bool,
METHOD(key_exchange_t, get_public_key_448, bool,
private_diffie_hellman_t *this, chunk_t *value)
{
word32 len = CURVE448_KEY_SIZE;
@@ -226,7 +227,7 @@ METHOD(diffie_hellman_t, get_my_public_value_448, bool,
return TRUE;
}
METHOD(diffie_hellman_t, set_private_value_448, bool,
METHOD(key_exchange_t, set_private_key_448, bool,
private_diffie_hellman_t *this, chunk_t value)
{
curve448_key pub;
@@ -257,7 +258,7 @@ METHOD(diffie_hellman_t, set_private_value_448, bool,
#endif /* HAVE_CURVE448 */
METHOD(diffie_hellman_t, get_shared_secret, bool,
METHOD(key_exchange_t, get_shared_secret, bool,
private_diffie_hellman_t *this, chunk_t *secret)
{
if (!this->shared_secret.len)
@@ -268,13 +269,13 @@ METHOD(diffie_hellman_t, get_shared_secret, bool,
return TRUE;
}
METHOD(diffie_hellman_t, get_dh_group, diffie_hellman_group_t,
METHOD(key_exchange_t, get_method, key_exchange_method_t,
private_diffie_hellman_t *this)
{
return this->group;
}
METHOD(diffie_hellman_t, destroy, void,
METHOD(key_exchange_t, destroy, void,
private_diffie_hellman_t *this)
{
if (this->group == CURVE_25519)
@@ -296,7 +297,7 @@ METHOD(diffie_hellman_t, destroy, void,
/*
* Described in header
*/
diffie_hellman_t *wolfssl_x_diffie_hellman_create(diffie_hellman_group_t group)
key_exchange_t *wolfssl_x_diffie_hellman_create(key_exchange_method_t group)
{
private_diffie_hellman_t *this;
WC_RNG rng;
@@ -305,7 +306,7 @@ diffie_hellman_t *wolfssl_x_diffie_hellman_create(diffie_hellman_group_t group)
INIT(this,
.public = {
.get_shared_secret = _get_shared_secret,
.get_dh_group = _get_dh_group,
.get_method = _get_method,
.destroy = _destroy,
},
.group = group,
@@ -321,9 +322,9 @@ diffie_hellman_t *wolfssl_x_diffie_hellman_create(diffie_hellman_group_t group)
if (group == CURVE_25519)
{
#ifdef HAVE_CURVE25519
this->public.set_other_public_value = _set_other_public_value_25519;
this->public.get_my_public_value = _get_my_public_value_25519;
this->public.set_private_value = _set_private_value_25519;
this->public.set_public_key = _set_public_key_25519;
this->public.get_public_key = _get_public_key_25519;
this->public.set_private_key = _set_private_key_25519;
if (wc_curve25519_init(&this->key.key25519) != 0)
{
@@ -338,9 +339,9 @@ diffie_hellman_t *wolfssl_x_diffie_hellman_create(diffie_hellman_group_t group)
else if (group == CURVE_448)
{
#ifdef HAVE_CURVE448
this->public.set_other_public_value = _set_other_public_value_448;
this->public.get_my_public_value = _get_my_public_value_448;
this->public.set_private_value = _set_private_value_448;
this->public.set_public_key = _set_public_key_448;
this->public.get_public_key = _get_public_key_448;
this->public.set_private_key = _set_private_key_448;
if (wc_curve448_init(&this->key.key448) != 0)
{
src/libstrongswan/plugins/wolfssl/wolfssl_x_diffie_hellman.h
+3 -3
View File
@@ -33,11 +33,11 @@
#include <library.h>
/**
* Creates a new diffie_hellman_t object.
* Creates a new key_exchange_t object.
*
* @param group Diffie Hellman group number to use
* @param group Diffie-Hellman group number to use
* @return object, NULL if not supported
*/
diffie_hellman_t *wolfssl_x_diffie_hellman_create(diffie_hellman_group_t group);
key_exchange_t *wolfssl_x_diffie_hellman_create(key_exchange_method_t group);
#endif /** WOLFSSL_PLUGIN_X_DIFFIE_HELLMAN_H_ @}*/
src/libstrongswan/tests/suites/test_crypto_factory.c
+57 -57
View File
@@ -141,93 +141,93 @@ START_TEST(test_create_rng)
}
END_TEST
static diffie_hellman_t *dh_create(char *plugin)
static key_exchange_t *ke_create(char *plugin)
{
return (diffie_hellman_t*)plugin;
return (key_exchange_t*)plugin;
}
static diffie_hellman_t *dh_create_modp1024(diffie_hellman_group_t group, ...)
static key_exchange_t *ke_create_modp1024(key_exchange_method_t group, ...)
{
ck_assert(group == MODP_1024_BIT);
return dh_create("plugin1");
return ke_create("plugin1");
}
static diffie_hellman_t *dh_create_modp1024_second(diffie_hellman_group_t group,
...)
static key_exchange_t *ke_create_modp1024_second(key_exchange_method_t group,
...)
{
ck_assert(group == MODP_1024_BIT);
return dh_create("plugin2");
return ke_create("plugin2");
}
static diffie_hellman_t *dh_create_modp2048(diffie_hellman_group_t group, ...)
static key_exchange_t *ke_create_modp2048(key_exchange_method_t group, ...)
{
ck_assert(group == MODP_2048_BIT);
return dh_create("plugin1");
return ke_create("plugin1");
}
static diffie_hellman_t *dh_create_modp2048_second(diffie_hellman_group_t group,
...)
static key_exchange_t *ke_create_modp2048_second(key_exchange_method_t group,
...)
{
ck_assert(group == MODP_2048_BIT);
return dh_create("plugin2");
return ke_create("plugin2");
}
static struct {
char *exp1024;
char *exp2048;
struct {
diffie_hellman_group_t g;
dh_constructor_t create;
key_exchange_method_t ke;
ke_constructor_t create;
char *plugin;
} data[4];
} dh_data[] = {
} ke_data[] = {
{ NULL, NULL, {
{ MODP_NONE, NULL, NULL }
}},
{ "plugin1", NULL, {
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_NONE, NULL, NULL }
}},
{ "plugin1", NULL, {
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_1024_BIT, dh_create_modp1024_second, "plugin2" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024_second, "plugin2" },
{ MODP_NONE, NULL, NULL }
}},
{ "plugin2", NULL, {
{ MODP_1024_BIT, dh_create_modp1024_second, "plugin2" },
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024_second, "plugin2" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_NONE, NULL, NULL }
}},
{ "plugin1", "plugin1", {
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_2048_BIT, dh_create_modp2048, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_2048_BIT, ke_create_modp2048, "plugin1" },
{ MODP_NONE, NULL }
}},
{ "plugin1", "plugin1", {
{ MODP_2048_BIT, dh_create_modp2048, "plugin1" },
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_2048_BIT, ke_create_modp2048, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_NONE, NULL }
}},
{ "plugin1", "plugin1", {
{ MODP_2048_BIT, dh_create_modp2048, "plugin1" },
{ MODP_2048_BIT, dh_create_modp2048_second, "plugin2" },
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_2048_BIT, ke_create_modp2048, "plugin1" },
{ MODP_2048_BIT, ke_create_modp2048_second, "plugin2" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_NONE, NULL }
}},
{ "plugin1", "plugin2", {
{ MODP_2048_BIT, dh_create_modp2048_second, "plugin2" },
{ MODP_2048_BIT, dh_create_modp2048, "plugin1" },
{ MODP_1024_BIT, dh_create_modp1024, "plugin1" },
{ MODP_2048_BIT, ke_create_modp2048_second, "plugin2" },
{ MODP_2048_BIT, ke_create_modp2048, "plugin1" },
{ MODP_1024_BIT, ke_create_modp1024, "plugin1" },
{ MODP_NONE, NULL }
}},
};
static void verify_dh(crypto_factory_t *factory, diffie_hellman_group_t request,
static void verify_ke(crypto_factory_t *factory, key_exchange_method_t request,
char *expected)
{
char *plugin;
plugin = (char*)factory->create_dh(factory, request);
plugin = (char*)factory->create_ke(factory, request);
if (!expected)
{
ck_assert(!plugin);
@@ -239,56 +239,56 @@ static void verify_dh(crypto_factory_t *factory, diffie_hellman_group_t request,
}
}
START_TEST(test_create_dh)
START_TEST(test_create_ke)
{
enumerator_t *enumerator;
crypto_factory_t *factory;
diffie_hellman_group_t group;
key_exchange_method_t ke;
char *plugin;
int i, len = 0;
factory = crypto_factory_create();
for (i = 0; dh_data[_i].data[i].g != MODP_NONE; i++)
for (i = 0; ke_data[_i].data[i].ke != MODP_NONE; i++)
{
ck_assert(factory->add_dh(factory, dh_data[_i].data[i].g,
dh_data[_i].data[i].plugin,
dh_data[_i].data[i].create));
ck_assert(factory->add_ke(factory, ke_data[_i].data[i].ke,
ke_data[_i].data[i].plugin,
ke_data[_i].data[i].create));
}
verify_dh(factory, MODP_1024_BIT, dh_data[_i].exp1024);
verify_dh(factory, MODP_2048_BIT, dh_data[_i].exp2048);
verify_ke(factory, MODP_1024_BIT, ke_data[_i].exp1024);
verify_ke(factory, MODP_2048_BIT, ke_data[_i].exp2048);
len = countof(dh_data[_i].data);
enumerator = factory->create_dh_enumerator(factory);
for (i = 0; enumerator->enumerate(enumerator, &group, &plugin) && i < len;)
len = countof(ke_data[_i].data);
enumerator = factory->create_ke_enumerator(factory);
for (i = 0; enumerator->enumerate(enumerator, &ke, &plugin) && i < len;)
{
ck_assert_int_eq(dh_data[_i].data[i].g, group);
while (dh_data[_i].data[i].g == group)
{ /* skip other entries by the same group */
ck_assert_int_eq(ke_data[_i].data[i].ke, ke);
while (ke_data[_i].data[i].ke == ke)
{ /* skip other entries of the same method */
i++;
}
switch (group)
switch (ke)
{
case MODP_1024_BIT:
ck_assert(dh_data[_i].exp1024);
ck_assert_str_eq(dh_data[_i].exp1024, plugin);
ck_assert(ke_data[_i].exp1024);
ck_assert_str_eq(ke_data[_i].exp1024, plugin);
break;
case MODP_2048_BIT:
ck_assert(dh_data[_i].exp2048);
ck_assert_str_eq(dh_data[_i].exp2048, plugin);
ck_assert(ke_data[_i].exp2048);
ck_assert_str_eq(ke_data[_i].exp2048, plugin);
break;
default:
fail("unexpected DH group");
fail("unexpected key exchange method");
break;
}
}
ck_assert(!enumerator->enumerate(enumerator));
ck_assert_int_eq(dh_data[_i].data[i].g, MODP_NONE);
ck_assert_int_eq(ke_data[_i].data[i].ke, MODP_NONE);
enumerator->destroy(enumerator);
for (i = 0; dh_data[_i].data[i].g != MODP_NONE; i++)
for (i = 0; ke_data[_i].data[i].ke != MODP_NONE; i++)
{
factory->remove_dh(factory, dh_data[_i].data[i].create);
factory->remove_ke(factory, ke_data[_i].data[i].create);
}
factory->destroy(factory);
}
@@ -305,8 +305,8 @@ Suite *crypto_factory_suite_create()
tcase_add_loop_test(tc, test_create_rng, 0, countof(rng_data));
suite_add_tcase(s, tc);
tc = tcase_create("create_dh");
tcase_add_loop_test(tc, test_create_dh, 0, countof(dh_data));
tc = tcase_create("create_ke");
tcase_add_loop_test(tc, test_create_ke, 0, countof(ke_data));
suite_add_tcase(s, tc);
return s;
src/libstrongswan/tests/suites/test_ntru.c
+40 -40
View File
@@ -54,8 +54,8 @@ IMPORT_FUNCTION_FOR_TESTS(ntru, ntru_public_key_create_from_data, ntru_public_ke
* NTRU parameter sets to test
*/
static struct {
diffie_hellman_group_t group;
char *group_name;
key_exchange_method_t ke;
char *name;
} params[] = {
{ NTRU_112_BIT, "NTRU_112" },
{ NTRU_128_BIT, "NTRU_128" },
@@ -811,39 +811,39 @@ END_TEST
START_TEST(test_ntru_ke)
{
chunk_t pub_key, cipher_text, i_shared_secret, r_shared_secret;
diffie_hellman_t *i_ntru, *r_ntru;
key_exchange_t *i_ntru, *r_ntru;
char buf[10];
int k, n, len;
k = (_i) / countof(parameter_sets);
n = (_i) % countof(parameter_sets);
len = snprintf(buf, sizeof(buf), "%N", diffie_hellman_group_names,
params[k].group);
len = snprintf(buf, sizeof(buf), "%N", key_exchange_method_names,
params[k].ke);
ck_assert(len == 8);
ck_assert(streq(buf, params[k].group_name));
ck_assert(streq(buf, params[k].name));
lib->settings->set_str(lib->settings,
"libstrongswan.plugins.ntru.parameter_set", parameter_sets[n]);
i_ntru = lib->crypto->create_dh(lib->crypto, params[k].group);
i_ntru = lib->crypto->create_ke(lib->crypto, params[k].ke);
ck_assert(i_ntru != NULL);
ck_assert(i_ntru->get_dh_group(i_ntru) == params[k].group);
ck_assert(i_ntru->get_method(i_ntru) == params[k].ke);
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key));
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key));
ck_assert(pub_key.len > 0);
r_ntru = lib->crypto->create_dh(lib->crypto, params[k].group);
r_ntru = lib->crypto->create_ke(lib->crypto, params[k].ke);
ck_assert(r_ntru != NULL);
ck_assert(r_ntru->set_other_public_value(r_ntru, pub_key));
ck_assert(r_ntru->get_my_public_value(r_ntru, &cipher_text));
ck_assert(r_ntru->set_public_key(r_ntru, pub_key));
ck_assert(r_ntru->get_public_key(r_ntru, &cipher_text));
ck_assert(cipher_text.len > 0);
ck_assert(r_ntru->get_shared_secret(r_ntru, &r_shared_secret));
ck_assert(r_shared_secret.len > 0);
ck_assert(i_ntru->set_other_public_value(i_ntru, cipher_text));
ck_assert(i_ntru->set_public_key(i_ntru, cipher_text));
ck_assert(i_ntru->get_shared_secret(i_ntru, &i_shared_secret));
ck_assert(chunk_equals(i_shared_secret, r_shared_secret));
@@ -858,12 +858,12 @@ END_TEST
START_TEST(test_ntru_retransmission)
{
diffie_hellman_t *i_ntru;
key_exchange_t *i_ntru;
chunk_t pub_key1, pub_key2;
i_ntru = lib->crypto->create_dh(lib->crypto, NTRU_256_BIT);
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key1));
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key2));
i_ntru = lib->crypto->create_ke(lib->crypto, NTRU_256_BIT);
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key1));
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key2));
ck_assert(chunk_equals(pub_key1, pub_key2));
chunk_free(&pub_key1);
@@ -885,12 +885,12 @@ chunk_t oid_tests[] = {
START_TEST(test_ntru_pubkey_oid)
{
diffie_hellman_t *r_ntru;
key_exchange_t *r_ntru;
chunk_t cipher_text;
r_ntru = lib->crypto->create_dh(lib->crypto, NTRU_128_BIT);
ck_assert(!r_ntru->set_other_public_value(r_ntru, oid_tests[_i]));
ck_assert(r_ntru->get_my_public_value(r_ntru, &cipher_text));
r_ntru = lib->crypto->create_ke(lib->crypto, NTRU_128_BIT);
ck_assert(!r_ntru->set_public_key(r_ntru, oid_tests[_i]));
ck_assert(r_ntru->get_public_key(r_ntru, &cipher_text));
ck_assert(cipher_text.len == 0);
r_ntru->destroy(r_ntru);
}
@@ -898,21 +898,21 @@ END_TEST
START_TEST(test_ntru_wrong_set)
{
diffie_hellman_t *i_ntru, *r_ntru;
key_exchange_t *i_ntru, *r_ntru;
chunk_t pub_key, cipher_text;
lib->settings->set_str(lib->settings,
"libstrongswan.plugins.ntru.parameter_set",
"x9_98_bandwidth");
i_ntru = lib->crypto->create_dh(lib->crypto, NTRU_112_BIT);
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key));
i_ntru = lib->crypto->create_ke(lib->crypto, NTRU_112_BIT);
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key));
lib->settings->set_str(lib->settings,
"libstrongswan.plugins.ntru.parameter_set",
"optimum");
r_ntru = lib->crypto->create_dh(lib->crypto, NTRU_112_BIT);
ck_assert(!r_ntru->set_other_public_value(r_ntru, pub_key));
ck_assert(r_ntru->get_my_public_value(r_ntru, &cipher_text));
r_ntru = lib->crypto->create_ke(lib->crypto, NTRU_112_BIT);
ck_assert(!r_ntru->set_public_key(r_ntru, pub_key));
ck_assert(r_ntru->get_public_key(r_ntru, &cipher_text));
ck_assert(cipher_text.len == 0);
chunk_free(&pub_key);
@@ -933,7 +933,7 @@ START_TEST(test_ntru_ciphertext)
chunk_create(buf_ff, sizeof(buf_ff)),
};
diffie_hellman_t *i_ntru;
key_exchange_t *i_ntru;
chunk_t pub_key, shared_secret;
int i;
@@ -942,9 +942,9 @@ START_TEST(test_ntru_ciphertext)
for (i = 0; i < countof(test); i++)
{
i_ntru = lib->crypto->create_dh(lib->crypto, NTRU_128_BIT);
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key));
ck_assert(!i_ntru->set_other_public_value(i_ntru, test[i]));
i_ntru = lib->crypto->create_ke(lib->crypto, NTRU_128_BIT);
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key));
ck_assert(!i_ntru->set_public_key(i_ntru, test[i]));
ck_assert(!i_ntru->get_shared_secret(i_ntru, &shared_secret));
ck_assert(shared_secret.len == 0);
@@ -956,18 +956,18 @@ END_TEST
START_TEST(test_ntru_wrong_ciphertext)
{
diffie_hellman_t *i_ntru, *r_ntru, *m_ntru;
key_exchange_t *i_ntru, *r_ntru, *m_ntru;
chunk_t pub_key_i, pub_key_m, cipher_text, shared_secret;
i_ntru = lib->crypto->create_dh(lib->crypto, NTRU_128_BIT);
r_ntru = lib->crypto->create_dh(lib->crypto, NTRU_128_BIT);
m_ntru = lib->crypto->create_dh(lib->crypto, NTRU_128_BIT);
i_ntru = lib->crypto->create_ke(lib->crypto, NTRU_128_BIT);
r_ntru = lib->crypto->create_ke(lib->crypto, NTRU_128_BIT);
m_ntru = lib->crypto->create_ke(lib->crypto, NTRU_128_BIT);
ck_assert(i_ntru->get_my_public_value(i_ntru, &pub_key_i));
ck_assert(m_ntru->get_my_public_value(m_ntru, &pub_key_m));
ck_assert(r_ntru->set_other_public_value(r_ntru, pub_key_m));
ck_assert(r_ntru->get_my_public_value(r_ntru, &cipher_text));
ck_assert(!i_ntru->set_other_public_value(i_ntru, cipher_text));
ck_assert(i_ntru->get_public_key(i_ntru, &pub_key_i));
ck_assert(m_ntru->get_public_key(m_ntru, &pub_key_m));
ck_assert(r_ntru->set_public_key(r_ntru, pub_key_m));
ck_assert(r_ntru->get_public_key(r_ntru, &cipher_text));
ck_assert(!i_ntru->set_public_key(i_ntru, cipher_text));
ck_assert(!i_ntru->get_shared_secret(i_ntru, &shared_secret));
ck_assert(shared_secret.len == 0);
src/libstrongswan/tests/suites/test_proposal.c
+26 -26
View File
@@ -20,24 +20,24 @@
START_TEST(test_dh_group_mapping)
{
enum_name_t *e = diffie_hellman_group_names_short;
diffie_hellman_group_t group;
enum_name_t *e = key_exchange_method_names_short;
key_exchange_method_t ke;
const proposal_token_t *token;
char *name;
do
{
for (group = e->first; group <= e->last; group++)
for (ke = e->first; ke <= e->last; ke++)
{
if (group == MODP_CUSTOM)
if (ke == MODP_CUSTOM)
{ /* can't be configured */
continue;
}
name = e->names[group - e->first];
name = e->names[ke - e->first];
token = lib->proposal->get_token(lib->proposal, name);
ck_assert_msg(token, "%s can't be mapped", name);
ck_assert_int_eq(token->type, DIFFIE_HELLMAN_GROUP);
ck_assert_int_eq(token->algorithm, group);
ck_assert_int_eq(token->type, KEY_EXCHANGE_METHOD);
ck_assert_int_eq(token->algorithm, ke);
}
}
while ((e = e->next));
@@ -124,11 +124,11 @@ static struct {
{ PROTO_ESP, "aes128-aes256-sha1-sha256", "aes256-aes128-sha256-sha1", "aes128-sha1" },
{ PROTO_ESP, "aes256-aes128-sha256-sha1", "aes128-aes256-sha1-sha256", "aes256-sha256" },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256", NULL },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256", "aes128-sha256", PROPOSAL_SKIP_DH },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256", "aes128-sha256", PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-sha256", "aes128-sha256-modp3072", NULL },
{ PROTO_ESP, "aes128-sha256", "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_DH },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_DH },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-ecp256", "aes128-sha256", PROPOSAL_SKIP_DH },
{ PROTO_ESP, "aes128-sha256", "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-ecp256", "aes128-sha256", PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-modpnone", NULL },
{ PROTO_ESP, "aes128-sha256-modpnone", "aes128-sha256-modp3072", NULL },
{ PROTO_ESP, "aes128-sha256-modp3072-modpnone", "aes128-sha256", "aes128-sha256" },
@@ -246,10 +246,10 @@ static struct {
{ "aes256-modp2048", "aes128-modp2048" }, NULL },
{ PROTO_ESP, { "aes128-modp1024", "aes256-modp1024" },
{ "aes256-modp2048", "aes128-modp2048" }, "aes128",
PROPOSAL_SKIP_DH },
PROPOSAL_SKIP_KE },
{ PROTO_ESP, { "aes128-modp1024", "aes256-modp1024" },
{ "aes256-modp2048", "aes128-modp2048" }, "aes256",
PROPOSAL_PREFER_SUPPLIED | PROPOSAL_SKIP_DH },
PROPOSAL_PREFER_SUPPLIED | PROPOSAL_SKIP_KE },
};
START_TEST(test_select_proposal)
@@ -301,38 +301,38 @@ START_TEST(test_select_proposal)
}
END_TEST
START_TEST(test_promote_dh_group)
START_TEST(test_promote_ke_method)
{
proposal_t *proposal;
proposal = proposal_create_from_string(PROTO_IKE,
"aes128-sha256-modp3072-ecp256");
ck_assert(proposal->promote_dh_group(proposal, ECP_256_BIT));
ck_assert(proposal->promote_ke_method(proposal, ECP_256_BIT));
assert_proposal_eq(proposal, "IKE:AES_CBC_128/HMAC_SHA2_256_128/PRF_HMAC_SHA2_256/ECP_256/MODP_3072");
proposal->destroy(proposal);
}
END_TEST
START_TEST(test_promote_dh_group_already_front)
START_TEST(test_promote_ke_method_already_front)
{
proposal_t *proposal;
proposal = proposal_create_from_string(PROTO_IKE,
"aes128-sha256-modp3072-ecp256");
ck_assert(proposal->promote_dh_group(proposal, MODP_3072_BIT));
ck_assert(proposal->promote_ke_method(proposal, MODP_3072_BIT));
assert_proposal_eq(proposal, "IKE:AES_CBC_128/HMAC_SHA2_256_128/PRF_HMAC_SHA2_256/MODP_3072/ECP_256");
proposal->destroy(proposal);
}
END_TEST
START_TEST(test_promote_dh_group_not_contained)
START_TEST(test_promote_ke_method_not_contained)
{
proposal_t *proposal;
proposal = proposal_create_from_string(PROTO_IKE,
"aes128-sha256-modp3072-ecp256");
ck_assert(!proposal->promote_dh_group(proposal, MODP_2048_BIT));
ck_assert(!proposal->promote_ke_method(proposal, MODP_2048_BIT));
assert_proposal_eq(proposal, "IKE:AES_CBC_128/HMAC_SHA2_256_128/PRF_HMAC_SHA2_256/MODP_3072/ECP_256");
proposal->destroy(proposal);
}
@@ -447,11 +447,11 @@ static struct {
{ PROTO_ESP, "aes128-serpent", "aes128-serpent" },
{ PROTO_ESP, "aes128-serpent", "aes128", PROPOSAL_SKIP_PRIVATE },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256-modp3072" },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_DH },
{ PROTO_ESP, "aes128-sha256-modp3072", "aes128-sha256", PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-serpent-modp3072", "aes128-serpent",
PROPOSAL_SKIP_DH },
PROPOSAL_SKIP_KE },
{ PROTO_ESP, "aes128-serpent-modp3072", "aes128",
PROPOSAL_SKIP_PRIVATE | PROPOSAL_SKIP_DH },
PROPOSAL_SKIP_PRIVATE | PROPOSAL_SKIP_KE },
};
START_TEST(test_clone)
@@ -505,10 +505,10 @@ Suite *proposal_suite_create()
countof(select_proposal_data));
suite_add_tcase(s, tc);
tc = tcase_create("promote_dh_group");
tcase_add_test(tc, test_promote_dh_group);
tcase_add_test(tc, test_promote_dh_group_already_front);
tcase_add_test(tc, test_promote_dh_group_not_contained);
tc = tcase_create("promote_ke_method");
tcase_add_test(tc, test_promote_ke_method);
tcase_add_test(tc, test_promote_ke_method_already_front);
tcase_add_test(tc, test_promote_ke_method_not_contained);
suite_add_tcase(s, tc);
tc = tcase_create("unknown transform types");
src/libstrongswan/tests/suites/test_vectors.c
+1 -1
View File
@@ -31,7 +31,7 @@ static transform_type_t tfs[] = {
KEY_DERIVATION_FUNCTION,
DETERMINISTIC_RANDOM_BIT_GENERATOR,
RANDOM_NUMBER_GENERATOR,
DIFFIE_HELLMAN_GROUP,
KEY_EXCHANGE_METHOD,
};
START_TEST(test_vectors)
src/libstrongswan/tests/tests.h
+1 -1
View File
@@ -57,7 +57,7 @@ TEST_SUITE(rng_tester_suite_create)
TEST_SUITE_DEPEND(mgf1_sha1_suite_create, XOF, XOF_MGF1_SHA1)
TEST_SUITE_DEPEND(mgf1_sha256_suite_create, XOF, XOF_MGF1_SHA256)
TEST_SUITE_DEPEND(prf_plus_suite_create, KDF, KDF_PRF_PLUS)
TEST_SUITE_DEPEND(ntru_suite_create, DH, NTRU_112_BIT)
TEST_SUITE_DEPEND(ntru_suite_create, KE, NTRU_112_BIT)
TEST_SUITE_DEPEND(fetch_http_suite_create, FETCHER, "http://")
TEST_SUITE_DEPEND(ed25519_suite_create, PRIVKEY_GEN, KEY_ED25519)
TEST_SUITE_DEPEND(ed448_suite_create, PRIVKEY_GEN, KEY_ED448)