Skip to content

R
reencrypt
Commit 22dce94c authored by pengjun's avatar pengjun
Browse files
Options

update sdk to chain33-sdk-go

parent 58871f6c
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 31 additions and 1430 deletions
go.mod
View file @ 22dce94c
...@@ -3,18 +3,21 @@ module gitlab.33.cn/pengjun/reencrypt ...@@ -3,18 +3,21 @@ module gitlab.33.cn/pengjun/reencrypt
go 1.12 go 1.12
require ( require (
github.com/33cn/chain33-sdk-go v0.0.0-20200612015917-5eeccd604dbc
github.com/BurntSushi/toml v0.3.1 github.com/BurntSushi/toml v0.3.1
github.com/btcsuite/btcd v0.0.0-20190824003749-130ea5bddde3 github.com/btcsuite/btcd v0.20.1-beta
github.com/golang/protobuf v1.3.4 github.com/golang/protobuf v1.4.2
github.com/golang/snappy v0.0.1 // indirect github.com/golang/snappy v0.0.1 // indirect
github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1 github.com/inconshreveable/log15 v0.0.0-20200109203555-b30bc20e4fd1
github.com/mattn/go-colorable v0.1.6 // indirect github.com/mr-tron/base58 v1.2.0 // indirect
github.com/mr-tron/base58 v1.1.3
github.com/onsi/ginkgo v1.12.0 // indirect github.com/onsi/ginkgo v1.12.0 // indirect
github.com/onsi/gomega v1.9.0 // indirect github.com/onsi/gomega v1.9.0 // indirect
github.com/rs/cors v1.7.0 github.com/rs/cors v1.7.0
github.com/spf13/cobra v0.0.7 github.com/spf13/cobra v1.0.0
github.com/stretchr/testify v1.5.1 github.com/stretchr/testify v1.5.1
github.com/syndtr/goleveldb v1.0.0 github.com/syndtr/goleveldb v1.0.0
golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392 github.com/tjfoc/gmsm v1.3.2 // indirect
golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9 // indirect
golang.org/x/sys v0.0.0-20200610111108-226ff32320da // indirect
google.golang.org/protobuf v1.24.0 // indirect
) )
go.sum
View file @ 22dce94c
This diff is collapsed.
sdk/account.go deleted 100644 → 0
View file @ 58871f6c
package sdk
import (
"errors"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
)
type Account struct {
PrivateKey []byte
PublicKey []byte
Address string
SignType string
}
func NewAccount(signType string) (*Account, error) {
if signType == "" {
signType = crypto.SECP256K1
}
account := Account{}
account.SignType = signType
if signType == crypto.SECP256K1 {
account.PrivateKey = crypto.GeneratePrivateKey()
account.PublicKey = crypto.PubKeyFromPrivate(account.PrivateKey)
addr, err := crypto.PubKeyToAddress(account.PublicKey)
if err != nil {
return nil, err
}
account.Address = addr
} else if signType == crypto.SM2 {
// TODO
} else if signType == crypto.ED25519 {
// TODO
} else {
return nil, errors.New("sign type not support")
}
return &account, nil
}
\ No newline at end of file
sdk/client/jsonclient.go deleted 100644 → 0
View file @ 58871f6c
// Copyright Fuzamei Corp. 2020 All Rights Reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package jsonclient 实现JSON rpc客户端请求功能
package client
import (
"bytes"
"crypto/tls"
"encoding/json"
"errors"
"fmt"
"github.com/golang/protobuf/proto"
"io/ioutil"
"net/http"
"strings"
)
// JSONClient a object of jsonclient
type JSONClient struct {
url string
prefix string
tlsVerify bool
client *http.Client
}
func addPrefix(prefix, name string) string {
if strings.Contains(name, ".") {
return name
}
return prefix + "." + name
}
// NewJSONClient produce a json object
func NewJSONClient(prefix, url string) (*JSONClient, error) {
return new(prefix, url, false)
}
// New produce a jsonclient by perfix and url
func new(prefix, url string, tlsVerify bool) (*JSONClient, error) {
httpcli := http.DefaultClient
if strings.Contains(url, "https") { //暂不校验tls证书
httpcli = &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: !tlsVerify}}}
}
return &JSONClient{
url: url,
prefix: prefix,
tlsVerify: tlsVerify,
client: httpcli,
}, nil
}
type clientRequest struct {
Method string `json:"method"`
Params [1]interface{} `json:"params"`
ID uint64 `json:"id"`
}
type clientResponse struct {
ID uint64 `json:"id"`
Result *json.RawMessage `json:"result"`
Error interface{} `json:"error"`
}
func (client *JSONClient) Call(method string, params, resp interface{}) error {
method = addPrefix(client.prefix, method)
req := &clientRequest{}
req.Method = method
req.Params[0] = params
data, err := json.Marshal(req)
if err != nil {
return err
}
postresp, err := client.client.Post(client.url, "application/json", bytes.NewBuffer(data))
if err != nil {
return err
}
defer postresp.Body.Close()
b, err := ioutil.ReadAll(postresp.Body)
if err != nil {
return err
}
cresp := &clientResponse{}
err = json.Unmarshal(b, &cresp)
if err != nil {
return err
}
if cresp.Error != nil {
x, ok := cresp.Error.(string)
if !ok {
return fmt.Errorf("invalid error %v", cresp.Error)
}
if x == "" {
x = "unspecified error"
}
return fmt.Errorf(x)
}
if cresp.Result == nil {
return errors.New("Empty result")
}
if msg, ok := resp.(proto.Message); ok {
var str json.RawMessage
err = json.Unmarshal(*cresp.Result, &str)
if err != nil {
return err
}
b, err := str.MarshalJSON()
if err != nil {
return err
}
err = json.Unmarshal(b, msg)
if err != nil {
fmt.Println("err", err)
return err
}
return nil
}
return json.Unmarshal(*cresp.Result, resp)
}
type ParseFunc func(result json.RawMessage) (interface{},error)
//回调函数，用于自定义解析返回得result数据
func (client *JSONClient) CallBack(method string, params interface{},parseFunc ParseFunc) (interface{}, error) {
method = addPrefix(client.prefix, method)
req := &clientRequest{}
req.Method = method
req.Params[0] = params
data, err := json.Marshal(req)
if err != nil {
return nil, err
}
postresp, err := client.client.Post(client.url, "application/json", bytes.NewBuffer(data))
if err != nil {
return nil, err
}
defer postresp.Body.Close()
b, err := ioutil.ReadAll(postresp.Body)
if err != nil {
return nil, err
}
cresp := &clientResponse{}
err = json.Unmarshal(b, &cresp)
if err != nil {
return nil, err
}
if cresp.Error != nil {
x, ok := cresp.Error.(string)
if !ok {
return nil, fmt.Errorf("invalid error %v", cresp.Error)
}
if x == "" {
x = "unspecified error"
}
return nil, fmt.Errorf(x)
}
if cresp.Result == nil {
return nil, errors.New("Empty result")
}
return parseFunc(*cresp.Result)
}
// 发送交易
func (client *JSONClient) SendTransaction(signedTx string) (string, error) {
var res string
send := &RawParm{
Token: "BTY",
Data: signedTx,
}
err := client.Call("Chain33.SendTransaction", send, &res)
if err != nil {
return "", err
}
return res, nil
}
// 查询交易
func (client *JSONClient) QueryTransaction(hash string) (*TransactionDetail, error) {
query := QueryParm{
Hash: hash,
}
var detail TransactionDetail
err := client.Call("Chain33.QueryTransaction", query, &detail)
if err != nil {
return nil, err
}
return &detail, nil
}
sdk/client/type.go deleted 100644 → 0
View file @ 58871f6c
package client
import "encoding/json"
// RawParm defines raw parameter command
type RawParm struct {
Token string `json:"token"`
Data string `json:"data"`
}
// CreateTxIn create tx input
type CreateTxIn struct {
Execer string `json:"execer"`
ActionName string `json:"actionName"`
Payload json.RawMessage `json:"payload"`
}
// QueryParm Query parameter
type QueryParm struct {
Hash string `json:"hash"`
}
// Signature parameter
type Signature struct {
Ty int32 `json:"ty"`
Pubkey string `json:"pubkey"`
Signature string `json:"signature"`
}
// Transaction parameter
type Transaction struct {
Execer string `json:"execer"`
Payload json.RawMessage `json:"payload"`
RawPayload string `json:"rawPayload"`
Signature *Signature `json:"signature"`
Fee int64 `json:"fee"`
FeeFmt string `json:"feefmt"`
Expire int64 `json:"expire"`
Nonce int64 `json:"nonce"`
From string `json:"from,omitempty"`
To string `json:"to"`
Amount int64 `json:"amount,omitempty"`
AmountFmt string `json:"amountfmt,omitempty"`
GroupCount int32 `json:"groupCount,omitempty"`
Header string `json:"header,omitempty"`
Next string `json:"next,omitempty"`
Hash string `json:"hash,omitempty"`
}
// ReceiptDataResult receipt data result
type ReceiptDataResult struct {
Ty int32 `json:"ty"`
TyName string `json:"tyName"`
Logs []*ReceiptLogResult `json:"logs"`
}
// ReceiptLogResult receipt log result
type ReceiptLogResult struct {
Ty int32 `json:"ty"`
TyName string `json:"tyName"`
Log json.RawMessage `json:"log"`
RawLog string `json:"rawLog"`
}
// Asset asset
type Asset struct {
Exec string `json:"exec"`
Symbol string `json:"symbol"`
Amount int64 `json:"amount"`
}
// TxProof :
type TxProof struct {
Proofs []string `json:"proofs"`
Index uint32 `json:"index"`
RootHash string `json:"rootHash"`
}
// TransactionDetail transaction detail
type TransactionDetail struct {
Tx *Transaction `json:"tx"`
Receipt *ReceiptDataResult `json:"receipt"`
Proofs []string `json:"proofs"`
Height int64 `json:"height"`
Index int64 `json:"index"`
Blocktime int64 `json:"blockTime"`
Amount int64 `json:"amount"`
Fromaddr string `json:"fromAddr"`
ActionName string `json:"actionName"`
Assets []*Asset `json:"assets"`
TxProofs []*TxProof `json:"txProofs"`
FullHash string `json:"fullHash"`
}
// Query4Jrpc query jrpc
type Query4Jrpc struct {
Execer string `json:"execer"`
FuncName string `json:"funcName"`
Payload json.RawMessage `json:"payload"`
}
sdk/crypto/address.go deleted 100644 → 0
View file @ 58871f6c
package crypto
import (
"crypto/sha256"
"fmt"
"github.com/mr-tron/base58/base58"
)
//不同币种的前缀版本号
var coinPrefix = map[string][]byte{
"BTC": {0x00},
"BCH": {0x00},
"BTY": {0x00},
"LTC": {0x30},
"ZEC": {0x1c, 0xb8},
"USDT": {0x00},
}
var addrSeed = []byte("address seed bytes for public key")
//MaxExecNameLength 执行器名最大长度
const MaxExecNameLength = 100
func PubKeyToAddress(pub []byte) (addr string, err error) {
if len(pub) != 33 && len(pub) != 65 { //压缩格式 与 非压缩格式
return "", fmt.Errorf("invalid public key byte")
}
//添加版本号
hash160res := append(coinPrefix["BTY"], Rimp160(pub)...)
//添加校验码
cksum := checksum(hash160res)
address := append(hash160res, cksum[:]...)
//地址进行base58编码
addr = base58.Encode(address)
return
}
//checksum: first four bytes of double-SHA256.
func checksum(input []byte) (cksum [4]byte) {
h := sha256.New()
_, err := h.Write(input)
if err != nil {
return
}
intermediateHash := h.Sum(nil)
h.Reset()
_, err = h.Write(intermediateHash)
if err != nil {
return
}
finalHash := h.Sum(nil)
copy(cksum[:], finalHash[:])
return
}
func GetExecAddress(name string) string {
if len(name) > MaxExecNameLength {
panic("name too long")
}
var bname [200]byte
buf := append(bname[:0], addrSeed...)
buf = append(buf, []byte(name)...)
pub := Sha2Sum(buf)
var ad [25]byte
ad[0] = 0
copy(ad[1:21], Rimp160(pub))
sh := Sha2Sum(ad[0:21])
checksum := make([]byte, 4)
copy(checksum, sh[:4])
copy(ad[21:25], checksum[:])
addr := base58.Encode(ad[:])
return addr
}
\ No newline at end of file
sdk/crypto/aes.go deleted 100644 → 0
View file @ 58871f6c
package crypto
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"errors"
"io"
)
const (
AESPrivateKeyLength = 16
)
func pkcs7Padding(src []byte) []byte {
padding := aes.BlockSize - len(src)%aes.BlockSize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(src, padtext...)
}
func aesCBCEncrypt(key, s []byte) ([]byte, error) {
return aesCBCEncryptWithRand(rand.Reader, key, s)
}
func aesCBCEncryptWithRand(prng io.Reader, key, s []byte) ([]byte, error) {
if len(s)%aes.BlockSize != 0 {
return nil, errors.New("Invalid plaintext. It must be a multiple of the block size")
}
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
ciphertext := make([]byte, aes.BlockSize+len(s))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(prng, iv); err != nil {
return nil, err
}
mode := cipher.NewCBCEncrypter(block, iv)
mode.CryptBlocks(ciphertext[aes.BlockSize:], s)
return ciphertext, nil
}
func aesCBCDecrypt(key, src []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
if len(src) < aes.BlockSize {
return nil, errors.New("Invalid ciphertext. It must be a multiple of the block size")
}
iv := src[:aes.BlockSize]
src = src[aes.BlockSize:]
if len(src)%aes.BlockSize != 0 {
return nil, errors.New("Invalid ciphertext. It must be a multiple of the block size")
}
mode := cipher.NewCBCDecrypter(block, iv)
mode.CryptBlocks(src, src)
return src, nil
}
func pkcs7UnPadding(src []byte) ([]byte, error) {
length := len(src)
unpadding := int(src[length-1])
if unpadding > aes.BlockSize || unpadding == 0 {
return nil, errors.New("Invalid pkcs7 padding (unpadding > aes.BlockSize || unpadding == 0)")
}
pad := src[len(src)-unpadding:]
for i := 0; i < unpadding; i++ {
if pad[i] != byte(unpadding) {
return nil, errors.New("Invalid pkcs7 padding (pad[i] != unpadding)")
}
}
return src[:(length - unpadding)], nil
}
func AESCBCPKCS7Encrypt(key, src []byte) ([]byte, error) {
tmp := pkcs7Padding(src)
return aesCBCEncrypt(key, tmp)
}
func AESCBCPKCS7Decrypt(key, src []byte) ([]byte, error) {
pt, err := aesCBCDecrypt(key, src)
if err == nil {
return pkcs7UnPadding(pt)
}
return nil, err
}
func GenetateAESKey() []byte {
return getRandBytes(AESPrivateKeyLength)
}
\ No newline at end of file
sdk/crypto/btcSigner.go deleted 100644 → 0
View file @ 58871f6c
package crypto
import (
"bytes"
"crypto/rand"
secp256k1 "github.com/btcsuite/btcd/btcec"
)
var (
SECP256K1 = "secp256k1"
SM2 = "sm2"
ED25519 = "ed25519" //TODO
)
func GeneratePrivateKey() []byte {
privKeyBytes := make([]byte, 32)
for {
key := getRandBytes(32)
if bytes.Compare(key, secp256k1.S256().Params().N.Bytes()) >= 0 {
continue
}
copy(privKeyBytes[:], key)
break
}
priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKeyBytes[:])
copy(privKeyBytes[:], priv.Serialize())
return privKeyBytes
}
func PubKeyFromPrivate(privKey []byte) []byte {
_, pub := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:])
pubSecp256k1 := make([]byte, 33)
copy(pubSecp256k1[:], pub.SerializeCompressed())
return pubSecp256k1
}
func Sign(msg []byte, privKey []byte) []byte {
priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:])
sig, err := priv.Sign(Sha256(msg))
if err != nil {
panic("Error signing secp256k1" + err.Error())
}
return sig.Serialize()
}
func PrivateFromByte(privKey []byte) *secp256k1.PrivateKey {
priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey[:])
return priv
}
func PublicFromByte(pubKey []byte) *secp256k1.PublicKey {
pub, _ := secp256k1.ParsePubKey(pubKey, secp256k1.S256())
return pub
}
func getRandBytes(numBytes int) []byte {
b := make([]byte, numBytes)
_, err := rand.Read(b)
if err != nil {
panic("Panic on a Crisis" + err.Error())
}
return b
}
\ No newline at end of file
sdk/crypto/crypto_test.go deleted 100644 → 0
View file @ 58871f6c
package crypto
import (
"fmt"
"github.com/33cn/chain33-sdk-go/crypto/gm"
"github.com/33cn/chain33-sdk-go/types"
"github.com/stretchr/testify/assert"
"testing"
)
func TestAES(t *testing.T) {
var text = "hello aes"
var key = getRandBytes(16)
cipherText, err := AESCBCPKCS7Encrypt(key, []byte(text))
if err != nil {
fmt.Println(err)
return
}
cipher, err := AESCBCPKCS7Decrypt(key, cipherText)
if err != nil {
fmt.Println(err)
return
}
assert.Equal(t, text, string(cipher))
}
func TestSign(t *testing.T) {
priv, _ := types.FromHex("0xc2b31057b8692a56c7dd18199df71c1d21b781c0b6858c52997c9dbf778e8550")
msg := []byte("sign test")
sig := Sign(msg, priv)
fmt.Printf("sig = %x\n", sig)
}
func TestSM2(t *testing.T) {
priv, pub := gm.GenetateKey()
fmt.Println(types.ToHex(pub))
msg := []byte("sign test")
sig := gm.SM2Sign(msg, priv, nil)
fmt.Printf("sig = %x\n", sig)
result := gm.SM2Verify(msg, pub, sig, nil)
fmt.Println(result)
}
func TestSM4(t *testing.T) {
key := []byte{0x1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}
fmt.Printf("key = %v\n", key)
data := []byte{0x1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}
fmt.Printf("data = %x\n", data)
d0 := gm.SM4Encrypt(key, data)
fmt.Printf("d0 = %x\n", d0)
d1 := gm.SM4Decrypt(key, d0)
fmt.Printf("d1 = %x\n", d1)
assert.Equal(t, data, d1)
}
func TestAddress(t *testing.T) {
priv, _ := types.FromHex("0xc2b31057b8692a56c7dd18199df71c1d21b781c0b6858c52997c9dbf778e8550")
pub := PubKeyFromPrivate(priv)
fmt.Println(types.ToHex(pub))
addr, err := PubKeyToAddress(pub)
if err != nil {
panic(err)
}
fmt.Println(addr)
}
func TestKDF(t *testing.T) {
key := []byte{0x1, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x11}
keyf := KDF(key, 32)
fmt.Println(keyf)
fmt.Println(len(keyf))
}
sdk/crypto/hash.go deleted 100644 → 0
View file @ 58871f6c
package crypto
import (
"crypto/sha256"
"golang.org/x/crypto/ripemd160"
"math/big"
)
func Sha256(b []byte) []byte {
hasher := sha256.New()
hasher.Write(b)
return hasher.Sum(nil)
}
func Sha2Sum(b []byte) []byte {
tmp := sha256.Sum256(b)
tmp = sha256.Sum256(tmp[:])
return tmp[:]
}
func rimpHash(in []byte, out []byte) {
sha := sha256.New()
_, err := sha.Write(in)
if err != nil {
return
}
rim := ripemd160.New()
_, err = rim.Write(sha.Sum(nil)[:])
if err != nil {
return
}
copy(out, rim.Sum(nil))
}
// Rimp160 Returns hash: RIMP160( SHA256( data ) )
// Where possible, using RimpHash() should be a bit faster
func Rimp160(b []byte) []byte {
out := make([]byte, 20)
rimpHash(b, out[:])
return out[:]
}
func KDF(x []byte, length int) []byte {
var c []byte
var ct int64 = 1
h := sha256.New()
for i, j := 0, (length+31)/32; i < j; i++ {
h.Reset()
h.Write(x)
h.Write(big.NewInt(ct).Bytes())
hash := h.Sum(nil)
if i+1 == j && length%32 != 0 {
c = append(c, hash[:length%32]...)
} else {
c = append(c, hash...)
}
ct++
}
return c
}
\ No newline at end of file
sdk/pre.go deleted 100644 → 0
View file @ 58871f6c
package sdk
import (
"crypto/rand"
"errors"
"fmt"
secp256k1 "github.com/btcsuite/btcd/btcec"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
"gitlab.33.cn/pengjun/reencrypt/sdk/types"
"golang.org/x/crypto/blake2b"
"math/big"
)
var baseN = secp256k1.S256().Params().N
type KFrag struct {
Random string
Value string
PrecurPub string
}
type ReKeyFrag struct {
ReKeyR string
ReKeyU string
Random string
PrecurPub string
}
type EccPoit struct {
x *big.Int
y *big.Int
}
func NewEccPoint(pubStr string) (*EccPoit, error) {
reKeyRByte, err := types.FromHex(pubStr)
if err != nil {
fmt.Errorf("get reKeyRByte err", err)
return nil, err
}
reKeyR := crypto.PublicFromByte(reKeyRByte)
return &EccPoit{x: reKeyR.X, y: reKeyR.Y}, nil
}
func (p *EccPoit) Add(v *EccPoit) *EccPoit {
if v == nil {
return p
}
p.x, p.y = secp256k1.S256().Add(p.x, p.y, v.x, v.y)
return p
}
func (p *EccPoit) MulInt(i *big.Int) *EccPoit {
p.x, p.y = secp256k1.S256().ScalarMult(p.x, p.y, i.Bytes())
return p
}
func (p *EccPoit) ToPublicKey() *secp256k1.PublicKey {
return &secp256k1.PublicKey{
X: p.x,
Y: p.y,
Curve: secp256k1.S256(),
}
}
func hashToModInt(digest []byte) *big.Int {
orderBits := baseN.BitLen()
orderBytes := (orderBits + 7) / 8
if len(digest) > orderBytes {
digest = digest[:orderBytes]
}
ret := new(big.Int).SetBytes(digest)
excess := len(digest)*8 - orderBits
if excess > 0 {
ret.Rsh(ret, uint(excess))
}
return ret
}
func makeShamirPolyCoeff(threshold int) []*big.Int {
coeffs := make([]*big.Int, threshold-1)
for i,_ := range coeffs {
coeffs[i] = new(big.Int).SetBytes(crypto.GeneratePrivateKey())
}
return coeffs
}
// p0*x^2 + p1 * x + p2
func hornerPolyEval(poly []*big.Int, x *big.Int) *big.Int {
result := big.NewInt(0)
result.Add(result, poly[0])
for i := 1; i < len(poly); i++ {
result = result.Mul(result, x).Add(result, poly[i])
}
return result.Mod(result, baseN)
}
func calcPart(a *big.Int, b *big.Int) *big.Int {
p := big.NewInt(0)
p.Sub(a, b).Mod(p, baseN)
res := big.NewInt(0)
res.Mul(a, p.ModInverse(p, baseN)).Mod(res, baseN)
return res
}
func calcLambdaCoeff(inId *big.Int, selectedIds []*big.Int) *big.Int {
var ids []*big.Int
for _, id := range selectedIds {
if inId.Cmp(id) == 0 {
continue
}
ids = append(ids, id)
}
if len(ids) == 0 {
return big.NewInt(1)
}
result := calcPart(ids[0], inId)
if len(ids) > 1 {
for _, id_j := range ids[1:] {
result.Mul(result, calcPart(id_j, inId)).Mod(result, baseN)
}
}
return result
}
func getRandomInt(order *big.Int) *big.Int {
randInt, err := rand.Int(rand.Reader, order)
if err != nil {
panic(err)
}
return randInt
}
func GeneratePreEncryptKey(pubOwner []byte) ([]byte, string, string) {
pubOwnerKey := crypto.PublicFromByte(pubOwner)
priv_r := crypto.PrivateFromByte(crypto.GeneratePrivateKey())
priv_u := crypto.PrivateFromByte(crypto.GeneratePrivateKey())
result := &secp256k1.PublicKey{}
result.Curve = pubOwnerKey.Curve
sum := big.NewInt(0)
sum.Add(priv_u.D, priv_r.D).Mod(sum, baseN)
result.X, result.Y = secp256k1.S256().ScalarMult(pubOwnerKey.X, pubOwnerKey.Y, sum.Bytes())
pub_r := types.ToHex((*secp256k1.PublicKey)(&priv_r.PublicKey).SerializeCompressed())
pub_u := types.ToHex((*secp256k1.PublicKey)(&priv_u.PublicKey).SerializeCompressed())
share_key := crypto.KDF(result.SerializeCompressed(), 32)
return share_key, pub_r, pub_u
}
func GenerateKeyFragments(privOwner []byte, pubRecipient []byte, numSplit, threshold int) ([]*KFrag, error) {
precursor := crypto.PrivateFromByte(crypto.GeneratePrivateKey())
precurPub := types.ToHex((*secp256k1.PublicKey)(&precursor.PublicKey).SerializeCompressed())
privOwnerKey := crypto.PrivateFromByte(privOwner)
pubRecipientKey := crypto.PublicFromByte(pubRecipient)
dh_Alice_poit_x := types.ECDH(precursor, pubRecipientKey)
dAliceHash, err := blake2b.New256(precursor.X.Bytes())
if err != nil {
fmt.Errorf("Generate precursor Key err", err)
return nil, err
}
dAliceHash.Write(pubRecipientKey.X.Bytes())
dAliceHash.Write(dh_Alice_poit_x)
dAlice := dAliceHash.Sum(nil)
dAliceBN := hashToModInt(dAlice)
// c0, c1, c2
f0 := big.NewInt(0)
f0.Mul(privOwnerKey.D, f0.ModInverse(dAliceBN, baseN)).Mod(f0, baseN)
kFrags := make([]*KFrag, numSplit)
if numSplit == 1 {
id := getRandomInt(baseN)
kFrags[0] = &KFrag{Random: id.String(), Value: f0.String(), PrecurPub: precurPub}
} else {
coeffs := makeShamirPolyCoeff(threshold)
coeffs = append(coeffs, f0)
// rk[i] = f2*id^2 + f1*id + f0
for i, _ := range kFrags {
id := getRandomInt(baseN)
dShareHash, err := blake2b.New256(precursor.X.Bytes())
if err != nil {
fmt.Errorf("Generate precursor Key err", err)
return nil, err
}
dShareHash.Write(pubRecipientKey.X.Bytes())
dShareHash.Write(dh_Alice_poit_x)
dShareHash.Write(id.Bytes())
share := hashToModInt(dShareHash.Sum(nil))
rk := hornerPolyEval(coeffs, share)
kFrags[i] = &KFrag{Random: id.String(), Value: rk.String(), PrecurPub: precurPub}
}
}
return kFrags, nil
}
func AssembleReencryptFragment(privRecipient []byte, reKeyFrags []*ReKeyFrag) ([]byte, error) {
privRecipientKey := crypto.PrivateFromByte(privRecipient)
precursor, err := types.FromHex(reKeyFrags[0].PrecurPub)
if err != nil {
fmt.Errorf("FromHex", err)
return nil, err
}
precursorPubKey := crypto.PublicFromByte(precursor)
dh_Bob_poit_x := types.ECDH(privRecipientKey, precursorPubKey)
dBobHash, err := blake2b.New256(precursorPubKey.X.Bytes())
if err != nil {
fmt.Errorf("Generate precursor Key err", err)
return nil, err
}
dBobHash.Write(privRecipientKey.X.Bytes())
dBobHash.Write(dh_Bob_poit_x)
dhBob := dBobHash.Sum(nil)
dhBobBN := hashToModInt(dhBob)
var result *EccPoit
if len(reKeyFrags) == 1 {
rPoint, err := NewEccPoint(reKeyFrags[0].ReKeyR)
if err != nil {
fmt.Errorf("get reKeyRByte err", err)
return nil, err
}
uPoint, err := NewEccPoint(reKeyFrags[0].ReKeyU)
if err != nil {
fmt.Errorf("get reKeyRByte err", err)
return nil, err
}
result = rPoint.Add(uPoint).MulInt(dhBobBN)
} else {
var eFinal, vFinal *EccPoit
ids := make([]*big.Int, len(reKeyFrags))
for x, _ := range ids {
xs, err := blake2b.New256(precursorPubKey.X.Bytes())
if err != nil {
fmt.Errorf("Generate precursor Key err", err)
return nil, err
}
xs.Write(privRecipientKey.X.Bytes())
xs.Write(dh_Bob_poit_x)
random, ret := new(big.Int).SetString(reKeyFrags[x].Random, 10)
if !ret {
fmt.Errorf("AssembleReencryptFragment.get value int",)
return nil, errors.New("get big int value from keyFragment failed")
}
xs.Write(random.Bytes())
ids[x] = hashToModInt(xs.Sum(nil))
}
for i, id := range ids {
lambda := calcLambdaCoeff(id, ids)
if lambda == nil {
continue
}
rPoint, err := NewEccPoint(reKeyFrags[i].ReKeyR)
if err != nil {
fmt.Errorf("get reKeyRByte err", err)
return nil, err
}
uPoint, err := NewEccPoint(reKeyFrags[i].ReKeyU)
if err != nil {
fmt.Errorf("get reKeyRByte err", err)
return nil, err
}
e := rPoint.MulInt(lambda)
v := uPoint.MulInt(lambda)
eFinal = e.Add(eFinal)
vFinal = v.Add(vFinal)
}
result = eFinal.Add(vFinal).MulInt(dhBobBN)
}
share_key := crypto.KDF(result.ToPublicKey().SerializeCompressed(), 32)
return share_key, nil
}
\ No newline at end of file
sdk/proto/create_protobuf.sh deleted 100644 → 0
View file @ 58871f6c
#!/bin/sh
protoc --go_out=plugins=grpc:../types/ ./*.proto --proto_path=.
sdk/proto/sdk.proto deleted 100644 → 0
View file @ 58871f6c
syntax = "proto3";
package types;
message Transaction {
bytes execer = 1;
bytes payload = 2;
Signature signature = 3;
int64 fee = 4;
int64 expire = 5;
//随机ID，可以防止payload 相同的时候，交易重复
int64 nonce = 6;
//对方地址，如果没有对方地址，可以为空
string to = 7;
int32 groupCount = 8;
bytes header = 9;
bytes next = 10;
}
message Signature {
int32 ty = 1;
bytes pubkey = 2;
//当ty为5时，格式应该用RingSignature去解析
bytes signature = 3;
}
sdk/transaction.go deleted 100644 → 0
View file @ 58871f6c
package sdk
import (
"errors"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
. "gitlab.33.cn/pengjun/reencrypt/sdk/types"
)
func Sign(tx *Transaction, privateKey []byte, signType string) (*Transaction, error) {
if signType == "" {
signType = crypto.SECP256K1
}
tx.Signature = nil
if signType == crypto.SECP256K1 {
pub := crypto.PubKeyFromPrivate(privateKey)
data := Encode(tx)
signature := crypto.Sign(data, privateKey)
tx.Signature = &Signature{
Ty: 1,
Pubkey: pub,
Signature: signature,
}
} else if signType == crypto.SM2 {
// TODO
} else if signType == crypto.ED25519 {
// TODO
} else {
return nil, errors.New("sign type not support")
}
return tx, nil
}
func cloneTx(tx *Transaction) *Transaction {
copytx := &Transaction{}
copytx.Execer = tx.Execer
copytx.Payload = tx.Payload
copytx.Signature = tx.Signature
copytx.Fee = tx.Fee
copytx.Expire = tx.Expire
copytx.Nonce = tx.Nonce
copytx.To = tx.To
copytx.GroupCount = tx.GroupCount
copytx.Header = tx.Header
copytx.Next = tx.Next
return copytx
}
func Hash(tx *Transaction) []byte {
copytx := cloneTx(tx)
copytx.Signature = nil
copytx.Header = nil
data := Encode(copytx)
return crypto.Sha256(data)
}
\ No newline at end of file
sdk/types/sdk.pb.go deleted 100644 → 0
View file @ 58871f6c
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: sdk.proto
package types
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type Transaction struct {
Execer []byte `protobuf:"bytes,1,opt,name=execer,proto3" json:"execer,omitempty"`
Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
Signature *Signature `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
Fee int64 `protobuf:"varint,4,opt,name=fee,proto3" json:"fee,omitempty"`
Expire int64 `protobuf:"varint,5,opt,name=expire,proto3" json:"expire,omitempty"`
//随机ID，可以防止payload 相同的时候，交易重复
Nonce int64 `protobuf:"varint,6,opt,name=nonce,proto3" json:"nonce,omitempty"`
//对方地址，如果没有对方地址，可以为空
To string `protobuf:"bytes,7,opt,name=to,proto3" json:"to,omitempty"`
GroupCount int32 `protobuf:"varint,8,opt,name=groupCount,proto3" json:"groupCount,omitempty"`
Header []byte `protobuf:"bytes,9,opt,name=header,proto3" json:"header,omitempty"`
Next []byte `protobuf:"bytes,10,opt,name=next,proto3" json:"next,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Transaction) Reset() { *m = Transaction{} }
func (m *Transaction) String() string { return proto.CompactTextString(m) }
func (*Transaction) ProtoMessage() {}
func (*Transaction) Descriptor() ([]byte, []int) {
return fileDescriptor_70decb0fb6f436df, []int{0}
}
func (m *Transaction) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Transaction.Unmarshal(m, b)
}
func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Transaction.Marshal(b, m, deterministic)
}
func (m *Transaction) XXX_Merge(src proto.Message) {
xxx_messageInfo_Transaction.Merge(m, src)
}
func (m *Transaction) XXX_Size() int {
return xxx_messageInfo_Transaction.Size(m)
}
func (m *Transaction) XXX_DiscardUnknown() {
xxx_messageInfo_Transaction.DiscardUnknown(m)
}
var xxx_messageInfo_Transaction proto.InternalMessageInfo
func (m *Transaction) GetExecer() []byte {
if m != nil {
return m.Execer
}
return nil
}
func (m *Transaction) GetPayload() []byte {
if m != nil {
return m.Payload
}
return nil
}
func (m *Transaction) GetSignature() *Signature {
if m != nil {
return m.Signature
}
return nil
}
func (m *Transaction) GetFee() int64 {
if m != nil {
return m.Fee
}
return 0
}
func (m *Transaction) GetExpire() int64 {
if m != nil {
return m.Expire
}
return 0
}
func (m *Transaction) GetNonce() int64 {
if m != nil {
return m.Nonce
}
return 0
}
func (m *Transaction) GetTo() string {
if m != nil {
return m.To
}
return ""
}
func (m *Transaction) GetGroupCount() int32 {
if m != nil {
return m.GroupCount
}
return 0
}
func (m *Transaction) GetHeader() []byte {
if m != nil {
return m.Header
}
return nil
}
func (m *Transaction) GetNext() []byte {
if m != nil {
return m.Next
}
return nil
}
type Signature struct {
Ty int32 `protobuf:"varint,1,opt,name=ty,proto3" json:"ty,omitempty"`
Pubkey []byte `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
//当ty为5时，格式应该用RingSignature去解析
Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Signature) Reset() { *m = Signature{} }
func (m *Signature) String() string { return proto.CompactTextString(m) }
func (*Signature) ProtoMessage() {}
func (*Signature) Descriptor() ([]byte, []int) {
return fileDescriptor_70decb0fb6f436df, []int{1}
}
func (m *Signature) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Signature.Unmarshal(m, b)
}
func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Signature.Marshal(b, m, deterministic)
}
func (m *Signature) XXX_Merge(src proto.Message) {
xxx_messageInfo_Signature.Merge(m, src)
}
func (m *Signature) XXX_Size() int {
return xxx_messageInfo_Signature.Size(m)
}
func (m *Signature) XXX_DiscardUnknown() {
xxx_messageInfo_Signature.DiscardUnknown(m)
}
var xxx_messageInfo_Signature proto.InternalMessageInfo
func (m *Signature) GetTy() int32 {
if m != nil {
return m.Ty
}
return 0
}
func (m *Signature) GetPubkey() []byte {
if m != nil {
return m.Pubkey
}
return nil
}
func (m *Signature) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func init() {
proto.RegisterType((*Transaction)(nil), "types.Transaction")
proto.RegisterType((*Signature)(nil), "types.Signature")
}
func init() {
proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df)
}
var fileDescriptor_70decb0fb6f436df = []byte{
// 255 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0x41, 0x4e, 0xc3, 0x30,
0x10, 0x45, 0xe5, 0xa4, 0x49, 0xc9, 0xb4, 0x42, 0xd5, 0x08, 0xa1, 0x59, 0x20, 0x14, 0x75, 0xe5,
0x55, 0x16, 0x70, 0x04, 0x4e, 0x80, 0xe1, 0x02, 0x6e, 0x32, 0x94, 0xa8, 0xc8, 0xb6, 0x1c, 0x47,
0xaa, 0xcf, 0xc0, 0xa5, 0x51, 0x9c, 0x14, 0x2a, 0x76, 0xf3, 0x5e, 0xa2, 0x3f, 0x9e, 0x0f, 0xd5,
0xd0, 0x9d, 0x1a, 0xe7, 0x6d, 0xb0, 0x58, 0x84, 0xe8, 0x78, 0xd8, 0x7f, 0x67, 0xb0, 0x79, 0xf7,
0xda, 0x0c, 0xba, 0x0d, 0xbd, 0x35, 0x78, 0x0f, 0x25, 0x9f, 0xb9, 0x65, 0x4f, 0xa2, 0x16, 0x72,
0xab, 0x16, 0x42, 0x82, 0xb5, 0xd3, 0xf1, 0xcb, 0xea, 0x8e, 0xb2, 0xf4, 0xe1, 0x82, 0xd8, 0x40,
0x35, 0xf4, 0x47, 0xa3, 0xc3, 0xe8, 0x99, 0xf2, 0x5a, 0xc8, 0xcd, 0xd3, 0xae, 0x49, 0xe1, 0xcd,
0xdb, 0xc5, 0xab, 0xbf, 0x5f, 0x70, 0x07, 0xf9, 0x07, 0x33, 0xad, 0x6a, 0x21, 0x73, 0x35, 0x8d,
0xf3, 0x4e, 0xd7, 0x7b, 0xa6, 0x22, 0xc9, 0x85, 0xf0, 0x0e, 0x0a, 0x63, 0x4d, 0xcb, 0x54, 0x26,
0x3d, 0x03, 0xde, 0x42, 0x16, 0x2c, 0xad, 0x6b, 0x21, 0x2b, 0x95, 0x05, 0x8b, 0x8f, 0x00, 0x47,
0x6f, 0x47, 0xf7, 0x62, 0x47, 0x13, 0xe8, 0xa6, 0x16, 0xb2, 0x50, 0x57, 0x66, 0x4a, 0xff, 0x64,
0xdd, 0xb1, 0xa7, 0x6a, 0xbe, 0x68, 0x26, 0x44, 0x58, 0x19, 0x3e, 0x07, 0x82, 0x64, 0xd3, 0xbc,
0x7f, 0x85, 0xea, 0xf7, 0xcd, 0x69, 0x51, 0x4c, 0x35, 0x14, 0x2a, 0x0b, 0x71, 0x0a, 0x72, 0xe3,
0xe1, 0xc4, 0x71, 0x69, 0x60, 0x21, 0x7c, 0xf8, 0x5f, 0xc0, 0xf6, 0xea, 0xdc, 0x43, 0x99, 0xea,
0x7e, 0xfe, 0x09, 0x00, 0x00, 0xff, 0xff, 0x21, 0x50, 0x6b, 0x04, 0x7b, 0x01, 0x00, 0x00,
}
sdk/types/utils.go deleted 100644 → 0
View file @ 58871f6c
package types
import (
"encoding/hex"
secp256k1 "github.com/btcsuite/btcd/btcec"
"github.com/golang/protobuf/proto"
)
//exec type
const (
ExecErr = 0
ExecPack = 1
ExecOk = 2
)
//FromHex hex -> []byte
func FromHex(s string) ([]byte, error) {
if len(s) > 1 {
if s[0:2] == "0x" || s[0:2] == "0X" {
s = s[2:]
}
if len(s)%2 == 1 {
s = "0" + s
}
return hex.DecodeString(s)
}
return []byte{}, nil
}
//ToHex []byte -> hex
func ToHex(b []byte) string {
hex := hex.EncodeToString(b)
// Prefer output of "0x0" instead of "0x"
if len(hex) == 0 {
return ""
}
return hex
}
//ToHex []byte -> hex
func ToHexPrefix(b []byte) string {
hex := hex.EncodeToString(b)
// Prefer output of "0x0" instead of "0x"
if len(hex) == 0 {
return ""
}
return "0x" + hex
}
//Encode 编码
func Encode(data proto.Message) []byte {
b, err := proto.Marshal(data)
if err != nil {
panic(err)
}
return b
}
//Decode 解码
func Decode(data []byte, msg proto.Message) error {
return proto.Unmarshal(data, msg)
}
// ECDH Calculate a shared secret using elliptic curve Diffie-Hellman
func ECDH(priv *secp256k1.PrivateKey, pub *secp256k1.PublicKey) []byte {
ecKey := &secp256k1.PublicKey{}
ecKey.X, ecKey.Y = secp256k1.S256().ScalarMult(pub.X, pub.Y, priv.D.Bytes())
return ecKey.SerializeCompressed()
}
\ No newline at end of file
server/preclient.go
View file @ 22dce94c
...@@ -8,9 +8,9 @@ import ( ...@@ -8,9 +8,9 @@ import (
"encoding/hex" "encoding/hex"
"errors" "errors"
"fmt" "fmt"
"gitlab.33.cn/pengjun/reencrypt/sdk" "github.com/33cn/chain33-sdk-go"
"gitlab.33.cn/pengjun/reencrypt/sdk/client" "github.com/33cn/chain33-sdk-go/client"
"gitlab.33.cn/pengjun/reencrypt/sdk/types" "github.com/33cn/chain33-sdk-go/types"
"time" "time"
) )
......
server/rpchandler.go
View file @ 22dce94c
...@@ -2,11 +2,11 @@ package server ...@@ -2,11 +2,11 @@ package server
import ( import (
"errors" "errors"
"github.com/33cn/chain33-sdk-go/crypto"
"github.com/33cn/chain33-sdk-go/types"
secp256k1 "github.com/btcsuite/btcd/btcec" secp256k1 "github.com/btcsuite/btcd/btcec"
"github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb"
"gitlab.33.cn/pengjun/reencrypt/common" "gitlab.33.cn/pengjun/reencrypt/common"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
"gitlab.33.cn/pengjun/reencrypt/sdk/types"
"math/big" "math/big"
"time" "time"
) )
......
server/server.go
View file @ 22dce94c
...@@ -9,8 +9,8 @@ package server ...@@ -9,8 +9,8 @@ package server
import ( import (
"bytes" "bytes"
"fmt" "fmt"
"gitlab.33.cn/pengjun/reencrypt/sdk/client" "github.com/33cn/chain33-sdk-go/client"
"gitlab.33.cn/pengjun/reencrypt/sdk/types" "github.com/33cn/chain33-sdk-go/types"
log "github.com/inconshreveable/log15" log "github.com/inconshreveable/log15"
"github.com/rs/cors" "github.com/rs/cors"
...@@ -209,7 +209,9 @@ func CheckExpireRoutine(db *leveldb.DB) { ...@@ -209,7 +209,9 @@ func CheckExpireRoutine(db *leveldb.DB) {
if keyFragment.Expire != 0 && keyFragment.Expire <= now { if keyFragment.Expire != 0 && keyFragment.Expire <= now {
rlog.Info("Key Fragment Expired", "key", string(iter.Key()), "expire", keyFragment.Expire) rlog.Info("Key Fragment Expired", "key", string(iter.Key()), "expire", keyFragment.Expire)
remove = append(remove, iter.Key()) tmpKey := make([]byte, len(iter.Key()))
copy(tmpKey, iter.Key())
remove = append(remove, tmpKey)
} }
} }
......
server/server_test.go
View file @ 22dce94c
...@@ -2,11 +2,11 @@ package server ...@@ -2,11 +2,11 @@ package server
import ( import (
"fmt" "fmt"
"github.com/33cn/chain33-sdk-go"
"github.com/33cn/chain33-sdk-go/crypto"
"github.com/33cn/chain33-sdk-go/types"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"gitlab.33.cn/pengjun/reencrypt/common" "gitlab.33.cn/pengjun/reencrypt/common"
"gitlab.33.cn/pengjun/reencrypt/sdk"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
"gitlab.33.cn/pengjun/reencrypt/sdk/types"
"testing" "testing"
) )
......
tool/cli.go
View file @ 22dce94c
...@@ -2,12 +2,12 @@ package main ...@@ -2,12 +2,12 @@ package main
import ( import (
"fmt" "fmt"
"github.com/33cn/chain33-sdk-go"
client "github.com/33cn/chain33-sdk-go/client"
"github.com/33cn/chain33-sdk-go/crypto"
"github.com/33cn/chain33-sdk-go/types"
"github.com/spf13/cobra" "github.com/spf13/cobra"
"gitlab.33.cn/pengjun/reencrypt/common" "gitlab.33.cn/pengjun/reencrypt/common"
"gitlab.33.cn/pengjun/reencrypt/sdk"
client "gitlab.33.cn/pengjun/reencrypt/sdk/client"
"gitlab.33.cn/pengjun/reencrypt/sdk/crypto"
"gitlab.33.cn/pengjun/reencrypt/sdk/types"
"os" "os"
) )
...@@ -71,13 +71,12 @@ func ownerEncrypt(cmd *cobra.Command, args []string) { ...@@ -71,13 +71,12 @@ func ownerEncrypt(cmd *cobra.Command, args []string) {
rpcLaddr = "http://localhost:11801" rpcLaddr = "http://localhost:11801"
} }
driver := crypto.NewSignDriver(crypto.SECP256k1)
keybyte, err := types.FromHex(key) keybyte, err := types.FromHex(key)
if err != nil { if err != nil {
panic(err) panic(err)
} }
pubOwner := driver.PubKeyFromPrivate(keybyte) pubOwner := crypto.PubKeyFromPrivate(keybyte)
enKey, pub_r, pub_u := sdk.GenerateEncryptKey(pubOwner) enKey, pub_r, pub_u := sdk.GeneratePreEncryptKey(pubOwner)
cipher, err := crypto.AESCBCPKCS7Encrypt(enKey[1:], []byte(msg)) cipher, err := crypto.AESCBCPKCS7Encrypt(enKey[1:], []byte(msg))
if err != nil { if err != nil {
panic(err) panic(err)
...@@ -102,7 +101,7 @@ func ownerEncrypt(cmd *cobra.Command, args []string) { ...@@ -102,7 +101,7 @@ func ownerEncrypt(cmd *cobra.Command, args []string) {
if err != nil { if err != nil {
panic(err) panic(err)
} }
dhproof := types.ECDH(crypto.PrivateECDSAFromByte(keybyte), crypto.PublicECDSAFromByte(serverPub)) dhproof := types.ECDH(crypto.PrivateFromByte(keybyte), crypto.PublicFromByte(serverPub))
param := &common.ReqSendKeyFragment{ param := &common.ReqSendKeyFragment{
PubOwner: types.ToHex(pubOwner), PubOwner: types.ToHex(pubOwner),
PubRecipient: pub, PubRecipient: pub,
...@@ -142,12 +141,11 @@ func recipientDecrypt(cmd *cobra.Command, args []string) { ...@@ -142,12 +141,11 @@ func recipientDecrypt(cmd *cobra.Command, args []string) {
if err != nil { if err != nil {
panic(err) panic(err)
} }
driver := crypto.NewSignDriver(crypto.SECP256k1)
keybyte, err := types.FromHex(key) keybyte, err := types.FromHex(key)
if err != nil { if err != nil {
panic(err) panic(err)
} }
pubRecipient := driver.PubKeyFromPrivate(keybyte) pubRecipient := crypto.PubKeyFromPrivate(keybyte)
param := &common.ReqReeencryptParam{ param := &common.ReqReeencryptParam{
PubOwner: pub, PubOwner: pub,
PubRecipient: types.ToHex(pubRecipient), PubRecipient: types.ToHex(pubRecipient),
...@@ -189,12 +187,11 @@ func addAccountInfoFlags(cmd *cobra.Command) { ...@@ -189,12 +187,11 @@ func addAccountInfoFlags(cmd *cobra.Command) {
func accountInfo(cmd *cobra.Command, args []string) { func accountInfo(cmd *cobra.Command, args []string) {
key, _ := cmd.Flags().GetString("key") key, _ := cmd.Flags().GetString("key")
driver := crypto.NewSignDriver(crypto.SECP256k1)
keybyte, err := types.FromHex(key) keybyte, err := types.FromHex(key)
if err != nil { if err != nil {
panic(err) panic(err)
} }
pubKey := driver.PubKeyFromPrivate(keybyte) pubKey := crypto.PubKeyFromPrivate(keybyte)
fmt.Println("public key:", types.ToHex(pubKey)) fmt.Println("public key:", types.ToHex(pubKey))
addr, err := crypto.PubKeyToAddress(pubKey) addr, err := crypto.PubKeyToAddress(pubKey)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment