Migliorare la sicurezza con i criteri di gestione dei dispositivi

Ritiro dell'amministrazione del dispositivo. Alcuni criteri amministrativi sono stati contrassegnati come deprecati quando sono stati richiamati da un amministratore del dispositivo. Per saperne di più e visualizzare le opzioni di migrazione, vedi Ritiro dell'amministrazione del dispositivo.

A partire da Android 2.2 (livello API 8), la piattaforma Android offre funzionalità di gestione dei dispositivi a livello di sistema tramite le API di amministrazione dei dispositivi.

In questa lezione imparerai a creare un'applicazione sensibile alla sicurezza che gestisce l'accesso ai suoi contenuti applicando criteri di gestione dei dispositivi. Nello specifico, l'applicazione può essere configurata in modo da garantire che venga impostata una password di blocco schermo di sicurezza sufficiente prima di mostrare all'utente contenuti con restrizioni.

Definisci e dichiara il tuo criterio

Innanzitutto, devi definire i tipi di criteri da supportare a livello funzionale. I criteri possono coprire la sicurezza della password del blocco schermo, il timeout per la scadenza, la crittografia e così via.

Devi dichiarare il set di criteri selezionato, che verrà applicato in modo forzato dall'applicazione, nel file res/xml/device_admin.xml. Il file manifest Android deve anche fare riferimento al set di criteri dichiarato.

Ogni criterio dichiarato corrisponde a un certo numero di metodi dei criteri relativi ai dispositivi correlati in DevicePolicyManager (la definizione di lunghezza minima della password e il numero minimo di caratteri maiuscoli sono due esempi). Se un'applicazione tenta di richiamare metodi il cui criterio corrispondente non è dichiarato nel codice XML, verrà restituito un SecurityException in fase di runtime. Se l'applicazione intende gestire altri tipi di criteri, sono disponibili altre autorizzazioni, ad esempio force-lock. Come vedrai più avanti, nell'ambito della procedura di attivazione dell'amministratore del dispositivo, l'elenco dei criteri dichiarati verrà presentato all'utente su uno schermo di sistema.

Lo snippet seguente dichiara il criterio relativo alla limitazione delle password in res/xml/device_admin.xml:

<device-admin xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-policies>
        <limit-password />
    </uses-policies>
</device-admin>

XML della dichiarazione dei criteri a cui viene fatto riferimento nel file manifest Android:

<receiver android:name=".Policy$PolicyAdmin"
    android:permission="android.permission.BIND_DEVICE_ADMIN">
    <meta-data android:name="android.app.device_admin"
        android:resource="@xml/device_admin" />
    <intent-filter>
        <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
    </intent-filter>
</receiver>

Crea un ricevitore per l'amministrazione del dispositivo

Crea un ricevitore di trasmissione per l'amministrazione dei dispositivi, che riceve notifiche sugli eventi relativi ai criteri che hai dichiarato di supportare. Un'applicazione può eseguire l'override selettivo dei metodi di callback.

Nell'applicazione di esempio, Amministratore dispositivo, quando l'amministratore del dispositivo viene disattivato dall'utente, il criterio configurato viene cancellato dalla preferenza condivisa. Valuta l'implementazione di una logica di business pertinente al tuo caso d'uso. Ad esempio, l'applicazione potrebbe intraprendere alcune azioni per ridurre i rischi per la sicurezza implementando alcune combinazioni di eliminazione di dati sensibili sul dispositivo, disattivazione della sincronizzazione remota, avviso a un amministratore e così via.

Affinché il ricevitore della trasmissione funzioni, assicurati di registrarlo nel file manifest Android, come illustrato nello snippet riportato sopra.

Kotlin

class PolicyAdmin : DeviceAdminReceiver() {

    override fun onDisabled(context: Context, intent: Intent) {
        // Called when the app is about to be deactivated as a device administrator.
        // Deletes previously stored password policy.
        super.onDisabled(context, intent)
        context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE).edit().apply {
            clear()
            apply()
        }
    }
}

Java

public static class PolicyAdmin extends DeviceAdminReceiver {

    @Override
    public void onDisabled(Context context, Intent intent) {
        // Called when the app is about to be deactivated as a device administrator.
        // Deletes previously stored password policy.
        super.onDisabled(context, intent);
        SharedPreferences prefs = context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE);
        prefs.edit().clear().commit();
    }
}

Attivare l'amministratore del dispositivo

Prima di applicare qualsiasi criterio, l'utente deve attivare manualmente l'applicazione come amministratore del dispositivo. Lo snippet riportato di seguito illustra come attivare l'attività delle impostazioni in cui l'utente può attivare l'applicazione. È buona norma includere il testo esplicativo per evidenziare per gli utenti perché l'applicazione richiede il ruolo di amministratore del dispositivo, specificando l'elemento aggiuntivo EXTRA_ADD_EXPLANATION nell'intent.

Figura 1. La schermata di attivazione utente in cui puoi fornire una descrizione dei criteri relativi ai dispositivi.

Kotlin

if (!policy.isAdminActive()) {

    val activateDeviceAdminIntent = Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN)

    activateDeviceAdminIntent.putExtra(
            DevicePolicyManager.EXTRA_DEVICE_ADMIN,
            policy.getPolicyAdmin()
    )

    // It is good practice to include the optional explanation text to
    // explain to user why the application is requesting to be a device
    // administrator. The system will display this message on the activation
    // screen.
    activateDeviceAdminIntent.putExtra(
            DevicePolicyManager.EXTRA_ADD_EXPLANATION,
            resources.getString(R.string.device_admin_activation_message)
    )

    startActivityForResult(activateDeviceAdminIntent, REQ_ACTIVATE_DEVICE_ADMIN)
}

