Android SharedPreferences加密存储

最新推荐文章于 2025-04-28 19:11:27 发布
最新推荐文章于 2025-04-28 19:11:27 发布
阅读量1.3k 收藏
点赞数
分类专栏： android 文章标签： android 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xu_coding/article/details/108987408
版权

我们都知道sharedPreferences是将信息以xml文件格式的键值对存储在应用的对应的目录下。但是这个目录本是不够安全，这也就导致了我们存储的信息就不够安全。因此我们需要对信息进行加密存储。
即使是加密存储，秘钥的管理也十分重要，如何才能让秘钥不被外界获取，这里我们使用Android系统提供的KeyStore来提供秘钥，最大程度保证安全性。

object AppKeyStore {
    private var sApplicationContext: Context? = null
    private var sSystemKeyStoreMasterKeyAlias: String? = null
    private var sAppKeyStorePreferencesName: String? = null
    private const val ANDROID_KEY_STORE = "AndroidKeyStore"
    private const val KEY_COMPATIBLE = "compatible"
    private const val MASTER_KEY_BIT_SIZE = 256
    private const val MASTER_KEY_ALGORITHM = "AES"
    private const val MASTER_CIPHER_GCM_TRANSFORMATION = "AES/GCM/NoPadding"
    private const val MASTER_CIPHER_GCM_TAG_BIT_LENGTH = 128
    private const val MASTER_CIPHER_GCM_IV_BIT_SIZE = 96
    private const val TAG = "AppKeyStore"
    private var sDebugLog = false

    @JvmOverloads
    fun init(
        context: Context,
        systemKeyStoreMasterKeyAlias: String = "app_key_store_master_key",
        appKeyStorePreferenceName: String = "app_key_store"
    ) {
        sApplicationContext = context.applicationContext
        sSystemKeyStoreMasterKeyAlias = systemKeyStoreMasterKeyAlias
        sAppKeyStorePreferencesName = appKeyStorePreferenceName
    }

    fun setDebugLog(debugLog: Boolean) {
        sDebugLog = debugLog
    }

  
    fun getOrCreateSecretKey(
        keyAlias: String,
        algorithm: String,
        keySizeInBits: Int
    ): SecretKey {
        checkInit()
        require(keySizeInBits % 8 == 0) { "key bit size must be multiple of 8" }
        val masterKey = masterKey
        val preferences = keyStorePreferences
        val encryptKeyAlias: String
        encryptKeyAlias = try {
            encryptKeyAlias(masterKey, keyAlias)
        } catch (ex: GeneralSecurityException) {
            throw KeyStoreUnavailableException(
                "Failed to encrypt key alias, so unable to recover secret key from storage",
                ex
            )
        }
        val keyData = preferences.getString(encryptKeyAlias, null)
        if (!TextUtils.isEmpty(keyData)) {
            try {
                return decryptSecretKey(masterKey, keyData!!, algorithm)
            } catch (ex: GeneralSecurityException) {
                Log.w(
                    TAG,
                    "decrypt key fail, create new key instead: $keyAlias"
                )
            }
        }
        val randomBytes: ByteArray = CryptoUtil.randomBytes(keySizeInBits / 8)
        val secretKey: SecretKey =
            SecretKeySpec(randomBytes, algorithm)
        return try {
            val encrypted = encryptSecretKey(masterKey, secretKey)
            preferences.edit().putString(encryptKeyAlias, encrypted).apply()
            secretKey
        } catch (ex: GeneralSecurityException) {
            throw KeyStoreUnavailableException(
                "Failed to encrypt the created secret key, so unable to persist it to storage",
                ex
            )
        }
    }

    @get:TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
    private val masterKey: SecretKey
        private get() {
            val preferences = keyStorePreferences
            if (preferences.getBoolean(KEY_COMPATIBLE, false)) {
                if (sDebugLog) {
                    Log.d(TAG, "get MasterKey compatible flag")
                }
                return masterKeyCompat
            }
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (sDebugLog) {
                    Log.d(TAG, "get MasterKey below Marshmallow")
                }
                preferences.edit().putBoolean(KEY_COMPATIBLE, true).apply()
                return masterKeyCompat
            }
            return try {
                getMasterKeyByKeyStore(sSystemKeyStoreMasterKeyAlias)
            } catch (ex: GeneralSecurityException) {
                Log.w(
                    TAG,
                    "get MasterKey in keystore error, fallback to compat: $ex"
                )
                preferences.edit().putBoolean(KEY_COMPATIBLE, true).apply()
                masterKeyCompat
            } catch (ex: IOException) {
                Log.w(
                    TAG,
                    "get MasterKey in keystore error, fallback to compat: $ex"
                )
                preferences.edit().putBoolean(KEY_COMPATIBLE, true).apply()
                masterKeyCompat
            }
        }

    @TargetApi(Build.VERSION_CODES.M)
    @Throws(GeneralSecurityException::class, IOException::class)
    private fun getMasterKeyByKeyStore(masterKeyAlias: String?): SecretKey {
        val keyStore =
            KeyStore.getInstance(ANDROID_KEY_STORE)
        keyStore.load(null)
        if (keyStore.containsAlias(masterKeyAlias)) {
            val entry = keyStore.getEntry(masterKeyAlias, null)
            if (entry is KeyStore.SecretKeyEntry) {
                if (sDebugLog) {
                    Log.d(TAG, "master key already exist")
                }
                return entry.secretKey
            }
            keyStore.deleteEntry(masterKeyAlias)
            Log.w(TAG, "master key type not match, delete it to recreate")
        }
        if (sDebugLog) {
            Log.d(TAG, "create master key in KeyStore")
        }
        val keyGenerator = KeyGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_AES,
            ANDROID_KEY_STORE
        )
        val spec = KeyGenParameterSpec.Builder(
            masterKeyAlias!!,
            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
        )
            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
            .setKeySize(MASTER_KEY_BIT_SIZE)
            .setRandomizedEncryptionRequired(false) // need to init GCMParameterSpec
            .build()
        keyGenerator.init(spec)
        return keyGenerator.generateKey()
    }

   
    private val masterKeyCompat: SecretKey
        private get() {
            @SuppressLint("HardwareIds") val ids =
                Settings.Secure.getString(
                    sApplicationContext!!.contentResolver,
                    Settings.Secure.ANDROID_ID
                ).toByteArray(StandardCharsets.UTF_8)
            val key =
                Arrays.copyOf(ids, MASTER_KEY_BIT_SIZE / 8)
            return SecretKeySpec(key, MASTER_KEY_ALGORITHM)
        }

    @Throws(GeneralSecurityException::class)
    private fun encryptSecretKey(
        masterKey: SecretKey,
        key: SecretKey
    ): String {
        val iv: ByteArray =
            CryptoUtil.randomBytes(MASTER_CIPHER_GCM_IV_BIT_SIZE / 8)
        val encrypted = encrypt(masterKey, key.encoded, iv)
        return CiphertextIv(encrypted, iv).toString()
    }

    @Throws(GeneralSecurityException::class)
    private fun decryptSecretKey(
        masterKey: SecretKey,
        encryptedText: String,
        algorithm: String
    ): SecretKey {
        val ciphertextIv = CiphertextIv(encryptedText)
        val decrypted =
            decrypt(masterKey, ciphertextIv.ciphertext, ciphertextIv.iv)
        return SecretKeySpec(decrypted, algorithm)
    }

    @Throws(GeneralSecurityException::class)
    private fun encryptKeyAlias(
        masterKey: SecretKey,
        keyAlias: String
    ): String {
        val encrypted = encrypt(
            masterKey,
            keyAlias.toByteArray(StandardCharsets.UTF_8),
            constantKeyAliasIv
        )
        return Base64.encodeToString(encrypted, Base64.NO_WRAP)
    }

    @Throws(GeneralSecurityException::class)
    private fun decryptKeyAlias(
        masterKey: SecretKey,
        encryptedText: String
    ): String {
        val decoded: ByteArray
        decoded = try {
            Base64.decode(
                encryptedText.toByteArray(StandardCharsets.UTF_8),
                Base64.NO_WRAP
            )
        } catch (ex: IllegalArgumentException) {
            throw GeneralSecurityException("Base64 decode error", ex)
        }
        val decrypted =
            decrypt(masterKey, decoded, constantKeyAliasIv)
        return String(decrypted, StandardCharsets.UTF_8)
    }

    @Throws(GeneralSecurityException::class)
    private fun encrypt(
        key: SecretKey,
        data: ByteArray,
        iv: ByteArray
    ): ByteArray {
        val cipher =
            Cipher.getInstance(MASTER_CIPHER_GCM_TRANSFORMATION)
        val gcmParameterSpec =
            getGcmParameterSpec(iv)
        cipher.init(Cipher.ENCRYPT_MODE, key, gcmParameterSpec)
        return cipher.doFinal(data)
    }

    @Throws(GeneralSecurityException::class)
    private fun decrypt(
        key: SecretKey,
        data: ByteArray,
        iv: ByteArray
    ): ByteArray {
        val cipher =
            Cipher.getInstance(MASTER_CIPHER_GCM_TRANSFORMATION)
        val gcmParameterSpec =
            getGcmParameterSpec(iv)
        cipher.init(Cipher.DECRYPT_MODE, key, gcmParameterSpec)
        return cipher.doFinal(data)
    }

    private fun checkInit() {
        checkNotNull(sApplicationContext) { "Must call AppKeyStore.init() before any operation" }
    }

    private val constantKeyAliasIv: ByteArray
        private get() {
            @SuppressLint("HardwareIds") val ids =
                Settings.Secure.getString(
                    sApplicationContext!!.contentResolver,
                    Settings.Secure.ANDROID_ID
                ).toByteArray(StandardCharsets.UTF_8)
            return Arrays.copyOf(ids, MASTER_CIPHER_GCM_IV_BIT_SIZE / 8)
        }

    private val keyStorePreferences: SharedPreferences
        private get() = sApplicationContext!!.applicationContext.getSharedPreferences(
            sAppKeyStorePreferencesName,
            Context.MODE_PRIVATE
        )

    private fun getGcmParameterSpec(iv: ByteArray): AlgorithmParameterSpec {
        return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            IvParameterSpec(iv)
        } else GCMParameterSpec(MASTER_CIPHER_GCM_TAG_BIT_LENGTH, iv)
    }

    class KeyStoreUnavailableException internal constructor(
        message: String?,
        cause: Throwable?
    ) :
        RuntimeException(message, cause)
}

对应的CiphertextIv实体类

public class CiphertextIv {

    private static final String DELIMITER = ":";
    private static final int BASE64_FLAGS = Base64.NO_WRAP;

    public final byte[] ciphertext;
    public final byte[] iv;

    public CiphertextIv(byte[] ciphertext, byte[] iv) {
        this.ciphertext = new byte[ciphertext.length];
        System.arraycopy(ciphertext, 0, this.ciphertext, 0, ciphertext.length);
        this.iv = new byte[iv.length];
        System.arraycopy(iv, 0, this.iv, 0, iv.length);
    }

   
    public CiphertextIv(@NonNull String encodedText) throws IllegalCiphertextIvException {
        String[] parts = encodedText.split(DELIMITER);

        if (parts.length != 2) {
            throw new IllegalCiphertextIvException("CiphertextIv not this format: cipher:iv");
        }

        try {
            ciphertext = Base64.decode(parts[0].getBytes(StandardCharsets.UTF_8), BASE64_FLAGS);
            iv = Base64.decode(parts[1].getBytes(StandardCharsets.UTF_8), BASE64_FLAGS);
        } catch (IllegalArgumentException ex) {
            throw new IllegalCiphertextIvException(ex);
        }
    }

   
    @Override
    public String toString() {
        return Base64.encodeToString(ciphertext, BASE64_FLAGS) + DELIMITER
                + Base64.encodeToString(iv, BASE64_FLAGS);
    }

    private static class IllegalCiphertextIvException extends GeneralSecurityException {
        IllegalCiphertextIvException(String msg) {
            super(msg);
        }

        IllegalCiphertextIvException(Throwable cause) {
            super(cause);
        }
    }
}

通过实现SharedPreferences的接口类完成加密的SharedPreferences 封装。其本身的存储原理并没有改变，数据的存储位置也没有改变。只是我们对存储数据做了加密处理，对数据获取做了解密处理。最大程度上保证了我们数据的安全性。

class SecurePreferences(
    context: Context,
    name: String?,
    secretKey: SecretKey
) :
    SharedPreferences {
    private val mRawPrefs: SharedPreferences = context.getSharedPreferences(name, Context.MODE_PRIVATE)
    private val mSecretKey: SecretKey = secretKey
    private val mConstantKeyIv: ByteArray

    override fun getAll(): Map<String?, *> {
        val all = mRawPrefs.all
        val decryptedAll: MutableMap<String?, Any?> =
            HashMap()
        for ((key, value) in all) {
            val decodedKey = decryptKey(key)
            val rawValue = value!!
            if (rawValue is String) {
                decryptedAll[decodedKey] = decryptValue(rawValue)
            } else if (rawValue is Set<*>) {
                val rawSet =
                    rawValue as Set<String>
                val decryptedSet: MutableSet<String?> =
                    HashSet(rawSet.size)
                for (text in rawSet) {
                    decryptedSet.add(decryptValue(text))
                }
                decryptedAll[decodedKey] = decryptedSet
            }
       
        }
        return decryptedAll
    }

    @Nullable
    override fun getString(
        key: String,
        @Nullable defValue: String?
    ): String? {
        val encrypted = mRawPrefs.getString(encryptKey(key), null)
        val value = decryptValue(encrypted)
        return value ?: defValue
    }

    @Nullable
    override fun getStringSet(
        key: String,
        @Nullable defValues: Set<String>?
    ): Set<String?>? {
        val encryptedSet =
            mRawPrefs.getStringSet(encryptKey(key), null)
        var values: MutableSet<String?>? = null
        if (encryptedSet != null) {
            values = HashSet(encryptedSet.size)
            for (text in encryptedSet) {
                values.add(decryptValue(text))
            }
        }
        return values?.toSet() ?: defValues
    }

    override fun getInt(key: String, defValue: Int): Int {
        val encrypted = mRawPrefs.getString(encryptKey(key), null)
        val value = decryptValue(encrypted) ?: return defValue
        return try {
            value.toInt()
        } catch (ex: NumberFormatException) {
            defValue
        }
    }

    override fun getLong(key: String, defValue: Long): Long {
        val encrypted = mRawPrefs.getString(encryptKey(key), null)
        val value = decryptValue(encrypted) ?: return defValue
        return try {
            value.toLong()
        } catch (ex: NumberFormatException) {
            defValue
        }
    }

    override fun getFloat(key: String, defValue: Float): Float {
        val encrypted = mRawPrefs.getString(encryptKey(key), null)
        val value = decryptValue(encrypted) ?: return defValue
        return try {
            value.toFloat()
        } catch (ex: NumberFormatException) {
            defValue
        }
    }

    override fun getBoolean(key: String, defValue: Boolean): Boolean {
        val encrypted = mRawPrefs.getString(encryptKey(key), null)
        val value = decryptValue(encrypted) ?: return defValue
        return try {
            java.lang.Boolean.parseBoolean(value)
        } catch (ex: NumberFormatException) {
            defValue
        }
    }

    override fun contains(key: String): Boolean {
        return mRawPrefs.contains(encryptKey(key))
    }

    override fun edit(): Editor {
        return Editor()
    }

    override fun registerOnSharedPreferenceChangeListener(listener: OnSharedPreferenceChangeListener) {
        mRawPrefs.registerOnSharedPreferenceChangeListener(listener)
    }

    override fun unregisterOnSharedPreferenceChangeListener(listener: OnSharedPreferenceChangeListener) {
        mRawPrefs.unregisterOnSharedPreferenceChangeListener(listener)
    }

    private fun encryptKey(@Nullable text: String): String? {
        return if (TextUtils.isEmpty(text)) {
            text
        } else try {
            val encrypted =
                encrypt(text.toByteArray(StandardCharsets.UTF_8), mConstantKeyIv)
            Base64.encodeToString(
                encrypted,
                BASE64_FLAGS
            )
        } catch (ex: GeneralSecurityException) {
            Log.w(TAG, "encryptKey error:$ex")
            null
        }
    }

    private fun decryptKey(@Nullable text: String): String? {
        return if (TextUtils.isEmpty(text)) {
            text
        } else try {
            val decode = Base64.decode(
                text.toByteArray(StandardCharsets.UTF_8),
                BASE64_FLAGS
            )
            val decrypted = decrypt(decode, mConstantKeyIv)
            String(decrypted, StandardCharsets.UTF_8)
        } catch (ex: GeneralSecurityException) {
            Log.w(TAG, "decryptKey error:$ex")
            null
        } catch (ex: IllegalArgumentException) {
            Log.w(TAG, "decryptKey error:$ex")
            null
        }
    }

    @Nullable
    private fun encryptValue(@Nullable text: String?): String? {
        return if (TextUtils.isEmpty(text)) {
            text
        } else try {
            val iv: ByteArray =
                CryptoUtil.randomBytes(CIPHER_GCM_IV_BIT_SIZE / 8)
            val encrypted =
                encrypt(text!!.toByteArray(StandardCharsets.UTF_8), iv)
            CiphertextIv(encrypted, iv).toString()
        } catch (ex: GeneralSecurityException) {
            Log.w(TAG, "encryptValue error:$ex")
            null
        }
    }

    @Nullable
    private fun decryptValue(@Nullable text: String?): String? {
        return if (TextUtils.isEmpty(text)) {
            text
        } else try {
            val ciphertextIv = CiphertextIv(text!!)
            val decrypted = decrypt(ciphertextIv.ciphertext, ciphertextIv.iv)
            String(decrypted, StandardCharsets.UTF_8)
        } catch (ex: GeneralSecurityException) {
            Log.w(TAG, "decryptValue error:$ex")
            null
        }
    }

    @Throws(GeneralSecurityException::class)
    private fun encrypt(data: ByteArray, iv: ByteArray): ByteArray {
        val cipher =
            Cipher.getInstance(CIPHER_GCM_TRANSFORMATION)
        val gcmParameterSpec =
            getGcmParameterSpec(iv)
        cipher.init(Cipher.ENCRYPT_MODE, mSecretKey, gcmParameterSpec)
        return cipher.doFinal(data)
    }

    @Throws(GeneralSecurityException::class)
    private fun decrypt(data: ByteArray, iv: ByteArray): ByteArray {
        val cipher =
            Cipher.getInstance(CIPHER_GCM_TRANSFORMATION)
        val gcmParameterSpec =
            getGcmParameterSpec(iv)
        cipher.init(Cipher.DECRYPT_MODE, mSecretKey, gcmParameterSpec)
        return cipher.doFinal(data)
    }

    private fun getConstantKeyIv(context: Context): ByteArray {
        @SuppressLint("HardwareIds") val ids =
            Settings.Secure.getString(
                context.contentResolver,
                Settings.Secure.ANDROID_ID
            ).toByteArray(StandardCharsets.UTF_8)
        return Arrays.copyOf(ids, CIPHER_GCM_IV_BIT_SIZE / 8)
    }

    inner class Editor @SuppressLint("CommitPrefEdits") internal constructor() :
        SharedPreferences.Editor {
        private val mEditor: SharedPreferences.Editor
        override fun putString(
            key: String,
            @Nullable value: String?
        ): SharedPreferences.Editor {
            mEditor.putString(encryptKey(key), encryptValue(value))
            return this
        }

        override fun putStringSet(
            key: String,
            @Nullable values: Set<String>?
        ): SharedPreferences.Editor {
            var encryptSet: MutableSet<String?>? = null
            if (values != null) {
                encryptSet = HashSet(values.size)
                for (text in values) {
                    encryptSet.add(encryptValue(text))
                }
            }
            mEditor.putStringSet(encryptKey(key), encryptSet)
            return this
        }

        override fun putInt(key: String, value: Int): SharedPreferences.Editor {
            mEditor.putString(encryptKey(key), encryptValue(Integer.toString(value)))
            return this
        }

        override fun putLong(
            key: String,
            value: Long
        ): SharedPreferences.Editor {
            mEditor.putString(encryptKey(key), encryptValue(java.lang.Long.toString(value)))
            return this
        }

        override fun putFloat(
            key: String,
            value: Float
        ): SharedPreferences.Editor {
            mEditor.putString(encryptKey(key), encryptValue(java.lang.Float.toString(value)))
            return this
        }

        override fun putBoolean(
            key: String,
            value: Boolean
        ): SharedPreferences.Editor {
            mEditor.putString(encryptKey(key), encryptValue(java.lang.Boolean.toString(value)))
            return this
        }

        override fun remove(key: String): SharedPreferences.Editor {
            mEditor.remove(encryptKey(key))
            return this
        }

        override fun clear(): SharedPreferences.Editor {
            mEditor.clear()
            return this
        }

        override fun commit(): Boolean {
            return mEditor.commit()
        }

        override fun apply() {
            mEditor.apply()
        }

        init {
            mEditor = mRawPrefs.edit()
        }
    }

    companion object {
        private const val CIPHER_GCM_TRANSFORMATION = "AES/GCM/NoPadding"
        private const val CIPHER_GCM_TAG_BIT_LENGTH = 128
        private const val CIPHER_GCM_IV_BIT_SIZE = 96
        private const val BASE64_FLAGS = Base64.NO_WRAP
        private const val TAG = "SecurePreferences"
        private fun getGcmParameterSpec(iv: ByteArray): AlgorithmParameterSpec {
            return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
                // GCMParameterSpec should work since API 19, but in some device it's not supported (e.g. Google's Android 4.4 emulator).
                // We can use IvParameterSpec instead, it will use the default tag size of 128 bits.
                IvParameterSpec(iv)
            } else GCMParameterSpec(
                CIPHER_GCM_TAG_BIT_LENGTH,
                iv
            )
        }
    }


    init {
        mConstantKeyIv = getConstantKeyIv(context)
    }
}

