图文彻底搞懂非对称加密（公钥密钥） - 知乎

图文彻底搞懂非对称加密（公钥密钥） - 知乎首发于密码学切换模式写文章登录/注册图文彻底搞懂非对称加密（公钥密钥）爱码叔架构师、多年中小型团队的管理者更多密码学文章，个站地址：密码学公众号：爱码叔漫画软件设计（搜：爱码叔）前文详细讲解了对称加密及算法原理（图文详解对称加密（DES、AES））。那么是不是对称加密就万无一失了呢？对称加密有一个天然的缺点，就是加密方和解密方都要持有同样的密钥。你可以能会提出疑问：既然要加、解密，当然双方都要持有密钥，这有什么问题呢？别急，我们继续往下看。对称密钥的缺点我们先看一个例子，小明和小红要进行通信，但是不想被其他人知道通信的内容，所以双方决定采用对称加密的方式。他们做了下面的事情：1、双方商定了加密和解密的算法2、双方确定密钥3、通信过程中采用这个密钥进行加密和解密这是不是一个看似完美的方案？但其中有一个步骤存在漏洞！问题出在步骤2：双方确定密钥！你肯定会问，双方不确定密钥，后面的加、解密怎么做？问题在于确定下来的密钥如何让双方都知道。密钥在传递过程中也是可能被盗取的！这里引出了一个经典问题：密钥配送问题。密钥配送问题小明和小红在商定密钥的过程中肯定会多次沟通密钥是什么。即使单方一次确定下来，也要发给对方。加密是为了保证信息传输的安全，但密钥本身也是信息，密钥的传输安全又该如何保证呢？难不成还要为密钥的传输再做一次加密？这样不就陷入了死循环？你是不是在想，密钥即使被盗取，不还有加密算法保证信息安全吗？如果你真的有这个想法，那么赶紧复习一下上一篇文章讲的杜绝隐蔽式安全性。任何算法最终都会被破译，所以不能依赖算法的复杂度来保证安全。小明和小红现在左右为难，想加密就要给对方发密钥，但发密钥又不能保证密钥的安全。他们应该怎么办呢？有如下几种解决密钥配送问题的方案：事先共享密钥密钥分配中心Diffie-Hellman密钥交换非对称加密本文就不展开讲每种方式，这里只是为了引出今天的主角——非对称加密。非对称加密非对称加密也称为公钥密码。我更愿意用非对称加密这种叫法。因为可以体现出加密和解密使用不同的密钥。对称加密中，我们只需要一个密钥，通信双方同时持有。而非对称加密需要4个密钥。通信双方各自准备一对公钥和私钥。其中公钥是公开的，由信息接受方提供给信息发送方。公钥用来对信息加密。私钥由信息接受方保留，用来解密。既然公钥是公开的，就不存在保密问题。也就是说非对称加密完全不存在密钥配送问题！你看，是不是完美解决了密钥配送问题？回到刚才的例子，小明和下红经过研究发现非对称加密能解决他们通信的安全问题，于是做了下面的事情：1、小明确定了自己的私钥 mPrivateKey，公钥 mPublicKey。自己保留私钥，将公钥mPublicKey发给了小红2、小红确定了自己的私钥 hPrivateKey，公钥 hPublicKey。自己保留私钥，将公钥 hPublicKey 发给了小明3、小明发送信息 “周六早10点soho T1楼下见”，并且用小红的公钥 hPublicKey 进行加密。4、小红收到信息后用自己的私钥 hPrivateKey 进行解密。然后回复 “收到，不要迟到” 并用小明的公钥mPublicKey加密。5、小明收到信息后用自己的私钥 mPrivateKey 进行解密。读取信息后心里暗想：还提醒我不迟到？每次迟到的都是你吧？以上过程是一次完整的request和response。通过这个例子我们梳理出一次信息传输的非对称加、解密过程：1、消息接收方准备好公钥和私钥2、私钥接收方自己留存、公钥发布给消息发送方3、消息发送方使用接收方公钥对消息进行加密4、消息接收方用自己的私钥对消息解密公钥只能用做数据加密。公钥加密的数据，只能用对应的私钥才能解密。这是非对称加密的核心概念。下面我用一个更为形象的例子来帮助大家理解。我有下图这样一个信箱。带两把锁的信箱由于我只想接收我期望与之通信的朋友信件。于是我在投递口加了一把锁，这把锁的钥匙（公钥）我可以复制n份，发给我想接受其信件的人。只有这些人可以用这把钥匙打开寄信口，把信件投入。我准备好了两把锁的钥匙：公钥和私钥收信门是另外一把锁，打开后可以拿出所有的信件。寄信口的钥匙并不能打开这把锁。这把锁的钥匙（私钥）当然只有我有。我可以用这把钥匙打开信箱门，取出所有发给我的信件。私钥我自己保留，公钥给我的朋友相信通过这个例子，可以帮助大家彻底理解公钥和私钥的概念。非对称加密算法RSA 是现在使用最为广泛的非对称加密算法，本节我们来简单介绍 RSA 加解密的过程。RSA 加解密算法其实很简单：密文=明文^E mod N 明文=密文^D mod N RSA 算法并不会像对称加密一样，用玩魔方的方式来打乱原始信息。RSA 加、解密中使用了是同样的数 N。公钥是公开的，意味着 N 也是公开的。所以私钥也可以认为只是 D。我们接下来看一看 N、E、D 是如何计算的。1、求 N首先需要准备两个很大质数 a 和 b。太小容易破解，太大计算成本太高。我们可以用 512 bit 的数字，安全性要求高的可以使用 1024，2048 bit。N=a*b2、求 LL 只是生成密钥对过程中产生的数，并不参与加解密。L 是 (a-1) 和 (b-1) 的最小公倍数3、求 E（公钥）E 有两个限制：1通俗易懂的对称加密与非对称加密原理浅析 - 掘金

通俗易懂的对称加密与非对称加密原理浅析 - 掘金

首页 首页

沸点

课程

直播

活动

竞赛

商城

APP

插件 搜索历史

清空

创作者中心

写文章 发沸点 写笔记 写代码 草稿箱 创作灵感

查看更多

会员

登录

注册

通俗易懂的对称加密与非对称加密原理浅析

白菜说技术

2021-05-21

10,289

白菜Java自习室 涵盖核心知识

偶然之间，在同行（程序员）口中听到：base64和md5都是用来加密的。他们对加密没有概念，他们也认为压缩是加密。所以今天特地来这里解释下什么是加密，加密的原理和用途。

1. 加密概念

密码学是研究编制密码和破译密码的技术科学。以数学为基础，在加密和解密、攻击和防守、矛和盾的对抗过程中交替发展起来。从数学算法的角度看，它包含对称密码算法、非对称密码算法和杂凑算法。

我们先来看下加密中经常提到的一些概念吧！

明文：明文指的是未被加密过的原始数据。

密文：明文被某种加密算法加密之后，会变成密文，从而确保原始数据的安全。密文也可以被解密，得到原始的明文。

密钥：密钥是一种参数，它是在明文转换为密文或将密文转换为明文的算法中输入的参数。密钥分为对称密钥与非对称密钥，分别应用在对称加密和非对称加密上。

2. 对称加密

对称加密又叫做私钥加密，即信息的发送方和接收方使用同一个密钥去加密和解密数据。对称加密的特点是算法公开、加密和解密速度快，适合于对大数据量进行加密。

加密过程如下：明文 + 加密算法 + 私钥 => 密文

解密过程如下：密文 + 解密算法 + 私钥 => 明文

对称加密中用到的密钥叫做私钥，私钥表示个人私有的密钥，即该密钥不能被泄露。 其加密过程中的私钥与解密过程中用到的私钥是同一个密钥，这也是称加密之所以称之为“对称”的原因。由于对称加密的算法是公开的，所以一旦私钥被泄露，那么密文就很容易被破解，所以对称加密的缺点是密钥安全管理困难。

如果你不是很理解，就看这个通俗易懂的例子：

甲对乙说，我这有一把锁，以后我们互相传消息，就把消息放盒子里，然后用这个锁锁上再传，这个锁有两把一模一样的钥匙，咱俩一人一把，说完甲把钥匙递给了乙。

3. 非对称加密

非对称加密也叫做公钥加密。非对称加密与对称加密相比，其安全性更好。对称加密的通信双方使用相同的密钥，如果一方的密钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对密钥，即公钥和私钥，且二者成对出现。私钥被自己保存，不能对外泄露。公钥指的是公共的密钥，任何人都可以获得该密钥。用公钥或私钥中的任何一个进行加密，用另一个进行解密。

被公钥加密过的密文只能被私钥解密，过程如下：

明文 + 加密算法 + 公钥 => 密文， 密文 + 解密算法 + 私钥 => 明文

由于加密和解密使用了两个不同的密钥，这就是非对称加密“非对称”的原因。非对称加密的缺点是加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

如果你不是很理解，就看这个通俗易懂的例子：

甲对乙说，我这里有A型号锁，对应钥匙A，我给你一大箱子A锁，但是钥匙A不给你，以后你给我发消息就用A锁锁在盒子里给我，然后我自己用钥匙A就能打开看。

乙对甲说，我这里有B型号锁，对应钥匙B，我给你一大箱子B锁，但是钥匙B不给你，以后你给我发消息就用B锁锁在盒子里给我，然后我自己用钥匙B就能打开看。

4. 常见加密算法比较

加密算法分 对称加密 和 非对称加密，其中对称加密算法的加密与解密 密钥相同，非对称加密算法的加密密钥与解密 密钥不同，此外，还有一类 不需要密钥 的 散列算法。

常见的 对称加密 算法主要有 DES、3DES、AES 等，常见的 非对称算法 主要有 RSA、ECC 等，散列算法 主要有 SHA-1、MD5 等。

4.1. 散列算法比较

名称安全性速度MD5中快SHA-1高慢

4.2. 对称加密算法比较

名称密钥名称运行速度安全性资源消耗DES56位较快低中3DES112位或168位慢中高AES128、192、256位快高低

4.3. 非对称加密算法比较

名称成熟度运行速度安全性资源消耗RSA高中高中ECC高慢高高

对称加密 的 密钥管理比较难，不适合互联网，一般用于内部系统，安全性只能算中等，但加密速度快好 几个数量级 (软件加解密速度至少快 100 倍，每秒可以加解密数 M 比特 数据)，适合大数据量的加解密处理。非对称加密 的 密钥容易管理，安全性也较高，但是加密速度比较慢，适合 小数据量 加解密或数据签名。

5. 常见加密算法使用

5.1. MD5算法

MD5 用的是 哈希函数，它的典型应用是对一段信息产生 信息摘要，以 防止被篡改。严格来说，MD5 不是一种 加密算法 而是 摘要算法。无论是多长的输入，MD5 都会输出长度为 128bits 的一个串 (通常用 16 进制 表示为 32 个字符)。

Java使用案例：

public static final byte[] computeMD5(byte[] content) {

try {

MessageDigest md5 = MessageDigest.getInstance("MD5");

return md5.digest(content);

} catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

}

}

5.2. SHA1算法

SHA1 是和 MD5 一样流行的 消息摘要算法，然而 SHA1 比 MD5 的 安全性更强。对于长度小于 2 ^ 64 位的消息，SHA1 会产生一个 160 位的 消息摘要。基于 MD5、SHA1 的信息摘要特性以及 不可逆 (一般而言)，可以被应用在检查 文件完整性 以及 数字签名 等场景。

Java使用案例：

public static byte[] computeSHA1(byte[] content) {

try {

MessageDigest sha1 = MessageDigest.getInstance("SHA1");

return sha1.digest(content);

} catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

}

}

5.3. HMAC算法

MAC 是密钥相关的 哈希运算消息认证码（Hash-based Message Authentication Code），HMAC 运算利用 哈希算法 (MD5、SHA1 等)，以 一个密钥 和 一个消息 为输入，生成一个 消息摘要 作为 输出。HMAC 发送方 和 接收方 都有的 key 进行计算，而没有这把 key 的第三方，则是 无法计算 出正确的 散列值的，这样就可以 防止数据被篡改。

Java使用案例：

package net.pocrd.util;

import net.pocrd.annotation.NotThreadSafe;

import net.pocrd.define.ConstField;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Mac;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import java.util.Arrays;

@NotThreadSafe

public class HMacHelper {

private static final Logger logger = LoggerFactory.getLogger(HMacHelper.class);

private Mac mac;

/**

* MAC算法可选以下多种算法

* HmacMD5/HmacSHA1/HmacSHA256/HmacSHA384/HmacSHA512

*/

private static final String KEY_MAC = "HmacMD5";

public HMacHelper(String key) {

try {

SecretKey secretKey = new SecretKeySpec(key.getBytes(ConstField.UTF8), KEY_MAC);

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

mac.init(secretKey);

} catch (Exception e) {

logger.error("create hmac helper failed.", e);

}

}

public byte[] sign(byte[] content) {

return mac.doFinal(content);

}

public boolean verify(byte[] signature, byte[] content) {

try {

byte[] result = mac.doFinal(content);

return Arrays.equals(signature, result);

} catch (Exception e) {

logger.error("verify sig failed.", e);

}

return false;

}

}

注意：HMAC 算法实例在 多线程环境 下是 不安全的。但是需要在 多线程访问 时，进行同步的辅助类，使用 ThreadLocal 为 每个线程缓存 一个实例可以避免进行锁操作。

5.4. AES算法

ES、DES、3DES 都是 对称 的 块加密算法，加解密 的过程是 可逆的。常用的有 AES128、AES192、AES256 (默认安装的 JDK 尚不支持 AES256，需要安装对应的 jce 补丁进行升级 jce1.7，jce1.8)。

DES 加密算法是一种 分组密码，以 64 位为 分组对数据 加密，它的 密钥长度 是 56 位，加密解密 用 同一算法。DES 加密算法是对 密钥 进行保密，而 公开算法，包括加密和解密算法。这样，只有掌握了和发送方 相同密钥 的人才能解读由 DES加密算法加密的密文数据。因此，破译 DES 加密算法实际上就是 搜索密钥的编码。对于 56 位长度的 密钥 来说，如果用 穷举法 来进行搜索的话，其运算次数为 2 ^ 56 次。3DES 是基于 DES 的 对称算法，对 一块数据 用 三个不同的密钥 进行 三次加密，强度更高。

AES 加密算法是密码学中的 高级加密标准，该加密算法采用 对称分组密码体制，密钥长度的最少支持为 128 位、 192 位、256 位，分组长度 128 位，算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的 区块加密标准。AES 本身就是为了取代 DES 的，AES 具有更好的 安全性、效率 和 灵活性。

Java使用案例：

import net.pocrd.annotation.NotThreadSafe;

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import java.security.SecureRandom;

@NotThreadSafe

public class AesHelper {

private SecretKeySpec keySpec;

private IvParameterSpec iv;

public AesHelper(byte[] aesKey, byte[] iv) {

if (aesKey == null || aesKey.length < 16 || (iv != null && iv.length < 16)) {

throw new RuntimeException("错误的初始密钥");

}

if (iv == null) {

iv = Md5Util.compute(aesKey);

}

keySpec = new SecretKeySpec(aesKey, "AES");

this.iv = new IvParameterSpec(iv);

}

public AesHelper(byte[] aesKey) {

if (aesKey == null || aesKey.length < 16) {

throw new RuntimeException("错误的初始密钥");

}

keySpec = new SecretKeySpec(aesKey, "AES");

this.iv = new IvParameterSpec(Md5Util.compute(aesKey));

}

public byte[] encrypt(byte[] data) {

byte[] result = null;

Cipher cipher = null;

try {

cipher = Cipher.getInstance("AES/CFB/NoPadding");

cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);

result = cipher.doFinal(data);

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

public byte[] decrypt(byte[] secret) {

byte[] result = null;

Cipher cipher = null;

try {

cipher = Cipher.getInstance("AES/CFB/NoPadding");

cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);

result = cipher.doFinal(secret);

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

public static byte[] randomKey(int size) {

byte[] result = null;

try {

KeyGenerator gen = KeyGenerator.getInstance("AES");

gen.init(size, new SecureRandom());

result = gen.generateKey().getEncoded();

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

}

5.5. RSA算法

RSA 加密算法是目前最有影响力的 公钥加密算法，并且被普遍认为是目前 最优秀的公钥方案 之一。RSA 是第一个能同时用于 加密 和 数字签名 的算法，它能够抵抗到目前为止已知的 所有密码攻击，已被 ISO 推荐为公钥数据加密标准。

RSA 加密算法 基于一个十分简单的数论事实：将两个大 素数 相乘十分容易，但想要对其乘积进行 因式分解 却极其困难，因此可以将 乘积 公开作为 加密密钥。

Java使用案例：

import net.pocrd.annotation.NotThreadSafe;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.security.KeyFactory;

import java.security.Security;

import java.security.Signature;

import java.security.interfaces.RSAPrivateCrtKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe

public class RsaHelper {

private static final Logger logger = LoggerFactory.getLogger(RsaHelper.class);

private RSAPublicKey publicKey;

private RSAPrivateCrtKey privateKey;

static {

// 使用bouncycastle作为加密算法实现

Security.addProvider(new BouncyCastleProvider());

}

public RsaHelper(String publicKey, String privateKey) {

this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));

}

public RsaHelper(byte[] publicKey, byte[] privateKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

if (privateKey != null && privateKey.length > 0) {

this.privateKey = (RSAPrivateCrtKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public RsaHelper(String publicKey) {

this(Base64Util.decode(publicKey));

}

public RsaHelper(byte[] publicKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public byte[] encrypt(byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

if (content == null) {

return null;

}

try {

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

int size = publicKey.getModulus().bitLength() / 8 - 11;

ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 11));

int left = 0;

for (int i = 0; i < content.length; ) {

left = content.length - i;

if (left > size) {

cipher.update(content, i, size);

i += size;

} else {

cipher.update(content, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public byte[] decrypt(byte[] secret) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

if (secret == null) {

return null;

}

try {

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

int size = privateKey.getModulus().bitLength() / 8;

ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size - 12) / (size - 11) * size);

int left = 0;

for (int i = 0; i < secret.length; ) {

left = secret.length - i;

if (left > size) {

cipher.update(secret, i, size);

i += size;

} else {

cipher.update(secret, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

logger.error("rsa decrypt failed.", e);

}

return null;

}

public byte[] sign(byte[] content) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

if (content == null) {

return null;

}

try {

Signature signature = Signature.getInstance("SHA1WithRSA");

signature.initSign(privateKey);

signature.update(content);

return signature.sign();

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public boolean verify(byte[] sign, byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

if (sign == null || content == null) {

return false;

}

try {

Signature signature = Signature.getInstance("SHA1WithRSA");

signature.initVerify(publicKey);

signature.update(content);

return signature.verify(sign);

} catch (Exception e) {

logger.error("rsa verify failed.", e);

}

return false;

}

}

5.6. ECC算法

ECC 也是一种 非对称加密算法，主要优势是在某些情况下，它比其他的方法使用 更小的密钥，比如 RSA 加密算法，提供 相当的或更高等级 的安全级别。不过一个缺点是 加密和解密操作 的实现比其他机制 时间长 (相比 RSA 算法，该算法对 CPU 消耗严重)。

Java使用案例：

import net.pocrd.annotation.NotThreadSafe;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.security.KeyFactory;

import java.security.Security;

import java.security.Signature;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe

public class EccHelper {

private static final Logger logger = LoggerFactory.getLogger(EccHelper.class);

private static final int SIZE = 4096;

private BCECPublicKey publicKey;

private BCECPrivateKey privateKey;

static {

Security.addProvider(new BouncyCastleProvider());

}

public EccHelper(String publicKey, String privateKey) {

this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));

}

public EccHelper(byte[] publicKey, byte[] privateKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

if (privateKey != null && privateKey.length > 0) {

this.privateKey = (BCECPrivateKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));

}

} catch (ClassCastException e) {

throw new RuntimeException("", e);

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public EccHelper(String publicKey) {

this(Base64Util.decode(publicKey));

}

public EccHelper(byte[] publicKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public byte[] encrypt(byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

try {

Cipher cipher = Cipher.getInstance("ECIES", "BC");

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

int size = SIZE;

ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 45));

int left = 0;

for (int i = 0; i < content.length; ) {

left = content.length - i;

if (left > size) {

cipher.update(content, i, size);

i += size;

} else {

cipher.update(content, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public byte[] decrypt(byte[] secret) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

try {

Cipher cipher = Cipher.getInstance("ECIES", "BC");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

int size = SIZE + 45;

ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size + 44) / (size + 45) * size);

int left = 0;

for (int i = 0; i < secret.length; ) {

left = secret.length - i;

if (left > size) {

cipher.update(secret, i, size);

i += size;

} else {

cipher.update(secret, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

logger.error("ecc decrypt failed.", e);

}

return null;

}

public byte[] sign(byte[] content) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

try {

Signature signature = Signature.getInstance("SHA1withECDSA", "BC");

signature.initSign(privateKey);

signature.update(content);

return signature.sign();

} catch (Exception e) {

throw new RuntimeException(e);

}

}

public boolean verify(byte[] sign, byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

try {

Signature signature = Signature.getInstance("SHA1withECDSA", "BC");

signature.initVerify(publicKey);

signature.update(content);

return signature.verify(sign);

} catch (Exception e) {

logger.error("ecc verify failed.", e);

}

return false;

}

}

白菜说技术

优质技术作者 @问题儿童

144

文章

277k

阅读

685

粉丝 目录 收起

1. 加密概念

2. 对称加密

3. 非对称加密

4. 常见加密算法比较

4.1. 散列算法比较

4.2. 对称加密算法比较

4.3. 非对称加密算法比较

5. 常见加密算法使用

5.1. MD5算法

5.2. SHA1算法

5.3. HMAC算法

5.4. AES算法

5.5. RSA算法

5.6. ECC算法

什么是非对称加密？ - 知乎

什么是非对称加密？ - 知乎切换模式写文章登录/注册什么是非对称加密？Peter 王广忠程序员，专业区块链讲解员https://www.zhihu.com/video/1060580798515859456密码学中有两种技术：一种叫对称加密，另外一种叫非对称加密。这次咱们主要聊聊非对称加密。对称加密不过咱们先从对称加密说起，这是比较直观的一种加密方式。基本逻辑是这样。如果 Alice 想把一个信息传递给 Bob 。比如信息是一个数字 m ，Alice 不能把这个数字直接传递给 Bob ，因为互联网是一个不安全的环境，很容易被窃听。所以她可以通过一个加密算法，比如，通过给 m 加上一个数字 e ，得到一个数字 c ，这个 c 就叫做密文。这样 Bob 拿到密文 c ，再减去 e 就可以得到信息 m 了。比如，想要传递的 m 等于2，e 等于1，那么2+1得到密文就是3，3传递给 Bob 之后，Bob 用3-1得到信息 m 了。这个过程中，密文是可以放心的在互联网上传播的，被窃听了也没人能看懂。e 就是密钥，密钥如果一旦泄露了，通信过程就不安全了。当然实际中加密算法以及密钥都必须很复杂，不是简单的加一个数字，因为现在人们的解密手段其实也已经非常高超了。对称加密的优势是可以加密大段信息，这个是非对称加密做不到的，但是对称加密的问题在于如何能够安全的把密钥传递给对方。因为如果 Alice 不能安全的把密钥传递给 Bob ，那么加密通信就实现不了。而如果不能实现加密通信，那又怎么可能安全的传递密钥呢，所以对称加密在互联网上使用，就有了这个鸡生蛋蛋生鸡的问题。非对称加密被发明出来，就是为了解决对称加密的这个最为致命的痛点。非对称加密非对称加密之所以不对称，指的就是加密用一个密钥，而解密的时候用的是另外一个密钥。这个过程是这样的。Bob 作为接收信息的一方，首先要生成一对儿密钥，一个叫做公钥，意思就是可以公开出去的密钥。另外一个叫做私钥，也就是要私密保存的。注意这一对儿密钥是有天然的数学联系的，不然也不可能用公钥加密后能用私钥解密。具体这个联系是什么，可以参考 RSA 算法 https://learning.nervos.org/crypto-block/8-idea ，我们这里就不展开了。接下来，Bob 把自己的公钥传递给 Alice ，Alice 用 Bob 的公钥去加密信息 m 得到密文 c 。Bob 拿到密文 c 之后，注意这里就体现出来不对称了，因为 Bob 解密用的不是公钥，而是自己的私钥。咱们思考一下这个过程里面的安全性。暴露在互联网上的首先是公钥，然后是密文，非对称加密的算法本身是公开的。但是即使公钥密文算法都被攻击者拿到，他也不能解密拿到信息的。所以整个过程是安全的。非对称加密本身没有对称加密的鸡生蛋的问题，所以是当代密码学也就是互联网密码学的核心技术。同时，非对称加密可以帮忙解决对称加密的鸡生蛋问题，那就是先让 Alice 跟 Bob 用非对称加密的方式来互相共享一个对称加密的秘钥，然后再用对称加密的方式来传递大段信息。互联网上通信一般都是把两种加密方式配合起来用的。数字签名非对称加密还有一个名字叫公钥加密，这种加密算法除了能进行加密通信之外，还能进行数字签名。数字签名是干啥的呢？密码学要达成的是在一个根本不安全的网络上进行安全的信息传递。不安全的网络具体就是指互联网，安全的信息传递包括两个方面：一方面是加密通信，Alice 跟 Bob 发信息，只有这两个人能看到，没人任何第三方能够窃取到信息。另一方面是数字签名，Bob 收到一条信息号称发送方是 Alice ，那怎么才能确定这个信息就真的是 Alice 发出的呢？我们就可以联想现实世界，同事给我一个文件说是老板发出的，如果文件上的确有老板的签名那就可以证实了。数字签名也是一样的道理，一个信息传递给 Bob ，只要 Bob 也收到了跟信息相关的 Alice 的数字签名，那么就可以确认这个信息的确是 Alice 发出的了。至于 Bob 如何验证这个私钥签名的确是 Alice 亲自签署的，那要涉及到公钥和私钥的关系了。其实私钥加密的东西也可以用公钥去解密的。所以 Alice 如果用私钥去把信息的哈希 https://learning.nervos.org/crypto-block/3-hash 给加密一下，就会得到数字签名，Bob 收到数字签名之后，如果能用 Alice 的公钥去解密这个签名，就可以验证两点：第一，这个签名的确是由私钥的持有者发出的了，第二，也可以证明信息没有被篡改过，因为签名中也包含信息的哈希。总结非对称加密的基本情况就介绍这些了。非对称加密和对称加密是目前互联网上常用的两种加密方法。非对称加密不太适合加密大段信息，所以一般是和对称加密配合使用。除了完成加密通信，非对称加密还有另外一个功能，那就是数字签名。参考：https://www.youtube.com/watch?v=D_kMadCtKp8发布于 2018-12-24 17:03密码​赞同 60​​8 条评论​分享​喜欢​收藏​申请

深入理解对称加密和非对称加密 - 知乎

深入理解对称加密和非对称加密 - 知乎首发于问我学院切换模式写文章登录/注册深入理解对称加密和非对称加密问我学院问我学院，专注计算机信息，区块链，人工智能和大数据等技术研究关于对称加密和非对称加密 我们都知道，密码体制有两种: 对称密码体制( 又称为单钥密码体制) 和非对称密码体制( 又称为双钥密码体制或公钥密码体制) 。对称密码体制使用相同的密钥( 秘密密钥) 对消息进行加密/解密，系统的保密性主要由密钥的安全性决定，而与算法是否保密无关。 对称密码体制设计和实现的中心是: 用何种方法产生满足保密要求的密钥以及用何种方法将密钥安全又可靠地分配给通信双方。对称密码体制可以通过分组密码或流密码来实现，它既可以用于数据加密，又可以用于消息认证。非对称密码体制使用公钥加密消息，使用私钥来解密。使用非对称密码体制可增强通信的安全性。 在密码学体系中，对称加密、非对称加密、单向散列函数、消息认证码、数字签名和伪随机数生成器被统称为密码学家的工具箱。其中，对称加密和非对称加密主要是用来保证机密性；单向散列函数用来保证消息的完整性；消息认证码的功能主要是认证；数字签名保证消息的不可抵赖性。这篇文章所要讲诉的就是保证消息的机密性的对称密码和非对称密码。密码学的发展简史 密码学的发展大致可以分为 3 个阶段: 1949 年之前的古典密码学阶段; 1949 年至 1975 年密码学成为科学的分支; 1976 年以后对称密钥密码算法得到进一步发展，产生了密码学的新方向—公钥密码学。1976 年，W.Diffie 和 M.Hellman 在发表的文章“密码学的新方向”中首次公开提出了公钥密码( Public-key Cryptography) 的概念。公钥密码的提出实现了加密密钥和解密密钥之间的独立，解决了对称密码体制中通信双方必须共享密钥的问题，在密码学界具有划时代的意义。本文的结构 文章会对称加密和非对称加密的加密的特点进行介绍，比较对称加密和非对称加密的优缺点，介绍几种比较经典的对称加密算法和非对称加密算法，例如：DES、 AES、RSA 和 ECC 等。 本文的混合加密所指的内容是取对称加密和非对称加密的优点，摒弃他们的缺点而形式的高效的混合加密方案，这种方式在目前的加密系统中的应用也很广泛。对称加密 对称加密又称但密钥加密，整个加密过程中只使用一个密钥。所谓对称其实就是使用一把密钥加密，使用同一把密钥解密。对称加密由于加解和解密使用的是同一个密钥算法，故而在加解密的过程中速度比较快，适合于数据量比较大的加解密。 对称加密的主要有优点就是算法公开、计算量小、加密速度快、加密效率高；但是它也存在强大的缺点，缺点就是密钥协商过程中，一旦密钥泄露，别人可以获取到密钥，这样也能对密文进行解密。另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的独一密钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。 常用的对称加密算法有 DES、3DES、AES、TDEA、Blowfish、RC2、RC4 和 RC5 等。两种经典的对称加密算法DES DES 加密解密算法最初由美国 IBM 公司研究人员所设计发明，且为第一个公开的商用密码算法标准，自诞生以来便得到了 ISO 的一致认可。DES 是分组密码算法的典型代表，它的明文分组长度为 64bits，密钥长度为 64bits，其中包括有 8bits 的奇偶校验，因此有效密钥长度为 56bits。DES 加密解密算法使用的过程相同，且可以随时均都可以进行变动。它们其中有极少数被认为是易破解的弱密钥，但是很容易抛开它们不使用，因此其自身安全性主要依赖于有效密钥。 DES 算法加密过程首先先对明文分组进行操作，需要加密的明文分为每块 64bits 的固定大小。下图所示左右两部分分别为64bits 的明文分组加密过程和其 16 个子密钥生成的过程。DES 核心算法模块IP 初始置换IP 初始置换，在第一轮运算之前执行，对输入的分组采用下面的数字进行 IP 初始变换，按照从左向右、从上向下进行置换。58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6 64 56 48 40 32 24 16 8 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7子密钥获取流程子密钥的获取流程如下图 此处，用户输入 64 位的密钥。根据密钥置换表 PC-1，将 64 位变成 56 位密钥（此处去掉了奇偶校验位）。 PC-1 置换得到的 56 位密钥。此处密钥被分为前 28位 C0 和后 28 位 D0。分别对它们进行循环左移，C0 左移得到 C1，D0 左移得到 D1。将 C1 和 D1 合并变成 56 位。然后通过 PC-2 表进行压缩置换，得到此轮的 48 位子密钥 K1。 再对 C1 和 D1 进行相同的左移和压缩置换，获取下一轮的子密钥……一共进行 16 轮，于是可以得到 16 个 48 bits 的子密钥。E盒扩展 E 盒扩展置换，则是将右半部分 32bits 按照 8 行 4 列方式依次排列，得到一个 8*4的二维矩阵，然后根据如表 2 所示的 E 盒扩展置换表扩展为 8*6的二维矩阵。32 1 2 3 4 5 4 5 6 7 8 9 8 9 10 11 12 13 12 13 14 15 16 17 16 17 18 19 20 21 20 21 22 23 24 25 24 25 26 27 28 29 28 29 30 31 32 1异或运算 将 P 盒置换的结果与最初的 64bits 分组的左半部分异或，然后左、右半部分交换，接着开始另一轮。S 盒扩展 当产生了 48bits 密钥后就可以和明文进行异或运算，便可得到 48bits 的密文。再开始下轮的 S 盒迭代运算，其功能是把 6bit数据变为 4bits 数据，每个 S 盒是一个 4 行、16 列的表。每个 S盒的使用方法为：S 盒收到 6bits 的输入，6bits 的第 1 个 bit 和最后 1 个 bits 构成的 2 位二进制为该 S 盒行号，中间的 4bits 二进制为该 S 盒的列号，然后根据行号和列号查 S 盒定义表得到对应的值（通常为十进制），该值就是 S 盒变换的输出，并转化为二进制。P 盒置换 S 盒代替运算之后，输出 32bits，作为 F 函数最后一个变换 P 盒置换的输入。将该 32bits 位数据进行 P 盒置换，置换后得到一个仍然是 32 bits 的结果，此处可得 F 函数的输出值。逆初始置换 DES 完成 16 轮变换后，得到 64bits 数据作为 IP-1 逆初始置换的输入，经过 IP-1 逆初始置换表（如表 3 所示），64bits 输入数据位置重新编排，就得到 64bits 的密文。40 8 48 16 56 24 64 32 39 7 47 15 55 23 63 31 38 6 46 14 54 22 62 30 37 5 45 13 53 21 61 29 36 4 44 12 52 20 60 28 35 3 43 11 51 19 59 27 34 2 42 10 50 18 58 26 33 1 41 9 49 17 57 25AES AES 加密算法为分组密码，分组长度为 128 位即 16 个字节，密匙长度有128、192 或 256 位，根据密匙 长 度的不同，加密的轮数也不同，本文采用长度为 128 位的密匙，加密轮数为 10 轮。AES 加密算法不仅编码紧凑、设计简单而且可抵抗多种类型的攻击，其基本结构包括 ４个部分。这四个部分分别为字节替换、行位移、列混合和轮密匙加。字节替换（SubBytes） 字节替换也就是通 过 S-BOX 对字节元素进行非线性的变换，S-BOX 由有限域 GF(2 的 8 次方) 上的乘法求逆运算和仿射变换运算而来，通过查表的方式即可直接得到变换前后的字节元素，替换后字节元素至少有两位发生变换，能 充分打乱原来的字节元素，本文所介绍的 AES 加 密 算 法 就是对 S-BOX 进行改 进 而 来。具体替换规则为假设一字 节为 xy，则 S-BOX 中第ｘ行第ｙ列所对应的元素就是替换后的元素。行位移（ShiftRows） 行位移是 AES 加密算法中的一个简单线性运算，即在 4 x 4 的状态矩阵中，把第ｉ行循环左移ｉ个字节(i＝0, 1, 2, 3)。列混合（MixColumns） 列混合是将状态矩阵中的每一列看成一个多项式，让其与一个固定的多项式 a(x) 相乘，再做模多项式 m(x) = x4（x的四次方） + 1 的运算，其中 a(x)＝’03‘x3（x的3次方）+ ’01‘x2（x的平方）+ '01'x + ‘02’。轮密匙加（AddRoundKey） 轮密匙加变换就是让状态矩阵与经过密匙扩展得到的子密匙做异或运算，因此轮密匙加变换的逆变换就是其本身，其中子密匙是原始密匙通过密匙扩展算法得到的。AES 算法流程下图是整个算法的流程图 AES 加密算法先将 128 位的明文进行分组，得到一个 4x4 的明文状态矩阵作为算法的输入，然后选取密匙矩阵先对明文状态矩阵做一次轮密匙加变换，再经过 10 轮的轮函数加密，轮函数操作依次为字节替换、行位移、列混合和轮密匙加，其中由于最后一轮的列混合不仅不会提高安全性，反而会拉低 算 法 运 算 速 度，故该轮丢弃列混合变换。解密算法仍为 10 轮，由于算法的4个轮操作均为可逆变换，因此解密过程就是用与加密过程同样的密匙对每一轮的加密操作进行逆运算。非对称加密 非对称加密又称为公钥密码，该技术是针对私钥密码体制（对称加密算法）的缺陷被提出来的，非对称加密会产生两把密钥，分别为公钥（Public Key）和私钥（Private Key），其中一把密钥用于加密，另一把密钥用于解密。非对称加密的特征是算法强度复杂、安全性依赖于算法与密钥但是由于其算法复杂，而使得加密解密速度没有对称加密解密的速度快。对称密码体制中只有一种密钥，并且是非公开的，如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全，而非对称密钥体制有两种密钥，其中一个是公开的，这样就可以不需要像对称密码那样传输对方的密钥了。这样安全性就高了很多。 常用的非对称加密算发有 RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）等。两种经典的非对称加密算法RSA RSA 算法是一种迄今为止理论上比较成熟和完善的公钥密码体制，是非对称密码体制的典型代表。在网络、信息安全等许多方面都使用 RSA 算法，特别是 RSA 算法典型应用在通信中的数字签名，可实现对手的身份、不可抵赖性验证。在身份认证、信息安全、电子商务中有着广泛的应用前景。RSA 的算法流程RSA 算法由密钥的产生、加密算法和解密算法 3 个部分组成。密钥的产生过程如下：产生两个大素数 p 和 q ；计算 n = p × q ，欧拉函数 φ(n) =(p - 1)(q - 1)选择整数 e ，使其满足条件：1 < e < φ(n) ，且gcd(e,φ(n)) = 1（注：gcd () 函数计算两个数的最大公约数）；计算 e 的逆元 d ：d∙e ≡ 1 mod φ(n)（注：由于gcd(e,φ(n)) = 1，则 d 一定存在）；取序对 (e,n) 为公钥，可公开；(d,n) 为私钥，对外保密。加密算法过程如下将要发送的字符串分割为长度为 m < n 的分组，然后对分组 mi 执行加密运算，得到密文 ci ：ci ≡(mi)e mod n解密算法过程如下收到密文 ci 后，接收者使用自己的私钥执行解密运算，得到明文 mi ：mi ≡(ci)d mod nRSA 详细的算法设计流程大素数的产生和测试Miller-Rabin 算法是一种基于概率的素数测试方法，在密码学的素数产生中，由于该算法的速度快、原理简单、易于实现，成为进行素数检测的最佳选择。Miller-Rabin 算法是对费马算法改进，它的操作步骤如下：计算 m ，满足 n = (2r 2的r次方 ) m + 1；选择随机数 a ∈[1,n] ；若 am mod n = 1 ，或满足 aim mod n = n - 1 ，则 n 通过随机数 a 的测试；再取不同 a 要的值对 n 进行 t = 5 次测试，如果每次测试结果为 n 是素数，则以高概率判定 n 是素数。假设 n 通过 t 次测试，则判定结果错误的概率是1/4t；若只通过一次测试，素数判定的错误概率是 25%。流程图如下：密钥 e 生成模块 通过上面的的大素数生成模块，可以得到大素数 p和大素数 q ，根据欧拉函数 φ(n) =(p - 1)(q - 1) ，同时密钥 e 与 φ(n) 互质，根据中国剩余定理可以计算密钥e 。过程如下：密钥 d 生成模块 通过大素数生成模块得到大素数 p 和 q ，密钥 e 生成模块，根据 1 = ed mod ( p - 1) (q - 1) 。利用中国剩余定理计算 e 的乘法逆元 d 。快速指数算法 得到 e 后，就可以通过公钥 (e,n) 进行加密得到密文 C 。在 RSA 加密过程中，为了计算 ci ≡(mi)e mod n ，采用快速指数算法。将快速指数算法描述为三元组(M,E,Y) ，其初始值为 (M,E,Y ) =(mi,e,1) 。重复执行以下操作：①若 E 是奇数，则 Y = MY mod n ，E = E - 1 ; ②若 E 是偶数，则 X = XX mod n ，E = E/2 。 最终，当 E = 0 时，则 Y = X^E mod n 。RSA加密和解密算法设计过程如下：ECC 椭圆曲线加密算法（ECC）是基于椭圆曲线数学的一种非对称密码算法，是建立在基于椭圆曲线的离散对数问题上的密码体制。随着分解大整数方法的进步以及各方面的完善，RSA 算法渐渐不能满足现状，ECC 算法的需求性逐渐增大。ECC 以其明显的“短密钥”优势得到了广泛应用，并逐渐被确定为许多编码方式的数字签名标准。当然，ECC 还有许多未解决的问题，不过这种引用了丰富数学理论的算法，也印证了将更多数学有较大可行性理论应用到密码学这一领域中。 首先从数学角度阐释算法加密原理，ECC椭圆曲线加密算法数学基础是利用有限域上椭圆曲线离散对数问题（ECDLP）的计算困难性，所谓椭圆曲线是指由韦尔斯特拉方程。其椭圆曲线方程如下：y2 + a1xy + a2 y = x3 + a3x2 + a4 x + a5下面是椭圆曲线方式图示 其中，系数 ai 定义在某个域上（密码算法中需要把之前连续曲线变为有限域上的点，故 ai 也定义在有限域中）。曲线上所有点和一个无穷远点构成一个集合连同定义上的加法（eg：a+b≡c (mod p)）构成阿贝尔群。由于曲线上每一点都是非奇异点，故可在椭圆曲线上找到两点 P、Q，且存在如下关系式： 由此可见，已知 m、P 求 Q 较为容易，反之由 Q 逆向求 m、P 难度却较大，椭圆曲线密码正是基于该机制来展开设计及应用。混合加密-对称加密和非对称加密的实际应用场景 所谓混合加密就是使用在实际的应用中把对称加密和非对称加密结合起来使用。我们都知道非对称加密算法比对称加密算法慢数千倍，但在保护通信安全方面，非对称加密算法却具有对称密码难以企及的优势。所以在实际的应用中，都是对称加密与非对称加密混合使用。取其优势，去其糟粕，达到完美使用的一个目的。 对称加密技术，即专用密钥加密技术或单钥密码技术，加密密钥与解密密钥一致，发送方与接收方用同一组的公私密钥对加密或者解密信息。数据加密的一个关键要求是有相同的密钥才能解密。因为通信双方共享密钥，如果密钥丢失或泄露，那么获取密钥的人就可以加密或者解密数据，所以为保证消息的机密性必须保障密钥的安全。 这种算法比较简单且计算量比较小，对网络开放、从而能够效率高地加密。同时存在的缺点，一是通讯双方基于通过非面对面的方式协商一个共同的密钥，因此不能保证协商过程的安全性。二是通讯双方每次进行数据传输时都使用惟一密钥，这使得对称加密技术在开放型的网络中需要使用和生成大量的密钥，对于密钥的管理就成为用户的很大负担。三是对称加密算法只能对数据进行加解密，保证数据的机密性，但无法验证通讯双方的真实身份，不能确定数据的完整性。 非对称密钥加密技术，由公钥和私钥形成一个密钥对，其中公钥向公众公开，私钥归密钥持有人单独保管。通讯双方使用非对称密钥对数据进行加密和解密时，必须使用相互匹配的公钥和私钥。它有两种方式：一种是发送方用接收方的公钥来加密信息，接收方用其私钥解密信息，这样接收方可以收到多个发送方传来的加密数据，且此加密数据只有接收方一个用户可以解读；另一种即发送方利用自身的私钥加密信息，接收方用对方公钥解密信息，这样一个信息有可能被多个接收方解密。 非对称密钥加密技术的优点是简化了密钥的发放及管理的过程，支持数字签名等安全认证技术，缺点是加密和解密的计算过程特别复杂，运行数据加密和解密的速度比较慢。原文链接：http://www.wenwoha.com/blog_detail-7.html支持平台：链眼社区http://www.chaineye.info椭圆曲线（原木姜子科技）http://www.gingernet.vip/ 发布于 2021-06-03 12:18密码加密非对称式加密对称加密​赞同 13​​添加评论​分享​喜欢​收藏​申请转载​文章被以下专栏收录问我学院专注软硬件开发，测试和运维平台技术文

非对称加密算法 - 廖雪峰的官方网站

非对称加密算法 - 廖雪峰的官方网站

Index

廖雪峰的官方网站

Blog

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

More

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Profile

Passkey

Sign Out

Sign In

English

简体中文

Index

Java教程

Java快速入门

Java简介

安装JDK

第一个Java程序

Java代码助手

使用IDE

使用IDE练习插件

Java程序基础

Java程序基本结构

变量和数据类型

整数运算

浮点数运算

布尔运算

字符和字符串

数组类型

流程控制

输入和输出

if判断

switch多重选择

while循环

do while循环

for循环

break和continue

数组操作

遍历数组

数组排序

多维数组

命令行参数

面向对象编程

面向对象基础

方法

构造方法

方法重载

继承

多态

抽象类

接口

静态字段和静态方法

包

作用域

内部类

classpath和jar

class版本

模块

Java核心类

字符串和编码

StringBuilder

StringJoiner

包装类型

JavaBean

枚举类

记录类

BigInteger

BigDecimal

常用工具类

异常处理

Java的异常

捕获异常

抛出异常

自定义异常

NullPointerException

使用断言

使用JDK Logging

使用Commons Logging

使用Log4j

使用SLF4J和Logback

反射

Class类

访问字段

调用方法

调用构造方法

获取继承关系

动态代理

注解

使用注解

定义注解

处理注解

泛型

什么是泛型

使用泛型

编写泛型

擦拭法

extends通配符

super通配符

泛型和反射

集合

Java集合简介

使用List

编写equals方法

使用Map

编写equals和hashCode

使用EnumMap

使用TreeMap

使用Properties

使用Set

使用Queue

使用PriorityQueue

使用Deque

使用Stack

使用Iterator

使用Collections

IO

File对象

InputStream

OutputStream

Filter模式

操作Zip

读取classpath资源

序列化

Reader

Writer

PrintStream和PrintWriter

使用Files

日期与时间

基本概念

Date和Calendar

LocalDateTime

ZonedDateTime

DateTimeFormatter

Instant

最佳实践

单元测试

编写JUnit测试

使用Fixture

异常测试

条件测试

参数化测试

正则表达式

正则表达式简介

匹配规则

复杂匹配规则

分组匹配

非贪婪匹配

搜索和替换

加密与安全

编码算法

哈希算法

BouncyCastle

Hmac算法

对称加密算法

口令加密算法

密钥交换算法

非对称加密算法

签名算法

数字证书

多线程

多线程基础

创建新线程

线程的状态

中断线程

守护线程

线程同步

同步方法

死锁

使用wait和notify

使用ReentrantLock

使用Condition

使用ReadWriteLock

使用StampedLock

使用Semaphore

使用Concurrent集合

使用Atomic

使用线程池

使用Future

使用CompletableFuture

使用ForkJoin

使用ThreadLocal

使用虚拟线程

Maven基础

Maven介绍

依赖管理

构建流程

使用插件

模块管理

使用mvnw

发布Artifact

网络编程

网络编程基础

TCP编程

UDP编程

发送Email

接收Email

HTTP编程

RMI远程调用

XML与JSON

XML简介

使用DOM

使用SAX

使用Jackson

使用JSON

JDBC编程

JDBC简介

JDBC查询

JDBC更新

JDBC事务

JDBC Batch

JDBC连接池

函数式编程

Lambda基础

方法引用

使用Stream

创建Stream

使用map

使用filter

使用reduce

输出集合

其他操作

设计模式

创建型模式

工厂方法

抽象工厂

生成器

原型

单例

结构型模式

适配器

桥接

组合

装饰器

外观

享元

代理

行为型模式

责任链

命令

解释器

迭代器

中介

备忘录

观察者

状态

策略

模板方法

访问者

Web开发

Web基础

Servlet入门

Servlet开发

Servlet进阶

重定向与转发

使用Session和Cookie

JSP开发

MVC开发

MVC高级开发

使用Filter

修改请求

修改响应

使用Listener

部署

Spring开发

IoC容器

IoC原理

装配Bean

使用Annotation配置

定制Bean

使用Resource

注入配置

使用条件装配

使用AOP

装配AOP

使用注解装配AOP

AOP避坑指南

访问数据库

使用JDBC

使用声明式事务

使用DAO

集成Hibernate

集成JPA

集成MyBatis

设计ORM

开发Web应用

使用Spring MVC

使用REST

集成Filter

使用Interceptor

处理CORS

国际化

异步处理

使用WebSocket

集成第三方组件

集成JavaMail

集成JMS

使用Scheduler

集成JMX

Spring Boot开发

第一个Spring Boot应用

使用开发者工具

打包Spring Boot应用

瘦身Spring Boot应用

使用Actuator

使用Profiles

使用Conditional

加载配置文件

禁用自动配置

添加Filter

集成第三方组件

集成Open API

访问Redis

集成Artemis

集成RabbitMQ

集成Kafka

Spring Cloud开发

项目架构设计

搭建项目框架

设计交易引擎

设计资产系统

设计订单系统

设计撮合引擎

设计清算系统

完成交易引擎

设计定序系统

设计API系统

设计行情系统

设计推送系统

编写UI

项目总结

关注公众号不定期领红包：

加入知识星球社群：

关注微博获取实时动态：

非对称加密算法

Last updated: ...

/

Reads: 1148333

Edit

从DH算法我们可以看到，公钥-私钥组成的密钥对是非常有用的加密方式，因为公钥是可以公开的，而私钥是完全保密的，由此奠定了非对称加密的基础。

非对称加密就是加密和解密使用的不是相同的密钥：只有同一个公钥-私钥对才能正常加解密。

因此，如果小明要加密一个文件发送给小红，他应该首先向小红索取她的公钥，然后，他用小红的公钥加密，把加密文件发送给小红，此文件只能由小红的私钥解开，因为小红的私钥在她自己手里，所以，除了小红，没有任何人能解开此文件。

非对称加密的典型算法就是RSA算法，它是由Ron Rivest，Adi Shamir，Leonard Adleman这三个哥们一起发明的，所以用他们仨的姓的首字母缩写表示。

非对称加密相比对称加密的显著优点在于，对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在N个人之间通信的时候：使用非对称加密只需要N个密钥对，每个人只管理自己的密钥对。而使用对称加密需要则需要N*(N-1)/2个密钥，因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏。

既然非对称加密这么好，那我们抛弃对称加密，完全使用非对称加密行不行？也不行。因为非对称加密的缺点就是运算速度非常慢，比对称加密要慢很多。

所以，在实际应用的时候，非对称加密总是和对称加密一起使用。假设小明需要给小红需要传输加密文件，他俩首先交换了各自的公钥，然后：

小明生成一个随机的AES口令，然后用小红的公钥通过RSA加密这个口令，并发给小红；

小红用自己的RSA私钥解密得到AES口令；

双方使用这个共享的AES口令用AES加密通信。

可见非对称加密实际上应用在第一步，即加密“AES口令”。这也是我们在浏览器中常用的HTTPS协议的做法，即浏览器和服务器先通过RSA交换AES口令，接下来双方通信实际上采用的是速度较快的AES对称加密，而不是缓慢的RSA非对称加密。

Java标准库提供了RSA算法的实现，示例代码如下：

import java.math.BigInteger;

import java.security.*;

import javax.crypto.Cipher;

----

public class Main {

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

// 明文:

byte[] plain = "Hello, encrypt use RSA".getBytes("UTF-8");

// 创建公钥／私钥对:

Person alice = new Person("Alice");

// 用Alice的公钥加密:

byte[] pk = alice.getPublicKey();

System.out.println(String.format("public key: %x", new BigInteger(1, pk)));

byte[] encrypted = alice.encrypt(plain);

System.out.println(String.format("encrypted: %x", new BigInteger(1, encrypted)));

// 用Alice的私钥解密:

byte[] sk = alice.getPrivateKey();

System.out.println(String.format("private key: %x", new BigInteger(1, sk)));

byte[] decrypted = alice.decrypt(encrypted);

System.out.println(new String(decrypted, "UTF-8"));

}

}

class Person {

String name;

// 私钥:

PrivateKey sk;

// 公钥:

PublicKey pk;

public Person(String name) throws GeneralSecurityException {

this.name = name;

// 生成公钥／私钥对:

KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");

kpGen.initialize(1024);

KeyPair kp = kpGen.generateKeyPair();

this.sk = kp.getPrivate();

this.pk = kp.getPublic();

}

// 把私钥导出为字节

public byte[] getPrivateKey() {

return this.sk.getEncoded();

}

// 把公钥导出为字节

public byte[] getPublicKey() {

return this.pk.getEncoded();

}

// 用公钥加密:

public byte[] encrypt(byte[] message) throws GeneralSecurityException {

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.ENCRYPT_MODE, this.pk);

return cipher.doFinal(message);

}

// 用私钥解密:

public byte[] decrypt(byte[] input) throws GeneralSecurityException {

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.DECRYPT_MODE, this.sk);

return cipher.doFinal(input);

}

}

RSA的公钥和私钥都可以通过getEncoded()方法获得以byte[]表示的二进制数据，并根据需要保存到文件中。要从byte[]数组恢复公钥或私钥，可以这么写：

byte[] pkData = ...

byte[] skData = ...

KeyFactory kf = KeyFactory.getInstance("RSA");

// 恢复公钥:

X509EncodedKeySpec pkSpec = new X509EncodedKeySpec(pkData);

PublicKey pk = kf.generatePublic(pkSpec);

// 恢复私钥:

PKCS8EncodedKeySpec skSpec = new PKCS8EncodedKeySpec(skData);

PrivateKey sk = kf.generatePrivate(skSpec);

以RSA算法为例，它的密钥有256/512/1024/2048/4096等不同的长度。长度越长，密码强度越大，当然计算速度也越慢。

如果修改待加密的byte[]数据的大小，可以发现，使用512bit的RSA加密时，明文长度不能超过53字节，使用1024bit的RSA加密时，明文长度不能超过117字节，这也是为什么使用RSA的时候，总是配合AES一起使用，即用AES加密任意长度的明文，用RSA加密AES口令。

此外，只使用非对称加密算法不能防止中间人攻击。

练习

RSA加密

小结

非对称加密就是加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密；

只使用非对称加密算法不能防止中间人攻击。

Comments

Make a comment

Sign in to

make a comment

Index

Java教程

Java快速入门

Java简介

安装JDK

第一个Java程序

Java代码助手

使用IDE

使用IDE练习插件

Java程序基础

Java程序基本结构

变量和数据类型

整数运算

浮点数运算

布尔运算

字符和字符串

数组类型

流程控制

输入和输出

if判断

switch多重选择

while循环

do while循环

for循环

break和continue

数组操作

遍历数组

数组排序

多维数组

命令行参数

面向对象编程

面向对象基础

方法

构造方法

方法重载

继承

多态

抽象类

接口

静态字段和静态方法

包

作用域

内部类

classpath和jar

class版本

模块

Java核心类

字符串和编码

StringBuilder

StringJoiner

包装类型

JavaBean

枚举类

记录类

BigInteger

BigDecimal

常用工具类

异常处理

Java的异常

捕获异常

抛出异常

自定义异常

NullPointerException

使用断言

使用JDK Logging

使用Commons Logging

使用Log4j

使用SLF4J和Logback

反射

Class类

访问字段

调用方法

调用构造方法

获取继承关系

动态代理

注解

使用注解

定义注解

处理注解

泛型

什么是泛型

使用泛型

编写泛型

擦拭法

extends通配符

super通配符

泛型和反射

集合

Java集合简介

使用List

编写equals方法

使用Map

编写equals和hashCode

使用EnumMap

使用TreeMap

使用Properties

使用Set

使用Queue

使用PriorityQueue

使用Deque

使用Stack

使用Iterator

使用Collections

IO

File对象

InputStream

OutputStream

Filter模式

操作Zip

读取classpath资源

序列化

Reader

Writer

PrintStream和PrintWriter

使用Files

日期与时间

基本概念

Date和Calendar

LocalDateTime

ZonedDateTime

DateTimeFormatter

Instant

最佳实践

单元测试

编写JUnit测试

使用Fixture

异常测试

条件测试

参数化测试

正则表达式

正则表达式简介

匹配规则

复杂匹配规则

分组匹配

非贪婪匹配

搜索和替换

加密与安全

编码算法

哈希算法

BouncyCastle

Hmac算法

对称加密算法

口令加密算法

密钥交换算法

非对称加密算法

签名算法

数字证书

多线程

多线程基础

创建新线程

线程的状态

中断线程

守护线程

线程同步

同步方法

死锁

使用wait和notify

使用ReentrantLock

使用Condition

使用ReadWriteLock

使用StampedLock

使用Semaphore

使用Concurrent集合

使用Atomic

使用线程池

使用Future

使用CompletableFuture

使用ForkJoin

使用ThreadLocal

使用虚拟线程

Maven基础

Maven介绍

依赖管理

构建流程

使用插件

模块管理

使用mvnw

发布Artifact

网络编程

网络编程基础

TCP编程

UDP编程

发送Email

接收Email

HTTP编程

RMI远程调用

XML与JSON

XML简介

使用DOM

使用SAX

使用Jackson

使用JSON

JDBC编程

JDBC简介

JDBC查询

JDBC更新

JDBC事务

JDBC Batch

JDBC连接池

函数式编程

Lambda基础

方法引用

使用Stream

创建Stream

使用map

使用filter

使用reduce

输出集合

其他操作

设计模式

创建型模式

工厂方法

抽象工厂

生成器

原型

单例

结构型模式

适配器

桥接

组合

装饰器

外观

享元

代理

行为型模式

责任链

命令

解释器

迭代器

中介

备忘录

观察者

状态

策略

模板方法

访问者

Web开发

Web基础

Servlet入门

Servlet开发

Servlet进阶

重定向与转发

使用Session和Cookie

JSP开发

MVC开发

MVC高级开发

使用Filter

修改请求

修改响应

使用Listener

部署

Spring开发

IoC容器

IoC原理

装配Bean

使用Annotation配置

定制Bean

使用Resource

注入配置

使用条件装配

使用AOP

装配AOP

使用注解装配AOP

AOP避坑指南

访问数据库

使用JDBC

使用声明式事务

使用DAO

集成Hibernate

集成JPA

集成MyBatis

设计ORM

开发Web应用

使用Spring MVC

使用REST

集成Filter

使用Interceptor

处理CORS

国际化

异步处理

使用WebSocket

集成第三方组件

集成JavaMail

集成JMS

使用Scheduler

集成JMX

Spring Boot开发

第一个Spring Boot应用

使用开发者工具

打包Spring Boot应用

瘦身Spring Boot应用

使用Actuator

使用Profiles

使用Conditional

加载配置文件

禁用自动配置

添加Filter

集成第三方组件

集成Open API

访问Redis

集成Artemis

集成RabbitMQ

集成Kafka

Spring Cloud开发

项目架构设计

搭建项目框架

设计交易引擎

设计资产系统

设计订单系统

设计撮合引擎

设计清算系统

完成交易引擎

设计定序系统

设计API系统

设计行情系统

设计推送系统

编写UI

项目总结

廖雪峰的官方网站

©Copyright 2019-2021

Powered by iTranswarp

Feedback

License

非对称加密算法有哪些？他们的优缺点是什么？ - 知乎

非对称加密算法有哪些？他们的优缺点是什么？ - 知乎首页知乎知学堂发现等你来答​切换模式登录/注册程序员算法网络安全Android 开发密码学非对称加密算法有哪些？他们的优缺点是什么？看了《白帽子讲 web 安全》很受益。但是书中貌似没有提到非对称加密，特来请教下大家。比如 RSA 和 ECC 哪个更好？关注者42被浏览134,226关注问题​写回答​邀请回答​好问题​添加评论​分享​6 个回答默认排序传智教育博学谷分享优质编程学习干货，为学习指点迷津。​ 关注众所周知，非对称加密算法是区块链系统内所有权验证机制的基础可是又有多少人真正了解非对称加密算法呢？本文将从非对称加密算法的定义、特点、优点和缺点，来为大家全面分析讲解。1、非对称加密算法的定义：非对称加密（公钥加密）：指加密和解密使用不同密钥的加密算法，也称为公私钥加密。假设两个用户要加密交换数据，双方交换公钥，使用时一方用对方的公钥加密，另一方即可用自己的私钥解密。如果企业中有n个用户，企业需要生成n对密钥，并分发n个公钥。假设A用B的公钥加密消息，用A的私钥签名，B接到消息后，首先用A的公钥验证签名，确认后用自己的私钥解密消息。由于公钥是可以公开的，用户只要保管好自己的私钥即可，因此加密密钥的分发将变得 十分简单。同时，由于每个用户的私钥是唯一的，其他用户除了可以通过信息发送者的公钥来验证信息的来源是否真实，还可以通过数字签名确保发送者无法否认曾发送过该信息。2、非对称加密算法的特点：不对称加密算法不对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用不对称加密算法加密文件时，只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。加密明文时采用公钥加密，解密密文时使用私钥才能完成，而且发信方（加密者）知道收信方的公钥，只有收信方（解密者）才是唯一知道自己私钥的人。不对称加密算法的基本原理是，如果发信方想发送只有收信方才能解读的加密信息，发信方必须首先知道收信方的公钥，然后利用收信方的公钥来加密原文；收信方收到加密密文后，使用自己的私钥才能解密密文。显然，采用不对称加密算法，收发信双方在通信之前，收信方必须将自己早已随机生成的公钥送给发信方，而自己保留私钥。由于不对称算法拥有两个密钥，因而特别适用于分布式系统中的数据加密。广泛应用的不对称加密算法有RSA算法和美国国家标准局提出的DSA。3、非对称加密算法的优点：安全性高。非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步秘钥。因此非对称加密算法更安全，密钥越长，它就越难破解4、非对称加密算法的缺点：非对称加密的缺点是加密和解密花费时间长、速度慢，在某些极端情况下，甚至能比对称加密慢上1000倍。以此非对称加密算法只适合对少量数据进行加密。相信大家看到这，都明白了“什么是非对称加密算法”。非对称加密算法的缺点，同时也是它的优点，因此只要在适当的时候使用它，就能发挥它的最大作用。发布于 2022-12-28 17:13​赞同​​添加评论​分享​收藏​喜欢收起​郝锡强致知于行​ 关注非对称加密优点不用说，更加安全一些，毕竟私钥只有自己才知道，只要是不泄露就是安全的缺点加解密速递慢RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）。使用最广泛的是RSA算法，Elgamal是另一种常用的非对称加密算法。Elgamal由Taher Elgamal于1985年发明，其基础是DiffieˉHellman密钥交换算法，后者使通信双方能通过公开通信来推导出只有他们知道的秘密密钥值[DiffieˉHellman]。DiffieˉHellman是Whitfield Diffie和Martin Hellman于1976年发明的，被视为第一种 非对称加密算法，DiffieˉHellman 与RSA的不同之处在于，DiffieˉHellman不是加密算法，它只是生成可用作对称密钥的秘密数值。在DiffieˉHellman密钥交换过程中，发送方和接收方分别生成一个秘密的随机数，并根据随机数推导出公开值，然后，双方再交换公开值。DiffieˉHellman算法的基础是具备生成共享密钥的能力。只要交换了公开值，双方就能使用自己的私有数和对方的公开值来生成对称密钥，称为共享密钥，对双方来说，该对称密钥是相同的，可以用于使用对称加密算法加密数据。与RSA相比，DiffieˉHellman的优势之一是每次交换密钥时都使用一组新值，而使用RSA算法时，如果攻击者获得了私钥，那么他不仅能解密之前截获的消息，还能解密之后的所有消息。然而，RSA可以通过认证（如使用X.509数字证书）来防止中间人攻击，但Diff ieˉHellman在应对中间人攻击时非常脆弱。编辑于 2016-08-02 16:25​赞同 11​​添加评论​分享​收藏​喜欢

如何用通俗易懂的话来解释非对称加密? - 知乎

如何用通俗易懂的话来解释非对称加密? - 知乎首页知乎知学堂发现等你来答​切换模式登录/注册程序员软件开发算法加密密码学如何用通俗易懂的话来解释非对称加密?给同行解释，其实也是一帮程序员，他们对加密没有概念。在他们眼中base64和md5都是用来加密的。 我已经可以通过通俗易懂的话加上简单的生活中的例子来…显示全部 ​关注者1,072被浏览396,492关注问题​写回答​邀请回答​好问题 21​3 条评论​分享​92 个回答默认排序威胁猎人以情报构筑数字化安全基石​ 关注举一个小学生都能懂的例子吧：-----------------------------看一个小时候经常在《趣味数学》这类书里的一个数学小魔术：让对方任意想一个3位数，并把这个数和91相乘，然后告诉我积的最后三位数，我就可以猜出对方想的是什么数字啦！比如对方想的是123，那么对方就计算出123 * 91等于11193，并把结果的末三位193告诉我。看起来，这么做似乎损失了不少信息，让我没法反推出原来的数。不过，我仍然有办法：只需要把对方告诉我的结果再乘以11，乘积的末三位就是对方刚开始想的数了。可以验证一下，193 * 11 = 2123，末三位正是对方所想的秘密数字！其实道理很简单，91乘以11等于1001，而任何一个三位数乘以1001后，末三位显然都不变（例如123乘以1001就等于123123）。知道原理后，我们可以构造一个定义域和值域更大的加密解密系统。比方说，任意一个数乘以400000001后，末8位都不变，而400000001 = 19801 * 20201，于是你来乘以19801，我来乘以20201，又一个加密解密不对称的系统就构造好了。甚至可以构造得更大一些：4000000000000000000000000000001 = 1199481995446957 * 3334772856269093，这样我们就成功构造了一个30位的加密系统。这是一件非常coooooooool的事情，任何人都可以按照我公布的方法加密一个数，但是只有我才知道怎么把所得的密文变回去。其安全性就建立在算乘积非常容易，但是要把4000000000000000000000000000001分解成后面两个数相乘，在没有计算机的时代几乎不可能成功！但如果仅仅按照上面的思路，如果对方知道原理，知道我要构造出带很多0的数，根据19801和8位算法这2个条件非常容易穷举出400000001这个目标值。要解决这个问题，真实世界就不是使用乘法了，比如RSA算法使用的是指数和取模运算，但本质上就是上面这套思想。编辑于 2017-07-04 00:27​赞同 1410​​110 条评论​分享​收藏​喜欢收起​刘巍然-学酥​密码学话题下的优秀答主​ 关注数据跑不完啊跑不完… 于是混知乎答答题。=============================这道题其实我关注很久了。这也是我一直头痛的问题… 怎么给一个完全不懂密码学的人讲解非对称（Asymmetric）/公钥（Public Key）加密体制呢。想起了我Boss的一句话：密码学都源于生活，是为了解决生活中实际问题而来的。而且几乎所有的密码学体制在实际生活中都有一个对应。那么，我也来试着用生活中的例子来讲一讲公钥加密体制呗。这个答案中，我尽量不使用任何公式，而是尽量用通俗易懂的方式回答。=============================1. 引言：以门锁为例（对称/私钥加密体制，Symmetric / Private Key Encryption）愚蠢的人类啊，为了保护自己的财产，天天都跟门锁和钥匙打交道。最开始的门锁是这样的：这样的：以及看起来高端点，但其实还是很脆弱的这样的：看着挺结实，稍微来个钳子什么的马上就断了啊有木有！直到人们明确了什么叫做安全的锁，并且按照规定制造了这样的锁，门锁才变得比较安全。门锁大概有什么样的要求呢？简单地说有这么几条：锁芯前面的金属头必须非常坚固，非特殊工具无法打开。钥匙必须足够复杂，非常难复制（所以现在防盗门钥匙基本都很难配的）。当然了，门本身也必须足够结实…按照这样的要求，人们制作了一些很安全的门锁，比如这样的：以及这样的：但是这些门锁都有一个共同的问题：就是锁门的时候必须用钥匙锁！在实际生活中这其实是个好事情。如果不用钥匙锁，那我把门撞上了结果没带钥匙岂不是瞎了（这种情况时常发生嘛）…不过，如果门锁只是锁自己家的还好，毕竟进自己家门的话当然需要自己的许可了。可是，如果锁门需要几个人的参与，事情可就比较麻烦了，考虑这样的情况：我亲戚（或者其他我比较信任的人）来我家做客，但我临时有事要出去，不知道几点回来。难道让我亲戚看家，等我回来再离开么？最好的方法就是他歇够了，出门把门一撞，完事~我新买的房子，需要装修队装修。装修过程中当然可以开着门谁都能进。装修完了呢？施工队等我回来验收后我主动来锁门他们才能走？ 人类的智慧是无穷的。前面也提到了，我们可以找那种能把门撞上打不开的门锁嘛，比如球形锁这样的：这个非常方便啊有木有。别人想锁门的时候，从里面把按钮按下去，一撞门，外面就打不开了，只有有钥匙的人才能打开。如果不把按钮按下去，外面还是可以打开的。更典型的是酒店的门锁，差不多是这样：电子的哎，更高端了有木有。电子锁如果检测到门被关上了，它会自动弹出锁芯把门锁住，只有刷卡才能开。这非常好啊，彻底解决了这个问题。=============================2. 能“撞”上的保险箱（非对称/公钥加密体制，Asymmetric / Public Key Encryption）数据加密解密和门锁很像。最开始的时候，人们只想到了那种只能用钥匙“锁”数据的锁。如果在自己的电脑上自己加密数据，当然可以用最开始这种门锁的形式啦，方便快捷，简单易用有木有。但是我们现在是通信时代啊，双方都想做安全的通信怎么办呢？如果也用这种方法，通信就好像互相发送密码保险箱一样… 而且双方必须都有钥匙才能进行加密和解密。也就是说，两个人都拿着保险箱的钥匙，你把数据放进去，用钥匙锁上发给我。我用同样的钥匙把保险箱打开，再把我的数据锁进保险箱，发送给你。大概就这么个样子：这样看起来好像没什么问题。但是，这里面最大的问题是：我们两个怎么弄到同一个保险箱的同一个钥匙呢？好像仅有的办法就是我们两个一起去买个保险箱，然后一人拿一把钥匙，以后就用这个保险箱了。可是，现代通信社会，绝大多数情况下别说一起去买保险箱了，连见个面都难，这怎么办啊？于是，人们想到了“撞门”的方法。我这有个可以“撞上”的保险箱，你那里自己也买一个这样的保险箱。通信最开始，我把保险箱打开，就这么开着把保险箱发给你。你把数据放进去以后，把保险箱“撞”上发给我。撞上以后，除了我以外，谁都打不开保险箱了。这样听起来好像很合理的样子，大概是这么个情况：=============================3. 权威机构造保险箱（可信第三方，Trusted Third Party）这种锁看起来好像很不错，但是锁在运输的过程中有这么一个严重的问题：你怎么确定你收到的开着的保险箱就是我发来的呢？对于一个聪明人，他完全可以这么干：装作运输工人。我现在把我开着的保险箱运给对方。运输工人自己也弄这么一个保险箱，运输的时候把保险箱换成他做的。对方收到保险箱后，没法知道这个保险箱是我最初发过去的，还是运输工人替换的。对方把数据放进去，把保险箱撞上。运输工人往回运的时候，用自己的钥匙打开自己的保险箱，把数据拿走。然后复印也好，伪造也好，弄出一份数据，把这份数据放进我的保险箱，撞上，然后发给我。从我的角度，从对方的角度，都会觉得这数据传输过程没问题。但是，运输工人成功拿到了数据，整个过程还是不安全的，大概的过程是这样：这怎么办啊？这个问题的本质原因是，人们没办法获知，保险箱到底是“我”做的，还是运输工人做的。那干脆，我们都别做保险箱了，让权威机构做保险箱，然后在每个保险箱上用特殊的工具刻上一个编号。对方收到保险箱的时候，在权威机构的“公告栏”上查一下编号，要是和保险箱上的编号一样，我就知道这个保险箱是“我”的，就安心把数据放进去。大概过程是这样的：如何做出刻上编号，而且编号没法修改的保险箱呢？这涉及到了公钥体制中的另一个问题：数字签名。不过题主的问题里面既然没有问道的话，我也就不劳心答了~=============================2015.08.04晚22:00继续更新本来就想到此为止了，不过评论区2个知乎er们希望我继续讲下去，那么就继续？=============================4 在保险箱上刻个字（数字签名，Digital Signature）上回说到如何做出刻上编号，而且编号没法修改的保险箱。那么我们继续楼。要知道，刻字这种事情吧，谁都能干，所以想做出只能自己刻字，还没法让别人修改的保险箱确实有点难度。那么怎么办呢？这其实困扰了人们很长的时间。直到有一天，人们发现：我们不一定非要在保险箱上刻规规矩矩的字，我们干脆在保险箱上刻手写名字好了。而且，刻字有点麻烦，干脆我们在上面弄张纸，让人直接在上面写，简单不费事。具体做法是，我们在保险箱上嵌进去一张纸，然后每个出产的保险箱都让权威机构的CEO签上自己的名字。然后，CEO把自己的签名公开在权威机构的“公告栏”上面。比如这个CEO就叫“学酥”，那么整个流程差不多是这个样子：这个方法的本质原理是，每个人都能够通过笔迹看出保险箱上的字是不是学酥CEO签的。但是呢，这个字体是学酥CEO唯一的字体。别人很难模仿。如果模仿我们就能自己分辨出来了。要是实在分辨不出来呢，我们就请一个笔迹专家来分辨。这不是很好嘛。这个在密码学上就是数字签名。=============================5 在保险箱上刻的字不能一样（带时间戳 / 随机数的签名，Signature with Timestamp / Randomness）上面这个签字的方法虽然好，但是还有一个比较蛋疼的问题。因为签字的样子是公开的，一个聪明人可以把公开的签字影印一份，自己造个保险箱，然后把这个影印的字也嵌进去。这样一来，这个聪明人也可以造一个相同签字的保险箱了。解决这个问题一个非常简单的方法就是在看保险箱上的签名时，不光看字体本身，还要看字体是不是和公开的字体完全一样。要是完全一样，就可以考虑这个签名可能是影印出来的。甚至，还要考察字体是不是和其他保险柜上的字体一模一样。因为聪明人为了欺骗大家，可能不影印公开的签名，而影印其他保险箱上的签名。这种解决方法虽然简单，但是验证签名的时候麻烦了一些。麻烦的地方在于我不仅需要对比保险箱上的签名是否与公开的笔迹一样，还需要对比得到的签名是否与公开的笔迹完全一样，乃至是否和所有发布的保险箱上的签名完全一样。有没有什么更好的方法呢？当然有，人们想到了一个比较好的方法。那就是，学酥CEO签字的时候吧，不光把名字签上，还得带上签字得日期，或者带上这个保险箱的编号。这样一来，每一个保险箱上的签字就唯一了，这个签字是学酥CEO的签名+学酥CEO写上的时间或者编号。这样一来，就算有人伪造，也只能伪造用过的保险箱。这个问题就彻底解决了。这个过程大概是这么个样子：=============================6 造价问题（密钥封装机制，Key Encapsulation Mechanism）解决了上面的各种问题，我们要考虑考虑成本了… 这种能“撞”门的保险箱虽然好，但是这种锁造价一般来说要比普通的锁要高，而且锁生产时间也会变长。在密码学中，对于同样“结实”的锁，能“撞”门的锁的造价一般来说是普通锁的上千倍。同时，能“撞”门的锁一般来说只能安装在小的保险柜里面。毕竟，这么复杂的锁，装起来很费事啊！而普通锁安装在多大的保险柜上面都可以呢。如果两个人想传输大量数据的话，用一个大的保险柜比用一堆小的保险柜慢慢传要好的多呀。怎么解决这个问题呢？人们又想出了一个非常棒的方法：我们把两种锁结合起来。能“撞”上的保险柜里面放一个普通锁的钥匙。然后造一个用普通的保险柜来锁大量的数据。这样一来，我们相当于用能“撞”上的保险柜发一个钥匙过去。对方收到两个保险柜后，先用自己的钥匙把小保险柜打开，取出钥匙。然后在用这个钥匙开大的保险柜。这样做更棒的一个地方在于，既然对方得到了一个钥匙，后续再通信的时候，我们就不再需要能“撞”上的保险柜了啊，在以后一定时间内就用普通保险柜就好了，方便快捷嘛。这个过程大概是这么个样子：=============================7 迎接美妙生活吧最终，我和对方可以充分利用各种各样的锁，通过一些很棒的方法，在公开场合下面做安全的通信啦。现在网络通信中的过程大致就是如此，不过里面还有很多细节的东西。在此我卖个关子，大家可以按照实际生活中的解决方法想一想如何才能解决呢。一些其他的细节问题大致如下：既然能“撞上”的保险箱都是权威机构产生的，那么权威机构怎么把这个保险箱的钥匙发给用户呢？我们如何保证权威机构生产的保险箱是安全的呢？要是权威机构生产的保险箱本身就不安全怎么办（这实际上就是棱镜门事件的一个理论原因）？另一方面，对于普通的保险箱，或者能“撞上”的保险箱，在现今社会我们还有一些其他需求，这些需求怎么解决呢？比如下面的问题：（密钥委托，Key Delegation）：我想让我的亲属能打开我一部分的保险箱。否则遇到突发情况的时候，谁帮我用我的钱交医药费啊…同时，我又不能让他们能打开我全部的保险箱，比如锁着我日记的保险箱，锁着我不可告人的秘密的保险箱。（全同态加密/签名，Fully Homomorphic Encryption/Signature）：我在保险箱里锁了一些金子，我想让金匠帮我造个首饰，但是我又不想让金匠在加工过程中偷我的金子。在实际中解决的方法就是我保险箱上面装了好多工具。金匠可以用这些工具对我保险箱里面的金子进行加工。但是因为金子还在保险箱里面锁着，金匠拿不出金子来。（函数加密，Functional Encryption）：我想锁一些数据在保险箱里面。但是其实我也不知道这些数据谁能够打开。不过，我可以确定，满足某某某某条件的那些人可以打开保险柜，把数据取走。比如说：名字叫学酥的人；只要是个知乎er，还对密码学感兴趣；甚至，是个知乎er，而且年龄在25岁以下的；甚至，我们可以定义任意的条件，反正能满足的才能打开就对了~更多的功能等待各位知乎er们来挖掘啦。没准就是一个很好的密码学点子呢。=============================以上。编辑于 2015-08-04 23:26​赞同 707​​61 条评论​分享​收藏​喜欢

什么是非对称加密_非对称加密简介_非对称加密的优势以及应用场景-腾讯云开发者社区

     * DSA 
     * Default Keysize 1024  
     * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
     *