Diese Seite wurde von der Cloud Translation API übersetzt.

App-Sicherheit verbessern

Wenn Sie Ihre App sicherer machen, tragen Sie dazu bei, das Vertrauen der Nutzer und die Geräteintegrität zu wahren.

Auf dieser Seite werden mehrere Best Practices vorgestellt, die sich spürbar positiv auf die Sicherheit Ihrer App auswirken.

Sichere Kommunikation erzwingen

Wenn Sie den Datenaustausch zwischen Ihrer App und anderen Apps oder zwischen Ihrer App und einer Website absichern, indem Sie eine sichere Kommunikation erzwingen, verbessern Sie die Stabilität Ihrer App und schützen die Daten, die Sie senden und empfangen.

Kommunikation zwischen Apps absichern

Um die Kommunikation zwischen Apps sicherer zu gestalten, sollten Sie implizite Intents mit einer App-Auswahl, signaturbasierte Berechtigungen und nicht exportierte Contentanbieter verwenden.

App-Auswahl anzeigen

Wenn ein impliziter Intent dazu führt, dass auf dem Gerät des Nutzers mindestens zwei mögliche Apps gestartet werden können, muss explizit eine App-Auswahl angezeigt werden. Mit dieser Interaktionsstrategie können Nutzer vertrauliche Informationen an eine App übertragen, der sie vertrauen.

Kotlin

val intent = Intent(Intent.ACTION_SEND)
val possibleActivitiesList: List<ResolveInfo> =
        packageManager.queryIntentActivities(intent, PackageManager.MATCH_ALL)

// Verify that an activity in at least two apps on the user's device
// can handle the intent. Otherwise, start the intent only if an app
// on the user's device can handle the intent.
if (possibleActivitiesList.size > 1) {

    // Create intent to show chooser.
    // Title is something similar to "Share this photo with."

    val chooser = resources.getString(R.string.chooser_title).let { title ->
        Intent.createChooser(intent, title)
    }
    startActivity(chooser)
} else if (intent.resolveActivity(packageManager) != null) {
    startActivity(intent)
}

Java

Intent intent = new Intent(Intent.ACTION_SEND);
List<ResolveInfo> possibleActivitiesList = getPackageManager()
        .queryIntentActivities(intent, PackageManager.MATCH_ALL);

// Verify that an activity in at least two apps on the user's device
// can handle the intent. Otherwise, start the intent only if an app
// on the user's device can handle the intent.
if (possibleActivitiesList.size() > 1) {

    // Create intent to show chooser.
    // Title is something similar to "Share this photo with."

    String title = getResources().getString(R.string.chooser_title);
    Intent chooser = Intent.createChooser(intent, title);
    startActivity(chooser);
} else if (intent.resolveActivity(getPackageManager()) != null) {
    startActivity(intent);
}

Weitere Informationen:

Signaturbasierte Berechtigungen anwenden

Wenn Sie Daten zwischen zwei Apps teilen, die Sie kontrollieren oder die Ihre eigenen sind, verwenden Sie signaturbasierte Berechtigungen. Für diese Berechtigungen ist keine Nutzerbestätigung erforderlich. Stattdessen wird geprüft, ob die Apps, die auf die Daten zugreifen, mit demselben Signaturschlüssel signiert sind. Durch die Verwendung dieser Berechtigungen vereinfachen Sie die Nutzung für die Nutzer und machen sie sicherer.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp">
    <permission android:name="my_custom_permission_name"
                android:protectionLevel="signature" />

Weitere Informationen:

Zugriff auf die Contentanbieter Ihrer App untersagen

Wenn Sie nicht beabsichtigen, Daten aus Ihrer App an eine andere App zu senden, die nicht Ihre eigene ist, sollten Sie Apps anderer Entwickler den Zugriff auf die ContentProvider-Objekte Ihrer App explizit untersagen. Diese Einstellung ist besonders wichtig, wenn Ihre App auf Geräten mit Android 4.1.1 (API‑Level 16) oder niedriger installiert werden kann, da das Attribut android:exported des Elements <provider> in diesen Android-Versionen standardmäßig true ist.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp">
    <application ... >
        <provider
            android:name="android.support.v4.content.FileProvider"
            android:authorities="com.example.myapp.fileprovider"
            ...
            android:exported="false">
            <!-- Place child elements of <provider> here. -->
        </provider>
        ...
    </application>
