Nilalaman

• Panatilihing napapanahon ang iyong mga dependencies
• Limitahan ang iyong mga kahilingan sa pahintulot
• Hayaan ang iyong mga gumagamit magpasya: Ipinapakita ang piniling app
• Iwasan ang panlabas na imbakan
• Gumamit ng bagong pag-access sa direktoryo ng bagong lokasyon ng Android
• Huwag kailanman cache ng sensitibong data ng gumagamit
• Protektahan ang iyong mga susi laban sa hindi awtorisadong paggamit
• Gawing pribado ang iyong NilalamanProvider
• I-fingerprint ang iyong mga gumagamit, na may biometric authentication
• Sundin lahat pinakamahusay na kasanayan sa networking
• Gumamit ng WebViews nang may pag-iingat
• Pamahalaan ang Ligtas na Socket Layer (SSL) ng iyong app
• Paglikha ng isang File ng Pag-configure ng Security sa Network: Pagtitiwala sa Mga Pasadyang CA
• Magtiwala ng mga karagdagang CA, kung naaangkop
• Huwag magpadala ng sensitibong data sa pamamagitan ng SMS
• Protektahan laban sa mga banta sa seguridad sa mga API ng SafetyNet
• Gumamit ng Protektadong kumpirmasyon ng Android para sa mga sensitibong transaksyon
• Android 10: Patakbuhin nang direkta ang naka-embed na DEX code
• Pagputol

Kung mag-hang ka sa iyong madla at ang iyong reputasyon bilang isang mapagkakatiwalaang developer ng Android, pagkatapos ay kailangan mong seryosohin ang seguridad ng Android app bilang isang developer.

Kung ang iyong app ay tumagas sa pribadong data, ikaw ay nasa panganib na mawala ang isang malaking bahagi ng iyong madla. Naiintindihan ng mga gumagamit ng tech-savvy mobile ngayon na ang pinakamahusay na paraan upang maprotektahan ang kanilang sarili laban sa isang insecure app ay alisin ito sa kanilang aparato. Ang mga malubhang paglabag sa data ay patuloy ding iniulat ng media, kaya ang pagkuha ng isang madulas na diskarte sa mobile security ay maaaring magresulta sa ilang masamang publisidad.

Mataas ang mga pusta, at sa mga bagong nakakahamak na apps na inilalabas sa lahat ng oras, mayroong isang palaging pagtaas ng pagkakataon na ang iyong app ay maaaring magbahagi ng isang aparato sa malware at nakakahamak na third-party code.

Ang pagkuha ng isang madulas na diskarte sa mobile security ay maaaring magresulta sa ilang masamang publisidad.

Sa kabutihang palad, ang Android ay may isang malawak na hanay ng mga built-in na mga tampok ng seguridad na makakatulong upang mapanatiling masikip ang data ng iyong mga gumagamit. Sa artikulong ito, tuklasin namin ang lahat ng mga pangunahing tampok sa privacy na inihurnong sa platform ng Android, kasama ang mga karagdagang tool, diskarte, at pinakamahusay na kasanayan na maaari mong magamit upang makatulong na matiyak na ang iyong data ng pribadong aplikasyon ay mananatiling pribado.

Panatilihing napapanahon ang iyong mga dependencies

Hindi bihira sa mga modernong mobile app na gumamit ng maraming mga aklatan, SDK, at maraming iba pang mga iba't ibang dependencies. Ang mga bagong paglabas ng mga dependencies ay madalas na naglalaman ng mga pag-aayos ng bug, mga patch at iba pang mga tampok ng seguridad, kaya kailangan mong tiyakin na ginagamit mo ang pinakabagong mga bersyon habang binubuo ang iyong app.

Bago i-deploy ang iyong app, magandang ideya din na magsagawa ng isang pangwakas na tseke, tiyaking tiyakin na walang magagamit na mga update.

Kung gumagamit ang iyong app ng Google Play Services, maaari mong suriin kung ang aparato ng gumagamit ay may pinakabagong bersyon na na-install, at pagkatapos ay mag-trigger ng isang pag-update kung kinakailangan.

