Obfuscator — ano ito, mga paraan ng obfuscation ng code at mga tool sa proteksyon

Ano ang Obfuscator?

Obfuscator — program na nagsasagawa ng obfuscation: pag-convert ng nababasang code sa katumbas na functionally ngunit hindi nababasa ng tao. Ang mga pangunahing gawain ng obfuscator — pagpapalit ng pangalan ng mga identifier (identifier mangling), pag-alis ng debug information, paggulo ng control flow (control flow obfuscation) at encryption ng string literals (string encryption).

Ang obfuscation ay hindi encryption. Na-encrypt na code ay hindi maaaring isagawa nang walang decryption. Ang obfuscated code ay direktang isinasagawa ng JVM, ART o JavaScript engine, ngunit napakahirap intindihin ng tao. Hindi nagbibigay ang obfuscation ng ganap na proteksyon — ang motivated na espesyalista ay palaging maaaring ibalik ang logic sa pamamagitan ng deobfuscator o runtime debugging.

Kasaysayan ng pag-unlad ng mga obfuscator

Ang unang komersyal na obfuscator na ProGuard ay lumitaw noong 2002 bilang tool para sa Java applets. Sa paglago ng Android (2008), naging pamantayan ang ProGuard para sa mobile development. Noong 2018, inilabas ng Google ang R8 bilang kapalit ng ProGuard para sa Android Gradle Plugin 3.4. Ang R8 ay 2-3 beses na mas mabilis kaysa ProGuard at bumubuo ng mas compact na bytecode dahil sa malalim na optimization sa antas ng SSA (Static Single Assignment) — isang format ng intermediate representation na nagpapahintulot sa pagsusuri ng data flow.

Sa web development, ang obfuscation ay nag-evolve mula sa simpleng pagpapalit (YUI Compressor, 2007) hanggang sa kumplikadong AST transformer (Obfuscator.io, 2016). Ang mga modernong JavaScript obfuscator ay gumagamit ng control flow flattening, opaque predicates (mga kondisyon na laging true o false ngunit hindi halata sa analyzer) at string encryption na may self-decrypt sa runtime. Isinasama ng Jscrambler (2012) ang obfuscation sa proteksyon laban sa debugger at DRM mechanisms.

Saklaw ng aplikasyon ng obfuscation ay malawak. Sa mobile development, pinoprotektahan ng mga obfuscator ang code laban sa pagnanakaw sa pamamagitan ng APK decompiler (jadx, APKTool, dex2jar). Sa web development, pinoprotektahan ng JavaScript obfuscation ang mga algorithm, API key at business logic ng client side. Sa mga library at SDK, pinipigilan ng obfuscation ang paggamit ng code ng mga kakumpitensya.

Ano ang ginagawa ng obfuscator sa code

Mga paraan ng obfuscation ng code

Identifier mangling (pagpapalit ng pangalan ng mga identifier) — ang pinakakaraniwang paraan. Ang mga pangalan ng klase, method, field at variable ay pinapalitan ng maiikling hindi impormatibong string: a, b, c, aa, ab. Ito ay nagpapahirap sa pag-intindi ng layunin ng bawat elemento ng code. Ang ProGuard at R8 ay gumagamit ng magkakaparehong pangalan para sa iba't ibang uri (klase A, field A, method A), lalong ginugulo ang pagsusuri.

Control flow obfuscation (paggulo ng control flow) ay nagbabago ng istruktura ng code upang ang linear sequence ay hindi halata. Ang mga dead branches ay idinadagdag, ang mga kondisyon ay binabaligtad (if (!a) sa halip na if (a)), ang mga operator na parang goto (break/continue na may label) ay isinisingit. Ginagawa nitong napakahirap ang pagsusuri sa pamamagitan ng decompiler at debugger.

Halimbawa ng JavaScript obfuscation sa pamamagitan ng Obfuscator.io

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

// Pagkatapos ng Obfuscator.io sa high mode
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 ay nagdagdag ng mga string array, self-invoking function para guluhin ang array, pinalitan ang pangalan ng lahat ng identifier at pinalitan ang mga string ng array index. Ang source code na 5 linya ay naging 20+ hindi nababasang linya, ngunit ang functionality ng authenticate(token) ay ganap na napanatili. Ang deobfuscation ay posible sa pamamagitan ng AST analysis, ngunit nangangailangan ng oras.

ProGuard at R8: obfuscation ng mga Android application

ProGuard — klasikong obfuscator para sa Java at Android, ginagamit mula 2002. Ang ProGuard ay gumaganap ng tatlong gawain: compression (shrinking — pag-alis ng hindi ginagamit na mga klase at method), optimization (optimization ng bytecode) at obfuscation (pagpapalit ng pangalan ng mga identifier). Ang ProGuard ay naka-embed sa Android Gradle Plugin sa pamamagitan ng file na proguard-rules.pro na may mga exception rule para sa mga library.

R8 — mas modernong obfuscator, isinama sa Android Gradle Plugin simula AGP 3.4. Ang R8 ay gumaganap ng parehong function tulad ng ProGuard, ngunit mas mabilis (isinulat mula sa simula sa Kotlin) at mas mahusay (mas mahusay na nag-o-optimize ng bytecode para sa ART Runtime). Ang configuration ng R8 ay ginagawa sa pamamagitan ng parehong proguard-rules.pro file tulad ng para sa ProGuard. Para i-activate ang R8, sapat na itakda ang minifyEnabled true sa build.gradle.

