MD2/MD5/SHA/SHA256/SHA384/SHA512算法

package qeeka.test.qeeka.test;  

import java.security.InvalidAlgorithmParameterException;  

import java.security.InvalidKeyException;  

import java.security.NoSuchAlgorithmException;  

import java.security.SecureRandom;  

import java.security.spec.AlgorithmParameterSpec;  

import javax.crypto.BadPaddingException;  

import javax.crypto.Cipher;  

import javax.crypto.IllegalBlockSizeException;  

import javax.crypto.KeyGenerator;  

import javax.crypto.NoSuchPaddingException;  

import javax.crypto.SecretKey;  

import javax.crypto.spec.IvParameterSpec;  

/** 

 * 通过AES算法对文本进行加密解密 

 * @author ShaoJiang 

 * 

 */  

public class AESUtil {  

    private static byte[] keyValue = new byte[] {       //用户密钥  

        22,25,-35,-45,25,98,-55,-45,10,35,-45,25,  

        26,-95,25,-65,-78,-99,85,45,-62,10,-0,11,  

        -35,48,-98,65,-32,14,-78,25,36,-56,-45,-45,  

        12,15,-35,-75,15,-14,62,-25,33,-45,55,68,-88  

    };  

    private static byte[] iv = new byte[] {             //算法参数  

        -12,35,-25,65,45,-87,95,-22,-15,45,55,-66,32,5-4,84,55  

    };  

    private static SecretKey key;                       //加密密钥  

    private static AlgorithmParameterSpec paramSpec;    //算法参数  

    private static Cipher ecipher;                      //加密算法  

    static{       

        KeyGenerator kgen;  

        try {  

            //为指定算法生成一个密钥生成器对象。  

            kgen = KeyGenerator.getInstance("AES");  

            //使用用户提供的随机源初始化此密钥生成器，使其具有确定的密钥长度。  

            kgen.init(128, new SecureRandom(keyValue));  

            //使用KeyGenerator生成（对称）密钥。  

            key = kgen.generateKey();  

            //使用iv中的字节作为IV来构造一个 算法参数。  

            paramSpec = new IvParameterSpec(iv);  

            //生成一个实现指定转换的 Cipher 对象  

            ecipher = Cipher.getInstance("AES/CBC/PKCS5Padding");         

        } catch (NoSuchAlgorithmException e) {  

            e.printStackTrace();  

        } catch (NoSuchPaddingException e) {  

            e.printStackTrace();  

        }  

    }  

    /** 

     * 加密，使用指定数据源生成密钥，使用用户数据作为算法参数进行AES加密 

     * @param msg 加密的数据 

     * @return 

     */  

    public static String encrypt(String msg) {  

        String str = "";  

        try {             

            //用密钥和一组算法参数初始化此 cipher  

            ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);  

            //加密并转换成16进制字符串  

            str = asHex(ecipher.doFinal(msg.getBytes()));  

        } catch (BadPaddingException e) {  

            e.printStackTrace();  

        } catch (InvalidKeyException e) {  

            e.printStackTrace();  

        } catch (InvalidAlgorithmParameterException e) {  

            e.printStackTrace();  

        } catch (IllegalBlockSizeException e) {  

            e.printStackTrace();  

        }  

        return str;  

    }  

    /** 

     * 解密，对生成的16进制的字符串进行解密 

     * @param value 解密的数据 

     * @return 

     */  

    public static String decrypt(String value) {  

        try {  

            ecipher.init(Cipher.DECRYPT_MODE, key, paramSpec);  

            return new String(ecipher.doFinal(asBin(value)));  

        } catch (BadPaddingException e) {  

            e.printStackTrace();  

        } catch (InvalidKeyException e) {  

            e.printStackTrace();  

        } catch (InvalidAlgorithmParameterException e) {  

            e.printStackTrace();  

        } catch (IllegalBlockSizeException e) {  

            e.printStackTrace();  

        }  

        return "";  

    }  

    /** 

     * 将字节数组转换成16进制字符串 

     * @param buf 

     * @return 

     */  

    private static String asHex(byte buf[]) {  

        StringBuffer strbuf = new StringBuffer(buf.length * 2);  

        int i;  

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

            if (((int) buf[i] & 0xff) < 0x10)//小于十前面补零  

                strbuf.append("0");  

            strbuf.append(Long.toString((int) buf[i] & 0xff, 16));  

        }  

        return strbuf.toString();  

    }  

    /** 

     * 将16进制字符串转换成字节数组 

     * @param src 

     * @return 

     */  

    private static byte[] asBin(String src) {  

        if (src.length() < 1)  

            return null;  

        byte[] encrypted = new byte[src.length() / 2];  

        for (int i = 0; i < src.length() / 2; i++) {  

            int high = Integer.parseInt(src.substring(i * 2, i * 2 + 1), 16);//取高位字节  

            int low = Integer.parseInt(src.substring(i * 2 + 1, i * 2 + 2), 16);//取低位字节  

            encrypted[i] = (byte) (high * 16 + low);  

        }  

        return encrypted;  

    }  

    public static void main(String args[]){

    System.out.println(encrypt("念数成金"));

    System.out.println(decrypt("914a643420185282b9e35c7a3eb848af"));

    }

}

