Java加密

MD5加密：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * MD5加密，不可逆
 * 
 * @author yyw
 * 
 */
public class MD5Encrypt {
    /**
     * 对指定的字符串进行md5加密
     * 
     * @param srcString
     *            指定的字符串
     * @return 加密后的字符串
     */
    public static String md5Encrypt(String srcString) {
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            byte[] result = md.digest(srcString.getBytes());
            StringBuilder sBuilder = new StringBuilder();
            for (byte b : result) {
                int i = b & 0xff;// 加盐
                String mString = Integer.toHexString(i);
                if (mString.length() == 1) {
                    sBuilder.append("0");
                }
                sBuilder.append(mString);
            }
            return sBuilder.toString();
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return srcString;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.err.println(md5Encrypt("123456"));

    }

}

RSA加密：

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * 用RSA进行加密解密的工具类
 * 
 * @author yyw
 * 
 */
public class RSAHepler {
    /**
     * 包含私钥的字符串，可以获取私钥
     */
    private static final String PRIVATE_KEY_STRING = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJ9JhbdNwIWsH8Ms4ENyYis5b9ma931Bv1ejKIAkNcqAbY2w4jwJ0JWW2vTc3B1sr2pC4ABbFKS6ARhNgmrr5gpNYXAxIwL/b/N2im+KpqI5GE5naiItgr049AL1BFIgTdG2b+N8q5TVHXz+bE9hIEzu6Xss2XOQ6uyHb2Gxd6r7AgMBAAECgYA6kouUCwhHXzLSz1asFoyYvmctynlFWv7kV//VlvscursORkP6tdU4nJ9pOSnLvCKI3YyHNPbTV/59FEtny9Tr0F98DTql+J/LbH7Zh8QY/yJTYwmTDYljxYxsVSn0E8jCO5VKs2n2ZwVDubwA32yqu1abkDmZHC8lHu2SKCONUQJBAO4QXsSgLz7RzRkACJL2+9JeRo5eqsm0yvr6hmdvSweQvBYYUpZnDq/Cz20TNruKNG3fxUJbuT/jGys68Mk4mxMCQQCrScFJxFNUdVuNCFCGiRdyeN1U0pc2+KsG9O47hzngawMeIdqX4qA0NV+Nt8gp4KUr93C7LNz1vuY7uTRZdQV5AkA7SyJ/cLIzwEeIGYUJLbDs5YRHQ3bgREJmHm3JZ2PVn4vpKOexBDwZNLk7HpT8QuDqGNjlvTi3m9YRf12nkIy3AkEAnDyAI8sBvy30veVxneV6D54TNIWKDEgxp/zNOFsV/Y9enqN+gb/jJPvyFpAl8ZzIzBu9Jd28BiOEWcGK8HX+8QJBAO0jIFf80YkE8D/kJAUZyv0d6zn0HDx4P+mdmUR+sbf1BYtMKrTGB5O+hN5jrzhvhyb3PES4WxVGSChJDHDpxko=";
    /**
     * 包含公钥的字符串，可以获取公钥
     */
    private static final String PUBLIC_LEY_STRING = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCfSYW3TcCFrB/DLOBDcmIrOW/Zmvd9Qb9XoyiAJDXKgG2NsOI8CdCVltr03NwdbK9qQuAAWxSkugEYTYJq6+YKTWFwMSMC/2/zdopviqaiORhOZ2oiLYK9OPQC9QRSIE3Rtm/jfKuU1R18/mxPYSBM7ul7LNlzkOrsh29hsXeq+wIDAQAB";

    /** 加密算法 **/
    private static final String KEY_ALGORITHM = "RSA";

    /**
     * 获取公钥
     * 
     * @param key
     *            包含公钥的字符串
     * @return 公钥
     * @throws Exception
     */
    public static RSAPublicKey getPublicKey(String key) throws Exception {
        byte[] keyBytes = (new BASE64Decoder()).decodeBuffer(key);
        X509EncodedKeySpec xKeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        RSAPublicKey publicKey = (RSAPublicKey) keyFactory
                .generatePublic(xKeySpec);
        return publicKey;
    }

