cpryto.cpp

Protel 2004 Crack

	{
		TRACE("BLOB 长度错误 。\n");
		TRACE("秘钥输出失败.\n");
		return false;
	}
	/*
//--------------------------------------------------------------------
// 检查 pbKeyBlob 空间.
	if(KeyBlob = (BYTE*)malloc(*BlobLen)) 
	{
		TRACE("pbKeyBlob 空间允许. \n");
	}
	else
	{
		TRACE("pbKeyBlob 空间溢出. \n");
		return false;
	}*/
//--------------------------------------------------------------------
// 秘钥输出.

	if(CryptExportKey(   
		hKey, 
		NULL,    
		BlobType,    
		0,
		KeyBlob,    
		BlobLen))
	{
		TRACE("秘钥输出成功. \n");
	}
	else
	{
		TRACE("秘钥输出失败.\n");
		return false;
	}
	return true;
}


//==============================================================
//创建 CSP 秘钥
bool CCpryto::CSPGenKey(HCRYPTPROV hProv,HCRYPTKEY *hKey)
{
	
	if(CryptGenKey(
          hProv, 
          CALG_RSA_SIGN,				//CALG_MD5,		//CALG_RSA_SIGN,//|AT_SIGNATURE,//ENCRYPT_ALGORITHM, 
          KEYLENGTH | CRYPT_EXPORTABLE,	//|CRYPT_CREATE_SALT, 
          hKey))
	{
		TRACE("创建 CSP 秘钥成功。\n");
		
	} 
	else
	{
		TRACE("创建 CSP 秘钥失败。\n"); 
		return false;
        
	}
	return true;
}


