שיפור האבטחה של האפליקציה

הגברת האבטחה של האפליקציה עוזרת לשמור על אמון המשתמשים ועל תקינות המכשיר.

בדף הזה מוצגות כמה שיטות מומלצות שיש להן השפעה משמעותית וחיובית על אבטחת האפליקציה.

אכיפת תקשורת מאובטחת

כשאתם מגינים על הנתונים שאתם מחליפים בין האפליקציה לבין אפליקציות אחרות, או בין האפליקציה לאתר, אפשר לשפר את היציבות של האפליקציה ולהגן על הנתונים שאתם שולחים ומקבלים.

הגנה על התקשורת בין אפליקציות

כדי לתקשר בין אפליקציות בצורה בטוחה יותר, כדאי להשתמש בכוונות משתמעות עם בורר אפליקציות, בהרשאות שמבוססות על חתימות ובספקי תוכן שלא מיוצאים.

הצגה של בורר האפליקציות

אם כוונה משתמעת יכולה להפעיל לפחות שתי אפליקציות אפשריות במכשיר של המשתמש, צריך להציג בבירור בורר אפליקציות. אסטרטגיית האינטראקציה הזו מאפשרת למשתמשים להעביר מידע רגיש לאפליקציה שהם סומכים עליה.

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

מידע קשור:

החלת הרשאות המבוססות על חתימה

כשמשתפים נתונים בין שתי אפליקציות שנמצאות בשליטתכם או בבעלותכם, צריך להשתמש בהרשאות מבוססות-חתימה. ההרשאות האלה לא מחייבות אישור מהמשתמש, אלא בודקות שהאפליקציות שגולשות בנתונים חתומות באמצעות אותו מפתח חתימה. לכן, ההרשאות האלה מספקות חוויית משתמש מאובטחת ויעילה יותר.

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

מידע קשור:

איסור גישה לספקי התוכן של האפליקציה

אם אתם לא מתכוונים לשלוח נתונים מהאפליקציה שלכם לאפליקציה אחרת שאינה בבעלותכם, אסור לאפליקציות של מפתחים אחרים לגשת לאובייקטים מסוג ContentProvider של האפליקציה שלכם. ההגדרה הזו חשובה במיוחד אם אפשר להתקין את האפליקציה במכשירים עם Android מגרסה 4.1.1 (רמת API 16) ומטה, כי המאפיין android:exported של הרכיב <provider> הוא true כברירת מחדל בגרסאות האלה של Android.

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

בקשה לפרטי כניסה לפני הצגת מידע רגיש

כשאתם מבקשים ממשתמשים להזין פרטי כניסה כדי שיוכלו לגשת למידע אישי רגיש או לתוכן פרימיום באפליקציה, בקשו מהם להזין קוד אימות, סיסמה או קו ביטול נעילה, או פרטי כניסה ביומטריים כמו זיהוי פנים או זיהוי טביעת אצבע.

למידע נוסף על שליחת בקשה לפרטי כניסה ביומטריים, ראו המדריך בנושא אימות ביומטרי.

יישום אמצעי אבטחת הרשת

בקטעים הבאים מוסבר איך לשפר את אבטחת הרשת של האפליקציה.

שימוש בתעבורת TLS

אם האפליקציה מתקשרת עם שרת אינטרנט שיש לו אישור שהונפק על ידי רשות אישורים (CA) מוכרת וידועה, צריך להשתמש בבקשת HTTPS כמו בדוגמה הבאה:

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

הוספת תצורה של אבטחת רשת

אם באפליקציה שלכם נעשה שימוש באישורים חדשים או בהתאמה אישית, אפשר להצהיר על הגדרות האבטחה של הרשת בקובץ התצורה. התהליך הזה מאפשר ליצור את ההגדרה בלי לשנות את קוד האפליקציה.

כדי להוסיף קובץ תצורה של אבטחת רשת לאפליקציה, מבצעים את הפעולות הבאות:

  1. צריך להצהיר על ההגדרה במניפסט של האפליקציה:
    2. <manifest ... >
    <application
        android:networkSecurityConfig="@xml/network_security_config"
        ... >
        <!-- Place child elements of <application> element here. -->
    </application>
</manifest>

  2. מוסיפים קובץ משאב XML שנמצא ב-res/xml/network_security_config.xml.

    כדי לציין שכל התנועה לדומיינים מסוימים חייבת להשתמש ב-HTTPS על ידי השבתת הטקסט הנקי:

    <network-security-config>
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">secure.example.com</domain>
        ...
    </domain-config>
</network-security-config>

    במהלך תהליך הפיתוח, אפשר להשתמש ברכיב <debug-overrides> כדי לאפשר באופן מפורש אישורים שהותקנו על ידי משתמשים. האלמנט הזה מבטל את האפשרויות של האפליקציה שחשובות לאבטחה במהלך ניפוי הבאגים והבדיקה, בלי להשפיע על הגדרות הגרסה של האפליקציה. קטע הקוד הבא מראה איך מגדירים את האלמנט הזה בקובץ ה-XML של הגדרות האבטחה ברשת של האפליקציה:

    <network-security-config>
    <debug-overrides>
        <trust-anchors>
            <certificates src="user" />
        </trust-anchors>
    </debug-overrides>
</network-security-config>

מידע קשור: תצורה של אבטחת רשת

יצירת מנהל אמון משלכם

בודק ה-TLS לא אמור לקבל כל אישור. יכול להיות שתצטרכו להגדיר מנהל אמון ולטפל בכל האזהרות של TLS שמופיעות אם אחד מהמצבים הבאים רלוונטי לתרחיש לדוגמה שלכם:

  • אתם מתקשרים עם שרת אינטרנט שיש לו אישור שנחתם על ידי רשות אישורים חדשה או מותאמת אישית.
  • המכשיר שבו אתם משתמשים לא סומך על רשות האישורים הזו.
  • אי אפשר להשתמש בתצורה של אבטחת הרשת.

בדיון על טיפול ברשות אישורים לא ידועה מוסבר איך מבצעים את השלבים האלה.

מידע קשור:

שימוש זהיר באובייקטים של WebView

באובייקטים של WebView באפליקציה אסור לאפשר למשתמשים לנווט לאתרים שלא בשליטתכם. כשאפשר, כדאי להשתמש ברשימת היתרים כדי להגביל את התוכן שנטען על ידי האובייקטים WebView של האפליקציה.

בנוסף, לעולם אל תפעילו תמיכה בממשק JavaScript, אלא אם אתם שולטים לחלוטין בתוכן באובייקטים WebView של האפליקציה ואתם סומכים עליו.

שימוש בערוצים להעברת הודעות בפורמט HTML

אם האפליקציה שלכם חייבת להשתמש בתמיכה בממשק JavaScript במכשירים עם Android 6.0 (רמת API 23) ואילך, צריך להשתמש בערוצי הודעות HTML במקום בתקשורת בין אתר לאפליקציה, כפי שמתואר בקטע הקוד הבא:

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

מידע קשור:

מתן ההרשאות המתאימות

בקשו רק את מספר ההרשאות המינימלי שנחוץ לאפליקציה כדי לפעול כראוי. כשאפשר, כדאי לבטל את ההרשאות כשלא צריך אותן יותר.

שימוש בכוונות כדי לדחות הרשאות

כשהדבר אפשרי, אל תוסיפו לאפליקציה הרשאה לביצוע פעולה שאפשר לבצע באפליקציה אחרת. במקום זאת, השתמשו בכוונה (intent) כדי להעביר את הבקשה לאפליקציה אחרת שכבר יש לה את ההרשאה הנדרשת.

בדוגמה הבאה מוסבר איך להשתמש בכוונה (intent) כדי להפנות משתמשים לאפליקציית אנשי קשר במקום לבקש את ההרשאות READ_CONTACTS ו-WRITE_CONTACTS:

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

בנוסף, אם האפליקציה צריכה לבצע פעולות קלט/פלט שמבוססות על קבצים – כמו גישה לאחסון או בחירה בקובץ – היא לא צריכה הרשאות מיוחדות כי המערכת יכולה להשלים את הפעולות בשם האפליקציה. יתרה מכך, אחרי שמשתמש בוחר תוכן בכתובת URI מסוימת, לאפליקציה המפעילה ניתנת הרשאה למשאב שנבחר.

מידע קשור:

שיתוף נתונים בצורה מאובטחת בין אפליקציות