</manifest>

Vor dem Anzeigen vertraulicher Informationen nach Anmeldedaten fragen

Wenn Sie Anmeldedaten von Nutzern anfordern, damit sie in Ihrer App auf vertrauliche Informationen oder Premium-Inhalte zugreifen können, fragen Sie entweder nach einer PIN, einem Passwort oder einem Muster oder nach biometrischen Anmeldedaten wie Gesichtserkennung oder Fingerabdruckerkennung.

Weitere Informationen zum Anfordern biometrischer Anmeldedaten finden Sie im Leitfaden zur biometrischen Authentifizierung.

Netzwerksicherheitsmaßnahmen anwenden

In den folgenden Abschnitten wird beschrieben, wie Sie die Netzwerksicherheit Ihrer App verbessern können.

TLS-Traffic verwenden

Wenn Ihre App mit einem Webserver kommuniziert, der ein Zertifikat von einer bekannten, vertrauenswürdigen Zertifizierungsstelle (CA) hat, verwenden Sie eine HTTPS-Anfrage wie die folgende:

Kotlin

val url = URL("https://www.google.com")
val urlConnection = url.openConnection() as HttpsURLConnection
urlConnection.connect()
urlConnection.inputStream.use {
    ...
}

Java

URL url = new URL("https://www.google.com");
HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
urlConnection.connect();
InputStream in = urlConnection.getInputStream();

Netzwerksicherheitskonfiguration hinzufügen

Wenn Ihre App neue oder benutzerdefinierte Zertifizierungsstellen verwendet, können Sie die Sicherheitseinstellungen Ihres Netzwerks in einer Konfigurationsdatei deklarieren. Mit diesem Verfahren können Sie die Konfiguration erstellen, ohne den App-Code zu ändern.

So fügen Sie Ihrer App eine Datei mit der Netzwerksicherheitskonfiguration hinzu:

Deklarieren Sie die Konfiguration im Manifest Ihrer App:

<manifest ... >
    <application
        android:networkSecurityConfig="@xml/network_security_config"
        ... >
        <!-- Place child elements of <application> element here. -->
    </application>
</manifest>

Fügen Sie eine XML-Ressourcendatei unter res/xml/network_security_config.xml hinzu.

Geben Sie an, dass für den gesamten Traffic zu bestimmten Domains HTTPS verwendet werden muss, indem Sie die Klartext-Übertragung deaktivieren:
```
<network-security-config>
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">secure.example.com</domain>
        ...
    </domain-config>
</network-security-config>
```
Während der Entwicklung können Sie das Element <debug-overrides> verwenden, um explizit vom Nutzer installierte Zertifikate zuzulassen. Dieses Element überschreibt die sicherheitskritischen Optionen Ihrer App während des Debuggens und Testens, ohne die Releasekonfiguration der App zu beeinträchtigen. Das folgende Snippet zeigt, wie Sie dieses Element in der XML-Datei für die Netzwerksicherheitskonfiguration Ihrer App definieren:
```
<network-security-config>
    <debug-overrides>
        <trust-anchors>
            <certificates src="user" />
        </trust-anchors>
    </debug-overrides>
</network-security-config>
```

Weitere Informationen: Konfiguration der Netzwerksicherheit

Eigenen Trust Manager erstellen

Ihr TLS-Checker sollte nicht jedes Zertifikat akzeptieren. Möglicherweise empfiehlt es sich, einen Trust Manager einzurichten, der sich um alle TLS-Warnungen kümmert, die auftreten, wenn für Ihren Anwendungsfall eine der folgenden Bedingungen gilt:

Sie kommunizieren mit einem Webserver, der ein Zertifikat hat, das von einer neuen oder benutzerdefinierten Zertifizierungsstelle signiert wurde.
Die Zertifizierungsstelle wird von dem Gerät, das Sie verwenden, nicht als vertrauenswürdig eingestuft.
Sie können keine Netzwerksicherheitskonfiguration verwenden.

Weitere Informationen zum Ausführen dieser Schritte finden Sie im Abschnitt zum Umgang mit einer unbekannten Zertifizierungsstelle.

Weitere Informationen:

WebView-Objekte mit Bedacht verwenden

WebView-Objekte in Ihrer App sollten Nutzer nicht zu Websites weiterleiten, die nicht unter Ihrer Kontrolle stehen. Verwenden Sie nach Möglichkeit eine Zulassungsliste, um die Inhalte einzuschränken, die die WebView-Objekte Ihrer App laden dürfen.

Aktivieren Sie außerdem niemals die Unterstützung der JavaScript-Schnittstelle, es sei denn, Sie haben die vollständige Kontrolle über die Inhalte in den WebView-Objekten Ihrer App und vertrauen ihnen.

HTML-Nachrichtenkanäle verwenden

Wenn Ihre App auf Geräten mit Android 6.0 (API-Level 23) und höher die Unterstützung von JavaScript-Schnittstellen verwenden muss, verwenden Sie HTML-Nachrichtenkanäle, statt die direkte Kommunikation zwischen einer Website und Ihrer App zuzulassen. Dies wird im folgenden Code-Snippet gezeigt:

Kotlin

val myWebView: WebView = findViewById(R.id.webview)

// channel[0] and channel[1] represent the two ports.
// They are already entangled with each other and have been started.
val channel: Array<out WebMessagePort> = myWebView.createWebMessageChannel()

// Create handler for channel[0] to receive messages.
channel[0].setWebMessageCallback(object : WebMessagePort.WebMessageCallback() {

    override fun onMessage(port: WebMessagePort, message: WebMessage) {
        Log.d(TAG, "On port $port, received this message: $message")
    }
})

// Send a message from channel[1] to channel[0].
channel[1].postMessage(WebMessage("My secure message"))

Java

WebView myWebView = (WebView) findViewById(R.id.webview);

// channel[0] and channel[1] represent the two ports.
// They are already entangled with each other and have been started.
WebMessagePort[] channel = myWebView.createWebMessageChannel();

// Create handler for channel[0] to receive messages.
channel[0].setWebMessageCallback(new WebMessagePort.WebMessageCallback() {
    @Override
    public void onMessage(WebMessagePort port, WebMessage message) {
         Log.d(TAG, "On port " + port + ", received this message: " + message);
    }
});

// Send a message from channel[1] to channel[0].
channel[1].postMessage(new WebMessage("My secure message"));

Weitere Informationen:

WebMessage
WebMessagePort

Die richtigen Berechtigungen erteilen

Fordern Sie nur die Mindestanzahl an Berechtigungen an, die für die ordnungsgemäße Funktion Ihrer App erforderlich sind. Entziehen Sie Berechtigungen nach Möglichkeit wieder, wenn Ihre App sie nicht mehr benötigt.

Berechtigungen mit Intents delegieren

Fügen Sie Ihrer App nach Möglichkeit keine Berechtigung hinzu, damit sie eine Aktion ausführt, die auch in einer anderen App ausgeführt werden kann. Verwenden Sie stattdessen einen Intent, um die Anfrage an eine andere App zu delegieren, die bereits die erforderliche Berechtigung hat.

Das folgende Beispiel zeigt, wie Sie Nutzer mithilfe eines Intents zu einer Kontakte-App weiterleiten, anstatt die Berechtigungen READ_CONTACTS und WRITE_CONTACTS anzufordern:

Kotlin

// Delegates the responsibility of creating the contact to a contacts app,
// which has already been granted the appropriate WRITE_CONTACTS permission.
Intent(Intent.ACTION_INSERT).apply {
    type = ContactsContract.Contacts.CONTENT_TYPE
}.also { intent ->
    // Make sure that the user has a contacts app installed on their device.
    intent.resolveActivity(packageManager)?.run {
        startActivity(intent)
    }
}

Java

// Delegates the responsibility of creating the contact to a contacts app,
// which has already been granted the appropriate WRITE_CONTACTS permission.
Intent insertContactIntent = new Intent(Intent.ACTION_INSERT);
insertContactIntent.setType(ContactsContract.Contacts.CONTENT_TYPE);

// Make sure that the user has a contacts app installed on their device.
if (insertContactIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(insertContactIntent);
}

Wenn Ihre App dateibasierte E/A-Vorgänge ausführen muss, z. B. auf den Speicher zugreifen oder eine Datei auswählen, sind keine speziellen Berechtigungen erforderlich, da das System die Vorgänge im Namen Ihrer App ausführen kann. Noch besser: Nachdem ein Nutzer Inhalte unter einem bestimmten URI ausgewählt hat, erhält die aufrufende App die Berechtigung für die ausgewählte Ressource.

Weitere Informationen:

Häufige Intents
Intent

Mit den folgenden Best Practices können Sie die Inhalte Ihrer App sicherer mit anderen Apps teilen:

Erzwingen Sie, je nach Bedarf, Nur-lesen- oder Nur-schreiben-Berechtigungen.
Nutzen Sie die Flags FLAG_GRANT_READ_URI_PERMISSION und FLAG_GRANT_WRITE_URI_PERMISSION, um Clients lediglich einmaligen Zugriff auf Daten zu gewähren.
Verwenden Sie beim Teilen von Daten statt file://-URIs lieber content://-URIs. Das können Instanzen von FileProvider für Sie übernehmen.

Das folgende Code-Snippet zeigt, wie Sie URI-Berechtigungsflags und Contentanbieterberechtigungen verwenden, damit die PDF-Datei einer App in einer separaten PDF-Viewer-App angezeigt wird:

Kotlin

// Create an Intent to launch a PDF viewer for a file owned by this app.
Intent(Intent.ACTION_VIEW).apply {
    data = Uri.parse("content://com.example/personal-info.pdf")

    // This flag gives the started app read access to the file.
    addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
}.also { intent ->
    // Make sure that the user has a PDF viewer app installed on their device.
    intent.resolveActivity(packageManager)?.run {
        startActivity(intent)
    }
}

Java

// Create an Intent to launch a PDF viewer for a file owned by this app.
Intent viewPdfIntent = new Intent(Intent.ACTION_VIEW);
viewPdfIntent.setData(Uri.parse("content://com.example/personal-info.pdf"));

// This flag gives the started app read access to the file.
viewPdfIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

// Make sure that the user has a PDF viewer app installed on their device.
if (viewPdfIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(viewPdfIntent);
}

Hinweis: Das Ausführen von Dateien direkt vom beschreibbaren App-Home-Verzeichnis aus ist ein W^X-Verstoß. Aus diesem Grund können nicht vertrauenswürdige Apps, die auf Android 10 (API-Level 29) und höher ausgerichtet sind, exec() nicht für Dateien im Home-Verzeichnis der App aufrufen, sondern nur für den Binärcode, der in der APK-Datei der App eingebettet ist. Außerdem dürfen Apps, die auf Android 10 und höher ausgerichtet sind, im Arbeitsspeicher keinen ausführbaren Code aus Dateien ändern, die mit dlopen() geöffnet wurden. Dazu gehören alle Dateien mit gemeinsam genutzten Objekten (.so) mit Text-Relokationen.

Weitere Informationen: android:grantUriPermissions

Daten sicher speichern

Sollte Ihre App Zugriff auf vertrauliche Nutzerinformationen benötigen, sollten Sie beachten, dass die Nutzer nur dann Zugriff auf ihre Daten gewähren, wenn sie Ihnen vertrauen.

Private Daten im internen Speicher speichern

Speichern Sie alle privaten Nutzerdaten im internen Speicher des Geräts, in dem jede App in einer eigenen Sandbox ausgeführt wird. Ihre App muss keine Berechtigung zum Anzeigen dieser Dateien anfordern und andere Apps können nicht auf die Dateien zugreifen. Als zusätzliche Sicherheitsmaßnahme werden beim Deinstallieren einer App alle Dateien gelöscht, die von der App im internen Speicher gespeichert wurden.

Das folgende Code-Snippet zeigt eine Möglichkeit, Daten in den internen Speicher zu schreiben:

Kotlin

// Creates a file with this name, or replaces an existing file
// that has the same name. Note that the file name cannot contain
// path separators.
val FILE_NAME = "sensitive_info.txt"
val fileContents = "This is some top-secret information!"
File(filesDir, FILE_NAME).bufferedWriter().use { writer ->
    writer.write(fileContents)
}

Java

// Creates a file with this name, or replaces an existing file
// that has the same name. Note that the file name cannot contain
// path separators.
final String FILE_NAME = "sensitive_info.txt";
String fileContents = "This is some top-secret information!";
try (BufferedWriter writer =
             new BufferedWriter(new FileWriter(new File(getFilesDir(), FILE_NAME)))) {
    writer.write(fileContents);
} catch (IOException e) {
    // Handle exception.
}

Das folgende Code-Snippet zeigt den umgekehrten Vorgang, das Lesen von Daten aus dem internen Speicher:

Kotlin

val FILE_NAME = "sensitive_info.txt"
val contents = File(filesDir, FILE_NAME).bufferedReader().useLines { lines ->
    lines.fold("") { working, line ->
        "$working\n$line"
    }
}

Java

final String FILE_NAME = "sensitive_info.txt";
StringBuffer stringBuffer = new StringBuffer();
try (BufferedReader reader =
             new BufferedReader(new FileReader(new File(getFilesDir(), FILE_NAME)))) {

    String line = reader.readLine();
    while (line != null) {
        stringBuffer.append(line).append('\n');
        line = reader.readLine();
    }
} catch (IOException e) {
    // Handle exception.
}

Weitere Informationen:

Daten je nach Anwendungsfall in externem Speicher speichern

Verwenden Sie externen Speicher für große, nicht vertrauliche Dateien, die für Ihre App spezifisch sind, sowie für Dateien, die Ihre App mit anderen Apps teilt. Welche APIs Sie verwenden, hängt davon ab, ob Ihre App für den Zugriff auf app-spezifische Dateien oder auf freigegebene Dateien konzipiert ist.

Wenn eine Datei keine privaten oder vertraulichen Informationen enthält, aber nur in Ihrer App für den Nutzer von Nutzen ist, speichern Sie die Datei in einem app-spezifischen Verzeichnis auf dem externen Speicher.

Wenn Ihre App auf eine Datei zugreifen oder eine Datei speichern muss, die für andere Apps von Nutzen ist, verwenden Sie je nach Anwendungsfall eine der folgenden APIs:

Mediendateien: Wenn Sie Bilder, Audiodateien und Videos haben, die zwischen Apps geteilt werden, und diese speichern und auf sie zugreifen möchten, verwenden Sie die Media Store API.
Andere Dateien:Wenn Sie andere Arten von freigegebenen Dateien haben, einschließlich heruntergeladener Dateien, und diese speichern und auf sie zugreifen möchten, verwenden Sie das Storage Access Framework.

Verfügbarkeit des Speichervolumes prüfen

Wenn Ihre App mit einem Wechseldatenträger interagiert, sollten Sie bedenken, dass es passieren kann, dass der Nutzer das Speichermedium entfernt, während Ihre App gerade darauf zugreift. Sorgen Sie daher dafür, dass Ihre App vorab prüft, dass das Speichermedium verfügbar ist.

Gültigkeit von Daten prüfen

Wenn Ihre App Daten aus dem externen Speicher verwendet, lassen Sie die App vorab prüfen, dass diese Daten weder korrumpiert wurden noch dass ihr Inhalt geändert wurde. Sorgen Sie dafür, dass die App mit Daten umgehen kann, deren Format nicht mehr stabil ist.

Das folgende Code-Snippet enthält ein Beispiel für einen Hash-Prüfer:

Kotlin

val hash = calculateHash(stream)
// Store "expectedHash" in a secure location.
if (hash == expectedHash) {
    // Work with the content.
}

// Calculating the hash code can take quite a bit of time, so it shouldn't
// be done on the main thread.
suspend fun calculateHash(stream: InputStream): String {
    return withContext(Dispatchers.IO) {
        val digest = MessageDigest.getInstance("SHA-512")
        val digestStream = DigestInputStream(stream, digest)
        while (digestStream.read() != -1) {
            // The DigestInputStream does the work; nothing for us to do.
        }
        digest.digest().joinToString(":") { "%02x".format(it) }
    }
}

Java

Executor threadPoolExecutor = Executors.newFixedThreadPool(4);
private interface HashCallback {
    void onHashCalculated(@Nullable String hash);
}

boolean hashRunning = calculateHash(inputStream, threadPoolExecutor, hash -> {
    if (Objects.equals(hash, expectedHash)) {
        // Work with the content.
    }
});

if (!hashRunning) {
    // There was an error setting up the hash function.
}

private boolean calculateHash(@NonNull InputStream stream,
                              @NonNull Executor executor,
                              @NonNull HashCallback hashCallback) {
    final MessageDigest digest;
    try {
        digest = MessageDigest.getInstance("SHA-512");
    } catch (NoSuchAlgorithmException nsa) {
        return false;
    }

    // Calculating the hash code can take quite a bit of time, so it shouldn't
    // be done on the main thread.
    executor.execute(() -> {
        String hash;
        try (DigestInputStream digestStream =
                new DigestInputStream(stream, digest)) {
            while (digestStream.read() != -1) {
                // The DigestInputStream does the work; nothing for us to do.
            }
            StringBuilder builder = new StringBuilder();
            for (byte aByte : digest.digest()) {
                builder.append(String.format("%02x", aByte)).append(':');
            }
            hash = builder.substring(0, builder.length() - 1);
        } catch (IOException e) {
            hash = null;
        }

        final String calculatedHash = hash;
        runOnUiThread(() -> hashCallback.onHashCalculated(calculatedHash));
    });
    return true;
}

In Cache-Dateien nur Daten speichern, die nicht vertraulich sind

Nicht vertrauliche App-Daten können im Cache des Geräts gespeichert werden, von wo aus schneller auf sie zugegriffen werden kann. Wenn der Cache größer als 1 MB ist, verwenden Sie getExternalCacheDir(). Ist der Cache nicht größer als 1 MB, verwenden Sie getCacheDir(). Bei beiden Methoden kann das File-Objekt genutzt werden, das die im Cache gespeicherten Daten Ihrer App enthält.

Das folgende Code-Snippet zeigt, wie eine Datei im Cache gespeichert werden kann, die Ihre App vor Kurzem heruntergeladen hat:

Kotlin

val cacheFile = File(myDownloadedFileUri).let { fileToCache ->
    File(cacheDir.path, fileToCache.name)
}

Java

File cacheDir = getCacheDir();
File fileToCache = new File(myDownloadedFileUri);
String fileToCacheName = fileToCache.getName();
File cacheFile = new File(cacheDir.getPath(), fileToCacheName);

Hinweis: Wenn Sie den Cache Ihrer App mithilfe von getExternalCacheDir() im freigegebenen Speicher platzieren, sollten Sie die App auf den Fall vorbereiten, dass der Nutzer plötzlich das Medium mit diesem Speicher entfernt, während Ihre App noch läuft. Sorgen Sie dafür, dass die App mit diesem durch den Nutzer verursachten Cacheverlust angemessen umgehen kann.

Achtung: Für diese Dateien wird keine Sicherheit erzwungen. Daher kann jede App, die auf Android 10 (API‑Level 29) oder niedriger ausgerichtet ist und die Berechtigung WRITE_EXTERNAL_STORAGE hat, auf die Inhalte dieses Cache zugreifen.

Weitere Informationen: Daten- und Dateispeicher – Übersicht

SharedPreferences im privaten Modus verwenden

Wenn Sie getSharedPreferences() verwenden, um die SharedPreferences-Objekte Ihrer App zu erstellen oder darauf zuzugreifen, verwenden Sie MODE_PRIVATE. So kann nur Ihre App auf die Informationen in der Datei mit den freigegebenen Einstellungen zugreifen.

Wenn Sie Daten zwischen Apps freigeben möchten, verwenden Sie keine SharedPreferences-Objekte. Folgen Sie stattdessen der Anleitung zum sicheren Teilen von Daten zwischen Apps.

Weitere Informationen:

Daten- und Dateispeicher – Übersicht

Dienste und Abhängigkeiten auf dem neuesten Stand halten

Die meisten Apps verwenden externe Bibliotheken und Geräteinformationen, um spezielle Aufgaben auszuführen. Wenn Sie die Abhängigkeiten Ihrer App auf dem neuesten Stand halten, machen Sie diese Kommunikationspunkte sicherer.

Sicherheitsanbieter der Google Play-Dienste prüfen

Hinweis: Dieser Abschnitt gilt nur für Apps, die auf Geräte mit installierten Google Play-Diensten ausgerichtet sind.

Wenn Ihre App die Google Play-Dienste verwendet, müssen diese auf dem Gerät, auf dem die App installiert ist, aktualisiert werden. Führen Sie die Prüfung asynchron außerhalb des UI-Threads durch. Wenn das Gerät nicht auf dem neuesten Stand ist, sollte ein Autorisierungsfehler ausgelöst werden.

Wenn Sie prüfen möchten, ob die Google Play-Dienste auf dem Gerät, auf dem Ihre App installiert ist, auf dem neuesten Stand sind, folgen Sie der Anleitung unter Sicherheitsanbieter zum Schutz vor SSL-Exploits aktualisieren.

Weitere Informationen:

Alle App-Abhängigkeiten aktualisieren

Prüfen Sie vor der Bereitstellung Ihrer App, ob alle Bibliotheken, SDKs und anderen Abhängigkeiten auf dem neuesten Stand sind:

Verwenden Sie für Erstanbieterabhängigkeiten wie das Android SDK die Aktualisierungstools in Android Studio, z. B. den SDK-Manager.
Prüfen Sie bei Drittanbieterabhängigkeiten die Websites der Bibliotheken, die Ihre App verwendet, und installieren Sie alle verfügbaren Updates und Sicherheitspatches.

Zugehörige Informationen: Build-Abhängigkeiten hinzufügen

Weitere Informationen

Weitere Informationen dazu, wie Sie Ihre App sicherer machen können, finden Sie in den folgenden Ressourcen:

Checkliste zur Sicherheit von Apps
Programm zur Verbesserung der App-Sicherheit
YouTube-Kanal für Android-Entwickler
Android Protected Confirmation: Taking transaction security to the next level (Durch Android geschützte Bestätigung: Transaktionssicherheit auf einem ganz neuen Niveau)

App-Sicherheit verbessern Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Sichere Kommunikation erzwingen

Kommunikation zwischen Apps absichern

App-Auswahl anzeigen

Kotlin

Java

Signaturbasierte Berechtigungen anwenden

Zugriff auf die Contentanbieter Ihrer App untersagen

Vor dem Anzeigen vertraulicher Informationen nach Anmeldedaten fragen

Netzwerksicherheitsmaßnahmen anwenden

TLS-Traffic verwenden

Kotlin

Java

Netzwerksicherheitskonfiguration hinzufügen

Eigenen Trust Manager erstellen

WebView-Objekte mit Bedacht verwenden

HTML-Nachrichtenkanäle verwenden

Kotlin

Java

Die richtigen Berechtigungen erteilen

Berechtigungen mit Intents delegieren

Kotlin

Java

Daten sicher zwischen Apps teilen

Kotlin

Java

Daten sicher speichern

Private Daten im internen Speicher speichern

Kotlin

Java

Kotlin

Java

Daten je nach Anwendungsfall in externem Speicher speichern

Verfügbarkeit des Speichervolumes prüfen

Gültigkeit von Daten prüfen

Kotlin

Java

In Cache-Dateien nur Daten speichern, die nicht vertraulich sind

Kotlin

Java

SharedPreferences im privaten Modus verwenden

Dienste und Abhängigkeiten auf dem neuesten Stand halten

Sicherheitsanbieter der Google Play-Dienste prüfen

Alle App-Abhängigkeiten aktualisieren

Weitere Informationen

App-Sicherheit verbessern