Var
hProv: HCRYPTPROV;
bufLen:DWORD;
Hash: HCRYPTHASH;
pbIV:TMemoryStream;// âåêòîð èíèôèàëèçàöèè ñåññèîííîãî êëþ÷à
EnCrMes:TMemoryStream;
SessionKey:TMemoryStream;
Key: HCRYPTKEY;
dwBlobLenSimple:DWORD;//äëèíà ñåññèîííîãî êëþ÷åâîãî áëîáà
hPubKey:HCRYPTKEY;
hSessionKey:HCRYPTKEY;
DataLen,BuffLen: DWORD;
Str, Pass: string;
CryptStream:TMemoryStream;
CrMes, Res,Vector: TMemoryStream;
hAgreeKey:HCRYPTKEY;
buf: array [0..511] of byte;
Param: Cardinal;
VecSizeIV: PByte;
pbKeyBlobSimple:TMemoryStream;//  ñåññèîííûé êëþ÷åâîé ÁËÎÁ
dwCount: Byte;
dwIV: Dword; //äëèíà âåêòîðà èíèöèàëèçàöèè
pbKeyBlob:TMemoryStream;
dwBlobLen:dword;
ke_alg:ALG_ID ;
sourceFIle:TMemoryStream;
sourceSize:Dword;
begin
//??????????? ? ??????????_
CryptAcquireContextA(@hProv,nil,nil,PROV_GOST_2001_DH,PROV_RSA_FULL); //CRYPT_VERIFYCONTEXT  CRYPT_NEWKEYSET

// ïîëó÷èòü ÏÓÁËÈ×ÍÛÉ ÊËÞ×
// èìïîðòèðóåì ïóáëè÷íûé êëþ÷
        if (CryptImportPublicKeyInfoEx(hProv,MY_ENCODING_TYPE,@(pCertContext.pCertInfo.SubjectPublicKeyInfo),0,0,nil,@hPubKey)) then
        begin

        end
        else
        begin
