forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-26 14:46:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #3224 from gluk256/04

Browse source 
whisper: refactoring
This commit is contained in:
Viktor Trón 2016-11-22 21:49:09 +01:00 committed by GitHub
commit 97bec5e2d9
10 changed files with 709 additions and 503 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
whisper/shhapi/api.go
View file

@ -155,7 +155,7 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber,
}
filter := whisperv5.Filter{
Src: crypto.ToECDSAPub(args.From),
Src: crypto.ToECDSAPub(common.FromHex(args.From)),
KeySym: api.whisper.GetSymKey(args.KeyName),
PoW: args.PoW,
Messages: make(map[common.Hash]*whisperv5.ReceivedMessage),
@ -195,7 +195,7 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber,
}
if len(args.To) > 0 {
dst := crypto.ToECDSAPub(args.To)
dst := crypto.ToECDSAPub(common.FromHex(args.To))
if !whisperv5.ValidatePublicKey(dst) {
info := "NewFilter: Invalid 'To' address"
glog.V(logger.Error).Infof(info)
@ -259,7 +259,7 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
params := whisperv5.MessageParams{
TTL: args.TTL,
Dst: crypto.ToECDSAPub(args.To),
Dst: crypto.ToECDSAPub(common.FromHex(args.To)),
KeySym: api.whisper.GetSymKey(args.KeyName),
Topic: args.Topic,
Payload: args.Payload,
@ -269,7 +269,7 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
}
if len(args.From) > 0 {
pub := crypto.ToECDSAPub(args.From)
pub := crypto.ToECDSAPub(common.FromHex(args.From))
if !whisperv5.ValidatePublicKey(pub) {
info := "Post: Invalid 'From' address"
glog.V(logger.Error).Infof(info)
@ -321,13 +321,13 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
return errors.New(info)
}
if len(args.To) == 0 && len(args.KeyName) == 0 {
if len(args.To) == 0 && len(params.KeySym) == 0 {
info := "Post: message must be encrypted either symmetrically or asymmetrically"
glog.V(logger.Error).Infof(info)
return errors.New(info)
}
if len(args.To) != 0 && len(args.KeyName) != 0 {
if len(args.To) != 0 && len(params.KeySym) != 0 {
info := "Post: ambigous encryption method requested"
glog.V(logger.Error).Infof(info)
return errors.New(info)
@ -367,32 +367,32 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
}
type PostArgs struct {
TTL uint32 `json:"ttl"`
From rpc.HexBytes `json:"from"`
To rpc.HexBytes `json:"to"`
KeyName string `json:"keyname"`
Topic whisperv5.TopicType `json:"topic"`
Padding rpc.HexBytes `json:"padding"`
Payload rpc.HexBytes `json:"payload"`
WorkTime uint32 `json:"worktime"`
PoW float64 `json:"pow"`
FilterID int `json:"filter"`
PeerID rpc.HexBytes `json:"directP2P"`
TTL uint32
From string
To string
KeyName string
Topic whisperv5.TopicType
Padding rpc.HexBytes
Payload rpc.HexBytes
WorkTime uint32
PoW float64
FilterID int
PeerID rpc.HexBytes
}
func (args *PostArgs) UnmarshalJSON(data []byte) (err error) {
var obj struct {
TTL uint32 `json:"ttl"`
From rpc.HexBytes `json:"from"`
To rpc.HexBytes `json:"to"`
From string `json:"from"`
To string `json:"to"`
KeyName string `json:"keyname"`
Topic whisperv5.TopicType `json:"topic"`
Payload rpc.HexBytes `json:"payload"`
Padding rpc.HexBytes `json:"padding"`
WorkTime uint32 `json:"worktime"`
PoW float64 `json:"pow"`
FilterID rpc.HexBytes `json:"filter"`
PeerID rpc.HexBytes `json:"directP2P"`
FilterID rpc.HexBytes `json:"filterID"`
PeerID rpc.HexBytes `json:"peerID"`
}
if err := json.Unmarshal(data, &obj); err != nil {
@ -420,8 +420,8 @@ func (args *PostArgs) UnmarshalJSON(data []byte) (err error) {
}
type WhisperFilterArgs struct {
To []byte
From []byte
To string
From string
KeyName string
PoW float64
Topics []whisperv5.TopicType
@ -433,8 +433,8 @@ type WhisperFilterArgs struct {
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
// Unmarshal the JSON message and sanity check
var obj struct {
To rpc.HexBytes `json:"to"`
From rpc.HexBytes `json:"from"`
To string `json:"to"`
From string `json:"from"`
KeyName string `json:"keyname"`
PoW float64 `json:"pow"`
Topics []interface{} `json:"topics"`

496
whisper/shhapi/api_test.go
View file

@ -17,8 +17,11 @@
package shhapi
import (
"bytes"
"testing"
"time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/whisper/whisperv5"
)
@ -27,78 +30,64 @@ func TestBasic(x *testing.T) {
var id string = "test"
api := NewPublicWhisperAPI()
if api == nil {
x.Errorf("failed to create API.")
return
x.Fatalf("failed to create API.")
}
ver, err := api.Version()
if err != nil {
x.Errorf("failed generateFilter: %s.", err)
return
x.Fatalf("failed generateFilter: %s.", err)
}
if ver.Uint64() != whisperv5.ProtocolVersion {
x.Errorf("wrong version: %d.", ver.Uint64())
return
x.Fatalf("wrong version: %d.", ver.Uint64())
}
var hexnum rpc.HexNumber
mail := api.GetFilterChanges(hexnum)
if len(mail) != 0 {
x.Errorf("failed GetFilterChanges")
return
x.Fatalf("failed GetFilterChanges")
}
exist, err := api.HasIdentity(id)
if err != nil {
x.Errorf("failed 1 HasIdentity: %s.", err)
return
x.Fatalf("failed test case 1: %s.", err)
}
if exist {
x.Errorf("failed 2 HasIdentity: false positive.")
return
x.Fatalf("failed test case 2, HasIdentity: false positive.")
}
err = api.DeleteIdentity(id)
if err != nil {
x.Errorf("failed 3 DeleteIdentity: %s.", err)
return
x.Fatalf("failed test case 3: %s.", err)
}
pub, err := api.NewIdentity()
if err != nil {
x.Errorf("failed 4 NewIdentity: %s.", err)
return
x.Fatalf("failed test case 4: %s.", err)
}
if len(pub) == 0 {
x.Errorf("NewIdentity 5: empty")
return
x.Fatalf("test case 5, NewIdentity: empty")
}
exist, err = api.HasIdentity(pub)
if err != nil {
x.Errorf("failed 6 HasIdentity: %s.", err)
return
x.Fatalf("failed test case 6: %s.", err)
}
if !exist {
x.Errorf("failed 7 HasIdentity: false negative.")
return
x.Fatalf("failed test case 7, HasIdentity: false negative.")
}
err = api.DeleteIdentity(pub)
if err != nil {
x.Errorf("failed 8 DeleteIdentity: %s.", err)
return
x.Fatalf("failed 8 DeleteIdentity: %s.", err)
}
exist, err = api.HasIdentity(pub)
if err != nil {
x.Errorf("failed 9 HasIdentity: %s.", err)
return
x.Fatalf("failed test case 9: %s.", err)
}
if exist {
x.Errorf("failed 10 HasIdentity: false positive.")
return
x.Fatalf("failed test case 10, HasIdentity: false positive.")
}
id = "arbitrary text"
@ -106,65 +95,468 @@ func TestBasic(x *testing.T) {
exist, err = api.HasSymKey(id)
if err != nil {
x.Errorf("failed 11 HasSymKey: %s.", err)
return
x.Fatalf("failed test case 11: %s.", err)
}
if exist {
x.Errorf("failed 12 HasSymKey: false positive.")
return
x.Fatalf("failed test case 12, HasSymKey: false positive.")
}
err = api.GenerateSymKey(id)
if err != nil {
x.Errorf("failed 13 GenerateSymKey: %s.", err)
return
x.Fatalf("failed 13 GenerateSymKey: %s.", err)
}
exist, err = api.HasSymKey(id)
if err != nil {
x.Errorf("failed 14 HasSymKey: %s.", err)
return
x.Fatalf("failed test case 14: %s.", err)
}
if !exist {
x.Errorf("failed 15 HasSymKey: false negative.")
return
x.Fatalf("failed test case 15, HasSymKey: false negative.")
}
err = api.AddSymKey(id, []byte("some stuff here"))
if err == nil {
x.Errorf("failed 16 AddSymKey: %s.", err)
return
x.Fatalf("failed test case 16: %s.", err)
}
err = api.AddSymKey(id2, []byte("some stuff here"))
if err != nil {
x.Errorf("failed 17 AddSymKey: %s.", err)
return
x.Fatalf("failed test case 17: %s.", err)
}
exist, err = api.HasSymKey(id2)
if err != nil {
x.Errorf("failed 18 HasSymKey: %s.", err)
return
x.Fatalf("failed test case 18: %s.", err)
}
if !exist {
x.Errorf("failed 19 HasSymKey: false negative.")
return
x.Fatalf("failed test case 19, HasSymKey: false negative.")
}
err = api.DeleteSymKey(id)
if err != nil {
x.Errorf("failed 20 DeleteSymKey: %s.", err)
return
x.Fatalf("failed test case 20: %s.", err)
}
exist, err = api.HasSymKey(id)
if err != nil {
x.Errorf("failed 21 HasSymKey: %s.", err)
return
x.Fatalf("failed test case 21: %s.", err)
}
if exist {
x.Errorf("failed 22 HasSymKey: false positive.")
return
x.Fatalf("failed test case 22, HasSymKey: false positive.")
}
}
func TestUnmarshalFilterArgs(x *testing.T) {
s := []byte(`{
"to":"0x70c87d191324e6712a591f304b4eedef6ad9bb9d",
"from":"0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
"keyname":"testname",
"pow":2.34,
"topics":["0x00000000", "0x007f80ff", "0xff807f00", "0xf26e7779"],
"acceptP2P":true
}`)
var f WhisperFilterArgs
err := f.UnmarshalJSON(s)
if err != nil {
x.Fatalf("failed UnmarshalJSON: %s.", err)
}
if f.To != "0x70c87d191324e6712a591f304b4eedef6ad9bb9d" {
x.Fatalf("wrong To: %x.", f.To)
}
if f.From != "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83" {
x.Fatalf("wrong From: %x.", f.To)
}
if f.KeyName != "testname" {
x.Fatalf("wrong KeyName: %s.", f.KeyName)
}
if f.PoW != 2.34 {
x.Fatalf("wrong pow: %f.", f.PoW)
}
if !f.AcceptP2P {
x.Fatalf("wrong AcceptP2P: %v.", f.AcceptP2P)
}
if len(f.Topics) != 4 {
x.Fatalf("wrong topics number: %d.", len(f.Topics))
}
i := 0
if f.Topics[i] != (whisperv5.TopicType{0x00, 0x00, 0x00, 0x00}) {
x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i])
}
i++
if f.Topics[i] != (whisperv5.TopicType{0x00, 0x7f, 0x80, 0xff}) {
x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i])
}
i++
if f.Topics[i] != (whisperv5.TopicType{0xff, 0x80, 0x7f, 0x00}) {
x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i])
}
i++
if f.Topics[i] != (whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}) {
x.Fatalf("wrong topic[%d]: %x.", i, f.Topics[i])
}
}
func TestUnmarshalPostArgs(x *testing.T) {
s := []byte(`{
"ttl":12345,
"from":"0x70c87d191324e6712a591f304b4eedef6ad9bb9d",
"to":"0x9b2055d370f73ec7d8a03e965129118dc8f5bf83",
"keyname":"shh_test",
"topic":"0xf26e7779",
"padding":"0x74686973206973206D79207465737420737472696E67",
"payload":"0x7061796C6F61642073686F756C642062652070736575646F72616E646F6D",
"worktime":777,
"pow":3.1416,
"filterID":"0x40",
"peerID":"0xf26e7779"
}`)
var a PostArgs
err := a.UnmarshalJSON(s)
if err != nil {
x.Fatalf("failed UnmarshalJSON: %s.", err)
}
if a.TTL != 12345 {
x.Fatalf("wrong ttl: %d.", a.TTL)
}
if a.From != "0x70c87d191324e6712a591f304b4eedef6ad9bb9d" {
x.Fatalf("wrong From: %x.", a.To)
}
if a.To != "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83" {
x.Fatalf("wrong To: %x.", a.To)
}
if a.KeyName != "shh_test" {
x.Fatalf("wrong KeyName: %s.", a.KeyName)
}
if a.Topic != (whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}) {
x.Fatalf("wrong topic: %x.", a.Topic)
}
if string(a.Padding) != "this is my test string" {
x.Fatalf("wrong Padding: %s.", string(a.Padding))
}
if string(a.Payload) != "payload should be pseudorandom" {
x.Fatalf("wrong Payload: %s.", string(a.Payload))
}
if a.WorkTime != 777 {
x.Fatalf("wrong WorkTime: %d.", a.WorkTime)
}
if a.PoW != 3.1416 {
x.Fatalf("wrong pow: %f.", a.PoW)
}
if a.FilterID != 64 {
x.Fatalf("wrong FilterID: %d.", a.FilterID)
}
if bytes.Compare(a.PeerID[:], a.Topic[:]) != 0 {
x.Fatalf("wrong PeerID: %x.", a.PeerID)
}
}
func waitForMessage(api *PublicWhisperAPI, id *rpc.HexNumber, target int) bool {
for i := 0; i < 64; i++ {
all := api.GetMessages(*id)
if len(all) >= target {
return true
}
time.Sleep(time.Millisecond * 16)
}
// timeout 1024 milliseconds
return false
}
func TestIntegrationAsym(x *testing.T) {
api := NewPublicWhisperAPI()
if api == nil {
x.Fatalf("failed to create API.")
}
sig, err := api.NewIdentity()
if err != nil {
x.Fatalf("failed test case 22: %s.", err)
}
if len(sig) == 0 {
x.Fatalf("failed test case 23")
}
exist, err := api.HasIdentity(sig)
if err != nil {
x.Fatalf("failed test case 24: %s.", err)
}
if !exist {
x.Fatalf("failed test case 25, HasIdentity: false negative.")
}
key, err := api.NewIdentity()
if err != nil {
x.Fatalf("failed test case 26: %s.", err)
}
if len(key) == 0 {
x.Fatalf("failed test case 27")
}
var topics [2]whisperv5.TopicType
topics[0] = whisperv5.TopicType{0x00, 0x64, 0x00, 0xff}
topics[1] = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
var f WhisperFilterArgs
f.To = key
f.From = sig
f.Topics = topics[:]
f.PoW = whisperv5.MinimumPoW / 2
f.AcceptP2P = true
id, err := api.NewFilter(f)
if err != nil {
x.Fatalf("failed to create new filter: %s.", err)
}
var p PostArgs
p.TTL = 2
p.From = f.From
p.To = f.To
p.Padding = []byte("test string")
p.Payload = []byte("extended test string")
p.PoW = whisperv5.MinimumPoW
p.Topic = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
p.WorkTime = 2
err = api.Post(p)
if err != nil {
x.Errorf("failed to post message: %s.", err)
}
ok := waitForMessage(api, id, 1)
if !ok {
x.Fatalf("failed to receive first message: timeout.")
}
mail := api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail))
}
text := string(common.FromHex(mail[0].Payload))
if text != string("extended test string") {
x.Fatalf("failed to decrypt first message: %s.", text)
}
p.Padding = []byte("new value")
p.Payload = []byte("extended new value")
err = api.Post(p)
if err != nil {
x.Fatalf("failed to post next message: %s.", err)
}
ok = waitForMessage(api, id, 2)
if !ok {
x.Fatalf("failed to receive second message: timeout.")
}
mail = api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail))
}
text = string(common.FromHex(mail[0].Payload))
if text != string("extended new value") {
x.Fatalf("failed to decrypt second message: %s.", text)
}
}
func TestIntegrationSym(x *testing.T) {
api := NewPublicWhisperAPI()
if api == nil {
x.Fatalf("failed to create API.")
}
keyname := "schluessel"
err := api.GenerateSymKey(keyname)
if err != nil {
x.Fatalf("failed test case 1: %s.", err)
}
sig, err := api.NewIdentity()
if err != nil {
x.Fatalf("failed test case 2: %s.", err)
}
if len(sig) == 0 {
x.Fatalf("failed test case 3")
}
exist, err := api.HasIdentity(sig)
if err != nil {
x.Fatalf("failed test case 4: %s.", err)
}
if !exist {
x.Fatalf("failed test case 5, HasIdentity: false negative.")
}
var topics [2]whisperv5.TopicType
topics[0] = whisperv5.TopicType{0x00, 0x7f, 0x80, 0xff}
topics[1] = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
var f WhisperFilterArgs
f.KeyName = keyname
f.Topics = topics[:]
f.PoW = 0.324
f.From = sig
f.AcceptP2P = false
id, err := api.NewFilter(f)
if err != nil {
x.Fatalf("failed 31 to create new filter: %s.", err)
}
var p PostArgs
p.TTL = 1
p.KeyName = keyname
p.From = f.From
p.Padding = []byte("test string")
p.Payload = []byte("extended test string")
p.PoW = whisperv5.MinimumPoW
p.Topic = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
p.WorkTime = 2
err = api.Post(p)
if err != nil {
x.Fatalf("failed test case 32 (post message): %s.", err)
}
ok := waitForMessage(api, id, 1)
if !ok {
x.Fatalf("failed test case 33 (receive first message: timeout).")
}
mail := api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed test case 34 (GetFilterChanges: got %d messages).", len(mail))
}
text := string(common.FromHex(mail[0].Payload))
if text != string("extended test string") {
x.Fatalf("failed test case 35 (decrypt first message): %s.", text)
}
p.Padding = []byte("new value")
p.Payload = []byte("extended new value")
err = api.Post(p)
if err != nil {
x.Fatalf("failed test case 42 (post message): %s.", err)
}
ok = waitForMessage(api, id, 2)
if !ok {
x.Fatalf("failed test case 43 (receive second message: timeout).")
}
mail = api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed test case 44 (GetFilterChanges: got %d messages).", len(mail))
}
text = string(common.FromHex(mail[0].Payload))
if text != string("extended new value") {
x.Fatalf("failed test case 45 (decrypt second message: %s).", text)
}
}
func TestIntegrationSymWithFilter(x *testing.T) {
api := NewPublicWhisperAPI()
if api == nil {
x.Fatalf("failed to create API.")
}
keyname := "schluessel"
err := api.GenerateSymKey(keyname)
if err != nil {
x.Fatalf("failed to GenerateSymKey: %s.", err)
}
sig, err := api.NewIdentity()
if err != nil {
x.Fatalf("failed test case 2: %s.", err)
}
if len(sig) == 0 {
x.Fatalf("failed test case 3.")
}
exist, err := api.HasIdentity(sig)
if err != nil {
x.Fatalf("failed test case 4: %s.", err)
}
if !exist {
x.Fatalf("failed test case 5.")
}
var topics [2]whisperv5.TopicType
topics[0] = whisperv5.TopicType{0x00, 0x7f, 0x80, 0xff}
topics[1] = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
var f WhisperFilterArgs
f.KeyName = keyname
f.Topics = topics[:]
f.PoW = 0.324
f.From = sig
f.AcceptP2P = false
id, err := api.NewFilter(f)
if err != nil {
x.Fatalf("failed to create new filter: %s.", err)
}
var p PostArgs
p.TTL = 1
p.FilterID = id.Int()
p.From = sig
p.Padding = []byte("test string")
p.Payload = []byte("extended test string")
p.PoW = whisperv5.MinimumPoW
p.Topic = whisperv5.TopicType{0xf2, 0x6e, 0x77, 0x79}
p.WorkTime = 2
err = api.Post(p)
if err != nil {
x.Fatalf("failed to post message: %s.", err)
}
ok := waitForMessage(api, id, 1)
if !ok {
x.Fatalf("failed to receive first message: timeout.")
}
mail := api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail))
}
text := string(common.FromHex(mail[0].Payload))
if text != string("extended test string") {
x.Fatalf("failed to decrypt first message: %s.", text)
}
p.Padding = []byte("new value")
p.Payload = []byte("extended new value")
err = api.Post(p)
if err != nil {
x.Fatalf("failed to post next message: %s.", err)
}
ok = waitForMessage(api, id, 2)
if !ok {
x.Fatalf("failed to receive second message: timeout.")
}
mail = api.GetFilterChanges(*id)
if len(mail) != 1 {
x.Fatalf("failed to GetFilterChanges: got %d messages.", len(mail))
}
text = string(common.FromHex(mail[0].Payload))
if text != string("extended new value") {
x.Fatalf("failed to decrypt second message: %s.", text)
}
}

