0
点赞
收藏
分享

微信扫一扫

加密技术概述

非常帅气的昵称吧 2022-04-07 阅读 30
java

加密技术概述及分类

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

  • 对称加密，如AES
    • 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
    • 优势：算法公开、计算量小、加密速度快、加密效率高
    • 缺陷：双方都使用同样密钥，安全性得不到保证
  • 非对称加密，如RSA、git的ssh公钥和私钥
    • 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端 私钥是用于加密的，公钥是用于解密的。
      • 私钥加密，持有私钥或公钥才可以解密
      • 公钥加密，持有私钥才可解密
    • 优点：安全，难以破解
    • 缺点：算法比较耗时
  • 不可逆加密，如MD5，SHA
    • 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

Base64加密和解密

原理剖析：https://blog.csdn.net/qq_42402854/article/details/99849284

Base64是网络上最常见的用于传输 8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。

Base64一般用于在 HTTP协议下传输二进制数据，由于 HTTP协议是文本协议，所以在HTTP协议下传输二进制数据需要将二进制数据转换为字符数据。然而直接转换是不行的。因为网络传输只能传输可打印字符。

**可打印字符：**在ASCII码中规定，031、127这33个字符属于控制字符，32126这95个字符属于可打印字符，也就是说网络传输只能传输这95个字符，不在这个范围内的字符无法传输。那么该怎么才能传输其他字符呢？其中一种方式就是使用Base64。

大多数编码都是由字符串转化成二进制的过程，而Base64的编码则是从二进制转换为字符串。与常规恰恰相反。

Base64编码主要用在传输、存储、表示二进制领域，不能算得上加密，只是无法直接看到明文。也可以通过打乱Base64编码来进行加密。

中文有多种编码（比如：utf-8、gb2312、gbk等），不同编码对应Base64编码结果都不一样。


java.util.Base64工具类：该类仅由用于获得Base64编码方案的编码器和解码器的静态方法组成。

作用：

  • 使用Base64里边的编码器对数据进行编码(加密)
  • 使用Base64里边的解码器对数据进行解码(解密)

Base64工具类 静态方法：

// 使用Basic型base64编码方案
static Base64.Encoder getEncoder() 		// 获取加密器(编码器)
static Base64.Decoder getDecoder() 		// 获取解密器(解码器)
    
// 使用MIME型base64编码方案
static Base64.Encoder getMineEncoder() 		// 获取加密器(编码器)
static Base64.Decoder getMineDecoder() 		// 获取解密器(解码器)
static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator)	// 指定行长度和行分隔符获取加密器
    
// 使用 URL and Filename safe 型base64编码方案
static Base64.Encoder getUrlEncoder() 		// 获取加密器(编码器)
static Base64.Decoder getUrlDecoder() 		// 获取解密器(解码器)

java.util.Base64.Encoder：是Base64的内部类，用于对数据进行加密

Encoder 的成员方法：

String encodeToString(byte[] src) 		// 使用Base64编码方案将指定的字节数组编码为字符串。

java.util.Base64.Decoder：是Base64的内部类，用于对数据进行解密

Decoder 的成员方法：

 byte[] decode(String src) 		// 使用Base64编码方案将Base64编码的字符串解码为新分配的字节数组。

实例：

import java.util.Base64;

public class Demo01Base64 {
    public static void main(String[] args) {
        //定义一个原始的没有加密的字符串
        String s1 = "国家的绝密文件!";
        System.out.println("原字符串:"+s1);		//原字符串:国家的绝密文件!

        //使用加密器Encoder中的方法encodeToString把字符串进行加密
        //Base64.Encoder encoder = Base64.getEncoder();//获取加密器
        //String s2 = encoder.encodeToString(s1.getBytes());//调用加密方法进行加密
        String s2 = Base64.getEncoder().encodeToString(s1.getBytes());
        System.out.println("加密后的字符串:"+s2);	//加密后的字符串：5Zu95a6255qE57ud5a+G5paH5Lu2IQ==

        //使用解密器Decoder中的方法decode把加密的字符串进行解密
        byte[] bytes = Base64.getDecoder().decode(s2);
        String s3 = new String(bytes);
        System.out.println("解密后的字符串:"+s3);	//解密后的字符串:国家的绝密文件!
    }
}

RSA加密和解密

一、概述

  • RSA是基于大数因子分解难题。目前各种主流计算机语言都支持RSA算法的实现
  • java6及以上版本支持RSA算法
  • RSA算法可以用于数据加密和数字签名
  • RSA算法相对于DES/AES等对称加密算法，他的速度要慢的多
  • 总原则：公钥加密，私钥解密 / 私钥加密，公钥解密

二、模型分析

RSA算法构建密钥对简单，这里以甲乙双方发送数据为模型

  1. 甲方在本地构建密钥对（公钥+私钥），并将公钥公布给乙方

  2. 甲方将数据用私钥进行加密，发送给乙方

  3. 乙方用甲方提供的公钥对数据进行解密

如果乙方向传送数据给甲方：

  1. 乙方用公钥对数据进行加密，然后传送给甲方

  2. 甲方用私钥对数据进行解密


三、代码分析

package com.rsa;

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

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;


/**
 * 非对称加密算法RSA算法组件
 * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要
 * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单
 *
 * @author kongqz
 */
public class RSACoder {
    //非对称密钥算法
    public static final String KEY_ALGORITHM = "RSA";


    /**
     * 密钥长度，DH算法的默认密钥长度是1024
     * 密钥长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 512;
    //公钥
    private static final String PUBLIC_KEY = "RSAPublicKey";

    //私钥
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 初始化密钥对
     *
     * @return Map 甲方密钥的Map
     */
    public static Map<String, Object> initKey() throws Exception {
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String, Object> keyMap = new HashMap<String, Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }


    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key       密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥加密
     *
     * @param data 待加密数据
     * @param key       密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return byte[] 私钥
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return byte[] 公钥
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }

    /**
     * 测试
     */
    public static void main(String[] args) throws Exception {
        //初始化密钥
        //生成密钥对
        Map<String, Object> keyMap = RSACoder.initKey();
        //公钥
        byte[] publicKey = RSACoder.getPublicKey(keyMap);
        //私钥
        byte[] privateKey = RSACoder.getPrivateKey(keyMap);
        System.out.println("公钥：" + Base64.encodeBase64String(publicKey));
        System.out.println("私钥：" + Base64.encodeBase64String(privateKey));

        System.out.println("==========密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输==========");
        String str = "RSA密码交换算法";
        System.out.println("===========甲方向乙方发送加密数据==============");
        System.out.println("原文:" + str);
        //甲方进行数据的加密
        byte[] code1 = RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);
        System.out.println("加密后的数据：" + Base64.encodeBase64String(code1));
        System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
        //乙方进行数据的解密
        byte[] decode1 = RSACoder.decryptByPublicKey(code1, publicKey);
        System.out.println("乙方解密后的数据：" + new String(decode1));

        System.out.println("===========反向进行操作，乙方向甲方发送数据==============");

        str = "乙方向甲方发送数据RSA算法";
        System.out.println("原文:" + str);
        //乙方使用公钥对数据进行加密
        byte[] code2 = RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
        System.out.println("===========乙方使用公钥对数据进行加密==============");
        System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));

        System.out.println("=============乙方将数据传送给甲方======================");
        System.out.println("===========甲方使用私钥对数据进行解密==============");
        //甲方使用私钥对数据进行解密
        byte[] decode2 = RSACoder.decryptByPrivateKey(code2, privateKey);
        System.out.println("甲方解密后的数据：" + new String(decode2));
    }
}
举报

相关推荐

应用数据加密技术概述

加密技术运维yyds干货盘点

JavaScript常规加密技术

字符串数据二进制数JavaScript前端开发

apk伪加密技术

压缩文件2dzip压缩Python后端开发

对称加密和非对称加密技术

对称加密非对称加密数据前端开发

08-加密技术应用

网络协议华为网络安全

【Python】数据加密解密技术

python爬虫数据分析

js常见混淆加密技术

加密技术JS混淆JS加密JS解密JS安全JavaScript前端开发

Java加密技术（四）——非对称加密算…

数据数字签名加密算法JavaScript前端开发

SSL双向认证加密技术图解

ssl双向认证加密

加密解密技术基础、PKI和OpenSSL

安全httppkiopenssl加密解密
0 条评论