speed.c

IBM的Linux上的PKCS#11实现

      if (diff < min_time)
         min_time = diff;

      if (diff > max_time)
         max_time = diff;
   }

   avg_time -= min_time;
   avg_time -= max_time;

   printf("1000 DES3 %d byte ENCR operations:  %d ms\n", BIG_REQUEST, avg_time );
   printf("Minimum:                        %d ms\n", min_time );
   printf("Maximum:                        %d ms\n", max_time );

   printf("\n");

   avg_time = 0;
   max_time = 0;
   min_time = 0xFFFFFFFF;

   for (i=0; i < 1000; i++) {
      GetSystemTime(&t1);

      rc = funcs->C_DecryptInit( session, &mech, h_key );
      if (rc != CKR_OK) {
         show_error("   C_DecryptInit #1", rc );
         return FALSE;
      }

      clear_len = BIG_REQUEST;
      rc = funcs->C_Decrypt( session, cipher, cipher_len, clear, &clear_len );
      if (rc != CKR_OK) {
         show_error("   C_Decrypt #1", rc );
         return FALSE;
      }

      GetSystemTime(&t2);

      diff = process_time(t1, t2);

      avg_time += diff;

      if (diff < min_time)
         min_time = diff;

      if (diff > max_time)
         max_time = diff;
   }

   avg_time -= min_time;
   avg_time -= max_time;

   printf("1000 DES3 %d byte DECR operations:  %d ms\n", BIG_REQUEST, avg_time );
   printf("Minimum:                        %d ms\n", min_time );
   printf("Maximum:                        %d ms\n", max_time );

   rc = funcs->C_CloseAllSessions( slot_id );
   if (rc != CKR_OK) {
      show_error("   C_CloseAllSessions #1", rc );
      return FALSE;
   }

   if (original)  free( original );
   if (cipher)    free( cipher );
   if (clear)     free( clear );

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


//
//
int do_DES3_CBC_EncrDecr( void )
{
   CK_BYTE            *original;
   CK_BYTE            *cipher;
   CK_BYTE            *clear;

   CK_SLOT_ID          slot_id;
   CK_SESSION_HANDLE   session;
   CK_MECHANISM        mech;
   CK_OBJECT_HANDLE    h_key;
   CK_FLAGS            flags;
   CK_BYTE             user_pin[8];
   CK_BYTE             init_v[8] = { 1,2,3,4,5,6,7,8 };
   CK_ULONG            user_pin_len;
   CK_ULONG            i;
   CK_ULONG            orig_len, cipher_len, clear_len;
   CK_RV               rc;

   SYSTEMTIME          t1, t2;
   CK_ULONG            avg_time, min_time, max_time, diff;

   printf("do_DES3_CBC_EncrDecr\n");

   original = (CK_BYTE *)malloc(BIG_REQUEST);
   cipher   = (CK_BYTE *)malloc(BIG_REQUEST);
   clear    = (CK_BYTE *)malloc(BIG_REQUEST);
   if (!original || !cipher || !clear) {
      if (original)  free( original );
      if (cipher)    free( cipher );
      if (clear)     free( clear );

      printf("HOST MEMORY ERROR\n");
      return FALSE;
   }


   slot_id = SLOT_ID;
   flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
   rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session );
   if (rc != CKR_OK) {
      show_error("   C_OpenSession #1", rc );
      return FALSE;
   }

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

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

   mech.mechanism      = CKM_DES3_KEY_GEN;
   mech.ulParameterLen = 0;
   mech.pParameter     = NULL;

   // first, generate a DES key
   //
   rc = funcs->C_GenerateKey( session, &mech, NULL, 0, &h_key );
   if (rc != CKR_OK) {
      show_error("   C_GenerateKey #1", rc );
      return FALSE;
   }


   // now, encrypt some data
   //
   orig_len = BIG_REQUEST;
   for (i=0; i < orig_len; i++) {
      original[i] = i % 255;
   }

   mech.mechanism      = CKM_DES3_CBC;
   mech.ulParameterLen = 8;
   mech.pParameter     = init_v;

   avg_time = 0;
   max_time = 0;
   min_time = 0xFFFFFFFF;

   for (i=0; i < 1000; i++) {
      GetSystemTime(&t1);
      rc = funcs->C_EncryptInit( session, &mech, h_key );
      if (rc != CKR_OK) {
         show_error("   C_EncryptInit #1", rc );
         return FALSE;
      }

      cipher_len = BIG_REQUEST;
      rc = funcs->C_Encrypt( session, original, orig_len, cipher, &cipher_len );
      if (rc != CKR_OK) {
         show_error("   C_Encrypt #1", rc );
         return FALSE;
      }

      GetSystemTime(&t2);

      diff = process_time(t1, t2);

      avg_time += diff;

      if (diff < min_time)
         min_time = diff;

      if (diff > max_time)
         max_time = diff;
   }

   avg_time -= min_time;
   avg_time -= max_time;

   printf("1000 DES3 %d byte ENCR operations:  %d ms\n", BIG_REQUEST, avg_time );
   printf("Minimum:                        %d ms\n", min_time );
   printf("Maximum:                        %d ms\n", max_time );

   printf("\n");

   avg_time = 0;
   max_time = 0;
   min_time = 0xFFFFFFFF;

   for (i=0; i < 1000; i++) {
      GetSystemTime(&t1);

      rc = funcs->C_DecryptInit( session, &mech, h_key );
      if (rc != CKR_OK) {
         show_error("   C_DecryptInit #1", rc );
         return FALSE;
      }

      clear_len = BIG_REQUEST;
      rc = funcs->C_Decrypt( session, cipher, cipher_len, clear, &clear_len );
      if (rc != CKR_OK) {
         show_error("   C_Decrypt #1", rc );
         return FALSE;
      }

      GetSystemTime(&t2);

      diff = process_time(t1, t2);

      avg_time += diff;

      if (diff < min_time)
         min_time = diff;

      if (diff > max_time)
         max_time = diff;
   }

   avg_time -= min_time;
   avg_time -= max_time;

   printf("1000 DES3 %d byte DECR operations:  %d ms\n", BIG_REQUEST, avg_time );
   printf("Minimum:                        %d ms\n", min_time );
   printf("Maximum:                        %d ms\n", max_time );

   rc = funcs->C_CloseAllSessions( slot_id );
   if (rc != CKR_OK) {
      show_error("   C_CloseAllSessions #1", rc );
      return FALSE;
   }

   if (original)  free( original );
   if (cipher)    free( cipher );
   if (clear)     free( clear );

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


