crussh 0.1.0

data/lib/crussh/protocol/channel_request.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ChannelRequest < Message
+      message_type CHANNEL_REQUEST
+
+      field :recipient_channel, :uint32
+      field :request_type, :string
+      field :want_reply, :boolean
+      field :request_data, :remaining
+
+      def want_reply? = want_reply
+      def pty? = request_type == "pty-req"
+      def x11? = request_type == "x11-req"
+      def env? = request_type == "env"
+      def shell? = request_type == "shell"
+      def exec? = request_type == "exec"
+      def subsystem? = request_type == "subsystem"
+      def window_change? = request_type == "window-change"
+      def local_flow_control? = request_type == "xon-xoff"
+      def signal? = request_type == "signal"
+      def exit_status? = request_type == "exit-status"
+      def exit_signal? = request_type == "exit-signal"
+
+      def pty
+        return @pty_data if @pty_data
+        return unless pty?
+
+        reader = Transport::Reader.new(request_data)
+
+        term = reader.string
+        width = reader.uint32
+        height = reader.uint32
+        pixel_width = reader.uint32
+        pixel_height = reader.uint32
+        modes = reader.string
+
+        @pty_data = Channel::Pty.new(term:, width:, height:, pixel_width:, pixel_height:, modes:)
+      end
+
+      def x11
+        return @x11_data if @x11_data
+        return unless x11?
+
+        reader = Transport::Reader.new(request_data)
+
+        single_connection = reader.boolean
+        x11_auth_protocol = reader.string
+        x11_auth_cookie = reader.string
+        x11_screen_number = reader.uint32
+
+        @x11_data = X11.new(single_connection:, auth_protocol: x11_auth_protocol, auth_cookie: x11_auth_cookie, screen_number: x11_screen_number)
+      end
+      X11 = Data.define(:single_connection, :auth_protocol, :auth_cookie, :screen_number) do
+        def single_connection? = single_connection
+      end
+
+      def env
+        return @env_data if @env_data
+        return unless env?
+
+        reader = Transport::Reader.new(request_data)
+
+        variable_name = reader.string
+        variable_value = reader.string
+
+        @env_data = Env.new(variable_name:, variable_value:)
+      end
+      Env = Data.define(:variable_name, :variable_value)
+
+      def command
+        return @command if @command
+        return unless exec?
+
+        reader = Transport::Reader.new(request_data)
+        @command = reader.string
+      end
+
+      def subsystem_name
+        return @subsystem_name if @subsystem_name
+        return unless subsystem?
+
+        reader = Transport::Reader.new(request_data)
+        @subsystem_name = reader.string
+      end
+
+      def window_change
+        return @window_change_data if @window_change_data
+        return unless window_change?
+
+        reader = Transport::Reader.new(request_data)
+
+        width = reader.uint32
+        height = reader.uint32
+        pixel_width = reader.uint32
+        pixel_height = reader.uint32
+
+        @window_change_data = Channel::WindowChange.new(width:, height:, pixel_width:, pixel_height:)
+      end
+
+      def can_do_local_flow_control?
+        return @can_do_local_flow_control unless @can_do_local_flow_control.nil?
+        return false unless local_flow_control?
+
+        reader = Transport::Reader.new(request_data)
+
+        @can_do_local_flow_control = reader.boolean
+      end
+
+      def signal
+        return @signal if @signal
+        return false unless signal?
+
+        reader = Transport::Reader.new(request_data)
+
+        @signal = Channel::Signal.new(name: reader.string)
+      end
+
+      def exit_status
+        return @exit_status if @exit_status
+        return unless exit_status?
+
+        reader = Transport::Reader.new(request_data)
+
+        @exit_status = reader.uint32
+      end
+
+      def exit_signal
+        return @exit_signal if @exit_signal
+        return unless exit_signal?
+
+        reader = Transport::Reader.new(request_data)
+
+        core_dumped = reader.boolean
+        error_message = reader.string
+        language_tag = reader.string
+
+        @exit_signal = ExitSignal.new(core_dumped:, error_message:, language_tag:)
+      end
+      ExitSignal = Data.define(:core_dumped, :error_message, :language_tag) do
+        def core_dumped? = core_dumped
+      end
+    end
+  end
+end

data/lib/crussh/protocol/channel_success.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ChannelSuccess < Message
+      message_type CHANNEL_SUCCESS
+
+      field :recipient_channel, :uint32
+    end
+  end
+end

