मैं अक्सर सवाल सुनता हूं कि "एंड्रॉइड ऐप में प्रमाणीकरण कैसे लागू करें?", "जहां एक पिन स्टोर करना है?", "अरे यार, क्या मैं सुरक्षित रहूंगा अगर मैं इस तरह से प्रमाणीकरण सुविधा लागू करूं?" और बहुत तरह का। मैं इन सवालों का जवाब देते हुए वास्तव में थक गया था इसलिए मैंने सभी प्रश्नकर्ताओं के साथ साझा करने के लिए अपने सभी विचारों को एक बार लिखने का फैसला किया।

सामग्री की तालिका

• प्रमाणीकरण: मुझे यह क्यों करना है?
• सरल तरीका है
• चलो इसे बेहतर बनाते हैं
• सही तरीका
• लेकिन रुको, बायोमेट्रिक्स के बारे में क्या?
• क्या मैं पूरी तरह से सुरक्षित हूं?

प्रमाणीकरण: मुझे यह क्यों करना है?

चलिए परिभाषा से शुरू करते हैं। प्रमाणीकरण (ग्रीक से: αὐθενicationιik प्रमाणिकोस, "वास्तविक, वास्तविक", αesν "प्रामाणिकता से," लेखक ") एक जोर साबित करने की क्रिया है, जैसे कि कंप्यूटर सिस्टम उपयोगकर्ता की पहचान।

इसलिए, यदि आपके आवेदन में संवेदनशील जानकारी है (किसी भी उपयोगकर्ता की जानकारी संवेदनशील IMHO है) तो आपको इस जानकारी के अनधिकृत उपयोग को रोकने के लिए ऐप में एक प्रमाणीकरण परिदृश्य जोड़ना होगा।

सबसे लोकप्रिय प्रमाणीकरण परिदृश्य इस प्रकार हैं:

• लॉगिन + पासवर्ड
• मास्टर पासवर्ड
• पिन (4 या अधिक अंक)
• बॉयोमेट्रिक्स

स्वाभाविक रूप से, लॉगिन और पासवर्ड प्रमाणीकरण एक बैक-एंड से आपके आवेदन पर आता है और इस तंत्र की सुरक्षा हम बैक-एंड सुरक्षा आश्वासन टीम को छोड़ देंगे;) बस सार्वजनिक कुंजी पिनिंग को लागू करने के लिए मत भूलना।

मास्टर पासवर्ड प्रमाणीकरण का उपयोग शायद ही कभी किया जाता है और केवल उन ऐप्स में जिन्हें उच्च स्तर की सुरक्षा की आवश्यकता होती है (जैसे पासवर्ड प्रबंधक)।

इस प्रकार, हमारे पास केवल दो सबसे लोकप्रिय परिदृश्य हैं: एक पिन और बायोमेट्रिक्स । वे काफी उपयोगकर्ता के अनुकूल हैं और कार्यान्वयन में अपेक्षाकृत आसान हैं (वास्तव में वे नहीं हैं ...)। इस लेख में हम इन विशेषताओं के सही कार्यान्वयन के मुख्य पहलुओं को शामिल करेंगे।

सरल तरीका है

जरा सोचिए, आप एक Android डेवलपर हैं और आपका कोड आपके पैसे छापता है। आप किसी भी चीज के बारे में चिंता नहीं करते हैं, और आपको गंभीर मोबाइल एप्लिकेशन सुरक्षा विशेषज्ञता में बहुत आवश्यकता नहीं है। लेकिन एक दिन, एक प्रबंधक आपके पास आता है और "हमारे आवेदन में एक पिन और एक फिंगरप्रिंट के माध्यम से एक अतिरिक्त प्रमाणीकरण को लागू करने" के लिए एक कार्य देता है। कहानी यहाँ से शुरू होती है ...

पिन प्रमाणीकरण को लागू करने के लिए आप कुछ स्क्रीन इस तरह बनाएंगे:

और अपना पिन बनाने और जांचने के लिए ऐसा कोड लिखें

fun savePin(pin: String) { preferences.edit().putString(StorageKey.PIN, pin).apply() } 

 fun authenticate(pin: String) { authenticationState.value = if (pinIsValid(pin)) { AuthenticationState.AUTHENTICATED } else { AuthenticationState.INVALID_AUTHENTICATION } } private fun pinIsValid(pin: String): Boolean { return preferences.getString(StorageKey.PIN, null) == pin } 

बस इतना ही! अब, आपके पास एक पिन के माध्यम से एक शांत प्रमाणीकरण प्रणाली है। बधाई हो। यह बहुत आसान था, है ना?

बेशक, आपने पहले ही मेरे शब्दों में विडंबना को पकड़ लिया है। यह तरीका बहुत बुरा है क्योंकि एक पिन को प्लेनटेक्स्ट के रूप में संग्रहीत किया जाता है। अगर मालवेयर किसी तरह से इंटरनल एप्लिकेशन स्टोरेज तक पहुंच जाता है, तो उसे यूजर पिन मिलेगा। आप मुझसे पूछ सकते हैं "यह इतना बुरा क्यों है? यह स्थानीय प्रमाणीकरण से सिर्फ एक पिन है ..."। हाँ, लेकिन उपयोगकर्ता हर जगह एक ही पिन सेट करते हैं। इसलिए, एक उपयोगकर्ता पिन का ज्ञान एक घुसपैठिया को हमले की सतह का विस्तार करने की अनुमति देता है।

इसके अलावा, ऐसी प्रमाणीकरण योजना आपको एक सुरक्षित तरीके से पिन के आधार पर उपयोगकर्ता डेटा एन्क्रिप्शन को लागू करने की अनुमति नहीं देती है (हम इसके बारे में बाद में बात करेंगे)।

चलो इसे बेहतर बनाते हैं

हम अपने पिछले कार्यान्वयन को कैसे सुधार सकते हैं? पहला और स्पष्ट दृष्टिकोण आपके पिन से एक हैश ले रहा है और इस हैश को संग्रहीत कर रहा है।

हैश फ़ंक्शन कोई भी फ़ंक्शन है जिसका उपयोग निश्चित आकार के मानों के मनमाने आकार के डेटा को मैप करने के लिए किया जा सकता है। हैश फ़ंक्शन द्वारा लौटाए गए मानों को हैश मान, हैश कोड, डाइजेस्ट या बस हैश कहा जाता है। मान का उपयोग हैश तालिका नामक निश्चित आकार की तालिका को अनुक्रमित करने के लिए किया जाता है। हैश टेबल को इंडेक्स करने के लिए हैश फंक्शन का उपयोग हैशिंग या स्कैटर स्टोरेज एड्रेसिंग कहलाता है।

एंड्रॉइड फ्रेमवर्क ( जावा क्रिप्टोग्राफी आर्किटेक्चर में , सटीक होने के लिए) में बहुत सारे उपलब्ध हैश फ़ंक्शन हैं, लेकिन आज उनमें से प्रत्येक को सुरक्षित नहीं माना जाता है। मैं टकराव के कारण MD5 और SHA-1 का उपयोग करने की सलाह नहीं देता। SHA-256 अधिकांश कार्यों के लिए एक अच्छा विकल्प है।

 fun sha256(byteArray: ByteArray): ByteArray { val digest = try { MessageDigest.getInstance("SHA-256") } catch (e: NoSuchAlgorithmException) { MessageDigest.getInstance("SHA") } return with(digest) { update(byteArray) digest() } } 

हैश पिन को संग्रहीत करने के लिए हमारी savePin(...) विधि को संशोधित करें

 fun savePin(pin: String) { val hashedPin = sha256(pin.toByteArray()) val encodedHash = Base64.encodeToString(hashedPin, Base64.DEFAULT) preferences.edit().putString(StorageKey.PIN, encodedHash).apply() } 

हैश का उपयोग करना एक अच्छी शुरुआत है, लेकिन नंगे हैश हमारे कार्य के लिए पर्याप्त नहीं है। वास्तविक जीवन में एक हमलावर पहले से ही सभी 4-अंकीय पिन हैश की गणना कर चुका है। वह उन सभी चोरी किए गए हैशड पिन को आसानी से डिक्रिप्ट कर सकेगा। इससे निपटने के लिए एक दृष्टिकोण है - एक नमक ।

क्रिप्टोग्राफी में, एक नमक यादृच्छिक डेटा होता है जो एक तरह के फ़ंक्शन के लिए एक अतिरिक्त इनपुट के रूप में उपयोग किया जाता है जो "हैश" डेटा, एक पासवर्ड या पासफ़्रेज़। भंडारण में पासवर्ड को सुरक्षित करने के लिए सलाट्स का उपयोग किया जाता है। ऐतिहासिक रूप से एक पासवर्ड को एक सिस्टम पर प्लेनटेक्स्ट में संग्रहीत किया गया था, लेकिन समय के साथ अतिरिक्त सुरक्षा उपायों को उपयोगकर्ता के पासवर्ड को सिस्टम से पढ़े जाने से बचाने के लिए विकसित किया गया। एक नमक उन तरीकों में से एक है।

अपने सुरक्षा तंत्र में नमक जोड़ने के लिए हमें ऊपर दिखाए गए कोड को इस तरह बदलना होगा

 fun generate(lengthByte: Int = 32): ByteArray { val random = SecureRandom() val salt = ByteArray(lengthByte) random.nextBytes(salt) return salt } 

 fun savePin(pin: String) { val salt = Salt.generate() val saltedPin = pin.toByteArray() + salt val hashedPin = Sha256.hash(saltedPin) val encodedHash = Base64.encodeToString(hashedPin, Base64.DEFAULT) val encodedSalt = Base64.encodeToString(salt, Base64.DEFAULT) preferences.edit() .putString(StorageKey.PIN, encodedHash) .putString(StorageKey.SALT, encodedSalt) .apply() } 

ध्यान दें, आपको नमक को एक साथ पिन के साथ स्टोर करना होगा क्योंकि आपको उपयोगकर्ता इनपुट से पिन की जांच करते समय हर बार परिणाम हैश (नमक का उपयोग करना) की आवश्यकता होती है।

 private fun pinIsValid(pin: String): Boolean { val encodedSalt = preferences.getString(StorageKey.SALT, null) val encodedHashedPin = preferences.getString(StorageKey.PIN, null) val salt = Base64.decode(encodedSalt, Base64.DEFAULT) val storedHashedPin = Base64.decode(encodedHashedPin, Base64.DEFAULT) val enteredHashedPin = Sha256.hash(pin.toByteArray() + salt) return storedHashedPin contentEquals enteredHashedPin } 

जैसा कि आप देख सकते हैं, कोड अभी भी समझने में इतना कठिन नहीं है, लेकिन इस समाधान की सुरक्षा बहुत मजबूत हो गई है। मैं और भी अधिक कहूंगा, यह दृष्टिकोण अधिकांश अनुप्रयोगों के लिए काफी उत्पादन के लिए तैयार है जिन्हें उच्च स्तर की सुरक्षा की आवश्यकता नहीं है।

"लेकिन क्या होगा अगर मुझे और अधिक सुरक्षित समाधान की आवश्यकता है?", आप पूछते हैं। ठीक है, मेरे पीछे आओ।

सही तरीका

आइए हमारे प्रमाणीकरण दृष्टिकोण के लिए कई सुधार बिंदुओं पर चर्चा करें।

सबसे पहले, "साधारण हैश" (और यहां तक ​​कि "नमकीन साधारण हैश") का मुख्य दोष एक क्रूर बल हमले (लगभग प्रति मिनट अरबों हैश ) की अपेक्षाकृत उच्च गति है। इस दोष को समाप्त करने के लिए, हमें PBKDF2 जैसे एक विशेष केडीएफ-फ़ंक्शन का उपयोग करने के लिए मिला है जो मूल रूप से एंड्रॉइड फ्रेमवर्क द्वारा समर्थित है। बेशक, केडीएफ कार्यों के बीच कुछ अंतर है और आप शायद दूसरे को चुनना चाहेंगे, लेकिन यह इस लेख के दायरे से बाहर है। मैं आपको लेख के अंत में इस विषय के बारे में कई उपयोगी लिंक दूंगा।

दूसरे, हमारे पास इस बिंदु पर कोई उपयोगकर्ता डेटा एन्क्रिप्शन नहीं है। इसे लागू करने के कई तरीके हैं और मैं सबसे सरल और सबसे विश्वसनीय एक दिखाऊंगा। यह दो पुस्तकालयों और उनके आसपास कुछ कोड का एक सेट होगा।

