MetaTrader 5 / Exemplos
English Русский 中文 Español Deutsch 日本語 한국어 Français Italiano Türkçe
Código MQL5 de segurança: proteção de senha, geradores de chaves, limites de tempo, licenças remotas e técnicas de codificação de chave de licença de EA avançadas

Código MQL5 de segurança: proteção de senha, geradores de chaves, limites de tempo, licenças remotas e técnicas de codificação de chave de licença de EA avançadas

MetaTrader 5 — Exemplos | 20 fevereiro 2014, 15:12
14 571 2
investeo
investeo

Introdução

A maioria dos desenvolvedores precisa ter seu código protegido. Este artigo apresentará algumas maneiras diferentes de proteger o software MQL5. Todos os exemplos no artigo referem-se a Expert Advisors, mas as mesmas regras podem ser aplicadas a Scripts e Indicadores. O artigo começa com proteção de senha simples e segue com geradores de chave, licenciamento de uma determinada conta de corretores e proteção de limite de tempo. Em seguida, introduz um conceito de servidor de licença remota. Meu último arquivo sobre a estrutura MQL5-RPC descreveu chamadas de procedimento remoto do MetaTrader 5 a qualquer servidor XML-RPC.

Farei uso desta solução para dar um exemplo de uma licença remota. Além disso, vou descrever como melhorar esta solução com a codificação base64 e fornecer conselhos para suporte PGP para fazer proteção ultra-segura para Expert Advisors e Indicadores MQL5. Estou ciente que a MetaQuotes Software Corp. está fornecendo algumas opções para licença do código diretamente da seção de mercadoda MQL5.com. Isso é muito bom para todos os desenvolvedores e não invalida as ideias apresentadas neste artigo. Ambas as soluções utilizadas em conjunto só podem tornar a proteção mais forte e mais segura contra o roubo de software.


1. Proteção de senha

Vamos começar com algo simples. A primeira solução mais utilizada para a proteção de software de computador é a senha ou proteção de chave de licença. Durante a primeira execução após instalação, o usuário é consultado com uma caixa de diálogo para inserir uma senha presa a uma cópia de software (como a chave de série do Microsoft Windows ou Microsoft Office) e se a senha digitada for compatível, o usuário terá permissão para usar uma única cópia registrada de um software. Podemos usar uma variável de entrada ou uma caixa de texto direta para introduzir o código. Um código de stub (esboço de método) é mostrado abaixo.

O código abaixo inicializa um campo CChartObjectEdit que é usado para inserir uma senha. Há uma disposição predefinida de senhas permitidas que é comparada com uma senha inserida por um usuário. A senha é verificada no método OnChartEvent() após recebimento do evento CHARTEVENT_OBJECT_ENDEDIT.

//+------------------------------------------------------------------+
//|                                          PasswordProtectedEA.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"

#include <ChartObjects/ChartObjectsTxtControls.mqh>

CChartObjectEdit password_edit;

const string allowed_passwords[] = { "863H-6738725-JG76364",
                             "145G-8927523-JG76364",
                             "263H-7663233-JG76364" };
                             
int    password_status = -1;
string password_message[] = { "WRONG PASSWORD. Trading not allowed.",
                         "EA PASSWORD verified." };

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   password_edit.Create(0, "password_edit", 0, 10, 10, 260, 25);
   password_edit.BackColor(White);
   password_edit.BorderColor(Black);
   password_edit.SetInteger(OBJPROP_SELECTED, 0, true);
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   password_edit.Delete();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  if (password_status>0) 
  {
    // password correct
  } 
  }
//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if (id == CHARTEVENT_OBJECT_ENDEDIT && sparam == "password_edit" )
      {
         password_status = -1;
         
         for (int i=0; i<ArraySize(allowed_passwords); i++)
            if (password_edit.GetString(OBJPROP_TEXT) == allowed_passwords[i]) 
            {
               password_status = i;
               break;
            }
            
         if (password_status == -1) 
            password_edit.SetString(OBJPROP_TEXT, 0, password_message[0]);
         else 
            password_edit.SetString(OBJPROP_TEXT, 0, password_message[1]); 
      }
  }