57
whisper/whisperv5/benchmarks_test.go
View file

@ -40,8 +40,7 @@ func BenchmarkEncryptionSym(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
for i := 0; i < b.N; i++ {
@ -60,13 +59,11 @@ func BenchmarkEncryptionAsym(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
key, err := crypto.GenerateKey()
if err != nil {
b.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
params.KeySym = nil
params.Dst = &key.PublicKey
@ -75,8 +72,7 @@ func BenchmarkEncryptionAsym(b *testing.B) {
msg := NewSentMessage(params)
_, err := msg.Wrap(params)
if err != nil {
b.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
}
}
@ -86,22 +82,19 @@ func BenchmarkDecryptionSymValid(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
b.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
f := Filter{KeySym: params.KeySym}
for i := 0; i < b.N; i++ {
msg := env.Open(&f)
if msg == nil {
b.Errorf("failed to open with seed %d.", seed)
return
b.Fatalf("failed to open with seed %d.", seed)
}
}
}
@ -111,22 +104,19 @@ func BenchmarkDecryptionSymInvalid(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
b.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
f := Filter{KeySym: []byte("arbitrary stuff here")}
for i := 0; i < b.N; i++ {
msg := env.Open(&f)
if msg != nil {
b.Errorf("opened envelope with invalid key, seed: %d.", seed)
return
b.Fatalf("opened envelope with invalid key, seed: %d.", seed)
}
}
}
@ -136,13 +126,11 @@ func BenchmarkDecryptionAsymValid(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
key, err := crypto.GenerateKey()
if err != nil {
b.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
f := Filter{KeyAsym: key}
params.KeySym = nil
@ -150,15 +138,13 @@ func BenchmarkDecryptionAsymValid(b *testing.B) {
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
b.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
for i := 0; i < b.N; i++ {
msg := env.Open(&f)
if msg == nil {
b.Errorf("fail to open, seed: %d.", seed)
return
b.Fatalf("fail to open, seed: %d.", seed)
}
}
}
@ -168,35 +154,30 @@ func BenchmarkDecryptionAsymInvalid(b *testing.B) {
params, err := generateMessageParams()
if err != nil {
b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
key, err := crypto.GenerateKey()
if err != nil {
b.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
params.KeySym = nil
params.Dst = &key.PublicKey
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
b.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
b.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
key, err = crypto.GenerateKey()
if err != nil {
b.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
f := Filter{KeyAsym: key}
for i := 0; i < b.N; i++ {
msg := env.Open(&f)
if msg != nil {
b.Errorf("opened envelope with invalid key, seed: %d.", seed)
return
b.Fatalf("opened envelope with invalid key, seed: %d.", seed)
}
}
}

2
whisper/whisperv5/doc.go
View file

@ -46,7 +46,7 @@ const (
messagesCode = 1
p2pCode = 2
mailRequestCode = 3
NumberOfMessageCodes = 4
NumberOfMessageCodes = 10
paddingMask = byte(3)
signatureFlag = byte(4)

35
whisper/whisperv5/filter.go
View file

@ -143,18 +143,9 @@ func (f *Filter) MatchMessage(msg *ReceivedMessage) bool {
}
if f.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() {
// if Dst match, ignore the topic
return isPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst)
return isPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst) && f.MatchTopic(msg.Topic)
} else if f.expectsSymmetricEncryption() && msg.isSymmetricEncryption() {
// check if that both the key and the topic match
if f.SymKeyHash == msg.SymKeyHash {
for _, t := range f.Topics {
if t == msg.Topic {
return true
}
}
return false
}
return f.SymKeyHash == msg.SymKeyHash && f.MatchTopic(msg.Topic)
}
return false
}
@ -164,25 +155,25 @@ func (f *Filter) MatchEnvelope(envelope *Envelope) bool {
return false
}
encryptionMethodMatch := false
if f.expectsAsymmetricEncryption() && envelope.isAsymmetric() {
encryptionMethodMatch = true
if f.Topics == nil {
// wildcard
return true
}
return f.MatchTopic(envelope.Topic)
} else if f.expectsSymmetricEncryption() && envelope.IsSymmetric() {
encryptionMethodMatch = true
return f.MatchTopic(envelope.Topic)
}
return false
}
func (f *Filter) MatchTopic(topic TopicType) bool {
if len(f.Topics) == 0 {
// any topic matches
return true
}
if encryptionMethodMatch {
for _, t := range f.Topics {
if t == envelope.Topic {
if t == topic {
return true
}
}
}
return false
}

230
whisper/whisperv5/filter_test.go
View file

@ -61,7 +61,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) {
key, err := crypto.GenerateKey()
if err != nil {
x.Errorf("generateFilter failed 1 with seed %d.", seed)
x.Fatalf("generateFilter 1 failed with seed %d.", seed)
return nil, err
}
f.Src = &key.PublicKey
@ -73,7 +73,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) {
} else {
f.KeyAsym, err = crypto.GenerateKey()
if err != nil {
x.Errorf("generateFilter failed 2 with seed %d.", seed)
x.Fatalf("generateFilter 2 failed with seed %d.", seed)
return nil, err
}
}
@ -107,8 +107,7 @@ func TestInstallFilters(x *testing.T) {
}
if j < SizeTestFilters-1 {
x.Errorf("seed %d: wrong index %d", seed, j)
return
x.Fatalf("seed %d: wrong index %d", seed, j)
}
for _, t := range tst {
@ -121,12 +120,10 @@ func TestInstallFilters(x *testing.T) {
fil := filters.Get(t.id)
exist := (fil != nil)
if exist != t.alive {
x.Errorf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive)
return
x.Fatalf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive)
}
if exist && fil.PoW != t.f.PoW {
x.Errorf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive)
return
x.Fatalf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive)
}
}
}
@ -136,29 +133,24 @@ func TestComparePubKey(x *testing.T) {
key1, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey 1 with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey 1 with seed %d: %s.", seed, err)
}
key2, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey 2 with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey 2 with seed %d: %s.", seed, err)
}
if isPubKeyEqual(&key1.PublicKey, &key2.PublicKey) {
x.Errorf("failed !equal with seed %d.", seed)
return
x.Fatalf("failed !equal with seed %d.", seed)
}
// generate key3 == key1
rand.Seed(seed)
key3, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey 3 with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey 3 with seed %d: %s.", seed, err)
}
if isPubKeyEqual(&key1.PublicKey, &key3.PublicKey) {
x.Errorf("failed equal with seed %d.", seed)
return
x.Fatalf("failed equal with seed %d.", seed)
}
}
@ -167,20 +159,17 @@ func TestMatchEnvelope(x *testing.T) {
fsym, err := generateFilter(x, true)
if err != nil {
x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err)
}
fasym, err := generateFilter(x, false)
if err != nil {
x.Errorf("failed generateFilter 2 with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateFilter 2 with seed %d: %s.", seed, err)
}
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams 3 with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams 3 with seed %d: %s.", seed, err)
}
params.Topic[0] = 0xFF // ensure mismatch
@ -189,18 +178,15 @@ func TestMatchEnvelope(x *testing.T) {
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
x.Errorf("failed Wrap 4 with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap 4 with seed %d: %s.", seed, err)
}
match := fsym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 5 with seed %d.", seed)
return
x.Fatalf("failed test case 5 with seed %d.", seed)
}
match = fasym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 6 with seed %d.", seed)
return
x.Fatalf("failed test case 6 with seed %d.", seed)
}
// encrypt symmetrically
@ -210,109 +196,109 @@ func TestMatchEnvelope(x *testing.T) {
msg = NewSentMessage(params)
env, err = msg.Wrap(params)
if err != nil {
x.Errorf("failed test case 7 with seed %d, test case 3: %s.", seed, err)
return
x.Fatalf("failed test case 7 with seed %d, test case 3: %s.", seed, err)
}
// symmetric + matching topic: match
match = fsym.MatchEnvelope(env)
if !match {
x.Errorf("failed test case 8 with seed %d.", seed)
return
x.Fatalf("failed test case 8 with seed %d.", seed)
}
// asymmetric + matching topic: mismatch
match = fasym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 9 with seed %d.", seed)
return
x.Fatalf("failed test case 9 with seed %d.", seed)
}
// symmetric + matching topic + insufficient PoW: mismatch
fsym.PoW = env.PoW() + 1.0
match = fsym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 10 with seed %d.", seed)
return
x.Fatalf("failed test case 10 with seed %d.", seed)
}
// symmetric + matching topic + sufficient PoW: match
fsym.PoW = env.PoW() / 2
match = fsym.MatchEnvelope(env)
if !match {
x.Errorf("failed test case 11 with seed %d.", seed)
return
x.Fatalf("failed test case 11 with seed %d.", seed)
}
// symmetric + topics are nil: mismatch
// symmetric + topics are nil (wildcard): match
prevTopics := fsym.Topics
fsym.Topics = nil
match = fasym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 12 with seed %d.", seed)
return
match = fsym.MatchEnvelope(env)
if !match {
x.Fatalf("failed test case 12 with seed %d.", seed)
}
fsym.Topics = prevTopics
// encrypt asymmetrically
key, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err)
}
params.KeySym = nil
params.Dst = &key.PublicKey
msg = NewSentMessage(params)
env, err = msg.Wrap(params)
if err != nil {
x.Errorf("failed test case 14 with seed %d, test case 3: %s.", seed, err)
return
x.Fatalf("failed test case 14 with seed %d, test case 3: %s.", seed, err)
}
// encryption method mismatch
match = fsym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 15 with seed %d.", seed)
return
x.Fatalf("failed test case 15 with seed %d.", seed)
}
// asymmetric + mismatching topic: mismatch
match = fasym.MatchEnvelope(env)
if !match {
x.Errorf("failed test case 16 with seed %d.", seed)
return
x.Fatalf("failed test case 16 with seed %d.", seed)
}
// asymmetric + matching topic: match
fasym.Topics[i] = fasym.Topics[i+1]
match = fasym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 17 with seed %d.", seed)
return
x.Fatalf("failed test case 17 with seed %d.", seed)
}
// asymmetric + topic is nil (wildcard): match
// asymmetric + filter without topic (wildcard): match
fasym.Topics = nil
match = fasym.MatchEnvelope(env)
if !match {
x.Errorf("failed test case 18 with seed %d.", seed)
return
x.Fatalf("failed test case 18 with seed %d.", seed)
}
// asymmetric + insufficient PoW: mismatch
fasym.PoW = env.PoW() + 1.0
match = fasym.MatchEnvelope(env)
if match {
x.Errorf("failed test case 19 with seed %d.", seed)
return
x.Fatalf("failed test case 19 with seed %d.", seed)
}
// asymmetric + sufficient PoW: match
fasym.PoW = env.PoW() / 2
match = fasym.MatchEnvelope(env)
if !match {
x.Errorf("failed test case 20 with seed %d.", seed)
return
x.Fatalf("failed test case 20 with seed %d.", seed)
}
// filter without topic + envelope without topic: match
env.Topic = TopicType{}
match = fasym.MatchEnvelope(env)
if !match {
x.Fatalf("failed test case 21 with seed %d.", seed)
}
// filter with topic + envelope without topic: mismatch
fasym.Topics = fsym.Topics
match = fasym.MatchEnvelope(env)
if match {
x.Fatalf("failed test case 22 with seed %d.", seed)
}
}
@ -321,14 +307,12 @@ func TestMatchMessageSym(x *testing.T) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
f, err := generateFilter(x, true)
if err != nil {
x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err)
}
const index = 1
@ -338,90 +322,77 @@ func TestMatchMessageSym(x *testing.T) {
sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params)
if err != nil {
x.Errorf("failed Wrap 2 with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap 2 with seed %d: %s.", seed, err)
}
msg := env.Open(f)
if msg == nil {
x.Errorf("failed to open 3 with seed %d.", seed)
return
x.Fatalf("failed to open 3 with seed %d.", seed)
}
// Src mismatch
if f.MatchMessage(msg) {
x.Errorf("failed test case 4 with seed %d.", seed)
return
x.Fatalf("failed test case 4 with seed %d.", seed)
}
// Src: match
*f.Src.X = *params.Src.PublicKey.X
*f.Src.Y = *params.Src.PublicKey.Y
if !f.MatchMessage(msg) {
x.Errorf("failed test case 5 with seed %d.", seed)
return
x.Fatalf("failed test case 5 with seed %d.", seed)
}
// insufficient PoW: mismatch
f.PoW = msg.PoW + 1.0
if f.MatchMessage(msg) {
x.Errorf("failed test case 6 with seed %d.", seed)
return
x.Fatalf("failed test case 6 with seed %d.", seed)
}
// sufficient PoW: match
f.PoW = msg.PoW / 2
if !f.MatchMessage(msg) {
x.Errorf("failed test case 7 with seed %d.", seed)
return
x.Fatalf("failed test case 7 with seed %d.", seed)
}
// topic mismatch
f.Topics[index][0]++
if f.MatchMessage(msg) {
x.Errorf("failed test case 8 with seed %d.", seed)
return
x.Fatalf("failed test case 8 with seed %d.", seed)
}
f.Topics[index][0]--
// key mismatch
f.SymKeyHash[0]++
if f.MatchMessage(msg) {
x.Errorf("failed test case 9 with seed %d.", seed)
return
x.Fatalf("failed test case 9 with seed %d.", seed)
}
f.SymKeyHash[0]--
// Src absent: match
f.Src = nil
if !f.MatchMessage(msg) {
x.Errorf("failed test case 10 with seed %d.", seed)
return
x.Fatalf("failed test case 10 with seed %d.", seed)
}
// key hash mismatch mismatch
h := f.SymKeyHash
f.SymKeyHash = common.Hash{}
if f.MatchMessage(msg) {
x.Errorf("failed test case 11 with seed %d.", seed)
return
x.Fatalf("failed test case 11 with seed %d.", seed)
}
f.SymKeyHash = h
if !f.MatchMessage(msg) {
x.Errorf("failed test case 12 with seed %d.", seed)
return
x.Fatalf("failed test case 12 with seed %d.", seed)
}
// encryption method mismatch
f.KeySym = nil
f.KeyAsym, err = crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err)
}
if f.MatchMessage(msg) {
x.Errorf("failed test case 14 with seed %d.", seed)
return
x.Fatalf("failed test case 14 with seed %d.", seed)
}
}
@ -430,14 +401,12 @@ func TestMatchMessageAsym(x *testing.T) {
f, err := generateFilter(x, false)
if err != nil {
x.Errorf("failed generateFilter with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateFilter with seed %d: %s.", seed, err)
}
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
const index = 1
@ -449,50 +418,42 @@ func TestMatchMessageAsym(x *testing.T) {
sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params)
if err != nil {
x.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
msg := env.Open(f)
if msg == nil {
x.Errorf("failed to open with seed %d.", seed)
return
x.Fatalf("failed to open with seed %d.", seed)
}
// Src mismatch
if f.MatchMessage(msg) {
x.Errorf("failed test case 4 with seed %d.", seed)
return
x.Fatalf("failed test case 4 with seed %d.", seed)
}
// Src: match
*f.Src.X = *params.Src.PublicKey.X
*f.Src.Y = *params.Src.PublicKey.Y
if !f.MatchMessage(msg) {
x.Errorf("failed test case 5 with seed %d.", seed)
return
x.Fatalf("failed test case 5 with seed %d.", seed)
}
// insufficient PoW: mismatch
f.PoW = msg.PoW + 1.0
if f.MatchMessage(msg) {
x.Errorf("failed test case 6 with seed %d.", seed)
return
x.Fatalf("failed test case 6 with seed %d.", seed)
}
// sufficient PoW: match
f.PoW = msg.PoW / 2
if !f.MatchMessage(msg) {
x.Errorf("failed test case 7 with seed %d.", seed)
return
x.Fatalf("failed test case 7 with seed %d.", seed)
}
// topic mismatch, but still match, because for asymmetric encryption
// only private key matters (in case the message is already decrypted)
// topic mismatch
f.Topics[index][0]++
if !f.MatchMessage(msg) {
x.Errorf("failed test case 8 with seed %d.", seed)
return
if f.MatchMessage(msg) {
x.Fatalf("failed test case 8 with seed %d.", seed)
}
f.Topics[index][0]--
@ -501,24 +462,21 @@ func TestMatchMessageAsym(x *testing.T) {
zero := *big.NewInt(0)
*f.KeyAsym.PublicKey.X = zero
if f.MatchMessage(msg) {
x.Errorf("failed test case 9 with seed %d.", seed)
return
x.Fatalf("failed test case 9 with seed %d.", seed)
}
*f.KeyAsym.PublicKey.X = prev
// Src absent: match
f.Src = nil
if !f.MatchMessage(msg) {
x.Errorf("failed test case 10 with seed %d.", seed)
return
x.Fatalf("failed test case 10 with seed %d.", seed)
}
// encryption method mismatch
f.KeySym = keySymOrig
f.KeyAsym = nil
if f.MatchMessage(msg) {
x.Errorf("failed test case 11 with seed %d.", seed)
return
x.Fatalf("failed test case 11 with seed %d.", seed)
}
}
@ -538,7 +496,7 @@ func cloneFilter(orig *Filter) *Filter {
func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams 77 with seed %d: %s.", seed, err)
x.Fatalf("failed generateMessageParams 77 with seed %d: %s.", seed, err)
return nil
}
@ -547,7 +505,7 @@ func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope {
sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params)
if err != nil {
x.Errorf("failed Wrap 78 with seed %d: %s.", seed, err)
x.Fatalf("failed Wrap 78 with seed %d: %s.", seed, err)
return nil
}
return env
@ -595,20 +553,17 @@ func TestWatchers(x *testing.T) {
}
if total != NumMessages {
x.Errorf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages)
return
x.Fatalf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages)
}
for i = 0; i < NumFilters; i++ {
mail = tst[i].f.Retrieve()
if len(mail) != 0 {
x.Errorf("failed test case 2 with seed %d: i = %d.", seed, i)
return
x.Fatalf("failed test case 2 with seed %d: i = %d.", seed, i)
}
if tst[i].msgCnt != count[i] {
x.Errorf("failed test case 3 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
return
x.Fatalf("failed test case 3 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
}
}
@ -648,30 +603,25 @@ func TestWatchers(x *testing.T) {
combined := tst[0].msgCnt + tst[last].msgCnt
if total != NumMessages+count[0] {
x.Errorf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0])
return
x.Fatalf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0])
}
if combined != count[0] {
x.Errorf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0])
return
x.Fatalf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0])
}
if combined != count[last] {
x.Errorf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last])
return
x.Fatalf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last])
}
for i = 1; i < NumFilters-1; i++ {
mail = tst[i].f.Retrieve()
if len(mail) != 0 {
x.Errorf("failed test case 7 with seed %d: i = %d.", seed, i)
return
x.Fatalf("failed test case 7 with seed %d: i = %d.", seed, i)
}
if tst[i].msgCnt != count[i] {
x.Errorf("failed test case 8 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
return
x.Fatalf("failed test case 8 with seed %d: i = %d, get %d, want %d.", seed, i, tst[i].msgCnt, count[i])
}
}
@ -686,8 +636,7 @@ func TestWatchers(x *testing.T) {
}
if total != 0 {
x.Errorf("failed test case 9 with seed %d.", seed)
return
x.Fatalf("failed test case 9 with seed %d.", seed)
}
f := filters.Get(0)
@ -701,7 +650,6 @@ func TestWatchers(x *testing.T) {
}
if total != 1 {
x.Errorf("failed test case 10 with seed %d: total = %d.", seed, total)
return
x.Fatalf("failed test case 10 with seed %d: total = %d.", seed, total)
}
}

90
whisper/whisperv5/message_test.go
View file

@ -60,14 +60,12 @@ func generateMessageParams() (*MessageParams, error) {
func singleMessageTest(x *testing.T, symmetric bool) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
key, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
if !symmetric {
@ -85,8 +83,7 @@ func singleMessageTest(x *testing.T, symmetric bool) {
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
x.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
var decrypted *ReceivedMessage
@ -97,35 +94,28 @@ func singleMessageTest(x *testing.T, symmetric bool) {
}
if err != nil {
x.Errorf("failed to encrypt with seed %d: %s.", seed, err)
return
x.Fatalf("failed to encrypt with seed %d: %s.", seed, err)
}
if !decrypted.Validate() {
x.Errorf("failed to validate with seed %d.", seed)
return
x.Fatalf("failed to validate with seed %d.", seed)
}
padsz := len(decrypted.Padding)
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 {
x.Errorf("failed with seed %d: compare padding.", seed)
return
x.Fatalf("failed with seed %d: compare padding.", seed)
}
if bytes.Compare(text, decrypted.Payload) != 0 {
x.Errorf("failed with seed %d: compare payload.", seed)
return
x.Fatalf("failed with seed %d: compare payload.", seed)
}
if !isMessageSigned(decrypted.Raw[0]) {
x.Errorf("failed with seed %d: unsigned.", seed)
return
x.Fatalf("failed with seed %d: unsigned.", seed)
}
if len(decrypted.Signature) != signatureLength {
x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
return
x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
}
if !isPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
x.Errorf("failed with seed %d: signature mismatch.", seed)
return
x.Fatalf("failed with seed %d: signature mismatch.", seed)
}
}
@ -146,8 +136,7 @@ func TestMessageWrap(x *testing.T) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
msg := NewSentMessage(params)
@ -156,14 +145,12 @@ func TestMessageWrap(x *testing.T) {
params.PoW = target
env, err := msg.Wrap(params)
if err != nil {
x.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
pow := env.PoW()
if pow < target {
x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
return
x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
}
}
@ -174,8 +161,7 @@ func TestMessageSeal(x *testing.T) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
msg := NewSentMessage(params)
@ -187,8 +173,7 @@ func TestMessageSeal(x *testing.T) {
env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg)
if err != nil {
x.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
env.Expiry = uint32(seed) // make it deterministic
@ -200,8 +185,7 @@ func TestMessageSeal(x *testing.T) {
env.calculatePoW(0)
pow := env.PoW()
if pow < target {
x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
return
x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
}
params.WorkTime = 1
@ -210,8 +194,7 @@ func TestMessageSeal(x *testing.T) {
env.calculatePoW(0)
pow = env.PoW()
if pow < 2*target {
x.Errorf("failed Wrap with seed %d: pow too small %f.", seed, pow)
return
x.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow)
}
}
@ -228,14 +211,12 @@ func TestEnvelopeOpen(x *testing.T) {
func singleEnvelopeOpenTest(x *testing.T, symmetric bool) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
}
key, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
}
if !symmetric {
@ -253,54 +234,43 @@ func singleEnvelopeOpenTest(x *testing.T, symmetric bool) {
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
x.Errorf("failed Wrap with seed %d: %s.", seed, err)
return
x.Fatalf("failed Wrap with seed %d: %s.", seed, err)
}
f := Filter{KeyAsym: key, KeySym: params.KeySym}
decrypted := env.Open(&f)
if decrypted == nil {
x.Errorf("failed to open with seed %d.", seed)
return
x.Fatalf("failed to open with seed %d.", seed)
}
padsz := len(decrypted.Padding)
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 {
x.Errorf("failed with seed %d: compare padding.", seed)
return
x.Fatalf("failed with seed %d: compare padding.", seed)
}
if bytes.Compare(text, decrypted.Payload) != 0 {
x.Errorf("failed with seed %d: compare payload.", seed)
return
x.Fatalf("failed with seed %d: compare payload.", seed)
}
if !isMessageSigned(decrypted.Raw[0]) {
x.Errorf("failed with seed %d: unsigned.", seed)
return
x.Fatalf("failed with seed %d: unsigned.", seed)
}
if len(decrypted.Signature) != signatureLength {
x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
return
x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
}
if !isPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
x.Errorf("failed with seed %d: signature mismatch.", seed)
return
x.Fatalf("failed with seed %d: signature mismatch.", seed)
}
if decrypted.isAsymmetricEncryption() == symmetric {
x.Errorf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
return
x.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
}
if decrypted.isSymmetricEncryption() != symmetric {
x.Errorf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric)
return
x.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric)
}
if !symmetric {
if decrypted.Dst == nil {
x.Errorf("failed with seed %d: dst is nil.", seed)
return
x.Fatalf("failed with seed %d: dst is nil.", seed)
}
if !isPubKeyEqual(decrypted.Dst, &key.PublicKey) {
x.Errorf("failed with seed %d: Dst.", seed)
return
x.Fatalf("failed with seed %d: Dst.", seed)
}
}
}

