redhound 1.0.1 → 2.0.0.rc2

data/lib/redhound/l2/ether.rb

@@ -1,68 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L2
-    class Ether
-      attr_reader :type #: Protocol
-
-      class << self
-        # @rbs (bytes: Array[Integer], count: Integer) -> Redhound::L2::Ether
-        def generate(bytes:, count:)
-          new(bytes:, count:).generate
-        end
-      end
-
-      # @rbs (bytes: Array[Integer], count: Integer) -> void
-      def initialize(bytes:, count:)
-        raise ArgumentError, "bytes must be #{size} bytes" unless bytes.size >= size
-
-        @bytes = bytes
-        @count = count
-      end
-
-      # @rbs () -> Integer
-      def size = 14
-
-      # @rbs () -> Redhound::L2::Ether
-      def generate
-        @dhost = @bytes[0..5]
-        @shost = @bytes[6..11]
-        @type = Protocol.new(protocol: hex_type(@bytes[12..13]))
-        self
-      end
-
-      # @rbs () -> void
-      def dump
-        puts self
-      end
-
-      # @rbs () -> String
-      def to_s
-        "[#{@count}] Ethernet Dst: #{dhost} Src: #{shost} Type: #{@type}"
-      end
-
-      # @rbs () -> bool
-      def supported_type?
-        @type.ipv4? || @type.ipv6? || @type.arp? # steep:ignore
-      end
-
-      private
-
-      # @rbs () -> String
-      def dhost
-        @dhost.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-
-      # @rbs () -> String
-      def shost
-        @shost.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-
-      # @rbs (Array[Integer] type) -> Integer
-      def hex_type(type)
-        type.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-    end
-  end
-end

data/lib/redhound/l2/protocol.rb

@@ -1,33 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L2
-    class Protocol
-      PROTO_TABLE = {
-        0x0060 => 'Loopback',
-        0x0800 => 'IPv4',
-        0x0806 => 'ARP',
-        0x86DD => 'IPv6',
-        0x8100 => 'VLAN',
-      }
-
-      # @rbs (protocol: Integer) -> void
-      def initialize(protocol:)
-        @protocol = protocol
-      end
-
-      # @rbs () -> String
-      def to_s
-        PROTO_TABLE[@protocol] || 'Unknown'
-      end
-
-      PROTO_TABLE.each do |id, name|
-        method_name = name.downcase.gsub(/[ \-]/, '_') + '?'
-        define_method(method_name) do
-          @protocol == id
-        end
-      end
-    end
-  end
-end

data/lib/redhound/l2.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'l2/ether'
-require_relative 'l2/protocol'

data/lib/redhound/l3/arp.rb

@@ -1,114 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Arp < Base
-      class << self
-        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Arp
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
-      # @rbs (bytes: Array[Integer]) -> void
-      def initialize(bytes:)
-        raise ArgumentError, "bytes must be bigger than #{arp_size} bytes" unless bytes.size >= arp_size
-
-        @bytes = bytes
-      end
-
-      # @rbs () -> Redhound::L3::Arp
-      def generate
-        @htype = @bytes[0..1]
-        @ptype = @bytes[2..3]
-        @hlen = @bytes[4]
-        @plen = @bytes[5]
-        @oper = @bytes[6..7]
-        @sha = @bytes[8..13]
-        @spa = @bytes[14..17]
-        @tha = @bytes[18..23]
-        @tpa = @bytes[24..27]
-        @type = Redhound::L2::Protocol.new(protocol: ptype)
-        @l3 = generate_l3
-        self
-      end
-
-      # @rbs () -> Integer
-      def arp_size = 28
-
-      # @rbs () -> Integer
-      def size
-        if @l3.nil?
-          arp_size
-        else
-          arp_size + @l3.size
-        end
-      end
-
-      # @rbs () -> String
-      def to_s
-        "    └─ ARP HType: #{htype} PType: #{ptype} HLen: #{@hlen} PLen: #{@plen} Oper: #{oper} SHA: #{sha} SPA: #{spa} THA: #{tha} TPA: #{tpa}"
-      end
-
-      # @rbs () -> bool
-      def supported_protocol?
-        return false if @l3.nil?
-        @l3.supported_protocol?
-      end
-
-      # @rbs () -> String?
-      def protocol
-        @l3.protocol if @l3
-      end
-
-      private
-
-      # @rbs () -> Integer
-      def htype
-        @htype.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> Integer
-      def ptype
-        @ptype.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> Integer
-      def oper
-        @oper.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> String
-      def sha
-        @sha.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-
-      # @rbs () -> String
-      def spa
-        @spa.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
-      end
-
-      # @rbs () -> String
-      def tha
-        @tha.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-
-      # @rbs () -> String
-      def tpa
-        @tpa.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
-      end
-
-      # @rbs () -> Redhound::L3::Base?
-      def generate_l3
-        return if @bytes.size == arp_size
-
-        if @type.ipv4?
-          Ipv4.generate(bytes: @bytes[arp_size..])
-        elsif @type.ipv6?
-          Ipv6.generate(bytes: @bytes[arp_size..])
-        end
-      end
-    end
-  end
-end

data/lib/redhound/l3/base.rb

@@ -1,49 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Base
-      class << self
-        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Base
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
-      # @rbs (bytes: Array[Integer]) -> void
-      def initialize(bytes:)
-        warn 'initialize method must be implemented'
-      end
-
-      # @rbs () -> Redhound::L3::Base
-      def generate
-        warn 'generate method must be implemented'
-        self
-      end
-
-      # @rbs () -> void
-      def dump
-        puts self
-      end
-
-      # @rbs () -> Integer
-      def size
-        warn 'size method must be implemented'
-        0
-      end
-
-      # @rbs () -> bool
-      def supported_protocol?
-        warn 'supported_protocol? method must be implemented'
-        false
-      end
-
-      # @rbs () -> Protocol
-      def protocol
-        warn 'protocol method must be implemented'
-        Protocol.new(protocol: 0)
-      end
-    end
-  end
-end

data/lib/redhound/l3/ipv4.rb

@@ -1,95 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Ipv4 < Base
-      class << self
-        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Ipv4
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
-      attr_reader :protocol #: Protocol
-
-      # @rbs (bytes: Array[Integer]) -> void
-      def initialize(bytes:)
-        raise ArgumentError, "bytes must be #{size} bytes" unless bytes.size >= size
-
-        @bytes = bytes
-      end
-
-      # @rbs () -> Redhound::L3::Ipv4
-      def generate
-        @version = @bytes[0]
-        @ihl = @bytes[0]
-        @tos = @bytes[1]
-        @tot_len = @bytes[2..3]
-        @id = @bytes[4..5]
-        @frag_off = @bytes[6..7]
-        @ttl = @bytes[8]
-        @protocol = Protocol.new(protocol: @bytes[9])
-        @check = @bytes[10..11]
-        @saddr = @bytes[12..15]
-        @daddr = @bytes[16..19]
-        self
-      end
-
-      # @rbs () -> Integer
-      def size = 20
-
-      # @rbs () -> String
-      def to_s
-        " └─ IPv4 Ver: #{version} IHL: #{ihl} TOS: #{@tos} Total Length: #{tot_len} ID: #{id} Offset: #{frag_off} TTL: #{@ttl} Protocol: #{@protocol} Checksum: #{check} Src: #{saddr} Dst: #{daddr}"
-      end
-
-      # @rbs () -> bool
-      def supported_protocol?
-        @protocol.udp? || @protocol.icmp? # steep:ignore
-      end
-
-      private
-
-      # @rbs () -> Integer
-      def version
-        @version & 0xF0
-      end
-
-      # @rbs () -> Integer
-      def ihl
-        @ihl & 0x0F
-      end
-
-      # @rbs () -> Integer
-      def tot_len
-        @tot_len.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> Integer
-      def id
-        @id.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> Integer
-      def frag_off
-        @frag_off.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16) & 0x1FFF
-      end
-
-      # @rbs () -> Integer
-      def check
-        @check.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> String
-      def saddr
-        @saddr.join('.')
-      end
-
-      # @rbs () -> String
-      def daddr
-        @daddr.join('.')
-      end
-    end
-  end
-end

data/lib/redhound/l3/ipv6.rb

