JAVA加密C++解密简单方法

    java加密C++解密：【key可以随机生成】需要KEY需要一样（如果需要更为复杂的加密可以在加密器初始化是传入一个盐值，具体实现方法可以网上搜很多），java加密的填充方式 和C++解密填充方式要一样，其中加密解密返回的都是字节数组，将字节数组转换为字符串的方法：base64转或者用16进制的方式转换，加密后的字节数组不能直接new String（“”，字符集）这样是乱码。同一种语言中转换是很方便和简单的 但是java与c++的base64转换存在差别：具体差别找度娘吧！

。当时用的是16进制转换方式，但同样存在C++中需要写一个对应的逆转16进制字符串到byte[] 形式进行解密（这个应该可以实现吧。以下方法中有java的16进制字符串转byte[]经过测试是可以的，但是C++或许会有些要注意的地方，本人学JAVA的 不懂C++），最后选择了一个最简单的方法就是将加密得到的字节数组遍历出来组成一个字符串，C++通过简单处理这个字符串得到byte[]形式。就可以解密了。还有就是字符集环境C++与java不同：这里java端最好用GBK，C++解密后不是乱码 。这里用了取巧的方法 哈哈

  这个前辈的博客中讲了文件方式的加解密非常详细：http://blog.sina.com.cn/s/blog_48d4cf2d0101eqdf.html

package com.company.item.desc;

// DES：
//Java加密代码：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

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

/**
 *  java加密匹配C++解密类   
 * @author
 * @Date:2015年11月16日
 */
public class DESofJC {
    private static BASE64Encoder encoder = new BASE64Encoder();
    private static BASE64Decoder decoder = new BASE64Decoder();
    // 全局数组
    private final static String[] strDigits = { "0", "1", "2", "3", "4", "5",
        "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };

    // 测试方法
    public static void main(String[] args) throws Exception {
    String ss = DESofJC.desEncrypt("java加密数据");
    System.out.println(ss.toString());
    }

    /**
     * java端加密方法
     *
     * @author zt
     * @Date 2015年11月16日
     * @param source
     * @param rawKeyData
     * @return
     * @throws GeneralSecurityException
     */
    public static byte[] desEncrypt(byte[] source, byte rawKeyData[])
        throws GeneralSecurityException {
    // 处理密钥
    SecretKeySpec key = new SecretKeySpec(rawKeyData, "DES");
    // 加密器定义
    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    // 初始化加密器
    cipher.init(Cipher.ENCRYPT_MODE, key);
    return cipher.doFinal(source);
    }

    /**
     * java端加密返回字符串
     *
     * @Date 2015年11月16日
     * @param str
     * @return
     * @throws Exception
     */
    // java加密方法，C++可解密,字符集设为GBk c++解密正常
    public static String desEncrypt(String str) throws Exception {
    // java加密key C++对应的解密key相同，字符集设为GBK与C++字符集编码环境匹配
    byte rawKeyData[] = "hellodes".getBytes("GBK");
    // 获取字符串字节数组，字符集设为GBK
    byte[] source = str.getBytes("GBK");
    // 传入key进行加密操作
    byte[] enc = desEncrypt(source, rawKeyData);
    StringBuilder sb = new StringBuilder();
    // 对字节数组进行处理转换为C++端方便处理字符串
    for (int i = 0; i < enc.length; i++) {
        sb.append(enc[i]).append(",");
    }
    return sb.toString().substring(0, sb.length() - 1).trim();
    }

    // 转换字节数组为16进制字串
    private static String byteToString(byte[] bByte) {
    StringBuffer sBuffer = new StringBuffer();
    for (int i = 0; i < bByte.length; i++) {
        sBuffer.append(byteToArrayString(bByte[i]));
    }
    return sBuffer.toString();
    }

    // 返回形式为数字跟字符串
    private static String byteToArrayString(byte bByte) {
    int iRet = bByte;
    // System.out.println("iRet="+iRet);
    if (iRet < 0) {
        iRet += 256;
    }
    int iD1 = iRet / 16;
    int iD2 = iRet % 16;
    return strDigits[iD1] + strDigits[iD2];
    }

    // 返回形式只为数字
    private static String byteToNum(byte bByte) {
    int iRet = bByte;
    System.out.println("iRet1=" + iRet);
    if (iRet < 0) {
        iRet += 256;
    }
    return String.valueOf(iRet);
    }

    /**
     * 字节数组转16进制字符串
     *
     * @author
     * @Date 2015年11月16日
     * @param src
     * @return
     */
    public static String bytesToHexString(byte[] src) {
    StringBuilder stringBuilder = new StringBuilder("");
    if (src == null || src.length <= 0) {
        return null;
    }
    for (int i = 0; i < src.length; i++) {
        int v = src[i] & 0xFF;
        String hv = Integer.toHexString(v);
        if (hv.length() < 2) {
        stringBuilder.append(0);
        }
        stringBuilder.append(hv);
    }
    return stringBuilder.toString();
    }

    /**
     * 16进制字符串转为byte[]
     *
     * @param hexString
     *            the hex string
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hexString) {
    if (hexString == null || hexString.equals("")) {
        return null;
    }
    hexString = hexString.toUpperCase();
    int length = hexString.length() / 2;
    char[] hexChars = hexString.toCharArray();
    byte[] d = new byte[length];
    for (int i = 0; i < length; i++) {
        int pos = i * 2;
        d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
    }
    return d;
    }

    private static byte charToByte(char c) {
    return (byte) "0123456789ABCDEF".indexOf(c);
    }

}