Attached is a patch that includes the deprecation of misc_tests and
sess_mgmt_tests within testcases/pkcs11 in favor of updated testcase
versions. This continues the trend to separate function categories into
their own testcase suites (ex: slot/token, session, object mgmt, etc).
Ian Davis
LTC Security
diff --git a/testcases/pkcs11/Makefile.am b/testcases/pkcs11/Makefile.am
index bd0a948..75c8e2c 100644
--- a/testcases/pkcs11/Makefile.am
+++ b/testcases/pkcs11/Makefile.am
@@ -1,15 +1,16 @@
-noinst_PROGRAMS=hw_fn misc_tests sess_mgmt_tests sess_bench attribute findobjects destroyobjects copyobjects slot_token_tests
+noinst_PROGRAMS=hw_fn sess_bench attribute findobjects destroyobjects copyobjects slot_token_tests session_mgmt_tests
AM_CFLAGS=-I. -I../../usr/include/pkcs11 -I../include -I../common -I../../usr/lib/pkcs11/common -Wall
AM_LDFLAGS=-L../common -lc -ldl -lpthread -lcommon
hw_fn_SOURCES = hw_fn.c
-misc_tests_SOURCES = misc_func.c
-sess_mgmt_tests_SOURCES = sess_mgmt.c
+#misc_tests_SOURCES = misc_func.c
+#sess_mgmt_tests_SOURCES = sess_mgmt.c
sess_bench_SOURCES = sess_perf.c
attribute_SOURCES = attribute.c
findobjects_SOURCES = findobjects.c
destroyobjects_SOURCES = destroyobjects.c
copyobjects_SOURCES = copyobjects.c
slot_token_tests_SOURCES = slot_token.c
+session_mgmt_tests_SOURCES = session_mgmt.c
diff --git a/testcases/pkcs11/session_mgmt.c b/testcases/pkcs11/session_mgmt.c
new file mode 100644
index 0000000..3bd4d7a
--- /dev/null
+++ b/testcases/pkcs11/session_mgmt.c
@@ -0,0 +1,1296 @@
+// File: sess_mgmt.c
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <memory.h>
+
+#include "pkcs11types.h"
+#include "regress.h"
+
+//
+//
+void dump_session_info( CK_SESSION_INFO *info )
+{
+ printf(" CK_SESSION_INFO:\n");
+ printf(" slotID: %ld\n", info->slotID );
+ printf(" state: ");
+ switch (info->state) {
+ case CKS_RO_PUBLIC_SESSION: printf("CKS_RO_PUBLIC_SESSION\n");
+ break;
+ case CKS_RW_PUBLIC_SESSION: printf("CKS_RW_PUBLIC_SESSION\n");
+ break;
+ case CKS_RO_USER_FUNCTIONS: printf("CKS_RO_USER_FUNCTIONS\n");
+ break;
+ case CKS_RW_USER_FUNCTIONS: printf("CKS_RW_USER_FUNCTIONS\n");
+ break;
+ case CKS_RW_SO_FUNCTIONS: printf("CKS_RW_SO_FUNCTIONS\n");
+ break;
+ }
+ printf(" flags: %p\n", (void *)info->flags );
+ printf(" ulDeviceError: %ld\n\n", info->ulDeviceError );
+}
+
+
+
+//
+//
+CK_RV do_OpenSession( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_FLAGS flags;
+ CK_SESSION_HANDLE handle;
+ CK_RV rc;
+
+ testcase_begin("Basic OpenSession/CloseSession function check\n");
+
+ slot_id = SLOT_ID;
+ flags = CKF_SERIAL_SESSION; // read-only session
+
+ testcase_new_assertion();
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &handle );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_CloseSession( handle );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("Test session opened/closed successfully");
+
+ return rc;
+}
+
+
+//
+//
+CK_RV do_OpenSession2( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_FLAGS flags;
+ CK_SESSION_HANDLE h1, h2;
+ CK_RV rc;
+
+ testcase_begin("Multiple OpenSession/CloseSession function check\n");
+ testcase_new_assertion();
+
+ slot_id = SLOT_ID;
+ flags = CKF_SERIAL_SESSION; // read-only session
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_CloseSession( h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_CloseSession( h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("No errors encountered with multiple sessions");
+
+ return rc;
+}
+
+
+//
+//
+CK_RV do_CloseAllSessions( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_FLAGS flags;
+ CK_SESSION_HANDLE h1, h2, h3;
+ CK_SESSION_INFO info;
+ CK_RV rc;
+
+ testcase_begin("Test to make sure sessions are closed properly with C_CloseAllSessions\n");
+
+ testcase_new_assertion();
+
+ slot_id = SLOT_ID;
+ flags = CKF_SERIAL_SESSION; // read-only session
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #3 rc=%s", p11_get_ckr(rc));
+ }
+
+ rc = funcs->C_CloseAllSessions( slot_id );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseAllSessions rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetSessionInfo( h1, &info );
+ if (rc != CKR_SESSION_HANDLE_INVALID) {
+ testcase_fail(" C_GetSessionInfo #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ //Reset rc after GetSessionInfo returns != CKR_OK
+ rc = CKR_OK;
+ testcase_pass("All sessions closed");
+
+ return rc;
+}
+
+
+//
+//
+CK_RV do_GetSessionInfo( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_FLAGS flags;
+ CK_SESSION_HANDLE h1, h2, h3;
+ CK_SESSION_INFO info;
+ CK_RV rc;
+
+ testcase_begin("GetSessionInfo on multiple sessions\n");
+
+ slot_id = SLOT_ID;
+ flags = CKF_SERIAL_SESSION; // read-only session
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetSessionInfo( h1, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_GetSessionInfo( h2, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_GetSessionInfo( h2, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_CloseAllSessions( slot_id );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseAllSessions rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("GetSessionInfo returned data successfully");
+
+ return rc;
+}
+
+
+
+// This is a messy function but it does alot of tests:
+//
+// 1) Create 1 RO session and 2 RW sessions
+// 2) Log the USER into session #1. Verify that all 3 become USER sessions.
+// 3) Try to login again, this time to session #2. Verify that it fails
+// 4) Logout session #1
+// 5) Try to logout from session #2. Verify that this fails.
+// 6) Try to log the SO into session #1. Verify that it fails (RO session exists)
+// 7) Try to log the SO into session #2. Verify that it fails (RO session exists)
+// 8) Close all sessions
+// 9) Creaate 2 RW sessions
+// A) Log the SO into one. Verify that both are now SO sessions.
+// B) Create a 3rd RW session. Verify that it immediately becomes an SO session
+// C) Try to create a RO session. Verify that it fails (SO session exists)
+// D) Close all sessions and return
+//
+CK_RV do_LoginLogout( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_FLAGS flags;
+ CK_SESSION_HANDLE h1, h2, h3, h4;
+ CK_SESSION_INFO info;
+ CK_RV rc;
+ CK_BYTE user_pin[PKCS11_MAX_PIN_LEN];
+ CK_ULONG user_pin_len;
+ CK_BYTE so_pin[PKCS11_MAX_PIN_LEN];
+ CK_ULONG so_pin_len;
+
+ testcase_begin("Login/Logout - Repeated logins/logouts under available conditions\n");
+
+ if (get_user_pin(user_pin))
+ return CKR_FUNCTION_FAILED;
+ user_pin_len = (CK_ULONG)strlen((char *)user_pin);
+
+ if (get_so_pin(so_pin))
+ return CKR_FUNCTION_FAILED;
+ so_pin_len = (CK_ULONG)strlen((char *)so_pin);
+
+ slot_id = SLOT_ID;
+ flags = CKF_SERIAL_SESSION; // read-only session
+
+ //
+ // create 3 sessions. 1 RO, two RW
+ //
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ //
+ // log the first session in. all sessions should become USER sessions
+ //
+ rc = funcs->C_Login( h1, CKU_USER, user_pin, user_pin_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Login #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetSessionInfo( h1, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_GetSessionInfo( h2, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_GetSessionInfo( h2, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ testcase_pass("Login USER sessions\n");
+ testcase_new_assertion();
+
+ //
+ // now, try to log in session #2. this should fail (already logged in)
+ //
+ rc = funcs->C_Login( h2, CKU_USER, user_pin, user_pin_len );
+ if (rc != CKR_USER_ALREADY_LOGGED_IN) {
+ testcase_fail(" C_Login #2 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_USER_ALREADY_LOGGED_IN\n");
+ return -1;
+ }
+
+ //
+ // now, try to logout twice
+ //
+ rc = funcs->C_Logout( h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Logout #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_Logout( h2 );
+ if (rc != CKR_USER_NOT_LOGGED_IN) {
+ testcase_fail(" C_Logout #2 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_USER_NOT_LOGGED_IN\n");
+ return rc;
+ }
+
+ testcase_pass("Multiple logouts\n");
+ testcase_new_assertion();
+
+ //
+ // now, try to log the SO in. this should fail since H1 is a RO session
+ //
+ rc = funcs->C_Login( h1, CKU_SO, so_pin, so_pin_len );
+ if (rc != CKR_SESSION_READ_ONLY_EXISTS) {
+ testcase_fail(" C_Login #4 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_SESSION_READ_ONLY_EXISTS\n");
+ return -1;
+ }
+
+ rc = funcs->C_Login( h2, CKU_SO, so_pin, so_pin_len );
+ if (rc != CKR_SESSION_READ_ONLY_EXISTS) {
+ testcase_fail(" C_Login #5 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_SESSION_READ_ONLY_EXISTS\n");
+ return -1;
+ }
+
+ testcase_pass("SO in RO session");
+ testcase_new_assertion();
+
+ //
+ // log completely out
+ //
+
+ rc = funcs->C_CloseAllSessions( slot_id );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseAllSessions #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ //
+ // now, start two RW sessions
+ //
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #5 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ //
+ // now, try to log the SO in. this should work
+ //
+ rc = funcs->C_Login( h1, CKU_SO, so_pin, so_pin_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Login #6 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetSessionInfo( h1, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ rc = funcs->C_GetSessionInfo( h2, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #5 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ //
+ // now, create a 3rd RW session. verify that it is automatically an SO session
+ //
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #6 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetSessionInfo( h3, &info );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetSessionInfo #6 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ dump_session_info( &info );
+
+ testcase_pass("SO in RW session");
+ testcase_new_assertion();
+
+ //
+ // now, try to create a 4th session. RO this time. Should fail
+ //
+ flags = CKF_SERIAL_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &h4 );
+ if (rc != CKR_SESSION_READ_WRITE_SO_EXISTS) {
+ testcase_fail(" C_OpenSession #6 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_SESSION_READ_WRITE_SO_EXISTS\n");
+ return -1;
+ }
+
+
+ //
+ // we're done...close all sessions
+ //
+ rc = funcs->C_CloseAllSessions( slot_id );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseAllSessions #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+
+ testcase_pass("Login/Logout process successful\n");
+
+ return rc;
+}
+
+
+//
+//
+CK_RV do_OperationState1( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_SESSION_HANDLE session1, session2;
+ CK_FLAGS flags;
+ CK_BYTE user_pin[PKCS11_MAX_PIN_LEN];
+ CK_ULONG user_pin_len;
+ CK_RV rc;
+
+ CK_BYTE original[1024];
+ CK_BYTE crypt1 [1024];
+ CK_BYTE crypt2 [1024];
+ CK_BYTE trash1 [8];
+ CK_BYTE trash2 [8];
+
+ CK_BYTE *op_state = NULL;
+ CK_ULONG op_state_len;
+
+ CK_ULONG orig_len, crypt1_len, crypt2_len, trash1_len, trash2_len;
+ CK_ULONG i;
+
+ CK_MECHANISM mech;
+ CK_OBJECT_HANDLE h_key;
+
+
+ testcase_begin("OperationState1\n");
+ testcase_new_assertion();
+ slot_id = SLOT_ID;
+
+ //
+ // here's the goal:
+ //
+ // All the hash values should be the same
+ // 1) session #1 starts a multi-part encryption
+ // 2) save session #1 operation state
+ // 3) session #1 passes garbage to encrypt update
+ // 4) session #2's operation state is set to what we saved
+ // 5) sessoin #2 finishes the encryption operation
+ //
+ // Session #2's results should be the same as the single-part version
+ //
+
+ // create two USER RW sessions
+ //
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (get_user_pin(user_pin))
+ return CKR_FUNCTION_FAILED;
+ user_pin_len = (CK_ULONG)strlen((char *)user_pin);
+
+ rc = funcs->C_Login( session1, CKU_USER, user_pin, user_pin_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Login #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ orig_len = sizeof(original);
+ for (i=0; i < orig_len; i++)
+ original[i] = i % 255;
+
+ trash1_len = sizeof(trash1);
+ memcpy( trash1, "asdflkjasdlkjadslkj", trash1_len );
+
+
+ // first generate a DES key
+ //
+ mech.mechanism = CKM_DES_KEY_GEN;
+ mech.ulParameterLen = 0;
+ mech.pParameter = NULL;
+
+ rc = funcs->C_GenerateKey( session1, &mech, NULL, 0, &h_key );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GenerateKey #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // now encrypt the original data all at once using CBC
+ //
+ mech.mechanism = CKM_DES_CBC;
+ mech.ulParameterLen = 8;
+ mech.pParameter = "asdfqwer";
+
+ rc = funcs->C_EncryptInit( session1, &mech, h_key );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptInit #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ crypt1_len = sizeof(crypt1);
+ rc = funcs->C_Encrypt( session1, original, orig_len, crypt1, &crypt1_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Encrypt #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+
+ // now, begin encrypting multipart
+ //
+ rc = funcs->C_EncryptInit( session1, &mech, h_key );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptInit #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ crypt2_len = sizeof(crypt2);
+ rc = funcs->C_EncryptUpdate( session1, original, orig_len / 2,
+ crypt2, &crypt2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptUpdate #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // save session #1's operation state
+ //
+ rc = funcs->C_GetOperationState( session1, NULL, &op_state_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ op_state = (CK_BYTE *)malloc(op_state_len);
+ if (!op_state) {
+ testcase_fail(" HOST MEMORY ERROR %lu", (CK_ULONG)CKR_HOST_MEMORY );
+ return -1;
+ }
+
+ rc = funcs->C_GetOperationState( session1, op_state, &op_state_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // now, encrypt some garbage. this will affect the CBC even if
+ // we throw the encrypted garbage away
+ //
+ trash2_len = sizeof(trash2);
+ rc = funcs->C_EncryptUpdate( session1, trash1, trash1_len,
+ trash2, &trash2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptUpdate #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // restore session #1's operation state that we just saved back
+ // into session #2 and continue with the encryption
+ //
+ rc = funcs->C_SetOperationState( session2, op_state, op_state_len,
+ h_key, 0 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_SetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ free( op_state );
+
+ // now, encrypt the rest of the original data
+ //
+ i = crypt2_len;
+ crypt2_len = sizeof(crypt2) - crypt2_len;
+ rc = funcs->C_EncryptUpdate( session2,
+ original + orig_len/2, orig_len/2,
+ crypt2 + i, &crypt2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptUpdate #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ crypt2_len += i;
+
+ trash2_len = sizeof(trash2);
+ rc = funcs->C_EncryptFinal( session2, trash2, &trash2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptFinal #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (crypt2_len != crypt1_len) {
+ testcase_error(" ERROR: Lengths don't match\n");
+ return -1;
+ }
+
+ if (memcmp(crypt1, crypt2, crypt1_len) != 0) {
+ testcase_error(" ERROR: crypt1 != crypt2\n");
+ return -1;
+ }
+
+ rc = funcs->C_CloseSession( session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_CloseSession( session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("OperationState1\n");
+ return rc;
+}
+
+
+//
+//
+CK_RV do_OperationState2( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_SESSION_HANDLE session1, session2, session3;
+ CK_FLAGS flags;
+ CK_BYTE user_pin[PKCS11_MAX_PIN_LEN];
+ CK_ULONG user_pin_len;
+ CK_RV rc;
+
+ CK_BYTE original[1024];
+ CK_BYTE digest1[16];
+ CK_BYTE digest2[16];
+ CK_BYTE digest3[16];
+
+ CK_ULONG orig_len;
+ CK_ULONG digest1_len, digest2_len, digest3_len;
+
+ CK_BYTE *op_state1 = NULL;
+ CK_BYTE *op_state2 = NULL;
+ CK_ULONG op_state1_len;
+ CK_ULONG op_state2_len;
+
+ CK_ULONG i;
+
+ CK_MECHANISM mech;
+
+
+ testcase_begin("OperationState2\n");
+ testcase_new_assertion();
+ slot_id = SLOT_ID;
+
+ //
+ // here's the goal:
+ // 1) session #1 digests the first 499 bytes
+ // 2) session #2 digests the first 27 bytes
+ // 3) session #3 digests the whole thing
+ // 3) we save both operation states
+ // 4) we set the operation states to the 'other' session thereby
+ // switching sessions. Session #2 picks up where session #1 was
+ // saved, session #1 picks up where session #2 was saved.
+ // 5) session #1 digests the final (1024 - 27) bytes
+ // 6) session #2 digests the final (1024 - 499) bytes
+ //
+ // All the hash values should be the same
+ //
+
+ // create three USER RW sessions
+ //
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (get_user_pin(user_pin))
+ return CKR_FUNCTION_FAILED;
+ user_pin_len = (CK_ULONG)strlen((char *)user_pin);
+
+ rc = funcs->C_Login( session1, CKU_USER, user_pin, user_pin_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Login #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ orig_len = sizeof(original);
+ for (i=0; i < orig_len; i++)
+ original[i] = i % 255;
+
+ mech.mechanism = CKM_MD5;
+ mech.pParameter = NULL;
+ mech.ulParameterLen = 0;
+
+ rc = funcs->C_DigestInit( session1, &mech );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestInit #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestInit( session2, &mech );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestInit #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestInit( session3, &mech );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestInit #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestUpdate( session1, original, 499 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestUpdate( session2, original, 27 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ orig_len = sizeof(original);
+ digest3_len = sizeof(digest3);
+ rc = funcs->C_Digest( session3, original, orig_len,
+ digest3, &digest3_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Digest #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // save the operation states of sessions 1 and 2
+ //
+ rc = funcs->C_GetOperationState( session1, NULL, &op_state1_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ op_state1 = (CK_BYTE *)malloc(op_state1_len);
+ if (!op_state1) {
+ testcase_fail(" HOST MEMORY ERROR %lu", (CK_ULONG)CKR_HOST_MEMORY );
+ return -1;
+ }
+ rc = funcs->C_GetOperationState( session1, op_state1, &op_state1_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_GetOperationState( session2, NULL, &op_state2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ op_state2 = (CK_BYTE *)malloc(op_state2_len);
+ if (!op_state2) {
+ testcase_fail(" HOST MEMORY ERROR %lu", (CK_ULONG)CKR_HOST_MEMORY );
+ return -1;
+ }
+ rc = funcs->C_GetOperationState( session2, op_state2, &op_state2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // switch the states
+ //
+ rc = funcs->C_SetOperationState( session1, op_state2, op_state2_len,
+ 0, 0 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_SetOperationState #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_SetOperationState( session2, op_state1, op_state1_len,
+ 0, 0 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_SetOperationState #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // now, finish the digest operations
+ //
+ rc = funcs->C_DigestUpdate( session2, original+499, (orig_len - 499) );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestUpdate( session1, original+27, orig_len - 27 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ digest1_len = sizeof(digest1);
+ rc = funcs->C_DigestFinal( session1, digest1, &digest1_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestFinal #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ digest2_len = sizeof(digest2);
+ rc = funcs->C_DigestFinal( session2, digest2, &digest2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestFinal #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (digest1_len != digest2_len || digest1_len != digest3_len) {
+ testcase_error(" ERROR: digested lengths don't match\n");
+ return -1;
+ }
+
+ if (memcmp(digest1, digest2, digest1_len) != 0) {
+ testcase_error(" ERROR: digest1 != digest2\n");
+ return -1;
+ }
+
+ if (memcmp(digest1, digest3, digest1_len) != 0) {
+ testcase_error(" ERROR: digest1 != digest3\n");
+ return -1;
+ }
+
+ rc = funcs->C_CloseSession( session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ rc = funcs->C_CloseSession( session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ rc = funcs->C_CloseSession( session3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #5 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("OperationState2\n");
+ return rc;
+}
+
+
+//
+//
+CK_RV do_OperationState3( void )
+{
+ CK_SLOT_ID slot_id;
+ CK_SESSION_HANDLE session1, session2, session3;
+ CK_FLAGS flags;
+ CK_BYTE user_pin[PKCS11_MAX_PIN_LEN];
+ CK_ULONG user_pin_len;
+ CK_RV rc;
+
+ CK_BYTE original[1024];
+ CK_BYTE digest1[16];
+ CK_BYTE digest2[16];
+ CK_BYTE digest3[16];
+ CK_BYTE junk[1024];
+
+ CK_ULONG orig_len, junk_len;
+ CK_ULONG digest1_len, digest2_len, digest3_len;
+
+ CK_BYTE *op_state2 = NULL;
+ CK_ULONG op_state2_len;
+
+ CK_ULONG i;
+
+ CK_MECHANISM mech1, mech2;
+ CK_OBJECT_HANDLE key;
+
+
+ testcase_begin("OperationState3\n");
+ testcase_new_assertion();
+ slot_id = SLOT_ID;
+
+ //
+ // here's the goal:
+ // 1) session #1 starts a multi-part encrypt
+ // 2) session #2 starts a multi-part digest
+ // 3) session #3 digests the whole thing
+ // 4) assign session #2's operating state to session #1
+ // 5) session #1 tries C_EncryptUpdate. Should fail.
+ // 6) session #1 finishes the multi-part digest
+ // 7) session #2 finishes the multi-part digest
+ //
+ // All the hash values should be the same
+ //
+
+ // create three USER RW sessions
+ //
+ flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_OpenSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (get_user_pin(user_pin))
+ return CKR_FUNCTION_FAILED;
+ user_pin_len = (CK_ULONG)strlen((char *)user_pin);
+
+ rc = funcs->C_Login( session1, CKU_USER, user_pin, user_pin_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Login #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ orig_len = sizeof(original);
+ for (i=0; i < orig_len; i++)
+ original[i] = i % 255;
+
+
+ mech1.mechanism = CKM_DES_KEY_GEN;
+ mech1.pParameter = NULL;
+ mech1.ulParameterLen = 0;
+
+ rc = funcs->C_GenerateKey( session1, &mech1, NULL, 0, &key );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GenerateKey #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+
+ mech1.mechanism = CKM_DES_ECB;
+ mech1.pParameter = NULL;
+ mech1.ulParameterLen = 0;
+
+ rc = funcs->C_EncryptInit( session1, &mech1, key );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_EncryptInit #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ mech2.mechanism = CKM_MD5;
+ mech2.pParameter = NULL;
+ mech2.ulParameterLen = 0;
+
+ rc = funcs->C_DigestInit( session2, &mech2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestInit #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestInit( session3, &mech2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestInit #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestUpdate( session2, original, 499 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ orig_len = sizeof(original);
+ digest3_len = sizeof(digest3);
+ rc = funcs->C_Digest( session3, original, orig_len,
+ digest3, &digest3_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_Digest #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+
+ rc = funcs->C_GetOperationState( session2, NULL, &op_state2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ op_state2 = (CK_BYTE *)malloc(op_state2_len);
+ if (!op_state2) {
+ testcase_fail(" HOST MEMORY ERROR #1 %lu", (CK_ULONG)CKR_HOST_MEMORY );
+ return -1;
+ }
+ rc = funcs->C_GetOperationState( session2, op_state2, &op_state2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_GetOperationState #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_SetOperationState( session1, op_state2, op_state2_len, 0, 0 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_SetOperationState #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ // session #1 should not be set to do digest not encryption
+ //
+ junk_len = sizeof(junk);
+ rc = funcs->C_EncryptUpdate( session1, original, 499, junk, &junk_len );
+ if (rc != CKR_OPERATION_NOT_INITIALIZED) {
+ testcase_fail(" C_EncryptUpdate #1 rc=%s", p11_get_ckr(rc));
+ testcase_error(" Expected CKR_OPERATION_NOT_INITIALIZED\n" );
+ return -1;
+ }
+
+
+ // now, finish the digest operations
+ //
+ rc = funcs->C_DigestUpdate( session1, original+499, (orig_len - 499) );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ rc = funcs->C_DigestUpdate( session2, original+499, (orig_len - 499) );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestUpdate #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+
+ digest1_len = sizeof(digest1);
+ rc = funcs->C_DigestFinal( session1, digest1, &digest1_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestFinal #1 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ digest2_len = sizeof(digest2);
+ rc = funcs->C_DigestFinal( session2, digest2, &digest2_len );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_DigestFinal #2 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ if (digest1_len != digest2_len || digest1_len != digest3_len) {
+ testcase_error(" ERROR: digested lengths don't match\n");
+ return -1;
+ }
+
+ if (memcmp(digest1, digest2, digest1_len) != 0) {
+ testcase_error(" ERROR: digest1 != digest2\n");
+ return -1;
+ }
+
+ if (memcmp(digest1, digest3, digest1_len) != 0) {
+ testcase_error(" ERROR: digest1 != digest3\n");
+ return -1;
+ }
+
+ rc = funcs->C_CloseSession( session1 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #3 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ rc = funcs->C_CloseSession( session2 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #4 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+ rc = funcs->C_CloseSession( session3 );
+ if (rc != CKR_OK) {
+ testcase_fail(" C_CloseSession #5 rc=%s", p11_get_ckr(rc));
+ return rc;
+ }
+
+ testcase_pass("OperationState3\n");
+ return rc;
+}
+
+CK_RV sess_mgmt_functions()
+{
+ SYSTEMTIME t1, t2;
+ CK_RV rc;
+
+
+ GetSystemTime(&t1);
+ rc = do_OpenSession();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_OpenSession2();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_CloseAllSessions();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+ GetSystemTime(&t1);
+ rc = do_GetSessionInfo();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_LoginLogout();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_OperationState1();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_OperationState2();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+
+ GetSystemTime(&t1);
+ rc = do_OperationState3();
+ if (rc && !no_stop)
+ return rc;
+ GetSystemTime(&t2);
+ process_time( t1, t2 );
+
+ return rc;
+}
+
+int main(int argc, char **argv)
+{
+ CK_C_INITIALIZE_ARGS cinit_args;
+ int rc;
+ CK_RV rv;
+
+ rc = do_ParseArgs(argc, argv);
+ if ( rc != 1)
+ return rc;
+
+ printf("Using slot #%lu...\n\n", SLOT_ID );
+ printf("With option: no_init: %d\n", no_init);
+
+ rc = do_GetFunctionList();
+ if (!rc) {
+ testcase_error("ERROR do_GetFunctionList() Failed , rc = 0x%0x\n", rc);
+ return rc;
+ }
+
+ memset( &cinit_args, 0x0, sizeof(cinit_args) );
+ cinit_args.flags = CKF_OS_LOCKING_OK;
+
+ // SAB Add calls to ALL functions before the C_Initialize gets hit
+
+ funcs->C_Initialize( &cinit_args );
+
+ {
+ CK_SESSION_HANDLE hsess = 0;
+
+ rc = funcs->C_GetFunctionStatus(hsess);
+ if (rc != CKR_FUNCTION_NOT_PARALLEL)
+ return rc;
+
+ rc = funcs->C_CancelFunction(hsess);
+ if (rc != CKR_FUNCTION_NOT_PARALLEL)
+ return rc;
+
+ }
+
+ rv = sess_mgmt_functions();
+ /* make sure we return non-zero if rv is non-zero */
+ return ((rv==0) || (rv % 256) ? rv : -1);
+}
------------------------------------------------------------------------------
Monitor Your Dynamic Infrastructure at Any Scale With Datadog!
Get real-time metrics from all of your servers, apps and tools
in one place.
SourceForge users - Click here to start your Free Trial of Datadog now!
http://pubads.g.doubleclick.net/gampad/clk?id=241902991&iu=/4140
_______________________________________________
Opencryptoki-tech mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opencryptoki-tech