bitcoinrb 1.14.0 → 1.16.0

data/lib/bitcoin/key.rb

@@ -95,7 +95,7 @@ module Bitcoin
     # @return [Bitcoin::Key]
     def self.from_point(point, compressed: true)
       pubkey = ECDSA::Format::PointOctetString.encode(point, compression: compressed).bth
-      Bitcoin::Key.new(pubkey: pubkey, key_type: TYPES[:compressed])
+      Bitcoin::Key.new(pubkey: pubkey, key_type: compressed ? TYPES[:compressed] : TYPES[:uncompressed])
     end
 
     # export private key with wif format
@@ -164,6 +164,7 @@ module Bitcoin
         case algo
         when :ecdsa
           sig = ecdsa_signature_parse_der_lax(sig)
+          return false unless sig
           secp256k1_module.verify_sig(data, sig, pubkey)
         when :schnorr
           secp256k1_module.verify_sig(data, sig, xonly_pubkey, algo: :schnorr)
@@ -192,10 +193,17 @@ module Bitcoin
       Bitcoin::Script.to_p2wpkh(hash160).to_addr
     end
 
-    # Get pay to taproot address
+    # Get pay to taproot address.
+    # By default the x-only public key of this key becomes the output key as it is, which is
+    # what the rawtr() descriptor does. With +as_internal+ this key is the internal key P and
+    # the output key is Q = P + hash_TapTweak(P)G, which is what the tr() descriptor does and
+    # what BIP-86 defines for a single key address. Spending such an output needs the tweaked
+    # private key, see Bitcoin::Taproot.tweak_private_key.
+    # @param [Boolean] as_internal Whether to treat this key as the internal key. Default is false.
     # @return [String] address
-    def to_p2tr
-      Bitcoin::Script.to_p2tr(self).to_addr
+    def to_p2tr(as_internal: false)
+      output_key = as_internal ? Bitcoin::Taproot.tweak_public_key(self, '') : self
+      Bitcoin::Script.to_p2tr(output_key).to_addr
     end
 
     # get p2wpkh address nested in p2sh.
@@ -352,7 +360,11 @@ module Bitcoin
       if secp256k1_module.native?
         Bitcoin::BIP324::EllSwiftPubkey.new(secp256k1_module.ellswift_create(priv_key))
       else
-        Bitcoin::BIP324::EllSwiftPubkey.new(Bitcoin::BIP324.xelligatorswift(xonly_pubkey))
+        encoded = Bitcoin::BIP324.xelligatorswift(xonly_pubkey)
+        # t and -t decode to the same x, and the parity of t gives the Y coordinate, as libsecp256k1 encodes it.
+        t = encoded[64..-1].hex
+        t = Bitcoin::BIP324::FIELD.mod(-t) if t.odd? != to_point.y.odd?
+        Bitcoin::BIP324::EllSwiftPubkey.new(encoded[0...64] + ECDSA::Format::IntegerOctetString.encode(t, 32).bth)
       end
     end
 
@@ -387,22 +399,69 @@ module Bitcoin
       MIN_PRIV_KEY_MOD_ORDER <= value && value <= MAX_PRIV_KEY_MOD_ORDER
     end
 
-    # Supported violations include negative integers, excessive padding, garbage
-    # at the end, and overly long length descriptors. This is safe to use in
-    # Bitcoin because since the activation of BIP66, signatures are verified to be
-    # strict DER before being passed to this module, and we know it supports all
-    # violations present in the blockchain before that point.
+    # Parse a DER signature the way ecdsa_signature_parse_der_lax in Bitcoin Core does, and return it
+    # as strict DER for the backend. Supported violations include negative integers, excessive padding,
+    # garbage at the end, and overly long length descriptors. This is safe to use in Bitcoin because
+    # since the activation of BIP66, signatures are verified to be strict DER before being passed to
+    # this method, and it supports all violations present in the blockchain before that point.
+    # @param [String] sig a signature with binary format, without the sighash type.
+    # @return [String, nil] the signature as strict DER, or nil when it cannot be parsed or R or S is
+    #   zero or not below the curve order, which Bitcoin Core also treats as an invalid signature.
     def ecdsa_signature_parse_der_lax(sig)