//+------------------------------------------------------------------+

Este método é simples, mas fica vulnerável para que alguém publique a senha em um website com números de série hackeados. O autor do EA não pode fazer nada até que um novo Expert Advisor seja liberado e a senha roubada esteja na lista negra.


2. Gerador de chave

Geradores de chaves são mecanismos que permitem a utilização de um conjunto de senhas com base em regras predefinidas. Darei uma visão geral, fornecendo um esboço para um keygenerator (gerador de chave) abaixo. No exemplo apresentado a seguir a chave deve consistir em três números separados por dois hifens. Portanto, o formato permitido para uma senha é XXXXX-XXXXX-XXXXX.

O primeiro número deve ser divisível por 3, o segundo número deve ser divisível por 4 e o terceiro número deve ser divisível por 5. Portanto, as senhas permitidas podem ser 3-4-5, 18000-20000-20000 ou a mais complicada 3708-102792-2844770.

//+------------------------------------------------------------------+
//|                                      KeyGeneratorProtectedEA.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"

#include <ChartObjects/ChartObjectsTxtControls.mqh>
#include <Strings/String.mqh>

CChartObjectEdit password_edit;
CString user_pass;

const double divisor_sequence[] = { 3.0, 4.0, 5.0 };
                             
int    password_status = -1;
string password_message[] = { "WRONG PASSWORD. Trading not allowed.",
                         "EA PASSWORD verified." };

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   password_edit.Create(0, "password_edit", 0, 10, 10, 260, 25);
   password_edit.BackColor(White);
   password_edit.BorderColor(Black);
   password_edit.SetInteger(OBJPROP_SELECTED, 0, true);
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   password_edit.Delete();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  if (password_status==3) 
  {
    // password correct
  } 
  }
  
//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if (id == CHARTEVENT_OBJECT_ENDEDIT && sparam == "password_edit" )
      {
         password_status = 0;
         
         user_pass.Assign(password_edit.GetString(OBJPROP_TEXT));

         int hyphen_1 = user_pass.Find(0, "-");
         int hyphen_2 = user_pass.FindRev("-");
         
         if (hyphen_1 == -1 || hyphen_2 == -1 || hyphen_1 == hyphen_2) {
            password_edit.SetString(OBJPROP_TEXT, 0, password_message[0]);
            return;
         } ;     
         
         long pass_1 = StringToInteger(user_pass.Mid(0, hyphen_1));
         long pass_2 = StringToInteger(user_pass.Mid(hyphen_1 + 1, hyphen_2));
         long pass_3 = StringToInteger(user_pass.Mid(hyphen_2 + 1, StringLen(user_pass.Str())));
         
         // PrintFormat("%d : %d : %d", pass_1, pass_2, pass_3);
         
         if (MathIsValidNumber(pass_1) && MathMod((double)pass_1, divisor_sequence[0]) == 0.0) password_status++;
         if (MathIsValidNumber(pass_2) && MathMod((double)pass_2, divisor_sequence[1]) == 0.0) password_status++;
         if (MathIsValidNumber(pass_3) && MathMod((double)pass_3, divisor_sequence[2]) == 0.0) password_status++;
            
         if (password_status != 3) 
            password_edit.SetString(OBJPROP_TEXT, 0, password_message[0]);
         else
            password_edit.SetString(OBJPROP_TEXT, 0, password_message[1]); 
      }
  }
//+------------------------------------------------------------------+

É claro que o número de dígitos de um número pode ser ajustado para um determinado valor e os cálculos podem ser mais complicados. Pode-se também adicionar uma variável que é válida somente com um determinado hardware, acrescentando número de série do disco rígido ou ID da CPU no cálculo. Nesse caso, a pessoa que executar o EA teria que executar o gerador adicional calculado com base no hardware.

