DexGuard: vad är det, obfuskering och säkerhet för Android-applikationer

Vad är DexGuard?

DexGuard är ett kommersiellt verktyg för obfuskering och skydd av Android-applikationer, utvecklat av samma team som skapade ProGuard (Eric Lafortune). Produkten lanserades 2012 som en utökning för projekt där standard ProGuard-obfuskering inte räcker. DexGuard arbetar i efterkompileringsfasen och omvandlar DEX-bytekod till en skyddad form innan den paketeras i APK.

Arkitekturen i DexGuard är uppbyggd på en flernivåskyddsmodell. Den första nivån är obfuskering av klass-, metod- och fältnamn med overload induction. Den andra är kryptering av strängkonstanter och inläsning via stub-metoder vid körning. Den tredje är APK-integritetskontroll genom verifiering av kontrollsumma för signaturer. Enligt Guardsquares tekniska rapport (2025) ökar den kombinerade användningen av dessa nivåer analystiden för en applikation från några minuter till flera veckor.

DexGuard stödjer alla typer av Android-projekt: applikationer, bibliotek, SDK och spelprojekt på Unity. Verktyget integreras i den standardmässiga Gradle-pipelinen via pluginet com.guardsquare.dexguard och kräver inget manuellt ingripande efter konfiguration.

Den viktigaste skillnaden mellan DexGuard och open-source-alternativ är aktivt skydd vid körning. Verktyget förvirrar inte bara koden utan lägger till en agent som utför kontroller under applikationens körning. Detta gör det möjligt att upptäcka attacker som Frida-injektion, Xposed eller felsökning via JDWP och reagera på dem: nödstopp, generering av falska data eller servermeddelande.

Hur fungerar obfuskering i DexGuard

Obfuskeringsprocessen i DexGuard består av successiva steg av bytekodtransformation, var och en riktad mot en specifik attackvektor.

Namnobfuskering med överlagring

En vanlig obfuskerare ersätter namn med enkelteckens a, b, c. DexGuard använder overload induction — tilldelar samma korta namn till olika metoder med olika signaturer. Dekompilatorn kan inte lösa överlagringen och genererar felaktig kod. Enligt Guardsquares tester ökar namnöverlagring antalet dekompileringsfel med 78%.

Kryptering av konstanter

Strängliteraler, webbadresser, API-nycklar och token krypteras med AES-256-algoritmen under byggfasen. Vid körning dekrypterar en stub-metod strängen före användning och nollställer minnesområdet efteråt. Detta skyddar mot statisk visning av strängar i DEX-filen. Exempel utan kryptering: en angripare kör strings dexguard.apk och ser alla API-slutpunkter i klartext.

Kodintegritetskontroll

DexGuard beräknar en SHA-256-hash för varje DEX-fil och lagrar värdet i det nativa lagret. När applikationen startar jämför agenten den aktuella hashen med referensen. Vid avvikelse (ändrad APK) avslutas applikationen. Alternativt kan integriteten för resurser och manifest kontrolleras.

// build.gradle (app-nivå)
buildscript {
    repositories {
        maven { url "https://guard repositories.com/dexguard" }
    }
    dependencies {
        classpath "com.guardsquare:dexguard-gradle-plugin:9.1.05"
    }
}

apply plugin: "com.guardsquare.dexguard"

android {
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            dexguard {
                config "dexguard-project.txt"
            }
        }
    }
}

DexGuard vs ProGuard: viktiga skillnader

Båda verktygen är utvecklade av samma företag men riktar sig till olika scenarier. ProGuard är en open-source-optimerare och minimal obfuskerare som finns som standard i Android SDK. DexGuard är en kommersiell produkt som lägger till skyddsnivåer som inte är tillgängliga i den kostnadsfria versionen.

Valet mellan verktygen bestäms av klassen av skyddad information. För en vanlig mobilapplikation räcker ProGuard. För bank-, betalnings- och medicinska applikationer där kodavslöjande medför finansiella eller regulatoriska risker är DexGuard den rekommenderade lösningen. Enligt OWASP Mobile Top 10 (2024) anses brist på obfuskering i applikationer med konfidentiella data vara en kritisk risk.

Konfigurera DexGuard i Gradle-projekt

Integration av DexGuard börjar med att ansluta Guardsquare-förvarets i rotens build.gradle. Plugin version 9.x är kompatibel med AGP 7.4–8.5 och Gradle 7.6–8.7. Skyddskonfigurationen anges i en separat dexguard-project.txt där specifika tekniker aktiveras.

