sess_mgmt.c

IBM的Linux上的PKCS#11实现

   if (!op_state1) {
      show_error("   HOST MEMORY ERROR", CKR_HOST_MEMORY );
      return FALSE;
   }
   rc = funcs->C_GetOperationState( session1, op_state1, &op_state1_len );
   if (rc != CKR_OK) {
      show_error("   C_GetOperationState #2", rc );
      return FALSE;
   }

   rc = funcs->C_GetOperationState( session2, NULL, &op_state2_len );
   if (rc != CKR_OK) {
      show_error("   C_GetOperationState #3", rc );
      return FALSE;
   }
   op_state2 = (CK_BYTE *)malloc(op_state2_len);
   if (!op_state2) {
      show_error("   HOST MEMORY ERROR", CKR_HOST_MEMORY );
      return FALSE;
   }
   rc = funcs->C_GetOperationState( session2, op_state2, &op_state2_len );
   if (rc != CKR_OK) {
      show_error("   C_GetOperationState #4", rc );
      return FALSE;
   }

   // switch the states
   //
   rc = funcs->C_SetOperationState( session1, op_state2, op_state2_len,
                                    0, 0 );
   if (rc != CKR_OK) {
      show_error("   C_SetOperationState #2", rc );
      return FALSE;
   }

   rc = funcs->C_SetOperationState( session2, op_state1, op_state1_len,
                                    0, 0 );
   if (rc != CKR_OK) {
      show_error("   C_SetOperationState #3", rc );
      return FALSE;
   }

   // now, finish the digest operations
   //
   rc = funcs->C_DigestUpdate( session2, original+499, (orig_len - 499) );
   if (rc != CKR_OK) {
      show_error("   C_DigestUpdate #3", rc );
      return FALSE;
   }

   rc = funcs->C_DigestUpdate( session1, original+27, orig_len - 27 );
   if (rc != CKR_OK) {
      show_error("   C_DigestUpdate #4", rc );
      return FALSE;
   }

   digest1_len = sizeof(digest1);
   rc = funcs->C_DigestFinal( session1, digest1, &digest1_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #1", rc );
      return FALSE;
   }

   digest2_len = sizeof(digest2);
   rc = funcs->C_DigestFinal( session2, digest2, &digest2_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #2", rc );
      return FALSE;
   }

   if (digest1_len != digest2_len || digest1_len != digest3_len) {
      printf("   ERROR:  digested lengths don't match\n");
      return FALSE;
   }

   if (memcmp(digest1, digest2, digest1_len) != 0) {
      printf("   ERROR:  digest1 != digest2\n");
      return FALSE;
   }

   if (memcmp(digest1, digest3, digest1_len) != 0) {
      printf("   ERROR:  digest1 != digest3\n");
      return FALSE;
   }

   rc = funcs->C_CloseSession( session1 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #3", rc );
      return FALSE;
   }
   rc = funcs->C_CloseSession( session2 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #4", rc );
      return FALSE;
   }
   rc = funcs->C_CloseSession( session3 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #5", rc );
      return FALSE;
   }

   printf("Looks okay...\n");
   return TRUE;
}


