JAVA常用加密方式介绍及使用汇总（全集）

文章目录

引文：

传说在古罗马时代，发生了一次大战。正当敌方部队向罗马城推进时，古罗马皇帝凯撒向前线司令官发出了一封密信：VWRS WUDIILF。这封密信被敌方情报人员翻遍英文字典，也查不出这两个词的意思。

此时古罗马皇帝同时又发出了另一个指令：“前进三步”。然后古罗马军队司令官根据第二个指令很快明白了这封密信的含义。

“前进三步”这个提示的意思是向前推算三位的意思。推算出的结果就是：STOP TRAFFIC 停止运输或停止交通的意思！据说恺撒是率先使用加密函的古代将领之一，因此这种加密方法被称为凯撒密码。

它是一种替代密码，通过将字母按顺序推后起3位起到加密作用，如将字母A换作字母D，将字母B换作字母E。凯撒算法是最早使用的算法之一，是最简单的一种对称加密算法。

一、摘要加密（Hash加密）

引文：
如果开发者需要保存密码（比如网站用户的密码），要考虑如何保护这些密码数据，网站用户密码的泄露是一件非常严重的事情，容易引起用户恐慌，
所以在安全方面是重中之重，直接将密码以明文写入数据库中是极不安全的，因为任何可以打开数据库的人，都将可以直接看到这些密码。
解决的办法是将密码加密后再存储进数据库，比较常用的加密方法是使用哈希函数（Hash Function），也就是摘要加密。
通过哈希函数，我们就可以将密码的哈希值存储进数据库。用户登录网站的时候，我们可以检验用户输入密码的哈希值是否与数据库中的哈希值相同。
由于哈希函数是不可逆的，即使有人打开了数据库，也无法看到用户的密码是多少。（但不意味着存储经过哈希函数加密后的密码就是绝对的安全！）

介绍：摘要加密是一种不需要密钥的加密算法，生成的密文是唯一的、定长的并且无法破解，具有不可逆性、唯一性。常见的算法有MD5、SHA等。

原理：通过hash算法（单向算法）对目标信息生成一段特定长度的唯一hash值。

应用场景：密码加密，数字签名，文件完整性的校验 ，版权等应用场景。

1.MD5加密

介绍：全称Message Digest Algorithm(信息摘要算法)，是将任意长度的数据字符串转化成短小的固定长度的值的单向操作，任意两个字符串不应有相同的散列值。

(1)不加盐版

使用示例：

publicstaticbyte[]encryMD5(byte[] data)throwsException{MessageDigest md5 =MessageDigest.getInstance("MD5");
        md5.update(data);return md5.digest();}

(2)加盐版
需要注意的是，如果直接对密码进行散列，那么黑客可以对通过获得这个密码散列值，然后通过查散列值字典（例如MD5密码破解网站），得到某用户的密码。
以及彩虹表技术（在字典法的基础上改进，以时间换空间）的兴起，可以建立彩虹表进行查表破解，目前这种方式已经很不安全了。
此时我们可以通过加盐来解决这个问题。
盐（Salt） 是什么？就是一个 随机生成的字符串。我们将盐与原始密码连接（concat）在一起（放在前面或后面都可以），然后将concat后的字符串加密。Salt这个值是由系统随机生成的，并且只有系统知道。

加盐版算法：
每次保存密码到数据库时，都生成一个随机16位数字，将这16位数字和密码相加再求MD5摘要，然后在摘要中再将这16位数字按规则掺入形成一个48位的字符串。
在验证密码时再从48位字符串中按规则提取16位数字，和用户输入的密码相加再MD5。按照这种方法形成的结果肯定是不可直接反查的，且同一个密码每次保存时形成的摘要也都是不同的。

加盐使用示例：

