डिवाइस की सुरक्षा की स्थिति के बारे में जानकारी

आपका ऐप्लिकेशन, सिर्फ़ उस ओएस जितना सुरक्षित होता है जिस पर वह काम करता है. जोखिम को कम करने के लिए, आपके ऐप्लिकेशन को सुरक्षा से जुड़ी संवेदनशील कार्रवाइयों को डिवाइस की सुरक्षा की स्थिति के रीयल-टाइम आकलन के साथ गेट करना चाहिए. इससे यह तय किया जा सकेगा कि डिवाइस, खास तौर पर इसके मुख्य सिस्टम कॉम्पोनेंट, पूरी तरह से अपडेट हैं या नहीं. साथ ही, Android Security Bulletin में पब्लिश की गई कमियों से सुरक्षित हैं या नहीं. डिवाइस की सुरक्षा की स्थिति के बारे में जानकारी मिलने से, आपको ज़्यादा जोखिम वाले ऑपरेशन करने से पहले सुरक्षा के इंतज़ाम करने में मदद मिलती है.

AndroidX Security State एक Jetpack लाइब्रेरी है. यह Android डिवाइस की सुरक्षा की स्थिति को एक साथ ऐक्सेस करने की सुविधा देती है. यह AOSP एपीआई और Android के सार्वजनिक तौर पर उपलब्ध सुरक्षा से जुड़ी कमियों की जानकारी देने वाले फ़ीड को मिलाकर, डिवाइस की सुरक्षा की स्थिति के बारे में पूरी, सटीक, और कार्रवाई करने लायक जानकारी देता है. यह जानकारी, सिर्फ़ सुरक्षा पैच लेवल (एसपीएल) से ज़्यादा होती है.

ध्यान दें: Security State लाइब्रेरी, सॉफ़्टवेयर पैच के अनुपालन और अपडेट की उपलब्धता का आकलन करती है. हार्डवेयर-बैक्ड डिवाइस की पुष्टि करने, डिवाइस के साथ छेड़छाड़ का पता लगाने या ऐप्लिकेशन के लाइसेंस की पुष्टि करने के लिए, इस लाइब्रेरी के साथ Play Integrity API का इस्तेमाल करें.

आर्किटेक्चर की खास जानकारी

इस डायग्राम में दिखाया गया है कि AndroidX Security State लाइब्रेरी, डिवाइस पर मौजूद प्लैटफ़ॉर्म प्रॉपर्टी, इंटरप्रोसेस कम्यूनिकेशन (आईपीसी) अपडेट करने वाले प्रोवाइडर, और सार्वजनिक तौर पर उपलब्ध सुरक्षा से जुड़ी कमियों की जानकारी देने वाले फ़ीड को एक ही एपीआई सेट में कैसे शामिल करती है.

सुरक्षा पैच की स्थितियां और कॉम्पोनेंट

Security State लाइब्रेरी का मुख्य फ़ायदा यह है कि यह कॉम्पोनेंट लेवल पर, सुरक्षा पैच का लेवल (एसपीएल) विस्तृत रूप से दिखाती है. पिछले कुछ सालों में, Android ने Google Play के सिस्टम अपडेट (प्रोजेक्ट मेनलाइन) के लिए ज़्यादा मॉड्यूल लॉन्च किए हैं. ये मॉड्यूल, Google Play का इस्तेमाल करके अपडेट किए जाते हैं. ये सिस्टम ओवर-द-एयर (ओटीए) अपडेट से अलग होते हैं. इनसे सुरक्षा से जुड़ी ज़रूरी समस्याओं को ठीक करने में मदद मिलती है.

इसी तरह, सुरक्षा पैच का लेवल के लिए आम तौर पर, जेनेरिक कर्नल इमेज (जीकेआई) के ज़रूरी वर्शन की ज़रूरत होती है. हालांकि, कर्नल अपडेट, सिस्टम के शेड्यूल से पहले भी किए जा सकते हैं. ऐसा हो सकता है कि कर्नल से जुड़े इन फ़िक्स को सिस्टम की मुख्य एसपीएल स्ट्रिंग में पूरी तरह से शामिल न किया गया हो.

पारदर्शिता को बेहतर बनाने के लिए, Security State Library, तीनों कॉम्पोनेंट के लिए अलग-अलग इफ़ेक्टिव पैच लेवल उपलब्ध कराती है:

• सिस्टम (COMPONENT_SYSTEM): यह स्टैंडर्ड ओएस और सिस्टम की सुरक्षा की स्थिति को दिखाता है. यह स्टैंडर्ड सुरक्षा पैच लेवल फ़ील्ड से मिलता है.
• सिस्टम मेनलाइन मॉड्यूल (COMPONENT_SYSTEM_MODULES): यह मॉड्यूलर सिस्टम कॉम्पोनेंट (Google Play के सिस्टम अपडेट) की सुरक्षा की स्थिति को दिखाता है. यह स्थिति, मॉड्यूल के रिलीज़ किए गए वर्शन से मिलती है.
• कर्नेल (COMPONENT_KERNEL): यह डिवाइस के कर्नेल की सुरक्षा की स्थिति को दिखाता है. यह कर्नेल वर्शन स्ट्रिंग से सीधे तौर पर मिलता है.

कॉम्पोनेंट के आधार पर, लाइब्रेरी पैच लेवल की जानकारी के ज़्यादा से ज़्यादा तीन डाइमेंशन उपलब्ध कराती है:

• डिवाइस एसपीएल (डीएसपीएल): डिवाइस पर चल रहे अलग-अलग कॉम्पोनेंट का मौजूदा पैच लेवल. इसे नेटवर्क अनुरोधों के बिना, सिंक्रोनस तरीके से क्वेरी किया जाता है. सिस्टम और मेनलाइन, कैलेंडर की तारीखों (DateBasedSecurityPatchLevel) की जानकारी देते हैं. वहीं, कर्नेल अपने रिलीज़ के लिए तैयार वर्शन (VersionedSecurityPatchLevel, उदाहरण के लिए 5.15.148) की जानकारी देता है.
• पब्लिश किया गया एसपीएल (पीएसपीएल): यह वह बेसलाइन है जिसे आधिकारिक तौर पर Android सुरक्षा बुलेटिन और Open Source Vulnerabilities (OSV) डेटाबेस की रिपोर्ट में पब्लिश किया गया है. आपका ऐप्लिकेशन, डिवाइस के एसपीएल से मिली तारीखों या वर्शन स्ट्रिंग की तुलना करके, यह पता लगा सकता है कि ज़रूरी शर्तों का पालन किया गया है या नहीं.
• उपलब्ध एसपीएल (एएसपीएल): इससे पता चलता है कि किसी डिवाइस पर अपडेट उपलब्ध हैं या नहीं. ये अपडेट, अपडेट देने वाली कंपनियों से मिलते हैं. इन्हें आईपीसी का इस्तेमाल करके एसिंक्रोनस तरीके से क्वेरी किया जाता है. Android और Google Play के सिस्टम अपडेट की सुविधा, Mainline मॉड्यूल के लिए उपलब्ध होती है. साथ ही, ओईएम के ओटीए क्लाइंट, सिस्टम अपडेट के लिए उपलब्ध होते हैं. कर्नल अपडेट, ऑपरेटिंग सिस्टम इमेज में बंडल किए जाते हैं. इसलिए, कर्नल अपडेट की उपलब्धता का आकलन करने के लिए COMPONENT_SYSTEM का इस्तेमाल किया जाता है.

सुरक्षा से जुड़ी सुविधाओं को कंट्रोल करने की सुविधा