//            CertFreeCertificateContext(pCertContext);
            Err('');
        end;

        pbKeyBlob:=TMemoryStream.Create;
        // ýêñïîðòèðóåì åãî â  BLOB
        if (CryptExportKey(hPubKey,0,PUBLICKEYBLOB,0,pbKeyBlob.Memory,@dwBlobLen)) then
        begin
                //printf("Public key exported to blob\n");
        end
        else
        begin
            Err('');;
        end;
        pbKeyBlob.Size:=dwBlobLen;
        if (CryptExportKey(hPubKey,0,PUBLICKEYBLOB,0,pbKeyBlob.Memory,@dwBlobLen)) then
        begin
            //printf("Public key exported to blob\n");
        end
        else
        begin
            Err('');;
        end;



         ///ïîëó÷àåì äåñêðèïòîð çàêðûòîãî êëþ÷à îòïðàâèòåëÿ
        if CryptGetUserKey(hProv,AT_KEYEXCHANGE,@Key) then
        begin

        end
        else
        begin
         Err('');
        end;

       //Ïîëó÷åíèå êëþ÷à ñîãëàñîâàíèÿ èìïîðòîì îòêðûòîãî êëþ÷à ïîëó÷àòåëÿ
       // íà çàêðûòîì êëþ÷å îòïðàâèòåëÿ.
       if(CryptImportKey(hProv,pbKeyBlob.Memory,dwBlobLen,Key,0,@hAgreeKey)) then
       begin
        //printf("The responder public key has been imported. \n");
       end
       else
       begin
         Err('');;
       end;
       ke_alg := CALG_PRO_EXPORT; // PRO_EXPORT àëãîðèòì êëþ÷à ñîãëàñîâàíèÿ

       // Óñòàíîâëåíèå PRO_EXPORT àëãîðèòìà êëþ÷à ñîãëàñîâàíèÿ
       if(CryptSetKeyParam(hAgreeKey,KP_ALGID,@ke_alg,0)) then
       begin
            //        printf("PRO_EXPORT agree key algorithm has been set. \n");
       end
       else
       begin
         Err('');;
       end;

       // ãåíåðàöèÿ ñåññèîííîãî êëþ÷à.
       if(CryptGenKey(hProv,CALG_G28147,CRYPT_EXPORTABLE,@hSessionKey)) then
       begin
       // printf("Original session key is created. \n");
       end
       else
       begin
       // HandleError("ERROR -- CryptGenKey.");
       Err('');;
       end;
       //--------------------------------------------------------------------
       // Çàøèôðîâàíèå ñåññèîííîãî êëþ÷à.
       //--------------------------------------------------------------------

       //--------------------------------------------------------------------
       // Îïðåäåëåíèå ðàçìåðà BLOBà ñåññèîííîãî êëþ÷à è ðàñïðåäåëåíèå ïàìÿòè.


       if(CryptExportKey(hSessionKey,hAgreeKey,SIMPLEBLOB,0,nil,@dwBlobLenSimple)) then
       begin
       // printf("Size of the BLOB for the sender session key determined. \n");
       end
       else
       begin
        //HandleError("Error computing BLOB length.");
        Err('');;
       end;

       pbKeyBlobSimple:=TMemoryStream.Create;
       pbKeyBlobSimple.size:=dwBlobLenSimple;

       //    if(!pbKeyBlobSimple)
       //        HandleError("Out of memory. \n");

       // Çàøèôðîâàíèå ñåññèîííîãî êëþ÷à íà êëþ÷å Agree.

       if(CryptExportKey(hSessionKey,hAgreeKey,SIMPLEBLOB,0,pbKeyBlobSimple.Memory,@dwBlobLenSimple)) then
       begin
           //           printf("Contents have been written to the BLOB. \n");
       end
       else
       begin
         Err('');;
         //        HandleError("Error during CryptExportKey.");
       end;
      // Îïðåäåëåíèå ðàçìåðà âåêòîðà èíèöèàëèçàöèè ñåññèîííîãî êëþ÷à.
      if(CryptGetKeyParam(hSessionKey,KP_IV,nil,@dwIV,0)) then
      begin
       // printf("Size of the IV for the session key determined. \n");
      end
      else
      begin
        Err('');;
        //HandleError("Error computing IV length.");
      end;
      pbIV:=TMemoryStream.Create;
      pbIV.size:=dwIV;

      // Îïðåäåëåíèå âåêòîðà èíèöèàëèçàöèè ñåññèîííîãî êëþ÷à.
      if(CryptGetKeyParam(hSessionKey,KP_IV,pbIV.Memory,@dwIV,0)) then
      begin
       // printf( "CryptGetKeyParam succeeded. \n");
      end
      else
      begin
       Err('');;
       // HandleError("Error during CryptGetKeyParam.");
      end;


      //--------------------------------------------------------------------
      // Çàïèñü âåêòîðà èíèöèàëèçàöèè â ôàéë.
      pbIV.Position:=0;
      pbIV.SaveToFile('c:\hp\my.vector');
      pbIV.Position:=0;

      // Çàïèñü çàøèôðîâàííîãî ñåññèîííîãî êëþ÷à â ôàéë.

      SessionKey:=TMemorystream.create;
      SessionKey.WriteBuffer(PCryptSimpleBLOB(pbKeyBlobSimple.Memory).bSV,1*SEANCE_VECTOR_LEN);
      SessionKey.Position:=0;
      SessionKey.SaveToFile('c:\hp\my.bsv');
      SessionKey.Clear;

      //--------------------------------------------------------------------
      // Çàïèñü çàøèôðîâàííîãî ñåññèîííîãî êëþ÷à â ôàéë.
      SessionKey.WriteBuffer(PCryptSimpleBLOB(pbKeyBlobSimple).bEncryptedKey,1*G28147_KEYLEN);
      SessionKey.Position:=0;
      SessionKey.SaveToFile('c:\hp\my.bEncryptedKey');
      SessionKey.Clear;


      //--------------------------------------------------------------------
      // Çàïèñü çàøèôðîâàííîãî ñåññèîííîãî êëþ÷à â ôàéë.
      SessionKey.WriteBuffer(PCryptSimpleBLOB(pbKeyBlobSimple).bMacKey,1*EXPORT_IMIT_SIZE);
      SessionKey.Position:=0;
      SessionKey.SaveToFile('c:\hp\my.bMacKey');
      SessionKey.Clear;

      //--------------------------------------------------------------------
      // ×òåíèå  ôàéëà, êîòîðûé áóäåò çàøèôðîâàí áëîêàìè ïî 4 ÊÁ. Çàøèôðîâàíèå
      // ïðî÷èòàííîãî áëîêà è çàïèñü åãî â ôàéë "encrypt.bin".
      //--------------------------------------------------------------------
      sourceFIle:=TMemoryStream.Create;
      sourceFIle.LoadFromFile('c:\hp\my.txt');
      sourceFIle.Position:=0;
      sourceSize:=sourceFIle.Size;
      bufLen:=sourceFIle.Size;
     // çàøèôðîâûâàåì ïðî÷èòàííûé áëîê íà ñåññèîííîì êëþ÷å.
     if(CryptEncrypt(hSessionKey,0,True,//bFinal,
                0,sourceFIle.Memory,@sourceSize,bufLen)) then
     begin
         //  printf( "Encryption succeeded. \n");
         sourceFIle.Position:=0;
         sourceFIle.SaveToFile('c:\hp\my.enc');
     end
     else
     begin
           //HandleError("Encryption failed.");
           Err('');;
     end;

