加密和解密
目录介绍
-
1.加密和解密php
- 1.1 问答环节
- 1.2 加解密概况
-
2.对称加密和非对称加密java
- 2.1 什么是对称加密
- 2.2 什么是非对称加密
- 2.3 常见对称加密有什么
- 2.4 常见非对称加密有什么
- 2.5 非对称加密用途
-
3.关于单向加密android
- 3.1 MD加密
- 3.2 什么叫作加盐
-
4.加密和解密代码展现git
- 4.1 DES加密和解密
- 4.2 AES解密和解密
-
5.RSA非对称加解密github
- 5.1 公钥加密，私钥解密
- 5.2 私钥加密，公钥解密
- 5.3 完整工具类代码
- 5.4 注意RSA加密填充方式
- 5.5 RSA加密内容长度限制问题
- 5.6 加解密效率测试
- 5.7 分段加密解密工具类代码
好消息
- 博客笔记大汇总【16年3月到至今】，包括Java基础及深刻知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，长期更新维护而且修正，持续完善……开源的文件是markdown格式的！转载请注明出处，谢谢！
- https://github.com/yangchong2...
1.加密和解密
1.1 问答环节
- 1.1.1 常见的加密和解密有哪些？
- 1.1.2 MD5加密是属于什么类型？是否可逆，以及有哪些应用场景？
- 1.1.3 实际开发中有哪些加解密的应用场景？
1.2 加解密概况
- 1）在对称加密算法中，双方使用的密钥相同，要求解密方事先必须知道加密密钥。这类加密算法技术较为成熟，加密效率高。
- 2）在非对称加密算法中，收发双方使用不一样的密钥，发方使用公开密钥对消息进行加密，收发使用私有密钥机型解密，保密性更高，但效率更低。
- 3）单向加密算法在加密过程当中不须要使用密钥，输入明文后由算法直接加密成密文，密文没法解密，只有从新输入密文，并通过一样的加密算法处理，获得形同的密文并被系统从新识别后，才能真正的解密，这种算法很是复杂，一般只在数据量有限的情形下使用，如普遍应用在计算机系统中的口令加密等。
2.对称加密和非对称加密
2.1 什么是对称加密
- 密钥能够本身指定，只有一把密钥,若是密钥暴露,文件就会被暴露
- 特色是加密速度很快，可是缺点是安全性较低，由于只要密钥暴漏，数据就能够被解密了。
- 一句话归纳：加密和解密都是用相同密钥
2.2 什么是非对称加密
- 有两把钥匙(密钥对)，公钥和私钥，公钥的话给别人，私钥本身保存
- 把密钥一般是经过程序生成，不能本身指定
- 特色是加密速度慢些，可是安全系数很高
- 加密和解密的规则是：公钥加密只能私钥解密，私钥加密只能公钥解密
- 应用场景举例：在集成支付宝支付sdk时，须要生成私钥和公钥，公钥须要设置到支付宝网站的管理后台，在程序中调用支付接口的时候，使用咱们本身的私钥进行加密，这样支付宝因为有公钥能够解密，其余人即时劫持了数据，可是没有公钥，也没法解密。
2.3 常见对称加密有什么
- DES算法(Data Encryption Standard)
- AES算法(Advanced Encryption Standard)
2.4 常见非对称加密有什么
- RSA
2.5 非对称加密用途
-
身份认证算法
- 一条加密信息若能用A 的公钥能解开，则该信息必定是用A 的私钥加密的，该能肯定该用户是A。
-
陌生人通讯segmentfault
- A 和B 两我的互不认识，A把本身的公钥发给B，B也把本身的公钥发给A，则双方能够经过对方的公钥加密信息通讯。C 虽然也能获得A、B 的公钥，可是他解不开密文。
-
支付宝支付加密数组
- 具体能够参考支付宝sdk的官方demo
3.关于单向加密
-
MD5安全
- 关于MD5加密的工具类代码以下所示
4.加密和解密代码展现
4.1 DES加密和解密【对称加密】
-
加密过程服务器
- 须要加密的内容，也就是明文；而后须要密钥。最后经过工具类加密获得加密后的密文
private final String desEncryptString = "yangchong"; private final String desEncryptKey = "19930311"; s1 = DES.encryptDES(desEncryptString, desEncryptKey); Log.e("加密和解密", s1); 加密和解密: 84r1gS+D3Op8yrSnF5ZDrQ== //s1为加密后的密文 -
解密过程
- 利用加密后的密文，与设置的key，也就是密钥，则能够解密获得加密的内容
String s2 = DES.decryptDES(s1, desEncryptKey); Log.e("加密和解密", s2); //加密和解密: yangchong - Android中实现DES加密和解密的核心代码以下
public class DES {
//初始化向量，随意填写
private static byte[] iv = {1,2,3,4,5,6,7,8};
/**
*
* @param encryptString 明文
* @param encryptKey 密钥
* @return 加密后的密文
*/
public static String encryptDES(String encryptString,String encryptKey){
try {
//实例化IvParameterSpec对象，使用指定的初始化向量
IvParameterSpec zeroIv=new IvParameterSpec(iv);
//实例化SecretKeySpec，根据传入的密钥得到字节数组来构造SecretKeySpec
SecretKeySpec key =new SecretKeySpec(encryptKey.getBytes(),"DES");
//建立密码器
Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
//用密钥初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE,key,zeroIv);
//执行加密操做
byte[]encryptedData=cipher.doFinal(encryptString.getBytes());
return Base64.encodeToString(encryptedData,0);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return null;
}
/**
* 解密的过程与加密的过程大体相同
* @param decryptString 密文
* @param decryptKey 密钥
* @return 返回明文
*/
public static String decryptDES(String decryptString,String decryptKey){
try {
//先使用Base64解密
byte[]byteMi = Base64.decode(decryptString,0);
//实例化IvParameterSpec对象使用指定的初始化向量
IvParameterSpec zeroIv=new IvParameterSpec(iv);
//实例化SecretKeySpec，根据传入的密钥得到字节数组来构造SecretKeySpec,
SecretKeySpec key=new SecretKeySpec(decryptKey.getBytes(),"DES");
//建立密码器
Cipher cipher=Cipher.getInstance("DES/CBC/PKCS5Padding");
//用密钥初始化Cipher对象,上面是加密，这是解密模式
cipher.init(Cipher.DECRYPT_MODE,key,zeroIv);
//获取解密后的数据
byte [] decryptedData=cipher.doFinal(byteMi);
return new String(decryptedData);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return null;
}
}
4.2 AES解密和解密【对称加密】
public class AES {
private static final String Algorithm = "AES";
private final static String HEX = "0123456789ABCDEF";
//加密函数，key为密钥
public static String encrypt(String key, String src) throws Exception {
byte[] rawKey = getRawKey(key.getBytes());
byte[] result = encrypt(rawKey, src.getBytes());
return toHex(result);
}
//解密函数。key值必须和加密时的key一致
public static String decrypt(String key, String encrypted) throws Exception {
byte[] rawKey = getRawKey(key.getBytes());
byte[] enc = toByte(encrypted);
byte[] result = decrypt(rawKey, enc);
return new String(result);
}
private static void appendHex(StringBuffer sb, byte b) {
sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
}
private static byte[] getRawKey(byte[] seed) throws Exception {
KeyGenerator kgen = KeyGenerator.getInstance(Algorithm);
// SHA1PRNG 强随机种子算法, 要区别Android 4.2.2以上版本的调用方法
SecureRandom sr = null;
if (android.os.Build.VERSION.SDK_INT >= 17) {
sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
} else {
sr = SecureRandom.getInstance("SHA1PRNG");
}
sr.setSeed(seed);
kgen.init(256, sr); // 256位或128位或192位
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();
return raw;
}
private static byte[] encrypt(byte[] key, byte[] src) throws Exception {
SecretKeySpec skeySpec = new SecretKeySpec(key, Algorithm);
Cipher cipher = Cipher.getInstance(Algorithm);
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal(src);
return encrypted;
}
private static byte[] decrypt(byte[] key, byte[] encrypted) throws Exception {
SecretKeySpec skeySpec = new SecretKeySpec(key, Algorithm);
Cipher cipher = Cipher.getInstance(Algorithm);
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] decrypted = cipher.doFinal(encrypted);
return decrypted;
}
private static byte[] toByte(String hexString) {
int len = hexString.length() / 2;
byte[] result = new byte[len];
for (int i = 0; i < len; i++) {
result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).byteValue();
}
return result;
}
private static String toHex(byte[] buf) {
if (buf == null) {
return "";
}
StringBuffer result = new StringBuffer(2 * buf.length);
for (int i = 0; i < buf.length; i++) {
appendHex(result, buf[i]);
}
return result.toString();
}
}
5.RSA非对称加解密
5.1 公钥加密，私钥解密
-
第一步：获取随机的公钥和私钥
- 代码以下所示：
//秘钥默认长度 public static final int DEFAULT_KEY_SIZE = 2048; KeyPair keyPair = RSA.generateRSAKeyPair(DEFAULT_KEY_SIZE); if (keyPair != null) { // 公钥 publicKey = (RSAPublicKey) keyPair.getPublic(); // 私钥 privateKey = (RSAPrivateKey) keyPair.getPrivate(); } -
第二步：公钥加密
- 代码以下所示：
//用公钥对字符串进行加密 try { bytes = RSA.encryptByPublicKey(DEFAULT_SPLIT, publicKey.getEncoded()); String s = new String(bytes); Log.e("加密和解密", s); } catch (Exception e) { e.printStackTrace(); } -
第三步：私钥解密
//使用私钥进行解密 try { byte[] bytes = RSA.decryptByPrivateKey(this.bytes, privateKey.getEncoded()); String s = new String(bytes); Log.e("加密和解密", s); //解密后获得的数据：yangchong } catch (Exception e) { e.printStackTrace(); }
5.2 私钥加密，公钥解密
-
第一步：获取随机的公钥和私钥
- 代码以下所示：
//秘钥默认长度 public static final int DEFAULT_KEY_SIZE = 2048; KeyPair keyPair = RSA.generateRSAKeyPair(DEFAULT_KEY_SIZE); if (keyPair != null) { // 公钥 publicKey = (RSAPublicKey) keyPair.getPublic(); // 私钥 privateKey = (RSAPrivateKey) keyPair.getPrivate(); } -
第二步：私钥加密
- 代码以下所示：
//使用私钥加密 try { bytes1 = RSA.encryptByPrivateKey(DEFAULT_SPLIT, privateKey.getEncoded()); String s = new String(bytes); Log.e("加密和解密", s); } catch (Exception e) { e.printStackTrace(); } -
第三步：公钥解密
//使用公钥解密 try { byte[] bytes = RSA.decryptByPublicKey(this.bytes1, publicKey.getEncoded()); String s = new String(bytes); Log.e("加密和解密", s); //解密后获得的数据：yangchong } catch (Exception e) { e.printStackTrace(); }
5.3 完整工具类代码
-
代码以下所示：
public class RSA { public static final String RSA = "RSA";// 非对称加密密钥算法 public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式 /**
*
* @param keyLength 密钥长度，范围：512～2048
* 通常1024
* @return
*/
public static KeyPair generateRSAKeyPair(int keyLength) {
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
/*-------------------------------------------------------------------------------------------------*/
/**
* 用公钥对字符串进行加密
* @param data 原文
* @param publicKey 密钥
* @return byte[] 解密数据
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 获得公钥
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 加密数据
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.ENCRYPT_MODE, keyPublic);
return cp.doFinal(data);
}
/**
* 私钥加密
*
* @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(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(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 数据解密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.DECRYPT_MODE, keyPublic);
return cipher.doFinal(data);
}
/**
* 使用私钥进行解密
* @param encrypted 待解密数据
* @param privateKey 密钥
* @return byte[] 解密数据
* @throws Exception 异常
*/
public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {
// 获得私钥
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 解密数据
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.DECRYPT_MODE, keyPrivate);
byte[] arr = cp.doFinal(encrypted);
return arr;
}
}
```
5.4 注意RSA加密填充方式
- 以前觉得上面操做就能实现rsa加解密，觉得能够呢，可是遇到Android这边加密过的数据，服务器端死活解密不了，原来android系统的RSA实现是"RSA/None/NoPadding"，而标准JDK实现是"RSA/None/PKCS1Padding"，这形成了在android机上加密后没法在服务器上解密的缘由，因此在实现的时候这个必定要注意这个问题。
5.5 RSA加密内容长度限制问题
- RSA非对称加密内容长度有限制，1024位key的最多只能加密127位数据，不然就会报错(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes)
- RSA 算法规定：待加密的字节数不能超过密钥的长度值除以 8 再减去 11（即：KeySize / 8 - 11），而加密后获得密文的字节数，正好是密钥的长度值除以 8（即：KeySize / 8）。
5.6 加解密效率测试
-
第一步：获取随机的公钥和私钥
- 代码以下所示：
//秘钥默认长度 public static final int DEFAULT_KEY_SIZE = 2048; KeyPair keyPair = RSA.generateRSAKeyPair(DEFAULT_KEY_SIZE); if (keyPair != null) { // 公钥 publicKey = (RSAPublicKey) keyPair.getPublic(); // 私钥 privateKey = (RSAPrivateKey) keyPair.getPrivate(); } -
第二步：用公钥对对象进行加密
- 代码以下所示：
//用公钥对对象进行加密 YC yc = new YC(); yc.setAge(25); yc.setName("杨充"); StringBuilder stringBuilder = new StringBuilder(); for(int a=0 ; a<500 ; a++){ stringBuilder.append("都比小杨"+a); } yc.setInfo(stringBuilder.toString()); String string = yc.toString(); long start = System.currentTimeMillis(); encryptBytes = new byte[0]; try { encryptBytes = RSA.encryptByPublicKeyForSpilt(string.getBytes(),publicKey.getEncoded()); } catch (Exception e) { e.printStackTrace(); } long end=System.currentTimeMillis(); Log.e("YC","公钥加密耗时 cost time---->"+(end-start)); String encryStr = new String(encryptBytes); Log.e("YC","加密前数据长度 --1-->"+string.length()); Log.e("YC","加密后数据长度 --1-->"+encryStr.length()); -
第三步：使用私钥进行解密
//使用私钥进行解密 long start2 = System.currentTimeMillis(); byte[] decryptBytes= new byte[0]; try { decryptBytes = RSA.decryptByPrivateKeyForSpilt(encryptBytes,privateKey.getEncoded()); } catch (Exception e) { e.printStackTrace(); } String decryStr = new String(decryptBytes); long end2 =System.currentTimeMillis(); Log.e("YC","私钥解密耗时 cost time---->"+(end2-start2)); Log.e("YC","解密后数据 --1-->"+decryStr); -
第四步：加密和解密效率比较
- 以下所示
- 加密后数据大小的变化：数据量差很少是加密前的1.6倍
- 通过几回测试可知，解密要比加密费时间多，因此通常建议在服务端作解密的逻辑操做
5.7 分段加密解密工具类代码
-
代码以下所示
//秘钥默认长度 private static final int DEFAULT_KEY_SIZE = 2048; // 当前秘钥支持加密的最大字节数 private static final int DEFAULT_BUFFER_SIZE = (DEFAULT_KEY_SIZE / 8) - 11; // 当要加密的内容超过bufferSize，则采用partSplit进行分块加密 private static final byte[] DEFAULT_SPLIT = "#PART#".getBytes(); /** * 用公钥对字符串进行分段加密 * @param data 须要加密数据 * @param publicKey 公钥 * @return byte[] 加密数据 * @throws Exception 异常
*/
public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFER_SIZE) {
return encryptByPublicKey(data, publicKey);
}
List<Byte> allBytes = new ArrayList<>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
for (int i = 0; i < dataLen; i++) {
if (buf != null) {
buf[bufIndex] = data[i];
}
if (++bufIndex == DEFAULT_BUFFER_SIZE || 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_BUFFER_SIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b;
}
return bytes;
}
/**
* 用秘钥对字符串进行分段加密
*
* @param data 要加密的原始数据
* @param privateKey 秘钥
* @return byte[] 加密数据
* @throws Exception 异常
* https://github.com/yangchong211
*/
public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFER_SIZE) {
return encryptByPrivateKey(data, privateKey);
}
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
for (int i = 0; i < dataLen; i++) {
if (buf != null) {
buf[bufIndex] = data[i];
}
if (++bufIndex == DEFAULT_BUFFER_SIZE || 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_BUFFER_SIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b;
}
return bytes;
}
/**
* 用公钥分段解密
*
* @param encrypted 待解密数据
* @param publicKey 公钥
* @return byte[] 解密数据
* @throws Exception 异常
* https://github.com/yangchong211
*/
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<Byte> allBytes = new ArrayList<Byte>(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;
}
return bytes;
}
/**
* 使用私钥分段解密
*
* @param encrypted 待解密数据
* @param privateKey 私钥
* @return byte[] 解密数据
* @throws Exception 异常
* https://github.com/yangchong211
*/
public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
if (splitLen <= 0) {
return decryptByPrivateKey(encrypted, privateKey);
}
int dataLen = encrypted.length;
List<Byte> allBytes = new ArrayList<Byte>(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, privateKey);
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, privateKey);
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;
}
return bytes;
}
```
关于其余内容介绍
01.关于博客汇总连接
02.关于个人博客
- 个人我的站点：www.yczbj.org，www.ycbjie.cn
- github：https://github.com/yangchong211
- 知乎：https://www.zhihu.com/people/...
- 简书：http://www.jianshu.com/u/b7b2...
- csdn：http://my.csdn.net/m0_37700275
- 喜马拉雅听书：http://www.ximalaya.com/zhubo...
- 开源中国：https://my.oschina.net/zbj161...
- 泡在网上的日子：http://www.jcodecraeer.com/me...
- 邮箱：yangchong211@163.com
- 阿里云博客：https://yq.aliyun.com/users/a... 239.headeruserinfo.3.dT4bcV
- segmentfault头条：https://segmentfault.com/u/xi...
相关文章
- 1. 加密和解密
- 2. Java的MD5加密和解密 Java的MD5加密和解密
- 3. 256位加密和解密、AES解密和加密
- 4. js_md5加密和base64的加密解密
- 5. Aes 加密解密 java加密解密
- 6. Base64加密和解密
- 7. DES加密和解密
- 8. oracle的加密和解密
- 9. JDK8 Base64加密和解密
- 10. MD5的加密和解密
- 更多相关文章...
- • Kotlin 数据类与密封类 - Kotlin 教程
- • XQuery 添加元素 和属性 - XQuery 教程
- • 使用阿里云OSS+CDN部署前端页面与加速静态资源
- • IntelliJ IDEA 代码格式化配置和快捷键
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解决方法
- 2. Qt5.7以上调用虚拟键盘(支持中文)，以及源码修改(可拖动，水平缩放)
- 3. 软件测试面试- 购物车功能测试用例设计
- 4. ElasticSearch（概念篇）：你知道的, 为了搜索…
- 5. redux理解
- 6. gitee创建第一个项目
- 7. 支持向量机之硬间隔（一步步推导，通俗易懂）
- 8. Mysql 异步复制延迟的原因及解决方案
- 9. 如何在运行SEPM配置向导时将不可认的复杂数据库密码改为简单密码
- 10. windows系统下tftp服务器使用
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 加密和解密
- 2. Java的MD5加密和解密 Java的MD5加密和解密
- 3. 256位加密和解密、AES解密和加密
- 4. js_md5加密和base64的加密解密
- 5. Aes 加密解密 java加密解密
- 6. Base64加密和解密
- 7. DES加密和解密
- 8. oracle的加密和解密
- 9. JDK8 Base64加密和解密
- 10. MD5的加密和解密