सुरक्षा से जुड़ी संवेदनशील सुविधाओं को गेट करने के लिए, डिवाइस एसएपीएल (डीएसपीएल), उपलब्ध एसएपीएल (एएसपीएल), और पब्लिश किए गए एसएपीएल (पीएसपीएल) से मिली जानकारी को एक साथ इस्तेमाल किया जा सकता है. उदाहरण के लिए, DSPL की तुलना ASPL से की जा सकती है. इससे यह पता लगाया जा सकता है कि कोई नया सुरक्षा पैच उपलब्ध है या नहीं. अगर उपलब्ध है, तो यह देखा जा सकता है कि उपयोगकर्ता ने उसे अब तक इंस्टॉल किया है या नहीं. अगर उपयोगकर्ता ने उसे इंस्टॉल नहीं किया है, तो उसे संवेदनशील कार्रवाइयां शुरू करने से पहले अपडेट करने के लिए कहा जा सकता है. जैसे, पेमेंट करना या क्रेडेंशियल रजिस्टर करना. areCvesPatched() का इस्तेमाल करके यह भी पुष्टि की जा सकती है कि डिवाइस पर, ज़्यादा जोखिम वाली कुछ खास कमियों को ठीक किया गया है या नहीं. ऐसा, कमज़ोर सबसिस्टम को चालू करने से पहले किया जाता है. जैसे, आस-पास मौजूद डिवाइसों से पेमेंट करने या डेटा शेयर करने की अनुमति देने से पहले, यह जांच करना कि क्या एनएफ़सी या ब्लूटूथ से जुड़ी गंभीर कमियों को ठीक किया गया है.

प्लैटफ़ॉर्म के वर्शन के बारे में ध्यान देने वाली बातें

सुरक्षा की स्थिति से जुड़ी कुछ सुविधाएं, प्लैटफ़ॉर्म के आर्किटेक्चर पर निर्भर करती हैं. ये Android के पुराने वर्शन पर उपलब्ध नहीं हैं:

• Android 11 (एपीआई लेवल 30) और इसके बाद के वर्शन: सभी कॉम्पोनेंट के साथ पूरी तरह से काम करता है. इनमें बुलेटिन में पब्लिश किए गए कर्नेल के एलटीएस वर्शन और अपडेट की उपलब्धता (एएसपीएल) क्वेरी शामिल हैं.
• Android 10 (एपीआई लेवल 29): यह सिस्टम और सिस्टम मॉड्यूल के पैच लेवल के साथ काम करता है; हालांकि, बुलेटिन में पब्लिश किए गए कर्नेल वर्शन उपलब्ध नहीं हैं, क्योंकि Android सुरक्षा बुलेटिन में सामान्य कर्नेल इमेज (जीकेआई) ट्रैकिंग और कर्नेल एलटीएस टारगेट, Android 11 से शुरू हुए थे. डिवाइस पर मौजूद कर्नेल वर्शन को अब भी स्थानीय तौर पर पढ़ा जा सकता है.
• Android 9 (एपीआई लेवल 28) और इससे पहले के वर्शन: Android 10 की सीमाओं के अलावा, मॉड्यूलर सिस्टम कॉम्पोनेंट (प्रोजेक्ट मेनलाइन) Android 10 से पहले मौजूद नहीं थे. सिस्टम मॉड्यूल के एसपीएल उपलब्ध न होने पर, getDeviceSecurityPatchLevel(COMPONENT_SYSTEM_MODULES) को सुरक्षित तरीके से कॉल करने पर, यूनिक्स के शुरुआती समय (1970-01-01) की तारीख पर वापस आ जाता है.

अपडेट की उपलब्धता और उपलब्ध एसएपीएल (एएसपीएल) के बारे में जानकारी

किसी डिवाइस की सुरक्षा की स्थिति का पता लगाने के लिए, यह जानना ज़रूरी है कि अलग-अलग कॉम्पोनेंट के लिए सुरक्षा से जुड़े अपडेट उपलब्ध हैं या नहीं. Android डिवाइसों को सुरक्षा से जुड़े अपडेट, अलग-अलग तरीकों से मिलते हैं. जैसे, मॉड्यूलर कॉम्पोनेंट के लिए सिस्टम के ओवर-द-एयर (OTA) अपडेट और Google Play के सिस्टम अपडेट.

आपका ऐप्लिकेशन किसी कॉम्पोनेंट के लिए ASPL तब ही पा सकता है, जब अपडेट देने वाली कंपनी उस जानकारी को पब्लिश कर दे. अपडेट के इन अलग-अलग सोर्स के बीच तालमेल बिठाने के लिए, क्लाइंट ऐप्लिकेशन AndroidX Security State लाइब्रेरी का इस्तेमाल करके सुरक्षा की स्थिति के बारे में क्वेरी करते हैं. वहीं, डिवाइस पर अपडेट करने वाले क्लाइंट, AndroidX Security State Provider लाइब्रेरी का इस्तेमाल करके, सुरक्षा पैच का उपलब्ध लेवल (एएसपीएल) पब्लिश करते हैं.

Google, GMS Android डिवाइसों के लिए Mainline मॉड्यूल के अपडेट की जानकारी देता है. साथ ही, Google OTA क्लाइंट (GOTA) का इस्तेमाल करने वाले डिवाइसों के लिए, सिस्टम के ओटीए अपडेट की जानकारी भी देता है.

नीचे दिए गए डायग्राम में बताया गया है कि क्लाइंट ऐप्लिकेशन, AndroidX Security State लाइब्रेरी का इस्तेमाल करके, Google Play सिस्टम अपडेट और सिस्टम ओटीए अपडेट, दोनों के लिए सुरक्षा की स्थिति के बारे में कैसे क्वेरी करते हैं:

डिपेंडेंसी जोड़ें

AndroidX Security State पर डिपेंडेंसी जोड़ने के लिए, आपको अपने प्रोजेक्ट में Google Maven रिपॉज़िटरी को शामिल करना होगा. अपने ऐप्लिकेशन की build.gradle.kts या build.gradle फ़ाइल में, यह डिपेंडेंसी जोड़ें:

Kotlin

// Kotlin DSL (build.gradle.kts)
dependencies {
    implementation("androidx.security:security-state:1.1.0")
}

Groovy

// Groovy DSL (build.gradle)
dependencies {
    implementation "androidx.security:security-state:1.1.0"
}

अनुमतियों की जानकारी देने वाली मैट्रिक्स

टारगेट एपीआई	AndroidManifest.xml में ज़रूरी अनुमतियां	ऑपरेशनल नोट
getDeviceSecurityPatchLevel()	कोई नहीं	यह कुकी, लोकल नेटिव सिस्टम प्रॉपर्टी और पैकेज के मेटाडेटा को एक साथ पढ़ती है.
fetchAvailableSecurityPatchLevel() queryAllAvailableUpdates()	कोई नहीं	यह डिवाइस पर मौजूद आईपीसी का इस्तेमाल करके कम्यूनिकेट करता है. यह लाइब्रेरी, डिवाइस पर सिर्फ़ भरोसेमंद कॉम्पोनेंट से क्वेरी करती है. इसके लिए, अपडेट देने वाली कंपनियों के पास READ_PRIVILEGED_PHONE_STATE अनुमति होनी चाहिए. इसलिए, आपका ऐप्लिकेशन इस बात पर भरोसा कर सकता है कि उसे जो जानकारी मिल रही है वह सही है.
createVulnerabilityReportUrl() loadVulnerabilityReport() getPublishedSecurityPatchLevel() areCvesPatched() isDeviceFullyUpdated()	android.permission.INTERNET	सार्वजनिक ओएसवी रिपोर्ट फ़ेच करने के लिए ज़रूरी है. loadVulnerabilityReport() का इस्तेमाल करके मेमोरी में लोड करने के बाद, क्वेरी करने के तरीके, नेटवर्क ऐक्सेस के बिना स्थानीय तौर पर काम करते हैं.

ध्यान दें: Android 11 (एपीआई लेवल 30) और इसके बाद के वर्शन पर, लाइब्रेरी का AAR मेनिफ़ेस्ट, ज़रूरी <queries> इंटेंट फ़िल्टर के एलान (androidx.security.state.provider.UPDATE_INFO_SERVICE) को आपके ऐप्लिकेशन के मेनिफ़ेस्ट में अपने-आप मर्ज कर देता है. इसलिए, पैकेज की दृश्यता को मैन्युअल तरीके से कॉन्फ़िगर करने की ज़रूरत नहीं होती.