//
//
int do_SHA1( void )
{
   CK_SESSION_HANDLE session;
   CK_SLOT_ID        slot_id;
   CK_MECHANISM      mech;
   CK_ULONG          flags;
   CK_ULONG          i;
   CK_RV             rc;


   printf("do_SHA1...\n");

   slot_id = SLOT_ID;
   flags = CKF_SERIAL_SESSION | CKF_RW_SESSION;
   rc = funcs->C_OpenSession( slot_id, flags, NULL, NULL, &session );
   if (rc != CKR_OK) {
      show_error("   C_OpenSession #1", rc );
      return FALSE;
   }

   {
      CK_BYTE           *data;
      CK_BYTE           hash1[SHA1_HASH_LEN];
      CK_ULONG          data_len;
      CK_ULONG          hash_len;

      SYSTEMTIME        t1, t2;
      CK_ULONG          diff, avg_time, min_time, max_time;

      data = (CK_BYTE *)malloc( BIG_REQUEST );
      if (!data) {
         printf("HOST MEMORY ERROR\n");
         return FALSE;
      }

      mech.mechanism      = CKM_SHA_1;
      mech.ulParameterLen = 0;
      mech.pParameter     = NULL;

      // generate some data to hash
      //
      data_len = BIG_REQUEST;
      for (i=0; i < data_len; i++)
         data[i] = i % 255;

      avg_time = 0;
      max_time = 0;
      min_time = 0xFFFFFFFF;

      for (i=0; i < 1000; i++) {
         GetSystemTime(&t1);

         rc = funcs->C_DigestInit( session, &mech );
         if (rc != CKR_OK) {
            show_error("   C_DigestInit #5", rc );
            return FALSE;
         }

         hash_len = sizeof(hash1);
         rc = funcs->C_Digest( session, data,     data_len,
                                        hash1,   &hash_len );
         if (rc != CKR_OK) {
            show_error("   C_Digest #3", rc );
            return FALSE;
         }

         GetSystemTime(&t2);

         diff = process_time(t1, t2);

         avg_time += diff;

         if (diff < min_time)
            min_time = diff;

         if (diff > max_time)
            max_time = diff;
      }

      avg_time -= min_time;
      avg_time -= max_time;

      printf("1000 SHA-1 %d byte operations:  %d ms\n", BIG_REQUEST, avg_time );
      printf("Minimum:                    %d ms\n", min_time );
      printf("Maximum:                    %d ms\n", max_time );

      free( data );
   }



   rc = funcs->C_CloseAllSessions( slot_id );
   if (rc != CKR_OK) {
      show_error("   C_CloseAllSessions #1", rc );
      return FALSE;
   }

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


//
//
int do_DummyFunction( void )
{
   CK_SLOT_ID        slot_id;
   CK_ULONG          i;
   CK_ULONG          diff, avg_time, min_time, max_time;
   SYSTEMTIME        t1, t2;


   printf("do_DummyFunction...\n");
#if DUMMY
   slot_id = SLOT_ID;

   avg_time = 0;
   max_time = 0;
   min_time = 0xFFFFFFFF;

   for (i=0; i < 1000; i++) {
      GetSystemTime(&t1);


      DummyFunction( slot_id );

      GetSystemTime(&t2);

      diff = process_time(t1, t2);

      avg_time += diff;

      if (diff < min_time)
         min_time = diff;

      if (diff > max_time)
         max_time = diff;
   }

   avg_time -= min_time;
   avg_time -= max_time;

   printf("1000 DummyFunction %d byte operations:  %d ms\n", 1024, avg_time );
   printf("Minimum:                    %d ms\n", min_time );
   printf("Maximum:                    %d ms\n", max_time );
#endif
}



//
//
void main( int argc, char **argv )
{
   CK_C_INITIALIZE_ARGS  cinit_args;
   int        rc, i;

   SLOT_ID = 0;

   for (i=1; i < argc; i++) {
      if (strcmp(argv[i], "-slot") == 0) {
         SLOT_ID = atoi(argv[i+1]);
         i++;
      }

      if (strcmp(argv[i], "-h") == 0) {
         printf("usage:  %s [-slot <num>] [-h]\n\n", argv[0] );
         printf("By default, Slot #1 is used\n\n");
         return;
      }
   }

   printf("Using slot #%d...\n\n", SLOT_ID );

   rc = do_GetFunctionList();
   if (!rc)
      return;

   memset( &cinit_args, 0x0, sizeof(cinit_args) );
   cinit_args.flags = CKF_OS_LOCKING_OK;

   funcs->C_Initialize( &cinit_args );

#if 1
   rc = do_RSA_KeyGen_2048();
   if (!rc)
      return;

   rc = do_RSA_KeyGen_1024();
   if (!rc)
      return;

#endif
#if 1
   rc = do_RSA_PKCS_SignVerify_1024();
   if (!rc)
      return;

#endif
#if 1
   rc = do_RSA_PKCS_EncryptDecrypt( );
   if (!rc)
      return;

   rc = do_DES3_ECB_EncrDecr();
   if (!rc)
      return;

   rc = do_DES3_CBC_EncrDecr();
   if (!rc)
      return;

   rc = do_SHA1();
   if (!rc)
      return;
#endif

//   rc = do_DES_ECB_EncrDecr();
//   if (!rc)
//      return;

#if 1
   rc = do_DES3_ECB_EncrDecr();
   if (!rc)
      return;

   rc = do_DES3_CBC_EncrDecr();
   if (!rc)
      return;

   rc = do_SHA1();
   if (!rc)
      return;
#endif

   funcs->C_Finalize( NULL );
}