秘钥加密解密

做项目时，需要解密接口请求回来的被加密的数据，需要根据公钥进行解密

package com._21cn.points.common.utils.encrypt.XXtea;

import java.security.NoSuchAlgorithmException;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.annotation.adapters.HexBinaryAdapter;


// Referenced classes of package com._21cn.open.common.cipher:
//            ByteFormat, StringUtil

public class MACTool
{

    public MACTool()
    {
    }

    public static byte[] initHmacMD5Key()
        throws NoSuchAlgorithmException
    {
        KeyGenerator generator = KeyGenerator.getInstance("HmacMD5");
        SecretKey secretKey = generator.generateKey();
        byte key[] = secretKey.getEncoded();
        return key;
    }

    public static String encodeHmacMD5(byte data[], byte key[])
        throws Exception
    {
        SecretKey secretKey = new SecretKeySpec(key, "HmacMD5");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        byte digest[] = mac.doFinal(data);
        return (new HexBinaryAdapter()).marshal(digest);
    }

    public static byte[] initHmacSHAKey()
        throws NoSuchAlgorithmException
    {
        KeyGenerator generator = KeyGenerator.getInstance("HmacSHA1");
        SecretKey secretKey = generator.generateKey();
        byte key[] = secretKey.getEncoded();
        return key;
    }

    public static String encodeHmacSHA1(byte data[], byte key[])
        throws Exception
    {
        SecretKey secretKey = new SecretKeySpec(key, "HmacSHA1");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        byte digest[] = mac.doFinal(data);
        return (new HexBinaryAdapter()).marshal(digest);
    }

    public static byte[] initHmacSHA256Key()
        throws NoSuchAlgorithmException
    {
        KeyGenerator generator = KeyGenerator.getInstance("HmacSHA256");
        SecretKey secretKey = generator.generateKey();
        byte key[] = secretKey.getEncoded();
        return key;
    }

    public static String encodeHmacSHA256(byte data[], byte key[])
        throws Exception
    {
        SecretKey secretKey = new SecretKeySpec(key, "HmacSHA256");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        byte digest[] = mac.doFinal(data);
        return (new HexBinaryAdapter()).marshal(digest);
    }

    public static byte[] initHmacSHA384Key()
        throws NoSuchAlgorithmException
    {
        KeyGenerator generator = KeyGenerator.getInstance("HmacSHA384");
        SecretKey secretKey = generator.generateKey();
        byte key[] = secretKey.getEncoded();
        return key;
    }

    public static String encodeHmacSHA384(byte data[], byte key[])
        throws Exception
    {
        SecretKey secretKey = new SecretKeySpec(key, "HmacSHA384");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        byte digest[] = mac.doFinal(data);
        return (new HexBinaryAdapter()).marshal(digest);
    }

    public static byte[] initHmacSHA512Key()
        throws NoSuchAlgorithmException
    {
        KeyGenerator generator = KeyGenerator.getInstance("HmacSHA512");
        SecretKey secretKey = generator.generateKey();
        byte key[] = secretKey.getEncoded();
        return key;
    }

    public static String encodeHmacSHA512(byte data[], byte key[])
        throws Exception
    {
        SecretKey secretKey = new SecretKeySpec(key, "HmacSHA512");
        Mac mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
        byte digest[] = mac.doFinal(data);
        return (new HexBinaryAdapter()).marshal(digest);
    }
}

package com._21cn.points.common.utils.encrypt.XXtea;

import com._21cn.points.util.ByteFormat;

public class XXTea
{

    public XXTea()
    {
    }

    public static String encrypt(String plain, String charset, String hexKey)
        throws Exception
    {
        if (plain == null || charset == null || hexKey == null)
            return null;
        else
            return ByteFormat.toHex(encrypt(plain.getBytes(charset), ByteFormat.hexToBytes(hexKey)));
    }

    public static String decrypt(String cipherHex, String charset, String hexKey)
        throws Exception
    {
        if (cipherHex == null || charset == null || hexKey == null)
            return null;
        else
            return new String(decrypt(ByteFormat.hexToBytes(cipherHex), ByteFormat.hexToBytes(hexKey)), charset);
    }

    public static byte[] encrypt(byte plainData[], byte key[])
    {
        if (plainData == null || plainData.length == 0 || key == null)
            return null;
        else
            return toByteArray(encrypt(toIntArray(plainData, true), toIntArray(key, false)), false);
    }

    public static byte[] decrypt(byte cipherData[], byte key[])
    {
        if (cipherData == null || cipherData.length == 0 || key == null)
            return null;
        else
            return toByteArray(decrypt(toIntArray(cipherData, false), toIntArray(key, false)), true);
    }