publicstaticStringencryMD5Salt(String data)throwsException{MessageDigest md5 =MessageDigest.getInstance("MD5");//每次的盐都是随机的String salt = UUID.randomUUID().toString().substring(0,16);
    md5.update((data + salt).getBytes());//获取十六进制字符串形式的MD5摘要String password =newString(newHex().encode(md5.digest()));char[] cs =newchar[48];for(int i =0; i <48; i +=3){
        cs[i]= password.charAt(i /3*2);char c = salt.charAt(i /3);
        cs[i +1]= c;
        cs[i +2]= password.charAt(i /3*2+1);}returnnewString(cs);}/**
 * 校验密码是否正确
 */publicstaticbooleanverify(String password,String md5)throwsNoSuchAlgorithmException{char[] cs1 =newchar[32];char[] cs2 =newchar[16];for(int i =0; i <48; i +=3){
        cs1[i /3*2]= md5.charAt(i);
        cs1[i /3*2+1]= md5.charAt(i +2);
        cs2[i /3]= md5.charAt(i +1);}String salt =newString(cs2);MessageDigest md5Verify =MessageDigest.getInstance("MD5");
    md5Verify.update((password + salt).getBytes());returnnewString(newHex().encode(md5Verify.digest())).equals(newString(cs1));}

结果测试：

publicstaticvoidmain(String[] args)throwsException{//System.out.println(encryMD5("123456"));System.out.println(encryMD5Salt("123456"));System.out.println(verify("123456",encryMD5Salt("123456")));}

2.SHA加密

介绍：全称Secure Hash Algorithm（安全散列算法），是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。

SHA与MD5：
（1）对强行攻击的安全性：最显著和最重要的区别是SHA-1摘要比MD5摘要长32位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作，而对SHA-1则是2160数量级的操作。
这样，SHA-1对强行攻击有更大的强度。
（2）对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这样的攻击。
（3）速度：在相同的硬件上，SHA-1的运行速度比MD5慢。

注：SHA-256、SHA-512加密（目前用于比特币区块链的哈希算法）已经是当前很安全的加密方式，不需要额外进行加盐处理。

示例：

publicstaticbyte[]encryptSHA(byte[] data)throwsException{MessageDigest sha =MessageDigest.getInstance("SHA");
    sha.update(data);return sha.digest();}publicstaticStringSHAEncrypt(finalString content){try{MessageDigest sha =MessageDigest.getInstance("SHA");byte[] sha_byte = sha.digest(content.getBytes());StringBuffer hexValue =newStringBuffer();for(byte b : sha_byte){//将其中的每个字节转成十六进制字符串：byte类型的数据最高位是符号位，通过和0xff进行与操作，转换为int类型的正整数。String toHexString =Integer.toHexString(b &0xff);
            hexValue.append(toHexString.length()==1?"0"+ toHexString : toHexString);}return hexValue.toString();}catch(Exception e){
        e.printStackTrace();}return"";}//SHA-256加密publicstaticStringSHA256Encrypt(String sourceStr){MessageDigest md =null;try{
        md =MessageDigest.getInstance("SHA-256");}catch(NoSuchAlgorithmException e){
        e.printStackTrace();}if(null!= md){
        md.update(sourceStr.getBytes());String digestStr =getDigestStr(md.digest());return digestStr;}returnnull;}

