pkcs11-spy.c

读写Smart卡加解密接口的程序

			pSignature, *pulSignatureLen);
  }
  return retne(rv);
}


CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession,
		       CK_BYTE_PTR pPart,
		       CK_ULONG  ulPartLen)
{
  CK_RV rv;
  enter("C_SignUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
  rv = po->C_SignUpdate(hSession, pPart, ulPartLen);
  return retne(rv);
}


CK_RV C_SignFinal(CK_SESSION_HANDLE hSession,
		      CK_BYTE_PTR pSignature,
		      CK_ULONG_PTR pulSignatureLen)
{
  CK_RV rv;
  enter("C_SignFinal");
  spy_dump_ulong_in("hSession", hSession);
  rv = po->C_SignFinal(hSession, pSignature, pulSignatureLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pSignature[*pulSignatureLen]",
			pSignature, *pulSignatureLen);
  }
  return retne(rv);
}


CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession,
			    CK_MECHANISM_PTR pMechanism,
			    CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_SignRecoverInit");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hKey", hKey);
  rv = po->C_SignRecoverInit(hSession, pMechanism, hKey);
  return retne(rv);
}


CK_RV C_SignRecover(CK_SESSION_HANDLE hSession,
			CK_BYTE_PTR pData,
			CK_ULONG  ulDataLen,
			CK_BYTE_PTR pSignature,
			CK_ULONG_PTR pulSignatureLen)
{
  CK_RV rv;
  enter("C_SignRecover");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
  rv = po->C_SignRecover(hSession, pData, ulDataLen,
			 pSignature, pulSignatureLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pSignature[*pulSignatureLen]",
			pSignature, *pulSignatureLen);
  }
  return retne(rv);
}

CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession,
		       CK_MECHANISM_PTR pMechanism,
		       CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_VerifyInit");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hKey", hKey);
  rv = po->C_VerifyInit(hSession, pMechanism, hKey);
  return retne(rv);
}


CK_RV C_Verify(CK_SESSION_HANDLE hSession,
		   CK_BYTE_PTR pData,
		   CK_ULONG  ulDataLen,
		   CK_BYTE_PTR pSignature,
		   CK_ULONG  ulSignatureLen)
{
  CK_RV rv;
  enter("C_Verify");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pData[ulDataLen]", pData, ulDataLen);
  spy_dump_string_in("pSignature[ulSignatureLen]",
		     pSignature, ulSignatureLen);
  rv = po->C_Verify(hSession, pData, ulDataLen, pSignature, ulSignatureLen);
  return retne(rv);
}


CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession,
			 CK_BYTE_PTR pPart,
			 CK_ULONG  ulPartLen)
{
  CK_RV rv;
  enter("C_VerifyUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
  rv = po->C_VerifyUpdate(hSession, pPart, ulPartLen);
  return retne(rv);
}


CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession,
			CK_BYTE_PTR pSignature,
			CK_ULONG  ulSignatureLen)
{
  CK_RV rv;
  enter("C_VerifyFinal");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pSignature[ulSignatureLen]",
		     pSignature, ulSignatureLen);
  rv = po->C_VerifyFinal(hSession, pSignature, ulSignatureLen);
  return retne(rv);
}


CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,
			      CK_MECHANISM_PTR pMechanism,
			      CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_VerifyRecoverInit");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hKey", hKey);
  rv = po->C_VerifyRecoverInit(hSession, pMechanism, hKey);
  return retne(rv);
}


CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession,
			  CK_BYTE_PTR pSignature,
			  CK_ULONG  ulSignatureLen,
			  CK_BYTE_PTR pData,
			  CK_ULONG_PTR pulDataLen)
{
  CK_RV rv;
  enter("C_VerifyRecover");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pSignature[ulSignatureLen]",
		     pSignature, ulSignatureLen);
  rv = po->C_VerifyRecover(hSession, pSignature, ulSignatureLen,
			   pData, pulDataLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pData[*pulDataLen]", pData, *pulDataLen);
  }
  return retne(rv);
}

CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession,
				CK_BYTE_PTR pPart,
				CK_ULONG  ulPartLen,
				CK_BYTE_PTR pEncryptedPart,
				CK_ULONG_PTR pulEncryptedPartLen)
{
  CK_RV rv;
  enter("C_DigestEncryptUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
  rv = po->C_DigestEncryptUpdate(hSession, pPart, ulPartLen,
				 pEncryptedPart, pulEncryptedPartLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pEncryptedPart[*pulEncryptedPartLen]",
			pEncryptedPart, *pulEncryptedPartLen);
  }
  return retne(rv);
}


CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession,
				CK_BYTE_PTR pEncryptedPart,
				CK_ULONG  ulEncryptedPartLen,
				CK_BYTE_PTR pPart,
				CK_ULONG_PTR pulPartLen)
{
  CK_RV rv;
  enter("C_DecryptDigestUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]",
		      pEncryptedPart, ulEncryptedPartLen);
  rv = po->C_DecryptDigestUpdate(hSession, pEncryptedPart,
				 ulEncryptedPartLen,
				 pPart,  pulPartLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pPart[*pulPartLen]", pPart, *pulPartLen);
  }
  return retne(rv);
}


CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession,
			      CK_BYTE_PTR pPart,
			      CK_ULONG  ulPartLen,
			      CK_BYTE_PTR pEncryptedPart,
			      CK_ULONG_PTR pulEncryptedPartLen)
{
  CK_RV rv;
  enter("C_SignEncryptUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pPart[ulPartLen]", pPart, ulPartLen);
  rv = po->C_SignEncryptUpdate(hSession, pPart, ulPartLen,
			       pEncryptedPart, pulEncryptedPartLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pEncryptedPart[*pulEncryptedPartLen]",
			pEncryptedPart, *pulEncryptedPartLen);
  }
  return retne(rv);
}


CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession,
				CK_BYTE_PTR pEncryptedPart,
				CK_ULONG  ulEncryptedPartLen,
				CK_BYTE_PTR pPart,
				CK_ULONG_PTR pulPartLen)
{
  CK_RV rv;
  enter("C_DecryptVerifyUpdate");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pEncryptedPart[ulEncryptedPartLen]",
		      pEncryptedPart, ulEncryptedPartLen);
  rv = po->C_DecryptVerifyUpdate(hSession, pEncryptedPart,
				 ulEncryptedPartLen, pPart,
				 pulPartLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pPart[*pulPartLen]", pPart, *pulPartLen);
  }
  return retne(rv);
}

CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession,
			CK_MECHANISM_PTR pMechanism,
			CK_ATTRIBUTE_PTR pTemplate,
			CK_ULONG  ulCount,
			CK_OBJECT_HANDLE_PTR phKey)
{
  CK_RV rv;
  enter("C_GenerateKey");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_attribute_list_in("pTemplate", pTemplate, ulCount);
  rv = po->C_GenerateKey(hSession, pMechanism, pTemplate,
			 ulCount, phKey);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("hKey", *phKey);
  }
  return retne(rv);
}

CK_RV C_GenerateKeyPair(CK_SESSION_HANDLE hSession,
			    CK_MECHANISM_PTR pMechanism,
			    CK_ATTRIBUTE_PTR pPublicKeyTemplate,
			    CK_ULONG  ulPublicKeyAttributeCount,
			    CK_ATTRIBUTE_PTR pPrivateKeyTemplate,
			    CK_ULONG  ulPrivateKeyAttributeCount,
			    CK_OBJECT_HANDLE_PTR phPublicKey,
			    CK_OBJECT_HANDLE_PTR phPrivateKey)
{
  CK_RV rv;
  enter("C_GenerateKeyPair");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_attribute_list_in("pPublicKeyTemplate",
			pPublicKeyTemplate, ulPublicKeyAttributeCount);
  spy_attribute_list_in("pPrivateKeyTemplate",
			pPrivateKeyTemplate, ulPrivateKeyAttributeCount);
  rv = po->C_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate,
			     ulPublicKeyAttributeCount, pPrivateKeyTemplate,
			     ulPrivateKeyAttributeCount, phPublicKey,
			     phPrivateKey);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("hPublicKey", *phPublicKey);
    spy_dump_ulong_out("hPrivateKey", *phPrivateKey);
  }
  return retne(rv);
}