//==============================================================
//数字签名验证
bool CCpryto::CSPVerifySign(BYTE *inText,int length, BYTE *vrText,int vrlength,HCRYPTPROV hCryptProv,HCRYPTKEY hPubKey)
{
	HCRYPTHASH hHash;
/*
//--------------------------------------------------------------------
// 获取一个密钥

	if(CryptGetUserKey(   
		hCryptProv,    
		AT_SIGNATURE,    
		&hKey)) 
	{
		TRACE("获取签名密钥成功. \n");
	}
	else
	{
		MyHandleError("获取签名密钥失败！");
		return false;
	}
*/
//--------------------------------------------------------------------
// 获取一个Hash句柄.

	if(CryptCreateHash(
		hCryptProv, 
		CALG_MD5,			//8003h
		0, 
		0, 
		&hHash)) 
	{
		TRACE("创建一个空Hash句柄. \n");
	}
	else
	{
		TRACE("创建Hash句柄错误!\n");
		return false;
	}
//--------------------------------------------------------------------
//  产生一个Hash效验数据.

	if(CryptHashData(
		hHash, 
		inText, 
		length, 
		NULL)) 
	{
		TRACE("产生一个Hash效验数据成功.\n");
	}
	else
	{
		TRACE("产生一个Hash效验数据成功错误.\n");
		return false;
	}
//--------------------------------------------------------------------
//数字签名验证.

	if(CryptVerifySignature(
		hHash,								//00169FB8
		vrText,								//0x0121243B
	    0x100,								//0x100
		hPubKey,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("数字签名验证有效.\n");
		
	}
	else
	{
		TRACE("数字签名验证无效\n");
		return false;
	}
	return true;

}


//==============================================================
//创建数字签名
bool CCpryto::CSPCreateSign(BYTE *inText,int length,BYTE *pbSignature,DWORD *sgLen,HCRYPTPROV hCryptProv)
{

	HCRYPTHASH  hHash;

/*
//--------------------------------------------------------------------
// 获取一个密钥

	if(CryptGetUserKey(   
		hCryptProv,    
		AT_SIGNATURE,    
		&hKey)) 
	{
		TRACE("获取签名密钥成功. \n");
	}
	else
	{
		MyHandleError("获取签名密钥失败！");
		return false;
	}
*/
//--------------------------------------------------------------------
// 获取一个Hash句柄.

	if(CryptCreateHash(
		hCryptProv, 
		CALG_MD5,			//8003h
		0, 
		0, 
		&hHash)) 
	{
		TRACE("创建一个空Hash句柄. \n");
	}
	else
	{
		TRACE("创建Hash句柄错误!\n");
		return false;
		
	}
//--------------------------------------------------------------------
// 产生一个Hash效验数据.

	if(CryptHashData(
		hHash, 
		inText, 
		length, 
		0)) 
	{
		TRACE("产生一个Hash效验数据成功.\n");
	}
	else
	{
		TRACE("产生一个Hash效验数据成功错误.\n");
		return false;
		
	}
//--------------------------------------------------------------------
// 创建数字签名.

	if(CryptSignHash(
		hHash, 
		AT_SIGNATURE, 
		NULL,//szDescription, 
		NULL,//CRYPT_X931_FORMAT,
		pbSignature, 
		sgLen))
	{
		TRACE("pbSignature is the hash signature.\n");
	
	}
	else
	{
		//MyHandleError("Error during CryptSignHash.");
		return false;
	}

return true;
}
//==============================================================
//错误处理
void MyHandleError(char *s)
{
    TRACE("An error occurred in running the program.\n");
    TRACE("%s\n",s);
    TRACE("Error number %x\n.",GetLastError());
    TRACE("Program terminating.\n");
    //exit(1);

	//return false;
}


// FileHash(fileData,flieLength);
BOOL CCpryto::CreateFileSign(BYTE* fileData, ULONGLONG flieLength,BYTE *pbSignature,DWORD *sgLen)
{
	int i,j;
	BYTE KeyBlobPriIWESUN[1172];
	DWORD KeyBlobPriIWESUNlen;
	HCRYPTHASH hHash;
	CSPCreate(&hCryptProvIWESUN,NULL,NULL);
	KeyBlobPriIWESUNlen=sizeof(KeyBlobPriIWESUNcon);
	if(KeyBlobPriIWESUNlen!=0)
	{
		j=0;
		for(i=0;i<1172;i++) 
		{
			KeyBlobPriIWESUN[i]=CCpryto::KeyBlobPriIWESUNcon[i]^CCpryto::KeyBlobPubIWESUNcon[j];
			j++;if(j>0x100)j=0;
		}

		CSPImportKey(hCryptProvIWESUN,(BYTE *) KeyBlobPriIWESUN,KeyBlobPriIWESUNlen,&hPriKeyIWESUN);
	}else
	{
		TRACE("无法加载私密，不能完成数字签名！","错误",MB_OK|MB_ICONERROR);
		return NULL ;
	}
	if(CSPCreateSign(fileData,flieLength,pbSignature,sgLen,hCryptProvIWESUN))
	{
		TRACE("创建数字签名成功！");
		return true;
	}
	else
	{
		TRACE("创建数字签名失败！","错误",MB_OK|MB_ICONERROR);
		return false;
	}


}
DWORD CCpryto::FileType(BYTE* fileData, ULONGLONG flieLength)
{
	
	HCRYPTHASH hHash;
	int i=0,j=0,k=0;
	CString text;
	CSPCreate(&hCryptProvIWESUN,NULL,CRYPT_VERIFYCONTEXT);
	if(sizeof(KeyBlobPubIWESUNcon)!=0)
		CSPImportKey(hCryptProvIWESUN,(BYTE *) KeyBlobPubIWESUNcon,sizeof(KeyBlobPubIWESUNcon),&hPubKeyIWESUN);

/*
//--------------------------------------------------------------------
// 获取一个密钥

	if(CryptGetUserKey(   
		hCryptProv,    
		AT_SIGNATURE,    
		&hKey)) 
	{
		TRACE("获取签名密钥成功. \n");
	}
	else
	{
		MyHandleError("获取签名密钥失败！");
		return false;
	}
*/
//--------------------------------------------------------------------
// 获取一个Hash句柄.

	if(CryptCreateHash(
		hCryptProvIWESUN, 
		CALG_MD5,			//8003h
		0, 
		0, 
		&hHash)) 
	{
		TRACE("创建一个空Hash句柄. \n");
	}
	else
	{
		TRACE("创建Hash句柄错误!\n");
		return 0;
	}
//--------------------------------------------------------------------
//  产生一个Hash效验数据.

	if(CryptHashData(
		hHash, 
		fileData, 
		flieLength, 
		NULL)) 
	{
		TRACE("产生一个Hash效验数据成功.\n");
	}
	else
	{
		TRACE("产生一个Hash效验数据成功错误.\n");
		return 0;
	}
//--------------------------------------------------------------------
//数字签名验证.

	if(CryptVerifySignature(
		hHash,								//00169FB8
		AltiumDXPSign,						//0x0121243B
	    0x100,								//0x100
		hPubKeyIWESUN,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("AltiumDXPSign 数字签名验证有效.\n");
		return(1);
	}
	else
	{
		TRACE("数字签名验证无效\n");
		
	}
	if(CryptVerifySignature(
		hHash,								//00169FB8
		IwesunDXPSign,						//0x0121243B
	    0x100,								//0x100
		hPubKeyIWESUN,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("AltiumDXPSign 数字签名验证有效.\n");
		return(2);
	}
	else
	{
		TRACE("数字签名验证无效\n");
		
	}
	if(CryptVerifySignature(
		hHash,								//00169FB8
		AltiumServiceSign,						//0x0121243B
	    0x100,								//0x100
		hPubKeyIWESUN,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("AltiumDXPSign 数字签名验证有效.\n");
		return(3);
	}
	else
	{
		TRACE("数字签名验证无效\n");
		
	}
	if(CryptVerifySignature(
		hHash,								//00169FB8
		IwesunServiceSign,						//0x0121243B
	    0x100,								//0x100
		hPubKeyIWESUN,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("AltiumDXPSign 数字签名验证有效.\n");
		return(4);
	}
	else
	{
		TRACE("数字签名验证无效\n");
		
	}
	/*
	if(CryptVerifySignature(
		hHash,								//00169FB8
		SelfSign,							//0x0121243B
	    0x100,								//0x100
		hPubKeyIWESUN,						//0x00164E90 ,00164E98
	    0, 
		0)) 
	{
		TRACE("AltiumDXPSign 数字签名验证有效.\n");
		return(5);
	}
	else
	{
		TRACE("数字签名验证无效\n");
		
	}

	*/
	return 0;

}

CString CCpryto::Bin2HexText(BYTE *data,DWORD Len)
{
	int i=0,k=0,j=0;
	CString fbuffer="";
	char buffer[5];
	while(k<Len)
	{
		j=0;
		while((j<16)&&(k<Len))
		{
			sprintf(buffer,"0x%2X",data[k]);k++;j++;
			if(buffer[2]==' ')buffer[2]='0';
			buffer[4]=0;
			fbuffer+=buffer;
			fbuffer+=",";
			if(j==16)  fbuffer+="\r\n";
		}
	}
	return(fbuffer);
}
DWORD CCpryto::Find(BYTE *data,DWORD Len,bool flag)
{
	DWORD i=0,k=0,j=0;
	if(flag)
	{
		for(i=0;i<Len-sizeof(KeyBlobPubProtel);i++)
		{
			for(j=0;j<sizeof(KeyBlobPubProtel);j++)
			{

				if(data[i+j]!=KeyBlobPubProtel[j])break;
			}
		
			if(j==sizeof(KeyBlobPubProtel))
			{
				k=j;break;
			}
		}
		return(i);
	}else
	{
		for(i=0;i<Len-sizeof(KeyBlobPubIWESUNcon);i++)
		{
			for(j=0;j<sizeof(KeyBlobPubIWESUNcon);j++)
			{
				if(data[i+j]!=KeyBlobPubIWESUNcon[j])break;
			}
		
			if(j==sizeof(KeyBlobPubProtel))
			{
				k=j;break;
			}
		}
		return(i);
	}
}