लाइब्रेरी शुरू करना

Android Context का इस्तेमाल करके, SecurityPatchState को शुरू करें:

Kotlin

import androidx.security.state.SecurityPatchState

val securityPatchState = SecurityPatchState(context)

Java

import androidx.security.state.SecurityPatchState;

SecurityPatchState securityPatchState = new SecurityPatchState(context);

सिर्फ़ context का इस्तेमाल करने पर, नेटवर्क पर निर्भरता के बिना ही ऑफ़लाइन डिवाइस के पैच लेवल को तुरंत ऐक्सेस किया जा सकता है. उपलब्धता के बारे में क्वेरी अपडेट करें उपयोगकर्ता के डिवाइस पर मौजूद सेवा देने वाली कंपनियों के साथ एसिंक्रोनस तरीके से कम्यूनिकेट करें).

अगर आपका ऐप्लिकेशन, CVE के नियमों का पालन करने की जांच करता है और उसने पहले ही ओएसवी की जोखिम वाली रिपोर्ट को मेमोरी में लोड कर लिया है, तो Kotlin कॉलर, JSON स्ट्रिंग को सीधे Kotlin में कंस्ट्रक्टर को पास कर सकते हैं:

val securityPatchState = SecurityPatchState(context, vulnerabilityReportJsonString = jsonString)

Java में या स्टार्टअप के बाद रिपोर्ट को एसिंक्रोनस तरीके से लोड करते समय, कॉन्टेक्स्ट के साथ शुरू करें और securityPatchState.loadVulnerabilityReport(jsonString) को कॉल करें.

डिवाइस के पैच लेवल की जांच करना

उपयोगकर्ता के डिवाइस पर मौजूद पैच लेवल के बारे में सिंक्रोनस तरीके से क्वेरी करना:

Kotlin

val deviceSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM)
val mainlineSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM_MODULES)
val kernelVersion = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_KERNEL)

// Gatekeeping check: compare against a required baseline patch date
val requiredSpl = SecurityPatchState.DateBasedSecurityPatchLevel.fromString("2026-01-01")
if (deviceSpl < requiredSpl) {
    // Restrict access to sensitive features or guide user to update
}

Java

SecurityPatchState.SecurityPatchLevel deviceSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM);
SecurityPatchState.SecurityPatchLevel mainlineSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM_MODULES);
SecurityPatchState.SecurityPatchLevel kernelVersion = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_KERNEL);

// Gatekeeping check: compare against a required baseline patch date
SecurityPatchState.SecurityPatchLevel requiredSpl = SecurityPatchState.DateBasedSecurityPatchLevel.fromString("2026-01-01");
if (deviceSpl.compareTo(requiredSpl) < 0) {
    // Restrict access to sensitive features or guide user to update
}

देखें कि सिस्टम के लिए कोई अपडेट बाकी है या नहीं

ऐप्लिकेशन, उपयोगकर्ता के डिवाइस पर अपडेट की सुविधा देने वाली भरोसेमंद कंपनियों के साथ एसिंक्रोनस तरीके से कम्यूनिकेट करके, अपडेट के उपलब्ध होने का आकलन कर सकते हैं. इनमें आम तौर पर, Google Play के सिस्टम अपडेट और ओईएम के OTA क्लाइंट शामिल होते हैं:

• fetchAvailableSecurityPatchLevel(): यह किसी कॉम्पोनेंट के लिए, उपलब्ध एसपीएल की जानकारी दिखाता है. अगर कोई नया अपडेट उपलब्ध नहीं है, तो यह डिवाइस के मौजूदा एसपीएल की जानकारी दिखाता है. इस जानकारी का इस्तेमाल, डिवाइस के एसपीएल और पब्लिश किए गए एसपीएल की तुलना करने के लिए किया जा सकता है.
• queryAllAvailableUpdates(): डिवाइस पर अपडेट देने वाली सभी भरोसेमंद कंपनियों का पता लगाता है. साथ ही, सोर्स और डेटा के अपडेट होने की तारीख के बारे में मेटाडेटा के साथ-साथ, UpdateCheckResult की जानकारी देता है.

