xlat 0.1.0.alpha1

data/lib/xlat/protocols/icmp/error.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require_relative './base'
+
+module Xlat
+  module Protocols
+    module Icmp
+      class Error < Base
+        V4_TYPE_DEST_UNREACH = 3
+        V4_TYPE_TIME_EXCEEDED = 11
+        V4_TYPE_PARAMETER_PROBLEM = 12
+
+        V6_TYPE_DEST_UNREACH = 1
+        V6_TYPE_PACKET_TOO_BIG = 2
+        V6_TYPE_TIME_EXCEEDED = 3
+        V6_TYPE_PARAMETER_PROBLEM = 4
+
+        attr_reader :payload_bytes
+        attr_reader :payload_bytes_offset
+        attr_reader :payload_bytes_length
+
+        def _parse
+          super
+          # Base.parse ensures packet.l4_bytes_length >= 8
+
+          packet = @packet
+
+          @payload_bytes = packet.l4_bytes
+          @payload_bytes_offset = packet.l4_bytes_offset + 8
+          @payload_bytes_length = packet.l4_bytes_length - 8
+
+          self
+        end
+
+        def apply(cs_delta)
+          # @original.apply
+
+          # # overwrite packet image with orig packet being built
+          # @packet.bytes[@packet.l4_start + 8..] = @original.bytes
+
+          # Base.recalculate_checksum(@packet)
+        end
+      end
+    end
+  end
+end
+

data/lib/xlat/protocols/icmp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require_relative './icmp/base'
+require_relative './icmp/echo'
+require_relative './icmp/error'
+
+module Xlat
+  module Protocols
+    module Icmp
+      def self.parse(packet)
+        Xlat::Protocols::Icmp::Base.parse(packet)
+      end
+    end
+  end
+end

