//--------------------------------------------------------------------
// В данном примере производится зашифрование файла на открытом ключе
// получателя.
// Для корректной работы данного примера предварительно необходимо 
// записать открытый ключ в файл "public.bin" при помощи
// примера ExportInFile.
// Также предварительно необходимо создать файл, подлежаший зашифрованию, 
// с именем "source.txt".
// Следует сделить за тем, чтобы контейнер с именем "Public", используемый
// в программе ExportInFile, на момент выполнения данной программы существовал.
//--------------------------------------------------------------------

#include <string.h>
void HandleError(char *s);

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

HCRYPTPROV hProv; 		 // Дескриптор CSP 
HCRYPTKEY hKey; 			 // Дескриптор закрытого ключа 
HCRYPTKEY hSessionKey; 	// Дескриптор сессионного ключа
HCRYPTKEY hAgreeKey; 		// Дескриптор ключа согласования
BYTE  pbKeyBlob[100]; 	 // Указатель на ключевой BLOB 
DWORD dwBlobLen; 			// Длина ключевого BLOBа
BYTE *pbKeyBlobSimple; 	// Указатель на сессионный ключевой BLOB 
DWORD dwBlobLenSimple; 	// Длина сессионного ключевого BLOBа
FILE *Public; 			 // Файл, в котором хранится открытый ключ
FILE *source; 			 // Исходный файл
FILE *encrypt; 			// Зашифрованный файл
FILE *session; 			// Файл для хранения сессионного ключа
FILE *vector; 			 // Файл для хранения вектора инициализации
BYTE pbContent[4096]; 	 // Указатель на содержимое исходного файла
DWORD cbContent = 0; 		// Длина содержимого
BYTE *pbIV = NULL; 		// Вектор инициализации сессионного ключа
DWORD dwIV = 0; 			 // Длина вектора инициализации
DWORD bufLen = sizeof(pbContent);   // Длина буфера



//--------------------------------------------------------------------
// Открытие файла, в котором содержится открытый ключ получателя.

Public = fopen( "public.bin", "r+b" );

if(Public)
{
	printf( "The file 'public.bin' was opened\n" );
}
else
{
	HandleError( "Problem opening the file 'public.bin'\n" );
}

//--------------------------------------------------------------------
// Открытие файла, который будет зашифрован.

source = fopen( "source.txt", "r+b" );

if(source)
{
	printf( "The file 'source.txt' was opened\n" );
}
else
{
	HandleError( "Problem opening the file 'source.txt'\n" );
}

//--------------------------------------------------------------------
// Открытие файла, в который будет производится запись зашифрованного
// файла.

encrypt = fopen( "encrypt.bin", "w+b" );

if(encrypt)
{
	printf( "The file 'encrypt.bin' was opened\n" );
}
else
{
	HandleError( "Problem opening the file 'encrypt.bin'\n" );
}

//--------------------------------------------------------------------
// Открытие файла, в который производится запись сессионного ключа.

session = fopen( "session.bin", "w+b" );

if(session)
{
	printf( "The file 'session.bin' was opened\n" );
}
else
{
	HandleError( "Problem opening the file 'session.bin'\n" );
}

//--------------------------------------------------------------------
// Открытие файла, в который производится запись вектора инициализации.

vector = fopen( "vector.bin", "w+b" );

if(vector)
{
	printf( "The file 'vector.bin' was opened\n" );
}
else
{
	HandleError( "Problem opening the file 'vector.bin'\n" );
}

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

if(CryptAcquireContext(
   &hProv, 
   "Public", 
   NULL, 
   75, 
   0)) 
{
	printf("The key container \"Public\" has been acquired. \n");
}
else
{
	HandleError("Error during CryptAcquireContext.");
}

//--------------------------------------------------------------------
// Чтение  открытого ключа получателя из файла.

dwBlobLen = (DWORD)fread(pbKeyBlob, 1, 100, Public);

if(dwBlobLen)
{
	printf( "The public key was read from the 'public.bin'\n" );
}
else
{
	HandleError( "The public key can not be reading from the 'public.bin'\n" );
}  

fclose(Public);


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

if(CryptGetUserKey(
   hProv, 
   AT_KEYEXCHANGE, 
   &hKey)) 
{
	printf("The private key has been acquired. \n");
}
else
{
	printf("Error during CryptGetUserKey private key.");
}

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

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

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

//--------------------------------------------------------------------
// Зашифрование сессионного ключа.
//--------------------------------------------------------------------

//--------------------------------------------------------------------
// Определение размера 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");
}
//--------------------------------------------------------------------
// Зашифрование сессионного ключа на ключе Agree.

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

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

if (CryptGetKeyParam(
	hSessionKey, 
	KP_IV, 
	NULL, 
	&dwIV, 
	0))
{
	printf("Size of the IV for the session key determined. \n");
}
else
{
	 HandleError("Error computing IV length.");
}

pbIV = (BYTE*)malloc(dwIV);

if (pbIV)
{
	printf("Memory has been allocated for the IV. \n");
}
else
{
	HandleError("Out of memory. \n");
}

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

if (CryptGetKeyParam(
	hSessionKey, 
	KP_IV, 
	pbIV, 
	&dwIV, 
	0))
{
	printf( "CryptGetKeyParam succeeded. \n");
}
else
{
	HandleError("Error during CryptGetKeyParam.");
}


//--------------------------------------------------------------------
// Запись вектора инициализации в файл.

if(fwrite(
   pbIV,
   1,
   dwIV,
   vector))
{
	printf( "The IV was written to the 'vector.bin'\n" );
}
else
{
	HandleError( "The IV can not be written to the 'vector.bin'\n" );
}  

//--------------------------------------------------------------------
// Запись зашифрованного сессионного ключа в файл.

if(fwrite(
   pbKeyBlobSimple,
   1,
   dwBlobLenSimple,
   session))
{
	printf( "The session key was written to the 'session.bin'\n" );
}
else
{
	HandleError( "The session key can not be written to the 'session.bin'\n" );
}  

//--------------------------------------------------------------------
// Чтение  файла, который будет зашифрован блоками по 4 КБ. Зашифрование 
// прочитанного блока и запись его в файл "encrypt.bin".
//--------------------------------------------------------------------

do 
{
	cbContent = (DWORD)fread(pbContent, 1, 4096, source);
	if(cbContent)
	{
	 // Зашифрование прочитанного блока на сессионном ключе.
		if(CryptEncrypt(
		hSessionKey,
		0,
		TRUE,
		0,
		pbContent,
		&cbContent,
		bufLen))
		{
			printf( "Encryption succeeded. \n");
			// Запись зашифрованного блока в файл.
			if(fwrite(
				pbContent,
				1,
				cbContent,
				encrypt))
			{
				printf( "The encrypted content was written to the 'encrypt.bin'\n" );
		}
			else
			{
				HandleError( "The encrypted content can not be written to the 'encrypt.bin'\n" );
		}  
	}
		else
		{
			HandleError("Encryption failed.");
	}
}
	else
	{
		HandleError( "Problem reading the file 'source.txt'\n" );
}
}
while (!feof(source));

//--------------------------------------------------------------------
// Закрытие файлов.

fclose (source);
fclose (encrypt);
fclose (session);
fclose (vector);

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

free(pbKeyBlobSimple);

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

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

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

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

printf("The program ran to completion without error. \n");

}// Конец 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: не поддерживает.