अहम जानकारी: अगर अपडेट देने वाली कंपनी का जवाब समय पर नहीं मिलता है या वह बताती है कि कोई अपडेट उपलब्ध नहीं है, तो fetchAvailableSecurityPatchLevel() अपने-आप उपयोगकर्ता के डिवाइस पर मौजूद पैच लेवल (getDeviceSecurityPatchLevel()) की जानकारी देने लगता है. इससे यह पक्का होता है कि आपके ऐप्लिकेशन को हमेशा सही पोस्चर की जानकारी मिलती रहे. हालांकि, इस फ़ॉलबैक से यह पता नहीं चलता कि डिवाइस वाकई में अप-टू-डेट है या नहीं. साथ ही, इससे यह भी पता नहीं चलता कि सेवा देने वाली कंपनी का टाइम आउट हो गया है या उसके पास पुरानी कैश मेमोरी है. इसलिए, नीति के पालन से जुड़े ऐप्लिकेशन (जैसे कि बैंकिंग ऐप्लिकेशन या एंटरप्राइज़ डिवाइस नीति कंट्रोलर (डीपीसी)) को queryAllAvailableUpdates का इस्तेमाल करना चाहिए, ताकि lastCheckTimeMillis की जांच की जा सके और अपडेट की फ़्रेशनेस की पुष्टि की जा सके.

उदाहरण 1: उपयोगकर्ताओं को इंस्टॉल नहीं किए गए अपडेट के बारे में सूचना देना

सुरक्षा से जुड़े अपडेट उपलब्ध होने पर, उपयोगकर्ताओं को सूचना देने के लिए fetchAvailableSecurityPatchLevel() का इस्तेमाल करें. उदाहरण के लिए, Settings.ACTION_SYSTEM_UPDATE_SETTINGS लॉन्च करके:

Kotlin

import androidx.lifecycle.lifecycleScope
import androidx.security.state.SecurityPatchState
import kotlinx.coroutines.launch

// Pattern A: Prompt users for pending updates (with automatic offline fallback)
lifecycleScope.launch {
    val currentSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM)
    val availableSpl = securityPatchState.fetchAvailableSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM)
    if (availableSpl > currentSpl) {
        // Prompt the user to install pending updates in system settings
    }
}

Java

Java में, एसिंक्रोनस तरीके ListenableFuture दिखाते हैं और ContextCompat.getMainExecutor() का इस्तेमाल करके कॉलबैक को रूट करते हैं:

import androidx.core.content.ContextCompat;
import androidx.security.state.SecurityPatchState;
import androidx.security.state.SecurityPatchState.SecurityPatchLevel;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;

// Pattern A: Prompt users for pending updates (with automatic offline fallback)
SecurityPatchLevel currentSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM);
ListenableFuture<SecurityPatchLevel> availableSpl = securityPatchState.fetchAvailableSecurityPatchLevelAsync(
    SecurityPatchState.COMPONENT_SYSTEM,
    SecurityPatchState.UPDATE_INFO_SERVICE_BINDING_TIMEOUT_MS
);

