Desenvolvedores, Protejam-se a Si Mesmo!

9 outubro 2015, 09:28
Sergey Kravchuk
0
3 003

Proteção da propriedade intelectual ainda é um grande problema. Este artigo descreve os princípios básicos de proteção dos programas MQL4. Usando estes princípios, você pode garantir que os resultados dos seus desenvolvimentos não sejam roubados por um ladrão, ou pelo menos para complicar o "trabalho" dele, tanto que ele simplesmente se recusará a fazê-lo.



Introdução

Quando eu comecei a interagir com MQL, através dos óculos cor de rosa de um programador iniciante eu tive uma visão, "agradável em todos os aspectos": pensei na época o quanto era simples negociar e eu tinha o conhecimento suficiente para escrever um programa. Então, todos que me contratassem para um trabalho de programação, após os primeiros lucros, poderiam transferir uma pequena parte para mim como gratidão por um produto de alta qualidade.

O trader iniciante que ganhasse os seus primeiros $ 5 no primeiro depósito de $ 20, com entusiasmo me transferiria $ 2, se eu conseguisse alguns ases da negociação, uma vez retirado 2K, muito agadecidos me repassariam $ 200. Tudo parecia completamente honesto: eu estaria fazendo o trabalho do trader que usaria o progama para ganhar mais\freqüentemente\fácil\constantemente do que sem ele. Juntos, teríamos sucesso e um excelente resultado financeiro, dividiríamos com base na equivalência patrimonial. Eu mesmo inventei um termos especial para este serviço - FairWare.

Imagine minha surpresa, apesar do número decente de meus primeiros downloads de produtos e constantes perguntas e consultas sobre eles, eu recebi apenas um pagamento de $3, onde uma pessoa tinha entendido claramente as minhas condições do FairWare. A honestidade de usuários anônimos de meus produtos foi bastante pobre e eu decidi colocar pelo menos algum pagamento mínimo para a utilização das minhas ferramentas nas contas reais.

Por isso eu tinha que protegê-las e pensei nos princípios do sistema Shareware. Como minhas ferramentas tornaram-se mais maturadas, mais rigoroso tornou-se o meu desejo de protegê-las, então desenvolvi algumas maneiras comprovadas que decidi compartilhar com companheiros de codificação MQL. Todos nós, mais ou menos, temos seguido um caminho como eu descrevi no início deste artigo e informações sobre este assunto reunidas em um só lugar, certamente vão aliviar estes "sofrimentos de proteção".

Então, vamos começar: do simples ao complexo...


Protegendo String Constantes

A primeira coisa que você quer proteger - é o seu autor. Não apenas para se orgulhar e se vangloriar de ser um programador legal, por ter escrito uma coisa ou algo tão bacana, mas também para garantir que os usuários tenham a oportunidade de obter o feedback com o desenvolvedor. Como afirma a Lei de Murphy, "cada último bug que você encontrou é realmente a penúltimo", se você não tropeçar nele durante os testes, então alguém vai encontrar algo que lhe passou despercebido. Neste caso, você tem que vincular a string de texto com o seu e-mail ou endereço de um site que não seja alterado, quando ele for exibido na janela do Expert Advisor. Considere um simples código:

//+------------------------------------------------------------------+
//|                                                  Protect-001.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start()
{
  Comment("Copyright © 2009, Sergey Kravchuk");
  return(0);
}

Tudo é simples e aberto. O script exibe o seu comentário. No entanto, olhando dentro do arquivo ex4 vemos todos os textos assim:


Qualquer Editor Hexadecimal permitirá facilmente a substituição do texto visível e o script modificado vai perder o seu autor.

Agora vamos pensar: o que é uma string de texto? É uma sequência de caracteres ligados uns aos outros. Quem nos impede de escrever uma string "caractere por caractere"? Antes de fazer isto, vamos preparar o coletor de strings codificadas. Aqui está o seu código fonte:

//+------------------------------------------------------------------+
//|                                                  Protect-002.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

#property show_inputs

extern string prefix = "char";
extern string text   = "input your text for encoding";
string rez           = ""; // aqui vamos montar o resultado

