ruby-masscan 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 221aba609e42676f60a8ff8ca50017f52b107ce4bbfd09b2d17fac243e876db8
-  data.tar.gz: 92ffeee1fd37297f5a1731fb2af18d5409c99ceda7704beab4f762e9270e85e3
+  metadata.gz: f03fa94f7c501646be712a24b98fe07a6dd156c054c7ae27714cac80b1fbb5e8
+  data.tar.gz: a346c7b055da689cad8571a38383b43a5e797889d6206b85ca7d2a64e25b904f
 SHA512:
-  metadata.gz: f3cb61b85ec433a38a77e5f3993902fb48c340ee8eb6a2476ad98afc8369f33a55ade52fb75f55bcde9f36251da1cea84e5215f717b33821af733744d22087e6
-  data.tar.gz: 4224460de4162eeb091db2d5d194e66eec3c81bea585c64101adadbfc9c959dfdecae482c7c607717d828f2922ef82b99c2d52f99a0b146153cafe3b8e724add
+  metadata.gz: ecdea1cc3b62cf1d0dbb2b7771807c05f2e6339b573f6208dcfb21e94fdaad160e51adc077e158ec6c4b4bc9426c7925dfd376d53d455922c5e318e6ee999936
+  data.tar.gz: 88bbf9a1332946ae7688fae852a1a3565269a853eff17434dc8e0b1fd7eae2c3e14b09cc64fa3fc80a06781f3fd644b97e5f97fcc52ccd2aa71cbc2a32b15f3c

data/ChangeLog.md

@@ -1,3 +1,10 @@
+### 0.1.1 / 2021-09-09
+
+* Added missing {Masscan::Banner#ttl}.
+* Fixed {Masscan::Parsers::Binary} to populate {Masscan::Banner#ttl}.
+* Fixed {Masscan::Parsers::Binary#parse_status} to populate
+  {Masscan::Status#reason} and {Masscan::Status#ttl}.
+
 ### 0.1.0 / 2021-08-31
 
 * Initial release:

data/lib/masscan/banner.rb

@@ -2,7 +2,37 @@ module Masscan
   #
   # Represents a banner record.
   #
-  class Banner < Struct.new(:protocol,:port,:ip,:timestamp,:app_protocol,:payload)
+  class Banner < Struct.new(:protocol,:port,:ttl,:ip,:timestamp,:app_protocol,:payload)
+
+    #
+    # Initializes the banner.
+    #
+    # @param [:icmp, :tcp, :udp, :sctp] protocol
+    #   The IP protocol.
+    #
+    # @param [Integer] port
+    #   The port number.
+    #
+    # @param [Integer, nil] ttl
+    #   The optional TTL.
+    #
+    # @param [IPAddr] ip
+    #   The IP address.
+    #
+    # @param [Time] timestamp
+    #   The record timestamp.
+    #
+    # @param [Symbol] app_protocol
+    #   The application protocol.
+    #
+    # @param [String] payload
+    #   The banner/capture payload.
+    #
+    # @api private
+    #
+    def initialize(protocol: , port: , ttl: nil, ip: , timestamp: , app_protocol: , payload: )
+      super(protocol,port,ttl,ip,timestamp,app_protocol,payload)
+    end
 
     alias service app_protocol
     alias banner payload

data/lib/masscan/parsers/binary.rb

@@ -366,12 +366,14 @@ module Masscan
                    end
 
         return Status.new(
-          status,
-          protocol,
-          port,
-          ip,
-          timestamp,
-          mac
+          status:    status,
+          protocol:  protocol,
+          port:      port,
+          reason:    reason,
+          ttl:       ttl,
+          ip:        ip,
+          timestamp: timestamp,
+          mac:       mac
         )
       end
 
@@ -396,12 +398,13 @@ module Masscan
         ttl = 0
 
         return Banner.new(
-          ip_proto,
-          port,
-          ip,
-          timestamp,
-          app_proto,
-          payload
+          protocol:     ip_proto,
+          port:         port,
+          ttl:          ttl,
+          ip:           ip,
+          timestamp:    timestamp,
+          app_protocol: app_proto,
+          payload:      payload
         )
       end
 
@@ -419,7 +422,7 @@ module Masscan
           return
         end
 
-        timestamp, ip, ip_prot, port, app_proto, payload = buffer.unpack('L>L>CS>S>A*')
+        timestamp, ip, ip_proto, port, app_proto, payload = buffer.unpack('L>L>CS>S>A*')
 
         timestamp = decode_timestamp(timestamp)
         ip        = decode_ipv4(ip)
@@ -430,12 +433,13 @@ module Masscan
         ttl = 0
 
         return Banner.new(
-          ip_proto,
-          port,
-          ip,
-          timestamp,
-          app_proto,
-          payload
+          protocol:     ip_proto,
+          port:         port,
+          ttl:          ttl,
+          ip:           ip,
+          timestamp:    timestamp,
+          app_protocol: app_proto,
+          payload:      payload
         )
       end
 
@@ -467,14 +471,14 @@ module Masscan
               end
 
         return Status.new(
-          status,
-          ip_proto,
-          port,
-          reason,
-          ttl,
-          ip,
-          timestamp,
-          mac
+          status:    status,
+          protocol:  ip_proto,
+          port:      port,
+          reason:    reason,
+          ttl:       ttl,
+          ip:        ip,
+          timestamp: timestamp,
+          mac:       mac
         )
       end
 
@@ -499,12 +503,13 @@ module Masscan
         app_proto = lookup_app_protocol(app_proto)
 
         return Banner.new(
-          ip_proto,
-          port,
-          ip,
-          timestamp,
-          app_proto,
-          payload
+          protocol:     ip_proto,
+          port:         port,
+          ttl:          ttl,
+          ip:           ip,
+          timestamp:    timestamp,
+          app_protocol: app_proto,
+          payload:      payload
         )
       end
 
@@ -541,13 +546,13 @@ module Masscan
         ipv6      = decode_ipv6(ipv6_hi,ipv6_lo)
 
         return Status.new(
-          status,
-          ip_proto,
-          port,
-          reason,
-          ttl,
-          ipv6,
-          timestamp
+          status:    status,
+          protocol:  ip_proto,
+          port:      port,
+          reason:    reason,
+          ttl:       ttl,
+          ip:        ipv6,
+          timestamp: timestamp
         )
       end
 
@@ -577,12 +582,13 @@ module Masscan
         ipv6      = decode_ipv6(ipv6_hi,ipv6_lo)
 
         return Banner.new(
-          ip_proto,
-          port,
-          ipv6,
-          timestamp,
-          app_proto,
-          payload
+          protocol:     ip_proto,
+          port:         port,
+          ttl:          ttl,
+          ip:           ipv6,
+          timestamp:    timestamp,
+          app_protocol: app_proto,
+          payload:      payload
         )
       end
 

data/lib/masscan/parsers/json.rb

@@ -74,12 +74,12 @@ module Masscan
                   service_banner = service_json['banner']
 
                   yield Banner.new(
-                    proto,
-                    port,
-                    ip,
-                    timestamp,
-                    service_name,
-                    service_banner
+                    protocol:     proto,
+                    port:         port,
+                    ip:           ip,
+                    timestamp:    timestamp,
+                    app_protocol: service_name,
+                    payload:      service_banner
                   )
                 else
                   status = parse_status(port_json['status'])
@@ -87,13 +87,13 @@ module Masscan
                   reason = parse_reason(port_json['reason'])
 
                   yield Status.new(
-                    status,
-                    proto,
-                    port,
-                    reason,
-                    ttl,
-                    ip,
-                    timestamp
+                    status:    status,
+                    protocol:  proto,
+                    port:      port,
+                    reason:    reason,
+                    ttl:       ttl,
+                    ip:        ip,
+                    timestamp: timestamp
                   )
                 end
               end

data/lib/masscan/parsers/list.rb

@@ -57,24 +57,22 @@ module Masscan
             type, ip_proto, port, ip, timestamp = line.split(' ',5)
 
             yield Status.new(
-              parse_status(type),
-              parse_ip_protocol(ip_proto),
-              port.to_i,
-              nil,
-              nil,
-              parse_ip(ip),
-              parse_timestamp(timestamp)
+              status:    parse_status(type),
+              protocol:  parse_ip_protocol(ip_proto),
+              port:      port.to_i,
+              ip:        parse_ip(ip),
+              timestamp: parse_timestamp(timestamp)
             )
           elsif line.start_with?('banner ')
             type, ip_proto, port, ip, timestamp, app_proto, banner = line.split(' ',7)
 
             yield Banner.new(
-              parse_ip_protocol(ip_proto),
-              port.to_i,
-              parse_ip(ip),
-              parse_timestamp(timestamp),
-              parse_app_protocol(app_proto),
-              banner
+              protocol:     parse_ip_protocol(ip_proto),
+              port:         port.to_i,
+              ip:           parse_ip(ip),
+              timestamp:    parse_timestamp(timestamp),
+              app_protocol: parse_app_protocol(app_proto),
+              payload:      banner
             )
           end
         end

data/lib/masscan/status.rb

@@ -3,5 +3,38 @@ module Masscan
   # Represents a port status record.
   #
   class Status < Struct.new(:status,:protocol,:port,:reason,:ttl,:ip,:timestamp,:mac)
+
+    #
+    # Initializes the status record.
+    #
+    # @param [:open, :closed] status
+    #   The status of the port.
+    #
+    # @param [:icmp, :tcp, :udp, :sctp] protocol
+    #   The IP protocol.
+    #
+    # @param [Integer] port
+    #   The port number.
+    #
+    # @param [Array<:fin, :syn, :rst, :psh, :ack, :urg, :ece, :cwr>, nil] reason
+    #   Flags indicating why the port was open or closed.
+    #
+    # @param [Integer, nil] ttl
+    #   TTL.
+    #
+    # @param [IPAddr] ip
+    #   The IP address.
+    #
+    # @param [Time] timestamp
+    #   The record timestamp.
+    #
+    # @param [String, nil] mac
+    #   Optional mac address.
+    #
+    # @api private
+    #
+    def initialize(status: , protocol: , port: , reason: nil, ttl: nil, ip: , timestamp: , mac: nil)
+      super(status,protocol,port,reason,ttl,ip,timestamp,mac)
+    end
   end
 end

data/lib/masscan/version.rb

@@ -1,4 +1,4 @@
 module Masscan
   # ruby-masscan version
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/spec/parsers/binary_spec.rb

@@ -221,4 +221,508 @@ describe Masscan::Parsers::Binary do
       end
     end
   end
+
+  describe ".parse_status" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("1.2.3.4") }
+    let(:ip_uint) { ipaddr.to_i           }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:ttl) { 54 }
+
+    let(:reason)      { [:syn, :ack] }
+    let(:reason_uint) { 0x02 | 0x10  }
+
+    let(:buffer) do
+      [
+        timestamp, ip_uint, port, reason_uint, ttl 
+      ].pack("L>L>S>CC")
+    end
+
+    let(:status) { :open }
+
+    subject { super().parse_status(buffer,status) }
+
+    context "when the buffer length is less than 12" do
+      let(:buffer) { "A" * 11 }
+
+      it "must return nil" do
+        expect(subject).to be(nil)
+      end
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must set #status" do
+      expect(subject.status).to eq(status)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    context "when the port is 53" do
+      let(:port) { 53 }
+      let(:ip_proto) { :udp }
+
+      it "must default the ip_proto :udp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 123" do
+      let(:port) { 123 }
+      let(:ip_proto) { :udp }
+
+      it "must default the ip_proto :udp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 137" do
+      let(:port) { 137 }
+      let(:ip_proto) { :udp }
+
+      it "must default the ip_proto :udp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 161" do
+      let(:port) { 161 }
+      let(:ip_proto) { :udp }
+
+      it "must default the ip_proto :udp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 36422" do
+      let(:port)     { 36422 }
+      let(:ip_proto) { :sctp }
+
+      it "must default the ip_proto :sctp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 36412" do
+      let(:port)     { 36412 }
+      let(:ip_proto) { :sctp }
+
+      it "must default the ip_proto :sctp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    context "when the port is 2905" do
+      let(:port)     { 2905 }
+      let(:ip_proto) { :sctp }
+
+      it "must default the ip_proto :sctp" do
+        expect(subject.protocol).to eq(ip_proto)
+      end
+    end
+
+    it "must default the ip_proto to :tcp" do
+      expect(subject.protocol).to eq(:tcp)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ttl field" do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    it "must decode the reason field" do
+      expect(subject.reason).to eq(reason)
+    end
+  end
+
+  describe ".parser_banner3" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("1.2.3.4") }
+    let(:ip_uint) { ipaddr.to_i           }
+
+    let(:port) { 1111 }
+
+    let(:app_proto) { :html_title }
+    let(:app_proto_uint) do
+      described_class::APP_PROTOCOLS.index(app_proto)
+    end
+
+    let(:payload) { "404 - Not Found" }
+
+    let(:buffer) do
+      p([timestamp, ip_uint, port, app_proto_uint, payload]).pack("L>L>S>S>A*")
+    end
+
+    subject { super().parse_banner3(buffer) }
+
+    it "must default #ip_proto to :tcp" do
+      expect(subject.protocol).to eq(:tcp)
+    end
+
+    it "must default #ttl to 0" do
+      expect(subject.ttl).to eq(0)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must decode the app_proto field" do
+      expect(subject.app_protocol).to eq(app_proto)
+    end
+
+    it "must decode the payload field" do
+      expect(subject.payload).to eq(payload)
+    end
+  end
+
+  describe ".parser_banner4" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("1.2.3.4") }
+    let(:ip_uint) { ipaddr.to_i           }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:app_proto) { :html_title }
+    let(:app_proto_uint) do
+      described_class::APP_PROTOCOLS.index(app_proto)
+    end
+
+    let(:payload) { "404 - Not Found" }
+
+    let(:buffer) do
+      [
+        timestamp, ip_uint, ip_proto_uint, port, app_proto_uint, payload
+      ].pack("L>L>CS>S>A*")
+    end
+
+    subject { super().parse_banner4(buffer) }
+
+    context "when the buffer length is less than 13" do
+      let(:buffer) { "A" * 12 }
+
+      it "must return nil" do
+        expect(subject).to be(nil)
+      end
+    end
+
+    it "must decode the ip_proto field" do
+      expect(subject.protocol).to eq(:tcp)
+    end
+
+    it "must default #ttl to 0" do
+      expect(subject.ttl).to eq(0)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must decode the app_proto field" do
+      expect(subject.app_protocol).to eq(app_proto)
+    end
+
+    it "must decode the payload field" do
+      expect(subject.payload).to eq(payload)
+    end
+  end
+
+  describe ".parse_status2" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("1.2.3.4") }
+    let(:ip_uint) { ipaddr.to_i           }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:ttl) { 54 }
+
+    let(:reason)      { [:syn, :ack] }
+    let(:reason_uint) { 0x02 | 0x10  }
+
+    let(:buffer) do
+      [
+        timestamp, ip_uint, ip_proto_uint, port, reason_uint, ttl 
+      ].pack("L>L>CS>CC")
+    end
+
+    let(:status) { :open }
+
+    subject { super().parse_status2(buffer,status) }
+
+    context "when the buffer length is less than 13" do
+      let(:buffer) { "A" * 12 }
+
+      it "must return nil" do
+        expect(subject).to be(nil)
+      end
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must set #status" do
+      expect(subject.status).to eq(status)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the ip_proto field" do
+      expect(subject.protocol).to eq(ip_proto)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ttl field" do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    it "must decode the reason field" do
+      expect(subject.reason).to eq(reason)
+    end
+  end
+
+  describe ".parser_banner9" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("1.2.3.4") }
+    let(:ip_uint) { ipaddr.to_i           }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:app_proto) { :html_title }
+    let(:app_proto_uint) do
+      described_class::APP_PROTOCOLS.index(app_proto)
+    end
+
+    let(:ttl) { 54 }
+
+    let(:payload) { "404 - Not Found" }
+
+    let(:buffer) do
+      [
+        timestamp, ip_uint, ip_proto_uint, port, app_proto_uint, ttl, payload
+      ].pack("L>L>CS>S>CA*")
+    end
+
+    subject { super().parse_banner9(buffer) }
+
+    context "when the buffer length is less than 14" do
+      let(:buffer) { "A" * 13 }
+
+      it "must return nil" do
+        expect(subject).to be(nil)
+      end
+    end
+
+    it "must decode the ip_proto field" do
+      expect(subject.protocol).to eq(:tcp)
+    end
+
+    it "must decode the ttl field" do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must decode the app_proto field" do
+      expect(subject.app_protocol).to eq(app_proto)
+    end
+
+    it "must decode the payload field" do
+      expect(subject.payload).to eq(payload)
+    end
+  end
+
+  describe ".parse_status6" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("2606:2800:220:1:248:1893:25c8:1946") }
+    let(:ip_uint) { ipaddr.to_i }
+    let(:ipv6_hi) { (ip_uint & (0xffffffff_ffffffff << 64)) >> 64 }
+    let(:ipv6_lo) { (ip_uint & 0xffffffff_ffffffff) }
+
+    let(:ip_version) { 6 }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:ttl) { 54 }
+
+    let(:reason)      { [:syn, :ack] }
+    let(:reason_uint) { 0x02 | 0x10  }
+
+    let(:buffer) do
+      [
+        timestamp, ip_proto_uint, port, reason_uint, ttl, ip_version, ipv6_hi, ipv6_lo
+      ].pack("L>CS>CCCQ>Q>")
+    end
+
+    let(:status) { :open }
+
+    subject { super().parse_status6(buffer,status) }
+
+    context "if the ip_version is not 6" do
+      let(:ip_version) { 9 }
+
+      it do
+        expect {
+          described_class.parse_status6(buffer,status)
+        }.to raise_error(described_class::CorruptedFile,"expected ip_version to be 6: #{ip_version.inspect}")
+      end
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must set #status" do
+      expect(subject.status).to eq(status)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the ip_proto field" do
+      expect(subject.protocol).to eq(ip_proto)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ttl field" do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    it "must decode the reason field" do
+      expect(subject.reason).to eq(reason)
+    end
+  end
+
+  describe ".parser_banner6" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    let(:ipaddr)  { IPAddr.new("2606:2800:220:1:248:1893:25c8:1946") }
+    let(:ip_uint) { ipaddr.to_i }
+    let(:ipv6_hi) { (ip_uint & (0xffffffff_ffffffff << 64)) >> 64 }
+    let(:ipv6_lo) { (ip_uint & 0xffffffff_ffffffff) }
+
+    let(:ip_version) { 6 }
+
+    let(:ip_proto)      { :tcp }
+    let(:ip_proto_uint) { described_class::IP_PROTOCOLS.invert[:tcp] }
+
+    let(:port) { 1111 }
+
+    let(:app_proto) { :html_title }
+    let(:app_proto_uint) do
+      described_class::APP_PROTOCOLS.index(app_proto)
+    end
+
+    let(:ttl) { 54 }
+
+    let(:payload) { "404 - Not Found" }
+
+    let(:buffer) do
+      [
+        timestamp, ip_proto_uint, port, app_proto_uint, ttl, ip_version, ipv6_hi, ipv6_lo, payload
+      ].pack("L>CS>S>CCQ>Q>A*")
+    end
+
+    subject { super().parse_banner6(buffer) }
+
+    it "must decode the ip_proto field" do
+      expect(subject.protocol).to eq(:tcp)
+    end
+
+    it "must decode the ttl field" do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    it "must decode the port field" do
+      expect(subject.port).to eq(port)
+    end
+
+    it "must decode the ip field" do
+      expect(subject.ip).to eq(ipaddr)
+    end
+
+    it "must decode the timestamp field" do
+      expect(subject.timestamp).to eq(time)
+    end
+
+    it "must decode the app_proto field" do
+      expect(subject.app_protocol).to eq(app_proto)
+    end
+
+    it "must decode the payload field" do
+      expect(subject.payload).to eq(payload)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-masscan
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Postmodern
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-31 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rprogram