tool.cpp

对数据进行base64编码

 *                                   如果为私钥，则还需要输入pbD、pbP、pbQ、等
 * 返 回 值：成功，返回0；否则，返回相应的错误值。
 * 历    史：
*********************************************************************/

//ToDER() 函数用到的宏定义
#define CKA_MODULUS                 0x00000120
#define CKA_MODULUS_BITS            0x00000121
#define CKA_PUBLIC_EXPONENT         0x00000122
#define CKA_PRIVATE_EXPONENT        0x00000123
#define CKA_PRIME_1                 0x00000124
#define CKA_PRIME_2                 0x00000125
#define CKA_EXPONENT_1              0x00000126
#define CKA_EXPONENT_2              0x00000127
#define CKA_COEFFICIENT             0x00000128



#define USBKEY_INVALID_PARAMETER    1           //返回值定义：参数无效

//little endian
DWORD CTool::ToDER(
		   OUT BYTE *pbDERValue,
		   IN OUT DWORD *pdwDERValueLen,
		   IN BYTE bKeyType,
		   IN BYTE *pbBits, IN DWORD dwBitsLen,
		   IN BYTE *pbN, IN DWORD dwNLen,
		   IN BYTE *pbE, IN DWORD dwELen,
		   IN BYTE *pbD, IN DWORD dwDLen,
		   IN BYTE *pbP, IN DWORD dwPLen,
		   IN BYTE *pbQ, IN DWORD dwQLen,
		   IN BYTE *pbDP, IN DWORD dwDPLen,
		   IN BYTE *pbDQ, IN DWORD dwDQLen,
		   IN BYTE *pbQINV, IN DWORD dwQINVLen)
{
	DWORD dwRet = 0;
	BYTE baDataBuff[1024] = {0};
	BYTE baValueBuff[1024] = {0};
	DWORD dwValueBufLen = 0;
	DWORD dwDataLen = 0;
	DWORD dwOffset = 0;
	DWORD dwSquDataStart = 0;
	DWORD dwOffsetDataLen = 0;
	DWORD dwExtraTagSize = 0;
	DWORD dwStartAttrType = 0;
	DWORD dwStopType = 0;
	DWORD dwAttriType = 0;

	if(bKeyType < TYPE_PUBKEY || bKeyType > TYPE_PRIKEY)
	{
		return USBKEY_INVALID_PARAMETER;
	}
	if(bKeyType == TYPE_PUBKEY)
	{
		if(NULL == pbN || NULL == pbE)
		{
			return USBKEY_INVALID_PARAMETER;
		}
		//公钥
		//SEQUENCE 类型tag
		//0x30;
		baDataBuff[dwOffset] = CLASS_UNIVERSAL | MASK_TAG_IS_STRUCT | (MASK_TAG_VALUE & TAG_NUM_SEQ);
		dwOffset++;
		//----------------------
		//length byte,use long form,
			//127个字节。第一个字节的Bit 8为1，bit 7－1表示后面有多少个用于/表示实际长度的octet。
			//第二个和随后的octet给出实际长度，基于256，
			//高位数字在先。
		//0x81，公钥小雨256字节
		baDataBuff[dwOffset] = BIT_LEN_LONG_FORM | 0x01;
		dwOffset++;
		//最后要用真实的数据长度来修正 dwDataLen
		dwOffsetDataLen = dwOffset;
		baDataBuff[dwOffset] = 0x00;
		dwOffset++;
		
		//数据开始
		dwSquDataStart = dwOffset;
		dwDataLen = 0;
		//=======================
		

		dwStartAttrType = CKA_MODULUS;
		dwStopType = CKA_PUBLIC_EXPONENT;
	}
	else
	{
		if(NULL == pbN || NULL == pbE || NULL == pbBits || NULL == pbD ||
			NULL == pbP || NULL == pbQ || NULL == pbDP || NULL == pbDQ || NULL == pbQINV)
		{
			dwRet = USBKEY_INVALID_PARAMETER;
			goto err;
		}
		//私钥
		//SEQUENCE 类型tag
		//0x30;
		baDataBuff[dwOffset] = CLASS_UNIVERSAL | MASK_TAG_IS_STRUCT | (MASK_TAG_VALUE & TAG_NUM_SEQ);
		dwOffset++;
		//----------------------
		//length byte,use long form,
			//127个字节。第一个字节的Bit 8为1，bit 7－1表示后面有多少个用于/表示实际长度的octet。
			//第二个和随后的octet给出实际长度，基于256，
			//高位数字在先。
		//0x82
		baDataBuff[dwOffset] = BIT_LEN_LONG_FORM | 0x02;
		dwOffset++;
		//最后要用真实的数据长度来修正 dwDataLen
			//highbyte of datalen
		dwOffsetDataLen = dwOffset;
		baDataBuff[dwOffset] = 0x02;
		dwOffset++;
			//lowbyte of datalen
		baDataBuff[dwOffset] = 0x5d;
		dwOffset++;
		
		//数据开始，第一个是 version
		dwSquDataStart = dwOffset;
		
		//=======================
		//Contents octets
		dwDataLen = 0;
		//version           Version, 
		//tag num
		baDataBuff[dwOffset] = TAG_NUM_INTEGER;
		dwOffset ++;
		dwDataLen ++;
		//lengh
		baDataBuff[dwOffset] = 0x01;
		dwOffset ++;
		dwDataLen ++;
		//version = 0
		baDataBuff[dwOffset] = 0x00;
		dwOffset ++;
		dwDataLen ++;

		//=======================
		dwStartAttrType = CKA_MODULUS;
		dwStopType = CKA_COEFFICIENT;
	}

	for(dwAttriType = dwStartAttrType; dwAttriType <= dwStopType; dwAttriType++)
	{
		memset(baValueBuff, 0, sizeof(baValueBuff));
		dwValueBufLen = 0;
		switch(dwAttriType)
		{
		case CKA_MODULUS :
			memcpy(baValueBuff, pbN, dwNLen);
			dwValueBufLen = dwNLen;
			break;
		case CKA_MODULUS_BITS :
			memcpy(baValueBuff, pbBits, dwBitsLen);
			dwValueBufLen = dwBitsLen;
			break;
		case CKA_PUBLIC_EXPONENT :
			memcpy(baValueBuff, pbE, dwELen);
			dwValueBufLen = dwELen;
			break;
		case CKA_PRIVATE_EXPONENT :
			memcpy(baValueBuff, pbD, dwDLen);
			dwValueBufLen = dwDLen;
			break;
		case CKA_PRIME_1 :
			memcpy(baValueBuff, pbP, dwPLen);
			dwValueBufLen = dwPLen;
			break;
		case CKA_PRIME_2 :
			memcpy(baValueBuff, pbQ, dwQLen);
			dwValueBufLen = dwQLen;
			break;
		case CKA_EXPONENT_1 :
			memcpy(baValueBuff, pbDP, dwDPLen);
			dwValueBufLen = dwDPLen;
			break;
		case CKA_EXPONENT_2 :
			memcpy(baValueBuff, pbDQ, dwDQLen);
			dwValueBufLen = dwDQLen;
			break;
		case CKA_COEFFICIENT :
			memcpy(baValueBuff, pbQINV, dwQINVLen);
			dwValueBufLen = dwQINVLen;
			break;
		default:
			break;
		}
		
		dwExtraTagSize = 0;
		//公钥的der编码只有两个属性
		if(bKeyType == TYPE_PUBKEY && dwAttriType == CKA_MODULUS_BITS)
		{//nothing to do
		}
		else
		{
			//tag num, its integer
			baDataBuff[dwOffset] = TAG_NUM_INTEGER;
			dwOffset++;
			//for private key
			//some tag??
			//这几项属性需要00标识的前缀
			if( (dwAttriType == CKA_MODULUS) ||
				(dwAttriType == CKA_PRIVATE_EXPONENT) ||
				(dwAttriType == CKA_PRIME_1) ||
				(dwAttriType == CKA_PRIME_2) ||
				(dwAttriType == CKA_EXPONENT_2)
				//(dwAttriType == CKA_COEFFICIENT)
				
			){
				dwExtraTagSize = 1;
			}

			dwDataLen = dwExtraTagSize +  dwValueBufLen;
			//integer len
			if(dwDataLen > MAX_VALUE_LEN_SHORT_FORM){
			//长型数据 HIBYTE(
				BYTE bActLenSize;
				

				//bActLenSize = 1;
				if(dwDataLen > 0xffff){
				//4 len
					bActLenSize = 4;
					baDataBuff[dwOffset] = BIT_LEN_LONG_FORM | bActLenSize;
					dwOffset++;
					
					baDataBuff[dwOffset] = (BYTE)((dwDataLen >>24)& 0xff);
					dwOffset++;
					baDataBuff[dwOffset] = (BYTE)((dwDataLen >>16)& 0xff);
					dwOffset++;
					baDataBuff[dwOffset] = (BYTE)((dwDataLen >>8)& 0xff);
					dwOffset++;
					baDataBuff[dwOffset] = (BYTE)((dwDataLen )& 0xff);
					dwOffset++;
					

				}else if(dwDataLen > 0xff){
				//2 len
					bActLenSize = 2;
					baDataBuff[dwOffset] = BIT_LEN_LONG_FORM | bActLenSize;
					dwOffset++;
					
					baDataBuff[dwOffset] = (BYTE)((dwDataLen >>8)& 0xff);
					dwOffset++;
					baDataBuff[dwOffset] = (BYTE)((dwDataLen )& 0xff);
					dwOffset++;
				}else{//<0xff
					bActLenSize = 1;
					baDataBuff[dwOffset] = BIT_LEN_LONG_FORM | bActLenSize;
					dwOffset++;
					
					baDataBuff[dwOffset] = (BYTE)((dwDataLen )& 0xff);
					dwOffset++;
				}
				
			}else{
			//短型数据
				baDataBuff[dwOffset] =(BYTE)( MASK_LEN_SHORT_FORM & dwDataLen);
				dwOffset++;
				;
			}

			//do copy data
			//这几项属性需要00标识的前缀
			if( (dwAttriType == CKA_MODULUS) ||
				(dwAttriType == CKA_PRIVATE_EXPONENT) ||
				(dwAttriType == CKA_PRIME_1) ||
				(dwAttriType == CKA_PRIME_2) ||
				(dwAttriType == CKA_EXPONENT_2)
				//(dwAttriType == CKA_COEFFICIENT)
				
			){
				baDataBuff[dwOffset] = 0x00;
				dwOffset++;
			}

			//从模板复制数据，不受dwDataLen的影响
			memcpy(baDataBuff + dwOffset,
				baValueBuff,
				dwValueBufLen);
			
			//DER 高位在前
			i_Reverse(baDataBuff + dwOffset, dwValueBufLen);
			
			dwOffset += dwValueBufLen;;
		}
	}
	//更新全部数据长度
	//并根据长度和类型来修正squ 的长度及tag部分
	//
	if(bKeyType == TYPE_PRIKEY)
	{
		baDataBuff[dwOffsetDataLen ] =  HIBYTE((WORD)dwOffset-dwSquDataStart) ;
		baDataBuff[dwOffsetDataLen +1] = LOBYTE((WORD)dwOffset-dwSquDataStart);
	}
	else
	{
		baDataBuff[dwOffsetDataLen ] =  (BYTE)(dwOffset-dwSquDataStart) ;
	}
	
	*pdwDERValueLen = dwOffset;
	if(*pdwDERValueLen < dwOffset)
	{
		dwRet = USBKEY_INVALID_PARAMETER;
		goto err;
	}
	*pdwDERValueLen = dwOffset;
	memcpy(pbDERValue,baDataBuff,dwOffset);
	
err:
	return dwRet;
}