Сервер для отправки зашифрованных данных

#include "stdafx.h"
#pragma comment(lib, "crypt32.lib")
 
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <Wincrypt.h>
#include <iostream>
 
#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
////////////////////////////////
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;
using namespace System::Text;
using namespace System::Net::Sockets;
using namespace System::Net;
using namespace System::IO;
using namespace System::Runtime::InteropServices;
using namespace std;
 
 
int main(array<System::String ^> ^args)
{   
    TcpListener^ listner = gcnew TcpListener(gcnew IPEndPoint(IPAddress::Parse("127.0.0.1"), 12000));
    listner->Start();
    TcpClient^ client = listner->AcceptTcpClient();
    StreamReader^ sr = gcnew StreamReader(client->GetStream());
 
    ////////////////////////////////////////////////////////////////////
    TcpClient^ client2 = gcnew TcpClient();
    client2->Connect(gcnew IPEndPoint(IPAddress::Parse("127.0.0.1"), 12012));
 
    StreamWriter^ sw = gcnew StreamWriter(client2->GetStream());
    sw->AutoFlush = true;
    ////////////////////////////////////////////////////////////////////
 
    ////////////////////////////////////////
    //String^ managedString = "Hello unmanaged world (from the managed world).";
 
    // Marshal the managed string to unmanaged memory.
    //char* stringPointer = (char*) Marshal::StringToHGlobalAnsi(managedString ).ToPointer();
 
    //String^ managedString = "ytutu";
    
    //system("pause");
 
    //////////////////////////////////////
    try
    {
        while (true)
        {
            
            String^ managedString = ((String ^)sr->ReadLine());
            char* stringPointer = (char*) Marshal::StringToHGlobalAnsi(managedString ).ToPointer();
 
            //описание структур
            DATA_BLOB DataIn;
            DATA_BLOB DataOut;
            DATA_BLOB DataVerify;
            //BYTE *pbDataInput = (BYTE *)argv[1];  //шифр текст
            BYTE *pbDataInput = (BYTE *)stringPointer;  //шифр текст
    
            DWORD cbDataInput = strlen((char *)pbDataInput)+1;
            DataIn.pbData = pbDataInput;    
            DataIn.cbData = cbDataInput;
            //CRYPTPROTECT_PROMPTSTRUCT PromptStruct;
            //LPWSTR pDescrOut = NULL;
 
//-------------------------------------------------------------------
            // вывод шифруемого текста
            printf("The data to be encrypted is: %s\n", pbDataInput);
//-------------------------------------------------------------------
 
            //  ZeroMemory(&PromptStruct, sizeof(PromptStruct));
            //  PromptStruct.cbSize = sizeof(PromptStruct);
            //  PromptStruct.dwPromptFlags = CRYPTPROTECT_PROMPT_ON_PROTECT;
            //  PromptStruct.szPrompt = L"This is a user prompt.";
 
//-------------------------------------------------------------------
//  шифрование текста
 
            if(CryptProtectData(&DataIn, L"This is the description string.", NULL, NULL, NULL, CRYPTPROTECT_AUDIT, &DataOut))
            {       
                printf("The encryption phase worked. \n");
            }
            else
            {
                printf("Encryption error!");
                //MyHandleError("Encryption error!");
            }
 
//-------------------------------------------------------------------
//   расшифровывание текста 
 
            if (CryptUnprotectData(&DataOut, NULL, NULL, NULL, NULL, 0, &DataVerify))
            {
                //cout << DataOut.cbData<< endl;//узнаем количество символов в массиве
                //вывод массива/зашифрованного текста
                for (int i=0; i <= DataOut.cbData; i++)
                {
                    //преобразование из байт в стринг
                    //String^ sw = gcnew String(reinterpret_cast<char*>(DataOut.pbData[i]));
                //  sw = (String ^)DataOut.pbData[i];
                    //sw2->WriteLine(Console::ReadLine());
                    
                    printf("%c",DataOut.pbData[i]);
                }
                printf("\n");
                printf("The decrypted data is: %s\n", DataVerify.pbData);
                //      printf("The description of the data was: %S\n",pDescrOut);
            }
            else
            {
                printf("Decryption error!");
                //MyHandleError("Decryption error!");
            }
 
            
 
            Console::WriteLine(sr->ReadLine());
            ///////////////client//////////////////////////
            sw->WriteLine(Console::ReadLine());
 
 
            //  LocalFree(pDescrOut);
            LocalFree(DataOut.pbData);
            LocalFree(DataVerify.pbData);
            Marshal::FreeHGlobal(IntPtr(stringPointer));
        }
    }
    catch (Exception^ ex)
    {
        Console::Write("Соединение разорвано!"); 
    }
 
    client->Close();
 
    Console::ReadKey("Соединение разорвано!");   
    return 0;
}

#include "stdafx.h"
 
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;
using namespace System::Text;
using namespace System::Net::Sockets;
using namespace System::Net;
using namespace System::IO;
 
int main(array<System::String ^> ^args)
{
    TcpClient^ client = gcnew TcpClient();
    client->Connect(gcnew IPEndPoint(IPAddress::Parse("127.0.0.1"), 12000));
 
    StreamWriter^ sw = gcnew StreamWriter(client->GetStream());
    sw->AutoFlush = true;
 
 
    //////////////////////////////////////////////////////////////
    
    TcpListener^ listner = gcnew TcpListener(gcnew IPEndPoint(IPAddress::Parse("127.0.0.1"), 12012));
    listner->Start();
    TcpClient^ client2 = listner->AcceptTcpClient();
    StreamReader^ sr = gcnew StreamReader(client2->GetStream());
 
    //////////////////////////////////////////////////////////////
    try
    {
        while (true)
        {
            sw->WriteLine(Console::ReadLine());
            /////server/////////////////////////////
            Console::WriteLine(sr->ReadLine());
        }
    }
    catch (Exception^ ex)
    {
        Console::Write("Соединение разорвано!"); 
    }
 
    client->Close();
 
    Console::ReadKey();
 
    return 0;
 
    return 0;
}