4. 非对称加密

"非对称加密也叫公钥密码: 使用公钥加密, 使用私钥解密"

在对称密码中，由于加密和解密的密钥是相同的，因此必须向接收者配送密钥。用于解密的密钥必须被配送给接收者，这一问题称为密钥配送问题。如果使用非对称加密也可以称为公钥密码，则无需向接收者配送用于解密的密钥，这样就解决了密钥配送问题。可以说非对称加密是密码学历史上最伟大的发明。

非对称加密中，密钥分为加密密钥和解密密钥两种。发送者用加密密钥对消息进行加密，接收者用解密密钥对密文进行解密。要理解公钥密码，清楚地区分加密密钥和解密密钥是非常重要的。加密密钥是发送者加密时使用的，而解密密钥则是接收者解密时使用的。

仔细思考一下加密密钥和解密密钥的区别，我们可以发现：

• 发送者只需要加密密钥
• 接收者只需要解密密钥
• 解密密钥不可以被窃听者获取
• 加密密钥被窃听者获取也没问题

也就是说，解密密钥从一开始就是由接收者自己保管的，因此只要将加密密钥发给发送者就可以解决密钥配送问题了，而根本不需要配送解密密钥。

非对称加密中，加密密钥一般是公开的。正是由于加密密钥可以任意公开，因此该密钥被称为公钥（publickey）。公钥可以通过邮件直接发送给接收者，也可以刊登在报纸的广告栏上，做成看板放在街上，或者做成网页公开给世界上任何人，而完全不必担心被窃听者窃取。

当然，我们也没有必要非要将公钥公开给全世界所有的人，但至少我们需要将公钥发送给需要使用公钥进行加密的通信对象（也就是给自己发送密文的发送者）。

相对地，解密密钥是绝对不能公开的，这个密钥只能由你自己来使用，因此称为私钥（privatekey）。私钥不可以被别人知道，也不可以将它发送给别人，甚至也不能发送给自己的通信对象。

公钥和私钥是一一对应的，一对公钥和私钥统称为密钥对（keypair）。由公钥进行加密的密文，必须使用与该公钥配对的私钥才能够解密。密钥对中的两个密钥之间具有非常密切的关系(数学上的关系)一一因此公钥和私钥是不能分别单独生成的。

公钥密码的使用者需要生成一个包括公钥和私钥的密钥对，其中公钥会被发送给别人，而私钥则仅供自己使用。稍后我们将具体尝试生成一个密钥对。

4.1 非对称加密通信流程

下面我们来看一看使用公钥密码的通信流程。和以前一样、我们还是假设Alice要给Bob发送一条消息，Alice是发送者，Bob是接收者，而这一次窃听者Eve依然能够窃所到他们之间的通信内容。

在公非对称加密通信中，通信过程是由接收者Bob来启动的。

1. Bob生成一个包含公钥和私钥的密钥对。

   私钥由Bob自行妥善保管。

2. Bob将自己的公钥发送给Alicea

   Bob的公钥被窃听者Eve截获也没关系。

   将公钥发送给Alice，表示Bob请Alice用这个公钥对消息进行加密并发送给他。

3. Alice用Bob的公钥对消息进行加密。

   加密后的消息只有用Bob的私钥才能够解密。

   虽然Alice拥有Bob的公钥，但用Bob的公钥是无法对密文进行解密的。

4. Alice将密文发送给Bobo

   密文被窃听者Eve截获也没关系。Eve可能拥有Bob的公钥，但是用Bob的公钥是无法进行解密的。

5. Bob用自己的私钥对密文进行解密。

   请参考下图, 看一看在Alice和Bob之间到底传输了哪些信息。其实它们之间所传输的信息只有两个：Bob的公钥以及用Bob的公钥加密的密文。由于Bob的私钥没有出现在通信内容中，因此窃听者Eve无法对密文进行解密。

窃听者Eve可能拥有Bob的公钥，但是Bob的公钥只是加密密钥，而不是解密密钥，因此窃听者Eve就无法完成解密操作。

4.2 RSA—做数字签名

非对称加密的密钥分为加密密钥和解密密钥，但这到底是怎样做到的呢？本节中我们来讲解现在使用最广泛的公钥密码算法一一RSA。

RSA是一种非对称加密算法，它的名字是由它的三位开发者，即RonRivest、AdiShamir和LeonardAdleman 的姓氏的首字母组成的（Rivest-Shamir-Leonard）。

RSA可以被用于非对称加密和数字签名，关于数字签名我们将在后面章节进行讲解。

1983年，RSA公司为RSA算法在美国取得了专利，但现在该专利已经过期。

4.2.1 RSA加密

下面我们终于可以讲一讲非对称加密的代表—RSA的加密过程了。在RSA中，明文、密钥和密文都是数字。RSA的加密过程可以用下列公式来表达，如下。

$$密文=明{文}^{E}modN（RSA加密）$$

也就是说，RSA的密文是对代表明文的数字的E次方求modN的结果。换句话说，就是将明文自己做E次乘法，然后将其结果除以N求余数，这个余数就是密文。

咦，就这么简单？

对，就这么简单。仅仅对明文进行乘方运算并求mod即可，这就是整个加密的过程。在对称密码中，出现了很多复杂的函数和操作，就像做炒鸡蛋一样将比特序列挪来挪去，还要进行XOR(按位异或)等运算才能完成，但RSA却不同，它非常简洁。