package qeeka.test.qeeka.test;

/**

 * reference apache commons <a

 * href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>

 * 

 * @author Aub

 * 

 */

public class Hex {

 /**

  * 用于建立十六进制字符的输出的小写字符数组

  */

 private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5',

   '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

 /**

  * 用于建立十六进制字符的输出的大写字符数组

  */

 private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5',

   '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

 /**

  * 将字节数组转换为十六进制字符数组

  * 

  * @param data

  *            byte[]

  * @return 十六进制char[]

  */

 public static char[] encodeHex(byte[] data) {

  return encodeHex(data, true);

 }

 /**

  * 将字节数组转换为十六进制字符数组

  * 

  * @param data

  *            byte[]

  * @param toLowerCase

  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式

  * @return 十六进制char[]

  */

 public static char[] encodeHex(byte[] data, boolean toLowerCase) {

  return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);

 }

 /**

  * 将字节数组转换为十六进制字符数组

  * 

  * @param data

  *            byte[]

  * @param toDigits

  *            用于控制输出的char[]

  * @return 十六进制char[]

  */

 protected static char[] encodeHex(byte[] data, char[] toDigits) {

  int l = data.length;

  char[] out = new char[l << 1];

  // two characters form the hex value.

  for (int i = 0, j = 0; i < l; i++) {

   out[j++] = toDigits[(0xF0 & data[i]) >>> 4];

   out[j++] = toDigits[0x0F & data[i]];

  }

  return out;

 }

 /**

  * 将字节数组转换为十六进制字符串

  * 

  * @param data

  *            byte[]

  * @return 十六进制String

  */

 public static String encodeHexStr(byte[] data) {

  return encodeHexStr(data, true);

 }

 /**

  * 将字节数组转换为十六进制字符串

  * 

  * @param data

  *            byte[]

  * @param toLowerCase

  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式

  * @return 十六进制String

  */

 public static String encodeHexStr(byte[] data, boolean toLowerCase) {

  return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);

 }

 /**

  * 将字节数组转换为十六进制字符串

  * 

  * @param data

  *            byte[]

  * @param toDigits

  *            用于控制输出的char[]

  * @return 十六进制String

  */

 protected static String encodeHexStr(byte[] data, char[] toDigits) {

  return new String(encodeHex(data, toDigits));

 }

 /**

  * 将十六进制字符数组转换为字节数组

  * 

  * @param data

  *            十六进制char[]

  * @return byte[]

  * @throws RuntimeException

  *             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常

  */

 public static byte[] decodeHex(char[] data) {

  int len = data.length;

  if ((len & 0x01) != 0) {

   throw new RuntimeException("Odd number of characters.");

  }

  byte[] out = new byte[len >> 1];

  // two characters form the hex value.

  for (int i = 0, j = 0; j < len; i++) {

   int f = toDigit(data[j], j) << 4;

   j++;

   f = f | toDigit(data[j], j);

   j++;

   out[i] = (byte) (f & 0xFF);

  }

  return out;

 }

 /**

  * 将十六进制字符转换成一个整数

  * 

  * @param ch

  *            十六进制char

  * @param index

  *            十六进制字符在字符数组中的位置

  * @return 一个整数

  * @throws RuntimeException

  *             当ch不是一个合法的十六进制字符时，抛出运行时异常

  */

 protected static int toDigit(char ch, int index) {

  int digit = Character.digit(ch, 16);

  if (digit == -1) {

   throw new RuntimeException("Illegal hexadecimal character " + ch

     + " at index " + index);

  }

  return digit;

 }

 public static void main(String[] args) {

  String srcStr = "待转换字符串";

  String encodeStr = encodeHexStr(srcStr.getBytes());

  String decodeStr = new String(decodeHex(encodeStr.toCharArray()));

  System.out.println("转换前：" + srcStr);

  System.out.println("转换后：" + encodeStr);

  System.out.println("还原后：" + decodeStr);

 }

}