封装使用：

使用初始化一下KeyStore就好

AppKeyStore.init(this)
AppKeyStore.setDebugLog(BuildConfig.DEBUG)
// 获取SecretKey
val commonAesKey = AppKeyStore.getOrCreateSecretKey(COMMON_AES_KEY_ALIAS,
    COMMON_AES_KEY_ALGORITHM, COMMON_AES_KEY_SIZE_BITS)
// 初始化SecurePreferences
val prefs = SecurePreferences(this, SECURE_PREFERENCES, commonAesKey)
Android入门第52天-在SharedPreference中使用加密
打造全国最全的AI Agent开发知识领域的博客
12-21 1068
在上一篇中，我们讲了SharedPreference的使用。但是那不是一个生产场景。特别是我们举了一个例子，存放登录信息的例子。这个例子里用户的密码没有加密，比如说在真实的实际生产环境里用户的一些敏感信息或者说是像：用户四要素按照等保3规范以及“个信”法，都是需要加密和脱敏的。所以当碰到这样的“敏感”信息脱敏需求时，我们不可以直接把一个明文存入SharedPreference。因此我们今天会使用MD5来对SharedPreference中存放的信息进行脱敏处理。
Android开发：SharedPreferences设置密码的保存与读取
游手好闲
04-22 2555
文章目录SharedPreferences设置密码的保存与读取效果 SharedPreferences SharedPreferences是Android中的一种数据存储方式。 使用SharedPreferences实现对密码的保存与读取，这是在登录账号时【记住密码】功能的简化操作。 设置密码的保存与读取 activity.xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://sche
Android-一个比较安全的SharedPreference加密方案
08-13
一个比较安全的SharedPreference加密方案
拿来就用：Android 对sharedpreferences 数据进行加密
黄孝果的博客
10-14 7296
先来看看效果：这里显示的密文就是存储在SP中的密文，下面我们再来看看sp文件内容这样就起到了在sp存储时的加密功能，下面我们来看看代码，加密我使用的是RSA加密，并把秘钥保存在androidKeyStore中，这样就保险，更加保障了我们的秘钥安全 生成RSA秘钥工具类：AndroidKeyStoreRSAUtils package tsou.com.encryption.AndroidKeyStor
Android SharedPreferences
最新发布
weixin_41548050的博客
04-28 495
由于get是直接访问同一个SharedPreferencesImpl实例的内存Map进行get的，并没有等刷盘结果，所以无论何种写方式（apply、commit），get操作都是可以立刻返回更新后的结果。如果不属于以上场景，单纯app进程内通过SharedPreference api先写后读，apply写后直接get是可以立刻get到的更新后的内容的，不用等磁盘文件更新完成，因为get是直接读内存的。先更新同一个SharedPreferencesImpl实例的内存Map，更新完投递刷盘任务后通过。
android sharedpreferences加密,（译）使用AndroidX安全库加密SharedPreferences
weixin_29471009的博客
05-30 1217
本文译自Encrypting Shared Preferences with the AndroidX Security Library，介绍了AndroidX安全库中EncryptedSharedPreferences的使用。备注：仅支持minSdkVersion 23及以上。《离思五首·其四》曾经沧海难为水，除却巫山不是云。取次花丛懒回顾，半缘修道半缘君。-唐代，元稹Android框架给我们提...
AES加密进行Android的SharedPreferences存储
iplayvs2008的专栏
03-27 1311
1.概述 SharedPreferences是Android提供用来存储一些简单配置信息的机制，其以KEY-VALUE对的方式进行存储，以便我们可以方便进行读取和存储。主要可以用来存储应用程序的欢迎语、常量参数或登录账号密码等。 2.实例 （1）创建项目SharedPreferencesDemo项目 （2）编辑主界面的布局文件main.xml如下： [xhtml]  view p
Android SharedPreferences加密存储方法
残风乱了温柔的博客
12-04 2224
这一篇是整理 Android本地数据SP加密存储的方法，也是属于APP安全范畴。主要是通过AES加密方法进行加密，对Key和Value全部加密，进一步保障数据安全 方法整理如下： import android.content.Context; import android.content.SharedPreferences; import android.preference.PreferenceManager; import android.text.TextUtils; import an
EncryptedSharedPreferences:为Android SharedPreferences提供加密
05-20
为SharedPreferences集成系统提供加密。 它使用AES 128位加密技术来保护数据安全，并且与UTF-8兼容元素兼容。 ====================== Gradle集成： 添加存储库依赖项： repositories { jcenter() maven { ...
Android SharedPreferences的加密包装器
04-06
可以选择在设备上安全地存储一个密钥，例如使用Android KeyStore系统，或者在首次安装时生成一个随机密钥并将其加密存储。 5. **测试与验证**：确保在各种场景下，如应用程序重启、设备恢复出厂设置等，加密包装器...
使用MD5对SharedPreferences密码加密
07-17
在每个Android软件都会使用到SharedPreferences，将密码保存在本地，但是由于没有对密码进行加密，只要用户对手机进行root，获取了权限就很容易得到密码，为了防止密码外露，每个Android软件都要对SharedPreferences的密码进行加密。
Android学习之sharedpreferences加密
午夜三点的一匹狼
09-03 441
使用AES对密码进行加密加密工具类public class AESEncryptor { public static String encrypt(String key, String src) throws Exception { byte[] rawKey = getRawKey(key.getBytes()); byte[] result = encry
android sharedpreferences加密,让源码告诉你：Android 不要滥用 SharedPreferences（上）
weixin_34566429的博客
05-30 328
链接：https://www.jianshu.com/p/5fcef7f68341前言本文不是与大家一起探讨关于SharedPreferences的基本使用，而是结合源码的角度分析对 SharedPreferences 使用不当可能引发的“严重后果”以及该如何正确的使用 SharedPreferences。SharedPreferences 是 Android 平台为应用开发者提供的一个轻量级的存...
Android 一个对sharedpreferences 数据进行加密的开源库
weixin_33964094的博客
03-02 308
1、项目地址 https://github.com/iamMehedi/Secured-Preference-Store 2、使用方法 2.1、存数据 1 2 3 //存数据 SecuredPreferenceStore prefStore = SecuredPreferenceStore.getSh...
android sharedpreferences加密,android - encrypt data in SharedPreferences - Stack Overflow
weixin_33610601的博客
05-30 121
You should take a look at Slink.I came to realize that most of the SharedPreferences encryption tools use encryption for each action you make, meaning that each key-value pair is saved only after both...
Android 一个对sharedpreferences 数据进行加密的开源库
weixin_34348111的博客
09-01 164
1、项目地址      https://github.com/iamMehedi/Secured-Preference-Store   2、使用方法      2.1、存数据   //存数据 SecuredPreferenceStore prefStore = SecuredPreferenceStore.getSharedInstance(getApplicationCon...
android SharedPreferences加密(高级) (AES+base64+PBE)
国苏
12-27 2585
1.前言转载请注明出处 http://blog.youkuaiyun.com/wangguoyang429883793/article/details/50385423 (AES+base64+PEB)高级加密，先看下效果。 加密前： 加密后： 2.代码1.先简单看下代码使用，后面会详细解释，给demo。public class MyApplication extends Application {
浅谈android数据存储加密
say_from_wen的博客
09-06 5082
写在开头在移动端的开发中，数据安全的问题一直是大家备受关注的，数据加密技术也受到了大家的青睐。项目中也用到了一些，在这里学习总结下，完善下自己的知识，也分享给大家，一起交流！（末尾也会说下自己在项目中的使用） 按可逆性：加密可分为可逆算法和不可逆算法 按对称性：加密可分为对称算法和非对称算法 一般的加密分为以下几种，下面会分别简单讲解原理和其使用方法： Base64编码算法 （可逆） MD5加密
android preference内容加密,Android SharePreference 加密存储及 AndroidKeyStore密钥存储
weixin_35600177的博客
06-03 467
Android SharePreference 加密存储及 AndroidKeyStore密钥存储前言最近由于项目中对数据存储特别是SharePreference部分数据存储这块有所需求，在查询了少量资料后对这部分内容做了少量封装。框架主要实现了两方面的需求，一是密钥安全存储方面，二就是SharePreference加解密方面的使用。下面会从这两部分进行讲解。简单粗暴上代码假如大家不想看废话可以直...
Android SharedPreferences数据存储实例详解
SharedPreferences是Android平台上一个轻量级的存储类，它提供了一种方便的方式来存储和检索少量数据，如用户的偏好设置。这类数据通常存储为键值对（key-value pairs），可以跨多个组件和应用会话保持数据持久性。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值