From b929f7b5768f8d9b0dde5062059a365c0df88494 Mon Sep 17 00:00:00 2001 From: Stef Walter Date: Thu, 4 Dec 2008 20:57:31 +0000 Subject: Implement initialize testing. --- src/module.c | 247 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/p11-tests.c | 1 + src/p11-tests.h | 3 + 3 files changed, 251 insertions(+) diff --git a/src/module.c b/src/module.c index 9815c21..8677c22 100644 --- a/src/module.c +++ b/src/module.c @@ -4,9 +4,142 @@ #include "p11-tests.h" #include +#include +#include +#include +#include static void *module = NULL; CK_FUNCTION_LIST_PTR p11_funcs = NULL; +static CK_C_INITIALIZE_ARGS init_args; +static int is_initialized = 0; + +static CK_RV +create_mutex(void **mutex) +{ + pthread_mutex_t *mut; + + if(!mutex) + { + p11t_msg_print("null mutex passed to create_mutex"); + return CKR_ARGUMENTS_BAD; + } + + mut = malloc(sizeof(pthread_mutex_t)); + assert(mut); + + if(pthread_mutex_init(mut, NULL) != 0) + assert(0); + *mutex = mut; + return CKR_OK; +} + +static CK_RV +destroy_mutex (void *mutex) +{ + int res; + + if(!mutex) + { + p11t_msg_print("destroying null mutex"); + return CKR_MUTEX_BAD; + } + + res = pthread_mutex_destroy(mutex); + if(res != 0) + { + if(res == EBUSY) + { + p11t_msg_print("trying to destroy locked mutex"); + return CKR_GENERAL_ERROR; + } + else if(res == EINVAL) + { + p11t_msg_print("destroying invalid mutex used"); + return CKR_MUTEX_BAD; + } + else + { + p11t_msg_print("couldn't destroy mutex: %d", res); + return CKR_GENERAL_ERROR; + + } + } + + return CKR_OK; +} + +static CK_RV +lock_mutex (void *mutex) +{ + int res; + if (!mutex) + { + p11t_msg_print("locking null mutex"); + return CKR_MUTEX_BAD; + } + + res = pthread_mutex_lock(mutex); + if(res != 0) + { + if(res == EDEADLK) + { + p11t_msg_print("locking mutex would deadlock"); + return CKR_CANT_LOCK; + } + else if(res == EINVAL) + { + p11t_msg_print("locking invalid mutex used"); + return CKR_MUTEX_BAD; + } + else + { + p11t_msg_print("couldn't lock mutex: %d", res); + return CKR_GENERAL_ERROR; + + } + } + + return CKR_OK; +} + +static CK_RV +unlock_mutex (void *mutex) +{ + int res; + if (!mutex) + { + p11t_msg_print("unlocking null mutex"); + return CKR_MUTEX_BAD; + } + + res = pthread_mutex_lock(mutex); + if(res != 0) + { + if(res == EPERM) + { + p11t_msg_print("unlocking mutex without locked"); + return CKR_MUTEX_NOT_LOCKED; + } + else if(res == EINVAL) + { + p11t_msg_print("unlocking invalid mutex used"); + return CKR_MUTEX_BAD; + } + else + { + p11t_msg_print("couldn't unlock mutex: %d", res); + return CKR_GENERAL_ERROR; + + } + } + else + { + free(mutex); + } + + return CKR_OK; +} void p11t_module_load(const char *filename) @@ -35,6 +168,120 @@ p11t_module_load(const char *filename) (int)p11_funcs->version.minor); } +static void +initialize_common(const char *mode) +{ + CK_RV rv; + + assert(p11_funcs); + + rv = (p11_funcs->C_Initialize) (&init_args); + if (rv != CKR_OK) + { + if(rv != CKR_CANT_LOCK) + p11t_msg_print("C_Initialize failed (%s): %s", mode, p11t_msg_rv(rv)); + } + else + { + is_initialized = 1; + } +} + +static void +initialize_locking_1(const char *initstr) +{ + memset(&init_args, 0, sizeof (init_args)); + init_args.pReserved = (void*)initstr; + initialize_common("locking mode 1: no threads"); +} + +static void +initialize_locking_2(const char *initstr) +{ + memset(&init_args, 0, sizeof (init_args)); + init_args.flags = CKF_OS_LOCKING_OK; + init_args.pReserved = (void*)initstr; + initialize_common("locking mode 2: os locking"); +} + +static void +initialize_locking_3(const char *initstr) +{ + memset(&init_args, 0, sizeof (init_args)); + init_args.flags = 0; + init_args.CreateMutex = create_mutex; + init_args.DestroyMutex = destroy_mutex; + init_args.LockMutex = lock_mutex; + init_args.UnlockMutex = unlock_mutex; + init_args.pReserved = (void*)initstr; + initialize_common("locking mode 3: app locking"); +} + +static void +initialize_locking_4(const char *initstr) +{ + memset(&init_args, 0, sizeof (init_args)); + init_args.flags = CKF_OS_LOCKING_OK; + init_args.CreateMutex = create_mutex; + init_args.DestroyMutex = destroy_mutex; + init_args.LockMutex = lock_mutex; + init_args.UnlockMutex = unlock_mutex; + init_args.pReserved = (void*)initstr; + initialize_common("locking mode 4: either locking"); +} + +void +p11t_module_initialize(const char *initstr) +{ + CK_INFO info; + CK_RV rv; + + assert(p11_funcs); + + /* Some invalid use without initializing */ + rv = (p11_funcs->C_GetInfo)(&info); + if(rv != CKR_CRYPTOKI_NOT_INITIALIZED) + p11t_msg_print("shouldn't run without initialize: %s", p11t_msg_rv(rv)); + + /* The various different locking modes */ + initialize_locking_1(initstr); + p11t_module_finalize(); + initialize_locking_2(initstr); + p11t_module_finalize(); + initialize_locking_3(initstr); + p11t_module_finalize(); + initialize_locking_4(initstr); + + if(!is_initialized) + p11t_msg_fatal("liberal locking strategy failed, can't continue"); + + /* Double initialize */ + rv = (p11_funcs->C_Initialize) (&init_args); + if (rv != CKR_CRYPTOKI_ALREADY_INITIALIZED) + { + p11t_msg_print("double initialize should return CKR_CRYPTOKI_ALREADY_INITIALIZED: %s", p11t_msg_rv(rv)); + } + else + { + is_initialized = 1; + } +} + +void +p11t_module_finalize(void) +{ + CK_RV rv; + + if(is_initialized) + { + assert(p11_funcs); + rv = p11_funcs->C_Finalize(NULL); + if(rv != CKR_OK) + p11t_msg_print("C_Finalize failed: %s", p11t_msg_rv(rv)); + is_initialized = 0; + } +} + void p11t_module_unload(void) { diff --git a/src/p11-tests.c b/src/p11-tests.c index 80185cf..b871533 100644 --- a/src/p11-tests.c +++ b/src/p11-tests.c @@ -36,6 +36,7 @@ main(int argc, char* argv[]) usage(); p11t_module_load(argv[0]); + p11t_module_initialize(argc == 2 ? argv[1] : NULL); p11t_module_unload(); diff --git a/src/p11-tests.h b/src/p11-tests.h index 83c69af..cf37346 100644 --- a/src/p11-tests.h +++ b/src/p11-tests.h @@ -3,6 +3,7 @@ #include "pkcs11/pkcs11.h" +#include #include /* ------------------------------------------------------------------- @@ -21,6 +22,8 @@ void p11t_msg_prefix(const char *prefix); */ void p11t_module_load(const char *filename); +void p11t_module_initialize(const char *initstr); +void p11t_module_finalize(void); void p11t_module_unload(void); #endif /* P11TESTST_H_ */ -- cgit v1.2.3