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

כך תוכלו לשמור על אמון המשתמשים ועל שלמות המכשיר.

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

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

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

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

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

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

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

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

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

מידע שקשור לנושא:

• הצגת כלי לבחירת אפליקציה
• 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" />

מידע שקשור לנושא:

• חתימה על האפליקציה
• android:protectionLevel

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

אלא אם אתם מתכוונים לשלוח נתונים מהאפליקציה שלכם לאפליקציה אחרת שאינה בבעלותכם, עליכם להגדיר במפורש שאפליקציות של מפתחים אחרים לא יוכלו לגשת לאובייקטים של 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 כמו הבקשה הבאה:

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

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

הוספת הגדרת אבטחת רשת

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

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

1. מצהירים על ההגדרה במניפסט של האפליקציה:

<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, משביתים את האפשרות clear-text:

   <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 שמופיעות אם אחד מהתנאים הבאים רלוונטי לתרחיש השימוש שלכם:

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

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

מידע שקשור לנושא:

• אבטחה עם פרוטוקולי רשת
• CertificateFactory
• HttpsURLConnection
• TrustManager

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

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

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

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

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

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

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

מידע שקשור לנושא:

• WebMessage
• WebMessagePort

מתן ההרשאות הנכונות

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

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

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

בדוגמה הבאה מוצג אופן השימוש ב-Intent כדי להפנות משתמשים לאפליקציית אנשי קשר במקום לבקש את ההרשאות READ_CONTACTS ו-WRITE_CONTACTS:

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

// 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 מסוימת, לאפליקציה שקוראת ל-API ניתנת הרשאה למשאב שנבחר.

מידע שקשור לנושא:

• כוונות נפוצות
• Intent

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מידע שקשור לנושא:

• סקירה כללית על אחסון נתונים וקבצים
• FileInputStream
• FileOutputStream
• Context.MODE_PRIVATE

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

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

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

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

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

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

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

בדיקת התוקף של הנתונים

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

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

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

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(). שתי השיטות מספקות לכם את האובייקט File שמכיל את הנתונים שבמטמון של האפליקציה.

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

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

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. במקום זאת, פועלים לפי השלבים לשיתוף נתונים באופן מאובטח בין אפליקציות.

מידע שקשור לנושא:

• סקירה כללית על אחסון נתונים וקבצים

שמירה על עדכניות של שירותים ותלות

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

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

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

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

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

מידע שקשור לנושא:

• ProviderInstaller
• ProviderInstaller.ProviderInstallListener

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

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

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

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

מידע נוסף

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

• רשימת משימות לבדיקת איכות האבטחה של אפליקציות ליבה
• תוכנית לשיפור אבטחת אפליקציות
• הערוץ Android Developers ב-YouTube
• Android אישור מוגן: משדרגים את אבטחת העסקאות