密钥生成流程

• 生成私钥操作流程概述

  1. 使用rsa中的GenerateKey方法生成私钥

     func GenerateKey(random io.Reader, bits int) (priv *PrivateKey, err error)

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

  2. 通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串

     func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte

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

     初始化一个pem.Block块

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

  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格式块中

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

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

     func Encode(out io.Writer, b *Block) error

RSA加解密

RSA加密

1. 将公钥文件中的公钥读出, 得到使用pem编码的字符串

   -- 读文件

2. 将得到的字符串解码

   -- pem.Decode

3. 使用x509将编码之后的公钥解析出来

   -- func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error)

4. 使用得到的公钥通过rsa进行数据加密

RSA解密

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

使用

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

// 生成rsa的密钥对, 并且保存到磁盘文件中
func GenerateRsaKey(keySize int) {
   // 1. 使用rsa中的GenerateKey方法生成私钥
   privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
   if err != nil {
      panic(err)
   }
   // 2. 通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
   derText := x509.MarshalPKCS1PrivateKey(privateKey)
   // 3. 要组织一个pem.Block(base64编码)
   // 里面还有个Headers属性可以写可以不写
   block := pem.Block{
      Type : "rsa private key", // 这个地方写个字符串就行
      Bytes : derText,
   }
   // 4. pem编码
   file, err := os.Create("private.pem")
   if err != nil {
      panic(err)
   }
   pem.Encode(file, &block)
   file.Close()

   // ============ 公钥 ==========
   // 1. 从私钥中取出公钥
   publicKey := privateKey.PublicKey
   // 2. 使用x509标准序列化
   derstream, err := x509.MarshalPKIXPublicKey(&publicKey)
   if err != nil {
      panic(err)
   }
   // 3. 将得到的数据放到pem.Block中
   block = pem.Block{
      Type : "rsa public key",   // 这个地方写个字符串就行
      Bytes : derstream,
   }
   // 4. pem编码
   file, err  = os.Create("public.pem")
   if err != nil {
      panic(err)
   }
   pem.Encode(file, &block)
   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())
   file.Read(buf)
   file.Close()
   // 2. pem解码
   block, _ := pem.Decode(buf)
   pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
   //断言类型转换
   pubKey := pubInterface.(*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())
   file.Read(buf)
   file.Close()
   // 2. pem解码
   block, _ := pem.Decode(buf)
   privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
   if err != nil {
      panic(err)
   }

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

//测试文件
func main() {

   GenerateRsaKey(4096)
   src := []byte("abc abc...")
   cipherText := RSAEncrypt(src, "public.pem")
   plainText := RSADecrypt(cipherText, "private.pem")
   fmt.Println(string(plainText))

   myHash()
   myHash()
}


// 使用sha256
func myHash() {
   // sha256.Sum256([]byte("hello, go"))

   // 1. 创建哈希接口对象
   myHash := sha256.New()
   // 2. 添加数据
   src := []byte("123 123...")
   myHash.Write(src)
   myHash.Write(src)
   myHash.Write(src)
   // 3. 计算结果
   res := myHash.Sum(nil)
   // 4. 格式化为16进制形式
   myStr := hex.EncodeToString(res)
   fmt.Printf("%s\n", myStr)
}