拿来就用：Android 对sharedpreferences 数据进行加密(1)

最新推荐文章于 2024-04-28 08:01:02 发布

egrhef

最新推荐文章于 2024-04-28 08:01:02 发布

阅读量672

点赞数 26

分类专栏：程序员文章标签： android java 开发语言

本文链接：https://blog.csdn.net/egrhef/article/details/138014088

版权

程序员专栏收录该内容

196 篇文章 2 订阅

订阅专栏

}

/**

私钥加密
@param data 待加密数据
@param privateKey 密钥
@return byte[] 加密数据

public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {

// 得到私钥

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);

KeyFactory kf = KeyFactory.getInstance(SecurityConstants.TYPE_RSA);

PrivateKey keyPrivate = kf.generatePrivate(keySpec);

// 数据加密

Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);

cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);

return cipher.doFinal(data);

}

/**

公钥解密
@param data 待解密数据
@param publicKey 密钥
@return byte[] 解密数据

public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {

// 得到公钥

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);

KeyFactory kf = KeyFactory.getInstance(SecurityConstants.TYPE_RSA);

PublicKey keyPublic = kf.generatePublic(keySpec);

// 数据解密

Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);

cipher.init(Cipher.DECRYPT_MODE, keyPublic);

return cipher.doFinal(data);

}

/**

使用私钥进行解密

public static byte[] decryptByPrivateKey(byte[] encrypted) throws Exception {

KeyStore ks = KeyStore.getInstance(“AndroidKeyStore”);

ks.load(null);

if (mAlias == null) {

setAlias(SAMPLE_ALIAS);

}

//从Android加载密钥对密钥存储库中

KeyStore.Entry entry = ks.getEntry(mAlias, null);

if (entry == null) {

return null;

}

if (!(entry instanceof KeyStore.PrivateKeyEntry)) {

return null;

}

PrivateKey keyPrivate = ((KeyStore.PrivateKeyEntry) entry).getPrivateKey();

// 解密数据

Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);

cp.init(Cipher.DECRYPT_MODE, keyPrivate);

byte[] arr = cp.doFinal(encrypted);

return arr;

}

/**

用公钥对字符串进行分段加密

public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {

int dataLen = data.length;

if (dataLen <= DEFAULT_BUFFERSIZE) {

return encryptByPublicKey(data, publicKey);

}

List allBytes = new ArrayList(2048);

int bufIndex = 0;

int subDataLoop = 0;

byte[] buf = new byte[DEFAULT_BUFFERSIZE];

for (int i = 0; i < dataLen; i++) {

buf[bufIndex] = data[i];

if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {

subDataLoop++;

if (subDataLoop != 1) {

for (byte b : DEFAULT_SPLIT) {

allBytes.add(b);

}

byte[] encryptBytes = encryptByPublicKey(buf, publicKey);

for (byte b : encryptBytes) {

allBytes.add(b);

}

bufIndex = 0;

if (i == dataLen - 1) {

buf = null;

} else {

buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];

}

byte[] bytes = new byte[allBytes.size()];

{

int i = 0;

for (Byte b : allBytes) {

bytes[i++] = b.byteValue();

}

return bytes;

}

/**

分段加密
@param data 要加密的原始数据
@param privateKey 秘钥

public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {

int dataLen = data.length;

if (dataLen <= DEFAULT_BUFFERSIZE) {

return encryptByPrivateKey(data, privateKey);

}

List allBytes = new ArrayList(2048);

int bufIndex = 0;

int subDataLoop = 0;

byte[] buf = new byte[DEFAULT_BUFFERSIZE];

for (int i = 0; i < dataLen; i++) {

buf[bufIndex] = data[i];

if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {

subDataLoop++;

if (subDataLoop != 1) {

for (byte b : DEFAULT_SPLIT) {

allBytes.add(b);

}

byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);

for (byte b : encryptBytes) {

allBytes.add(b);

}

bufIndex = 0;

if (i == dataLen - 1) {

buf = null;

} else {

buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];

}

byte[] bytes = new byte[allBytes.size()];

{

int i = 0;

for (Byte b : allBytes) {

bytes[i++] = b.byteValue();

}

return bytes;

}

/**

公钥分段解密
@param encrypted 待解密数据
@param publicKey 密钥

public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {

int splitLen = DEFAULT_SPLIT.length;

if (splitLen <= 0) {

return decryptByPublicKey(encrypted, publicKey);

}

int dataLen = encrypted.length;

List allBytes = new ArrayList(1024);

int latestStartIndex = 0;

for (int i = 0; i < dataLen; i++) {

byte bt = encrypted[i];

boolean isMatchSplit = false;

if (i == dataLen - 1) {

// 到data的最后了

byte[] part = new byte[dataLen - latestStartIndex];

System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);

byte[] decryptPart = decryptByPublicKey(part, publicKey);

for (byte b : decryptPart) {

allBytes.add(b);

}

latestStartIndex = i + splitLen;

i = latestStartIndex - 1;

} else if (bt == DEFAULT_SPLIT[0]) {

// 这个是以split[0]开头

if (splitLen > 1) {

if (i + splitLen < dataLen) {

// 没有超出data的范围

for (int j = 1; j < splitLen; j++) {

if (DEFAULT_SPLIT[j] != encrypted[i + j]) {

break;

}

if (j == splitLen - 1) {

// 验证到split的最后一位，都没有break，则表明已经确认是split段

isMatchSplit = true;

}

} else {

// split只有一位，则已经匹配了

isMatchSplit = true;

}

if (isMatchSplit) {

byte[] part = new byte[i - latestStartIndex];

System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);

byte[] decryptPart = decryptByPublicKey(part, publicKey);

for (byte b : decryptPart) {

allBytes.add(b);

}

latestStartIndex = i + splitLen;

i = latestStartIndex - 1;

}

byte[] bytes = new byte[allBytes.size()];

{

int i = 0;

for (Byte b : allBytes) {

bytes[i++] = b.byteValue();

}

return bytes;

}

/**

使用私钥分段解密

public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted) throws Exception {

int splitLen = DEFAULT_SPLIT.length;

if (splitLen <= 0) {

return decryptByPrivateKey(encrypted);

}

int dataLen = encrypted.length;

List allBytes = new ArrayList(1024);

int latestStartIndex = 0;

for (int i = 0; i < dataLen; i++) {

byte bt = encrypted[i];

boolean isMatchSplit = false;

if (i == dataLen - 1) {

// 到data的最后了

byte[] part = new byte[dataLen - latestStartIndex];

System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);

byte[] decryptPart = decryptByPrivateKey(part);

for (byte b : decryptPart) {

allBytes.add(b);

}

latestStartIndex = i + splitLen;

i = latestStartIndex - 1;

} else if (bt == DEFAULT_SPLIT[0]) {

// 这个是以split[0]开头

if (splitLen > 1) {

if (i + splitLen < dataLen) {

// 没有超出data的范围

for (int j = 1; j < splitLen; j++) {

if (DEFAULT_SPLIT[j] != encrypted[i + j]) {

break;

}

if (j == splitLen - 1) {

// 验证到split的最后一位，都没有break，则表明已经确认是split段

isMatchSplit = true;

}

} else {

// split只有一位，则已经匹配了

isMatchSplit = true;

}

if (isMatchSplit) {

byte[] part = new byte[i - latestStartIndex];

System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);

byte[] decryptPart = decryptByPrivateKey(part);

for (byte b : decryptPart) {

allBytes.add(b);

}

latestStartIndex = i + splitLen;

i = latestStartIndex - 1;

}

byte[] bytes = new byte[allBytes.size()];

{

int i = 0;

for (Byte b : allBytes) {

bytes[i++] = b.byteValue();

}

return bytes;

}

/**

通过字符串生成私钥，转换服务器传递过来的私钥

public static PrivateKey getPrivateKey(String privateKeyData) {

PrivateKey privateKey = null;

try {

byte[] decodeKey = Base64Decoder.decodeToBytes(privateKeyData);

PKCS8EncodedKeySpec x509 = new PKCS8EncodedKeySpec(decodeKey);//创建x509证书封装类

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);//指定RSA

privateKey = keyFactory.generatePrivate(x509);//生成私钥

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (InvalidKeySpecException e) {

e.printStackTrace();

}

return privateKey;

}

/**

通过字符串生成公钥，转换服务器传递过来的公钥

public static PublicKey getPublicKey(String publicKeyData) {

PublicKey publicKey = null;

try {

byte[] decodeKey = Base64Decoder.decodeToBytes(publicKeyData);

X509EncodedKeySpec x509 = new X509EncodedKeySpec(decodeKey);

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

publicKey = keyFactory.generatePublic(x509);

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (InvalidKeySpecException e) {

e.printStackTrace();

}

return publicKey;

}

/**

判断是否创建过秘钥
@return
@throws KeyStoreException
@throws CertificateException
@throws NoSuchAlgorithmException
@throws IOException
@throws UnrecoverableEntryException

public static boolean isHaveKeyStore() {

try {

KeyStore ks = KeyStore.getInstance(“AndroidKeyStore”);

ks.load(null);

if (mAlias == null) {

setAlias(SAMPLE_ALIAS);

}

//从Android加载密钥对密钥存储库中

KeyStore.Entry entry = ks.getEntry(mAlias, null);

if (entry == null) {

return false;

}

} catch (KeyStoreException e) {

e.printStackTrace();

return false;

} catch (CertificateException e) {

e.printStackTrace();

return false;

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

return false;

} catch (IOException e) {

e.printStackTrace();

return false;

} catch (UnrecoverableEntryException e) {

e.printStackTrace();

return false;

}

return true;

}

/**

获得本地AndroidKeyStore中的公钥
@return

public static PublicKey getLocalPublicKey() {

try {

KeyStore ks = KeyStore.getInstance(“AndroidKeyStore”);

ks.load(null);

if (mAlias == null) {

setAlias(SAMPLE_ALIAS);

}

//从Android加载密钥对密钥存储库中

KeyStore.Entry entry = ks.getEntry(mAlias, null);

if (entry == null) {

return null;

}

if (!(entry instanceof KeyStore.PrivateKeyEntry)) {

return null;

}

PublicKey publicKey = ((KeyStore.PrivateKeyEntry) entry).getCertificate().getPublicKey();

return publicKey;

} catch (KeyStoreException e) {

e.printStackTrace();

return null;

} catch (CertificateException e) {

e.printStackTrace();

return null;

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

return null;

} catch (IOException e) {

e.printStackTrace();

return null;

} catch (UnrecoverableEntryException e) {

e.printStackTrace();

return null;

}

package tsou.com.encryption.androidkeystoresign;

public class SecurityConstants {

public static final String KEYSTORE_PROVIDER_ANDROID_KEYSTORE = “AndroidKeyStore”;

public static final String TYPE_RSA = “RSA”;

public static final String TYPE_DSA = “DSA”;

public static final String TYPE_BKS = “BKS”;

public static final String SIGNATURE_SHA256withRSA = “SHA256withRSA”;

public static final String SIGNATURE_SHA512withRSA = “SHA512withRSA”;

}

加密封装在SPSecuredUtils秘钥中方便拿过来直接用

package tsou.com.encryption.sp;

import android.content.Context;

import android.content.SharedPreferences;

import android.util.Base64;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.security.interfaces.RSAPublicKey;

import java.util.Map;

import tsou.com.encryption.AndroidKeyStoreRSA.AndroidKeyStoreRSAUtils;

import tsou.com.encryption.aescbc.Base64Decoder;

import tsou.com.encryption.aescbc.Base64Encoder;

/**

Created by zb666 on 2017/2/9.

public class SPSecuredUtils {

/**

保存在手机里面的文件名

public static final String FILE_NAME = “sp_secured”;

private static SharedPreferences mSharedPreferences;

/**

保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
@param context
@param key
@param object
@param publicKey

public static void put(Context context, String key, Object object, RSAPublicKey publicKey) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

SharedPreferences.Editor editor = sp.edit();

// byte[] encryptBytes = AndroidKeyStoreRSAUtils.encryptByPublicKeyForSpilt(encryptionString.getBytes(),

// publicKey.getEncoded());

try {

if (object instanceof String) {

byte[] encryptBytes = AndroidKeyStoreRSAUtils.encryptByPublicKey(((String) object).getBytes(),

publicKey.getEncoded());

editor.putString(key, Base64Encoder.encode(encryptBytes));

} else if (object instanceof Integer) {

put(context, key, Integer.toString((Integer) object), publicKey);

} else if (object instanceof Boolean) {

put(context, key, Boolean.toString((Boolean) object), publicKey);

} else if (object instanceof Float) {

put(context, key, Float.toString((Float) object), publicKey);

} else if (object instanceof Long) {

put(context, key, Long.toString((Long) object), publicKey);

} else {

put(context, key, object.toString(), publicKey);

}

SharedPreferencesCompat.apply(editor);

} catch (Exception e) {

e.printStackTrace();

}

/**

得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
@param context
@param key
@param defaultObject
@return

public static Object get(Context context, String key, Object defaultObject) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

// byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKeyForSpilt(

// Base64Decoder.decodeToBytes(decodeString));

try {

if (defaultObject instanceof String) {

String string = sp.getString(key, (String) defaultObject);

if (!string.equals((String) defaultObject)) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return new String(decryptBytes);

}

return (String) defaultObject;

} else if (defaultObject instanceof Integer) {

String string = sp.getString(key, Integer.toString((Integer) defaultObject));

if (!string.equals(Integer.toString((Integer) defaultObject))) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return Integer.valueOf(new String(decryptBytes));

}

return (Integer) defaultObject;

} else if (defaultObject instanceof Boolean) {

String string = sp.getString(key, Boolean.toString((Boolean) defaultObject));

if (!string.equals(Boolean.toString((Boolean) defaultObject))) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return Boolean.valueOf(new String(decryptBytes));

}

return (Boolean) defaultObject;

} else if (defaultObject instanceof Float) {

String string = sp.getString(key, Float.toString((Float) defaultObject));

if (!string.equals(Float.toString((Float) defaultObject))) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return Float.valueOf(new String(decryptBytes));

}

return (Float) defaultObject;

} else if (defaultObject instanceof Long) {

String string = sp.getString(key, Long.toString((Long) defaultObject));

if (!string.equals(Long.toString((Long) defaultObject))) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return Long.valueOf(new String(decryptBytes));

}

return (Long) defaultObject;

}else if (defaultObject instanceof Double){

String string = sp.getString(key, Double.toString((Double) defaultObject));

if (!string.equals(Double.toString((Double) defaultObject))) {

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(string));

return Double.valueOf(new String(decryptBytes));

}

return (Double) defaultObject;

}

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

将对象储存到sharepreference
@param key
@param device
@param

public static boolean saveDeviceData(Context context, String key, T device, RSAPublicKey publicKey) {

if (mSharedPreferences == null) {

mSharedPreferences = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);

}

ByteArrayOutputStream baos = new ByteArrayOutputStream();

try { //Device为自定义类

// 创建对象输出流，并封装字节流

ObjectOutputStream oos = new ObjectOutputStream(baos);

// 将对象写入字节流

oos.writeObject(device);

// 将字节流编码成base64的字符串

String oAuth_Base64 = new String(Base64.encode

(baos.toByteArray(), Base64.DEFAULT));

byte[] encryptBytes = AndroidKeyStoreRSAUtils.encryptByPublicKey(oAuth_Base64.getBytes(),

publicKey.getEncoded());

mSharedPreferences.edit().putString(key, Base64Encoder.encode(encryptBytes)).apply();

return true;

} catch (Exception e) {

e.printStackTrace();

return false;

}

/**

将对象从shareprerence中取出来
@param key
@param
@return

public static T getDeviceData(Context context, String key) {

if (mSharedPreferences == null) {

mSharedPreferences = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);

}

try {

T device = null;

String productBase64 = mSharedPreferences.getString(key, null);

if (productBase64 == null) {

return null;

}

byte[] decryptBytes = AndroidKeyStoreRSAUtils.decryptByPrivateKey(

Base64Decoder.decodeToBytes(productBase64));

// 读取字节

byte[] base64 = Base64.decode(new String(decryptBytes).getBytes(), Base64.DEFAULT);

// 封装到字节流

ByteArrayInputStream bais = new ByteArrayInputStream(base64);

// 再次封装

ObjectInputStream bis = new ObjectInputStream(bais);

// 读取对象

device = (T) bis.readObject();

return device;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

移除某个key值已经对应的值
@param context
@param key

public static void remove(Context context, String key) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

SharedPreferences.Editor editor = sp.edit();

editor.remove(key);

SharedPreferencesCompat.apply(editor);

}

/**

清除所有数据
@param context

public static void clear(Context context) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

SharedPreferences.Editor editor = sp.edit();

editor.clear();

SharedPreferencesCompat.apply(editor);

}

/**

查询某个key是否已经存在
@param context
@param key
@return

public static boolean contains(Context context, String key) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

return sp.contains(key);

}

/**

返回所有的键值对
@param context
@return

public static Map<String, ?> getAll(Context context) {

SharedPreferences sp = context.getSharedPreferences(FILE_NAME,

Context.MODE_PRIVATE);

return sp.getAll();

}

/**

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

建议

当我们出去找工作，或者准备找工作的时候，我们一定要想，我面试的目标是什么，我自己的技术栈有哪些，近期能掌握的有哪些，我的哪些短板，列出来，有计划的去完成，别看前两天掘金一些大佬在驳来驳去，他们的观点是他们的，不要因为他们的观点，膨胀了自己，影响自己的学习节奏。基础很大程度决定你自己技术层次的厚度，你再熟练框架也好，也会比你便宜的，性价比高的替代，很现实的问题但也要有危机意识，当我们年级大了，有哪些亮点，与比我们经历更旺盛的年轻小工程师，竞争。