int start()
{
  // inserir o texto original para ver o que é esta  string
  rez = "/* " + text + " */ "; 
  
  for (int i = 0; i < StringLen(text); i++) 
  rez = rez + prefix + "[" + StringGetChar(text, i) + "]+";
  
  // Cortar o último caractere '+' e imprimir a string para o registro ( log)
  Print(StringSubstr(rez, 0, StringLen(rez)-1)); 
}

Espero que o algoritmo de trabalho seja óbvio: nós entramos com um comentário para ver o que foi codificado e concatenamos caractere por caractere para obter o código da string, montada a partir de caracteres individuais. A string resultante é impressa para iniciar sessão, copiar a string e inserir no código-fonte original.

Para entender como isso funciona, vamos olhar para a fonte com a seqüência codificada.

//+------------------------------------------------------------------+
//|                                                  Protect-003.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start()
{  
  string char[256]; int i;

  for (i = 0; i < 256; i++) char[i] = CharToStr(i);

  Comentário
  (
    /* Copyright © 2009, Sergey Kravchuk*/ 
    char[67]  + char[111] + char[112] + char[121] + char[114] + char[105] + char[103] +
    char[104] + char[116] + char[32]  + char[169] + char[32]  + char[50]  + char[48]  +
    char[48]  + char[57]  + char[44]  + char[32]  + char[83]  + char[101] + char[114] +
    char[103] + char[101] + char[121] + char[32]  + char[75]  + char[114] + char[97]  +
    char[118] + char[99]  + char[104] + char[117] + char[107]
  );
  return(0);
}

Como você pode ver, em primeiro lugar declaramos o array de string de todos os possíveis 256 caracteres da tabela ASCII principal e preenchemos cada elemento com o caractere correspondente. Entao substituímos a string original com o texto codificado, copiado do registro na guia Experts da janela Terminal, compilamos e o resultado está aqui:


Como resultado, o conteúdo foi criptografado e não vemos mais a nossa string codificada. Foi embora - em vez disto, existe um conjunto de comandos para montar a partir de caraceteres distintos. Os restantes das strings não são criptografados - são constantes a partir da "#property copyright" e "#property link". Infelizmente, estes não podem ser codificados porque eles são definidos como strings e códigos assembly não são permitidos.

Assim, cada string que desejamos proteger contra possíveis mudanças através de um Editor Hexadecimal pode ser codificada desta forma. Você pode obter a sua forma criptografada usando o script Protect-002.mq4. Ao usar um código assembly, você deve ter em mente que esta operação leva algum tempo. Portanto, não insira esses blocos de código diretamente no corpo do expert, pois do contrário terá que usá-los cem vezes a cada tick. É o suficiente declarar as variáveis das strings necessárias, inicialize-as uma vez com a codificação assembly na inicialização do indicador ou expert, depois então use as variáveis.


Proteção Contra a Utilização Não Autorizada

Bem, nós temos nossos direitos autorais protegidos e temos outro problema. Seu Expert Advisor pode ser copiado por alguém sem o seu conhecimento (por exemplo, quando você estiver longe de seu computador) e mais tarde usado sem o seu conhecimento. Se você estiver usando apenas para si mesmo ou para vendê-lo, este "furto" é claro que não é de seu interesse.

Há muitos mecanismos de proteção contra a utilização não autorizada: a partir de simples geradores de números de série para proteções, utilizando serviços on-line e/ou chaves de segurança eletrônica. A última forma é a mais confiável, mas ao mesmo tempo irá dispensar muito trabalho intensivo. No entanto, o terminal do cliente MetaTrader tem a sua própria característica específica juntamente com o objeto de proteção específico, permitindo uma utilização mais simples que também é um método fiável.

Na verdade, você faz o seu Expert Advisor ou Indicador apenas para os traders a quem você deu ou vendeu. Para identificar definitivamente o proprietário, há uma coisa completamente única para cada usuário: o número de sua conta de investimento. Em conjunto com o nome do servidor de negociação, torna-se totalmente original este "passaporte eletrônico" do proprietário do Expert Advisor.

Aqui está o exemplo de um simples código que implementa este esquema de proteção:

//+------------------------------------------------------------------+
//|                                                  Protect-004.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start()
{  
  string char[256]; int i;

  for (i = 0; i < 256; i++) char[i] = CharToStr(i);
  // Número de conta, onde o expert está autorizado a trabalhar
  int    AllowedAccountNo = StrToInteger(/* 49153 */ char[52]+char[57]+char[49]+char[53]+char[51]); 
  string AllowedServer = /* UWC-Demo.com */ char[85]+char[87]+char[67]+char[45]+char[68]+
  char[101]+char[109]+char[111]+char[46]+char[99]+char[111]+char[109];

  if (AccountNumber() != AllowedAccountNo || AccountServer() != AllowedServer) 
  {
    Print("You don't have permission to use this script!");
    return(1);
  }
  
  Print("You can use this script!");
}

Aqui nós usamos o nosso método anterior de esconder número da conta e o nome do servidor de negociação como strings criptografadas, pode ter relativa certeza que seu ex4 não será "corrigido" de maneira que possa funcionar em outras contas e servidores.

Organizar uma proteção para reconstruir um Expert Advisor para cada cliente, permitindo ou inventando algum tipo de esquema de proteção universal que usa o mecanismo de strings codificadas, não está no escopo deste artigo. E não é seguro discutir abertamente a lógica de tal proteção universal, pois do contrário estaria disponível não só para os desenvolvedores como também para os crackers - então por que facilitar o trabalho deles em quebrar nossos programas?


Proteção pelo Tempo

Outra maneira de proteger um Expert Advisor é limitar o seu trabalho pelo tempo. Você pode deixá-lo trabalhar apenas até uma determinada data em qualquer conta ou servidor. Quando o período de demonstração expirar, o Expert Advisor não funcionará mais e o usuário terá que pedir-lhe a versão devidamente protegida do expert.

Aqui está o texto do script com este mecanismo de proteção.

