Share
En apps troverdighet i dag avhenger mye av hvordan brukerens private data administreres. Android-stakken har mange kraftige APIer som omgir legitimasjon og nøkkellagring, med spesifikke funksjoner som bare er tilgjengelige i enkelte versjoner.
Denne korte serien vil starte med en enkel tilnærming for å komme seg opp ved å se på lagringssystemet og hvordan å kryptere og lagre sensitive data via et passord som er levert av brukeren. I den andre opplæringen vil vi se på mer komplekse måter å beskytte nøkler og legitimasjon på.
Det første spørsmålet å tenke på er hvor mye data du faktisk trenger å skaffe seg. En god tilnærming er å unngå å lagre private data hvis du ikke virkelig trenger det.
For data som du må lagre, er Android-arkitekturen klar til å hjelpe. Siden 6.0 Marshmallow er fulldiskkryptering aktivert som standard for enheter med mulighet. Filer og SharedPreferences som lagres av appen, settes automatisk inn med MODE_PRIVATE konstant. Dette betyr at dataene kun kan nås av din egen app.
Det er en god ide å holde fast ved denne standarden. Du kan angi det eksplisitt når du lagrer en felles preferanse.
Accentsconagua
SharedPreferences.Editor editor = getSharedPreferences ("preferenceName", MODE_PRIVATE) .edit (); editor.putString ("key", "value"); editor.commit (); Eller når du lagrer en fil.
FileOutputStream fos = openFileOutput (filnavnString, kontekst.MODE_PRIVATE); fos.write (data); fos.close ();
Unngå å lagre data på ekstern lagring, da dataene er synlige av andre apper og brukere. Faktisk, for å gjøre det vanskeligere for folk å kopiere appens binære data og data, kan du forhindre at brukere kan installere appen på ekstern lagring. legge android: install med en verdi på internalOnly til manifestfilen vil oppnå det.
Du kan også forhindre at appen og dataene blir sikkerhetskopiert. Dette forhindrer også at innholdet i en apps private datakatalog lastes ned med Adb backup. For å gjøre det, sett inn android: allowBackup tilskrive falsk i manifestfilen. Som standard er denne attributtet satt til ekte.
Disse er beste praksis, men de fungerer ikke for en kompromittert eller rotfestet enhet, og diskkryptering er bare nyttig når enheten er sikret med en låseskjerm. Dette er hvor å ha et app-side passord som beskytter dataene med kryptering, er fordelaktig.
Conceal er et godt valg for et krypteringsbibliotek fordi det får deg til å løpe veldig fort uten å måtte bekymre deg for de underliggende detaljene. En utnyttelse rettet mot et populært rammeverk vil imidlertid samtidig påvirke alle appene som er avhengige av det.
Det er også viktig å være kunnskapsrik om hvordan krypteringssystemer fungerer for å kunne fortelle om du bruker et bestemt rammeverk sikkert. Så, for dette innlegget, kommer vi til å få hendene våre skitne ved å se på krypteringsleverandøren direkte.
Vi bruker den anbefalte AES-standarden, som krypterer data som er gitt en nøkkel. Den samme nøkkelen som brukes til å kryptere data, brukes til å dekryptere dataene, som kalles symmetrisk kryptering. Det er forskjellige nøkkelstørrelser, og AES256 (256 bits) er den foretrukne lengden for bruk med sensitive data.
Selv om brukeropplevelsen av appen din burde tvinge en bruker til å bruke et sterkt passord, er det en sjanse for at samme passord også blir valgt av en annen bruker. Det er ikke trygt å sette sikkerhet for våre krypterte data i brukerens hender. Våre data må sikres i stedet med en nøkkel Det er tilfeldig og stort nok (dvs. det har nok entropi) å bli ansett som sterk. Derfor anbefales det aldri å bruke et passord direkte for å kryptere data - det er her en funksjon kalles Passordbasert nøkkelavledningsfunksjon (PBKDF2) kommer inn i spill.
PBKDF2 oppnår a nøkkel fra en passord ved hashing det mange ganger med et salt. Dette kalles nøkkelstrekning. Saltet er bare en tilfeldig rekkefølge av data og gjør den avledede nøkkelen unik selv om det samme passordet ble brukt av noen andre.
La oss starte med å generere det saltet.
SecureRandom random = new SecureRandom (); bytesalt [] = nytt byte [256]; random.nextBytes (salt);
De SecureRandom klassen garanterer at den genererte produksjonen blir vanskelig å forutsi - det er en "kryptografisk sterk tilfeldig talgenerator". Vi kan nå sette salt og passord inn i et passordbasert krypteringsobjekt: PBEKeySpec. Objektets konstruktør tar også et iterasjonstallskjema, noe som gjør nøkkelen sterkere. Dette skyldes at økende antall iterasjoner utvider den tiden det ville ta å operere på et sett med nøkler under et brutalt kraftangrep. De PBEKeySpec så blir det passert inn i SecretKeyFactory, som til slutt genererer nøkkelen som en byte [] array. Vi vil vikle den råen byte [] array inn i a SecretKeySpec gjenstand.
char [] passwordChar = passwordString.toCharArray (); // Slå passord til char [] array PBEKeySpec pbKeySpec = ny PBEKeySpec (passwordChar, salt, 1324, 256); // 1324 iterasjoner SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance ("PBKDF2WithHmacSHA1"); byte [] keyBytes = secretKeyFactory.generateSecret (pbKeySpec) .getEncoded (); SecretKeySpec keySpec = ny SecretKeySpec (keyBytes, "AES"); Merk at passordet er bestått som en char [] array og PBEKeySpec klassen lagrer det som en char [] array også. char [] Arrays brukes vanligvis til kryptering funksjoner fordi mens string klassen er uforanderlig, a char [] array som inneholder sensitiv informasjon kan overskrives, og dermed fjerner du sensitive data helt fra enhetens minne.
Vi er nå klar til å kryptere dataene, men vi har en ting å gjøre. Det finnes forskjellige krypteringsmoduser med AES, men vi bruker den anbefalte en: krypteringsblokkering (CBC). Dette opererer på våre data ett kvartal om gangen. Den gode tingen om denne modusen er at hver neste ukrypterte blokk med data er XOR'd med den forrige krypterte blokk for å gjøre krypteringen sterkere. Det betyr imidlertid at den første blokken aldri er like unik som alle de andre!
Hvis en melding som skal krypteres skulle starte med det samme som en annen melding som skal krypteres, vil den begynnelsen krypterte utdata være den samme, og det vil gi en angriper en anelse om å finne ut hva meldingen kan være. Løsningen er å bruke en initialiseringsvektor (IV).
En IV er bare en blokk med tilfeldige byte som vil bli XOR'd med den første blokken med brukerdata. Siden hver blokk avhenger av alle blokkene som er behandlet frem til det punktet, vil hele meldingen bli kryptert unikt identiske meldinger som krypteres med samme nøkkel, vil ikke produsere like resultater.
La oss lage en IV nå.
SecureRandom ivRandom = nytt SecureRandom (); // ikke caching tidligere seeded forekomst av SecureRandom byte [] iv = new byte [16]; ivRandom.nextBytes (iv); IvParameterSpec ivSpec = nytt IvParameterSpec (iv);
Et notat om SecureRandom. I versjon 4.3 og under hadde Java kryptografiarkitekturen et sårbarhet på grunn av feil initialisering av den underliggende pseudorandom-tallgeneratoren (PRNG). Hvis du målretter mot versjon 4.3 og under, er en løsning tilgjengelig.
Bevæpnet med en IvParameterSpec, Vi kan nå gjøre den faktiske kryptering.
Cipher cipher = Cipher.getInstance ("AES / CBC / PKCS7Padding"); cipher.init (Cipher.ENCRYPT_MODE, keySpec, ivSpec); byte [] encrypted = cipher.doFinal (plainTextBytes); Her passerer vi i strengen "AES / CBC / PKCS7Padding". Dette spesifiserer AES-kryptering med cypher-blokkering. Den siste delen av denne strengen refererer til PKCS7, som er en etablert standard for polstringsdata som ikke passer perfekt inn i blokkstørrelsen. (Blokker er 128 bits, og polstring er ferdig før kryptering.)
For å fullføre vårt eksempel, vil vi sette denne koden i en krypteringsmetode som vil pakke resultatet inn i a HashMap inneholder de krypterte dataene sammen med salt- og initialiseringsvektoren som er nødvendig for dekryptering.
