JAVA 常用加密方法

JAVA 常用加密方法

1.Base64

加密：org.apache.commons.codec.binary.Base64.encodeBase64(byte[]binaryData)

解密：org.apache.commons.codec.binary.Base64.decodeBase64(byte[]base64Data)

2.Md5

加密：org.apache.commons.codec.digest.md5Hex(byte[]data)

解密：无

3.DES（des-ecb,3des,des-cbc,cbc-mac）

view plaincopy to clipboardprint?

importjava.io.ByteArrayOutputStream;

importjava.security.SecureRandom;

import java.util.Arrays;

importjavax.crypto.Cipher;

importjavax.crypto.SecretKey;

importjavax.crypto.SecretKeyFactory;

importjavax.crypto.spec.DESKeySpec;

importjavax.crypto.spec.DESedeKeySpec;

importjavax.crypto.spec.IvParameterSpec;

importjavax.crypto.spec.SecretKeySpec;

importorg.bouncycastle.crypto.BlockCipher;

importorg.bouncycastle.crypto.Mac;

importorg.bouncycastle.crypto.engines.DESEngine;

importorg.bouncycastle.crypto.macs.CBCBlockCipherMac;

importorg.bouncycastle.crypto.params.KeyParameter;

importcom.alibaba.common.lang.StringUtil;

importcom.huateng.commons.lang.convert.HexUtils;

public class ShfftDes {

//验证用密钥

privatebyte[] key ="000000000000000000000000".getBytes();

// privatebyte[] key = Hex.decode("00000000");

privatebyte[] ivs = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0};

privatestatic final StringDES_EDE ="DESede/ECB/NoPadding"; //定义 加密算法,可用DES,DESede,Blowfish //keybyte为加密密钥，长度为24字节 //src为被加密的数据缓冲区（源）

privatestatic final String DES_EDE_CBC ="DESede/CBC/NoPadding"; //定义 加密算法,可用DES,DESede,Blowfish //keybyte为加密密钥，长度为24字节 //src为被加密的数据缓冲区（源）

privatestatic final StringDES_CBC = "DES/CBC/NoPadding";

privatestatic final StringDES_ECB = "DES/ECB/PKCS5Padding";

publicbyte[] CryptByDes(byte[] content, int mode) throws Exception{

Cipher cipher =Cipher.getInstance(DES_ECB);

SecretKeyFactory keyFactory =SecretKeyFactory.getInstance("DES");

SecretKey secretKey = keyFactory.generateSecret(newDESKeySpec(key));

cipher.init(mode,secretKey);

returncipher.doFinal(content);

}

publicbyte[] CryptBy3Des(byte[] content, int mode) throws Exception{

Cipher cipher =Cipher.getInstance(DES_EDE);

SecretKey secretKey = new SecretKeySpec(key,"DESede");

cipher.init(mode,secretKey);

returncipher.doFinal(content);

}

publicbyte[] CryptByDesCbc(byte[] content, int mode) throws Exception{

Cipher cipher =Cipher.getInstance(DES_CBC);

SecretKey secureKey = new SecretKeySpec(key,"DES");

IvParameterSpec iv = newIvParameterSpec(ivs);

cipher.init(mode, secureKey,iv);

return cipher.doFinal(HexUtils.fromHex(newString(content)));

}

publicbyte[] CryptBy3DesCbc(byte[] content, int mode) throws Exception{

Cipher cipher =Cipher.getInstance(DES_EDE_CBC);

SecretKey secureKey = new SecretKeySpec(key,"DESede");

IvParameterSpec iv = newIvParameterSpec(ivs);

cipher.init(mode, secureKey,iv);

returncipher.doFinal(content);

}

publicbyte[] CryptByDesCbcMac(byte[] content) throws Exception{

BlockCipher engine = newDESEngine();

Mac mac = new CBCBlockCipherMac(engine,64);

byte[] macText = newbyte[engine.getBlockSize()];

mac.init(newKeyParameter(key));

mac.update(Padding(content, 64), 0,content.length);

mac.update(content, 0,content.length);

mac.doFinal(macText, 0);

return macText;

}