-      sig_array = sig.unpack('C*')
-      len_r = sig_array[3]
-      r = sig_array[4...(len_r+4)].pack('C*').bth
-      len_s = sig_array[len_r + 5]
-      s = sig_array[(len_r + 6)...(len_r + 6 + len_s)].pack('C*').bth
-      ECDSA::Signature.new(r.to_i(16), s.to_i(16)).to_der
+      bytes = sig.unpack('C*')
+      pos = 0
+      return nil if bytes[pos] != 0x30 # sequence tag
+      pos += 1
+      return nil if pos >= bytes.size
+      len_byte = bytes[pos] # the sequence length is skipped, however long it claims to be
+      pos += 1
+      if len_byte & 0x80 != 0
+        len_byte -= 0x80
+        return nil if len_byte > bytes.size - pos
+        pos += len_byte
+      end
+      r, pos = parse_lax_der_integer(bytes, pos)
+      return nil unless r
+      s, _ = parse_lax_der_integer(bytes, pos)
+      return nil unless s
+      order = ECDSA::Group::Secp256k1.order
+      return nil if r.zero? || s.zero? || r >= order || s >= order
+      ECDSA::Signature.new(r, s).to_der
+    end
+
+    # Parse one INTEGER of a lax DER signature starting at +pos+.
+    # @return [Array(Integer, Integer), nil] the value and the position after it, or nil.
+    def parse_lax_der_integer(bytes, pos)
+      return nil if pos >= bytes.size || bytes[pos] != 0x02 # integer tag
+      pos += 1
+      return nil if pos >= bytes.size
+      len_byte = bytes[pos]
+      pos += 1
+      if len_byte & 0x80 != 0
+        len_byte -= 0x80
+        return nil if len_byte > bytes.size - pos
+        while len_byte > 0 && bytes[pos] == 0 # leading zeros of the length
+          pos += 1
+          len_byte -= 1
+        end
+        return nil if len_byte >= 4
+        len = 0
+        len_byte.times do
+          len = (len << 8) + bytes[pos]
+          pos += 1
+        end
+      else
+        len = len_byte
+      end
+      return nil if len > bytes.size - pos
+      # Read as an unsigned number: a leading 0x80 bit, which strict DER would call negative, and
+      # leading zero padding are both accepted.
+      value = len.zero? ? 0 : bytes[pos, len].pack('C*').unpack1('H*').to_i(16)
+      [value, pos + len]
     end
 
     def valid_pubkey?
-      !pubkey.nil? && pubkey.size > 0
+      !pubkey.nil? && pubkey.size > 0 && pubkey.valid_hex?
     end
 
     # check whether the signature is low-R

data/lib/bitcoin/key_path.rb

@@ -2,6 +2,7 @@ module Bitcoin
   module KeyPath
 
     # key path convert an array of derive number
+    # A hardened index is marked with a trailing ' or h, as Bitcoin Core's ParseHDKeypath reads it.
     # @param [String] path_string
     # @return [Array[Integer]] key path numbers.
     # @raise [ArgumentError] if invalid +path_string+.
@@ -14,11 +15,13 @@ module Bitcoin
           next if p == 'm'
           raise ArgumentError, "Invalid path." unless p == 'm'
         end
-        raise ArgumentError, "Invalid path." if p.count("'") > 1 || (p.count("'") == 1 && p[-1] != "'")
-        raise ArgumentError, "Invalid path." unless p.delete("'") =~ /^[0-9]+$/
-        value = (p[-1] == "'" ? p.delete("'").to_i + Bitcoin::HARDENED_THRESHOLD : p.to_i)
-        raise ArgumentError, "Invalid path." if value > 4294967295 # 4294967295 = 0xFFFFFFFF (uint32 max)
-        value
+        hardened = p.end_with?("'", 'h')
+        number = hardened ? p[0...-1] : p
+        raise ArgumentError, "Invalid path." unless number =~ /\A[0-9]+\z/
+        value = number.to_i
+        # 4294967295 = 0xFFFFFFFF (uint32 max)
+        raise ArgumentError, "Invalid path." if value > (hardened ? Bitcoin::HARDENED_THRESHOLD - 1 : 4294967295)
+        hardened ? value + Bitcoin::HARDENED_THRESHOLD : value
       end[1..-1]
     end
 