对了，加密公式中出现的两个数一一一E和N，到底都是什么数呢？RSA的加密是求明文的E次方modN，因此只要知道E和N这两个数，任何人都可以完成加密的运算。所以说，E和N是RSA加密的密钥，也就是说，E和N的组合就是公钥。

不过，E和N并不是随便什么数都可以的，它们是经过严密计算得出的。顺便说一句，E是加密（Encryption）的首字母，N是数字（Number)的首字母。

有一个很容易引起误解的地方需要大家注意一一E和N这两个数并不是密钥对（公钥和私钥的密钥对）。E和N两个数才组成了一个公钥，因此我们一般会写成 “公钥是(E，N)” 或者 “公钥是{E, N}" 这样的形式，将E和N用括号括起来。

现在大家应该已经知道，RSA的加密就是 “求E次方的modN"，接下来我们来看看RSA的解密。

4.2.2 RSA解密

RSA的解密和加密一样简单，可以用下面的公式来表达：

$$明文=密{文}^{D}modN（RSA解密）$$

也就是说，对表示密文的数字的D次方求modN就可以得到明文。换句话说，将密文自己做D次乘法，再对其结果除以N求余数，就可以得到明文。

这里所使用的数字N和加密时使用的数字N是相同的。数D和数N组合起来就是RSA的解密密钥，因此D和N的组合就是私钥。只有知道D和N两个数的人才能够完成解密的运算。

大家应该已经注意到，在RSA中，加密和解密的形式是相同的。加密是求 "E次方的mod N”，而解密则是求 "D次方的modN”，这真是太美妙了。

当然，D也并不是随便什么数都可以的，作为解密密钥的D，和数字E有着相当紧密的联系。否则，用E加密的结果可以用D来解密这样的机制是无法实现的。

顺便说一句，D是解密〈Decryption）的首字母，N是数字（Number）的首字母。

我们将上面讲过的内容整理一下，如下表所示。

RSA的加密和解密

4.2.3 Go中生成公钥和私钥

需要引入的包

import (
	"crypto/rsa"
	"crypto/rand"
	"crypto/x509"
	"encoding/pem"
	"os"
)

生成私钥操作流程概述

1. 使用rsa中的GenerateKey方法生成私钥
2. 通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串----把密钥对保存到文件中
3. 将私钥字符串设置到pem格式块中—pem编码规范数据加密，base64–对数据编码，可逆的–不管原始数据是什么，将原始数据使用64个字符来替代
4. 通过pem将设置好的数据进行编码, 并写入磁盘文件中

生成公钥操作流程

1. 从得到的私钥对象中将公钥信息取出
2. 通过x509标准将得到 的rsa公钥序列化为字符串
3. 将公钥字符串设置到pem格式块中–初始化一个pem.Block块
4. 通过pem将设置好的数据进行编码, 并写入磁盘文件—准备一个文件指针

生成公钥和私钥的源代码

// 参数bits: 指定生成的秘钥的长度, 单位: bit
func RsaGenKey(bits int) error{
	// 1. 生成私钥文件
	// GenerateKey函数使用随机数据生成器random生成一对具有指定字位数的RSA密钥
	// 参数1: Reader是一个全局、共享的密码用强随机数生成器
	// 参数2: 秘钥的位数 - bit
	privateKey, err := rsa.GenerateKey(rand.Reader, bits)
	if err != nil{
		return err
	}
	// 2. MarshalPKCS1PrivateKey将rsa私钥序列化为ASN.1 PKCS#1 DER编码
	derStream := x509.MarshalPKCS1PrivateKey(privateKey)
	// 3. Block代表PEM编码的结构, 对其进行设置
	block := pem.Block{
		Type: "RSA PRIVATE KEY",//"RSA PRIVATE KEY",
		Bytes: derStream,
	}
	// 4. 创建文件
	privFile, err := os.Create("private.pem")
	if err != nil{
		return err
	}
	// 5. 使用pem编码, 并将数据写入文件中
	err = pem.Encode(privFile, &block)
	if err != nil{
		return err
	}
	// 6. 最后的时候关闭文件
	defer privFile.Close()

	// 7. 生成公钥文件
	publicKey := privateKey.PublicKey
	derPkix, err := x509.MarshalPKIXPublicKey(&publicKey)
	if err != nil{
		return err
	}
	block = pem.Block{
		Type: "RSA PUBLIC KEY",//"PUBLIC KEY",
		Bytes: derPkix,
	}
	pubFile, err := os.Create("public.pem")
	if err != nil{
		return err
	}
	// 8. 编码公钥, 写入文件
	err = pem.Encode(pubFile, &block)
	if err != nil{
		panic(err)
		return err
	}
	defer pubFile.Close()

	return nil

}

重要的函数介绍:

1. GenerateKey函数使用随机数据生成器random生成一对具有指定字位数的RSA密钥。

   "crypto/rsa" 包中的函数
   func GenerateKey(random io.Reader, bits int) (priv *PrivateKey, err error)
       - 参数1: io.Reader: 赋值为: rand.Reader
           -- rand包实现了用于加解密的更安全的随机数生成器。
           -- var Reader io.Reader (rand包中的变量)
       - 参数2: bits: 秘钥长度
       - 返回值1: 代表一个RSA私钥。
       - 返回值2: 错误信息
   
   

2. 通过x509 将rsa私钥序列化为ASN.1 PKCS#1 DER编码

   "crypto/x509" 包中的函数 (x509包解析X.509编码的证书和密钥)。
   func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte
       - 参数1: 通过rsa.GenerateKey得到的私钥
       - 返回值: 将私钥通过ASN.1序列化之后得到的私钥编码数据
   