Futures.addCallback(availableSpl, new FutureCallback<SecurityPatchLevel>() {
    @Override
    public void onSuccess(SecurityPatchLevel available) {
        if (available.compareTo(currentSpl) > 0) {
            // Prompt the user to install pending updates in system settings
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle timeout or IPC communication error
    }
}, ContextCompat.getMainExecutor(context));

दूसरा उदाहरण: सेवा देने वाली कंपनी की स्थिति की पूरी जानकारी देखना

अलग-अलग प्रोवाइडर, टाइमस्टैंप, और UpdateInfo रिकॉर्ड की जांच करने के लिए, queryAllAvailableUpdates() का इस्तेमाल करें:

Kotlin

import androidx.lifecycle.lifecycleScope
import androidx.security.state.SecurityPatchState
import kotlinx.coroutines.launch

// Pattern B: Inspect detailed provider status
lifecycleScope.launch {
    val updateResults = securityPatchState.queryAllAvailableUpdates()
    for (result in updateResults) {
        val provider = result.providerPackageName
        val lastCheck = result.lastCheckTimeMillis
        val updates = result.updates // List<UpdateInfo>
    }
}

Java

import androidx.core.content.ContextCompat;
import androidx.security.state.SecurityPatchState;
import androidx.security.state.UpdateCheckResult;
import androidx.security.state.UpdateInfo;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;

// Pattern B: Inspect detailed provider status
ListenableFuture<List<UpdateCheckResult>> updateResults = securityPatchState.queryAllAvailableUpdatesAsync(
    SecurityPatchState.UPDATE_INFO_SERVICE_BINDING_TIMEOUT_MS
);

Futures.addCallback(updateResults, new FutureCallback<List<UpdateCheckResult>>() {
    @Override
    public void onSuccess(List<UpdateCheckResult> results) {
        for (UpdateCheckResult result : results) {
            String provider = result.getProviderPackageName();
            long lastCheck = result.getLastCheckTimeMillis();
            List<UpdateInfo> updates = result.getUpdates();
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle error
    }
}, ContextCompat.getMainExecutor(context));

ध्यान दें: queryAllAvailableUpdates(), अपडेट की जानकारी देने वाली सभी कंपनियों से एक साथ कनेक्ट होता है. इसके लिए, बाउंड सेवाओं का इस्तेमाल किया जाता है, ताकि कम से कम समय में अपडेट की जानकारी मिल सके. इसके बाद, UpdateCheckResult ऑब्जेक्ट की सूची दिखाता है. सिस्टम के संसाधनों को खाली करने के लिए, कॉल के तुरंत बाद सेवाओं को अनबाइंड कर दिया जाता है.

कमज़ोरी को ठीक किए जाने की पुष्टि करना और CVE की जांच करना

CVE से जुड़ी समस्याओं को कम करने के तरीकों का आकलन करने, अपडेट से जुड़ी ज़रूरी शर्तों का पालन करने की जांच करने या पब्लिश किए गए सुरक्षा पैच के लेवल (पीएसपीएल) की जांच करने के लिए, आपके ऐप्लिकेशन को सबसे पहले ओएसवी की गड़बड़ी की रिपोर्ट हासिल करनी होगी और उसे लोड करना होगा. इसके बारे में SecurityPatchState के लिए एपीआई रेफ़रंस में बताया गया है.

Kotlin

// Load vulnerability report
val reportUrl = SecurityPatchState.createVulnerabilityReportUrl()
// ... download JSON string from reportUrl ...
securityPatchState.loadVulnerabilityReport(jsonString)

// Check overall update compliance against published bulletin
val isFullyUpdated = securityPatchState.isDeviceFullyUpdated()

val cves = listOf("CVE-2019-9501", "CVE-2020-3699", "CVE-2024-0016")
val isPatched = securityPatchState.areCvesPatched(cves)

// Get a list of all patched CVEs for a specific component and SPL
val deviceSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM)
val patchedSystemCVEs = securityPatchState.getPatchedCves(SecurityPatchState.COMPONENT_SYSTEM, deviceSpl)

// Inspect published SPL and kernel LTS target versions from the bulletin
val publishedSystemSpl = securityPatchState.getPublishedSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM)
val kernelLtsTargets = securityPatchState.getPublishedSecurityPatchLevel(SecurityPatchState.COMPONENT_KERNEL)

Java

// Load vulnerability report
Uri reportUrl = SecurityPatchState.createVulnerabilityReportUrl();
// ... download JSON string from reportUrl ...
securityPatchState.loadVulnerabilityReport(jsonString);

// Check overall update compliance against published bulletin
boolean isFullyUpdated = securityPatchState.isDeviceFullyUpdated();

List<String> cves = Arrays.asList("CVE-2019-9501", "CVE-2020-3699", "CVE-2024-0016");
boolean isPatched = securityPatchState.areCvesPatched(cves);

