加密工具。

来源：互联网发布：java什么叫序列化编辑：程序博客网时间：2024/06/05 10:19

如下：

package com.util;
import java.security.Key;
import java.security.Security;
import javax.crypto.Cipher;

public class DesHelper {
private static String strDefaultKey = "national";
private Cipher encryptCipher = null;
private Cipher decryptCipher = null;

/**
* 将byte数组转换为表示16进制值的字符串，如：byte[]{8,18}转换为：0813，和public static byte[]
* hexStr2ByteArr(String strIn) 互为可逆的转换过程
*
* @param arrB
* 需要转换的byte数组
* @return 转换后的字符串
* @throws Exception
* 本方法不处理任何异常，所有异常全部抛出
*/
public static String byteArr2HexStr(byte[] arrB) throws Exception {
int iLen = arrB.length;
// 每个byte用两个字符才能表示，所以字符串的长度是数组长度的两倍
StringBuffer sb = new StringBuffer(iLen * 2);
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 strIn
* 需要转换的字符串
* @return 转换后的byte数组
* @throws Exception
* 本方法不处理任何异常，所有异常全部抛出
* @author <a href="mailto:leo841001@163.com">LiGuoQing</a>
*/
public static byte[] hexStr2ByteArr(String strIn) throws Exception {
byte[] arrB = strIn.getBytes();
int iLen = arrB.length;

// 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
byte[] arrOut = new byte[iLen / 2];
for (int i = 0; i < iLen; i = i + 2) {
String strTmp = new String(arrB, i, 2);
arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
}
return arrOut;
}

/**
* 默认构造方法，使用默认密钥
*
* @throws Exception
*/
public DesHelper() throws Exception {
this(strDefaultKey);
}

/**
* 指定密钥构造方法
*
* @param strKey
* 指定的密钥
* @throws Exception
*/
public DesHelper(String strKey) throws Exception {
Security.addProvider(new com.sun.crypto.provider.SunJCE());
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 strIn
* 需加密的字符串
* @return 加密后的字符串
* @throws Exception
*/
public String encrypt(String strIn) throws Exception {
return byteArr2HexStr(encrypt(strIn.getBytes()));
}

/**
* 解密字节数组
*
* @param arrB
* 需解密的字节数组
* @return 解密后的字节数组
* @throws Exception
*/
public byte[] decrypt(byte[] arrB) throws Exception {
return decryptCipher.doFinal(arrB);
}

/**
* 解密字符串
*
* @param strIn
* 需解密的字符串
* @return 解密后的字符串
* @throws Exception
*/
public String decrypt(String strIn) throws Exception {
return new String(decrypt(hexStr2ByteArr(strIn)));
}

/**
* 从指定字符串生成密钥，密钥所需的字节数组长度为8位不足8位时后面补0，超出8位只取前8位
*
* @param arrBTmp
* 构成该字符串的字节数组
* @return 生成的密钥
* @throws java.lang.Exception
*/
private Key getKey(byte[] arrBTmp) throws 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;
}

public static void main(String[] args) {
DesHelper dh;
try {
dh = new DesHelper();
/*11d5adbab010be08
String s1 = dh.encrypt("cupeas@163.com");
System.out.println(s1);
String s2 = dh.decrypt(s1);
System.out.println(s2);*/
String s1 = dh.encrypt("GZFR000");
System.out.println(s1);
String s2 = dh.decrypt(s1);
System.out.println(s2);

System.out.println(Integer.valueOf(dh.decrypt("88a5c240cfb976e8")));

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

再如：

package org.common.utils;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.apache.commons.codec.binary.Hex;

public class Md5PwdEncoder implements PwdEncoder {

/*密码加密*/
public String encodePassword(String rawPass) {
String saltedPass = mergePasswordAndSalt(rawPass, salt, false);
MessageDigest messageDigest = getMessageDigest();
byte[] digest;
try {
digest = messageDigest.digest(saltedPass.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("UTF-8 not supported!");
}
return new String(Hex.encodeHex(digest));
}
/*验证密码是否正确*/
public boolean isPasswordValid(String encPass, String rawPass) {
String pass1 = "" + encPass;
String pass2 = encodePassword(rawPass);
return pass1.equals(pass2);
}

protected final MessageDigest getMessageDigest() {
String algorithm = "MD5";
try {
return MessageDigest.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
throw new IllegalArgumentException("No such algorithm ["
+ algorithm + "]");
}
}

/**
* Used by subclasses to extract the password and salt from a merged
* <code>String</code> created using
* {@link #mergePasswordAndSalt(String,Object,boolean)}.
* <p>
* The first element in the returned array is the password. The second
* element is the salt. The salt array element will always be present, even
* if no salt was found in the <code>mergedPasswordSalt</code> argument.
* </p>
*
* @param mergedPasswordSalt
* as generated by <code>mergePasswordAndSalt</code>
*
* @return an array, in which the first element is the password and the
* second the salt
*
* @throws IllegalArgumentException
* if mergedPasswordSalt is null or empty.
*/
protected String mergePasswordAndSalt(String password, Object salt,
boolean strict) {
if (password == null) {
password = "";
}
if (strict && (salt != null)) {
if ((salt.toString().lastIndexOf("{") != -1)
|| (salt.toString().lastIndexOf("}") != -1)) {
throw new IllegalArgumentException(
"Cannot use { or } in salt.toString()");
}
}
if ((salt == null) || "".equals(salt)) {
return password;
} else {
return password + "{" + salt.toString() + "}";
}
}

private String salt = "PONY";

public String getSalt() {
return salt;
}

public void setSalt(String salt) {
this.salt = salt;
}

public static void main(String[] args) {
Md5PwdEncoder m = new Md5PwdEncoder();
System.out.println(m.encodePassword("along"));
}
}

0 0