非对称加密java代码,对称加密 java

Java 加密解密的方法都有哪些

加密解密并非java才有的，所有编程语言都有加密和解密。

目前的加密解密主要可分为以下2大类：

对称秘钥加密：如DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法等。其主要特点是加密方和解密方都有同一个密码，加密方和解密方可以使用秘钥任意加密解密。

非对称密码加密：这种加密方式加密方仅有加密秘钥，对加密后的密文无法反向解密，解密方仅有解密秘钥，无法对明文进行加密。

另外还有一些摘要算法，比如MD5和HASH此类算法不可逆，但经常用来作为确认字段或者对一些重要匹配信息签名防止明文内容被修改。

相关问答

Q1: 用java把一个命令加密成10个字母（输入的命大于10个则减到10个，少的补足10个）

题主,你好

您提出的需求据我所知是无法实现的.

如果是对称加密, 则密文和原文长度有关联, 即原文长度越长,密文长度也越长.

如果是非对称加密, 即摘要算法,最低也会有32个字母, 且无法解密.

如不明,再追问.

Q2: 非对称加密算法 (RSA、DSA、ECC、DH)

非对称加密需要两个密钥：公钥(publickey) 和私钥 (privatekey)。公钥和私钥是一对，如果用公钥对数据加密，那么只能用对应的私钥解密。如果用私钥对数据加密，只能用对应的公钥进行解密。因为加密和解密用的是不同的密钥，所以称为非对称加密。

非对称加密算法的保密性好，它消除了最终用户交换密钥的需要。但是加解密速度要远远慢于对称加密，在某些极端情况下，甚至能比对称加密慢上1000倍。

算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，而使得加密解密速度没有对称加密解密的速度快。对称密码体制中只有一种密钥，并且是非公开的，如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全，而非对称密钥体制有两种密钥，其中一个是公开的，这样就可以不需要像对称密码那样传输对方的密钥了。这样安全性就大了很多。

RSA、Elgamal、背包算法、Rabin、D-H、ECC (椭圆曲线加密算法)。使用最广泛的是 RSA 算法，Elgamal 是另一种常用的非对称加密算法。

收信者是唯一能够解开加密信息的人，因此收信者手里的必须是私钥。发信者手里的是公钥，其它人知道公钥没有关系，因为其它人发来的信息对收信者没有意义。

客户端需要将认证标识传送给服务器，此认证标识 (可能是一个随机数) 其它客户端可以知道，因此需要用私钥加密，客户端保存的是私钥。服务器端保存的是公钥，其它服务器知道公钥没有关系，因为客户端不需要登录其它服务器。

数字签名是为了表明信息没有受到伪造，确实是信息拥有者发出来的，附在信息原文的后面。就像手写的签名一样，具有不可抵赖性和简洁性。

简洁性：对信息原文做哈希运算，得到消息摘要，信息越短加密的耗时越少。

不可抵赖性：信息拥有者要保证签名的唯一性，必须是唯一能够加密消息摘要的人，因此必须用私钥加密 (就像字迹他人无法学会一样)，得到签名。如果用公钥，那每个人都可以伪造签名了。

问题起源：对1和3，发信者怎么知道从网上获取的公钥就是真的？没有遭受中间人攻击？

这样就需要第三方机构来保证公钥的合法性，这个第三方机构就是 CA (Certificate Authority)，证书中心。

CA 用自己的私钥对信息原文所有者发布的公钥和相关信息进行加密，得出的内容就是数字证书。

信息原文的所有者以后发布信息时，除了带上自己的签名，还带上数字证书，就可以保证信息不被篡改了。信息的接收者先用 CA给的公钥解出信息所有者的公钥，这样可以保证信息所有者的公钥是真正的公钥，然后就能通过该公钥证明数字签名是否真实了。

RSA 是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。

A 要把信息发给 B 为例，确定角色：A 为加密者，B 为解密者。首先由 B 随机确定一个 KEY，称之为私钥，将这个 KEY 始终保存在机器 B 中而不发出来；然后，由这个 KEY 计算出另一个 KEY，称之为公钥。这个公钥的特性是几乎不可能通过它自身计算出生成它的私钥。接下来通过网络把这个公钥传给 A，A 收到公钥后，利用公钥对信息加密，并把密文通过网络发送到 B，最后 B 利用已知的私钥，就能对密文进行解码了。以上就是 RSA 算法的工作流程。

由于进行的都是大数计算，使得 RSA 最快的情况也比 DES 慢上好几倍，无论是软件还是硬件实现。速度一直是 RSA 的缺陷。一般来说只用于少量数据加密。RSA 的速度是对应同样安全级别的对称密码算法的1/1000左右。

比起 DES 和其它对称算法来说，RSA 要慢得多。实际上一般使用一种对称算法来加密信息，然后用 RSA 来加密比较短的公钥，然后将用 RSA 加密的公钥和用对称算法加密的消息发送给接收方。

这样一来对随机数的要求就更高了，尤其对产生对称密码的要求非常高，否则的话可以越过 RSA 来直接攻击对称密码。

和其它加密过程一样，对 RSA 来说分配公钥的过程是非常重要的。分配公钥的过程必须能够抵挡中间人攻击。假设 A 交给 B 一个公钥，并使 B 相信这是A 的公钥，并且 C 可以截下 A 和 B 之间的信息传递，那么 C 可以将自己的公钥传给 B，B 以为这是 A 的公钥。C 可以将所有 B 传递给 A 的消息截下来，将这个消息用自己的密钥解密，读这个消息，然后将这个消息再用 A 的公钥加密后传给 A。理论上 A 和 B 都不会发现 C 在偷听它们的消息，今天人们一般用数字认证来防止这样的攻击。

(1) 针对 RSA 最流行的攻击一般是基于大数因数分解。1999年，RSA-155 (512 bits) 被成功分解，花了五个月时间（约8000 MIPS 年）和224 CPU hours 在一台有3.2G 中央内存的 Cray C916计算机上完成。

RSA-158 表示如下：

2009年12月12日，编号为 RSA-768 (768 bits, 232 digits) 数也被成功分解。这一事件威胁了现通行的1024-bit 密钥的安全性，普遍认为用户应尽快升级到2048-bit 或以上。

RSA-768表示如下：

(2) 秀尔算法

量子计算里的秀尔算法能使穷举的效率大大的提高。由于 RSA 算法是基于大数分解 (无法抵抗穷举攻击)，因此在未来量子计算能对 RSA 算法构成较大的威胁。一个拥有 N 量子位的量子计算机，每次可进行2^N 次运算，理论上讲，密钥为1024位长的 RSA 算法，用一台512量子比特位的量子计算机在1秒内即可破解。

DSA (Digital Signature Algorithm) 是 Schnorr 和 ElGamal 签名算法的变种，被美国 NIST 作为 DSS (DigitalSignature Standard)。 DSA 是基于整数有限域离散对数难题的。

简单的说，这是一种更高级的验证方式，用作数字签名。不单单只有公钥、私钥，还有数字签名。私钥加密生成数字签名，公钥验证数据及签名，如果数据和签名不匹配则认为验证失败。数字签名的作用就是校验数据在传输过程中不被修改，数字签名，是单向加密的升级。

椭圆加密算法（ECC）是一种公钥加密算法，最初由 Koblitz 和 Miller 两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成 Abel 加法群上椭圆离散对数的计算困难性。公钥密码体制根据其所依据的难题一般分为三类：大整数分解问题类、离散对数问题类、椭圆曲线类。有时也把椭圆曲线类归为离散对数类。

ECC 的主要优势是在某些情况下它比其他的方法使用更小的密钥 (比如 RSA)，提供相当的或更高等级的安全。ECC 的另一个优势是可以定义群之间的双线性映射，基于 Weil 对或是 Tate 对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。

ECC 被广泛认为是在给定密钥长度的情况下，最强大的非对称算法，因此在对带宽要求十分紧的连接中会十分有用。

