summaryrefslogtreecommitdiff
path: root/src/libstrongswan/crypto
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstrongswan/crypto')
-rw-r--r--src/libstrongswan/crypto/crypto_factory.c200
-rw-r--r--src/libstrongswan/crypto/crypto_factory.h71
-rw-r--r--src/libstrongswan/crypto/crypto_tester.c211
-rw-r--r--src/libstrongswan/crypto/crypto_tester.h28
4 files changed, 510 insertions, 0 deletions
diff --git a/src/libstrongswan/crypto/crypto_factory.c b/src/libstrongswan/crypto/crypto_factory.c
index f2f01987d..96b4630f7 100644
--- a/src/libstrongswan/crypto/crypto_factory.c
+++ b/src/libstrongswan/crypto/crypto_factory.c
@@ -20,6 +20,7 @@
#include <utils/linked_list.h>
#include <crypto/crypto_tester.h>
+<<<<<<< HEAD
typedef struct entry_t entry_t;
struct entry_t {
/* algorithm */
@@ -27,6 +28,31 @@ struct entry_t {
/* benchmarked speed */
u_int speed;
/* constructor */
+=======
+const char *default_plugin_name = "default";
+
+typedef struct entry_t entry_t;
+
+struct entry_t {
+ /**
+ * algorithm
+ */
+ u_int algo;
+
+ /**
+ * plugin that registered this algorithm
+ */
+ const char *plugin_name;
+
+ /**
+ * benchmarked speed
+ */
+ u_int speed;
+
+ /**
+ * constructor
+ */
+>>>>>>> upstream/4.5.1
union {
crypter_constructor_t create_crypter;
aead_constructor_t create_aead;
@@ -128,7 +154,12 @@ METHOD(crypto_factory_t, create_crypter, crypter_t*,
{
if (this->test_on_create &&
!this->tester->test_crypter(this->tester, algo, key_size,
+<<<<<<< HEAD
entry->create_crypter, NULL))
+=======
+ entry->create_crypter, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -160,7 +191,12 @@ METHOD(crypto_factory_t, create_aead, aead_t*,
{
if (this->test_on_create &&
!this->tester->test_aead(this->tester, algo, key_size,
+<<<<<<< HEAD
entry->create_aead, NULL))
+=======
+ entry->create_aead, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -191,7 +227,12 @@ METHOD(crypto_factory_t, create_signer, signer_t*,
{
if (this->test_on_create &&
!this->tester->test_signer(this->tester, algo,
+<<<<<<< HEAD
entry->create_signer, NULL))
+=======
+ entry->create_signer, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -223,7 +264,12 @@ METHOD(crypto_factory_t, create_hasher, hasher_t*,
{
if (this->test_on_create && algo != HASH_PREFERRED &&
!this->tester->test_hasher(this->tester, algo,
+<<<<<<< HEAD
entry->create_hasher, NULL))
+=======
+ entry->create_hasher, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -254,7 +300,12 @@ METHOD(crypto_factory_t, create_prf, prf_t*,
{
if (this->test_on_create &&
!this->tester->test_prf(this->tester, algo,
+<<<<<<< HEAD
entry->create_prf, NULL))
+=======
+ entry->create_prf, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -286,7 +337,12 @@ METHOD(crypto_factory_t, create_rng, rng_t*,
{
if (this->test_on_create &&
!this->tester->test_rng(this->tester, quality,
+<<<<<<< HEAD
entry->create_rng, NULL))
+=======
+ entry->create_rng, NULL,
+ default_plugin_name))
+>>>>>>> upstream/4.5.1
{
continue;
}
@@ -350,7 +406,12 @@ METHOD(crypto_factory_t, create_dh, diffie_hellman_t*,
* Insert an algorithm entry to a list
*/
static void add_entry(private_crypto_factory_t *this, linked_list_t *list,
+<<<<<<< HEAD
int algo, u_int speed, void *create)
+=======
+ int algo, const char *plugin_name,
+ u_int speed, void *create)
+>>>>>>> upstream/4.5.1
{
entry_t *entry, *current;
linked_list_t *tmp;
@@ -358,6 +419,10 @@ static void add_entry(private_crypto_factory_t *this, linked_list_t *list,
INIT(entry,
.algo = algo,
+<<<<<<< HEAD
+=======
+ .plugin_name = plugin_name,
+>>>>>>> upstream/4.5.1
.speed = speed,
);
entry->create = create;
@@ -391,16 +456,27 @@ static void add_entry(private_crypto_factory_t *this, linked_list_t *list,
}
METHOD(crypto_factory_t, add_crypter, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, encryption_algorithm_t algo,
crypter_constructor_t create)
+=======
+ private_crypto_factory_t *this, encryption_algorithm_t algo,
+ const char *plugin_name, crypter_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_crypter(this->tester, algo, 0, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->crypters, algo, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->crypters, algo, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -425,16 +501,27 @@ METHOD(crypto_factory_t, remove_crypter, void,
}
METHOD(crypto_factory_t, add_aead, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, encryption_algorithm_t algo,
aead_constructor_t create)
+=======
+ private_crypto_factory_t *this, encryption_algorithm_t algo,
+ const char *plugin_name, aead_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_aead(this->tester, algo, 0, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->aeads, algo, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->aeads, algo, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -459,16 +546,27 @@ METHOD(crypto_factory_t, remove_aead, void,
}
METHOD(crypto_factory_t, add_signer, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, integrity_algorithm_t algo,
signer_constructor_t create)
+=======
+ private_crypto_factory_t *this, integrity_algorithm_t algo,
+ const char *plugin_name, signer_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_signer(this->tester, algo, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->signers, algo, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->signers, algo, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -493,16 +591,27 @@ METHOD(crypto_factory_t, remove_signer, void,
}
METHOD(crypto_factory_t, add_hasher, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, hash_algorithm_t algo,
hasher_constructor_t create)
+=======
+ private_crypto_factory_t *this, hash_algorithm_t algo,
+ const char *plugin_name, hasher_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_hasher(this->tester, algo, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->hashers, algo, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->hashers, algo, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -527,16 +636,27 @@ METHOD(crypto_factory_t, remove_hasher, void,
}
METHOD(crypto_factory_t, add_prf, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, pseudo_random_function_t algo,
prf_constructor_t create)
+=======
+ private_crypto_factory_t *this, pseudo_random_function_t algo,
+ const char *plugin_name, prf_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_prf(this->tester, algo, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->prfs, algo, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->prfs, algo, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -562,15 +682,25 @@ METHOD(crypto_factory_t, remove_prf, void,
METHOD(crypto_factory_t, add_rng, void,
private_crypto_factory_t *this, rng_quality_t quality,
+<<<<<<< HEAD
rng_constructor_t create)
+=======
+ const char *plugin_name, rng_constructor_t create)
+>>>>>>> upstream/4.5.1
{
u_int speed = 0;
if (!this->test_on_add ||
this->tester->test_rng(this->tester, quality, create,
+<<<<<<< HEAD
this->bench ? &speed : NULL))
{
add_entry(this, this->rngs, quality, speed, create);
+=======
+ this->bench ? &speed : NULL, plugin_name))
+ {
+ add_entry(this, this->rngs, quality, plugin_name, speed, create);
+>>>>>>> upstream/4.5.1
}
}
@@ -595,10 +725,17 @@ METHOD(crypto_factory_t, remove_rng, void,
}
METHOD(crypto_factory_t, add_dh, void,
+<<<<<<< HEAD
private_crypto_factory_t *this, diffie_hellman_group_t group,
dh_constructor_t create)
{
add_entry(this, this->dhs, group, 0, create);
+=======
+ private_crypto_factory_t *this, diffie_hellman_group_t group,
+ const char *plugin_name, dh_constructor_t create)
+{
+ add_entry(this, this->dhs, group, plugin_name, 0, create);
+>>>>>>> upstream/4.5.1
}
METHOD(crypto_factory_t, remove_dh, void,
@@ -660,9 +797,17 @@ static enumerator_t *create_enumerator(private_crypto_factory_t *this,
/**
* Filter function to enumerate algorithm, not entry
*/
+<<<<<<< HEAD
static bool crypter_filter(void *n, entry_t **entry, encryption_algorithm_t *algo)
{
*algo = (*entry)->algo;
+=======
+static bool crypter_filter(void *n, entry_t **entry, encryption_algorithm_t *algo,
+ void *i2, const char **plugin_name)
+{
+ *algo = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -681,9 +826,17 @@ METHOD(crypto_factory_t, create_aead_enumerator, enumerator_t*,
/**
* Filter function to enumerate algorithm, not entry
*/
+<<<<<<< HEAD
static bool signer_filter(void *n, entry_t **entry, integrity_algorithm_t *algo)
{
*algo = (*entry)->algo;
+=======
+static bool signer_filter(void *n, entry_t **entry, integrity_algorithm_t *algo,
+ void *i2, const char **plugin_name)
+{
+ *algo = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -696,9 +849,17 @@ METHOD(crypto_factory_t, create_signer_enumerator, enumerator_t*,
/**
* Filter function to enumerate algorithm, not entry
*/
+<<<<<<< HEAD
static bool hasher_filter(void *n, entry_t **entry, hash_algorithm_t *algo)
{
*algo = (*entry)->algo;
+=======
+static bool hasher_filter(void *n, entry_t **entry, hash_algorithm_t *algo,
+ void *i2, const char **plugin_name)
+{
+ *algo = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -711,9 +872,17 @@ METHOD(crypto_factory_t, create_hasher_enumerator, enumerator_t*,
/**
* Filter function to enumerate algorithm, not entry
*/
+<<<<<<< HEAD
static bool prf_filter(void *n, entry_t **entry, pseudo_random_function_t *algo)
{
*algo = (*entry)->algo;
+=======
+static bool prf_filter(void *n, entry_t **entry, pseudo_random_function_t *algo,
+ void *i2, const char **plugin_name)
+{
+ *algo = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -726,9 +895,17 @@ METHOD(crypto_factory_t, create_prf_enumerator, enumerator_t*,
/**
* Filter function to enumerate algorithm, not entry
*/
+<<<<<<< HEAD
static bool dh_filter(void *n, entry_t **entry, diffie_hellman_group_t *group)
{
*group = (*entry)->algo;
+=======
+static bool dh_filter(void *n, entry_t **entry, diffie_hellman_group_t *group,
+ void *i2, const char **plugin_name)
+{
+ *group = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -738,6 +915,25 @@ METHOD(crypto_factory_t, create_dh_enumerator, enumerator_t*,
return create_enumerator(this, this->dhs, dh_filter);
}
+<<<<<<< HEAD
+=======
+/**
+ * Filter function to enumerate algorithm, not entry
+ */
+static bool rng_filter(void *n, entry_t **entry, rng_quality_t *quality,
+ void *i2, const char **plugin_name)
+{
+ *quality = (*entry)->algo;
+ *plugin_name = (*entry)->plugin_name;
+ return TRUE;
+}
+
+METHOD(crypto_factory_t, create_rng_enumerator, enumerator_t*,
+ private_crypto_factory_t *this)
+{
+ return create_enumerator(this, this->rngs, rng_filter);
+}
+>>>>>>> upstream/4.5.1
METHOD(crypto_factory_t, add_test_vector, void,
private_crypto_factory_t *this, transform_type_t type, void *vector)
{
@@ -812,6 +1008,10 @@ crypto_factory_t *crypto_factory_create()
.create_hasher_enumerator = _create_hasher_enumerator,
.create_prf_enumerator = _create_prf_enumerator,
.create_dh_enumerator = _create_dh_enumerator,
+<<<<<<< HEAD
+=======
+ .create_rng_enumerator = _create_rng_enumerator,
+>>>>>>> upstream/4.5.1
.add_test_vector = _add_test_vector,
.destroy = _destroy,
},
diff --git a/src/libstrongswan/crypto/crypto_factory.h b/src/libstrongswan/crypto/crypto_factory.h
index ff06eda7b..61c46b59c 100644
--- a/src/libstrongswan/crypto/crypto_factory.h
+++ b/src/libstrongswan/crypto/crypto_factory.h
@@ -33,6 +33,11 @@ typedef struct crypto_factory_t crypto_factory_t;
#include <crypto/diffie_hellman.h>
#include <crypto/transform.h>
+<<<<<<< HEAD
+=======
+#define CRYPTO_MAX_ALG_LINE 120 /* characters */
+
+>>>>>>> upstream/4.5.1
/**
* Constructor function for crypters
*/
@@ -144,11 +149,19 @@ struct crypto_factory_t {
* Register a crypter constructor.
*
* @param algo algorithm to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_crypter)(crypto_factory_t *this, encryption_algorithm_t algo,
+<<<<<<< HEAD
crypter_constructor_t create);
+=======
+ const char *plugin_name, crypter_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a crypter constructor.
@@ -168,21 +181,37 @@ struct crypto_factory_t {
* Register a aead constructor.
*
* @param algo algorithm to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_aead)(crypto_factory_t *this, encryption_algorithm_t algo,
+<<<<<<< HEAD
aead_constructor_t create);
+=======
+ const char *plugin_name, aead_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Register a signer constructor.
*
* @param algo algorithm to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_signer)(crypto_factory_t *this, integrity_algorithm_t algo,
+<<<<<<< HEAD
signer_constructor_t create);
+=======
+ const char *plugin_name, signer_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a signer constructor.
@@ -198,11 +227,19 @@ struct crypto_factory_t {
* create_hasher(HASH_PREFERRED).
*
* @param algo algorithm to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_hasher)(crypto_factory_t *this, hash_algorithm_t algo,
+<<<<<<< HEAD
hasher_constructor_t create);
+=======
+ const char *plugin_name, hasher_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a hasher constructor.
@@ -215,11 +252,19 @@ struct crypto_factory_t {
* Register a prf constructor.
*
* @param algo algorithm to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_prf)(crypto_factory_t *this, pseudo_random_function_t algo,
+<<<<<<< HEAD
prf_constructor_t create);
+=======
+ const char *plugin_name, prf_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a prf constructor.
@@ -232,9 +277,17 @@ struct crypto_factory_t {
* Register a source of randomness.
*
* @param quality quality of randomness this RNG serves
+<<<<<<< HEAD
* @param create constructor function for such a quality
*/
void (*add_rng)(crypto_factory_t *this, rng_quality_t quality, rng_constructor_t create);
+=======
+ * @param plugin_name plugin that registered this algorithm
+ * @param create constructor function for such a quality
+ */
+ void (*add_rng)(crypto_factory_t *this, rng_quality_t quality,
+ const char *plugin_name, rng_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a source of randomness.
@@ -247,11 +300,19 @@ struct crypto_factory_t {
* Register a diffie hellman constructor.
*
* @param group dh group to constructor
+<<<<<<< HEAD
+=======
+ * @param plugin_name plugin that registered this algorithm
+>>>>>>> upstream/4.5.1
* @param create constructor function for that algorithm
* @return
*/
void (*add_dh)(crypto_factory_t *this, diffie_hellman_group_t group,
+<<<<<<< HEAD
dh_constructor_t create);
+=======
+ const char *plugin_name, dh_constructor_t create);
+>>>>>>> upstream/4.5.1
/**
* Unregister a diffie hellman constructor.
@@ -303,6 +364,16 @@ struct crypto_factory_t {
enumerator_t* (*create_dh_enumerator)(crypto_factory_t *this);
/**
+<<<<<<< HEAD
+=======
+ * Create an enumerator over all registered random generators.
+ *
+ * @return enumerator over rng_quality_t
+ */
+ enumerator_t* (*create_rng_enumerator)(crypto_factory_t *this);
+
+ /**
+>>>>>>> upstream/4.5.1
* Add a test vector to the crypto factory.
*
* @param type type of the test vector
diff --git a/src/libstrongswan/crypto/crypto_tester.c b/src/libstrongswan/crypto/crypto_tester.c
index d17485ff2..d4a8728e2 100644
--- a/src/libstrongswan/crypto/crypto_tester.c
+++ b/src/libstrongswan/crypto/crypto_tester.c
@@ -165,7 +165,11 @@ static u_int bench_crypter(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_crypter, bool,
private_crypto_tester_t *this, encryption_algorithm_t alg, size_t key_size,
+<<<<<<< HEAD
crypter_constructor_t create, u_int *speed)
+=======
+ crypter_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
crypter_test_vector_t *vector;
@@ -188,7 +192,15 @@ METHOD(crypto_tester_t, test_crypter, bool,
}
crypter = create(alg, vector->key_size);
if (!crypter)
+<<<<<<< HEAD
{ /* key size not supported... */
+=======
+ {
+ DBG1(DBG_LIB, "%N[%s]: %u bit key size not supported",
+ encryption_algorithm_names, alg, plugin_name,
+ BITS_PER_BYTE * vector->key_size);
+ failed = TRUE;
+>>>>>>> upstream/4.5.1
continue;
}
@@ -231,24 +243,46 @@ METHOD(crypto_tester_t, test_crypter, bool,
crypter->destroy(crypter);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
encryption_algorithm_names, alg, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ encryption_algorithm_names, alg, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
encryption_algorithm_names, alg);
return !this->required;
+=======
+ if (failed)
+ {
+ DBG1(DBG_LIB,"disable %N[%s]: no key size supported",
+ encryption_algorithm_names, alg, plugin_name);
+ return FALSE;
+ }
+ else
+ {
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? "disabled" : "enabled ",
+ encryption_algorithm_names, alg, plugin_name);
+ return !this->required;
+ }
+>>>>>>> upstream/4.5.1
}
if (!failed)
{
if (speed)
{
*speed = bench_crypter(this, alg, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
encryption_algorithm_names, alg, tested, *speed);
}
@@ -256,6 +290,15 @@ METHOD(crypto_tester_t, test_crypter, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
encryption_algorithm_names, alg, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ encryption_algorithm_names, alg, tested, plugin_name, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ encryption_algorithm_names, alg, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
@@ -311,7 +354,11 @@ static u_int bench_aead(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_aead, bool,
private_crypto_tester_t *this, encryption_algorithm_t alg, size_t key_size,
+<<<<<<< HEAD
aead_constructor_t create, u_int *speed)
+=======
+ aead_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
aead_test_vector_t *vector;
@@ -335,7 +382,15 @@ METHOD(crypto_tester_t, test_aead, bool,
}
aead = create(alg, vector->key_size);
if (!aead)
+<<<<<<< HEAD
{ /* key size not supported... */
+=======
+ {
+ DBG1(DBG_LIB, "%N[%s]: %u bit key size not supported",
+ encryption_algorithm_names, alg, plugin_name,
+ BITS_PER_BYTE * vector->key_size);
+ failed = TRUE;
+>>>>>>> upstream/4.5.1
continue;
}
@@ -388,24 +443,46 @@ METHOD(crypto_tester_t, test_aead, bool,
aead->destroy(aead);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
encryption_algorithm_names, alg, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ encryption_algorithm_names, alg, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
encryption_algorithm_names, alg);
return !this->required;
+=======
+ if (failed)
+ {
+ DBG1(DBG_LIB,"disable %N[%s]: no key size supported",
+ encryption_algorithm_names, alg, plugin_name);
+ return FALSE;
+ }
+ else
+ {
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? "disabled" : "enabled ",
+ encryption_algorithm_names, alg, plugin_name);
+ return !this->required;
+ }
+>>>>>>> upstream/4.5.1
}
if (!failed)
{
if (speed)
{
*speed = bench_aead(this, alg, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
encryption_algorithm_names, alg, tested, *speed);
}
@@ -413,6 +490,15 @@ METHOD(crypto_tester_t, test_aead, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
encryption_algorithm_names, alg, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ encryption_algorithm_names, alg, plugin_name, tested, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ encryption_algorithm_names, alg, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
@@ -460,7 +546,11 @@ static u_int bench_signer(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_signer, bool,
private_crypto_tester_t *this, integrity_algorithm_t alg,
+<<<<<<< HEAD
signer_constructor_t create, u_int *speed)
+=======
+ signer_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
signer_test_vector_t *vector;
@@ -482,8 +572,13 @@ METHOD(crypto_tester_t, test_signer, bool,
signer = create(alg);
if (!signer)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: creating instance failed",
integrity_algorithm_names, alg);
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
+ integrity_algorithm_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
failed = TRUE;
break;
}
@@ -538,17 +633,28 @@ METHOD(crypto_tester_t, test_signer, bool,
signer->destroy(signer);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
integrity_algorithm_names, alg, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ integrity_algorithm_names, alg, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
integrity_algorithm_names, alg);
+=======
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? "disabled" : "enabled ",
+ integrity_algorithm_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
return !this->required;
}
if (!failed)
@@ -556,6 +662,7 @@ METHOD(crypto_tester_t, test_signer, bool,
if (speed)
{
*speed = bench_signer(this, alg, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
integrity_algorithm_names, alg, tested, *speed);
}
@@ -563,6 +670,15 @@ METHOD(crypto_tester_t, test_signer, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
integrity_algorithm_names, alg, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ integrity_algorithm_names, alg, plugin_name, tested, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ integrity_algorithm_names, alg, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
@@ -604,7 +720,11 @@ static u_int bench_hasher(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_hasher, bool,
private_crypto_tester_t *this, hash_algorithm_t alg,
+<<<<<<< HEAD
hasher_constructor_t create, u_int *speed)
+=======
+ hasher_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
hasher_test_vector_t *vector;
@@ -626,8 +746,13 @@ METHOD(crypto_tester_t, test_hasher, bool,
hasher = create(alg);
if (!hasher)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: creating instance failed",
hash_algorithm_names, alg);
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
+ hash_algorithm_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
failed = TRUE;
break;
}
@@ -669,17 +794,28 @@ METHOD(crypto_tester_t, test_hasher, bool,
hasher->destroy(hasher);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
hash_algorithm_names, alg, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ hash_algorithm_names, alg, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
hash_algorithm_names, alg);
+=======
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? "disabled" : "enabled ",
+ hash_algorithm_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
return !this->required;
}
if (!failed)
@@ -687,6 +823,7 @@ METHOD(crypto_tester_t, test_hasher, bool,
if (speed)
{
*speed = bench_hasher(this, alg, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
hash_algorithm_names, alg, tested, *speed);
}
@@ -694,6 +831,15 @@ METHOD(crypto_tester_t, test_hasher, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
hash_algorithm_names, alg, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ hash_algorithm_names, alg, plugin_name, tested, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ hash_algorithm_names, alg, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
@@ -735,7 +881,11 @@ static u_int bench_prf(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_prf, bool,
private_crypto_tester_t *this, pseudo_random_function_t alg,
+<<<<<<< HEAD
prf_constructor_t create, u_int *speed)
+=======
+ prf_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
prf_test_vector_t *vector;
@@ -757,8 +907,13 @@ METHOD(crypto_tester_t, test_prf, bool,
prf = create(alg);
if (!prf)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: creating instance failed",
pseudo_random_function_names, alg);
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
+ pseudo_random_function_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
failed = TRUE;
break;
}
@@ -811,17 +966,28 @@ METHOD(crypto_tester_t, test_prf, bool,
prf->destroy(prf);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
pseudo_random_function_names, alg, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ pseudo_random_function_names, alg, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
pseudo_random_function_names, alg);
+=======
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? "disabled" : "enabled ",
+ pseudo_random_function_names, alg, plugin_name);
+>>>>>>> upstream/4.5.1
return !this->required;
}
if (!failed)
@@ -829,6 +995,7 @@ METHOD(crypto_tester_t, test_prf, bool,
if (speed)
{
*speed = bench_prf(this, alg, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
pseudo_random_function_names, alg, tested, *speed);
}
@@ -836,6 +1003,15 @@ METHOD(crypto_tester_t, test_prf, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
pseudo_random_function_names, alg, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ pseudo_random_function_names, alg, plugin_name, tested, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ pseudo_random_function_names, alg, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
@@ -874,7 +1050,11 @@ static u_int bench_rng(private_crypto_tester_t *this,
METHOD(crypto_tester_t, test_rng, bool,
private_crypto_tester_t *this, rng_quality_t quality,
+<<<<<<< HEAD
rng_constructor_t create, u_int *speed)
+=======
+ rng_constructor_t create, u_int *speed, const char *plugin_name)
+>>>>>>> upstream/4.5.1
{
enumerator_t *enumerator;
rng_test_vector_t *vector;
@@ -883,8 +1063,13 @@ METHOD(crypto_tester_t, test_rng, bool,
if (!this->rng_true && quality == RNG_TRUE)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: skipping test (disabled by config)",
rng_quality_names, quality);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: skipping test (disabled by config)",
+ rng_quality_names, quality, plugin_name);
+>>>>>>> upstream/4.5.1
return TRUE;
}
@@ -903,8 +1088,13 @@ METHOD(crypto_tester_t, test_rng, bool,
rng = create(quality);
if (!rng)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: creating instance failed",
rng_quality_names, quality);
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: creating instance failed",
+ rng_quality_names, quality, plugin_name);
+>>>>>>> upstream/4.5.1
failed = TRUE;
break;
}
@@ -933,17 +1123,28 @@ METHOD(crypto_tester_t, test_rng, bool,
rng->destroy(rng);
if (failed)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "disabled %N: %s test vector failed",
rng_quality_names, quality, get_name(vector));
+=======
+ DBG1(DBG_LIB, "disabled %N[%s]: %s test vector failed",
+ rng_quality_names, quality, plugin_name, get_name(vector));
+>>>>>>> upstream/4.5.1
break;
}
}
enumerator->destroy(enumerator);
if (!tested)
{
+<<<<<<< HEAD
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? ", disabled" : "enabled ",
rng_quality_names, quality);
+=======
+ DBG1(DBG_LIB, "%s %N[%s]: no test vectors found",
+ this->required ? ", disabled" : "enabled ",
+ rng_quality_names, quality, plugin_name);
+>>>>>>> upstream/4.5.1
return !this->required;
}
if (!failed)
@@ -951,6 +1152,7 @@ METHOD(crypto_tester_t, test_rng, bool,
if (speed)
{
*speed = bench_rng(this, quality, create);
+<<<<<<< HEAD
DBG1(DBG_LIB, "enabled %N: passed %u test vectors, %d points",
rng_quality_names, quality, tested, *speed);
}
@@ -958,6 +1160,15 @@ METHOD(crypto_tester_t, test_rng, bool,
{
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
rng_quality_names, quality, tested);
+=======
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors, %d points",
+ rng_quality_names, quality, plugin_name, tested, *speed);
+ }
+ else
+ {
+ DBG1(DBG_LIB, "enabled %N[%s]: passed %u test vectors",
+ rng_quality_names, quality, plugin_name, tested);
+>>>>>>> upstream/4.5.1
}
}
return !failed;
diff --git a/src/libstrongswan/crypto/crypto_tester.h b/src/libstrongswan/crypto/crypto_tester.h
index cef0b3c18..1354bec52 100644
--- a/src/libstrongswan/crypto/crypto_tester.h
+++ b/src/libstrongswan/crypto/crypto_tester.h
@@ -143,7 +143,11 @@ struct crypto_tester_t {
*/
bool (*test_crypter)(crypto_tester_t *this, encryption_algorithm_t alg,
size_t key_size, crypter_constructor_t create,
+<<<<<<< HEAD
u_int *speed);
+=======
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Test an aead algorithm, optionally using a specified key size.
@@ -156,7 +160,11 @@ struct crypto_tester_t {
*/
bool (*test_aead)(crypto_tester_t *this, encryption_algorithm_t alg,
size_t key_size, aead_constructor_t create,
+<<<<<<< HEAD
u_int *speed);
+=======
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Test a signer algorithm.
*
@@ -166,7 +174,12 @@ struct crypto_tester_t {
* @return TRUE if test passed
*/
bool (*test_signer)(crypto_tester_t *this, integrity_algorithm_t alg,
+<<<<<<< HEAD
signer_constructor_t create, u_int *speed);
+=======
+ signer_constructor_t create,
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Test a hasher algorithm.
*
@@ -176,7 +189,12 @@ struct crypto_tester_t {
* @return TRUE if test passed
*/
bool (*test_hasher)(crypto_tester_t *this, hash_algorithm_t alg,
+<<<<<<< HEAD
hasher_constructor_t create, u_int *speed);
+=======
+ hasher_constructor_t create,
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Test a PRF algorithm.
*
@@ -186,7 +204,12 @@ struct crypto_tester_t {
* @return TRUE if test passed
*/
bool (*test_prf)(crypto_tester_t *this, pseudo_random_function_t alg,
+<<<<<<< HEAD
prf_constructor_t create, u_int *speed);
+=======
+ prf_constructor_t create,
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Test a RNG implementation.
*
@@ -196,7 +219,12 @@ struct crypto_tester_t {
* @return TRUE if test passed
*/
bool (*test_rng)(crypto_tester_t *this, rng_quality_t quality,
+<<<<<<< HEAD
rng_constructor_t create, u_int *speed);
+=======
+ rng_constructor_t create,
+ u_int *speed, const char *plugin_name);
+>>>>>>> upstream/4.5.1
/**
* Add a test vector to test a crypter.
*
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-19 10:43:48 +0000