Сканер портов VPN протокола IKeV2 для Borland C++ Builder 6

    
#ifndef HH
#define HH
      
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <windows.h>
#pragma comment(lib, "ws2_32.lib")
      
// Явные определения для BCB6
#ifndef SOCKET_ERROR
#define SOCKET_ERROR (-1)
#endif
#ifndef INVALID_SOCKET
#define INVALID_SOCKET (SOCKET)(~0)
#endif
      
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
      
class TForm1 : public TForm
{
__published:
    TButton *btnStart;
    TButton *btnStop;
    TMemo *Memo1;
    void __fastcall btnStartClick(TObject *Sender);
    void __fastcall btnStopClick(TObject *Sender);
    void __fastcall FormCreate(TObject *Sender);
    void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
      
private:
    bool isRunning;
    SOCKET tcpSocket;
    SOCKET udpSocket;
    static DWORD WINAPI TCPProxyThread(LPVOID lpParam);
    static DWORD WINAPI UDPProxyThread(LPVOID lpParam);
    void Log(const AnsiString &message);
      
public:
    __fastcall TForm1(TComponent* Owner);
};
      
// Правильное объявление глобальной переменной формы
extern PACKAGE TForm1 *Form1;
      
#endif

  

    
#include "h.h"
#include <stdio.h>
      
// Явное определение глобальной переменной формы
TForm1 *Form1;
      
#define PROXY_IP "46.17.107.238"
#define PROXY_PORT 500
      
//---------------------------------------------------------------------------
char* inet_ntoa_r(in_addr addr, char* buf) {
    sprintf(buf, "%d.%d.%d.%d",
            addr.S_un.S_un_b.s_b1,
            addr.S_un.S_un_b.s_b2,
            addr.S_un.S_un_b.s_b3,
            addr.S_un.S_un_b.s_b4);
    return buf;
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)
{
    isRunning = false;
    tcpSocket = INVALID_SOCKET;
    udpSocket = INVALID_SOCKET;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        Log("Ошибка инициализации Winsock");
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
    btnStopClick(NULL);
    WSACleanup();
}
//---------------------------------------------------------------------------
void TForm1::Log(const AnsiString &message)
{
    Memo1->Lines->Add(DateTimeToStr(Now()) + " | " + message);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnStartClick(TObject *Sender)
{
    if (isRunning) return;
      
    // TCP сервер
    tcpSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (tcpSocket == INVALID_SOCKET) {
        Log("Ошибка создания TCP сокета: " + IntToStr(WSAGetLastError()));
        return;
    }
      
    sockaddr_in tcpAddr;
    tcpAddr.sin_family = AF_INET;
    tcpAddr.sin_port = htons(PROXY_PORT);
    tcpAddr.sin_addr.s_addr = INADDR_ANY;
      
    if (bind(tcpSocket, (sockaddr*)&tcpAddr, sizeof(tcpAddr)) == -1) {
        Log("Ошибка привязки TCP сокета: " + IntToStr(WSAGetLastError()));
        closesocket(tcpSocket);
        return;
    }
    listen(tcpSocket, SOMAXCONN);
      
    // UDP сервер
    udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (udpSocket == INVALID_SOCKET) {
        Log("Ошибка создания UDP сокета: " + IntToStr(WSAGetLastError()));
        closesocket(tcpSocket);
        return;
    }
      
    sockaddr_in udpAddr;
    udpAddr.sin_family = AF_INET;
    udpAddr.sin_port = htons(PROXY_PORT);
    udpAddr.sin_addr.s_addr = INADDR_ANY;
      
    if (bind(udpSocket, (sockaddr*)&udpAddr, sizeof(udpAddr)) == -1) {
        Log("Ошибка привязки UDP сокета: " + IntToStr(WSAGetLastError()));
        closesocket(tcpSocket);
        closesocket(udpSocket);
        return;
    }
      
    // Запуск потоков
    CreateThread(NULL, 0, &TCPProxyThread, this, 0, NULL);
    CreateThread(NULL, 0, &UDPProxyThread, this, 0, NULL);
      
    isRunning = true;
    Log("Прокси запущен на порту " + IntToStr(PROXY_PORT));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::btnStopClick(TObject *Sender)
{
    if (!isRunning) return;
      
    closesocket(tcpSocket);
    closesocket(udpSocket);
    isRunning = false;
    Log("Прокси остановлен");
}
//---------------------------------------------------------------------------
DWORD WINAPI TForm1::TCPProxyThread(LPVOID lpParam)
{
    TForm1 *form = (TForm1*)lpParam;
    SOCKET clientSocket;
    sockaddr_in clientAddr;
    int addrLen = sizeof(clientAddr);
      
    while (form->isRunning) {
        clientSocket = accept(form->tcpSocket, (sockaddr*)&clientAddr, &addrLen);
        if (clientSocket == INVALID_SOCKET) continue;
      
        char clientIP[16];
        inet_ntoa_r(clientAddr.sin_addr, clientIP);
        form->Log("TCP подключение от: " + AnsiString(clientIP) + ":" + IntToStr(ntohs(clientAddr.sin_port)));
      
        // Перенаправление
        SOCKET proxySocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (proxySocket == INVALID_SOCKET) {
            form->Log("Ошибка создания прокси-сокета: " + IntToStr(WSAGetLastError()));
            closesocket(clientSocket);
            continue;
        }
      
        sockaddr_in proxyAddr;
        proxyAddr.sin_family = AF_INET;
        proxyAddr.sin_port = htons(PROXY_PORT);
        proxyAddr.sin_addr.s_addr = inet_addr(PROXY_IP);
      
        if (connect(proxySocket, (sockaddr*)&proxyAddr, sizeof(proxyAddr)) == -1) {
            form->Log("Ошибка подключения к прокси: " + IntToStr(WSAGetLastError()));
            closesocket(clientSocket);
            closesocket(proxySocket);
            continue;
        }
      
        // Передача данных
        char buffer[4096];
        int bytesRead;
        while ((bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0)) > 0) {
            if (send(proxySocket, buffer, bytesRead, 0) == -1) {
                break;
            }
            form->Log("TCP пакет: " + IntToStr(bytesRead) + " байт");
        }
      
        closesocket(clientSocket);
        closesocket(proxySocket);
    }
    return 0;
}
//---------------------------------------------------------------------------
DWORD WINAPI TForm1::UDPProxyThread(LPVOID lpParam)
{
    TForm1 *form = (TForm1*)lpParam;
    char buffer[4096];
    sockaddr_in clientAddr;
    int addrLen = sizeof(clientAddr);
      
    while (form->isRunning) {
        int bytesRead = recvfrom(form->udpSocket, buffer, sizeof(buffer), 0,
                               (sockaddr*)&clientAddr, &addrLen);
        if (bytesRead <= 0) continue;
      
        char clientIP[16];
        inet_ntoa_r(clientAddr.sin_addr, clientIP);
        form->Log("UDP пакет от: " + AnsiString(clientIP) + ":" + IntToStr(ntohs(clientAddr.sin_port)) + 
                 ", размер: " + IntToStr(bytesRead) + " байт");
      
        // Перенаправление
        sockaddr_in proxyAddr;
        proxyAddr.sin_family = AF_INET;
        proxyAddr.sin_port = htons(PROXY_PORT);
        proxyAddr.sin_addr.s_addr = inet_addr(PROXY_IP);
      
        sendto(form->udpSocket, buffer, bytesRead, 0,
              (sockaddr*)&proxyAddr, sizeof(proxyAddr));
    }
    return 0;
}