Zwiększanie bezpieczeństwa dzięki zasadom zarządzania urządzeniami

Wycofanie administratora urządzenia. Niektóre zasady administratora zostały oznaczone jako wycofane po wywołaniu przez administratora urządzenia. Aby dowiedzieć się więcej i poznać opcje migracji, zobacz Wycofanie administratora urządzenia.

Od Androida 2.2 (poziom interfejsu API 8) platforma Androida oferuje funkcje zarządzania urządzeniami na poziomie systemu w ramach interfejsów API do administrowania urządzeniami.

Z tej lekcji dowiesz się, jak utworzyć bezpieczną aplikację, która zarządza dostępem do swoich treści, egzekwując zasady zarządzania urządzeniami. W szczególności aplikację można skonfigurować, tak, by przed wyświetleniem zostało skonfigurowane odpowiednie hasło blokady ekranu dostęp do treści ograniczony do użytkownika.

Zdefiniuj i zadeklaruj zasady

Najpierw należy zdefiniować rodzaje zasad, które mają być obsługiwane na poziomie funkcjonalnego. Zasady mogą określić siłę hasła blokady ekranu, czas wygaśnięcia, szyfrowanie itp.

Wybrany zestaw zasad musi być zadeklarowany w aplikacji, res/xml/device_admin.xml. Plik manifestu Androida powinien też odnosić się do zadeklarowanej zasady.

Każda zadeklarowana zasada odpowiada pewnej liczbie powiązanych metod zasad dotyczących urządzeń w DevicePolicyManager (zdefiniowaną minimalną długość hasła i minimalną liczbę wielkie litery to dwa przykłady). Jeśli aplikacja próbuje wywołać metody, których odpowiednia zasada nie jest zadeklarowana w pliku XML, spowoduje to wywołanie SecurityException w czasie działania. inne uprawnienia, takie jak force-lock, są dostępne, jeśli aplikacja zamierza zarządzać innych rodzajów zasad. Jak zobaczysz później, w trakcie procesu aktywacji administratora lista zadeklarowanych zasad zostanie wyświetlona na ekranie systemu.

Ten fragment deklaruje zasady dotyczące limitów haseł w res/xml/device_admin.xml:

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

Kod XML deklaracji zasad, do którego odwołuje się plik manifestu Androida:

<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>

Tworzenie odbiornika administrowania urządzeniem

Utwórz odbiornik do administrowania urządzeniem, który będzie otrzymywać powiadomienia o zdarzeniach związanych z obsługiwanymi przez Ciebie zasadami. Aplikacja może wybiórczo zastąpić metody wywołania zwrotnego.

W przykładowej aplikacji Administrator urządzenia, gdy administrator urządzenia zostanie zdezaktywowany przez użytkownika, skonfigurowane zasady są usuwane z preferencji wspólnych. Zastanów się, logikę biznesową odpowiednią do Twojego przypadku użycia. Na przykład aplikacja może potrzebować działania mające na celu zminimalizowanie ryzyka związanego z bezpieczeństwem przez wdrożenie kilku kombinacji usuwania danych wrażliwych wyłączając zdalną synchronizację, powiadamiając administratora itp.

Aby odbiornik działał, zarejestruj go w pliku manifestu Androida, jak pokazano we fragmencie kodu powyżej.

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();
    }
}

Aktywowanie administratora urządzenia

Przed wyegzekwowaniem zasad użytkownik musi ręcznie aktywować aplikację jako urządzenie . Fragment kodu poniżej pokazuje, jak wyzwolić ustawienia, w ramach których użytkownik może aktywować Twoją aplikację. Warto dodać tekst objaśniający, użytkownikom, dlaczego aplikacja prosi o przyznanie uprawnień administratora urządzenia, określając EXTRA_ADD_EXPLANATION dodatkowy w zamiarze.

Rysunek 1. Wyświetli się ekran aktywacji użytkownika, podaj opis zasad dotyczących urządzeń.

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);
}

Jeśli użytkownik wybierze „Aktywuj”, aplikacja staje się administratorem urządzenia i może rozpocząć proces konfigurowania i egzekwowania zasad.

Aplikacja musi być też przygotowana na obsługę sytuacji, w których użytkownik zrezygnuje. procesu aktywacji, naciskając przycisk Anuluj, przycisk Wstecz lub klawisz Home. Dlatego Pole onResume() w aktywności związanej z konfiguracją zasad musi mieć logikę aby ponownie ocenić warunek i udostępnić użytkownikowi opcję Aktywacja administratora urządzenia, jeśli niezbędną.

Wdrażanie kontrolera zasad dotyczących urządzeń

Po udanej aktywacji administratora urządzenia aplikacja skonfiguruje urządzenie. Menedżer zasad z żądaną zasadą. Pamiętaj, że do Androida z każdą wersją. Sprawdzanie wersji aplikacji jest odpowiednie, jeśli używasz przy jednoczesnej obsłudze starszych wersji platformy. Na przykład Hasło Minimum Zasady pisania wielkimi literami są dostępne tylko w interfejsie API na poziomie 11 (Honeycomb) lub wyższym. Następujący kod: pokazuje, jak sprawdzić wersję w czasie działania.

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);
}

W tym momencie zasada może wymuszać stosowanie tej zasady w aplikacji. Aplikacja nie ma dostępu do rzeczywistego używanego hasła blokady ekranu (za pomocą interfejsu Device Policy Manager API) może określić, czy dotychczasowe hasło jest zgodne z wymaganą zasadą. Jeśli okaże się, że hasło blokady ekranu jest niewystarczające. Interfejs API administrowania urządzeniem nie pobiera automatycznie działania naprawcze. Obowiązkiem aplikacji jest jednoznaczne uruchomienie systemu ekran zmiany hasła w aplikacji Ustawienia. Na przykład:

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);
}

Normalnie użytkownik może wybrać jeden z dostępnych mechanizmów blokowania, takich jak Brak, Wzór, Kod PIN (numeryczny) lub Hasło (alfanumeryczny). Jeśli są skonfigurowane zasady dotyczące haseł, typy słabsze od zdefiniowanych w zasadzie są wyłączane. Na przykład, jeśli plik Skonfigurowano jakość hasła „liczbową”. Użytkownik może wybrać kod PIN (liczbowy) lub hasło. (tylko w formacie alfanumerycznym).

Po prawidłowym zabezpieczeniu urządzenia przez ustawienie prawidłowego hasła blokady ekranu aplikacja umożliwia dostęp do zabezpieczonej treści.

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));
}