Keys, Credentials dan Storage pada Android

() translation by (you can also view the original English article)

Pada postingan sebelumnya tentang keamanan data pengguna Android, kita melihat pada proses enkripsi data melewati user-supplied passcode. Pada tutorial ini akan memfokuskan pada credential dan key storage. Saya akan memulai dengan memperkenalkan account credential dan diakhiri dengan mengamankan data menggunakan KeyStore.

Sering, ketika bekerja dengan third-party service, akan terdapat beberapa bentuk dari autentikasi yang diperlukan. Ini akan terlihat sederhana seperti /login pada titik akhir yang menerima username dan password.

Itu akan terlihat sesuatu bahwa solusi yang sederhana untuk membangun UI yang meminta user untuk login dan kemudian mengambil dan menyimpan login credential mereka. Namun, ini bukan cara yang baik karena aplikasi kita tidak perlu tahu credential dari akun third-party. Tapi, kita dapat menggunakan Account Manager, dimana akan melimpahkan informasi sensitf pada kita.

Account Manager

Account Manager merupakan suatu helper yang terpusat untuk user account credential jadi aplikasi Anda tidak perlu untuk menangani banyak password secara langsung. Ini biasanya akan menyiapkan sebuah token pada tempat dimana username dan password yang asli dapat digunakan untuk membuat suatu permintaan autentikasi untuk sebuah service. Sebagai contoh adalah ketika meminta request beberapa OAuth2 token.

Terkadang, semua informasi yang dibutuhkan sudah tersimpan pada suatu perangkat, dan pada kesempatan lain suatu Account Manager akan membutuhkan panggilan sebuah server untuk mendapatkan token yang baru. Anda mungkin sudah melihat bagian Akun pada suatu pengaturan perangkat untuk berbagai macam aplikasi. Kita dapat mengambil semua daftar yang tersedia pada akun seperti ini:

1	AccountManager accountManager = AccountManager.get(this);
2	Account[] accounts = accountManager.getAccounts();

Code ini akan membutuhkan izin android.permission.GET_ACCOUNTS. Jika Anda mencari suatu akun yang spesifik, Anda bisa mencarinya seperti ini:

1	AccountManager accountManager = AccountManager.get(this);
2	Account[] accounts = accountManager.getAccountsByType("com.google");

Ketika Anda telah mendapatkan akun tersebut, sebuah token untuk akun bisa diambil dengan cara memanggil metohod getAuthToken(Account, String, Bundle, Activity, AccountManagerCallback, Handler). Token kemudian bisa digunakan untuk membuat autentikasi API requests ke suatu service. Ini bisa jadi adalah sebuah RESTful API dimana Anda bisa menyampaikan pada parameter token ketika dilakukan HTTPS request, tanpa sama sekali untuk mengetahui detail dari akun pribadi pengguna

Karena setiap service akan mempunyai cara yang berbeda untuk melakukan autentikasi dan menyimpan suatu private credentials, Account Manager menyediakan authenticator module untuk third-party service untuk di implementasi. Ketika Android telah melakukan implementasi untuk banyak service yang popular, ini berarti Anda dapat menulis authenticator Anda sendiri untuk menangani account authentication untuk aplikasi Anda dan tempat penyimpanan credential. Ini memungkinkan Anda untuk memastikan credentialnya ter-enkripsi. Yang harus diingat, Ini juga berarti credential pada Account Manager digunakan untuk service lain yang mungkin disimpan dalam teks asli, membuat mereka mudah dilihat oleh siapapun yang telah melakukan root pada perangkatnya.

Dari pada credential yang sederhana, ada waktunya ketika Anda membutuhkan suatu kunci atau sertifikat untuk individual atau suatu kelompok, sebagai contoh, ketika suatu third-party mengirimkan Anda sebuah file sertifikat yang Anda harus simpan. Skenario yang paling umum adalah ketika suatu aplikasi membutuhkan autentikasi untuk private organization’s server.

Pada tutorial selanjutnya, kita akan melihat cara menggunakan sertifikat untuk autentikasi dan mengamankan suatu komunikasi, tapi saya akan mengingatkan bagaimana cara menyimpan item ini pada sementara waktu. Pada dasarnya Keychain API dibuat untuk sesuatu yang spesifik, melakukan install private key atau pasangan sertifikat dari sebuah PKCS#12 file.

Keychain

Diperkenalkan pada Android 4.0(API level 14), Keychain API terlibat dengan key management. Secara spesifik, itu dapat bekerja dengan PrivateKey dan X509Certificate objek dan menyediakan container yang lebih aman daripada menggunakan penyimpanan data aplikasi Anda. Itu karena izin untuk sebuah private key hanya memperbolehkan untuk aplikasi Anda, dan hanya setelah dilakukan autorisasi. Ini berarti suatu layar kunci harus di siapkan sebelum mengakses sebuah penyimpanan credential. Juga, objek di Keychain mungkin terikat pada secure hardware, jika tersedia.

Code ini akan meng-install sebuah sertifikat seperti:

1	Intent intent = KeyChain.createInstallIntent();
2	byte[] p12Bytes = //... read from file, such as example.pfx or example.p12...
3	intent.putExtra(KeyChain.EXTRA_PKCS12, p12Bytes);
4	startActivity(intent);

Pengguna akan diminta sebuah password untuk mengakses private key dan pilihan untuk nama sertifikat. Untuk mengambil kunci, kode berikut menyajikan UI yang memperbolehkan user untuk memilih daftar dari kunci yang sudah terinstall.

1	KeyChain.choosePrivateKeyAlias(this, this, new String[]{"RSA"}, null, null, -1, null);

Ketika sudah membuat pilihan, sebuah string atau nama di tampilkan pada sebuah alias(final String alias) dimana Anda bisa mengakses private key atau rantai sertifikat secara langsung.

public class KeychainTest extends Activity implements ..., KeyChainAliasCallback
{
    //...
    
    @Override
    public void alias(final String alias)
    {
        Log.e("MyApp", "Alias is " + alias);

        try
        {
            PrivateKey privateKey = KeyChain.getPrivateKey(this, alias);
            X509Certificate[] certificateChain = KeyChain.getCertificateChain(this, alias);
        }
        catch ...
    }
    
    //...
}

Dengan memiliki pengetahuan tersebut, mari kita melihat bagaimana kita menggunakan penyimpanan credential untuk menyimpan data sensitif Anda.

KeyStore

Pada tutorial sebelumnya, kita melihat proses melindungi data menggunakan user-supplied passcode. Cara seperti ini bagus, tetapi kebutuhan suatu aplikasi biasanya menjauhi user untuk melakukan log in setiap waktu dan mengingat suatu passcode tambahan.

Itulah dimana KeyStore API bisa digunakan. Sejak API 1, KeyStore telah digunakan oleh sistem untuk menyimpan Wifi dan VPN credential. Seperti 4.3 (API 18), memungkinkan Anda untuk bekerja dengan app-specific asymmetric keys Anda sendiri, dan pada Android M (API 23) itu bisa menyimpan AES symmetric key. Jadi ketika API tidak memperbolehkan untuk menyimpan data sensitif secara langsung, kunci ini bisa disimpan dan kemudian digunakan untuk mengenkripsi kalimat.

Keunggulan dari menyimpan suatu kunci di KeyStore itu adalah memperbolehkan kunci untuk dioperasikan tanpa mengekspos konten rahasia dari si kunci; data kunci tidak masuk pada penyimpanan aplikasi. Ingat bahwa kunci diamankan menggunakan izin jadi hanya aplikasi Anda yang dapat mengakses mereka, dan mereka juga dapat menggunakan perangkat keras yang didukung jika perangkat tersebut mendukung. Ini membuat container lebih sulit untuk di ekstrak dari perangkat.