3. 设置Pem编码结构

   Block代表PEM编码的结构。
   type Block struct {
       Type    string            // 得自前言的类型（如"RSA PRIVATE KEY"）
       Headers map[string]string // 可选的头项，Headers是可为空的多行键值对。
       Bytes   []byte            // 内容解码后的数据，一般是DER编码的ASN.1结构
   }
   

4. 将得到的Pem格式私钥通过文件指针写入磁盘中

   "encoding/pem" 包中的函数
   func Encode(out io.Writer, b *Block) error
       - 参数1: 可进行写操作的IO对象, 此处需要指定一个文件指针
       - 参数2: 初始化完成的Pem块对象, 即Block对象
   

5. 通过RSA私钥得到公钥

   // 私钥
   type PrivateKey struct {
       PublicKey            // 公钥
       D         *big.Int   // 私有的指数
       Primes    []*big.Int // N的素因子，至少有两个
       // 包含预先计算好的值，可在某些情况下加速私钥的操作
       Precomputed PrecomputedValues
   }
   // 公钥
   type PublicKey struct {
       N   *big.Int // 模
       E   int      // 公开的指数
   }
   通过私钥获取公钥
   publicKey := privateKey.PublicKey // privateKey为私钥对象
   

6. 通过x509将公钥序列化为PKIX格式DER编码。

   "crypto/x509" 包中的函数
   func MarshalPKIXPublicKey(pub interface{}) ([]byte, error)
       - 参数1: 通过私钥对象得到的公钥
       - 返回值1：将公钥通过ASN.1序列化之后得到的编码数据
       - 返回值2: 错误信息
   

7. 将公钥编码之后的数据格式化为Pem结构, 参考私钥的操作

8. 将得到的Pem格式公钥通过文件指针写入磁盘中

9. 生成的私钥和公钥文件数据

   // 私钥文件数据
   -----BEGIN RSA PRIVATE KEY-----
   MIICXgIBAAKBgQC5bm0DCEV+EFeiLUqSshziqhSB30jXy5BWbPV5SlMq4aWiEknM
   i+Mw1aXic4bEsM3YyT73eWsifqZNSc/4fRaV4qz5OL8IIe9AZoGDSLX/Ar9AQMJf
   OHbAtdIlCGQ4d80KjpDpPs2wZkTqllWCg31d7U3DVEm5kqTGtSYIu9e7JQIDAQAB
   AoGARGdn72ZtvENrEHiEufjajwMO7Zng1TpS1I79PvEcHQWAhHkaoEo6VRl7SD41
   yPkv9njGsaQo0WDHGFvSTGhYm/EWGrBWRPc5xXbSBg7ty9Iza9B1ekAj8VfWryen
   Wje3xDOCVCDUiCcYdaSfPiJPYuWMSnNMNa+0cR921zBQg0ECQQDpCMljuH7LrpbC
   NDF5q+LbUWMAE2KLDPX4WmDSdZdIO3mPux3MdwOUEfrcvSBGZNB7gyaEG7goZL8G
   BqL22MJHAkEAy7SqbVPoPbMPHuLI52VQ2FDp6xxSWLhjmv1ePCHGo28MDCaHeVzZ
   QaxyuIbnY8A6NHfu/QGwz/eB941IjYNBMwJBAI9XEEl+mr++zIz4fdZRnGE7VqId
   SmgtuL7jGNtb6YpMyyFV/6ZdLp5N0PkmfEvQh0zyBycLxeNS1Q1n16Xu/tECQQCZ
   dF42wdDgOfWYFMu31VETw9CTtuApya3vYhMNRXx4Pf1bYeMIf/OCT8CUVbwWHwc5
   42d73TwvTorvy9TuFgSVAkEA6F69THlTn5oIP8IWHcHuqS01fIR/vGfEwQ4cFZGR
   ketfieyeeF8rjn4qzwT/ugwRNjkhfKmoILnIC8UhEEJdjA==
   -----END RSA PRIVATE KEY-----
   

   // 公钥文件数据
   -----BEGIN RSA PUBLIC KEY-----
   MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC5bm0DCEV+EFeiLUqSshziqhSB
   30jXy5BWbPV5SlMq4aWiEknMi+Mw1aXic4bEsM3YyT73eWsifqZNSc/4fRaV4qz5
   OL8IIe9AZoGDSLX/Ar9AQMJfOHbAtdIlCGQ4d80KjpDpPs2wZkTqllWCg31d7U3D
   VEm5kqTGtSYIu9e7JQIDAQAB
   -----END RSA PUBLIC KEY-----
   

私钥和公钥写入文件代码​–示例

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
)

// GenerateRsaKey 生成rsa的密钥对，并且保存到磁盘文件中
func GenerateRsaKey(keySize int) {
	//使用rsa中的GenerateKey方法生成私钥

	//第一个参数是随机数，第二个参数====秘钥的位数--->1024个bit的倍数
	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
	if err != nil {
		fmt.Println("GenerateKey", err)
		return
	}

	// 通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
	derText := x509.MarshalPKCS1PrivateKey(privateKey)
	// 将公钥字符串设置到pem格式块中 --- 要组织一个pem Block块
	block := pem.Block{
		Type: "rsa private key", //这个地方写个字符串就行
		//Headers:  //可选
		Bytes: derText, // 内容解码后的数据，一般是DER编码的ASN.1结构
	}

	// pem编码---写入到磁盘中
	file, err := os.Create("private.pem")
	if err != nil {
		panic(err)
	}
	err = pem.Encode(file, &block)
	if err != nil {
		panic(err)
		//return
	} //把Bytes格式化

	file.Close()

	=====================================公钥===============
	//1 从私钥中取出公钥
	publicKey := privateKey.PublicKey
	//使用x509标准序列化==>转换为字符串
	derstream, err := x509.MarshalPKIXPublicKey(&publicKey) //编码之后的字符串 在swich里面是指针的判断
	if err != nil {
		panic(err)
	}
	//将得到的数据放到pem Block中
	block1 := pem.Block{
		Type:  "rsa public key",
		Bytes: derstream, //通过x509转换的字符串放到字节中去
	}

	//pem编码
	file1, err := os.Create("public.pem")
	if err != nil {
		return
	}
	err = pem.Encode(file1, &block1)
	if err != nil {
		panic(err)
	}

	file1.Close()
}

func main() {
	GenerateRsaKey(1024)
}

4.2.4 Go中使用RSA

1. 操作步骤

   • 公钥加密

     1. 将公钥文件中的公钥读出, 得到使用pem编码的字符串
     2. 将得到的字符串解码
     3. 使用x509将编码之后的公钥解析出来
     4. 使用得到的公钥通过rsa进行数据加密

   • 私钥解密

     1. 将私钥文件中的私钥读出, 得到使用pem编码的字符串
     2. 将得到的字符串解码
     3. 使用x509将编码之后的私钥解析出来
     4. 使用得到的私钥通过rsa进行数据解密

2. 代码实现

   • RSA公钥加密

     func RSAEncrypt(src, filename []byte) []byte {
         // 1. 根据文件名将文件内容从文件中读出
         file, err := os.Open(string(filename))
         if err != nil {
             return nil
         }
         // 2. 读文件
         info, _ := file.Stat()
         allText := make([]byte, info.Size())
         file.Read(allText)
         // 3. 关闭文件
         file.Close()
     
         // 4. 从数据中查找到下一个PEM格式的块
         block, _ := pem.Decode(allText)
         if block == nil {
             return nil
         }
         // 5. 解析一个DER编码的公钥
         pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
         if err != nil {
             return nil
         }
         pubKey := pubInterface.(*rsa.PublicKey)
     
         // 6. 公钥加密
         result, _ := rsa.EncryptPKCS1v15(rand.Reader, pubKey, src)
         return result
     }
     

   • RSA私钥解密

     func RSADecrypt(src, filename []byte) []byte {
       // 1. 根据文件名将文件内容从文件中读出
       file, err := os.Open(string(filename))
       if err != nil {
           return nil
       }
       // 2. 读文件
       info, _ := file.Stat()
       allText := make([]byte, info.Size())
       file.Read(allText)
       // 3. 关闭文件
       file.Close()
       // 4. 从数据中查找到下一个PEM格式的块
       block, _ := pem.Decode(allText)
       // 5. 解析一个pem格式的私钥
       privateKey , err := x509.ParsePKCS1PrivateKey(block.Bytes)
       // 6. 私钥解密
       result, _ := rsa.DecryptPKCS1v15(rand.Reader, privateKey, src)
     
         return result
       }
     

   • 重要的函数介绍

     1. 将得到的Pem格式私钥通过文件指针写入磁盘中

        "encoding/pem" 包中的函数
        func Decode(data []byte) (p *Block, rest []byte)
            - 参数 data: 需要解析的数据块
            - 返回值1: 从参数中解析出的PEM格式的块
            - 返回值2: 参数data剩余的未被解码的数据
        

     2. 解析一个DER编码的公钥 , pem中的Block结构体中的数据格式为ASN.1编码

        函数所属的包: "crypto/x509"
        func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)
            - 参数 derBytes: 从pem的Block结构体中取的ASN.1编码数据
            - 返回值 pub: 接口对象, 实际是公钥数据
            - 参数 err:   错误信息
        

     3. 解析一个DER编码的私钥 , pem中的Block结构体中的数据格式为ASN.1编码

        函数所属的包: "crypto/x509"
        func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error)
            - 参数 der: 从pem的Block结构体中取的ASN.1编码数据
            - 返回值 key: 解析出的私钥
            - 返回值 err: 错误信息
        

     4. 将接口转换为公钥

        pubKey := pubInterface.(*rsa.PublicKey)
            - pubInterface: ParsePKIXPublicKey函数返回的 interface{} 对象
            - pubInterface.(*rsa.PublicKey): 将pubInterface转换为公钥类型 rsa.PublicKey
        

     5. 使用公钥加密数据

        函数所属的包: "crypto/rsa"
        func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error)
            - 参数 rand: 随机数生成器, 赋值为 rand.Reader
            - 参数 pub:  非对称加密加密使用的公钥
            - 参数 msg:  要使用公钥加密的原始数据
            - 返回值 out: 加密之后的数据
            - 返回值 err: 错误信息
        

     6. 使用私钥解密数据

        函数所属的包: "crypto/rsa"
        func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error)
            - 参数 rand: 随机数生成器, 赋值为 rand.Reader
            - 参数 priv: 非对称加密解密使用的私钥
            - 参数 ciphertext: 需要使用私钥解密的数据
            - 返回值 out: 解密之后得到的数据
            - 返回值 err: 错误信
        

