📄 enumobjdlg.cpp

📁 PKCS#11 读取USB KEY证书
💻 CPP
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
// EnumObjDlg.cpp : implementation file
//

#include "stdafx.h"
#include "EnumObj.h"
#include "EnumObjDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "DlgUserPIN.h"

#define NEWLINE "\r\n"


/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

//////////////////////////////////////////////////////////////////////////
//byte to string according with special format
static CString nByteToStr(DWORD dwSize, void* pData, DWORD dwByte, DWORD dwSplit);
int sign(CK_RV   rv,CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE privatekey);
CString nByteToStr(DWORD dwSize, void* pData, DWORD dwByte, DWORD dwSplit)
{
	BYTE* pBuf = (BYTE*)pData; // local pointer to a BYTE in the BYTE array.
	
	CString strRet("");	
	DWORD nLine = 0;	
	DWORD dwLines = 0;
	DWORD dwRest = 0;
	bool bNeedSplit = true;
	char szTemp[20] = {0, };
	
	DWORD dwBlock = 0;	
	if(0 == dwSplit)
	{
		dwSplit = dwSize;
		bNeedSplit = false;
	}
	
	dwRest = dwSize % dwSplit;
	dwLines = dwSize / dwSplit;
	
	DWORD i, j, k, m;
	for(i = 0; i < dwLines; i++)
	{
		DWORD dwRestTemp = dwSplit % dwByte;
		DWORD dwByteBlock = dwSplit / dwByte;
		
		for(j = 0; j < dwByteBlock; j++)
		{
			for(k = 0; k < dwByte; k++)
			{
				wsprintf(szTemp, "%02X", pBuf[i * dwSplit + j * dwByte + k]);
				strRet += szTemp;
			}
			strRet += " ";
		}
		if(dwRestTemp)
		{
			for(m = 0; m < dwRestTemp; m++)
			{
				wsprintf(
					szTemp, "%02X",
					pBuf[i * dwSplit + j * dwByte + k - 3 + dwRestTemp]);
				strRet += szTemp;
			}
		}
		if(bNeedSplit)
			strRet += NEWLINE;
	}
	
	if(dwRest)
	{
		DWORD dwRestTemp = dwRest % dwByte;
		DWORD dwByteBlock = dwRest / dwByte;
		for(j = 0; j < dwByteBlock; j++)
		{
			for(k = 0; k < dwByte; k++)
			{
				wsprintf(szTemp, "%02X", pBuf[dwSize - dwRest + k+ j * dwByte]);
				strRet += szTemp;
			}
			strRet += " ";
		}
		if(dwRestTemp)
		{
			for(m = 0; m < dwRestTemp; m++)
			{
				wsprintf(
					szTemp, "%02X",
					pBuf[dwSize - dwRest + k - 1 + dwRestTemp]);
				strRet += szTemp;
			}
		}
		if(bNeedSplit)
			strRet += NEWLINE;
	}
	
	
	return strRet;
}  // End of ByteToStr

CString parse_bool_val(CK_ATTRIBUTE& attr)
{
	BOOL b = ((BOOL*)(attr.pValue))[0];
	if(b)
		return "TRUE";
	else
		return "FALSE";
}

CString parse_bin_val(CK_ATTRIBUTE& attr)
{
	return nByteToStr(attr.ulValueLen, attr.pValue, 1, 16);
}

CString parse_string_val(CK_ATTRIBUTE& attr)
{
	if('\0' != ((char*)attr.pValue)[attr.ulValueLen])
		return "[!! NOT STRING !!]";
	char* sz = (char*)attr.pValue;
	if(0 == lstrlen(sz))
		return "[!! NULL !!]";
	return sz;
}

