github.com/yinchengtsinghua/golang-Eos-dpos-Ethereum@v0.0.0-20190121132951-92cc4225ed8e/whisper/whisperv5/message_test.go (about)

     1  
     2  //此源码被清华学神尹成大魔王专业翻译分析并修改
     3  //尹成QQ77025077
     4  //尹成微信18510341407
     5  //尹成所在QQ群721929980
     6  //尹成邮箱 yinc13@mails.tsinghua.edu.cn
     7  //尹成毕业于清华大学,微软区块链领域全球最有价值专家
     8  //https://mvp.microsoft.com/zh-cn/PublicProfile/4033620
     9  //
    10  //
    11  //
    12  //
    13  //
    14  //
    15  //
    16  //
    17  //
    18  //
    19  //
    20  //
    21  //
    22  //
    23  //
    24  
    25  package whisperv5
    26  
    27  import (
    28  	"bytes"
    29  	mrand "math/rand"
    30  	"testing"
    31  
    32  	"github.com/ethereum/go-ethereum/crypto"
    33  	"github.com/ethereum/go-ethereum/rlp"
    34  )
    35  
    36  func generateMessageParams() (*MessageParams, error) {
    37  //
    38  
    39  	buf := make([]byte, 4)
    40  	mrand.Read(buf)
    41  	sz := mrand.Intn(400)
    42  
    43  	var p MessageParams
    44  	p.PoW = 0.01
    45  	p.WorkTime = 1
    46  	p.TTL = uint32(mrand.Intn(1024))
    47  	p.Payload = make([]byte, sz)
    48  	p.KeySym = make([]byte, aesKeyLength)
    49  	mrand.Read(p.Payload)
    50  	mrand.Read(p.KeySym)
    51  	p.Topic = BytesToTopic(buf)
    52  
    53  	var err error
    54  	p.Src, err = crypto.GenerateKey()
    55  	if err != nil {
    56  		return nil, err
    57  	}
    58  
    59  	return &p, nil
    60  }
    61  
    62  func singleMessageTest(t *testing.T, symmetric bool) {
    63  	params, err := generateMessageParams()
    64  	if err != nil {
    65  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
    66  	}
    67  
    68  	key, err := crypto.GenerateKey()
    69  	if err != nil {
    70  		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
    71  	}
    72  
    73  	if !symmetric {
    74  		params.KeySym = nil
    75  		params.Dst = &key.PublicKey
    76  	}
    77  
    78  	text := make([]byte, 0, 512)
    79  	text = append(text, params.Payload...)
    80  
    81  	msg, err := NewSentMessage(params)
    82  	if err != nil {
    83  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
    84  	}
    85  	env, err := msg.Wrap(params)
    86  	if err != nil {
    87  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
    88  	}
    89  
    90  	var decrypted *ReceivedMessage
    91  	if symmetric {
    92  		decrypted, err = env.OpenSymmetric(params.KeySym)
    93  	} else {
    94  		decrypted, err = env.OpenAsymmetric(key)
    95  	}
    96  
    97  	if err != nil {
    98  		t.Fatalf("failed to encrypt with seed %d: %s.", seed, err)
    99  	}
   100  
   101  	if !decrypted.Validate() {
   102  		t.Fatalf("failed to validate with seed %d.", seed)
   103  	}
   104  
   105  	if !bytes.Equal(text, decrypted.Payload) {
   106  		t.Fatalf("failed with seed %d: compare payload.", seed)
   107  	}
   108  	if !isMessageSigned(decrypted.Raw[0]) {
   109  		t.Fatalf("failed with seed %d: unsigned.", seed)
   110  	}
   111  	if len(decrypted.Signature) != signatureLength {
   112  		t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
   113  	}
   114  	if !IsPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
   115  		t.Fatalf("failed with seed %d: signature mismatch.", seed)
   116  	}
   117  }
   118  
   119  func TestMessageEncryption(t *testing.T) {
   120  	InitSingleTest()
   121  
   122  	var symmetric bool
   123  	for i := 0; i < 256; i++ {
   124  		singleMessageTest(t, symmetric)
   125  		symmetric = !symmetric
   126  	}
   127  }
   128  
   129  func TestMessageWrap(t *testing.T) {
   130  	seed = int64(1777444222)
   131  	mrand.Seed(seed)
   132  	target := 128.0
   133  
   134  	params, err := generateMessageParams()
   135  	if err != nil {
   136  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   137  	}
   138  
   139  	msg, err := NewSentMessage(params)
   140  	if err != nil {
   141  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   142  	}
   143  	params.TTL = 1
   144  	params.WorkTime = 12
   145  	params.PoW = target
   146  	env, err := msg.Wrap(params)
   147  	if err != nil {
   148  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   149  	}
   150  
   151  	pow := env.PoW()
   152  	if pow < target {
   153  		t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
   154  	}
   155  
   156  //
   157  	msg2, err := NewSentMessage(params)
   158  	if err != nil {
   159  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   160  	}
   161  	params.TTL = 1000000
   162  	params.WorkTime = 1
   163  	params.PoW = 10000000.0
   164  	_, err = msg2.Wrap(params)
   165  	if err == nil {
   166  		t.Fatalf("unexpectedly reached the PoW target with seed %d.", seed)
   167  	}
   168  }
   169  
   170  func TestMessageSeal(t *testing.T) {
   171  //
   172  	seed = int64(1976726903)
   173  	mrand.Seed(seed)
   174  
   175  	params, err := generateMessageParams()
   176  	if err != nil {
   177  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   178  	}
   179  
   180  	msg, err := NewSentMessage(params)
   181  	if err != nil {
   182  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   183  	}
   184  	params.TTL = 1
   185  	aesnonce := make([]byte, 12)
   186  	mrand.Read(aesnonce)
   187  
   188  	env := NewEnvelope(params.TTL, params.Topic, aesnonce, msg)
   189  	if err != nil {
   190  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   191  	}
   192  
   193  env.Expiry = uint32(seed) //
   194  	target := 32.0
   195  	params.WorkTime = 4
   196  	params.PoW = target
   197  	env.Seal(params)
   198  
   199  	env.calculatePoW(0)
   200  	pow := env.PoW()
   201  	if pow < target {
   202  		t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target)
   203  	}
   204  
   205  	params.WorkTime = 1
   206  	params.PoW = 1000000000.0
   207  	env.Seal(params)
   208  	env.calculatePoW(0)
   209  	pow = env.PoW()
   210  	if pow < 2*target {
   211  		t.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow)
   212  	}
   213  }
   214  
   215  func TestEnvelopeOpen(t *testing.T) {
   216  	InitSingleTest()
   217  
   218  	var symmetric bool
   219  	for i := 0; i < 256; i++ {
   220  		singleEnvelopeOpenTest(t, symmetric)
   221  		symmetric = !symmetric
   222  	}
   223  }
   224  
   225  func singleEnvelopeOpenTest(t *testing.T, symmetric bool) {
   226  	params, err := generateMessageParams()
   227  	if err != nil {
   228  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   229  	}
   230  
   231  	key, err := crypto.GenerateKey()
   232  	if err != nil {
   233  		t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err)
   234  	}
   235  
   236  	if !symmetric {
   237  		params.KeySym = nil
   238  		params.Dst = &key.PublicKey
   239  	}
   240  
   241  	text := make([]byte, 0, 512)
   242  	text = append(text, params.Payload...)
   243  
   244  	msg, err := NewSentMessage(params)
   245  	if err != nil {
   246  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   247  	}
   248  	env, err := msg.Wrap(params)
   249  	if err != nil {
   250  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   251  	}
   252  
   253  	f := Filter{KeyAsym: key, KeySym: params.KeySym}
   254  	decrypted := env.Open(&f)
   255  	if decrypted == nil {
   256  		t.Fatalf("failed to open with seed %d.", seed)
   257  	}
   258  
   259  	if !bytes.Equal(text, decrypted.Payload) {
   260  		t.Fatalf("failed with seed %d: compare payload.", seed)
   261  	}
   262  	if !isMessageSigned(decrypted.Raw[0]) {
   263  		t.Fatalf("failed with seed %d: unsigned.", seed)
   264  	}
   265  	if len(decrypted.Signature) != signatureLength {
   266  		t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature))
   267  	}
   268  	if !IsPubKeyEqual(decrypted.Src, &params.Src.PublicKey) {
   269  		t.Fatalf("failed with seed %d: signature mismatch.", seed)
   270  	}
   271  	if decrypted.isAsymmetricEncryption() == symmetric {
   272  		t.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric)
   273  	}
   274  	if decrypted.isSymmetricEncryption() != symmetric {
   275  		t.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric)
   276  	}
   277  	if !symmetric {
   278  		if decrypted.Dst == nil {
   279  			t.Fatalf("failed with seed %d: dst is nil.", seed)
   280  		}
   281  		if !IsPubKeyEqual(decrypted.Dst, &key.PublicKey) {
   282  			t.Fatalf("failed with seed %d: Dst.", seed)
   283  		}
   284  	}
   285  }
   286  
   287  func TestEncryptWithZeroKey(t *testing.T) {
   288  	InitSingleTest()
   289  
   290  	params, err := generateMessageParams()
   291  	if err != nil {
   292  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   293  	}
   294  	msg, err := NewSentMessage(params)
   295  	if err != nil {
   296  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   297  	}
   298  	params.KeySym = make([]byte, aesKeyLength)
   299  	_, err = msg.Wrap(params)
   300  	if err == nil {
   301  		t.Fatalf("wrapped with zero key, seed: %d.", seed)
   302  	}
   303  
   304  	params, err = generateMessageParams()
   305  	if err != nil {
   306  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   307  	}
   308  	msg, err = NewSentMessage(params)
   309  	if err != nil {
   310  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   311  	}
   312  	params.KeySym = make([]byte, 0)
   313  	_, err = msg.Wrap(params)
   314  	if err == nil {
   315  		t.Fatalf("wrapped with empty key, seed: %d.", seed)
   316  	}
   317  
   318  	params, err = generateMessageParams()
   319  	if err != nil {
   320  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   321  	}
   322  	msg, err = NewSentMessage(params)
   323  	if err != nil {
   324  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   325  	}
   326  	params.KeySym = nil
   327  	_, err = msg.Wrap(params)
   328  	if err == nil {
   329  		t.Fatalf("wrapped with nil key, seed: %d.", seed)
   330  	}
   331  }
   332  
   333  func TestRlpEncode(t *testing.T) {
   334  	InitSingleTest()
   335  
   336  	params, err := generateMessageParams()
   337  	if err != nil {
   338  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   339  	}
   340  	msg, err := NewSentMessage(params)
   341  	if err != nil {
   342  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   343  	}
   344  	env, err := msg.Wrap(params)
   345  	if err != nil {
   346  		t.Fatalf("wrapped with zero key, seed: %d.", seed)
   347  	}
   348  
   349  	raw, err := rlp.EncodeToBytes(env)
   350  	if err != nil {
   351  		t.Fatalf("RLP encode failed: %s.", err)
   352  	}
   353  
   354  	var decoded Envelope
   355  	rlp.DecodeBytes(raw, &decoded)
   356  	if err != nil {
   357  		t.Fatalf("RLP decode failed: %s.", err)
   358  	}
   359  
   360  	he := env.Hash()
   361  	hd := decoded.Hash()
   362  
   363  	if he != hd {
   364  		t.Fatalf("Hashes are not equal: %x vs. %x", he, hd)
   365  	}
   366  }
   367  
   368  func singlePaddingTest(t *testing.T, padSize int) {
   369  	params, err := generateMessageParams()
   370  	if err != nil {
   371  		t.Fatalf("failed generateMessageParams with seed %d and sz=%d: %s.", seed, padSize, err)
   372  	}
   373  	params.Padding = make([]byte, padSize)
   374  	params.PoW = 0.0000000001
   375  	pad := make([]byte, padSize)
   376  	_, err = mrand.Read(pad)
   377  	if err != nil {
   378  		t.Fatalf("padding is not generated (seed %d): %s", seed, err)
   379  	}
   380  	n := copy(params.Padding, pad)
   381  	if n != padSize {
   382  		t.Fatalf("padding is not copied (seed %d): %s", seed, err)
   383  	}
   384  	msg, err := NewSentMessage(params)
   385  	if err != nil {
   386  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   387  	}
   388  	env, err := msg.Wrap(params)
   389  	if err != nil {
   390  		t.Fatalf("failed to wrap, seed: %d and sz=%d.", seed, padSize)
   391  	}
   392  	f := Filter{KeySym: params.KeySym}
   393  	decrypted := env.Open(&f)
   394  	if decrypted == nil {
   395  		t.Fatalf("failed to open, seed and sz=%d: %d.", seed, padSize)
   396  	}
   397  	if !bytes.Equal(pad, decrypted.Padding) {
   398  		t.Fatalf("padding is not retireved as expected with seed %d and sz=%d:\n[%x]\n[%x].", seed, padSize, pad, decrypted.Padding)
   399  	}
   400  }
   401  
   402  func TestPadding(t *testing.T) {
   403  	InitSingleTest()
   404  
   405  	for i := 1; i < 260; i++ {
   406  		singlePaddingTest(t, i)
   407  	}
   408  
   409  	lim := 256 * 256
   410  	for i := lim - 5; i < lim+2; i++ {
   411  		singlePaddingTest(t, i)
   412  	}
   413  
   414  	for i := 0; i < 256; i++ {
   415  		n := mrand.Intn(256*254) + 256
   416  		singlePaddingTest(t, n)
   417  	}
   418  
   419  	for i := 0; i < 256; i++ {
   420  		n := mrand.Intn(256*1024) + 256*256
   421  		singlePaddingTest(t, n)
   422  	}
   423  }