密码技术--非对称加密算法及Go语言应用

Posted 2021-09-13 Yuan_sr

非对称加密算法

1.对称加密的弊端

• 秘钥分发困难

• 可以通过非对称加密完成秘钥的分发

  Alice和Bob通信，Alice给Bob发送数据，使用对称加密的流程

  1.Bob生成一个非对称的密钥对，

  2.Bob将公钥发送给Alice

  3.Alice生成一个用于对称加密的秘钥

  4.Alice使用Bob的公钥就对对称加密的秘钥进行加密，并发送给Bob

  5.Bob使用私钥对数据解密，得到对称加密的私钥

  通信的双方使用写好的秘钥进行对称加密对数据加密

• 场景分析

1.通信流程，信息加密（A写数据给B，信息只允许B读）
A: 公钥
B：私钥

2.登录认证（客户端要登录，连接服务器，向服务器请求个人数据）
客户端：私钥
服务端：公钥

3.数字签名（表明信息没有受到篡改，确实是信息拥有者发出来的，附在信息原文的后面）
发送端：私钥
接受端：公钥

4.网银U盾
个人：私钥
银行：公钥.

总结: 数据对谁更重要,谁就拿私钥

2. 非对称加密的秘钥

• 不存在秘钥分发的困难问题

3.生成RSA的密钥对

1. 概念
   x509证书规范、pem、base64

   • pem是一种源自保密增强邮件协议的编码规范，可进行数据加密
   • base64也是一种编码规范，过程可逆

   • 无论原始数据是什么，将原始数据使用64个字符来代替（a-z、A-Z、0-9、/、+）

     ASN.1抽象语法标记
     PKCS1标准

2. 密钥对生成流程

私钥生成

1.使用rsa中的GenerateKey方法生成私钥
func GenerateKey(random io.Reader, bits int) (priv *PrivateKey, err error)

• rand.Reader -> import "crypto/rand"
• bits 1024的整数倍-建议

2.通过x509标准将得到的rsa私钥序列化为ASN.1的DER编码字符串
func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte

3.将私钥字符串设置到pem格式块中
初始化一个pem.Block块

4.通过pem将设置好的数据进行编码，并写入磁盘文件
func Encode(out io.Writer, b *Block) error
out - 准备一个文件指针

公钥生成

1.从得到的私钥对象中将公钥信息取出

type PrivateKey struct {
 PublicKey            // 公钥
 D         *big.Int   // 私有的指数
 Primes    []*big.Int // N的素因子，至少有两个
 // 包含预先计算好的值，可在某些情况下加速私钥的操作
 Precomputed PrecomputedValues
}

2.通过x509标准将得到的rsa公钥序列化为字符串

func MarshalPKIXPublicKey(pub interface{}) ([]byte, error)

3.将公钥字符串设置到pem格式块中

4.通过pem将设置好的数据进行编码，并写入磁盘文件

4.RSA加解密

package main

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

//生成rsa私钥和公钥并写入磁盘文件
func GenerateRsaKey(keySize int) {
    //1.生成rsa秘钥
    privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
    if err != nil {
        panic(err)
    }
    //2.通过x509标准将得到的rsa私钥序列化为ASN.1的DER编码字符串
    derText := x509.MarshalPKCS1PrivateKey(privateKey)
    //3.创建一个pem.Block结构体
    block := pem.Block{
        Type: "rsa private key",
        Bytes: derText,
    }
    //4.通过pem将设置好的私钥数据进行编码，并写入磁盘文件
    file, err := os.Create("private.pem")
    if err != nil {
        panic(err)
    }
    err = pem.Encode(file, &block)
    if err != nil {
        panic(err)
    }

    // ==========公钥==================
    //1.从私钥中取出公钥
    publicKey := privateKey.PublicKey
    //2.使用x509序列化公钥为字符串
    marshalPKIXPublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
    if err != nil {
        panic(err)
    }
    //3.通过公钥字符串设置到pem格式块中
    block = pem.Block{
        Type:    "rsa public key",
        Headers: nil,
        Bytes:   marshalPKIXPublicKey,
    }
    //4.pem编码
    file, err = os.Create("public.pem")
    if err != nil {
        panic(err)
    }
    err = pem.Encode(file, &block)
    if err != nil {
        panic(err)
    }
    file.Close()
}

//rsa加密
func RSAEncrypt(plainText []byte, fileName string) []byte {
    //1.打开公钥文件
    file, err := os.Open(fileName)
    if err != nil {
        panic(err)
    }
    fileInfo, err := file.Stat()
    if err != nil {
        panic(err)
    }
    buf := make([]byte, fileInfo.Size())
    _, err = file.Read(buf)
    if err != nil {
        panic(err)
    }
    file.Close()
    //2.pem decode
    block, _ := pem.Decode(buf)
    publicKey, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    pubKey := publicKey.(*rsa.PublicKey)
    //3.使用公钥加密
    cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, plainText)
    if err != nil {
        panic(err)
    }
    return cipherText
}

//rsa解密
func RSADecrypt(cipherText []byte, fileName string) []byte {
    //1.打开私钥文件
    file, err := os.Open(fileName)
    if err != nil {
        panic(err)
    }
    fileInfo, err := file.Stat()
    if err != nil {
        panic(err)
    }
    buf := make([]byte, fileInfo.Size())
    _, err = file.Read(buf)
    if err != nil {
        panic(err)
    }
    //2.pem decode
    block, _ := pem.Decode(buf)
    privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    //3.解密数据
    plainText, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, cipherText)
    if err != nil {
        panic(err)
    }
    return plainText
}

func main() {
    GenerateRsaKey(1024)
    src := []byte("解决了秘钥分发的困难问题,不能加密稍长一点的数据，主要用来加密对称秘钥")
    cipherText := RSAEncrypt(src, "public.pem")
    plainText := RSADecrypt(cipherText, "private.pem")
    fmt.Println("解密结果：", string(plainText))
}