//
//
int do_OperationState3( void )
{
   CK_SLOT_ID          slot_id;
   CK_SESSION_HANDLE   session1, session2, session3;
   CK_FLAGS            flags;
   CK_BYTE             user_pin[8];
   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;


   printf("do_OperationState3...\n");
   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) {
      show_error("   C_OpenSession #1", rc );
      return FALSE;
   }

   rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session2 );
   if (rc != CKR_OK) {
      show_error("   C_OpenSession #2", rc );
      return FALSE;
   }

   rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session3 );
   if (rc != CKR_OK) {
      show_error("   C_OpenSession #3", rc );
      return FALSE;
   }

   memcpy( user_pin, "12345678", 8 );
   user_pin_len = 8;

   rc = funcs->C_Login( session1, CKU_USER, user_pin, user_pin_len );
   if (rc != CKR_OK) {
      show_error("   C_Login #1", rc );
      return FALSE;
   }

   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) {
      show_error("   C_GenerateKey #1", rc );
      return FALSE;
   }


   mech1.mechanism      = CKM_DES_ECB;
   mech1.pParameter     = NULL;
   mech1.ulParameterLen = 0;

   rc = funcs->C_EncryptInit( session1, &mech1, key );
   if (rc != CKR_OK) {
      show_error("   C_EncryptInit #1", rc );
      return FALSE;
   }

   mech2.mechanism      = CKM_MD5;
   mech2.pParameter     = NULL;
   mech2.ulParameterLen = 0;

   rc = funcs->C_DigestInit( session2, &mech2 );
   if (rc != CKR_OK) {
      show_error("   C_DigestInit #1", rc );
      return FALSE;
   }

   rc = funcs->C_DigestInit( session3, &mech2 );
   if (rc != CKR_OK) {
      show_error("   C_DigestInit #2", rc );
      return FALSE;
   }

   rc = funcs->C_DigestUpdate( session2, original, 499 );
   if (rc != CKR_OK) {
      show_error("   C_DigestUpdate #1", rc );
      return FALSE;
   }

   orig_len = sizeof(original);
   digest3_len = sizeof(digest3);
   rc = funcs->C_Digest( session3, original,  orig_len,
                                   digest3,  &digest3_len );
   if (rc != CKR_OK) {
      show_error("   C_Digest #1", rc );
      return FALSE;
   }


   rc = funcs->C_GetOperationState( session2, NULL, &op_state2_len );
   if (rc != CKR_OK) {
      show_error("   C_GetOperationState #1", rc );
      return FALSE;
   }
   op_state2 = (CK_BYTE *)malloc(op_state2_len);
   if (!op_state2) {
      show_error("   HOST MEMORY ERROR #1", CKR_HOST_MEMORY );
      return FALSE;
   }
   rc = funcs->C_GetOperationState( session2, op_state2, &op_state2_len );
   if (rc != CKR_OK) {
      show_error("   C_GetOperationState #2", rc );
      return FALSE;
   }

   rc = funcs->C_SetOperationState( session1, op_state2, op_state2_len, 0, 0 );
   if (rc != CKR_OK) {
      show_error("   C_SetOperationState #1", rc );
      return FALSE;
   }

   // 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) {
      show_error("   C_EncryptUpdate #1", rc );
      printf("   Expected CKR_OPERATION_NOT_INITIALIZED\n" );
      return FALSE;
   }


   // now, finish the digest operations
   //
   rc = funcs->C_DigestUpdate( session1, original+499, (orig_len - 499) );
   if (rc != CKR_OK) {
      show_error("   C_DigestUpdate #2", rc );
      return FALSE;
   }

   rc = funcs->C_DigestUpdate( session2, original+499, (orig_len - 499) );
   if (rc != CKR_OK) {
      show_error("   C_DigestUpdate #3", rc );
      return FALSE;
   }


   digest1_len = sizeof(digest1);
   rc = funcs->C_DigestFinal( session1, digest1, &digest1_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #1", rc );
      return FALSE;
   }

   digest2_len = sizeof(digest2);
   rc = funcs->C_DigestFinal( session2, digest2, &digest2_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #2", rc );
      return FALSE;
   }

   if (digest1_len != digest2_len || digest1_len != digest3_len) {
      printf("   ERROR:  digested lengths don't match\n");
      return FALSE;
   }

   if (memcmp(digest1, digest2, digest1_len) != 0) {
      printf("   ERROR:  digest1 != digest2\n");
      return FALSE;
   }

   if (memcmp(digest1, digest3, digest1_len) != 0) {
      printf("   ERROR:  digest1 != digest3\n");
      return FALSE;
   }

   rc = funcs->C_CloseSession( session1 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #3", rc );
      return FALSE;
   }
   rc = funcs->C_CloseSession( session2 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #4", rc );
      return FALSE;
   }
   rc = funcs->C_CloseSession( session3 );
   if (rc != CKR_OK) {
      show_error("   C_CloseSession #5", rc );
      return FALSE;
   }

   printf("Looks okay...\n");
   return TRUE;
}


int sess_mgmt_functions()
{
   SYSTEMTIME  t1, t2;
   int         rc;


   GetSystemTime(&t1);
   rc = do_OpenSession();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_OpenSession2();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_CloseAllSessions();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );

   GetSystemTime(&t1);
   rc = do_GetSessionInfo();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_LoginLogout();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_OperationState1();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_OperationState2();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );


   GetSystemTime(&t1);
   rc = do_OperationState3();
   if (!rc)
      return FALSE;
   GetSystemTime(&t2);
   process_time( t1, t2 );

   return TRUE;
}