    private static int[] encrypt(int v[], int k[])
    {
        int n = v.length - 1;
        if (n < 1)
            return v;
        if (k.length < 4)
        {
            int key[] = new int[4];
            System.arraycopy(k, 0, key, 0, k.length);
            k = key;
        }
        int z = v[n];
        int y = v[0];
        int delta = 0x9e3779b9;
        int sum = 0;
        for (int q = 6 + 52 / (n + 1); q-- > 0;)
        {
            sum += delta;
            int e = sum >>> 2 & 3;
            int p;
            for (p = 0; p < n; p++)
            {
                y = v[p + 1];
                z = v[p] += (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            }

            y = v[0];
            z = v[n] += (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
        }

        return v;
    }

    public static String encode(String secrectText , String secrectKey){
        String params = null;
        try {
            if (secrectText == null || secrectText.trim() == "") {
            } else {
                params = XXTea.encrypt(secrectText, "UTF-8", ByteFormat.toHex(secrectKey.getBytes()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return params;
    }

    private static int[] decrypt(int v[], int k[])
    {
        System.out.println("-------Start--------");
    for(int i=0;i<v.length;i++){
        System.out.print(v[i]);
        System.out.print(" ");
    }
    System.out.println();
    for(int i=0;i<k.length;i++){
        System.out.print(k[i]);
        System.out.print(" ");
    }
        
    System.out.println("------End---------");
        
        
        int n = v.length - 1;
        if (n < 1)
            return v;
        if (k.length < 4)
        {
            int key[] = new int[4];
            System.arraycopy(k, 0, key, 0, k.length);
            k = key;
        }
        int z = v[n];
        int y = v[0];
        int delta = 0x9e3779b9;
        int q = 6 + 52 / (n + 1);
        for (int sum = q * delta; sum != 0; sum -= delta)
        {
            int e = sum >>> 2 & 3;
            int p;
            for (p = n; p > 0; p--)
            {
                z = v[p - 1];
                y = v[p] -= (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            }

            z = v[n];
            y = v[0] -= (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
        }

        return v;
    }

    private static int[] toIntArray(byte data[], boolean includeLength)
    {
        int n = (data.length & 3) != 0 ? (data.length >>> 2) + 1 : data.length >>> 2;
        int result[];
        if (includeLength)
        {
            result = new int[n + 1];
            result[n] = data.length;
        } else
        {
            result = new int[n];
        }
        n = data.length;
        for (int i = 0; i < n; i++)
            result[i >>> 2] |= (0xff & data[i]) << ((i & 3) << 3);

        return result;
    }

    private static byte[] toByteArray(int data[], boolean includeLength)
    {
        int n = data.length << 2;
        if (includeLength)
        {
            int m = data[data.length - 1];
            if (m > n || m <= 0)
                return null;
            n = m;
        }
        byte result[] = new byte[n];
        for (int i = 0; i < n; i++)
            result[i] = (byte)(data[i >>> 2] >>> ((i & 3) << 3) & 0xff);

        return result;
    }
}

package com._21cn.points.util;


public class ByteFormat
{

    private static final char HEX[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
        'A', 'B', 'C', 'D', 'E', 'F'
    };
    private static final int ROW_BYTES = 16;
    private static final int ROW_QTR1 = 3;
    private static final int ROW_HALF = 7;
    private static final int ROW_QTR2 = 11;

    public ByteFormat()
    {
    }

    public static final String bytesToHexString(byte bArray[])
    {
        StringBuffer sb = new StringBuffer(bArray.length);
        for (int i = 0; i < bArray.length; i++)
        {
            String sTemp = Integer.toHexString(0xff & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }

        return sb.toString();
    }

    public static String toHex(byte buf[])
    {
        if (buf == null || buf.length == 0)
            return "";
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < buf.length; i++)
            out.append(HEX[buf[i] >> 4 & 0xf]).append(HEX[buf[i] & 0xf]);

        return out.toString();
    }

    public static byte[] hexToBytes(String str)
    {
        if (str == null)
            return null;
        char hex[] = str.toCharArray();
        int length = hex.length / 2;
        byte raw[] = new byte[length];
        for (int i = 0; i < length; i++)
        {
            int high = Character.digit(hex[i * 2], 16);
            int low = Character.digit(hex[i * 2 + 1], 16);
            int value = high << 4 | low;
            if (value > 127)
                value -= 256;
            raw[i] = (byte)value;
        }

        return raw;
    }

    public static String dumpHex(byte buf[])
    {
        if (buf == null)
            return "";
        else
            return dumpHex(buf, 0, buf.length);
    }

    public static String dumpHex(byte buf[], int offset, int numBytes)
    {
        if (buf == null || buf.length == 0)
            return "";
        if (offset >= buf.length)
            offset = buf.length - 1;
        if (numBytes > buf.length - offset)
            numBytes = buf.length - offset;
        StringBuffer out = new StringBuffer();
        byte save_buf[] = new byte[18];
        char hex_buf[] = new char[4];
        char idx_buf[] = new char[8];
        int rows = numBytes >> 4;
        int residue = numBytes & 0xf;
        int i;
        for (i = 0; i < rows; i++)
        {
            int hexVal = i * 16;
            idx_buf[0] = HEX[hexVal >> 12 & 0xf];
            idx_buf[1] = HEX[hexVal >> 8 & 0xf];
            idx_buf[2] = HEX[hexVal >> 4 & 0xf];
            idx_buf[3] = HEX[hexVal & 0xf];
            String idxStr = new String(idx_buf, 0, 4);
            out.append((new StringBuilder(String.valueOf(idxStr))).append(": ").toString());
            int j;
            for (j = 0; j < 16; j++)
            {
                save_buf[j] = buf[offset + i * 16 + j];
                hex_buf[0] = HEX[save_buf[j] >> 4 & 0xf];
                hex_buf[1] = HEX[save_buf[j] & 0xf];
                out.append(hex_buf[0]);
                out.append(hex_buf[1]);
                out.append(' ');
                if (j == 3 || j == 7 || j == 11)
                    out.append(' ');
                if (save_buf[j] < 32 || save_buf[j] > 126)
                    save_buf[j] = 46;
            }

            String saveStr = new String(save_buf, 0, j);
            out.append((new StringBuilder(" ; ")).append(saveStr).append("
").toString());
        }

        if (residue > 0)
        {
            int hexVal = i * 16;
            idx_buf[0] = HEX[hexVal >> 12 & 0xf];
            idx_buf[1] = HEX[hexVal >> 8 & 0xf];
            idx_buf[2] = HEX[hexVal >> 4 & 0xf];
            idx_buf[3] = HEX[hexVal & 0xf];
            String idxStr = new String(idx_buf, 0, 4);
            out.append((new StringBuilder(String.valueOf(idxStr))).append(": ").toString());
            int j;
            for (j = 0; j < residue; j++)
            {
                save_buf[j] = buf[offset + i * 16 + j];
                hex_buf[0] = HEX[save_buf[j] >> 4 & 0xf];
                hex_buf[1] = HEX[save_buf[j] & 0xf];
                out.append(hex_buf[0]);
                out.append(hex_buf[1]);
                out.append(' ');
                if (j == 3 || j == 7 || j == 11)
                    out.append(' ');
                if (save_buf[j] < 32 || save_buf[j] > 126)
                    save_buf[j] = 46;
            }

            for (; j < 16; j++)
            {
                save_buf[j] = 32;
                out.append("   ");
                if (j == 3 || j == 7 || j == 11)
                    out.append(" ");
            }

            String saveStr = new String(save_buf, 0, j);
            out.append((new StringBuilder(" ; ")).append(saveStr).append("
").toString());
        }
        return out.toString();
    }

    public static void main(String args[])
    {
        byte data[] = new byte[0x10000];
        for (int i = 0; i < data.length; i++)
            data[i] = (byte)i;

    }

}

package com._21cn.points.controller;

import com._21cn.points.common.utils.encrypt.XXtea.MACTool;
import com._21cn.points.common.utils.encrypt.XXtea.XXTea;
import com._21cn.points.util.ByteFormat;

public class Test {
    public static void main(String[] args) {
        String mobile="18922718369";
        String userId="100230";
        String tmpAccessToken="a3431aba6914fd671dc9bdaca7b1c4da";
        String appId="1116416306";
        String timeStamp="1510829685188";
        String version="V1.0.0";
        String appSecret = "UYB5elTW2ci897OtELMN1245XR6sxLkT"; // key，密钥

        String sign = "";
        String params = "";
        try {
            params = XXTea.encrypt("mobile=" + mobile + "&userId=" + userId + "&tmpAccessToken=" + tmpAccessToken, "UTF-8", ByteFormat.toHex(appSecret.getBytes()));
        } catch (Exception e) {
        }
        System.out.println("Params:"+params);
        
        System.out.println("HexSecret:"+ByteFormat.toHex(appSecret.getBytes()));
        try {
            String u =  XXTea.decrypt(params, "UTF-8", ByteFormat.toHex(appSecret.getBytes()));
            System.out.println("--------------" + u);
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        try {
            sign = MACTool.encodeHmacSHA256((appId+timeStamp+version+params).getBytes(),appSecret.getBytes());
            System.out.println(".......................    " + appId+timeStamp+version+params);
            System.out.println("=====" + sign);
            System.out.println("--------" + sign.length());
        } catch (Exception e) {
        }
        System.out.println("mobile=" + mobile + "
 userId=" + userId + "
 tmpAccessToken=" + tmpAccessToken);
        System.out.println("appId=" + appId+ "
 timeStamp="+timeStamp+ "
 version="+version );
        System.out.println("params=" + params + "
 sign=" + sign );
        
    }

}