Vulnerabilidades en el almacenamiento en caché de la clave ofuscada? Licencia de Android

Question

Estoy almacenando en caché la autenticación de un usuario cada vez que el servidor de ping de Licencias de Android Market devuelve un pong GRANT_ACCESS.

¿Alguien ve alguna vulnerabilidad con esta estrategia? Creo que es muy fuerte, ya que estoy ofuscando una tecla, y la única forma de desenfocarlo es conocer la sal. Ahora, alguien podría abrir el apk y buscar la sal, pero este no es realmente el nivel de agrietamiento que creo que es demasiado importante de lo que preocuparse.

Como puede ver, se está agregando información específica del dispositivo a la técnica de ofuscación.

// 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); 

A continuación, la creación de la datos persistentes:

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(); 
    } 

Entonces, he utilizado otro método para comprobar el estado del contenido almacenado en caché:

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; 
    } 
} 

Por último, he comprobado si isCachedLicens e en las siguientes ubicaciones de LicenseCheckerCallback: @Override dontAllow y @override applicationError. Si isCachedLicense es verdadero, entonces dejo que el usuario reenvíe.

Además, el código fuente completo se encuentra en here.

Answer 1

La ofuscación con sal generalmente es una estrategia débil. El atacante solo tiene que descubrir la sal, lo que es bastante fácil de hacer una vez que sepas lo que estás buscando, y se puede hacer sin acceso directo a tu aplicación. Una vez que la sal es descubierta (por cualquier persona), toda nuestra base de instalación se ha visto comprometida.

Su mejor opción es, en lugar de utilizar un algoritmo de ofuscación con una clave fija, usar una biblioteca de cifrado comprobada + algoritmo con una clave que sea exclusiva del usuario o del dispositivo en el que se está ejecutando.