=============================================================================
1-------
Issuer         : E=info@cryptopro.ru, C=RU, O=CRYPTO-PRO, CN=Test Center CRYPTO-PRO
Subject        : CN=Alex
Serial         : 0x5DC0000002006DB8221B
PrivateKey Link: Yes. Container: HDIMAGE\\alex.000\F493
2-------
Issuer         : E=info@cryptopro.ru, C=RU, O=CRYPTO-PRO, CN=Test Center CRYPTO-PRO
Subject        : CN="Borisov E=borisov@cg.ru"
Serial         : 0xDBBE00000200F68B3B16
PrivateKey Link: Yes. Container: HDIMAGE\\borisov2.000\C300
3-------
Issuer         : E=info@cryptopro.ru, C=RU, O=CRYPTO-PRO, CN=Test Center CRYPTO-PRO
Subject        : CN="Ivanov E=Ivanov_I@mail.ru"
Serial         : 0xD9BE0000020051C43016
PrivateKey Link: Yes. Container: HDIMAGE\\borisov.000\32C3
=============================================================================

#include "CSP_WinCrypt.h"

#define szOID_CP_GOST_R3411 "1.2.643.2.2.9";

#define CALG_GR3411 \
    (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_GR3411)

#define ALG_SID_GR3411				30
#define ALG_SID_GR3411_HASH			39
#define ALG_SID_GR3411_HASH34			40

int main ()
{
	HCRYPTPROV hProv;
	HCRYPTHASH hHash;
	HCRYPTKEY hKey;
	DWORD cbData;
        DWORD d_Keyspec;
	BYTE b_nameProv[100];


	if(!CryptAcquireContext(&hProv, "\\\\.\\HDIMAGE\\borisov2", /*"Crypto-Pro GOST R 34.10-2001 KC1 CSP"*/0, 75, 0))
	{
		printf("Error CryptAcquireContext() = %d\n", GetLastError());			
	}
        printf("CryptAcquireContext() %d\n", hProv);			
	

	if(!CryptGetProvParam(hProv,PP_NAME, NULL, &cbData,0))
	{
		printf("Error CryptGetProvParam() = %d\n", GetLastError());			
	}	
        printf("CryptGetProvParam() CSP NAME COOUNT= %d\n", cbData);			

	char* name_value = static_cast< char* >(malloc(cbData + 1));
	ZeroMemory(name_value, cbData + 1);


	if(!CryptGetProvParam(hProv,PP_NAME, (BYTE*)name_value, &cbData,0))
	{
		printf("Error CryptGetProvParam() = %d\n", GetLastError());			
	}	
        printf("CryptGetProvParam() CSP NAME = %s\n", name_value);			


	if(!CryptGetProvParam(hProv,PP_CONTAINER, b_nameProv, &cbData,0))
	{

	}	
        printf("CryptGetProvParam() CONTAINER NAME = %s\n", b_nameProv);			

        printf("CryptGetProvParam() KEYSPEC  = %d\n", d_Keyspec);			

		
	if(!CryptSetProvParam(hProv, PP_KEYEXCHANGE_PIN, reinterpret_cast< const BYTE* >("12345678"), 0))
	{
		printf("Error CryptSetProvParam() = %d\n", GetLastError());			
	}


	
	printf("CryptSetProvParam()\n");				

	if(!CryptCreateHash(hProv,/* CALG_SHA1*/CALG_GR3411 /*CALG_MD5*/, 0, 0, &hHash))
	{
		printf("Error CryptCreateHash() = %d\n", GetLastError());			
	}

	printf("CryptCreateHash() %d\n", hHash);			

	if(!CryptHashData(hHash, (BYTE*)"12345", 5, 0))                                         
	{
		printf("Error CryptHashData() = %d\n", GetLastError());			
	}

	printf("CryptHashData()\n");				

        DWORD count = 0;

	if(!CryptGetHashParam(hHash, HP_HASHVAL, NULL, &count, 0))
	{
		printf("Error CryptGetHashParam() = %d\n", GetLastError());			
	}

	printf("CryptGetHashParam() count= %d\n", count);				


	char* hash_value = static_cast< char* >(malloc(count + 1));
	ZeroMemory(hash_value, count + 1);

	if(!CryptGetHashParam(hHash, HP_HASHVAL, (BYTE*)hash_value, &count, 0))
	{
		printf("Error CryptGetHashParam() = %d\n", GetLastError());			
	}

	printf("CryptGetHashParam() hash_value= %s\n", hash_value);				
	
	count = 0;

	if(!CryptSignHash(hHash, AT_SIGNATURE, NULL, 0, NULL, &count))
	{
		printf("Error CryptSignHash() = %d\n", GetLastError());			
	}

	printf("CryptSignHash() count=%d\n", count);				

 
	char* sign_hash = static_cast< char* >(malloc(count + 1));
	ZeroMemory(sign_hash, count + 1);

	if(!CryptSignHash(hHash, AT_SIGNATURE, NULL, 0, (BYTE*)sign_hash, &count))
	{                               
		printf("Error CryptSignHash() = %d\n", GetLastError());			
	}


        if(hHash)
	{
		CryptDestroyHash(hHash);
		printf("CryptDestroyHash()\n");				
	}
        if(hProv)
	{
		CryptReleaseContext(hProv, 0);
		printf("CryptReleaseContext()\n");				
	}

	return 0;
}

