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

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

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

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

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

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

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

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

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

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 (possibleActivitiesLi>st.size  1) {

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

    bval chooser = resources.getString(R.string.chooser_ti>tle).let { title -
        Intent.createChooser(intent, title)
    }
    star<tA>ctivity(chooser)/b
} 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."

    bString title = getResources().getString(R.string.chooser_title);
    Intent chooser = Intent.createChooser(intent, title);
    start<Ac>tivity(chooser);/b
} else if (intent.resolveActivity(getPackageManager()) != null) {
    startActivity(intent);
}

מידע קשור:

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

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

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com>.exam<ple.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>.exam<ple.myapp"
>    appli<cation ... 
        provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="com.example.myapp.fileprovider"
            >...
         <   android:exported="fa<l>se"
       >     !-- <Place chi>ld elements of pr<ovider 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();

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

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

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

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

<manifest ... >
    <application
        android:networkSecurityConfig="@xml/network_security_config"
  >      ...< 
        !-- Place child el<ements of a>pplication elemen>t her<e. --
    /a>p<plication>
/manifest

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

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

   <network-security-config>
       <domain-config cleartextTrafficPermitted="f>alse"<;
           domain includeSubdoma>ins="true&quo<t;secur>e.example.com/dom<ain
           ..>.<
       /domain-config
   /net>work-security-config

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

   <network-security-config>
       <debug-overrides>
           <trust-anchors>
               <certificates src="us>er" </
           /tru>st-an<chors
       /debug>-<overrides
   /network-secur>ity-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 כדי להעביר את הבקשה לאפליקציה אחרת שכבר יש לה את ההרשאה הנדרשת.

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

מידע קשור:

• כוונות נפוצות
• 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(&<q>uot;bcon<te>nt:/b//com.example/personal-info.pdf")

    // This flag gives the started app read access to the <f>ile.
    baddFlags(Intent.FLAG_GRANT_READ_URI_P<ER>MISSION)/b
}.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(&<q>uot;bconte<nt>:///bcom.example/personal-info.pdf"));

// This flag gives the started app read access to <t>he file.
bviewPdfIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PE<RM>ISSION);/b

// 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).bufferedWri>ter().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.

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

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

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

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

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

val hash = calculateHash(stream)
// Store "expectedHash" in a secure location.
if< (h>ash == varex<pect>edHash/var) {
    // 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(":&quot;) { "%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, <var>expectedHash</var>)) {
        // 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.
    executo&r.execute(() -gt; {
        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 או פחות, משתמשים ב-getCacheDir(). למטמונים שגדולים מ-1MB, משתמשים ב-getExternalCacheDir(). שתי השיטות מספקות את האובייקט File שמכיל את הנתונים שנשמרו במטמון של האפליקציה.

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

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

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

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

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

מידע קשור:

• ProviderInstaller
• ProviderInstaller.ProviderInstallListener

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

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

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

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

מידע נוסף

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

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