密码与我们的生活息息相关,远到国家机密,近到个人账户,我们每天都在跟密码打交道:

那么,密码从何而来?生活中常见的加密是怎么实现的?怎么保证个人信息安全?本文将从这几方面进行浅谈,如有纰漏,敬请各位大佬指正。

代码部分从第二章节——常见加密算法开始,对代码比较感兴趣的铁子们可以从第二章节开始看。

一、 密码学发展史

密码学是网络安全、信息安全、区块链等产品的基础,常见的非对称加密、对称加密、散列函数等,都属于密码学范畴。

密码学有数千年的历史,从最开始的替换法到如今的非对称加密算法,经历了古典密码学,近代密码学和现代密码学三个阶段。密码学不仅仅是数学家们的智慧,更是如今网络空间安全的重要基础。

1.1 古典密码学

古典密码的加密方式主要有替换法和移位法。古典密码虽然很简单,但是在密码史上是使用的最久的加密方式,直到“概率论”的数学方法被发现,古典密码就被破解了。

1.2 近代密码学

古典密码的安全性受到了威胁,外加使用便利性较低,到了工业化时代,近现代密码被广泛应用。

恩尼格玛机

恩尼格玛机是二战时期纳粹德国使用的加密机器,后被英国破译,参与破译的人员有被称为计算机科学之父、人工智能之父的图灵。

1.3 现代密码学

① 散列函数

散列函数,也见杂凑函数、摘要函数或哈希函数,可将任意长度的消息经过运算,变成固定长度数值,常见的有MD5、SHA-1、SHA256,多应用在文件校验,数字签名中。

MD5 可以将任意长度的原文生成一个128位(16字节)的哈希值

SHA-1可以将任意长度的原文生成一个160位(20字节)的哈希值

② 对称密码

对称密码应用了相同的加密密钥和解密密钥。对称密码分为:序列密码(流密码),分组密码(块密码)两种。流密码是对信息流中的每一个元素(一个字母或一个比特)作为基本的处理单元进行加密,块密码是先对信息流分块,再对每一块分别加密。

例如原文为1234567890,流加密即先对1进行加密,再对2进行加密,再对3进行加密……最后拼接成密文;块加密先分成不同的块,如1234成块,5678成块,90XX(XX为补位数字)成块,再分别对不同块进行加密,最后拼接成密文。前文提到的古典密码学加密方法,都属于流加密。

③ 非对称密码

对称密码的密钥安全极其重要,加密者和解密者需要提前协商密钥,并各自确保密钥的安全性,一但密钥泄露,即使算法是安全的也无法保障原文信息的私密性。

在实际的使用中,远程的提前协商密钥不容易实现,即使协商好,在远程传输过程中也容易被他人获取,因此非对称密钥此时就凸显出了优势。

非对称密码有两支密钥,公钥(publickey)和私钥(privatekey),加密和解密运算使用的密钥不同。用公钥对原文进行加密后,需要由私钥进行解密;用私钥对原文进行加密后(此时一般称为签名),需要由公钥进行解密(此时一般称为验签)。公钥可以公开的,大家使用公钥对信息进行加密,再发送给私钥的持有者,私钥持有者使用私钥对信息进行解密,获得信息原文。因为私钥只有单一人持有,因此不用担心被他人解密获取信息原文。

二、常见加密算法

让我们来看看生活中常见的几种加密方式:

2.1 对称加密算法

采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。

示例

  • 我们现在有一个原文3要发送给B
  • 设置密钥为108, 3 * 108 = 324, 将324作为密文发送给B
  • B拿到密文324后, 使用324/108 = 3 得到原文

常见加密算法

DES : Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛流传开来。

AES : Advanced Encryption Standard, 高级加密标准 .在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。

特点

  • 加密速度快, 可以加密大文件
  • 密文可逆, 一旦密钥文件泄漏, 就会导致数据暴露
  • 加密后编码表找不到对应字符, 出现乱码
  • 一般结合Base64使用

2.1.1 DES加密

示例代码 des加密算法

Cipher :文档 https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html#getInstance-java.lang.String-

运行:

出现这个bug的原因是DES算法规定,key必须是8个字节;

修改 密钥 key = “12345678” ,再次运行 ,出现乱码是因为对应的字节出现负数,但负数没有出现在 ascii 码表里面,所以出现乱码,需要配合base64进行转码

2.1.2 拓展:base64编码

在Java 8中,Base64编码已经成为Java类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:

- 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。

- URL:输出映射到一组字符A-Za-z0-9+_,输出是URL和文件。

- MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

上面的例子用Java8自带的base64进行编码:

运行:

除了上面的编码方式外,base64还有其他的编码方式,由于笔者时间有限,没有过多研究,在此放入一个demo,供大家参考:

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.UUID; /**
* 在Java 8中,Base64编码已经成为Java类库的标准。
* Java 8 内置了 Base64 编码的编码器和解码器。
* Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:
* <p>
* 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。
* URL:输出被映射到一组字符A-Za-z0-9+_,输出是URL和文件。
* MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割。
*/
public class Base64Test { private static final String UTF_8 = "utf-8";
private static final int MAX = 10; @Test
public void base64() throws UnsupportedEncodingException {
// test();
// basic();
url();
// mime(); } /**
* 测试几个特殊字符
*/
private void test() throws UnsupportedEncodingException {
String ss = "星期五?/\\|";
System.out.println("ordinal : " + ss);
byte[] encode = Base64.getEncoder().encode(ss.getBytes(UTF_8));
System.out.println("basic encode : " + new String(encode, UTF_8)); byte[] decode = Base64.getDecoder().decode(encode);
System.out.println("Using Basic : " + new String(decode, UTF_8)); byte[] decode1 = Base64.getUrlDecoder().decode(encode);
System.out.println("Using URL : " + new String(decode1, UTF_8)); byte[] decode2 = Base64.getMimeDecoder().decode(encode);
System.out.println("Using MIME : " + new String(decode2, UTF_8)); System.out.println();
} /**
* MIME编码器会使用基本的字母数字产生BASE64输出,
* 而且对MIME格式友好:每一行输出不超过76个字符,而且每行以“\r\n”符结束
*/
private void mime() throws UnsupportedEncodingException { StringBuilder sb = new StringBuilder();
for (int t = 0; t < MAX; ++t) {
sb.append(UUID.randomUUID().toString());
} byte[] toEncode = sb.toString().getBytes("utf-8");
String mimeEncoded = Base64.getMimeEncoder().encodeToString(toEncode);
System.out.println("Using MIME : ");
System.out.println(mimeEncoded);
} /**
* 但由于URL对反斜线“/”有特殊的意义,因此URL编码需要替换掉它,使用下划线替换
* 如果是使用基本的编码器,那么输出可能会包含反斜线“/”字符,
* 但是如果使用URL编码器,那么输出的内容对URL来说是安全的。
*/
private void url() throws UnsupportedEncodingException { String ordinal = "subjects?abcd";
System.out.println("ordinal : " + ordinal); // 输出为: Using Basic Alphabet: c3ViamVjdHM/YWJjZA==
String basicEncoded = Base64.getEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using Basic : " + basicEncoded); byte[] decode = Base64.getDecoder().decode(basicEncoded);
System.out.println("basic decode : " + new String(decode, UTF_8));
System.out.println();
System.out.println("ordinal : " + ordinal);
String urlEncoded = Base64.getUrlEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using URL : " + urlEncoded); byte[] decode1 = Base64.getUrlDecoder().decode(urlEncoded);
System.out.println("url decode : " + new String(decode1, UTF_8));
System.out.println(); String mimeEncoded = Base64.getMimeEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using mime : " + mimeEncoded);
byte[] decode2 = Base64.getMimeDecoder().decode(mimeEncoded);
System.out.println("mime decode : " + new String(decode2, UTF_8));
System.out.println(); } /**
* Basic编码是标准的BASE64编码,用于处理常规的需求:输出的内容不添加换行符,而且输出的内容由字母加数字组成。
*/
private void basic() throws UnsupportedEncodingException {
String s = "some string";
System.out.println("ordinal : " + s);
// 编码
String asB64 = Base64.getEncoder().encodeToString(s.getBytes(UTF_8));
// 输出为: c29tZSBzdHJpbmc=
System.out.println("Using Basic : " + asB64); // 解码
byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");
// 输出为: some string
System.out.println("basic decode : " + new String(asBytes, UTF_8));
System.out.println();
}
}

运行:

2.1.3 DES解密

在2.1.1中的例子基础上加入解密方法

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64; public class DesDemo {
// DES加密算法,key的大小必须是8个字节 public static void main(String[] args) throws Exception {
String input ="华为";
// DES加密算法,key的大小必须是8个字节
String key = "12345678"; String transformation = "DES"; // 9PQXVUIhaaQ=
// 指定获取密钥的算法
String algorithm = "DES";
String encryptDES = encryptDES(input, key, transformation, algorithm);
System.out.println("加密:" + encryptDES);
String s = decryptDES(encryptDES, key, transformation, algorithm);
System.out.println("解密:" + s); } /**
* 使用DES加密数据
*
* @param input : 原文
* @param key : 密钥(DES,密钥的长度必须是8个字节)
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @return : 密文
* @throws Exception
*/
private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 获取加密对象
Cipher cipher = Cipher.getInstance(transformation);
// 创建加密规则
// 第一个参数key的字节
// 第二个参数表示加密算法
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// ENCRYPT_MODE:加密模式
// DECRYPT_MODE: 解密模式
// 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks);
// 加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 输出加密后的数据
String encode = new String(Base64.getEncoder().encode(bytes), "UTF-8"); // System.out.println(encode);
return encode;
} /**
* 使用DES解密
*
* @param input : 密文
* @param key : 密钥
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @throws Exception
* @return: 原文
*/
private static String decryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 1,获取Cipher对象
Cipher cipher = Cipher.getInstance(transformation);
// 指定密钥规则
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
cipher.init(Cipher.DECRYPT_MODE, sks);
// 3. 解密,上面使用的base64编码,下面直接用密文
byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(input)); // System.out.println("解密" + new String(decode, "UTF-8"));
// 因为是明文,所以直接返回
return new String(bytes);
}
}

