Obfuscator — vad är det, metoder för kodobfuskering och skyddsverktyg

Vad är Obfuscator?

Obfuscator — ett program som utför obfuskering: omvandling av läsbar kod till funktionellt ekvivalent men oläslig för människor. Obfuskerarens huvuduppgifter — omdöpning av identifierare (identifier mangling), borttagning av felsökningsinformation, förvirring av kontrollflödet (control flow obfuscation) och kryptering av strängliteral (string encryption).

Obfuskering är inte kryptering. Krypterad kod kan inte exekveras utan dekryptering. Obfuskerad kod exekveras direkt av JVM, ART eller JavaScript-motorn, men är extremt svår för människor att förstå. Obfuskering ger inte absolut skydd — en motiverad specialist kan alltid återställa logiken genom en deobfuskerare eller felsökning under körning.

Historia om utvecklingen av obfuskerare

Den första kommersiella obfuskeraren ProGuard dök upp 2002 som ett verktyg för Java-applets. Med Android-tillväxten (2008) blev ProGuard standard inom mobilutveckling. 2018 släppte Google R8 som ersättning för ProGuard för Android Gradle Plugin 3.4. R8 är 2-3 gånger snabbare än ProGuard och genererar mer kompakt bytekod tack vare djup optimering på SSA-nivå (Static Single Assignment) — ett format för mellanrepresentation som möjliggör dataflödesanalys.

Inom webbutveckling har obfuskering utvecklats från enkla ersättningar (YUI Compressor, 2007) till komplexa AST-omvandlare (Obfuscator.io, 2016). Moderna JavaScript-obfuskerare använder control flow flattening, opaque predicates (villkor som alltid är true eller false men inte uppenbara för analysatorn) och strängkryptering med självdekryptering under körning. Jscrambler (2012) integrerar obfuskering med skydd mot felsökare och DRM-mekanismer.

Användningsområdet för obfuskering är brett. Inom mobilutveckling skyddar obfuskerare kod mot stöld via APK-dekompilerare (jadx, APKTool, dex2jar). Inom webbutveckling skyddar JavaScript-obfuskering algoritmer, API-nycklar och affärslogik på klientsidan. I bibliotek och SDK förhindrar obfuskering användning av kod av konkurrenter.

Vad gör obfuskeraren med koden

Metoder för kodobfuskering

Identifier mangling (omdöpning av identifierare) — den vanligaste metoden. Namn på klasser, metoder, fält och variabler ersätts med korta, icke informativa strängar: a, b, c, aa, ab. Detta försvårar förståelsen av syftet med varje kodelement. ProGuard och R8 använder identiska namn för olika typer (klass A, fält A, metod A), vilket ytterligare förvirrar analysen.

Control flow obfuscation (förvirring av kontrollflödet) ändrar kodstrukturen så att den linjära sekvensen blir otydlig. Döda grenar (dead branches) läggs till, villkor inverteras (if (!a) istället för if (a)), goto-liknande operatorer (break/continue med etiketter) infogas. Detta gör analys via dekompilerare och felsökare extremt tidskrävande.

Exempel på JavaScript-obfuskering via Obfuscator.io

// Källkod
function authenticate(token) {
  const url = "https://api.example.com/auth";
  const headers = { Authorization: "Bearer " + token };
  return fetch(url, { method: "POST", headers });
}

// Efter Obfuscator.io i högt läge
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 lade till strängarrayer, en självanropande funktion för att blanda arrayen, döpte om alla identifierare och ersatte strängar med arrayindex. Källkoden på 5 rader förvandlades till 20+ oläsliga rader, men funktionaliteten för authenticate(token) är fullt bevarad. Deobfuskering är möjlig via AST-analys, men kräver tid.

ProGuard och R8: obfuskering av Android-applikationer

ProGuard — klassisk obfuskerare för Java och Android, i användning sedan 2002. ProGuard utför tre uppgifter: komprimering (shrinking — borttagning av oanvända klasser och metoder), optimering (bytekodoptimering) och obfuskering (omdöpning av identifierare). ProGuard är inbyggt i Android Gradle Plugin via filen proguard-rules.pro med undantagsregler för bibliotek.

R8 — en modernare obfuskerare, inkluderad i Android Gradle Plugin från AGP 3.4. R8 utför samma funktioner som ProGuard, men snabbare (skriven från grunden i Kotlin) och effektivare (optimerar bytekod bättre för ART Runtime). Konfigurering av R8 görs via samma proguard-rules.pro-filer som för ProGuard. För att aktivera R8 räcker det att ställa in minifyEnabled true i build.gradle.