כדי לשתף את התוכן של האפליקציה עם אפליקציות אחרות בצורה מאובטחת יותר, מומלץ לפעול לפי השיטות המומלצות הבאות:

  • לאכוף הרשאות קריאה בלבד או הרשאות כתיבה בלבד לפי הצורך.
  • הענקת גישה חד-פעמית לנתונים ללקוחות באמצעות הדגלים FLAG_GRANT_READ_URI_PERMISSION ו-FLAG_GRANT_WRITE_URI_PERMISSION.
  • כשמשתפים נתונים, צריך להשתמש במזהי URI של content:// ולא ב-URI file://. מכונות של FileProvider עושות זאת בשבילכם.

קטע הקוד הבא מראה איך משתמשים בדגלים להענקת הרשאות URI ובהרשאות של ספקי תוכן כדי להציג קובץ PDF של אפליקציה באפליקציית צפייה ב-PDF נפרדת:

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

הערה: הפעלת קבצים מהספרייה הראשית של האפליקציה שניתנת לכתיבה היא הפרת W^X. לכן, אפליקציות לא מהימנות שמטרגטות את Android 10 ואילך (רמת API 29 ואילך) לא יכולות להפעיל את exec() בקובצי ספריית הבית של האפליקציה, אלא רק את הקוד הבינארי שמוטמע בקובץ ה-APK של האפליקציה. בנוסף, אפליקציות שמטרגטות את Android מגרסה 10 ואילך לא יכולות לשנות בזיכרון קוד הפעלה מקבצים שנפתחו באמצעות dlopen(). זה כולל כל קובץ של אובייקטים משותפים (.so) עם העברת טקסט למיקום אחר.

מידע קשור: android:grantUriPermissions

אחסון נתונים בצורה בטוחה

יכול להיות שהאפליקציה שלכם תצטרך גישה למידע רגיש של משתמשים, אבל המשתמשים יעניקו לאפליקציה גישה לנתונים שלהם רק אם הם סומכים עליכם שתגנו עליהם כראוי.

אחסון נתונים פרטיים באחסון הפנימי

לשמור את כל נתוני המשתמש הפרטיים באחסון הפנימי של המכשיר, שמוגדר כארגז חול לכל אפליקציה. האפליקציה לא צריכה לבקש הרשאה כדי להציג את הקבצים האלה, ולאפליקציות אחרות אין גישה לקבצים. כאמצעי אבטחה נוסף, כשמשתמש מסיר אפליקציה, המכשיר מוחק את כל הקבצים שהאפליקציה שמרה באחסון הפנימי.

קטע הקוד הבא מדגים דרך אחת לכתוב נתונים לאחסון הפנימי:

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

קטע הקוד הבא מציג את הפעולה ההפוכה, קריאת נתונים מהאחסון הפנימי:

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

מידע קשור:

אחסון נתונים באחסון חיצוני על סמך תרחיש לדוגמה

כדאי להשתמש באחסון חיצוני לקבצים גדולים שאינם רגישים וספציפיים לאפליקציה, וגם לקבצים שהאפליקציה משתפת עם אפליקציות אחרות. ממשקי ה-API הספציפיים שבהם אתם משתמשים תלויים בכך שהאפליקציה שלכם מיועדת לגשת לקבצים ספציפיים לאפליקציה או לגשת לקבצים משותפים.

אם קובץ לא מכיל מידע אישי או רגיש אבל מספק ערך למשתמש רק באפליקציה, כדאי לאחסן את הקובץ בספרייה ספציפית לאפליקציה באחסון חיצוני.

אם האפליקציה שלכם צריכה לגשת לקובץ שמספק ערך לאפליקציות אחרות או לאחסן אותו, תוכלו להשתמש באחד מממשקי ה-API הבאים, בהתאם לתרחיש לדוגמה שלכם:

  • קובצי מדיה: כדי לאחסן תמונות, קובצי אודיו וסרטונים ששותפו בין אפליקציות ולגשת אליהם, צריך להשתמש ב-Media Store API.
  • קבצים אחרים: כדי לאחסן סוגים אחרים של קבצים משותפים, כולל קבצים שהורדו, להשתמש במסגרת Storage Access כדי לאחסן ולגשת אליהם.

בדיקת הזמינות של נפח האחסון

חשוב לזכור שאם האפליקציה מקיימת אינטראקציה עם התקן אחסון חיצוני נשלף, המשתמש עשוי להסיר את התקן האחסון בזמן שהאפליקציה מנסה לגשת אליו. מוסיפים לוגיקה כדי לוודא שמכשיר האחסון זמין.

בדיקת תקינות הנתונים

