2016-10-29 05:11:37 -07:00
|
|
|
// Copyright 2016 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
package whisperv5
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"math/rand"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
)
|
|
|
|
|
|
|
|
func copyFromBuf(dst []byte, src []byte, beg int) int {
|
|
|
|
copy(dst, src[beg:])
|
|
|
|
return beg + len(dst)
|
|
|
|
}
|
|
|
|
|
|
|
|
func generateMessageParams() (*MessageParams, error) {
|
2016-12-19 15:58:01 -08:00
|
|
|
// set all the parameters except p.Dst
|
|
|
|
|
2016-10-29 05:11:37 -07:00
|
|
|
buf := make([]byte, 1024)
|
|
|
|
randomize(buf)
|
|
|
|
sz := rand.Intn(400)
|
|
|
|
|
|
|
|
var p MessageParams
|
2016-12-19 15:58:01 -08:00
|
|
|
p.PoW = 0.01
|
|
|
|
p.WorkTime = 1
|
2016-10-29 05:11:37 -07:00
|
|
|
p.TTL = uint32(rand.Intn(1024))
|
|
|
|
p.Payload = make([]byte, sz)
|
|
|
|
p.Padding = make([]byte, padSizeLimitUpper)
|
|
|
|
p.KeySym = make([]byte, aesKeyLength)
|
|
|
|
|
|
|
|
var b int
|
|
|
|
b = copyFromBuf(p.Payload, buf, b)
|
|
|
|
b = copyFromBuf(p.Padding, buf, b)
|
|
|
|
b = copyFromBuf(p.KeySym, buf, b)
|
|
|
|
p.Topic = BytesToTopic(buf[b:])
|
|
|
|
|
|
|
|
var err error
|
|
|
|
p.Src, err = crypto.GenerateKey()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return &p, nil
|
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func singleMessageTest(t *testing.T, symmetric bool) {
|
2016-10-29 05:11:37 -07:00
|
|
|
params, err := generateMessageParams()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
key, err := crypto.GenerateKey()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
var decrypted *ReceivedMessage
|
|
|
|
if symmetric {
|
|
|
|
decrypted, err = env.OpenSymmetric(params.KeySym)
|
|
|
|
} else {
|
|
|
|
decrypted, err = env.OpenAsymmetric(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed to encrypt with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if !decrypted.Validate() {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed to validate with seed %d.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
padsz := len(decrypted.Padding)
|
|
|
|
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: compare padding.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if bytes.Compare(text, decrypted.Payload) != 0 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: compare payload.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if !isMessageSigned(decrypted.Raw[0]) {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: unsigned.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if len(decrypted.Signature) != signatureLength {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
2016-12-19 15:58:01 -08:00
|
|
|
if !IsPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: signature mismatch.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func TestMessageEncryption(t *testing.T) {
|
2016-10-29 05:11:37 -07:00
|
|
|
InitSingleTest()
|
|
|
|
|
|
|
|
var symmetric bool
|
|
|
|
for i := 0; i < 256; i++ {
|
2016-12-01 11:09:22 -08:00
|
|
|
singleMessageTest(t, symmetric)
|
2016-10-29 05:11:37 -07:00
|
|
|
symmetric = !symmetric
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func TestMessageWrap(t *testing.T) {
|
2016-10-29 05:11:37 -07:00
|
|
|
seed = int64(1777444222)
|
|
|
|
rand.Seed(seed)
|
|
|
|
target := 128.0
|
|
|
|
|
|
|
|
params, err := generateMessageParams()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
msg := NewSentMessage(params)
|
|
|
|
params.TTL = 1
|
|
|
|
params.WorkTime = 12
|
|
|
|
params.PoW = target
|
|
|
|
env, err := msg.Wrap(params)
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pow := env.PoW()
|
|
|
|
if pow < target {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
2016-12-19 15:58:01 -08:00
|
|
|
|
|
|
|
// set PoW target too high, expect error
|
|
|
|
msg2 := NewSentMessage(params)
|
|
|
|
params.TTL = 1000000
|
|
|
|
params.WorkTime = 1
|
|
|
|
params.PoW = 10000000.0
|
|
|
|
env, err = msg2.Wrap(params)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("unexpectedly reached the PoW target with seed %d.", seed)
|
|
|
|
}
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func TestMessageSeal(t *testing.T) {
|
2016-10-29 05:11:37 -07:00
|
|
|
// this test depends on deterministic choice of seed (1976726903)
|
|
|
|
seed = int64(1976726903)
|
|
|
|
rand.Seed(seed)
|
|
|
|
|
|
|
|
params, err := generateMessageParams()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
msg := NewSentMessage(params)
|
|
|
|
params.TTL = 1
|
|
|
|
aesnonce := make([]byte, 12)
|
|
|
|
salt := make([]byte, 12)
|
|
|
|
randomize(aesnonce)
|
|
|
|
randomize(salt)
|
|
|
|
|
|
|
|
env := NewEnvelope(params.TTL, params.Topic, salt, aesnonce, msg)
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
env.Expiry = uint32(seed) // make it deterministic
|
|
|
|
target := 32.0
|
|
|
|
params.WorkTime = 4
|
|
|
|
params.PoW = target
|
|
|
|
env.Seal(params)
|
|
|
|
|
|
|
|
env.calculatePoW(0)
|
|
|
|
pow := env.PoW()
|
|
|
|
if pow < target {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
params.WorkTime = 1
|
|
|
|
params.PoW = 1000000000.0
|
|
|
|
env.Seal(params)
|
|
|
|
env.calculatePoW(0)
|
|
|
|
pow = env.PoW()
|
|
|
|
if pow < 2*target {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func TestEnvelopeOpen(t *testing.T) {
|
2016-10-29 05:11:37 -07:00
|
|
|
InitSingleTest()
|
|
|
|
|
|
|
|
var symmetric bool
|
|
|
|
for i := 0; i < 256; i++ {
|
2016-12-01 11:09:22 -08:00
|
|
|
singleEnvelopeOpenTest(t, symmetric)
|
2016-10-29 05:11:37 -07:00
|
|
|
symmetric = !symmetric
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-01 11:09:22 -08:00
|
|
|
func singleEnvelopeOpenTest(t *testing.T, symmetric bool) {
|
2016-10-29 05:11:37 -07:00
|
|
|
params, err := generateMessageParams()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
key, err := crypto.GenerateKey()
|
|
|
|
if err != nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
f := Filter{KeyAsym: key, KeySym: params.KeySym}
|
|
|
|
decrypted := env.Open(&f)
|
|
|
|
if decrypted == nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed to open with seed %d.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
padsz := len(decrypted.Padding)
|
|
|
|
if bytes.Compare(steg[:padsz], decrypted.Padding) != 0 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: compare padding.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if bytes.Compare(text, decrypted.Payload) != 0 {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: compare payload.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if !isMessageSigned(decrypted.Raw[0]) {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: unsigned.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if len(decrypted.Signature) != signatureLength {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
2016-12-19 15:58:01 -08:00
|
|
|
if !IsPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: signature mismatch.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if decrypted.isAsymmetricEncryption() == symmetric {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if decrypted.isSymmetricEncryption() != symmetric {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
if !symmetric {
|
|
|
|
if decrypted.Dst == nil {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: dst is nil.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
2016-12-19 15:58:01 -08:00
|
|
|
if !IsPubKeyEqual(decrypted.Dst, &key.PublicKey) {
|
2016-12-01 11:09:22 -08:00
|
|
|
t.Fatalf("failed with seed %d: Dst.", seed)
|
2016-10-29 05:11:37 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-12-19 15:58:01 -08:00
|
|
|
|
|
|
|
func TestEncryptWithZeroKey(t *testing.T) {
|
|
|
|
InitSingleTest()
|
|
|
|
|
|
|
|
params, err := generateMessageParams()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
msg := NewSentMessage(params)
|
|
|
|
|
|
|
|
params.KeySym = make([]byte, aesKeyLength)
|
|
|
|
_, err = msg.Wrap(params)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("wrapped with zero key, seed: %d.", seed)
|
|
|
|
}
|
|
|
|
|
|
|
|
params.KeySym = make([]byte, 0)
|
|
|
|
_, err = msg.Wrap(params)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("wrapped with empty key, seed: %d.", seed)
|
|
|
|
}
|
|
|
|
|
|
|
|
params.KeySym = nil
|
|
|
|
_, err = msg.Wrap(params)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("wrapped with nil key, seed: %d.", seed)
|
|
|
|
}
|
|
|
|
}
|