目录
AES 高级加密标准(AES,Advanced Encryption Standard)
AES的底层算法就是基于密钥长度设置加密轮数，通过轮密钥加进行逐位异或操作等基础算法来完成对状态矩阵的描述，想要深入了解的小伙伴可以前往：
3. IV（向量/偏移量）：辅助生成独特的加密规则（也可以不用，建议使用，可以提高安全性）；
4. charEncoding（字符编码格式）：设置加密所用的字符编码格式（基本上都使用 Utf8 ，前后端都能识别）；
1. 基于 charEncoding（字符编码格式）规则，把 data（明文），aesKey（密钥）和 IV（向量/偏移量）转为 字节数组；
2. 基于1.中的数据，配置AES密码器规则和加密模式，构建AES密码器，利用该密码器后即可将 明文字节数组 加密成 AES字节数组；
3. 用Base64加密算法将 2.中的AES字节数组 转成字符串（密文）即可；
2. 基于 charEncoding（字符编码格式）规则，把 aesKey（密钥）和 IV（向量/偏移量）转为 字节数组；
3. 基于1.和2.中的数据，配置AES密码器规则和解密模式，构建AES密码器，利用该密码器后即可生成 data（明文）的字节码数组，再转成字符串（明文）即可；
问题现象：
最近在项目中需要使用加密算法，在组长的推荐下，了解了 RSA 和 AES 算法，这里先发表一下我在学习 AES算法的心得体会。
问题分析：
1.简介：
AES 高级加密标准(AES,Advanced Encryption Standard)
AES算法常用于微信小程序加密传输，是最常见的对称加密算法（加密和解密用相同的密钥）之一，具体的加密流程如下图：
下面简单介绍下各个部分的作用与意义：
-
明文P
没有经过加密的数据。
-
密钥K
用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。
-
AES加密函数
设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输入，则加密函数E会输出密文C。
-
密文C
经加密函数处理后的数据
-
AES解密函数
设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输入，则解密函数会输出明文P。
2.实现逻辑及其他加密算法相关参考：
AES的底层算法就是基于密钥长度设置加密轮数，通过轮密钥加进行逐位异或操作等基础算法来完成对状态矩阵的描述，想要深入了解的小伙伴可以前往：
其他加密算法相关参考：
RSA 加密算法原理简述：RSA 加密算法原理简述_FKNIGHT 的博客-CSDN博客_rsa加密原理
Java 实现 AES 和 RSA 算法：Java实现AES和RSA算法_FKNIGHT 的博客-CSDN博客_java实现aes算法
JS 与 JAVA 跨语言实现 RSA 和 AES 加密算法：JS 与 JAVA 跨语言实现 RSA 和 AES加密算法_FKNIGHT 的博客-CSDN博客_js实现rsa加密算法
3.心得体会
上文看不懂的朋友也不用着急，这里我总结一下自己的学习心得，比较通俗易懂：
3.1. AES算法有 4个 关键变量：
1. data（明文）：需要加密的数据；
2. aesKey（密钥）：用于生成独特的加密规则；
3. IV（向量/偏移量）：辅助生成独特的加密规则（也可以不用，建议使用，可以提高安全性）；
4. charEncoding（字符编码格式）：设置加密所用的字符编码格式（基本上都使用 Utf8 ，前后端都能识别）；
3.2. AES算法有 2个 基本函数：
1. encrypt（加密函数）；
2. decrypt（解密函数）；
3.3. AES算法的加密思路：
1. 基于 charEncoding（字符编码格式）规则，把 data（明文），aesKey（密钥）和 IV（向量/偏移量）转为 字节数组；
2. 基于1.中的数据，配置AES密码器规则和加密模式，构建AES密码器，利用该密码器后即可将 明文字节数组 加密成 AES字节数组；
3. 用Base64加密算法将 2.中的AES字节数组 转成字符串（密文）即可；
3.4. AES算法的加密思路（和加密思路差不多）：
1. 用Base64解密算法将 密文数据 转为 字节数组；
2. 基于 charEncoding（字符编码格式）规则，把 aesKey（密钥）和 IV（向量/偏移量）转为 字节数组；
3. 基于1.和2.中的数据，配置AES密码器规则和解密模式，构建AES密码器，利用该密码器后即可生成 data（明文）的字节码数组，再转成字符串（明文）即可；
4.实例演示
上面简单介绍了AES算法思维，相信很多小伙伴还是一知半解，还不如直接上代码，理解起来会快得多：
4.1 首先是前端的加密和解密算法：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<!--引入aes算法的js包-->
<script src="./rollups/aes.js"></script>
</head>
<body>
<script>
//约定的 AES_KEY
let AES_KEY = 'ABCDEFGHIJKL_key';
//约定的 AES_IV
let AES_IV = 'ABCDEFGHIJKLM_iv';
// 加密
function encrypt(data, key, iv) {
// 此处 data 不用转为 Utf8 字符编码格式
var key1 = CryptoJS.enc.Utf8.parse(key); // key 转为 Utf8 字符编码格式的字符串对象
var iv1 = CryptoJS.enc.Utf8.parse(iv); // iv 转为 Utf8 字符编码格式的字符串对象
return CryptoJS.AES.encrypt(data, key1, { // 使用转码后的 key 和 iv 对 data 加密
iv: iv1,
mode: CryptoJS.mode.CBC, //使用CBC模式创建密码器
padding: CryptoJS.pad.Pkcs7 //使用Pkcs7偏移算法，增加加密算法的强度
}).toString(); //对象转为字符串格式并输出
}
// 解密
function decrypt(data, key, iv) {
var key1 = CryptoJS.enc.Utf8.parse(key); // key 转为 Utf8 字符编码格式的字符串对象
var iv1 = CryptoJS.enc.Utf8.parse(iv); // iv 转为 Utf8 字符编码格式的字符串对象
return CryptoJS.AES.decrypt(data, key1, { // 使用转码后的 key 和 iv 对 data 解密
iv: iv1,
mode: CryptoJS.mode.CBC, //使用CBC模式创建密码器
padding: CryptoJS.pad.Pkcs7 //使用Pkcs7偏移算法，增加加密算法的强度
}).toString(CryptoJS.enc.Utf8); //使用 Utf8 字符编码格式 转为字符串并输出
}
//调用函数并打印
let data = 'admin123456'
let code = encrypt(data, AES_KEY, AES_IV) //加密 明文为：'admin123456'
console.log(code) //打印 密文为：'AzPbSRRVk2f7EHwbSw/reg=='
console.log(decrypt(code, AES_KEY, AES_IV)) //解密 并打印 明文为：'admin123456'
</script>
</body>
</html>结果：
AzPbSRRVk2f7EHwbSw/reg== //密文
admin123456 //明文4.1 后端算法：
AESUtil:
//package 配置文件路径
import org.apache.commons.lang.StringUtils;
import sun.misc.BASE64Decoder;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class AESUtil {
/**
* 判空
*
* @param data 原文/明文/密文
* @param key AES密钥
* @param iv IV向量
* @param charEncoding 字符编码格式
* @return
*/
private static String isEmpty(String data, String key, String iv, String charEncoding) {
if ( StringUtils.isEmpty(data) ) {
throw new IllegalArgumentException("'Data' must be specified and not be null!");
}
if ( StringUtils.isEmpty(key) ) {
throw new IllegalArgumentException("'AES Key' must be specified and not be null!");
}
if ( StringUtils.isEmpty(iv) ) {
throw new IllegalArgumentException("'IV' must be specified and not be null!");
}
if ( key.length() != 16 ) {
throw new RuntimeException("Invalid 'AES Key' length (must be 16 bytes)!");
}
if ( StringUtils.isEmpty(data) && iv.length() != 16 ) {
throw new RuntimeException("Invalid 'IV' length (must be 16 bytes)!");
}
if ( iv.length() != 16 ) {
throw new RuntimeException("Invalid 'IV' length (must be 16 bytes)!");
}
if ( StringUtils.isEmpty(charEncoding) ) {
charEncoding = VariableConfigure.UTF8_CHAR_ENCODING;
}
return charEncoding;
}
/**
* AES加密
*
* @param data 原文/明文
* @param key AES密钥
* @param iv IV向量
* @param charEncoding 字符编码格式
* @return 返回密文字符串
*/
public static String encrypt(String data, String key, String iv, String charEncoding) {
charEncoding = isEmpty(data, key, iv, charEncoding);
try {
byte[] dataByte = data.getBytes(charEncoding);//转为utf8字节数组
byte[] keyByte = key.getBytes(charEncoding);//转为utf8字节数组
byte[] ivByte = iv.getBytes(charEncoding);//转为utf8字节数组
Cipher cipher = Cipher.getInstance(VariableConfigure.AES_ALGORITHM);// 使用CBC模式创建密码器
IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);//创建向量/偏移量iv，增加加密算法的强度
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyByte, "AES"), ivParameterSpec);// 配置加密模式并初始化
byte[] valueByte = cipher.doFinal(dataByte); // 密码器加密数据
return new String(Base64.encode(valueByte)); // Base64加密并转成字符串
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Encrypt Fail!", e);
}
}
/**
* AES解密
*
* @param encryptCode
* @param key
* @param iv
* @param charEncoding
* @return
*/
public static String decrypt(String encryptCode, String key, String iv, String charEncoding) {
charEncoding = isEmpty(encryptCode, key, iv, charEncoding);
try {
byte[] encryptCodeByte = new BASE64Decoder().decodeBuffer(encryptCode);//对密文进行Base64解密
byte[] keyByte = key.getBytes(charEncoding);//转为utf8字节数组
byte[] ivByte = iv.getBytes(charEncoding);//转为utf8字节数组
Cipher cipher = Cipher.getInstance(VariableConfigure.AES_ALGORITHM);// 使用CBC模式创建密码器
IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);//创建向量/偏移量iv，增加加密算法的强度
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyByte, "AES"), ivParameterSpec);// 配置加密模式并初始化
byte[] decryptBytes = cipher.doFinal(encryptCodeByte);// 密码器解密数据
return new String(decryptBytes);// 转为字符串
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Decrypt Fail!", e);
}
}
//测试
public static void main(String[] args) throws Exception {
String data = "admin123456";
String key = "ABCDEFGHIJKL_key";
String iv = "ABCDEFGHIJKLM_iv";
String encryptCode = encrypt(data, key, iv, null);
System.out.println("密文： " + encryptCode);
String decryptCode = decrypt(encryptCode, key, iv, null);
System.out.println("明文： " + decryptCode);
}
}Base64（Base64工具类）:
//package 配置文件路径
import java.io.UnsupportedEncodingException;
public class Base64 {
/**
* Chunk size per RFC 2045 section 6.8.
*
* <p>The {@value} character limit does not count the trailing CRLF, but counts
* all other characters, including any equal signs.</p>
*
* @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 6.8</a>
*/
static final int CHUNK_SIZE = 76;
/**
* Chunk separator per RFC 2045 section 2.1.
*
* @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
*/
static final byte[] CHUNK_SEPARATOR = "\r\n".getBytes();
/**
* The base length.
*/
static final int BASELENGTH = 255;
/**
* Lookup length.
*/
static final int LOOKUPLENGTH = 64;
/**
* Used to calculate the number of bits in a byte.
*/
static final int EIGHTBIT = 8;
/**
* Used when encoding something which has fewer than 24 bits.
*/
static final int SIXTEENBIT = 16;
/**
* Used to determine how many bits data contains.
*/
static final int TWENTYFOURBITGROUP = 24;
/**
* Used to get the number of Quadruples.
*/
static final int FOURBYTE = 4;
/**
* Used to test the sign of a byte.
*/
static final int SIGN = -128;
/**
* Byte used to pad output.
*/
static final byte PAD = (byte) '=';
// Create arrays to hold the base64 characters and a
// lookup for base64 chars
private static byte[] base64Alphabet = new byte[BASELENGTH];
private static byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];
// Populating the lookup and character arrays
static {
for (int i = 0; i < BASELENGTH; i++) {
base64Alphabet[i] = (byte) -1;
}
for (int i = 'Z'; i >= 'A'; i--) {
base64Alphabet[i] = (byte) (i - 'A');
}
for (int i = 'z'; i >= 'a'; i--) {
base64Alphabet[i] = (byte) (i - 'a' + 26);
}
for (int i = '9'; i >= '0'; i--) {
base64Alphabet[i] = (byte) (i - '0' + 52);
}
base64Alphabet['+'] = 62;
base64Alphabet['/'] = 63;
for (int i = 0; i <= 25; i++) {
lookUpBase64Alphabet[i] = (byte) ('A' + i);
}
for (int i = 26, j = 0; i <= 51; i++, j++) {
lookUpBase64Alphabet[i] = (byte) ('a' + j);
}
for (int i = 52, j = 0; i <= 61; i++, j++) {
lookUpBase64Alphabet[i] = (byte) ('0' + j);
}
lookUpBase64Alphabet[62] = (byte) '+';
lookUpBase64Alphabet[63] = (byte) '/';
}
private static boolean isBase64(byte octect) {
if (octect == PAD) {
return true;
} else if (base64Alphabet[octect] == -1) {
return false;
} else {
return true;
}
}
/**
* Tests a given byte array to see if it contains
* only valid characters within the Base64 alphabet.
*
* @param arrayOctect byte array to test
* @return true if all bytes are valid characters in the Base64
* alphabet or if the byte array is empty; false, otherwise
*/
public static boolean isArrayByteBase64(byte[] arrayOctect) {
arrayOctect = discardWhitespace(arrayOctect);
int length = arrayOctect.length;
if (length == 0) {
// shouldn't a 0 length array be valid base64 data?
// return false;
return true;
}
for (int i = 0; i < length; i++) {
if (!isBase64(arrayOctect[i])) {
return false;
}
}
return true;
}
/**
* Encodes binary data using the base64 algorithm but
* does not chunk the output.
*
* @param binaryData binary data to encode
* @return Base64 characters
*/
public static byte[] encodeBase64(byte[] binaryData) {
return encodeBase64(binaryData, false);
}
/**
* Encodes binary data using the base64 algorithm and chunks
* the encoded output into 76 character blocks
*
* @param binaryData binary data to encode
* @return Base64 characters chunked in 76 character blocks
*/
public static byte[] encodeBase64Chunked(byte[] binaryData) {
return encodeBase64(binaryData, true);
}
/**
* Decodes a byte[] containing containing
* characters in the Base64 alphabet.
*
* @param pArray A byte array containing Base64 character data
* @return a byte array containing binary data
*/
public static byte[] decode(byte[] pArray) {
return decodeBase64(pArray);
}
/**
* Encodes binary data using the base64 algorithm, optionally
* chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if isChunked is true this encoder will chunk
* the base64 output into 76 character blocks
* @return Base64-encoded data.
*/
public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
int lengthDataBits = binaryData.length * EIGHTBIT;
int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
byte encodedData[] = null;
int encodedDataLength = 0;
int nbrChunks = 0;
if (fewerThan24bits != 0) {
//data not divisible by 24 bit
encodedDataLength = (numberTriplets + 1) * 4;
} else {
// 16 or 8 bit
encodedDataLength = numberTriplets * 4;
}
// If the output is to be "chunked" into 76 character sections,
// for compliance with RFC 2045 MIME, then it is important to
// allow for extra length to account for the separator(s)
if (isChunked) {
nbrChunks =
(CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math.ceil((float) encodedDataLength / CHUNK_SIZE));
encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;
}
encodedData = new byte[encodedDataLength];
byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
int encodedIndex = 0;
int dataIndex = 0;
int i = 0;
int nextSeparatorIndex = CHUNK_SIZE;
int chunksSoFar = 0;
//log.debug("number of triplets = " + numberTriplets);
for (i = 0; i < numberTriplets; i++) {
dataIndex = i * 3;
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
b3 = binaryData[dataIndex + 2];
//log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3);
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 =
((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
byte val3 =
((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
//log.debug( "val2 = " + val2 );
//log.debug( "k4 = " + (k<<4) );
//log.debug( "vak = " + (val2 | (k<<4)) );
encodedData[encodedIndex + 1] =
lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] =
lookUpBase64Alphabet[(l << 2) | val3];
encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
encodedIndex += 4;
// If we are chunking, let's put a chunk separator down.
if (isChunked) {
// this assumes that CHUNK_SIZE % 4 == 0
if (encodedIndex == nextSeparatorIndex) {
System.arraycopy(
CHUNK_SEPARATOR,
0,
encodedData,
encodedIndex,
CHUNK_SEPARATOR.length);
chunksSoFar++;
nextSeparatorIndex =
(CHUNK_SIZE * (chunksSoFar + 1)) +
(chunksSoFar * CHUNK_SEPARATOR.length);
encodedIndex += CHUNK_SEPARATOR.length;
}
}
}
// form integral number of 6-bit groups
dataIndex = i * 3;
if (fewerThan24bits == EIGHTBIT) {
b1 = binaryData[dataIndex];
k = (byte) (b1 & 0x03);
//log.debug("b1=" + b1);
//log.debug("b1<<2 = " + (b1>>2) );
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
encodedData[encodedIndex + 2] = PAD;
encodedData[encodedIndex + 3] = PAD;
} else if (fewerThan24bits == SIXTEENBIT) {
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
byte val1 =
((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 =
((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] =
lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
encodedData[encodedIndex + 3] = PAD;
}
if (isChunked) {
// we also add a separator to the end of the final chunk.
if (chunksSoFar < nbrChunks) {
System.arraycopy(
CHUNK_SEPARATOR,
0,
encodedData,
encodedDataLength - CHUNK_SEPARATOR.length,
CHUNK_SEPARATOR.length);
}
}
return encodedData;
}
/**
* Decodes Base64 data into octects
*
* @param base64Data Byte array containing Base64 data
* @return Array containing decoded data.
*/
public static byte[] decodeBase64(byte[] base64Data) {
// RFC 2045 requires that we discard ALL non-Base64 characters
base64Data = discardNonBase64(base64Data);
// handle the edge case, so we don't have to worry about it later
if (base64Data.length == 0) {
return new byte[0];
}
int numberQuadruple = base64Data.length / FOURBYTE;
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;
// Throw away anything not in base64Data
int encodedIndex = 0;
int dataIndex = 0;
{
// this sizes the output array properly - rlw
int lastData = base64Data.length;
// ignore the '=' padding
while (base64Data[lastData - 1] == PAD) {
if (--lastData == 0) {
return new byte[0];
}
}
decodedData = new byte[lastData - numberQuadruple];
}
for (int i = 0; i < numberQuadruple; i++) {
dataIndex = i * 4;
marker0 = base64Data[dataIndex + 2];
marker1 = base64Data[dataIndex + 3];
b1 = base64Alphabet[base64Data[dataIndex]];
b2 = base64Alphabet[base64Data[dataIndex + 1]];
if (marker0 != PAD && marker1 != PAD) {
//No PAD e.g 3cQl
b3 = base64Alphabet[marker0];
b4 = base64Alphabet[marker1];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] =
(byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4);
} else if (marker0 == PAD) {
//Two PAD e.g. 3c[Pad][Pad]
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
} else if (marker1 == PAD) {
//One PAD e.g. 3cQ[Pad]
b3 = base64Alphabet[marker0];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] =
(byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
}
encodedIndex += 3;
}
return decodedData;
}
/**
* Discards any whitespace from a base-64 encoded block.
*
* @param data The base-64 encoded data to discard the whitespace
* from.
* @return The data, less whitespace (see RFC 2045).
*/
static byte[] discardWhitespace(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for (int i = 0; i < data.length; i++) {
switch (data[i]) {
case (byte) ' ' :
case (byte) '\n' :
case (byte) '\r' :
case (byte) '\t' :
break;
default:
groomedData[bytesCopied++] = data[i];
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Discards any characters outside of the base64 alphabet, per
* the requirements on page 25 of RFC 2045 - "Any characters
* outside of the base64 alphabet are to be ignored in base64
* encoded data."
*
* @param data The base-64 encoded data to groom
* @return The data, less non-base64 characters (see RFC 2045).
*/
static byte[] discardNonBase64(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for (int i = 0; i < data.length; i++) {
if (isBase64(data[i])) {
groomedData[bytesCopied++] = data[i];
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Encodes a byte[] containing binary data, into a byte[] containing
* characters in the Base64 alphabet.
*
* @param pArray a byte array containing binary data
* @return A byte array containing only Base64 character data
*/
public static byte[] encode(byte[] pArray) {
return encodeBase64(pArray, false);
}
public static String encode(String str) throws UnsupportedEncodingException
{
String baseStr = new String(encode(str.getBytes("UTF-8")));
String tempStr = Digest.digest(str).toUpperCase();
String result = tempStr+baseStr;
return new String(encode(result.getBytes("UTF-8")));
}
public static String decode(String cryptoStr) throws
UnsupportedEncodingException {
if(cryptoStr.length()<40)
return "";
try
{
String tempStr = new String(decode(cryptoStr.getBytes("UTF-8")));
String result = tempStr.substring(40, tempStr.length());
return new String(decode(result.getBytes("UTF-8")));
}
catch(ArrayIndexOutOfBoundsException ex)
{
return "";
}
}
/**
* Decodes Base64 data into octects
*
* @param encoded string containing Base64 data
* @return Array containind decoded data.
*/
public static byte[] decode2(String encoded) {
if (encoded == null) {
return null;
}
char[] base64Data = encoded.toCharArray();
// remove white spaces
int len = removeWhiteSpace(base64Data);
if (len % FOURBYTE != 0) {
return null;//should be divisible by four
}
int numberQuadruple = (len / FOURBYTE);
if (numberQuadruple == 0) {
return new byte[0];
}
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
int i = 0;
int encodedIndex = 0;
int dataIndex = 0;
decodedData = new byte[(numberQuadruple) * 3];
for (; i < numberQuadruple - 1; i++) {
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
|| !isData((d3 = base64Data[dataIndex++]))
|| !isData((d4 = base64Data[dataIndex++]))) {
return null;
}//if found "no data" just return null
b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2];
b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
}
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
return null;//if found "no data" just return null
}
b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2];
d3 = base64Data[dataIndex++];
d4 = base64Data[dataIndex++];
if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
if (isPad(d3) && isPad(d4)) {
if ((b2 & 0xf) != 0)//last 4 bits should be zero
{
return null;
}
byte[] tmp = new byte[i * 3 + 1];
System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
return tmp;
} else if (!isPad(d3) && isPad(d4)) {
b3 = base64Alphabet[d3];
if ((b3 & 0x3) != 0)//last 2 bits should be zero
{
return null;
}
byte[] tmp = new byte[i * 3 + 2];
System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
return tmp;
} else {
return null;
}
} else { //No PAD e.g 3cQl
b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
}
return decodedData;
}
private static boolean isWhiteSpace(char octect) {
return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
}
private static boolean isData(char octect) {
return (octect < BASELENGTH && base64Alphabet[octect] != -1);
}
private static boolean isPad(char octect) {
return (octect == PAD);
}
/**
* remove WhiteSpace from MIME containing encoded Base64 data.
*
* @param data the byte array of base64 data (with WS)
* @return the new length
*/
private static int removeWhiteSpace(char[] data) {
if (data == null) {
return 0;
}
// count characters that's not whitespace
int newSize = 0;
int len = data.length;
for (int i = 0; i < len; i++) {
if (!isWhiteSpace(data[i])) {
data[newSize++] = data[i];
}
}
return newSize;
}
}
ConvertUtils（公式转换工具类）：
//package 配置文件路径
import java.io.UnsupportedEncodingException;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
public abstract class ConvertUtils {
private static final DecimalFormat simpleFormat = new DecimalFormat("####");
public static final boolean objectToBoolean(Object o){
return o != null ? Boolean.valueOf(o.toString()).booleanValue() : false;
}
public static final int objectToInt(Object o){
if(o instanceof Number)
return ((Number)o).intValue();
try{
if(o == null)
return -1;
else
return Integer.parseInt(o.toString());
}catch(NumberFormatException e){
return -1;
}
}
public static final short objectToShort(Object o){
if(o instanceof Number)
return ((Number)o).shortValue();
try{
if(o == null)
return -1;
else
return Short.parseShort(o.toString());
}catch(NumberFormatException e){
return -1;
}
}
public static final double objectToDouble(Object o){
if(o instanceof Number)
return ((Number)o).doubleValue();
try{
if(o == null)
return -1D;
else
return Double.parseDouble(o.toString());
}catch(NumberFormatException e){
return -1D;
}
}
public static final long objectToLong(Object o)
{
if(o instanceof Number)
return ((Number)o).longValue();
try{
if(o == null)
return -1L;
else
return Long.parseLong(o.toString());
}catch(NumberFormatException e){
return -1L;
}
}
public static final String objectToString(Object obj, DecimalFormat fmt)
{
fmt.setDecimalSeparatorAlwaysShown(false);
if(obj instanceof Double)
return fmt.format(((Double)obj).doubleValue());
if(obj instanceof Long)
return fmt.format(((Long)obj).longValue());
else
return obj.toString();
}
public static final Object getObjectValue(String value)
{
try{
return Long.valueOf(value);
}catch(NumberFormatException e) {}
try{
return Double.valueOf(value);
}catch(NumberFormatException e){
return value;
}
}
public static String longToSimpleString(long value){
return simpleFormat.format(value);
}
public static String asHex(byte hash[]){
return toHex(hash);
}
public static String toHex(byte input[]){
if(input == null)
return null;
StringBuffer output = new StringBuffer(input.length * 2);
for(int i = 0; i < input.length; i++){
int current = input[i] & 0xff;
if(current < 16)
output.append("0");
output.append(Integer.toString(current, 16));
}
return output.toString();
}
public static byte[] fromHex(String input){
if(input == null)
return null;
byte output[] = new byte[input.length() / 2];
for(int i = 0; i < output.length; i++)
output[i] = (byte)Integer.parseInt(input.substring(i * 2, (i + 1) * 2), 16);
return output;
}
public static String stringToHexString(String input, String encoding)
throws UnsupportedEncodingException{
return input != null ? toHex(input.getBytes(encoding)) : null;
}
public static String stringToHexString(String input){
try{
return stringToHexString(input, "UTF-8");
}catch(UnsupportedEncodingException e){
throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
}
}
public static String hexStringToString(String input, String encoding)
throws UnsupportedEncodingException{
return input != null ? new String(fromHex(input), encoding) : null;
}
public static String hexStringToString(String input){
try{
return hexStringToString(input, "UTF-8");
}catch(UnsupportedEncodingException e){
throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
}
}
public static String timeZoneToCode(TimeZone tz){
return timeZoneToString(tz);
}
public static TimeZone codeToTimeZone(String tzString){
return stringToTimeZone(tzString);
}
public static String timeZoneToString(TimeZone tz){
return tz != null ? tz.getID() : "";
}
public static TimeZone stringToTimeZone(String tzString){
return TimeZone.getTimeZone(tzString != null ? tzString : "");
}
public static String localeToCode(Locale aLocale){
return localeToString(aLocale);
}
public static Locale codeToLocale(String locString){
return stringToLocale(locString);
}
public static String localeToString(Locale loc){
return loc != null ? loc.toString() : "";
}
public static Locale stringToLocale(String locString){
locString = locString != null ? locString.trim() : "";
if(locString.equals(""))
return new Locale("", "", "");
int pos = locString.indexOf(95);
if(pos == -1)
return new Locale(locString, "", "");
String language = locString.substring(0, pos);
locString = locString.substring(pos + 1);
pos = locString.indexOf(95);
if(pos == -1){
return new Locale(language, locString, "");
}else{
String country = locString.substring(0, pos);
locString = locString.substring(pos + 1);
return new Locale(language, country, locString);
}
}
public static Date dateToSQLDate(java.util.Date d){
return d != null ? new Date(d.getTime()) : null;
}
public static Time dateToSQLTime(java.util.Date d){
return d != null ? new Time(d.getTime()) : null;
}
public static Timestamp dateToSQLTimestamp(java.util.Date d){
return d != null ? new Timestamp(d.getTime()) : null;
}
public static java.util.Date sqlTimestampToDate(Timestamp t){
return t != null ? new java.util.Date(Math.round((double)t.getTime() + (double)t.getNanos() / 1000000D)) : null;
}
public static Timestamp getCurrentDate(){
Calendar c = Calendar.getInstance();
c.set(c.get(1), c.get(2), c.get(5), 0, 0, 0);
Timestamp t = new Timestamp(c.getTime().getTime());
t.setNanos(0);
return t;
}
public static java.util.Date getDate(int y, int m, int d, boolean inclusive)
{
java.util.Date dt = null;
Calendar c = Calendar.getInstance();
c.clear();
if(c.getActualMinimum(1) <= y && y <= c.getActualMaximum(1))
{
c.set(1, y);
if(c.getActualMinimum(2) <= m && m <= c.getActualMaximum(2))
{
c.set(2, m);
if(c.getActualMinimum(5) <= d && d <= c.getActualMaximum(5))
c.set(5, d);
}
if(inclusive)
{
c.add(5, 1);
c.add(14, -1);
}
dt = c.getTime();
}
return dt;
}
public static java.util.Date getDateStart(java.util.Date d)
{
Calendar c = new GregorianCalendar();
c.clear();
Calendar co = new GregorianCalendar();
co.setTime(d);
c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH));
c.set(Calendar.MONTH,co.get(Calendar.MONTH));
c.set(Calendar.YEAR,co.get(Calendar.YEAR));
//c.add(Calendar.DAY_OF_MONTH,1);
//c.add(Calendar.MILLISECOND,-1);
return c.getTime();
}
public static java.util.Date getDateEnd(java.util.Date d)
{
Calendar c = Calendar.getInstance();
c.clear();
Calendar co = Calendar.getInstance();
co.setTime(d);
c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH));
c.set(Calendar.MONTH,co.get(Calendar.MONTH));
c.set(Calendar.YEAR,co.get(Calendar.YEAR));
c.add(Calendar.DAY_OF_MONTH,1);
c.add(Calendar.MILLISECOND,-1);
return c.getTime();
}
public static double roundNumber(double rowNumber, int roundingPoint)
{
double base = Math.pow(10D, roundingPoint);
return (double)Math.round(rowNumber * base) / base;
}
public static Object getObject(String type,String value) throws Exception{
type=type.toLowerCase();
if("boolean".equals(type))
return Boolean.valueOf(value);
if("byte".equals(type))
return Byte.valueOf(value);
if("short".equals(type))
return Short.valueOf(value);
if("char".equals(type))
if(value.length() != 1)
throw new NumberFormatException("Argument is not a character!");
else
return Character.valueOf(value.toCharArray()[0]);
if("int".equals(type))
return Integer.valueOf(value);
if("long".equals(type))
return Long.valueOf(value);
if("float".equals(type))
return Float.valueOf(value);
if("double".equals(type))
return Double.valueOf(value);
if("string".equals(type))
return value;
else{
Object objs[]=new String[]{value};
return Class.forName(type).getConstructor(new Class[] {
String.class
}).newInstance(objs);
}
}
private ConvertUtils(){}
// public static void main(String[] args)
// {
// System.out.println(getDateStart(new java.util.Date()));
// }
}
Digest（摘要工具类）：
//package 配置文件路径
import org.bouncycastle.jcajce.provider.asymmetric.RSA;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
public class Digest {
private final static Logger log = LoggerFactory.getLogger(RSA.class);
public static final String ENCODE = "UTF-8";
public static String signMD5(String aValue, String encoding) {
try {
byte[] input = aValue.getBytes(encoding);
MessageDigest md = MessageDigest.getInstance("MD5");
return ConvertUtils.toHex(md.digest(input));
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
} catch (UnsupportedEncodingException e) {
log.error(e.getMessage(), e);
return null;
}
}
public static String hmacSign(String aValue) {
try {
byte[] input = aValue.getBytes();
MessageDigest md = MessageDigest.getInstance("MD5");
return ConvertUtils.toHex(md.digest(input));
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
}
}
public static String hmacSign(String aValue, String aKey) {
return hmacSign(aValue, aKey, ENCODE);
}
public static String hmacSign(String aValue, String aKey, String encoding) {
byte k_ipad[] = new byte[64];
byte k_opad[] = new byte[64];
byte keyb[];
byte value[];
try {
keyb = aKey.getBytes(encoding);
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
keyb = aKey.getBytes();
value = aValue.getBytes();
}
Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
Arrays.fill(k_opad, keyb.length, 64, (byte)92);
for ( int i = 0; i < keyb.length; i++ ) {
k_ipad[i] = (byte)(keyb[i] ^ 0x36);
k_opad[i] = (byte)(keyb[i] ^ 0x5c);
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
}
md.update(k_ipad);
md.update(value);
byte dg[] = md.digest();
md.reset();
md.update(k_opad);
md.update(dg, 0, 16);
dg = md.digest();
return ConvertUtils.toHex(dg);
}
public static String hmacSHASign(String aValue, String aKey, String encoding) {
byte k_ipad[] = new byte[64];
byte k_opad[] = new byte[64];
byte keyb[];
byte value[];
try {
keyb = aKey.getBytes(encoding);
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
keyb = aKey.getBytes();
value = aValue.getBytes();
}
Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
Arrays.fill(k_opad, keyb.length, 64, (byte)92);
for ( int i = 0; i < keyb.length; i++ ) {
k_ipad[i] = (byte)(keyb[i] ^ 0x36);
k_opad[i] = (byte)(keyb[i] ^ 0x5c);
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
}
md.update(k_ipad);
md.update(value);
byte dg[] = md.digest();
md.reset();
md.update(k_opad);
md.update(dg, 0, 20);
dg = md.digest();
return ConvertUtils.toHex(dg);
}
public static String digest(String aValue) {
return digest(aValue, ENCODE);
}
public static String digest(String aValue, String encoding) {
aValue = aValue.trim();
byte value[];
try {
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
value = aValue.getBytes();
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
}
return ConvertUtils.toHex(md.digest(value));
}
public static String digest(String aValue, String alg, String encoding) {
aValue = aValue.trim();
byte value[];
try {
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
value = aValue.getBytes();
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance(alg);
} catch (NoSuchAlgorithmException e) {
log.error(e.getMessage(), e);
return null;
}
return ConvertUtils.toHex(md.digest(value));
}
public static String udpSign(String aValue) {
try {
byte[] input = aValue.getBytes("UTF-8");
MessageDigest md = MessageDigest.getInstance("SHA1");
return new String(Base64.encode(md.digest(input)), ENCODE);
} catch (Exception e) {
return null;
}
}
}
VariableConfigure（变量配置工具类）：
//package 配置文件路径
public class VariableConfigure {
//UTF-8字符编码格式（可识别中英文，全球通用）
public static final String UTF8_CHAR_ENCODING = "UTF-8";
//AES算法
public static final String AES_ALGORITHM = "AES/CBC/PKCS5Padding";
//RSA算法
public static final String RSA_ALGORITHM = "RSA/ECB/PKCS1Padding";
}
结果：
8711
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