A saída seria uma entrada para um keygen (gerador de chave) e a senha gerada seria válida apenas para um determinado hardware. Este possui uma limitação de alguém mudar o hardware do computador ou de usar VPS para a execução de EA, mas isso poderia ser resolvido, distribuindo duas ou três senhas válidas. Este é também o caso na seção Market do website MQL5.


3. Licença de conta única

Uma vez que o número da conta do terminal de qualquer dado corretor é exclusiva, isso pode ser usado para permitir o uso de EA em uma ou em um conjunto de números de conta. Em tais casos é suficiente utilizar os métodos AccountInfoString (ACCOUNT_COMPANY) e AccountInfoInteger (ACCOUNT_LOGIN) para alcançar dados de conta e compará-los com os valores pré-compilados permitidos:

//+------------------------------------------------------------------+
//|                                           AccountProtectedEA.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"


const string allowed_broker = "MetaQuotes Software Corp.";
const long allowed_accounts[] = { 979890, 436290, 646490, 225690, 279260 };
                             
int password_status = -1;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   string broker = AccountInfoString(ACCOUNT_COMPANY);
   long account = AccountInfoInteger(ACCOUNT_LOGIN);
   
   printf("The name of the broker = %s", broker);
   printf("Account number =  %d", account);
   
   if (broker == allowed_broker) 
      for (int i=0; i<ArraySize(allowed_accounts); i++)
       if (account == allowed_accounts[i]) { 
         password_status = 1;
         Print("EA account verified");
         break;
       }
   if (password_status == -1) Print("EA is not allowed to run on this account."); 
    
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---  
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  if (password_status == 1) 
  {
    // password correct
  } 
  }

Esta é uma proteção simples embora bem poderosa. A desvantagem é que é necessário recompilar o EA para cada novo número de conta adicionado à base de dados de conta.


4. Proteção de limite de tempo

A proteção de limite de tempo é útil quando a licença é concedida em caráter temporário, por exemplo, utilizando a versão de teste do software ou quando a licença é concedida em caráter mensal ou anual. Uma vez que seja óbvio que isso possa ser aplicado para Expert Advisors e indicadores.

A primeira ideia é verificar o tempo de servidor e com base em que permitem que o usuário use o indicador ou Expert Advisor dentro de determinado período de tempo. Depois de expirar, o concessor de licença é capaz de desativar parcialmente ou totalmente a sua funcionalidade ao licenciado.

//+------------------------------------------------------------------+
//|                                         TimeLimitProtectedEA.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"
                           
datetime allowed_until = D'2012.02.11 00:00'; 
                             
int password_status = -1;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   printf("This EA is valid until %s", TimeToString(allowed_until, TIME_DATE|TIME_MINUTES));
   datetime now = TimeCurrent();
   
   if (now < allowed_until) 
         Print("EA time limit verified, EA init time : " + TimeToString(now, TIME_DATE|TIME_MINUTES));
   
    
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  if (TimeCurrent() < allowed_until) 
    {        
    }
   else Print("EA expired."); 
  }

A única dificuldade é que a solução terá que ser compilada separadamente para cada licenciado.


5. Licenças remotas

Não seria bom ter um total controle fosse para desativar a licença ou para estender o período de teste com base no usuário? Isso pode ser feito simplesmente utilizando a chamada MQL5-RPC que envia uma consulta com o nome da conta e recebe o valor seja para executar o script no modo de teste ou para desativá-lo.

Por favor, veja o código abaixo para uma implementação de amostra:

from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler

class RequestHandler( SimpleXMLRPCRequestHandler ):
    rpc_path = ( '/RPC2', )
    