// Get a list of all patched CVEs for a specific component and SPL
SecurityPatchState.SecurityPatchLevel deviceSpl = securityPatchState.getDeviceSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM);
Map<SecurityPatchState.Severity, Set<String>> patchedSystemCVEs =
    securityPatchState.getPatchedCves(SecurityPatchState.COMPONENT_SYSTEM, deviceSpl);

// Inspect published SPL and kernel LTS target versions from the bulletin
List<SecurityPatchState.SecurityPatchLevel> publishedSystemSpl =
    securityPatchState.getPublishedSecurityPatchLevel(SecurityPatchState.COMPONENT_SYSTEM);
List<SecurityPatchState.SecurityPatchLevel> kernelLtsTargets =
    securityPatchState.getPublishedSecurityPatchLevel(SecurityPatchState.COMPONENT_KERNEL);

चेतावनी: isDeviceFullyUpdated(), areCvesPatched(), getPatchedCves(), और getPublishedSecurityPatchLevel() तरीकों के लिए, ओएसवी रिपोर्ट को मेमोरी में लोड करना ज़रूरी है. अगर loadVulnerabilityReport() से पहले कॉल किया जाता है, तो वे IllegalStateException भेजते हैं.

सुरक्षा कमियों की रिपोर्ट लोड करना

1. लोकल कैश मेमोरी और WorkManager रीफ़्रेश: Android सुरक्षा बुलेटिन हर महीने पब्लिश किए जाते हैं. इसलिए, डाउनलोड किए गए JSON को डिवाइस के स्टोरेज (context.filesDir) में सेव करें. साथ ही, WorkManager का इस्तेमाल करके, समय-समय पर बैकग्राउंड टास्क शेड्यूल करें. टास्क को हर 24 से 48 घंटे में शेड्यूल करना बेहतर होता है, ताकि रिपोर्ट रीफ़्रेश हो सके. इसके अलावा, ऐप्लिकेशन लॉन्च होने पर लोकल कैश मेमोरी से डेटा को सिंक्रोनस तरीके से पढ़ा जा सके.
2. बैकग्राउंड थ्रेडिंग: CVE रिकॉर्ड पार्स करते समय, मुख्य यूज़र इंटरफ़ेस (यूआई) थ्रेड को ब्लॉक होने से बचाने के लिए, बैकग्राउंड थ्रेड (Kotlin में Dispatchers.IO या Java में Executor) पर loadVulnerabilityReport() को लागू करें.
3. कर्नल एलटीएस का आकलन: getPatchedCves(COMPONENT_KERNEL, ...) को कॉल करने पर IllegalArgumentException दिखता है. साथ ही, areCvesPatched() कर्नल सीवीई का आकलन नहीं करता है. इसके बजाय, डिवाइस के कर्नल वर्शन की तुलना getPublishedSecurityPatchLevel(COMPONENT_KERNEL) से मिले Android Common Kernel LTS टारगेट से करके, कर्नल की सुरक्षा का आकलन करें.यह तुलना, डिवाइस के मुख्य और छोटे ब्रांच से मेल खाने वाले कर्नल वर्शन के आधार पर की जाती है. उदाहरण के लिए, 5.15.140 कर्नल की तुलना 5.15.159 टारगेट से करना.

अन्य संसाधन

डिवाइस की सुरक्षा की स्थिति के बारे में ज़्यादा जानने के लिए, यहां दिए गए लेख पढ़ें:

दस्तावेज़

• Android सुरक्षा बुलेटिन
• मॉड्यूलर सिस्टम कॉम्पोनेंट
• जेनेरिक कर्नेल इमेज (GKI)
• अतिरिक्त सुरक्षा पैच
• Play Integrity API
• Open Source Vulnerabilities (OSV) डेटाबेस
• Security State 1.1.0 की जानकारी

एपीआई का संदर्भ

• SecurityPatchState
• SecurityPatchLevel
• UpdateCheckResult
• UpdateInfo
• SecurityStateManagerCompat