Menghasilkan sebuah Random Key Baru

Sebagai contoh, daripada menghasilkan kunci AES dari user-supplied passcode, kita bisa menghasilkan kunci acak secara otomatis yang akan diamankan di KeyStore. Kita bisa melakukan ini dengan membuat KeyGenerator instance, siapkan untuk "AndroidKeyStore" provider.

//Generate a key and store it in the KeyStore
final KeyGenerator keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
final KeyGenParameterSpec keyGenParameterSpec = new KeyGenParameterSpec.Builder("MyKeyAlias",
        KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
        //.setUserAuthenticationRequired(true) //requires lock screen, invalidated if lock screen is disabled
        //.setUserAuthenticationValidityDurationSeconds(120) //only available x seconds from password authentication. -1 requires finger print - every time
        .setRandomizedEncryptionRequired(true) //different ciphertext for same plaintext on each call
        .build();
keyGenerator.init(keyGenParameterSpec);
keyGenerator.generateKey();

Bagian penting yang perlu dilihat disini adalah .setUserAuthenticationRequired(true) dan spesifikasi .setUserAuthenticationValidityDurationSeconds(120). Ini dibutuhkan untuk mengunci layar yang di siapkan dan akan terkunci sampai user ter-autentikasi.

Melihat dari dokumentasi untuk .setUserAuthenticationValidityDurationSeconds(), Anda berarti akan melihat kunci hanya tersedia beberapa detik dari suatu autentikasi password, dan dikirim pada -1 yang dibutuhkan untuk fingerprint authentication setiap kali Anda ingin mengakses kunci. Memungkinkan kebutuhan untuk autentikasi juga memilki efek untuk menolak kunci ketika user menghapus atau mengubah kunci pada layar.

Karena menyimpan sesuatu yang tidak terlindungi bersamaan dengan data yang terenkripsi seperti menaruh kunci rumah dibawah keset, pilihan ini mencoba untuk mengamankan kunci di setiap kegiatan yang ada pada perangkat. Sebagai contoh seperti offline data dump dari suatu perangkat. Tanpa sebuah password yang diketahui untuk sebuah perangkat, data yang dirender tidaklah berguna.

Pengaturan .setRandomizedEncryptionRequired(true) memungkinkan kebutuhan yang cukup untuk melakukan sesuatu secara acak (sebuah random IV setiap saat) jadi jika data yang sama terenkripsi setiap detik, hasil enkripsi akan tetap berbeda. Ini akan mencegah penyerang untuk mendapatkan sebuah petunjuk tentang ciphertext dari data yang sama.

Pengaturan yang lain yang perlu dicatat adalah setUserAuthenticationValidWhileOnBody(boolean remainsValid), yang mengunci sebuah kunci ketika perangkat terdeteksi tidak pada pemilik yang asli.

Mengenkripsi Data

Sekarang kunci tersebut disimpan di KeyStore, kita bisa membuat method yang mengenkripsi data menggunakan Cipher object, yang diberikan SecretKey. Itu akan membalikan sebuah HashMap yang mengandung data terenkripsi dan sebuah randomize IV yang akan dibutuhkan untuk mendekripsi data. Enkripsi data, bersama dengan IV, bisa kemudian disimpan pada sebuah file atau pada shared preferences.

private HashMap<String, byte[]> encrypt(final byte[] decryptedBytes)
{
    final HashMap<String, byte[]> map = new HashMap<String, byte[]>();
    try
    {
        //Get the key
        final KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
        keyStore.load(null);
        final KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry)keyStore.getEntry("MyKeyAlias", null);
        final SecretKey secretKey = secretKeyEntry.getSecretKey();

        //Encrypt data
        final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        final byte[] ivBytes = cipher.getIV();
        final byte[] encryptedBytes = cipher.doFinal(decryptedBytes);
        map.put("iv", ivBytes);
        map.put("encrypted", encryptedBytes);
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }

    return map;
}

