Obfuscator — co to je, metody obfuskace kódu a nástroje ochrany

Co je Obfuscator?

Obfuscator — program provádějící obfuskaci: převod čitelného kódu na funkčně ekvivalentní, ale pro člověka nečitelný. Hlavní úkoly obfuskátoru — přejmenování identifikátorů (identifier mangling), odstranění ladicích informací, zmatení toku řízení (control flow obfuscation) a šifrování řetězcových literálů (string encryption).

Obfuskace není šifrování. Zašifrovaný kód nelze provést bez dešifrování. Obfuskovaný kód je prováděn přímo JVM, ART nebo JavaScriptovým enginem, ale člověk jej velmi obtížně chápe. Obfuskace neposkytuje absolutní ochranu — motivovaný specialista může vždy obnovit logiku pomocí deobfuskátoru nebo ladění za běhu.

Historie vývoje obfuskátorů

První komerční obfuskátor ProGuard se objevil v roce 2002 jako nástroj pro Java aplety. S růstem Androidu (2008) se ProGuard stal standardem pro mobilní vývoj. V roce 2018 Google vydal R8 jako náhradu ProGuardu pro Android Gradle Plugin 3.4. R8 je 2-3krát rychlejší než ProGuard a generuje kompaktnější bajtkód díky hluboké optimalizaci na úrovni SSA (Static Single Assignment) — formátu mezireprezentace umožňujícího analýzu toku dat.

Ve webovém vývoji se obfuskace vyvinula od jednoduchých náhrad (YUI Compressor, 2007) ke složitým AST transformátorům (Obfuscator.io, 2016). Moderní JavaScriptové obfuskátory používají control flow flattening, opaque predicates (podmínky vždy true nebo false, ale pro analyzátor ne zřejmé) a šifrování řetězců s vlastním dešifrováním za běhu. Jscrambler (2012) integruje obfuskaci s ochranou před ladicími nástroji a DRM mechanismy.

Oblast použití obfuskace je široká. V mobilním vývoji obfuskátory chrání kód před krádeží přes APK dekompilátory (jadx, APKTool, dex2jar). Ve webovém vývoji obfuskace JavaScriptu chrání algoritmy, API klíče a obchodní logiku na straně klienta. V knihovnách a SDK obfuskace brání použití kódu konkurenty.

Co obfuskátor dělá s kódem

Metody obfuskace kódu

Identifier mangling (přejmenování identifikátorů) — nejrozšířenější metoda. Názvy tříd, metod, polí a proměnných jsou nahrazeny krátkými, neinformativními řetězci: a, b, c, aa, ab. To ztěžuje pochopení účelu každého prvku kódu. ProGuard a R8 používají identické názvy pro různé typy (třída A, pole A, metoda A), čímž dále zamotávají analýzu.

Control flow obfuscation (zmatení toku řízení) mění strukturu kódu tak, že lineární posloupnost není zřejmá. Přidávají se mrtvé větve (dead branches), podmínky se obracejí (if (!a) místo if (a)), vkládají se operátory podobné goto (break/continue s popisky). To činí analýzu přes dekompilátor a ladicí nástroj extrémně pracnou.

Příklad obfuskace JavaScriptu přes Obfuscator.io

// Zdrojový kód
function authenticate(token) {
  const url = "https://api.example.com/auth";
  const headers = { Authorization: "Bearer " + token };
  return fetch(url, { method: "POST", headers });
}

// Po Obfuscator.io v režimu high
const _0x4f2e = ["https://api.example.com/auth",
  "Authorization", "Bearer ", "POST"];
(function(_0x5a3b, _0x4f2e) {
  const _0x1c2d = function(_0x3e4f) {
    while (--_0x3e4f) {
      _0x5a3b["push"](_0x5a3b["shift"]());
    }
  };
  _0x1c2d(++_0x4f2e);
}(_0x4f2e, _0x1c2d));

function _0x1c2d(_0x5a3b, _0x4f2e) {
  return _0x4f2e[_0x5a3b];
}

function _0x3e4f(_0x1c2d) {
  const _0x5a3b = _0x1c2d(0, "https://api.example.com/auth");
  const _0x4f2e = { Authorization: "Bearer " + _0x1c2d };
  return fetch(_0x5a3b, { method: "POST", headers: _0x4f2e });
}

Obfuscator.io přidal pole řetězců, samovolnou funkci pro zamíchání pole, přejmenoval všechny identifikátory a nahradil řetězce indexy pole. Zdrojový kód o 5 řádcích se změnil na 20+ nečitelných řádků, ale funkčnost authenticate(token) je plně zachována. Deobfuskace je možná přes AST analýzu, ale vyžaduje čas.

ProGuard a R8: obfuskace Android aplikací

ProGuard — klasický obfuskátor pro Java a Android, používaný od roku 2002. ProGuard plní tři úkoly: kompresi (shrinking — odstranění nepoužívaných tříd a metod), optimalizaci (optimalizace bajtkódu) a obfuskaci (přejmenování identifikátorů). ProGuard je zabudován do Android Gradle Plugin přes soubor proguard-rules.pro s pravidly výjimek pro knihovny.

