ecc演算法的代碼實作
什么是ecc演算法
Elliptic curve cryptography，橢圓曲線密碼學，即ECC，是一種建立公開密鑰加密的演算法，基于橢圓曲線數學，橢圓曲線在密碼學中的使用是在1985年由Neal Koblitz和Victor Miller分別獨立提出的，詳情鏈接https://www.cnblogs.com/Kalafinaian/p/7392505.html，
如果你能夠堅持看完上面的博客，并且能夠看懂里面的內容，我十分佩服，因為我實在是沒看下去，不過或多或少了解了一些基本的概念比如橢圓曲線函式并不是說真的就是一個函式來生成橢圓上的兩個點這么簡單，函式的幾何形狀也并不真的是一個橢圓，(真的就看懂了這么點東西..)所以有機會還是希望多多閱讀一下大神的博客，
有關與go語言的ecc包
在go語言中crypto/elliptic包是宣告橢圓曲線模型的包
注意：對于go語言自帶的ECC函式來說，數字越大對應的ECC的公私鑰的長度就越長，對應的加密等級就越高，當然也就越安全，那么對應的執行效率也就會相對降低，
crypto/ecdsa包則是go中用于橢圓曲線數字簽名的包，
具體實作流程
一、生成公私鑰
生成密鑰-->將生成的私鑰進行x509序列化為ASN.1標準的DER二進制編碼--> 構建pem.Block資料塊-->pem編碼【公鑰同理】
二、ecdsa私鑰生成數字簽名
讀取本地私鑰pem檔案-->pem決議pem資料塊-->x509決議der字串，獲得私鑰-->計算hash-->ecdsa簽名
三、ecdsa簽名驗證
讀取本地公鑰pem檔案-->pem決議pem資料塊-->x509決議der字串，獲得公鑰-->計算hash-->ecdsa簽名驗證
代碼實作
package main
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/sha256"
"crypto/x509"
"encoding/pem"
"fmt"
"math/big"
"os"
)
// 初始化創建ecc密鑰
func generateECDSAKey() {
// 生成ecc演算法的密鑰
privateKey, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
if err != nil {
panic(err)
}
// 將私鑰本地化,使用x509進行序列化
privateDerBytes, err := x509.MarshalECPrivateKey(privateKey)
if err != nil {
panic(err)
}
// 再將它轉換成pem的格式編碼
privatePemBlock := pem.Block{
Type: "Ecc PrivateKey", // 簡介使用演算法型別rsa/ecc
Bytes: privateDerBytes,
}
// 在本地創建pem檔案
privateFile, err := os.Create("ECDSAPrivateKey.pem")
if err != nil {
panic(err)
}
defer privateFile.Close()
// 進行pem編碼
err = pem.Encode(privateFile, &privatePemBlock)
if err != nil {
panic(err)
}
// 公鑰同理
publicKey := privateKey.PublicKey
publicDerBytes, err := x509.MarshalPKIXPublicKey(&publicKey)
if err != nil {
panic(err)
}
publicPemBlock := pem.Block{
Type: "Ecc PublicKey",
Bytes: publicDerBytes,
}
publicFile, err := os.Create("ECDSAPublicKey.pem")
if err != nil {
panic(err)
}
defer publicFile.Close()
pem.Encode(publicFile, &publicPemBlock)
}
// 私鑰簽名
func privateKeySignature(data []byte, privateKeyPemFileName string) (rText, sText []byte) {
// 讀取私鑰
privateFile, err := os.Open(privateKeyPemFileName)
if err != nil {
panic(err)
}
defer privateFile.Close()
// 讀取檔案源資訊
fileInfo, err := privateFile.Stat()
if err != nil {
panic(err)
}
buffer := make([]byte, fileInfo.Size())
privateFile.Read(buffer)
// pem解碼
block, _ := pem.Decode(buffer)
// x509 DER解碼
privateKey, err := x509.ParseECPrivateKey(block.Bytes)
if err != nil {
panic(err)
}
// 進行簽名
r, s, err := ecdsa.Sign(rand.Reader, privateKey, getHash(data))
// 將big的資料轉換成[]byte
rText, _ = r.MarshalText()
sText, _ = s.MarshalText()
return
}
// 獲取哈希
func getHash(data []byte) []byte {
hash256 := sha256.New()
hash256.Write(data)
return hash256.Sum(nil)
}
// 公鑰驗證
func publicKeyVerify(data, rText, sText []byte, publicKeyPemFileName string) bool {
// 讀取公鑰
publicFile, err := os.Open(publicKeyPemFileName)
if err != nil {
panic(err)
}
defer publicFile.Close()
fileInfo, err := publicFile.Stat()
if err != nil {
panic(err)
}
buffer := make([]byte, fileInfo.Size())
publicFile.Read(buffer)
block, _ := pem.Decode(buffer)
publicKeyType, err := x509.ParsePKIXPublicKey(block.Bytes)
if err != nil {
panic(err)
}
// 獲取到publicKey的型別，要進行斷言判斷rsa/ecc
publicKey := publicKeyType.(*ecdsa.PublicKey)
// 對[]byte簽名資料轉換成big資料
var r, s big.Int
r.UnmarshalJSON(rText)
s.UnmarshalJSON(sText)
if !ecdsa.Verify(publicKey, getHash(data), &r, &s) {
return false
} else {
return true
}
}
func main() {
data := []byte("我向某用戶轉賬10元")
generateECDSAKey()
rText, sText := privateKeySignature(data, "ECDSAPrivateKey.pem")
fmt.Println(publicKeyVerify(data, rText, sText, "ECDSAPublicKey.pem"))
}
使用以太坊的ecc加密演算法實作
以太坊的crypto模塊
該模塊分為兩個部分一個是實作sha3,一個是實作secp256k1(這也是位元幣中使用的簽名演算法). 需要說明的是secp256k1有兩種實作方式,一種是依賴libsecp256k1,需要cgo,另外一種是依賴github.com/btcsuite/btcd,這是一個使用go語言實作的位元幣的客戶端.
sha3模塊
這個模塊實際上可以認為就是一個功能計算sha3-256,用法也很簡單,就是呼叫crypto中的Keccak256,輸出是一個32位元組的hash結果
hash := crypto.Keccak256Hash([]byte("hello"))
//hash值:4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45
secp256k1模塊
這個模塊比較復雜,如果要細度原始碼,需要對密碼學有比較深入的理解,但是使用起來其實比較簡單.
主要就是簽名,驗證,以及公鑰與以太坊地址轉換
1.簽名
secp256k1的私鑰地址長度是32位元組256位,公鑰地址長度是65位元組,而以太坊的地址長度是20位元組.
2.驗證
驗證簽名是否正確,需要公鑰,hash(對message進行hash的結果),以及簽名. 這里面真正校驗的是第三步,也就是公鑰是否和我的相同,而不像普通工RSA簽名驗證一樣.當然我們可以封裝成和RSA簽名驗證一樣形式的func VerifySignature(pubKey,msg,sig []byte) error
3.公鑰與地址的轉換
以太坊中并沒有直接拿公鑰當做賬戶地址,而是進行了一個簡單的轉換,具體來說就是hash(公鑰)的后20位,這里的hash演算法是sha3-256,可以用一行代碼來表示
crypto.Keccak256(pubKey)[12:]
以太坊ecc的簡單模式實作
package main
import (
"bytes"
"crypto/ecdsa"
"crypto/rand"
"crypto/sha256"
"encoding/hex"
"fmt"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/crypto/ecies"
"strconv"
)
// 獲取私鑰
func getKey() (*ecdsa.PrivateKey, error) {
privateKey, err := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
if err != nil {
return privateKey, err
}
return privateKey, nil
}
// 加密
func ECCEncrypt(publicKey ecies.PublicKey, data []byte) ([]byte, error) {
ct, err := ecies.Encrypt(rand.Reader, &publicKey, data, nil, nil)
return ct, err
}
// 解密
func ECCDecrypt(privateKey ecies.PrivateKey, ct []byte) ([]byte, error) {
m, err := privateKey.Decrypt(ct, nil, nil)
return m, err
}
// 獲取哈希
func getHash2(data []byte, nonce int) string {
hashBytes := sha256.Sum256([]byte(string(data) + strconv.Itoa(nonce)))
return hex.EncodeToString(hashBytes[:])
}
// 獲取挖礦等級需求來進行判斷hash是否滿足
func getMineDiff(diff int) (str string) {
for i := 0; i < diff; i++ {
str = str + "0"
}
return
}
// 開始挖礦[鏈的挖礦難度]
func calculationHash(diff int, data []byte) string {
strDiff := getMineDiff(diff)
var nonce int
for {
if getHash2(data, nonce)[:diff] == strDiff {
return getHash2(data, nonce)
}
nonce++
}
}
// 簽名
func signature(hash []byte, privateKey *ecdsa.PrivateKey) ([]byte, error) {
signature, err := crypto.Sign(hash, privateKey)
if err != nil {
return signature, err
}
return signature, nil
}
// 驗證
func validate(recoveredPub, recoveredPubBytes []byte) bool {
if !bytes.Equal(recoveredPubBytes, recoveredPub) {
return false
}
return true
}
func main() {
privateKeyECDSA, _ := getKey()
// 將ecdsa的私鑰轉換成以太坊的私鑰
privateKey := ecies.ImportECDSA(privateKeyECDSA)
publicKey := privateKey.PublicKey
// 公鑰加密
data := []byte("我向某用戶轉賬10元")
hash := calculationHash(4, data)
fmt.Println("哈希散列為", hash)
encryptData, err := ECCEncrypt(publicKey, []byte(hash))
if err != nil {
panic(err)
}
fmt.Println("公鑰加密后為", hex.EncodeToString(encryptData))
// 私鑰解密
decryptData, err := ECCDecrypt(*privateKey, encryptData)
if err != nil {
panic(err)
}
fmt.Println("私鑰解密后為", string(decryptData))
// 進行簽名
signData, _ := signature(crypto.Keccak256([]byte(hash)), privateKey.ExportECDSA())
fmt.Println("簽名為", hex.EncodeToString(signData))
// 驗證
recoveredPub, _ := crypto.Ecrecover(crypto.Keccak256([]byte(hash)), signData)
recoveredPubBytes := crypto.FromECDSAPub(&privateKeyECDSA.PublicKey)
fmt.Println(validate(recoveredPub, recoveredPubBytes))
}
ecc密鑰對與[]byte型別轉換
https://blog.csdn.net/reigns_/article/details/83110066
借鑒參考：
https://blog.csdn.net/u013792921/article/details/85057646#1.ECC 密碼學07--數字簽名之go中的橢圓曲線數字簽名
https://www.cnblogs.com/baizx/p/6936258.html 以太坊系列之三: 以太坊的crypto模塊--以太坊原始碼學習
https://blog.csdn.net/reigns_/article/details/83069118 golang實作ecc加密解密
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/326.html
標籤：Go