Mapping-filer och deobfuskering av crashrapporter

Mapping-fil — resultatet av R8/ProGuard-arbete, som innehåller överensstämmelse mellan ursprungliga och obfuskerade namn på klasser, metoder och fält. Mapping-filen är kritisk för analys av crashrapporter: utan den kommer stacktrace att innehålla a.a.b istället för com.example.app.MainActivity.onCreate. Firebase Crashlytics och Sentry laddar automatiskt mapping-filer och återställer ursprungliga namn i rapporterna.

Mapping-filer måste laddas upp till Firebase eller Sentry vid varje publicering av en ny version av applikationen. Om mapping-filen tappas bort eller inte laddas upp blir alla crashrapporter efter obfuskering oläsliga. Android Gradle Plugin sparar automatiskt mapping-filen i build/outputs/mapping/release/mapping.txt. För Firebase används Crashlytics Gradle Plugin, som laddar upp mapping vid bygget av release-versionen.

Konfigurering av ProGuard/R8 för Android

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

# proguard-rules.pro — bevaranderegler
# Bevara datamodell för Gson
-keep class com.example.model.** { *; }

# Bevara klasser för Retrofit-gränssnitt
-keep,allowobfuscation interface com.example.api.*

# Obfusker inte publika aktiviteter
-keep class * extends android.app.Activity {
    public protected *;
}

# Ta bort loggar i produktion
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(...);
    public static int v(...);
    public static int d(...);
}

-keep-regler i proguard-rules.pro är kritiska — utan dem tar R8 bort eller döper om klasser och metoder som används via reflektion (Gson, Retrofit, Room). assumenosideeffects tar bort Log.v- och Log.d-anrop från produktionskod. Bibliotek som Gson, Retrofit och OkHttp tillhandahåller färdiga regler i proguard.txt inuti AAR.

JavaScript-obfuskering: Obfuscator.io och Jscrambler

Obfuscator.io — den mest populära open-source JavaScript-obfuskeraren med stöd för omdöpning av identifierare, strängkryptering, control flow flattening och skydd mot felsökning (debug protection). Konfigurering av obfuskering görs via JSON-konfig eller CLI. Den gratis versionen stöder grundläggande metoder; Enterprise-versionen lägger till polymorf kod och självskydd.

Jscrambler — en kommersiell JavaScript-obfuskerare med utökat skydd: polymorfa transformationer (varje exekvering genererar ny obfuskerad kod), skydd mot felsökare (detektering av DevTools), skydd mot skärmbilder (self-defending) och utgångsmekanismer (koden slutar fungera efter ett visst datum). Jscrambler används i bankapplikationer och DRM-system.

Konfigurering av Obfuscator.io

// obfuscate.js — konfigurering av 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);

Parametrar Obfuscator.io: controlFlowFlattening: 0.75 förvirrar kontrollflödet i 75% av blocken; stringArray: true flyttar strängar till en array; debugProtection förhindrar öppning av DevTools; disableConsoleOutput tar bort console.log. Ju högre trösklar, desto längre obfuskeringstid och kodstorlek, men desto svårare analys.

Begränsningar och risker med obfuskering

Obfuskering skyddar inte mot analys under körning. En angripare kan köra applikationen i en felsökare (Frida, Objection, Xposed) och fånga metoder i realtid. Obfuskering skyddar mot statisk analys (dekompilering av APK, läsning av bytekod), men inte mot dynamisk analys. För skydd mot analys under körning krävs ytterligare åtgärder: SSL Pinning, Root Detection, Integrity Verification.

Applikationsstorleken efter obfuskering kan öka med 20-50%. Control flow obfuscation lägger till döda grenar och duplicerar villkor — detta ökar mängden bytekod. Strängkryptering ersätter korta strängliteral med anrop till decrypt(), vilket också ökar storleken. För mobila applikationer är detta kritiskt eftersom APK-storleken direkt påverkar konverteringen i Google Play.

Prestanda påverkas också. Control flow obfuscation lägger till extra kontroller och förgreningar, vilket ökar metodernas exekveringstid med 5-15%. Strängkryptering lägger till ett decrypt-anrop vid varje åtkomst till en sträng. För prestandakritiska funktioner (onDraw i Android, render i React) bör obfuskering inaktiveras via -keep-regler.