@@ -1,69 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Ipv6 < Base
-      class << self
-        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Ipv6
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
-      attr_reader :protocol #: Protocol
-
-      # @rbs (bytes: Array[Integer]) -> void
-      def initialize(bytes:)
-        raise ArgumentError, "bytes must be bigger than #{size} bytes" unless bytes.size >= size
-
-        @bytes = bytes
-      end
-
-      # @rbs () -> Integer
-      def size = 40
-
-      # @rbs () -> Redhound::L3::Ipv6
-      def generate
-        version_traffic_flow = @bytes[0..3].join.to_i(16)
-        @version = (version_traffic_flow >> 28) & 0xF
-        @traffic_class = (version_traffic_flow >> 20) & 0xFF
-        @flow_label = version_traffic_flow & 0xFFFFF
-        @payload_length = @bytes[4..5]
-        @next_header = @bytes[6]
-        @hop_limit = @bytes[7]
-        @saddr = @bytes[8..23]
-        @daddr = @bytes[24..39]
-        @protocol = Protocol.new(protocol: @next_header)
-        self
-      end
-
-      # @rbs () -> String
-      def to_s
-        " └─ IPv6 Ver: #{@version} Traffic Class: #{@traffic_class} Flow Label: #{@flow_label} Payload Length: #{payload_length} Next Header: #{@protocol} Hop Limit: #{@hop_limit} Src: #{saddr} Dst: #{daddr}"
-      end
-
-      # @rbs () -> bool
-      def supported_protocol?
-        @protocol.udp? # steep:ignore
-      end
-
-      private
-
-      # @rbs () -> Integer
-      def payload_length
-        @payload_length.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
-      end
-
-      # @rbs () -> Integer
-      def saddr
-        @saddr.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-
-      # @rbs () -> Integer
-      def daddr
-        @daddr.map { |b| b.to_s(16).rjust(2, '0') }.join(':')
-      end
-    end
-  end
-end

data/lib/redhound/l3/protocol.rb

@@ -1,173 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Protocol
-      # refs: https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml#protocol-numbers-1
-      PROTO_TABLE = {
-        0 => 'HOPOPT',
-        1 => 'ICMP',
-        2 => 'IGMP',
-        3 => 'GGP',
-        4 => 'IP-in-IP',
-        5 => 'ST',
-        6 => 'TCP',
-        7 => 'CBT',
-        8 => 'EGP',
-        9 => 'IGP',
-        10 => 'BBN-RCC-MON',
-        11 => 'NVP-II',
-        12 => 'PUP',
-        13 => 'ARGUS',
-        14 => 'EMCON',
-        15 => 'XNET',
-        16 => 'CHAOS',
-        17 => 'UDP',
-        18 => 'MUX',
-        19 => 'DCN-MEAS',
-        20 => 'HMP',
-        21 => 'PRM',
-        22 => 'XNS-IDP',
-        23 => 'TRUNK-1',
-        24 => 'TRUNK-2',
-        25 => 'LEAF-1',
-        26 => 'LEAF-2',
-        27 => 'RDP',
-        28 => 'IRTP',
-        29 => 'ISO-TP4',
-        30 => 'NETBLT',
-        31 => 'MFE-NSP',
-        32 => 'MERIT-INP',
-        33 => 'DCCP',
-        34 => '3PC',
-        35 => 'IDPR',
-        36 => 'XTP',
-        37 => 'DDP',
-        38 => 'IDPR-CMTP',
-        39 => 'TP++',
-        40 => 'IL',
-        41 => 'IPv6',
-        42 => 'SDRP',
-        43 => 'IPv6-Route',
-        44 => 'IPv6-Frag',
-        45 => 'IDRP',
-        46 => 'RSVP',
-        47 => 'GRE',
-        48 => 'DSR',
-        49 => 'BNA',
-        50 => 'ESP',
-        51 => 'AH',
-        52 => 'I-NLSP',
-        53 => 'SWIPE',
-        54 => 'NARP',
-        55 => 'MOBILE',
-        56 => 'TLSP',
-        57 => 'SKIP',
-        58 => 'IPv6-ICMP',
-        59 => 'IPv6-NoNxt',
-        60 => 'IPv6-Opts',
-        61 => 'Any host internal protocol',
-        62 => 'CFTP',
-        63 => 'Any local network',
-        64 => 'SAT-EXPAK',
-        65 => 'KRYPTOLAN',
-        66 => 'RVD',
-        67 => 'IPPC',
-        68 => 'Any distributed file system',
-        69 => 'SAT-MON',
-        70 => 'VISA',
-        71 => 'IPCV',
-        72 => 'CPNX',
-        73 => 'CPHB',
-        74 => 'WSN',
-        75 => 'PVP',
-        76 => 'BR-SAT-MON',
-        77 => 'SUN-ND',
-        78 => 'WB-MON',
-        79 => 'WB-EXPAK',
-        80 => 'ISO-IP',
-        81 => 'VMTP',
-        82 => 'SECURE-VMTP',
-        83 => 'VINES',
-        84 => 'TTP',
-        85 => 'NSFNET-IGP',
-        86 => 'DGP',
-        87 => 'TCF',
-        88 => 'EIGRP',
-        89 => 'OSPFIGP',
-        90 => 'Sprite-RPC',
-        91 => 'LARP',
-        92 => 'MTP',
-        93 => 'AX.25',
-        94 => 'IPIP',
-        95 => 'MICP',
-        96 => 'SCC-SP',
-        97 => 'ETHERIP',
-        98 => 'ENCAP',
-        99 => 'Any private encryption scheme',
-        100 => 'GMTP',
-        101 => 'IFMP',
-        102 => 'PNNI',
-        103 => 'PIM',
-        104 => 'ARIS',
-        105 => 'SCPS',
-        106 => 'QNX',
-        107 => 'A/N',
-        108 => 'IPComp',
-        109 => 'SNP',
-        110 => 'Compaq-Peer',
-        111 => 'IPX-in-IP',
-        112 => 'VRRP',
-        113 => 'PGM',
-        114 => 'Any 0-hop protocol',
-        115 => 'L2TP',
-        116 => 'DDX',
-        117 => 'IATP',
-        118 => 'STP',
-        119 => 'SRP',
-        120 => 'UTI',
-        121 => 'SMP',
-        122 => 'SM',
-        123 => 'PTP',
-        124 => 'IS-IS over IPv4',
-        125 => 'FIRE',
-        126 => 'CRTP',
-        127 => 'CRUDP',
-        128 => 'SSCOPMCE',
-        129 => 'IPLT',
-        130 => 'SPS',
-        131 => 'PIPE',
-        132 => 'SCTP',
-        133 => 'FC',
-        134 => 'RSVP-E2E-IGNORE',
-        135 => 'Mobility Header',
-        136 => 'UDPLite',
-        137 => 'MPLS-in-IP',
-        138 => 'manet',
-        139 => 'HIP',
-        140 => 'Shim6',
-        141 => 'WESP',
-        142 => 'ROHC',
-        255 => 'Reserved'
-      }.freeze
-
-      # @rbs (protocol: Integer) -> void
-      def initialize(protocol:)
-        @protocol = protocol
-      end
-
-      # @rbs () -> String
-      def to_s
-        PROTO_TABLE[@protocol] || 'Unknown'
-      end
-
-      PROTO_TABLE.each do |code, name|
-        method_name = name.downcase.gsub(/[ \-]/, '_') + '?'
-        define_method(method_name) do
-          @protocol == code
-        end
-      end
-    end
-  end
-end

data/lib/redhound/l3/resolver.rb

@@ -1,30 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L3
-    class Resolver
-      # @rbs (bytes: Array[Integer], l2: Redhound::L2::Ether) -> Redhound::L3::Base?
-      def self.resolve(bytes:, l2:)
-        new(bytes:, l2:).resolve
-      end
-
-      # @rbs (bytes: Array[Integer], l2: Redhound::L2::Ether) -> void
-      def initialize(bytes:, l2:)
-        @bytes = bytes
-        @l2 = l2
-      end
-
-      # @rbs () -> Redhound::L3::Base?
-      def resolve
-        if @l2.type.ipv4?
-          Ipv4.generate(bytes: @bytes)
-        elsif @l2.type.ipv6?
-          Ipv6.generate(bytes: @bytes)
-        elsif @l2.type.arp?
-          Arp.generate(bytes: @bytes)
-        end
-      end
-    end
-  end
-end

data/lib/redhound/l3.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'l3/base'
-
-require_relative 'l3/arp'
-require_relative 'l3/ipv4'
-require_relative 'l3/ipv6'
-require_relative 'l3/protocol'
-require_relative 'l3/resolver'

data/lib/redhound/l4/base.rb

@@ -1,31 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Redhound
-  class L4
-    class Base
-      class << self
-        # @rbs (bytes: Array[Integer]) -> Redhound::L4::Base
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
-      # @rbs (bytes: Array[Integer]) -> void
-      def initialize(bytes:)
-        warn 'initialize method must be implemented'
-      end
-
-      # @rbs () -> Redhound::L4::Base
-      def generate
-        warn 'generate method must be implemented'
-        self
-      end
-
-      # @rbs () -> void
-      def dump
-        puts self
-      end
-    end
-  end
-end