אם האפליקציה משתמשת בנתונים מאחסון חיצוני, חשוב לוודא שתוכן הנתונים לא פגום או השתנה. צריך לכלול לוגיקה לטיפול בקבצים שכבר לא בפורמט יציב.

קטע הקוד הבא כולל דוגמה לאימות גיבוב:

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

אחסון רק מידע לא רגיש בקובצי מטמון

כדי לספק גישה מהירה יותר לנתוני אפליקציות שאינם רגישים, כדאי לאחסן אותם במטמון של המכשיר. למטמון גדול מ-1MB, משתמשים ב-getExternalCacheDir(). למטמון בגודל 1MB ומטה, משתמשים ב-getCacheDir(). שתי ה-methods מספקות את האובייקט File שמכיל את הנתונים ששמורים במטמון של האפליקציה.

קטע הקוד הבא מראה איך לשמור במטמון קובץ שהאפליקציה הורדה לאחרונה:

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

הערה: אם תשתמשו ב-getExternalCacheDir() כדי להציב את המטמון של האפליקציה באחסון המשותף, יכול להיות שהמשתמש יוציא את המדיה שמכילה את נפח האחסון הזה בזמן שהאפליקציה פועלת. מומלץ לכלול לוגיקה לטיפול מושכל במקרים שבהם המטמון לא מחזיר נתונים בגלל התנהגות המשתמש הזו.

זהירות: אין אכיפה של אבטחה על הקבצים האלה. לכן, כל אפליקציה שמטרגטת ל-Android 10 (רמת API 29) או לגרסאות ישנות יותר, ויש לה את ההרשאה WRITE_EXTERNAL_STORAGE, יכולה לגשת לתוכן של המטמון הזה.

מידע קשור: סקירה כללית של נתונים ואחסון קבצים

שימוש ב-SharedPreferences במצב פרטי

כשמשתמשים ב-getSharedPreferences() כדי ליצור או לגשת לאובייקטים מסוג SharedPreferences של האפליקציה, צריך להשתמש ב-MODE_PRIVATE. כך רק לאפליקציה שלכם תהיה גישה למידע בקובץ ההעדפות המשותף.

אם רוצים לשתף נתונים בין אפליקציות, לא משתמשים באובייקטים מסוג SharedPreferences. במקום זאת, יש לפעול לפי השלבים לשיתוף נתונים באופן מאובטח בין אפליקציות.

ספריית האבטחה מספקת גם את המחלקה EncryptedSharedPreferences, שעופפת את המחלקה SharedPreferences ומצפין באופן אוטומטי מפתחות וערכים.

מידע קשור:

עדכון השירותים ויחסי התלות

רוב האפליקציות משתמשות בספריות חיצוניות ובמידע על מערכת המכשיר כדי לבצע משימות ייעודיות. אם תעדכנו את יחסי התלות של האפליקציה, נקודות התקשורת האלה יהיו מאובטחות יותר.

בדיקת ספק האבטחה של Google Play Services

הערה: הקטע הזה רלוונטי רק לאפליקציות שמטרגטות מכשירים שבהם מותקנת Google Play Services.

אם האפליקציה שלכם משתמשת ב-Google Play Services, חשוב לוודא שהיא מעודכנת במכשיר שבו היא מותקנת. לבצע את הבדיקה באופן אסינכרוני, מחוץ לשרשור של ממשק המשתמש. אם המכשיר לא מעודכן, תופעל שגיאת הרשאה.

כדי לבדוק אם Google Play Services עדכני במכשיר שבו מותקנת האפליקציה, פועלים לפי השלבים במדריך בנושא עדכון ספק האבטחה כדי להגן מפני ניצול לרעה של SSL.

מידע קשור:

עדכון כל יחסי התלות של האפליקציה

לפני הפריסה של האפליקציה, חשוב לוודא שכל הספריות, ערכות ה-SDK ויחסי התלות האחרים מעודכנים:

  • עבור יחסי תלות מאינטראקציה ישירה, כמו Android SDK, משתמשים בכלי העדכון שנמצאים ב-Android Studio, כמו SDK Manager.
  • לגבי יחסי תלות של צד שלישי, כדאי לבדוק את האתרים של הספריות שבהן האפליקציה משתמשת ולהתקין את כל העדכונים ותיקוני האבטחה הזמינים.

מידע קשור: הוספת יחסי תלות ל-build

מידע נוסף

למידע נוסף על שיפור האבטחה של האפליקציה, כדאי לעיין במקורות המידע הבאים: