redhound 0.1.0 → 1.0.0

data/lib/redhound/{header → l3}/ipv4.rb

@@ -1,24 +1,26 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
-  class Header
-    class Ipv4
+  class L3
+    class Ipv4 < Base
       class << self
+        # @rbs (bytes: Array[Integer]) -> Redhound::L3::Ipv4
         def generate(bytes:)
           new(bytes:).generate
         end
       end
 
-      # ref: https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml#protocol-numbers-1
-      ICMP = 1
-      UDP = 17
+      attr_reader :protocol #: Protocol
 
+      # @rbs (bytes: Array[Integer]) -> void
       def initialize(bytes:)
-        raise ArgumentError, 'bytes must be 20 bytes' unless bytes.size == 20
+        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]
@@ -27,85 +29,66 @@ module Redhound
         @id = @bytes[4..5]
         @frag_off = @bytes[6..7]
         @ttl = @bytes[8]
-        @protocol = @bytes[9]
+        @protocol = Protocol.new(protocol: @bytes[9])
         @check = @bytes[10..11]
         @saddr = @bytes[12..15]
         @daddr = @bytes[16..19]
         self
       end
 
-      def icmp?
-        @protocol == ICMP
-      end
-
-      def udp?
-        @protocol == UDP
-      end
+      # @rbs () -> Integer
+      def size = 20
 
-      def dump
-        puts 'IPv4 HEADER----------------'
-        puts self
+      # @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
 
-      def to_s
-        <<~IPV4
-          Version: #{@version}
-          IHL: #{@ihl}
-          TOS: #{@tos}
-          Total Length: #{tot_len}
-          ID: #{id}
-          Fragment Offset: #{frag_off}
-          TTL: #{@ttl}
-          Protocol: #{protocol}
-          Checksum: #{check}
-          Source IP: #{saddr}
-          Destination IP: #{daddr}
-        IPV4
+      # @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
 
-      def protocol
-        case @protocol
-        when ICMP
-          'ICMP'
-        when UDP
-          'UDP'
-        else
-          'Unknown'
-        end
-      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.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
+        @saddr.join('.')
       end
 
+      # @rbs () -> String
       def daddr
-        @daddr.map { |b| b.to_s(16).rjust(2, '0') }.join('.')
+        @daddr.join('.')
       end
     end
   end

data/lib/redhound/l3/ipv6.rb

@@ -0,0 +1,69 @@
+# 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

@@ -0,0 +1,173 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

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

data/lib/redhound/l4/base.rb

@@ -0,0 +1,31 @@
+# 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

data/lib/redhound/{header → l4}/icmp.rb

@@ -1,20 +1,17 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
-  class Header
-    class Icmp
-      class << self
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
+  class L4
+    class Icmp < Base
+      # @rbs (bytes: Array[Integer]) -> void
       def initialize(bytes:)
-        raise ArgumentError, 'bytes must be bigger than 8 bytes' unless bytes.size >= 8
+        raise ArgumentError, "bytes must be bigger than #{size} bytes" unless bytes.size >= size
 
         @bytes = bytes
       end
 
+      # @rbs () -> Redhound::L4::Icmp
       def generate
         @type = @bytes[0]
         @code = @bytes[1]
@@ -30,47 +27,44 @@ module Redhound
         self
       end
 
-      def dump
-        puts 'ICMP HEADER----------------'
-        puts self
-      end
+      # @rbs () -> Integer
+      def size = 8
 
+      # @rbs () -> String
       def to_s
         if @type.zero? || @type == 8
-          <<~ICMP
-            Type: #{@type}
-            Code: #{@code}
-            Checksum: #{check}
-            ID: #{id}
-            Sequence: #{seq}
-            Data: #{data}
+          <<-ICMP.chomp
+    └─ ICMP Type: #{@type} Code: #{@code} Checksum: #{check} ID: #{id} Sequence: #{seq}
+        └─ Payload: #{data}
           ICMP
         else
-          <<~ICMP
-            Type: #{@type}
-            Code: #{@code}
-            Checksum: #{check}
-            Data: #{data}
+          <<-ICMP.chomp
+    └─ ICMP Type: #{@type} Code: #{@code} Checksum: #{check}
+        └─ Payload: #{data}
           ICMP
         end
       end
 
       private
 
+      # @rbs () -> Integer
       def check
         @check.map { |b| b.to_s(16).rjust(2, '0') }.join
       end
 
+      # @rbs () -> Integer
       def id
         @id.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def seq
         @seq.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> String
       def data
-        @data.map(&:chr).join
+        @data.map(&:chr).join.force_encoding("UTF-8")
       end
     end
   end

data/lib/redhound/l4/resolver.rb

@@ -0,0 +1,28 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Redhound
+  class L4
+    class Resolver
+      # @rbs (bytes: Array[Integer], l3: Redhound::L3::Base) -> Redhound::L4::Base?
+      def self.resolve(bytes:, l3:)
+        new(bytes:, l3:).resolve
+      end
+
+      # @rbs (bytes: Array[Integer], l3: Redhound::L3::Base) -> void
+      def initialize(bytes:, l3:)
+        @bytes = bytes
+        @l3 = l3
+      end
+
+      # @rbs () -> Redhound::L4::Base?
+      def resolve
+        if @l3.protocol.udp?
+          Udp.generate(bytes: @bytes)
+        elsif @l3.protocol.icmp?
+          Icmp.generate(bytes: @bytes)
+        end
+      end
+    end
+  end
+end

data/lib/redhound/{header → l4}/udp.rb

@@ -1,20 +1,17 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Redhound
-  class Header
-    class Udp
-      class << self
-        def generate(bytes:)
-          new(bytes:).generate
-        end
-      end
-
+  class L4
+    class Udp < Base
+      # @rbs (bytes: Array[Integer]) -> void
       def initialize(bytes:)
-        raise ArgumentError, 'bytes must be bigger than 8 bytes' unless bytes.size >= 8
+        raise ArgumentError, "bytes must be bigger than #{size} bytes" unless bytes.size >= size
 
         @bytes = bytes
       end
 
+      # @rbs () -> Redhound::L4::Udp
       def generate
         @sport = @bytes[0..1]
         @dport = @bytes[2..3]
@@ -24,37 +21,40 @@ module Redhound
         self
       end
 
-      def dump
-        puts 'UDP HEADER----------------'
-        puts self
-      end
+      # @rbs () -> Integer
+      def size = 8
 
+      # @rbs () -> String
       def to_s
-        <<~UDP
-          Source Port: #{sport}
-          Destination Port: #{dport}
-          Length: #{len}
-          Checksum: #{check}
-          Data: #{data}
+        <<-UDP
+    └─ UDP Src: #{sport} Dst: #{dport} Len: #{len} Checksum: #{check}
+        └─ Payload: #{data}
         UDP
       end
 
+      private
+
+      # @rbs () -> Integer
       def sport
         @sport.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def dport
         @dport.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def len
         @len.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> Integer
       def check
         @check.map { |b| b.to_s(16).rjust(2, '0') }.join.to_i(16)
       end
 
+      # @rbs () -> String
       def data
         @data.map(&:chr).join
       end

data/lib/redhound/l4.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'l4/base'
+require_relative 'l4/icmp'
+require_relative 'l4/resolver'
+require_relative 'l4/udp'