चलो शुरू करने के लिए एक PBKDF2 कुंजी बनाने का कारखाना लिखते हैं।

 object Pbkdf2Factory { private const val DEFAULT_ITERATIONS = 10000 private const val DEFAULT_KEY_LENGTH = 256 private val secretKeyFactory by lazy { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { SecretKeyFactory.getInstance("PBKDF2withHmacSHA1") } else { SecretKeyFactory.getInstance("PBKDF2withHmacSHA256") } } fun createKey( passphraseOrPin: CharArray, salt: ByteArray, iterations: Int = DEFAULT_ITERATIONS, outputKeyLength: Int = DEFAULT_KEY_LENGTH ): SecretKey { val keySpec = PBEKeySpec(passphraseOrPin, salt, iterations, outputKeyLength) return secretKeyFactory.generateSecret(keySpec) } } 

अब इस फैक्ट्री से लैस होकर हमने अपने savePin() और pinIsValid() तरीकों को pinIsValid()

 fun savePin(pin: String) { val salt = Salt.generate() val secretKey = Pbkdf2Factory.createKey(pin.toCharArray(), salt) val encodedKey = Base64.encodeToString(secretKey.encoded, Base64.DEFAULT) val encodedSalt = Base64.encodeToString(salt, Base64.DEFAULT) preferences.edit() .putString(StorageKey.KEY, encodedKey) .putString(StorageKey.SALT, encodedSalt) .apply() pinIsCreated.value = true } 

 private fun pinIsValid(pin: String): Boolean { val encodedSalt = preferences.getString(StorageKey.SALT, null) val encodedKey = preferences.getString(StorageKey.KEY, null) val salt = Base64.decode(encodedSalt, Base64.DEFAULT) val storedKey = Base64.decode(encodedKey, Base64.DEFAULT) val enteredKey = Pbkdf2Factory.createKey(pin.toCharArray(), salt) return storedKey contentEquals enteredKey.encoded } 

इस प्रकार, हमने अपने पिछले समाधान के मुख्य दोष को कम कर दिया है। यह अच्छा है, और अब हमें उपयोगकर्ता डेटा एन्क्रिप्शन जोड़ने की आवश्यकता है। इसे लागू करने के लिए, हम इन पुस्तकालयों को लेंगे:

• टिंक - एक बहु-भाषा, क्रॉस-प्लेटफ़ॉर्म लाइब्रेरी जो क्रिप्टोग्राफ़िक एपीआई प्रदान करती है जो दुरुपयोग करने के लिए सुरक्षित, आसान उपयोग करने के लिए और हार्ड (एर) है।
• Jetpack Security - सुरक्षा सर्वोत्तम प्रथाओं का पालन करके एन्क्रिप्टेड फ़ाइलों और साझा प्राथमिकताओं को पढ़ें और लिखें।

एक अच्छा एन्क्रिप्टेड स्टोरेज पाने के लिए, हमें ऐसा कोड लिखना होगा:

 class App : Application() { ... val encryptedStorage by lazy { EncryptedSharedPreferences.create( "main_storage", "main_storage_key", this, EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV, EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM ) } ... } 

बस इतना ही। बाद में, हम इसके साथ काम कर सकते हैं जैसे कि यह SharedPreferences थे, लेकिन सभी डेटा एन्क्रिप्ट किए जाएंगे। अब हम पिछले कार्यान्वयन को आसानी से बदल सकते हैं।

 class CreatePinViewModel(application: Application) : AndroidViewModel(application) { ... private val preferences by lazy { getApplication<App>().encryptedStorage } ... } 

 class InputPinViewModel(application: Application) : AndroidViewModel(application) { ... private val preferences by lazy { getApplication<App>().encryptedStorage } ... } 

आइए संक्षेप को संक्षेप में प्रस्तुत करें। हमारे पास एक पिन से प्राप्त एक सुरक्षित कुंजी है, और इसे स्टोर करने के लिए एक काफी विश्वसनीय दृष्टिकोण है। यह अच्छा लग रहा है, लेकिन पर्याप्त नहीं है। क्या होगा अगर हम यह मान लें कि हमलावर ने हमारे डिवाइस तक पहुंच प्राप्त कर ली है और उससे पूरा डेटा निकाल लिया है। सिद्धांत रूप में, इस समय डेटा को डिक्रिप्ट करने के लिए उसके पास सभी घटक हैं। इस समस्या को हल करने के लिए, हमें दो चीजें हासिल करनी हैं:

• एक पिन बिल्कुल भी संग्रहीत नहीं है
• एन्क्रिप्शन ऑपरेशन पिन पर आधारित हैं

पूरे कोड को दोबारा लिखे बिना हम इन लक्ष्यों को कैसे प्राप्त कर सकते हैं? यह आसान है! Insofar जैसा कि हम Tink का उपयोग कर रहे हैं, हम इसके एन्क्रिप्शन फीचर को संबंधित डेटा के रूप में लागू कर सकते हैं।

संबद्ध डेटा को प्रमाणित किया जाना है, लेकिन एन्क्रिप्ट नहीं किया गया है। संबद्ध डेटा वैकल्पिक है, इसलिए यह पैरामीटर शून्य हो सकता है। इस मामले में शून्य मान एक खाली (शून्य-लंबाई) बाइट सरणी के बराबर है। सफल डिक्रिप्शन के लिए समान संबद्धता सिफरटेक्स्ट के साथ प्रदान की जानी चाहिए।

यह बात है! हम अपने निर्धारित लक्ष्यों को प्राप्त करने के लिए संबंधित डेटा के रूप में एक पिन का उपयोग कर सकते हैं। इस प्रकार, उपयोगकर्ता डेटा को डिक्रिप्ट करने की संभावना या असंभवता पिन शुद्धता के संकेतक के रूप में कार्य करेगा। यह योजना आमतौर पर निम्नानुसार काम करती है:

यदि कोई उपयोगकर्ता गलत पिन दर्ज करता है, तो आपको एक्सेस टोकन को डिक्रिप्ट करने की कोशिश करते समय GeneralSecurityException प्राप्त होगी। तो, अंतिम कार्यान्वयन इस तरह दिखाई दे सकता है:

 class CreatePinViewModel(application: Application): AndroidViewModel(application) { ... private val fakeAccessToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzZWNyZXQiOiJXZSdyZSBoaXJpbmcgOykifQ.WZrEWG-l3VsJzJrbnjn2BIYO68gHIGyat6jrw7Iu-Rw" private val preferences by lazy { getApplication<App>().encryptedStorage } private val aead by lazy { getApplication<App>().pinSecuredAead } ... fun savePin(pin: String) { val salt = Salt.generate() val secretKey = Pbkdf2Factory.createKey(pin.toCharArray(), salt) val encryptedToken = aead.encrypt( fakeAccessToken.toByteArray(), secretKey.encoded ) preferences.edit { putString(StorageKey.TOKEN, Base64.encodeToString( encryptedToken, Base64.DEFAULT )) putString(StorageKey.SALT, Base64.encodeToString(salt, Base64.DEFAULT)) putBoolean(StorageKey.PIN_IS_ENABLED, true) } ... } } 

 class InputPinViewModel(application: Application) : AndroidViewModel(application) { ... private val preferences by lazy { getApplication<App>().encryptedStorage } private val aead by lazy { getApplication<App>().pinSecuredAead } fun authenticate(pin: String) { authenticationState.value = if (pinIsValid(pin)) { AuthenticationState.AUTHENTICATED } else { AuthenticationState.INVALID_AUTHENTICATION } } private fun pinIsValid(pin: String): Boolean { val salt = Base64.decode( preferences.getString(StorageKey.SALT, null), Base64.DEFAULT ) val secretKey = Pbkdf2Factory.createKey(pin.toCharArray(), salt) val token = try { val encryptedToken = Base64.decode( preferences.getString(StorageKey.TOKEN, null), Base64.DEFAULT ) aead.decrypt(encryptedToken, secretKey.encoded) } catch (e: GeneralSecurityException) { null } return token?.isNotEmpty() ?: false } } 

अच्छा परिणाम! अब हम पिन को स्टोर नहीं कर रहे हैं, और सभी डेटा डिफ़ॉल्ट रूप से एन्क्रिप्ट किया गया है। यदि आप चाहते हैं तो बेशक, इस कार्यान्वयन को बेहतर बनाने के कई तरीके हैं। मैंने सिर्फ मूल सिद्धांत दिखाया है।

लेकिन रुको, बायोमेट्रिक्स के बारे में क्या?

मुझे नहीं लगता कि सुरक्षा के बारे में "बॉयोमीट्रिक्स" है। मैं इसका नाम "एक बहुत ही सुविधाजनक उपयोगकर्ता सुविधा" रखूंगा। और यह सुविधा और सुरक्षा के बीच एक बहुत पुराना पवित्र युद्ध है। लेकिन अधिकांश उपयोगकर्ता इस तरह के प्रमाणीकरण को पसंद करते हैं और हमें डेवलपर्स के रूप में इसे यथासंभव सुरक्षित रूप से लागू करना है।

दुर्भाग्य से, बायोमेट्रिक कोर कार्यान्वयन काफी मुश्किल है। इसलिए मैं आपको कुछ सामान्य कार्यान्वयन सिद्धांत दिखाने के साथ शुरू करूंगा और कुछ स्पष्टीकरण दूंगा। इसके बाद हम कोड में गहरा गोता लगाएँगे।

इस योजना में एक महत्वपूर्ण बारीकियाँ शामिल हैं: गुप्त कुंजी डिस्क पर सहेजी जाती है । बेशक एक सादे पाठ के रूप में नहीं, लेकिन फिर भी।

जैसा कि आप देख सकते हैं, हमने कीस्टोर में एक नई एन्क्रिप्शन कुंजी बनाई है और हम इस कुंजी का उपयोग हमारी गुप्त कुंजी को एन्क्रिप्ट करने के लिए करते हैं जो कि पिन से ली गई है। इस तरह की स्कीम हमें ऑथेंटिकेशन मेथड को बदलते समय सभी डेटा को दोबारा एन्क्रिप्ट नहीं करने देती है। इसके अलावा, हमारे पास अभी भी एक पिन दर्ज करने की क्षमता है यदि बायोमेट्रिक प्रमाणीकरण किसी भी कारण से विफल हो गया था। ठीक है, बहुत कोड लिखते हैं।

सबसे पहले, मैं पिन निर्माण प्रवाह में परिवर्तन दिखाऊंगा:

 class CreatePinViewModel(application: Application): AndroidViewModel(application) { companion object { private const val ANDROID_KEY_STORE = "AndroidKeyStore" private const val KEY_NAME = "biometric_key" } ... val biometricEnableDialog = MutableLiveData<SingleLiveEvent<Unit>>() val biometricParams = MutableLiveData<BiometricParams>() val authenticationCallback = object : BiometricPrompt.AuthenticationCallback() { override fun onAuthenticationError(errorCode: Int, errString: CharSequence) { super.onAuthenticationError(errorCode, errString) } override fun onAuthenticationSucceeded(result: AuthenticationResult) { super.onAuthenticationSucceeded(result) val encryptedSecretKey = result.cryptoObject?.cipher?.doFinal( secretKey.encoded ) preferences.edit { putString(StorageKey.KEY, Base64.encodeToString( encryptedSecretKey, Base64.DEFAULT )) } pinIsCreated.postValue(true) } override fun onAuthenticationFailed() { super.onAuthenticationFailed() } } ... private val biometricManager by lazy { getApplication<App>().biometricManager } private val keyStore = KeyStore.getInstance(ANDROID_KEY_STORE) private lateinit var secretKey: SecretKey ... fun enableBiometric(isEnabled: Boolean) { generateKey() val cipher = createCipher().also { preferences.edit { putString(StorageKey.KEY_IV, Base64.encodeToString(it.iv, Base64.DEFAULT)) } } val promptInfo = createPromptInfo() val cryptoObject = BiometricPrompt.CryptoObject(cipher) if (isEnabled) { biometricParams.value = BiometricParams(isEnabled, promptInfo, cryptoObject) } else { pinIsCreated.value = true } } private fun createPromptInfo(): BiometricPrompt.PromptInfo { return BiometricPrompt.PromptInfo.Builder() .setTitle("Create biometric authorization") .setSubtitle("Touch your biometric sensor") .setNegativeButtonText("Cancel") .build() } private fun generateKey() { try { keyStore.load(null) val keyProperties = PURPOSE_ENCRYPT or PURPOSE_DECRYPT val builder = KeyGenParameterSpec.Builder(KEY_NAME, keyProperties) .setBlockModes(BLOCK_MODE_CBC) .setUserAuthenticationRequired(true) .setEncryptionPaddings(ENCRYPTION_PADDING_NONE) val keyGenerator = KeyGenerator.getInstance( KEY_ALGORITHM_AES, ANDROID_KEY_STORE ) keyGenerator.run { init(builder.build()) generateKey() } } catch (e: Exception) { authenticationCallback.onAuthenticationError( BiometricConstants.ERROR_NO_DEVICE_CREDENTIAL, e.localizedMessage ) } } private fun createCipher(): Cipher { val key = with(keyStore) { load(null) getKey(KEY_NAME, null) } return Cipher.getInstance( "$KEY_ALGORITHM_AES/$BLOCK_MODE_CBC/$ENCRYPTION_PADDING_NONE" ).apply { init(Cipher.ENCRYPT_MODE, key) } } } 

मुझे खुशी होगी अगर Google ने Tink in Biometrics को शामिल किया, लेकिन ... हमें इस बायलरप्लेट कोड को सिफर और कीस्टोर के साथ लिखना होगा। यह कोड उन लोगों के लिए काफी परिचित है, जो एंड्रॉइड में क्रिप्टोग्राफी के साथ काम करते हैं, लेकिन मैं एन्क्रिप्शन पैडिंग पर आपका ध्यान देना चाहता हूं। हां, पेडिंग ओरेकल हमले को रोकने के लिए हम पैडिंग का उपयोग बिल्कुल नहीं करते हैं। इस प्रकार, डिस्क पर गुप्त कुंजी संग्रहीत करते समय हम जोखिमों को कम करते हैं।

बॉयोमीट्रिक जाँच के लिए कोड बहुत समान है:

 class InputPinViewModel(application: Application) : AndroidViewModel(application) { companion object { private const val ANDROID_KEY_STORE = "AndroidKeyStore" private const val KEY_NAME = "biometric_key" } ... val biometricErrorMessage = MutableLiveData<SingleLiveEvent<String>>() val biometricParams = MutableLiveData<BiometricParams>() ... private val biometricManager by lazy { getApplication<App>().biometricManager } private val keyStore = KeyStore.getInstance(ANDROID_KEY_STORE) val authenticationCallback = object : BiometricPrompt.AuthenticationCallback() { override fun onAuthenticationError(errorCode: Int, errString: CharSequence) { super.onAuthenticationError(errorCode, errString) } override fun onAuthenticationSucceeded(result: AuthenticationResult) { super.onAuthenticationSucceeded(result) val encryptedSecretKey = Base64.decode( preferences.getString(StorageKey.KEY, ""), Base64.DEFAULT ) val secretKey = result.cryptoObject?.cipher?.doFinal(encryptedSecretKey) val token = try { val encryptedToken = Base64.decode( preferences.getString(StorageKey.TOKEN, null), Base64.DEFAULT ) aead.decrypt(encryptedToken, secretKey) } catch (e: GeneralSecurityException) { null } val state = if (token?.isNotEmpty() == true) { AuthenticationState.AUTHENTICATED } else { AuthenticationState.INVALID_AUTHENTICATION } authenticationState.postValue(state) } override fun onAuthenticationFailed() { super.onAuthenticationFailed() } } ... fun biometricAuthenticate() { if (preferences.contains(StorageKey.KEY)) { when (biometricManager.canAuthenticate()) { BiometricManager.BIOMETRIC_SUCCESS -> { val promptInfo = createPromptInfo() val cryptoObject = BiometricPrompt.CryptoObject(createCipher()) biometricParams.value = BiometricParams(promptInfo, cryptoObject) } } } else { biometricErrorMessage.value = SingleLiveEvent( "Biometric authentication isn't configured" ) } } ... private fun createPromptInfo(): BiometricPrompt.PromptInfo { return BiometricPrompt.PromptInfo.Builder() .setTitle("Biometric login for my app") .setSubtitle("Log in using your biometric credential") .setNegativeButtonText("Cancel") .build() } private fun createCipher(): Cipher { val key = with(keyStore) { load(null) getKey(KEY_NAME, null) } return Cipher.getInstance( "$KEY_ALGORITHM_AES/$BLOCK_MODE_CBC/$ENCRYPTION_PADDING_NONE" ).apply { val iv = Base64.decode( preferences.getString(StorageKey.KEY_IV, null), Base64.DEFAULT ) init(Cipher.DECRYPT_MODE, key, IvParameterSpec(iv)) } } } 

authenticationCallback.onAuthenticationSucceeded ध्यान authenticationCallback.onAuthenticationSucceeded , इसमें पोस्ट-बायोमेट्रिक ऑथेंटिकेशन का मुख्य तर्क होता है। वास्तव में, यह pinIsValid() विधि का एक वैकल्पिक कार्यान्वयन है। यदि आपके पास दो पिछले कोड ब्लॉक में क्या हो रहा है, इसकी कोई मजबूत समझ नहीं है, तो कृपया बायोमेट्रिक आधिकारिक दस्तावेज देखें ।

क्या मैं पूरी तरह से सुरक्षित हूं?

हमने एक पिन और बायोमेट्रिक्स के साथ प्रमाणीकरण का एहसास करने के लिए बहुत सारी शानदार चीजें की हैं, लेकिन क्या यह इतना विश्वसनीय और सुरक्षित है? बेशक, हमने अपना सर्वश्रेष्ठ प्रदर्शन किया है, लेकिन ध्यान में रखने के लिए कुछ बिंदु हैं।

एक क्लासिक पिन में केवल चार अंक होते हैं और इसमें प्रवेश भी बहुत कम होता है। इसलिए, इस तरह का कोड उपयोग करने के लिए काफी सुरक्षित नहीं है। हमने जो कुछ भी किया है उसके बावजूद, एक मौका है कि एक घुसपैठिया इस कोड को क्रैक कर सकता है। हाँ, उसे आपके एप्लिकेशन की रिवर्स इंजीनियरिंग को पूरा करना होगा और समझना होगा कि आप उपयोगकर्ता के डेटा को कैसे एन्क्रिप्ट कर रहे हैं, लेकिन फिर भी। यदि कोई हमलावर पर्याप्त रूप से प्रेरित होता है तो वह बिना किसी हिचकिचाहट के ऐसा करेगा।

दूसरा बिंदु रूट किए गए स्मार्टफ़ोन के बारे में है। जब यह निहित उपकरणों की बात आती है, तो आप अपने सभी सुरक्षा आश्वासन प्रयासों को दूर फेंक सकते हैं। रूट एक्सेस के साथ कोई भी मैलवेयर सभी सुरक्षा तंत्र को बायपास करने में सक्षम है। इसलिए, आपको एप्लिकेशन में अतिरिक्त सुरक्षा सुविधाएं और चेक जोड़ना होगा। मैं आपको इन दोषों को कम करने के लिए दो सबसे सरल चीजें सुझाता हूं:

• सेफ्टीनेट - यह सेवाओं और एपीआई का एक सेट प्रदान करता है जो आपके ऐप को सुरक्षा खतरों से बचाने में मदद करता है, जिसमें डिवाइस से छेड़छाड़, खराब यूआरएल, संभावित हानिकारक ऐप और नकली उपयोगकर्ता शामिल हैं।
• Obfuscation - कृपया याद रखें कि ProGuard एक आक्षेप उपकरण नहीं है! ProGuard छोटा और संसाधन सिकुड़ने के बारे में है, न कि आपत्ति या सुरक्षा के लिए। डेक्सगार्ड, डेक्सप्रोटेक्टर, आदि का उपयोग करें।

इस लेख के दृष्टिकोणों को लागू करने के बाद सेफ्टीनेट और ऑबफिकेशन का उपयोग एक अच्छा अगला कदम है। यदि आप गलतियाँ, सुरक्षा दोष या अन्य बकवास नोट करते हैं, तो कृपया मुझे बताएँ। आप GitHub पर लेख के सभी कोड पा सकते हैं।

और अगली बार मैं आपको दिखाऊंगा कि बैक-एंड का उपयोग करके पिन प्रमाणीकरण कैसे लागू किया जाए। देखते रहो।

उपयोगी लिंक

• KDF फ़ंक्शन: आर्गन 2 , स्क्रीप्ट
• साझा प्राथमिकताओं को एन्क्रिप्ट करने का एक वैकल्पिक तरीका (आरयू)
• सूचना एन्ट्रापी
• अधिक सुरक्षित रूप से डेटा के साथ काम करें