Mendekripsi ke Byte Array

Untuk mendekripsi, suatu reverse diperlukan. Cipher object di inisialisasi menggunakan konstan DECRYPT_MODE, dan sebuah dekripsi byte[] array yang akan dikembalikan.

private byte[] decrypt(final HashMap<String, byte[]> map)
{
    byte[] decryptedBytes = null;
    try
    {
        //Get the key
        final KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
        keyStore.load(null);
        final KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry)keyStore.getEntry("MyKeyAlias", null);
        final SecretKey secretKey = secretKeyEntry.getSecretKey();

        //Extract info from map
        final byte[] encryptedBytes = map.get("encrypted");
        final byte[] ivBytes = map.get("iv");

        //Decrypt data
        final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        final GCMParameterSpec spec = new GCMParameterSpec(128, ivBytes);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, spec);
        decryptedBytes = cipher.doFinal(encryptedBytes);
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }

    return decryptedBytes;
}

Menguji Contoh

Sekarang kita dapat mencoba sebuah contoh!

@TargetApi(Build.VERSION_CODES.M)
private void testEncryption()
{
    try
    {
        //Generate a key and store it in the KeyStore
        final KeyGenerator keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
        final KeyGenParameterSpec keyGenParameterSpec = new KeyGenParameterSpec.Builder("MyKeyAlias",
                KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                //.setUserAuthenticationRequired(true) //requires lock screen, invalidated if lock screen is disabled
                //.setUserAuthenticationValidityDurationSeconds(120) //only available x seconds from password authentication. -1 requires finger print - every time
                .setRandomizedEncryptionRequired(true) //different ciphertext for same plaintext on each call
                .build();
        keyGenerator.init(keyGenParameterSpec);
        keyGenerator.generateKey();

        //Test
        final HashMap<String, byte[]> map = encrypt("My very sensitive string!".getBytes("UTF-8"));
        final byte[] decryptedBytes = decrypt(map);
        final String decryptedString = new String(decryptedBytes, "UTF-8");
        Log.e("MyApp", "The decrypted string is " + decryptedString);
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }
}

Menggunakan RSA Asymmetric Keys untuk Perangkat yang Lama

Ini adalah solusi yang bagus untuk menyimpan data dari versi M dan lebih tinggi, tapi bagaimana jika aplikasi Anda mendukung versi sebelumnya? Sementara kunci AES symmetric tidak mendukung dibawah M, RSA asymmetric keys. Itu berarti kita bisa menggunakan RSA keys dan enkripsi untuk mendapatkan sesuatu yang sama.

Perbedaan utama disini adalah asymmetric keypair mengandung dua kunci, private dan public key, dimana public key mengenkripsi data dan private key mendeskripsinya. Sebuah KeyPairGeneratorSpec dikirim ke KeyPairGenerator yang di inisialisai dengan KEY_ALGORITHM_RSA dan "AndroidKeyStore" provider.

private void testPreMEncryption()
{
    try
    {
        //Generate a keypair and store it in the KeyStore
        KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
        keyStore.load(null);

        Calendar start = Calendar.getInstance();
        Calendar end = Calendar.getInstance();
        end.add(Calendar.YEAR, 10);
        KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(this)
                .setAlias("MyKeyAlias")
                .setSubject(new X500Principal("CN=MyKeyName, O=Android Authority"))
                .setSerialNumber(new BigInteger(1024, new Random()))
                .setStartDate(start.getTime())
                .setEndDate(end.getTime())
                .setEncryptionRequired() //on API level 18, encrypted at rest, requires lock screen to be set up, changing lock screen removes key
                .build();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
        keyPairGenerator.initialize(spec);
        keyPairGenerator.generateKeyPair();

        //Encryption test
        final byte[] encryptedBytes = rsaEncrypt("My secret string!".getBytes("UTF-8"));
        final byte[] decryptedBytes = rsaDecrypt(encryptedBytes);
        final String decryptedString = new String(decryptedBytes, "UTF-8");
        Log.e("MyApp", "Decrypted string is " + decryptedString);
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }
}

Untuk mengenkripsi, kita mengambil RSAPublicKey dari Keypair dan menggunakannya dengan Cipher object.

public byte[] rsaEncrypt(final byte[] decryptedBytes)
{
    byte[] encryptedBytes = null;
    try
    {
        final KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
        keyStore.load(null);
        final KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry("MyKeyAlias", null);
        final RSAPublicKey publicKey = (RSAPublicKey)privateKeyEntry.getCertificate().getPublicKey();

        final Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "AndroidOpenSSL");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        final CipherOutputStream cipherOutputStream = new CipherOutputStream(outputStream, cipher);
        cipherOutputStream.write(decryptedBytes);
        cipherOutputStream.close();

        encryptedBytes = outputStream.toByteArray();

    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }
    return encryptedBytes;
}