// root build.gradle
buildscript {
    repositories {
        maven { url "https://maven.guardsquare.com/dexguard" }
    }
}

// dexguard-project.txt — minimal konfiguration
# Strängkryptering
@stringEncryption

# Obfuskering med namnöverlagring
@overloadInduction

# APK-integritetskontroll
@integrityCheck

# Skydd mot felsökning och emulator
@antiDebug
@antiEmulator

Direktiven @stringEncryption och @overloadInduction är nyckeln till att skydda kommersiell kod. När alla annoteringar aktiveras ökar byggtiden med 30–60 sekunder, vilket är motiverat med tanke på skyddsnivån. Konfigurationen lagras i VCS och tillämpas endast för release-bygget.

Det är viktigt att konfigurera undantag för klasser som används via reflektion. DexGuard, liksom ProGuard, analyserar inte reflektion automatiskt. I dexguard-project.txt måste -keep-regler läggas till för biblioteksklasser som laddas via Class.forName eller @JavascriptInterface.

// dexguard-project.txt — keep-regler
# Bevara Gson-modellklasser
-keep class com.example.model.** { *; }

# Bevara WebView-gränssnitt
-keepclassmembers class * {
    @android.webkit.JavascriptInterface <methods>;
}

# Uteslut Firebase-krashrapporter
-keep class com.google.firebase.** { *; }

DexGuards skyddstekniker

DexGuard innehåller över 20 skyddstekniker, uppdelade i statiska (under byggfasen) och dynamiska (vid körning). Valet av specifika tekniker beror på applikationens hotmodell.

Statiskt skydd

Resurskryptering — bilder, tillgångar och konfigurationsfiler krypteras och dekrypteras vid första åtkomst. Control flow obfuscation infogar död kod och ändrar instruktionsordningen, vilket gör bytekod oläslig för dekompilerare som jadx. Dolda konstanter (constant hiding) ersätter numeriska literaler med aritmetiska uttryck som beräknas vid körning.

Dynamiskt skydd (RASP)

Runtime Application Self-Protection — en agent inuti applikationen som övervakar körningsmiljöns beteende. DexGuard RASP upptäcker: Frida-anslutning via /proc/self/maps, närvaro av Xposed Framework, körning under en debugger (JDWP), Android-emulator (QEMU). Vid upptäckt av ett hot aktiveras en policy — krasch eller generering av felaktiga data. Enligt forskning av OWASP Mobile Security (2025) har RASP-skydd stoppat 94% av typiska automatiserade attacker.

Skydd mot tidsbaserade attacker

DexGuard lägger till slumpmässiga fördröjningar i kritiska koddelar, vilket ökar genomsökningstiden vid dynamisk analys. Parametern ställs in i millisekunder och randomiseras vid varje bygge. Detta försvårar användningen av fuzzning-verktyg och automatiska skannrar.

Integrationsriktlinjer och kompatibilitet

När DexGuard införs i ett befintligt projekt måste bakåtkompatibilitet med bibliotek och populära SDK beaktas. Vissa bibliotek är inte kompatibla med extrem obfuskering på grund av reflektionsanrop.

Kompatibilitet med populära SDK

DexGuard är kompatibel med Firebase Crashlytics, Google Analytics, Google Play Services, Retrofit, OkHttp, Glide och Gson med korrekta keep-regler. Bibliotek som använder annoteringar och kodgenerering (Dagger, Hilt, Room, DataBinding) kräver explicit bevarande av genererade klasser. Guardsquare-teamet publicerar officiella konfigurationsprover för populära SDK.

Miljökrav

Minsta krav: Android Gradle Plugin 7.4, Gradle 7.6, JDK 11. DexGuard 9.1 stödjer targetSdk 34 och compileSdk 34. För Java 17 och AGP 8.2+ krävs DexGuard version 9.2 och senare. Verktyget är inte kompatibelt med R8 i fullt optimeringsläge — när DexGuard används inaktiveras R8 automatiskt.

Testning efter obfuskering

Efter konfiguration av DexGuard måste regressionstester utföras på alla vägar som påverkas av reflektion och dynamisk klassladdning. Det rekommenderas att köra UI-autotester på bygget med aktiverat skydd före lansering. Guardsquare tillhandahåller verktyget DexGuard Tracer som loggar ClassNotFoundException-fel vid körning utan att krascha applikationen, vilket förenklar felsökning av keep-regler.