通过椭圆曲线加密实现数字签名 #

package main
import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha1"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"math/big"
	"os"
)

func main() {
	GenerateEccKey()
	src := []byte("使用x509对pem.Block中的Bytes变量中的数据进行解析 ->  得到一接口")
	rText, sText := EccSignature(src, "eccPrivate.pem")
	bl := EccVerify(src, rText, sText, "eccPublic.pem")
	fmt.Println(bl)
}
// 1. 生成密钥对
func GenerateEccKey() {
	//1. 使用ecdsa生成密钥对
	privateKey, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
	if err != nil {
		panic(err)
	}
	//2. 将私钥写入磁盘
	//- 使用x509进行序列化
	derText, err := x509.MarshalECPrivateKey(privateKey)
	if err != nil {
		panic(err)
	} //返回私钥
	//- 将得到的切片字符串放入pem.Block结构体中
	block := pem.Block{
		Type : "ecdsa private key",
		Bytes : derText,
	}
	//- 使用pem编码
	file, err := os.Create("eccPrivate.pem")
	if err != nil {
		panic(err)
	}
	pem.Encode(file, &block)
	file.Close()
	//3. 将公钥写入磁盘
	//- 从私钥中得到公钥
	publicKey := privateKey.PublicKey
	//- 使用x509进行序列化
	derText, err = x509.MarshalPKIXPublicKey(&publicKey)
	if err != nil {
		panic(err)
	}
	//- 将得到的切片字符串放入pem.Block结构体中
	block = pem.Block{
		Type : "ecdsa public key",
		Bytes : derText,
	}
	//- 使用pem编码
	file, err = os.Create("eccPublic.pem")
	if err != nil {
		panic(err)
	}
	pem.Encode(file, &block)
	file.Close()
}

// ecc签名 - 私钥
func EccSignature(plainText []byte, privName string)  (rText, sText []byte){
	//1. 打开私钥文件, 将内容读出来 ->[]byte
	file, err := os.Open(privName)
	if err != nil {
		panic(err)
	}
	info, err := file.Stat()
	if err != nil {
		panic(err)
	}
	buf := make([]byte, info.Size())
	file.Read(buf)
	file.Close()
	//2. 使用pem进行数据解码 -> pem.Decode()
	block, _ := pem.Decode(buf)
	//3. 使用x509, 对私钥进行还原
	privateKey, err := x509.ParseECPrivateKey(block.Bytes)
	if err != nil {
		panic(err)
	}
	//4. 对原始数据进行哈希运算 -> 散列值
	hashText := sha1.Sum(plainText)
	//5. 进行数字签名
	r, s, err := ecdsa.Sign(rand.Reader, privateKey, hashText[:])
	if err != nil {
		panic(err)
	}
	// 6. 对r, s内存中的数据进行格式化 -> []byte
	rText, err = r.MarshalText()
	if err != nil {
		panic(err)
	}
	sText, err = s.MarshalText()
	if err != nil {
		panic(err)
	}
	return
}

// ecc签名认证
func EccVerify(plainText, rText, sText []byte, pubFile string) bool {
	//1. 打开公钥文件, 将里边的内容读出 -> []byte
	file, err := os.Open(pubFile)
	if err != nil {
		panic(err)
	}
	info, err := file.Stat()
	if err != nil {
		panic(err)
	}
	buf := make([]byte, info.Size())
	file.Read(buf)
	file.Close()
	//2. pem解码 -> pem.Decode()
	block, _ := pem.Decode(buf)
	//3. 使用x509对公钥还原
	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		panic(err)
	}
	//4. 将接口 -> 公钥
	publicKey := pubInterface.(*ecdsa.PublicKey)
	//5. 对原始数据进行哈希运算 -> 得到散列值
	hashText := sha1.Sum(plainText)
	// 将rText, sText -> int数据
	var r, s big.Int
	r.UnmarshalText(rText)
	s.UnmarshalText(sText)
	//6. 签名的认证 - > ecdsa  (问题,api的设计为什么在这个地方要传地址,直接传值比较不是更好吗?)
	bl := ecdsa.Verify(publicKey, hashText[:], &r, &s)
	return bl
}

func main() {

	//加密
	src := []byte("少壮不努力,活该你单身,223333")
	fmt.Println(string(src))
	
	date, err := EnRsaPublic("/Users/tianzhiwei/go/src/webapp/PublicKey.pem", src)
	if err != nil {
		panic(err)
	}
	fmt.Println("非对称加密结果", string(date))
	date, err = DeRsaPrivate(date, "/Users/tianzhiwei/go/src/webapp/PriveteKey.pem")
	if err != nil {
		panic(err)
	}
	fmt.Println("非对称加密解密结果", string(date))
}

/*
生成私钥操作流程
    1.使用rsa中GenerateKey方法生成私钥
    2.通过x509标准将得到的rsa私钥序列化为ASN.1的DER编码字符串
    3.将私钥字符串设置到pem格式块中
    4.通过pem将设置好的数据进行编码,并写入磁盘文件中
生成公钥操作流程
    1.从得到的私钥对象中将公钥信息取出
    2.通过x509标准将得到的rsa公钥序列化为ASN.1的DER编码字符串
    3.将公钥字符串设置到pem格式块中
    4.通过pem将设置好的数据进行编码,并写入磁盘文件中
*/
func GeneRsa(blockSize int) error {
	PrivateKey, err := rsa.GenerateKey(rand.Reader, blockSize)
	if err != nil {
		return err
	}
	stream := x509.MarshalPKCS1PrivateKey(PrivateKey)
	block := pem.Block{
		Type:  "RSA PrivateKey",
		Bytes: stream,
	}
	PrivateFile, err := os.Create("PriveteKey.pem")
	if err != nil {
		return err
	}
	err = pem.Encode(PrivateFile, &block)
	PublicKey := PrivateKey.PublicKey
	stream1, err := x509.MarshalPKIXPublicKey(&PublicKey)
	if err != nil {
		return err
	}
	block1 := pem.Block{
		Type:  "RSA PublicKey",
		Bytes: stream1,
	}
	PublicFile, err := os.Create("PublicKey.pem")
	if err != nil {
		return err
	}
	err = pem.Encode(PublicFile, &block1)
	return err
}
/*
公钥加密
    1.将公钥取出得到PEM编码的字符串
    2.将得到的字符串进行pem解码
    3.使用x509进行解析公钥
    4.使用Rsa对公钥进行加密
私钥解密
    1.将私钥取出得到PEM编码的字符串
    2.将得到的字符串进行pem解码
    3.使用x509进行解析私钥
    4.对私钥使用rsa进行解密
*/
func EnRsaPublic(filePath string, src []byte) ([]byte, error) {
	file, err := os.Open(filePath)
	msg := []byte(" ")
	if err != nil {
		return msg, err
	}
	//(file *File) Stat() (FileInfo, error)
	info, err := file.Stat()
	//type FileInfo interface
	if err != nil {
		return msg, err
	}
	byteSize := make([]byte, info.Size())
	//(f *File) Read(b []byte) (n int, err error) Read方法从f中读取最多len(b)字节数据并写入b
	file.Read(byteSize)
	//Decode(data []byte) (p *Block, rest []byte)
	block, _ := pem.Decode(byteSize)
	//type Block struct
	//ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err)
	pubinter, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return msg, err
	}
	pubKey := pubinter.(*rsa.PublicKey)
	//EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte)
	msg, err = rsa.EncryptPKCS1v15(rand.Reader, pubKey, src)
	if err != nil {
		return msg, err
	}
	return msg, nil
}
func DeRsaPrivate(src []byte, filePath string) ([]byte, error) {
	file, err := os.Open(filePath)
	msg := []byte(" ")
	if err != nil {
		return msg, err
	}
	//(file *File) Stat() (FileInfo, error)
	info, err := file.Stat()
	//type FileInfo interface
	if err != nil {
		return msg, err
	}
	byteSize := make([]byte, info.Size())
	//(f *File) Read(b []byte) (n int, err error) //Read方法从f中读取最多len(b)字节数据并写入b
	file.Read(byteSize)
	block, _ := pem.Decode(byteSize)
	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return msg, err
	}
	msg, err = rsa.DecryptPKCS1v15(rand.Reader, priKey, src)
	if err != nil {
		return msg, err
	}
	return msg, nil
}