对称加密和非对称工具类

最新推荐文章于 2023-08-01 16:55:40 发布
最新推荐文章于 2023-08-01 16:55:40 发布
阅读量429 收藏
点赞数
分类专栏： 码码在线
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzh657083979/article/details/79328433
版权

加密方法有对称加密和非对称加密两种。
对称加密是key+明文==加密后的数据
然后服务端得到加密后的数据和key解密得到明文。
这里key是一致的。
非对称加密是key是不一致的。安全，但效率低。

这里需要base64工具类，因为生成的乱码会在传输的过程中出问题。比如说我在这加密了一套算法，服务端那边拿到解密却不是这一套算法，这不是乱套了么，，所以最好规定一套公共的，加密解密都用这种算法才不会出问题。

Base64Util.java

package com.coder520.mamabike.security;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Base64Util {
    private static final char[] legalChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
            .toCharArray();



    public static String encode(byte[] data) {
        byte start = 0;
        int len = data.length;
        StringBuffer buf = new StringBuffer(data.length * 3 / 2);
        int end = len - 3;
        int i = start;
        int n = 0;

        int d;
        while (i <= end) {
            d = (data[i] & 255) << 16 | (data[i + 1] & 255) << 8 | data[i + 2] & 255;
            buf.append(legalChars[d >> 18 & 63]);
            buf.append(legalChars[d >> 12 & 63]);
            buf.append(legalChars[d >> 6 & 63]);
            buf.append(legalChars[d & 63]);
            i += 3;
            if (n++ >= 14) {
                n = 0;
                buf.append(" ");
            }
        }

        if (i == start + len - 2) {
            d = (data[i] & 255) << 16 | (data[i + 1] & 255) << 8;
            buf.append(legalChars[d >> 18 & 63]);
            buf.append(legalChars[d >> 12 & 63]);
            buf.append(legalChars[d >> 6 & 63]);
            buf.append("=");
        } else if (i == start + len - 1) {
            d = (data[i] & 255) << 16;
            buf.append(legalChars[d >> 18 & 63]);
            buf.append(legalChars[d >> 12 & 63]);
            buf.append("==");
        }

        return buf.toString();
    }

    private static int decode(char c) {
        if (c >= 65 && c <= 90) {
            return c - 65;
        } else if (c >= 97 && c <= 122) {
            return c - 97 + 26;
        } else if (c >= 48 && c <= 57) {
            return c - 48 + 26 + 26;
        } else {
            switch (c) {
            case '+':
                return 62;
            case '/':
                return 63;
            case '=':
                return 0;
            default:
                throw new RuntimeException("unexpected code: " + c);
            }
        }
    }

    public static byte[] decode(String s) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        try {
            decode(s, bos);
        } catch (IOException var5) {
            throw new RuntimeException();
        }

        byte[] decodedBytes = bos.toByteArray();

        try {
            bos.close();
            bos = null;
        } catch (IOException var4) {
            System.err.println("Error while decoding BASE64: " + var4.toString());
        }

        return decodedBytes;
    }

    private static void decode(String s, OutputStream os) throws IOException {
        int i = 0;
        int len = s.length();

        while (true) {
            while (i < len && s.charAt(i) <= 32) {
                ++i;
            }

            if (i == len) {
                break;
            }

            int tri = (decode(s.charAt(i)) << 18) + (decode(s.charAt(i + 1)) << 12) + (decode(s.charAt(i + 2)) << 6)
                    + decode(s.charAt(i + 3));
            os.write(tri >> 16 & 255);
            if (s.charAt(i + 2) == 61) {
                break;
            }

            os.write(tri >> 8 & 255);
            if (s.charAt(i + 3) == 61) {
                break;
            }

            os.write(tri & 255);
            i += 4;
        }

    }

}

AESUtil.java

package com.coder520.mamabike.security;

import org.springframework.stereotype.Component;

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

/**
 * Created by JackWangon[www.coder520.com] 2017/7/31.
 */

public class AESUtil {


    public static final String KEY_ALGORITHM = "AES";
    public static final String KEY_ALGORITHM_MODE = "AES/CBC/PKCS5Padding";


    /**
     * AES对称加密
     * @param data
     * @param key key需要16位
     * @return
     */
    public static String encrypt(String data , String key) {
        try {
            SecretKeySpec spec = new SecretKeySpec(key.getBytes("UTF-8"),KEY_ALGORITHM);
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM_MODE);
            cipher.init(Cipher.ENCRYPT_MODE , spec,new IvParameterSpec(new byte[cipher.getBlockSize()]));
            byte[] bs = cipher.doFinal(data.getBytes("UTF-8"));
            return Base64Util.encode(bs);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  null;
    }


    /**
     * AES对称解密 key需要16位
     * @param data
     * @param key
     * @return
     */
    public static String decrypt(String data, String key) {
        try {
            SecretKeySpec spec = new SecretKeySpec(key.getBytes("UTF-8"), KEY_ALGORITHM);
            Cipher cipher = Cipher.getInstance(KEY_ALGORITHM_MODE);
            cipher.init(Cipher.DECRYPT_MODE , spec , new IvParameterSpec(new byte[cipher.getBlockSize()]));
            byte[] originBytes = Base64Util.decode(data);
            byte[] result = cipher.doFinal(originBytes);
            return new String(result,"UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return  null;
    }


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

        String s="123456789qazwsx";
        String encrypt = AESUtil.encrypt(s, "123456789qazwsxc");
        System.out.println(encrypt);
        String decrypt = AESUtil.decrypt(encrypt, "123456789qazwsxc");
        System.out.println(decrypt);

        /*String okey = "123456789abcdefg";
        //移动端随机key  AES加密数据
       String enr= encrypt("{'mobile':'18980840843','code':'8060','platform':'android','channelId':12454348}",okey);
       System.out.println(enr);
       //移动端RSA加密AES的key 和加密的数据一起传到服务器
       byte[] keyrsa = RSAUtil.encryptByPublicKey(okey.getBytes("UTF-8"),"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCuVRY8B3+Af5euC9WbgNkJKAiBzqOvrYi9mSST78jd4clpn7vkYHDfHzJiqFz9wjNRLzg9MUREF53bw9yhSljZ7F8JPMryfe8RR2Ed6CJq5nCy/2hvTTw4L6ypDemwe9f9yjIg52oPRPwU8lm8Uj3wKhjedDmZrkO1TAmt3sbQtwIDAQAB");
       System.out.println(Base64Util.encode(keyrsa));
       String base = Base64Util.encode(keyrsa);*/

//       //服务端RSA解密AES的key
//       byte[] keybyte= RSAUtil.decryptByPrivateKey(Base64Util.decode(base));
//       String keyR=new String(keybyte,"UTF-8");
//        System.out.println(keyR);
    }
}

非对称加密大概思路

1。首先通过javax的包，不用引入其他包，里面的类得到公钥和私钥。

 public static void main(String[] args) throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        System.out.println(Base64Util.encode(privateKey.getEncoded()));  //私钥
        System.out.println(Base64Util.encode(publicKey.getEncoded()));   //公钥
    }

2。然后通过公钥加密返回一个byte[]数组。 注意：这里第一个参数传的数组需要加密的key.getBytes(“UTF-8”)得到，第二个参数就是字符串的公钥

   /**
     *
     * @param data
     * @param key
     * @return      公钥加密
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {
        byte[] keyBytes = Base64Util.decode(key);
        X509EncodedKeySpec pkcs8KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicKey = keyFactory.generatePublic(pkcs8KeySpec);

//        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

3。然后通过返回加密返回的byte[]数组和私钥解密，返回的还是byte[]数组，new String(bytes1,”UTF-8”)这种解密就可以得到字符串key。

 /**
     * 私钥解密
     *
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data) throws Exception {
        convert();  //先读取私钥
        byte[] keyBytes = Base64Util.decode(PRIVATE_KEY);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

main函数测试

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

        String data="孙悟空来了----";
        String key="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCoxN+GpRBuQT1+J72rVtyX GADOn1peU7kaLQ+CLxisx3+n9sdUWnF85Av6miE829NQ4G6R1J7wt2JnuMir 89/BHBie4L19H8qMnVpyWEVBtGWiy8A/Zw9IdL21v1+e1v1NEUIVvws/nyrf +shjI/jIVajz6h1Ql/z/aDpl1KMYLwIDAQAB";
        //公钥加密
        byte[] bytes = encryptByPublicKey(data.getBytes("UTF-8"), key);
         //私钥解密
        byte[] bytes1 = decryptByPrivateKey(bytes);
        System.out.println(new String(bytes1,"UTF-8"));
    }

总结：采用对称和非对称加密相结合的方法来解决问题。

第一：采用对称方法拿到加密过后的数据。但是key在http协议中传输不安全，然后采用非对称加密的方法来加密key。把加密后的数据和加密后的key传到服务端。注意：加密后的key使用RSAUtil.encryptByPublicKey（）方法返回的是数组，需要传字符串，所以需要用Base64Util.encode(bytes)来得到字符串。。。不然乱码！！！！！！！！！！！
第二：服务端拿到加密后的key之后，将key解密出来。然后再根据key和加密的数据来解密加密过的数据。

 String okey="123456789abcdefg";
        String enr= encrypt("{'mobile':'15515664xxx','code':'8888','platform':'android'}",okey);
        System.out.println(enr);//加密后的数据

        byte[] bytes = RSAUtil.encryptByPublicKey(okey.getBytes("UTF-8"), "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCoxN+GpRBuQT1+J72rVtyX GADOn1peU7kaLQ+CLxisx3+n9sdUWnF85Av6miE829NQ4G6R1J7wt2JnuMir 89/BHBie4L19H8qMnVpyWEVBtGWiy8A/Zw9IdL21v1+e1v1NEUIVvws/nyrf +shjI/jIVajz6h1Ql/z/aDpl1KMYLwIDAQAB");
        System.out.println(Base64Util.encode(bytes));//公钥加密的key

这个就是客户端传送的加密后的数据，和公钥加密的key。
服务器端先解密key，然后再解密加密的数据。

//RSA解密AES的key
byte[] aesKey = RSAUtil.decryptByPrivateKey(Base64Util.decode(key));
 //AES的key解密AES加密数据
 decryptData = AESUtil.decrypt(data, new String(aesKey, "UTF-8"));

理下思路：

首先我需要传送一个加密的数据和一个公钥加密的key。但是公钥加密的key返回的是数组，所以我需要用Base64来转成字符串。
然后后台接收到字符串后，又用Base64转换成数组然后解密key。得到的还是数组。这时候就不用Bash64了
得到key之后，再解密数据

发疯的man
关注
专栏目录
java树形数据结构递归求上级，附答案
m0_57081368的博客
06-27 1107
Part 1微服务架构设计概述 1.1 传统应用架构的问题 1.2 微服务架构是什么 1.3 微服务架构有哪些特点和挑战 1.4 如何搭建微服务架构 Part 2微服务开发框架 2.1 Spring Boot 是什么 2.2 如何使用Spring Boot框架 2.3 Spring Boot生产级特性 Part 3微服务网关 3.1 Node.js 是什么 3.2 如何使用 Node.js 3.3 使用Node.js搭建微服务网关 Part 4微服务注册与发现. 4.1 ZooKeepe
Rsa非对称加密技术工具类
03-10
Rsa非对称加密技术工具类
ASR (Asymmetric Signcryption) 非对称加密(工具类)
07-04
ASR（Asymmetric Signcryption）是一种非对称加密算法，它结合了对称加密和非对称加密的优点，用于保护数据的机密性和完整性。 ASR 的核心思想是使用一对公钥和私钥来进行加密和解密。其中，公钥用于加密数据，私钥用于解密数据。与传统的非对称加密算法不同，ASR 在加密过程中使用对称加密算法对数据进行加密，然后使用公钥对对称密钥进行加密，以确保数据的安全性。 ASR 的特点如下： 安全性高，结合了对称加密和非对称加密的优点，能够提供更高级别的安全性保障。 加密和解密速度较快，能够满足大量数据的加密和解密需求。 适用于分布式系统，能够实现高效的密钥管理。 能够对数据进行完整性验证和数字签名，确保数据的完整性和真实性。 ASR 常用于以下场景： 电子签名，用于验证文档或消息的真实性和完整性。 数据库安全，用于保护数据库中数据的机密性和完整性。 移动通信安全，用于保护移动通信数据的机密性和完整性。 物联网安全，用于保护物联网设备之间的通信数据的安全性。 ASR 常用的算法包括 RSA、ECC（椭圆曲线加密）等。实际应用中，根据具体需求选择合适的算法和密钥长度来确保数据的安全性
工具类-RSA非对称加密工具类，自用留存
07-06
工具类-RSA非对称加密工具类，自用留存
AES(对称加密)和RSA(非对称加密)使用详情
eastWind1101的博客
06-07 6478
AES和RSA的混合使用,以及OC中常用的加密方式.参数加密
对称加密工具类
no pain !no gain !
09-30 338
头文件 包含终端命令，可以验证加密结果是否正确#import <Foundation/Foundation.h> #import <CommonCrypto/CommonCrypto.h>/** * 终端测试指令 * * DES(ECB)加密 * $ echo -n hello | openssl enc -des-ecb -K 616263 -nosalt | base64 *
AES 对称加密解密工具类
phpfzh的博客
03-17 628
最近在做一个邮件找回密码功能时，需要对核心参数加密，所以记录下来。 private static String rawKey = "6bd5601c8ced37e7229c9fbdb76493a8"; /** * AES */ private final static String algorithm = "AES"; /* * 转为十六进制 */ pri
AES 对称加密工具类
最新发布
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
08-01 664
AES对称加密工具类，拿来即用！
IT_Most的博客
11-26 684
AES对称加密，一看就会~
rsa非对称加密java工具类
02-08
项目中使用过的一个rsa非对称加密类，用着很不错 ，需要注意的是里边的密钥长度最小是128，不能再小了，还有里边用到了base64的编码，我们用的是jdk 1.8自带的工具类，如果要用的童靴的项目是不jdk 1.8的项目也可以...
对称加密工具
03-05
信息加密工具，可以供学生实验使用。没有电子书。
AES对称加密java工具类
12-30
适用于java开发者使用，用于对称加密的数据。进行加密。
Java AES对称加密工具类Utils
12-18
综合网上的AES加密，把其做成一个工具类，方便加密解密的实现
常见加密算法方式(对称加密和非对称加密)
03-26
对称加密：DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES 非对称加密：RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）
对称加密工具软件 DESTOOL DesTool
03-13
对称加密算法的教学实用工具。以及对对称加密技术的研究，都需要联系实用此工具。书山有路勤为径，学海无涯苦作舟。
AES对称加密工具类
09-18
AES对称加密工具类，本工具类已经测试通过，不需要额外依赖，直接copy即可使用
对称加密工具类（前后端）
IGIli的博客
07-20 255
对称加密
对称加密与非对称加密工具类及测试
guanzhongye007的博客
11-20 742
1.public class AESUtil { /** * 将byte[]转为各种进制的字符串 * @param bytes byte[] * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制 * @return 转换后的字符串 */ private static String
【常用工具】java aes对称加密工具类
seesun2012的专栏
08-17 523
AES对称加密工具类，代码如下： package com.sszh.utils.security; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; /** * AES对称加密工具类 */ public class AesEncryption { /** * 加密数据 * * @param d
RSA非对称加密工具类实现
RSAUtils工具类是一个用于RSA非对称加密的Java实现，它提供了一系列静态方法来处理公钥和私钥的读取、解码以及加密解密操作。该工具类由liujian于2020/11/18创建。 在密码学中，RSA是一种广泛使用的非对称加密算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

发疯的man

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值