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

Revert "whisper: refactoring"

Browse source
This commit is contained in:
Jeffrey Wilcke 2016-11-22 21:59:56 +01:00 committed by GitHub
parent 97bec5e2d9
commit d4f44679bd
10 changed files with 503 additions and 709 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{ filter := whisperv5.Filter{
Src: crypto.ToECDSAPub(common.FromHex(args.From)), Src: crypto.ToECDSAPub(args.From),
KeySym: api.whisper.GetSymKey(args.KeyName), KeySym: api.whisper.GetSymKey(args.KeyName),
PoW: args.PoW, PoW: args.PoW,
Messages: make(map[common.Hash]*whisperv5.ReceivedMessage), Messages: make(map[common.Hash]*whisperv5.ReceivedMessage),
@ -195,7 +195,7 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber,
} }
if len(args.To) > 0 { if len(args.To) > 0 {
dst := crypto.ToECDSAPub(common.FromHex(args.To)) dst := crypto.ToECDSAPub(args.To)
if !whisperv5.ValidatePublicKey(dst) { if !whisperv5.ValidatePublicKey(dst) {
info := "NewFilter: Invalid 'To' address" info := "NewFilter: Invalid 'To' address"
glog.V(logger.Error).Infof(info) glog.V(logger.Error).Infof(info)
@ -259,7 +259,7 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
params := whisperv5.MessageParams{ params := whisperv5.MessageParams{
TTL: args.TTL, TTL: args.TTL,
Dst: crypto.ToECDSAPub(common.FromHex(args.To)), Dst: crypto.ToECDSAPub(args.To),
KeySym: api.whisper.GetSymKey(args.KeyName), KeySym: api.whisper.GetSymKey(args.KeyName),
Topic: args.Topic, Topic: args.Topic,
Payload: args.Payload, Payload: args.Payload,
@ -269,7 +269,7 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
} }
if len(args.From) > 0 { if len(args.From) > 0 {
pub := crypto.ToECDSAPub(common.FromHex(args.From)) pub := crypto.ToECDSAPub(args.From)
if !whisperv5.ValidatePublicKey(pub) { if !whisperv5.ValidatePublicKey(pub) {
info := "Post: Invalid 'From' address" info := "Post: Invalid 'From' address"
glog.V(logger.Error).Infof(info) glog.V(logger.Error).Infof(info)
@ -321,13 +321,13 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
return errors.New(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: message must be encrypted either symmetrically or asymmetrically" info := "Post: message must be encrypted either symmetrically or asymmetrically"
glog.V(logger.Error).Infof(info) glog.V(logger.Error).Infof(info)
return errors.New(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" info := "Post: ambigous encryption method requested"
glog.V(logger.Error).Infof(info) glog.V(logger.Error).Infof(info)
return errors.New(info) return errors.New(info)
@ -367,32 +367,32 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
} }
type PostArgs struct { type PostArgs struct {
TTL uint32 TTL uint32 `json:"ttl"`
From string From rpc.HexBytes `json:"from"`
To string To rpc.HexBytes `json:"to"`
KeyName string KeyName string `json:"keyname"`
Topic whisperv5.TopicType Topic whisperv5.TopicType `json:"topic"`
Padding rpc.HexBytes Padding rpc.HexBytes `json:"padding"`
Payload rpc.HexBytes Payload rpc.HexBytes `json:"payload"`
WorkTime uint32 WorkTime uint32 `json:"worktime"`
PoW float64 PoW float64 `json:"pow"`
FilterID int FilterID int `json:"filter"`
PeerID rpc.HexBytes PeerID rpc.HexBytes `json:"directP2P"`
} }
func (args *PostArgs) UnmarshalJSON(data []byte) (err error) { func (args *PostArgs) UnmarshalJSON(data []byte) (err error) {
var obj struct { var obj struct {
TTL uint32 `json:"ttl"` TTL uint32 `json:"ttl"`
From string `json:"from"` From rpc.HexBytes `json:"from"`
To string `json:"to"` To rpc.HexBytes `json:"to"`
KeyName string `json:"keyname"` KeyName string `json:"keyname"`
Topic whisperv5.TopicType `json:"topic"` Topic whisperv5.TopicType `json:"topic"`
Payload rpc.HexBytes `json:"payload"` Payload rpc.HexBytes `json:"payload"`
Padding rpc.HexBytes `json:"padding"` Padding rpc.HexBytes `json:"padding"`
WorkTime uint32 `json:"worktime"` WorkTime uint32 `json:"worktime"`
PoW float64 `json:"pow"` PoW float64 `json:"pow"`
FilterID rpc.HexBytes `json:"filterID"` FilterID rpc.HexBytes `json:"filter"`
PeerID rpc.HexBytes `json:"peerID"` PeerID rpc.HexBytes `json:"directP2P"`
} }
if err := json.Unmarshal(data, &obj); err != nil { if err := json.Unmarshal(data, &obj); err != nil {
@ -420,8 +420,8 @@ func (args *PostArgs) UnmarshalJSON(data []byte) (err error) {
} }
type WhisperFilterArgs struct { type WhisperFilterArgs struct {
To string To []byte
From string From []byte
KeyName string KeyName string
PoW float64 PoW float64
Topics []whisperv5.TopicType Topics []whisperv5.TopicType
@ -433,8 +433,8 @@ type WhisperFilterArgs struct {
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) { func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
// Unmarshal the JSON message and sanity check // Unmarshal the JSON message and sanity check
var obj struct { var obj struct {
To string `json:"to"` To rpc.HexBytes `json:"to"`
From string `json:"from"` From rpc.HexBytes `json:"from"`
KeyName string `json:"keyname"` KeyName string `json:"keyname"`
PoW float64 `json:"pow"` PoW float64 `json:"pow"`
Topics []interface{} `json:"topics"` Topics []interface{} `json:"topics"`

496
whisper/shhapi/api_test.go
View file

@ -17,11 +17,8 @@
package shhapi package shhapi
import ( import (
"bytes"
"testing" "testing"
"time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/whisper/whisperv5" "github.com/ethereum/go-ethereum/whisper/whisperv5"
) )
@ -30,64 +27,78 @@ func TestBasic(x *testing.T) {
var id string = "test" var id string = "test"
api := NewPublicWhisperAPI() api := NewPublicWhisperAPI()
if api == nil { if api == nil {
x.Fatalf("failed to create API.") x.Errorf("failed to create API.")
return
} }
ver, err := api.Version() ver, err := api.Version()
if err != nil { if err != nil {
x.Fatalf("failed generateFilter: %s.", err) x.Errorf("failed generateFilter: %s.", err)
return
} }
if ver.Uint64() != whisperv5.ProtocolVersion { if ver.Uint64() != whisperv5.ProtocolVersion {
x.Fatalf("wrong version: %d.", ver.Uint64()) x.Errorf("wrong version: %d.", ver.Uint64())
return
} }
var hexnum rpc.HexNumber var hexnum rpc.HexNumber
mail := api.GetFilterChanges(hexnum) mail := api.GetFilterChanges(hexnum)
if len(mail) != 0 { if len(mail) != 0 {
x.Fatalf("failed GetFilterChanges") x.Errorf("failed GetFilterChanges")
return
} }
exist, err := api.HasIdentity(id) exist, err := api.HasIdentity(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 1: %s.", err) x.Errorf("failed 1 HasIdentity: %s.", err)
return
} }
if exist { if exist {
x.Fatalf("failed test case 2, HasIdentity: false positive.") x.Errorf("failed 2 HasIdentity: false positive.")
return
} }
err = api.DeleteIdentity(id) err = api.DeleteIdentity(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 3: %s.", err) x.Errorf("failed 3 DeleteIdentity: %s.", err)
return
} }
pub, err := api.NewIdentity() pub, err := api.NewIdentity()
if err != nil { if err != nil {
x.Fatalf("failed test case 4: %s.", err) x.Errorf("failed 4 NewIdentity: %s.", err)
return
} }
if len(pub) == 0 { if len(pub) == 0 {
x.Fatalf("test case 5, NewIdentity: empty") x.Errorf("NewIdentity 5: empty")
return
} }
exist, err = api.HasIdentity(pub) exist, err = api.HasIdentity(pub)
if err != nil { if err != nil {
x.Fatalf("failed test case 6: %s.", err) x.Errorf("failed 6 HasIdentity: %s.", err)
return
} }
if !exist { if !exist {
x.Fatalf("failed test case 7, HasIdentity: false negative.") x.Errorf("failed 7 HasIdentity: false negative.")
return
} }
err = api.DeleteIdentity(pub) err = api.DeleteIdentity(pub)
if err != nil { if err != nil {
x.Fatalf("failed 8 DeleteIdentity: %s.", err) x.Errorf("failed 8 DeleteIdentity: %s.", err)
return
} }
exist, err = api.HasIdentity(pub) exist, err = api.HasIdentity(pub)
if err != nil { if err != nil {
x.Fatalf("failed test case 9: %s.", err) x.Errorf("failed 9 HasIdentity: %s.", err)
return
} }
if exist { if exist {
x.Fatalf("failed test case 10, HasIdentity: false positive.") x.Errorf("failed 10 HasIdentity: false positive.")
return
} }
id = "arbitrary text" id = "arbitrary text"
@ -95,468 +106,65 @@ func TestBasic(x *testing.T) {
exist, err = api.HasSymKey(id) exist, err = api.HasSymKey(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 11: %s.", err) x.Errorf("failed 11 HasSymKey: %s.", err)
return
} }
if exist { if exist {
x.Fatalf("failed test case 12, HasSymKey: false positive.") x.Errorf("failed 12 HasSymKey: false positive.")
return
} }
err = api.GenerateSymKey(id) err = api.GenerateSymKey(id)
if err != nil { if err != nil {
x.Fatalf("failed 13 GenerateSymKey: %s.", err) x.Errorf("failed 13 GenerateSymKey: %s.", err)
return
} }
exist, err = api.HasSymKey(id) exist, err = api.HasSymKey(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 14: %s.", err) x.Errorf("failed 14 HasSymKey: %s.", err)
return
} }
if !exist { 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")) err = api.AddSymKey(id, []byte("some stuff here"))
if err == nil { 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")) err = api.AddSymKey(id2, []byte("some stuff here"))
if err != nil { if err != nil {
x.Fatalf("failed test case 17: %s.", err) x.Errorf("failed 17 AddSymKey: %s.", err)
return
} }
exist, err = api.HasSymKey(id2) exist, err = api.HasSymKey(id2)
if err != nil { if err != nil {
x.Fatalf("failed test case 18: %s.", err) x.Errorf("failed 18 HasSymKey: %s.", err)
return
} }
if !exist { if !exist {
x.Fatalf("failed test case 19, HasSymKey: false negative.") x.Errorf("failed 19 HasSymKey: false negative.")
return
} }
err = api.DeleteSymKey(id) err = api.DeleteSymKey(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 20: %s.", err) x.Errorf("failed 20 DeleteSymKey: %s.", err)
return
} }
exist, err = api.HasSymKey(id) exist, err = api.HasSymKey(id)
if err != nil { if err != nil {
x.Fatalf("failed test case 21: %s.", err) x.Errorf("failed 21 HasSymKey: %s.", err)
return
} }
if exist { if exist {
x.Fatalf("failed test case 22, HasSymKey: false positive.") x.Errorf("failed 22 HasSymKey: false positive.")
} return
}
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,7 +40,8 @@ func BenchmarkEncryptionSym(b *testing.B) {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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++ { for i := 0; i < b.N; i++ {
@ -59,11 +60,13 @@ func BenchmarkEncryptionAsym(b *testing.B) {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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() key, err := crypto.GenerateKey()
if err != nil { 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.KeySym = nil
params.Dst = &key.PublicKey params.Dst = &key.PublicKey
@ -72,7 +75,8 @@ func BenchmarkEncryptionAsym(b *testing.B) {
msg := NewSentMessage(params) msg := NewSentMessage(params)
_, err := msg.Wrap(params) _, err := msg.Wrap(params)
if err != nil { 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() params, err := generateMessageParams()
if err != nil { 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) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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} f := Filter{KeySym: params.KeySym}
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
msg := env.Open(&f) msg := env.Open(&f)
if msg == nil { 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() params, err := generateMessageParams()
if err != nil { 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) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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")} f := Filter{KeySym: []byte("arbitrary stuff here")}
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
msg := env.Open(&f) msg := env.Open(&f)
if msg != nil { 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() params, err := generateMessageParams()
if err != nil { 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() key, err := crypto.GenerateKey()
if err != nil { 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} f := Filter{KeyAsym: key}
params.KeySym = nil params.KeySym = nil
@ -138,13 +150,15 @@ func BenchmarkDecryptionAsymValid(b *testing.B) {
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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++ { for i := 0; i < b.N; i++ {
msg := env.Open(&f) msg := env.Open(&f)
if msg == nil { 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() params, err := generateMessageParams()
if err != nil { 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() key, err := crypto.GenerateKey()
if err != nil { 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.KeySym = nil
params.Dst = &key.PublicKey params.Dst = &key.PublicKey
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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() key, err = crypto.GenerateKey()
if err != nil { 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} f := Filter{KeyAsym: key}
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
msg := env.Open(&f) msg := env.Open(&f)
if msg != nil { if msg != nil {
b.Fatalf("opened envelope with invalid key, seed: %d.", seed) b.Errorf("opened envelope with invalid key, seed: %d.", seed)
return
} }
} }
} }

2
whisper/whisperv5/doc.go
View file

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

43
whisper/whisperv5/filter.go
View file

@ -143,9 +143,18 @@ func (f *Filter) MatchMessage(msg *ReceivedMessage) bool {
} }
if f.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() { 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() { } 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 return false
} }
@ -155,25 +164,25 @@ func (f *Filter) MatchEnvelope(envelope *Envelope) bool {
return false return false
} }
encryptionMethodMatch := false
if f.expectsAsymmetricEncryption() && envelope.isAsymmetric() { if f.expectsAsymmetricEncryption() && envelope.isAsymmetric() {
return f.MatchTopic(envelope.Topic) encryptionMethodMatch = true
} else if f.expectsSymmetricEncryption() && envelope.IsSymmetric() { if f.Topics == nil {
return f.MatchTopic(envelope.Topic) // wildcard
}
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 {
return true 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 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() key, err := crypto.GenerateKey()
if err != nil { if err != nil {
x.Fatalf("generateFilter 1 failed with seed %d.", seed) x.Errorf("generateFilter failed 1 with seed %d.", seed)
return nil, err return nil, err
} }
f.Src = &key.PublicKey f.Src = &key.PublicKey
@ -73,7 +73,7 @@ func generateFilter(x *testing.T, symmetric bool) (*Filter, error) {
} else { } else {
f.KeyAsym, err = crypto.GenerateKey() f.KeyAsym, err = crypto.GenerateKey()
if err != nil { if err != nil {
x.Fatalf("generateFilter 2 failed with seed %d.", seed) x.Errorf("generateFilter failed 2 with seed %d.", seed)
return nil, err return nil, err
} }
} }
@ -107,7 +107,8 @@ func TestInstallFilters(x *testing.T) {
} }
if j < SizeTestFilters-1 { 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 { for _, t := range tst {
@ -120,10 +121,12 @@ func TestInstallFilters(x *testing.T) {
fil := filters.Get(t.id) fil := filters.Get(t.id)
exist := (fil != nil) exist := (fil != nil)
if exist != t.alive { 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 { 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() key1, err := crypto.GenerateKey()
if err != nil { 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() key2, err := crypto.GenerateKey()
if err != nil { 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) { 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 // generate key3 == key1
rand.Seed(seed) rand.Seed(seed)
key3, err := crypto.GenerateKey() key3, err := crypto.GenerateKey()
if err != nil { 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) { 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) fsym, err := generateFilter(x, true)
if err != nil { 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) fasym, err := generateFilter(x, false)
if err != nil { 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() params, err := generateMessageParams()
if err != nil { 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 params.Topic[0] = 0xFF // ensure mismatch
@ -178,15 +189,18 @@ func TestMatchEnvelope(x *testing.T) {
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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) match := fsym.MatchEnvelope(env)
if match { 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) match = fasym.MatchEnvelope(env)
if match { 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 // encrypt symmetrically
@ -196,109 +210,109 @@ func TestMatchEnvelope(x *testing.T) {
msg = NewSentMessage(params) msg = NewSentMessage(params)
env, err = msg.Wrap(params) env, err = msg.Wrap(params)
if err != nil { 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 // symmetric + matching topic: match
match = fsym.MatchEnvelope(env) match = fsym.MatchEnvelope(env)
if !match { 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 // asymmetric + matching topic: mismatch
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if match { 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 // symmetric + matching topic + insufficient PoW: mismatch
fsym.PoW = env.PoW() + 1.0 fsym.PoW = env.PoW() + 1.0
match = fsym.MatchEnvelope(env) match = fsym.MatchEnvelope(env)
if match { 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 // symmetric + matching topic + sufficient PoW: match
fsym.PoW = env.PoW() / 2 fsym.PoW = env.PoW() / 2
match = fsym.MatchEnvelope(env) match = fsym.MatchEnvelope(env)
if !match { 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 prevTopics := fsym.Topics
fsym.Topics = nil fsym.Topics = nil
match = fsym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if !match { if match {
x.Fatalf("failed test case 12 with seed %d.", seed) x.Errorf("failed test case 12 with seed %d.", seed)
return
} }
fsym.Topics = prevTopics fsym.Topics = prevTopics
// encrypt asymmetrically // encrypt asymmetrically
key, err := crypto.GenerateKey() key, err := crypto.GenerateKey()
if err != nil { 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.KeySym = nil
params.Dst = &key.PublicKey params.Dst = &key.PublicKey
msg = NewSentMessage(params) msg = NewSentMessage(params)
env, err = msg.Wrap(params) env, err = msg.Wrap(params)
if err != nil { 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 // encryption method mismatch
match = fsym.MatchEnvelope(env) match = fsym.MatchEnvelope(env)
if match { 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 // asymmetric + mismatching topic: mismatch
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if !match { 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 // asymmetric + matching topic: match
fasym.Topics[i] = fasym.Topics[i+1] fasym.Topics[i] = fasym.Topics[i+1]
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if match { 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 fasym.Topics = nil
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if !match { 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 // asymmetric + insufficient PoW: mismatch
fasym.PoW = env.PoW() + 1.0 fasym.PoW = env.PoW() + 1.0
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if match { 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 // asymmetric + sufficient PoW: match
fasym.PoW = env.PoW() / 2 fasym.PoW = env.PoW() / 2
match = fasym.MatchEnvelope(env) match = fasym.MatchEnvelope(env)
if !match { if !match {
x.Fatalf("failed test case 20 with seed %d.", seed) x.Errorf("failed test case 20 with seed %d.", seed)
} return
// 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)
} }
} }
@ -307,12 +321,14 @@ func TestMatchMessageSym(x *testing.T) {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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) f, err := generateFilter(x, true)
if err != nil { 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 const index = 1
@ -322,77 +338,90 @@ func TestMatchMessageSym(x *testing.T) {
sentMessage := NewSentMessage(params) sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params) env, err := sentMessage.Wrap(params)
if err != nil { 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) msg := env.Open(f)
if msg == nil { 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 // Src mismatch
if f.MatchMessage(msg) { 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 // Src: match
*f.Src.X = *params.Src.PublicKey.X *f.Src.X = *params.Src.PublicKey.X
*f.Src.Y = *params.Src.PublicKey.Y *f.Src.Y = *params.Src.PublicKey.Y
if !f.MatchMessage(msg) { 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 // insufficient PoW: mismatch
f.PoW = msg.PoW + 1.0 f.PoW = msg.PoW + 1.0
if f.MatchMessage(msg) { 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 // sufficient PoW: match
f.PoW = msg.PoW / 2 f.PoW = msg.PoW / 2
if !f.MatchMessage(msg) { 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
f.Topics[index][0]++ f.Topics[index][0]++
if f.MatchMessage(msg) { 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]-- f.Topics[index][0]--
// key mismatch // key mismatch
f.SymKeyHash[0]++ f.SymKeyHash[0]++
if f.MatchMessage(msg) { 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]-- f.SymKeyHash[0]--
// Src absent: match // Src absent: match
f.Src = nil f.Src = nil
if !f.MatchMessage(msg) { 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 // key hash mismatch mismatch
h := f.SymKeyHash h := f.SymKeyHash
f.SymKeyHash = common.Hash{} f.SymKeyHash = common.Hash{}
if f.MatchMessage(msg) { 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 f.SymKeyHash = h
if !f.MatchMessage(msg) { 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 // encryption method mismatch
f.KeySym = nil f.KeySym = nil
f.KeyAsym, err = crypto.GenerateKey() f.KeyAsym, err = crypto.GenerateKey()
if err != nil { 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) { 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) f, err := generateFilter(x, false)
if err != nil { 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() params, err := generateMessageParams()
if err != nil { 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 const index = 1
@ -418,42 +449,50 @@ func TestMatchMessageAsym(x *testing.T) {
sentMessage := NewSentMessage(params) sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params) env, err := sentMessage.Wrap(params)
if err != nil { 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) msg := env.Open(f)
if msg == nil { if msg == nil {
x.Fatalf("failed to open with seed %d.", seed) x.Errorf("failed to open with seed %d.", seed)
return
} }
// Src mismatch // Src mismatch
if f.MatchMessage(msg) { 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 // Src: match
*f.Src.X = *params.Src.PublicKey.X *f.Src.X = *params.Src.PublicKey.X
*f.Src.Y = *params.Src.PublicKey.Y *f.Src.Y = *params.Src.PublicKey.Y
if !f.MatchMessage(msg) { 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 // insufficient PoW: mismatch
f.PoW = msg.PoW + 1.0 f.PoW = msg.PoW + 1.0
if f.MatchMessage(msg) { 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 // sufficient PoW: match
f.PoW = msg.PoW / 2 f.PoW = msg.PoW / 2
if !f.MatchMessage(msg) { 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]++ f.Topics[index][0]++
if f.MatchMessage(msg) { 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]-- f.Topics[index][0]--
@ -462,21 +501,24 @@ func TestMatchMessageAsym(x *testing.T) {
zero := *big.NewInt(0) zero := *big.NewInt(0)
*f.KeyAsym.PublicKey.X = zero *f.KeyAsym.PublicKey.X = zero
if f.MatchMessage(msg) { 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 *f.KeyAsym.PublicKey.X = prev
// Src absent: match // Src absent: match
f.Src = nil f.Src = nil
if !f.MatchMessage(msg) { 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 // encryption method mismatch
f.KeySym = keySymOrig f.KeySym = keySymOrig
f.KeyAsym = nil f.KeyAsym = nil
if f.MatchMessage(msg) { 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 { func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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 return nil
} }
@ -505,7 +547,7 @@ func generateCompatibeEnvelope(x *testing.T, f *Filter) *Envelope {
sentMessage := NewSentMessage(params) sentMessage := NewSentMessage(params)
env, err := sentMessage.Wrap(params) env, err := sentMessage.Wrap(params)
if err != nil { 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 nil
} }
return env return env
@ -553,17 +595,20 @@ func TestWatchers(x *testing.T) {
} }
if total != NumMessages { 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++ { for i = 0; i < NumFilters; i++ {
mail = tst[i].f.Retrieve() mail = tst[i].f.Retrieve()
if len(mail) != 0 { 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] { 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 combined := tst[0].msgCnt + tst[last].msgCnt
if total != NumMessages+count[0] { 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] { 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] { 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++ { for i = 1; i < NumFilters-1; i++ {
mail = tst[i].f.Retrieve() mail = tst[i].f.Retrieve()
if len(mail) != 0 { 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] { 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 { 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) f := filters.Get(0)
@ -650,6 +701,7 @@ func TestWatchers(x *testing.T) {
} }
if total != 1 { 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
} }
} }

90
whisper/whisperv5/message_test.go
View file

@ -60,12 +60,14 @@ func generateMessageParams() (*MessageParams, error) {
func singleMessageTest(x *testing.T, symmetric bool) { func singleMessageTest(x *testing.T, symmetric bool) {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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() key, err := crypto.GenerateKey()
if err != nil { 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 { if !symmetric {
@ -83,7 +85,8 @@ func singleMessageTest(x *testing.T, symmetric bool) {
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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 var decrypted *ReceivedMessage
@ -94,28 +97,35 @@ func singleMessageTest(x *testing.T, symmetric bool) {
} }
if err != nil { 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() { 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) padsz := len(decrypted.Padding)
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { 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 { 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]) { 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 { 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, &params.Src.PublicKey) { if !isPubKeyEqual(decrypted.Src, &params.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() params, err := generateMessageParams()
if err != nil { 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) msg := NewSentMessage(params)
@ -145,12 +156,14 @@ func TestMessageWrap(x *testing.T) {
params.PoW = target params.PoW = target
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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() pow := env.PoW()
if pow < target { 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() params, err := generateMessageParams()
if err != nil { 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) msg := NewSentMessage(params)
@ -173,7 +187,8 @@ func TestMessageSeal(x *testing.T) {
env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg) env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg)
if err != nil { 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 env.Expiry = uint32(seed) // make it deterministic
@ -185,7 +200,8 @@ func TestMessageSeal(x *testing.T) {
env.calculatePoW(0) env.calculatePoW(0)
pow := env.PoW() pow := env.PoW()
if pow < target { 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 params.WorkTime = 1
@ -194,7 +210,8 @@ func TestMessageSeal(x *testing.T) {
env.calculatePoW(0) env.calculatePoW(0)
pow = env.PoW() pow = env.PoW()
if pow < 2*target { 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) { func singleEnvelopeOpenTest(x *testing.T, symmetric bool) {
params, err := generateMessageParams() params, err := generateMessageParams()
if err != nil { 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() key, err := crypto.GenerateKey()
if err != nil { 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 { if !symmetric {
@ -234,43 +253,54 @@ func singleEnvelopeOpenTest(x *testing.T, symmetric bool) {
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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} f := Filter{KeyAsym: key, KeySym: params.KeySym}
decrypted := env.Open(&f) decrypted := env.Open(&f)
if decrypted == nil { 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) padsz := len(decrypted.Padding)
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 { 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 { 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]) { 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 { 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, &params.Src.PublicKey) { if !isPubKeyEqual(decrypted.Src, &params.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 { 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 { 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 !symmetric {
if decrypted.Dst == nil { 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) { if !isPubKeyEqual(decrypted.Dst, &key.PublicKey) {
x.Fatalf("failed with seed %d: Dst.", seed) x.Errorf("failed with seed %d: Dst.", seed)
return
} }
} }
} }

32
whisper/whisperv5/peer_test.go
View file

@ -124,7 +124,8 @@ func initialize(x *testing.T) {
node.filerId = node.shh.Watch(&f) node.filerId = node.shh.Watch(&f)
node.id, err = crypto.HexToECDSA(keys[i]) node.id, err = crypto.HexToECDSA(keys[i])
if err != nil { 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 port := port0 + i
addr := fmt.Sprintf(":%d", port) // e.g. ":30303" addr := fmt.Sprintf(":%d", port) // e.g. ":30303"
@ -154,7 +155,8 @@ func initialize(x *testing.T) {
err = node.server.Start() err = node.server.Start()
if err != nil { if err != nil {
x.Fatalf("failed to start server %d.", i) x.Errorf("failed to start server %d.", i)
return
} }
nodes[i] = &node nodes[i] = &node
@ -185,7 +187,8 @@ func checkPropagation(x *testing.T) {
for i := 0; i < NumNodes; i++ { for i := 0; i < NumNodes; i++ {
f := nodes[i].shh.GetFilter(nodes[i].filerId) f := nodes[i].shh.GetFilter(nodes[i].filerId)
if f == nil { 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() mail := f.Retrieve()
@ -194,12 +197,13 @@ func checkPropagation(x *testing.T) {
} }
if isTestComplete() { if isTestComplete() {
return 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 { 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 return true
} }
if cnt > 1 { if cnt > 1 {
x.Fatalf("node %d received %d.", index, cnt) x.Errorf("node %d received %d.", index, cnt)
return false return false
} }
@ -224,7 +228,8 @@ func validateMail(x *testing.T, index int, mail []*ReceivedMessage) bool {
defer result.mutex.Unlock() defer result.mutex.Unlock()
result.counter[index] += cnt result.counter[index] += cnt
if result.counter[index] > 1 { 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 return true
@ -265,12 +270,14 @@ func sendMsg(x *testing.T, expected bool, id int) {
msg := NewSentMessage(&opt) msg := NewSentMessage(&opt)
envelope, err := msg.Wrap(&opt) envelope, err := msg.Wrap(&opt)
if err != nil { if err != nil {
x.Fatalf("failed to seal message.") x.Errorf("failed to seal message.")
return
} }
err = nodes[id].shh.Send(envelope) err = nodes[id].shh.Send(envelope)
if err != nil { 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() params, err := generateMessageParams()
if err != nil { if err != nil {
x.Fatalf("failed generateMessageParams with seed %d.", seed) x.Errorf("failed 1 with seed %d.", seed)
return
} }
params.PoW = 0.001 params.PoW = 0.001
msg := NewSentMessage(params) msg := NewSentMessage(params)
env, err := msg.Wrap(params) env, err := msg.Wrap(params)
if err != nil { 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 := newPeer(nil, nil, nil)
p.mark(env) p.mark(env)
if !p.marked(env) { if !p.marked(env) {
x.Fatalf("failed mark with seed %d.", seed) x.Errorf("failed 3 with seed %d.", seed)
return
} }
} }

14
whisper/whisperv5/topic_test.go
View file

@ -32,7 +32,7 @@ func TestTopicString(x *testing.T) {
for i, tst := range topicStringTests { for i, tst := range topicStringTests {
s := tst.topic.String() s := tst.topic.String()
if s != tst.str { 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 { for i, tst := range bytesToTopicTests {
t := BytesToTopic(tst.data) t := BytesToTopic(tst.data)
if t != tst.topic { 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 var t TopicType
err := t.UnmarshalJSON(tst.data) err := t.UnmarshalJSON(tst.data)
if err != nil { 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 { } 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 var t TopicType
err := t.UnmarshalJSON(tst.data) err := t.UnmarshalJSON(tst.data)
if err == nil { 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 var t TopicType
err := t.UnmarshalJSON(tst.data) err := t.UnmarshalJSON(tst.data)
if err != nil { 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 { } 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)
} }
} }
} }

198
whisper/whisperv5/whisper_test.go
View file

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