예제 #1
0
// Receive waits for the response promised by the future and returns the raw
// block requested from the server given its hash.
func (r FutureGetBlockResult) Receive() (*dcrutil.Block, error) {
	res, err := receiveFuture(r)
	if err != nil {
		return nil, err
	}

	// Unmarshal result as a string.
	var blockHex string
	err = json.Unmarshal(res, &blockHex)
	if err != nil {
		return nil, err
	}

	// Decode the serialized block hex to raw bytes.
	serializedBlock, err := hex.DecodeString(blockHex)
	if err != nil {
		return nil, err
	}

	// Deserialize the block and return it.
	var msgBlock wire.MsgBlock
	err = msgBlock.Deserialize(bytes.NewReader(serializedBlock))
	if err != nil {
		return nil, err
	}
	return dcrutil.NewBlock(&msgBlock), nil
}
예제 #2
0
파일: block.go 프로젝트: decred/dcrutil
// NewBlockFromReader returns a new instance of a block given a
// Reader to deserialize the block.  See Block.
func NewBlockFromReader(r io.Reader) (*Block, error) {
	// Deserialize the bytes into a MsgBlock.
	var msgBlock wire.MsgBlock
	err := msgBlock.Deserialize(r)
	if err != nil {
		return nil, err
	}

	b := Block{
		hash:        msgBlock.BlockHash(),
		msgBlock:    &msgBlock,
		blockHeight: int64(msgBlock.Header.Height),
	}
	return &b, nil
}
예제 #3
0
// TestBlockSerializeErrors performs negative tests against wire encode and
// decode of MsgBlock to confirm error paths work correctly.
func TestBlockSerializeErrors(t *testing.T) {
	tests := []struct {
		in       *wire.MsgBlock // Value to encode
		buf      []byte         // Serialized data
		max      int            // Max size of fixed buffer to induce errors
		writeErr error          // Expected write error
		readErr  error          // Expected read error
	}{
		{&testBlock, testBlockBytes, 0, io.ErrShortWrite, io.EOF}, // 0
		// Force error in prev block hash.
		{&testBlock, testBlockBytes, 4, io.ErrShortWrite, io.EOF}, // 1
		// Force error in merkle root.
		{&testBlock, testBlockBytes, 36, io.ErrShortWrite, io.EOF}, // 2
		// Force error in stake root.
		{&testBlock, testBlockBytes, 68, io.ErrShortWrite, io.EOF}, // 3
		// Force error in vote bits.
		{&testBlock, testBlockBytes, 100, io.ErrShortWrite, io.EOF}, // 4
		// Force error in finalState.
		{&testBlock, testBlockBytes, 102, io.ErrShortWrite, io.EOF}, // 5
		// Force error in voters.
		{&testBlock, testBlockBytes, 108, io.ErrShortWrite, io.EOF}, // 8
		// Force error in freshstake.
		{&testBlock, testBlockBytes, 110, io.ErrShortWrite, io.EOF}, // 9
		// Force error in revocations.
		{&testBlock, testBlockBytes, 111, io.ErrShortWrite, io.EOF}, // 10
		// Force error in poolsize.
		{&testBlock, testBlockBytes, 112, io.ErrShortWrite, io.EOF}, // 11
		// Force error in difficulty bits.
		{&testBlock, testBlockBytes, 116, io.ErrShortWrite, io.EOF}, // 12
		// Force error in stake difficulty bits.
		{&testBlock, testBlockBytes, 120, io.ErrShortWrite, io.EOF}, // 13
		// Force error in height.
		{&testBlock, testBlockBytes, 128, io.ErrShortWrite, io.EOF}, // 14
		// Force error in size.
		{&testBlock, testBlockBytes, 132, io.ErrShortWrite, io.EOF}, // 15
		// Force error in timestamp.
		{&testBlock, testBlockBytes, 136, io.ErrShortWrite, io.EOF}, // 16
		// Force error in nonce.
		{&testBlock, testBlockBytes, 140, io.ErrShortWrite, io.EOF}, // 17
		// Force error in tx count.
		{&testBlock, testBlockBytes, 180, io.ErrShortWrite, io.EOF}, // 18
		// Force error in tx.
		{&testBlock, testBlockBytes, 181, io.ErrShortWrite, io.EOF}, // 19
	}

	t.Logf("Running %d tests", len(tests))
	for i, test := range tests {
		// Serialize the block.
		w := newFixedWriter(test.max)
		err := test.in.Serialize(w)
		if err != test.writeErr {
			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
				i, err, test.writeErr)
			continue
		}

		// Deserialize the block.
		var block wire.MsgBlock
		r := newFixedReader(test.max, test.buf)
		err = block.Deserialize(r)
		if err != test.readErr {
			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
				i, err, test.readErr)
			continue
		}

		var txLocBlock wire.MsgBlock
		br := bytes.NewBuffer(test.buf[0:test.max])
		_, _, err = txLocBlock.DeserializeTxLoc(br)
		if err != test.readErr {
			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, want: %v",
				i, err, test.readErr)
			continue
		}
	}
}
예제 #4
0
// TestBlockOverflowErrors  performs tests to ensure deserializing blocks which
// are intentionally crafted to use large values for the number of transactions
// are handled properly.  This could otherwise potentially be used as an attack
// vector.
func TestBlockOverflowErrors(t *testing.T) {
	// Use protocol version 70001 specifically here instead of the latest
	// protocol version because the test data is using bytes encoded with
	// that version.
	pver := uint32(1)

	tests := []struct {
		buf  []byte // Wire encoding
		pver uint32 // Protocol version for wire encoding
		err  error  // Expected error
	}{
		// Block that claims to have ~uint64(0) transactions.
		{
			[]byte{
				0x01, 0x00, 0x00, 0x00, // Version 1
				0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
				0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
				0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
				0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // PrevBlock
				0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44,
				0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
				0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
				0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e, // MerkleRoot
				0x98, 0x20, 0x51, 0xfd, 0x1e, 0x4b, 0xa7, 0x44,
				0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
				0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
				0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e, // StakeRoot
				0x00, 0x00, // VoteBits
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // FinalState
				0x00, 0x00, // Voters
				0x00,                   // FreshStake
				0x00,                   // Revocations
				0x00, 0x00, 0x00, 0x00, // Poolsize
				0xff, 0xff, 0x00, 0x1d, // Bits
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SBits
				0x01, 0x00, 0x00, 0x00, // Height
				0x01, 0x00, 0x00, 0x00, // Size
				0x61, 0xbc, 0x66, 0x49, // Timestamp
				0x01, 0xe3, 0x62, 0x99, // Nonce
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ExtraData
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
				0x00, 0x00, 0x00, 0x00,
				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
				0xff, // TxnCount
			}, pver, &wire.MessageError{},
		},
	}

	t.Logf("Running %d tests", len(tests))
	for i, test := range tests {
		// Decode from wire format.
		var msg wire.MsgBlock
		r := bytes.NewReader(test.buf)
		err := msg.BtcDecode(r, test.pver)
		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
				i, err, reflect.TypeOf(test.err))
			continue
		}

		// Deserialize from wire format.
		r = bytes.NewReader(test.buf)
		err = msg.Deserialize(r)
		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
				i, err, reflect.TypeOf(test.err))
			continue
		}

		// Deserialize with transaction location info from wire format.
		br := bytes.NewBuffer(test.buf)
		_, _, err = msg.DeserializeTxLoc(br)
		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, "+
				"want: %v", i, err, reflect.TypeOf(test.err))
			continue
		}
	}
}
예제 #5
0
// TestBlockSerialize tests MsgBlock serialize and deserialize.
func TestBlockSerialize(t *testing.T) {
	tests := []struct {
		in      *wire.MsgBlock // Message to encode
		out     *wire.MsgBlock // Expected decoded message
		buf     []byte         // Serialized data
		txLocs  []wire.TxLoc   // Expected transaction locations
		sTxLocs []wire.TxLoc   // Expected stake transaction locations
	}{
		{
			&testBlock,
			&testBlock,
			testBlockBytes,
			testBlockTxLocs,
			testBlockSTxLocs,
		},
	}

	t.Logf("Running %d tests", len(tests))
	for i, test := range tests {
		// Serialize the block.
		var buf bytes.Buffer
		err := test.in.Serialize(&buf)
		if err != nil {
			t.Errorf("Serialize #%d error %v", i, err)
			continue
		}
		if !bytes.Equal(buf.Bytes(), test.buf) {
			t.Errorf("Serialize #%d\n got: %s want: %s", i,
				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
			continue
		}

		// Deserialize the block.
		var block wire.MsgBlock
		rbuf := bytes.NewReader(test.buf)
		err = block.Deserialize(rbuf)
		if err != nil {
			t.Errorf("Deserialize #%d error %v", i, err)
			continue
		}
		if !reflect.DeepEqual(&block, test.out) {
			t.Errorf("Deserialize #%d\n got: %s want: %s", i,
				spew.Sdump(&block), spew.Sdump(test.out))
			continue
		}

		// Deserialize the block while gathering transaction location
		// information.
		var txLocBlock wire.MsgBlock
		br := bytes.NewBuffer(test.buf)
		txLocs, sTxLocs, err := txLocBlock.DeserializeTxLoc(br)
		if err != nil {
			t.Errorf("DeserializeTxLoc #%d error %v", i, err)
			continue
		}
		if !reflect.DeepEqual(&txLocBlock, test.out) {
			t.Errorf("DeserializeTxLoc #%d\n got: %s want: %s", i,
				spew.Sdump(&txLocBlock), spew.Sdump(test.out))
			continue
		}
		if !reflect.DeepEqual(txLocs, test.txLocs) {
			t.Errorf("DeserializeTxLoc #%d\n got: %s want: %s", i,
				spew.Sdump(txLocs), spew.Sdump(test.txLocs))
			continue
		}
		if !reflect.DeepEqual(sTxLocs, test.sTxLocs) {
			t.Errorf("DeserializeTxLoc, sTxLocs #%d\n got: %s want: %s", i,
				spew.Sdump(sTxLocs), spew.Sdump(test.sTxLocs))
			continue
		}
	}
}