¡Protegerse, los desarrolladores!

La protección de la propiedad intelectual sigue siendo un gran problema. Este artículo describe los principios básicos de la protección de los programas en MQL4. Usando estos principios usted puede asegurar que los resultados de su evolución no son robados por un ladrón, o al menos complicar mucho su "trabajo" tanto que simplemente se negará a hacerlo.

Introducción

Cuando empecé a conocer el MQL, como a través de un mundo de color de rosa del principiante programador MQL, me vino una imagen "agradable en todos los sentidos": entiendo esto del trading, me dije a mi mismo. Yo no soy menos como parae escribir un programa claramente. Entonces todos los que lo tiene como trabajo, después de que el primer beneficio ganado me transfiere una parte pequeña de eeste como agradecimiento a producto de alta calidad.

El trader novato, que ha ganado los primeros 5$ en el primer depósito de 20$, me transfiere 2$ con entusiasmo, y algun as del trade, una vez más retirados 2 K, me lo agradece mucho mas, tanto como 200$. Todo se veía totalmente honesto: estoy haciendo el trabajo que no puede hacer el trader, que se utiliza para ganar mas\con frecuencia\fácilmente\constantemente que sin este. Juntos hemos trabajado con éxito y tienen excelente resultado financiero, que puede dividirse sobre la base de la equidad. He incluso inventé los términos de distribución especial para ello - FairWare.

Imagínense mi sorpresa cuando, a pesar del número decente de mis primeras descargas de instrumentos y constantes preguntas y consultas sobre ellos, sólo he recibido un solo pago de $3, en la que el hombre se había referido claramente a mis condiciones de FairWare . Por lo tanto, la honestidad de los usuarios anónimos de mis productos era bastante pobre, y decidí establecer al menos un pago mínimo para el uso de mis herramientas en cuentas reales.

Para esto debía protegerlos y poner en funcionamiento los principios del Shareware. Conforme mis herramientas se hicieron más maduras, más estrictos fueron mis deseos para protegerlas, y por ahora he recopilado unas formas probadas, que decido compartir con los compañeros de codificación MQL. Todos más o menos hemos estado haciendo el camino, lo he descrito anteriormente en este artículo. Y para informar sobre este tema, se reunieron en un lugar, y sin duda facilitará estos "sufrimientos por la protección".

Por lo tanto, vamos a empezar: de fácil a difícil...

Protección de constantes del string (cadena de texto)

Lo primero que desea proteger - es sus derechos de autor. No sólo para estar orgullosos y presumir de que eres un programador de fresco, que escribió una cosa muy guai, sino que también para asegurar que los usuarios tienen la oportunidad de obtener feedback del desarrollador. Como se indica en la ley de Murphy, "hasta el último error que se encontra es realmente el penúltimo", y es probable que no se tropiece con el durante la prueba, y por otro lado algo se le escapó más allá. En este caso, usted tiene que hacer el string con su dirección de correo electrónico o sitio web que permanezcan sin cambios, cuando el EA se muestra en la ventana. Considere un simple 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);
}

Todo es plano y abierto. La script muestra tu comentario. Sin embargo, mirando dentro del archivo ex4 se verán todos los textos perfilados.

Cualquier editor hexadecimal permite fácilmente reemplazar el texto visible, y el script modificado va a perder sus derechos de autor.

Ahora pensemos: ¿Qué es un script? Se trata de una secuencia de caracteres, vinculados entre sí. ¿Que nos impide escribir este tipo de cadenas "carácter por carácter"? Sin embargo, antes de hacerlo, prepararemos el colector de strings codificados. Aquí está el código fuente:

//+------------------------------------------------------------------+
//|                                                  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   = "entrada de testo a codificar";
string rez           = ""; // aquí montaremos el resultado

int start()
{
  // Introduzca el texto original para ver lo que es esta cadena es
  rez = "/* " + text + " */ "; 
  
  for (int i = 0; i < StringLen(text); i++) 
  rez = rez + prefix + "[" + StringGetChar(text, i) + "]+";
  
  // cortar e último carácter '+' y visualizar el string para el registro
  Print(StringSubstr(rez, 0, StringLen(rez)-1)); 
}