结果测试：
publicstaticvoidmain(String[] args)throwsException{//System.out.println(encryMD5("123456"));//System.out.println(encryMD5Salt("123456"));//System.out.println(verify("123456",encryMD5Salt("123456")));System.out.println(encryptSHA("123456".getBytes()));System.out.println(SHAEncrypt("123456"));System.out.println(SHA256Encrypt("123456"));}

3.BCrypt加密

介绍：基于Blowfish算法的密码哈希函数,内部自己实现了随机加盐处理,是一种较为安全的加密方法。

原理：由四部分组成①saltRounds: 正数，代表hash杂凑次数，数值越高越安全，默认10次;②myPassword: 明文密码字符串;③salt: 盐，一个128bits随机字符串，22字符;
④myHash: 经过明文密码password和盐salt进行hash，默认循环加盐hash10次，得到myHash。
每次明文字符串myPassword过来，就通过10次循环加盐salt加密后得到myHash, 然后拼接BCrypt版本号+salt盐+myHash等到最终的bcrypt密码 ，存入数据库中。
在下次校验时，从myHash中取出salt，（salt通过截取密文得到），salt跟password进行hash；得到的结果跟保存在DB中的hash进行比对。

使用示例：

// 加密String encodedPassword =BCrypt.hashpw("123456",BCrypt.gensalt());System.out.println(encodedPassword);// 验证密码是否正确boolean flag =BCrypt.checkpw("123456", encodedPassword);System.out.println(flag);

所需依赖：

<dependency><groupId>org.mindrot</groupId><artifactId>jbcrypt</artifactId><version>0.4</version></dependency>

二、对称加密

介绍：加密和解密使用相同密钥的加密算法。常见算法的有DES、3DES、AES等。
DES(Data Encryption Standard)和3DES（Triple DES）由于安全性原因基本已经退出舞台，作为取代的是AES(Advanced Encryption Standard)。

原理：密钥是控制加密及解密过程的指令。算法是一组规则，规定如何进行加密和解密。

应用场景：速度快，适用于离线的大量数据加密。

1.AES加密(Rijndael[读作rain-dahl]加密)

AES一共有四种加密模式：电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB）。
以下是ECB的使用示例:

packagecom.example.user.utils;importjavax.crypto.Cipher;importjavax.crypto.SecretKey;importjavax.crypto.spec.SecretKeySpec;importjava.util.Base64;importjava.util.Random;publicclassAESUtils{/**
     * 加解密统一编码方式
     */privatefinalstaticString ENCODING ="utf-8";/**
     * 加解密方式
     */privatefinalstaticString ALGORITHM ="AES";/**
     * 加密模式及填充方式
     */privatefinalstaticString PATTERN ="AES/ECB/pkcs5padding";/**
     * 秘钥生成来源
     */publicstaticfinalString ALLCHAR ="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";/**
     * 生成AES密钥对象
     *
     */publicstaticStringgenerateAESKey(){StringBuffer sb =newStringBuffer();Random random =newRandom();for(int i =0; i <16; i++){
            sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));}return sb.toString();}/**
     * AES加密
     *
     * @param plainText
     * @param key
     * @return
     * @throws Exception
     */publicstaticStringencrypt(String plainText,String key)throwsException{if(key ==null){System.out.print("Key为空null");returnnull;}// 判断Key是否为16位if(key.length()!=16){System.out.print("Key长度不是16位");returnnull;}SecretKey secretKey =newSecretKeySpec(key.getBytes(ENCODING), ALGORITHM);// AES加密采用pkcs5padding填充Cipher cipher =Cipher.getInstance(PATTERN);//用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);//执行加密操作byte[] encryptData = cipher.doFinal(plainText.getBytes(ENCODING));returnBase64.getEncoder().encodeToString(encryptData);}/**
     * AES解密
     *
     * @param plainText
     * @param key
     * @return
     * @throws Exception
     */publicstaticStringdecrypt(String plainText,String key)throwsException{SecretKey secretKey =newSecretKeySpec(key.getBytes(ENCODING), ALGORITHM);// 获取 AES 密码器Cipher cipher =Cipher.getInstance(PATTERN);// 初始化密码器（解密模型）
        cipher.init(Cipher.DECRYPT_MODE, secretKey);// 解密数据, 返回明文byte[] encryptData = cipher.doFinal(Base64.getDecoder().decode(plainText));returnnewString(encryptData, ENCODING);}publicstaticvoidmain(String[] args)throwsException{String key =generateAESKey();System.out.println(encrypt("123456",key));System.out.println(decrypt(encrypt("123456",key),key));}}

2.PBE加密

介绍：全称Password Based Encryption，基于口令加密。其特点是使用口令代替了密钥，而口令由用户自己掌管，采用随机数杂凑多重加密等方法保证数据的安全性。

口令和密钥的区别：
口令：一般与用户名对应，是某个用户自己编织的便于 记忆的一串单词、数字、汉字字符，口令的特点容易被记忆， 也容易泄露和被盗取，容易被社会工程学、暴力破解、撞库等方式获取。
密钥：是经过加密算法计算出来的，密钥一般不容易记忆，不容易被破解，而且很多时候密钥是作为算法的参数出现的，算法对于密钥长度也是有要求的，因为加密算法的作用就是利用密钥来扰乱明文顺序。

原理：PBE算法在加密过程中并不是直接使用口令来加密，而是加密的密钥由口令生成，这个功能由PBE算法中的KDF函数完成。
KDF函数的实现过程为：将用户输入的口令首先通过“盐”（salt）的扰乱产生准密钥，再将准密钥经过散列函数（摘要）多次迭代后生成最终加密密钥，
密钥生成后，PBE算法再选用对称加密算法对数据进行加密。–结合了摘要加密与对称加密

使用示例：

packagecom.example.user.utils;importorg.bouncycastle.jce.provider.BouncyCastleProvider;importjavax.crypto.*;importjavax.crypto.spec.PBEKeySpec;importjavax.crypto.spec.PBEParameterSpec;importjava.security.*;importjava.security.spec.InvalidKeySpecException;importjava.util.Base64;publicenumPBEAlgorithmUtils{PBE_With_MD5_And_DES("PBEWithMD5andDES","default"),PBE_WITH_MD5_AND_TRIPE_DES("PBEWithMD5AndTripeDES","default"),PBE_WITH_SHA1_AND_DESEDE("PBEWithSHA1AndDESede","default"),PBE_WITH_SHA1_AND_RC2_40("PBEWithSHA1AndRC2_40","default"),PBE_WITH_MD5_AND_RC2("PBEWithMD5AndRC2","BC"),PBE_WITH_SHA1_AND_DES("PBEWithSHA1AndDES","BC"),PBE_WITH_SHA1_AND_RC2("PBEWithSHA1AndRC2","BC"),PBE_WITH_SHA_AND_IDEA_CBC("PBEWithSHAAndIDEA-CBC","BC"),PBE_WITH_SHA_AND_2_KEY_TRIPLE_DES_CBC("PBEWithSHAAnd2-KeyTripleDES-CBC","BC"),PBE_WITH_SHA_AND_3_KEY_TRIPLE_DES_CBC("PBEWithSHAAnd3-KeyTripleDES-CBC","BC"),PBE_WITH_SHA_AND_128_BIT_RC2_CBC("PBEWithSHAAnd128BitRC2-CBC","BC"),PBE_WITH_SHA_AND_40_BIT_RC2_CBC("PBEWithSHAAnd40BitRC2-CBC","BC"),PBE_WITH_SHA_AND_128_BIT_RC4("PBEWithSHAAnd128BitRC4","BC"),PBE_WITH_SHA_AND_40_BIT_RC4("PBEWithSHAAnd40BitRC4","BC"),PBE_WITH_SHA_AND_BLOWFISH("PBEWithSHAAndBlowfish","BC");static{Security.addProvider(newBouncyCastleProvider());}privateString algorithm ="";privateString providerName ="";PBEAlgorithmUtils(String algorithm,String providerName){this.algorithm = algorithm;this.providerName = providerName;}publicStringencrypt(String plainText,String password,String saltStr,int iterationCount)throwsNoSuchAlgorithmException,InvalidKeySpecException,NoSuchPaddingException,InvalidAlgorithmParameterException,InvalidKeyException,BadPaddingException,IllegalBlockSizeException,NoSuchProviderException{PBEKeySpec keySpec =newPBEKeySpec(password.toCharArray());SecretKeyFactory factory =null;if("default".equals(this.providerName)){
            factory =SecretKeyFactory.getInstance(this.algorithm);}else{
            factory =SecretKeyFactory.getInstance(this.algorithm,this.providerName);}SecretKey secretKey = factory.generateSecret(keySpec);PBEParameterSpec parameterSpec =newPBEParameterSpec(saltStr.getBytes(), iterationCount);Cipher cipher =Cipher.getInstance(this.algorithm);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, parameterSpec);byte[] bytes = cipher.doFinal(plainText.getBytes());String cipherText =Base64.getEncoder().encodeToString(bytes);System.out.println(String.format("%s(%s-%d) plain text: %s -> cipher text: %s",this.algorithm, saltStr, iterationCount, plainText, cipherText));return cipherText;}publicStringdecrypt(String base64CipherText,String password,String saltStr,int iterationCount)throwsNoSuchPaddingException,NoSuchAlgorithmException,InvalidKeySpecException,InvalidAlgorithmParameterException,InvalidKeyException,BadPaddingException,IllegalBlockSizeException,NoSuchProviderException{PBEKeySpec keySpec =newPBEKeySpec(password.toCharArray());SecretKeyFactory factory =null;if("default".equals(this.providerName)){
            factory =SecretKeyFactory.getInstance(this.algorithm);}else{
            factory =SecretKeyFactory.getInstance(this.algorithm,this.providerName);}SecretKey secretKey = factory.generateSecret(keySpec);PBEParameterSpec parameterSpec =newPBEParameterSpec(saltStr.getBytes(), iterationCount);Cipher cipher =Cipher.getInstance(this.algorithm);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, parameterSpec);byte[] cipherBytes =Base64.getDecoder().decode(base64CipherText);byte[] plainBytes = cipher.doFinal(cipherBytes);String plainText =newString(plainBytes).trim();System.out.println(String.format("%s(%s-%d) cipher text: %s -> plain text: %s",this.algorithm, saltStr, iterationCount, base64CipherText, plainText));return plainText;}publicstaticvoidmain(String[] args)throwsInvalidAlgorithmParameterException,NoSuchPaddingException,IllegalBlockSizeException,NoSuchAlgorithmException,InvalidKeySpecException,BadPaddingException,InvalidKeyException,NoSuchProviderException{//口令为password，加密盐为salt，加密十次，使用MD5加密生成密钥，然后使用RC2进行对称加密String text =PBEAlgorithmUtils.PBE_WITH_MD5_AND_RC2.encrypt("123456","password","salt",10);PBEAlgorithmUtils.PBE_WITH_MD5_AND_RC2.decrypt(text,"password","salt",10);//口令为password，加密盐为salt，加密十次，使用SHA加密生成密钥，然后使用DES进行对称加密String text2 =PBEAlgorithmUtils.PBE_WITH_SHA1_AND_DES.encrypt("123456","password","salt",10);PBEAlgorithmUtils.PBE_WITH_SHA1_AND_DES.decrypt(text2,"password","salt",10);}}

三、非对称加密

介绍:非对称加密算法是一种密钥的保密方法，加密和解密使用两个不同的密钥，公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。
公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。常见的加密算法有RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）。

特点:算法强度复杂;加密解密速度没有对称密钥算法的速度快

应用场景:电商订单付款、银行相关业务、数字签名、与AES组合使用进行加密
注：在实际使用中，验签经常会加盐处理，拼接其他字符串如时间戳等后加密。

1.RSA加密

(1)基本使用示例

packagecom.example.user.utils;importorg.apache.commons.codec.binary.Base64;importjavax.crypto.Cipher;importjava.io.ByteArrayOutputStream;importjava.security.*;importjava.security.interfaces.RSAPrivateKey;importjava.security.interfaces.RSAPublicKey;importjava.security.spec.PKCS8EncodedKeySpec;importjava.security.spec.X509EncodedKeySpec;publicclassRSAUtils{/**
     * RSA最大加密明文大小
     */privatestaticfinalint MAX_ENCRYPT_BLOCK =117;/**
     * RSA最大解密密文大小
     */privatestaticfinalint MAX_DECRYPT_BLOCK =128;/**
     * 编码
     */privatestaticString charset ="utf-8";/**
     * 获取密钥对
     *
     * @return 密钥对
     */publicstaticKeyPairgetKeyPair()throwsException{KeyPairGenerator generator =KeyPairGenerator.getInstance("RSA");
        generator.initialize(1024);return generator.generateKeyPair();}/**
     * 获取私钥
     *
     * @param privateKey 私钥字符串
     * @return
     */publicstaticPrivateKeygetPrivateKey(String privateKey)throwsException{KeyFactory keyFactory =KeyFactory.getInstance("RSA");byte[] decodedKey =Base64.decodeBase64(privateKey.getBytes(charset));PKCS8EncodedKeySpec keySpec =newPKCS8EncodedKeySpec(decodedKey);return keyFactory.generatePrivate(keySpec);}/**
     * 获取公钥
     *
     * @param publicKey 公钥字符串
     * @return
     */publicstaticPublicKeygetPublicKey(String publicKey)throwsException{KeyFactory keyFactory =KeyFactory.getInstance("RSA");byte[] decodedKey =Base64.decodeBase64(publicKey.getBytes(charset));X509EncodedKeySpec keySpec =newX509EncodedKeySpec(decodedKey);return keyFactory.generatePublic(keySpec);}/**
     * RSA加密
     *
     * @param data 待加密数据
     * @param publicKey 公钥
     * @return
     */publicstaticStringencrypt(String data,PublicKey publicKey)throwsException{Cipher cipher =Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);int inputLen = data.getBytes(charset).length;ByteArrayOutputStream out =newByteArrayOutputStream();int offset =0;byte[] cache;int i =0;// 对数据分段加密while(inputLen - offset >0){if(inputLen - offset > MAX_ENCRYPT_BLOCK){
                cache = cipher.doFinal(data.getBytes(charset), offset, MAX_ENCRYPT_BLOCK);}else{
                cache = cipher.doFinal(data.getBytes(charset), offset, inputLen - offset);}
            out.write(cache,0, cache.length);
            i++;
            offset = i * MAX_ENCRYPT_BLOCK;}byte[] encryptedData = out.toByteArray();
        out.close();// 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串// 加密后的字符串returnBase64.encodeBase64String(encryptedData);}/**
     * RSA解密
     *
     * @param data 待解密数据
     * @param privateKey 私钥
     * @return
     */publicstaticStringdecrypt(String data,PrivateKey privateKey)throwsException{Cipher cipher =Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] dataBytes =Base64.decodeBase64(data);int inputLen = dataBytes.length;ByteArrayOutputStream out =newByteArrayOutputStream();int offset =0;byte[] cache;int i =0;// 对数据分段解密while(inputLen - offset >0){if(inputLen - offset > MAX_DECRYPT_BLOCK){
                cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);}else{
                cache = cipher.doFinal(dataBytes, offset, inputLen - offset);}
            out.write(cache,0, cache.length);
            i++;
            offset = i * MAX_DECRYPT_BLOCK;}byte[] decryptedData = out.toByteArray();
        out.close();// 解密后的内容returnnewString(decryptedData,"UTF-8");}/**
     * 签名
     *
     * @param data 待签名数据
     * @param privateKey 私钥
     * @return 签名
     */publicstaticStringsign(String data,String privateKey)throwsException{byte[] decoded =Base64.decodeBase64(privateKey);RSAPrivateKey priKey =(RSAPrivateKey)KeyFactory.getInstance("RSA").generatePrivate(newPKCS8EncodedKeySpec(decoded));//RSA解密Signature signature =Signature.getInstance("MD5withRSA");
        signature.initSign(priKey);
        signature.update(data.getBytes(charset));returnnewString(Base64.encodeBase64(signature.sign()),charset);}/**
     * 验签
     *
     * @param srcData 原始字符串
     * @param publicKey 公钥
     * @param sign 签名
     * @return 是否验签通过
     */publicstaticbooleanverify(String srcData,String publicKey,String sign)throwsException{byte[] decoded =Base64.decodeBase64(publicKey);RSAPublicKey pubKey =(RSAPublicKey)KeyFactory.getInstance("RSA").generatePublic(newX509EncodedKeySpec(decoded));Signature signature =Signature.getInstance("MD5withRSA");
        signature.initVerify(pubKey);
        signature.update(srcData.getBytes(charset));return signature.verify(Base64.decodeBase64(sign.getBytes(charset)));}publicstaticvoidmain(String[] args)throwsException{try{// 生成密钥对KeyPair keyPair =getKeyPair();String privateKey =newString(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));String publicKey =newString(Base64.encodeBase64(keyPair.getPublic().getEncoded()));System.out.println("私钥:"+ privateKey);System.out.println("公钥:"+ publicKey);// RSA加密String data ="123456";String encryptData =encrypt(data,getPublicKey(publicKey));System.out.println("加密后内容:"+ encryptData);// RSA解密String decryptData =decrypt(encryptData,getPrivateKey(privateKey));System.out.println("解密后内容:"+ decryptData);// RSA签名String sign =sign(data, privateKey);// RSA验签boolean result =verify(data, publicKey, sign);System.out.print("验签结果:"+ result);}catch(Exception e){
            e.printStackTrace();System.out.print("加解密异常");}}}

