diff --git a/whisper/shhapi/api.go b/whisper/shhapi/api.go index a660f35d12..50a8eb34a7 100644 --- a/whisper/shhapi/api.go +++ b/whisper/shhapi/api.go @@ -155,7 +155,7 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber, } filter := whisperv5.Filter{ - Src: crypto.ToECDSAPub(common.FromHex(args.From)), + Src: crypto.ToECDSAPub(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(common.FromHex(args.To)) + dst := crypto.ToECDSAPub(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(common.FromHex(args.To)), + Dst: crypto.ToECDSAPub(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(common.FromHex(args.From)) + pub := crypto.ToECDSAPub(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(params.KeySym) == 0 { + if len(args.To) == 0 && len(args.KeyName) == 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(params.KeySym) != 0 { + if len(args.To) != 0 && len(args.KeyName) != 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 - From string - To string - KeyName string - Topic whisperv5.TopicType - Padding rpc.HexBytes - Payload rpc.HexBytes - WorkTime uint32 - PoW float64 - FilterID int - PeerID rpc.HexBytes + 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"` } func (args *PostArgs) UnmarshalJSON(data []byte) (err error) { var obj struct { TTL uint32 `json:"ttl"` - From string `json:"from"` - To string `json:"to"` + From rpc.HexBytes `json:"from"` + To rpc.HexBytes `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:"filterID"` - PeerID rpc.HexBytes `json:"peerID"` + FilterID rpc.HexBytes `json:"filter"` + PeerID rpc.HexBytes `json:"directP2P"` } if err := json.Unmarshal(data, &obj); err != nil { @@ -420,8 +420,8 @@ func (args *PostArgs) UnmarshalJSON(data []byte) (err error) { } type WhisperFilterArgs struct { - To string - From string + To []byte + From []byte 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 string `json:"to"` - From string `json:"from"` + To rpc.HexBytes `json:"to"` + From rpc.HexBytes `json:"from"` KeyName string `json:"keyname"` PoW float64 `json:"pow"` Topics []interface{} `json:"topics"` diff --git a/whisper/shhapi/api_test.go b/whisper/shhapi/api_test.go index 820d4f01d8..8ce198595e 100644 --- a/whisper/shhapi/api_test.go +++ b/whisper/shhapi/api_test.go @@ -17,11 +17,8 @@ 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" ) @@ -30,64 +27,78 @@ func TestBasic(x *testing.T) { var id string = "test" api := NewPublicWhisperAPI() if api == nil { - x.Fatalf("failed to create API.") + x.Errorf("failed to create API.") + return } ver, err := api.Version() if err != nil { - x.Fatalf("failed generateFilter: %s.", err) + x.Errorf("failed generateFilter: %s.", err) + return } if ver.Uint64() != whisperv5.ProtocolVersion { - x.Fatalf("wrong version: %d.", ver.Uint64()) + x.Errorf("wrong version: %d.", ver.Uint64()) + return } var hexnum rpc.HexNumber mail := api.GetFilterChanges(hexnum) if len(mail) != 0 { - x.Fatalf("failed GetFilterChanges") + x.Errorf("failed GetFilterChanges") + return } exist, err := api.HasIdentity(id) if err != nil { - x.Fatalf("failed test case 1: %s.", err) + x.Errorf("failed 1 HasIdentity: %s.", err) + return } if exist { - x.Fatalf("failed test case 2, HasIdentity: false positive.") + x.Errorf("failed 2 HasIdentity: false positive.") + return } err = api.DeleteIdentity(id) if err != nil { - x.Fatalf("failed test case 3: %s.", err) + x.Errorf("failed 3 DeleteIdentity: %s.", err) + return } pub, err := api.NewIdentity() if err != nil { - x.Fatalf("failed test case 4: %s.", err) + x.Errorf("failed 4 NewIdentity: %s.", err) + return } if len(pub) == 0 { - x.Fatalf("test case 5, NewIdentity: empty") + x.Errorf("NewIdentity 5: empty") + return } exist, err = api.HasIdentity(pub) if err != nil { - x.Fatalf("failed test case 6: %s.", err) + x.Errorf("failed 6 HasIdentity: %s.", err) + return } if !exist { - x.Fatalf("failed test case 7, HasIdentity: false negative.") + x.Errorf("failed 7 HasIdentity: false negative.") + return } err = api.DeleteIdentity(pub) if err != nil { - x.Fatalf("failed 8 DeleteIdentity: %s.", err) + x.Errorf("failed 8 DeleteIdentity: %s.", err) + return } exist, err = api.HasIdentity(pub) if err != nil { - x.Fatalf("failed test case 9: %s.", err) + x.Errorf("failed 9 HasIdentity: %s.", err) + return } if exist { - x.Fatalf("failed test case 10, HasIdentity: false positive.") + x.Errorf("failed 10 HasIdentity: false positive.") + return } id = "arbitrary text" @@ -95,468 +106,65 @@ func TestBasic(x *testing.T) { exist, err = api.HasSymKey(id) if err != nil { - x.Fatalf("failed test case 11: %s.", err) + x.Errorf("failed 11 HasSymKey: %s.", err) + return } if exist { - x.Fatalf("failed test case 12, HasSymKey: false positive.") + x.Errorf("failed 12 HasSymKey: false positive.") + return } err = api.GenerateSymKey(id) if err != nil { - x.Fatalf("failed 13 GenerateSymKey: %s.", err) + x.Errorf("failed 13 GenerateSymKey: %s.", err) + return } exist, err = api.HasSymKey(id) if err != nil { - x.Fatalf("failed test case 14: %s.", err) + x.Errorf("failed 14 HasSymKey: %s.", err) + return } if !exist { - x.Fatalf("failed test case 15, HasSymKey: false negative.") + x.Errorf("failed 15 HasSymKey: false negative.") + return } err = api.AddSymKey(id, []byte("some stuff here")) if err == nil { - x.Fatalf("failed test case 16: %s.", err) + x.Errorf("failed 16 AddSymKey: %s.", err) + return } err = api.AddSymKey(id2, []byte("some stuff here")) if err != nil { - x.Fatalf("failed test case 17: %s.", err) + x.Errorf("failed 17 AddSymKey: %s.", err) + return } exist, err = api.HasSymKey(id2) if err != nil { - x.Fatalf("failed test case 18: %s.", err) + x.Errorf("failed 18 HasSymKey: %s.", err) + return } if !exist { - x.Fatalf("failed test case 19, HasSymKey: false negative.") + x.Errorf("failed 19 HasSymKey: false negative.") + return } err = api.DeleteSymKey(id) if err != nil { - x.Fatalf("failed test case 20: %s.", err) + x.Errorf("failed 20 DeleteSymKey: %s.", err) + return } exist, err = api.HasSymKey(id) if err != nil { - x.Fatalf("failed test case 21: %s.", err) + x.Errorf("failed 21 HasSymKey: %s.", err) + return } if exist { - 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) + x.Errorf("failed 22 HasSymKey: false positive.") + return } } diff --git a/whisper/whisperv5/benchmarks_test.go b/whisper/whisperv5/benchmarks_test.go index f2eef3c471..8bb6c05745 100644 --- a/whisper/whisperv5/benchmarks_test.go +++ b/whisper/whisperv5/benchmarks_test.go @@ -40,7 +40,8 @@ func BenchmarkEncryptionSym(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } for i := 0; i < b.N; i++ { @@ -59,11 +60,13 @@ func BenchmarkEncryptionAsym(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } key, err := crypto.GenerateKey() if err != nil { - b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } params.KeySym = nil params.Dst = &key.PublicKey @@ -72,7 +75,8 @@ func BenchmarkEncryptionAsym(b *testing.B) { msg := NewSentMessage(params) _, err := msg.Wrap(params) if err != nil { - b.Fatalf("failed Wrap with seed %d: %s.", seed, err) + b.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } } } @@ -82,19 +86,22 @@ func BenchmarkDecryptionSymValid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Fatalf("failed Wrap with seed %d: %s.", seed, err) + b.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } f := Filter{KeySym: params.KeySym} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg == nil { - b.Fatalf("failed to open with seed %d.", seed) + b.Errorf("failed to open with seed %d.", seed) + return } } } @@ -104,19 +111,22 @@ func BenchmarkDecryptionSymInvalid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Fatalf("failed Wrap with seed %d: %s.", seed, err) + b.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } f := Filter{KeySym: []byte("arbitrary stuff here")} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg != nil { - b.Fatalf("opened envelope with invalid key, seed: %d.", seed) + b.Errorf("opened envelope with invalid key, seed: %d.", seed) + return } } } @@ -126,11 +136,13 @@ func BenchmarkDecryptionAsymValid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } key, err := crypto.GenerateKey() if err != nil { - b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } f := Filter{KeyAsym: key} params.KeySym = nil @@ -138,13 +150,15 @@ func BenchmarkDecryptionAsymValid(b *testing.B) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Fatalf("failed Wrap with seed %d: %s.", seed, err) + b.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg == nil { - b.Fatalf("fail to open, seed: %d.", seed) + b.Errorf("fail to open, seed: %d.", seed) + return } } } @@ -154,30 +168,35 @@ func BenchmarkDecryptionAsymInvalid(b *testing.B) { params, err := generateMessageParams() if err != nil { - b.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + b.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } key, err := crypto.GenerateKey() if err != nil { - b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } params.KeySym = nil params.Dst = &key.PublicKey msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - b.Fatalf("failed Wrap with seed %d: %s.", seed, err) + b.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } key, err = crypto.GenerateKey() if err != nil { - b.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + b.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } f := Filter{KeyAsym: key} for i := 0; i < b.N; i++ { msg := env.Open(&f) if msg != nil { - b.Fatalf("opened envelope with invalid key, seed: %d.", seed) + b.Errorf("opened envelope with invalid key, seed: %d.", seed) + return } } } diff --git a/whisper/whisperv5/doc.go b/whisper/whisperv5/doc.go index 6bce5a59e5..ef3b93d12a 100644 --- a/whisper/whisperv5/doc.go +++ b/whisper/whisperv5/doc.go @@ -46,7 +46,7 @@ const ( messagesCode = 1 p2pCode = 2 mailRequestCode = 3 - NumberOfMessageCodes = 10 + NumberOfMessageCodes = 4 paddingMask = byte(3) signatureFlag = byte(4) diff --git a/whisper/whisperv5/filter.go b/whisper/whisperv5/filter.go index 2c61bde99f..5cc7be5874 100644 --- a/whisper/whisperv5/filter.go +++ b/whisper/whisperv5/filter.go @@ -143,9 +143,18 @@ func (f *Filter) MatchMessage(msg *ReceivedMessage) bool { } if f.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() { - return isPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst) && f.MatchTopic(msg.Topic) + // if Dst match, ignore the topic + return isPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst) } else if f.expectsSymmetricEncryption() && msg.isSymmetricEncryption() { - return f.SymKeyHash == msg.SymKeyHash && f.MatchTopic(msg.Topic) + // 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 false } @@ -155,25 +164,25 @@ func (f *Filter) MatchEnvelope(envelope *Envelope) bool { return false } + encryptionMethodMatch := false if f.expectsAsymmetricEncryption() && envelope.isAsymmetric() { - return f.MatchTopic(envelope.Topic) - } else if f.expectsSymmetricEncryption() && envelope.IsSymmetric() { - return f.MatchTopic(envelope.Topic) - } - return false -} - -func (f *Filter) MatchTopic(topic TopicType) bool { - if len(f.Topics) == 0 { - // any topic matches - return true - } - - for _, t := range f.Topics { - if t == topic { + encryptionMethodMatch = true + if f.Topics == nil { + // wildcard return true } + } else if f.expectsSymmetricEncryption() && envelope.IsSymmetric() { + encryptionMethodMatch = true } + + if encryptionMethodMatch { + for _, t := range f.Topics { + if t == envelope.Topic { + return true + } + } + } + return false } diff --git a/whisper/whisperv5/filter_test.go b/whisper/whisperv5/filter_test.go index 8406d813a0..8c25b05190 100644 --- a/whisper/whisperv5/filter_test.go +++ b/whisper/whisperv5/filter_test.go @@ -61,7 +61,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) { key, err := crypto.GenerateKey() if err != nil { - x.Fatalf("generateFilter 1 failed with seed %d.", seed) + x.Errorf("generateFilter failed 1 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.Fatalf("generateFilter 2 failed with seed %d.", seed) + x.Errorf("generateFilter failed 2 with seed %d.", seed) return nil, err } } @@ -107,7 +107,8 @@ func TestInstallFilters(x *testing.T) { } if j < SizeTestFilters-1 { - x.Fatalf("seed %d: wrong index %d", seed, j) + x.Errorf("seed %d: wrong index %d", seed, j) + return } for _, t := range tst { @@ -120,10 +121,12 @@ func TestInstallFilters(x *testing.T) { fil := filters.Get(t.id) exist := (fil != nil) if exist != t.alive { - x.Fatalf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive) + x.Errorf("seed %d: failed alive: %d, %v, %v", seed, i, exist, t.alive) + return } if exist && fil.PoW != t.f.PoW { - x.Fatalf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive) + x.Errorf("seed %d: failed Get: %d, %v, %v", seed, i, exist, t.alive) + return } } } @@ -133,24 +136,29 @@ func TestComparePubKey(x *testing.T) { key1, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey 1 with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey 1 with seed %d: %s.", seed, err) + return } key2, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey 2 with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey 2 with seed %d: %s.", seed, err) + return } if isPubKeyEqual(&key1.PublicKey, &key2.PublicKey) { - x.Fatalf("failed !equal with seed %d.", seed) + x.Errorf("failed !equal with seed %d.", seed) + return } // generate key3 == key1 rand.Seed(seed) key3, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey 3 with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey 3 with seed %d: %s.", seed, err) + return } if isPubKeyEqual(&key1.PublicKey, &key3.PublicKey) { - x.Fatalf("failed equal with seed %d.", seed) + x.Errorf("failed equal with seed %d.", seed) + return } } @@ -159,17 +167,20 @@ func TestMatchEnvelope(x *testing.T) { fsym, err := generateFilter(x, true) if err != nil { - x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err) + x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err) + return } fasym, err := generateFilter(x, false) if err != nil { - x.Fatalf("failed generateFilter 2 with seed %d: %s.", seed, err) + x.Errorf("failed generateFilter 2 with seed %d: %s.", seed, err) + return } params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams 3 with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams 3 with seed %d: %s.", seed, err) + return } params.Topic[0] = 0xFF // ensure mismatch @@ -178,15 +189,18 @@ func TestMatchEnvelope(x *testing.T) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Fatalf("failed Wrap 4 with seed %d: %s.", seed, err) + x.Errorf("failed Wrap 4 with seed %d: %s.", seed, err) + return } match := fsym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 5 with seed %d.", seed) + x.Errorf("failed test case 5 with seed %d.", seed) + return } match = fasym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 6 with seed %d.", seed) + x.Errorf("failed test case 6 with seed %d.", seed) + return } // encrypt symmetrically @@ -196,109 +210,109 @@ func TestMatchEnvelope(x *testing.T) { msg = NewSentMessage(params) env, err = msg.Wrap(params) if err != nil { - x.Fatalf("failed test case 7 with seed %d, test case 3: %s.", seed, err) + x.Errorf("failed test case 7 with seed %d, test case 3: %s.", seed, err) + return } // symmetric + matching topic: match match = fsym.MatchEnvelope(env) if !match { - x.Fatalf("failed test case 8 with seed %d.", seed) + x.Errorf("failed test case 8 with seed %d.", seed) + return } // asymmetric + matching topic: mismatch match = fasym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 9 with seed %d.", seed) + x.Errorf("failed test case 9 with seed %d.", seed) + return } // symmetric + matching topic + insufficient PoW: mismatch fsym.PoW = env.PoW() + 1.0 match = fsym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 10 with seed %d.", seed) + x.Errorf("failed test case 10 with seed %d.", seed) + return } // symmetric + matching topic + sufficient PoW: match fsym.PoW = env.PoW() / 2 match = fsym.MatchEnvelope(env) if !match { - x.Fatalf("failed test case 11 with seed %d.", seed) + x.Errorf("failed test case 11 with seed %d.", seed) + return } - // symmetric + topics are nil (wildcard): match + // symmetric + topics are nil: mismatch prevTopics := fsym.Topics fsym.Topics = nil - match = fsym.MatchEnvelope(env) - if !match { - x.Fatalf("failed test case 12 with seed %d.", seed) + match = fasym.MatchEnvelope(env) + if match { + x.Errorf("failed test case 12 with seed %d.", seed) + return } fsym.Topics = prevTopics // encrypt asymmetrically key, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err) + return } params.KeySym = nil params.Dst = &key.PublicKey msg = NewSentMessage(params) env, err = msg.Wrap(params) if err != nil { - x.Fatalf("failed test case 14 with seed %d, test case 3: %s.", seed, err) + x.Errorf("failed test case 14 with seed %d, test case 3: %s.", seed, err) + return } // encryption method mismatch match = fsym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 15 with seed %d.", seed) + x.Errorf("failed test case 15 with seed %d.", seed) + return } // asymmetric + mismatching topic: mismatch match = fasym.MatchEnvelope(env) if !match { - x.Fatalf("failed test case 16 with seed %d.", seed) + x.Errorf("failed test case 16 with seed %d.", seed) + return } // asymmetric + matching topic: match fasym.Topics[i] = fasym.Topics[i+1] match = fasym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 17 with seed %d.", seed) + x.Errorf("failed test case 17 with seed %d.", seed) + return } - // asymmetric + filter without topic (wildcard): match + // asymmetric + topic is nil (wildcard): match fasym.Topics = nil match = fasym.MatchEnvelope(env) if !match { - x.Fatalf("failed test case 18 with seed %d.", seed) + x.Errorf("failed test case 18 with seed %d.", seed) + return } // asymmetric + insufficient PoW: mismatch fasym.PoW = env.PoW() + 1.0 match = fasym.MatchEnvelope(env) if match { - x.Fatalf("failed test case 19 with seed %d.", seed) + x.Errorf("failed test case 19 with seed %d.", seed) + return } // asymmetric + sufficient PoW: match fasym.PoW = env.PoW() / 2 match = fasym.MatchEnvelope(env) if !match { - 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) + x.Errorf("failed test case 20 with seed %d.", seed) + return } } @@ -307,12 +321,14 @@ func TestMatchMessageSym(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } f, err := generateFilter(x, true) if err != nil { - x.Fatalf("failed generateFilter 1 with seed %d: %s.", seed, err) + x.Errorf("failed generateFilter 1 with seed %d: %s.", seed, err) + return } const index = 1 @@ -322,77 +338,90 @@ func TestMatchMessageSym(x *testing.T) { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Fatalf("failed Wrap 2 with seed %d: %s.", seed, err) + x.Errorf("failed Wrap 2 with seed %d: %s.", seed, err) + return } msg := env.Open(f) if msg == nil { - x.Fatalf("failed to open 3 with seed %d.", seed) + x.Errorf("failed to open 3 with seed %d.", seed) + return } // Src mismatch if f.MatchMessage(msg) { - x.Fatalf("failed test case 4 with seed %d.", seed) + x.Errorf("failed test case 4 with seed %d.", seed) + return } // Src: match *f.Src.X = *params.Src.PublicKey.X *f.Src.Y = *params.Src.PublicKey.Y if !f.MatchMessage(msg) { - x.Fatalf("failed test case 5 with seed %d.", seed) + x.Errorf("failed test case 5 with seed %d.", seed) + return } // insufficient PoW: mismatch f.PoW = msg.PoW + 1.0 if f.MatchMessage(msg) { - x.Fatalf("failed test case 6 with seed %d.", seed) + x.Errorf("failed test case 6 with seed %d.", seed) + return } // sufficient PoW: match f.PoW = msg.PoW / 2 if !f.MatchMessage(msg) { - x.Fatalf("failed test case 7 with seed %d.", seed) + x.Errorf("failed test case 7 with seed %d.", seed) + return } // topic mismatch f.Topics[index][0]++ if f.MatchMessage(msg) { - x.Fatalf("failed test case 8 with seed %d.", seed) + x.Errorf("failed test case 8 with seed %d.", seed) + return } f.Topics[index][0]-- // key mismatch f.SymKeyHash[0]++ if f.MatchMessage(msg) { - x.Fatalf("failed test case 9 with seed %d.", seed) + x.Errorf("failed test case 9 with seed %d.", seed) + return } f.SymKeyHash[0]-- // Src absent: match f.Src = nil if !f.MatchMessage(msg) { - x.Fatalf("failed test case 10 with seed %d.", seed) + x.Errorf("failed test case 10 with seed %d.", seed) + return } // key hash mismatch mismatch h := f.SymKeyHash f.SymKeyHash = common.Hash{} if f.MatchMessage(msg) { - x.Fatalf("failed test case 11 with seed %d.", seed) + x.Errorf("failed test case 11 with seed %d.", seed) + return } f.SymKeyHash = h if !f.MatchMessage(msg) { - x.Fatalf("failed test case 12 with seed %d.", seed) + x.Errorf("failed test case 12 with seed %d.", seed) + return } // encryption method mismatch f.KeySym = nil f.KeyAsym, err = crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey 13 with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey 13 with seed %d: %s.", seed, err) + return } if f.MatchMessage(msg) { - x.Fatalf("failed test case 14 with seed %d.", seed) + x.Errorf("failed test case 14 with seed %d.", seed) + return } } @@ -401,12 +430,14 @@ func TestMatchMessageAsym(x *testing.T) { f, err := generateFilter(x, false) if err != nil { - x.Fatalf("failed generateFilter with seed %d: %s.", seed, err) + x.Errorf("failed generateFilter with seed %d: %s.", seed, err) + return } params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } const index = 1 @@ -418,42 +449,50 @@ func TestMatchMessageAsym(x *testing.T) { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Fatalf("failed Wrap with seed %d: %s.", seed, err) + x.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } msg := env.Open(f) if msg == nil { - x.Fatalf("failed to open with seed %d.", seed) + x.Errorf("failed to open with seed %d.", seed) + return } // Src mismatch if f.MatchMessage(msg) { - x.Fatalf("failed test case 4 with seed %d.", seed) + x.Errorf("failed test case 4 with seed %d.", seed) + return } // Src: match *f.Src.X = *params.Src.PublicKey.X *f.Src.Y = *params.Src.PublicKey.Y if !f.MatchMessage(msg) { - x.Fatalf("failed test case 5 with seed %d.", seed) + x.Errorf("failed test case 5 with seed %d.", seed) + return } // insufficient PoW: mismatch f.PoW = msg.PoW + 1.0 if f.MatchMessage(msg) { - x.Fatalf("failed test case 6 with seed %d.", seed) + x.Errorf("failed test case 6 with seed %d.", seed) + return } // sufficient PoW: match f.PoW = msg.PoW / 2 if !f.MatchMessage(msg) { - x.Fatalf("failed test case 7 with seed %d.", seed) + x.Errorf("failed test case 7 with seed %d.", seed) + return } - // topic mismatch + // topic mismatch, but still match, because for asymmetric encryption + // only private key matters (in case the message is already decrypted) f.Topics[index][0]++ - if f.MatchMessage(msg) { - x.Fatalf("failed test case 8 with seed %d.", seed) + if !f.MatchMessage(msg) { + x.Errorf("failed test case 8 with seed %d.", seed) + return } f.Topics[index][0]-- @@ -462,21 +501,24 @@ func TestMatchMessageAsym(x *testing.T) { zero := *big.NewInt(0) *f.KeyAsym.PublicKey.X = zero if f.MatchMessage(msg) { - x.Fatalf("failed test case 9 with seed %d.", seed) + x.Errorf("failed test case 9 with seed %d.", seed) + return } *f.KeyAsym.PublicKey.X = prev // Src absent: match f.Src = nil if !f.MatchMessage(msg) { - x.Fatalf("failed test case 10 with seed %d.", seed) + x.Errorf("failed test case 10 with seed %d.", seed) + return } // encryption method mismatch f.KeySym = keySymOrig f.KeyAsym = nil if f.MatchMessage(msg) { - x.Fatalf("failed test case 11 with seed %d.", seed) + x.Errorf("failed test case 11 with seed %d.", seed) + return } } @@ -496,7 +538,7 @@ func cloneFilter(orig *Filter) *Filter { func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams 77 with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams 77 with seed %d: %s.", seed, err) return nil } @@ -505,7 +547,7 @@ func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope { sentMessage := NewSentMessage(params) env, err := sentMessage.Wrap(params) if err != nil { - x.Fatalf("failed Wrap 78 with seed %d: %s.", seed, err) + x.Errorf("failed Wrap 78 with seed %d: %s.", seed, err) return nil } return env @@ -553,17 +595,20 @@ func TestWatchers(x *testing.T) { } if total != NumMessages { - x.Fatalf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages) + x.Errorf("failed test case 1 with seed %d: total = %d, want: %d.", seed, total, NumMessages) + return } for i = 0; i < NumFilters; i++ { mail = tst[i].f.Retrieve() if len(mail) != 0 { - x.Fatalf("failed test case 2 with seed %d: i = %d.", seed, i) + x.Errorf("failed test case 2 with seed %d: i = %d.", seed, i) + return } if tst[i].msgCnt != count[i] { - x.Fatalf("failed test case 3 with seed %d: i = %d, get %d, want %d.", seed, i, 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 } } @@ -603,25 +648,30 @@ func TestWatchers(x *testing.T) { combined := tst[0].msgCnt + tst[last].msgCnt if total != NumMessages+count[0] { - x.Fatalf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0]) + x.Errorf("failed test case 4 with seed %d: total = %d, count[0] = %d.", seed, total, count[0]) + return } if combined != count[0] { - x.Fatalf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0]) + x.Errorf("failed test case 5 with seed %d: combined = %d, count[0] = %d.", seed, combined, count[0]) + return } if combined != count[last] { - x.Fatalf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last]) + x.Errorf("failed test case 6 with seed %d: combined = %d, count[last] = %d.", seed, combined, count[last]) + return } for i = 1; i < NumFilters-1; i++ { mail = tst[i].f.Retrieve() if len(mail) != 0 { - x.Fatalf("failed test case 7 with seed %d: i = %d.", seed, i) + x.Errorf("failed test case 7 with seed %d: i = %d.", seed, i) + return } if tst[i].msgCnt != count[i] { - x.Fatalf("failed test case 8 with seed %d: i = %d, get %d, want %d.", seed, i, 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 } } @@ -636,7 +686,8 @@ func TestWatchers(x *testing.T) { } if total != 0 { - x.Fatalf("failed test case 9 with seed %d.", seed) + x.Errorf("failed test case 9 with seed %d.", seed) + return } f := filters.Get(0) @@ -650,6 +701,7 @@ func TestWatchers(x *testing.T) { } if total != 1 { - x.Fatalf("failed test case 10 with seed %d: total = %d.", seed, total) + x.Errorf("failed test case 10 with seed %d: total = %d.", seed, total) + return } } diff --git a/whisper/whisperv5/message_test.go b/whisper/whisperv5/message_test.go index ed180132ed..78041fc1a2 100644 --- a/whisper/whisperv5/message_test.go +++ b/whisper/whisperv5/message_test.go @@ -60,12 +60,14 @@ func generateMessageParams() (*MessageParams, error) { func singleMessageTest(x *testing.T, symmetric bool) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } key, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } if !symmetric { @@ -83,7 +85,8 @@ func singleMessageTest(x *testing.T, symmetric bool) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Fatalf("failed Wrap with seed %d: %s.", seed, err) + x.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } var decrypted *ReceivedMessage @@ -94,28 +97,35 @@ func singleMessageTest(x *testing.T, symmetric bool) { } if err != nil { - x.Fatalf("failed to encrypt with seed %d: %s.", seed, err) + x.Errorf("failed to encrypt with seed %d: %s.", seed, err) + return } if !decrypted.Validate() { - x.Fatalf("failed to validate with seed %d.", seed) + x.Errorf("failed to validate with seed %d.", seed) + return } padsz := len(decrypted.Padding) if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { - x.Fatalf("failed with seed %d: compare padding.", seed) + x.Errorf("failed with seed %d: compare padding.", seed) + return } if bytes.Compare(text, decrypted.Payload) != 0 { - x.Fatalf("failed with seed %d: compare payload.", seed) + x.Errorf("failed with seed %d: compare payload.", seed) + return } if !isMessageSigned(decrypted.Raw[0]) { - x.Fatalf("failed with seed %d: unsigned.", seed) + x.Errorf("failed with seed %d: unsigned.", seed) + return } if len(decrypted.Signature) != signatureLength { - x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) + x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) + return } if !isPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { - x.Fatalf("failed with seed %d: signature mismatch.", seed) + x.Errorf("failed with seed %d: signature mismatch.", seed) + return } } @@ -136,7 +146,8 @@ func TestMessageWrap(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } msg := NewSentMessage(params) @@ -145,12 +156,14 @@ func TestMessageWrap(x *testing.T) { params.PoW = target env, err := msg.Wrap(params) if err != nil { - x.Fatalf("failed Wrap with seed %d: %s.", seed, err) + x.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } pow := env.PoW() if pow < target { - x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) + x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) + return } } @@ -161,7 +174,8 @@ func TestMessageSeal(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } msg := NewSentMessage(params) @@ -173,7 +187,8 @@ func TestMessageSeal(x *testing.T) { env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg) if err != nil { - x.Fatalf("failed Wrap with seed %d: %s.", seed, err) + x.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } env.Expiry = uint32(seed) // make it deterministic @@ -185,7 +200,8 @@ func TestMessageSeal(x *testing.T) { env.calculatePoW(0) pow := env.PoW() if pow < target { - x.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) + x.Errorf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) + return } params.WorkTime = 1 @@ -194,7 +210,8 @@ func TestMessageSeal(x *testing.T) { env.calculatePoW(0) pow = env.PoW() if pow < 2*target { - x.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow) + x.Errorf("failed Wrap with seed %d: pow too small %f.", seed, pow) + return } } @@ -211,12 +228,14 @@ func TestEnvelopeOpen(x *testing.T) { func singleEnvelopeOpenTest(x *testing.T, symmetric bool) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) + x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err) + return } key, err := crypto.GenerateKey() if err != nil { - x.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) + x.Errorf("failed GenerateKey with seed %d: %s.", seed, err) + return } if !symmetric { @@ -234,43 +253,54 @@ func singleEnvelopeOpenTest(x *testing.T, symmetric bool) { msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Fatalf("failed Wrap with seed %d: %s.", seed, err) + x.Errorf("failed Wrap with seed %d: %s.", seed, err) + return } f := Filter{KeyAsym: key, KeySym: params.KeySym} decrypted := env.Open(&f) if decrypted == nil { - x.Fatalf("failed to open with seed %d.", seed) + x.Errorf("failed to open with seed %d.", seed) + return } padsz := len(decrypted.Padding) if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { - x.Fatalf("failed with seed %d: compare padding.", seed) + x.Errorf("failed with seed %d: compare padding.", seed) + return } if bytes.Compare(text, decrypted.Payload) != 0 { - x.Fatalf("failed with seed %d: compare payload.", seed) + x.Errorf("failed with seed %d: compare payload.", seed) + return } if !isMessageSigned(decrypted.Raw[0]) { - x.Fatalf("failed with seed %d: unsigned.", seed) + x.Errorf("failed with seed %d: unsigned.", seed) + return } if len(decrypted.Signature) != signatureLength { - x.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) + x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) + return } if !isPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { - x.Fatalf("failed with seed %d: signature mismatch.", seed) + x.Errorf("failed with seed %d: signature mismatch.", seed) + return } if decrypted.isAsymmetricEncryption() == symmetric { - x.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric) + x.Errorf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric) + return } if decrypted.isSymmetricEncryption() != symmetric { - x.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric) + x.Errorf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric) + return } if !symmetric { if decrypted.Dst == nil { - x.Fatalf("failed with seed %d: dst is nil.", seed) + x.Errorf("failed with seed %d: dst is nil.", seed) + return } if !isPubKeyEqual(decrypted.Dst, &key.PublicKey) { - x.Fatalf("failed with seed %d: Dst.", seed) + x.Errorf("failed with seed %d: Dst.", seed) + return } } } diff --git a/whisper/whisperv5/peer_test.go b/whisper/whisperv5/peer_test.go index d4893bacd7..03c4725d8e 100644 --- a/whisper/whisperv5/peer_test.go +++ b/whisper/whisperv5/peer_test.go @@ -124,7 +124,8 @@ func initialize(x *testing.T) { node.filerId = node.shh.Watch(&f) node.id, err = crypto.HexToECDSA(keys[i]) if err != nil { - x.Fatalf("failed convert the key: %s.", keys[i]) + x.Errorf("failed convert the key: %s.", keys[i]) + return } port := port0 + i addr := fmt.Sprintf(":%d", port) // e.g. ":30303" @@ -154,7 +155,8 @@ func initialize(x *testing.T) { err = node.server.Start() if err != nil { - x.Fatalf("failed to start server %d.", i) + x.Errorf("failed to start server %d.", i) + return } nodes[i] = &node @@ -185,7 +187,8 @@ func checkPropagation(x *testing.T) { for i := 0; i < NumNodes; i++ { f := nodes[i].shh.GetFilter(nodes[i].filerId) if f == nil { - x.Fatalf("failed to get filterId %d from node %d.", nodes[i].filerId, i) + x.Errorf("failed to get filterId %d from node %d.", nodes[i].filerId, i) + return } mail := f.Retrieve() @@ -194,12 +197,13 @@ func checkPropagation(x *testing.T) { } if isTestComplete() { + return } } } - x.Fatalf("Test was not complete: timeout %d seconds.", iterations*cycle/1000) + x.Errorf("Test was not complete: timeout %d seconds.", iterations*cycle/1000) } func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { @@ -215,7 +219,7 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { return true } if cnt > 1 { - x.Fatalf("node %d received %d.", index, cnt) + x.Errorf("node %d received %d.", index, cnt) return false } @@ -224,7 +228,8 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool { defer result.mutex.Unlock() result.counter[index] += cnt if result.counter[index] > 1 { - x.Fatalf("node %d accumulated %d.", index, result.counter[index]) + x.Errorf("node %d accumulated %d.", index, result.counter[index]) + return false } } return true @@ -265,12 +270,14 @@ func sendMsg(x *testing.T, expected bool, id int) { msg := NewSentMessage(&opt) envelope, err := msg.Wrap(&opt) if err != nil { - x.Fatalf("failed to seal message.") + x.Errorf("failed to seal message.") + return } err = nodes[id].shh.Send(envelope) if err != nil { - x.Fatalf("failed to send message.") + x.Errorf("failed to send message.") + return } } @@ -279,19 +286,22 @@ func TestPeerBasic(x *testing.T) { params, err := generateMessageParams() if err != nil { - x.Fatalf("failed generateMessageParams with seed %d.", seed) + x.Errorf("failed 1 with seed %d.", seed) + return } params.PoW = 0.001 msg := NewSentMessage(params) env, err := msg.Wrap(params) if err != nil { - x.Fatalf("failed Wrap with seed %d.", seed) + x.Errorf("failed 2 with seed %d.", seed) + return } p := newPeer(nil, nil, nil) p.mark(env) if !p.marked(env) { - x.Fatalf("failed mark with seed %d.", seed) + x.Errorf("failed 3 with seed %d.", seed) + return } } diff --git a/whisper/whisperv5/topic_test.go b/whisper/whisperv5/topic_test.go index f3a572afbf..c2a940b79a 100644 --- a/whisper/whisperv5/topic_test.go +++ b/whisper/whisperv5/topic_test.go @@ -32,7 +32,7 @@ func TestTopicString(x *testing.T) { for i, tst := range topicStringTests { s := tst.topic.String() if s != tst.str { - x.Fatalf("failed test %d: have %s, want %s.", i, s, tst.str) + x.Errorf("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.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Errorf("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.Fatalf("failed test %d. input: %v.", i, tst.data) + x.Errorf("failed test %d. input: %v.", i, tst.data) } else if t != tst.topic { - x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Errorf("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.Fatalf("failed test %d. input: %v.", i, tst.data) + x.Errorf("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.Fatalf("failed test %d. input: %v.", i, tst.data) + x.Errorf("failed test %d. input: %v.", i, tst.data) } else if t == tst.topic { - x.Fatalf("failed test %d: have %v, want %v.", i, t, tst.topic) + x.Errorf("failed test %d: have %v, want %v.", i, t, tst.topic) } } } diff --git a/whisper/whisperv5/whisper_test.go b/whisper/whisperv5/whisper_test.go index 4892d2e3a1..1db26265a5 100644 --- a/whisper/whisperv5/whisper_test.go +++ b/whisper/whisperv5/whisper_test.go @@ -29,92 +29,114 @@ func TestWhisperBasic(x *testing.T) { p := w.Protocols() shh := p[0] if shh.Name != ProtocolName { - x.Fatalf("failed Protocol Name: %v.", shh.Name) + x.Errorf("failed Protocol Name: %v.", shh.Name) + return } if uint64(shh.Version) != ProtocolVersion { - x.Fatalf("failed Protocol Version: %v.", shh.Version) + x.Errorf("failed Protocol Version: %v.", shh.Version) + return } if shh.Length != NumberOfMessageCodes { - x.Fatalf("failed Protocol Length: %v.", shh.Length) + x.Errorf("failed Protocol Length: %v.", shh.Length) + return } if shh.Run == nil { - x.Fatalf("failed shh.Run.") + x.Errorf("failed shh.Run.") + return } if uint64(w.Version()) != ProtocolVersion { - x.Fatalf("failed whisper Version: %v.", shh.Version) + x.Errorf("failed whisper Version: %v.", shh.Version) + return } if w.GetFilter(0) != nil { - x.Fatalf("failed GetFilter.") + x.Errorf("failed GetFilter.") + return } peerID := make([]byte, 64) randomize(peerID) peer, err := w.getPeer(peerID) if peer != nil { - x.Fatalf("failed GetPeer.") + x.Errorf("failed GetPeer.") + return } err = w.MarkPeerTrusted(peerID) if err == nil { - x.Fatalf("failed MarkPeerTrusted.") + x.Errorf("failed MarkPeerTrusted.") + return } err = w.RequestHistoricMessages(peerID, peerID) if err == nil { - x.Fatalf("failed RequestHistoricMessages.") + x.Errorf("failed RequestHistoricMessages.") + return } err = w.SendP2PMessage(peerID, nil) if err == nil { - x.Fatalf("failed SendP2PMessage.") + x.Errorf("failed SendP2PMessage.") + return } exist := w.HasSymKey("non-existing") if exist { - x.Fatalf("failed HasSymKey.") + x.Errorf("failed HasSymKey.") + return } key := w.GetSymKey("non-existing") if key != nil { - x.Fatalf("failed GetSymKey.") + x.Errorf("failed GetSymKey.") + return } mail := w.Envelopes() if len(mail) != 0 { - x.Fatalf("failed w.Envelopes().") + x.Errorf("failed w.Envelopes().") + return } m := w.Messages(0) if len(m) != 0 { - x.Fatalf("failed w.Messages.") + x.Errorf("failed w.Messages.") + return } var derived []byte ver := uint64(0xDEADBEEF) derived, err = deriveKeyMaterial(peerID, ver) if err != unknownVersionError(ver) { - x.Fatalf("failed deriveKeyMaterial test case 1 with param = %v: %s.", peerID, err) + x.Errorf("failed deriveKeyMaterial 1 with param = %v: %s.", peerID, err) + return } derived, err = deriveKeyMaterial(peerID, 0) if err != nil { - x.Fatalf("failed deriveKeyMaterial test case 2 with param = %v: %s.", peerID, err) + x.Errorf("failed deriveKeyMaterial 2 with param = %v: %s.", peerID, err) + return } if !validateSymmetricKey(derived) { - x.Fatalf("failed validateSymmetricKey with param = %v.", derived) + x.Errorf("failed validateSymmetricKey with param = %v.", derived) + return } if containsOnlyZeros(derived) { - x.Fatalf("failed containsOnlyZeros with param = %v.", derived) + x.Errorf("failed containsOnlyZeros with param = %v.", derived) + return } buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0} le := bytesToIntLittleEndian(buf) be := BytesToIntBigEndian(buf) if le != uint64(0x280e5ff) { - x.Fatalf("failed bytesToIntLittleEndian: %d.", le) + x.Errorf("failed bytesToIntLittleEndian: %d.", le) + return } if be != uint64(0xffe5800200) { - x.Fatalf("failed BytesToIntBigEndian: %d.", be) + x.Errorf("failed BytesToIntBigEndian: %d.", be) + return } pk := w.NewIdentity() if !validatePrivateKey(pk) { - x.Fatalf("failed validatePrivateKey: %v.", pk) + x.Errorf("failed validatePrivateKey: %v.", pk) + return } if !ValidatePublicKey(&pk.PublicKey) { - x.Fatalf("failed ValidatePublicKey: %v.", pk) + x.Errorf("failed ValidatePublicKey: %v.", pk) + return } } @@ -127,16 +149,20 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 := w.GetIdentity(pub1) pk2 := w.GetIdentity(pub2) if !w.HasIdentity(pub1) { - x.Fatalf("failed test case 1.") + x.Errorf("failed HasIdentity 1.") + return } if !w.HasIdentity(pub2) { - x.Fatalf("failed test case 2.") + x.Errorf("failed HasIdentity 2.") + return } if pk1 != id1 { - x.Fatalf("failed test case 3.") + x.Errorf("failed GetIdentity 3.") + return } if pk2 != id2 { - x.Fatalf("failed test case 4.") + x.Errorf("failed GetIdentity 4.") + return } // Delete one identity @@ -144,16 +170,20 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Fatalf("failed test case 11.") + x.Errorf("failed HasIdentity 11.") + return } if !w.HasIdentity(pub2) { - x.Fatalf("failed test case 12.") + x.Errorf("failed HasIdentity 12.") + return } if pk1 != nil { - x.Fatalf("failed test case 13.") + x.Errorf("failed GetIdentity 13.") + return } if pk2 != id2 { - x.Fatalf("failed test case 14.") + x.Errorf("failed GetIdentity 14.") + return } // Delete again non-existing identity @@ -161,16 +191,20 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Fatalf("failed test case 21.") + x.Errorf("failed HasIdentity 21.") + return } if !w.HasIdentity(pub2) { - x.Fatalf("failed test case 22.") + x.Errorf("failed HasIdentity 22.") + return } if pk1 != nil { - x.Fatalf("failed test case 23.") + x.Errorf("failed GetIdentity 23.") + return } if pk2 != id2 { - x.Fatalf("failed test case 24.") + x.Errorf("failed GetIdentity 24.") + return } // Delete second identity @@ -178,16 +212,20 @@ func TestWhisperIdentityManagement(x *testing.T) { pk1 = w.GetIdentity(pub1) pk2 = w.GetIdentity(pub2) if w.HasIdentity(pub1) { - x.Fatalf("failed test case 31.") + x.Errorf("failed HasIdentity 31.") + return } if w.HasIdentity(pub2) { - x.Fatalf("failed test case 32.") + x.Errorf("failed HasIdentity 32.") + return } if pk1 != nil { - x.Fatalf("failed test case 33.") + x.Errorf("failed GetIdentity 33.") + return } if pk2 != nil { - x.Fatalf("failed test case 34.") + x.Errorf("failed GetIdentity 34.") + return } } @@ -201,22 +239,27 @@ func TestWhisperSymKeyManagement(x *testing.T) { err := w.GenerateSymKey(id1) if err != nil { - x.Fatalf("failed test case 1 with seed %d: %s.", seed, err) + x.Errorf("failed test case 1 with seed %d: %s.", seed, err) + return } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Fatalf("failed test case 2.") + x.Errorf("failed HasIdentity 2.") + return } if w.HasSymKey(id2) { - x.Fatalf("failed test case 3.") + x.Errorf("failed HasIdentity 3.") + return } if k1 == nil { - x.Fatalf("failed test case 4.") + x.Errorf("failed GetIdentity 4.") + return } if k2 != nil { - x.Fatalf("failed test case 5.") + x.Errorf("failed GetIdentity 5.") + return } // add existing id, nothing should change @@ -224,72 +267,91 @@ func TestWhisperSymKeyManagement(x *testing.T) { randomize(randomKey) err = w.AddSymKey(id1, randomKey) if err == nil { - x.Fatalf("failed test case 10 with seed %d.", seed) + x.Errorf("failed test case 10 with seed %d.", seed) + return } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Fatalf("failed test case 12.") + x.Errorf("failed HasIdentity 12.") + return } if w.HasSymKey(id2) { - x.Fatalf("failed test case 13.") + x.Errorf("failed HasIdentity 13.") + return } if k1 == nil { - x.Fatalf("failed test case 14.") + x.Errorf("failed GetIdentity 14.") + return } if bytes.Compare(k1, randomKey) == 0 { - x.Fatalf("failed test case 15: k1 == randomKey.") + x.Errorf("failed GetIdentity 15: k1 == randomKey.") + return } if k2 != nil { - x.Fatalf("failed test case 16.") + x.Errorf("failed GetIdentity 16.") + return } err = w.AddSymKey(id2, randomKey) // add non-existing (yet) if err != nil { - x.Fatalf("failed test case 21 with seed %d: %s.", seed, err) + x.Errorf("failed test case 21 with seed %d: %s.", seed, err) + return } k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if !w.HasSymKey(id1) { - x.Fatalf("failed test case 22.") + x.Errorf("failed HasIdentity 22.") + return } if !w.HasSymKey(id2) { - x.Fatalf("failed test case 23.") + x.Errorf("failed HasIdentity 23.") + return } if k1 == nil { - x.Fatalf("failed test case 24.") + x.Errorf("failed GetIdentity 24.") + return } if k2 == nil { - x.Fatalf("failed test case 25.") + x.Errorf("failed GetIdentity 25.") + return } if bytes.Compare(k1, k2) == 0 { - x.Fatalf("failed test case 26.") + x.Errorf("failed GetIdentity 26.") + return } if bytes.Compare(k1, randomKey) == 0 { - x.Fatalf("failed test case 27.") + x.Errorf("failed GetIdentity 27.") + return } if len(k1) != aesKeyLength { - x.Fatalf("failed test case 28.") + x.Errorf("failed GetIdentity 28.") + return } if len(k2) != aesKeyLength { - x.Fatalf("failed test case 29.") + x.Errorf("failed GetIdentity 29.") + return } w.DeleteSymKey(id1) k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if w.HasSymKey(id1) { - x.Fatalf("failed test case 31.") + x.Errorf("failed HasIdentity 31.") + return } if !w.HasSymKey(id2) { - x.Fatalf("failed test case 32.") + x.Errorf("failed HasIdentity 32.") + return } if k1 != nil { - x.Fatalf("failed test case 33.") + x.Errorf("failed GetIdentity 33.") + return } if k2 == nil { - x.Fatalf("failed test case 34.") + x.Errorf("failed GetIdentity 34.") + return } w.DeleteSymKey(id1) @@ -297,15 +359,19 @@ func TestWhisperSymKeyManagement(x *testing.T) { k1 = w.GetSymKey(id1) k2 = w.GetSymKey(id2) if w.HasSymKey(id1) { - x.Fatalf("failed test case 41.") + x.Errorf("failed HasIdentity 41.") + return } if w.HasSymKey(id2) { - x.Fatalf("failed test case 42.") + x.Errorf("failed HasIdentity 42.") + return } if k1 != nil { - x.Fatalf("failed test case 43.") + x.Errorf("failed GetIdentity 43.") + return } if k2 != nil { - x.Fatalf("failed test case 44.") + x.Errorf("failed GetIdentity 44.") + return } }