Mehr Sicherheit mit Richtlinien zur Geräteverwaltung

Einstellung des Geräteadministrators Einige Administratorrichtlinien wurden beim Aufrufen als veraltet markiert von einem Geräteadministrator. Weitere Informationen und die Migrationsoptionen finden Sie unter <ph type="x-smartling-placeholder"></ph> Einstellung des Geräteadministrators

Seit Android 2.2 (API-Level 8) bietet die Android-Plattform eine Geräteverwaltung auf Systemebene über die Device Administration APIs nutzen können.

In dieser Lektion erfahren Sie, wie Sie eine sicherheitsbewusste Anwendung erstellen, die den Zugriff auf durch Erzwingen von Richtlinien zur Geräteverwaltung. Insbesondere kann die Anwendung so konfiguriert werden, dass ein ausreichend starkes Passwort für die Displaysperre eingerichtet ist, eingeschränkte Inhalte für den Nutzer.

Richtlinie definieren und deklarieren

Zuerst müssen Sie festlegen, welche Richtlinientypen auf Funktionsebene unterstützt werden sollen. Richtlinien können die Passwortstärke für die Displaysperre, das Ablauf-Zeitlimit, die Verschlüsselung usw. abdecken.

Sie müssen den ausgewählten Richtliniensatz, der von der Anwendung durchgesetzt wird, in der res/xml/device_admin.xml-Datei. Das Android-Manifest sollte auch auf die deklarierte Richtlinie festgelegt.

Jede deklarierte Richtlinie entspricht einer Reihe zugehöriger Geräterichtlinienmethoden in DevicePolicyManager (d. h. die Mindestlänge des Passworts und die Mindestanzahl von sind zwei Beispiele). Wenn eine Anwendung versucht, Methoden aufzurufen, entsprechende Richtlinie nicht in der XML-Datei deklariert ist, führt dies zur SecurityException-Laufzeit. Weitere Berechtigungen, wie force-lock, sind verfügbar, wenn mit der Anwendung andere Arten von Richtlinien. Sie werden später bei der Aktivierung des Geräteadministrators Die Liste der deklarierten Richtlinien wird dem Nutzer auf einem Systembildschirm angezeigt.

Das folgende Snippet deklariert die Richtlinie zur Beschränkung von Passwörtern in 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-Datei zur Richtliniendeklaration, auf die im Android-Manifest verwiesen wird:

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

Empfänger für Geräteverwaltung erstellen

Erstellen Sie einen Übertragungsempfänger für die Geräteverwaltung, der über Ereignisse im Zusammenhang mit den von Ihnen angegebenen Richtlinien benachrichtigt wird. Eine Anwendung kann Callback-Methoden selektiv überschreiben.

Wenn der Geräteadministrator in der Beispielanwendung Device Admin durch den Nutzer, wird die konfigurierte Richtlinie aus der gemeinsamen Einstellung gelöscht. Sie sollten erwägen, die für Ihren Anwendungsfall relevant ist. Zum Beispiel benötigt die Anwendung Maßnahmen zur Minderung von Sicherheitsrisiken durch Implementierung einer Kombination aus dem Löschen sensibler Daten auf der Gerät, Deaktivieren der Remote-Synchronisierung, Benachrichtigung eines Administrators usw.

Damit der Übertragungsempfänger funktioniert, muss er wie im obigen Snippet im Android-Manifest registriert sein.

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

Geräteadministrator aktivieren

Bevor Richtlinien erzwungen werden, muss der Nutzer die Anwendung manuell als Gerät aktivieren Administrator. Das folgende Snippet veranschaulicht, wie die Einstellungsaktivität ausgelöst wird, in der die Nutzer Ihre Anwendung aktivieren können. Es empfiehlt sich, den erklärenden Text einzufügen, warum die Anwendung den Geräteadministrator anfordert, indem Sie die EXTRA_ADD_EXPLANATION Extra im Intent.

Abbildung 1: Der Aktivierungsbildschirm für den Nutzer, auf dem Sie eine Beschreibung Ihrer Geräterichtlinien.

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

Wenn der Nutzer „Aktivieren“ auswählt, wird die Anwendung ein Geräteadministrator und kann Konfiguration und Durchsetzung der Richtlinie.

Die Anwendung muss auch auf Situationen vorbereitet sein, in denen der Nutzer den Vorgang abbricht. des Aktivierungsprozesses durch Drücken der Taste "Abbrechen", der Zurück- oder der Home-Taste. Dementsprechend wird onResume() in der Aktivität zur Richtlinieneinrichtung muss eine Logik haben um den Zustand neu zu bewerten und dem Nutzer die Option zur Aktivierung des Geräteadministrators zu präsentieren, erforderlich.

Device Policy Controller implementieren

Nachdem der Geräteadministrator aktiviert wurde, konfiguriert die Anwendung das Gerät Richtlinienmanager mit der angeforderten Richtlinie. Denken Sie daran, dass neue Richtlinien Android mit jedem Release. Es empfiehlt sich, Versionsprüfungen in Ihrer Anwendung durchzuführen, wenn Sie neue Richtlinien zu entwickeln und gleichzeitig ältere Versionen der Plattform zu unterstützen. Zum Beispiel ist das Passwortminimum Die Richtlinie für Großbuchstaben ist nur ab API-Level 11 (Honeycomb) verfügbar. Der folgende Code zeigt, wie Sie die Version zur Laufzeit prüfen können.

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

Jetzt kann die Anwendung die Richtlinie erzwingen. Solange die Anwendung keinen Zugriff hat das verwendete Passwort für die Displaysperre über die Device Policy Manager API ob das vorhandene Passwort die erforderliche Richtlinie erfüllt. Wenn sich herausstellt, nicht ausreichend ist, nimmt die Device Administration API nicht automatisch Korrekturmaßnahmen ergreifen. Es liegt in der Verantwortung der App, das System explizit zu starten Bildschirm zum Ändern des Passworts in der App "Einstellungen". Hier einige Beispiele:

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

Normalerweise kann der Nutzer einen der verfügbaren Sperrmechanismen auswählen, wie z. B. Kein, Muster, PIN (numerisch) oder Passwort (alphanumerisch) Wenn eine Passwortrichtlinie konfiguriert ist, Typen, die schwächer sind als die in der Richtlinie definierten, werden deaktiviert. Wenn zum Beispiel der Parameter Die Passwortqualität „Numerisch“ ist konfiguriert. Der Nutzer kann entweder eine PIN (numerisch) oder ein Passwort auswählen. (alphanumerisches) Passwort.

Sobald das Gerät durch die Einrichtung eines geeigneten Passworts für die Displaysperre geschützt ist, den Zugriff auf die gesicherten Inhalte ermöglicht.

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