class RemoteLicenseExample(SimpleXMLRPCServer):

    def __init__(self):
        SimpleXMLRPCServer.__init__( self, ("192.168.2.103", 9099), requestHandler=RequestHandler, logRequests = False)
        
        self.register_introspection_functions()
        self.register_function( self.xmlrpc_isValid, "isValid" )        
        
        self.licenses = {} 
        
    def addLicense(self, ea_name, broker_name, account_number):
        if ea_name in self.licenses:
            self.licenses[ea_name].append({ 'broker_name': broker_name, 'account_number' : account_number })
        else:
            self.licenses[ea_name] = [ { 'broker_name': broker_name, 'account_number' : account_number } ]
             
    def listLicenses(self):
        print self.licenses
        
    def xmlrpc_isValid(self, ea_name, broker_name, account_number):
        isValidLicense = False
        
        ea_name = str(ea_name)
        broker_name = str(broker_name)
        
        print "Request for license", ea_name, broker_name, account_number
        
        try:
            account_number = int(account_number)
        except ValueError as error:
            return isValidLicense
    
        if ea_name in self.licenses:
            for license in self.licenses[ea_name]:
                if license['broker_name'] == broker_name and license['account_number'] == account_number:
                    isValidLicense = True
                    break
                
        print "License valid:", isValidLicense
        
        return isValidLicense
    
if __name__ == '__main__':
    server = RemoteLicenseExample()
    server.addLicense("RemoteProtectedEA", "MetaQuotes Software Corp.", 1024221)
    server.addLicense("RemoteProtectedEA", "MetaQuotes Software Corp.", 1024223)
    
    server.listLicenses()
    server.serve_forever()  

Isso é um simples servidor XML-RPC implementado em Phyton com duas licenças predefinidas para o MetaTrader 5. As licenças são definidas para o expert advisor "RemoteProtectedEA" em execução no servidor de demonstração MetaQuotes padrão (access.metatrader5.com:443) com números de conta 1024221 e 1024223. Uma solução industrial faria provável uso de uma base de dados de licença em PostgreSQL ou qualquer outra base de dados, mas o exemplo acima é mais do que suficiente para este artigo, uma vez que gerencia as licenças remotas muito bem.

Se você precisar de uma curta explicação sobre como instalar o Python, por favor, leia "MQL5-RPC. Chamadas de procedimento remotas do MQL5: Web Service Access e XML-RPC ATC Analyzer for Fun and Profit".

O EA que usa a licença remota simplesmente precisa preparar uma chamada remota MQL5-RPC para o método isValid() que retorna valores boleanos verdadeiros ou falsos, dependendo se a licença é válida. O exemplo abaixo mostra um EA exemplo que é baseado na proteção de conta:

//+------------------------------------------------------------------+
//|                                            RemoteProtectedEA.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"

#include <MQL5-RPC.mqh>
#include <Arrays\ArrayObj.mqh>
#include <Arrays\ArrayInt.mqh>
#include <Arrays\ArrayString.mqh>
#include <Arrays\ArrayBool.mqh>

bool license_status=false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
/* License proxy server */
   CXMLRPCServerProxy s("192.168.2.103:9099");
   if(s.isConnected()==true)
     {

      CXMLRPCResult *result;

/* Get account data */
      string broker= AccountInfoString(ACCOUNT_COMPANY);
      long account = AccountInfoInteger(ACCOUNT_LOGIN);

      printf("The name of the broker = %s",broker);
      printf("Account number =  %d",account);

/* Get remote license status */
      CArrayObj* params= new CArrayObj;
      CArrayString* ea = new CArrayString;
      CArrayString* br = new CArrayString;
      CArrayInt *ac=new CArrayInt;

      ea.Add("RemoteProtectedEA");
      br.Add(broker);
      ac.Add((int)account);

      params.Add(ea); params.Add(br); params.Add(ac);

      CXMLRPCQuery query("isValid",params);

      result=s.execute(query);

      CArrayObj *resultArray=result.getResults();
      if(resultArray!=NULL && resultArray.At(0).Type()==TYPE_BOOL)
        {
         CArrayBool *stats=resultArray.At(0);

         license_status=stats.At(0);
        }
      else license_status=false;

      if(license_status==true) printf("License valid.");
      else printf("License invalid.");

      delete params;
      delete result;
     }
   else Print("License server not connected.");
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(license_status==true)
     {
      // license valid
     }
  }
//+------------------------------------------------------------------+

