Mejora la seguridad con políticas de administración de dispositivos

Baja del administrador de dispositivos. Algunas políticas de administrador se marcaron como obsoletas cuando se invocaron por un administrador del dispositivo. Para obtener más información y ver las opciones de migración, consulta Baja del administrador de dispositivos.

A partir de Android 2.2 (nivel de API 8), la plataforma de Android ofrece administración de dispositivos a nivel del sistema a través de las APIs de administración de dispositivos.

En esta lección, aprenderás a crear una aplicación adaptada a la seguridad que administre el acceso a su contenido aplicando políticas de administración de dispositivos. Específicamente, la aplicación se puede configurar de modo que se garantice la configuración de una contraseña de bloqueo de pantalla con suficiente seguridad antes de mostrar restringido al usuario.

Define y declara tu política

En primer lugar, debes definir los tipos de políticas que admitirás a nivel funcional. Las políticas pueden cubrir la seguridad de la contraseña de bloqueo de pantalla, el tiempo de espera de caducidad, la encriptación, etc.

Debes declarar el conjunto de políticas seleccionado, que la aplicación aplicará en la res/xml/device_admin.xml. El manifiesto de Android también debe hacer referencia al y declarada como conjunto de políticas.

Cada política declarada corresponde a una serie de métodos de política de dispositivo relacionados en DevicePolicyManager (que definen la longitud mínima de las contraseñas y la cantidad mínima de los caracteres en mayúscula son dos ejemplos). Si una aplicación intenta invocar métodos cuyo No se declara la política correspondiente en el XML, lo que generará una SecurityException durante el tiempo de ejecución. Otros permisos, como force-lock, están disponibles si la aplicación tiene la intención de administrar y otros tipos de políticas. Como verás más adelante, en el proceso de activación del administrador de dispositivos, La lista de políticas declaradas se presentará al usuario en una pantalla del sistema.

En el siguiente fragmento, se declara la política de límite de contraseñas en res/xml/device_admin.xml:

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

XML de la declaración de políticas al que se hace referencia en el manifiesto de Android:

<receiver android:name=".Policy$PolicyAdmin"
    android:permission="android.permission.BIND_DEVICE_ADMIN">
    <meta-data android:name="android.app.device_admin"
        android:resource="@xml/device_admin" />
    <intent-filter>
        <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
    </intent-filter>
</receiver>

Crea un receptor de administración de dispositivos

Crea un receptor de emisión de la administración de dispositivos, que recibe notificaciones de eventos relacionados con las políticas que declaraste admitir. Una aplicación puede anular selectivamente los métodos de devolución de llamada.

En la aplicación de ejemplo, Administrador de dispositivos, cuando el administrador desactiva al administrador del dispositivo, usuario, la política configurada se borra de la preferencia compartida. Deberías considerar la implementación con la lógica empresarial que sea relevante para tu caso de uso. Por ejemplo, la aplicación puede tomar acciones para mitigar los riesgos de seguridad implementando alguna combinación de eliminación de datos sensibles en el inhabilitar la sincronización remota, alertar a un administrador, etc.

Para que el receptor de emisión funcione, asegúrate de registrarlo en el manifiesto de Android, como se ilustra en el fragmento anterior.

class PolicyAdmin : DeviceAdminReceiver() {

    override fun onDisabled(context: Context, intent: Intent) {
        // Called when the app is about to be deactivated as a device administrator.
        // Deletes previously stored password policy.
        super.onDisabled(context, intent)
        context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE).edit().apply {
            clear()
            apply()
        }
    }
}

public static class PolicyAdmin extends DeviceAdminReceiver {

    @Override
    public void onDisabled(Context context, Intent intent) {
        // Called when the app is about to be deactivated as a device administrator.
        // Deletes previously stored password policy.
        super.onDisabled(context, intent);
        SharedPreferences prefs = context.getSharedPreferences(APP_PREF, Activity.MODE_PRIVATE);
        prefs.edit().clear().commit();
    }
}

Activar el administrador del dispositivo

Antes de aplicar cualquier política, el usuario debe activar manualmente la aplicación como un dispositivo. administrador. El siguiente fragmento ilustra cómo activar la actividad de configuración en la que la usuario puede activar tu aplicación. Es una buena práctica incluir el texto explicativo para destacar el motivo por el cual la aplicación solicita ser administrador de dispositivos, especificando el EXTRA_ADD_EXPLANATION adicional en el intent.

Figura 1: La pantalla de activación del usuario en la que puedes proporciona una descripción de las políticas de dispositivo.

if (!policy.isAdminActive()) {

    val activateDeviceAdminIntent = Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN)

    activateDeviceAdminIntent.putExtra(
            DevicePolicyManager.EXTRA_DEVICE_ADMIN,
            policy.getPolicyAdmin()
    )

    // It is good practice to include the optional explanation text to
    // explain to user why the application is requesting to be a device
    // administrator. The system will display this message on the activation
    // screen.
    activateDeviceAdminIntent.putExtra(
            DevicePolicyManager.EXTRA_ADD_EXPLANATION,
            resources.getString(R.string.device_admin_activation_message)
    )

    startActivityForResult(activateDeviceAdminIntent, REQ_ACTIVATE_DEVICE_ADMIN)
}

