Vulnerabilità nella memorizzazione nella cache della chiave offuscata? Licenze Android

Question

Sto memorizzando nella cache l'autenticazione di un utente ogni volta che il server ping di Android Market Licensing restituisce un ping GRANT_ACCESS.

Qualcuno vede qualche vulnerabilità con questa strategia? Credo che sia molto forte, dal momento che sto offuscando una chiave, e l'unico modo per non offuscare è conoscere il sale. Ora, qualcuno potrebbe idealmente aprire l'apk e cercare il sale, ma questo non è proprio il livello di cracking che penso sia troppo importante per preoccuparsi.

Come si può vedere, informazioni specifiche del dispositivo vengono aggiunte alla tecnica di offuscamento.

// Try to use more data here. ANDROID_ID is a single point of attack. 
String deviceId = Secure.getString(getContentResolver(), Secure.ANDROID_ID); 
obfuscator = new AESObfuscator(SALT, getPackageName(), deviceId); 
mChecker = new LicenseChecker(this, new ServerManagedPolicy(this, obfuscator), BASE64_PUBLIC_KEY); 

successivo la creazione dei dati persistente:

public void allow() { 
    SharedPreferences settings = getSharedPreferences(PREFERENCES_EULA, 0); 
    SharedPreferences.Editor editor = settings.edit(); 
    String uid = UUID.randomUUID().toString(); 
    if(!settings.contains(ACCESS_KEY)) { 
    editor.putString(ACCESS_KEY,uid);  
    editor.commit(); 
    } 
    if(!settings.contains(OBFU_ACCESS_KEY)) { 
    String obfu = obfuscator.obfuscate(uid); 
    editor.putString(OBFU_ACCESS_KEY,obfu); 
    editor.commit(); 
    } 

Poi, ho usato un altro metodo per controllare lo stato del contenuto memorizzato nella cache:

boolean isCachedLicense() { 
    SharedPreferences settings = getSharedPreferences(PREFERENCES_EULA, 0); 
    if(settings.contains(ACCESS_KEY) && settings.contains(OBFU_ACCESS_KEY)) { 
    String accessKey = settings.getString(ACCESS_KEY, ""); 
    String obAccessKey = settings.getString(OBFU_ACCESS_KEY, ""); 
    try { 
     if(accessKey.equals(obfuscator.unobfuscate(obAccessKey))) { 
       return true; 
     } else { 
       return false; 
     } 
    } catch (ValidationException e) { 
     e.printStackTrace(); 
     return false; 
    } 
    } else { 
     return false; 
    } 
} 

Infine, ho controllato se isCachedLicens e nelle seguenti posizioni di LicenseCheckerCallback: @Override dontAllow e @override applicationError. Se isCachedLicense è vero, allora lascio andare l'utente.

Inoltre, il codice sorgente completo si trova in here.

Answer 1

L'offuscamento con sale è in generale una strategia debole. L'attaccante deve solo capire il sale, che è abbastanza semplice da fare una volta che sai cosa stai cercando, e può essere fatto senza accesso diretto alla tua applicazione. Una volta che il sale è stato scoperto (da chiunque), tutta la nostra base di installazione è stata compromessa.

La soluzione migliore è, anziché utilizzare un algoritmo di offuscamento con una chiave fissa, per utilizzare una libreria di crittografia comprovata + un algoritmo con una chiave che è univoca per l'utente o il dispositivo su cui si sta eseguendo.