//--------------------------------------------------------------------
// В данном примере осуществляется экспортирование сессионного ключа
// при помощи структуры BLOB.
// Для корректной работы этой программы необходимо создать два 
// контейнера: получателя (с именем "Responder") и отправителя (c именем
// "Sender").
//--------------------------------------------------------------------

void HandleError(char *s);

int main(void)
{
//--------------------------------------------------------------------
//  Объявление и инициализация переменных.

HCRYPTPROV hProvResponder;  // Дескриптор CSP получателя 
HCRYPTPROV hProvSender; 	// Дескриптор CSP отправителя
HCRYPTKEY hSessionKey; 	 // Дескриптор сессионного ключа 
HCRYPTKEY hAgreeKey; 	 // Дескриптор ключа согласования
HCRYPTKEY hResponderKey;  // Дескриптор открытого ключа получателя
HCRYPTKEY hSenderKey; 	// Дескриптор открытого ключа отправителя
BYTE *pbKeyBlobSender; 	 // Указатель на ключевой BLOB отправителя
DWORD dwBlobLenSender; 	 // Длина ключевого BLOBа отправителя
BYTE *pbKeyBlobResponder; // Указатель на ключевой BLOB получателя
DWORD dwBlobLenResponder; // Длина ключевого BLOBа получателя
BYTE *pbKeyBlobSimple; 	 // Указатель на сессионный ключевой BLOB 
DWORD dwBlobLenSimple; 	 // Длина сессионного ключевого BLOBа

//--------------------------------------------------------------------
// На стороне получателя: отправляем открытый ключ отправителю
//--------------------------------------------------------------------

//--------------------------------------------------------------------
// Получение дескриптора контейнера получателя с именем "Responder", 
// находящегося в рамках провайдера. 

if(CryptAcquireContext(
   &hProvResponder, 
   "Responder", 
   NULL, 
   75, 
   0)) 
{
	printf("The key container \"Responder\" has been acquired. \n");
}
else
{
	HandleError("Error during CryptAcquireContext.");
}
//--------------------------------------------------------------------
// Получение дескриптора открытого ключа получателя.

if(CryptGetUserKey(
   hProvResponder, 
   AT_KEYEXCHANGE, 
   &hResponderKey)) 
{
	printf("The responder public key has been acquired. \n");
}
else
{
	printf("Error during CryptGetUserKey public key.");
}

//--------------------------------------------------------------------
// pbKeyBlobResponder - открытый ключ получателя, передаем его оправителю.
//
//--------------------------------------------------------------------

//--------------------------------------------------------------------
// Определение размера BLOBа открытого ключа и распределение памяти.

if(CryptExportKey(
   hResponderKey, 
   0, 
   PUBLICKEYBLOB, 
   0, 
   NULL,
   &dwBlobLenResponder)) 
{
	 printf("Size of the BLOB for the responder public key determined. \n");
}
else
{
	 HandleError("Error computing BLOB length.");
}

pbKeyBlobResponder = (BYTE*)malloc(dwBlobLenResponder);

if(pbKeyBlobResponder) 
{
	printf("Memory has been allocated for the BLOB. \n");
}
else
{
	HandleError("Out of memory. \n");
}
//--------------------------------------------------------------------
// Экспортирование открытого ключа получателя в BLOB открытого ключа.

if(CryptExportKey(
   hResponderKey, 
   0, 
   PUBLICKEYBLOB, 
   0, 
   pbKeyBlobResponder, 
   &dwBlobLenResponder))
{
	 printf("Contents have been written to the BLOB. \n");
}
else
{
	HandleError("Error during CryptExportKey.");
}


//--------------------------------------------------------------------
// На стороне отправителя: отправляем открытый ключ получателю.
//--------------------------------------------------------------------

// Получение дескриптора контейнера отправителя с именем "Sender", 
// находящегося в рамках провайдера. 

if(CryptAcquireContext(
   &hProvSender, 
   "Sender", 
   NULL, 
   75, 
   0)) 
{
	printf("The key container \"Sender\" has been acquired. \n");
}
else
{
	HandleError("Error during CryptAcquireContext.");
}
//--------------------------------------------------------------------
// Получение дескриптора открытого ключа отправителя.

if(CryptGetUserKey(
   hProvSender, 
   AT_KEYEXCHANGE, 
   &hSenderKey)) 
{
	printf("The sender public key has been acquired. \n");
}
else
{
	printf("Error during CryptGetUserKey public key.");
}

//--------------------------------------------------------------------
// pbKeyBlobSender - открытый ключ отправителя, передаем его получателю.
//
//--------------------------------------------------------------------

//--------------------------------------------------------------------
// Определение размера BLOBа открытого ключа и распределение памяти.

if(CryptExportKey(
   hSenderKey, 
   0, 
   PUBLICKEYBLOB, 
   0, 
   NULL,
   &dwBlobLenSender)) 
{
	 printf("Size of the BLOB for the sender public key determined. \n");
}
else
{
	 HandleError("Error computing BLOB length.");
}

pbKeyBlobSender = (BYTE*)malloc(dwBlobLenSender);

if(pbKeyBlobSender) 
{
	printf("Memory has been allocated for the BLOB. \n");
}
else
{
	HandleError("Out of memory. \n");
}
//--------------------------------------------------------------------
// Экспортирование открытого ключа отправителя в BLOB открытого ключа.

if(CryptExportKey(
   hSenderKey, 
   0, 
   PUBLICKEYBLOB, 
   0, 
   pbKeyBlobSender, 
   &dwBlobLenSender))
{
	 printf("Contents have been written to the BLOB. \n");
}
else
{
	HandleError("Error during CryptExportKey.");
}
//--------------------------------------------------------------------
// Получение ключа согласования импортом открытого ключа получателя 
// на открытом ключе отправителя.

if (CryptImportKey(
	hProvSender, 
	pbKeyBlobResponder, 
	dwBlobLenResponder, 
	hSenderKey, 
	0, 
	&hAgreeKey))
{
	printf("The sender public key has been imported. \n");
}
else
{
	printf("Error during CryptImportKey public key.");
}
	
//--------------------------------------------------------------------
// Генерация сессионного ключа.

if (CryptGenKey(	 
	hProvSender, 
	CALG_G28147, 
	CRYPT_EXPORTABLE, 
	&hSessionKey))
{   
	printf("Original session key is created. \n");
}
else
{
   HandleError("ERROR -- CryptGenKey.");
}

//--------------------------------------------------------------------
// pbKeyBlobSimple - зашифрованный сессионный ключ, передаем его получателю.
//
//--------------------------------------------------------------------

//--------------------------------------------------------------------
// Определение размера BLOBа сессионного ключа и распределение памяти.

if(CryptExportKey(
   hSessionKey, 
   hAgreeKey, 
   SIMPLEBLOB, 
   0, 
   NULL,
   &dwBlobLenSimple)) 
{
	 printf("Size of the BLOB for the sender session key determined. \n");
}
else
{
	 HandleError("Error computing BLOB length.");
}

pbKeyBlobSimple = (BYTE*)malloc(dwBlobLenSimple);

if(pbKeyBlobSimple) 
{
	printf("Memory has been allocated for the BLOB. \n");
}
else
{
	HandleError("Out of memory. \n");
}
//--------------------------------------------------------------------
// Шифрование ключа согласования на сессионном ключе.

if(CryptExportKey(
   hSessionKey, 
   hAgreeKey,
   SIMPLEBLOB, 
   0, 
   pbKeyBlobSimple, 
   &dwBlobLenSimple))
{
	 printf("Contents have been written to the BLOB. \n");
}
else
{
	HandleError("Error during CryptExportKey.");
}


//--------------------------------------------------------------------
// На стороне получателя: получили зашифрованный сессионный ключ: 
// pbKeyBlobSimple, получили открытый ключ: pbKeyBlobSender. 
//--------------------------------------------------------------------

// Получение ключа согласования импортом открытого ключа отправителя 
// на открытом ключе получателя.

if (CryptImportKey(
	hProvResponder, 
	pbKeyBlobSender, 
	dwBlobLenSender, 
	hResponderKey, 
	0, 
	&hAgreeKey))
{
	printf("The responder public key has been imported. \n");
}
else
{
	printf("Error during CryptImportKey public key.");
}

// Получение сессионного ключа импортом зашифрованного сессионного ключа 
// на ключе Agree.

if (CryptImportKey(
	hProvResponder, 
	pbKeyBlobSimple, 
	dwBlobLenSimple, 
	hAgreeKey, 
	0, 
	&hSessionKey))
{
	printf("The session key has been imported. \n");
}
else
{
	printf("Error during CryptImportKey session key.");
}


//--------------------------------------------------------------------
//  Освобождение памяти, используемой ключевыми BLOBоми.

free(pbKeyBlobSender);
free(pbKeyBlobResponder);
free(pbKeyBlobSimple);

// Уничтожение сессионного ключа.
if(hSessionKey)
	CryptDestroyKey(hSessionKey);

// Уничтожение ключа согласования.
if(hAgreeKey)
	CryptDestroyKey(hAgreeKey);

// Уничтожение дескриптора открытого ключа получателя.
if(hResponderKey)
	 CryptDestroyKey(hResponderKey);

// Уничтожение дескриптора открытого ключа отправителя.
if(hSenderKey)
	 CryptDestroyKey(hSenderKey);

// Освобождение дескриптора провайдера.
if(hProvResponder) 
   CryptReleaseContext(hProvResponder, 0);
if(hProvSender) 
   CryptReleaseContext(hProvSender, 0);

printf("The program ran to completion without error. \n");
return 0;
}// Конец main													
	

Требования:

Windows 2000/XP/2003: Необходимо Windows 2000 SP4 или старше с Internet Explorer 6.0 или старше.
Windows NT/95/98/ME: CSP 3.0 не поддерживает (см. КриптоПро CSP 2.0 ).
Solaris: 9 Update 4 или выше.
FreeBSD: FreeBSD 5.2 или выше
Linux: RedHat 7.3, RedHad 9.0.
Ядро Windows NT: не поддерживает.