Uso de Proxy en Delphi/Pascal

Proxies en Delphi/Pascal

Delphi y Free Pascal siguen siendo populares para desarrollar aplicaciones de Windows. El trabajo con proxies se realiza a través de las librerías Indy (estándar de Delphi), Synapse y la API de WinINet.

Indy (Internet Direct)

Indy es la librería integrada de Delphi para programación de red.

Proxy HTTP

uses IdHTTP, IdSSLOpenSSL;

procedure FetchViaProxy;
var
  HTTP: TIdHTTP;
  SSL: TIdSSLIOHandlerSocketOpenSSL;
begin
  HTTP := TIdHTTP.Create(nil);
  SSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  try
    HTTP.IOHandler := SSL;

    // Configuración del proxy
    HTTP.ProxyParams.ProxyServer := 'proxy_ip';
    HTTP.ProxyParams.ProxyPort := 8080;
    HTTP.ProxyParams.ProxyUsername := 'username';
    HTTP.ProxyParams.ProxyPassword := 'password';
    HTTP.ProxyParams.BasicAuthentication := True;

    WriteLn(HTTP.Get('https://httpbin.org/ip'));
  finally
    SSL.Free;
    HTTP.Free;
  end;
end;

Proxy SOCKS5 a través de Indy

uses IdHTTP, IdSocks, IdSSLOpenSSL;

procedure FetchViaSocks5;
var
  HTTP: TIdHTTP;
  SSL: TIdSSLIOHandlerSocketOpenSSL;
  Socks: TIdSocksInfo;
begin
  HTTP := TIdHTTP.Create(nil);
  SSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  Socks := TIdSocksInfo.Create(nil);
  try
    // Configuración de SOCKS5
    Socks.Host := 'proxy_ip';
    Socks.Port := 1080;
    Socks.Version := svSocks5;
    Socks.Username := 'username';
    Socks.Password := 'password';
    Socks.Authentication := saUsernamePassword;

    SSL.TransparentProxy := Socks;
    HTTP.IOHandler := SSL;

    WriteLn(HTTP.Get('https://httpbin.org/ip'));
  finally
    Socks.Free;
    SSL.Free;
    HTTP.Free;
  end;
end;

SOCKS4

Socks.Version := svSocks4;
// SOCKS4 no soporta autenticación
Socks.Authentication := saNoAuthentication;

Synapse

Synapse es una librería de red alternativa para Free Pascal y Delphi.

Instalación

Descarga desde synapse.ararat.cz y añade a tu proyecto.

Proxy HTTP

uses httpsend;

procedure FetchViaSynapseProxy;
var
  HTTP: THTTPSend;
begin
  HTTP := THTTPSend.Create;
  try
    HTTP.ProxyHost := 'proxy_ip';
    HTTP.ProxyPort := '8080';
    HTTP.ProxyUser := 'username';
    HTTP.ProxyPass := 'password';

    if HTTP.HTTPMethod('GET', 'https://httpbin.org/ip') then
      WriteLn(HTTP.Document.DataString)
    else
      WriteLn('Error: ', HTTP.ResultCode);
  finally
    HTTP.Free;
  end;
end;

SOCKS a través de Synapse

uses blcksock;

procedure FetchViaSynapseSocks;
var
  Sock: TTCPBlockSocket;
begin
  Sock := TTCPBlockSocket.Create;
  try
    Sock.SocksIP := 'proxy_ip';
    Sock.SocksPort := '1080';
    Sock.SocksUsername := 'username';
    Sock.SocksPassword := 'password';
    Sock.SocksType := ST_Socks5;

    Sock.Connect('httpbin.org', '80');
    if Sock.LastError = 0 then begin
      Sock.SendString('GET /ip HTTP/1.1' + #13#10 +
                      'Host: httpbin.org' + #13#10 +
                      #13#10);
      WriteLn(Sock.RecvString(10000));
    end;
  finally
    Sock.Free;
  end;
end;

WinINet API (Windows)

Uso de la API de sistema de Windows:

uses WinInet;

procedure FetchViaWinINet;
var
  hInternet, hConnect: HINTERNET;
  Buffer: array[0..4095] of Char;
  BytesRead: DWORD;
begin
  // Abrir con proxy
  hInternet := InternetOpen(
    'MyApp',
    INTERNET_OPEN_TYPE_PROXY,
    PChar('http://proxy_ip:8080'),
    nil,
    0
  );

  if hInternet <> nil then begin
    // Establecer autenticación de proxy
    InternetSetOption(hInternet, INTERNET_OPTION_PROXY_USERNAME,
      PChar('username'), Length('username'));
    InternetSetOption(hInternet, INTERNET_OPTION_PROXY_PASSWORD,
      PChar('password'), Length('password'));

    hConnect := InternetOpenUrl(hInternet,
      'https://httpbin.org/ip', nil, 0,
      INTERNET_FLAG_RELOAD, 0);

    if hConnect <> nil then begin
      InternetReadFile(hConnect, @Buffer, SizeOf(Buffer), BytesRead);
      WriteLn(Copy(Buffer, 1, BytesRead));
      InternetCloseHandle(hConnect);
    end;

    InternetCloseHandle(hInternet);
  end;
end;

Uso de Proxies del Sistema

hInternet := InternetOpen(
  'MyApp',
  INTERNET_OPEN_TYPE_PRECONFIG,  // usar configuración del sistema
  nil,
  nil,
  0
);

Rotación de Proxies

type
  TProxyInfo = record
    Host: string;
    Port: Integer;
    Username: string;
    Password: string;
  end;

var
  Proxies: array of TProxyInfo;
  ProxyIndex: Integer = 0;

function GetNextProxy: TProxyInfo;
begin
  Result := Proxies[ProxyIndex mod Length(Proxies)];
  Inc(ProxyIndex);
end;

procedure FetchWithRotation(const URL: string);
var
  HTTP: TIdHTTP;
  Proxy: TProxyInfo;
begin
  Proxy := GetNextProxy;
  HTTP := TIdHTTP.Create(nil);
  try
    HTTP.ProxyParams.ProxyServer := Proxy.Host;
    HTTP.ProxyParams.ProxyPort := Proxy.Port;
    HTTP.ProxyParams.ProxyUsername := Proxy.Username;
    HTTP.ProxyParams.ProxyPassword := Proxy.Password;

    try
      WriteLn(HTTP.Get(URL));
    except
      on E: Exception do
        WriteLn('Error con el proxy ', Proxy.Host, ': ', E.Message);
    end;
  finally
    HTTP.Free;
  end;
end;

Consejos

1. Indy es la elección estándar para Delphi, viene con el IDE.
2. Synapse es para Free Pascal y proyectos multiplataforma.
3. WinINet es solo para aplicaciones de Windows, usando la pila del sistema.
4. Para SOCKS, usa Indy TIdSocksInfo o Synapse SocksType.
5. DLL de OpenSSL — no olvides colocar libeay32.dll y ssleay32.dll junto a tu ejecutable para HTTPS.

Conclusión

Delphi/Pascal proporcionan herramientas maduras para trabajar con proxies. Indy es la solución más completa, soportando HTTP, SOCKS4, SOCKS5 y autenticación. Para tareas sencillas en Windows, la API de WinINet es una opción rápida sin dependencias externas.