R8 — modernější obfuskátor, zahrnutý do Android Gradle Plugin od AGP 3.4. R8 plní stejné funkce jako ProGuard, ale rychleji (napsán od nuly v Kotlinu) a efektivněji (lépe optimalizuje bajtkód pro ART Runtime). Konfigurace R8 se provádí přes stejné soubory proguard-rules.pro jako pro ProGuard. Pro aktivaci R8 stačí nastavit minifyEnabled true v build.gradle.

Mapping soubory a deobfuskace hlášení o pádech

Mapping soubor — výsledek práce R8/ProGuard, obsahující mapování mezi původními a obfuskovanými názvy tříd, metod a polí. Mapping soubor je kritický pro analýzu hlášení o pádech: bez něj bude stack trace obsahovat a.a.b místo com.example.app.MainActivity.onCreate. Firebase Crashlytics a Sentry automaticky načítají mapping soubory a obnovují původní názvy v hlášeních.

Mapping soubory musí být nahrány do Firebase nebo Sentry při každém publikování nové verze aplikace. Pokud se mapping soubor ztratí nebo není nahrán, všechna hlášení o pádech po obfuskaci se stanou nečitelnými. Android Gradle Plugin automaticky ukládá mapping soubor do build/outputs/mapping/release/mapping.txt. Pro Firebase se používá Crashlytics Gradle Plugin, který nahrává mapping při sestavení release verze.

Konfigurace ProGuard/R8 pro Android

// app/build.gradle — obfuskace přes R8
android {
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
                "proguard-android-optimize.txt"),
                "proguard-rules.pro"
        }
    }
}

# proguard-rules.pro — pravidla zachování
# Zachovat datový model pro Gson
-keep class com.example.model.** { *; }

# Zachovat třídy pro Retrofit rozhraní
-keep,allowobfuscation interface com.example.api.*

# Nepochybovat veřejné aktivity
-keep class * extends android.app.Activity {
    public protected *;
}

# Odstranit logy v produkci
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(...);
    public static int v(...);
    public static int d(...);
}

Pravidla -keep v proguard-rules.pro jsou kritická — bez nich R8 odstraní nebo přejmenuje třídy a metody používané přes reflexi (Gson, Retrofit, Room). assumenosideeffects odstraňuje volání Log.v a Log.d z produkčního kódu. Knihovny jako Gson, Retrofit a OkHttp poskytují hotová pravidla v proguard.txt uvnitř AAR.

Obfuskace JavaScriptu: Obfuscator.io a Jscrambler

Obfuscator.io — nejpopulárnější open-source obfuskátor JavaScriptu s podporou přejmenování identifikátorů, šifrování řetězců, control flow flattening a ochrany před laděním (debug protection). Konfigurace obfuskace se provádí přes JSON-config nebo CLI. Bezplatná verze podporuje základní metody; Enterprise verze přidává polymorfní kód a sebeobranu.

Jscrambler — komerční obfuskátor JavaScriptu s rozšířenou ochranou: polymorfní transformace (každé spuštění generuje nový obfuskovaný kód), ochrana před ladicími nástroji (detekce DevTools), ochrana před snímky obrazovky (self-defending) a mechanismy vypršení (kód přestane fungovat po určitém datu). Jscrambler se používá v bankovních aplikacích a DRM systémech.

Konfigurace Obfuscator.io

// obfuscate.js — konfigurace Obfuscator.io
const JavaScriptObfuscator = require("javascript-obfuscator");
const fs = require("fs");

const code = fs.readFileSync("app.js", "utf8");
const result = JavaScriptObfuscator.obfuscate(code, {
  compact: true,
  controlFlowFlattening: true,
  controlFlowFlatteningThreshold: 0.75,
  numbersToExpressions: true,
  simplify: false,
  stringArray: true,
  stringArrayThreshold: 0.8,
  debugProtection: true,
  disableConsoleOutput: true,
});

fs.writeFileSync("app.obfuscated.js", result.code);

Parametry Obfuscator.io: controlFlowFlattening: 0.75 zamotává tok řízení v 75 % bloků; stringArray: true přesouvá řetězce do pole; debugProtection zabraňuje otevření DevTools; disableConsoleOutput odstraňuje console.log. Čím vyšší jsou prahy, tím delší je čas obfuskace a velikost kódu, ale tím obtížnější je analýza.

Omezení a rizika obfuskace

Obfuskace nechrání před runtime analýzou. Útočník může spustit aplikaci v ladicím nástroji (Frida, Objection, Xposed) a zachytávat metody v reálném čase. Obfuskace chrání před statickou analýzou (dekompilace APK, čtení bajtkódu), ale ne před dynamickou. Pro ochranu před runtime analýzou jsou vyžadována dodatečná opatření: SSL Pinning, Root Detection, Integrity Verification.

Velikost aplikace po obfuskaci může vzrůst o 20-50 %. Control flow obfuscation přidává mrtvé větve a duplikuje podmínky — to zvyšuje množství bajtkódu. String encryption nahrazuje krátké řetězcové literály voláními decrypt(), což také zvyšuje velikost. Pro mobilní aplikace je to kritické, protože velikost APK přímo ovlivňuje konverzi v Google Play.

Výkon také trpí. Control flow obfuscation přidává dodatečné kontroly a větvení, čímž zvyšuje dobu provádění metod o 5-15 %. String encryption přidává volání decrypt při každém přístupu k řetězci. U funkcí kritických pro výkon (onDraw v Androidu, render v Reactu) by měla být obfuskace vypnuta pomocí -keep pravidel.