Go语言实现椭圆曲线加密解密

已于 2022-05-12 16:51:45 修改
阅读量995 收藏 4
点赞数 1
文章标签： golang 开发语言 后端 算法 抽象代数
于 2022-05-12 01:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012421101/article/details/124722928
版权

本文借鉴了SM2的加密解密过程，这对我起了极大的帮助作用。本文基于Go语言实现了椭圆曲线加密解密。加密、解密、签名和验证的完整代码可以参考：https://github.com/lwqt99/myInterest，同时里面也包含了各类相关算法。

  1. 生成密钥对
type Ecdsa struct {
	randKey string
	priKey *ecdsa.PrivateKey
	pubKey *ecdsa.PublicKey
}
type Cipher struct {
	XCoordinate *big.Int
	YCoordinate *big.Int
	HASH        []byte
	CipherText  []byte
}
var ECDSA Ecdsa
//用于生成自定义的参数（如果使用官方自带参数则不需要使用下面的函数）
func initPX() elliptic.Curve {
	var p *elliptic.CurveParams
	p = &elliptic.CurveParams{Name: "P-X"}
	p.P, _ = new(big.Int).SetString("39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319", 10)
	p.N, _ = new(big.Int).SetString("39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643", 10)
	p.B, _ = new(big.Int).SetString("b3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef", 16)
	p.Gx, _ = new(big.Int).SetString("aa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7", 16)
	p.Gy, _ = new(big.Int).SetString("3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f", 16)
	p.BitSize = 384

	return p
}

//也可以使用自定义的曲线 具体可修改上面的函数
func (*Ecdsa)generateKey(priFile, pubFile *os.File) error {
	lenth := len(ECDSA.randKey)
	if lenth < 224/8 + 8 {
		return errors.New("randKey长度太短，至少为36位！")
	}
	// 根据随机密匙的长度创建私匙
	var curve elliptic.Curve
	if lenth > 521/8+8 {
		curve = elliptic.P521()
	} else if lenth > 384/8+8 {
		curve = elliptic.P384()
	} else if lenth > 256/8+8 {
		curve = elliptic.P256()
	} else if lenth > 224/8+8 {
		curve = elliptic.P224()
	}
	// 生成私匙
	priKey, err := ecdsa.GenerateKey(curve, strings.NewReader(ECDSA.randKey))
	if err != nil {
		return err
	}
	// 序列化私匙
	priBytes, err := x509.MarshalECPrivateKey(priKey)
	if err != nil {
		return err
	}
	priBlock := pem.Block{
		Type:  "ECD PRIVATE KEY",
		Bytes: priBytes,
	}
	// 编码私匙,写入文件
	if err := pem.Encode(priFile, &priBlock); err != nil {
		return err
	}
	// 序列化公匙
	pubBytes, err := x509.MarshalPKIXPublicKey(&priKey.PublicKey)
	if err != nil {
		return err
	}
	pubBlock := pem.Block{
		Type:  "ECD PUBLIC KEY",
		Bytes: pubBytes,
	}
	// 编码公匙,写入文件
	if err := pem.Encode(pubFile, &pubBlock); err != nil {
		return err
	}
	return nil
}
func (*Ecdsa)initECDSA() error {
	ECDSA.randKey = "ljz abc 123456 random choose some helpful id"
	// 初始化生成私匙公匙
	priFile, _ := os.Create("./gitgit/certificate/ecdsa-prikey.pem")
	pubFile, _ := os.Create("./gitgit/certificate/ecdsa-pubkey.pem")
	if err := ECDSA.generateKey(priFile, pubFile); err != nil {
		return err
	}
	return nil
}
func (*Ecdsa)GenerateKeys() error {
	if err := ECDSA.initECDSA(); err != nil{
		return err
	}
	return nil
}
// 加载私匙公匙
func (*Ecdsa)LoadKey() error {
	// 读取密匙
	pri, _ := ioutil.ReadFile("./gitgit/certificate/ecdsa-prikey.pem")
	pub, _ := ioutil.ReadFile("./gitgit/certificate/ecdsa-pubkey.pem")
	// 解码私匙
	block, _ := pem.Decode(pri)
	var err error
	// 反序列化私匙
	ECDSA.priKey, err = x509.ParseECPrivateKey(block.Bytes)
	if err != nil {
		return err
	}
	// 解码公匙
	block, _ = pem.Decode(pub)
	// 反序列化公匙
	var t interface{}
	t, err = x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return err
	}
	var ok bool
	ECDSA.pubKey, ok = t.(*ecdsa.PublicKey)
	if !ok {
		return errors.New("公钥interface转换失败")
	}
	return nil
}
  • 注意事项
    • randKey不重要，可以直接选用需要的曲线参数
    • 使用时需要先生成Key，然后每次使用前使用（指重新run代码）LoadKey()来加载密钥对
  1. 加密
/*
	用于生成随机数
 */
func randFieldElement(c elliptic.Curve, random io.Reader) (r *big.Int, err error) {
	one := new(big.Int).SetInt64(1)
	if random == nil {
		random = rand.Reader //If there is no external trusted random source,please use rand.Reader to instead of it.
	}
	params := c.Params()
	b := make([]byte, params.BitSize/8+8)
	_, err = io.ReadFull(random, b)
	if err != nil {
		return
	}
	r = new(big.Int).SetBytes(b)
	n := new(big.Int).Sub(params.N, one)
	r.Mod(r, n)
	r.Add(r, one)
	return
}

func intToBytes(x int) []byte {
	var buf = make([]byte, 4)

	binary.BigEndian.PutUint32(buf, uint32(x))
	return buf
}

// 填充
func zeroByteSlice(n int) []byte {
	return make([]byte,n)
}

/*
	加密
 */
func kdf(length, bitsize int, x ...[]byte) ([]byte, bool) {
	var c []byte

	ct := 1
	h := sm3.New()
	for i, j := 0, (length+bitsize-1)/bitsize; i < j; i++ {
		h.Reset()
		for _, xx := range x {
			h.Write(xx)
		}
		h.Write(intToBytes(ct))
		hash := h.Sum(nil)
		if i+1 == j && length%bitsize != 0 {
			c = append(c, hash[:length%bitsize]...)
		} else {
			c = append(c, hash...)
		}
		ct++
	}
	for i := 0; i < length; i++ {
		if c[i] != 0 {
			return c, true
		}
	}
	return c, false
}

func encrypt(message string, random io.Reader) ([]byte, error) {
	data := []byte(message)
	length := len(data)

	for {
		curve := ECDSA.pubKey.Curve
		r, err := randFieldElement(curve, random)
		if err != nil {
			return nil, err
		}
		x1, y1 := curve.ScalarBaseMult(r.Bytes()) //计算rG(kG便于理解)
		x2, y2 := curve.ScalarMult(ECDSA.pubKey.X, ECDSA.pubKey.Y, r.Bytes())

		x1Buf := x1.Bytes()
		y1Buf := y1.Bytes()
		x2Buf := x2.Bytes()
		y2Buf := y2.Bytes()

		//fmt.Println(len(x1Buf))
		bitsize := curve.Params().BitSize
		bitsize_8 := bitsize / 8

		if n := len(x1Buf); n < bitsize_8 {
			x1Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], x1Buf...)
		}
		if n := len(y1Buf); n < bitsize_8 {
			y1Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], y1Buf...)
		}
		if n := len(x2Buf); n < bitsize_8 {
			x2Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], x2Buf...)
		}
		if n := len(y2Buf); n < bitsize_8 {
			y2Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], y2Buf...)
		}

		// 计算加密结果
		c := []byte{}
		c = append(c, x1Buf...) // x分量
		c = append(c, y1Buf...) // y分量
		tm := []byte{}
		tm = append(tm, x2Buf...)
		tm = append(tm, data...)
		tm = append(tm, y2Buf...)

		h := sm3.Sm3Sum(tm)
		c = append(c, h...)
		ct, ok := kdf(length, bitsize_8, x2Buf, y2Buf) // 密文
		if !ok {
			continue
		}
		c = append(c, ct...)
		//for i := 0; i < len(c); i++ {
		//	fmt.Println(c[i])
		//}
		//fmt.Println(len(c))
		for i := 0; i < length; i++ {
			c[bitsize_8*3+i] ^= data[i]
		}

		return append([]byte{0x04}, c...), nil
	}
}
func CipherMarshal(bitsize int, data []byte) ([]byte, error) {
	data = data[1:]
	x := new(big.Int).SetBytes(data[:bitsize])
	y := new(big.Int).SetBytes(data[bitsize:bitsize*2])
	hash := data[bitsize*2:bitsize*3]
	cipherText := data[bitsize*3:]
	return asn1.Marshal(Cipher{x, y, hash, cipherText})
}

func (*Ecdsa) EncryptAsn1(message string, random io.Reader) ([]byte, error) {
	cipher, err := encrypt(message, random)
	if err != nil {
		return nil, err
	}
	return CipherMarshal(ECDSA.pubKey.Curve.Params().BitSize/8,cipher)
}
  1. 解密
/*
sm2密文asn.1编码格式转C1|C3|C2拼接格式
*/
func CipherUnmarshal(bitsize int, data []byte) ([]byte, error) {
	var cipher Cipher
	_, err := asn1.Unmarshal(data, &cipher)
	if err != nil {
		return nil, err
	}
	x := cipher.XCoordinate.Bytes()
	y := cipher.YCoordinate.Bytes()
	hash := cipher.HASH
	if err != nil {
		return nil, err
	}
	cipherText := cipher.CipherText
	if err != nil {
		return nil, err
	}
	if n := len(x); n < bitsize {
		x = append(zeroByteSlice(bitsize)[:bitsize-n], x...)
	}
	if n := len(y); n < bitsize {
		y = append(zeroByteSlice(bitsize)[:bitsize-n], y...)
	}
	c := []byte{}
	c = append(c, x...)          // x分量
	c = append(c, y...)          // y分
	c = append(c, hash...)       // x分量
	c = append(c, cipherText...) // y分
	return append([]byte{0x04}, c...), nil
}


func decrypt(priv *ecdsa.PrivateKey, data []byte) ([]byte, error) {
	data = data[1:]
	curve := priv.Curve
	bitsize_8 := curve.Params().BitSize / 8
	length := len(data) - bitsize * 3

	x := new(big.Int).SetBytes(data[:bitsize_8])
	y := new(big.Int).SetBytes(data[bitsize_8:bitsize_8*2])
	x2, y2 := curve.ScalarMult(x, y, priv.D.Bytes())
	x2Buf := x2.Bytes()
	y2Buf := y2.Bytes()
	if n := len(x2Buf); n < bitsize_8 {
		x2Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], x2Buf...)
	}
	if n := len(y2Buf); n < bitsize_8 {
		y2Buf = append(zeroByteSlice(bitsize_8)[:bitsize_8-n], y2Buf...)
	}
	c, ok := kdf(length,bitsize_8, x2Buf, y2Buf)
	if !ok {
		return nil, errors.New("Decrypt: failed to decrypt")
	}
	for i := 0; i < length; i++ {
		c[i] ^= data[i+bitsize*3]
	}
	tm := []byte{}
	tm = append(tm, x2Buf...)
	tm = append(tm, c...)
	tm = append(tm, y2Buf...)
	h := sm3.Sm3Sum(tm)
	if bytes.Compare(h, data[bitsize_8*2:bitsize_8*3]) != 0 {
		return c, errors.New("Decrypt: failed to decrypt")
	}
	return c, nil
}


func (*Ecdsa) DecryptAsn1(ciphertxt []byte) ([]byte, error) {
	bitsize_8 := ECDSA.pubKey.Curve.Params().BitSize / 8
	cipher, err := CipherUnmarshal(bitsize_8,ciphertxt)
	if err != nil {
		return nil, err
	}
	return decrypt(ECDSA.priKey, cipher)
}
l齐天
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
国密算法Go语言实现（详解）(八) ——SM2(椭圆曲线公钥密码算法)
weixin_46134229的博客
10-15 2581
Encrypt( ) 为SM2加密函数: - 生成随机数k, k属于区间[1,N-1] - 利用标准包elliptic的方法CurveParams.ScalarBaseMult()生成倍点C1=kG=(c1x, c1y) - 由于SM2推荐曲线余因子h=1，此时，点S=[h]PB就是公钥PB点，不可能为无穷远点O - 利用标准包elliptic的方法CurveParams.ScalarBaseMult()生成倍点kPB=(kPBx, kPBy) - 调用改进后的秘钥派生函数kdf(), 生成C2
国密算法Go语言实现（详解）(九) ——SM2(椭圆曲线公钥密码算法)
weixin_46134229的博客
10-15 3081
SignToRS( ) 为SM2签名算法的核心函数: - 以私钥(d倍数)为基础推算公钥点PA(XA, YA) - 调用预处理函数获取H值 - 调用标准包crypto/rand获取随机数k - 推算曲线点(x1, y1) = [k]G - 调用标准包math/big封装的加和取模函数计算r = (e + x1) mod n, 并校验r<>0, 且r+k<>n - 调用标准包math/big封装的取乘法逆元和取模函数计算s = ((1+d)^(-1) * (k - rd)) mod n
密码技术--国密SM2椭圆曲线公钥密码算法及Go语言应用
Innocence_0的博客
12-26 728
SM2算法和RSA算法都是公钥密码算法，SM2算法是一种更先进安全的算法，SM2是国家密码局与2010年12月17日发布的椭圆曲线公钥密码算法，在我们国家商用密码体系中被用来替换RSA算法。
Golang实现Sm2加解密
ZhongYuxuanG的博客
03-14 826
Golang实现国密Sm2加解密 本文仅供个人学习研究，如果涉及侵权，敬请告知！ SM2 椭圆曲线公钥密码算法，SM2曲线实现性能和Golang SDK中的NIST P256椭圆曲线原生实现（非BoringCrypto）类似，也对amd64 和 arm64架构做了专门汇编优化实现，SM2包实现了SM2椭圆曲线公钥密码算法的数字签名算法、公钥加密算法、密钥交换算法，中的密钥对保护数据格式。 SM2 公私钥对的话，要么是自己产生，要么是别的系统产生后通过某种方式传输给您的。 SM2公钥加密算法支持的密文编码格
【Golang】国密SM2公钥私钥序列化到redis中并加密解密实战_sm2反编
最新发布
youpwwcc的博客
04-15 795
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！PASS网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
SM2加解密、签名验签
热门推荐
qq_42873640的博客
08-11 1万+
加密流程。
国密算法SM2 密钥对的生成
xianmie的博客
11-09 7906
SM2国密算法的椭圆系统参数解释、密钥生成原理及实现
Go-ecc加密解密详解与代码
关注网络安全、云原生安全
07-03 5783
参考 《现代密码学教程 谷利泽，杨义先等》 Go标准库-crypto/des Go标准库-crypto/cipher 更多Go相关内容：Go-Golang学习总结笔记 有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。如果您感觉有所收获，自愿打赏，可选择支付宝18833895206（小于），您的支持是我不断更新的动力。 ...
椭圆曲线加密_椭圆曲线_椭圆曲线加密_
10-04
密码学椭圆曲线加密计算公钥、基点；实现加解密cpp文件
java使用bouncycastle实现椭圆曲线（ECC）双向加密解密
04-27
java借助bouncycastle库实现ECC双向加密解密算法Utils工具包。
简单椭圆曲线密钥生成与加解密python实现.rar
12-25
简单椭圆曲线密钥生成与加解密python实现
go语言base64加密解密的方法
12-25
本文实例讲述了go语言base64加密解密的方法。分享给大家供大家参考。具体实现方法如下： 代码如下:package main import (  “encoding/base64”  “fmt” ) const (  base64Table = “123...
Go语言实现区块链（五）
zhongliwen1981的专栏
04-28 1049
一、添加钱包 （1）定义钱包结构体 type Wallet struct { PrivateKey ecdsa.PrivateKey // 私钥 PublicKey []byte // 保存了公钥的X和Y } 由于不想在交易中传递公钥本身，提供公钥在网络上的传输效率，所以我们将公钥拆分成两个[]byte变量，然后将他们拼接成一个[]byte后存放在公钥字段中。 在verify之前一...
密码技术--椭圆曲线算法EDCSA数字签名及Go语言应用
weixin_38299404的博客
05-25 666
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.R
基于Go调用国密SM2算法
u012421101的博客
04-27 3397
// 一下为tool.go，辅助函数 /* 保存系统参数 */ func saveOneValue(filename string,save *big.Int) { outputFile, outputError := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)//os.O_APPEND追加 if outputError != nil { fmt.Println(outputError) return }
用golang实现对接java版的国密算法（Sm2SignWithSm3）
weixin_44781813的博客
11-13 5742
golang 对接 java 版的国密算法（Sm2SignWithSm3） 第三方加密算法升级国密SM2，找了好久才解决，直接上代码 需要依赖大神的包 https://github.com/ZZMarquis/gm 直接上源码 package sm2 import ( "encoding/base64" "encoding/hex" "encoding/json" "github.com/ZZMarquis/gm/sm2" "github.com/gin-gonic/gin" "githu
国密SM3——golang的实现
weixin_42117918的博客
05-08 687
SM3密码杂凑算法是中国国家密码管理局2010年公布的中国商用密码杂凑算法标准。SM3适用于商用密码应用中的数字签名和验证，是在[]基础上改进实现的一种算法，其。
密码学07--数字签名之go中的椭圆曲线数字签名
FengziTianYu的专栏
12-17 1100
目录 1.ECC 1.1 简介 1.2 GO语言中的ECC说明 1.3 Go语言中的ECC相关 1.4 Go语言中的ECC数字签名流程 1.4.1 ECDSA密钥对生成 1.4.2 ECDSA密钥对本地化 1.4.3 ECDSA私钥数字签名 1.4.4 ECDSA公钥签名校验 1.5 Go语言中的ECC数字签名模板 1.ECC 1.1 简介 Elliptic curv...
椭圆曲线加密解密 java实现
07-10
在Java中，可以使用Bouncy Castle库来实现椭圆曲线加密解密。 以下是一个简单的示例代码，演示了如何使用Bouncy Castle库在Java中实现椭圆曲线加密解密： ```java import org.bouncycastle.jce.ECNamedCurveTable;...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值