Ciertamente, el algoritmo de funcionamiento es obvio: ingresamos un comentario para ver lo que ha sido codificado y se concatena caracter a caracter para obtener el código del string, montado a partir de caracteres individuales. El string resultante se registra. Se copia desde allí y se inserta en el código fuente original.

Para entender cómo funciona, vamos a ver la fuente con el string codificado.

//+------------------------------------------------------------------+
//|                                                 Proteger-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);

  Comment
  (
    /* 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 se puede ver, primero declaramos la matriz de strings de los 256 caracteres posibles de la tabla principal ASCII y llenamos cada elemento con el carácter correspondiente. A continuación, hemos sustituido la cadena original con el texto codificado, copiado desde el registro de la ficha de expertos en la ventana del Terminal, lo compilamos, y aquí está el resultado.

Como resultado, los contenidos cifrados, y ya no vemos nuestra cadena codificada. Después de todo, se ha ido - y en su lugar hay un conjunto de comandos, mostados de con caraceres separados. Las restantes cadenas sin cifrar - son las constantes #property copyright y #property link. Por desgracia, no se codificaron porque se fijaron como cadenas de caracteres y no se permitió ningun código de montaje.

Así, cada cadena que queremos proteger contra posibles cambios en el editor hexadecimal puede ser codificada de esta manera. Usted puede obtener su forma cifrada usando el script Protect-002.mq4. Cuando se utiliza tal montaje, debe tener en cuenta que una operación de este tipo toma algún tiempo. Por lo tanto, no introduzca tales bloques de código directamente en el cuerpo del expertos, no a utilizarlo cientos de veces en cada tick. Es suficiente con declarar las variables de la cadena requerida, inícielos una vez con el monteje codificado sobre el indicador o inicialización del experto y luego usar estas variables.

Protección contra uso no autorizado

Bien, hemos protegido los derechos de autor y a otro problema. Su Asesor Experto puede ser copiado por alguien sin su conocimiento (por ejemplo, cuando estás lejos de su computadora en el piso comercial del DC's), y más tarde se utiliza sin su conocimiento. Si lo vas a usar sólo por sí mismo o a venderlo, esta "fuga" por supuesto no es de tu interés.

Hay muchos mecanismos de protección contra uso no autorizado: de generadores de números de serie simple a protecciones utilizando servicios en línea o claves de seguridad electrónica. La última forma - es la más fiable, pero al mismo tiempo la más laboriosa. Sin embargo, el terminal de cliente MetaTrader tiene su propio rasgo específico, que junto con el objeto de datos específicos de protección permite el uso de un método más simple, pero sin embargo fiable.

De hecho, para hacer su asesor experto o indicador usted necesita trabajar sólo para los tradres, a quien les dio o vendió. Para identificar definitivamente el dueño, hay que tener una cosa totalmente única para cada usuario: el número de su cuenta de trabajo. Y junto con el nombre de servidor de comercio, se convierte en totalmente único "pasaporte electrónico" del dueño del EA.

Este es un ejemplo de un código simple que implementa este esquema de protección:

//+------------------------------------------------------------------+
//|                                                  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 cuenta, en cuyos expertos se permitió trabajar
  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("¡No tiene permiso para utilizar este script!");
    return(1);
  }
  
  Print("¡Se puede utilizar este script!");
}

Aquí hemos utilizado nuestro método anterior para ocultar el número de cuenta y el nombre del servidor del trade en strings cifrados y puede estar relativamente seguro de que su ex4 no "se corrige" de manera que funcione en otros servidores y cuentas.

Organizar dicha protección (cada vez, para reconstruir el Asesor Experto de cada cliente permitido o para inventar algún tipo de sistema de protección universal, utiliza el mecanismo de cadenas (strings) codificadas) está fuera del alcance de este artículo. Y no es seguro discutir abiertamente la lógica de la protección universal. De lo contrario, estará disponible no sólo para los desarrolladores, sino también para crackers - así que ¿por qué facilitar su trabajo sobre el acceso de nuestros programas? 

Protección por Tiempo

Otra forma de proteger un Asesor Experto es limitar su trabajo por el tiempo. Puede limitarlo a trabajar sólo hasta una determinada fecha en cualquier cuenta o servidor. Cuando vence el plazo de la demo, ya no funciona el Asesor Experto y el usuario tendrá que pedir una versión del experto correctamente protegida.

Aquí está el texto del script con este mecanismo de protección.

//+------------------------------------------------------------------+
//|                                                  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);

  // Fecha, hasta que el experto puedo trabajar
  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("El período demo ha caducado " + TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
    return(1);
  }
  
  Print("You can work until "+ TimeToStr(LastAllowedDate,TIME_DATE|TIME_SECONDS));
}

También utiliza el cifrado de string, con fecha fin del período demo, por lo que será imposible "renovar" al editar archivo ex4.

Protección contra la descompilación

Lamentablemente, todos estos métodos funcionan correctamente sólo si el atacante no tiene acceso al código fuente de un experto. Sin embargo, todo lo construido - siempre puede ser roto. Hay una utilidad disponible en Internet, que permite decompilar archivos ex4. Sus autores han protegido este software y lo venden.

Pero esta utilidad también ha sido crackeada, y ahora todos los que lo consiguieron pueden descompilar el experto y su código fuente. Es posible hacer los cambios necesarios en el presente código descompilado (por ejemplo, solo quita el bloque que analiza las fechas, cuentas y servidores), lo recompile y obtener una versión totalmente desprotegida de su EA. 

Los desarrolladores del compilador MQL4 están luchando con este problema. Los detalles de esta lucha, por supuesto, nunca se anunciarán. Pero, por desgracia, a menudo se puede restaurar el código fuente. Aunque sea difícil leer su texto: todos los identificadores en lugar de nombres significativos tendrán nombres creados mecánimente. Por supuesto, esto, complica enormemente el proceso de revisar y reconstruir el algoritmo. En archivos de grandes tamaño, con un montón de funciones, puede convertirse en problema casi irresoluble. Sin embargo, cuando un experto es pequeño, puede ser restaurado al estado casi original.

Y ahora viene en primer lugar el arte de la programación. La tarea del desarrollador del sistema de protección (sabiendo de qué forma el decompilador restaurará el código fuente), es escribir de tal manera que la posibilidad de encontrar y desactivar la protección será más difícil para un atacante. Esta parte sin duda no se detallará - tienes que inventar métodos de protección por tí mismo.

La recomendación más común es separar el código de seguridad en un módulo completo. El atacante debe agotars mientras analiza el código, para que él no desee hackear. Lo valores de las variables de control deben recogerse en lugares diferentes del código fuente y cuanto más insospechado sea el lugar, más difícil será adivinar que se trata de la pieza del código de seguridad.

Por ejemplo, al armar la fecha final esta puede ser dividida en dos partes: seleccionar el año al principio del EA, y el mes, día y hora se añadirán al cálculo de las señales de trade. También, el análisis de las violaciones puede hacerse en un solo lugar y las acciones sobre sus resultados (reducción de la funcionalidad o salida de emergencia) - en otro.  

El decompiler existente de archvos ex4 no es capaz de restaurar los nombres de variables, pero es capaz de restaurar los nombres de funciones. A diferencia de los nombres de las variables, están presentes en los archivos ex4, de los cuales son seleccionados por el decompilador. Por lo tanto, si utiliza la función con nombre IsDemoMode(), está dando una indicación directa donde apagar su protección.

Si nos reescribimos nuestro guión un poco para comprobar el periodo de demo por fecha, queda como este "mal":

//+------------------------------------------------------------------+
//|                                                  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);

  // Fecha, hasta que el experto puedo trabajar
  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("El período demo ha caducado " + 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); 
}

entonces el decompilador dará el siguiente 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 puedes ver, la cadena con la fecha está codificada y a primera vista usted no puede entender lo que se comprueba y cómo. Sin embargo, es bastante claro dónde y qué editar del código fuente en la función IsDemoMode, así que la protección está desactivada.

MQLEnigma - codificador de los códigos fuente MQ4

Para luchar contra el decompilador existente, tenemos que aprender a reemplazar los nombres de funciones que usamos. Esto es prácticamente imposible por medio de MQL4 (bueno, salvo que hagamos un reemplazo de contenido de nombres normales con basura absoluta). Así que tuve que escribir el programa encoder utilizando VB.NET. 

¿Por qué VB.NET? Sólo porque en los últimos años hacer he hecho un montón de código en VBA y VB.NET, y con su ayuda he podido realizar esta tarea de forma rápida y sencilla. Además, la compilación fue hecha en Visual Studio Express, que es totalmente gratuito.

La única desventaja para los futuros usuarios de este programa - es que necesitan tener net FrameWork 3.5 instalado en sus sistemas. Pero, a pesar de su buena cantidad, se puede ya instalar en sistemas con software moderno, que a menudo es escrito en .NET e instalado junto con él. Si no hay .NET en tu sistema, puedes descargarlo desde aquí e instalarlo por ti mismo.

MQLEnigma - es una aplicación de consola. Tiene un parámetro obligatorio - el nombre del archivo de la codificación. Después se hacen las siguientes manipulaciones con el texto:

1. Insertar todos los archivos #include. Si tienes las variables globales que se utilizan en distintos archivos de otras EAs, deben recogerse en un archivo común. Así el reemplazo afectará sólo este particular EA, y otros continuarán utilizando el archivo incluido con nombres sin cifrar.

2. Cortar todos los comentarios del texto total resultante (no para correr en algo como // int i=0;).

3. El texto autorizado se dividen en dos partes: los cuerpos de la función (se cortan y analizan por separado) y todas las variables externas y #define (así como las declaraciones de las función).

4. Retire todas las descripciones de las funciones importadas del bloque de los textos externos. Sus nombres se dan desde el exterior y no pueden ser codificados.

5. Encontrar descripciones de los tipos comunes como int, string, etc. en ambos bloques de texto (internos y externos). Eliminar las inicializaciones de variables y dimensiones de la matriz de estos tipos. 

6. Eliminar la palabra clave #define y los parámetros de las secciones de #define, por lo que quedan sólo los nombres definidos. También eliminar palabras clave reservadas (es decir, que accidentalmente no sustituyan al nombre de color Magenta con algo basura).

7. Como resultado, quedan sólo los nombres de variables, funciones internas y las constantes declaradas. Estos nombres están recogidos en la lista común, de la cual se eliminan los duplicados (descripción como int i=0; puede ocurrir en varias funciones). Son Creados los nombres "basura" de variables para los reemplazos y determinantes son las longitudes de los identificadores encontrados para realizar sustituciones de las más largas. De lo contrario, en el caso de dos variables como str y str2str, la str2str más larga puede tener el nombre incorrecto, si dos "partes" del str serían sustituidas primero.

Eso es todo: limpiar texto completo del archivo del EA, con todos los #includes insertados en él, se escriben en un archivo separado con el sufijo Abierto . Después estos identificadores son reemplazados. La tabla de nombres del identificador correspondiente se escribe en un archivo separado con el sufijo codificaciones , y el archivo codificado está escrito con el sufijo codificada . Usted necesitará compilar este archivo mucho y distribuir el ex4 resultante.

Se pueden montar nuevos nombres se pueden montar según le gusten, pero estos deben ser sin sentido y únicos. Utilicé un método simple: tomé el máximo entero, desde la izquierda anexada al válido, pero "invisible" carácter con código 160 (espacio de no ruptura) y agregar números al azar a la izquierda y derecha del número principal para aumentar la basura. Al formar el nombre siguiente el 1 se resta del anterior número principal (para asegurar la unicidad del nombre) y luego se agrega al espacio invisible y a la basura.

Para no cambiar los nombres de variables en la constante de texto tal como:

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

He utilizado el siguiente truco: antes de reemplazar las variables, después de cada carácter de constante he insertado el carácter con código 3. Puede ser simplemente escribir en el teclado, y por lo tanto no puede ser en el texto. Como resultado del "LotSize =" constante se transforma en "#L#o#t#S#i#z#e##=##" (donde # significa el carácter con código 3). Ahora si tengo que buscar una subcadena substituir LotSize en constante de cadena, simplemente no encontrar y permanecerá desapercibido. Después de todas estas variables se sustituirán, simplemente corté todos los caracteres con código 3 y se restablecieron las constantes de cadena original.

Cuando sustituimos el texto del ejemplo anterior, las variables según esta lista (el primer número - el número de casos encontrados por el identificador en el código fuente):

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

entonces tenemos el siguiente archivo:

#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("Ha caducado el período de demo " + TimeToStr( 3650920921474836448123 ,TIME_DATE|TIME_SECONDS));
    return(1);
  }
  Print("Se puede trabajar hasta "+ TimeToStr( 3650920921474836448123 ,TIME_DATE|TIME_SECONDS));
}
bool  158651616521474836452710 (int  3650920921474836448123 )
{
  if (TimeCurrent() >=  3650920921474836448123 ) return(true); else return(false);
}

Tal codificación del texto original tiene una característica divertida: Supongamos que tienes el código fuente del EA, pero no los quiere dejar. Pero ahora usted puede dar este texto codificado, de hecho aunque ha dado el código fuente, no se reveló el secreto de su algoritmo.

Después de su decompilación obtenemos el siguiente 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);
}

No tiene ningun nombre descriptivo (bien, excepto la reservada 'start' y nombres de las funciones estándar) y aunque usted puede resolver este ejemplo simple, con el texto más complejo, con un montón de variables, será totalmente insuficiente. Su costo de hacking es tan alto, que será más barato y más fácil comprar el EA al autor, recibiendo apoyo oficial.

Conclusión

Para ser honesto, MQLEnigma fue desarrollado en las peores tradiciones de Extreme Programming. Supuse que el texto de la fuente de entrada es sintácticamente "correcto". Así, por ejemplo, no debe haber apoyos desalineados de funciones, declaraciones de tipo sin nombres de variable (int;), etc.. El algoritmo fue desarrollado "sobre la marcha" - Tomé mi proyecto más grande y poco a poco corté todo innecesario, mirando el texto resultante - después de todo, solo deben permanecer losnombres de variables. Eso es por qué no incluí numerosas excepciones y manejé posibles errores.

Además, la próxima MQL5 tendrá protección contra la decompilación, así este trabajo tiene sentido sólo para los programas de MQL4. Por la misma razón, he elegido a VB.NET - utilizando esta (VBA, para ser más precisos) herramienta con la que estoy haciendo mi trabajo cada día, por lo que era más fácil, más rápido y cómodo para poder potenciarlo.

A pesar de esta forma imprecisa de programación MQLEnigma trabaja y todavía no he ejecutado el código fuente, que fue procesado injustamente y su compilación conduciría a errores. Pero esto no significa, que de esta manera es absolutamente correcto. Por eso le doy su código fuente completo. Si tiene MQLEnigma no funciona correctamente, usted será capaz de encontrar la causa y, si es necesario, corregirlo por si mismo (si esto sucede, por favor no olvide informarme acerca de la modificación realizada en la discusión de este artículo).

Este artículo considera sólo las maneras más simples de protección, pero sin embargo pueden proteger eficazmente su evolución. Volviendo a lo que escribí al principio de este artículo, puedo decir lo mismo que me escribió en la conclusión de mi primera licencia FairWare: el autor le ha ayudado, a escribir programas que nunca se ha inventado o escrito por sí mismo. Ahora - le toca a usted ayudar al, si es posible :-) .

El código fuente de MQLEnigma puede contener algunos errores de lógica que no eran evidentes en los textos que tuve durante la depuración. Si la encuentra, por favor hágamelo saber para que pueda realizar cambios y actualizar los archivos adjuntos a este artículo. Si conoce otras formas de protección, que pueden ser publicada abiertamente sin ser una ayuda para los hackers, deja tu comentario. Yo y otros miembros de nuestra comunidad MQL4 le serán agradecidos por su aporte.

Bueno, la conclusión final: el tema de la protección del código fuente es muy difícil. Compartir todos los secretos no es una buena idea, porque así demuestras a los atacantes potenciales sus debilidades. Decidí publicar este artículo sólo porque no hay nada nuevo para los decodificadores. Sin embargo, estos son los primeros métodos bien conocidos de protección, que trabajan con mucha eficacia, y pueden ser útiles, especialmente para los principiantes en programación MQL.