//+------------------------------------------------------------------+
//|                                                  Protect-005.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start()
{  
  string char[256]; int i;

  for (i = 0; i < 256; i++) char[i] = CharToStr(i);

  // Data que o expert está autorizado a trabalhar
  int LastAllowedDate = StrToTime(
  /* 2009.09.11 23:59:00 */ 
  char[50]+char[48]+char[48]+char[57]+char[46]+char[48]+char[57]+char[46]+char[49]+
  char[49]+char[32]+char[50]+char[51]+char[58]+char[53]+char[57]+char[58]+char[48]+char[48]

  ); 

  if (TimeCurrent() >= LastAllowedDate) 
  {
    Print("Demo period has expired " + TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
    return(1);
  }
  
  Print("You can work until "+ TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
}

Ele também usa a criptografia de string, contendo data de encerramento do período de demonstração, por isso vai ser impossível "renovar" a edição do ex4.


Proteção contra Descompilação

Infelizmente, todos esses métodos funcionam com êxito somente se o atacante não tem acesso ao código-fonte de um expert. Assim tudo o que foi construído - sempre pode ser quebrado. Há um utilitário disponível através da internet que permite descompilar arquivos ex4, seus autores tinham este software protegido e estava a venda.

Mas este utilitário também foi craqueado, agora qualquer um que conseguiu este aplicativo pode descompilar o seu expert e obter o seu código fonte. Então é possível fazer as mudanças necessárias no código descompilado (por exemplo, remover o bloco que analisa datas, contas e servidores) e obter uma versão totalmente desprotegida do seu Expert Advisor. 

Desenvolvedores de compilador MQL4 estão lutando com esse problema, os detalhes dessa luta, é claro nunca serão anunciados. Mas infelizmente o código-fonte pode muitas vezes ser restaurado, por mais que o seu texto seja difícil de ler, tipo criar mecanicamente nomes diferentes a todos os identificadores, naturalmente isto complica muito o processo de revisão e reconstrução do algoritmo. Em arquivos grandes, com muitas funções, pode se tornar problema quase insolúvel, porém quando um expert é pequeno, ele pode ser restaurado à condição de quase original.

E aqui, em primeiro lugar vem a arte da programação. A tarefa de desenvolvedor do sistema de proteção (mesmo sabendo que um descompilador poderá restaurar o código-fonte) é escrevê-lo de tal maneira que a possibilidade de encontrar e desativar a proteção será mais difícil para um atacante. Esta parte certamente não será detalhada - você terá de inventar os seus próprios métodos de proteção.

A recomendação mais comum é espalhar o código de segurança no módulo inteiro. O atacante deve ficar exausto ao analisar seu código, de tal forma que ele não terá vontade mais de hackear. Valores das variáveis de controle devem ser recolhidas em locais diferentes do código-fonte, quanto mais insuspeito é o lugar mais difícil será para adivinhar que este é o pedaço de código de segurança.

Por exemplo, a montagem da data final pode ser dividida em duas partes: configurar o ano no início do Expert Advisor e o mês, dia e hora serão adicionados ao calcular sinais de negociação. A análise das violações também pode ser feita em um único local e as ações de seus resultados em outro (saídas de emergência ou reduzir a funcionalidade).  

A descompilação de arquivos ex4 existentes não é capaz de restaurar os nomes de variáveis, mas é capaz de restaurar os nomes das funções. Ao contrário dos nomes de variáveis, as funções estão presentes no arquivo ex4, a partir do qual são selecionadas para descompilar. Logo se você usar a função com o nome IsDemoMode(), você está possibilitando uma indicação direta de onde desligar sua proteção.

Vamos reescrever um pouco nosso script para verificar o período de demonstração pela data, como este "errado":

//+------------------------------------------------------------------+
//|                                                  Protect-006.mq4 |
//|                                Copyright © 2009, Sergey Kravchuk |
//|                                         http://forextools.com.ua |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start()
{  
  string char[256]; int i;

  for (i = 0; i < 256; i++) char[i] = CharToStr(i);

  // Data que o expert está autorizado a trabalhar
  int LastAllowedDate = StrToTime(
  /* 2009.09.11 23:59:00 */ 
  char[50]+char[48]+char[48]+char[57]+char[46]+char[48]+char[57]+char[46]+char[49]+
  char[49]+char[32]+char[50]+char[51]+char[58]+char[53]+char[57]+char[58]+char[48]+char[48]

  ); 

  if (IsDemoMode(LastAllowedDate)) 
  {
    Print("Demo period has expired " + TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
    return(1);
  }
  
  Print("You can work until "+ TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
}

bool IsDemoMode(int LastAllowedDate)
{
  if (TimeCurrent() >= LastAllowedDate) return(true); else return(false); 
}

então se decompilar teremos o seguinte resultado:

#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start() {
   string lsa_0[256];
   for (int l_index_4 = 0; l_index_4 < 256; l_index_4++) lsa_0[l_index_4] = CharToStr(l_index_4);
   int l_str2time_8 = StrToTime(lsa_0[50] + lsa_0[48] + lsa_0[48] + lsa_0[57] + lsa_0[46] + 
      lsa_0[48] + lsa_0[57] + lsa_0[46] + lsa_0[49] + lsa_0[49] + lsa_0[32] + lsa_0[50] +
      lsa_0[51] + lsa_0[58] + lsa_0[53] + lsa_0[57] + lsa_0[58] + lsa_0[48] + lsa_0[48]);
   if (IsDemoMode(l_str2time_8)) {
      Print("Demo period has expired " + TimeToStr(l_str2time_8, TIME_DATE|TIME_SECONDS));
      return (1);
   }
   Print("You can work until " + TimeToStr(l_str2time_8, TIME_DATE|TIME_SECONDS));
   return (0);
}

bool IsDemoMode(int ai_0) {
   if (TimeCurrent() >= ai_0) return (TRUE);
   return (FALSE);
}

Como você pode ver, a string com a data é codificada e a primeira vista você não pode entender o que e como é verificado. No entanto, pelo código fonte é muito claro onde e qual a função para editar, IsDemoMode, de modo que a proteção é desativada.


MQLEnigma - Programa Codificador de Códigos Fonte MQ4

Para lutar contra a existência de descompilação, temos que aprender a substituir os nomes das funções utilizadas. Isto é praticamente impossível por meio da MQL4 (bem, exceto se você substituir o conteúdo de nomes normais por lixo completo). Então usei VB.NET para escrever o programa codificador. 

Por que VB.NET? Pelo simples fato que nos últimos anos eu faço um monte de codificação em VBA e VB.NET e com esta linguagem realizo essa tarefa de forma rápida e fácil. Além disso, a compilação é feita em Visual Studio Express que é completamente livre para usar.

A única desvantagem para os futuros usuários deste programa - eles precisam ter o .NET Framework 3.5 instalado nos seus sistemas, pode ser instalado em sistemas com software moderno, muitas vezes escritos em .NET e instalados junto com ele. Se não houver nenhum .NET Framework em seu sistema, você pode baixá-lo Aqui e instalá-lo você mesmo.

MQLEnigma - é um aplicativo de console. Ele tem um parâmetro obrigatório - o nome do arquivo para codificação. Depois disso as seguintes manipulações são feitas com texto:

  1. Insira todos os arquivos #include. Se você tem variáveis globais que são usadas em diferentes arquivos em outros Expert Advisors, elas devem ser reunidas num arquivo comum. Assim, a substituição afetará somente este Expert Advisor particular, os outros vão continuar a usar o arquivo incluído com nomes não criptografados.

  2. Cortar todos os comentários resultante de texto total (para não ocorrer em algo como // int i=0;).

  3. Dividir texto claros em duas partes: os corpos das funções (estes são cortados e analisados separadamente), todas as variáveis externas e #define (assim como declarações de função).

  4. Remover todas as descrições das funções importadas a partir de blocos de textos externos. Os nomes são obtidos a partir do exterior e não pode ser codificados.

  5. Encontre descrições dos tipos comuns, como int, string, etc., em ambos os blocos de texto (interno e externo). Excluir inicializações de variáveis e dimensões de array a partir destes tipos. 

  6. Excluir a palavra-chave #define e a configuração de parâmetros das seções #define, de modo que apenas nomes definidos são deixados. Também excluir as palavras-chave reservadas (ou seja, onde você acidentalmente não vai substituir o nome de cor magenta com algum lixo).

  7. Como resultado, apenas os nomes de variáveis, funções internas e constantes declaradas são deixadas. Estes nomes são coletados numa lista comum, desde que os duplicados sejam removidos (descrição como int i=0; pode ocorrer dentro de várias funções). Criar os nomes "lixos" das variáveis para as substituições e determinar os comprimentos dos identificadores encontrados para realizar a substituição dos nomes mais longos. Do contrário, em caso de duas variáveis, como str e str2str, a mais longa str2str pode ter o nome errado, pois duas "partes" str poderiam ser substituídas pelo primeiro nome.

É isso: o texto completamente limpo do Expert Advisor, com todos os #includes inseridos nele e escritos num arquivo separado com o sufixo Open. Depois disso, os identificadores são substituídos. A tabela de nomes correspondentes do identificador é escrita num arquivo separado com o sufixo Encodings, o arquivo codificado é escrito com o sufixo Encoded. Você precisará compilar neste exato arquivo e distribuir o ex4 resultante.

Novos nomes podem ser montados como você gosta, mas eles devem ter significados e serem únicos. Eu usei um método simples: peguei um número tipo integer máximo, a partir da esquerda e anexei-o ao válido, mas com caractere "invisível" de código 160 (espaço sem quebras) e adicionei números aleatórios à esquerda e à direita do número principal, afim de aumentar a lixo. Quando é formado o próximo nome, o valor 1 é subtraído do número de página anterior (para garantir a unicidade do nome), então o lixo e o espaço invisível são acrescentado.

A fim de não substituir os nomes das variáveis na constante de texto como:

Print(" LotSize = " + DoubleToStr(LotSize,2));

Eu usei o seguinte truque: antes de substituir as variáveis, depois de cada caractere dentro da constante, eu inseri o caractere com código 3 que pode simplesmente ser digitado no teclado e não pode estar no seu texto. Como resultado, "LotSize =" constante transformada em "#L#o#t#S#i#z#e# #=# #" (onde # significa o caractere com código 3). Agora se eu tenho que procurar por uma substring para substituir LotSize na string constante, eu simplesmente não vou encontrá-la, vai passar despercebido. Depois de todas estas variáveis serem substituídas, eu vou simplesmente cortar todos os caracteres com código 3 e as constantes da string original serão restauradas.

Quando substituímos o texto do exemplo anterior, as variáveis são encontradas de acordo com esta lista (o primeiro número - o número de ocorrências encontradas do identificador no código-fonte):

21      char             2114319876214748364748749 
6       i                1596751872214748364643597 
1       IsDemoMode       158651616521474836452710 
5       LastAllowedDate  3650920921474836448123 

então nós temos o seguinte arquivo:

#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"
int start()
{
  string  2114319876214748364748749 [256]; int  1596751872214748364643597 ;
  for ( 1596751872214748364643597  = 0;  1596751872214748364643597  < 256;  1596751872214748364643597 ++)
  2114319876214748364748749 [ 1596751872214748364643597 ] = CharToStr( 1596751872214748364643597 );
  int  3650920921474836448123  = StrToTime(
  2114319876214748364748749 [50]+ 2114319876214748364748749 [48]+ 2114319876214748364748749 [48]+
  2114319876214748364748749 [57]+ 2114319876214748364748749 [46]+ 2114319876214748364748749 [48]+
  2114319876214748364748749 [57]+ 2114319876214748364748749 [46]+ 2114319876214748364748749 [49]+
  2114319876214748364748749 [49]+ 2114319876214748364748749 [32]+ 2114319876214748364748749 [50]+
  2114319876214748364748749 [51]+ 2114319876214748364748749 [58]+ 2114319876214748364748749 [53]+
  2114319876214748364748749 [57]+ 2114319876214748364748749 [58]+ 2114319876214748364748749 [48]+
  2114319876214748364748749 [48]
  );
  if ( 158651616521474836452710 ( 3650920921474836448123 ))
  {
    Print("Demo period has expired " + TimeToStr( 3650920921474836448123 ,TIME_DATE|TIME_SECONDS));
    return(1);
  }
  Print("You can work until "+ TimeToStr( 3650920921474836448123 ,TIME_DATE|TIME_SECONDS));
}
bool  158651616521474836452710 (int  3650920921474836448123 )
{
  if (TimeCurrent() >=  3650920921474836448123 ) return(true); else return(false);
}

Esta codificação de texto do código fonte tem uma característica divertida: suponha que você tenha o código fonte de um Expert Advisor e você não quer mostrar para ninguém, mas agora você pode dar este texto codificado e o segredo de seu algoritmo não será divulgado.

Após a descompilação temos o seguinte código:

#property copyright "Copyright © 2009, Sergey Kravchuk"
#property link      "http://forextools.com.ua"

int start() {
   string lsa_0[256];
   for (int l_index_4 = 0; l_index_4 < 256; l_index_4++) lsa_0[l_index_4] = CharToStr(l_index_4);
   int l_str2time_8 = StrToTime(lsa_0[50] + lsa_0[48] + lsa_0[48] + lsa_0[57] + lsa_0[46] + 
      lsa_0[48] + lsa_0[57] + lsa_0[46] + lsa_0[49] + lsa_0[49] + lsa_0[32] + lsa_0[50] +
      lsa_0[51] + lsa_0[58] + lsa_0[53] + lsa_0[57] + lsa_0[58] + lsa_0[48] + lsa_0[48]);
   if (f0_1276(l_str2time_8)) {
      Print("Demo period has expired " + TimeToStr(l_str2time_8, TIME_DATE|TIME_SECONDS));
      return (1);
   }
   Print("You can work until " + TimeToStr(l_str2time_8, TIME_DATE|TIME_SECONDS));
   return (0);
}

bool f0_1276(int ai_0) {
   if (TimeCurrent() >= ai_0) return (TRUE);
   return (FALSE);
}

Ele não tem nomes significativos (bem, exceto para o nome de funções padrões e a reservada 'start'), embora você possa decifrar este exemplo simples, mas um texto mais complexo com muitas variáveis será completamente inadequado. Seu custo para hackear será tão alto que sairá mais em conta e mais fácil comprar Expert Advisor direto do desenvolvedor e receber um suporte oficial.


Conclusão

Para ser honesto, o MQLEnigma foi desenvolvido nas piores tradições da Programação Extrema. Presumi que o texto fonte de entrada é sintaticamente "correto", por exemplo, não deve haver descasamento de funções chaves, tipo declarar variáveis (int;) sem nomes, etc. O algoritmo foi desenvolvido com código executável dinamicamente (on the fly) - tirei o meu maior projeto e gradualmente cortei tudo o que era desnecessário, olhando para o resultado do texto - afinal de contas, apenas os nomes das variáveis haveriam de permanecer. É por isso que não incluem numerosas exceções e possíveis erros de manipulação.

Além disso, o próximo MQL5 terá proteção contra descompilação, de modo que este trabalho somente faz sentido para os programas MQL4. Pela mesma razão, eu escolhi VB.NET (VBA, para ser mais preciso) - uso esta ferramenta de trabalho todos os dias, por isso era mais fácil, mais rápido e confortável para mim em aproveitá-la.

Apesar desta forma imprecisa de programação, o MQLEnigma funciona e eu ainda não executei um código fonte que tenha sido processado de forma errada ou que sua compilação tivesse erros. Mas isso não significa que desta forma é absolutamente corret, é por isso que coloquei o código fonte completo. Se o MQLEnigma não funcionar corretamente, você mesmo poderá encontrar a causa e corrigi-la se necessário (se isso acontecer, por favor não se esqueça de me informar sobre a modificação feita na discussão deste artigo).

Este artigo considera apenas as formas mais simples de proteção, mas apesar de simples elas podem eficazmente proteger os seus desenvolvimentos. Voltando ao que eu escrevi no início deste artigo, eu repito o que escrevi na conclusão da minha primeira licença FairWare: O autor tem lhe ajudado, escrevendo programas que podem nunca terem sido inventados ou escrito por você mesmo. Agora - é sua vez de retornar a ajuda ao autor, da maneira que você puder :-) .

O código fonte MQLEnigma pode conter alguns erros de lógica que não estão aparentes nestes textos durante a depuração. Se você encontrá-los, por favor me avise para que eu possa fazer mudanças e atualizar os arquivos anexados neste artigo. Se você conhecer outras formas de proteção que pode ser publicada abertamente, sem ser uma ajuda aos hackers, deixe seus comentários. Eu e outros membros da nossa comunidade MQL4 seremos gratos a você por sua contribuição.

Bem, a última conclusão: o tema da proteção do código fonte é muito desafiador. Compartilhar todos os segredos não é uma boa idéia, pois você mostra aos potenciais atacantes suas fraquezas. Eu decidi publicar este artigo porque não existe nada de novo aos descodificadores, porém estes são os primeiros processos bem conhecidos de proteção que trabalham de forma bastante eficaz, podendo ser útil especialmente para iniciantes em programação MQL.

Traduzido do russo pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/1572

Arquivos anexados |
files_en.zip (29.18 KB)
Utilizando Redes Neurais No MetaTrader Utilizando Redes Neurais No MetaTrader

Este artigo mostra como usar facilmente Redes Neurais em seu código MQL4, aproveitando a disponibilidade gratuita da melhor biblioteca artificial de rede neural (FANN) e empregando múltiplas redes neurais em seu código.

Trabalhando Com Doubles no MQL4 Trabalhando Com Doubles no MQL4

Neste artigo vamos considerar erros típicos de programação que ocorrem durante o trabalho com números tipo double nos programas MQL4.

Projeto Meta COT - Novos Horizontes para Analise do Relatório da CFTC em MetaTrader 4 Projeto Meta COT - Novos Horizontes para Analise do Relatório da CFTC em MetaTrader 4

O artigo é sobre o uso das informações do relatório da CFTC (Commodity Futures Trading Commission) em MetaTrader. O artigo descreve em datalhes a proposta do projeto META COT, mostra como carregar e processar as informações necessárias. O Expert Advisor incluído no projeto nos ajudará a analisar a eficácia do conceito apresentado no artigo. Por fim, vamos tirar algumas conclusões e oferecer sugestões úteis.

Tutorial da Rede Neural FANN2MQL Tutorial da Rede Neural FANN2MQL

Este artigo foi publicado para mostrar-lhe como usar redes neurais através da FANN2MQL, usando um exemplo simples, vai ensinar um padrão para uma rede neural e testá-la para ver se ela reconhecerá padrões que nunca viu.