运行:

2.1.4 AES加密解密

AES 加密解密和 DES 加密解密代码一样,只需要修改加密算法就行,在此不做过多阐述,值得注意的是:AES 加密的密钥key , 需要传入16个字节.

2.1.5 加密模式

AES的加密模式如下:

参考链接:https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html

这里主要介绍两种加密模式:ECB和CBC

ECB

Electronic codebook, 电子密码本. 需要加密的消息按照块密码的块大小被分为数个块,并对每个块进行独立加密

  • 优点 : 可以并行处理数据
  • 缺点 : 同样的原文生成同样的密文, 不能很好的保护数据
  • 同时加密,原文是一样的,加密出来的密文也是一样的

CBC

Cipher-block chaining, 密码块链接. 每个明文块先与前一个密文块进行异或后,再进行加密。在这种方法中,每个密文块都依赖于它前面的所有明文块

  • 优点 : 同样的原文生成的密文不一样
  • 缺点 : 串行处理数据.

2.1.6 填充模式

当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则,这里主要介绍以下两种:

NoPadding

  • 不填充.
  • 在DES加密算法下, 要求原文长度必须是8byte的整数倍
  • 在AES加密算法下, 要求原文长度必须是16byte的整数倍

PKCS5Padding

  • 数据块的大小为8位, 不够就补足

Tips

  • 默认情况下, 加密模式和填充模式为 : ECB/PKCS5Padding
  • 如果使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new IvParameterSpec(key.getBytes());

加密模式和填充模式:其中括号里数字表示加密位数,位数越高,则越安全

加密模式和填充模式例子

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; /**
* 功能描述: 加密模式和填充模式例子
*
* @author cWX970190
* @since 2020-10-11
*/
import com.sun.org.apache.xml.internal.security.utils.Base64; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec; public class DesDemo {
// DES加密算法,key的大小必须是8个字节 public static void main(String[] args) throws Exception { String input ="华为"; // DES加密算法,key的大小必须是8个字节
String key = "12345678"; // 指定获取Cipher的算法,如果没有指定加密模式和填充模式,ECB/PKCS5Padding就是默认值
// String transformation = "DES"; // 9PQXVUIhaaQ= //String transformation = "DES/ECB/PKCS5Padding"; // 9PQXVUIhaaQ= // CBC模式,必须指定初始向量,初始向量中密钥的长度必须是8个字节
// String transformation = "DES/CBC/PKCS5Padding"; // 9PQXVUIhaaQ= // NoPadding模式,原文的长度必须是8个字节的整倍数 ,所以必须把 硅谷改成硅谷12
String transformation = "DES/CBC/NoPadding"; // 9PQXVUIhaaQ= // 指定获取密钥的算法
String algorithm = "DES"; String encryptDES = encryptDES(input, key, transformation, algorithm); System.out.println("加密:" + encryptDES);
String s = dncryptDES(encryptDES, key, transformation, algorithm);
System.out.println("解密:" + s); } /**
* 使用DES加密数据
*
* @param input : 原文
* @param key : 密钥(DES,密钥的长度必须是8个字节)
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @return : 密文
* @throws Exception
*/
private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 获取加密对象
Cipher cipher = Cipher.getInstance(transformation);
// 创建加密规则
// 第一个参数key的字节
// 第二个参数表示加密算法
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// ENCRYPT_MODE:加密模式
// DECRYPT_MODE: 解密模式
// 初始向量,参数表示跟谁进行异或,初始向量的长度必须是8位
// IvParameterSpec iv = new IvParameterSpec(key.getBytes()); // 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks);
// 加密 byte[] bytes = cipher.doFinal(input.getBytes()); // 输出加密后的数据
String encode = Base64.encode(bytes); return encode;
} /**
* 使用DES解密
*
* @param input : 密文
* @param key : 密钥
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @throws Exception
* @return: 原文
*/
private static String dncryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 1,获取Cipher对象
Cipher cipher = Cipher.getInstance(transformation);
// 指定密钥规则
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// IvParameterSpec iv = new IvParameterSpec(key.getBytes());
cipher.init(Cipher.DECRYPT_MODE, sks);
// 3. 解密
byte[] bytes = cipher.doFinal(Base64.decode(input)); return new String(bytes);
}
}

运行:

非填充模式下,原文必须是8个字节,修改加密模式为:

 String transformation = "DES/CBC/PKCS5Padding";

再次运行:

发现加密没有问题,但是解密时需要添加一个参数,添加参数并修改初始化规则:

  // 初始向量,参数表示跟谁进行异或,初始向量的长度必须是8位
IvParameterSpec iv = new IvParameterSpec(key.getBytes()); // 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks,iv);

再次运行:

在测试 AES 的时候需要注意,key需要16个字节,加密向量也需要16个字节 ,其他方式跟 DES 一样。

2.2 消息摘要(单向散列)函数

消息摘要(Message Digest)又称为数字摘要(Digital Digest)

它是一个唯一对应一个消息或文本的固定长度的值,它由一个单向Hash加密函数对消息进行作用而产生

使用数字摘要生成的值是不可以篡改的,为了保证文件或者值的安全

2.2.1 特点

无论输入的消息有多长,计算出来的消息摘要的长度总是固定的。例如应用MD5算法摘要的消息有128个比特位,用SHA-1算法摘要的消息最终有160比特位的输出

只要输入的消息不同,对其进行摘要以后产生的摘要消息也必不相同;但相同的输入必会产生相同的输出

消息摘要是单向、不可逆的

常见算法 :

  • MD5
  • SHA1
  • SHA256
  • SHA512

浏览器搜索 tomcat ,进入官网下载 ,会经常发现有 sha1,sha512 , 这些都是数字摘要

2.2.2 获取字符串消息摘要

运行:

使用在线 md5 加密 ,发现我们生成的值和代码生成的值不一样,那是因为消息摘要不是使用base64进行编码的,所以我们需要把值转成16进制。

数字摘要转换成 16 进制

package com.huawei.it.jalor.boot.test;

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/ import com.sun.org.apache.xml.internal.security.utils.Base64; import java.security.MessageDigest; public class DigestDemo1 { public static void main(String[] args) throws Exception{
// 原文
String input = "aa";
// 算法
String algorithm = "MD5";
// 获取数字摘要对象
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 获取消息数字摘要的字节数组
byte[] digest = messageDigest.digest(input.getBytes("UTF-8"));
// System.out.println(new String(digest));
// base64编码
// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder(); for (byte b : digest) {
// 转成 16进制
String s = Integer.toHexString(b & 0xff);
//System.out.println(s);
if (s.length() == 1){
// 如果生成的字符只有一个,前面补0
s = "0"+s;
}
sb.append(s);
}
System.out.println(sb.toString()); }
}

运行,结果和在线一致:

2.2.3 其他消息摘要算法

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/
import java.security.MessageDigest; /**
* DigestDemo1
*
* @Author: 陈志强
* @CreateTime: 2020-03-17
* @Description:
*/
public class DigestDemo1 { public static void main(String[] args) throws Exception{
// 4124bc0a9335c27f086f24ba207a4912 md5 在线校验
// QSS8CpM1wn8IbyS6IHpJEg== 消息摘要使用的是16进制
// 原文
String input = "aa";
// 算法
String algorithm = "MD5";
// 获取数字摘要对象
String md5 = getDigest(input, "MD5");
System.out.println(md5); String sha1 = getDigest(input, "SHA-1");
System.out.println(sha1); String sha256 = getDigest(input, "SHA-256");
System.out.println(sha256); String sha512 = getDigest(input, "SHA-512");
System.out.println(sha512); } private static String toHex(byte[] digest) throws Exception { // System.out.println(new String(digest));
// base64编码
// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder(); for (byte b : digest) {
// 转成 16进制
String s = Integer.toHexString(b & 0xff);
if (s.length() == 1){
// 如果生成的字符只有一个,前面补0
s = "0"+s;
}
sb.append(s);
}
System.out.println("16进制数据的长度:" + sb.toString().getBytes().length);
return sb.toString();
} private static String getDigest(String input, String algorithm) throws Exception {
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 消息数字摘要
byte[] digest = messageDigest.digest(input.getBytes());
System.out.println("密文的字节长度:" + digest.length); return toHex(digest);
}
}

运行:

2.2.4 获取文件消息摘要

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.security.MessageDigest; /**
* DigestDemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-11
* @Description:
*/
public class DigestDemo { public static void main(String[] args) throws Exception{
String input = "aa";
String algorithm = "MD5"; // sha1 可以实现秒传功能 String sha1 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-1");
System.out.println(sha1); String sha512 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-512");
System.out.println(sha512); // String md5 = getDigest("aa", "MD5");
// System.out.println(md5);
//
// String md51 = getDigest("aa ", "MD5");
// System.out.println(md51);
} private static String getDigestFile(String filePath, String algorithm) throws Exception{
FileInputStream fis = new FileInputStream(filePath);
int len;
byte[] buffer = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ( (len = fis.read(buffer))!=-1){
baos.write(buffer,0,len);
}
// 获取消息摘要对象
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 获取消息摘要
byte[] digest = messageDigest.digest(baos.toByteArray());
System.out.println("密文的字节长度:"+digest.length);
return toHex(digest);
} private static String getDigest(String input, String algorithm) throws Exception{
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
byte[] digest = messageDigest.digest(input.getBytes());
System.out.println("密文的字节长度:"+digest.length);
return toHex(digest);
} private static String toHex(byte[] digest) {
// System.out.println(new String(digest));
// 消息摘要进行表示的时候,是用16进制进行表示
StringBuilder sb = new StringBuilder();
for (byte b : digest) {
// 转成16进制 String s = Integer.toHexString(b & 0xff);
// 保持数据的完整性,前面不够的用0补齐
if (s.length()==1){
s="0"+s;
}
sb.append(s);
}
System.out.println("16进制数据的长度:"+ sb.toString().getBytes().length);
return sb.toString();
}
}

运行结果:

查看官网上的sha512加密结果,发现一致:

使用 sha-1 算法,可以实现秒传功能,只要是同一文件的加密,不管如何修改文件的名字,最后得到的值是一样的,具体可以自己测试。

不过,如果原文不一样,例如,下图上面的原文多两个空格:

运行后:

总结

  • MD5算法 : 摘要结果16个字节, 转16进制后32个字节
  • SHA1算法 : 摘要结果20个字节, 转16进制后40个字节
  • SHA256算法 : 摘要结果32个字节, 转16进制后64个字节
  • SHA512算法 : 摘要结果64个字节, 转16进制后128个字节

2.3 非对称加密

简介:

① 非对称加密算法又称现代加密算法。

② 非对称加密是计算机通信安全的基石,保证了加密数据不会被破解。

③ 与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey) 和私有密(privatekey)

④ 公开密钥和私有密钥是一对

⑤ 如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密。

⑥ 如果用私有密钥对数据进行加密,只有用对应的公开密钥才能解密。

⑦ 因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

示例

首先生成密钥对, 公钥为(5,14), 私钥为(11,14)

现在A希望将原文2发送给B

A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B

B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2

特点

  • 加密和解密使用不同的密钥
  • 如果使用私钥加密, 只能使用公钥解密
  • 如果使用公钥加密, 只能使用私钥解密
  • 处理数据的速度较慢, 因为安全级别高

常见算法

RSA

ECC

2.3.1 生成公钥和私钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception { // 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 打印私钥
System.out.println(privateKeyString);
// 打印公钥
System.out.println(publicKeyString);
}
}

运行程序,先打印私钥,再打印公钥:

2.3.2 私钥加密

import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "华为";
// 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded); // 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes)); }
}

运行程序:

2.3.3 私钥加密私钥解密

public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "华为";
// 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,privateKey);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1)); }
}

运行结果error,因为私钥加密,只能公钥解密:

2.3.4 私钥加密公钥解密

修改2.3.3中的代码

// 公钥进行解密
cipher.init(Cipher.DECRYPT_MODE,publicKey);

再次运行

2.3.5 公钥加密和公钥解密

一样会报错

2.3.6 保存公私钥

有些情况下需要把加密和解密的方法全部到本地的根目录下面:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA"; //生成密钥对并保存在本地文件中
generateKeyToFile(algorithm, "a.pub", "a.pri"); //加密
// String s = encryptRSA(algorithm, privateKey, input);
// 解密
// String s1 = decryptRSA(algorithm, publicKey, s);
// System.out.println(s1); } /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}

运行程序后,本地多了两个文件,打开:

2.3.7 读取私钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm); } public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}

2.3.8 读取公钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; /**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm); String s = encryptRSA(algorithm, privateKey, input);
String s1 = decryptRSA(algorithm, publicKey, s);
System.out.println(s);
System.out.println(s1); } public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
} public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
}
}

运行程序

2.4 数字签名

我们经常会用到数字签名,只是大家平时不太注意,比如我们访问银行 ,证券公司,基金公司,金融类的公司网站全部都是 https 协议,如果是 https 协议,那么都需要有一个证书。签名可以用来验证网络传输数据的时候,数据是否被人篡改。

签名的作用简单来说就是证明某个文件上的内容确实是我写的,别人不能冒充我的签名(不可伪造),我也不能否认上面的签名是我的(不可抵赖)。

我们知道,手写签名之所以不能伪造,是因为每一个人的笔迹都是独一无二的,即使模仿,也可以通过专家鉴定分别出来。而不可抵赖,是因为每个人的笔迹都有固定特征,这些特征是很难摆脱的。

正是这两点特性使得手写签名在日常生活中被广泛承认,比如签合同、借条等等。

数字签名的要求是,只有我自己能签我的名字,其他人能验证我的签名,但是不能伪造我的签名。

2.4.1 网页加密

我们看一个应用“数字证书”的实例:https协议。这个协议主要用于网页加密

首先,客户端向服务器发出加密请求。

服务器用自己的私钥加密网页以后,连同本身的数字证书,一起发送给客户端。

客户端(浏览器)的“证书管理器”,有“受信任的根证书颁发机构”列表。客户端会根据这张列表,查看解开数字证书的公钥是否在列表之内。

如果数字证书记载的网址,与你正在浏览的网址不一致,就说明这张证书可能被冒用,浏览器会发出警告。

如果这张数字证书不是由受信任的机构颁发的,浏览器会发出另一种警告。

如果数字证书是可靠的,客户端就可以使用证书中的服务器公钥,对信息进行加密,然后与服务器交换加密信息。

2.4.2 证书从哪里来

“证书中心”(certificate authority,简称CA),为公钥做认证。证书中心用自己的私钥,对公钥和一些相关信息一起加密,生成“数字证书”(Digital Certificate)。

拿到数字证书以后,就可以放心了。以后只要在签名的同时,再附上数字证书就行了。

用CA的公钥解开数字证书,就可以拿到真实的公钥了,然后就能证明“数字签名”是否真的是公司签的。

修改之前的RSAdemo代码:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; /**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm);
String s = encryptRSA(algorithm, privateKey, input);
String s1 = decryptRSA(algorithm, publicKey, s);
System.out.println(s);
System.out.println(s1); } public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
} public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
} /**
* 从文件中加载公钥
*
* @param algorithm : 算法
* @param filePath : 文件路径
* @return : 公钥
* @throws Exception
*/
public static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8")); return loadPublicKeyFromString(algorithm, keyString); } /**
* 从字符串中加载公钥
*
* @param algorithm : 算法
* @param keyString : 公钥字符串
* @return : 公钥
* @throws Exception
*/
public static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {
// 进行Base64解码
byte[] decode = Base64.decode(keyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范
X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);
// 获取公钥
return keyFactory.generatePublic(keyspec); } /**
* 从文件中加载私钥
*
* @param algorithm : 算法
* @param filePath : 文件路径
* @return : 私钥
* @throws Exception
*/
public static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
return loadPrivateKeyFromString(algorithm, keyString); } /**
* 从字符串中加载私钥
*
* @param algorithm : 算法
* @param keyString : 私钥字符串
* @return : 私钥
* @throws Exception
*/
public static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {
// 进行Base64解码
byte[] decode = Base64.decode(keyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范
PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);
// 生成私钥
return keyFactory.generatePrivate(keyspec); }
}

写一个验证数字签名的类:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64; import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature; /**
* 功能描述: 验证数字签名
*
* @author cWX970190
* @since 2020-10-11
*/
public class SignatureDemo {
public static void main(String[] args) throws Exception {
String a = "123";
PublicKey publicKey =RSAdemo.loadPublicKeyFromFile("RSA", "a.pub");
PrivateKey privateKey = RSAdemo.loadPrivateKeyFromFile("RSA", "a.pri");
String signaturedData = getSignature(a, "sha256withrsa", privateKey);
boolean b = verifySignature(a, "sha256withrsa", publicKey, signaturedData);
System.out.println(b);
} /**
* 生成签名
*
* @param input : 原文
* @param algorithm : 算法
* @param privateKey : 私钥
* @return : 签名
* @throws Exception
*/
private static String getSignature(String input, String algorithm, PrivateKey privateKey) throws Exception {
// 获取签名对象
Signature signature = Signature.getInstance(algorithm);
// 初始化签名
signature.initSign(privateKey);
// 传入原文
signature.update(input.getBytes());
// 开始签名
byte[] sign = signature.sign();
// 对签名数据进行Base64编码
return Base64.encode(sign);
} /**
* 校验签名
*
* @param input : 原文
* @param algorithm : 算法
* @param publicKey : 公钥
* @param signaturedData : 签名
* @return : 数据是否被篡改
* @throws Exception
*/
private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signaturedData) throws Exception {
// 获取签名对象
Signature signature = Signature.getInstance(algorithm);
// 初始化签名
signature.initVerify(publicKey);
// 传入原文
signature.update(input.getBytes());
// 校验数据
return signature.verify(Base64.decode(signaturedData)); }
}

运行,验证成功:

拓展: 2.5 Byte和bit

Byte : 字节. 数据存储的基本单位,比如移动硬盘1T , 单位是byte

bit : 比特, 又叫位. 一个位要么是0要么是1. 数据传输的单位 , 比如家里的宽带100MB,下载速度并没有达到100MB,一般都是12-13MB,那么是因为需要使用 100 / 8

关系: 1Byte = 8bit

2.5.1 获取字符串byte

/**
* ByteBit
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class ByteBit {
public static void main(String[] args) {
String a = "a";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
int c=b;
// 打印发现byte实际上就是ascii码
System.out.println(c);
}
}
}

运行结果:

和ascii码表一致

2.5.2 byte对应bit

public class ByteBit {
public static void main(String[] args) {
String a = "a";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
int c=b;
// 打印发现byte实际上就是ascii码
System.out.println(c);
// 我们在来看看每个byte对应的bit,byte获取对应的bit
String s = Integer.toBinaryString(c);
System.out.println(s);
}
}
}

运行结果

2.5.3 中文对应的字节

package com.huawei.it.jalor.boot.test;

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/
public class ByteBitDemo {
public static void main(String[] args) throws Exception{ String a = "华";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
System.out.print(b + " ");
String s = Integer.toBinaryString(b);
System.out.println(s);
}
} }

运行程序,我们发现一个中文是有 3 个字节组成:

我们修改 编码格式 , 编码格式改成 GBK

修改代码

 // UTF-8:编码格式占3个字节
byte[] bytes = a.getBytes("GBK");

再运行发现变成了 2 个字节

2.5.4 英文对应的字节

/**
* ByteBit
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class ByteBit {
public static void main(String[] args) throws Exception{ String a = "a";
byte[] bytes = a.getBytes();
// 在中文情况下,不同的编码格式,对应不同的字节
// byte[] bytes = a.getBytes("GBK");
for (byte b : bytes) {
System.out.print(b + " ");
String s = Integer.toBinaryString(b);
System.out.println(s);
}
}
}

运行程序

三、如何设置密码才安全

通过上述密码学发展史的介绍,以及对常见加密算法的阐述,相信大家对密码应该有了较为理性的认识,那么,如何设置密码才安全呢?这里给出一点小建议:

- 密码不要太常见,不要使用类似于123456式的常用密码。

- 各应用软件密码建议不同,避免出现一个应用数据库被脱库,全部应用密码崩塌,

- 可在设置密码时增加注册时间、注册地点、应用特性等方法。例如tianjin123456,表示在天津注册的该应用

参考文献:

现代密码学之对称加密-DES及AES算法- element ui
http://element-ui.cn/article/show-97007.aspx

Java Base64 编码与解码----三种实现方式的代码实例
https://blog.csdn.net/qq_27093465/article/details/93977519

网络安全之密码学:信息安全
https://www.bilibili.com/video/av583369085/

好了,本期的分享到此就跟大家saygoodbye了,密码学博大精深,本文只是浅尝辄止,关于密码学的知识一直都在更新,希望下次可以给大家带来更前沿、更实用的密码学相关知识,喜欢的老铁欢迎关注点赞,笔芯 !!!

点击关注,第一时间了解华为云新鲜技术~

密码与我们的生活息息相关,远到国家机密,近到个人账户,我们每天都在跟密码打交道:

那么,密码从何而来?生活中常见的加密是怎么实现的?怎么保证个人信息安全?本文将从这几方面进行浅谈,如有纰漏,敬请各位大佬指正。

代码部分从第二章节——常见加密算法开始,对代码比较感兴趣的铁子们可以从第二章节开始看。

一、 密码学发展史

密码学是网络安全、信息安全、区块链等产品的基础,常见的非对称加密、对称加密、散列函数等,都属于密码学范畴。

密码学有数千年的历史,从最开始的替换法到如今的非对称加密算法,经历了古典密码学,近代密码学和现代密码学三个阶段。密码学不仅仅是数学家们的智慧,更是如今网络空间安全的重要基础。

1.1 古典密码学

古典密码的加密方式主要有替换法和移位法。古典密码虽然很简单,但是在密码史上是使用的最久的加密方式,直到“概率论”的数学方法被发现,古典密码就被破解了。

1.2 近代密码学

古典密码的安全性受到了威胁,外加使用便利性较低,到了工业化时代,近现代密码被广泛应用。

恩尼格玛机

恩尼格玛机是二战时期纳粹德国使用的加密机器,后被英国破译,参与破译的人员有被称为计算机科学之父、人工智能之父的图灵。

1.3 现代密码学

① 散列函数

散列函数,也见杂凑函数、摘要函数或哈希函数,可将任意长度的消息经过运算,变成固定长度数值,常见的有MD5、SHA-1、SHA256,多应用在文件校验,数字签名中。

MD5 可以将任意长度的原文生成一个128位(16字节)的哈希值

SHA-1可以将任意长度的原文生成一个160位(20字节)的哈希值

② 对称密码

对称密码应用了相同的加密密钥和解密密钥。对称密码分为:序列密码(流密码),分组密码(块密码)两种。流密码是对信息流中的每一个元素(一个字母或一个比特)作为基本的处理单元进行加密,块密码是先对信息流分块,再对每一块分别加密。

例如原文为1234567890,流加密即先对1进行加密,再对2进行加密,再对3进行加密……最后拼接成密文;块加密先分成不同的块,如1234成块,5678成块,90XX(XX为补位数字)成块,再分别对不同块进行加密,最后拼接成密文。前文提到的古典密码学加密方法,都属于流加密。

③ 非对称密码

对称密码的密钥安全极其重要,加密者和解密者需要提前协商密钥,并各自确保密钥的安全性,一但密钥泄露,即使算法是安全的也无法保障原文信息的私密性。

在实际的使用中,远程的提前协商密钥不容易实现,即使协商好,在远程传输过程中也容易被他人获取,因此非对称密钥此时就凸显出了优势。

非对称密码有两支密钥,公钥(publickey)和私钥(privatekey),加密和解密运算使用的密钥不同。用公钥对原文进行加密后,需要由私钥进行解密;用私钥对原文进行加密后(此时一般称为签名),需要由公钥进行解密(此时一般称为验签)。公钥可以公开的,大家使用公钥对信息进行加密,再发送给私钥的持有者,私钥持有者使用私钥对信息进行解密,获得信息原文。因为私钥只有单一人持有,因此不用担心被他人解密获取信息原文。

二、常见加密算法

让我们来看看生活中常见的几种加密方式:

2.1 对称加密算法

采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。

示例

  • 我们现在有一个原文3要发送给B
  • 设置密钥为108, 3 * 108 = 324, 将324作为密文发送给B
  • B拿到密文324后, 使用324/108 = 3 得到原文

常见加密算法

DES : Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛流传开来。

AES : Advanced Encryption Standard, 高级加密标准 .在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。

特点

  • 加密速度快, 可以加密大文件
  • 密文可逆, 一旦密钥文件泄漏, 就会导致数据暴露
  • 加密后编码表找不到对应字符, 出现乱码
  • 一般结合Base64使用

2.1.1 DES加密

示例代码 des加密算法

Cipher :文档 https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html#getInstance-java.lang.String-

运行:

出现这个bug的原因是DES算法规定,key必须是8个字节;

修改 密钥 key = “12345678” ,再次运行 ,出现乱码是因为对应的字节出现负数,但负数没有出现在 ascii 码表里面,所以出现乱码,需要配合base64进行转码

2.1.2 拓展:base64编码

在Java 8中,Base64编码已经成为Java类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:

- 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。

- URL:输出映射到一组字符A-Za-z0-9+_,输出是URL和文件。

- MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

上面的例子用Java8自带的base64进行编码:

运行:

除了上面的编码方式外,base64还有其他的编码方式,由于笔者时间有限,没有过多研究,在此放入一个demo,供大家参考:

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.UUID; /**
* 在Java 8中,Base64编码已经成为Java类库的标准。
* Java 8 内置了 Base64 编码的编码器和解码器。
* Base64工具类提供了一套静态方法获取下面三种BASE64编解码器:
* <p>
* 基本:输出被映射到一组字符A-Za-z0-9+/,编码不添加任何行标,输出的解码仅支持A-Za-z0-9+/。
* URL:输出被映射到一组字符A-Za-z0-9+_,输出是URL和文件。
* MIME:输出隐射到MIME友好格式。输出每行不超过76字符,并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割。
*/
public class Base64Test { private static final String UTF_8 = "utf-8";
private static final int MAX = 10; @Test
public void base64() throws UnsupportedEncodingException {
// test();
// basic();
url();
// mime(); } /**
* 测试几个特殊字符
*/
private void test() throws UnsupportedEncodingException {
String ss = "星期五?/\\|";
System.out.println("ordinal : " + ss);
byte[] encode = Base64.getEncoder().encode(ss.getBytes(UTF_8));
System.out.println("basic encode : " + new String(encode, UTF_8)); byte[] decode = Base64.getDecoder().decode(encode);
System.out.println("Using Basic : " + new String(decode, UTF_8)); byte[] decode1 = Base64.getUrlDecoder().decode(encode);
System.out.println("Using URL : " + new String(decode1, UTF_8)); byte[] decode2 = Base64.getMimeDecoder().decode(encode);
System.out.println("Using MIME : " + new String(decode2, UTF_8)); System.out.println();
} /**
* MIME编码器会使用基本的字母数字产生BASE64输出,
* 而且对MIME格式友好:每一行输出不超过76个字符,而且每行以“\r\n”符结束
*/
private void mime() throws UnsupportedEncodingException { StringBuilder sb = new StringBuilder();
for (int t = 0; t < MAX; ++t) {
sb.append(UUID.randomUUID().toString());
} byte[] toEncode = sb.toString().getBytes("utf-8");
String mimeEncoded = Base64.getMimeEncoder().encodeToString(toEncode);
System.out.println("Using MIME : ");
System.out.println(mimeEncoded);
} /**
* 但由于URL对反斜线“/”有特殊的意义,因此URL编码需要替换掉它,使用下划线替换
* 如果是使用基本的编码器,那么输出可能会包含反斜线“/”字符,
* 但是如果使用URL编码器,那么输出的内容对URL来说是安全的。
*/
private void url() throws UnsupportedEncodingException { String ordinal = "subjects?abcd";
System.out.println("ordinal : " + ordinal); // 输出为: Using Basic Alphabet: c3ViamVjdHM/YWJjZA==
String basicEncoded = Base64.getEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using Basic : " + basicEncoded); byte[] decode = Base64.getDecoder().decode(basicEncoded);
System.out.println("basic decode : " + new String(decode, UTF_8));
System.out.println();
System.out.println("ordinal : " + ordinal);
String urlEncoded = Base64.getUrlEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using URL : " + urlEncoded); byte[] decode1 = Base64.getUrlDecoder().decode(urlEncoded);
System.out.println("url decode : " + new String(decode1, UTF_8));
System.out.println(); String mimeEncoded = Base64.getMimeEncoder().encodeToString(ordinal.getBytes(UTF_8));
System.out.println("Using mime : " + mimeEncoded);
byte[] decode2 = Base64.getMimeDecoder().decode(mimeEncoded);
System.out.println("mime decode : " + new String(decode2, UTF_8));
System.out.println(); } /**
* Basic编码是标准的BASE64编码,用于处理常规的需求:输出的内容不添加换行符,而且输出的内容由字母加数字组成。
*/
private void basic() throws UnsupportedEncodingException {
String s = "some string";
System.out.println("ordinal : " + s);
// 编码
String asB64 = Base64.getEncoder().encodeToString(s.getBytes(UTF_8));
// 输出为: c29tZSBzdHJpbmc=
System.out.println("Using Basic : " + asB64); // 解码
byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");
// 输出为: some string
System.out.println("basic decode : " + new String(asBytes, UTF_8));
System.out.println();
}
}

运行:

2.1.3 DES解密

在2.1.1中的例子基础上加入解密方法

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64; public class DesDemo {
// DES加密算法,key的大小必须是8个字节 public static void main(String[] args) throws Exception {
String input ="华为";
// DES加密算法,key的大小必须是8个字节
String key = "12345678"; String transformation = "DES"; // 9PQXVUIhaaQ=
// 指定获取密钥的算法
String algorithm = "DES";
String encryptDES = encryptDES(input, key, transformation, algorithm);
System.out.println("加密:" + encryptDES);
String s = decryptDES(encryptDES, key, transformation, algorithm);
System.out.println("解密:" + s); } /**
* 使用DES加密数据
*
* @param input : 原文
* @param key : 密钥(DES,密钥的长度必须是8个字节)
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @return : 密文
* @throws Exception
*/
private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 获取加密对象
Cipher cipher = Cipher.getInstance(transformation);
// 创建加密规则
// 第一个参数key的字节
// 第二个参数表示加密算法
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// ENCRYPT_MODE:加密模式
// DECRYPT_MODE: 解密模式
// 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks);
// 加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 输出加密后的数据
String encode = new String(Base64.getEncoder().encode(bytes), "UTF-8"); // System.out.println(encode);
return encode;
} /**
* 使用DES解密
*
* @param input : 密文
* @param key : 密钥
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @throws Exception
* @return: 原文
*/
private static String decryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 1,获取Cipher对象
Cipher cipher = Cipher.getInstance(transformation);
// 指定密钥规则
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
cipher.init(Cipher.DECRYPT_MODE, sks);
// 3. 解密,上面使用的base64编码,下面直接用密文
byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(input)); // System.out.println("解密" + new String(decode, "UTF-8"));
// 因为是明文,所以直接返回
return new String(bytes);
}
}

运行:

2.1.4 AES加密解密

AES 加密解密和 DES 加密解密代码一样,只需要修改加密算法就行,在此不做过多阐述,值得注意的是:AES 加密的密钥key , 需要传入16个字节.

2.1.5 加密模式

AES的加密模式如下:

参考链接:https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html

这里主要介绍两种加密模式:ECB和CBC

ECB

Electronic codebook, 电子密码本. 需要加密的消息按照块密码的块大小被分为数个块,并对每个块进行独立加密

  • 优点 : 可以并行处理数据
  • 缺点 : 同样的原文生成同样的密文, 不能很好的保护数据
  • 同时加密,原文是一样的,加密出来的密文也是一样的

CBC

Cipher-block chaining, 密码块链接. 每个明文块先与前一个密文块进行异或后,再进行加密。在这种方法中,每个密文块都依赖于它前面的所有明文块

  • 优点 : 同样的原文生成的密文不一样
  • 缺点 : 串行处理数据.

2.1.6 填充模式

当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则,这里主要介绍以下两种:

NoPadding

  • 不填充.
  • 在DES加密算法下, 要求原文长度必须是8byte的整数倍
  • 在AES加密算法下, 要求原文长度必须是16byte的整数倍

PKCS5Padding

  • 数据块的大小为8位, 不够就补足

Tips

  • 默认情况下, 加密模式和填充模式为 : ECB/PKCS5Padding
  • 如果使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new IvParameterSpec(key.getBytes());

加密模式和填充模式:其中括号里数字表示加密位数,位数越高,则越安全

加密模式和填充模式例子

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; /**
* 功能描述: 加密模式和填充模式例子
*
* @author cWX970190
* @since 2020-10-11
*/
import com.sun.org.apache.xml.internal.security.utils.Base64; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec; public class DesDemo {
// DES加密算法,key的大小必须是8个字节 public static void main(String[] args) throws Exception { String input ="华为"; // DES加密算法,key的大小必须是8个字节
String key = "12345678"; // 指定获取Cipher的算法,如果没有指定加密模式和填充模式,ECB/PKCS5Padding就是默认值
// String transformation = "DES"; // 9PQXVUIhaaQ= //String transformation = "DES/ECB/PKCS5Padding"; // 9PQXVUIhaaQ= // CBC模式,必须指定初始向量,初始向量中密钥的长度必须是8个字节
// String transformation = "DES/CBC/PKCS5Padding"; // 9PQXVUIhaaQ= // NoPadding模式,原文的长度必须是8个字节的整倍数 ,所以必须把 硅谷改成硅谷12
String transformation = "DES/CBC/NoPadding"; // 9PQXVUIhaaQ= // 指定获取密钥的算法
String algorithm = "DES"; String encryptDES = encryptDES(input, key, transformation, algorithm); System.out.println("加密:" + encryptDES);
String s = dncryptDES(encryptDES, key, transformation, algorithm);
System.out.println("解密:" + s); } /**
* 使用DES加密数据
*
* @param input : 原文
* @param key : 密钥(DES,密钥的长度必须是8个字节)
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @return : 密文
* @throws Exception
*/
private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 获取加密对象
Cipher cipher = Cipher.getInstance(transformation);
// 创建加密规则
// 第一个参数key的字节
// 第二个参数表示加密算法
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// ENCRYPT_MODE:加密模式
// DECRYPT_MODE: 解密模式
// 初始向量,参数表示跟谁进行异或,初始向量的长度必须是8位
// IvParameterSpec iv = new IvParameterSpec(key.getBytes()); // 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks);
// 加密 byte[] bytes = cipher.doFinal(input.getBytes()); // 输出加密后的数据
String encode = Base64.encode(bytes); return encode;
} /**
* 使用DES解密
*
* @param input : 密文
* @param key : 密钥
* @param transformation : 获取Cipher对象的算法
* @param algorithm : 获取密钥的算法
* @throws Exception
* @return: 原文
*/
private static String dncryptDES(String input, String key, String transformation, String algorithm) throws Exception {
// 1,获取Cipher对象
Cipher cipher = Cipher.getInstance(transformation);
// 指定密钥规则
SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
// IvParameterSpec iv = new IvParameterSpec(key.getBytes());
cipher.init(Cipher.DECRYPT_MODE, sks);
// 3. 解密
byte[] bytes = cipher.doFinal(Base64.decode(input)); return new String(bytes);
}
}

运行:

非填充模式下,原文必须是8个字节,修改加密模式为:

 String transformation = "DES/CBC/PKCS5Padding";

再次运行:

发现加密没有问题,但是解密时需要添加一个参数,添加参数并修改初始化规则:

  // 初始向量,参数表示跟谁进行异或,初始向量的长度必须是8位
IvParameterSpec iv = new IvParameterSpec(key.getBytes()); // 初始化加密模式和算法
cipher.init(Cipher.ENCRYPT_MODE,sks,iv);

再次运行:

在测试 AES 的时候需要注意,key需要16个字节,加密向量也需要16个字节 ,其他方式跟 DES 一样。

2.2 消息摘要(单向散列)函数

消息摘要(Message Digest)又称为数字摘要(Digital Digest)

它是一个唯一对应一个消息或文本的固定长度的值,它由一个单向Hash加密函数对消息进行作用而产生

使用数字摘要生成的值是不可以篡改的,为了保证文件或者值的安全

2.2.1 特点

无论输入的消息有多长,计算出来的消息摘要的长度总是固定的。例如应用MD5算法摘要的消息有128个比特位,用SHA-1算法摘要的消息最终有160比特位的输出

只要输入的消息不同,对其进行摘要以后产生的摘要消息也必不相同;但相同的输入必会产生相同的输出

消息摘要是单向、不可逆的

常见算法 :

  • MD5
  • SHA1
  • SHA256
  • SHA512

浏览器搜索 tomcat ,进入官网下载 ,会经常发现有 sha1,sha512 , 这些都是数字摘要

2.2.2 获取字符串消息摘要

运行:

使用在线 md5 加密 ,发现我们生成的值和代码生成的值不一样,那是因为消息摘要不是使用base64进行编码的,所以我们需要把值转成16进制。

数字摘要转换成 16 进制

package com.huawei.it.jalor.boot.test;

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/ import com.sun.org.apache.xml.internal.security.utils.Base64; import java.security.MessageDigest; public class DigestDemo1 { public static void main(String[] args) throws Exception{
// 原文
String input = "aa";
// 算法
String algorithm = "MD5";
// 获取数字摘要对象
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 获取消息数字摘要的字节数组
byte[] digest = messageDigest.digest(input.getBytes("UTF-8"));
// System.out.println(new String(digest));
// base64编码
// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder(); for (byte b : digest) {
// 转成 16进制
String s = Integer.toHexString(b & 0xff);
//System.out.println(s);
if (s.length() == 1){
// 如果生成的字符只有一个,前面补0
s = "0"+s;
}
sb.append(s);
}
System.out.println(sb.toString()); }
}

运行,结果和在线一致:

2.2.3 其他消息摘要算法

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/
import java.security.MessageDigest; /**
* DigestDemo1
*
* @Author: 陈志强
* @CreateTime: 2020-03-17
* @Description:
*/
public class DigestDemo1 { public static void main(String[] args) throws Exception{
// 4124bc0a9335c27f086f24ba207a4912 md5 在线校验
// QSS8CpM1wn8IbyS6IHpJEg== 消息摘要使用的是16进制
// 原文
String input = "aa";
// 算法
String algorithm = "MD5";
// 获取数字摘要对象
String md5 = getDigest(input, "MD5");
System.out.println(md5); String sha1 = getDigest(input, "SHA-1");
System.out.println(sha1); String sha256 = getDigest(input, "SHA-256");
System.out.println(sha256); String sha512 = getDigest(input, "SHA-512");
System.out.println(sha512); } private static String toHex(byte[] digest) throws Exception { // System.out.println(new String(digest));
// base64编码
// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder(); for (byte b : digest) {
// 转成 16进制
String s = Integer.toHexString(b & 0xff);
if (s.length() == 1){
// 如果生成的字符只有一个,前面补0
s = "0"+s;
}
sb.append(s);
}
System.out.println("16进制数据的长度:" + sb.toString().getBytes().length);
return sb.toString();
} private static String getDigest(String input, String algorithm) throws Exception {
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 消息数字摘要
byte[] digest = messageDigest.digest(input.getBytes());
System.out.println("密文的字节长度:" + digest.length); return toHex(digest);
}
}

运行:

2.2.4 获取文件消息摘要

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.security.MessageDigest; /**
* DigestDemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-11
* @Description:
*/
public class DigestDemo { public static void main(String[] args) throws Exception{
String input = "aa";
String algorithm = "MD5"; // sha1 可以实现秒传功能 String sha1 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-1");
System.out.println(sha1); String sha512 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-512");
System.out.println(sha512); // String md5 = getDigest("aa", "MD5");
// System.out.println(md5);
//
// String md51 = getDigest("aa ", "MD5");
// System.out.println(md51);
} private static String getDigestFile(String filePath, String algorithm) throws Exception{
FileInputStream fis = new FileInputStream(filePath);
int len;
byte[] buffer = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ( (len = fis.read(buffer))!=-1){
baos.write(buffer,0,len);
}
// 获取消息摘要对象
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
// 获取消息摘要
byte[] digest = messageDigest.digest(baos.toByteArray());
System.out.println("密文的字节长度:"+digest.length);
return toHex(digest);
} private static String getDigest(String input, String algorithm) throws Exception{
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
byte[] digest = messageDigest.digest(input.getBytes());
System.out.println("密文的字节长度:"+digest.length);
return toHex(digest);
} private static String toHex(byte[] digest) {
// System.out.println(new String(digest));
// 消息摘要进行表示的时候,是用16进制进行表示
StringBuilder sb = new StringBuilder();
for (byte b : digest) {
// 转成16进制 String s = Integer.toHexString(b & 0xff);
// 保持数据的完整性,前面不够的用0补齐
if (s.length()==1){
s="0"+s;
}
sb.append(s);
}
System.out.println("16进制数据的长度:"+ sb.toString().getBytes().length);
return sb.toString();
}
}

运行结果:

查看官网上的sha512加密结果,发现一致:

使用 sha-1 算法,可以实现秒传功能,只要是同一文件的加密,不管如何修改文件的名字,最后得到的值是一样的,具体可以自己测试。

不过,如果原文不一样,例如,下图上面的原文多两个空格:

运行后:

总结

  • MD5算法 : 摘要结果16个字节, 转16进制后32个字节
  • SHA1算法 : 摘要结果20个字节, 转16进制后40个字节
  • SHA256算法 : 摘要结果32个字节, 转16进制后64个字节
  • SHA512算法 : 摘要结果64个字节, 转16进制后128个字节

2.3 非对称加密

简介:

① 非对称加密算法又称现代加密算法。

② 非对称加密是计算机通信安全的基石,保证了加密数据不会被破解。

③ 与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey) 和私有密(privatekey)

④ 公开密钥和私有密钥是一对

⑤ 如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密。

⑥ 如果用私有密钥对数据进行加密,只有用对应的公开密钥才能解密。

⑦ 因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

示例

首先生成密钥对, 公钥为(5,14), 私钥为(11,14)

现在A希望将原文2发送给B

A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B

B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2

特点

  • 加密和解密使用不同的密钥
  • 如果使用私钥加密, 只能使用公钥解密
  • 如果使用公钥加密, 只能使用私钥解密
  • 处理数据的速度较慢, 因为安全级别高

常见算法

RSA

ECC

2.3.1 生成公钥和私钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception { // 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 打印私钥
System.out.println(privateKeyString);
// 打印公钥
System.out.println(publicKeyString);
}
}

运行程序,先打印私钥,再打印公钥:

2.3.2 私钥加密

import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "华为";
// 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded); // 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes)); }
}

运行程序:

2.3.3 私钥加密私钥解密

public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "华为";
// 加密算法
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 生成私钥
PrivateKey privateKey = keyPair.getPrivate();
// 生成公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥进行base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,privateKey);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1)); }
}

运行结果error,因为私钥加密,只能公钥解密:

2.3.4 私钥加密公钥解密

修改2.3.3中的代码

// 公钥进行解密
cipher.init(Cipher.DECRYPT_MODE,publicKey);

再次运行

2.3.5 公钥加密和公钥解密

一样会报错

2.3.6 保存公私钥

有些情况下需要把加密和解密的方法全部到本地的根目录下面:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA"; //生成密钥对并保存在本地文件中
generateKeyToFile(algorithm, "a.pub", "a.pri"); //加密
// String s = encryptRSA(algorithm, privateKey, input);
// 解密
// String s1 = decryptRSA(algorithm, publicKey, s);
// System.out.println(s1); } /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}

运行程序后,本地多了两个文件,打开:

2.3.7 读取私钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm); } public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}

2.3.8 读取公钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; /**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm); String s = encryptRSA(algorithm, privateKey, input);
String s1 = decryptRSA(algorithm, publicKey, s);
System.out.println(s);
System.out.println(s1); } public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
} public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
}
}

运行程序

2.4 数字签名

我们经常会用到数字签名,只是大家平时不太注意,比如我们访问银行 ,证券公司,基金公司,金融类的公司网站全部都是 https 协议,如果是 https 协议,那么都需要有一个证书。签名可以用来验证网络传输数据的时候,数据是否被人篡改。

签名的作用简单来说就是证明某个文件上的内容确实是我写的,别人不能冒充我的签名(不可伪造),我也不能否认上面的签名是我的(不可抵赖)。

我们知道,手写签名之所以不能伪造,是因为每一个人的笔迹都是独一无二的,即使模仿,也可以通过专家鉴定分别出来。而不可抵赖,是因为每个人的笔迹都有固定特征,这些特征是很难摆脱的。

正是这两点特性使得手写签名在日常生活中被广泛承认,比如签合同、借条等等。

数字签名的要求是,只有我自己能签我的名字,其他人能验证我的签名,但是不能伪造我的签名。

2.4.1 网页加密

我们看一个应用“数字证书”的实例:https协议。这个协议主要用于网页加密

首先,客户端向服务器发出加密请求。

服务器用自己的私钥加密网页以后,连同本身的数字证书,一起发送给客户端。

客户端(浏览器)的“证书管理器”,有“受信任的根证书颁发机构”列表。客户端会根据这张列表,查看解开数字证书的公钥是否在列表之内。

如果数字证书记载的网址,与你正在浏览的网址不一致,就说明这张证书可能被冒用,浏览器会发出警告。

如果这张数字证书不是由受信任的机构颁发的,浏览器会发出另一种警告。

如果数字证书是可靠的,客户端就可以使用证书中的服务器公钥,对信息进行加密,然后与服务器交换加密信息。

2.4.2 证书从哪里来

“证书中心”(certificate authority,简称CA),为公钥做认证。证书中心用自己的私钥,对公钥和一些相关信息一起加密,生成“数字证书”(Digital Certificate)。

拿到数字证书以后,就可以放心了。以后只要在签名的同时,再附上数字证书就行了。

用CA的公钥解开数字证书,就可以拿到真实的公钥了,然后就能证明“数字签名”是否真的是公司签的。

修改之前的RSAdemo代码:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils; import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec; /**
* RSAdemo
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "硅谷";
// 加密算法
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm);
String s = encryptRSA(algorithm, privateKey, input);
String s1 = decryptRSA(algorithm, publicKey, s);
System.out.println(s);
System.out.println(s1); } public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
} public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// 将文件内容转为字符串
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// 生成私钥
return keyFactory.generatePrivate(spec);
} /**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8")); } /**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密,不需要使用base64,因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1); }
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数:使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
} /**
* 从文件中加载公钥
*
* @param algorithm : 算法
* @param filePath : 文件路径
* @return : 公钥
* @throws Exception
*/
public static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8")); return loadPublicKeyFromString(algorithm, keyString); } /**
* 从字符串中加载公钥
*
* @param algorithm : 算法
* @param keyString : 公钥字符串
* @return : 公钥
* @throws Exception
*/
public static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {
// 进行Base64解码
byte[] decode = Base64.decode(keyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范
X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);
// 获取公钥
return keyFactory.generatePublic(keyspec); } /**
* 从文件中加载私钥
*
* @param algorithm : 算法
* @param filePath : 文件路径
* @return : 私钥
* @throws Exception
*/
public static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
return loadPrivateKeyFromString(algorithm, keyString); } /**
* 从字符串中加载私钥
*
* @param algorithm : 算法
* @param keyString : 私钥字符串
* @return : 私钥
* @throws Exception
*/
public static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {
// 进行Base64解码
byte[] decode = Base64.decode(keyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范
PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);
// 生成私钥
return keyFactory.generatePrivate(keyspec); }
}

写一个验证数字签名的类:

/*
* Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
*/ package com.huawei.it.jalor.boot.test; import com.sun.org.apache.xml.internal.security.utils.Base64; import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature; /**
* 功能描述: 验证数字签名
*
* @author cWX970190
* @since 2020-10-11
*/
public class SignatureDemo {
public static void main(String[] args) throws Exception {
String a = "123";
PublicKey publicKey =RSAdemo.loadPublicKeyFromFile("RSA", "a.pub");
PrivateKey privateKey = RSAdemo.loadPrivateKeyFromFile("RSA", "a.pri");
String signaturedData = getSignature(a, "sha256withrsa", privateKey);
boolean b = verifySignature(a, "sha256withrsa", publicKey, signaturedData);
System.out.println(b);
} /**
* 生成签名
*
* @param input : 原文
* @param algorithm : 算法
* @param privateKey : 私钥
* @return : 签名
* @throws Exception
*/
private static String getSignature(String input, String algorithm, PrivateKey privateKey) throws Exception {
// 获取签名对象
Signature signature = Signature.getInstance(algorithm);
// 初始化签名
signature.initSign(privateKey);
// 传入原文
signature.update(input.getBytes());
// 开始签名
byte[] sign = signature.sign();
// 对签名数据进行Base64编码
return Base64.encode(sign);
} /**
* 校验签名
*
* @param input : 原文
* @param algorithm : 算法
* @param publicKey : 公钥
* @param signaturedData : 签名
* @return : 数据是否被篡改
* @throws Exception
*/
private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signaturedData) throws Exception {
// 获取签名对象
Signature signature = Signature.getInstance(algorithm);
// 初始化签名
signature.initVerify(publicKey);
// 传入原文
signature.update(input.getBytes());
// 校验数据
return signature.verify(Base64.decode(signaturedData)); }
}

运行,验证成功:

拓展: 2.5 Byte和bit

Byte : 字节. 数据存储的基本单位,比如移动硬盘1T , 单位是byte