32
whisper/whisperv5/peer_test.go
View file

@ -124,8 +124,7 @@ func initialize(x *testing.T) {
node.filerId = node.shh.Watch(&f)
node.id, err = crypto.HexToECDSA(keys[i])
if err != nil {
x.Errorf("failed convert the key: %s.", keys[i])
return
x.Fatalf("failed convert the key: %s.", keys[i])
}
port := port0 + i
addr := fmt.Sprintf(":%d", port) // e.g. ":30303"
@ -155,8 +154,7 @@ func initialize(x *testing.T) {
err = node.server.Start()
if err != nil {
x.Errorf("failed to start server %d.", i)
return
x.Fatalf("failed to start server %d.", i)
}
nodes[i] = &node
@ -187,8 +185,7 @@ func checkPropagation(x *testing.T) {
for i := 0; i < NumNodes; i++ {
f := nodes[i].shh.GetFilter(nodes[i].filerId)
if f == nil {
x.Errorf("failed to get filterId %d from node %d.", nodes[i].filerId, i)
return
x.Fatalf("failed to get filterId %d from node %d.", nodes[i].filerId, i)
}
mail := f.Retrieve()
@ -197,13 +194,12 @@ func checkPropagation(x *testing.T) {
}
if isTestComplete() {
return
}
}
}
x.Errorf("Test was not complete: timeout %d seconds.", iterations*cycle/1000)
x.Fatalf("Test was not complete: timeout %d seconds.", iterations*cycle/1000)
}
func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool {
@ -219,7 +215,7 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool {
return true
}
if cnt > 1 {
x.Errorf("node %d received %d.", index, cnt)
x.Fatalf("node %d received %d.", index, cnt)
return false
}
@ -228,8 +224,7 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool {
defer result.mutex.Unlock()
result.counter[index] += cnt
if result.counter[index] > 1 {
x.Errorf("node %d accumulated %d.", index, result.counter[index])
return false
x.Fatalf("node %d accumulated %d.", index, result.counter[index])
}
}
return true
@ -270,14 +265,12 @@ func sendMsg(x *testing.T, expected bool, id int) {
msg := NewSentMessage(&opt)
envelope, err := msg.Wrap(&opt)
if err != nil {
x.Errorf("failed to seal message.")
return
x.Fatalf("failed to seal message.")
}
err = nodes[id].shh.Send(envelope)
if err != nil {
x.Errorf("failed to send message.")
return
x.Fatalf("failed to send message.")
}
}
@ -286,22 +279,19 @@ func TestPeerBasic(x *testing.T) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed 1 with seed %d.", seed)
return
x.Fatalf("failed generateMessageParams with seed %d.", seed)
}
params.PoW = 0.001
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
x.Errorf("failed 2 with seed %d.", seed)
return
x.Fatalf("failed Wrap with seed %d.", seed)
}
p := newPeer(nil, nil, nil)
p.mark(env)
if !p.marked(env) {
x.Errorf("failed 3 with seed %d.", seed)
return
x.Fatalf("failed mark with seed %d.", seed)
}
}

14
whisper/whisperv5/topic_test.go
View file

@ -32,7 +32,7 @@ func TestTopicString(x *testing.T) {
for i, tst := range topicStringTests {
s := tst.topic.String()
if s != tst.str {
x.Errorf("failed test %d: have %s, want %s.", i, s, tst.str)
x.Fatalf("failed test %d: have %s, want %s.", i, s, tst.str)
}
}
}
@ -57,7 +57,7 @@ func TestBytesToTopic(x *testing.T) {
for i, tst := range bytesToTopicTests {
t := BytesToTopic(tst.data)
if t != tst.topic {
x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic)
x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic)
}
}
}
@ -104,9 +104,9 @@ func TestUnmarshalTestsGood(x *testing.T) {
var t TopicType
err := t.UnmarshalJSON(tst.data)
if err != nil {
x.Errorf("failed test %d. input: %v.", i, tst.data)
x.Fatalf("failed test %d. input: %v.", i, tst.data)
} else if t != tst.topic {
x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic)
x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic)
}
}
}
@ -117,7 +117,7 @@ func TestUnmarshalTestsBad(x *testing.T) {
var t TopicType
err := t.UnmarshalJSON(tst.data)
if err == nil {
x.Errorf("failed test %d. input: %v.", i, tst.data)
x.Fatalf("failed test %d. input: %v.", i, tst.data)
}
}
}
@ -128,9 +128,9 @@ func TestUnmarshalTestsUgly(x *testing.T) {
var t TopicType
err := t.UnmarshalJSON(tst.data)
if err != nil {
x.Errorf("failed test %d. input: %v.", i, tst.data)
x.Fatalf("failed test %d. input: %v.", i, tst.data)
} else if t == tst.topic {
x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic)
x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic)
}
}
}

198
whisper/whisperv5/whisper_test.go
View file

@ -29,114 +29,92 @@ func TestWhisperBasic(x *testing.T) {
p := w.Protocols()
shh := p[0]
if shh.Name != ProtocolName {
x.Errorf("failed Protocol Name: %v.", shh.Name)
return
x.Fatalf("failed Protocol Name: %v.", shh.Name)
}
if uint64(shh.Version) != ProtocolVersion {
x.Errorf("failed Protocol Version: %v.", shh.Version)
return
x.Fatalf("failed Protocol Version: %v.", shh.Version)
}
if shh.Length != NumberOfMessageCodes {
x.Errorf("failed Protocol Length: %v.", shh.Length)
return
x.Fatalf("failed Protocol Length: %v.", shh.Length)
}
if shh.Run == nil {
x.Errorf("failed shh.Run.")
return
x.Fatalf("failed shh.Run.")
}
if uint64(w.Version()) != ProtocolVersion {
x.Errorf("failed whisper Version: %v.", shh.Version)
return
x.Fatalf("failed whisper Version: %v.", shh.Version)
}
if w.GetFilter(0) != nil {
x.Errorf("failed GetFilter.")
return
x.Fatalf("failed GetFilter.")
}
peerID := make([]byte, 64)
randomize(peerID)
peer, err := w.getPeer(peerID)
if peer != nil {
x.Errorf("failed GetPeer.")
return
x.Fatalf("failed GetPeer.")
}
err = w.MarkPeerTrusted(peerID)
if err == nil {
x.Errorf("failed MarkPeerTrusted.")
return
x.Fatalf("failed MarkPeerTrusted.")
}
err = w.RequestHistoricMessages(peerID, peerID)
if err == nil {
x.Errorf("failed RequestHistoricMessages.")
return
x.Fatalf("failed RequestHistoricMessages.")
}
err = w.SendP2PMessage(peerID, nil)
if err == nil {
x.Errorf("failed SendP2PMessage.")
return
x.Fatalf("failed SendP2PMessage.")
}
exist := w.HasSymKey("non-existing")
if exist {
x.Errorf("failed HasSymKey.")
return
x.Fatalf("failed HasSymKey.")
}
key := w.GetSymKey("non-existing")
if key != nil {
x.Errorf("failed GetSymKey.")
return
x.Fatalf("failed GetSymKey.")
}
mail := w.Envelopes()
if len(mail) != 0 {
x.Errorf("failed w.Envelopes().")
return
x.Fatalf("failed w.Envelopes().")
}
m := w.Messages(0)
if len(m) != 0 {
x.Errorf("failed w.Messages.")
return
x.Fatalf("failed w.Messages.")
}
var derived []byte
ver := uint64(0xDEADBEEF)
derived, err = deriveKeyMaterial(peerID, ver)
if err != unknownVersionError(ver) {
x.Errorf("failed deriveKeyMaterial 1 with param = %v: %s.", peerID, err)
return
x.Fatalf("failed deriveKeyMaterial test case 1 with param = %v: %s.", peerID, err)
}
derived, err = deriveKeyMaterial(peerID, 0)
if err != nil {
x.Errorf("failed deriveKeyMaterial 2 with param = %v: %s.", peerID, err)
return
x.Fatalf("failed deriveKeyMaterial test case 2 with param = %v: %s.", peerID, err)
}
if !validateSymmetricKey(derived) {
x.Errorf("failed validateSymmetricKey with param = %v.", derived)
return
x.Fatalf("failed validateSymmetricKey with param = %v.", derived)
}
if containsOnlyZeros(derived) {
x.Errorf("failed containsOnlyZeros with param = %v.", derived)
return
x.Fatalf("failed containsOnlyZeros with param = %v.", derived)
}
buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0}
le := bytesToIntLittleEndian(buf)
be := BytesToIntBigEndian(buf)
if le != uint64(0x280e5ff) {
x.Errorf("failed bytesToIntLittleEndian: %d.", le)
return
x.Fatalf("failed bytesToIntLittleEndian: %d.", le)
}
if be != uint64(0xffe5800200) {
x.Errorf("failed BytesToIntBigEndian: %d.", be)
return
x.Fatalf("failed BytesToIntBigEndian: %d.", be)
}
pk := w.NewIdentity()
if !validatePrivateKey(pk) {
x.Errorf("failed validatePrivateKey: %v.", pk)
return
x.Fatalf("failed validatePrivateKey: %v.", pk)
}
if !ValidatePublicKey(&pk.PublicKey) {
x.Errorf("failed ValidatePublicKey: %v.", pk)
return
x.Fatalf("failed ValidatePublicKey: %v.", pk)
}
}
@ -149,20 +127,16 @@ func TestWhisperIdentityManagement(x *testing.T) {
pk1 := w.GetIdentity(pub1)
pk2 := w.GetIdentity(pub2)
if !w.HasIdentity(pub1) {
x.Errorf("failed HasIdentity 1.")
return
x.Fatalf("failed test case 1.")
}
if !w.HasIdentity(pub2) {
x.Errorf("failed HasIdentity 2.")
return
x.Fatalf("failed test case 2.")
}
if pk1 != id1 {
x.Errorf("failed GetIdentity 3.")
return
x.Fatalf("failed test case 3.")
}
if pk2 != id2 {
x.Errorf("failed GetIdentity 4.")
return
x.Fatalf("failed test case 4.")
}
// Delete one identity
@ -170,20 +144,16 @@ func TestWhisperIdentityManagement(x *testing.T) {
pk1 = w.GetIdentity(pub1)
pk2 = w.GetIdentity(pub2)
if w.HasIdentity(pub1) {
x.Errorf("failed HasIdentity 11.")
return
x.Fatalf("failed test case 11.")
}
if !w.HasIdentity(pub2) {
x.Errorf("failed HasIdentity 12.")
return
x.Fatalf("failed test case 12.")
}
if pk1 != nil {
x.Errorf("failed GetIdentity 13.")
return
x.Fatalf("failed test case 13.")
}
if pk2 != id2 {
x.Errorf("failed GetIdentity 14.")
return
x.Fatalf("failed test case 14.")
}
// Delete again non-existing identity
@ -191,20 +161,16 @@ func TestWhisperIdentityManagement(x *testing.T) {
pk1 = w.GetIdentity(pub1)
pk2 = w.GetIdentity(pub2)
if w.HasIdentity(pub1) {
x.Errorf("failed HasIdentity 21.")
return
x.Fatalf("failed test case 21.")
}
if !w.HasIdentity(pub2) {
x.Errorf("failed HasIdentity 22.")
return
x.Fatalf("failed test case 22.")
}
if pk1 != nil {
x.Errorf("failed GetIdentity 23.")
return
x.Fatalf("failed test case 23.")
}
if pk2 != id2 {
x.Errorf("failed GetIdentity 24.")
return
x.Fatalf("failed test case 24.")
}
// Delete second identity
@ -212,20 +178,16 @@ func TestWhisperIdentityManagement(x *testing.T) {
pk1 = w.GetIdentity(pub1)
pk2 = w.GetIdentity(pub2)
if w.HasIdentity(pub1) {
x.Errorf("failed HasIdentity 31.")
return
x.Fatalf("failed test case 31.")
}
if w.HasIdentity(pub2) {
x.Errorf("failed HasIdentity 32.")
return
x.Fatalf("failed test case 32.")
}
if pk1 != nil {
x.Errorf("failed GetIdentity 33.")
return
x.Fatalf("failed test case 33.")
}
if pk2 != nil {
x.Errorf("failed GetIdentity 34.")
return
x.Fatalf("failed test case 34.")
}
}
@ -239,27 +201,22 @@ func TestWhisperSymKeyManagement(x *testing.T) {
err := w.GenerateSymKey(id1)
if err != nil {
x.Errorf("failed test case 1 with seed %d: %s.", seed, err)
return
x.Fatalf("failed test case 1 with seed %d: %s.", seed, err)
}
k1 = w.GetSymKey(id1)
k2 = w.GetSymKey(id2)
if !w.HasSymKey(id1) {
x.Errorf("failed HasIdentity 2.")
return
x.Fatalf("failed test case 2.")
}
if w.HasSymKey(id2) {
x.Errorf("failed HasIdentity 3.")
return
x.Fatalf("failed test case 3.")
}
if k1 == nil {
x.Errorf("failed GetIdentity 4.")
return
x.Fatalf("failed test case 4.")
}
if k2 != nil {
x.Errorf("failed GetIdentity 5.")
return
x.Fatalf("failed test case 5.")
}
// add existing id, nothing should change
@ -267,91 +224,72 @@ func TestWhisperSymKeyManagement(x *testing.T) {
randomize(randomKey)
err = w.AddSymKey(id1, randomKey)
if err == nil {
x.Errorf("failed test case 10 with seed %d.", seed)
return
x.Fatalf("failed test case 10 with seed %d.", seed)
}
k1 = w.GetSymKey(id1)
k2 = w.GetSymKey(id2)
if !w.HasSymKey(id1) {
x.Errorf("failed HasIdentity 12.")
return
x.Fatalf("failed test case 12.")
}
if w.HasSymKey(id2) {
x.Errorf("failed HasIdentity 13.")
return
x.Fatalf("failed test case 13.")
}
if k1 == nil {
x.Errorf("failed GetIdentity 14.")
return
x.Fatalf("failed test case 14.")
}
if bytes.Compare(k1, randomKey) == 0 {
x.Errorf("failed GetIdentity 15: k1 == randomKey.")
return
x.Fatalf("failed test case 15: k1 == randomKey.")
}
if k2 != nil {
x.Errorf("failed GetIdentity 16.")
return
x.Fatalf("failed test case 16.")
}
err = w.AddSymKey(id2, randomKey) // add non-existing (yet)
if err != nil {
x.Errorf("failed test case 21 with seed %d: %s.", seed, err)
return
x.Fatalf("failed test case 21 with seed %d: %s.", seed, err)
}
k1 = w.GetSymKey(id1)
k2 = w.GetSymKey(id2)
if !w.HasSymKey(id1) {
x.Errorf("failed HasIdentity 22.")
return
x.Fatalf("failed test case 22.")
}
if !w.HasSymKey(id2) {
x.Errorf("failed HasIdentity 23.")
return
x.Fatalf("failed test case 23.")
}
if k1 == nil {
x.Errorf("failed GetIdentity 24.")
return
x.Fatalf("failed test case 24.")
}
if k2 == nil {
x.Errorf("failed GetIdentity 25.")
return
x.Fatalf("failed test case 25.")
}
if bytes.Compare(k1, k2) == 0 {
x.Errorf("failed GetIdentity 26.")
return
x.Fatalf("failed test case 26.")
}
if bytes.Compare(k1, randomKey) == 0 {
x.Errorf("failed GetIdentity 27.")
return
x.Fatalf("failed test case 27.")
}
if len(k1) != aesKeyLength {
x.Errorf("failed GetIdentity 28.")
return
x.Fatalf("failed test case 28.")
}
if len(k2) != aesKeyLength {
x.Errorf("failed GetIdentity 29.")
return
x.Fatalf("failed test case 29.")
}
w.DeleteSymKey(id1)
k1 = w.GetSymKey(id1)
k2 = w.GetSymKey(id2)
if w.HasSymKey(id1) {
x.Errorf("failed HasIdentity 31.")
return
x.Fatalf("failed test case 31.")
}
if !w.HasSymKey(id2) {
x.Errorf("failed HasIdentity 32.")
return
x.Fatalf("failed test case 32.")
}
if k1 != nil {
x.Errorf("failed GetIdentity 33.")
return
x.Fatalf("failed test case 33.")
}
if k2 == nil {
x.Errorf("failed GetIdentity 34.")
return
x.Fatalf("failed test case 34.")
}
w.DeleteSymKey(id1)
@ -359,19 +297,15 @@ func TestWhisperSymKeyManagement(x *testing.T) {
k1 = w.GetSymKey(id1)
k2 = w.GetSymKey(id2)
if w.HasSymKey(id1) {
x.Errorf("failed HasIdentity 41.")
return
x.Fatalf("failed test case 41.")
}
if w.HasSymKey(id2) {
x.Errorf("failed HasIdentity 42.")
return
x.Fatalf("failed test case 42.")
}
if k1 != nil {
x.Errorf("failed GetIdentity 43.")
return
x.Fatalf("failed test case 43.")
}
if k2 != nil {
x.Errorf("failed GetIdentity 44.")
return
x.Fatalf("failed test case 44.")
}
}