Se você executar ambos scripts você deverá ser capaz de adicionar uma licença remota para seu número de conta. A licença remota pode ser usada ​também para a licença de limite de tempo ou uma licença de senha que pode ser desativada remotamente após um período de teste. Por exemplo, você daria um EA para alguém para teste de 10 dias, se ele não estiver satisfeito com o produto, você desativa a licença ou, se no caso ele estiver satisfeito, você pode ativar a licença para um dado período de tempo.


6. Criptografia de licença segura

As ideias apresentadas no último parágrafo usaram Chamadas de Procedimento Remoto para troca de informações entre o servidor de licença e terminal de cliente. Isso poderia ser, possivelmente, hackeado usando pacotes farejadores em uma cópia registrada do EA. Utilizando hacker de aplicativo farejador é capaz de capturar todos os pacotes TCP que são enviados entre duas máquinas. Superaremos este problema usando a codificação base64 para enviar os dados da conta e receber a mensagem criptografada.

Para uma pessoa qualificada também seria possível usar PGP e/ou colocar todo o código em uma DLL para maior proteção. Criei a ideia de que a mensagem será de fato uma outra mensagem RPC (como em uma boneca Matryoshka russa) que será posteriormente convertida em dados MQL5.

O primeiro passo é adicionar suporte de codificação e decodificação de base64 para MQL5-RPC. Felizmente, isso já foi feito para o MetaTrader 4 em https://www.mql5.com/pt/code/8098 por Renat portanto eu só precisava convertê-lo ao MQL5.

//+------------------------------------------------------------------+
//|                                                       Base64.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                  MT5 version © 2012, Investeo.pl |
//|                                        https://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "https://www.metaquotes.net"
 
static uchar ExtBase64Encode[64]={ 'A','B','C','D','E','F','G','H','I','J','K','L','M',
                                 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
                                 'a','b','c','d','e','f','g','h','i','j','k','l','m',
                                 'n','o','p','q','r','s','t','u','v','w','x','y','z',
                                 '0','1','2','3','4','5','6','7','8','9','+','/'      };
                                 
static uchar ExtBase64Decode[256]={
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  62,  -1,  -1,  -1,  63,
                    52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  -1,  -1,  -1,  -2,  -1,  -1,
                    -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
                    15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  -1,  -1,  -1,  -1,  -1,
                    -1,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
                    41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
                    -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 };
                               

void Base64Encode(string in,string &out)
  {
   int i=0,pad=0,len=StringLen(in);

   while(i<len)
     {
      
      int b3,b2,b1=StringGetCharacter(in,i);
      i++;
      if(i>=len) { b2=0; b3=0; pad=2; }
      else
        {
         b2=StringGetCharacter(in,i);
         i++;
         if(i>=len) { b3=0; pad=1; }
         else       { b3=StringGetCharacter(in,i); i++; }
        }
      //----
      int c1=(b1 >> 2);
      int c2=(((b1 & 0x3) << 4) | (b2 >> 4));
      int c3=(((b2 & 0xf) << 2) | (b3 >> 6));
      int c4=(b3 & 0x3f);
 
      out=out+CharToString(ExtBase64Encode[c1]);
      out=out+CharToString(ExtBase64Encode[c2]);
      switch(pad)
        {
         case 0:
           out=out+CharToString(ExtBase64Encode[c3]);
           out=out+CharToString(ExtBase64Encode[c4]);
           break;
         case 1:
           out=out+CharToString(ExtBase64Encode[c3]);
           out=out+"=";
           break;
         case 2:
           out=out+"==";
           break;
        }
     }
//----
  }

void Base64Decode(string in,string &out)
  {
   int i=0,len=StringLen(in);
   int shift=0,accum=0;

   while(i<len)
     {
      int value=ExtBase64Decode[StringGetCharacter(in,i)];
      if(value<0 || value>63) break;
      
      accum<<=6;
      shift+=6;
      accum|=value;
      if(shift>=8)
        {
         shift-=8;
         value=accum >> shift;
         out=out+CharToString((uchar)(value & 0xFF));
        } 
      i++;
     }
//----
  }
//+------------------------------------------------------------------+

