Skip to content

P
plugin
Commit 2f689e0e authored by sanghg's avatar sanghg Committed by vipwzw
Browse files
Options

issues #55

补充crypto的测试用例
parent 76169510
Hide whitespace changes
Inline Side-by-side
Showing with 151 additions and 179 deletions
plugin/dapp/privacy/crypto/privacy_test.go
View file @ 2f689e0e
......@@ -4,182 +4,107 @@
package privacy
/*
func TestPrivacyOnetimeKey(t *testing.T) {
t.Logf("Begin to do TestPrivacyOnetimeKey\n")
priKey := "BC7621CE84D3D67851326C360B518DB5"
pribyte, _ := common.Hex2Bytes(priKey)
priaddr32 := (*[32]byte)(unsafe.Pointer(&pribyte[0]))
privacyInfo, err := NewPrivacyWithPrivKey(priaddr32)
if err != nil {
t.Errorf("Failed to NewPrivacyWithPrivKey", "err info is", err)
return
}
t.Logf("viewprikey:%X, viewpubkey:%X\n", privacyInfo.ViewPrivKey, privacyInfo.ViewPubkey)
t.Logf("spendprikey:%X, spendpubkey:%X\n", privacyInfo.SpendPrivKey, privacyInfo.SpendPubkey)
viewPublic := (*[32]byte)(unsafe.Pointer(&privacyInfo.ViewPubkey[0]))
spendPublic := (*[32]byte)(unsafe.Pointer(&privacyInfo.SpendPubkey[0]))
pubkeyOnetime, txPublicKey, err := GenerateOneTimeAddr(viewPublic, spendPublic)
if err != nil {
t.Errorf("Failed to GenerateOneTimeAddr")
return
}
t.Logf("The generated pubkeyOnetime: %X \n", pubkeyOnetime[:])
t.Logf("The generated txPublicKey: %X \n", txPublicKey[:])
onetimePriKey, err := RecoverOnetimePriKey(txPublicKey[:], privacyInfo.ViewPrivKey, privacyInfo.SpendPrivKey)
if err != nil {
t.Errorf("Failed to RecoverOnetimePriKey")
return
}
t.Logf("The recovered one time privicy key is:%X", onetimePriKey.Bytes())
recoverPub := onetimePriKey.PubKey().Bytes()[:]
originPub := pubkeyOnetime[:]
t.Logf("****￥￥￥*****The recoverPub key is:%X", recoverPub)
t.Logf("****￥￥￥*****The originPub key is:%X", originPub)
if !bytes.Equal(recoverPub, originPub) {
t.Failed()
t.Errorf("recoverPub is not equal to originPub")
return
} else {
t.Logf("Yea!!! Succeed to do the TestPrivacyOnetimeKey.")
}
t.Logf("End to do TestPrivacyOnetimeKey\n")
}
*/
/*
// TODO: 需要增加隐私签名的UT
func TestPrivacySignWithFixInput(t *testing.T) {
prislice, _ := common.Hex2Bytes("9E0ED368F3DDAA9F472FE7F319F866227A74A2EF16B43410CEB3CE7C1BAAEB09")
var onetimePriKey PrivKeyPrivacy
copy(onetimePriKey[:], prislice)
recoverPub := onetimePriKey.PubKey().Bytes()[:]
data := []byte("Yea!!! Succeed to do the TestPrivacyOnetimeKey")
sig := onetimePriKey.Sign(data)
sign := &types.Signature{
Ty: 4,
Pubkey: recoverPub,
Signature: sig.Bytes(),
}
c := &oneTimeEd25519{}
pub, err := c.PubKeyFromBytes(sign.Pubkey)
if err != nil {
t.Failed()
t.Errorf("Failed to PubKeyFromBytes")
return
}
signbytes, err := c.SignatureFromBytes(sign.Signature)
if err != nil {
t.Failed()
t.Errorf("Failed to SignatureFromBytes")
return
}
if pub.VerifyBytes(data, signbytes) {
t.Logf("Yea!!! Succeed to pass CheckSign.")
} else {
t.Failed()
t.Errorf("Fail the CheckSign")
return
}
t.Logf("End to do TestPrivacyOnetimeKey\n")
}
*/
//func TestPrivacySign(t *testing.T) {
// t.Logf("Begin to do TestPrivacyOnetimeKey\n")
//
// priKey := "BC7621CE84D3D67851326C360B518DB5"
// pribyte, _ := common.Hex2Bytes(priKey)
// priaddr32 := (*[32]byte)(unsafe.Pointer(&pribyte[0]))
// privacyInfo, err := NewPrivacyWithPrivKey(priaddr32)
// if err != nil {
// t.Errorf("Failed to NewPrivacyWithPrivKey", "err info is", err)
// return
// }
//
// t.Logf("viewprikey:%X, viewpubkey:%X\n", privacyInfo.ViewPrivKey, privacyInfo.ViewPubkey)
// t.Logf("spendprikey:%X, spendpubkey:%X\n", privacyInfo.SpendPrivKey, privacyInfo.SpendPubkey)
//
// viewPublic := (*[32]byte)(unsafe.Pointer(&privacyInfo.ViewPubkey[0]))
// spendPublic := (*[32]byte)(unsafe.Pointer(&privacyInfo.SpendPubkey[0]))
// pubkeyOnetime, txPublicKey, err := privacyInfo.GenerateOneTimeAddr(viewPublic, spendPublic)
// if err != nil {
// t.Errorf("Failed to GenerateOneTimeAddr")
// return
// }
// t.Logf("The generated pubkeyOnetime: %X \n", pubkeyOnetime[:])
// t.Logf("The generated txPublicKey: %X \n", txPublicKey[:])
//
// onetimePriKey, err := privacyInfo.RecoverOnetimePriKey(txPublicKey[:], privacyInfo.ViewPrivKey, privacyInfo.SpendPrivKey)
// if err != nil {
// t.Errorf("Failed to RecoverOnetimePriKey")
// return
// }
// t.Logf("The recovered one time privicy key is:%X", onetimePriKey.Bytes())
//
// recoverPub := onetimePriKey.PubKey().Bytes()[:]
// originPub := pubkeyOnetime[:]
// t.Logf("****￥￥￥*****The recoverPub key is:%X", recoverPub)
// t.Logf("****￥￥￥*****The originPub key is:%X", originPub)
//
//
// if !bytes.Equal(recoverPub, originPub) {
// t.Failed()
// t.Errorf("recoverPub is not equal to originPub")
// return
//
// } else {
// t.Logf("Yea!!! Succeed to do the TestPrivacyOnetimeKey.")
// }
// data := []byte("Yea!!! Succeed to do the TestPrivacyOnetimeKey")
// sig := onetimePriKey.Sign(data)
// sign := &types.Signature{
// Ty: 4,
// Pubkey: recoverPub,
// Signature:sig.Bytes(),
// }
//
// c := &oneTimeEd25519{}
//
// pub, err := c.PubKeyFromBytes(sign.Pubkey)
// if err != nil {
// t.Failed()
// t.Errorf("Failed to PubKeyFromBytes")
// return
// }
// signbytes, err := c.SignatureFromBytes(sign.Signature)
// if err != nil {
// t.Failed()
// t.Errorf("Failed to SignatureFromBytes")
// return
// }
//
// if pub.VerifyBytes(data, signbytes) {
// t.Logf("Yea!!! Succeed to pass CheckSign.")
//
// } else {
// t.Failed()
// t.Errorf("Fail the CheckSign")
// return
//
// }
//
// t.Logf("End to do TestPrivacyOnetimeKey\n")
//}
import (
"testing"
"github.com/33cn/chain33/common/crypto"
"github.com/33cn/chain33/common/log"
"github.com/stretchr/testify/assert"
)
type pubKeyMock struct {
}
func (*pubKeyMock) Bytes() []byte {
return []byte("pubKeyMock")
}
func (*pubKeyMock) KeyString() string {
return "pubKeyMock"
}
func (*pubKeyMock) VerifyBytes(msg []byte, sig crypto.Signature) bool {
return true
}
func (*pubKeyMock) Equals(crypto.PubKey) bool {
return true
}
type signatureMock struct {
}
func (*signatureMock) Bytes() []byte {
return []byte("signatureMock")
}
func (*signatureMock) IsZero() bool {
return true
}
func (*signatureMock) String() string {
return "signatureMock"
}
func (*signatureMock) Equals(crypto.Signature) bool {
return true
}
type privKeyMock struct {
}
func (mock *privKeyMock) Bytes() []byte {
return []byte("1234")
}
func (mock *privKeyMock) Sign(msg []byte) crypto.Signature {
return &signatureMock{}
}
func (mock *privKeyMock) PubKey() crypto.PubKey {
return &pubKeyMock{}
}
func (mock *privKeyMock) Equals(crypto.PrivKey) bool {
return true
}
func init() {
log.SetLogLevel("crit")
}
func TestNewPrivacy(t *testing.T) {
test_NewPrivacy(t)
test_NewPrivacyWithPrivKey(t)
test_GenerateOneTimeAddr(t)
test_RecoverOnetimePriKey(t)
}
func test_RecoverOnetimePriKey(t *testing.T) {
R := []byte("1234")
pkm := privKeyMock{}
privKey, err := RecoverOnetimePriKey(R, &pkm, &pkm, 0)
assert.Nil(t, err)
assert.NotNil(t, privKey)
}
func test_GenerateOneTimeAddr(t *testing.T) {
bytes1 := [32]byte{}
pkot, err := GenerateOneTimeAddr(&bytes1, &bytes1, &bytes1, 0)
assert.Nil(t, err)
assert.NotNil(t, pkot)
}
func test_NewPrivacy(t *testing.T) {
p := NewPrivacy()
assert.NotNil(t, p)
}
func test_NewPrivacyWithPrivKey(t *testing.T) {
bytes1 := [KeyLen32]byte{}
p, err := NewPrivacyWithPrivKey(&bytes1)
assert.Nil(t, err)
assert.NotNil(t, p)
}
plugin/dapp/privacy/crypto/ring_signature_test.go
View file @ 2f689e0e
......@@ -6,8 +6,11 @@ package privacy
import (
"bytes"
"encoding/hex"
"testing"
"github.com/stretchr/testify/assert"
"math/rand"
"time"
......@@ -458,3 +461,47 @@ func Benchmark_RingSignatureAllStep(b *testing.B) {
}
}
func TestRingSignatureCrypto(t *testing.T) {
{
sig := &RingSignature{}
bytes := hex.EncodeToString(sig.Bytes())
assert.Equal(t, bytes, "")
assert.Equal(t, true, sig.IsZero())
assert.Equal(t, sig.String(), "")
assert.Equal(t, sig.Equals(sig), true)
}
{
key := &RingSignPrivateKey{}
bytes := hex.EncodeToString(key.Bytes())
assert.Equal(t, bytes, "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
assert.NotNil(t, key.PubKey())
assert.Equal(t, key.Equals(key), true)
sig := key.Sign([]byte("Messages"))
assert.NotNil(t, sig)
}
{
ringsig := &RingSignature{}
key := &RingSignPublicKey{}
bytes := hex.EncodeToString(key.Bytes())
assert.Equal(t, bytes, "0000000000000000000000000000000000000000000000000000000000000000")
assert.Equal(t, key.KeyString(), "0000000000000000000000000000000000000000000000000000000000000000")
assert.Equal(t, key.Equals(key), true)
assert.Equal(t, key.VerifyBytes([]byte("Message"), ringsig), false)
}
{
ring := &RingSignED25519{}
privKey, err := ring.GenKey()
assert.NoError(t, err)
assert.NotNil(t, privKey)
privKey, err = ring.PrivKeyFromBytes([]byte("00000000000000000000000000000000"))
assert.NoError(t, err)
assert.NotNil(t, privKey)
pubKey, err := ring.PubKeyFromBytes([]byte("00000000000000000000000000000000"))
assert.NoError(t, err)
assert.NotNil(t, pubKey)
sig, err := ring.SignatureFromBytes([]byte("00000000000000000000000000000000"))
assert.NoError(t, err)
assert.NotNil(t, sig)
}
}
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