Renforcer la sécurité avec les règles de gestion des appareils

Abandon de l'administrateur d'appareils. Certaines règles d'administration ont été marquées comme obsolètes lorsqu'elles sont appelées par l'administrateur de l'appareil. Pour en savoir plus et voir les options de migration, consultez <ph type="x-smartling-placeholder"></ph> Abandon de l'administrateur d'appareils.

Depuis Android 2.2 (niveau d'API 8), la plate-forme Android offre une gestion des appareils au niveau du système. via les API Device Administration.

Dans cette leçon, vous apprendrez à créer une application axée sur la sécurité qui gère l'accès son contenu en appliquant des règles de gestion des appareils. Plus précisément, vous pouvez configurer l'application de sorte qu'un mot de passe de verrouillage d'écran d'un niveau de sécurité suffisant soit défini avant d'afficher soumis à restriction à l'utilisateur.

Définir et déclarer vos règles

Tout d'abord, vous devez définir les types de règles à prendre en charge au niveau fonctionnel. Les règles peuvent aborder le niveau de sécurité du mot de passe de verrouillage de l'écran, le délai d'expiration, le chiffrement, etc.

Vous devez déclarer l'ensemble de règles sélectionné, qui sera appliqué par l'application, dans le res/xml/device_admin.xml. Le fichier manifeste Android doit également référencer ensemble de règles déclarées.

Chaque règle déclarée correspond à un certain nombre de méthodes de règles relatives aux appareils associées dans DevicePolicyManager (qui définissent la longueur minimale du mot de passe et le nombre minimal les caractères majuscules sont deux exemples). Si une application tente d'appeler des méthodes dont la règle correspondante n'est pas déclarée dans le fichier XML, ce qui génère une SecurityException au moment de l'exécution. Autres autorisations, comme force-lock, sont disponibles si l'application a l'intention de gérer d'autres types de règles. Comme vous le verrez plus tard, dans le cadre du processus d'activation administrateur de l'appareil, la liste des règles déclarées est présentée à l'utilisateur sur un écran système.

L'extrait de code suivant déclare la règle de limite de mot de passe dans res/xml/device_admin.xml:

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

Fichier XML de déclaration de règles référencé dans le fichier manifeste 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>

Créer un récepteur d'administration des appareils

Créez un broadcast receiver qui recevra des notifications concernant les événements liés aux règles que vous avez déclarées comme prendre en charge. Une application peut remplacer les méthodes de rappel de manière sélective.

Dans l'exemple d'application "Device Admin" (Administration de l'appareil), lorsque l'administrateur de l'appareil est désactivé par la règle configurée est supprimée de la préférence partagée. Vous devriez envisager d'implémenter la logique métier adaptée à votre cas d'utilisation. Par exemple, l'application peut prendre pour atténuer les risques de sécurité en implémentant certaines combinaisons de suppression des données sensibles un appareil, la désactivation de la synchronisation à distance, l'alerte d'un administrateur, etc.

Pour que le broadcast receiver fonctionne, veillez à l'enregistrer dans le fichier manifeste Android, comme illustré dans l'extrait ci-dessus.

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

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

Activer l'administrateur de l'appareil

Avant d'appliquer une règle, l'utilisateur doit activer manuellement l'application en tant qu'appareil. administrateur. L'extrait de code ci-dessous montre comment déclencher l'activité de paramétrage dans laquelle le peut activer votre application. Il est recommandé d'inclure le texte explicatif pour mettre en évidence aux utilisateurs pourquoi l'application demande à être administrateur de l'appareil, en spécifiant le EXTRA_ADD_EXPLANATION supplémentaire dans l'intent.

Figure 1 : L'écran d'activation de l'utilisateur, fournir une description des règles relatives aux appareils.

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

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

Si l'utilisateur choisit « Activer », l'application devient administrateur de l'appareil et peut commencer sa configuration et son application.

L'application doit également être préparée à gérer les situations de retard lorsque l'utilisateur abandonne le processus d'activation en appuyant sur le bouton "Annuler", la touche "Retour" ou la touche "Accueil". Par conséquent, onResume() dans l'activité de configuration des règles doit avoir une logique de réévaluer la situation et de présenter l'option d'activation de l'administrateur de l'appareil à l'utilisateur si nécessaires.

Implémenter l'outil de contrôle des règles relatives aux appareils

Une fois l'administrateur de l'appareil activé, l'application configure l'Appareil le gestionnaire de règles avec la règle demandée. N'oubliez pas que de nouvelles règles sont ajoutées Android à chaque version. Il convient d'effectuer des vérifications des versions de votre application si vous utilisez de nouvelles règles tout en étant compatible avec les anciennes versions de la plate-forme. Par exemple, le minimum de mots de passe Les règles concernant les majuscules ne sont disponibles qu'à partir du niveau d'API 11 (Honeycomb). Le code suivant montre comment vérifier la version au moment de l'exécution.

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

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

À ce stade, l'application peut appliquer la règle. Tant que l'application n'a pas accès au mot de passe de verrouillage de l'écran utilisé, l'API Device Policy Manager peut déterminer si le mot de passe existant est conforme à la stratégie requise. S'il s'avère que les fichiers mot de passe de verrouillage de l'écran n'est pas suffisant, l'API d'administration des appareils ne prend pas automatiquement des mesures correctives. Il est de la responsabilité de l'application de lancer explicitement le système l'écran de modification du mot de passe de l'application Paramètres. Par exemple:

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

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

Normalement, l'utilisateur peut sélectionner l'un des mécanismes de verrouillage disponibles, par exemple "Aucun", "Schéma" Code (numérique) ou mot de passe (alphanumérique). Lorsqu'une règle relative aux mots de passe est configurée, les types qui sont plus faibles que ceux définis dans la stratégie sont désactivés. Par exemple, si le La qualité du mot de passe "numérique" est configurée, l'utilisateur peut sélectionner un code (numérique) ou un mot de passe mot de passe (alphanumérique) uniquement.

Une fois l'appareil correctement sécurisé en définissant un mot de passe de verrouillage de l'écran approprié, l'application permet d'accéder au contenu sécurisé.

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

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