Java

if (!policy.isAdminActive()) {

    Intent activateDeviceAdminIntent =
        new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);

    activateDeviceAdminIntent.putExtra(
        DevicePolicyManager.EXTRA_DEVICE_ADMIN,
        policy.getPolicyAdmin());

    // It is good practice to include the optional explanation text to
    // explain to user why the application is requesting to be a device
    // administrator. The system will display this message on the activation
    // screen.
    activateDeviceAdminIntent.putExtra(
        DevicePolicyManager.EXTRA_ADD_EXPLANATION,
        getResources().getString(R.string.device_admin_activation_message));

    startActivityForResult(activateDeviceAdminIntent,
        REQ_ACTIVATE_DEVICE_ADMIN);
}

Se l'utente sceglie "Attiva", l'applicazione diventa un amministratore del dispositivo e può iniziare a configurare e applicare il criterio.

L'applicazione deve inoltre essere preparata a gestire le situazioni di riduzione in cui l'utente abbandona il processo di attivazione premendo il pulsante Annulla, il tasto Indietro o il tasto Home. Di conseguenza, onResume() nell'attività di configurazione dei criteri deve disporre di una logica per rivalutare la condizione e, se necessario, presentare all'utente l'opzione di attivazione amministratore dispositivo.

Implementare il controller dei criteri dei dispositivi

Una volta attivato l'amministratore del dispositivo, l'applicazione configura Gestione criteri dei dispositivi con il criterio richiesto. Tieni presente che a ogni release vengono aggiunti nuovi criteri ad Android. È appropriato eseguire controlli della versione nell'applicazione se utilizzi nuovi criteri e supporti le versioni precedenti della piattaforma. Ad esempio, il criterio Maiuscole minime della password è disponibile solo con il livello API 11 (Honeycomb) e versioni successive. Il codice seguente mostra come controllare la versione in fase di runtime.

Kotlin

private lateinit var dpm: DevicePolicyManager
private lateinit var policyAdmin: ComponentName

dpm = context.getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager
policyAdmin = ComponentName(context, PolicyAdmin::class.java)

dpm.apply {
    setPasswordQuality(policyAdmin, PASSWORD_QUALITY_VALUES[passwordQuality])
    setPasswordMinimumLength(policyAdmin, passwordLength)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        setPasswordMinimumUpperCase(policyAdmin, passwordMinUpperCase)
    }
}

Java

DevicePolicyManager dpm = (DevicePolicyManager)
        context.getSystemService(Context.DEVICE_POLICY_SERVICE);
ComponentName policyAdmin = new ComponentName(context, PolicyAdmin.class);

dpm.setPasswordQuality(policyAdmin, PASSWORD_QUALITY_VALUES[passwordQuality]);
dpm.setPasswordMinimumLength(policyAdmin, passwordLength);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    dpm.setPasswordMinimumUpperCase(policyAdmin, passwordMinUpperCase);
}

A questo punto, l'applicazione è in grado di applicare il criterio. Sebbene l'applicazione non abbia accesso all'effettiva password di blocco schermo utilizzata, tramite l'API Device Policy Manager può determinare se la password esistente soddisfa il criterio richiesto. Se la password di blocco schermo esistente non è sufficiente, l'API Device Administration non intraprende automaticamente azioni correttive. È responsabilità dell'applicazione avviare esplicitamente la schermata di modifica della password di sistema nell'app Impostazioni. Ad esempio:

Kotlin

if (!dpm.isActivePasswordSufficient) {
    // Triggers password change screen in Settings.
    Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD).also { intent ->
        startActivity(intent)
    }
}

Java

if (!dpm.isActivePasswordSufficient()) {
    ...
    // Triggers password change screen in Settings.
    Intent intent =
        new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
    startActivity(intent);
}

Normalmente, l'utente può selezionare uno dei meccanismi di blocco disponibili, ad esempio Nessuno, Sequenza, PIN (numerico) o Password (alfanumerica). Quando viene configurato un criterio per le password, i tipi di password più deboli di quelli definiti nel criterio vengono disattivati. Ad esempio, se è configurata la password "numerica", l'utente può selezionare solo la password PIN (numerica) o Password (alfanumerica).

Una volta che il dispositivo è stato protetto correttamente impostando una password di blocco schermo appropriata, l'applicazione consente l'accesso ai contenuti protetti.

Kotlin

when {
    !dpm.isAdminActive(policyAdmin) -> {
        // Activates device administrator.
        ...
    }
    !dpm.isActivePasswordSufficient -> {
        // Launches password set-up screen in Settings.
        ...
    }
    else -> {
        // Grants access to secure content.
        ...
        startActivity(Intent(context, SecureActivity::class.java))
    }
}

Java

if (!dpm.isAdminActive(..)) {
    // Activates device administrator.
    ...
} else if (!dpm.isActivePasswordSufficient()) {
    // Launches password set-up screen in Settings.
    ...
} else {
    // Grants access to secure content.
    ...
    startActivity(new Intent(context, SecureActivity.class));
}