publicbyte[] ShFftCryptByDessdsCbc(byte[] content, int mode) throwsException {

byte[] ks1 = HexUtils.fromHex(newString(key));

byte[] ks = new byte[24];

System.arraycopy(ks1, 0, ks, 0,ks1.length);

System.arraycopy(ks1, 0, ks, ks1.length,8);

Cipher cipher =Cipher.getInstance(DES_EDE_CBC);

SecretKeyFactory keyFactory =null;

keyFactory =SecretKeyFactory.getInstance("DESede");

SecretKey secretKey =null;

secretKey = keyFactory.generateSecret(newDESedeKeySpec(ks));

IvParameterSpec iv = new IvParameterSpec(new byte[] { 0, 0, 0, 0,0, 0, 0, 0 });

cipher.init(mode, secretKey,iv);

return cipher.doFinal(HexUtils.fromHex(newString(content)));

}

publicbyte[] mac(byte[] content) throws Exception{

int len;

byte plainData[];

byte encryptedData[];

len = (content.length / 8 + (content.length % 8 != 0 ? 1 : 0)) *8;

plainData = newbyte[len];

encryptedData = newbyte[8];

Arrays.fill(plainData, (byte)32);

System.arraycopy(content, 0, plainData, 0,content.length);

SecureRandom sr = newSecureRandom();

DESKeySpec dks = newDESKeySpec(key);

SecretKeyFactory keyFactory =null;

keyFactory =SecretKeyFactory.getInstance("DES");

SecretKey secretKey =keyFactory.generateSecret(dks);

Cipher cipher =Cipher.getInstance("DES/CBC/NoPadding");

IvParameterSpec iv = new IvParameterSpec(new byte[] { 0, 0, 0, 0,0, 0, 0, 0 });

cipher.init(1, secretKey, iv,sr);

System.arraycopy(cipher.doFinal(plainData), len - 8, encryptedData,0, 8);

return encryptedData;

}

publicbyte[] Padding(byte[] content, int block){

int contentLength =content.length;

int mod = contentLength %block;

if (mod != 0) {

int size = contentLength + block -mod;

// String s = newString(content);

// StringUtil.alignLeft(s, size, "");

byte[] s = newbyte[size];

System.arraycopy(content, 0, s, 0,content.length);

for (int i = content.length; i < size; i++){

s[i] = 32;

}

return s;

}

return content;

}

publicString Padding(String content, int block){

int contentLength =content.length();

int mod = contentLength %block;

if (mod != 0) {

int size = contentLength + block -mod;

String s = newString(content);

StringUtil.alignLeft(s, size, "");

return s;

}

return content;

}

public voidprintln(byte[] bs) {

for (byte b : bs) {

System.out.print(b + "");

}

System.out.println();

}

public voidprintlnByte(byte[] bs) {

for (byte b : bs) {

if (b < 0){

System.out.print((int) b + 256 + "");

} else {

System.out.print(b + "");

}

}

System.out.println();

}

public voidprintlnByteInt16(byte[] bs){

for (byte b : bs) {

System.out.print(Integer.toHexString((int) b) + "");

}

System.out.println();

}

publicString dumpBytes(byte[] bytes){

int i;

StringBuffer sb = newStringBuffer();

for (i = 0; i < bytes.length; i++){

int n = bytes[i] >= 0 ? bytes[i] : 256 +bytes[i];

String s =Integer.toHexString(n);

if (s.length() < 2){

s = "0" + s;

}

if (s.length() > 2){

s = s.substring(s.length() -2);

}

sb.append(s);

}

returnsb.toString().toUpperCase();

//return newBASE64Encoder().encode(bytes);

}

//一下程序将每2位16进制整数组装成一个字节

privateString hexString ="0123456789ABCDEF";

publicbyte[] decode(String bytes){

ByteArrayOutputStream baos = newByteArrayOutputStream(bytes.length() /2);

for (int i = 0; i < bytes.length(); i +=2)

baos.write((hexString.indexOf(bytes.charAt(i))<< 4 |hexString.indexOf(bytes

.charAt(i + 1))));

returnbaos.toByteArray();

}

publicbyte[] getKey() {

return key;

}

public voidsetKey(byte[] key) {

this.key = key;

}

publicbyte[] getIvs() {

return ivs;

}

public voidsetIvs(byte[] ivs) {

this.ivs = ivs;

}

}