Para uma descrição detalhada de codificação base64 você pode desejar visitar um artigo da Wikipédia.

Um teste de amostra de script de codificação e decodificação base64 MQL5 é apresentado abaixo:

//+------------------------------------------------------------------+
//|                                                   Base64Test.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"

#include <Base64.mqh>

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   string to_encode = "<test>Abrakadabra</test>";
   
   string encoded;
   string decoded;
   
   Base64Encode(to_encode, encoded);
   
   Print(encoded);
   
   Base64Decode(encoded, decoded);
   
   Print(decoded);
   
  }
//+------------------------------------------------------------------+

O script gera o seguinte resultado.

DK      0       Base64Test (EURUSD,H1)  16:21:13        Original string: <test>Abrakadabra</test>
PO      0       Base64Test (EURUSD,H1)  16:21:13        Base64 encoded string: PHRlc3Q+QWJyYWthZGFicmE8L3Rlc3Q+
FM      0       Base64Test (EURUSD,H1)  16:21:13        Base64 decoded string: <test>Abrakadabra</test>

A validade da codificação pode ser simplesmente verificada em Python em 4 linhas de código:

import base64

encoded = 'PHRlc3Q+QWJyYWthZGFicmE8L3Rlc3Q+'
decoded = base64.b64decode(encoded)
print decoded

<test>Abrakadabra</test>

O segundo passo é criptografar resultado XMLRPC em base64 (também conhecido como técnica Matryoshka):

import base64
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler

class RequestHandler( SimpleXMLRPCRequestHandler ):
    rpc_path = ( '/RPC2', )
    

class RemoteLicenseExampleBase64(SimpleXMLRPCServer):

    def __init__(self):
        SimpleXMLRPCServer.__init__( self, ("192.168.2.103", 9099), requestHandler=RequestHandler, logRequests = False)
        
        self.register_introspection_functions()
        self.register_function( self.xmlrpc_isValid, "isValid" )        
        
        self.licenses = {} 
        
    def addLicense(self, ea_name, broker_name, account_number):
        if ea_name in self.licenses:
            self.licenses[ea_name].append({ 'broker_name': broker_name, 'account_number' : account_number })
        else:
            self.licenses[ea_name] = [ { 'broker_name': broker_name, 'account_number' : account_number } ]
             
    def listLicenses(self):
        print self.licenses
        
    def xmlrpc_isValid(self, ea_name, broker_name, account_number):
        isValidLicense = False
        
        ea_name = str(ea_name)
        broker_name = str(broker_name)
        
        print "Request for license", ea_name, broker_name, account_number
        
        try:
            account_number = int(account_number)
        except ValueError as error:
            return isValidLicense
    
        if ea_name in self.licenses:
            for license in self.licenses[ea_name]:
                if license['broker_name'] == broker_name and license['account_number'] == account_number:
                    isValidLicense = True
                    break
                
        print "License valid:", isValidLicense
        
        # additional xml encoded with base64
        xml_response = "<?xml version='1.0'?><methodResponse><params><param><value><boolean>%d</boolean></value></param></params></methodResponse>"
        
        retval = xml_response % int(isValidLicense)
        
        return base64.b64encode(retval)
    
if __name__ == '__main__':
    server = RemoteLicenseExampleBase64()
    server.addLicense("RemoteProtectedEA", "MetaQuotes Software Corp.", 1024221)
    server.addLicense("RemoteProtectedEA", "MetaQuotes Software Corp.", 1024223)
    
    server.listLicenses()
    server.serve_forever()        

Depois que a licença é criptografada podemos usar o método MQL5-RPC para a conversão de mensagem descriptografada em dados MQL5:

//+------------------------------------------------------------------+
//|                                      RemoteProtectedEABase64.mq5 |
//|                                      Copyright 2012, Investeo.pl |
//|                                           http://www.investeo.pl |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Investeo.pl"
#property link      "http://www.investeo.pl"
#property version   "1.00"

