MetaTrader 5 herunterladen

Schützt Euch Selbst, Entwickler!

4 Mai 2016, 14:31
Sergey Kravchuk
0
1 054

Einführung

Als ich anfing mich mit MQL vertraut zu machen, sah ich durch die rosarote Brille von Anfänger MQL-Programmierer ein Bild, "angenehm in jeder Hinsicht": Mir wurde gesagt, verständlicherweise, wie man tradet. Ich bin nicht weniger gut ein Programm zu schreiben. Dann werden alle, die es für die Arbeit erhalten haben, nach den ersten verdienten Gewinnauszahlungen einen kleinen Teil davon an mich überweisen, als Dankbarkeit für das erhaltene Produkt von hoher Qualität.

Der Trading-Anfänger, der die ersten 5 $ auf die erste $ 20 Einzahlung verdient hat, überweist mir begeistert $ 2 und einige Trading-Asse, mal wieder 2K auszahlend, danken mir mit so viel wie 200 $. Alles sah ganz ehrlichaus: ich mache die Arbeit, die nicht von dem Trader gemacht werden kann, die verwenden es, um mehr zu verdienen \häufig\einfacher\ständig als ohne es. Gemeinsam haben wir erfolgreich gearbeitet und haben hervorragende Finanzergebnis erhalten, die auf Eigenkapitalbasis unterteilt werden kann. Ich habe sogar die besonderen Vertriebsbedingungen für diese erfunden - FairWare.

Stellen Sie sich meine Überraschung, als trotz der anständigen Zahl der Downloads meiner ersten Instrumente und ständigen Fragen und Konsultationen zu ihnen, habe ich nur eine $ 3 Zahlung empfangen, in dem der Mann sich klar auf meine FairWare Bedingungen bezogen hatte. Also war die Ehrlichkeit der anonymen Benutzer meiner Produkte eher schlecht, und ich habe beschlossen, zumindest eine gewisse Mindestzahlung für die Nutzung meiner Tools auf realen Konten festzulegen.

Dafür musste ich sie schützen und auf die Prinzipien der Shareware umschalten. Als meine Werkzeuge ausgereifter wurden, wurde mein Wunsch sie zu schützen umso stärker, und bisher habe ich ein paar bewährte Arten gesammelt, die ich entschieden habe mit MQL-Programmier-Kollegen zu teilen. Wir alle sind mehr oder weniger den Weg gegangen, den ich weiter oben beschrieben in diesem Artikel beschrieben habe. Und Informationen zu diesem Thema, an einer Stelle zu sammeln, wird dieses "Schutz Leiden" sicherlich erleichtern.

Also, fangen wir an: von einfach bis komplex...



Schützende String Konstanten

Das erste, was Sie schützen möchten - ist Ihr Urheberrecht. Nicht nur um stolz zu sein und sich zu rühmen, dass Sie ein cooler Programmierer sind, der solch eine coole Sache schrieb, sondern auch um sicherzustellen, dass die Nutzer die Möglichkeit haben Feedback von dem Entwickler zu erhalten. Wie in Murphys Gesetz angegeben, "jeder letzte Fehler den Sie gefunden haben, ist eigentlich der vorletzte", und es ist wahrscheinlich, dass Sie nicht während der Tests über sie stolpern, und ein anderer wird etwas, das an Ihnen vorbei gerutscht ist finden. In diesem Fall müssen Sie den Text String mit Ihrer E-Mail oder Website-Adresse so machen, dass es unverändert bleibt, wenn es im Fenster des Expert Advisor angezeigt wird. Betrachten wir einen einfachen Code:

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

Alles ist klar und offen. Das Skript zeigt Ihren Kommentar. Dennoch, schauen wir in die ex4-Datei, sehen wir alle Texte zerstückelt.

Jeder HEX-editor wird es ermöglichen des sichtbaren Text einfach zu ersetzen, und der geänderte Text wird Ihr Urheberecht verlieren.

Denken wir nach: Was ist ein Text String? Es ist eine Folge von Zeichen, alle miteinander verbunden. Wer hindert uns einen solchen String "Zeichen für Zeichen" zu schreiben? Jedoch, bevor wir das tun, werden wir den Kollektor für kodierte Strings vorbereiten. Hier ist der Quellcode:

//+------------------------------------------------------------------+
//|                                                  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           = ""; // here we will assemble the result

int start()
{
  // enter the original text to see what this string is
  rez = "/* " + text + " */ "; 
  
  for (int i = 0; i < StringLen(text); i++) 
  rez = rez + prefix + "[" + StringGetChar(text, i) + "]+";
  
  // cut the last '+' character and print string to the log
  Print(StringSubstr(rez, 0, StringLen(rez)-1)); 
}

Ich hoffe, die Arbeit des Algorithmus ist offensichtlich: Wir geben einen Kommentar ein, um zu sehen was codiert wurde, und verketten Zeichen für Zeichen um den Code für den String zu erhalten, zusammengesetzt aus einzelnen Zeichen. Der resultierende String wird in das Protokoll ausgegeben. Kopieren Sie ihn dort und fügen Sie ihn in den originalen Quellcode ein.

Um zu verstehen wie es funktioniert, werfen wir einen Blick in den Quellcode mit codiertem String.

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

  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);
}

Wie Sie sehen, haben wir zuerst das String-Array aller möglichen 256 Zeichen der Haupt ASCII-Tabelle deklariert und füllen jedes Element mit entsprechenden Zeichen. Dann haben wir original String mit codierten Text ersetzt, kopiert von dem Experten Registerkarte Protokoll im Terminalfenster, es kompiliert, und hier ist das Ergebnis.

Als Ergebnis wurden die Inhalte verschlüsselt, und wir sehen unsere codierte Zeichenfolge nicht mehr. Immerhin es ist weg - stattdessen gibt es eine Reihe von Befehlen, die es sich aus einzelnen Zeichen zusammensetzen. Die verbleibenden unverschlüsselten Strings - sind Konstanten der #property copyright und #property link. Leider können diese nicht codiert werden, da sie als Strings festgelegt sind, und keine zusammengesetzten Codes erlaubt sind.

Also, jeder String, den wir gegen mögliche Änderungen im HEX-Editor schützen wollen, kann auf diese Weise codiert werden. Sie können seine verschlüsselt Form mit dem Protect-002.mq4 Skript erhalten. Wenn Sie eine solche Zusammensetzung verwenden, müssen Sie bedenken, dass ein solcher Vorgang einige Zeit in Anspruch nimmt. Deshalb, legen Sie solche Code-Blöcke nicht direkt in den Expert Body, damit er nicht hundert Mal bei jedem Tick verwendet wird. Es ist ausreichend die erforderlichen string Variablen zu deklarieren, diese einmal mit der Zusammensetzung zu initialisieren, in der Indikator oder Expert Initialisierung, und dann diese Variablen zu verwenden.

Schutz gegen unbefugte Verwendung

Nun, wir haben unser Urheberrecht geschützt und kamen zu einem anderen Problem. Ihrem Expert Advisor kann von jemand ohne Ihr Wissen kopiert werden (zum Beispiel, wenn Sie von Ihrem Computer weg sind auf DC Trading Floor), und später wird er ohne Ihr Wissen verwendet. Wenn Sie ihn nur selbst verwenden wollen oder verkaufen, ist dieses "Leck" natürlich nicht ist in Ihrem Interesse.

Es gibt viele Mechanismen zum Schutz vor unbefugter Verwendung: von einfachen Seriennummern Generatoren zum Schutz der Verwendung von Online-Diensten und/oder elektronische Sicherheitsschlüssel . Die letzte Möglichkeit - ist die zuverlässigste, aber gleichzeitig die arbeitsintensivste. Allerdings hat das MetaTrader Client-Terminal seine eigene spezifische Eigenschaft, die zusammen mit den Besonderheiten des zu schützenden Objekts erlaubt eine einfachere, aber dennoch zuverlässige Methode zu verwenden.

In der Tat, müssen Sie Ihren Expert Advisor oder Indikator so fertigen, dass er nur für den Trader arbeitet, dem Sie ihn gegeben haben oder der ihn gekauft hat. Um den Besitzer eindeutig zu identifizieren, gibt es eine Sache, die für jeden Anwender absolut einzigartig ist: die Nummer seines Handelskontos. Und in Verbindung mit dem Namen des Handels-Servers, wird es absolut einzigartiger "elektronischen Pass" des Expert Advisor Besitzers.

Hier ist ein Beispiel für einen einfachen Code, der diese System zum Schutz umsetzt:

//+------------------------------------------------------------------+
//|                                                  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);
  // Account number, on which expert is allowed to work
  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!");
}

Hier haben wir unsere vorherige Methode zum Verbergen von Kontonummer und Handelsservernamen als verschlüsselte Zeichenfolgen verwendet, und Sie können relativ sicher sein, dass Ihre ex4 nicht in einer Weise "korrigiert" wird, um sie auf anderen Konten und Servern arbeiten zu lassen.

inen solchen Schutz zu organisieren (jedes Mal einen Expert Advisor für jeden zugelassenen Kunden neu erstellen oder irgendeine Art eines universellen Schutzsystem zu erfinden, das die codierten Zeichenketten-Mechanismus verwendet), würde den Rahmen dieses Artikels sprengen. Und es ist nicht sicher, offen über die Logik eines solchen universellen Schutzes zu diskutieren. Ansonsten wird es nicht nur für Entwickler verfügbar sein, sondern auch für Cracker - also warum ihre Arbeit zu erleichtern, unsere Programme zu brechen?

Schutz durch Zeit

Eine weitere Möglichkeit, einen Expert Advisor zu schützen, ist seine Arbeit durch Zeit zu begrenzen. Sie können ihn nur bis zu einem bestimmten Zeitpunkt auf einem Konto oder Server arbeiten lassen. Wenn der Demozeitraum abgelaufen ist, wird der Expert Advisor nicht mehr arbeiten und Benutzer müssen Sie nach einer angemessen geschützten Version des Expert Advisor fragen.

Hier ist der Text mit dem Skript des Schutzmechanismus.

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

  // Date, until which the expert is allowed to work
  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));
}

Es nutzt auch die String Verschlüsselung, mit dem Datum des Ende der Demo-Periode, so wird es unmöglich sein, dieses durch bearbeiten der ex4 Datei zu "erneuern".

Schutz vor Dekompilierung

Leider funktionieren alle diese Methoden nur dann erfolgreich, wenn der Angreifer keinen Zugriff auf den Quellcode eines Experten hat. Doch alles, was gebaut wurde - kann immer gebrochen werden. Es ist ein Programm, über das Internet verfügbar, das es ermöglich ex4-Dateien zu dekompilieren. Die Autoren haben diese Software geschützt und verkaufen sie.

Aber dieses Programm wurde ebenfalls geknackt, und jetzt kann jeder, der geschafft hat es zu bekommen, Ihren Expert Advisor dekompilieren und seinen Quellcode erhalten. Es ist möglich die erforderlichen Änderungen in diesem dekompilierten Code z machen (z.B. einfach den Block der Datum, Konten und Server analysiert entfernen), ihn neu kompilieren und eine ungeschützte Version Ihres Expert Advisors erhalten.

MQL4 Compiler-Entwickler haben mit diesem Problem zu kämpfen. Die Einzelheiten dieses Kampfes, natürlich, werden nie bekannt gegeben. Aber leider kann der Quellcode oft wiederhergestellt werden. Obwohl der Text schwer zu lesen sein wird: alle Identifikatoren werden, anstelle sinnvoller Namen, mechanisch erstellte Namen haben. Dies macht, natürlich sehr kompliziert, den Prozess der Überprüfung und den Algorithmus zu rekonstruieren sehr kompliziert. In großen Dateien, mit vielen Funktionen, kann es ein fast unlösbares Problem werden. Wenn jedoch ein Experte klein ist, kann er fast in seinen ursprünglichen Zustand wiederhergestellt werden.

Und hier kommt an erster Stelle die Kunst der Programmierung. Die Aufgabe des Schutz Systementwickler (während man weiß, in welcher Form die Decompiler wird den Quellcode wiederherstellen) ist es, in einer solchen Art und Weise zu schreiben, dass die Möglichkeit den Schutz zu finden zu deaktivieren das schwierigste für einen Angreifer sein wird. Dieser Teil wird sicherlich nicht detailliert sein - Sie müssen Methoden für einen solchen Schutz selbst erfinden.

Die häufigste Empfehlung ist es, den Sicherheitscode über das gesamte Modul zu verbreiten. Angreifer müssen ausgepowert werden, während Sie den Code analysieren, so dass er nicht mehr wünscht sich mit Hacking zu beschäftigen. Werte von Steuervariablen müssen an verschiedenen Stellen des Quellcodes gesammelt werden, und unverdächtiger der Ort, desto schwieriger wird es, zu erraten, dass dies ein Stück des Sicherheitscode ist.

Zum Beispiel, die Zusammensetzung des Enddatums kann in zwei Teile unterteilt werden: das Jahr, zu Beginn des Expert Advisor gesetzt, und der Monat, Tag und Zeit werden hinzugefügt, während Handelssignale berechnet werden. Die Analyse der Verletzungen kann auch an einem Ort, und die Aktionen auf die Ergebnisse (Notausstieg oder Verringerung der Funktionalität) - in einem anderen ausgeführt werden.

Der existierende Decompiler für ex4-Dateien ist nicht in der Lage Variablennamen wiederherzustellen, aber in der Lage, Funktionsnamen wiederherzustellen. Anders als Variablennamen sind sie in der ex4-Datei vorhanden, aus der sie durch den Decompiler ausgewählt werden. Deshalb, wenn Sie eine Funktion mit dem Namen IsDemoMode() verwenden, geben Sie dadurch einen direkten Hinweis, wo Ihr Schutz auszuschalten ist..

Wen wir unser Skript ein wenig umschreiben, um den Demo-Zeitraum nach Datum zu prüfen, wie dieses "falsche":

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

  // Date, until which the expert is allowed to work
  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); 
}

dann wird der Decompiler das folgende Ergebnis geben:

#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);
}

Wie Sie sehen, wird der String mit dem Datum codiert und auf den ersten Blick können Sie nicht verstehen, was überprüft wird und wie. Allerdings, durch den Quellcode ist es sehr deutlich, wo und was in der IsDemoMode Funktion zu bearbeiten ist, so dass der Schutz deaktiviert ist.


MQLEnigma - Encoder von MQ4 Quellcodes

Um gegen bestehende Decompiler zu kämpfen, müssen wir lernen, wie man die Namen der verwendeten Funktionen ersetzt. Dies ist praktisch unmöglich, durch MQL4 (gut, außer dass Sie die ersetzten Inhalte von normalen Namen mit völligem Müll). Also musste ich einen Encoder-Programm mit VB.NET schreiben

Warum VB.NET? Nur weil in den letzten paar Jahren eine Menge Codierung auf VBA und VB.NET gemacht habe, so war ich mit ihrer Hilfe in der Lage diese Aufgabe schnell und einfach zu erreichen. Darüber hinaus wurde die Zusammenstellung in Visual Studio Express gemacht, die völlig kostenlos zu verwenden ist.

r einzige Nachteil für künftige Nutzer dieses Programms - müssen sie auf ihren Systemen .NET FrameWork 3.5 installiert haben. Aber trotz seines angemessenen Betrags, kann es bereits auf Systemen mit moderner Software installiert sein, da diese die oft auf .NET geschrieben und zusammen mit ihm installiert wird. Wenn es kein .NET Framework in Ihrem System gibt, können Sie es von hier herunterladen und installieren Sie es selbst.

MMQLEnigma - ist eine Konsolenanwendung. Es hat einen obligatorischen Parameter - den Namen der Datei für die Codierung. Danach werden die folgenden Bearbeitungen sind mit Text gemacht:

  1. Fügen Sie alle #include-Dateien ein. Wenn Sie globale Variablen haben, die in verschiedenen Dateien in anderen Expert Advisors verwendet werden, müssen sie in einer gemeinsamen Datei gesammelt werden. So wird der Ersatz sich nur auf diesen speziellen Expert Advisor auswirken, und andere werden auch weiterhin die enthaltene Datei mit unverschlüsselten Namen verwenden.

  2. Schneiden Sie alle Kommentare aus dem resultierenden Gesamttext (um nicht in etwas zu laufen wie // int i = 0;).

  3. Teilen Sie gelöschten Text in zwei Teile: die Funktionskörper (diese werden abgeschnitten und separat analysiert) und alle externen Variablen und #define (sowie Funktionsdeklarationen).

  4. Entfernen Sie alle Beschreibungen von importierten Funktionen aus dem Block der externen Texte. Ihre Namen sind von außen gegeben und können nicht kodiert werden.

  5. Finden Sie Beschreibungen der gängigen Typen wie int, string usw. in beiden Textblöcken (intern und extern). Löschen Sie variable Initialisierungen und Array-Dimensionen von diesen Typen.

  6. Löschen Sie das #define Keyword und Parametereinstellung aus dem #define Abschnitt, so dass nur definierte Namen übrig sind. Löschen Sie auch reservierte Keywords (das heißt, dass Sie nicht versehentlich den Namen der Farbe Magenta mit einigen Müll ersetzen).

  7. Als Ergebnis werden nur die Namen der Variablen, die internen Funktionen und deklarierte Konstanten belassen werden. Diese Namen werden in gemeinsamen Liste gesammelt, aus denen die Duplikate entfernt werden (eine Beschreibung wie int i = 0; kann innerhalb von mehreren Funktionen auftreten). Erstellt werden die "Müll" Namen der Variablen für den Ersatz und bestimmt die Längen der gefundenen Identifikatoren um Ersatz von den längsten durchzuführen. Andernfalls, im Fall von zwei Variablen wie str und str2str kann die längste str2str den falschen Namen haben, würden zwei str "Teile" zuerst ersetzt werden.

Das ist es: gereinigter voller Text der Expert Advisor-Datei mit allen #includes in sie eingefügt, wird geschrieben in eine separate Datei mit dem Open-Suffix. Danach werden die Identifikatoren ersetzt. Die Tabelle der passenden Identifikator Namen mit dem Suffix Codierungen in eine separate Datei geschrieben, und die verschlüsselte Datei mit dem codierten Suffix geschrieben. Sie müssen diese Datei kompilieren und die resultierende ex4 verteilen.

Neue Namen können zusammengesetzt werden wie Sie möchten, aber sie müssen bedeutungslos und einzigartig sein. Ich verwendete eine einfache Methode: Ich nahm die maximale ganze Zahl, von der linken Seite an die gültigen angehängt, jedoch "unsichtbares" Zeichen mit dem Code 160 (non-breaking Leerzeichen) und fügte Zufallszahlen hinzu nach links und rechts von der Hauptnummer um den Müll zu erhöhen. Wenn der nächste Name gebildet wird, wird die 1 von der vorherigen Hauptnummer subtrahiert (um Eindeutigkeit des Namens gewährleisten) und dann Müll und unsichtbaren Raum angehängt.

Um die Variablennamen nicht in den Text Konstanten zu ersetzen, wie:

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

Ich habe den folgenden Trick verwendet: bevor die Variablen ersetzt werden, habe ich nach jedem Zeichen innerhalb Konstante das Zeichen mit dem Code 3 eingefügt haben. Es kann einfach über die Tastatur eingegeben werden, und deshalb kann es nicht in Ihrem Text sein. Als Ergebnis die "Mengengröße =" Konstante in "#L#o#t#S#i#z#e# #=# #" umgewandelt (wobei # das Zeichen mit dem Code 3 ist). Nun, wenn ich nach substring suche, um Mengengröße in einer String-Konstante zu ersetzen, werde ich es einfach nicht finden und es wird unbemerkt bleiben. Nachdem all diese Variablen ersetzt wurden, schneide ich einfach alle Zeichen mit Code 3 heraus und die ursprünglichen String-Konstanten werden wiederhergestellt.

Wenn wir den Text des vorherigen Beispiels ersetzt haben, werden die Variablen nach dieser Liste gefunden (die erste Zahl - die Anzahl der gefundenen Vorkommen der Identifikator im Quellcode):

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

dann erhalte wir die folgende Datei:

#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);
}

Eine solche Verschlüsselung in dem Quelltext hat eine amüsante Eigenschaft: Angenommen Sie haben Expert Advisor Quellcode, aber Sie möchten ihn nicht freigeben. Aber jetzt können Sie diesen verschlüsselten Text geben, in der Tat geben Sie den Quellcode preis, aber das Geheimnis des seines Algorithmus wird nicht offenbart.

Nach seiner Dekompilierung erhalten wir den folgenden code:

#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);
}

Er hat keine aussagekräftigen Namen (gut, mit Ausnahme der reservierten "Start" und Standard-Funktionsnamen), und obwohl Sie dieses einfache Beispiel sortieren können, aber der komplexere Text mit vielen Variablen völlig ist unzureichend. Die Hacker-Kosten werden so hoch sein, dass es billiger sein wird und leichter Expert Advisor von seinem Autor zu kaufen, und offiziellen Support zu erhalten.

Fazit

Um ehrlich zu sein, MQLEnigma wurde in den schlimmsten Traditionen des Extreme Programming entwickelt. Ich nahm an, dass der Eingabe Quelltext syntaktisch "richtig" ist. Nun, zum Beispiel, müssen es keine unpassende Klammern von Funktionen sein, Typdeklarationen ohne Variablennamen (int;) usw. Der Algorithmus wurde "on the fly" entwickelt - ich nahm mein größtes Projekt und habe nach und nach alles unnötige ausgeschnitten, während der Suche in dem Text - immerhin müssen nur Variablennamen bleiben. Deshalb habe ich nicht zahlreiche Ausnahmen und mögliche Fehler-Handhabung eingefügt.

Darüber hinaus wird das kommende MQL5 Schutz vor Dekompilierung haben, so dass diese Arbeit nur Sinn macht für MQL4 Programme. Aus dem gleichen Grund habe ich VB.NET gewählt - dieses Werkzeug (VBA, um genauer zu sein) benutze ich meine jeden für Tag Arbeit, so war es einfacher, schneller und bequemer für mich, es zu nutzen.

Trotz dieser ungenauen Art der Programmierung funktioniert MQLEnigma, und noch habe ich nicht in einen Quellcode laufen, der falsch verarbeitet war und seine Zusammenstellung würde zu Fehlern führen. Das bedeutet aber nicht, dass auf diese Weise absolut korrekt ist. Deshalb habe ich seinen vollen Quellcode bereitgestellt. Wenn MQLEnigma falsch arbeitet, können Sie die Ursache finden und, falls erforderlich, korrigieren es selbst korrigieren (wenn dies der Fall ist, vergessen Sie bitte nicht, mich in der Diskussion dieses Artikels über die vorgenommene Änderung zu informieren).

Dieser Artikel betrachtet nur die einfachsten Möglichkeiten des Schutzes, aber dennoch können sie effektiv Ihre Entwicklungen schützen. Wenn wir zu dem zurück gehen, was ich am Anfang dieses Artikels schrieb, kann ich das gleiche sagen, was ich meine in den Abschluss des ersten Lizenz FairWare geschrieben habe: Der Autor hat Ihnen geholfen, durch das Schreiben von Programmen, die Sie nicht selber schreiben oder erfinden können. Nun - sind Sie dran dem Autor zu helfen, so wie sie können :-) .

Der Quellcode von MQLEnigma kann einige Logikfehler enthalten, die nicht offensichtlich auf jene Texte waren, die ich während der Fehlersuche hatte. Wenn Sie sie finden, lassen Sie es mich wissen, damit ich Änderungen vornehmen und die Dateien aktualisieren kann, die diesem Artikel angehnagen sind. Wenn Sie andere Methoden des Schutzes kennen, die offen, ohne eine Hilfe für Hacker veröffentlicht werden können, hinterlassen Sie Ihre Kommentare. Ich und andere Mitglieder unserer MQL4 Community wären Ihnen für Ihren Beitrag dankbar.

Nun, das endgültige Fazit: Gegenstand des Quellcodes-Schutz ist sehr anspruchsvoll. Das Teilen aller Geheimnisse, ist keine gute Idee, denn so zeigen Sie potentiellen Angreifern Ihre Schwächen. Ich beschloss, diesen Artikel nur zu veröffentlichen, weil es nichts Neues für Decoder ist. Diese sind jedoch die ersten gut bekannten Methoden für den Schutz, die sehr effektiv funktionieren, und sie können vor allem für Anfänger in MQL Programmierung nützlich.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1572

Beigefügte Dateien |
files_en.zip (29.18 KB)
Neuronale Netze In MetaTrader verwenden Neuronale Netze In MetaTrader verwenden

Dieser Artikel zeigt Ihnen, wie Sie leicht Neuronale Netze in Ihrem MQL4 Code verwenden, die Vorteile der besten frei verfügbaren künstlichen neuronalen Netze-Bibliothek (FANN) nutzen und mehrere neuronale Netze in Ihrem Code verwenden.

Arbeiten mit Doubles in MQL4 Arbeiten mit Doubles in MQL4

In diesem Artikel werden wir typische Programmierfehler betrachten, die bei der Arbeit mit double Nummern in MQL4 Programmen auftreten.

Die Magie der Filtration Die Magie der Filtration

Die meisten Entwickler automatischer Handelssysteme verwenden irgendeine Form von Filtration für Handelssignale. In diesem Artikel erkunden wir die Erstellung und Implementierung von Bandpass- und diskreten Filtern für Expert Advisors, um die Eigenschaften des automatisierten Handelssystems zu verbessern.

Wettbewerb an Expert Advisors innerhalb eines Expert Advisor Wettbewerb an Expert Advisors innerhalb eines Expert Advisor

Mit dem virtuellen Handel können Sie einen anpassungsfähigen Expert Advisor kreieren, der das Einsetzen von virtuellen Trades im realen Markt automatisch ein- und ausschalten wird. Kombinieren Sie mehrere Strategien in einem einzigen Expert Advisor! Ihr Multi-System Expert Advisor wird automatisch eine Handelsstrategie wählen, mit der Sie, basierend auf der Rentabilität der virtuellen Trades, am besten im realen Markt handeln können. Diese Herangehensweise ermöglicht eine Reduzierung der Inanspruchnahme und eine Erhöhung der Rentabilität Ihrer Arbeit auf dem Markt. Experimentieren Sie und teilen Sie Ihre Ergebnisse mit anderen! Ich denke, viele Leute werden sich dafür interessieren, Ihr Portfolio von Strategien kennenzulernen.