-----BEGIN CERTIFICATE-----
MIIDIjCCAtGgAwIBAgIKFjuL9gACAAC+2zAIBgYqhQMCAgMwZTEgMB4GCSqGSIb3
DQEJARYRaW5mb0BjcnlwdG9wcm8ucnUxCzAJBgNVBAYTAlJVMRMwEQYDVQQKEwpD
UllQVE8tUFJPMR8wHQYDVQQDExZUZXN0IENlbnRlciBDUllQVE8tUFJPMB4XDTEw
MTEyMzExMzcwMFoXDTE0MTAwNDA3MDkwMFowOTE3MDUGA1UEAx4uAEIAbwByAGkA
cwBvAHYAIABFAD0AYgBvAHIAaQBzAG8AdgBAAGMAZwAuAHIAdTBjMBwGBiqFAwIC
EzASBgcqhQMCAiQABgcqhQMCAh4BA0MABEBphQzbNXGosUDM8mxHLoWl4idHP1IU
P6R8J3vWLrgNV70+PNRXuIzudrjg7oh3i6azjHhGgP+WK+JSZZ8TZoAUo4IBizCC
AYcwEwYDVR0lBAwwCgYIKwYBBQUHAwQwCwYDVR0PBAQDAgTwMB0GA1UdDgQWBBSA
RQ8vsnDVC1idZE4KRZ5JHgfV9DAfBgNVHSMEGDAWgBRtj14F2V+skReUHpWaBTA4
N3oQKjBVBgNVHR8ETjBMMEqgSKBGhkRodHRwOi8vd3d3LmNyeXB0b3Byby5ydS9j
ZXJ0ZW5yb2xsL1Rlc3QlMjBDZW50ZXIlMjBDUllQVE8tUFJPKDIpLmNybDCBngYI
KwYBBQUHAQEEgZEwgY4wMwYIKwYBBQUHMAGGJ2h0dHA6Ly93d3cuY3J5cHRvcHJv
LnJ1L29jc3BuYy9vY3NwLnNyZjBXBggrBgEFBQcwAoZLaHR0cDovL3d3dy5jcnlw
dG9wcm8ucnUvQ2VydEVucm9sbC9DcnlwdG9fVGVzdCUyMENlbnRlciUyMENSWVBU
Ty1QUk8oMikuY3J0MCsGA1UdEAQkMCKADzIwMTAxMTIzMTEzNzAwWoEPMjAxMjAy
MjMxMTM3MDBaMAgGBiqFAwICAwNBACQyCosTGloiviZVBtoa9UJEE4TJbCUmujFc
QM0jzy55uE5EE75lXzj9+NL3m6EKxVBdMfkVR5OZmUhkH1vgux8=
-----END CERTIFICATE-----