bit : 比特, 又叫位. 一个位要么是0要么是1. 数据传输的单位 , 比如家里的宽带100MB,下载速度并没有达到100MB,一般都是12-13MB,那么是因为需要使用 100 / 8

关系: 1Byte = 8bit

2.5.1 获取字符串byte

/**
* ByteBit
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class ByteBit {
public static void main(String[] args) {
String a = "a";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
int c=b;
// 打印发现byte实际上就是ascii码
System.out.println(c);
}
}
}

运行结果:

和ascii码表一致

2.5.2 byte对应bit

public class ByteBit {
public static void main(String[] args) {
String a = "a";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
int c=b;
// 打印发现byte实际上就是ascii码
System.out.println(c);
// 我们在来看看每个byte对应的bit,byte获取对应的bit
String s = Integer.toBinaryString(c);
System.out.println(s);
}
}
}

运行结果

2.5.3 中文对应的字节

package com.huawei.it.jalor.boot.test;

/**
* 功能描述
*
* @author cWX970190
* @since 2020-10-11
*/
public class ByteBitDemo {
public static void main(String[] args) throws Exception{ String a = "华";
byte[] bytes = a.getBytes();
for (byte b : bytes) {
System.out.print(b + " ");
String s = Integer.toBinaryString(b);
System.out.println(s);
}
} }

运行程序,我们发现一个中文是有 3 个字节组成:

我们修改 编码格式 , 编码格式改成 GBK

修改代码

 // UTF-8:编码格式占3个字节
byte[] bytes = a.getBytes("GBK");

再运行发现变成了 2 个字节

2.5.4 英文对应的字节

/**
* ByteBit
*
* @Author: 陈志强
* @CreateTime: 2020-10-12
* @Description:
*/
public class ByteBit {
public static void main(String[] args) throws Exception{ String a = "a";
byte[] bytes = a.getBytes();
// 在中文情况下,不同的编码格式,对应不同的字节
// byte[] bytes = a.getBytes("GBK");
for (byte b : bytes) {
System.out.print(b + " ");
String s = Integer.toBinaryString(b);
System.out.println(s);
}
}
}

运行程序

三、如何设置密码才安全

通过上述密码学发展史的介绍,以及对常见加密算法的阐述,相信大家对密码应该有了较为理性的认识,那么,如何设置密码才安全呢?这里给出一点小建议:

- 密码不要太常见,不要使用类似于123456式的常用密码。

- 各应用软件密码建议不同,避免出现一个应用数据库被脱库,全部应用密码崩塌,

- 可在设置密码时增加注册时间、注册地点、应用特性等方法。例如tianjin123456,表示在天津注册的该应用

参考文献:

现代密码学之对称加密-DES及AES算法- element ui
http://element-ui.cn/article/show-97007.aspx

Java Base64 编码与解码----三种实现方式的代码实例
https://blog.csdn.net/qq_27093465/article/details/93977519

网络安全之密码学:信息安全
https://www.bilibili.com/video/av583369085/

好了,本期的分享到此就跟大家saygoodbye了,密码学博大精深,本文只是浅尝辄止,关于密码学的知识一直都在更新,希望下次可以给大家带来更前沿、更实用的密码学相关知识,喜欢的老铁欢迎关注点赞,笔芯 !!!

点击关注,第一时间了解华为云新鲜技术~

【人人都懂密码学】一篇最易懂的Java密码学入门教程的更多相关文章

  1. 人人都懂区块链--pdf电子版学习资料下载

    人人都懂区块链 21天从区块链“小白”到资深玩家电子版pdf下载 链接:https://pan.baidu.com/s/1TWxYv4TLa2UtTgU-HqLECQ 提取码:6gy0 好的学习资料需 ...

  2. &lt;人人都懂设计模式&gt;-单例模式

    这个模式,我还是了解的. 书上用了三种不同的方法. class Singleton1: # 单例实现方式1 __instance = None __is_first_init = False def ...

  3. &lt;人人都懂设计模式&gt;-装饰模式

    书上,真的用一个人穿衣打拌来讲解装饰模式的呢. from abc import ABCMeta, abstractmethod class Person(metaclass=ABCMeta): def ...

  4. &lt;人人都懂设计模式&gt;-中介模式

    真正的用房屋中介来作例子, 好的书籍总是让人记忆深刻. class HouseInfo: def __init__(self, area, price, has_window, has_bathroo ...

  5. &lt;人人都懂设计模式&gt;-状态模式

    同样是水,固态,气态,液态的变化,是由温度引起. 引此为思考状态模式. from abc import ABCMeta, abstractmethod # 引入ABCMeta和abstractmeth ...

  6. 人人都可以写的可视化Python小程序第二篇:旋转的烟花

    兴趣是最好的老师 枯燥的编程容易让人放弃,兴趣才是最好的老师.无论孩子还是大人,只有发现这件事情真的有趣,我们才会非常执着的去做这件事,比如打游戏.如果编程能像玩游戏一样变得有趣,我相信很多人就特别愿 ...

  7. 腾讯QQ会员技术团队:人人都可以做深度学习应用:入门篇(下)

    四.经典入门demo:识别手写数字(MNIST) 常规的编程入门有"Hello world"程序,而深度学习的入门程序则是MNIST,一个识别28*28像素的图片中的手写数字的程序 ...

  8. 【腾讯Bugly干货分享】人人都可以做深度学习应用:入门篇

    导语 2016年,继虚拟现实(VR)之后,人工智能(AI)的概念全面进入大众的视野.谷歌,微软,IBM等科技巨头纷纷重点布局,AI 貌似将成为互联网的下一个风口. 很多开发同学,对人工智能非常感兴趣, ...

  9. [转帖]看完这篇文章,我奶奶都懂了https的原理

    看完这篇文章,我奶奶都懂了https的原理 http://www.17coding.info/article/22 非对称算法 以及 CA证书 公钥 核心是 大的质数不一分解 还有 就是 椭圆曲线算法 ...

随机推荐

  1. 颜色代码表#FFFFFF #FF0000 #00FF00 #FF00FF (2015-07-21 10:39)转载

    ▼标签: 颜色代码表 白色 ffffff 红色 ff0000 黑色 000000 it     分类: hht1 白色 #FFFFFF 2 红色 #FF0000 3 绿色 #00FF00 4 蓝色 # ...

  2. SVN——配置和安装

    SVN安装步骤: 所有安装文件下载地址:http://pan.baidu.com/s/1bocNTDl 一.安装01----VisualSVN-Server-3.4.2-x64.msi 文件 直接下一 ...

  3. xml 中转意字符&amp;\/使用方法

    所有 XML 元素都须有关闭标签 在 HTML,经常会看到没有关闭标签的元素: <p>This is a paragraph <p>This is another paragr ...

  4. 网络编程:socket--python核心编程(3),chapter 1

    最近两天把第一部分的网络编程socket好好学习了一番,收获也蛮多的... 套接字:能使运行在不同或相同计算机上运行的进行通信:套接字一种是基于文件的(同一台计算机进程间通信),另一种是基于网络的(同 ...

  5. SQL多表联合分页.....

    set ANSI_NULLS ON set QUOTED_IDENTIFIER ON go /* 支持多表查询分页存储过程(事理改进)2012.3 --多表联查1 declare @Count int ...

  6. 【CF689D Friends and Subsequences】二分搜索,区间查询

    题意:给定两个整数序列a,b,将a,b对齐,问有多少个区间满足a的区间内最大值等于b的区间内最小值. 数据范围:区间长度n属于[1, 200000],序列中的元素在整型范围内 思路:枚举所有n*(n+ ...

  7. .Net Core应用框架Util介绍(六)

    前面介绍了Util是如何封装以降低Angular应用的开发成本. 现在把关注点移到服务端,本文将介绍分层架构各构造块及基类,并对不同层次的开发人员应如何进行业务开发提供一些建议. Util分层架构介绍 ...

  8. CMDB服务器管理系统【s5day88】:采集资产-文件配置(一)

    django中间件工作原理 整体流程: 在接受一个Http请求之前的准备 启动一个支持WSGI网关协议的服务器监听端口等待外界的Http请求,比如Django自带的开发者服务器或者uWSGI服务器. ...

  9. MySQL Binlog--MIXED模式下数据更新

    在 Mixed 模式下,MySQL 会根据执行的每一条具体的 SQL 语句来区分对待记录的日志形式,也就是在 statement 和 row 之间选择一种.如果SQL语句为UPDATE/DELETE等 ...

  10. C++实现wc.exe程序

    github项目地址:https://github.com/insomniali/wc 基本功能 wc.exe -c file     统计文件file的字符数  [实现] wc.exe -w fil ...