if (!policy.isAdminActive()) {

    Intent activateDeviceAdminIntent =
        new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);

    activateDeviceAdminIntent.putExtra(
        DevicePolicyManager.EXTRA_DEVICE_ADMIN,
        policy.getPolicyAdmin());

    // It is good practice to include the optional explanation text to
    // explain to user why the application is requesting to be a device
    // administrator. The system will display this message on the activation
    // screen.
    activateDeviceAdminIntent.putExtra(
        DevicePolicyManager.EXTRA_ADD_EXPLANATION,
        getResources().getString(R.string.device_admin_activation_message));

    startActivityForResult(activateDeviceAdminIntent,
        REQ_ACTIVATE_DEVICE_ADMIN);
}

Si el usuario elige "Activar", la aplicación se convierte en administrador de dispositivos y puede comenzar configurar y aplicar la política.

La aplicación también debe estar preparada para manejar situaciones de retroceso en las que el usuario abandona el proceso de activación presionando el botón Cancelar, la tecla Atrás o la tecla Inicio. Por lo tanto, onResume() en la actividad de configuración de políticas debe tener lógica para reevaluar la condición y presentar la opción de Activación del administrador de dispositivos al usuario si según tus necesidades.

Cómo implementar el controlador de política de dispositivo

Una vez que el administrador del dispositivo se activa correctamente, la aplicación configura el dispositivo Administrador de políticas con la política solicitada. Ten en cuenta que se agregarán políticas nuevas Android con cada versión Es apropiado realizar verificaciones de versión en tu aplicación si usas políticas nuevas y, al mismo tiempo, la compatibilidad con versiones anteriores de la plataforma. Por ejemplo, el valor mínimo de contraseña La política en mayúsculas solo está disponible con el nivel de API 11 (Honeycomb) y versiones posteriores. El siguiente código demuestra cómo se puede verificar la versión en el tiempo de ejecución.

private lateinit var dpm: DevicePolicyManager
private lateinit var policyAdmin: ComponentName

dpm = context.getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager
policyAdmin = ComponentName(context, PolicyAdmin::class.java)

dpm.apply {
    setPasswordQuality(policyAdmin, PASSWORD_QUALITY_VALUES[passwordQuality])
    setPasswordMinimumLength(policyAdmin, passwordLength)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        setPasswordMinimumUpperCase(policyAdmin, passwordMinUpperCase)
    }
}

DevicePolicyManager dpm = (DevicePolicyManager)
        context.getSystemService(Context.DEVICE_POLICY_SERVICE);
ComponentName policyAdmin = new ComponentName(context, PolicyAdmin.class);

dpm.setPasswordQuality(policyAdmin, PASSWORD_QUALITY_VALUES[passwordQuality]);
dpm.setPasswordMinimumLength(policyAdmin, passwordLength);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    dpm.setPasswordMinimumUpperCase(policyAdmin, passwordMinUpperCase);
}

En este punto, la aplicación puede aplicar la política de manera forzosa. Mientras la aplicación no tenga acceso con la contraseña de bloqueo de pantalla que se usó; mediante la API de Device Policy Manager, puede determinar si la contraseña existente cumple con la política requerida. Si resulta que el estado contraseña de bloqueo de pantalla no es suficiente, la API de administración del dispositivo no toma automáticamente para tomar medidas correctivas. La aplicación debe iniciar explícitamente el sistema la pantalla de cambio de contraseña en la app de Configuración. Por ejemplo:

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

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

Normalmente, el usuario puede seleccionar uno de los mecanismos de bloqueo disponibles, como None, Pattern, PIN (numérico) o contraseña (alfanumérica). Cuando se configura una política de contraseñas, se inhabilitan los tipos más débiles que los definidos en la política. Por ejemplo, si el Se configura la calidad de contraseña “numérica”, el usuario puede seleccionar PIN (numérico) o contraseña (alfanumérica).

Una vez que el dispositivo esté correctamente protegido mediante la configuración de una contraseña de bloqueo de pantalla, la aplicación permite el acceso al contenido protegido.

when {
    !dpm.isAdminActive(policyAdmin) -> {
        // Activates device administrator.
        ...
    }
    !dpm.isActivePasswordSufficient -> {
        // Launches password set-up screen in Settings.
        ...
    }
    else -> {
        // Grants access to secure content.
        ...
        startActivity(Intent(context, SecureActivity::class.java))
    }
}

if (!dpm.isAdminActive(..)) {
    // Activates device administrator.
    ...
} else if (!dpm.isActivePasswordSufficient()) {
    // Launches password set-up screen in Settings.
    ...
} else {
    // Grants access to secure content.
    ...
    startActivity(new Intent(context, SecureActivity.class));
}