pkcs11-spy.c

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

			      CK_ULONG  ulOperationStateLen,
			      CK_OBJECT_HANDLE hEncryptionKey,
			      CK_OBJECT_HANDLE hAuthenticationKey)
{
  CK_RV rv;
  enter("SetOperationState");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_string_in("pOperationState[ulOperationStateLen]",
		     pOperationState, ulOperationStateLen);
  spy_dump_ulong_in("hEncryptionKey", hEncryptionKey);
  spy_dump_ulong_in("hAuthenticationKey", hAuthenticationKey);
  rv = po->C_SetOperationState(hSession, pOperationState,
			       ulOperationStateLen,
			       hEncryptionKey,
			       hAuthenticationKey);
  return retne(rv);
}


CK_RV C_Login(CK_SESSION_HANDLE hSession,
		  CK_USER_TYPE userType,
		  CK_UTF8CHAR_PTR pPin,
		  CK_ULONG  ulPinLen)
{
  CK_RV rv;
  enter("C_Login");
  spy_dump_ulong_in("hSession", hSession);
  fprintf(spy_output, "[in] userType = %s\n",
	  lookup_enum(USR_T, userType));
  spy_dump_string_in("pPin[ulPinLen]", pPin, ulPinLen);
  rv = po->C_Login(hSession, userType, pPin, ulPinLen);
  return retne(rv);
}

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

CK_RV C_CreateObject(CK_SESSION_HANDLE hSession,
			 CK_ATTRIBUTE_PTR pTemplate,
			 CK_ULONG  ulCount,
			 CK_OBJECT_HANDLE_PTR phObject)
{
  CK_RV rv;
  enter("C_CreateObject");
  spy_dump_ulong_in("hSession", hSession);
  spy_attribute_list_in("pTemplate", pTemplate, ulCount);
  rv = po->C_CreateObject(hSession, pTemplate, ulCount, phObject);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("*phObject", *phObject);
  }
  return retne(rv);
}

CK_RV C_CopyObject(CK_SESSION_HANDLE hSession,
		       CK_OBJECT_HANDLE hObject,
		       CK_ATTRIBUTE_PTR pTemplate,
		       CK_ULONG  ulCount,
		       CK_OBJECT_HANDLE_PTR phNewObject)
{
  CK_RV rv;
  enter("C_CopyObject");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_ulong_in("hObject", hObject);
  spy_attribute_list_in("pTemplate", pTemplate, ulCount);
  rv = po->C_CopyObject(hSession, hObject, pTemplate, ulCount, phNewObject);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("*phNewObject", *phNewObject);
  }
  return retne(rv);
}


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


CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession,
			  CK_OBJECT_HANDLE hObject,
			  CK_ULONG_PTR pulSize)
{
  CK_RV rv;
  enter("C_GetObjectSize");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_ulong_in("hObject", hObject);
  rv = po->C_GetObjectSize(hSession, hObject, pulSize);
  if (rv == CKR_OK) {
    spy_dump_ulong_out("*pulSize", *pulSize);
  }
  return retne(rv);
}


CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession,
			      CK_OBJECT_HANDLE hObject,
			      CK_ATTRIBUTE_PTR pTemplate,
			      CK_ULONG  ulCount)
{
  CK_RV rv;
  enter("C_GetAttributeValue");
  spy_dump_ulong_in("hSession", hSession);
  spy_attribute_req_in("pTemplate", pTemplate, ulCount);
  rv = po->C_GetAttributeValue(hSession, hObject, pTemplate, ulCount);
  if (rv == CKR_OK) {
    spy_attribute_list_out("pTemplate", pTemplate, ulCount);
  }
  return retne(rv);
}


CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession,
			      CK_OBJECT_HANDLE hObject,
			      CK_ATTRIBUTE_PTR pTemplate,
			      CK_ULONG  ulCount)
{
  CK_RV rv;
  enter("C_SetAttributeValue");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_ulong_in("hObject", hObject);
  spy_attribute_list_in("pTemplate", pTemplate, ulCount);
  rv = po->C_SetAttributeValue(hSession, hObject, pTemplate, ulCount);
  return retne(rv);
}


CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession,
			    CK_ATTRIBUTE_PTR pTemplate,
			    CK_ULONG  ulCount)
{
  CK_RV rv;
  enter("C_FindObjectsInit");
  spy_dump_ulong_in("hSession", hSession);
  spy_attribute_list_in("pTemplate", pTemplate, ulCount);
  rv = po->C_FindObjectsInit(hSession, pTemplate, ulCount);
  return retne(rv);
}


CK_RV C_FindObjects(CK_SESSION_HANDLE hSession,
			CK_OBJECT_HANDLE_PTR phObject,
			CK_ULONG  ulMaxObjectCount,
			CK_ULONG_PTR  pulObjectCount)
{
  CK_RV rv;
  enter("C_FindObjects");
  spy_dump_ulong_in("hSession", hSession);
  spy_dump_ulong_in("ulMaxObjectCount", ulMaxObjectCount);
  rv = po->C_FindObjects(hSession, phObject, ulMaxObjectCount,
			 pulObjectCount);
  if (rv == CKR_OK) {
    CK_ULONG          i;
    spy_dump_ulong_out("ulObjectCount", *pulObjectCount);
    for (i = 0; i < *pulObjectCount; i++) {
      fprintf(spy_output, "Object %ld Matches\n", phObject[i]);
    }
  }
  return retne(rv);
}


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

CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession,
			CK_MECHANISM_PTR pMechanism,
			CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_EncryptInit");
  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_EncryptInit(hSession, pMechanism, hKey);
  return retne(rv);
}


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


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

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


CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession,
			CK_MECHANISM_PTR pMechanism,
			CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_DecryptInit");
  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_DecryptInit(hSession, pMechanism, hKey);
  return retne(rv);
}


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


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


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

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


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


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


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


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

CK_RV C_SignInit(CK_SESSION_HANDLE hSession,
		     CK_MECHANISM_PTR pMechanism,
		     CK_OBJECT_HANDLE hKey)
{
  CK_RV rv;
  enter("C_SignInit");
  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_SignInit(hSession, pMechanism, hKey);
  return retne(rv);
}


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