Upang subukan kung napapanahon ang Mga Serbisyo ng Google Play ng aparato, tawagan ang paraan ng pag-installIfNeeded () na pamamaraan ng ProviderInstaller na klase. Kung magagamit ang isang pag-update, pagkatapos ang pamamaraan na ito ay magtatapon ng isang pagbubukod sa pahintulot, at sasenyasan ang gumagamit na i-update ang Mga Serbisyo ng Play sa Google sa kanilang aparato.

Limitahan ang iyong mga kahilingan sa pahintulot

Kung ang iyong app ay walang pag-access sa isang pahintulot, pagkatapos ay walang posibilidad na mawalan ito ng anumang sensitibong data o pag-andar na nauugnay sa pahintulot na iyon. Ang paghihigpit ng pag-access sa mga sensitibong pahintulot ay maaari ring gawin ang iyong app na hindi gaanong kaakit-akit na target sa mga hacker, kaya mahalaga na humiling ng ilang mga pahintulot hangga't maaari.

Bago gumawa anumang mga kahilingan sa pahintulot, dapat mong isaalang-alang kung mayroong isang paraan upang makamit ang parehong resulta nang walang pag-access sa pahintulot na iyon. Halimbawa, kung kailangan mong mag-save ng ilang data pagkatapos ay ma-access mo ang lokal na imbakan nang hindi humiling ng anumang mga pahintulot, sa halip na subukang i-save ang data sa panlabas, na nangangailangan ng pahintulot ng WRITE_EXTERNAL_STORAGE.

Bilang kahalili, maaari kang gumamit ng mga layunin upang maipasa ang isang gawain sa isang application na mayroon nang kinakailangang mga (mga) pahintulot. Halimbawa, sa halip na humiling ng mga pahintulot sa READ_CONTACTS at WRITE_CONTACTS, maaari mong i-delegate ang isang gawain sa application ng Mga contact:

Intent contactIntent = bagong Intent (Intent.ACTION_INSERT); contactIntent.setType (Mga contactContract.Contact.CONTENT_TYPE); kung (contactIntent.resolveActivity (getPackageManager ())! = null) {startActivity (contactIntent); }

Dapat mo ring iwanan ang anumang mga pahintulot na hindi na kinakailangan ng iyong app, na maaaring makabuluhang bawasan ang dami ng sensitibong data at mga tampok na ang access ng iyong app sa anumang oras.

Hayaan ang iyong mga gumagamit magpasya: Ipinapakita ang piniling app

Bakit ang pag-aaksaya ng oras at enerhiya muling pag-aayos ng gulong? Pinapayagan ka ng mga impormasyong hangarin na magsagawa ng mga gawain sa pakikipagtulungan sa mga application ng third-party, bawasan ang dami ng code na kailangan mong isulat upang maihatid ang lahat ng nais na pag-andar ng iyong app. Sa pamamagitan ng pagpasa ng isang gawain sa isa pang application, maaari mo ring bawasan ang bilang ng mga pahintulot na kinakailangan ng iyong app.

Ang mga hindi sinasadyang hangarin ay makakapagtipid sa iyo ng isang tonelada ng oras, ngunit bibigyan ka rin nila zero kontrol sa kung aling application ang tumugon sa iyong kahilingan. Kung ang isang insecure o malisyosong third party na app ay sumasagot sa iyong sadyang hangarin, baka mayroong pagkakataon na maaari mong hindi sinasadyang mailantad ang personal na data ng gumagamit sa isang third party.Kung ang privacy ng gumagamit ay nasira bilang isang resulta ng application ng ikatlong partido, maaaring ang iyong app ay maaaring makita na nagkasala ng samahan.

Kapag naglalabas ng isang sadyang hangarin, dapat mong ipakita ang tagapili ng app sa Android kung saan posible.

Sa pamamagitan ng pagpapakita ng gumagamit ng isang listahan ng lahat ng mga application na maaaring tumugon sa hangaring ito, binibigyan mo sila ng pagkakataon na pumili ng isang application na personal nilang pinagkakatiwalaan. Bagaman walang garantiya na ang bawat solong gumagamit ay pumili nang matalino, maaari nitong mabawasan ang pagkakataon na magbahagi ka ng data sa isang hindi mapagkakatiwalaang app.