Dekripsi dilakukan dengan menggunakan objek RSAPrivateKey.

public byte[] rsaDecrypt(final byte[] encryptedBytes)
{
    byte[] decryptedBytes = null;
    try
    {
        final KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
        keyStore.load(null);
        final KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry("MyKeyAlias", null);
        final RSAPrivateKey privateKey = (RSAPrivateKey)privateKeyEntry.getPrivateKey();

        final Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "AndroidOpenSSL");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        final CipherInputStream cipherInputStream = new CipherInputStream(new ByteArrayInputStream(encryptedBytes), cipher);
        final ArrayList<Byte> arrayList = new ArrayList<>();
        int nextByte;
        while ( (nextByte = cipherInputStream.read()) != -1 )
        {
            arrayList.add((byte)nextByte);
        }

        decryptedBytes = new byte[arrayList.size()];
        for(int i = 0; i < decryptedBytes.length; i++)
        {
            decryptedBytes[i] = arrayList.get(i);
        }
    }
    catch (Throwable e)
    {
        e.printStackTrace();
    }

    return decryptedBytes;
}

Satu hal tentang RSA adalah enkripsi lebih lambat dari AES. Ini tidak apa-apa untuk data yang jumlahnya sedikit, seperti mengamankan shared preference strings. Jika Anda menemukan masalah performa mengenkripsi sebuah data, namun, Anda bisa menggunakan contoh ini untuk mengenkripsi dan menyimpannya sama seperti AES key. Kemudian, gunakan enkripsi AES yang lebih cepat yang telah kita diskusikan pada tutorial sebelumnya untuk sisa data Anda. Anda bisa membuat AES key baru dan mengubahnya menjadi byte[] array yang cocok seperti contoh berikut.

1	KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
2	keyGenerator.init(256); //AES-256
3	SecretKey secretKey = keyGenerator.generateKey();
4	byte[] keyBytes = secretKey.getEncoded();

Untuk mendapatkan key kembali dari bytes, lakukan ini:

1	SecretKey key = new SecretKeySpec(keyBytes, 0, keyBytes.length, "AES");

Ada banyak sekali kode! Untuk membuat semua contoh mudah, saya telah menghilangkan secara menyeluruh exception handling. Tapi yang perlu diingat adalah produksi dari kode Anda, ini tidak di rekomendasikan untuk mengambil semua Throwable cases pada satu statement.

Kesimpulan

Ini melengkapi tutorial tentang bekerja pada credential dan keys. Sangat membingunkan pada keys dan storage karena evolusi pada Android OS, tetapi Anda bisa memilih solusi dari API level yang aplikasi Anda dukung.

Sekarang kita sudah mencakup cara terbaik untuk mengamankan data seluruhnya, tutorial berikutnya akan fokus pada mengamankan data di transit.