1.生成秘钥对并写入磁盘文件

1.使用ecdsa生成秘钥对

2.将私钥写入磁盘

• 使用x509进行反序列化
• 将得到的切片字符串放到pem.Block结构体中
• 使用pem编码

3.将公钥写入磁盘

• 从私钥中得到公钥
• 使用x509进行序列化
• 将得到的切片字符串放入pem.Block结构体中
• 使用pem编码

2.使用私钥进行数字签名

1.打开私钥文件，将内容读出来

2.使用pem进行数据解码

3.使用x509对数据还原

4.对原始数据进行哈希运算

5.进行数字签名
func Sign(rand io.Reader, priv PrivateKey, hash []byte) (r, s big.Int, err error)
6.返回值为指针，因此需要将该地址指向内存中的数据进行序列话

3.使用公钥验证数字签名

1.打开公钥文件，读出数据

2.使用pem进行解码

3.使用x509进行公钥数据还原
func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error)

4.由于上一步返回的是一个接口类型，因此需要进行类型断言，将接口类型转换为公钥

5.对原始数据进行哈希运算

6.验签

4.go中应用

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "os"
    "crypto/sha256"
    "math/big"
)

func GenerateEcdsaKey () {
    //1.使用ecdsa生成秘钥对
    privateKey, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
    if err != nil {
        panic(err)
    }
    //2.将私钥写入磁盘
    //* 使用x509进行反序列化
    ecPrivateKey, err := x509.MarshalECPrivateKey(privateKey)
    if err != nil {
        panic(err)
    }
    //* 将得到的切片字符串放到pem.Block结构体中
    block := pem.Block{
        Type:    "ecdsa private key",
        Headers: nil,
        Bytes:   ecPrivateKey,
    }
    //* 使用pem编码
    file, err := os.Create("ecPrivate.pem")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    err = pem.Encode(file, &block)
    if err != nil {
        panic(err)
    }
    //3.将公钥写入磁盘
    //* 从私钥中得到公钥
    publicKey := privateKey.PublicKey
    //* 使用x509进行序列化
    ecPublicKey, err := x509.MarshalPKIXPublicKey(&publicKey)
    if err != nil {
        panic(err)
    }
    //* 将得到的切片字符串放入pem.Block结构体中
    block = pem.Block{
        Type:    "ecdsa public key",
        Headers: nil,
        Bytes:   ecPublicKey,
    }
    //* 使用pem编码
    file, err = os.Create("ecPublic.pem")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    pem.Encode(file, &block)
}

//签名
func SignECDSA (plainText []byte, priFileName string) (rText, sText []byte) {
    //1.打开私钥文件，将内容读出来
    file, err := os.Open(priFileName)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    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进行数据解码
    block, _ := pem.Decode(buf)
    //3.使用x509对数据还原
    privateKey, err := x509.ParseECPrivateKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    //4.对原始数据进行哈希运算
    hashText := sha256.Sum256(plainText)
    //5.进行数字签名
    var r, s *big.Int //注意这里
    r, s, err = ecdsa.Sign(rand.Reader, privateKey, hashText[:])
    if err != nil {
        panic(err)
    }
    //6.返回值为指针，因此需要将该地址指向内存中的数据进行序列话
    rText, err = r.MarshalText()
    if err != nil {
        panic(err)
    }
    sText, err = s.MarshalText()
    if err != nil {
        panic(err)
    }
    return rText,sText
}

//验签
func VerifyECDSA (plainText, rText, sText []byte, pubFileName string) bool {
    //1.打开公钥文件，读出数据
    file, err := os.Open(pubFileName)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    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进行解码
    block, _ := pem.Decode(buf)
    //3.使用x509进行公钥数据还原
    pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        panic(err)
    }
    //4.由于上一步返回的是一个接口类型，因此需要进行类型断言，将接口类型转换为公钥
    publicKey := pubInterface.(*ecdsa.PublicKey)
    //5.对原始数据进行哈希运算
    hashText := sha256.Sum256(plainText)
    //6.验签
    var r, s big.Int
    r.UnmarshalText(rText)
    s.UnmarshalText(sText)
    res := ecdsa.Verify(publicKey, hashText[:], &r, &s)
    return res
}