data/lib/crussh/protocol/channel_window_adjust.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ChannelWindowAdjust < Message
+      message_type CHANNEL_WINDOW_ADJUST
+
+      field :recipient_channel, :uint32
+      field :bytes_to_add, :uint32
+    end
+  end
+end

data/lib/crussh/protocol/debug.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Debug < Message
+      message_type DEBUG
+
+      field :always_display, :boolean
+      field :message, :string
+      field :language, :string, default: ""
+
+      def always_display? = @always_display
+    end
+  end
+end

data/lib/crussh/protocol/disconnect.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Disconnect < Message
+      message_type DISCONNECT
+
+      field :reason_code, :uint32
+      field :description, :string, default: ""
+      field :language, :string, default: ""
+
+      REASONS_MAP = {
+        host_not_allowed_to_connect: 1,
+        protocol_error: 2,
+        key_exchange_failed: 3,
+        reserved: 4,
+        mac_error: 5,
+        compression_error: 6,
+        service_not_available: 7,
+        protocol_version_not_supported: 8,
+        host_key_not_verifiable: 9,
+        connection_lost: 10,
+        by_application: 11,
+        too_many_connections: 12,
+        auth_cancelled_by_user: 13,
+        no_more_auth_methods_available: 14,
+        illegal_user_name: 15,
+      }
+
+      class << self
+        def build(reason, description = "")
+          reason_code = REASONS_MAP[reason]
+
+          new(reason_code:, description:)
+        end
+      end
+    end
+  end
+end

data/lib/crussh/protocol/ext_info.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ExtInfo
+      def initialize(extensions: {})
+        @extensions = extensions
+      end
+
+      attr_reader :extensions
+
+      def serialize
+        writer = Transport::Writer.new
+        writer.byte(EXT_INFO)
+        writer.uint32(@extensions.size)
+
+        @extensions.each do |name, value|
+          writer.string(name)
+          writer.string(value)
+        end
+
+        writer.to_s
+      end
+
+      class << self
+        def parse(data)
+          reader = Transport::Reader.new(data)
+          wire_message_type = reader.byte
+
+          unless wire_message_type == EXT_INFO
+            raise ProtocolError, "Expected EXT_INFO, got message type #{wire_message_type}"
+          end
+
+          count = reader.uint32
+          extensions = {}
+
+          count.times do
+            name = reader.string
+            value = reader.string
+            extensions[name] = value
+          end
+
+          new(extensions: extensions)
+        end
+      end
+    end
+  end
+end

data/lib/crussh/protocol/global_request.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class GlobalRequest < Message
+      message_type GLOBAL_REQUEST
+
+      field :request_type, :string
+      field :want_reply, :boolean, default: false
+      field :request_data, :remaining, default: ""
+
+      def tcpip_forward?
+        request_type == "tcpip-forward"
+      end
+
+      def cancel_tcpip_forward?
+        request_type == "cancel-tcpip-forward"
+      end
+
+      def tcpip_forward
+        return @tcpip_forward if @tcpip_forward
+        return unless tcpip_forward?
+
+        reader = Transport::Reader.new(request_data)
+
+        address = reader.string
+        port = reader.uint32
+
+        @tcpip_forward = TcpipForward.new(address:, port:)
+      end
+      TcpipForward = Data.define(:address, :port)
+
+      def cancel_tcpip_forward
+        return @cancel_tcpip_forward if @cancel_tcpip_forward
+        return unless cancel_tcpip_forward?
+
+        reader = Transport::Reader.new(request_data)
+
+        address = reader.string
+        port = reader.uint32
+
+        @cancel_tcpip_forward = TcpipForward.new(address:, port:)
+      end
+    end
+  end
+end

data/lib/crussh/protocol/ignore.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Ignore < Message
+      message_type IGNORE
+
+      field :data, :string, default: ""
+    end
+  end
+end

data/lib/crussh/protocol/kex_ecdh_init.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class KexEcdhInit < Message
+      message_type KEX_ECDH_INIT
+
+      field :public_key, :string
+    end
+  end
+end

data/lib/crussh/protocol/kex_ecdh_reply.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class KexEcdhReply < Message
+      message_type KEX_ECDH_REPLY
+
+      field :public_host_key, :string
+      field :public_key, :string
+      field :signature, :string
+    end
+  end
+end

data/lib/crussh/protocol/kex_init.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class KexInit < Message
+      message_type KEXINIT
+
+      field :cookie, :raw, length: 16, default: -> { SecureRandom.random_bytes(16) }
+      field :kex_algorithms, :name_list, default: []
+      field :server_host_key_algorithms, :name_list, default: []
+      field :cipher_client_to_server, :name_list, default: []
+      field :cipher_server_to_client, :name_list, default: []
+      field :mac_client_to_server, :name_list, default: []
+      field :mac_server_to_client, :name_list, default: []
+      field :compression_client_to_server, :name_list, default: []
+      field :compression_server_to_client, :name_list, default: []
+      field :languages_client_to_server, :name_list, default: []
+      field :languages_server_to_client, :name_list, default: []
+      field :first_kex_packet_follows, :boolean, default: false
+      field :reserved, :uint32, default: 0
+
+      class << self
+        def from_preferred(preferred)
+          new(
+            kex_algorithms: preferred.kex,
+            server_host_key_algorithms: preferred.host_key,
+            cipher_client_to_server: preferred.cipher,
+            cipher_server_to_client: preferred.cipher,
+            mac_client_to_server: preferred.mac,
+            mac_server_to_client: preferred.mac,
+            compression_client_to_server: preferred.compression,
+            compression_server_to_client: preferred.compression,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/crussh/protocol/new_keys.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class NewKeys < Message
+      message_type NEWKEYS
+    end
+  end
+end

data/lib/crussh/protocol/ping.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Ping < Message
+      message_type PING
+
+      field :data, :string, default: ""
+    end
+  end
+end

data/lib/crussh/protocol/pong.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Pong < Message
+      message_type PONG
+
+      field :data, :string, default: ""
+    end
+  end
+end

data/lib/crussh/protocol/request_failure.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class RequestFailure < Message
+      message_type REQUEST_FAILURE
+    end
+  end
+end

data/lib/crussh/protocol/request_success.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class RequestSuccess < Message
+      message_type REQUEST_SUCCESS
+
+      field :response_data, :remaining
+    end
+  end
+end

data/lib/crussh/protocol/service_accept.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ServiceAccept < Message
+      message_type SERVICE_ACCEPT
+
+      field :service_name, :string
+    end
+  end
+end

data/lib/crussh/protocol/service_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class ServiceRequest < Message
+      message_type SERVICE_REQUEST
+
+      field :service_name, :string
+    end
+  end
+end

data/lib/crussh/protocol/unimplemented.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class Unimplemented < Message
+      message_type UNIMPLEMENTED
+
+      field :sequence_number, :uint32
+    end
+  end
+end

data/lib/crussh/protocol/userauth_banner.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class UserauthBanner < Message
+      message_type USERAUTH_BANNER
+
+      field :message, :string
+      field :language, :string, default: ""
+    end
+  end
+end

data/lib/crussh/protocol/userauth_failure.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class UserauthFailure < Message
+      message_type USERAUTH_FAILURE
+
+      field :authentications, :name_list
+      field :partial_success, :boolean, default: false
+    end
+  end
+end

data/lib/crussh/protocol/userauth_pk_ok.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class UserauthPkOk < Message
+      message_type USERAUTH_PK_OK
+
+      field :algorithm, :string
+      field :key_blob, :string
+    end
+  end
+end

data/lib/crussh/protocol/userauth_request.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class UserauthRequest < Message
+      message_type USERAUTH_REQUEST
+
+      field :username, :string
+      field :service_name, :string
+      field :method_name, :string
+      field :method_data, :remaining
+
+      def none?
+        method_name == "none"
+      end
+
+      def password?
+        method_name == "password"
+      end
+
+      def publickey?
+        method_name == "publickey"
+      end
+
+      def password
+        return unless password?
+        return @password if @password
+
+        reader = Transport::Reader.new(method_data)
+        reader.boolean
+        @password = reader.string
+      end
+
+      def public_key_data
+        return @public_key_data if @public_key_data
+        return unless publickey?
+
+        reader = Transport::Reader.new(method_data)
+        has_signature = reader.boolean
+        algorithm = reader.string
+        key_blob = reader.string
+        signature = has_signature && !reader.eof? ? reader.string : nil
+
+        @public_key_data = PublicKeyData.new(has_signature, algorithm, key_blob, signature)
+      end
+
+      PublicKeyData = Data.define(:has_signature, :algorithm, :key_blob, :signature) do
+        def has_signature? = has_signature
+      end
+    end
+  end
+end

data/lib/crussh/protocol/userauth_success.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Protocol
+    class UserauthSuccess < Message
+      message_type USERAUTH_SUCCESS
+    end
+  end
+end