void InfoTests::testGetFunctionList()
{
CK_RV rv;
CK_FUNCTION_LIST_PTR ckFuncList;
rv = C_GetFunctionList(NULL_PTR);
CPPUNIT_ASSERT(rv == CKR_ARGUMENTS_BAD);
rv = C_GetFunctionList(&ckFuncList);
CPPUNIT_ASSERT(rv == CKR_OK);
}
static void
test_initialize_multiple (void)
{
CK_FUNCTION_LIST_PTR proxy;
CK_RV rv;
rv = C_GetFunctionList (&proxy);
assert (rv == CKR_OK);
assert (p11_proxy_module_check (proxy));
rv = proxy->C_Initialize (NULL);
assert (rv == CKR_OK);
rv = proxy->C_Initialize (NULL);
assert (rv == CKR_OK);
rv = proxy->C_Finalize (NULL);
assert (rv == CKR_OK);
rv = proxy->C_Finalize (NULL);
assert (rv == CKR_OK);
rv = proxy->C_Finalize (NULL);
assert (rv == CKR_CRYPTOKI_NOT_INITIALIZED);
p11_proxy_module_cleanup ();
}
static void get_functions(CK_FUNCTION_LIST_PTR_PTR funcs) {
if (C_GetFunctionList(funcs) != CKR_OK) {
fprintf(stderr, "Get function list failed\n");
exit(EXIT_FAILURE);
}
}
static
void
Load (
IN const std::string &strModule,
OUT PKCS11_MODULE_HANDLE &hPKCS11,
OUT CK_FUNCTION_LIST_PTR &pkcs11
) {
CK_RV rv;
#if defined(_WIN32)
hPKCS11 = LoadLibraryA (strModule.c_str ());
#else
hPKCS11 = dlopen (strModule.c_str (), RTLD_NOW);
#endif
if (hPKCS11 == NULL) {
throw CEGeneral ("Cannot load module");
}
CK_C_GetFunctionList C_GetFunctionList = NULL;
#if defined(_WIN32)
C_GetFunctionList = (CK_C_GetFunctionList) (
GetProcAddress (hPKCS11, "C_GetFunctionList")
);
#else
void *p = dlsym (
hPKCS11,
"C_GetFunctionList"
);
memmove (
&C_GetFunctionList,
&p,
sizeof (void *)
);
#endif
if (C_GetFunctionList == NULL) {
throw CEGeneral ("Cannot get function list entry");
}
if ((rv = C_GetFunctionList (&pkcs11)) != CKR_OK) {
throw CEPKCS11 ("Cannot get function list", rv);
}
if ((rv = pkcs11->C_Initialize (NULL)) != CKR_OK) {
throw CEPKCS11 ("Cannot initialize", rv);
}
}
int do_GetFunctionList( void )
{
CK_RV rc;
printf("do_GetFunctionList...\n");
rc = C_GetFunctionList( &funcs ) ;
if (rc != CKR_OK) {
show_error(" C_GetFunctionList", rc );
return FALSE;
}
printf("Looks okay...\n");
return TRUE;
}
static void
test_initialize_finalize (void)
{
CK_FUNCTION_LIST_PTR proxy;
CK_RV rv;
rv = C_GetFunctionList (&proxy);
assert (rv == CKR_OK);
assert (p11_proxy_module_check (proxy));
rv = proxy->C_Initialize (NULL);
assert (rv == CKR_OK);
rv = proxy->C_Finalize (NULL);
assert_num_eq (rv, CKR_OK);
p11_proxy_module_cleanup ();
}
static void lib_info() {
CK_INFO info;
CK_FUNCTION_LIST_PTR funcs;
if (C_GetFunctionList(&funcs) != CKR_OK) {
fprintf(stderr, "Get function list failed\n");
exit(EXIT_FAILURE);
}
if (funcs->C_GetInfo(&info) != CKR_OK) {
fprintf(stderr, "GetInfo failed\n");
exit(EXIT_FAILURE);
}
if (strcmp(info.manufacturerID, MANUFACTURER_ID) != 0) {
fprintf(stderr, "unexpected manufacturer ID %s\n", info.manufacturerID);
exit(EXIT_FAILURE);
}
if (info.cryptokiVersion.major != CRYPTOKI_VERSION_MAJ ||
info.cryptokiVersion.minor != CRYPTOKI_VERSION_MIN ) {
fprintf(stderr, "unexpected Cryptoki version %d.%d\n", info.cryptokiVersion.major, info.cryptokiVersion.minor);
exit(EXIT_FAILURE);
}
if (info.libraryVersion.major != YKCS11_VERSION_MAJOR ||
info.libraryVersion.minor != ((YKCS11_VERSION_MINOR * 100) + YKCS11_VERSION_PATCH )) {
fprintf(stderr, "unexpected YKCS11 version %d.%d\n", info.libraryVersion.major, info.libraryVersion.minor);
exit(EXIT_FAILURE);
}
if (strcmp(info.libraryDescription, YKCS11_DESCRIPTION) != 0) {
fprintf(stderr, "unexpected description %s\n", info.libraryDescription);
exit(EXIT_FAILURE);
}
}
static CK_FUNCTION_LIST_PTR
setup_mock_module (CK_SESSION_HANDLE *session)
{
CK_FUNCTION_LIST_PTR proxy;
CK_SLOT_ID slots[32];
CK_RV rv;
rv = C_GetFunctionList (&proxy);
assert (rv == CKR_OK);
assert (p11_proxy_module_check (proxy));
rv = proxy->C_Initialize (NULL);
assert (rv == CKR_OK);
mock_slots_all = 32;
rv = proxy->C_GetSlotList (CK_FALSE, slots, &mock_slots_all);
assert (rv == CKR_OK);
assert (mock_slots_all >= 2);
/* Assume this is the slot we want to deal with */
mock_slot_one_id = slots[0];
mock_slot_two_id = slots[1];
rv = proxy->C_GetSlotList (CK_TRUE, NULL, &mock_slots_present);
assert (rv == CKR_OK);
assert (mock_slots_present > 1);
if (session) {
rv = (proxy->C_OpenSession) (mock_slot_one_id,
CKF_RW_SESSION | CKF_SERIAL_SESSION,
NULL, NULL, session);
assert (rv == CKR_OK);
}
return proxy;
}
/**********************************************************************
Function: sc_get_function_list()
Description:
Get the name of the PKCS11 dll to use from the registry,
load it, get the entry for the C_GetFunctionList
call it to set the pFunctionList.
Parameters:
Returns:
the pFunctionList or NULL
**********************************************************************/
CK_FUNCTION_LIST_PTR
sc_get_function_list()
{
CK_RV status;
#if defined(USE_PKCS11_DL) || defined(WIN32)
CK_RV (*gfl)(CK_FUNCTION_LIST_PTR_PTR);
#endif
if (pFunctionList) {
return pFunctionList;
}
#if defined(USE_PKCS11_DL) || defined(WIN32)
if (!h_m_pkcs11) {
char * dllname = NULL;
#ifdef WIN32
HKEY hkDir = NULL;
char val_dllname[512] = {"NONE"};
LONG lval;
DWORD type;
if (!h_m_pkcs11) {
RegOpenKey(HKEY_CURRENT_USER,GSI_REGISTRY_DIR,&hkDir);
lval = sizeof(val_dllname) -1;
if (hkDir && (RegQueryValueEx(hkDir,
"PKCS11.DLL",
0,
&type,
val_dllname,&lval) == ERROR_SUCCESS)) {
h_m_pkcs11 = LoadLibrary(val_dllname);
}
if (hkDir) {
RegCloseKey(hkDir);
}
if (!h_m_pkcs11) {
SCerr(SCERR_F_SCINIT,SCERR_R_NO_PKCS11_DLL);
ERR_add_error_data(2,"Name of DLL=",
dllname? dllname:"NONE");
return NULL;
}
}
gfl = (CK_RV (*)(CK_FUNCTION_LIST_PTR *))
GetProcAddress(h_m_pkcs11,"C_GetFunctionList");
#else
if (!h_m_pkcs11) {
dllname = getenv("PKCS11_LIB");
if (!dllname) {
dllname = "libDSPKCS.so";
}
h_m_pkcs11 = dlopen("libDSPKCS.so",RTLD_LAZY);
}
if (!h_m_pkcs11) {
SCerr(SCERR_F_SCINIT,SCERR_R_NO_PKCS11_DLL);
ERR_add_error_data(2,"Name of shared library=",
dllname);
return NULL;
}
gfl = (CK_RV(*)(CK_FUNCTION_LIST_PTR_PTR))
dlsym(h_m_pkcs11,"C_GetFunctionList");
#endif
if (!gfl) {
SCerr(SCERR_F_LOAD_DLL,SCERR_R_NO_PKCS11_DLL);
ERR_add_error_data(1,"Cant find C_GetFunctionList");
return NULL;
}
}
status = (*gfl)(&pFunctionList);
#else
status = C_GetFunctionList(&pFunctionList);
#endif /* PKCS11_DYNLOAD */
if (status != CKR_OK) {
SCerr(SCERR_F_LOAD_DLL,SCERR_R_UNSUPPORTED);
ERR_add_error_data(1,sc_ERR_code(status));
return NULL;
}
return pFunctionList;
}
int main(int argc, char** argv, char** envp)
{
extern char *optarg;
extern int optind;
CK_RV rv = CKR_OK;
CK_ULONG ulSlotCount;
CK_SLOT_ID_PTR pSlotList;
int i;
rv = C_GetFunctionList(&pFunctionList);
if(rv != CKR_OK)
{
printf("could not get function pointer list: %ld\n",rv);
exit(1);
}
rv = (pFunctionList->C_Initialize)(NULL_PTR);
if(rv != CKR_OK)
{
printf("could not initialize: %ld\n",rv);
exit(1);
}
/* get the slot list with token. this is not a test of C_OpenSession,
* thus only open sessions on token and not on slots
*/
rv = (pFunctionList->C_GetSlotList)(TRUE,NULL_PTR,&ulSlotCount);
if(rv != CKR_OK)
{
printf("FAIL: could not get slot count: %ld\n",rv);
exit(1);
}
pSlotList = malloc(sizeof(CK_SLOT_ID)*ulSlotCount);
if(pSlotList == NULL)
{
printf("could not allocate slot list: %d\n",CKR_HOST_MEMORY);
exit(1);
}
rv = (pFunctionList->C_GetSlotList)(TRUE,pSlotList,&ulSlotCount);
if(rv != CKR_OK)
{
printf("FAIL: could not get slot List: %ld\n",rv);
exit(1);
}
for(i=0;i<ulSlotCount;i++)
{
CK_SESSION_HANDLE sess_A, sess_B;
CK_OBJECT_HANDLE obj_handle;
printf("starting with token on slot %ld\n", pSlotList[i]);
/* open session A */
rv = (pFunctionList->C_OpenSession)(pSlotList[i],
CKF_SERIAL_SESSION,
NULL,NULL,&sess_A);
if(rv != CKR_OK)
{
printf("FAIL: C_OpenSession for Session A failed on slot %ld: %ld\n",pSlotList[i],rv);
continue;
}
rv = (pFunctionList->C_OpenSession)(pSlotList[i],
CKF_SERIAL_SESSION,
NULL,NULL,&sess_B);
if(rv != CKR_OK)
{
printf("FAIL: C_OpenSession for Session B failed on slot %ld for encryption: %ld\n",
pSlotList[i],rv);
continue;
}
/* open object in A */
/* destroy object in B */
/* close sessions */
rv = (pFunctionList->C_CloseSession)(sess_A);
if(rv != CKR_OK)
{
printf("FAIL: C_CloseSession in session %ld (session A): %ld\n",sess_A,rv);
continue;
}
rv = (pFunctionList->C_CloseSession)(sess_B);
if(rv != CKR_OK)
{
printf("FAIL: C_CloseSession in session %ld (session B): %ld\n",sess_B,rv);
continue;
}
printf("slot %ld done\n", pSlotList[i]);
} /* for each slot */
free(pSlotList);
(pFunctionList->C_Finalize)(NULL);
#ifdef CK_Win32
{
char buf[3]={1};
printf("weiter mit return");
_cgets(buf);
}
#endif
return 0;
}
int main (int argc, char **argv)
{
CK_RV rv = CKR_OK;
CK_FUNCTION_LIST_PTR pkcs11;
CK_RV (*C_GetFunctionList) (CK_FUNCTION_LIST_PTR_PTR) = 0;
char *lib_path, *string_to_search;
unsigned int string_to_search_len;
CK_INFO info;
CK_SLOT_INFO slot_info;
CK_ULONG slot_list_size = 8;
CK_SLOT_ID slot_list[slot_list_size];
CK_TOKEN_INFO token_info;
CK_ULONG i;
CK_SESSION_HANDLE session_handle;
CK_OBJECT_HANDLE object_list[16];
CK_ULONG object_list_size = 16, objects_found;
if (argc >= 2)
lib_path = argv[1];
if (argc >= 3)
string_to_search = argv[2];
string_to_search_len = strlen(string_to_search);
void *pkcs11_so;
pkcs11_so = dlopen (lib_path, RTLD_NOW);
if (pkcs11_so == NULL) {
fprintf (stderr, "Could not load library: %s\n", dlerror());
return CKR_GENERAL_ERROR;
}
C_GetFunctionList = (CK_RV (*)(CK_FUNCTION_LIST_PTR_PTR)) dlsym(pkcs11_so, "C_GetFunctionList");
rv = C_GetFunctionList (&pkcs11);
g_assert (rv == CKR_OK);
/**/
rv = pkcs11->C_Initialize (NULL);
g_assert (rv == CKR_OK);
rv = pkcs11->C_GetInfo (&info);
g_assert (rv == CKR_OK);
printf ("CK_INFO\n");
printf ("PKCS#11 version: %u.%u\n",
info.cryptokiVersion.major,
info.cryptokiVersion.minor);
printf ("Manufacturer ID: %s\n", info.manufacturerID);
printf ("Flags: %lx\n", (CK_ULONG) info.flags);
printf ("Library Description: ");
print_info (info.libraryDescription, 32);
printf ("library version: %u.%u\n",
info.libraryVersion.major,
info.libraryVersion.minor);
rv = pkcs11->C_GetSlotList (CK_TRUE, slot_list, &slot_list_size);
g_assert (rv == CKR_OK);
printf ("Number of slots: %lu\n", slot_list_size);
printf ("Slot number: ");
for (i = 0; i < slot_list_size; i++) {
printf ("%lu ", (CK_ULONG) slot_list[i]);
}
printf ("\n");
/**/
rv = pkcs11->C_GetSlotInfo (slot_list[0], &slot_info);
g_assert (rv == CKR_OK);
printf ("CK_SLOT_INFO\n");
printf ("Slot description: ");
print_info (slot_info.slotDescription, 64);
printf ("Manufacturer ID: ");
print_info (slot_info.manufacturerID, 32);
printf ("Flags: %lx\n", slot_info.flags);
printf ("Hardware version: %u.%u\n",
slot_info.hardwareVersion.major,
slot_info.hardwareVersion.minor);
printf ("Firmware version: %u.%u\n",
slot_info.firmwareVersion.major,
slot_info.firmwareVersion.minor);
rv = pkcs11->C_GetTokenInfo (slot_list[0], &token_info);
g_assert (rv == CKR_OK);
test_session (pkcs11, slot_list[0]);
rv = pkcs11->C_OpenSession (slot_list[0], CKF_SERIAL_SESSION, NULL, NULL, &session_handle);
g_assert (rv == CKR_OK);
test_search (pkcs11,
slot_list[0],
session_handle,
string_to_search,
string_to_search_len,
object_list,
object_list_size,
&objects_found);
test_attribute_value (pkcs11,
slot_list[0],
session_handle,
object_list[0]);
rv = pkcs11->C_CloseSession(session_handle);
g_assert (rv == CKR_OK);
rv = pkcs11->C_Finalize (NULL);
g_assert (rv == CKR_OK);
rv = dlclose(pkcs11_so);
if (rv != 0) {
fprintf (stderr, "Could not dlclose\n");
}
return 0;
}
int main(int argc, char** argv, char** envp)
{
extern char *optarg;
extern int optind;
CK_RV rv = CKR_OK;
if(argc != 2)
{
printf("Wrong number of arguments\nusage: %s <user_pin>\n",argv[0]);
exit(1);
}
rv = C_GetFunctionList(&pFunctionList);
if(rv != CKR_OK)
{
printf("FAIL: could not get function pointer list: %ld\n",rv);
exit(1);
}
rv = (pFunctionList->C_Initialize)(NULL_PTR);
if(rv != CKR_OK)
{
printf("FAIL: could not initialize: %ld\n",rv);
exit(1);
}
/* get the slot list with token. this is not a test of C_OpenSession,
* thus only open sessions on token and not on slots
*/
{
CK_ULONG ulSlotCount;
CK_SLOT_ID_PTR pSlotList;
int i;
rv = (pFunctionList->C_GetSlotList)(TRUE,NULL_PTR,&ulSlotCount);
if(rv != CKR_OK)
{
printf("FAIL: could not get slot count: %ld\n",rv);
exit(1);
}
pSlotList = malloc(sizeof(CK_SLOT_ID)*ulSlotCount);
if(pSlotList == NULL)
{
printf("could not allocate slot list: %d\n",CKR_HOST_MEMORY);
exit(1);
}
rv = (pFunctionList->C_GetSlotList)(TRUE,pSlotList,&ulSlotCount);
if(rv != CKR_OK)
{
printf("FAIL: could not get slot List: %ld\n",rv);
exit(1);
}
/* for each slot with a token */
for(i=0;(unsigned long)i<ulSlotCount;i++)
{
CK_SESSION_HANDLE sign_sess=0, verify_sess=0;
CK_ULONG mech_count;
CK_MECHANISM_TYPE_PTR mech_list;
CK_ULONG j,k, pub_handle_count,priv_handle_count;
CK_BBOOL do_token;
CK_OBJECT_HANDLE_PTR pub_handle_arr;
CK_OBJECT_HANDLE_PTR priv_handle_arr;
CK_SLOT_ID verify_slot;
printf("starting with token on slot %ld\n", pSlotList[i]);
/* check that the token supports RSA sign */
/* first only get the length of the list */
(pFunctionList->C_GetMechanismList)(pSlotList[i],
NULL_PTR, &mech_count);
mech_list = malloc(mech_count * sizeof(CK_MECHANISM_TYPE));
if(mech_list == NULL_PTR)
{
printf("FAIL: mem alloc\n");
exit(1);
}
(pFunctionList->C_GetMechanismList)(pSlotList[i],mech_list,
&mech_count);
/* look for the RSA operations */
for(j=0,do_token=FALSE;j<mech_count;j++)
if(mech_list[j] == CKM_RSA_PKCS) do_token = TRUE;
if(!do_token)
{
printf("FAIL: no RSA PKCS#11 on slot %lu\n",pSlotList[i]);
continue;
}
/* clean up */
free(mech_list);
/* open session */
rv = (pFunctionList->C_OpenSession)(pSlotList[i],
CKF_SERIAL_SESSION,
NULL,NULL,&sign_sess);
if(rv != CKR_OK)
{
printf("FAIL: C_OpenSession failed on slot %ld: %ld\n",pSlotList[i],rv);
continue;
}
// To be able to retrieve private objects from the token, the user must be authenticated */
rv = (pFunctionList->C_Login) (sign_sess, CKU_USER, argv[1], 8);
if(rv != CKR_OK)
{
printf("Bad login, rv: %d",rv);
exit(1);
}
/* find the public keys */
rv = pkcs11_find_object(sign_sess,
CK_I_rsa_public_key_template, CK_I_rsa_public_key_count ,
&pub_handle_arr, &pub_handle_count);
if(rv != CKR_OK)
{
printf("FAIL: unable to find public key: 0x%lx\n",rv);
continue;
}
/* find a token that supports RSA_PKCS for verify */
rv = find_rsa_verify(pFunctionList,&verify_slot);
if(rv != CKR_OK)
{
printf("FAIL: unable to find token for verify: 0x%lx. Cannot verify the signature\n",rv);
verify_sess = 0;
}
else
{
if (verify_slot == pSlotList[i])
verify_sess = sign_sess;
else
{
rv = (pFunctionList->C_OpenSession)(verify_slot,
CKF_SERIAL_SESSION|CKF_RW_SESSION,
NULL,NULL,&verify_sess);
if(rv != CKR_OK)
{
printf("FAIL: C_OpenSession failed on slot %ld for verify: %ld\n",
pSlotList[i],rv);
continue;
}
}
}
for(k=0; k<pub_handle_count; k++)
{
CK_ATTRIBUTE theTemplate = {CKA_ID, NULL, 0};
CK_CHAR_PTR clear_text1 ="foobar1";
CK_CHAR_PTR clear_text2 ="This is a text that is too long even for a 1k key: The quick brown fox jumps over the lazy dog. 1234567890";
CK_OBJECT_HANDLE new_pub_handle=0;
/* set the ID of the public key in the private key */
rv = (pFunctionList->C_GetAttributeValue)(sign_sess, pub_handle_arr[k], &theTemplate, 1);
if(rv != CKR_OK)
{
printf("FAIL: unable read id length for public key %li: 0x%lx\n",pub_handle_arr[k],rv);
continue;
}
theTemplate.pValue = malloc(theTemplate.ulValueLen);
if(theTemplate.pValue == NULL_PTR)
{
printf("FAIL: unable allocate memory for private key id\n");
continue;
}
rv = (pFunctionList->C_GetAttributeValue)(sign_sess, pub_handle_arr[k], &theTemplate, 1);
if(rv != CKR_OK)
{
printf("FAIL: unable to read id for public key %li: 0x%lx\n",
pub_handle_arr[k],rv);
continue;
}
rv = set_attribute(CK_I_rsa_private_key_template,
CK_I_rsa_private_key_count,
CKA_ID,
theTemplate.pValue, theTemplate.ulValueLen);
if(rv != CKR_OK)
{
printf("FAIL: unable to set id in templatee for private key: 0x%lx\n",rv);
continue;
}
/* find the matching private key */
rv = pkcs11_find_object(sign_sess, CK_I_rsa_private_key_template,
CK_I_rsa_private_key_count,
&priv_handle_arr, &priv_handle_count);
if(rv != CKR_OK)
{
printf("FAIL: unable to find public key: 0x%lx\n",rv);
continue;
}
/* is there exactly one (1) private key to this public key? */
if(priv_handle_count != 1)
{
printf("FAIL: wrong number of private keys: %li\n",priv_handle_count);
continue;
}
/* copy the public key if needed */
if(sign_sess != verify_sess)
{ if ( verify_sess != 0 )
rv = P11_loadPubRSAKey(pFunctionList, sign_sess,
pFunctionList, verify_sess,
pub_handle_arr[k], &new_pub_handle);
else
new_pub_handle = 0;
}
else
new_pub_handle = pub_handle_arr[k];
/* sign test vector */
rv = sign_and_verify(sign_sess,verify_sess,clear_text1,
priv_handle_arr[0],new_pub_handle,
argv[1]);
if(rv != CKR_OK)
continue;
if ( verify_sess != 0 )
printf("sign and verify succeded for short text session %ld: 0x%08lx\n",
sign_sess,rv);
else
printf("sign succeded for short text session %ld: 0x%08lx\n",
sign_sess,rv);
rv = sign_and_verify(sign_sess,verify_sess,clear_text2,
priv_handle_arr[0],new_pub_handle,
argv[1]);
if(rv == CKR_OK)
{
printf("FAIL: over long clear text did not fail\n");
continue;
}
if ( verify_sess != 0 )
printf("sign and verify succeded in session %ld: 0x%08lx\n",
sign_sess,rv);
else
printf("sign succeded in session %ld: 0x%08lx\n",
sign_sess,rv);
} /* for each public key */
/* close session */
rv = (pFunctionList->C_CloseSession)(sign_sess);
if(rv != CKR_OK)
{
printf("FAIL: C_CloseSession in session %ld: %ld\n",sign_sess,rv);
continue;
}
printf("slot %ld done\n", pSlotList[i]);
}
free(pSlotList);
}
(pFunctionList->C_Finalize)(NULL);
#ifdef CK_Win32
{
char buf[3]={1};
printf("\nPress any key to continue...");
_cgets(buf);
}
#endif
return 0;
}
CK_RV
mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
{
/* This would be a strange call to receive */
return C_GetFunctionList (list);
}
