Os recursos deste guia descrevem as funcionalidades de gerenciamento de segurança que podem ser implementadas no seu app de controlador de política de dispositivo (DPC). Este documento contém exemplos de código, e você também pode usar o app Test DPC como uma fonte de exemplos de código para os recursos corporativos do Android.
Um app DPC pode ser executado no modo de proprietário do perfil em dispositivos pessoais ou no modo de proprietário do dispositivo em dispositivos totalmente gerenciados. Esta tabela indica quais recursos estão disponíveis quando o DPC é executado no modo de proprietário do perfil ou modo de proprietário do dispositivo:
| Recurso | Proprietário do perfil | Proprietário do dispositivo |
|---|---|---|
| Desativar o acesso a apps | ✓ | ✓ |
| Bloquear apps de fontes desconhecidas | ✓ | ✓ |
| Restringir contas no Google Play | ✓ | ✓ |
| Ativar a proteção contra redefinição de fábrica para empresas | ✓ | |
| Monitorar registros de processos empresariais e relatórios de bugs remotos | ✓ | |
| Conceder e remover o acesso a um certificado do cliente | ✓ | ✓ |
| Redefinição segura de senha | ✓ | ✓ |
| Desafio de segurança do perfil de trabalho | ✓ |
Desativar o acesso a apps
Para organizações que querem impedir que os funcionários joguem ou assistam ao YouTube no dispositivo Android em determinados horários do dia ou dias da semana, um DPC pode desativar temporariamente o acesso aos apps.
Para desativar o acesso a apps, um DPC em execução no modo de proprietário do dispositivo ou do perfil
configura setPackagesSuspended(). Em seguida, o app selecionado age como se
estivesse desativado (o Google Launcher esmaece o app). Quando um usuário toca no app,
uma caixa de diálogo do sistema é exibida informando que o app está suspenso.
Enquanto um app está suspenso, ele não pode iniciar atividades, e as notificações para o pacote são suprimidas. Os pacotes suspensos não aparecem na tela de visão geral, não podem mostrar caixas de diálogo (incluindo avisos e snackbars) e não podem tocar áudio ou fazer o dispositivo vibrar.
Os inicializadores podem descobrir se um app está suspenso chamando o
método isPackageSuspended(). Para saber como configurar a suspensão de apps, consulte setPackagesSuspended.
Bloquear apps de fontes desconhecidas
Os apps que não são instalados pelo Google Play (ou outras app stores confiáveis) são chamados de apps de fontes desconhecidas. Os dispositivos e dados podem correr um risco maior quando as pessoas instalam esses apps.
Para impedir que alguém instale apps de fontes desconhecidas, os componentes de administração de
dispositivos totalmente gerenciados e perfis de trabalho podem adicionar a
restrição de usuário DISALLOW_INSTALL_UNKNOWN_SOURCES.
Restrição de perfil de trabalho em todo o dispositivo
Quando o administrador de um perfil de trabalho adiciona DISALLOW_INSTALL_UNKNOWN_SOURCES,
a restrição se aplica apenas ao perfil de trabalho. No entanto, o administrador de um perfil de trabalho
pode colocar uma restrição em todo o dispositivo definindo uma
configuração gerenciada para o Google Play. A restrição para todo o dispositivo está
disponível no Android 8.0 (ou mais recente) quando o app Google Play instalado é
da versão 80812500 ou mais recente.
Para restringir as instalações de apps ao Google Play, siga estas etapas:
- Defina um pacote de configuração gerenciada para o pacote do Google Play
com.android.vending. - No pacote, coloque um valor booleano para a
chave
verify_apps:device_wide_unknown_source_block. - Adicione a restrição de usuário
ENSURE_VERIFY_APPS.
O exemplo a seguir mostra como verificar se o Google Play é compatível com essa
configuração e definir o valor como 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);
A interface do usuário nas configurações do sistema permanece ativa, mas o sistema bloqueia a instalação de apps. Essa restrição afeta instalações futuras. Os apps instalados anteriormente permanecem no dispositivo. Os usuários do dispositivo podem continuar instalando apps no perfil pessoal usando o Android Debug Bridge (adb).
Para saber mais sobre fontes desconhecidas, leia Opções de distribuição alternativas.
Restringir contas no Google Play
Às vezes, uma organização pode querer permitir que as pessoas adicionem Contas do Google pessoais (para ler e-mails no Gmail, por exemplo), mas não quer que a conta pessoal instale apps. Seu DPC pode definir uma lista de contas que as pessoas podem usar no Google Play.
Os componentes de administrador de dispositivos totalmente gerenciados ou perfis de trabalho podem restringir as contas definindo uma configuração gerenciada para o Google Play. A restrição de conta está disponível quando o app Google Play instalado é da versão 80970100 ou mais recente.
Para limitar as contas no Google Play, faça o seguinte:
- Defina um pacote de configuração gerenciada para o pacote do Google Play
com.android.vending. - No pacote, coloque os endereços de e-mail separados por vírgulas como um valor de string para
a chave
allowed_accounts.
O exemplo a seguir mostra como limitar contas:
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);
Para limitar o Google Play apenas à conta de trabalho, defina allowed_accounts como a
conta gerenciada única assim que o DPC souber o endereço de e-mail da conta. Uma
string vazia impede que as pessoas usem qualquer conta no Google Play.
Ativar a proteção contra redefinição de fábrica para empresas
Com a proteção contra redefinição de fábrica para empresas, as organizações podem especificar quais Contas do Google podem provisionar um dispositivo que foi redefinido para a configuração original.
A proteção contra redefinição de fábrica para consumidores foi criada para evitar o roubo de dispositivos. Antes de permitir que alguém provisione o dispositivo após uma redefinição de fábrica não autorizada (como usar um EMM), o assistente de configuração exige que o usuário faça a autenticação em qualquer Conta do Google que estava no perfil pessoal do dispositivo.
Em um ambiente corporativo, a redefinição de fábrica é uma ferramenta importante para gerenciar os dispositivos dos funcionários quando eles saem da organização. No entanto, se a organização não souber as credenciais da conta de um funcionário, a proteção contra redefinição de fábrica pode impedir que a organização emita um dispositivo para outro funcionário.
Controlar o provisionamento após uma redefinição de fábrica
Ao ser executado no modo de proprietário do dispositivo, o DPC pode usar
setFactoryResetProtectionPolicy() para controlar quais contas estão
autorizadas a provisionar um dispositivo após uma redefinição de fábrica. Se essa configuração
for definida como null ou como uma lista vazia, as contas autorizadas a provisionar
um dispositivo após uma redefinição de fábrica serão as contas no perfil pessoal do
dispositivo.
Um DPC pode configurar essas contas durante todo o ciclo de vida de um dispositivo totalmente gerenciado.
- O admin de TI pode usar o método
people.getda API People com o valor especialme. Isso recupera ouserIdda conta conectada. OuserIDé retornado na chaveresourceNameno formatopeople/[userId]como uma string de número inteiro. As contas recém-criadas podem não estar disponíveis para redefinição de fábrica por 72 horas. - Também é possível permitir que um ou mais admins de TI desbloqueiem o dispositivo após
uma redefinição de fábrica. Peça para cada um desses admins de TI fazer login na Conta do Google,
seguir a etapa 1 e compartilhar o
userIdcom você. Assim, você poderá adicionar essesuserIdsà lista na próxima etapa. - O DPC define uma restrição de app adequada usando
setFactoryResetProtectionPolicy()para definir a lista deuserIdque podem provisionar um dispositivo com redefinição de fábrica. - O DPC ativa as contas que podem provisionar dispositivos após uma redefinição de fábrica
enviando a transmissão
com.google.android.gms.auth.FRP_CONFIG_CHANGEDcomo uma intent explícita para evitar que sejam descartadas devido a restrições em segundo plano.
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);
Legado
Para dispositivos que não podem usar setFactoryResetProtectionPolicy(), introduzido com o nível da API 30, o DPC pode usar setApplicationRestrictions para adicionar as contas escolhidas à configuração gerenciada factoryResetProtectionAdmin para o pacote 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);
Desativar a proteção contra redefinição de fábrica para empresas
Para desativar a proteção contra redefinição de fábrica, o DPC pode usar
setFactoryResetProtectionPolicy() transmitindo o valor 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);
Legado
Para dispositivos que não podem usar setFactoryResetProtectionPolicy(), introduzido com
o nível 30 da API, o DPC pode usar setApplicationRestrictions para definir um valor de chave
de true na configuração gerenciada
disableFactoryResetProtectionAdmin para o pacote 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);
Monitorar registros de processos corporativos e relatórios de bugs remotos
No console de EMM, um administrador pode monitorar dispositivos totalmente gerenciados usando registros de processos empresariais e relatórios de bugs remotos.
Registrar a atividade do dispositivo corporativo
Um DPC em execução no modo de proprietário do dispositivo pode identificar atividades suspeitas rastreando remotamente as atividades do dispositivo, incluindo inicializações de apps, atividades do Android Debug Bridge (adb) e desbloqueios de tela. Os registros de processo não exigem o consentimento do usuário.
Para ativar ou desativar a geração de registros, um DPC chama setSecurityLoggingEnabled().
Quando um novo lote de registros está disponível, um DeviceAdminReceiver recebe o
callback onSecurityLogsAvailable(). Para recuperar os registros (depois de receber o callback), um DPC chama retrieveSecurityLogs().
Os DPCs também podem chamar retrievePreRebootSecurityLogs() para buscar registros de segurança
gerados no ciclo de reinicialização anterior. Esse é o intervalo entre a
última reinicialização do dispositivo e a anterior. Os dispositivos que não são compatíveis com
retrieveSecurityLogs() retornam null. Se o app recuperar registros usando retrievePreRebootSecurityLogs() e retrieveSecurityLogs(), verifique se há entradas duplicadas.
Observação: esse recurso só registra atividades em dispositivos totalmente gerenciados (por um proprietário
ou pelo delegado DELEGATION_SECURITY_LOGGING) com um único usuário ou
usuários afiliados no dispositivo. Esse recurso não funciona em dispositivos pessoais, porque ele registra atividades em todo o dispositivo.
Essa configuração pode ser útil na auditoria pós-ocorrência de segurança porque registra os seguintes tipos de ações:
- Sempre que o app é iniciado do zero. Isso pode ajudar a identificar se há malware que começa com um app comprometido.
- Tentativas de desbloqueio sem sucesso em um dispositivo. Isso pode identificar se há várias tentativas de desbloqueio com falha em um curto período.
- Comandos adb potencialmente nocivos quando um usuário conecta o dispositivo a um computador usando um cabo USB.
Para saber como ler registros, consulte SecurityLog.
Durante o desenvolvimento e os testes, é possível forçar o sistema a disponibilizar todos os registros de segurança existentes para o DPC. Não é necessário esperar por um lote completo. No Android 9.0 (nível 28 da API) ou versões mais recentes, execute o seguinte comando do Android Debug Bridge (adb) no terminal:
adb shell dpm force-security-logs
O sistema limita a frequência com que você pode usar a ferramenta e informa qualquer
lentidão intencional na saída do terminal. Se houver registros disponíveis, seu
DPC vai receber o callback onSecurityLogsAvailable().
Solicitar um relatório de bugs remotamente
Um DPC em execução no modo de proprietário do dispositivo pode solicitar remotamente relatórios de bugs para dispositivos com apenas um usuário ou usuários afiliados. O relatório de bugs captura a atividade do dispositivo no momento exato em que é solicitado, mas também pode incluir atividades das últimas horas, dependendo da frequência com que o buffer do logcat é atualizado.
Para solicitar relatórios de bugs remotamente, o DPC chama requestBugreport():
- Se um usuário aceitar compartilhar o relatório do bug, o DPC vai receber o relatório usando
onBugreportShared(). - Se um usuário negar o compartilhamento do relatório do bug, o DPC vai receber uma mensagem de solicitação de compartilhamento negada usando
onBugreportSharingDeclined(). - Se o relatório de bug falhar, o DPC vai receber
onBugreportFailed()comBUGREPORT_FAILURE_FAILED_COMPLETINGouBUGREPORT_FAILURE_FILE_NO_LONGER_AVAILABLE.
Conceder e remover o acesso a um certificado do cliente
Se um DPC em execução no modo de proprietário do perfil ou do dispositivo conceder a um app de terceiros
a capacidade de gerenciar certificados, o app poderá conceder a si mesmo acesso aos
certificados que instalar sem intervenção do usuário. Para instalar um
certificado que todos os apps em um perfil podem acessar, use installKeyPair().
Para saber quais parâmetros configurar, consulte installKeyPair(). Esse recurso
funciona em conjunto com a API atual para gerenciar certificados.
Cenário de implantação
Sem o método installKeyPair():
- Os usuários precisam tocar no nome do certificado e em Permitir sempre que quiserem conceder acesso a um certificado.
- Os usuários recebem uma solicitação ao instalar um certificado e precisam nomeá-lo.
Com o método installKeyPair():
- Os usuários não precisam tocar em Permitir sempre que quiserem conceder acesso a um certificado.
- Os usuários não podem renomear certificados.
- Os administradores têm mais controle, já que podem bloquear certificados para apps que não devem ter acesso a certificados específicos.
Remover um certificado do cliente
Depois de conceder acesso a um certificado do cliente, para remover remotamente os certificados do cliente instalados por meio de installKeyPair(), chame removeKeyPair().
Um DPC em execução no modo de proprietário do dispositivo ou do perfil ou um instalador de certificado delegado pode chamar removeKeyPair(). Isso remove um
par de chaves de certificado e chave privada instalado em um determinado alias de chave privada.
Cenário de implantação
Use esse recurso se uma organização estiver migrando para uma forma mais segura de certificado do cliente. Se um administrador lançar um novo certificado e a distribuição levar um tempo significativo, ele poderá revogar os certificados descontinuados após a conclusão da migração.
Redefinição segura de senha
O DPC pode redefinir a senha de um usuário autorizando a mudança com um
token seguro pré-registrado. Os proprietários de dispositivos e de perfis podem chamar APIs de redefinição de senha seguras para mudar a senha de dispositivos e perfis de trabalho, respectivamente. A redefinição segura de senha substitui resetPassword() pelas
seguintes melhorias:
- O DPC pode redefinir a senha antes que o usuário desbloqueie o dispositivo ou perfil após uma reinicialização em dispositivos que usam criptografia baseada em arquivos.
- O Android Keystore retém as chaves autenticadas pelo usuário após uma redefinição de senha.
Use a redefinição segura de senha se o build do DPC for destinado ao Android 8.0 (nível 26 da API) ou versões mais recentes. Chamar resetPassword() gera uma
SecurityException em DPCs destinados ao Android 8.0 ou versões mais recentes. Por isso, talvez
seja necessário atualizar seu DPC.
Definir e ativar um token
Seu DPC precisa definir e ativar um token antes de redefinir uma senha. Como o DPC pode não conseguir usar o token imediatamente, defina o token antes do momento em que um admin de TI pode precisar usá-lo.
Um token de redefinição de senha é um valor aleatório criptograficamente forte e precisa ter pelo menos 32 bytes de comprimento. Crie um token para cada dispositivo e perfil. Não reutilize nem compartilhe os tokens gerados.
Recomendamos armazenar tokens ou os meios para descriptografar um token criptografado em um servidor. Se você armazenar tokens localmente no armazenamento criptografado por credenciais, o DPC não poderá redefinir a senha até que o usuário desbloqueie o dispositivo ou perfil. Se você armazenar os tokens localmente no armazenamento criptografado do dispositivo, que fica comprometido, um invasor poderá usar o token para acessar um perfil de trabalho ou um usuário principal.
É possível gerar um novo token no DPC ou buscar um token de um servidor. O exemplo abaixo mostra um DPC gerando um token e o informando a um servidor:
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); }
Na maioria dos casos, o DPC precisa ativar um token depois de defini-lo. No entanto, quando
o usuário não tem uma senha de tela de bloqueio, o sistema ativa um token
imediatamente. Para ativar um token, peça para o usuário confirmar as credenciais.
O DPC pode chamar o método KeyguardManager
createConfirmDeviceCredentialIntent() para receber uma Intent que inicia a
confirmação. Explique ao usuário do dispositivo na interface do usuário por que você está
pedindo que ele se autentique. O snippet abaixo mostra como ativar um
token no 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 }
É necessário ativar um token definido pelo DPC antes que o dispositivo seja reiniciado. O Android armazena um token não ativado na memória e não o mantém após uma reinicialização. Se o usuário reiniciar o dispositivo antes de ativar um token, o DPC poderá definir o mesmo token novamente ou gerar um novo.
Seu DPC pode confirmar se um token está ativo chamando
isResetPasswordTokenActive() e verificando se o resultado é true.
Depois que o DPC define e ativa um token, ele é válido até que o DPC o exclua ou substitua (ou até que o dispositivo seja redefinido para a configuração original). O token é independente da senha e não é afetado pela alteração ou limpeza da senha pelo usuário.
Excluir um token
É possível chamar clearResetPasswordToken() para excluir um token que o DPC
definiu anteriormente. Talvez seja necessário revogar um token comprometido ou remover a capacidade de redefinir a senha. O exemplo abaixo mostra como fazer isso no seu 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 ... }
Redefina a senha
Quando um admin de TI precisar redefinir a senha, chame
resetPasswordWithToken() e transmita o token que o DPC definiu e ativou
com antecedência:
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. }
Uma chamada para resetPasswordWithToken() retorna false, e a senha não muda quando a nova senha não atende às seguintes restrições:
- O número de caracteres atende a qualquer restrição de tamanho mínimo de senha. Chame
getPasswordMinimumLength()para saber se um administrador de TI definiu uma restrição de tamanho. - O intervalo e a complexidade dos caracteres na senha atendem a uma restrição de composição. Chame
getPasswordQuality()para saber se um administrador de TI definiu uma restrição de composição.
Se as restrições de qualidade da senha não exigirem que uma senha seja definida, transmita null ou uma string vazia para resetPasswordWithToken() para remover a senha.
Desafio de comprovação de segurança do perfil de trabalho
Um DPC em execução no modo de proprietário do perfil pode exigir que os usuários especifiquem um desafio de segurança para apps em execução no perfil de trabalho. O sistema mostra o desafio de segurança quando o usuário tenta abrir qualquer app de trabalho. Se o usuário concluir o desafio de segurança, o sistema vai desbloquear o perfil de trabalho e descriptografá-lo, se necessário.
Como funciona o desafio de comprovação de segurança do perfil de trabalho
- Se um DPC enviar uma intent
ACTION_SET_NEW_PASSWORD, o sistema vai solicitar que o usuário configure um desafio de segurança. - O DPC também pode enviar uma intent
ACTION_SET_NEW_PARENT_PROFILE_PASSWORDpara solicitar que o usuário defina um bloqueio de dispositivo.
Um DPC pode definir as políticas de senha para o desafio de trabalho de forma diferente das
políticas para outras senhas do dispositivo. Por exemplo, o tamanho mínimo da
resposta ao desafio do dispositivo pode ser diferente do tamanho exigido para outras
senhas. Um DPC define as políticas de desafio usando os métodos comuns
DevicePolicyManager, como setPasswordQuality() e
setPasswordMinimumLength().
Considerações
- O DPC pode redefinir a senha no perfil de trabalho, mas não pode redefinir a
senha do dispositivo (pessoal). Se um usuário definir a mesma senha para o trabalho e para o uso pessoal,
resetPassword()no perfil de trabalho vai fazer com que a senha seja redefinida apenas no perfil de trabalho, e ela não será igual à da tela de bloqueio do dispositivo. - Um DPC pode personalizar a tela de credenciais do desafio de trabalho usando
setOrganizationColor()esetOrganizationName(). - Os administradores de dispositivos não podem usar
resetPassword()para limpar senhas ou mudar as que já estão definidas. Os administradores do dispositivo ainda podem definir uma senha, mas apenas quando o dispositivo não tiver senha, PIN ou padrão.
Para mais informações, consulte getParentProfileInstance() e a documentação de referência em DevicePolicyManager.