比特币钱包公钥的生成使用了椭圆曲线算法，通过椭圆曲线乘法可以从私钥计算得到公钥， 这是不可逆转的过程。

Java 中 Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey 均不支持 ECC 算法。

DH，全称为"Diffie-Hellman"，它是一种确保共享 KEY 安全穿越不安全网络的方法，也就是常说的密钥一致协议。由公开密钥密码体制的奠基人 Diffie 和 Hellman 所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。也就是由甲方产出一对密钥 (公钥、私钥)，乙方依照甲方公钥产生乙方密钥对 (公钥、私钥)。

以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥 (SecretKey) 对数据加密。这样，在互通了本地密钥 (SecretKey) 算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯。

具体例子可以移步到这篇文章： 非对称密码之DH密钥交换算法

参考：

Q3: Java中RSA的方式如何实现非对称加密的示例

代码如下，需要依赖一个jar包commons-codec-1.9.jar，用于Base64转换，请自行下载。

import org.apache.commons.codec.binary.Base64;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSAUtils {

    // 加密方式

    public static final String ALGORITHM = "RSA";

    // 签名算法

    private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";

    // 创建密钥对初始长度

    private static final int KEY_SIZE = 512;

    // 字符编码格式

    private static final String CHARSET = "UTF-8";

    // RSA最大加密明文大小

    private static final int MAX_ENCRYPT_BLOCK = 117;

    // RSA最大解密密文大小

    private static final int MAX_DECRYPT_BLOCK = 128;

    private KeyFactory keyFactory;

    public RSAUtils() throws NoSuchAlgorithmException {

        keyFactory = KeyFactory.getInstance(ALGORITHM);

    }

    /**

     * 私钥加密

     *

     * @param content    待加密字符串

     * @param privateKey 私钥

     * @return 加密后字符串（BASE64编码）

     */

    public String encryptByPrivateKey(String content, String privateKey) throws Exception {

        String result;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥解密

     *

     * @param content   已加密字符串（BASE64加密）

     * @param publicKey 公钥

     * @return

     */

    public String decryptByPublicKey(String content, String publicKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥加密

     *

     * @param content   待加密字符串

     * @param publicKey 公钥

     * @return 加密后字符串（BASE64编码）

     */

    public String encryptByPublicKey(String content, String publicKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher,

                    data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 私钥解密

     *

     * @param content    已加密字符串

     * @param privateKey 私钥

     * @return 解密后字符串

     */

    public String decryptByPrivateKey(String content, String privateKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws

            BadPaddingException, IllegalBlockSizeException {

        int dataLen = data.length;

        int offSet = 0;

        byte[] cache;

        int i = 0;

        // 对数据分段解密

        while (dataLen - offSet  0) {

            if (dataLen - offSet  MAX_DECRYPT_BLOCK) {

                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(data, offSet, dataLen - offSet);

            }

            out.write(cache, 0, cache.length);

            i++;

            offSet = i * MAX_DECRYPT_BLOCK;

        }

    }

    /**

     * 用私钥对信息生成数字签名

     *

     * @param data       已加密数据

     * @param privateKey 私钥(BASE64编码)

     * @return sign

     */

    public String sign(String data, String privateKey) throws Exception {

        String result = "";

        try {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initSign(privateK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = new Base64().encodeToString(signature.sign());

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 校验数字签名

     *

     * @param data      已加密数据

     * @param publicKey 公钥(BASE64编码)

     * @param sign      数字签名

     * @return

     * @throws Exception

     */

    public boolean verify(String data, String publicKey, String sign) throws Exception {

        boolean result;

        try {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey publicK = keyFactory.generatePublic(keySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initVerify(publicK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = signature.verify(new Base64().decode(sign));

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 将二进制转换成16进制

     *

     * @param data

     * @return

     */

    public static String parse2HexStr(String data) throws Exception {

        String result = "";

        try {

            byte[] buf = data.getBytes(CHARSET);

            StringBuffer sb = new StringBuffer();

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

                String hex = Integer.toHexString(buf[i]  0xFF);

                if (hex.length() == 1) {

                    hex = '0' + hex;

                }

                sb.append(hex.toUpperCase());

            }

            result = sb.toString();

        } catch (UnsupportedEncodingException e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 生成公钥与私钥

     */

    public static void createKey() throws Exception {

        try {

            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

            keyPairGenerator.initialize(KEY_SIZE);

            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();

            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());

            String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

            System.out.println("publicKey=" + publicKey + "\nprivateKey=" + privateKey);

        } catch (NoSuchAlgorithmException e) {

            throw new Exception(e);

        }

    }

    public static void main(String[] args) throws Exception {

        String PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf";

        String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

        RSAUtils rsaUtil = new RSAUtils();

        String encryptByPublicKey = rsaUtil.encryptByPublicKey("你好！", PUBLIC_KEY);

        System.out.println(encryptByPublicKey);

        String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);

        System.out.println(decryptByPrivateKey);

        String encryptByPrivateKey = rsaUtil.encryptByPrivateKey("你好！", PRIVATE_KEY);

        System.out.println(encryptByPrivateKey);

        String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);

        System.out.println(decryptByPublicKey);

        String sign = rsaUtil.sign("1234", PRIVATE_KEY);

        System.out.println("sign:" + sign);

        System.out.println(rsaUtil.verify("1234", PUBLIC_KEY, sign));

    }

}

Q4: java 非对称加密算法有哪些

1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中

KeyPairGenerator --- KeyPair -- RSAPublicKey、RSAPrivateKey

2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方

RSACoder.encryptByPrivateKey(data, privateKey);

RSACoder.sign(encodedData, privateKey);

3、乙方则通过公钥验证签名的加密数据，如果验证正确则在通过公钥对加密数据进行解密

RSACoder.verify(encodedData, publicKey, sign);

RSACoder.decryptByPublicKey(encodedData, publicKey);

4、乙方在通过公钥加密发送给甲方

RSACoder.encryptByPublicKey(decodedData, publicKey);

5、甲方通过私钥解密该数据

RSACoder.decryptPrivateKey(encodedData, privateKey);

Q5: java加密的几种方式

基本的单向加密算法：

BASE64 严格地说，属于编码格式，而非加密算法

MD5(Message Digest algorithm 5，信息摘要算法)

SHA(Secure Hash Algorithm，安全散列算法)

HMAC(Hash Message Authentication Code，散列消息鉴别码)

复杂的对称加密（DES、PBE）、非对称加密算法：

DES(Data Encryption Standard，数据加密算法)

PBE(Password-based encryption，基于密码验证)

RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)

DH(Diffie-Hellman算法，密钥一致协议)

DSA(Digital Signature Algorithm，数字签名)

ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)

代码参考：

/**

* BASE64加密

*

* @param key

* @return

* @throws Exception

*/

public static String encryptBASE64(byte[] key) throws Exception {

return (new BASE64Encoder()).encodeBuffer(key);

}

/**

* MD5加密

*

* @param data

* @return

* @throws Exception

*/

public static byte[] encryptMD5(byte[] data) throws Exception {

MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);

md5.update(data);

return md5.digest();

}

/**

* SHA加密

*

* @param data

* @return

* @throws Exception

*/

public static byte[] encryptSHA(byte[] data) throws Exception {

MessageDigest sha = MessageDigest.getInstance(KEY_SHA);

sha.update(data);

return sha.digest();

}

}

/**

* 初始化HMAC密钥

*

* @return

* @throws Exception

*/

public static String initMacKey() throws Exception {

KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

SecretKey secretKey = keyGenerator.generateKey();

return encryptBASE64(secretKey.getEncoded());

}

/**

* HMAC加密

*

* @param data

* @param key

* @return

* @throws Exception

*/

public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);

Mac mac = Mac.getInstance(secretKey.getAlgorithm());

mac.init(secretKey);

return mac.doFinal(data);

}