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

whisper: added TestEnvelopeOpen and bugfix

Browse source
This commit is contained in:
Vlad 2016-10-18 17:46:28 +02:00
parent 99b9dcb2f1
commit e9d3ff3760
4 changed files with 107 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
whisper/shhapi/api.go
View file

@ -156,7 +156,6 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber,
filter := whisperv5.Filter{
Src: crypto.ToECDSAPub(args.From),
Dst: crypto.ToECDSAPub(args.To),
KeySym: api.whisper.GetSymKey(args.KeyName),
PoW: args.PoW,
Messages: make(map[common.Hash]*whisperv5.ReceivedMessage),
@ -196,12 +195,13 @@ func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (*rpc.HexNumber,
}
if len(args.To) > 0 {
if !whisperv5.ValidatePublicKey(filter.Dst) {
dst := crypto.ToECDSAPub(args.To)
if !whisperv5.ValidatePublicKey(dst) {
info := "NewFilter: Invalid 'To' address"
glog.V(logger.Error).Infof(info)
return nil, errors.New(info)
}
filter.KeyAsym = api.whisper.GetIdentity(filter.Dst)
filter.KeyAsym = api.whisper.GetIdentity(dst)
if filter.KeyAsym == nil {
info := "NewFilter: non-existent identity provided"
glog.V(logger.Error).Infof(info)
@ -295,9 +295,6 @@ func (api *PublicWhisperAPI) Post(args PostArgs) error {
if params.KeySym == nil && filter.KeySym != nil {
params.KeySym = filter.KeySym
}
if params.Dst == nil && filter.Dst != nil {
params.Dst = filter.Dst
}
if params.Src == nil && filter.Src != nil {
params.Src = filter.KeyAsym
}

2
whisper/whisperv5/envelope.go
View file

@ -207,7 +207,7 @@ func (e *Envelope) Open(watcher *Filter) (msg *ReceivedMessage) {
if e.isAsymmetric() {
msg, _ = e.OpenAsymmetric(watcher.KeyAsym)
if msg != nil {
msg.Dst = watcher.Dst
msg.Dst = &watcher.KeyAsym.PublicKey
}
} else if e.IsSymmetric() {
msg, _ = e.OpenSymmetric(watcher.KeySym)

3
whisper/whisperv5/filter.go
View file

@ -25,7 +25,6 @@ import (
type Filter struct {
Src *ecdsa.PublicKey // Sender of the message
Dst *ecdsa.PublicKey // Recipient of the message
KeyAsym *ecdsa.PrivateKey // Private Key of recipient
KeySym []byte // Key associated with the Topic
Topics []TopicType // Topics to filter messages with
@ -142,7 +141,7 @@ func (f *Filter) MatchMessage(msg *ReceivedMessage) bool {
if f.expectsAsymmetricEncryption() && msg.isAsymmetricEncryption() {
// if Dst match, ignore the topic
return isPubKeyEqual(f.Dst, msg.Dst)
return isPubKeyEqual(&f.KeyAsym.PublicKey, msg.Dst)
} else if f.expectsSymmetricEncryption() && msg.isSymmetricEncryption() {
// check if that both the key and the topic match
if f.SymKeyHash == msg.SymKeyHash {

110
whisper/whisperv5/message_test.go
View file

@ -30,16 +30,14 @@ func copyFromBuf(dst []byte, src []byte, beg int) int {
return beg + len(dst)
}
func generateMessageParams(seed int64) (*MessageParams, error) {
var err error
var p MessageParams
func generateMessageParams() (*MessageParams, error) {
buf := make([]byte, 1024)
_, err = rand.Read(buf)
_, err := rand.Read(buf)
if err != nil {
return nil, err
}
var p MessageParams
p.TTL = uint32(rand.Intn(1024))
sz := rand.Intn(400)
p.Payload = make([]byte, sz)
@ -62,7 +60,7 @@ func generateMessageParams(seed int64) (*MessageParams, error) {
}
func singleMessageTest(x *testing.T, seed int64, symmetric bool) {
params, err := generateMessageParams(seed)
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
@ -149,7 +147,7 @@ func TestMessageWrap(x *testing.T) {
rand.Seed(seed)
target := 128.0
params, err := generateMessageParams(seed)
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
@ -176,7 +174,7 @@ func TestMessageSeal(x *testing.T) {
seed := int64(1976726903)
rand.Seed(seed)
params, err := generateMessageParams(seed)
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
@ -227,3 +225,99 @@ func TestMessageSeal(x *testing.T) {
return
}
}
func TestEnvelopeOpen(x *testing.T) {
seed := time.Now().Unix()
rand.Seed(seed)
var symmetric bool
for i := 0; i < 256; i++ {
singleEnvelopeOpenTest(x, seed, symmetric)
symmetric = !symmetric
}
}
func singleEnvelopeOpenTest(x *testing.T, seed int64, symmetric bool) {
params, err := generateMessageParams()
if err != nil {
x.Errorf("failed generateMessageParams with seed %d: %s.", seed, err)
return
}
key, err := crypto.GenerateKey()
if err != nil {
x.Errorf("failed GenerateKey with seed %d: %s.", seed, err)
return
}
if !symmetric {
params.KeySym = nil
params.Dst = &key.PublicKey
}
text := make([]byte, 0, 512)
steg := make([]byte, 0, 512)
raw := make([]byte, 0, 1024)
text = append(text, params.Payload...)
steg = append(steg, params.Padding...)
raw = append(raw, params.Padding...)
msg := NewSentMessage(params)
env, err := msg.Wrap(params)
if err != nil {
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.Errorf("failed to open with seed %d.", seed)
return
}
if !decrypted.Validate() {
x.Errorf("failed to validate with seed %d.", seed)
return
}
padsz := len(decrypted.Padding)
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 {
x.Errorf("failed with seed %d: compare padding.", seed)
return
}
if bytes.Compare(text, decrypted.Payload) != 0 {
x.Errorf("failed with seed %d: compare payload.", seed)
return
}
if !isMessageSigned(decrypted.Raw[0]) {
x.Errorf("failed with seed %d: unsigned.", seed)
return
}
if len(decrypted.Signature) != signatureLength {
x.Errorf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
return
}
if !isPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
x.Errorf("failed with seed %d: signature mismatch.", seed)
return
}
if decrypted.isAsymmetricEncryption() == symmetric {
x.Errorf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
return
}
if 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.Errorf("failed with seed %d: dst is nil.", seed)
return
}
if !isPubKeyEqual(decrypted.Dst, &key.PublicKey) {
x.Errorf("failed with seed %d: Dst.", seed)
return
}
}
}