Rilevamento delle manomissioni

Il rilevamento delle manomissioni è un aspetto fondamentale per garantire l’integrità e la sicurezza delle applicazioni software. In ambito .NET, Babel Obfuscator è uno strumento efficace per rilevare le manomissioni. Con la funzionalità di rilevamento delle manomissioni di Babel, gli sviluppatori possono aggiungere alle proprie applicazioni un ulteriore strato di protezione ed eseguire una logica personalizzata in risposta ai tentativi di manomissione.

Quando un assembly è firmato, .NET Framework è già in grado di rilevare se un’applicazione è stata manomessa. Babel Obfuscator fa un passo in più e offre una tutela aggiuntiva. Attivando in Babel il rilevamento delle manomissioni, l’assembly offuscato diventa capace di verificare da sé se è stato manomesso. In caso di manomissione l’applicazione può essere terminata, oppure possono essere richiamati metodi personalizzati dell’assembly per gestire la manomissione in modo più controllato.

Sui target mobili .NET MAUI, a partire dalla versione 12 il rilevamento delle manomissioni è affidato a un controllo di integrità del pacchetto anziché all’hash dell’immagine usato su desktop: un controllo della firma dell’APK su Android (vedi Integrità del pacchetto su Android (MAUI)) e un controllo dell’identificatore del bundle e del profilo di provisioning su iOS (vedi Integrità del pacchetto su iOS (MAUI)). Sui target desktop il controllo calcola l’hash dell’immagine caricata in memoria, quindi non ha effetto per le app pubblicate a file singolo, sottoposte a trimming o compilate AOT; Babel emette un avviso quando il rilevamento delle manomissioni viene richiesto per una pubblicazione di questo tipo.

Configurare il rilevamento delle manomissioni

Abilitare il rilevamento delle manomissioni in Babel è semplice. Puoi farlo dalla riga di comando, aggiungendo l’opzione apposita, oppure dal task Babel, includendo l’attributo TamperingDetection nel file di progetto.

Riga di comando


babel myapp.exe --tamperingdetection

Task Babel di MSBuild


<PropertyGroup>
  <TamperingDetection>true</TamperingDetection>
</PropertyGroup>
 
<Babel TamperingDetection="$(TamperingDetection)" />

Una volta attivato il rilevamento delle manomissioni, l’assembly offuscato verifica automaticamente in fase di esecuzione di non essere stato manomesso. Se l’assembly è stato manomesso, l’applicazione viene terminata.

Sui target desktop (.NET Framework e .NET in esecuzione su CoreCLR) il controllo calcola un hash dell’immagine caricata in memoria e lo confronta con un hash impresso nell’assembly al momento dell’offuscamento. Questa tecnica richiede che l’assembly sia presente come immagine mappata in memoria, quindi non si applica alle applicazioni pubblicate a file singolo, sottoposte a trimming o compilate AOT; quando richiedi il rilevamento delle manomissioni per una pubblicazione di questo tipo, Babel avvisa che il controllo non avrebbe effetto.

Integrità del pacchetto su Android (MAUI) Ultimate

L’hash dell’immagine in memoria descritto sopra non può essere usato su Android: l’applicazione viene eseguita su MonoVM e gli assembly gestiti sono confezionati all’interno dell’APK, non caricati come immagine PE di Windows. A partire dalla versione 12, Babel offre una protezione equivalente per i target .NET for Android (MAUI), basata sull’integrità della firma dell’APK.

Quando abiliti il rilevamento delle manomissioni per un assembly net*-android, Babel inietta un controllo in fase di esecuzione che legge il certificato con cui è stato firmato l’APK in esecuzione e lo confronta con una o più impronte di firmatari attendibili che fissi al momento dell’offuscamento. Se l’applicazione viene firmata di nuovo o riconfezionata con una chiave diversa (il modo classico di ridistribuire un’app modificata), le impronte non corrispondono più e scatta la reazione alla manomissione: l’applicazione viene terminata, oppure viene richiamato il tuo gestore personalizzato (vedi Azione personalizzata al rilevamento di una manomissione). Poiché il controllo esamina la firma del pacchetto a livello di sistema operativo anziché l’immagine gestita, continua a funzionare con il trimming e con la compilazione ahead-of-time (AOT).

Fissare il certificato di firma

Babel non può conoscere il certificato di firma dal solo assembly: viene applicato in seguito, quando l’APK viene firmato. Per questo fissi l’impronta SHA-256 del certificato previsto con l’opzione --trustedsigner. L’opzione è ripetibile, quindi puoi fissare più di un certificato (per esempio una chiave di caricamento e una chiave di firma dell’app di Google Play):


babel MyApp.dll --tamperingdetection --trustedsigner 2924C53EE9C511E9F26E0720FD8151064F7621681667D7AB1899E551CDB25104

Tramite il task MSBuild:


<PropertyGroup>
  <TamperingDetection>true</TamperingDetection>
  <TrustedSigner>2924C53EE9C511E9F26E0720FD8151064F7621681667D7AB1899E551CDB25104</TrustedSigner>
</PropertyGroup>
 
<Babel TamperingDetection="$(TamperingDetection)" TrustedSigner="$(TrustedSigner)" />

Puoi ottenere l’impronta SHA-256 del tuo certificato di firma con keytool (dal keystore) oppure con apksigner (da un APK compilato e firmato):


keytool -list -v -keystore my-release.keystore -alias my-alias | grep -i SHA256
# or, from a signed APK:
apksigner verify --print-certs MyApp.apk | grep -i 'SHA-256'

Rimuovi i due punti di separazione; il valore passato a --trustedsigner è una stringa esadecimale di 64 caratteri.

Se abiliti il rilevamento delle manomissioni su un target Android senza fissare un firmatario attendibile, Babel emette un avviso e ripiega su un controllo più debole, che verifica soltanto che il pacchetto sia firmato. Per una protezione reale passa sempre --trustedsigner (TrustedSigner) con l’impronta del tuo certificato di rilascio.

Integrità del pacchetto su iOS (MAUI) Ultimate

Su .NET for iOS (MAUI) il codice gestito è interamente compilato ahead-of-time e non esiste un’immagine PE mappata in memoria di cui calcolare l’hash, quindi la tecnica usata su desktop non è applicabile. A partire dalla versione 12, Babel offre per i target net*-ios un controllo dell’identità del pacchetto: in fase di esecuzione l’app offuscata verifica il proprio identificatore del bundle e, quando viene eseguita da una build con profilo di provisioning, l’identificatore del team Apple, confrontandoli con i valori che fissi al momento dell’offuscamento. Se uno dei due non corrisponde più, per esempio dopo che l’app è stata riconfezionata o firmata di nuovo con un’identità di sviluppatore diversa, scatta la reazione alla manomissione (l’applicazione viene terminata, oppure viene richiamato il tuo gestore personalizzato). Il controllo viene eseguito da un inizializzatore di modulo all’avvio del processo e funziona con la compilazione AOT completa.

Fissare gli identificatori del bundle e del team

Fissa i valori previsti con le opzioni --trustedbundle e --trustedteam:


babel MyApp.dll --tamperingdetection --trustedbundle com.mycompany.myapp --trustedteam ABCDE12345

Tramite il task MSBuild:


<PropertyGroup>
  <TamperingDetection>true</TamperingDetection>
  <TrustedBundle>com.mycompany.myapp</TrustedBundle>
  <TrustedTeam>ABCDE12345</TrustedTeam>
</PropertyGroup>
 
<Babel TamperingDetection="$(TamperingDetection)"
       TrustedBundle="$(TrustedBundle)"
       TrustedTeam="$(TrustedTeam)" />

--trustedbundle è il CFBundleIdentifier della tua app (da Info.plist).
--trustedteam è il tuo Apple Team ID di 10 caratteri (visibile nel portale Apple Developer alla voce Membership e nel nome dell’identità del tuo certificato di firma, per esempio Apple Development: You (ABCDE12345)).

Ogni valore fissato è facoltativo e viene verificato in modo indipendente: fissa l’identificatore del bundle, quello del team o entrambi.

Il controllo dell’identificatore del team legge il profilo di provisioning incorporato nell’app (embedded.mobileprovision), presente nelle build di sviluppo, ad hoc ed enterprise. Non è disponibile nel simulatore iOS (dove il controllo viene saltato) e viene rimosso dalle build per l’App Store (che Apple firma di nuovo), quindi per la distribuzione sull’App Store affidati all’identificatore del bundle fissato. Se abiliti il rilevamento delle manomissioni su un target iOS senza fissare nessuno dei due valori, Babel emette un avviso e non esegue alcun controllo di integrità.

Azione personalizzata al rilevamento di una manomissione

Per personalizzare la reazione ai tentativi di manomissione, gli sviluppatori possono definire un metodo specifico all’interno del proprio assembly. Applicando la funzionalità “on tampering detected method” con l’attributo [Obfuscation], viene designato un metodo personalizzato che gestisce l’evento di manomissione. In questo modo gli sviluppatori possono implementare una logica propria e intervenire in modo adeguato quando viene rilevata una manomissione. Per esempio possono impostare un flag nascosto, generare risultati errati o attivare contromisure specifiche per attenuare l’impatto della manomissione. Lo stesso gestore viene usato per il controllo dell’immagine su desktop e per i controlli di integrità del pacchetto su Android e iOS, quindi un solo metodo copre tutti i target.


class CustomTampering
{
    public static bool HasBeenTampered { get; internal set; }
    
    [Obfuscation(Feature = "on tampering detected method")]
    static void OnTamperingDetected()
    {
        HasBeenTampered = true;
    }
}

Il codice offre un’implementazione di base per gestire il rilevamento delle manomissioni.

Se HasBeenTampered vale true, significa che è stata rilevata una manomissione. L’uso suggerito è compiere determinate azioni o eseguire codice specifico quando viene rilevata una manomissione:


if (CustomTampering.HasBeenTampered)
{
    // Tampering detected: Implement appropriate security measures or handle the 
    // situation accordingly.
    // Examples include logging the incident, notifying system administrators, 
    // disabling critical functionality or terminating the application.
}

In sintesi, con il rilevamento delle manomissioni di Babel Obfuscator gli sviluppatori possono migliorare in modo significativo la sicurezza delle proprie applicazioni .NET. Potendo rilevare i tentativi di manomissione e reagire, possono tutelare il software dalle modifiche non autorizzate, preservare l’integrità dei dati e proteggere le informazioni sensibili.