data/lib/bitcoin/message/addr.rb

@@ -18,6 +18,7 @@ module Bitcoin
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         addr_count = Bitcoin.unpack_var_int_from_io(buf)
+        raise Bitcoin::Message::Error, "addr message size #{addr_count} exceeds #{MAX_ADDR_TO_SEND}." if addr_count > MAX_ADDR_TO_SEND
         addr = new
         addr_count.times do
           addr.addrs << NetworkAddr.parse_from_payload(buf)

data/lib/bitcoin/message/addr_v2.rb

@@ -16,6 +16,7 @@ module Bitcoin
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         addr_count = Bitcoin.unpack_var_int_from_io(buf)
+        raise Bitcoin::Message::Error, "addrv2 message size #{addr_count} exceeds #{MAX_ADDR_TO_SEND}." if addr_count > MAX_ADDR_TO_SEND
         v2 = new
         addr_count.times do
           v2.addrs << NetworkAddr.parse_from_payload(buf, type: NetworkAddr::TYPE[:addr_v2])

data/lib/bitcoin/message/base.rb

@@ -7,6 +7,9 @@ module Bitcoin
       include Bitcoin::Util
       extend Bitcoin::Util
 
+      # The size of the message header: magic, command, length and checksum.
+      HEADER_SIZE = 24
+
       # generate message header (binary format)
       # https://bitcoin.org/en/developer-reference#message-headers
       def to_pkt
@@ -28,10 +31,14 @@ module Bitcoin
       # @return [Bitcoin::Message::XXX] An instance of a class that inherits Bitcoin::Message::Base
       # @raise [ArgumentError] Occurs for data that cannot be decoded.
       def self.from_pkt(message)
+        raise ArgumentError, 'Message header is too short.' if message.bytesize < HEADER_SIZE
         buf = StringIO.new(message)
         magic = buf.read(4)
         raise ArgumentError, 'Invalid magic.' unless magic == Bitcoin.chain_params.magic_head.htb
-        command = buf.read(12).delete("\x00")
+        # The command is padded with NUL bytes to 12. Bitcoin Core rejects a command with a non-NUL byte
+        # after its first NUL.
+        command, padding = buf.read(12).split("\x00", 2)
+        raise ArgumentError, 'Invalid command.' if command.nil? || padding&.delete("\x00")&.bytesize.to_i > 0
         # The length is announced by the peer, so it is checked before it is used to read.
         length = buf.read(4).unpack1('V')
         if length > MAX_PROTOCOL_MESSAGE_LENGTH

data/lib/bitcoin/message/block.rb

@@ -19,14 +19,10 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        transactions = []
-        unless buf.eof?
-          tx_count = Bitcoin.unpack_var_int_from_io(buf)
-          tx_count.times do
-            transactions << Bitcoin::Tx.parse_from_payload(buf)
-          end
-        end
+        header = Bitcoin::BlockHeader.parse_from_payload(Bitcoin.read_exact(buf, 80))
+        # A block message always carries its tx count, which may be 0 only in a block nobody can produce.
+        tx_count = Bitcoin.unpack_var_int_from_io(buf)
+        transactions = tx_count.times.map { Bitcoin::Tx.parse_from_payload(buf) }
         new(header, transactions)
       end
 

data/lib/bitcoin/message/block_transaction_request.rb

@@ -15,18 +15,21 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        block_hash = buf.read(32).bth
+        block_hash = Bitcoin.read_exact(buf, 32)
         index_len = Bitcoin.unpack_var_int_from_io(buf)
-        indexes = index_len.times.map{Bitcoin.unpack_var_int_from_io(buf)}
-        # index data differentially encoded
+        # Each index takes at least one byte, so a count the payload cannot hold is rejected before
+        # anything is allocated for it.
+        raise Bitcoin::Message::Error, "Invalid getblocktxn payload. index count #{index_len} exceeds the payload." if index_len > (buf.size - buf.pos)
+        # index data differentially encoded. Bitcoin Core keeps every decoded index within 16 bits.
+        indexes = []
         offset = 0