#include <MQL5-RPC.mqh>
#include <Arrays\ArrayObj.mqh>
#include <Arrays\ArrayInt.mqh>
#include <Arrays\ArrayString.mqh>
#include <Arrays\ArrayBool.mqh>
#include <Base64.mqh>

bool license_status=false;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
/* License proxy server */
   CXMLRPCServerProxy s("192.168.2.103:9099");

   if(s.isConnected()==true)
     {
      CXMLRPCResult *result;

/* Get account data */
      string broker= AccountInfoString(ACCOUNT_COMPANY);
      long account = AccountInfoInteger(ACCOUNT_LOGIN);

      printf("The name of the broker = %s",broker);
      printf("Account number =  %d",account);

/* Get remote license status */
      CArrayObj* params= new CArrayObj;
      CArrayString* ea = new CArrayString;
      CArrayString* br = new CArrayString;
      CArrayInt *ac=new CArrayInt;

      ea.Add("RemoteProtectedEA");
      br.Add(broker);
      ac.Add((int)account);

      params.Add(ea); params.Add(br); params.Add(ac);

      CXMLRPCQuery query("isValid",params);

      result=s.execute(query);

      CArrayObj *resultArray=result.getResults();
      if(resultArray!=NULL && resultArray.At(0).Type()==TYPE_STRING)
        {
         CArrayString *stats=resultArray.At(0);

         string license_encoded=stats.At(0);

         printf("encoded license: %s",license_encoded);

         string license_decoded;

         Base64Decode(license_encoded,license_decoded);

         printf("decoded license: %s",license_decoded);

         CXMLRPCResult license(license_decoded);
         resultArray=license.getResults();

         CArrayBool *bstats=resultArray.At(0);

         license_status=bstats.At(0);
        }
      else license_status=false;

      if(license_status==true) printf("License valid.");
      else printf("License invalid.");

      delete params;
      delete result;
     }
   else Print("License server not connected.");

//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(license_status==true)
     {
      // license valid
     }
  }
//+------------------------------------------------------------------+

O resultado de executar o script fornecido que o servidor RemoteLicenseExampleBase64 está executando é conforme a seguir:

KI  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  The name of the broker = MetaQuotes Software Corp.
GP  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  Account number =  1024223
EM  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  <?xml version='1.0'?><methodResponse><params><param><value><string>PD94bWwgdmVyc2lvbj0nMS4wJz8+PG1ldGhvZFJlc3BvbnNlPjxwYXJhbXM+PHBhcmFtPjx2YWx1ZT48Ym9vbGVhbj4xPC9ib29sZWFuPjwvdmFsdWU+PC9wYXJhbT48L3BhcmFtcz48L21ldGhvZFJlc3BvbnNlPg==</string></value></param></params></methodResponse>
DG  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  encoded license: PD94bWwgdmVyc2lvbj0nMS4wJz8+PG1ldGhvZFJlc3BvbnNlPjxwYXJhbXM+PHBhcmFtPjx2YWx1ZT48Ym9vbGVhbj4xPC9ib29sZWFuPjwvdmFsdWU+PC9wYXJhbT48L3BhcmFtcz48L21ldGhvZFJlc3BvbnNlPg==
FL  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  decoded license: <?xml version='1.0'?><methodResponse><params><param><value><boolean>1</boolean></value></param></params></methodResponse>
QL  0  RemoteProtectedEABase64 (EURUSD,H1) 19:47:57  License valid.

Como você pode ver, a carga XML-RPC contém uma sequência que é na verdade uma mensagem XML-RPC codificada pela base64. Esta mensagem codificada base64 é decodificada em cadeia XML e depois decodificada em dados MQL5.


7. Linhas de orientação anti-descompilação avançada

Assim que o código MQL5 é descompilado até as proteções mais seguras que estão expostas à hábil engenharia inversa estarão vulneráveis para serem rachadas. Depois de alguma pesquisa, encontrei um site que oferece o descompilador MQL5, mas suspeito que seja simplesmente um falso, feito para tirar dinheiro de pessoas ingênuas, por quem gostariam de roubar o código de alguém. De qualquer forma, não experimentei-o e posso estar errado. Mesmo que tal solução exista, você deve ser capaz de fazer uma proteção mais forte, enviando parâmetros de entrada de EA/indicador criptografados ou transferência de índices de objeto.

Será muito difícil para um hacker obter parâmetros de entrada corretos para o EA protegido ou ver os valores de entrada corretos do indicador protegido, que por sua vez, o tornará inútil. Também é possível enviar parâmetros corretos se o ID de conta for compatível ou enviar parâmetros falsos não criptografados se ID de conta não for válido. Para esta solução pode-se desejar usar a PGP (Pretty Good Privacy) (Privacidade muito boa). Mesmo que o código seja descompilado, os dados serão enviados criptografados com chave privada PGP e parâmetros do EA serão decifrados apenas quando o ID de conta e a chave PGP forem compatíveis.


Conclusão

Neste artigo apresentei algumas maneiras de proteger o código MQL5. Introduzi também o conceito de licença remota através de chamada MQL5-RPC e adicionei suporte de codificação base64. Espero que este artigo sirva de base para ideias futuras sobre como assegurar o código MQL5. Todo o código fonte está anexo a este artigo.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/359

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Últimos Comentários | Ir para discussão (2)
TARCISIO LEMOS SILVA
TARCISIO LEMOS SILVA | 19 ago 2015 em 20:03
Como seria para adicionar essas linhas de comando para um ea desenvolvido par metatrader 4 ? 
Onde seria colocado essa linha de codigo. ??
MENAHEL1
MENAHEL1 | 15 dez 2023 em 21:46

Olá, como posso colocar o item 7 em meu EA para evitar descompilamento do arquivo ex.5?

Você tem exemplos de códigos para evitar isso?

Poderia explicar detalhado?

Promova seus projetos de desenvolvimento utilizando bibliotecas EX5 Promova seus projetos de desenvolvimento utilizando bibliotecas EX5
Ocultando os detalhes de implementação de classes/funções em um arquivo .ex5 vai permitir que você compartilhe seus algoritmos experientes com outros desenvolvedores, defina projetos comuns e promova-os na Internet. E enquanto a equipe MetaQuotes não mede esforços para viabilizar a possibilidade de herança direta de classes de biblioteca ex5, vamos implementá-la agora.
Trademinator 3: ascensão das máquinas comerciais Trademinator 3: ascensão das máquinas comerciais
No artigo "Dr. Tradelove..." criamos um Exper Advisor, que otimiza parâmetros independentemente do sistema de negociação pré-selecionado. Além disso, decidimos criar um Expert Advisor que não apenas otimizasse parâmetros de um sistema de negócio destacando o EA, mas também selecione o melhor dos vários sistemas de negócio. Vamos ver o que pode resultar disso...
A última cruzada A última cruzada
Veja seu terminal de negociação. Quais meios de apresentação de preço você pode ver? Barras, candlesticks, linhas. Estamos buscando tempo e preços onde temos apenas lucro com os preços. Devemos dar atenção aos preços ao analisarmos o mercado? Este artigo propõe um algorítimo e um script para um gráfico de ponto e figura ("jogo da velha") é dada consideração a vários padrões de preço em que o uso prático é destacado nas recomendações fornecidas.
Criando Expert Advisors usando o assistente visual Expert Advisor Criando Expert Advisors usando o assistente visual Expert Advisor
Assistente visual Expert Advisor para MetaTrader 5 fornece um ambiente gráfico altamente intuitivo com um conjunto abrangente de blocos comerciais predefinidos que permitem que você crie Expert Advisors em minutos. A abordagem clique, arraste e solte do Assistente visual Expert Advisor permite criar representações visuais de estratégias de negociação Forex e sinais de como você faria com lápis e papel. Esses diagramas comerciais são analisados automaticamente pelo gerador de código Molanis’ MQL5 que os transforma em Expert Advisors prontos para serem usados. O ambiente gráfico interativo simplifica o processo de design e elimina a necessidade de escrever código MQL5.