digest_func.c

IBM的Linux上的PKCS#11实现

// File: digest.c
//

#include <windows.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>

#include "pkcs11types.h"
#include "regress.h"

#include "md5.h"


//
//
int do_Digest_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_Digest_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;
   }

   // perform the hash tests from the FIPS 180-1 document
   //
   {
      CK_BYTE  data1[] = "abc";
      CK_BYTE  data2[] = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
      CK_ULONG data_len;
      CK_BYTE  expected1[] = {0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 0x25, 0x71, 0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D };
      CK_BYTE  expected2[] = {0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE, 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1 };
      CK_BYTE  hash[20];
      CK_ULONG hash_len;

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

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

      hash_len = sizeof(hash);
      data_len = strlen(data1);
      rc = funcs->C_Digest( session, data1,    data_len,
                                     hash,    &hash_len );
      if (rc != CKR_OK) {
         show_error("   C_Digest #1", rc );
         return FALSE;
      }

      if (hash_len != 20) {
         printf("   ERROR #1:  hash_len == %d, expected 20\n", hash_len );
         return FALSE;
      }

      if (memcmp(hash, expected1, hash_len) != 0) {
         printf("   ERROR #2:  hash output mismatch\n" );
         return FALSE;
      }


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

      data_len = strlen(data1);
      rc = funcs->C_DigestUpdate( session, data1, data_len );
      if (rc != CKR_OK) {
         show_error("   C_DigestUpdate #1", rc );
         return FALSE;
      }

      hash_len = sizeof(hash);
      rc = funcs->C_DigestFinal( session, hash, &hash_len );
      if (rc != CKR_OK) {
         show_error("   C_DigestFinal #1", rc );
         return FALSE;
      }

      if (hash_len != 20) {
         printf("   ERROR #3:  hash_len == %d, expected 20\n", hash_len );
         return FALSE;
      }

      if (memcmp(hash, expected1, hash_len) != 0) {
         printf("   ERROR #4:  hash output mismatch\n" );
         return FALSE;
      }


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

      hash_len = sizeof(hash);
      data_len = strlen(data2);
      rc = funcs->C_Digest( session, data2,    data_len,
                                     hash,    &hash_len );
      if (rc != CKR_OK) {
         show_error("   C_Digest #2", rc );
         return FALSE;
      }

      if (hash_len != 20) {
         printf("   ERROR #5:  hash_len == %d, expected 20\n", hash_len );
         return FALSE;
      }

      if (memcmp(hash, expected2, hash_len) != 0) {
         printf("   ERROR #6:  hash output mismatch\n" );
         return FALSE;
      }


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

      data_len = strlen(data2);
      rc = funcs->C_DigestUpdate( session, data2, data_len );
      if (rc != CKR_OK) {
         show_error("   C_DigestUpdate #2", rc );
         return FALSE;
      }

      hash_len = sizeof(hash);
      rc = funcs->C_DigestFinal( session, hash, &hash_len );
      if (rc != CKR_OK) {
         show_error("   C_DigestFinal #2", rc );
         return FALSE;
      }

      if (hash_len != 20) {
         printf("   ERROR #7:  hash_len == %d, expected 20\n", hash_len );
         return FALSE;
      }

      if (memcmp(hash, expected2, hash_len) != 0) {
         printf("   ERROR #8:  hash output mismatch\n" );
         return FALSE;
      }
   }

   // now, do custom testing
   //
   {
      CK_BYTE           data[BIG_REQUEST];
      CK_BYTE           hash1[SHA1_HASH_LEN];
      CK_BYTE           hash2[SHA1_HASH_LEN];
      CK_BYTE           hash3[SHA1_HASH_LEN];
      CK_ULONG          data_len;
      CK_ULONG          hash_len;

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

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


      // first, hash it all in 1 big block
      //
      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;
      }

      if (hash_len != SHA1_HASH_LEN) {
         printf("   ERROR #9:  expected len1 to be %d.  Got %d instead\n\n", SHA1_HASH_LEN, hash_len );
         return FALSE;
      }


      // now, hash it in 64-byte chunks.  this is an even multiple of the SHA1
      // blocksize
      //
      rc = funcs->C_DigestInit( session, &mech );
      if (rc != CKR_OK) {
         show_error("   C_DigestInit #6", rc );
         return FALSE;
      }

      for (i=0; i < sizeof(data); i += 64) {
         CK_ULONG size = sizeof(data) - i;
         size = MIN(size, 64);

         rc = funcs->C_DigestUpdate( session, &data[i], size );
         if (rc != CKR_OK) {
            show_error("   C_DigestUpdate #3", rc );
            printf("   Offset:  %d\n", i);
            return FALSE;
         }
      }

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

      if (hash_len != SHA1_HASH_LEN) {
         printf("   ERROR #10:  expected len2 to be %d.  Got %d instead\n\n", SHA1_HASH_LEN, hash_len );
         return FALSE;
      }


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


      // finally, hash it in 47-byte chunks.  this is not a multiple of the SHA1
      // block size.  it should exercise our ability to buffer requests
      // for the internal SHA1 restrictions
      //
      for (i=0; i < sizeof(data); i += 47) {
         CK_ULONG size = sizeof(data) - i;
         size = MIN(size, 47);

         rc = funcs->C_DigestUpdate( session, &data[i], size );
         if (rc != CKR_OK) {
            show_error("   C_DigestUpdate #4", rc );
            printf("   Offset:  %d\n", i);
            return FALSE;
         }
      }

      hash_len = sizeof(hash3);
      rc = funcs->C_DigestFinal( session, hash3, &hash_len );
      if (rc != CKR_OK) {
         show_error("   C_DigestFinal #4", rc );
         return FALSE;
      }

      if (hash_len != SHA1_HASH_LEN) {
         printf("   ERROR #11:  expected len3 to be %d.  Got %d instead\n\n", SHA1_HASH_LEN, hash_len );
         return FALSE;
      }


      // the hashes better be the same
      //
      if (memcmp(hash1, hash2, sizeof(hash1)) != 0) {
         printf("   ERROR #12:  hashes 1 and 2 don't match\n");
         return FALSE;
      }

      if (memcmp(hash1, hash3, sizeof(hash1)) != 0) {
         printf("   ERROR #13:  hashes 1 and 3 don't match\n");
         return FALSE;
      }
   }


   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_Digest_MD2( void )
{
   CK_SESSION_HANDLE session;
   CK_SLOT_ID        slot_id;
   CK_MECHANISM      mech;
   CK_BYTE           data[BIG_REQUEST];
   CK_BYTE           hash1[MD2_HASH_LEN];
   CK_BYTE           hash2[MD2_HASH_LEN];
   CK_BYTE           hash3[MD2_HASH_LEN];
   CK_ULONG          flags;
   CK_ULONG          data_len;
   CK_ULONG          hash_len;
   CK_ULONG          i;
   CK_RV             rc;


   printf("do_Digest_MD2...\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;
   }

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

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


   // first, hash it all in 1 big block
   //
   rc = funcs->C_DigestInit( session, &mech );
   if (rc != CKR_OK) {
      show_error("   C_DigestInit #1", 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 #1", rc );
      return FALSE;
   }

   if (hash_len != MD2_HASH_LEN) {
      printf("   ERROR:  expected len1 to be %d.  Got %d instead\n\n", MD2_HASH_LEN, hash_len );
      return FALSE;
   }


   // now hash in 64-byte chunks
   //
   rc = funcs->C_DigestInit( session, &mech );
   if (rc != CKR_OK) {
      show_error("   C_DigestInit #2", rc );
      return FALSE;
   }

   for (i=0; i < sizeof(data); i += 64) {
      CK_ULONG size = sizeof(data) - i;
      size = MIN(size, 64);

      rc = funcs->C_DigestUpdate( session, &data[i], size );
      if (rc != CKR_OK) {
         show_error("   C_DigestUpdate #1", rc );
         printf("   Offset:  %d\n", i);
         return FALSE;
      }
   }

   hash_len = sizeof(hash2);
   rc = funcs->C_DigestFinal( session, hash2, &hash_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #1", rc );
      return FALSE;
   }

   if (hash_len != MD2_HASH_LEN) {
      printf("   ERROR:  expected len2 to be %d.  Got %d instead\n\n", MD2_HASH_LEN, hash_len );
      return FALSE;
   }


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


   // finally, hash it in 47-byte chunks.
   //
   for (i=0; i < sizeof(data); i += 47) {
      CK_ULONG size = sizeof(data) - i;
      size = MIN(size, 47);

      rc = funcs->C_DigestUpdate( session, &data[i], size );
      if (rc != CKR_OK) {
         show_error("   C_DigestUpdate #2", rc );
         printf("   Offset:  %d\n", i);
         return FALSE;
      }
   }

   hash_len = sizeof(hash3);
   rc = funcs->C_DigestFinal( session, hash3, &hash_len );
   if (rc != CKR_OK) {
      show_error("   C_DigestFinal #2", rc );
      return FALSE;
   }