公钥加密—私钥解密

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
)

// GenerateRsaKey 生成rsa的密钥对，并且保存到磁盘文件中
func GenerateRsaKey(keySize int) {
	//使用rsa中的GenerateKey方法生成私钥

	//第一个参数是随机数，第二个参数====秘钥的位数--->1024个bit的倍数
	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
	if err != nil {
		fmt.Println("GenerateKey", err)
		return
	}

	// 通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
	derText := x509.MarshalPKCS1PrivateKey(privateKey)
	// 将公钥字符串设置到pem格式块中 --- 要组织一个pem Block块
	block := pem.Block{
		Type: "rsa private key", //这个地方写个字符串就行
		//Headers:  //可选
		Bytes: derText, // 内容解码后的数据，一般是DER编码的ASN.1结构
	}

	// pem编码---写入到磁盘中
	file, err := os.Create("private.pem")
	if err != nil {
		panic(err)
	}
	err = pem.Encode(file, &block)
	if err != nil {
		panic(err)
		//return
	} //把Bytes格式化

	file.Close()

	=====================================公钥===============
	//1 从私钥中取出公钥
	publicKey := privateKey.PublicKey
	//使用x509标准序列化==>转换为字符串
	derstream, err := x509.MarshalPKIXPublicKey(&publicKey) //编码之后的字符串 在swich里面是指针的判断
	if err != nil {
		panic(err)
	}
	//将得到的数据放到pem Block中
	block1 := pem.Block{
		Type:  "rsa public key",
		Bytes: derstream, //通过x509转换的字符串放到字节中去
	}

	//pem编码
	file1, err := os.Create("public.pem")
	if err != nil {
		return
	}
	err = pem.Encode(file1, &block1)
	if err != nil {
		panic(err)
	}

	file1.Close()
}

// RSAEncrypt RSA加密 公钥加密
// plainText明文 fileName 文件名字
func RSAEncrypt(plainText []byte, fileName string) []byte {
	//打开文件，并且读出文件内容
	file, err := os.Open(fileName)
	if err != nil {
		panic(err)
	}
	//buf := make([]byte, 10000)
	//file.Read(buf)

	//读取文件描述符 可以获取当前文件的属性信息
	fileInfo, err := file.Stat()
	if err != nil {
		panic(err)
	}

	buf := make([]byte, fileInfo.Size())
	file.Read(buf)
	file.Close()

	//2 pem解码 将公钥文件中的公钥读出, 得到使用pem编码的字符串
	block, _ := pem.Decode(buf)

	//使用x509将编码之后的公钥解析出来  publicInterface==>公钥
	publicInterface, err := x509.ParsePKIXPublicKey(block.Bytes) // message too long for RSA key size 加密过长，说明GenerateRsaKey(4096)给的长度太小
	if err != nil {
		panic(err)
	}

	//断言类型转换
	pubKey := publicInterface.(*rsa.PublicKey) //类型断言 类型转换

	//使用公钥加密
	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, plainText)
	if err != nil {
		panic(err)
	}
	//得到的加密密文
	return cipherText
}

// RSADecrypt RSA 解密
func RSADecrypt(cipherText []byte, fileName string) []byte {
	//打开文件，并且读出文件内容
	file, err := os.Open(fileName)
	if err != nil {
		panic(err)
	}
	//buf := make([]byte, 10000)
	//file.Read(buf)

	//读取文件描述符 可以获取当前文件的属性信息
	fileInfo, err := file.Stat()
	if err != nil {
		panic(err)
	}

	buf := make([]byte, fileInfo.Size())
	file.Read(buf)
	file.Close()

	//2 pem解码 将私钥文件中的私钥读出, 得到使用pem编码的字符串
	block, _ := pem.Decode(buf)

	//使用x509将编码之后的私钥解析出来  privateInterface==>私钥
	privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		panic(err)
	}

	//使用私钥解密
	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, privKey, cipherText)
	if err != nil {
		panic(err)
	}
	//得到的加密密文
	return plainText
}

func main() {
	//GenerateRsaKey(4096)
	src := []byte("我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...")
	cipherText := RSAEncrypt(src, "public.pem")
	plainText := RSADecrypt(cipherText, "private.pem")
	fmt.Println(string(plainText))
}

4.3 ECC椭圆曲线

1. 概念

   椭圆曲线密码学（英语：Elliptic curve cryptography，缩写为 ECC），一种建立公开密钥加密的算法，基于椭圆曲线数学。椭圆曲线在密码学中的使用是在1985年由Neal Koblitz和Victor Miller分别独立提出的。

   ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。

   椭圆曲线密码学的许多形式有稍微的不同，所有的都依赖于被广泛承认的解决椭圆曲线离散对数问题的困难性上。与传统的基于大质数因子分解困难性的加密方法不同，ECC通过椭圆曲线方程式的性质产生密钥。

   ECC 164位的密钥产生的一个安全级相当于RSA 1024位密钥提供的保密强度，而且计算量较小，处理速度更快，存储空间和传输带宽占用较少。目前我国居民二代身份证正在使用 256 位的椭圆曲线密码，虚拟货币比特币也选择ECC作为加密算法。

   具体算法详解参考：

   • https://www.cnblogs.com/Kalafinaian/p/7392505.html

   • https://blog.csdn.net/taifei/article/details/73277247

2. 数学原理

   不管是RSA还是ECC或者其它，公钥加密算法都是依赖于某个正向计算很简单（多项式时间复杂度），而逆向计算很难（指数级时间复杂度）的数学问题。

   椭圆曲线依赖的数学难题是:

   k为正整数，P是椭圆曲线上的点（称为基点）, k*P=Q , 已知Q和P，很难计算出k

4.4 非对称加密解惑

• 非对称加密比对称加密机密性更高吗?

  这个问题无法回答, 以为机密性高低是根据秘钥长度而变化的

• 采用1024bit 秘钥长度的非对称加密, 和采用128bit秘钥长度的对称加密中, 是秘钥更长的非对称加密更安全吗?

  不是。

  非对称加密的密钥长度不能与对称加密的密钥长度进行直接比较。下表是一张密钥长度的比较表（本表摘自《应用密码学》），根据这张表我们可以看出，1024比特的公钥密码与128比特的对称密码相比，反而是128比特的对称密码抵御暴力破解的能力更强。

  对称加密秘钥长度	非对称加密秘钥长度
  128 比特	2304 比特
  112 比特	1792 比特
  80 比特	768 比特
  64 比特	512 比特
  56 比特	384 比特

• 有了非对称加密， 以后对称加密会被替代吗？

  不会。

  一般来说，在采用具备同等机密性的密钥长度的情况下，非对称加密的处理速度只有对称加密的几百分之一。因此，非对称加密并不适合用来对很长的消息内容进行加密。根据目的的不同，还可能会配合使用对称加密和非对称加密，例如，混合密码系统就是将这两种密码组合而成的。

5. 单向散列函数—输出的数据是定长的（20字节）

"单向散列函数 --- 获取消息的指纹"

在刑事侦查中，侦查员会用到指纹。通过将某个特定人物的指纹与犯罪现场遗留的指纹进行对比，就能够知道该人物与案件是否存在关联。

针对计算机所处理的消息，有时候我们也需要用到“指纹"。当需要比较两条消息是否一致时，我们不必直接对比消息本身的内容，只要对比它们的“指纹”就可以了。

本章中，我们将学习单向散列函数的相关知识。使用单向散列函数就可以获取消息的“指纹”，通过对比 “指纹”，就能够知道两条消息是否一致。

下面，我们会先简单介绍一下单向散列函数，并给大家展示具体的例子。然后我们将详细介绍现在使用非常广泛的SHA-I单向散列函数。

5.1 什么是单向散列函数

单向散列函数（one-wayftnction）有一个输人和一个输出，其中输人称为消息（message），输出称为散列值（hashvalue）。单向散列函数可以根据消息的内容计算出散列值，而散列值就可以被用来检查消息的完整性。

这里的消息不一定是人类能够读懂的文字，也可以是图像文件或者声音文件。单向散列函数不需要知道消息实际代表的含义。无论任何消息，单向散列函数都会将它作为单纯的比特序列来处理，即根据比特序列计算出散列值。

散列值的长度和消息的长度无关。无论消息是1比特，还是100MB，甚至是IOOGB，单向散列函数都会计算出固定长度的散列值。以SHA-I单向散列函数为例，它所计算出的散列值的长度永远是160比特（20字节）。

5.2 关于术语

单向散列函数的相关术语有很多变体，不同参考资料中所使用的术语也不同，下面我们就介绍其中的儿个。

单向散列函数也称为消息摘要函数（message digest function）、哈希函数或者杂凑函数。

输人单向散列函数的消息也称为原像（pre-image）。

单向散列函数输出的散列值也称为消息摘要（message digest）或者指纹（fingerprint）。

完整性也称为一致性。

顺便说一句，单向散列函数中的“散列”的英文"hash一词，原意是古法语中的“斧子”，后来被引申为“剁碎的肉末"，也许是用斧子一通乱剁再搅在一起的那种感觉吧。单向散列函数的作用，实际上就是将很长的消息剁碎，然后再混合成固定长度的散列值。

5.3 单向散列函数的性质

通过使用单向散列函数，即便是确认几百MB大小的文件的完整性，也只要对比很短的散列值就可以了。那么，单向散列函数必须具备怎样的性质呢？我们来整理一下。

• 根据任意长度的消息计算出固定长度的散列值----不管原来的输入多长，输出数据都是定长的（比较起来块）

  首先，单向散列函数的输人必须能够是任意长度的消息。

  其次，无论输人多长的消息，单向散列函数必须都能够生成长度很短的散列值，如果消息越长生成的散列值也越长的话就不好用了。从使用方便的角度来看，散列值的长度最好是短且固定的。

• 能够快速计算出散列值–计算效率高

  计算散列值所花费的时间必须要短。尽管消息越长，计算散列值的时间也会越长，但如果不能在现实的时间内完成计算就没有意义了。

• 消息不同散列值也不同–只要消息一点不同，那么生成的散列值就会不同

  为了能够确认完整性，消息中哪怕只有1比特的改变，也必须有很高的概率产生不同的散列值。

  如果单向散列函数计算出的散列值没有发生变化，那么消息很容易就会被篡改，这个单向散列函数也就无法被用于完整性的检查。两个不同的消息产生同一个散列值的情况称为碰撞（collision）。如果要将单向散列函数用于完整性的检查，则需要确保在事实上不可能被人为地发现碰撞。

难以发现碰撞的性质称为抗碰撞性（collisionresistance）。密码技术中所使用的单向散列函数，都需要具备抗碰撞性。

强抗碰撞性，是指要找到散列值相同的两条不同的消息是非常困难的这一性质。在这里，散列值可以是任意值。密码技术中的单向散列函数必须具备强抗碰撞性。

• 具备单向性----不可以还原

  单向散列函数必须具备单向性（one-way）。单向性指的是无法通过散列值反算出消息的性质。根据消息计算散列值可以很容易，但这条单行路是无法反过来走的。

正如同将玻璃砸得粉碎很容易，但却无法将碎片还原成完整的玻璃一样，根据消息计算出散列值很容易，但根据散列值却无法反算出消息。

在这里需要注意的一点是，尽管单向散列函数所产生的散列值是和原来的消息完全不同的比特序列，但是单向散列函数并不是一种加密，因此无法通过解密将散列值还原为原来的消息。

5.4 单向散列函数的实际应用

下面我们来看一下实际应用单向散列函数的例子。

5.4.1 检测软件是否被篡改

我们可以使用单向散列函数来确认自己下载的软件是否被篡改。

很多软件，尤其是安全相关的软件都会把通过单向散列函数计算出的散列值公布在自己的官方网站上。用户在下载到软件之后，可以自行计算散列值，然后与官方网站上公布的散列值进行对比。通过散列值，用户可以确认自己所下载到的文件与软件作者所提供的文件是否一致。

这样的方法，在可以通过多种途径得到软件的情况下非常有用。为了减轻服务器的压力，很多软件作者都会借助多个网站（镜像站点）来发布软件，在这种情况下，单向散列函数就会在检测软件是否被篡改方面发挥重要作用。

5.4.2 消息认证码

使用单向散列函数可以构造消息认证码。

消息认证码是将“发送者和接收者之间的共享密钥”和“消息，进行混合后计算出的散列值。使用消息认证码可以检测并防止通信过程中的错误、篡改以及伪装。

消息认证码在SSL/TLS中也得到了运用，关于SSL/TLS我们将后边章节中介绍。

5.4.3 数字签名

在进行数字签名时也会使用单向散列函数。

数字签名是现实社会中的签名（sign）和盖章这样的行为在数字世界中的实现。数字签名的处理过程非常耗时，因此一般不会对整个消息内容直接施加数字签名，而是先通过单向散列函数计算出消息的散列值，然后再对这个散列值施加数字签名。

5.4.6 伪随机数生成器

使用单向散列函数可以构造伪随机数生成器。

密码技术中所使用的随机数需要具备“事实上不可能根据过去的随机数列预测未来的随机数列”这样的性质。为了保证不可预测性，可以利用单向散列函数的单向性。

5.4.7 一次性口令

使用单向散列函数可以构造一次性口令（one-time password）。

一次性口令经常被用于服务器对客户端的合法性认证。在这种方式中，通过使用单向散列函数可以保证口令只在通信链路上传送一次（one-time），因此即使窃听者窃取了口令，也无法使用。

5.5 常用的单向散列函数

5.5.1 MD4、MD5

MD4是由Rivest于1990年设计的单向散列函数，能够产生128比特的散列值（RFC1186，修订版RFC1320）。不过，随着Dobbertin提出寻找MD4散列碰撞的方法，因此现在它已经不安全了。

MD5是由Rwest于1991年设计的单项散列函数，能够产生128比特的散列值（RFC1321）。

MD5的强抗碰撞性已经被攻破，也就是说，现在已经能够产生具备相同散列值的两条不同的消息，因此它也已经不安全了。

MD4和MD5中的MD是消息摘要（Message Digest）的缩写。

####5.5.2 Go中使用MD5

• 需要导入的包

  import (
  	"crypto/md5"
  	"encoding/hex"
  )
  

• 计算Md5的方式1

  func getMD5_1(str []byte) string {
  	// 1. 计算数据的md5
  	result := md5.Sum(str)
  	fmt.Println(result)
  	fmt.Printf("%x\n", result)
  	// 2. 数据格式化为16进制格式字符串
  	res := fmt.Sprintf("%x", result)
  	fmt.Println(res)
  	// --- 这是另外一种格式化切片的方式
  	res = hex.EncodeToString(result[:])
  	fmt.Println("res: ", res)
  	return  res
  }
  

  重要函数说明:

  1. 返回数据data的MD5校验和

     函数所属的包: "crypto/md5"
     func Sum(data []byte) [Size]byte
         - 参数 data: 原始数据
         - 返回值: 经过md5计算之后得到的数据, 长度为 16字节(byte)
     

  2. 将字符串编码为16进制格式

     函数所属的包: "encoding/hex"
     func EncodeToString(src []byte) string
         - 参数 src: 要转换的数据
         - 返回值: 转换之后得到的16进制格式字符串
     