var
  tSimpleBlobHeaderStandart:CRYPT_SIMPLEBLOB;
  size:DWORD;
  p:Pointer;
  ke_alg:ALG_ID ;
  bEncryptionParamSetStandart: array [0..10] of byte; //íåìåíÿåìàÿ ÷àñòü áëîáà
  CryptedFile:TMemoryStream;
  CryptedFileSize:DWORD;
  SessionFile:TMemoryStream;
  pbIV:TMemoryStream;// âåêòîð èíèôèàëèçàöèè ñåññèîííîãî êëþ÷à
  SessionFileEncrypted:TMemoryStream;
  hAgreeKey:HCRYPTKEY;
    hPubKey:HCRYPTKEY;
    hKey:HCRYPTKEY;
  MacKey:TMemoryStream;
  Vector:TMemoryStream;
  resFile:TMemoryStream;
  pbKeyBlobSimple:TMemoryStream;
  hProv: HCRYPTPROV;
  hSessionKey:HCRYPTKEY;
  pbKeyBlob:TMemoryStream;//  ñåññèîííûé êëþ÷åâîé ÁËÎÁ
//  CryptedFile:TMemoryStream;
begin
    ke_alg := CALG_PRO_EXPORT; // PRO_EXPORT àëãîðèòì êëþ÷à ñîãëàñîâàíèÿ
    bEncryptionParamSetStandart[0]:=$30;
    bEncryptionParamSetStandart[1]:=$09;
    bEncryptionParamSetStandart[2]:=$06;
    bEncryptionParamSetStandart[3]:=$07;
    bEncryptionParamSetStandart[4]:=$2a;
    bEncryptionParamSetStandart[5]:=$85;
    bEncryptionParamSetStandart[6]:=$03;
    bEncryptionParamSetStandart[7]:=$02;
    bEncryptionParamSetStandart[8]:=$02;
    bEncryptionParamSetStandart[9]:=$1f;
    bEncryptionParamSetStandart[10]:=$01;

    FillChar( tSimpleBlobHeaderStandart, SizeOf( CRYPT_SIMPLEBLOB ), #0 );

 tSimpleBlobHeaderStandart.tSimpleBlobHeader.BlobHeader.aiKeyAlg := CALG_G28147;
    tSimpleBlobHeaderStandart.tSimpleBlobHeader.BlobHeader.bType := SIMPLEBLOB;
    tSimpleBlobHeaderStandart.tSimpleBlobHeader.BlobHeader.bVersion := BLOB_VERSION;
    tSimpleBlobHeaderStandart.tSimpleBlobHeader.BlobHeader.reserved := 0;

    tSimpleBlobHeaderStandart.tSimpleBlobHeader.EncryptKeyAlgId := CALG_G28147;
    tSimpleBlobHeaderStandart.tSimpleBlobHeader.Magic := G28147_MAGIC;

    CryptedFile:=TMemorystream.Create;
    CryptedFile.LoadFromFile('c:\hp\my.enc');

 // Îòêðûòèå ôàéëà, â êîòîðûé ïðîèçâîäèòñÿ çàïèñü ñåññèîííîãî êëþ÷à.
 SessionFile:=TMemoryStream.Create;
 SessionFile.LoadFromFile('c:\hp\my.bsv');//      SessionFile
 SessionFile.Position:=0;

    // Îòêðûòèå ôàéëà, â êîòîðûé ïðîèçâîäèòñÿ çàïèñü ñåññèîííîãî êëþ÷à.
    SessionFileEncrypted:=TMemoryStream.Create;
    SessionFileEncrypted.LoadFromFile('c:\hp\my.bEncryptedKey');//  SessionFileEncrypted
    SessionFileEncrypted.Position:=0;

    // Îòêðûòèå ôàéëà, â êîòîðûé ïðîèçâîäèòñÿ çàïèñü ñåññèîííîãî êëþ÷à.
    MacKey:=TMemoryStream.Create;
    MacKey.LoadFromFile('c:\hp\my.bMacKey');// MacKey
    MacKey.Position:=0;

    // Îòêðûòèå ôàéëà, â êîòîðîì õðàíèòñÿ âåêòîð èíèöèàëèçàöèè.
    Vector:=TMemoryStream.Create;
    Vector.LoadFromFile('c:\hp\my.Vector');// Vecto
    Vector.Position:=0;
    resFile:=TMemoryStream.Create;

    // ×òåíèå  âåêòîðà èíèöèàëèçàöèè èç ôàéëà.
    pbIV:=TMemoryStream.Create;
    pbIV.Size:=100;
    pbIV.LoadFromStream(Vector);

    // Ïîëó÷åíèå äåñêðèïòîðà êîíòåéíåðà ïîëó÷àòåëÿ ñ èìåíåì "Responder",
    // íàõîäÿùåãîñÿ â ðàìêàõ ïðîâàéäåðà.
    if not (CryptAcquireContext(@hProv,nil,nil,PROV_GOST_2001_DH,0)) then //0
    begin
       // HandleError("Error during CryptAcquireContext");
       Err('');
    end;
    pbKeyBlobSimple:=TMemoryStream.Create;
    pbKeyBlobSimple.Size:=((sizeof(CRYPT_SIMPLEBLOB_HEADER)+SEANCE_VECTOR_LEN+G28147_KEYLEN+EXPORT_IMIT_SIZE) + sizeof(bEncryptionParamSetStandart));
///      memcpy(&((CRYPT_SIMPLEBLOB*)pbKeyBlobSimple)->tSimpleBlobHeader, &tSimpleBlobHeaderStandart, sizeof(CRYPT_SIMPLEBLOB_HEADER)); //êîïèðóåì íåìåíÿåìûé õåäåð â áëîáå
    pbKeyBlobSimple.WriteBuffer(tSimpleBlobHeaderStandart,sizeof(CRYPT_SIMPLEBLOB_HEADER));

    // ×òåíèå  ñåñcèîííîãî êëþ÷à èç ôàéëà.
    pbKeyBlobSimple.Position:=SizeOf(CRYPT_SIMPLEBLOB_HEADER);
    SessionFile.Position:=0;
    pbKeyBlobSimple.CopyFrom(SessionFile,SEANCE_VECTOR_LEN);
//    dwBlobLenSimple:=SEANCE_VECTOR_LEN;




    // ×òåíèå  ñåñcèîííîãî êëþ÷à èç ôàéëà.
    // dwBlobLenSimple = (DWORD)fread(((CRYPT_SIMPLEBLOB*)pbKeyBlobSimple)->bEncryptedKey, 1, G28147_KEYLEN, session_EncryptedKey);
    pbKeyBlobSimple.Position:=SizeOf(CRYPT_SIMPLEBLOB_HEADER)+SEANCE_VECTOR_LEN;
    pbKeyBlobSimple.CopyFrom(SessionFileEncrypted,G28147_KEYLEN);

    // ×òåíèå  ñåñcèîííîãî êëþ÷à èç ôàéëà.
    //dwBlobLenSimple = (DWORD)fread(((CRYPT_SIMPLEBLOB*)pbKeyBlobSimple)->bMacKey, 1, EXPORT_IMIT_SIZE, session_MacKey);
    pbKeyBlobSimple.Position:=SizeOf(CRYPT_SIMPLEBLOB_HEADER)+SEANCE_VECTOR_LEN+G28147_KEYLEN;
    pbKeyBlobSimple.CopyFrom(MacKey,EXPORT_IMIT_SIZE);

    // memcpy(((CRYPT_SIMPLEBLOB*)pbKeyBlobSimple)->bEncryptionParamSet, bEncryptionParamSetStandart, 11); //êîïèðóåì íåìåíÿåìóþ ASN ñòðóêòóðó
    pbKeyBlobSimple.Position:=SizeOf(CRYPT_SIMPLEBLOB_HEADER)+SEANCE_VECTOR_LEN+G28147_KEYLEN+EXPORT_IMIT_SIZE;
    pbKeyBlobSimple.WriteBuffer(bEncryptionParamSetStandart,11);

    Application.MessageBox('11','');

   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   //LoadPublicKey
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// èìïîðòèðóåì îòêðûòûé êëþ÷
        if (CryptImportPublicKeyInfoEx(
            hProv,
            MY_ENCODING_TYPE,
            @(pCertContext.pCertInfo.SubjectPublicKeyInfo),
            0,
            0,
            nil,
            @hPubKey)) then
        begin
            //printf("Public key imported from cert file\n");
        end else begin
            CertFreeCertificateContext(pCertContext);
            //HandleError( "CryptImportPublicKeyInfoEx" );
            Err('');
        end;
        CertFreeCertificateContext(pCertContext);
        pbKeyBlob:=TMemoryStream.Create;
        pbKeyBlob.Size:=100;
        size:=pbKeyBlob.size;
        // ýêñïîðòèðóåì åãî â áëîá BLOB
        if (CryptExportKey(
            hPubKey,
            0,
            PUBLICKEYBLOB,
            0,
            pbKeyBlob.Memory,
            @size)) then
        begin
            //printf("Public key exported to blob\n");
        end
        else
        begin
           // HandleError( "CryptExportKey" );
                Err('');
        end;


        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Ïîëó÷åíèå äåñêðèïòîðà çàêðûòîãî êëþ÷à ïîëó÷àòåëÿ.
    if(CryptGetUserKey(hProv,AT_KEYEXCHANGE,@hKey)) then
    begin
        //printf("The private key has been acquired. \n");
    end
    else
    begin
        Err('');
//        HandleError("Error during CryptGetUserKey private key.");
    end;
                  //    111

// Ïîëó÷åíèå êëþ÷à ñîãëàñîâàíèÿ èìïîðòîì îòêðûòîãî êëþ÷à îòïðàâèòåëÿ
    // íà çàêðûòîì êëþ÷å ïîëó÷àòåëÿ.
    if (CryptImportKey(
        hProv,
        pbKeyBlob.Memory,
        100, //dwBlobLen
        hKey,
        0,
        @hAgreeKey)) then
    begin
       // printf("The sender public key has been imported. \n");
    end
    else
    begin
       // HandleError("Error during CryptImportKey public key.");
        Err('');
    end;

    // Óñòàíîâëåíèå PRO_EXPORT àëãîðèòìà êëþ÷à ñîãëàñîâàíèÿ
    if(CryptSetKeyParam(
        hAgreeKey,
        KP_ALGID,
        @ke_alg,//(LPBYTE)&ke_alg,
        0)) then
    begin
       // printf("PRO_EXPORT agree key algorithm has been set. \n");
    end
    else
    begin
       // HandleError("Error during CryptSetKeyParam agree key.");
        Err('');
    end;

      
// Ïîëó÷åíèå ñåññèîííîãî êëþ÷à èìïîðòîì çàøèôðîâàííîãî ñåññèîííîãî êëþ÷à
    // íà êëþ÷å Agree.
    if (CryptImportKey(
        hProv,
        pbKeyBlobSimple.Memory,
        71,
        hAgreeKey,
        0,
        @hSessionKey)) then
    begin
       // printf("The session key has been imported. \n");
    end
    else
    begin
       // HandleError("Error during CryptImportKey session key.");
        Err('');
    end;

    // Óñòàíîâêà âåêòîðà èíèöèàëèçàöèè - áåç íåãî ïåðâûå 8 áàéò ðàñøèôðóþòñÿ íåïðàâèëüíî.!!!!!!
    if not (CryptSetKeyParam(
        hSessionKey,
        KP_IV,
        pbIV.Memory,
        0)) then
    begin
       // HandleError("Error during CryptSetKeyParam.");
    end;
 //   printf( "CryptSetKeyParam succeeded. \n");
    CryptedFile:=TMemoryStream.Create;
    CryptedFile.LoadFromFile('c:\hp\my.enc');
    CryptedFile.Position:=0;
    CryptedFileSize:=CryptedFile.Size;


// ðàñøèôðîâàíèå ïðî÷èòàííîãî áëîêà íà ñåññèîííîì êëþ÷å.
            if(CryptDecrypt(
                hSessionKey,
                0,
                true,//bFinal,
                0,
                CryptedFile.Memory,
                @CryptedFilesize)) then
            begin
            end
            else
            begin
                CryptedFile.Position:=0;
                CryptedFile.SaveToFile('c:\hp\my.dec');
                Err('');
               // HandleError("Decryption failed.");
            end