data/lib/xlat/protocols/ip/ipv4.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require 'xlat/common'
+require 'xlat/protocols/icmp'
+
+module Xlat
+  module Protocols
+    class Ip
+      module Ipv4
+        extend Xlat::Common
+
+        def self.to_i
+          4
+        end
+
+        def self.tuple(bytes, offset)
+          bytes.slice(offset + 12, 8)
+        end
+
+        def self.icmp_protocol_id
+          Icmp::Base::V4_PROTOCOL_ID
+        end
+
+        def self.icmp_cs_delta(packet)
+          0
+        end
+
+        def self.new_icmp(packet, type)
+          case type
+          when Icmp::Echo::V4_TYPE_REQUEST
+            Icmp::Echo.new(packet, true)
+          when Icmp::Echo::V4_TYPE_REPLY
+            Icmp::Echo.new(packet, false)
+          when Icmp::Error::V4_TYPE_DEST_UNREACH, Icmp::Error::V4_TYPE_TIME_EXCEEDED, Icmp::Error::V4_TYPE_PARAMETER_PROBLEM
+            Icmp::Error.new(packet)
+          else
+            Icmp::Base.new(packet)
+          end
+        end
+
+        def self.parse(packet, b0)
+          bytes = packet.bytes
+          offset = packet.bytes_offset
+
+          header_length = (b0 & 0x0f) * 4
+          return false if header_length < 20
+
+          # tos?
+
+          total_length = bytes.get_value(:U16, offset + 2)
+          return false if total_length < header_length
+          return false unless packet.set_l4_region(header_length, total_length - header_length)
+
+          # ignore identification
+          return false if bytes.get_value(:U16, offset + 6) & 0xbfff != 0 # discard fragments
+
+          proto = bytes.get_value(:U8, offset + 9)
+          packet.proto = proto
+
+          true
+        end
+
+        def self.apply(bytes, offset, cs_delta, icmp_payload)
+          # decrement TTL
+          unless icmp_payload
+            ttl = bytes.get_value(:U8, offset + 8)
+            if ttl > 0
+              ttl -= 1
+              bytes.set_value(:U8, offset + 8, ttl)
+              cs_delta -= 0x0100 # checksum computation is performed per 2 octets
+            end
+          end
+
+          if cs_delta != 0
+            checksum = bytes.get_value(:U16, offset + 10)
+            checksum = Ip.checksum_adjust(checksum, cs_delta)
+            bytes.set_value(:U16, offset + 10, checksum)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xlat/protocols/ip/ipv6.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require 'xlat/common'
+require 'xlat/protocols/icmp'
+
+module Xlat
+  module Protocols
+    class Ip
+      module Ipv6
+        extend Xlat::Common
+
+        # https://www.iana.org/assignments/ipv6-parameters/ipv6-parameters.xhtml#extension-header
+        # except Fragment (44), ESP (50), AH (51)
+        EXTENSIONS = Ractor.make_shareable([0, 43, 60, 135, 139, 140, 253, 254].to_h { |id| [id, true] })
+
+        def self.to_i
+          6
+        end
+
+        def self.tuple(bytes, offset)
+          bytes.slice(offset + 8, 32)
+        end
+
+        def self.icmp_protocol_id
+          Icmp::Base::V6_PROTOCOL_ID
+        end
+
+        def self.icmp_cs_delta(packet)
+          upper_layer_packet_length = packet.l4_bytes.size - packet.l4_bytes_offset
+          Common.sum16be(tuple) + upper_layer_packet_length + packet.proto
+        end
+
+        def self.new_icmp(packet, type)
+          case type
+          when Icmp::Echo::V6_TYPE_REQUEST
+            Icmp::Echo.new(packet, true)
+          when Icmp::Echo::V6_TYPE_REPLY
+            Icmp::Echo.new(packet, true)
+          when Icmp::Error::V6_TYPE_DEST_UNREACH, Icmp::Error::V6_TYPE_PACKET_TOO_BIG, Icmp::Error::V6_TYPE_TIME_EXCEEDED, Icmp::Error::V6_TYPE_PARAMETER_PROBLEM
+            Icmp::Error.new(packet)
+          else
+            Icmp::Base.new(packet)
+          end
+        end
+
+        def self.parse(packet, _b0)
+          bytes = packet.bytes
+          bytes_length = packet.bytes_length
+          offset = packet.bytes_offset
+
+          return false if bytes_length < 40
+
+          payload_length = bytes.get_value(:U16, offset + 4)
+          proto = bytes.get_value(:U8, offset + 6)
+
+          # [draft-ietf-6man-eh-limits-19] Section 4 suggests IPv6 nodes
+          # to process at least 64 bytes long chain of EHs.
+          extensions_length_limit = [payload_length, 64].min
+          extensions_length = 0
+
+          while EXTENSIONS[proto]
+            extension_start = 40 + extensions_length
+            return false if extension_start + 8 > bytes_length  # EH is at least 8 byte long
+
+            proto = bytes.get_value(:U8, offset + extension_start)
+            length = bytes.get_value(:U8, offset + extension_start + 1) * 8 + 8
+
+            extensions_length += length
+            return false if extensions_length > extensions_length_limit
+
+            # TODO: Routing header
+          end
+
+          if proto == 51  # AH
+            # AH has a non-standard EH format. It doesn't work with NAT anyway.
+            return false
+          end
+
+          # We assume Fragment is at the last of EH chain.
+          if proto == 44  # Fragment
+            # TODO: handle fragmentation
+            return false
+          end
+
+          # ESP is handled as L4 protocol
+
+          return false unless packet.set_l4_region(40 + extensions_length, payload_length - extensions_length)
+          packet.proto = proto
+
+          true
+        end
+
+        def self.apply(bytes, offset, _cs_delta, icmp_payload)
+          # decrement hop limit
+          unless icmp_payload
+            hop_limit = bytes.get_value(:U8, offset + 7)
+            if hop_limit > 0
+              hop_limit -= 1
+              bytes.set_value(:U8, offset + 7, hop_limit)
+            end
+          end
+
+          # IPv6 has no checksum
+        end
+      end
+    end
+  end
+end
+
+

data/lib/xlat/protocols/ip.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+module Xlat
+  module Protocols
+    class Ip
+      attr_accessor :bytes  # IO::Buffer containing L3 header
+      attr_accessor :bytes_offset  # Offset where L3 header begins within `bytes`
+      attr_accessor :bytes_length  # Length of L3 datagram within `bytes`
+      attr_accessor :proto  # L4 protocol ID
+      attr_accessor :l4_start  # L3 header length
+      attr_accessor :l4_length # Length of L4 packet, as specified in L3 header
+      attr_accessor :l4
+      attr_accessor :l4_bytes  # IO::Buffer containing L4 packet
+      attr_accessor :l4_bytes_offset  # Offset where L4 header begins within `l4_bytes`
+      attr_accessor :l4_bytes_length  # Length of L4 datagram within `l4_bytes`, possibly truncated
+      attr_accessor :cs_delta  # Accumulated changes to be applied to L4 checksum
+
+      attr_reader :version
+
+      def initialize(icmp_payload: false)
+        @icmp_payload = icmp_payload
+        @_tcp = Tcp.new(self, icmp_payload:)
+        @_udp = Udp.new(self, icmp_payload:)
+      end
+
+      def self.parse(bytes)
+        new.parse(bytes:)
+      end
+
+      def parse(bytes:, bytes_offset: 0, bytes_length: bytes.size - bytes_offset, l4_bytes: nil, l4_bytes_offset: nil)
+        @bytes = bytes
+        @bytes_offset = bytes_offset
+        @bytes_length = bytes_length
+        @proto = nil
+        @version = nil
+        @l4_start = nil
+        @l4_length = nil
+        @l4 = nil
+        @l4_bytes = l4_bytes
+        @l4_bytes_offset = l4_bytes_offset
+        @l4_bytes_length = nil
+        @cs_delta = 0
+
+        # mimimum size for IPv4
+        return nil if bytes_length < 20
+
+        b0 = bytes.get_value(:U8, bytes_offset)
+        case b0 >> 4
+        when 4
+          @version = Ipv4
+        when 6
+          @version = Ipv6
+        else
+          return nil
+        end
+
+        return nil unless @version.parse(self, b0)
+
+        case @proto
+        when Protocols::Udp::PROTOCOL_ID
+          @l4 = @_udp.parse
+        when Protocols::Tcp::PROTOCOL_ID
+          @l4 = @_tcp.parse
+        when @version.icmp_protocol_id
+          @l4 = Protocols::Icmp.parse(self)
+        end
+
+        self
+      end
+
+      # @param start [Integer] Length of L3 header in octets
+      # @param length [Integer] Length of L4 datagram in octets, as specified in L3 header
+      # @return [true, false] Whether the given range is valid
+      def set_l4_region(start, length)
+        @l4_start = start
+        @l4_length = length
+
+        unless @l4_bytes
+          @l4_bytes = @bytes
+          @l4_bytes_offset = @bytes_offset + start
+          @l4_bytes_length = @bytes_length - start
+        end
+
+        if @l4_bytes_length < length
+          if @icmp_payload
+            # allow truncation in ICMP payload
+            length = @l4_bytes_length
+            return false if length < 0
+          else
+            return false
+          end
+        end
+
+        @l4_bytes_length = length
+
+        true
+      end
+
+      # Convert this packet into different IP version using the supplied buffer as header.
+      #
+      # @param version [Module] New version
+      # @param new_header_bytes [IO::Buffer] Buffer to hold L3 header.
+      #   The caller is responsible for populating the buffer with a proper content.
+      # @param cs_delta [Integer] Checksum delta in the pseudo header to be cancelled with the L4 checksum.
+      # @return [Ip] self
+      def convert_version!(version, new_header_bytes, cs_delta)
+        @bytes = new_header_bytes
+        @bytes_offset = 0
+        @bytes_length = new_header_bytes.size
+        @version = version
+        @l4_start = new_header_bytes.size
+        @cs_delta += cs_delta
+        self
+      end
+
+      def tuple
+        @version.tuple(@bytes, @bytes_offset)
+      end
+
+      def apply_changes
+        cs_delta = @cs_delta
+        @version.apply(@bytes, @bytes_offset, cs_delta, @icmp_payload)
+        @l4&.apply(cs_delta)
+        @cs_delta = 0
+      end
+
+      def self.checksum(bytes, from = nil, len = nil)
+        from = 0 if from.nil?
+        len = bytes.size - from if len.nil?
+        to = from + len - 1
+
+        sum = Common.sum16be(bytes.slice(from, len))
+        sum += bytes.get_value(:U8, to) * 256 if len.odd?
+        sum = (sum & 0xffff) + (sum >> 16) while sum > 65535
+        ~sum & 0xffff
+      end
+
+      def self.checksum_list(buffers)
+        sum = 0
+        offset = 0
+        buffers.each do |buf|
+          if offset.odd?
+            sum += buf.get_value(:U8, 0)
+            buf = buf.slice(1)
+            offset += 1
+          end
+          sum += Common.sum16be(buf)
+          len = buf.size
+          if len.odd?
+            sum += buf.get_value(:U8, len - 1) << 8
+          end
+          offset += len
+        end
+        sum = (sum & 0xffff) + (sum >> 16) while sum > 65535
+        ~sum & 0xffff
+      end
+
+      # this function assumes 0 <= sum <= 65534
+      def self.checksum_adjust(checksum, delta)
+        delta %= 65535
+
+        mod65535 = 65534 - checksum
+        mod65535 = (mod65535 + delta) % 65535
+        65534 - mod65535
+      end
+
+      def self.addr_to_s(addr)
+        case addr.length
+        when 4
+          addr.unpack('C4').join('.')
+        when 16
+          addr.unpack('n8').map { |f| format '%x', f }.join(':').gsub(/(:0)+(?=:)/, ':')
+        else
+          raise "unexpected address length of #{addr.length}"
+        end
+      end
+    end
+  end
+end
+
+require_relative './icmp'
+require_relative './ip/ipv4'
+require_relative './ip/ipv6'
+require_relative './tcp'
+require_relative './udp'

data/lib/xlat/protocols/tcp.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require_relative './tcpudp'
+
+module Xlat
+  module Protocols
+    class Tcp < Tcpudp
+      PROTOCOL_ID = 6
+      DATA_OFFSET_OFFSET = 12
+      CHECKSUM_OFFSET = 16
+      OPTION_KIND_END = 0
+      OPTION_KIND_NOOP = 1
+      OPTION_KIND_MSS = 2
+      FLAG_FIN = 0x01
+      FLAG_SYN = 0x02
+      FLAG_RST = 0x04
+      FLAG_PST = 0x08
+      FLAG_ACK = 0x10
+      FLAG_URG = 0x20
+      FLAG_ECE = 0x40
+      FLAG_CWR = 0x80
+
+      def parse
+        packet = @packet
+        return nil if packet.l4_bytes_length < (@icmp_payload ? 4 : 20)
+
+        # bytes = packet.l4_bytes
+        # offset = packet.l4_bytes_offset
+
+        super
+      end
+
+      def apply(cs_delta)
+        return if cs_delta.zero?
+
+        packet = @packet
+        return if packet.l4_bytes_length < 18
+
+        bytes = packet.l4_bytes
+        offset = packet.l4_bytes_offset
+
+        checksum = bytes.get_value(:U16, offset + 16)
+        checksum = _adjust_checksum(checksum, cs_delta)
+        bytes.set_value(:U16, offset + 16, checksum)
+      end
+    end
+  end
+end

data/lib/xlat/protocols/tcpudp.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# This file is based on the source code available at https://github.com/kazuho/rat under MIT License
+# 
+# Copyright (c) 2022 Kazuho Oku
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+require 'xlat/common'
+require 'xlat/protocols/icmp'
+
+module Xlat
+  module Protocols
+    class Tcpudp
+      include Xlat::Common
+
+      def initialize(packet, icmp_payload:)
+        @packet = packet
+        @icmp_payload = icmp_payload
+      end
+
+      def parse
+        self
+      end
+
+      def tuple
+        @bytes.slice(@offset, 4)
+      end
+
+      def _adjust_checksum(checksum, cs_delta)
+        Ip.checksum_adjust(checksum, cs_delta)
+      end
+    end
+  end
+end