Mapping file at deobfuscation ng mga crash report

Mapping file — resulta ng trabaho ng R8/ProGuard, naglalaman ng korespondensya sa pagitan ng orihinal at obfuscated na pangalan ng mga klase, method at field. Ang mapping file ay kritikal para sa pagsusuri ng mga crash report: kung wala ito, ang stack trace ay maglalaman ng a.a.b sa halip na com.example.app.MainActivity.onCreate. Ang Firebase Crashlytics at Sentry ay awtomatikong naglo-load ng mga mapping file at ibinabalik ang orihinal na pangalan sa mga report.

Ang mga mapping file ay dapat i-upload sa Firebase o Sentry sa bawat pag-publish ng bagong bersyon ng application. Kung ang mapping file ay nawala o hindi na-upload, lahat ng crash report pagkatapos ng obfuscation ay magiging hindi nababasa. Ang Android Gradle Plugin ay awtomatikong nagse-save ng mapping file sa build/outputs/mapping/release/mapping.txt. Para sa Firebase ginagamit ang Crashlytics Gradle Plugin, na nag-u-upload ng mapping sa pagbuo ng release version.

Configuration ng ProGuard/R8 para sa Android

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

# proguard-rules.pro — mga panuntunan sa pagpapanatili
# Panatilihin ang data model para sa Gson
-keep class com.example.model.** { *; }

# Panatilihin ang mga klase para sa Retrofit interfaces
-keep,allowobfuscation interface com.example.api.*

# Huwag i-obfuscate ang pampublikong aktibidad
-keep class * extends android.app.Activity {
    public protected *;
}

# Alisin ang mga log sa produksyon
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(...);
    public static int v(...);
    public static int d(...);
}

Mga -keep rule sa proguard-rules.pro ay kritikal — kung wala ang mga ito, tatanggalin o papalitan ng R8 ang pangalan ng mga klase at method na ginagamit sa pamamagitan ng reflection (Gson, Retrofit, Room). Inaalis ng assumenosideeffects ang mga tawag sa Log.v at Log.d mula sa production code. Ang mga library tulad ng Gson, Retrofit at OkHttp ay nagbibigay ng mga ready-made rule sa proguard.txt sa loob ng AAR.

JavaScript obfuscation: Obfuscator.io at Jscrambler

Obfuscator.io — ang pinakasikat na open-source JavaScript obfuscator na may suporta para sa pagpapalit ng pangalan ng identifier, string encryption, control flow flattening at debug protection. Ang configuration ng obfuscation ay ginagawa sa pamamagitan ng JSON-config o CLI. Ang libreng bersyon ay sumusuporta sa mga basic method; ang Enterprise version ay nagdaragdag ng polymorphic code at self-defense.

Jscrambler — komersyal na JavaScript obfuscator na may pinalawak na proteksyon: polymorphic transformations (bawat execution ay bumubuo ng bagong obfuscated code), proteksyon laban sa debugger (detection ng DevTools), proteksyon laban sa screenshot (self-defending) at expiration mechanisms (humihinto ang code sa paggana pagkatapos ng tiyak na petsa). Ginagamit ang Jscrambler sa mga banking application at DRM system.

Configuration ng Obfuscator.io

// obfuscate.js — configuration ng 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);

Mga parameter Obfuscator.io: controlFlowFlattening: 0.75 ginugulo ang control flow sa 75% ng mga block; stringArray: true naglilipat ng mga string sa array; debugProtection pumipigil sa pagbukas ng DevTools; disableConsoleOutput nag-aalis ng console.log. Kung mas mataas ang mga threshold, mas mahaba ang oras ng obfuscation at laki ng code, ngunit mas mahirap ang pagsusuri.

Mga limitasyon at panganib ng obfuscation

Hindi pinoprotektahan ng obfuscation laban sa runtime analysis. Maaaring patakbuhin ng attacker ang application sa debugger (Frida, Objection, Xposed) at harangin ang mga method sa real-time. Pinoprotektahan ng obfuscation laban sa static analysis (decompilation ng APK, pagbabasa ng bytecode), ngunit hindi laban sa dynamic analysis. Para sa proteksyon laban sa runtime analysis, kinakailangan ang mga karagdagang hakbang: SSL Pinning, Root Detection, Integrity Verification.

Ang laki ng application pagkatapos ng obfuscation ay maaaring tumaas ng 20-50%. Ang control flow obfuscation ay nagdaragdag ng mga dead branch at nagdo-doble ng mga kondisyon — pinapataas nito ang dami ng bytecode. Ang string encryption ay pinapalitan ang maiikling string literals ng mga tawag sa decrypt(), na nagpapataas din ng laki. Para sa mga mobile application ito ay kritikal, dahil ang laki ng APK ay direktang nakakaapekto sa conversion sa Google Play.

Ang performance ay naaapektuhan din. Ang control flow obfuscation ay nagdaragdag ng mga karagdagang pagsusuri at pagsasanga, pinapataas ang oras ng execution ng mga method ng 5-15%. Ang string encryption ay nagdaragdag ng tawag sa decrypt sa bawat pag-access sa string. Para sa mga function na kritikal sa performance (onDraw sa Android, render sa React), ang obfuscation ay dapat i-disable sa pamamagitan ng -keep rule.