-        index_len.times do |i|
-          index = indexes[i]
-          index += offset
-          indexes[i] = index
+        index_len.times do
+          index = Bitcoin.unpack_var_int_from_io(buf) + offset
+          raise Bitcoin::Message::Error, 'Invalid getblocktxn payload. index overflowed 16 bits.' if index > 0xffff
+          indexes << index
           offset = index + 1
         end
-        self.new(block_hash, indexes)
+        self.new(block_hash.bth, indexes)
       end
 
       def to_payload

data/lib/bitcoin/message/block_transactions.rb

@@ -15,8 +15,9 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        block_hash = buf.read(32).bth
+        block_hash = Bitcoin.read_exact(buf, 32).bth
         tx_count = Bitcoin.unpack_var_int_from_io(buf)
+        raise Bitcoin::Message::Error, "blocktxn tx count #{tx_count} exceeds #{MAX_COMPACT_BLOCK_TX_COUNT}." if tx_count > MAX_COMPACT_BLOCK_TX_COUNT
         txn = tx_count.times.map{Bitcoin::Tx.parse_from_payload(buf)}
         self.new(block_hash, txn)
       end

data/lib/bitcoin/message/cf_parser.rb

@@ -3,6 +3,7 @@ module Bitcoin
     module CFParser
 
       def parse_from_payload(payload)
+        raise Bitcoin::Message::Error, 'Payload must be 37 bytes.' unless payload.bytesize == 37
         type, start, hash = payload.unpack('CVH*')
         self.new(type, start, hash)
       end

data/lib/bitcoin/message/cfcheckpt.rb

@@ -19,10 +19,10 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack1('C')
-        hash = buf.read(32).unpack1('H*')
+        type = Bitcoin.read_exact(buf, 1).unpack1('C')
+        hash = Bitcoin.read_exact(buf, 32).unpack1('H*')
         count = Bitcoin.unpack_var_int_from_io(buf)
-        headers = count.times.map{buf.read(32).bth}
+        headers = count.times.map{Bitcoin.read_exact(buf, 32).bth}
         self.new(type, hash, headers)
       end
 

data/lib/bitcoin/message/cfheaders.rb

@@ -21,11 +21,12 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack1("C")
-        hash = buf.read(32).bth
-        header = buf.read(32).bth
+        type = Bitcoin.read_exact(buf, 1).unpack1("C")
+        hash = Bitcoin.read_exact(buf, 32).bth
+        header = Bitcoin.read_exact(buf, 32).bth
         count = Bitcoin.unpack_var_int_from_io(buf)
-        hashes = count.times.map{buf.read(32).bth}
+        raise Bitcoin::Message::Error, "cfheaders size #{count} exceeds #{MAX_CFHEADERS_RESULTS}." if count > MAX_CFHEADERS_RESULTS
+        hashes = count.times.map{Bitcoin.read_exact(buf, 32).bth}
         self.new(type, hash, header, hashes)
       end
 

data/lib/bitcoin/message/cfilter.rb

@@ -19,10 +19,10 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        type = buf.read(1).unpack1("C")
-        hash = buf.read(32).bth
+        type = Bitcoin.read_exact(buf, 1).unpack1("C")
+        hash = Bitcoin.read_exact(buf, 32).bth
         len = Bitcoin.unpack_var_int_from_io(buf)
-        filter = buf.read(len).bth
+        filter = Bitcoin.read_exact(buf, len).bth
         self.new(type, hash, filter)
       end
 

data/lib/bitcoin/message/error.rb

@@ -2,7 +2,9 @@ module Bitcoin
   module Message
 
     # P2P message layer Error
-    class Error < StandardError
+    # It is an ArgumentError, like the errors the other parsers raise, so that every failure to parse
+    # data from a peer can be rescued as one.
+    class Error < ArgumentError
 
     end
 

data/lib/bitcoin/message/fee_filter.rb

@@ -15,6 +15,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
+        raise Bitcoin::Message::Error, 'Payload must be 8 bytes.' unless payload.bytesize == 8
         new(payload.unpack1('Q<'))
       end
 

data/lib/bitcoin/message/filter_add.rb

@@ -15,7 +15,9 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(Bitcoin.unpack_var_string(payload).first.bth)
+        element = Bitcoin.unpack_var_string(payload).first
+        raise Bitcoin::Message::Error, "filteradd element size #{element.bytesize} exceeds #{Bitcoin::MAX_SCRIPT_ELEMENT_SIZE}." if element.bytesize > Bitcoin::MAX_SCRIPT_ELEMENT_SIZE
+        new(element.bth)
       end
 
       def to_payload

data/lib/bitcoin/message/filter_load.rb

@@ -28,14 +28,14 @@ module Bitcoin
           raise Bitcoin::Message::Error,
                 "filter size must be less than or equal to #{Bitcoin::BloomFilter::MAX_BLOOM_FILTER_SIZE}."
         end
-        filter = buf.read(filter_count).unpack('C*')
-        func_count = buf.read(4).unpack1('V')
+        filter = Bitcoin.read_exact(buf, filter_count).unpack('C*')
+        func_count = Bitcoin.read_exact(buf, 4).unpack1('V')
         if func_count > Bitcoin::BloomFilter::MAX_HASH_FUNCS
           raise Bitcoin::Message::Error,
                 "hash funcs must be less than or equal to #{Bitcoin::BloomFilter::MAX_HASH_FUNCS}."
         end
-        tweak = buf.read(4).unpack1('V')
-        flag = buf.read(1).unpack1('C')
+        tweak = Bitcoin.read_exact(buf, 4).unpack1('V')
+        flag = Bitcoin.read_exact(buf, 1).unpack1('C')
         FilterLoad.new(Bitcoin::BloomFilter.new(filter, func_count, tweak), flag)
       end
 

data/lib/bitcoin/message/get_cfcheckpt.rb

@@ -16,6 +16,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
+        raise Bitcoin::Message::Error, 'Payload must be 33 bytes.' unless payload.bytesize == 33
         type, hash = payload.unpack('CH*')
         self.new(type, hash)
       end

data/lib/bitcoin/message/header_and_short_ids.rb

@@ -6,9 +6,9 @@ module Bitcoin
     # https://github.com/bitcoin/bips/blob/master/bip-0152.mediawiki#HeaderAndShortIDs
     class HeaderAndShortIDs
       attr_accessor :header
-      attr_accessor :nonce
+      attr_accessor :nonce # 64 bit unsigned integer
       attr_accessor :short_ids
-      attr_accessor :prefilled_txn
+      attr_accessor :prefilled_txn # Array of PrefilledTx, whose index is the position in the block.
       attr_accessor :siphash_key
 
       def initialize(header, nonce, short_ids = [], prefilled_txn = [])
@@ -16,31 +16,46 @@ module Bitcoin
         @nonce = nonce
         @short_ids = short_ids
         @prefilled_txn = prefilled_txn
-        @siphash_key = Bitcoin.sha256(header.to_payload << [nonce].pack('q<*'))[0...16]
+        @siphash_key = Bitcoin.sha256(header.to_payload << [nonce].pack('Q<'))[0...16]
       end
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        nonce = buf.read(8).unpack1('q<*')
+        header = Bitcoin::BlockHeader.parse_from_payload(Bitcoin.read_exact(buf, 80))
+        nonce = Bitcoin.read_exact(buf, 8).unpack1('Q<')
         short_ids_len = Bitcoin.unpack_var_int_from_io(buf)
+        raise Bitcoin::Message::Error, "cmpctblock tx count #{short_ids_len} exceeds #{MAX_COMPACT_BLOCK_TX_COUNT}." if short_ids_len > MAX_COMPACT_BLOCK_TX_COUNT
         short_ids = short_ids_len.times.map do
-           buf.read(6).reverse.bth.to_i(16)
+           Bitcoin.read_exact(buf, 6).reverse.bth.to_i(16)
         end
         prefilled_txn_len = Bitcoin.unpack_var_int_from_io(buf)
+        if short_ids_len + prefilled_txn_len > MAX_COMPACT_BLOCK_TX_COUNT
+          raise Bitcoin::Message::Error, "cmpctblock tx count #{short_ids_len + prefilled_txn_len} exceeds #{MAX_COMPACT_BLOCK_TX_COUNT}."
+        end
+        # The index of a prefilled tx is differentially encoded. Bitcoin Core keeps every decoded index within 16 bits.
+        offset = 0
         prefilled_txn = prefilled_txn_len.times.map do
-          PrefilledTx.parse_from_io(buf)
+          prefilled = PrefilledTx.parse_from_io(buf)
+          prefilled.index += offset
+          raise Bitcoin::Message::Error, 'Invalid cmpctblock payload. prefilled tx index overflowed 16 bits.' if prefilled.index > 0xffff
+          offset = prefilled.index + 1
+          prefilled
         end
         self.new(header, nonce, short_ids, prefilled_txn)
       end
 
       def to_payload
         p = header.to_payload
-        p << [nonce].pack('q<*')
+        p << [nonce].pack('Q<')
         p << Bitcoin.pack_var_int(short_ids.size)
         p << short_ids.map{|id|sprintf('%012x', id).htb.reverse}.join
         p << Bitcoin.pack_var_int(prefilled_txn.size)
-        p << prefilled_txn.map(&:to_payload).join
+        prev = -1
+        prefilled_txn.each do |prefilled|
+          raise ArgumentError, 'prefilled tx indexes must be in ascending order.' unless prefilled.index > prev
+          p << PrefilledTx.new(prefilled.index - prev - 1, prefilled.tx).to_payload
+          prev = prefilled.index
+        end
         p
       end
 
@@ -48,8 +63,8 @@ module Bitcoin
       # @param [String] txid a transaction id
       # @return [Integer] 6 bytes short transaction id.
       def short_id(txid)
-        hash = SipHash.digest(siphash_key, txid.htb.reverse).to_even_length_hex
-        [hash].pack('H*')[2...8].bth.to_i(16)
+        # The low 6 bytes of the 64 bit SipHash output, which may have leading zero bytes.
+        SipHash.digest(siphash_key, txid.htb.reverse) & 0xffff_ffff_ffff
       end
 
     end

data/lib/bitcoin/message/headers.rb

@@ -7,6 +7,10 @@ module Bitcoin
 
       COMMAND = 'headers'
 
+      # The most headers one message may carry. Bitcoin Core sends this many for one getheaders and
+      # rejects a message with more (MAX_HEADERS_RESULTS).
+      MAX_HEADERS_RESULTS = 2000
+
       # Array[Bitcoin::BlockHeader]
       attr_accessor :headers
 
@@ -14,13 +18,17 @@ module Bitcoin
         @headers = headers
       end
 
+      # @raise [Bitcoin::Message::Error] If the payload is truncated or carries more headers than allowed.
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         header_count = Bitcoin.unpack_var_int_from_io(buf)
+        raise Bitcoin::Message::Error, "Invalid headers payload. header count #{header_count} exceeds #{MAX_HEADERS_RESULTS}." if header_count > MAX_HEADERS_RESULTS
         h = new
         header_count.times do
-          h.headers << Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-          buf.read(1) # read tx count 0x00 (headers message doesn't include any tx.)
+          h.headers << Bitcoin::BlockHeader.parse_from_payload(Bitcoin.read_exact(buf, 80))
+          # The tx count is a CompactSize, which Bitcoin Core reads and ignores since a headers message
+          # carries no tx. Reading a single byte here misaligned every header behind a longer encoding.
+          Bitcoin.unpack_var_int_from_io(buf)
         end
         h
       end

data/lib/bitcoin/message/headers_parser.rb

@@ -5,14 +5,16 @@ module Bitcoin
     module HeadersParser
 
       def parse_from_payload(payload)
+        raise Bitcoin::Message::Error, 'Payload is too short.' if payload.bytesize < 4
         ver, payload = payload.unpack('Va*')
         size, payload = Bitcoin.unpack_var_int(payload)
+        raise Bitcoin::Message::Error, "#{self::COMMAND} locator size #{size} exceeds #{MAX_LOCATOR_SZ}." if size > MAX_LOCATOR_SZ
         hashes = []
         buf = StringIO.new(payload)
         size.times do
-          hashes << buf.read(32).bth
+          hashes << Bitcoin.read_exact(buf, 32).bth
         end
-        new(ver, hashes, buf.read(32).bth)
+        new(ver, hashes, Bitcoin.read_exact(buf, 32).bth)
       end
 
       def to_payload

data/lib/bitcoin/message/inventories_parser.rb

@@ -6,10 +6,11 @@ module Bitcoin
 
       def parse_from_payload(payload)
         size, payload = Bitcoin.unpack_var_int(payload)
+        raise Bitcoin::Message::Error, "#{self::COMMAND} message size #{size} exceeds #{MAX_INV_SZ}." if size > MAX_INV_SZ
         buf = StringIO.new(payload)
         i = new
         size.times do
-          i.inventories << Inventory.parse_from_payload(buf.read(36))
+          i.inventories << Inventory.parse_from_payload(Bitcoin.read_exact(buf, 36))
         end
         i
       end

data/lib/bitcoin/message/inventory.rb

@@ -10,6 +10,7 @@ module Bitcoin
       MSG_BLOCK = 2
       MSG_FILTERED_BLOCK = 3
       MSG_CMPCT_BLOCK = 4
+      MSG_WTX = 5 # BIP-339, the hash is a wtxid.
       MSG_WITNESS_TX = SEGWIT_FLAG | MSG_TX
       MSG_WITNESS_BLOCK = SEGWIT_FLAG | MSG_BLOCK
       MSG_FILTERED_WITNESS_BLOCK = SEGWIT_FLAG | MSG_FILTERED_BLOCK
@@ -17,8 +18,17 @@ module Bitcoin
       attr_accessor :identifier
       attr_accessor :hash
 
+      KNOWN_IDENTIFIERS = [MSG_TX, MSG_BLOCK, MSG_FILTERED_BLOCK, MSG_CMPCT_BLOCK, MSG_WTX, MSG_WITNESS_TX,
+                           MSG_WITNESS_BLOCK, MSG_FILTERED_WITNESS_BLOCK].freeze
+
+      # A type which is not known is kept as it is, and is left for the receiver to ignore, as Bitcoin Core does.
+      # @param [Integer] identifier The type of the inventory, a 32 bit unsigned integer.
+      # @param [String] hash The hash with hex format.
+      # @raise [Bitcoin::Message::Error] If +identifier+ is not a 32 bit unsigned integer.
       def initialize(identifier, hash)
-        raise Error, "invalid type identifier specified. identifier = #{identifier}" unless valid_identifier?(identifier)
+        unless identifier.is_a?(Integer) && identifier.between?(0, 0xffffffff)
+          raise Error, "invalid type identifier specified. identifier = #{identifier}"
+        end
         @identifier = identifier
         @hash = hash
       end
@@ -39,11 +49,10 @@ module Bitcoin
         [MSG_BLOCK, MSG_WITNESS_BLOCK, MSG_FILTERED_WITNESS_BLOCK].include?(identifier)
       end
 
-      private
-
-      def valid_identifier?(identifier)
-        [MSG_TX, MSG_BLOCK, MSG_FILTERED_BLOCK, MSG_CMPCT_BLOCK, MSG_WITNESS_TX,
-         MSG_WITNESS_BLOCK, MSG_FILTERED_WITNESS_BLOCK].include?(identifier)
+      # Whether the type of this inventory is one this library knows.
+      # @return [Boolean]
+      def known?
+        KNOWN_IDENTIFIERS.include?(identifier)
       end
 
     end

data/lib/bitcoin/message/merkle_block.rb

@@ -19,15 +19,15 @@ module Bitcoin
       def self.parse_from_payload(payload)
         m = new
         buf = StringIO.new(payload)
-        m.header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        m.tx_count = buf.read(4).unpack1('V')
+        m.header = Bitcoin::BlockHeader.parse_from_payload(Bitcoin.read_exact(buf, 80))
+        m.tx_count = Bitcoin.read_exact(buf, 4).unpack1('V')
         hash_count = Bitcoin.unpack_var_int_from_io(buf)
         hash_count.times do
-          m.hashes << buf.read(32).bth
+          m.hashes << Bitcoin.read_exact(buf, 32).bth
         end
         flag_count = Bitcoin.unpack_var_int_from_io(buf)
         # A sequence of bits packed eight in a byte with the least significant bit first.
-        m.flags = buf.read(flag_count).bth
+        m.flags = Bitcoin.read_exact(buf, flag_count).bth
         # Reject a tree an untrusted peer could use to exhaust memory or CPU in #partial_tree.
         begin
           Bitcoin::PartialTree.validate!(m.tx_count, m.hashes, Bitcoin.byte_to_bit(m.flags.htb))