    /**
     * 获取私钥
     * 
     * @param key
     *            包含私钥的字符串
     * @return 私钥
     * @throws Exception
     */
    public static RSAPrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes = (new BASE64Decoder()).decodeBuffer(key);
        PKCS8EncodedKeySpec xKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        RSAPrivateKey privateKey = (RSAPrivateKey) keyFactory
                .generatePrivate(xKeySpec);
        return privateKey;
    }

    /**
     * 对Key进行编码
     * 
     * @param key
     *            要编码的Key
     * @return 编码后的字符串
     */
    public static String getKeyString(Key key) {
        byte[] encoded = key.getEncoded();
        return (new BASE64Encoder()).encode(encoded);
    }

    /**
     * 加密
     * 
     * @param string
     *            明文
     * @return 密文
     */
    public static String encrypt(String string) {
        try {
            // 获取解密加密的工具
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            RSAPublicKey publicKey = getPublicKey(PUBLIC_LEY_STRING);
            // 设置为加密模式，并放入公钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 获取要加密的字节长度
            final int size = string.getBytes().length;
            final byte[] input = string.getBytes();
            // 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为117
            // byte,加密后为128个byte;
            // 因此共有2个加密块，第一个117 byte第二个为11个byte
            
            final int blockSize = 117;
            // 获得加密块加密后块大小(都是128)
            final int resultSize = cipher.getOutputSize(size);
            System.err.println(resultSize);
            // 最后一个加密块的大小
            final int leavedSize = size % blockSize;
            // 加密块的数量
            final int blocksSize = leavedSize == 0 ? size / blockSize : size
                    / blockSize + 1;
            byte[] encrypts = new byte[resultSize * blocksSize];
            for (int i = 0; i < blocksSize; i++) {
                if (i == blocksSize - 1 && leavedSize > 0) {// 最后一次是不满一个代码块的时候执行
                    cipher.doFinal(input, i * blockSize, leavedSize, encrypts,
                            resultSize * i);
                } else {
                    cipher.doFinal(input, i * blockSize, blockSize, encrypts,
                            resultSize * i);
                }
            }
            // 对字节数组进行加密，返回加密后的字节数组
            // encrypts = cipher.doFinal(string.getBytes());
            // 对加密后的字节数组进行64位的编码，生成字符串
            String encrypt = new BASE64Encoder().encode(encrypts);
            System.out.println("加密之后:" + encrypt);
            return encrypt;
        } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 对文件进行加密
     * 
     * @param file
     *            要加密的文件
     * @param encryptFile
     *            加密后的文件
     * @return
     */
    public static boolean encrypt(File file, File encryptFile) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(encryptFile);
            // 获取解密加密的工具
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            RSAPublicKey publicKey = getPublicKey(PUBLIC_LEY_STRING);
            // 设置为加密模式，并放入公钥
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 获得加密块大小，如:加密前数据为128个byte，而key_size=1024 加密块大小为127
            // byte,加密后为128个byte;
            // 因此共有2个加密块，第一个127 byte第二个为1个byte
            final int blockSize = publicKey.getModulus().bitLength() / 8 - 11;
            System.err.println(blockSize);
            int len = -1;
            byte[] beffer = new byte[blockSize];
            while ((len = fis.read(beffer)) > 0) {
                byte[] doFinal = cipher.doFinal(beffer, 0, len);
                fos.write(doFinal);
            }
            // 对字节数组进行加密，返回加密后的字节数组
            // encrypts = cipher.doFinal(string.getBytes());
            // 对加密后的字节数组进行64位的编码，生成字符串
            return true;
        } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    /**
     * 对文件进行加密
     * 
     * @param file
     *            解密的文件
     * @param encryptFile
     *            加密后的文件
     * @return
     */
    public static boolean dencrypt(File encryptFile, File file) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(encryptFile);
            fos = new FileOutputStream(file);
            // 获取解密加密的工具
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            RSAPrivateKey privateKey = getPrivateKey(PRIVATE_KEY_STRING);
            // 设置为解密模式，并放入公钥
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // 可以解码的最大长度
            final int blockSize = privateKey.getModulus().bitLength() / 8;
            System.err.println(blockSize);
            int len = -1;
            byte[] buffer = new byte[blockSize];
            while ((len = fis.read(buffer)) > 0) {
                byte[] doFinal = cipher.doFinal(buffer, 0, len);
                fos.write(doFinal);
            }
            // 对字节数组进行加密，返回加密后的字节数组
            // encrypts = cipher.doFinal(string.getBytes());
            // 对加密后的字节数组进行64位的编码，生成字符串
            return true;
        } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    /**
     * 解密
     * 
     * @param string
     *            密文
     * @return 明文
     */
    public static String dencrypt(String string) {
        try {
            // 获取解密加密的工具
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
            RSAPrivateKey privateKey = getPrivateKey(PRIVATE_KEY_STRING);
            // 设置为解密模式，并放入密钥
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            // 对字符串进行解码
            byte[] decoders = new BASE64Decoder().decodeBuffer(string);
            // 对字节数组进行解密
            ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
            // 可以解码的最大长度
            final int blockSize = privateKey.getModulus().bitLength() / 8;
            // 需要解码的总长度
            final int size = decoders.length;
            // 最后一次是否有不满一次解码的最大长度
            final int leavedSize = size % blockSize;
            // 需要解码的次数
            final int blocksSize = leavedSize == 0 ? size / blockSize : size
                    / blockSize + 1;
            for (int j = 0; j < blocksSize; j++) {
                if (j == blocksSize - 1 && leavedSize > 0) {// 最后一次是不满一个代码块的时候执行
                    baos.write(cipher.doFinal(decoders, j * blockSize,
                            leavedSize));
                } else {
                    baos.write(cipher.doFinal(decoders, j * blockSize,
                            blockSize));
                }
            }
            String result = baos.toString();
            return result;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 生成公钥和密钥并保存到文件当中
     * 
     * @param publicKeyFileName
     *            公钥文件名
     * @param privateKeyFileName
     *            密钥文件名
     */
    public static void getKeyPair(String publicKeyFileName,
            String privateKeyFileName) {
        try {
            /** 为RSA算法创建一个KeyPairGenerator对象 */
            KeyPairGenerator keyPairGenerator = KeyPairGenerator
                    .getInstance(KEY_ALGORITHM);
            /** RSA算法要求有一个可信任的随机数源 */
            SecureRandom random = new SecureRandom();
            /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
            keyPairGenerator.initialize(1024, random);// 秘钥的位数
            /** 生成密匙对 */
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            /** 得到私钥 */
            PrivateKey privateKey = keyPair.getPrivate();
            /** 得到公钥 */
            PublicKey publicKey = keyPair.getPublic();
            /** 用对象流将生成的密钥写入文件 */
            ObjectOutputStream oos1 = new ObjectOutputStream(
                    new FileOutputStream(publicKeyFileName));
            ObjectOutputStream oos2 = new ObjectOutputStream(
                    new FileOutputStream(privateKeyFileName));
            oos1.writeObject(publicKey);
            oos2.writeObject(privateKey);
            /** 清空缓存，关闭文件输出流 */
            oos1.close();
            oos2.close();
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 生成公钥和密钥并打印出来
     */
    public static void getKeyPair() {
        try {
            /** 为RSA算法创建一个KeyPairGenerator对象 */
            KeyPairGenerator keyPairGenerator = KeyPairGenerator
                    .getInstance(KEY_ALGORITHM);
            /** RSA算法要求有一个可信任的随机数源 */
            SecureRandom random = new SecureRandom();
            /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
            keyPairGenerator.initialize(1024, random);// 秘钥的位数
            /** 生成密匙对 */
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            /** 得到私钥 */
            PrivateKey privateKey = keyPair.getPrivate();
            /** 得到公钥 */
            PublicKey publicKey = keyPair.getPublic();
            String publicKeyString = getKeyString(publicKey);
            String privateKeyString = getKeyString(privateKey);
            System.out.println("公钥：" + publicKeyString);
            System.out.println("密钥：" + privateKeyString);
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        getKeyPair();
        String src = encrypt("今天是周一；");
//      System.err.println(src);
        String dis = dencrypt(src);
        System.err.println(dis);
//      File file = new File("D:\\TYSubwayInspcetion.db");
//      File encryptfile = new File("D:\\encryptfile.db");
//      File decryptfile = new File("D:\\decryptfile.db");
//      encrypt(file, encryptfile);
//      dencrypt(encryptfile, decryptfile);
    
        
    }
}

CBC加密：

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class CBCEncrypt {
    private static final byte[] KEY_IV = { 11, 22, 33, 44, 55, 66, 77, 88 };
    private static final String DESEDE = "DESede";
    private static final String DESEDE_CIPHER = "DESede/CBC/PKCS5Padding";

    /**
     * 从Base64字符获取对应的Byte[]
     * 
     * @param s
     *            Base64字符串
     * */
    public static byte[] base64Decode(String s) throws IOException {
        if (s == null)
            return null;
        return new BASE64Decoder().decodeBuffer(s);
    }

    /**
     * 把指定的字节数据进行编码
     * 
     * @param date
     *            要编码的字节数据
     * */
    public static String base64Encode(byte[] date) throws IOException {
        if (date == null)
            return null;
        return new BASE64Encoder().encode(date);
    }

    /**
     * 对指定数据和指定的key进行加密
     * 
     * @param key
     *            加密的秘钥
     * @param data
     *            数据源
     * @return 加密后的数据源
     * @throws Exception
     */
    public static byte[] des3Encrypt(byte[] key, byte[] data) throws Exception {
        DESedeKeySpec keySpec = new DESedeKeySpec(key);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DESEDE);
        Key desKey = keyFactory.generateSecret(keySpec);
        Cipher cipher = Cipher.getInstance(DESEDE_CIPHER);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(KEY_IV);
        cipher.init(Cipher.ENCRYPT_MODE, desKey, ivParameterSpec);
        return cipher.doFinal(data);

    }

    /**
     * CBC解密
     * 
     * @param key
     *            密钥
     * @param keyiv
     *            IV
     * @param data
     *            Base64编码的密文
     * @return 明文
     * @throws Exception
     */
    public static byte[] des3Decrypt(byte[] key, byte[] data) throws Exception {
        //生成指定的秘钥
        DESedeKeySpec spec = new DESedeKeySpec(key);
        SecretKeyFactory keyfactory = SecretKeyFactory.getInstance(DESEDE);
        Key deskey = keyfactory.generateSecret(spec);
        //加密解密操作类
        Cipher cipher = Cipher.getInstance(DESEDE_CIPHER);
        //参数规范
        IvParameterSpec ips = new IvParameterSpec(KEY_IV);
        //初始化
        cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
        //解密
        return cipher.doFinal(data);
    }

    /**
     * key 秘钥的一部分字符串
     * 
     * @return 秘钥
     * @throws IOException
     */
    public static byte[] getKey(String key) throws IOException {
        int iKeyLength = 24;// key的长度为24
        String cryptionKey = "TongYanMetro" + key;
        if (cryptionKey.length() > iKeyLength) {
            cryptionKey.substring(0, iKeyLength - 1);
        }
        if (cryptionKey.length() < iKeyLength) {
            int iLength = iKeyLength - cryptionKey.length();
            for (int i = 0; i < iLength; i++) {
                cryptionKey += "0";
            }
        }
        byte[] pt1 = cryptionKey.getBytes("UTF-8");
        return pt1;
    }

    public static String encrypt(String key, String dataString)
            throws Exception {
        // 得到3-DES的密钥匙
        byte[] enKey = getKey(key);
        // 要进行3-DES加密的内容在进行/"UTF-16LE/"取字节
        byte[] src2 = dataString.getBytes("utf-8");
        // 进行3-DES加密后的内容的字节
        byte[] encryptedData = des3Encrypt(enKey,src2);
        // 进行3-DES加密后的内容进行BASE64编码
        String base64String = base64Encode(encryptedData);
        return base64String;

    }

    public static String decrypt(String key, String dataString)
            throws Exception {
        // 得到3-DES的密钥匙
        byte[] enKey = getKey(key);
        // 解码后的数据
        byte[] data = base64Decode(dataString);
        byte[] decryptData = des3Decrypt(enKey,data);
        return new String(decryptData,"UTF-8");

    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            String keyString = "zhangshan";
            String encryptString = encrypt(keyString, "点击付款");
            System.err.println(encryptString);
            System.err.println(decrypt(keyString, encryptString));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}