(2)RSA与AES组合使用示例

为什么要使用RSA与AES组合加密呢?
对称加密（AES）的优势在于加密较快，但劣势在于秘钥一旦给出去就不安全了。非对称加密（RSA）的优势在于安全，就算提供公钥出去，别人也解密不了数据，但加密速度较慢。
使用流程:
Ⅰ.先生成一个随机AES秘钥字符串;
Ⅱ.使用RSA公钥加密AES秘钥，然后再用AES秘钥加密真正的内容;
Ⅲ.把skey=加密的AES秘钥，body=AES秘钥加密的内容传过去;
Ⅳ.对面使用RSA私钥解密AES秘钥，然后用AES秘钥解密出内容。
使用示例：

publicstaticvoidmain(String[] args)throwsException{try{//生成AES密钥StringAESKey=AESUtils.generateAESKey();// 生成rsa密钥对KeyPair keyPair =getKeyPair();String privateKey =newString(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));String publicKey =newString(Base64.encodeBase64(keyPair.getPublic().getEncoded()));System.out.println("私钥:"+ privateKey);System.out.println("公钥:"+ publicKey);//加密端Start// RSA加密AESKeyString encryptKey =encrypt(AESKey,getPublicKey(publicKey));System.out.println("加密后的AES密钥:"+ encryptKey);// AES加密后的内容String data ="123456";String encryptData =AESUtils.encrypt(data,AESKey);System.out.println("AES加密后内容:"+ encryptData);//加密端 end//解密端Start// RSA解密拿到AESKeyString key =decrypt(encryptKey,keyPair.getPrivate());System.out.println("解密后的AES密钥:"+ key);// RSA验签String result =AESUtils.decrypt(encryptData,key);System.out.print("结果:"+ result);//解密端end}catch(Exception e){
        e.printStackTrace();System.out.print("加解密异常");}}