CK_RV C_WrapKey(CK_SESSION_HANDLE hSession,
		    CK_MECHANISM_PTR pMechanism,
		    CK_OBJECT_HANDLE hWrappingKey,
		    CK_OBJECT_HANDLE hKey,
		    CK_BYTE_PTR pWrappedKey,
		    CK_ULONG_PTR pulWrappedKeyLen)
{
  CK_RV rv;
  enter("C_WrapKey");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hWrappingKey", hWrappingKey);
  spy_dump_ulong_in("hKey", hKey);
  rv = po->C_WrapKey(hSession, pMechanism, hWrappingKey,
		     hKey, pWrappedKey, pulWrappedKeyLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("pWrappedKey[*pulWrappedKeyLen]",
			pWrappedKey, *pulWrappedKeyLen);
  }
  return retne(rv);
}

CK_RV C_UnwrapKey(CK_SESSION_HANDLE hSession,
		      CK_MECHANISM_PTR pMechanism,
		      CK_OBJECT_HANDLE hUnwrappingKey,
		      CK_BYTE_PTR  pWrappedKey,
		      CK_ULONG  ulWrappedKeyLen,
		      CK_ATTRIBUTE_PTR pTemplate,
		      CK_ULONG  ulAttributeCount,
		      CK_OBJECT_HANDLE_PTR phKey)
{
  CK_RV rv;
  enter("C_UnwrapKey");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hUnwrappingKey", hUnwrappingKey);
  spy_dump_string_in("pWrappedKey[ulWrappedKeyLen]",
		      pWrappedKey, ulWrappedKeyLen);
  spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount);
  rv = po->C_UnwrapKey(hSession, pMechanism, hUnwrappingKey,
		       pWrappedKey, ulWrappedKeyLen, pTemplate,
		       ulAttributeCount, phKey);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("hKey", *phKey);
  }
  return retne(rv);
}

CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession,
		      CK_MECHANISM_PTR pMechanism,
		      CK_OBJECT_HANDLE hBaseKey,
		      CK_ATTRIBUTE_PTR pTemplate,
		      CK_ULONG  ulAttributeCount,
		      CK_OBJECT_HANDLE_PTR phKey)
{
  CK_RV rv;
  enter("C_DeriveKey");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "pMechanism->type=%s\n",
	  lookup_enum(MEC_T, pMechanism->mechanism));
  spy_dump_ulong_in("hBaseKey", hBaseKey);
  spy_attribute_list_in("pTemplate", pTemplate, ulAttributeCount);
  rv = po->C_DeriveKey(hSession, pMechanism, hBaseKey,
		       pTemplate, ulAttributeCount, phKey);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("hKey", *phKey);
  }
  return retne(rv);
}

CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession,
		       CK_BYTE_PTR pSeed,
		       CK_ULONG  ulSeedLen)
{
  CK_RV rv;
  enter("C_SeedRandom");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pSeed[ulSeedLen]", pSeed, ulSeedLen);
  rv = po->C_SeedRandom(hSession, pSeed, ulSeedLen);
  return retne(rv);
}


CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession,
			   CK_BYTE_PTR RandomData,
			   CK_ULONG  ulRandomLen)
{
  CK_RV rv;
  enter("C_GenerateRandom");
  spy_dump_ulong_in("hSession", hSession);
  rv = po->C_GenerateRandom(hSession, RandomData, ulRandomLen);
  if (rv == CKR_OK) {
    spy_dump_string_out("RandomData[ulRandomLen]",
			RandomData, ulRandomLen);
  }
  return retne(rv);
}


CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
{
  CK_RV rv;
  enter("C_GetFunctionStatus");
  spy_dump_ulong_in("hSession", hSession);
  rv = po->C_GetFunctionStatus(hSession);
  return retne(rv);
}

CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession)
{
  CK_RV rv;
  enter("C_CancelFunction");
  spy_dump_ulong_in("hSession", hSession);
  rv = po->C_CancelFunction(hSession);
  return retne(rv);
}

CK_RV C_WaitForSlotEvent(CK_FLAGS flags,
			     CK_SLOT_ID_PTR pSlot,
			     CK_VOID_PTR pRserved)
{
  CK_RV rv;
  enter("C_WaitForSlotEvent");
  rv = po->C_WaitForSlotEvent(flags, pSlot, pRserved);
  return retne(rv);
}