import java.security.Key;
import javax.crypto.Cipher;
/**
* DES加密和解密工具,可以对字符串进行加密和解密操作 。
* 该加密工具适用于当前主流的"android锁机软件"的DES加解密
* @author 1595901624
* <p>
* 2016-10-01
* </p>
*/
public class DesUtils {
/** 字符串默认键值 */
private static String strDefaultKey
= "national";
/** 加密工具 */
private Cipher encryptCipher = null;
/** 解密工具 */
private Cipher decryptCipher = null;
/**
* 将byte数组转换为表示16进制值的字符串, 如:byte[]{8,18}转换为:0813, 和public static byte[]
* hexStr2ByteArr(String str) 互为可逆的转换过程
*
* @param arrB
* 需要转换的byte数组
* @return 转换后的字符串
* @throws Exception
* 本方法不处理任何异常,所有异常全部抛出
*/
int iLen = arrB.length;
// 每个byte用两个字符才能表示,所以字符串的长度是数组长度的两倍
for (int i = 0; i < iLen; i++) {
int intTmp = arrB[i];
// 把负数转换为正数
while (intTmp < 0) {
intTmp = intTmp + 256;
}
// 小于0F的数需要在前面补0
if (intTmp < 16) {
sb.append("0");
}
sb.
append(Integer.
toString(intTmp,
16)); }
return sb.toString();
}
/**
* 将表示16进制值的字符串转换为byte数组, 和public static String byteArr2HexStr(byte[] arrB)
* 互为可逆的转换过程
*
* @param str
* 需要转换的字符串
* @return 转换后的byte数组
* @throws Exception
* 本方法不处理任何异常,所有异常全部抛出
* @author 1595901624
*/
byte[] arrB = str.getBytes();
int iLen = arrB.length;
// 两个字符表示一个字节,所以字节数组长度是字符串长度除以2
byte[] arrOut = new byte[iLen / 2];
for (int i = 0; i < iLen; i = i + 2) {
arrOut
[i
/ 2] = (byte) Integer.
parseInt(strTmp,
16); }
return arrOut;
}
/**
* 默认构造方法,使用默认密钥
*
* @throws Exception
*/
this(strDefaultKey);
}
/**
* 指定密钥构造方法
*
* @param strKey
* 指定的密钥
* @throws Exception
*/
Key key
= getKey
(strKey.
getBytes());
encryptCipher = Cipher.getInstance("DES");
encryptCipher.init(Cipher.ENCRYPT_MODE, key);
decryptCipher = Cipher.getInstance("DES");
decryptCipher.init(Cipher.DECRYPT_MODE, key);
}
/**
* 加密字节数组
*
* @param arrB
* 需加密的字节数组
* @return 加密后的字节数组
* @throws Exception
*/
public byte[] encrypt
(byte[] arrB
) throws Exception { return encryptCipher.doFinal(arrB);
}
/**
* 加密字符串
*
* @param str
* 需加密的字符串
* @return 加密后的字符串
* @throws Exception
*/
return byteArr2HexStr(encrypt(str.getBytes()));
}
/**
* 解密字节数组
*
* @param arrB
* 需解密的字节数组
* @return 解密后的字节数组
* @throws Exception
*/
public byte[] decrypt
(byte[] arrB
) throws Exception { return decryptCipher.doFinal(arrB);
}
/**
* 解密字符串
*
* @param str
* 需解密的字符串
* @return 解密后的字符串
* @throws Exception
*/
return new String(decrypt
(hexStr2ByteArr
(str
))); }
/**
* 从指定字符串生成密钥,密钥所需的字节数组长度为8位 不足8位时后面补0,超出8位只取前8位
*
* @param arrBTmp
* 构成该字符串的字节数组
* @return 生成的密钥
* @throws java.lang.Exception
*/
// 创建一个空的8位字节数组(默认值为0)
byte[] arrB = new byte[8];
// 将原始字节数组转换为8位
for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
arrB[i] = arrBTmp[i];
}
// 生成密钥
Key key
= new javax.
crypto.
spec.
SecretKeySpec(arrB,
"DES");
return key;
}
/**
* main方法
*
* @author 1595901624
* @param args
*/
public static void main
(String[] args
) {
}
}
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