四、加密相关其他技术

1.BASE64

介绍：Base64并不是一种加密方式，而是一种编码方式。很多时候，我们都将Base64编码作为数据加密后的传输 / 存储格式。

原理：根据ASCII编码值进行转换。Base64二进制数6位为一个单元(所以总字符数只能是64)，一个字节有8位，将3个原字符转换成4个Base64密文。（后面的使用示例也能看出来）

应用场景：Base64能够将任何数据转换为易移植的字符串，避免了传输过程中失真问题。最初，Base64是为了解决电子邮件中无法直接使用非ASCII字符的问题。
一段数据先经过Base64编码为ASCII字符串后，可以在接收端，通过Base64解码还原为原数据后，而无需担心传输过程中失真。
很多时候，我们都将Base64编码作为数据加密后的传输 / 存储格式。例如，一段明文数据通过MD5 、SHA等手段加密后，经过Base64编码为字符串，就可以很方便地进行传输 & 存储。

使用示例：

byte[] bytes  ="123456".getBytes();System.out.println("Base64加密前："+Arrays.toString(bytes));byte[] encodeBytes =Base64.encodeBase64(bytes);System.out.println("Base64加密后："+Arrays.toString(encodeBytes));System.out.println("Base64解密后："+Arrays.toString(Base64.decodeBase64(encodeBytes)));