Referência MQL5Funções de redeSocketTlsHandshake

SocketTlsHandshake

Inicia uma conexão TLS (SSL) segura com o host especificado usando o protocolo TLS Handshake. Durante o Handshake, o cliente e o servidor concordam com os parâmetros de conexão: a versão do protocolo usado e o método de criptografia de dados.

bool  SocketTlsHandshake(
   int           socket,               // soquete
   const string  host                  // endereço do host
   );

Parâmetros

socket

[in] Identificador do soquete retornado pela função SocketCreate. Ao passar um identificador inválido para _LastError é registrado o erro 5270 (ERR_NETSOCKET_INVALIDHANDLE).

host

[in] Endereço do host com o qual é estabelecida uma conexão segura.

Valor retornado

Retorna true em caso de sucesso, caso contrário, false.

Comentário:

Antes de uma conexão segura, o programa deve estabelecer uma conexão TCP normal ao host usando SocketConnect.

Em caso de falha ao estabelecer uma conexão segura, em _LastError é registrado o erro 5274 (ERR_NETSOCKET_HANDSHAKE_FAILED).

Não é necessária a chamada desta função, se a conexão é realizada para a porta 443. Essa é a porta TCP padrão usada para conexões TLS (SSL) seguras.

A função só pode ser chamada por EAs e scripts, pois eles trabalham em seu próprio fluxo de execução. Quando chamado do indicador GetLastError() retorna o erro 4014 — "Função do sistema não permitida para chamada".

Exemplo:

//+------------------------------------------------------------------+
//|                                           SocketTlsHandshake.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com
#property version     "1.00"

#define   SERVER    "smtp.gmail.com"
#define   PORT      587
//+------------------------------------------------------------------+
//| Mudança manual de uma conexão insegura para uma conexão segura   |
//+------------------------------------------------------------------+
bool TlsHandshake(int socket)
  {
//--- recebemos a saudação do servidor
   string rsp;

   if(!RecvString(socket,rsp))
      return(false);
//--- cumprimentamos o servidor
   if(!SendString(socket,"EHLO my.domain.com\r\n"))
      return(false);
//--- recebemos uma resposta do servidor com a lista de comandos suportados
   if(!RecvString(socket,rsp))
      return(false);
//--- imprimimos a saudação
   Print("SERVER: ",rsp);
//--- informamos ao servidor que desejamos mudar de uma conexão insegura para uma segura usando TLS
   if(!SendString(socket,"STARTTLS\r\n"))
      return(false);
//--- obtemos a resposta do servidores
   if(!RecvString(socket,rsp))
      return(false);
//--- noo exemplo, não verificamos a resposta do servidor de que ele está pronto para mudar para o TLS ('Ready to start TLS')

//--- iniciamos uma conexão TLS (SSL) segura com o host especificado usando o protocolo TLS Handshake
   if(SocketTlsHandshake(socket,SERVER))
      return(true);

   Print("SocketTlsHandshake() failed. Error ",GetLastError());
   return(false);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart(void)
  {
//--- criamos um soquete e obtemos seu identificador
   int socket=SocketCreate();

   if(socket==INVALID_HANDLE)
     {
      Print("SocketCreate() failed. Error ",GetLastError());
      return;
     }
//--- contectamo-nos ao servidor SERVER na porta PORT
   if(!SocketConnect(socket,SERVER,PORT,10000))
     {
      Print("SocketConnect() failed. Error ",GetLastError());
     }
   else
     {
      //--- foi estabelecida uma conexão insegura
      PrintFormat("%s connection has been established to %s:%d",(PORT==443 ? "A secured" : "An unsecured"),SERVER,PORT);
      //--- mudamos para uma conexão segura
      if(PORT!=443 && TlsHandshake(socket))
        {
         PrintFormat("Unsecured connection to %s:%d switched to secured",SERVER,PORT);
         //--- se a conexão estiver protegida por um certificado, imprimimos seus dados
         string   subject,issuer,serial,thumbprint;
         datetime expiration;

         if(SocketTlsCertificate(socket,subject,issuer,serial,thumbprint,expiration))
           {
            Print("TLS certificate:");
            Print("   Owner:      ",subject);
            Print("   Issuer:     ",issuer);
            Print("   Number:     ",serial);
            Print("   Print:      ",thumbprint);
            Print("   Expiration: ",expiration);
           }
        }
     }
//--- fechamos o soquete após usá-lo
   SocketClose(socket);
   /*
   Resultado:
   An unsecured connection has been established to smtp.gmail.com:587
   SERVER: 220 smtp.gmail.com ESMTP a640c23a62f3a-a9b1f298319sm82305866b.105 - gsmtp

   SERVER: 250-smtp.gmail.com at your service, [37.193.40.122]
   250-SIZE 35882577
   250-8BITMIME
   250-STARTTLS
   250-ENHANCEDSTATUSCODES
   250-PIPELINING
   250-CHUNKING
   250 SMTPUTF8

   SERVER: 220 2.0.0 Ready to start TLS

   SocketTlsHandshake(): A secure connection to smtp.gmail.com:587 is now established
   TLS certificate:
      Owner:  /CN=smtp.gmail.com
      Issuer:  /C=US/O=Google Trust Services/CN=WR2
      Number:     1f:f4:db:2a:5a:e6:dc:52:0a:4c:05:ce:81:cc:c3:f7
      Print: d6be8af229b5329cd3d4c2789c02aa94f89b421c
      Expiration: 2024.12.30 08:25:30
   */
  }
//+------------------------------------------------------------------+
//| Enviamos uma string para o servidor                              |
//+------------------------------------------------------------------+
bool SendString(int socket,const string str)
  {
//--- convertemos a string em um array de caracteres
   uchar data[];
   int   size=StringToCharArray(str,data,0,str.Length(),CP_UTF8);
//--- enviamos os dados para o soquete
   ResetLastError();
   if(SocketSend(socket,data,size)==size)
      return(true);
//--- erro de envio de dados
   Print("Failed to send data to server. Error ",GetLastError());
   return false;
  }
//+------------------------------------------------------------------+
//| Obtém uma string do servidor                                     |
//+------------------------------------------------------------------+
bool RecvString(int socket,string& result,uint timeout_ms=1000)
  {
//--- aguardamos que os dados apareçam no soquete
   ulong wait_time_end=GetMicrosecondCount()+timeout_ms*1000;

   while(!SocketIsReadable(socket))
     {
      Sleep(10);
      //--- o tempo de espera dos dados expirou, retornamos NULL como resposta
      if(wait_time_end<GetMicrosecondCount())
        {
         Print("ERROR: No response from server");
         return(false);
        }
     }
//--- lemos os dados do soquete
   uchar  data[128];
   uint   size=0;
   string resp=NULL;

   do
     {
      uchar b[1];
      int   n=SocketRead(socket,b,1,1000);

      if(n < 0)
         break;

      if(n)
        {
         data[size++]=b[0];

         if(size==data.Size())
           {
            resp += CharArrayToString(data,0,data.Size(),CP_UTF8);
            size = 0;
           }
        }
     }
   while(SocketIsReadable(socket));
//--- copiamos os dados lidos para a linha
   if(size)
      resp+=CharArrayToString(data,0,size,CP_UTF8);
//--- se a string estiver vazia, ocorrerá um erro
   if(!resp.Length())
     {
      Print("ERROR: No response from server");
      return(false);
     }
//--- entregamos a string
   result=resp;
   return(true);
  }

SocketSend

SocketTlsCertificate