//#include "CSP_WinDef.h"
#include "CSP_WinCrypt.h"
#define szOID_CP_GOST_R3411 "1.2.643.2.2.9";

int main ()
{

	HCRYPTPROV hProv;
	HCRYPTKEY temp_key;
	DWORD cbData;
	BYTE b_nameProv[50];
	



        HCERTSTORE hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, hProv,0, L"MY");

	printf("CertOpenStore() %d | %d\n", hCertStore, GetLastError());

	PCCERT_CONTEXT pSignerCert = CertFindCertificateInStore(hCertStore,
					PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
					0,
					CERT_FIND_SUBJECT_STR, 
					L"Borisov E=borisov@cg.ru",
					NULL);

	
	printf("CertFindCertificateInStore() %d | %d\n", pSignerCert, GetLastError());

	char pszNameString[50];


	
	CRYPT_SIGN_MESSAGE_PARA		SignPara = {0};
	
	SignPara.cbSize = sizeof(CRYPT_SIGN_MESSAGE_PARA);
	SignPara.dwMsgEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
	SignPara.pSigningCert = pSignerCert;
	SignPara.HashAlgorithm.pszObjId = szOID_CP_GOST_R3411;
	SignPara.cMsgCert = 1;
	SignPara.cbSize = sizeof(CRYPT_SIGN_MESSAGE_PARA);
	SignPara.rgpMsgCert = &pSignerCert;
        SignPara.pvHashAuxInfo = NULL;
	SignPara.cMsgCert = 0;
	SignPara.rgpMsgCert = NULL;
	SignPara.cMsgCrl = 0;
	SignPara.rgpMsgCrl = NULL;
	SignPara.cAuthAttr = 0;
	SignPara.rgAuthAttr = 0;
	SignPara.cUnauthAttr = 0;
	SignPara.rgUnauthAttr = 0;
	SignPara.dwFlags = 0;
	SignPara.dwInnerContentType = 0;
	
	
	DWORD cbEncryptedBlob;
	BYTE* pbMessage = (BYTE*)"123456";
 

	DWORD MessageSizeArray[1];
	MessageSizeArray[0] = 6;

 	                                                                        	
	const BYTE *message[] = {pbMessage};

	printf("message %s | %d\n", message[0], MessageSizeArray[0]);

	if (!CryptSignMessage(&SignPara, FALSE, TRUE, message, MessageSizeArray, NULL, &cbEncryptedBlob))
	{
		printf("Error CryptSignMessage()%d\n", GetLastError());
     	}		


        
	BYTE *signature =NULL;
	signature = static_cast< BYTE* >(malloc(cbEncryptedBlob));


	if (!CryptSignMessage(&SignPara, TRUE, TRUE, message, MessageSizeArray, signature, &cbEncryptedBlob))
	{
		printf("Error CryptSignMessage()%d\n", GetLastError());
     	}		
	
	FILE *f_OutFile;
	f_OutFile = fopen("sign.txt", "w");
	fwrite(signature, 1, cbEncryptedBlob, f_OutFile);
	fclose(f_OutFile);


	printf("cbEncryptedBlob = %d\n", cbEncryptedBlob);	

	if(pSignerCert)
		CertFreeCertificateContext(pSignerCert);
	

	if(hCertStore)
		CertCloseStore(hCertStore, 0);

	CryptAcquireContext(&hProv, "\\\\.\\HDIMAGE\\borisov2", "Crypto-Pro GOST R 34.10-2001 KC1 CSP", 75, 0);
	
	CryptReleaseContext(hProv, 0);

	return 0;
}