Os recursos deste guia descrevem os recursos de gerenciamento de segurança que você pode implementar no seu app controlador de política de dispositivo (DPC). Este documento contém exemplos de código. Também é possível usar o app Test DPC como uma fonte de exemplo de código para os recursos empresariais do Android.
Um app de DPC pode ser executado no modo "Proprietário do perfil" em dispositivos pessoais ou no 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 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 corporativos e relatórios remotos de bugs | ✓ | |
Conceder e remover acesso a um certificado do cliente | ✓ | ✓ |
Redefinição de senha segura | ✓ | ✓ |
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 YouTube em um dispositivo Android durante determinados horários do dia, ou em certos dias da semana, um DPC pode desativar temporariamente o acesso aos aplicativos.
Para desativar o acesso a apps, um DPC em execução no modo "Proprietário do dispositivo" ou "Proprietário do perfil"
configura setPackagesSuspended()
, e o app selecionado age como se
estiver desativado (o Acesso rápido do Google esmaece o aplicativo). Quando um usuário toca no app,
ele vê uma caixa de diálogo do sistema informando que o app está suspenso.
Enquanto está suspenso, ele não pode iniciar atividades, e enviar notificações para o são suprimidos. Os pacotes suspensos não aparecem na visão geral , não podem mostrar caixas de diálogo (incluindo avisos e snackbars) e não pode reproduzir áudio ou vibrar o dispositivo.
A tela de início pode descobrir se um app está suspenso chamando o
método isPackageSuspended()
. Para detalhes sobre como configurar o app
suspensão, consulte setPackagesSuspended
.
Bloquear apps de fontes desconhecidas
Os apps que não são instalados do Google Play (ou de outras app stores confiáveis) não são chamados apps de fontes desconhecidas. Dispositivos e dados podem estar em maior risco quando as pessoas instalarem esses aplicativos.
Para impedir que alguém instale apps de fontes desconhecidas, os componentes do administrador do
que os dispositivos totalmente gerenciados e os perfis de trabalho
Restrição de usuário do DISALLOW_INSTALL_UNKNOWN_SOURCES
.
Restrição em todo o dispositivo do perfil de trabalho
Quando o administrador de um perfil de trabalho adicionar DISALLOW_INSTALL_UNKNOWN_SOURCES
,
a restrição se aplica apenas ao perfil de trabalho. No entanto, o administrador de um projeto
pode aplicar uma restrição em todo o dispositivo definindo uma
configuração gerenciada do Google Play. A restrição que abrange todo o dispositivo é
disponível no Android 8.0 (ou superior) quando o app Google Play instalado
versão 80812500 ou mais recente.
Para restringir as instalações de apps ao Google Play, siga estas etapas:
- Definir um pacote de configuração gerenciada para o pacote do Google Play
com.android.vending
: - No pacote, coloque um valor booleano para o valor
Tecla
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 esse
e defina 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 instalação do app. Essa restrição afeta instalações futuras. e os apps instalados continuam 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 Distribuição alternativa .
Restringir contas no Google Play
Às vezes, uma organização pode querer permitir que as pessoas adicionem informações pessoais do usuário (para ler e-mails no Gmail, por exemplo), mas não quer a conta pessoal para instalar apps. Seu DPC pode definir uma lista de contas que as pessoas podem usar Google Play
Os componentes do administrador de dispositivos totalmente gerenciados ou perfis de trabalho podem restringir o definindo uma configuração gerenciada para o Google Play. A conta a restrição está disponível quando a versão do app Google Play instalado é 80970100 ou superior.
Para limitar as contas no Google Play, faça o seguinte:
- Definir 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írgula como um valor de string para
a tecla
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 o
conta gerenciada assim que o seu DPC souber o endereço de e-mail dessa conta. Um
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, as organizações podem especificar quais As Contas do Google podem provisionar um dispositivo redefinido para a configuração original.
A proteção contra redefinição de fábrica para o consumidor foi criada para impedir o roubo de dispositivos. Antes permitir que qualquer pessoa provisione o dispositivo após uma redefinição de fábrica não autorizada (como como usa um EMM), o assistente de configuração exige que o usuário faça a autenticação em qualquer Contas do Google que estavam no perfil pessoal do dispositivo.
Em um ambiente corporativo, a redefinição para a configuração original é uma ferramenta importante para gerenciar aos dispositivos de um funcionário quando ele sai da organização. No entanto, se o a organização não sabe as credenciais da conta de um funcionário, redefinir para a configuração original pode bloquear a capacidade de uma organização de emitir um dispositivo funcionário.
Controlar o provisionamento após uma redefinição para a configuração original
No modo "Proprietário do dispositivo", o DPC pode usar
setFactoryResetProtectionPolicy()
para controlar quais contas são
autorizado a provisionar um dispositivo após a redefinição para a configuração original. Se essa configuração
for definido como null
ou como uma lista vazia, as contas autorizadas a provisionar
um dispositivo após a redefinição de fábrica são as contas no perfil pessoal do
dispositivo.
Um DPC pode configurar essas contas durante todo o ciclo de vida dispositivo.
- O administrador de TI pode usar o método
people.get
da API People. com o valor especialme
. Isso recupera ouserId
do está conectada. OuserID
é retornado na chaveresourceName
em o formatopeople/[userId]
como uma string de números inteiros. Contas recém-criadas podem não estará disponível para redefinição de fábrica por 72 horas. - Você também pode permitir que um ou mais administradores de TI desbloqueiem o dispositivo após
redefinir para a configuração original. Peça que cada um dos administradores de TI faça login na Conta do Google.
siga a etapa 1 e compartilhe o
userId
com você para adicioná-lasuserIds
à lista na próxima etapa. - O DPC define uma restrição de aplicativo apropriada usando
setFactoryResetProtectionPolicy()
para definir a lista deuserId
que pode provisionar um dispositivo redefinido para a configuração original. - O DPC ativa as contas que podem provisionar dispositivos depois da fábrica
redefinido enviando a transmissão
com.google.android.gms.auth.FRP_CONFIG_CHANGED
como uma intent explícita para evitar queda 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()
, introduzidos com
API de nível 30, o DPC pode usar setApplicationRestrictions
para adicionar
as contas escolhidas para a 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, seu 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()
, introduzidos com
API de nível 30, o DPC pode usar setApplicationRestrictions
para definir uma chave
de true
no disableFactoryResetProtectionAdmin
configuração 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);
Monitore registros de processos corporativos e relatórios remotos de bugs
No console de EMM, um administrador pode monitorar dispositivos totalmente gerenciados registros de processos e relatórios de bugs remotos.
Registrar atividade empresarial do dispositivo
Um DPC em execução no modo "Proprietário do dispositivo" pode identificar atividades suspeitas remotamente rastrear a atividade do dispositivo, incluindo inicializações de apps, Android Debug Bridge (adb); atividade física e desbloqueios de tela. Os registros do 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
receber o callback), o DPC vai chamar retrieveSecurityLogs()
.
Os DPCs também podem chamar retrievePreRebootSecurityLogs()
para buscar a segurança
registros gerados no ciclo de reinicialização anterior. É o intervalo entre
última reinicialização do dispositivo e a reinicialização anterior. Dispositivos sem suporte
retrieveSecurityLogs()
retorna null
. Se o app recuperar registros usando
retrievePreRebootSecurityLogs()
e retrieveSecurityLogs()
, será preciso
para verificar se há entradas duplicadas.
Observação: esse recurso só registra a atividade em dispositivos totalmente gerenciados com um único
ou usuários afiliados no dispositivo. Este recurso não funciona
dispositivos pessoais, porque registra a atividade em todo o dispositivo.
Essa configuração pode ser útil na auditoria pós-segurança, porque registra seguintes tipos de ações:
- Sempre que o app for iniciado. Isso pode ajudar a identificar se há malware que começa com um app comprometido.
- Tentativas de desbloqueio malsucedidas em um dispositivo. Isso pode identificar se há várias tentativas de desbloqueio malsucedidas em um curto período de tempo.
- Comandos adb potencialmente nocivos quando um usuário se conecta. o dispositivo a um computador usando um cabo USB.
Para detalhes sobre como ler registros, consulte SecurityLog
.
Enquanto você desenvolve e testa, é possível forçar o sistema a fazer registros de segurança existentes disponíveis para seu DPC. Você não precisa esperar em lote. No Android 9.0 (nível 28 da API) ou versões mais recentes, execute o seguinte: Comando do Android Debug Bridge (adb) no seu terminal:
adb shell dpm force-security-logs
O sistema limita a frequência com que você pode usar a ferramenta e informa qualquer
desaceleração intencional na saída do terminal. Se houver registros disponíveis,
O DPC recebe o callback onSecurityLogsAvailable()
.
Solicitar remotamente um relatório do bug
Um DPC executado no modo "Proprietário do dispositivo" pode solicitar remotamente relatórios de bugs para o usuário dispositivos com apenas um usuário ou usuários afiliados. O relatório do bug captura a atividade do dispositivo no momento exato em que o relatório do bug é solicitado, mas também pode incluem atividades das últimas horas, dependendo da frequência com que o logcat atualizações de buffer.
Para solicitar relatórios de bugs remotamente, o DPC chama requestBugreport()
:
- Se um usuário aceitar compartilhar o relatório do bug, o DPC receberá o bug
gerar um relatório usando
onBugreportShared()
- Se um usuário negar o compartilhamento do relatório do bug, o DPC receberá uma solicitação de
solicitação de mensagem negada usando
onBugreportSharingDeclined()
- Se o relatório falhar, o DPC verá
onBugreportFailed()
comBUGREPORT_FAILURE_FAILED_COMPLETING
ouBUGREPORT_FAILURE_FILE_NO_LONGER_AVAILABLE
.
Conceder e remover o acesso a um certificado do cliente
Se um DPC em execução no modo "Proprietário do perfil" ou "Proprietário do dispositivo" autorizar um app de terceiros
capacidade de gerenciar certificados, o aplicativo pode conceder acesso
certificados instalados sem a 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()
. Este recurso
funciona em conjunto com a API existente 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 todas as vezes. se quer conceder acesso a um certificado.
- Os usuários recebem uma solicitação ao instalar um certificado e precisam nomear certificado.
Com o método installKeyPair()
:
- Os usuários não precisarão 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, pois podem bloquear certificados para aplicativos 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 o cliente
certificados instalados pelo installKeyPair()
, chame
removeKeyPair()
Um DPC executado no modo "Proprietário do dispositivo" ou "Proprietário do perfil" ou delegado
o instalador de certificado pode chamar removeKeyPair()
. Com isso,
certificado e par de chaves privadas instalados em um determinado alias de chave privada.
Cenário de implantação
Use este recurso se uma organização estiver migrando para uma forma mais segura de cliente certificado. Se um administrador lançar um novo certificado e a respectiva distribuição levar muito tempo, o administrador poderá revogar a certificados após a migração.
Redefinição de senha segura
Seu DPC pode redefinir a senha de um usuário autorizando a alteração com uma
um token seguro e pré-registrado. Proprietários de dispositivos e de perfil podem ligar para o modo seguro
APIs de redefinição de senha para mudar a senha de dispositivos e perfis de trabalho
respectivamente. A redefinição de senha segura substitui resetPassword()
pelo
seguintes melhorias:
- Seu DPC pode redefinir a senha antes que o usuário desbloqueie o dispositivo ou perfil. após a reinicialização em dispositivos a criptografia baseada em arquivos.
- O Android Keystore retém chaves autenticadas pelo usuário após a redefinição da senha.
Use a redefinição de senha segura se o build do DPC for destinado ao Android 8.0 (API
nível 26) ou superior. Chamar resetPassword()
gera uma
SecurityException
em DPCs destinados ao Android 8.0 ou versões mais recentes, então você pode
precisa atualizar seu DPC.
Definir e ativar um token
Seu DPC precisa definir e ativar um token antes de redefinir uma senha. Devido ao seu DPC pode não conseguir usar o token imediatamente, você define o token antes que um administrador de TI precise usá-la.
Um token de redefinição de senha é um valor aleatório com criptografia forte e precisa ter pelo menos 32 bytes. Crie um token para cada dispositivo e perfil. Não reutilizar ou compartilhar os tokens gerados.
Recomendamos armazenar tokens, ou os meios para descriptografar um token criptografado, em uma servidor. Se você armazenar tokens localmente no armazenamento criptografado por credenciais, seu DPC não pode 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 pode usar o token para obter acesso a um perfil de trabalho ou a um usuário.
Você pode gerar um novo token no DPC ou buscar um token em um servidor. A exemplo abaixo mostra um DPC gerando o próprio token e relatando-o para 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, seu DPC precisa ativar um token depois de configurá-lo. Mas, quando
o usuário não tem uma senha para a tela de bloqueio, o sistema ativa um token
imediatamente. Para ativar um token, peça para o usuário confirmar as credenciais.
Seu DPC pode chamar o método KeyguardManager
createConfirmDeviceCredentialIntent()
para ter um Intent
que inicie o
confirmação. Explique ao usuário do dispositivo na interface do usuário por que você está
solicitando a autenticação. O snippet abaixo mostra como ativar
no seu 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 }
É preciso ativar um token definido pelo DPC antes da reinicialização do dispositivo. Android armazena um token não ativado na memória e não mantém o token depois que um reiniciar o dispositivo. Se o usuário reinicializar o dispositivo antes de ativar um token, o DPC poderá definir o mesmo token novamente ou gerar um novo token.
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 exclua ou substitui o token (ou o dispositivo é redefinido para a configuração original). O token é independente a senha e não seja afetada pela alteração ou limpeza da senha pelo usuário.
Excluir um token
É possível chamar clearResetPasswordToken()
para excluir um token que seu DPC
que você definiu antes. Talvez seja necessário revogar um token comprometido ou cancelar
remover a capacidade de redefinição da senha. O exemplo abaixo mostra como fazer
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 ... }
Redefinir a senha
Quando um administrador 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
mudar, quando a nova senha não atender às seguintes restrições:
- O número de caracteres atende a qualquer restrição de tamanho mínimo de senha. Ligação
getPasswordMinimumLength()
para saber se um departamento de TI o administrador definiu uma restrição de tamanho. - O alcance e a complexidade dos caracteres da senha atendem a uma composição
restrição. Chame
getPasswordQuality()
para saber se um departamento de TI administrador definiu uma restrição de composição.
Se as restrições de qualidade da senha não exigirem a definição de uma senha, você poderá
Transmita null
ou uma string vazia a resetPasswordWithToken()
para remover o
senha.
Desafio de segurança de perfil de trabalho
Um DPC executado no modo de proprietário do perfil pode exigir que os usuários especifiquem uma política para apps executados no perfil de trabalho. O sistema mostra a segurança um desafio quando o usuário tentar abrir qualquer aplicativo de trabalho. Se o usuário conseguir concluir o desafio de segurança, o sistema desbloqueia o perfil de trabalho e o descriptografa, se necessário.
Como funciona o desafio de segurança do perfil de trabalho
- Se um DPC enviar uma intent
ACTION_SET_NEW_PASSWORD
, o sistema solicitará para o usuário configurar um desafio de segurança. - O DPC também pode enviar um
ACTION_SET_NEW_PARENT_PROFILE_PASSWORD
para solicitar que o usuário defina um bloqueio de dispositivo.
Um DPC pode definir políticas de senha para o desafio de trabalho de forma diferente
políticas para senhas de outros dispositivos. Por exemplo, o comprimento mínimo
de resposta do desafio no dispositivo pode ser diferente do tamanho exigido para outros
senhas. Um DPC define as políticas de desafio usando a
Métodos DevicePolicyManager
, como setPasswordQuality()
e
setPasswordMinimumLength()
.
Considerações
- O DPC pode redefinir a senha no perfil de trabalho, mas não pode redefinir
do dispositivo (pessoal). Se um usuário escolher definir senhas de trabalho e pessoais
forem iguais,
resetPassword()
no perfil de trabalho fará com que o que a senha seja redefinida apenas no perfil de trabalho, e a senha não será a mesma da tela de bloqueio do dispositivo. - Um DPC pode personalizar a tela de credenciais para o desafio de trabalho usando
setOrganizationColor()
esetOrganizationName()
. - Os administradores do dispositivo não podem usar o
resetPassword()
para limpar ou mudar senhas as que já foram definidas. Os administradores do dispositivo ainda podem definir uma senha, mas apenas quando o dispositivo não tem senha, PIN ou padrão.
Para mais informações, consulte getParentProfileInstance()
e a referência
documentação em DevicePolicyManager
.