bool parse_object(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CString& strRet)
{
	strRet = NEWLINE;
	for(ULONG i = 0; i < ulCount; ++i)
	{
		CK_ATTRIBUTE& attr = pTemplate[i];

		switch(attr.type)
		{
		case CKA_TOKEN:				strRet += "CKA_TOKEN             : "; break;
		case CKA_PRIVATE:			strRet += "CKA_PRIVATE           : "; break;
		case CKA_TRUSTED:			strRet += "CKA_TRUSTED           : "; break;
		case CKA_SENSITIVE:			strRet += "CKA_SENSITIVE         : "; break;
		case CKA_ENCRYPT:			strRet += "CKA_ENCRYPT           : "; break;
		case CKA_DECRYPT:			strRet += "CKA_DECRYPT           : "; break;
		case CKA_WRAP:				strRet += "CKA_WRAP              : "; break;
		case CKA_UNWRAP:			strRet += "CKA_UNWRAP            : "; break;
		case CKA_SIGN:				strRet += "CKA_SIGN              : "; break;
		case CKA_SIGN_RECOVER:		strRet += "CKA_SIGN_RECOVER      : "; break;
		case CKA_VERIFY:			strRet += "CKA_VERIFY            : "; break;
		case CKA_VERIFY_RECOVER:	strRet += "CKA_VERIFY_RECOVER    : "; break;
		case CKA_DERIVE:			strRet += "CKA_DERIVE            : "; break;
		case CKA_EXTRACTABLE:		strRet += "CKA_EXTRACTABLE       : "; break;
		case CKA_LOCAL:				strRet += "CKA_LOCAL             : "; break;
		case CKA_NEVER_EXTRACTABLE:	strRet += "CKA_NEVER_EXTRACTABLE : "; break;
		case CKA_ALWAYS_SENSITIVE:	strRet += "CKA_ALWAYS_SENSITIVE  : "; break;
		case CKA_MODIFIABLE:		strRet += "CKA_MODIFIABLE        : "; break;
		case CKA_LABEL:				strRet += "CKA_LABEL             : "; break;
		case CKA_APPLICATION:		strRet += "CKA_APPLICATION       : "; break;
		case CKA_VALUE:				strRet += "CKA_VALUE             : "; break;
		case CKA_OBJECT_ID:			strRet += "CKA_OBJECT_ID         : "; break;
		case CKA_CERTIFICATE_TYPE:	strRet += "CKA_CERTIFICATE_TYPE  : "; break;
		case CKA_ISSUER:			strRet += "CKA_ISSUER            : "; break;
		case CKA_SERIAL_NUMBER:		strRet += "CKA_SERIAL_NUMBER     : "; break;
		case CKA_AC_ISSUER:			strRet += "CKA_AC_ISSUER         : "; break;
		case CKA_OWNER:				strRet += "CKA_OWNER             : "; break;
		case CKA_ATTR_TYPES:		strRet += "CKA_ATTR_TYPES        : "; break;
		case CKA_KEY_TYPE:			strRet += "CKA_KEY_TYPE          : "; break;
		case CKA_SUBJECT:			strRet += "CKA_SUBJECT           : "; break;
		case CKA_ID:				strRet += "CKA_ID                : "; break;
		case CKA_START_DATE:		strRet += "CKA_START_DATE        : "; break;
		case CKA_END_DATE:			strRet += "CKA_END_DATE          : "; break;
		case CKA_MODULUS:			strRet += "CKA_MODULUS           : "; break;
		case CKA_MODULUS_BITS:		strRet += "CKA_MODULUS_BITS      : "; break;
		case CKA_PUBLIC_EXPONENT:	strRet += "CKA_PUBLIC_EXPONENT   : "; break;
		case CKA_PRIVATE_EXPONENT:	strRet += "CKA_PRIVATE_EXPONENT  : "; break;
		case CKA_PRIME_1:			strRet += "CKA_PRIME_1           : "; break;
		case CKA_PRIME_2:			strRet += "CKA_PRIME_2           : "; break;
		case CKA_EXPONENT_1:		strRet += "CKA_EXPONENT_1        : "; break;
		case CKA_EXPONENT_2:		strRet += "CKA_EXPONENT_2        : "; break;
		case CKA_COEFFICIENT:		strRet += "CKA_COEFFICIENT       : "; break;
		case CKA_PRIME:				strRet += "CKA_PRIME             : "; break;
		case CKA_SUBPRIME:			strRet += "CKA_SUBPRIME          : "; break;
		case CKA_BASE:				strRet += "CKA_BASE              : "; break;
		case CKA_PRIME_BITS:		strRet += "CKA_PRIME_BITS        : "; break;
		case CKA_SUBPRIME_BITS:		strRet += "CKA_SUBPRIME_BITS (or CKA_SUB_PRIME_BITS): "; break;
		case CKA_VALUE_BITS:		strRet += "CKA_VALUE_BITS        : "; break;
		case CKA_VALUE_LEN:			strRet += "CKA_VALUE_LEN         : "; break;
		case CKA_KEY_GEN_MECHANISM:	strRet += "CKA_KEY_GEN_MECHANISM : "; break;
		case CKA_ECDSA_PARAMS:		strRet += "CKA_ECDSA_PARAMS (or CKA_EC_PARAMS): "; break;
		case CKA_EC_POINT:			strRet += "CKA_EC_POINT          : "; break;
		case CKA_SECONDARY_AUTH:	strRet += "CKA_SECONDARY_AUTH    : "; break;
		case CKA_AUTH_PIN_FLAGS:	strRet += "CKA_AUTH_PIN_FLAGS    : "; break;
		case CKA_HW_FEATURE_TYPE:	strRet += "CKA_HW_FEATURE_TYPE   : "; break;
		case CKA_RESET_ON_INIT:		strRet += "CKA_RESET_ON_INIT     : "; break;
		case CKA_HAS_RESET:			strRet += "CKA_HAS_RESET         : "; break;
		case CKA_CLASS: 			strRet += "CKA_CLASS             : "; break;
		default: {char szTemp[60] = {0}; sprintf(szTemp, "Unknown Attribute Type: 0x%08X."NEWLINE, attr.type); strRet += szTemp;}
		}

		switch(attr.type)
		{
//============================================================================
// boolean:

		case CKA_TOKEN:
		case CKA_PRIVATE:
		case CKA_TRUSTED:
		case CKA_SENSITIVE:
		case CKA_ENCRYPT:
		case CKA_DECRYPT:
		case CKA_WRAP:
		case CKA_UNWRAP:
		case CKA_SIGN:
		case CKA_SIGN_RECOVER:
		case CKA_VERIFY:
		case CKA_VERIFY_RECOVER:
		case CKA_DERIVE:
		case CKA_EXTRACTABLE:
		case CKA_LOCAL:
		case CKA_NEVER_EXTRACTABLE:
		case CKA_ALWAYS_SENSITIVE:
		case CKA_MODIFIABLE:
			{
				strRet += parse_bool_val(attr);
				strRet += NEWLINE;
			}
			break;


//============================================================================
// string.
		case CKA_LABEL:
		case CKA_APPLICATION:
			{
				strRet += parse_string_val(attr);
				strRet += NEWLINE;
			}
			break;

//============================================================================
// binary.
		case CKA_VALUE:
		case CKA_OBJECT_ID:
		case CKA_AC_ISSUER:
		case CKA_OWNER:
		case CKA_SERIAL_NUMBER:
		case CKA_ID:
		case CKA_MODULUS:
		case CKA_MODULUS_BITS:
		case CKA_PUBLIC_EXPONENT:
		case CKA_PRIVATE_EXPONENT:
			{
				strRet += NEWLINE;
				strRet += parse_bin_val(attr);
				strRet += NEWLINE;
			}
			break;


		case CKA_ATTR_TYPES:
		case CKA_START_DATE:
		case CKA_END_DATE:
		case CKA_BASE:
		case CKA_VALUE_LEN:
		case CKA_KEY_GEN_MECHANISM:
		case CKA_ECDSA_PARAMS:
		case CKA_EC_POINT:
		case CKA_SECONDARY_AUTH:
		case CKA_AUTH_PIN_FLAGS:
		case CKA_HW_FEATURE_TYPE:
		case CKA_RESET_ON_INIT:
		case CKA_HAS_RESET:
		case CKA_PRIME_1:
		case CKA_PRIME_2:
		case CKA_EXPONENT_1:
		case CKA_EXPONENT_2:
		case CKA_COEFFICIENT:
		case CKA_PRIME:
		case CKA_SUBPRIME:
		case CKA_PRIME_BITS:
		case CKA_SUBPRIME_BITS:
		case CKA_VALUE_BITS:
			strRet += "???"NEWLINE;
			break;

		case CKA_CLASS:
			{
				CK_ULONG ulClass = ((CK_ULONG*)(attr.pValue)) [0];
				switch( ulClass )
				{
				case CKO_DATA:
					strRet += "CKO_DATA"NEWLINE;
					break;
				case CKO_CERTIFICATE:
					strRet += "CKO_CERTIFICATE"NEWLINE;
					break;
				case CKO_PUBLIC_KEY:
					strRet += "CKO_PUBLIC_KEY"NEWLINE;
					break;
				case CKO_PRIVATE_KEY:
					strRet += "CKO_PRIVATE_KEY"NEWLINE;
					break;
				case CKO_SECRET_KEY:
					strRet += "CKO_SECRET_KEY"NEWLINE;
					break;
				case CKO_HW_FEATURE:
					strRet += "CKO_HW_FEATURE"NEWLINE;
					break;
				case CKO_DOMAIN_PARAMETERS:
					strRet += "CKO_DOMAIN_PARAMETERS"NEWLINE;
					break;
				default:
					{
						char szTemp[60] = {0};
						sprintf(szTemp, "Unknown Object Class: 0x%08X."NEWLINE, ulClass);
						strRet += szTemp;
					}
					break;
				}
			}
			break;

		case CKA_CERTIFICATE_TYPE:
			{
				CK_ULONG ulType = ((CK_ULONG*)(attr.pValue)) [0];
				switch(ulType)
				{
				case CKC_X_509:
					strRet += "CKC_X_509"NEWLINE;
					break;
				case CKC_X_509_ATTR_CERT:
					strRet += "CKC_X_509_ATTR_CERT"NEWLINE;
					break;
				default:
					{
						char szTemp[60] = {0};
						sprintf(szTemp, "Unknown Certificate Type: 0x%08X."NEWLINE, ulType);
						strRet += szTemp;
					}
					break;
				}
			}
			break;


		case CKA_KEY_TYPE:
			{
				CK_ULONG ulType = ((CK_ULONG*)(attr.pValue)) [0];
				switch( ulType )
				{
				case CKK_RSA:
					strRet += "CKK_RSA"NEWLINE;
					break;
				case CKK_DSA:
					strRet += "CKK_DSA"NEWLINE;
					break;
				case CKK_DH:
					strRet += "CKK_DH"NEWLINE;
					break;
				case CKK_ECDSA:
					strRet += "CKK_ECDSA (or CKK_EC)"NEWLINE;
					break;
				case CKK_X9_42_DH:
					strRet += "CKK_X9_42_DH"NEWLINE;
					break;
				case CKK_KEA:
					strRet += "CKK_KEA"NEWLINE;
					break;
				case CKK_GENERIC_SECRET:
					strRet += "CKK_GENERIC_SECRET"NEWLINE;
					break;
				case CKK_RC2:
					strRet += "CKK_RC2"NEWLINE;
					break;
				case CKK_RC4:
					strRet += "CKK_RC4"NEWLINE;
					break;
				case CKK_DES:
					strRet += "CKK_DES"NEWLINE;
					break;
				case CKK_DES2:
					strRet += "CKK_DES2"NEWLINE;
					break;
				case CKK_DES3:
					strRet += "CKK_DES3"NEWLINE;
					break;
				case CKK_CAST:
					strRet += "CKK_CAST"NEWLINE;
					break;
				case CKK_CAST3:
					strRet += "CKK_CAST3"NEWLINE;
					break;
				case CKK_CAST5:
					strRet += "CKK_CAST5 (or CKK_CAST128)"NEWLINE;
					break;
				case CKK_RC5:
					strRet += "CKK_RC5"NEWLINE;
					break;
				case CKK_IDEA:
					strRet += "CKK_IDEA"NEWLINE;
					break;
				case CKK_SKIPJACK:
					strRet += "CKK_SKIPJACK"NEWLINE;
					break;
				case CKK_BATON:
					strRet += "CKK_BATON"NEWLINE;
					break;
				case CKK_JUNIPER:
					strRet += "CKK_JUNIPER"NEWLINE;
					break;
				case CKK_CDMF:
					strRet += "CKK_CDMF"NEWLINE;
					break;
				case CKK_AES:
					strRet += "CKK_AES"NEWLINE;
					break;
				default:
					{
						char szTemp[60] = {0};
						sprintf(szTemp, "Unknown Key Type: 0x%08X."NEWLINE, ulType);
						strRet += szTemp;
					}
					break;
				}
			}
			break;



		case CKA_ISSUER:
		case CKA_SUBJECT:
			{
				if(0 == attr.ulValueLen)
				{
					strRet += "[!! NULL !!]"NEWLINE;
					continue;
				}

				CString strsubject;
				CERT_NAME_BLOB  SubName;
				SubName.cbData = attr.ulValueLen;
				SubName.pbData = (BYTE*)attr.pValue;

				DWORD dwStrDetailType =
					CERT_NAME_STR_NO_QUOTING_FLAG | 
					CERT_NAME_STR_REVERSE_FLAG |
12 3 下一页
💿 文件大小 5722 K
👤 上传用户 pjamytian
📂 所属分类 Linux/Unix编程
🏷️ 相关标签

#PKCS #KEY #USB #11
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -