Codesicherheit verbessern

Babel Obfuscator ist ein leistungsfähiges Tool, das Ihren Code robust schützt. Sich in alle Einzelheiten der Verschleierung einzuarbeiten, kann viel Zeit kosten. Deshalb haben wir Tipps zusammengestellt, mit denen Sie bei geringem Aufwand optimale Ergebnisse erzielen. Wenn Sie diesen Empfehlungen folgen, erhöhen Sie die Sicherheit Ihres Codes deutlich, ohne sich in Details zu verlieren.

Starker Schutz entsteht durch Defense in Depth: Keine einzelne Transformation soll einen Angreifer allein aufhalten. Die Umbenennung verbirgt die Absicht, die Verschlüsselung verbirgt Daten, Kontrollfluss und dynamische Proxys verbergen die Logik, und Laufzeitprüfungen wirken Manipulation und Debugging entgegen. Kombinieren Sie mehrere Schutzebenen, damit die übrigen bestehen bleiben, wenn eine überwunden wird. Die folgenden Tipps sind danach gruppiert, was die jeweilige Schutzebene schützt.

Symbole umbenennen und umstrukturieren

Typen in C# internalisieren oder in VB als Friend kennzeichnen

Typen, die als internal oder (in der Terminologie von VB) als Friend deklariert sind, sind für externe Assemblys nicht sichtbar und können bei der Verschleierung gefahrlos umbenannt werden. Dieser Schritt schirmt Ihren Code wirksam vor neugierigen Blicken ab.

Umbenennung verstärken

Über die standardmäßige Umbenennung von Symbolen hinaus machen einige Optionen die umbenannten Metadaten erheblich schwerer lesbar:

• Überladene Umbenennung verwendet einen einzigen verschleierten Namen für viele nicht zusammengehörende Member, sodass die Metadaten Ihren Membern nicht mehr eins zu eins entsprechen.
• Abflachung der Namespaces löst Ihre Namespace-Hierarchie auf und beseitigt die strukturellen Hinweise, auf die sich ein Decompiler stützt.
• Umbenennung virtueller Member benennt virtuelle Member und Schnittstellenmember über die gesamte Typhierarchie hinweg einheitlich um.

Babel CLI

babel.exe myapp.dll --overloaded --flatns --virtualmembers

Abhängigkeiten nach Möglichkeit zusammenführen

Mit Babel Obfuscator können Sie referenzierte Assemblys mit der Ziel-Assembly zusammenführen. Wenn Sie alle zusammengeführten Typen internalisieren, steigt die Zahl der umbenannten Symbole, und es wird für mögliche Angreifer schwerer, Ihren Code zu durchschauen.

Konstante Daten verbergen

Den Algorithmus HASH für die Zeichenfolgenverschlüsselung verwenden

Der Algorithmus HASH der Zeichenfolgenverschlüsselung bietet starken Schutz und verringert zugleich die Größe der verschleierten Assembly auf dem Datenträger. Sie schalten diese Funktion mit dem folgenden Befehl ein:

Babel CLI

babel.exe myapp.exe --stringencryption hash

MSBuild-Aufgabe Babel

<PropertyGroup>
  <StringEncryption>hash</StringEncryption>
</PropertyGroup>

Inline-Werte und Arrays verschlüsseln

Numerische Konstanten und Inline-Arrays enthalten häufig sensible Daten: Schwellenwerte, Schlüssel, magische Zahlen, Nachschlagetabellen. Die Wert- und Arrayverschlüsselung entfernt diese Literale aus dem IL-Code und entschlüsselt sie zur Laufzeit, sodass ein Decompiler die tatsächlichen Zahlen oder Arrayinhalte nicht mehr sieht.

Babel CLI

babel.exe myapp.exe --values int32=on --values int64=on --values single=on --values double=on --values array=on

Verwaltete Ressourcen verschlüsseln

Die Ressourcenverschlüsselung verbirgt eingebettete Ressourcen in Ihrer Assembly und komprimiert sie zugleich, was eine zusätzliche Schutzebene schafft. Wägen Sie die Auswirkungen auf die Leistung sorgfältig ab, bevor Sie diese Funktion einschalten.

Programmlogik verschleiern

Kontrollflussverschleierung einschalten

Die Kontrollflussverschleierung macht if-Anweisungen komplexer, fügt irrelevante Verzweigungen ein und führt mehrere switch-Anweisungen ein, ohne das Verhalten der Methode zu ändern. Wenn Sie gezielt Kontrollflussalgorithmen wie goto, if, switch, case und call einschalten, wird der Code am gründlichsten verwürfelt. Mit den folgenden empfohlenen Einstellungen erreichen Sie eine wirksame Kontrollflussverschleierung:

Babel CLI

babel.exe myapp.exe --controlflow goto=on --controlflow if=on --controlflow switch=on --controlflow case=on --controlflow call=on

MSBuild-Aufgabe Babel

<PropertyGroup>
  <ControlFlowObfuscation>goto=true;if=true;switch=true;case=true;call=true;true</ControlFlowObfuscation>
  <ControlFlowIterations>3</ControlFlowIterations>
</PropertyGroup>

Mit den obigen Einstellungen der Kontrollflussverschleierung stellen Sie eine robuste und wirksame Verschleierung Ihres Codes sicher. Die verschiedenen Algorithmen (goto, if, switch, case und call) machen den Kontrollfluss verschlungener und schwerer zu analysieren und erhöhen so die Sicherheit Ihrer Anwendung.

Dynamische Proxys für externe Methodenaufrufe erzeugen

Dynamische Proxys verbergen Aufrufe externer und interner Methoden wirksam. Oft genügt es, die Erzeugung dynamischer Proxys für externe Aufrufe einzuschalten, um ein hohes Maß an Verschleierung zu erreichen.

babel.exe myapp.exe --proxy external

Code verschlüsseln

Die Codeverschlüsselung schützt Methoden, die sensible Daten verarbeiten, etwa die Prüfung eines Lizenzschlüssels, besonders wirksam. Bedenken Sie jedoch die Auswirkungen auf die Leistung, denn die Codeverschlüsselung kann die Geschwindigkeit der Anwendung beeinträchtigen. Wenden Sie sie gezielt auf die Methoden an, die sie benötigen.

Durch die Integration mit dem Babel Licensing Service können Sie Aktivierungslizenzen oder Floating-Lizenzen für eine funktionsbasierte Lizenzierung einsetzen. So liefern Sie Verschlüsselungsschlüssel sicher über den Lizenzdienst aus und schalten bestimmte Funktionen Ihrer Anwendung für autorisierte Benutzer frei.

Wenn Sie den Babel Licensing Service mit der Codeverschlüsselung kombinieren, haben nur lizenzierte Benutzer Zugriff auf die verschlüsselten Codeabschnitte. Der Verschlüsselungsschlüssel wird sicher über den Lizenzdienst ausgeliefert. Das verhindert die unbefugte Nutzung und wahrt die Integrität der Funktionen Ihrer Anwendung.

Laufzeitangriffe erkennen und abwehren

Manipulationserkennung einschalten

Die Manipulationserkennung erkennt jede unbefugte Änderung an Ihrer Assembly. Wählen Sie geeignete Aktionen, etwa den Abbruch der Ausführung oder eine Fehlermeldung an den Benutzer, um Angreifer abzuschrecken. Mit stillen Aktionen wird es schwieriger, die Manipulationserkennung zu umgehen.

babel.exe myapp.exe --tamperingdetection

Debugging-Schutz einschalten

Der Debugging-Schutz erkennt, wenn Ihre Anwendung unter einem Debugger oder Profiler läuft, also unter den Tools, mit denen ein Angreifer Geheimnisse beobachtet, während sie zur Laufzeit entschlüsselt werden. Zusammen mit den oben beschriebenen Verschlüsselungsebenen schließt er die Lücke, die der Schutz vor statischer Analyse offen lässt.

babel.exe myapp.exe --antidebugging

Disassemblierungs- und Reflexionstools blockieren

Zwei leichtgewichtige Schalter erschweren die beiläufige Untersuchung: --ildasm kennzeichnet die Assembly so, dass der MSIL Disassembler (ildasm.exe) sie nicht öffnet, und --reflection hindert reflexionsbasierte Tools daran, die Metadaten der Assembly aufzulisten.

babel.exe myapp.exe --ildasm --reflection

Entfernen, was nicht ausgeliefert werden muss

Jedes Stück Metadaten, das Sie zurücklassen, ist ein Hinweis. Entfernen Sie, was die laufende Anwendung nicht braucht:

• Attribute bereinigen: --cleanattrs entfernt benutzerdefinierte Attribute, die nur dem Compiler oder Ihren Tools dienten.
• Ungenutzten Code entfernen: --deadcode entfernt nicht erreichbare Methoden und Member.
• Enumerationen entfernen: --enumremoval ersetzt Enumerationstypen durch ihre zugrunde liegenden Konstanten.
• Interne Klassen versiegeln: --seal versiegelt interne Typen, von denen nie geerbt wird.
• Keine Debugsymbole ausliefern: Stellen Sie die Anwendung ohne die .pdb-Datei bereit (vermeiden Sie --debug), damit einem Angreifer weder Zeilennummern noch lokale Namen zur Verfügung stehen.

Eine empfohlene Grundkonfiguration

Der folgende Befehl fasst die oben beschriebenen Schutzebenen zu einer starken, allgemein einsetzbaren Konfiguration zusammen. Fügen Sie --msilencryption für die einzelnen sensiblen Methoden hinzu, bei denen es gerechtfertigt ist.

babel.exe myapp.dll `
  --overloaded --flatns --virtualmembers `
  --stringencryption hash `
  --values int32=on --values int64=on --values single=on --values double=on --values array=on `
  --controlflow if=on --controlflow switch=on --controlflow case=on --controlflow chain=on `
  --proxy external `
  --resourceencryption `
  --tamperingdetection --antidebugging --ildasm `
  --cleanattrs --seal

Die entsprechenden Eigenschaften der MSBuild-Aufgabe:

<PropertyGroup>
  <OverloadedRenaming>true</OverloadedRenaming>
  <FlattenNamespaces>true</FlattenNamespaces>
  <VirtualFunctions>true</VirtualFunctions>
  <StringEncryption>hash</StringEncryption>
  <ValueEncryption>int32=true;int64=true;single=true;double=true;array=true;true</ValueEncryption>
  <ControlFlowObfuscation>if=true;switch=true;case=true;chain=true;true</ControlFlowObfuscation>
  <DynamicProxy>external=true;true</DynamicProxy>
  <ResourceEncryption>true</ResourceEncryption>
  <TamperingDetection>true</TamperingDetection>
  <DebuggingProtection>true</DebuggingProtection>
  <SuppressIldasm>true</SuppressIldasm>
  <CleanAttributes>true</CleanAttributes>
  <SealClasses>true</SealClasses>
</PropertyGroup>

Eine Map-Datei für den Support aufbewahren

Eine aggressive Verschleierung macht Stacktraces aus der Produktion unlesbar. Bewahren Sie die Map-Datei der Verschleierung auf, die bei jedem Build entsteht. Damit können Sie bei der Diagnose von Kundenproblemen Stacktraces decodieren und die ursprünglichen Namen wiederherstellen, ohne die ausgelieferte Assembly zu schwächen.

Wenn Sie diese Tipps befolgen, setzen Sie Babel Obfuscator wirksam ein und stärken die Sicherheit Ihres Codes. Ausführlichere Informationen und umfassende Anleitungen finden Sie im Benutzerhandbuch von Babel Obfuscator.