Les fonctionnalités présentées dans ce guide décrivent les fonctionnalités de gestion de la sécurité que vous pouvez mettre en œuvre dans votre application d'outil de contrôle des règles relatives aux appareils (DPC). Ce document contient des exemples de code. Vous pouvez également utiliser l'application Test DPC en tant que une source d'exemple de code pour les fonctionnalités d'entreprise d'Android.
Une application DPC peut s'exécuter en mode propriétaire de profil sur des appareils personnels ou en mode propriétaire de l'appareil sur les appareils entièrement gérés. Ce tableau présente les fonctionnalités disponibles Lorsque l'outil DPC s'exécute en mode propriétaire du profil ou en mode propriétaire de l'appareil:
Désactiver l'accès aux applications
Pour les organisations qui souhaitent empêcher les employés de jouer ou de regarder à utiliser YouTube sur leur appareil Android à certaines heures de la journée ; certains jours de la semaine, un DPC peut désactiver temporairement l'accès aux applications.
Pour désactiver l'accès aux applications, un DPC s'exécutant en mode propriétaire de l'appareil ou propriétaire du profil
configure setPackagesSuspended()
, puis l'application sélectionnée se comporte comme si
elle est désactivée (le lanceur d'applications Google fait apparaître l'application en grisé). Lorsqu'un utilisateur appuie sur l'application,
une boîte de dialogue système
indique que l'application est suspendue.
Lorsqu'une application est suspendue, elle ne peut pas démarrer d'activités et l'envoi de notifications à packages sont supprimés. Les packages suspendus n'apparaissent pas dans la vue d'ensemble. écran, ils ne peuvent pas afficher de boîtes de dialogue (y compris les toasts et les snackbars) et l'appareil ne peut pas lire de contenu audio ni le faire vibrer.
Les lanceurs d'applications peuvent savoir si une application est suspendue en appelant la méthode
isPackageSuspended()
. Pour savoir comment configurer une application
suspension, consultez setPackagesSuspended
.
Bloquer les applications provenant de sources inconnues
Les applications qui ne sont pas installées depuis Google Play (ou d'autres plates-formes de téléchargement d'applications de confiance) appelés applications provenant de sources inconnues. Risque accru sur les appareils et les données lorsqu'ils installent ces applications.
Pour empêcher quiconque d'installer des applications provenant de sources inconnues, les composants d'administration de
les appareils entièrement gérés et les profils professionnels peuvent ajouter
Restriction utilisateur DISALLOW_INSTALL_UNKNOWN_SOURCES
.
Restriction à l'échelle de l'appareil associée au profil professionnel
Lorsque l'administrateur d'un profil professionnel ajoute DISALLOW_INSTALL_UNKNOWN_SOURCES
:
la restriction ne s'applique qu'au profil professionnel. Toutefois, l'administrateur d'une
profil peut appliquer une restriction à l'échelle de l'appareil en définissant
configuration gérée pour Google Play. La restriction au niveau de l'appareil
disponible sur Android 8.0 (ou version ultérieure) lorsque l'application Google Play installée est
version 80812500 ou ultérieure.
Pour limiter les installations d'applications à Google Play, procédez comme suit:
- Définir un bundle de configuration gérée pour le package Google Play
com.android.vending
- Dans le groupe, indiquez une valeur booléenne pour le paramètre
Clé
verify_apps:device_wide_unknown_source_block
. - Ajoutez la restriction utilisateur
ENSURE_VERIFY_APPS
.
L'exemple suivant montre comment vérifier que Google Play prend en charge ce
et définissez sa valeur sur true
:
Kotlin
internal val DEVICE_WIDE_UNKNOWN_SOURCES = "verify_apps:device_wide_unknown_source_block" internal val GOOGLE_PLAY_APK = "com.android.vending" // ... // Add the setting to Google Play's existing managed config. Supported in // Google Play version 80812500 or higher--older versions ignore unsupported // settings. val dpm = context.getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager var existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK) val newConfig = Bundle(existingConfig) newConfig.putBoolean(DEVICE_WIDE_UNKNOWN_SOURCES, true) dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig) // Make sure that Google Play Protect verifies apps. dpm.addUserRestriction(adminName, UserManager.ENSURE_VERIFY_APPS) dpm.addUserRestriction(adminName, UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES)
Java
static final String DEVICE_WIDE_UNKNOWN_SOURCES = "verify_apps:device_wide_unknown_source_block"; static final String GOOGLE_PLAY_APK = "com.android.vending"; // ... // Add the setting to Google Play's existing managed config. Supported in // Google Play version 80812500 or higher--older versions ignore unsupported // settings. DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE); Bundle existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK); Bundle newConfig = new Bundle(existingConfig); newConfig.putBoolean(DEVICE_WIDE_UNKNOWN_SOURCES, true); dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig); // Make sure that Google Play Protect verifies apps. dpm.addUserRestriction(adminName, UserManager.ENSURE_VERIFY_APPS); dpm.addUserRestriction(adminName, UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES);
L'interface utilisateur dans les paramètres système reste active, mais le système se bloque l'installation d'applications. Cette restriction affecte les futures installations les applications installées restent sur l'appareil. Les utilisateurs d'appareils peuvent continuer à installer des applis au profil personnel à l'aide d'Android Debug Bridge (adb).
Pour en savoir plus sur les sources inconnues, consultez Autres distributions options.
Limiter les comptes dans Google Play
Parfois, une organisation peut souhaiter autoriser des utilisateurs à ajouter des comptes Google Comptes (pour lire les e-mails dans Gmail, par exemple), mais qui ne veulent pas pour installer des applications. Votre DPC peut définir une liste de comptes que les personnes peuvent utiliser dans Google Play.
Les composants d'administration d'appareils entièrement gérés ou de profils professionnels peuvent limiter en définissant une configuration gérée pour Google Play. Le compte est disponible lorsque l'application Google Play installée est à la version 80970100 ou supérieur.
Pour limiter les comptes dans Google Play, procédez comme suit:
- Définir un bundle de configuration gérée pour le package Google Play
com.android.vending
- Dans le groupe, saisissez les adresses e-mail séparées par une virgule en tant que valeur de chaîne pour
la clé
allowed_accounts
.
L'exemple suivant montre comment limiter des comptes:
Kotlin
internal val ALLOWED_ACCOUNTS = "allowed_accounts" internal val GOOGLE_PLAY_APK = "com.android.vending" // ... // Limit Google Play to one work and one personal account. Use // a comma-separated list of account email addresses (usernames). val googleAccounts = "ali@gmail.com,ali.connors@example.com" // Supported in Google Play version 80970100 or higher. val existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK) val newConfig = Bundle(existingConfig) newConfig.putString(ALLOWED_ACCOUNTS, googleAccounts) dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig)
Java
static final String ALLOWED_ACCOUNTS = "allowed_accounts"; static final String GOOGLE_PLAY_APK = "com.android.vending"; // ... // Limit Google Play to one work and one personal account. Use // a comma-separated list of account email addresses (usernames). String googleAccounts = "ali@gmail.com,ali.connors@example.com"; // Supported in Google Play version 80970100 or higher. Bundle existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK); Bundle newConfig = new Bundle(existingConfig); newConfig.putString(ALLOWED_ACCOUNTS, googleAccounts); dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig);
Pour limiter Google Play au seul compte professionnel, définissez allowed_accounts
sur
compte géré unique dès que votre DPC connaît l'adresse e-mail du compte. Une
Une chaîne vide empêche les utilisateurs d'utiliser un compte sur Google Play.
Activer la protection après rétablissement de la configuration d'usine de l'entreprise
Grâce à la protection après rétablissement de la configuration d'usine, les entreprises peuvent spécifier Les comptes Google peuvent provisionner un appareil dont la configuration d'usine a été rétablie.
La protection après rétablissement de la configuration d'usine du client est conçue pour dissuader le vol de l'appareil. Avant permettant à quiconque de provisionner l'appareil après une réinitialisation non autorisée que l'utilisation d'un fournisseur EMM), l'assistant de configuration demande à l'utilisateur de s'authentifier auprès de Comptes Google qui figuraient auparavant sur le profil personnel de l'appareil
Dans un environnement d'entreprise, le rétablissement de la configuration d'usine est un outil important pour gérer les appareils des employés lorsqu'ils quittent l'organisation. Toutefois, si le ne connaît pas les identifiants du compte d'un employé, peut empêcher l'organisation de transmettre un appareil un employé.
Contrôler le provisionnement après une réinitialisation
Lorsqu'il s'exécute en mode propriétaire de l'appareil, votre DPC peut utiliser
setFactoryResetProtectionPolicy()
pour contrôler les comptes
autorisé à provisionner un appareil après une réinitialisation. Si cette configuration
est définie sur null
ou définie sur une liste vide, les comptes autorisés à provisionner
un appareil après une réinitialisation selon les paramètres d'usine, sont les comptes figurant dans le profil personnel
appareil.
Un DPC peut configurer ces comptes tout au long de la durée de vie d'un compte appareil.
- L'administrateur informatique peut utiliser la méthode
people.get
de l'API People avec la valeur spécialeme
. Cette opération récupère lesuserId
pour connecté à un compte. LeuserID
est renvoyé dans la cléresourceName
dans au formatpeople/[userId]
, sous la forme d'une chaîne entière. Les comptes nouvellement créés ne sera pas disponible pour rétablir la configuration d'usine pendant 72 heures. - Vous pouvez également autoriser un ou plusieurs administrateurs informatiques à déverrouiller l'appareil après
rétablir la configuration d'usine. Demandez à chacun de ces administrateurs informatiques
de se connecter à leur compte Google et
Suivez également l'étape 1 et partagez leurs
userId
avec vous, afin que vous puissiez ajouter ces élémentsuserIds
à la liste à l'étape suivante. - Le DPC définit une restriction d'application appropriée en utilisant
setFactoryResetProtectionPolicy()
pour définir la liste desuserId
pouvant de provisionner un appareil rétabli à la configuration d'usine. - Le DPC permet aux comptes autorisés à provisionner des appareils après une usine
réinitialisé en envoyant la diffusion
com.google.android.gms.auth.FRP_CONFIG_CHANGED
comme intent explicite empêcher l'abandon en raison de restrictions d'arrière-plan.
Kotlin
const val ACTION_FRP_CONFIG_CHANGED = "com.google.android.gms.auth.FRP_CONFIG_CHANGED" const val GMSCORE_PACKAGE = "com.google.android.gms" // ... // List of userId that can provision a factory reset device. // You can use the value returned calling people/me endpoint. val accountIds = listOf("000000000000000000000") dpm.setFactoryResetProtectionPolicy( adminName, FactoryResetProtectionPolicy.Builder() .setFactoryResetProtectionAccounts(accountIds) .setFactoryResetProtectionEnabled(true) .build() ) val frpChangedIntent = Intent(ACTION_FRP_CONFIG_CHANGED) frpChangedIntent.setPackage(GMSCORE_PACKAGE) context.sendBroadcast(frpChangedIntent)
Java
static final String ACTION_FRP_CONFIG_CHANGED = "com.google.android.gms.auth.FRP_CONFIG_CHANGED"; static final String GMSCORE_PACKAGE = "com.google.android.gms"; // ... // List of userId that can provision a factory reset device. // You can use the value returned calling people/me endpoint. List<String> accountIds = new ArrayList<String>(); accountIds.add("000000000000000000000"); dpm.setFactoryResetProtectionPolicy( adminName, new FactoryResetProtectionPolicy.Builder() .setFactoryResetProtectionAccounts(accountIds) .setFactoryResetProtectionEnabled(true) .build()); Intent frpChangedIntent = new Intent(ACTION_FRP_CONFIG_CHANGED); frpChangedIntent.setPackage(GMSCORE_PACKAGE); context.sendBroadcast(frpChangedIntent);
Legacy
Pour les appareils qui ne peuvent pas utiliser setFactoryResetProtectionPolicy()
, introduit avec
Niveau d'API 30, votre DPC peut utiliser setApplicationRestrictions
pour ajouter
les comptes sélectionnés vers la configuration gérée factoryResetProtectionAdmin
pour le package com.google.android.gms
.
Kotlin
const val GOOGLE_PLAY_APK = "com.android.vending" const val FACTORY_RESET_PROTECTION_ADMIN = "factoryResetProtectionAdmin" const val DISABLE_FACTORY_RESET_PROTECTION_ADMIN = "disableFactoryResetProtectionAdmin" const val GMSCORE_PACKAGE = "com.google.android.gms" // ... val existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK) val newConfig = Bundle(existingConfig) newConfig.putBoolean(DISABLE_FACTORY_RESET_PROTECTION_ADMIN, false) newConfig.putString(FACTORY_RESET_PROTECTION_ADMIN, googleAccounts) dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig) val frpChangedIntent = Intent(ACTION_FRP_CONFIG_CHANGED) frpChangedIntent.setPackage(GMSCORE_PACKAGE) context.sendBroadcast(frpChangedIntent)
Java
static final String GOOGLE_PLAY_APK = "com.android.vending"; static final String FACTORY_RESET_PROTECTION_ADMIN = "factoryResetProtectionAdmin"; static final String DISABLE_FACTORY_RESET_PROTECTION_ADMIN = "disableFactoryResetProtectionAdmin"; static final String GMSCORE_PACKAGE = "com.google.android.gms"; // ... Bundle existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK); Bundle newConfig = new Bundle(existingConfig); newConfig.putBoolean(DISABLE_FACTORY_RESET_PROTECTION_ADMIN, false); newConfig.putStringArray(FACTORY_RESET_PROTECTION_ADMIN, accountIds.toArray(new String[accountIds.size()])); dpm.setApplicationRestrictions(adminName, GOOGLE_PLAY_APK, newConfig); Intent frpChangedIntent = new Intent(ACTION_FRP_CONFIG_CHANGED); frpChangedIntent.setPackage(GMSCORE_PACKAGE); context.sendBroadcast(frpChangedIntent);
Désactiver la protection après rétablissement de la configuration d'usine de l'entreprise
Pour désactiver la protection après rétablissement de la configuration d'usine, votre DPC peut utiliser
setFactoryResetProtectionPolicy()
en transmettant la valeur null
.
Kotlin
const val ACTION_FRP_CONFIG_CHANGED = "com.google.android.gms.auth.FRP_CONFIG_CHANGED" const val GMSCORE_PACKAGE = "com.google.android.gms" // ... dpm.setFactoryResetProtectionPolicy(adminName, null) val frpChangedIntent = Intent(ACTION_FRP_CONFIG_CHANGED) frpChangedIntent.setPackage(GMSCORE_PACKAGE) context.sendBroadcast(frpChangedIntent)
Java
static final String ACTION_FRP_CONFIG_CHANGED = "com.google.android.gms.auth.FRP_CONFIG_CHANGED"; static final String GMSCORE_PACKAGE = "com.google.android.gms"; // ... dpm.setFactoryResetProtectionPolicy(adminName, null); Intent frpChangedIntent = new Intent(ACTION_FRP_CONFIG_CHANGED); frpChangedIntent.setPackage(GMSCORE_PACKAGE); context.sendBroadcast(frpChangedIntent);
Legacy
Pour les appareils qui ne peuvent pas utiliser setFactoryResetProtectionPolicy()
, introduit avec
Niveau d'API 30, votre DPC peut utiliser setApplicationRestrictions
pour définir une clé
de true
dans l'environnement disableFactoryResetProtectionAdmin
géré
pour le package com.google.android.gms
.
Kotlin
const val GOOGLE_PLAY_APK = "com.android.vending" const val FACTORY_RESET_PROTECTION_ADMIN = "factoryResetProtectionAdmin" const val DISABLE_FACTORY_RESET_PROTECTION_ADMIN = "disableFactoryResetProtectionAdmin" const val GMSCORE_PACKAGE = "com.google.android.gms" // ... val existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK) val newConfig = Bundle(existingConfig) newConfig.putBoolean(DISABLE_FACTORY_RESET_PROTECTION_ADMIN, true) dpm.setApplicationRestrictions( adminName, GOOGLE_PLAY_SERVICES_PACKAGE, restrictions ) val frpChangedIntent = Intent(ACTION_FRP_CONFIG_CHANGED) frpChangedIntent.setPackage(GMSCORE_PACKAGE) context.sendBroadcast(frpChangedIntent)
Java
static final String GOOGLE_PLAY_APK = "com.android.vending"; static final String FACTORY_RESET_PROTECTION_ADMIN = "factoryResetProtectionAdmin"; static final String DISABLE_FACTORY_RESET_PROTECTION_ADMIN = "disableFactoryResetProtectionAdmin"; static final String GMSCORE_PACKAGE = "com.google.android.gms"; // ... Bundle existingConfig = dpm.getApplicationRestrictions(adminName, GOOGLE_PLAY_APK); Bundle newConfig = new Bundle(existingConfig); newConfig.putBoolean(DISABLE_FACTORY_RESET_PROTECTION_ADMIN, true); dpm.setApplicationRestrictions( adminName, GOOGLE_PLAY_SERVICES_PACKAGE, restrictions); Intent frpChangedIntent = new Intent(ACTION_FRP_CONFIG_CHANGED); frpChangedIntent.setPackage(GMSCORE_PACKAGE); context.sendBroadcast(frpChangedIntent);
Surveiller les journaux des processus d'entreprise et les rapports de bugs à distance
Dans votre console EMM, un administrateur peut surveiller les appareils entièrement gérés via des de traiter les journaux et les rapports de bogues distants.
Enregistrer l'activité des appareils de l'entreprise
Un DPC exécuté en mode propriétaire de l'appareil peut identifier une activité suspecte à distance Suivre l'activité de l'appareil, y compris les lancements d'applis, Android Debug Bridge (adb) l'activité et les déverrouillages de l'écran. Les journaux de processus ne nécessitent pas le consentement de l'utilisateur.
Pour activer ou désactiver la journalisation, un DPC appelle setSecurityLoggingEnabled()
.
Lorsqu'un nouveau lot de journaux est disponible, un DeviceAdminReceiver
reçoit le
Rappel onSecurityLogsAvailable()
. Pour récupérer les journaux (après
réception du rappel), un DPC appelle retrieveSecurityLogs()
.
Les DPC peuvent également appeler retrievePreRebootSecurityLogs()
pour récupérer la sécurité
les journaux générés lors du précédent cycle de redémarrage. Il s'agit de l'intervalle entre
le dernier redémarrage de l'appareil et le précédent. Appareils non compatibles
retrieveSecurityLogs()
renvoie null
. Si votre application récupère les journaux à l'aide des deux
retrievePreRebootSecurityLogs()
et retrieveSecurityLogs()
, vous devez :
rechercher les
entrées en double.
Remarque: Cette fonctionnalité enregistre uniquement l'activité sur les appareils entièrement gérés disposant d'un seul
ou des utilisateurs affiliés sur l'appareil. Cette fonctionnalité n'est pas disponible sur
les appareils personnels, car elle enregistre l'activité au niveau de l'appareil.
Ce paramètre peut être utile pour l'audit post-événement de sécurité, car il consigne types d'actions suivants:
- Chaque fois que l'application est lancée récemment. Cela pourrait aider à identifier s'il y a les logiciels malveillants commençant par une application compromise.
- Tentatives de déverrouillage infructueuses sur un appareil. Cela pourrait permettre d'identifier s'il y a plusieurs tentatives de déverrouillage infructueuses en peu de temps.
- Commandes adb potentiellement dangereuses lorsqu'un utilisateur se connecte l'appareil à un ordinateur à l'aide d'un câble USB.
Pour en savoir plus sur la lecture des journaux, consultez SecurityLog
.
Pendant le développement et le test, vous pouvez forcer le système les journaux de sécurité existants disponibles pour votre DPC, vous n'avez pas à attendre par lot. Sous Android 9.0 (niveau d'API 28) ou version ultérieure, exécutez la commande suivante : Android Debug Bridge (adb) dans votre terminal:
adb shell dpm force-security-logs
Le système limite la fréquence d'utilisation de l'outil et signale les
un ralentissement intentionnel
de la sortie du terminal. Si des journaux sont disponibles,
Le DPC reçoit le rappel onSecurityLogsAvailable()
.
Demander un rapport de bug à distance
Un DPC exécuté en mode propriétaire de l'appareil peut demander à distance des rapports de bug à l'utilisateur appareils avec un seul utilisateur ou des utilisateurs affiliés. Le rapport de bug capture l'activité de l'appareil au moment exact où le rapport de bug est demandé, mais il peut aussi incluent l'activité des dernières heures, en fonction de la fréquence à laquelle le tampon est actualisé.
Pour demander à distance des rapports de bug, l'outil DPC appelle requestBugreport()
:
- Si un utilisateur accepte de partager le rapport de bug, le DPC reçoit le bug
créer un rapport à l'aide de
onBugreportShared()
- Si un utilisateur refuse le partage du rapport de bug, le DPC reçoit une notification
de requête refusée avec
onBugreportSharingDeclined()
- Si le rapport de bug échoue, le DPC voit
onBugreportFailed()
avecBUGREPORT_FAILURE_FAILED_COMPLETING
ouBUGREPORT_FAILURE_FILE_NO_LONGER_AVAILABLE
Accorder et supprimer l'accès à un certificat client
Si un DPC exécuté en mode propriétaire du profil ou propriétaire de l'appareil accorde une application tierce
gérer les certificats, l'application peut s'accorder l'accès
et les certificats qu'il installe sans l'intervention d'un utilisateur. Pour installer un
un certificat auquel toutes les applications d'un profil peuvent accéder, utilisez installKeyPair()
.
Pour connaître les paramètres à configurer, consultez installKeyPair()
. Cette fonctionnalité
fonctionne avec l'API existante pour gérer les certificats.
Scénario de déploiement
Sans la méthode installKeyPair()
:
- Les utilisateurs doivent appuyer sur le nom du certificat, puis sur Autoriser à chaque fois. il veut accorder l’accès à un certificat.
- Les utilisateurs voient une invite lorsqu'ils installent un certificat et doivent nommer le certificat.
Avec la méthode installKeyPair()
:
- Les utilisateurs n'ont pas besoin d'appuyer sur Autoriser chaque fois qu'ils souhaitent accorder l'accès à certificat.
- Les utilisateurs ne peuvent pas renommer les certificats.
- Les administrateurs ont plus de contrôle, car ils peuvent bloquer les certificats pour des applications qui ne devraient pas avoir accès à des certificats spécifiques.
Supprimer un certificat client
Après avoir accordé l'accès à un certificat client, pour supprimer à distance le client
certificats installés via installKeyPair()
, appelez
removeKeyPair()
Un DPC s'exécutant en mode propriétaire de l'appareil ou en mode propriétaire du profil, ou délégué
Le programme d'installation du certificat peut appeler removeKeyPair()
. Cela supprime
de clé privée et de certificat installée
sous un alias de clé privée donné.
Scénario de déploiement
Utilisez cette fonctionnalité si une entreprise migre vers un type de client plus sécurisé certificat. Si un administrateur déploie un nouveau certificat et sa distribution prend beaucoup de temps, l'administrateur peut révoquer le certificat certificats après la migration.
Réinitialisation du code secret sécurisé
Votre DPC peut réinitialiser le mot de passe d'un utilisateur en autorisant la modification avec un
préenregistré et sécurisé. Les propriétaires d'appareils et de profils peuvent appeler des numéros sécurisés
API de réinitialisation de code secret pour modifier le mot de passe des appareils et des profils professionnels
respectivement. La réinitialisation d'un code secret sécurisé remplace resetPassword()
par le
améliorations suivantes:
- Votre DPC peut réinitialiser le code secret avant que l'utilisateur déverrouille l'appareil ou le profil. après un redémarrage sur les appareils chiffrement basé sur les fichiers.
- Android Keystore conserve les clés authentifiées par l'utilisateur. après la réinitialisation d'un code secret.
Vous devez utiliser la réinitialisation du code secret sécurisé si le build de votre DPC cible Android 8.0 (API
niveau 26) ou supérieur. L'appel de resetPassword()
génère une
SecurityException
dans les DPC ciblant Android 8.0 ou version ultérieure. Vous pourriez donc
mettre à jour votre DPC.
Définir et activer un jeton
Votre DPC doit définir et activer un jeton avant de réinitialiser un mot de passe. En effet, votre DPC pourrait ne pas être en mesure d'utiliser le jeton tout de suite, vous définissez le jeton avant qu'un administrateur informatique ait besoin de l'utiliser.
Un jeton de réinitialisation de mot de passe est une valeur aléatoire cryptographiquement forte et doit comporter au moins 32 octets. Créez un jeton pour chaque appareil et profil ; ne le faites pas réutiliser ou partager vos jetons générés.
Nous vous recommandons de stocker les jetons, c'est-à-dire les moyens de déchiffrer les jetons chiffrés, sur un Google Cloud. Si vous stockez des jetons localement dans un espace de stockage chiffré par identifiants, votre DPC ne peut pas réinitialiser le mot de passe tant que l'utilisateur n'a pas déverrouillé l'appareil ou le profil. Si vous stocker les jetons localement dans le stockage chiffré de l’appareil, qui est compromis, un pirate informatique peut utiliser le jeton pour accéder à un profil professionnel ou à une adresse utilisateur.
Vous pouvez générer un nouveau jeton dans votre DPC ou récupérer un jeton sur un serveur. La l'exemple ci-dessous montre un DPC qui génère lui-même un jeton et le signale à un serveur:
Kotlin
val token = ByteArray(32) // Generate a new token val random = SecureRandom() random.nextBytes(token) // Set the token to use at a later date val success: Boolean success = dpm.setResetPasswordToken(DeviceAdminReceiver.getComponentName(context), token) // Activate the token and update success variable... // Store the token on a server if (success) { sendTokenToServer(token) }
Java
byte token[] = new byte[32]; // Minimum size token accepted // Generate a new token SecureRandom random = new SecureRandom(); random.nextBytes(token); // Set the token to use at a later date boolean success; success = dpm.setResetPasswordToken(DeviceAdminReceiver.getComponentName(getContext()), token); // Activate the token and update success variable ... // Store the token on a server if (success) { sendTokenToServer(token); }
Dans la plupart des cas, votre DPC doit activer un jeton après l'avoir défini. Mais, quand
l'utilisateur n'a pas de mot de passe d'écran de verrouillage, le système active un jeton
tout de suite. Pour activer un jeton, demandez à l'utilisateur de confirmer ses identifiants.
Votre DPC peut appeler la méthode KeyguardManager
createConfirmDeviceCredentialIntent()
pour obtenir un Intent
qui lance le
confirmation. Expliquez à l'utilisateur de l'appareil dans l'interface utilisateur pourquoi vous
de s'authentifier. L'extrait ci-dessous montre comment activer
dans votre DPC:
Kotlin
// In your DPC, you'll need to localize the user prompt val ACTIVATE_TOKEN_PROMPT = "Use your credentials to enable remote password reset" val ACTIVATE_TOKEN_REQUEST = 1 // Create or fetch a token and set it in setResetPasswordToken() ... val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager val confirmIntent = keyguardManager.createConfirmDeviceCredentialIntent(null, ACTIVATE_TOKEN_PROMPT) if (confirmIntent != null) { startActivityForResult(confirmIntent, ACTIVATE_TOKEN_REQUEST) // Check your onActivityResult() callback for RESULT_OK } else { // Null means the user doesn't have a lock screen so the token is already active. // Call isResetPasswordTokenActive() if you need to confirm }
Java
// In your DPC, you'll need to localize the user prompt static final String ACTIVATE_TOKEN_PROMPT = "Use your credentials to enable remote password reset"; static final int ACTIVATE_TOKEN_REQUEST = 1; // Create or fetch a token and set it in setResetPasswordToken() ... KeyguardManager keyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); Intent confirmIntent = keyguardManager.createConfirmDeviceCredentialIntent( null, ACTIVATE_TOKEN_PROMPT); if (confirmIntent != null) { startActivityForResult(confirmIntent, ACTIVATE_TOKEN_REQUEST); // Check your onActivityResult() callback for RESULT_OK } else { // Null means the user doesn't have a lock screen so the token is already active. // Call isResetPasswordTokenActive() if you need to confirm }
Vous devez activer un jeton défini par votre DPC avant que l'appareil redémarre. Android stocke en mémoire un jeton non activé et ne le conserve pas après une redémarrer. Si l'utilisateur redémarre l'appareil avant d'activer un jeton, votre DPC peut définissez à nouveau le même jeton ou générez-en un nouveau.
Votre DPC peut confirmer qu'un jeton est actif en appelant
isResetPasswordTokenActive()
et la vérification du résultat est true
.
Une fois que votre DPC définit et active un jeton, il est valide jusqu'à ce que votre DPC soit supprimé ou remplace le jeton (ou la configuration d'usine de l'appareil est rétablie). Le jeton est indépendant le mot de passe et n’est pas affecté par le changement ou l’effacement du mot de passe par l’utilisateur.
Supprimer un jeton
Vous pouvez appeler clearResetPasswordToken()
pour supprimer un jeton que votre DPC
défini précédemment. Vous devrez peut-être révoquer un jeton compromis ou
supprimer la possibilité
de réinitialiser le mot de passe. L'exemple ci-dessous montre comment
ceci dans votre DPC:
Kotlin
val dpm = getDpm() val admin = DeviceAdminReceiver.getComponentName(requireActivity()) // Clear the token if (!dpm.clearResetPasswordToken(admin)) { // Report the failure and possibly try later ... }
Java
DevicePolicyManager dpm = getDpm(); ComponentName admin = DeviceAdminReceiver.getComponentName(getActivity()); // Clear the token if (!dpm.clearResetPasswordToken(admin)) { // Report the failure and possibly try later ... }
Réinitialiser le mot de passe
Lorsqu'un administrateur informatique doit réinitialiser le mot de passe, appelez
resetPasswordWithToken()
et transmettez le jeton que votre DPC a défini et activé
à l'avance:
Kotlin
val token: ByteArray = getTokenFromServer() val newPassword = "password" try { val result: Boolean = dpm.resetPasswordWithToken( DeviceAdminReceiver.getComponentName(requireContext()), newPassword, token, 0 ) if (result) { // The password is now 'password' } else { // Using 'password' doesn't meet password restrictions } } catch (e: IllegalStateException) { // The token doesn't match the one set earlier. }
Java
byte token[] = getTokenFromServer(); String newPassword = "password"; try { boolean result = dpm.resetPasswordWithToken( DeviceAdminReceiver.getComponentName(getContext()), newPassword, token, 0); if (result) { // The password is now 'password' } else { // Using `password` doesn't meet password restrictions } } catch (IllegalStateException e) { // The token doesn't match the one set earlier. }
Un appel à resetPasswordWithToken()
renvoie false
, mais le mot de passe ne renvoie pas
lorsque le nouveau mot de passe ne répond pas aux contraintes suivantes:
- Le nombre de caractères doit respecter les contraintes de longueur minimale du mot de passe. Appeler
getPasswordMinimumLength()
pour savoir si un service informatique l'administrateur a défini une contrainte de longueur. - La gamme et la complexité des caractères du mot de passe répondent à une composition
d'une contrainte. Appelez
getPasswordQuality()
pour savoir si un informaticien a défini une contrainte de composition.
Si les contraintes de qualité des mots de passe ne nécessitent pas la définition d’un mot de passe, vous pouvez
transmettez null
ou une chaîne vide à resetPasswordWithToken()
pour supprimer
mot de passe.
Question d'authentification via le profil professionnel
Un DPC exécuté en mode propriétaire de profil peut obliger les utilisateurs à spécifier un niveau de sécurité pour les applications exécutées dans le profil professionnel. Le système affiche le niveau de sécurité lorsque l'utilisateur tente d'ouvrir des applications professionnelles. Si l'utilisateur réussit achève le défi de sécurité, le système déverrouille le profil professionnel et le déchiffre, si nécessaire.
Fonctionnement de la question d'authentification à la sécurité du profil professionnel
- Si un DPC envoie un intent
ACTION_SET_NEW_PASSWORD
, le système vous invite à l'utilisateur de configurer une question d'authentification. - Le DPC peut également envoyer un
ACTION_SET_NEW_PARENT_PROFILE_PASSWORD
pour inviter l'utilisateur à définir un verrouillage de l'appareil.
Un DPC peut définir les règles de mot de passe pour la question d'authentification professionnelle différemment de la
des règles applicables aux autres mots de passe des appareils. Par exemple, la longueur minimale du paramètre
la réponse d'authentification via un appareil peut être différente de la longueur requise pour d'autres
mots de passe. Un DPC définit les règles
de défi en utilisant le
Méthodes DevicePolicyManager
, telles que setPasswordQuality()
et
setPasswordMinimumLength()
Points à prendre en compte
- Le DPC peut réinitialiser le mot de passe du profil professionnel, mais pas le
mot de passe (personnel) de l'appareil. Si un utilisateur choisit de définir des mots de passe professionnels et personnels
est identique, alors
resetPassword()
sur le profil professionnel entraîne le mot de passe ne pourra être réinitialisé que sur le profil professionnel, et le mot de passe sera différent que celle de l'écran de verrouillage de l'appareil. - Un DPC peut personnaliser l'écran des identifiants pour le défi professionnel en utilisant
setOrganizationColor()
etsetOrganizationName()
. - Les administrateurs des appareils ne peuvent pas utiliser
resetPassword()
pour effacer les mots de passe ni les modifier celles qui sont déjà définies. Les administrateurs d'appareils peuvent toujours définir un mot de passe, mais seulement si l'appareil ne dispose d'aucun mot de passe, code ou schéma.
Pour en savoir plus, consultez getParentProfileInstance()
et la documentation de référence
documentation sous DevicePolicyManager
.