Kapag naglalabas ng isang hangarin, dapat mong suriin kung ang gumagamit ay may maraming mga application na maaaring mahawakan ang hangaring ito. Sa pag-aakalang magagamit ang maraming mga katugmang apps, maaari mong ipakita ang tagapili ng app sa pamamagitan ng pagtawag sa lumikhaChooser () at ipasa ito upang magsimulaActivity ():

Intent myIntent = bagong Intent (Intent.ACTION_SEND); Listahan posiblengActivitiesList = queryIntentActivities (layunin, PackageManager.MATCH_ALL); // Suriin kung higit sa isang app ang maaaring mahawakan ang hangaring ito // kung (posibleActivitiesList.size ()> 1) {// Ipakita ang tagapili ng app // pamagat ng String = getRes Pinagmulan (). GetString (R.string.app_chooser_title); Hangarin ng tagapipili = Intent.createChooser (intensyon, pamagat); pagsisimulaActivity (tagapili); } iba pa kung (intensyon.resolveActivity (getPackageManager ())! = null) {startActivity (intensyon); }

Tandaan na hindi ka dapat gumamit ng isang hangarin na simulan upang magsimula ng isang Serbisyo, dahil wala kang kontrol sa kung aling Serbisyo ang tumutugon sa iyong iminungkahing hangarin.

Iwasan ang panlabas na imbakan

Kailangan mong tiyakin na ang anumang data na naiimbak mo sa aparato ng gumagamit ay hindi ma-access sa iba pang mga application - maliban kung bibigyan mo ng mga aprubadong pag-apruba ang mga app na iyon.

Ang mga file na nai-save sa panlabas na imbakan ay buong mundo na mabasa at mai-sulat, kaya ang anumang data na nai-save mo sa panlabas na imbakan ay maaaring ma-access at mabago ng anumang iba pang application. Wala ring garantiya na ang isang panlabas na storage medium ay mananatiling konektado sa kasalukuyang smartphone o tablet. Kung nagsusulat ang iyong app sa panlabas na imbakan, pagkatapos maaari mong mai-save ang sensitibong data ng gumagamit sa isang SD card na kalaunan ay aalisin at ipasok sa aparato ng ibang tao!

Maliban kung mayroon kang isang tukoy na kadahilanan na hindi, dapat mong palaging magse-save ng data sa panloob na imbakan, kung saan ito ay naka-sandwich at maa-access lamang sa iyong app nang default. Bilang karagdagan, kung ibinabalik ng isang gumagamit ang iyong aplikasyon, pagkatapos ang lahat ng mga file ng iyong app ay tatanggalin mula sa panloob na imbakan, kaya hindi mo kailangang mag-alala tungkol sa pag-iwan ng anumang sensitibong impormasyon.

Sa mga sumusunod na snippet, nagsusulat kami ng data sa panloob na imbakan:

panghuling String FILE_NAME = "user_data.txt"; String fileContents = "Ang tekstong file na ito ay naglalaman ng sensitibong data ng gumagamit"; subukan (BufferedWriter manunulat = bagong BufferedWriter (bagong FileWriter (bagong File (getFilesDir (), FILE_NAME)))) {writer.write (fileContents); } mahuli (IOException e) {// Gawin: Pangasiwaan ang pagbubukod //}

Kung ang data ay sensitibo lalo, maaari kang magbigay ng ilang karagdagang seguridad ng Android app sa pamamagitan ng pag-encrypt ng mga file na may susi na hindi naa-access sa iyong app, halimbawa isang key na inilalagay sa isang Keystore at protektado ng isang password na hindi naka-imbak sa ang aparato.

Gumamit ng bagong pag-access sa direktoryo ng bagong lokasyon ng Android

Minsan, ang isang app ay maaaring mangailangan ng pag-access sa mga tiyak na direktoryo sa loob ng panlabas na imbakan ng isang aparato, halimbawa ng pagkuha ng access sa direktoryo ng panlabas na Larawan ng aparato.

Habang maaari mong hilingin ang pahintulot sa READ_EXTERNAL_STORAGE, madalas itong magbigay ng iyong app ng pag-access sa mas maraming data kaysa sa kailangan nito. Hindi imposible para sa isang app na hindi masira ang data na wala itong access, kaya dapat mong subukang bawasan ang dami ng impormasyon na ma-access ng iyong aplikasyon, saanman posible.

Sa halip na humiling ng pahintulot sa READ_EXTERNAL_STORAGE, maaari kang humiling ng pag-access sa isang tukoy na direktoryo. Ito scoped na pag-access sa direktoryo hinihiling sa iyo na gamitin ang klase ng StorageManager at pagkatapos ay lumikha ng isang hangarin sa pamamagitan ng pagtawag sa StorageVolume.createAccessIntent () na pamamaraan ng pagkakataong iyon. Halimbawa, sa sumusunod na snippet kami ay naka-access sa direktoryo ng panlabas na Larawan:

ImbakanManager newStorageManager = (StorageManager) getSystemService (Context.STORAGE_SERVICE); ImbakanVolume volume = newStorageManager.getPrimaryStorageVolume (); Hangarin na hangarin = volume.createAccessIntent (Kapaligiran.DIRECTORY_PICTURES); simulanActivityForResult (layunin, kahilingan_code);

Kung ibigay ng gumagamit ang iyong pag-access sa app na ito sa panlabas na direktoryo, tatawagan ng Android ang iyong onActivityResult () na maabutan ang isang code ng resulta ng RESULT_OK, kasama ang isang hangarin na naglalaman ng URI para sa hiniling na direktoryo.

Huwag kailanman cache ng sensitibong data ng gumagamit

Kapag humawak ng data ng application na hindi sensitibo, maaari mong mapagbuti ang karanasan ng gumagamit sa pamamagitan ng pag-iimbak ng data na ito sa cache ng aparato.

Para sa mga cache na mas malaki kaysa sa 1 MB, maaari mong gamitin ang getExternalCacheDir (), na ibabalik ang landas sa isang direktoryo na partikular sa aplikasyon kung saan maaari mong maiimbak ang iyong naka-cache na nilalaman.

Kung magpasya kang mag-cache, tandaan lamang na ang anumang aplikasyon na may pahintulot na WRITE_EXTERNAL_STORAGE ay maaaring may nakasulat sa mga file na ito, kaya dapat mong hindi mag-imbak ng pribado o sensitibong impormasyon sa cache kung nagmamalasakit ka tungkol sa seguridad ng Android app.

Protektahan ang iyong mga susi laban sa hindi awtorisadong paggamit

Hinahayaan ka ng sistemang Android Keystore na mag-imbak ka ng mga key ng kriptograpiko sa loob ng isang lalagyan, na ginagawang mas mahirap makuha ang mga key na ito mula sa aparato.

Tiniyak ng Android Keystore na ang pangunahing materyal ay hindi nakapasok sa proseso ng aplikasyon, kaya kahit na ang mga proseso ng iyong aplikasyon ay nakompromiso at ang isang mang-atake ay nag-access sa iyong mga susi, hindi nila makukuha ang kanilang pangunahing materyal.

Maaari mo ring gamitin ang Keystore upang paghigpitan kung kailan at paano magamit ang iyong mga susi, halimbawa maaari mong paghigpitan ang pangunahing paggamit sa ilang mga mode ng cryptographic, o nangangailangan ng pagpapatunay ng gumagamit.

Gawing pribado ang iyong NilalamanProvider

Ang ContentProvider ay isang nakabalangkas na mekanismo ng imbakan na maaari mong gawing pribado sa iyong aplikasyon o pumili upang i-export, sa puntong ito ay maa-access sila sa iba pang mga app.

Maliban kung tahasang kailangan mong magbahagi ng data sa isang application ng third party, dapat mong gawing pribado ang lahat ng iyong ContentProviders, sa pamamagitan ng pagmamarka ng mga ito bilang android: nai-export = mali sa Manifest ng iyong aplikasyon. Kung ang iyong aplikasyon ay katugma sa Android 4.1.1 o mas mababa, lalo na mahalaga na markahan mo ang iyong pribadong NilalamanProvider bilang android: nai-export = maling, dahil ang lahat ng mga ContentProvider ay pampubliko sa pamamagitan ng default.

I-fingerprint ang iyong mga gumagamit, na may biometric authentication

Bago pinahihintulutan ang isang gumagamit na ma-access ang alinman sa sensitibong impormasyon o tampok ng iyong app, dapat mong i-verify ang kanilang pagkakakilanlan sa pamamagitan ng paghingi ng kanilang mga kredensyal.

Ang mga kredensyal ng gumagamit ay maaaring gumawa ng form ng isang PIN o password, gayunpaman, kung saan posible na mas ligtas na magsagawa ng pagpapatunay ng biometric, halimbawa sa pamamagitan ng paghiling ng fingerprint ng gumagamit.

Sundin lahat pinakamahusay na kasanayan sa networking

Hindi tulad ng hindi gaanong mga portable na aparato tulad ng mga desktop computer, madalas naming ikinonekta ang aming mga smartphone at tablet sa mga unsecured wireless network, tulad ng libreng pampublikong Wi-Fi. Upang makatulong na mapanatili ang privacy ng gumagamit, dapat mong lapitan ang lahat ng mga transaksyon sa network na likas na mapanganib, lalo na kapag naghahatid ka ng data ng gumagamit.

Kailanman kailangan mong magsagawa ng isang transaksyon sa network, mahalaga na sundin mo ang lahat ng pinakamahusay na kasanayan sa networking ng Android:

• Gumamit ng HTTPS sa halip na HTTP, kapag sinusuportahan ito sa server.
• Huwag kailanman magtiwala sa data na na-download mula sa mga protocol ng hindi secure, kabilang ang anumang mga tugon na inilabas laban sa HTTP.
• Gumamit ng naaangkop na mga protocol para sa sensitibong data, tulad ng HttpsURLConnection.
• Kung posible ang pagpapatunay, gumamit ng isang mekanismo ng IPC ng Android, tulad ng isang Serbisyo.
• Gamitin ang bukas na mapagkukunan ng seguridad ng network ng Nogotofail upang masubukan ang iyong app laban sa kilalang mga kahinaan sa TLS / SSL at maling pagsasaayos. Kasama sa Nogotofail ang mga pagsubok para sa mga karaniwang isyu sa pag-verify ng sertipiko ng SSL, mga HTTPS at TLS / SSL na mga bug ng library, mga isyu sa cleartext, at mga isyu sa pagtanggal ng SSL at STARTTLS. Para sa karagdagang impormasyon, tingnan ang pahina ng GitHub ng Nogotofail.
• Saanman posible, iwasan ang pag-load ng code mula sa labas ng iyong APK dahil pinatataas nito ang pagkakataon ng isang tao sa network na binabago ang iyong code habang ito ay ipinadala.

Gumamit ng WebViews nang may pag-iingat

Ang sangkap ng WebView ay maaaring kumonsumo ng HTML at JavaScript, kaya kung hindi mo tama na ginagamit ang mga WebViews ang iyong aplikasyon ay masusugatan sa mga karaniwang isyu sa seguridad sa web, tulad ng pag-script ng cross-site.

Kung hindi ka wastong gumagamit ng WebViews ang iyong aplikasyon ay masugatan sa mga karaniwang isyu sa seguridad sa web.

Upang makatulong na mapanatiling ligtas ang mga gumagamit ng Android, ang sangkap ng WebView ay hindi nagpapatupad ng JavaScript nang default. Gayunpaman, kung kinakailangan maaari mong paganahin ang JavaScript sa pamamagitan ng paggamit ng getSettings () upang makuha ang WebSettings, at pagkatapos ay pagpapatakbo ng setJavakripEnabled () na pamamaraan:

WebView myWebView = (WebView) hanapinViewById (R.id.webview); WebSettings webSettings = myWebView.getSettings (); webSettings.setJavakripEnabled (totoo);

Kahit na kailangan mong paganahin ang JavaScript, dapat mong iwasan ang paggamit ng addJavaScriptInterface () kung saan posible, dahil ang pamamaraang ito ay iniksyon ang ibinigay na object ng Java sa bahagi ng WebView. Kung ang iyong app ay naka-install sa isang aparato na nagpapatakbo ng Android 4.2 o mas maaga, kung gayon ang pamamaraang ito ay maaaring potensyal na pahintulutan ng JavaScript ang iyong aplikasyon.

Kung gumagamit ka ng WebViews, hindi mo papayagan ang mga gumagamit na mag-navigate sa anumang website na hindi mo kontrolin, ngunit lalo na dapat mong hindi gamitin ang addJavascriptInterface () na paraan kung ang gumagamit ay maaaring potensyal na mag-navigate sa isang hindi pinagkakatiwalaang webpage, dahil ito ay isang malaking peligro sa seguridad ng Android app.

Hindi mo dapat gamitin ang addJavascriptInterface () na paraan kung ang gumagamit ay maaaring potensyal na mag-navigate sa isang hindi pinagkakatiwalaang webpage.

Kung ang iyong bahagi ng WebView ay naka-access sa anumang personal na data, maaaring gusto mong pana-panahong tanggalin ang anumang mga file na nakaimbak nang lokal, gamit ang paraan ng clearCache (). Bilang kahalili, maaari mong pigilan ang iyong app mula sa cache ng sensitibong nilalaman, gamit ang header ng no-cache server.

Pamahalaan ang Ligtas na Socket Layer (SSL) ng iyong app

Ang SSL ay isang pangkaraniwang bahagi ng naka-encrypt na komunikasyon sa pagitan ng mga kliyente at server. Kung hindi tama ang paggamit ng iyong app sa SSL pagkatapos ng malisyosong mga third party ay maaaring makagambala sa data ng iyong aplikasyon habang ipinadala ito sa isang network.

Karaniwan, ang isang server ay na-configure na may isang sertipiko na naglalaman ng isang pampublikong key at isang pagtutugma ng pribadong key. Bilang bahagi ng komunikasyon sa pagitan ng SSL client at server, pipirma ng server ang sertipiko nito sa public-key na kriptograpiya. Gayunpaman, posible para sa isang ikatlong partido na makabuo ng sarili nitong sertipiko at pribadong key, kaya ang iyong kliyente ay dapat ding magkaroon ng isa o higit pang mga sertipiko na pinagkakatiwalaan nito. Kung ang isang sertipiko ay hindi nakatakda, ang iyong aplikasyon ay hindi dapat magtiwala sa server.

Upang gawing mas madali ang prosesong ito, ang mga server ay madalas na na-configure na may mga sertipiko mula sa kilalang Mga Awtoridad sa Sertipiko (CA). Bilang ng antas ng API 17, sinusuportahan ng Android ang higit sa 100 CA na na-update sa bawat paglaya. Kapag naglalabas ng isang sertipiko para sa isang server, pipirma ng CA ang sertipiko ng server gamit ang pribadong susi nito, at maaaring mapatunayan ng kliyente na ang sertipiko ay inisyu ng isang CA na kilala at pinagkakatiwalaan ng platform ng Android.

Kung ang iyong app ay nakikipag-usap sa isang web server na mayroong sertipiko na inisyu ng isang pinagkakatiwalaang CA, maaari mong gawin ang iyong kahilingan sa ilang mga linya ng code:

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

Gayunpaman, may ilang mga sitwasyon kung saan ang code sa itaas ay magreresulta sa isang pagbubukod:

• Ang CA na naglabas ng sertipiko ng server ay hindi kilala. Sa sitwasyong ito, maaari mong turuan ang HttpsURLConnection upang magtiwala sa hanay ng mga CA na ito.
• Ang sertipiko ng server ay nilagdaan sa sarili, na nangangahulugang ang server ay kumikilos bilang sariling CA. Para sa mga sertipiko na naka-sign sa sarili, maaari kang lumikha ng iyong sariling TrustManager, bagaman dapat mong tiyakin na ang iyong sertipiko na naka-sign sa sarili ay may isang malakas na susi.
• Nawawala ang pagsasaayos ng server ng isang intermediate CA. Maraming mga pampublikong CA ang hindi direktang pinirmahan ang mga sertipiko ng server. Pinagkakatiwalaan lamang ng Android ang mga CAs, kaya ang server ay kakailanganin magpadala ng isang kadena ng mga sertipiko mula sa server CA sa pamamagitan ng anumang mga tagapamagitan na kinakailangan upang maabot ang ugat. Kung hindi mo mai-configure ang server upang maisama ang intermediate CA sa chain chain, pagkatapos ang isang posibleng workaround ay ang lumikha ng iyong sariling TrustManager.

Paglikha ng isang File ng Pag-configure ng Security sa Network: Pagtitiwala sa Mga Pasadyang CA

Kung nais mong gumamit ng bago o pasadyang CA ang iyong app, dapat kang lumikha ng isang file ng Network Security Configuration kung saan tinukoy mo ang mga setting ng seguridad ng iyong network.

Upang lumikha ng isang Network Security Configur file:

• Kung ang iyong proyekto ay hindi na naglalaman ng isang XML folder, kakailanganin mong lumikha ng isa. I-control-click ang folder ng iyong proyekto at piliin ang Bago> Direktor ng Android mapagkukunan.
• Lumikha ng isang bagong file ng mapagkukunan XML sa loob ng iyong direktoryo ng XML, na magsisilbing file ng Configuration ng Network Security. Pinangalanan ko ang file na ito network_config.
• Buksan ang iyong file ng pagsasaayos ng network at tukuyin na ang lahat ng trapiko sa mga sumusunod na domain ay dapat gumamit ng HTTPS:

// Huwag paganahin ang malinaw na teksto // // Ilapat ang panuntunang ito sa domain at lahat ng mga subdomain nito // my.domain.com ... ... ...

Maaari mo na ngayong tukuyin ang hanay ng mga pasadyang CA na dapat pinagkakatiwalaan ng iyong aplikasyon. Halimbawa, kung nais mong kumonekta sa isang host na gumagamit ng isang naka-sign na CA, magdagdag ka ng sumusunod sa iyong file ng Network Security Configur:

my.domain.com // Isang hanay ng tiwala na mga angkla para sa ligtas na koneksyon // // Isang hanay ng mga sertipiko para sa mga elemento ng tiwala sa angkla, at ang mapagkukunan ng mga sertipiko na ito //

Huwag kalimutang ideklara ang file ng Configurations ng Network Security sa iyong Pinakikita:

Kailangan mong magdagdag ng mga pinagkakatiwalaang CA sa res / raw / pinagkakatiwalaan / proyekto, sa format na PEM o DER.

Magtiwala ng mga karagdagang CA, kung naaangkop

Sa wakas, baka gusto mong magtiwala sa mga karagdagang CA na hindi kilala sa platform ng Android. Upang madagdagan ang bilang ng mga CA na pinagkakatiwalaan ng iyong aplikasyon, kakailanganin mong tukuyin ang maraming mga mapagkukunan ng sertipiko:

Huwag magpadala ng sensitibong data sa pamamagitan ng SMS

Kung kailangan mong magpadala ng data mula sa isang server patungo sa iyong aplikasyon, dapat mong gamitin ang Google Cloud Messaging (GCM) at pagmemensahe ng IP, at hindi kailanman ang hindi naka-print na protocol ng SMS.

Basahin din: Pag-unlad ng Android: Paano tumawag, makatanggap ng SMS, at makuha ang mga contact ng mga gumagamit

Hindi ka dapat ding magsagawa ng mga sensitibong utos gamit ang SMS s, dahil ang SMS ay ipinapadala bilang mga intensyong broadcast, nangangahulugang ang anumang aplikasyon na may pahintulot sa READ_SMS ay mai-access ang kanilang mga nilalaman.

Protektahan laban sa mga banta sa seguridad sa mga API ng SafetyNet

Nagbibigay ang SafetyNet ng isang hanay ng mga serbisyo at mga API na magagamit mo upang maprotektahan ang iyong app laban sa mga banta sa seguridad tulad ng pag-tamper ng aparato, mga nakakahamak na URL, at pekeng mga gumagamit.

Sinusuportahan ng Android ang mga sumusunod na API ng SafetyNet:

• SafetyNet Attestation API. Pinapayagan ka ng anti-abuso na API na ma-access mo ang aparato ng Android kung saan tumatakbo ang iyong aplikasyon, kaya matutukoy mo kung nakikipag-ugnay ang iyong mga server sa isang tunay na aparato.
• SafeNet Ligtas na Pagba-browse ng API. Maaari mong gamitin ang API na ito upang matukoy kung inuri ng Google ang isang partikular na URL bilang isang kilalang banta.
• SafetyNet reCAPTCHA API. Kasama sa serbisyong ito ang isang reCAPTCHA API na magagamit mo upang maprotektahan ang iyong app laban sa mga banta tulad ng spam at malisyosong trapiko. Kung pinaghihinalaan ng API na nakikipag-ugnay ang iyong app sa isang bot, pagkatapos ay maghatid ito ng isang CAPTCHA na dapat malutas ng tatanggap bago nila ipagpatuloy ang paggamit ng iyong app.
• KaligtasanNet Patunayan ang Apps API. Kung naglalaman ang iyong app ng sensitibong data ng gumagamit, maaari mong gamitin ang API na ito upang makipag-ugnay sa tampok na I-verify ang Apps ng aparato, at suriin kung ang aparato ay libre mula sa mga nakakahamak na application. Kung hindi ligtas ang aparato, maaari kang magsagawa ng ilang mga limitasyon sa pinsala sa pamamagitan ng hindi paganahin ang lahat ng mga sensitibong tampok ng iyong app. Batid lamang na kahit na alerto ng SafetyNet ang mga gumagamit sa anumang potensyal na nakakapinsalang apps na natuklasan nito, walang garantiya na talagang tatanggalin ng gumagamit ang mga app na ito. Bilang karagdagan, ang mga nakakahamak na apps ay pinakawalan sa lahat ng oras, at ang mga hacker ay laging may mga bago at mapanlikha na mga paraan upang madulas sa ilalim ng radar, kaya kahit na ang isang aparato ay pumasa sa pagsubok sa SafetyNet hindi mo dapat ipagpalagay na walang nakakapinsalang mga app sa ang aparato.

Para sa karagdagang impormasyon tungkol sa mga API ng SafetyNet, kabilang ang mga tagubilin sa kung paano gamitin ang mga ito sa iyong mga app, suriin ang opisyal na mga dokumento ng Android.

Gumamit ng Protektadong kumpirmasyon ng Android para sa mga sensitibong transaksyon

Kung ang iyong app ay kailangang magsagawa ng isang sensitibong transaksyon, tulad ng paggawa ng pagbabayad, pagkatapos ay maaari mong gamitin ang Android Protected Confirmation sa mga aparato na tumatakbo sa Android 9 (API antas 28) o mas mataas.

Sa bawat oras na sinusubukan ng gumagamit na makumpleto ang isang sensitibong transaksyon, ang Android Protected Confirmation ay magpapakita ng isang agarang humihiling sa kanila na tanggapin ang isang maikling pahayag. Kung aprubahan ng gumagamit ang pahayag na ito, maaari mong lagdaan ang paggamit ng isang susi mula sa Android Keystore.

Para sa karagdagang impormasyon, kasama ang mga tagubilin sa kung paano ipatupad ang Android Protected Confirmation, tingnan ang opisyal na mga dokumento ng Android.

Android 10: Patakbuhin nang direkta ang naka-embed na DEX code

Sa mga aparato na nagpapatakbo ng Android 10 (API antas 29) at mas mataas, posible na magpatakbo ng naka-embed na DEX code nang direkta mula sa file ng APK ng iyong app, na makakatulong na maiwasan ang isang pag-atake kahit na ang hacker ay namamahala upang makagambala sa code na naipon ng lokal ng aparato.

Basahin din: Pag-explore ng Android Q: Pagdaragdag ng mga abiso sa bubble sa iyong app

Upang paganahin ang bagong tampok na seguridad, buksan ang Manifest ng iyong proyekto at idagdag ang sumusunod sa elemento:

Susunod, kakailanganin mong bumuo ng isang file ng APK na naglalaman ng hindi naka-compress na DEX code na maaaring direktang ma-access ng ART. Buksan ang iyong file na build.gradle, at idagdag ang sumusunod:

aaptOptions {noCompress dex}

Alalahanin lamang na gagamitin ng ART ang JIT compiler kapag nagsimula ang iyong app, na maaaring makaapekto sa pagganap ng iyong aplikasyon.

Pagputol

Sa artikulong ito, sinakop namin ang lahat ng pinakamahusay na kasanayan, mga tool, API at mga pamamaraan na maaari mong magamit upang makatulong na mapanatili ang seguridad ng iyong Android app.

Mayroon ka bang anumang payo para sa pagtaas ng seguridad ng iyong aplikasyon? Siguraduhing ibahagi ang iyong mga tip sa mga komento sa ibaba!