Segurança

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:

  1. Defina um pacote de configuração gerenciada para o pacote do Google Play com.android.vending.
  2. No pacote, coloque um valor booleano para a chave verify_apps:device_wide_unknown_source_block.
  3. 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:

  1. Defina um pacote de configuração gerenciada para o pacote do Google Play com.android.vending.
  2. 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.

  1. O admin de TI pode usar o método people.get da API People com o valor especial me. Isso recupera o userId da conta conectada. O userID é retornado na chave resourceName no formato people/[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.
  2. 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 userId com você. Assim, você poderá adicionar esses userIds à lista na próxima etapa.
  3. O DPC define uma restrição de app adequada usando setFactoryResetProtectionPolicy() para definir a lista de userId que podem provisionar um dispositivo com redefinição de fábrica.
  4. 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_CHANGED como 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():

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:

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

  1. Se um DPC enviar uma intent ACTION_SET_NEW_PASSWORD, o sistema vai solicitar que o usuário configure um desafio de segurança.
  2. O DPC também pode enviar uma intent ACTION_SET_NEW_PARENT_PROFILE_PASSWORD para 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() e setOrganizationName().
  • 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.