• 计算Md5的方式2

  func getMD5_2(str []byte) string {
  	// 1. 创建一个使用MD5校验的Hash对象`
  	myHash := md5.New()
  	// 2. 通过io操作将数据写入hash对象中
  	io.WriteString(myHash, "hello")
  	//io.WriteString(myHash, ", world")
  	myHash.Write([]byte(", world"))
  	// 3. 计算结果
  	result := myHash.Sum(nil)
  	fmt.Println(result)
  	// 4. 将结果转换为16进制格式字符串
  	res := fmt.Sprintf("%x", result)
  	fmt.Println(res)
  	// --- 这是另外一种格式化切片的方式
  	res = hex.EncodeToString(result)
  	fmt.Println(res)
  
  	return res
  }
  

  重要函数说明:

  1. 创建一个新的使用MD5校验的hash.Hash接口

     函数所属的包: "crypto/md5"
     func New() hash.Hash
     

     Hash是一个被所有hash函数实现的公共接口。

     type Hash interface {
         // 通过嵌入的匿名io.Writer接口的Write方法向hash中添加更多数据，永远不返回错误
         io.Writer
         // 返回添加b到当前的hash值后的新切片，不会改变底层的hash状态
         Sum(b []byte) []byte
         // 重设hash为无数据输入的状态
         Reset()
         // 返回Sum会返回的切片的长度
         Size() int
         // 返回hash底层的块大小；Write方法可以接受任何大小的数据，
         // 但提供的数据是块大小的倍数时效率更高
         BlockSize() int
     }
     
     "io" 包中 Writer 接口用于包装基本的写入方法。
     type Writer interface {
         Write(p []byte) (n int, err error)
     }
     

  2. 通过io操作将数据写入hash对象中

     # 第一种方式
     函数所属的包: "io"
     func WriteString(w Writer, s string) (n int, err error)
         - 参数 w: 实现了/包含Writer接口的对象
         - 参数 s: 要添加到IO对象中的数据
         - 返回值 n: 数据长度
         - 返回值 err: 错误信息
     # 第二种方式
     使用md5包中的New()方法得到的hash.Hash接口(假设名为: myHash)添加数据---可以多次添加数据
     myHash.Write([]byte("测试数据"))
     

  3. 使用hash.Hash接口中的Sum方法计算结果

     Sum(b []byte) []byte
         - 参数 b: 将b中的数据进行哈希计算, 结果添加到原始数据的前面, --这个参数并不能给我们追加数据
           		 一般情况下该参数指定为空, 即: nil
         - 返回值: 进行哈希运算之后得到的结果(散列值) --->一般是二进制的字符串，有些字符不可见---->
         - 需要格式化为16进制的数字串==>EncodeToString(src []byte) strin转换后，长度会翻倍
     

5.5.3 SHA-1、SHA-224、SHA-256、SHA-384、SHA-512—并不是全部都碰撞

SHA-1是由NIST（NationalInstituteOfStandardsandTechnology，美国国家标准技术研究所）设计的一种能够产生160比特的散列值的单向散列函数。1993年被作为美国联邦信息处理标准规格（FIPS PUB 180）发布的是SHA,1995年发布的修订版FIPS PUB 180-1称为SHA-1。

SHA-1的消息长度存在上限，但这个值接近于2⁶⁴比特，是个非常巨大的数值，因此在实际应用中没有问题。

SHA-256、SHA-384和SHA-512都是由NIST设计的单向散列函数，它们的散列值长度分别为256比特、384比特和512比特。这些单向散列函数合起来统称SHA-2，它们的消息长度也存在上限（SHA-256的上限接近于 2⁶⁴ 比特，SHA-384 和 SHA-512的上限接近于 2¹²⁸ 比特）。这些单向散列函数是于2002年和 SHA-1 一起作为 FIPS PUB 180-2发布的 SHA-1 的强抗碰撞性已于2005年被攻破, 也就是说，现在已经能够产生具备相同散列值的两条不同的消息。不过，SHA-2还尚未被攻破。

	比特数	字节数
MD4	128bit	16byte
MD5	128bit	16byte
SHA-1	160bit	20byte
SHA-224	224bit	28byte
SHA-256	256bit	32byte
SHA-384	384bit	48byte
SHA-512	512bit	64byte

####5.5.4 Go中对SHA-1、SHA-2的使用

• 需要导入的包

  import (
  	"crypto/sha1"
  	"encoding/hex"
      "crypto/sha256"
      "crypto/sha512"
  )
  

• 使用sha1计算文件指纹

  上一小节介绍了如何使用go提供的API计算数据的md5指纹, sha1的计算方式和md5的套路是一样的, 需要将md5包, 替换为sh1, 下面给大家介绍一下如何使用sha1计算文件的指纹(md5亦如此)

  func getSha1(src string) string {
  	// 1. 打开文件
  	fp, err := os.Open(src)
  	if err != nil {
  		return "文件打开失败"
  	}
  	// 2. 创建基于sha1算法的Hash对象
  	myHash := sha1.New()
  	// 3. 将文件数据拷贝给哈希对象
  	num, err := io.Copy(myHash, fp)
  	if err != nil {
  		return "拷贝文件失败"
  	}
  	fmt.Println("文件大小: ", num)
  	// 4. 计算文件的哈希值
  	tmp1 := myHash.Sum(nil)
  	// 5. 数据格式转换
      result := hex.EncodeToString(tmp1)
  	fmt.Println("sha1: ", result)
  
  	return result
  }
  

SHA-1的案例

// 使用sha256进行hash运算
func myHash() {
	// sha256.Sum256([]byte("hello, go"))这个适用于少量数据的情况

	//创建哈希接口对象
	myHash := sha256.New()

	//添加数据
	src := []byte("我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...我是小崔, 如果我死了, 肯定不是自杀...")
	myHash.Write(src)
	myHash.Write(src)
	myHash.Write(src)

	//计算结果---sha256 是32个字节
	res := myHash.Sum(nil)
	//格式化为16进制形式  转换之后得到的16进制格式字符串
	myStr := hex.EncodeToString(res)
	fmt.Println(myStr) //会得到64字节
	fmt.Println("---------------------")
	fmt.Printf("%s\n", myStr)
}