crussh 0.1.0

data/lib/crussh/handler/line_buffer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Crussh
+  class Handler
+    class LineBuffer
+      def initialize(channel, echo: true)
+        @channel = channel
+        @buffer = +""
+        @cursor = 0
+        @echo = echo
+      end
+
+      attr_reader :buffer
+
+      def handle(key)
+        case key
+        when String
+          insert(key)
+        when :backspace
+          backspace
+        when :delete
+          delete
+        when :arrow_left
+          move_left
+        when :arrow_right
+          move_right
+        when :home
+          move_to_start
+        when :end
+          move_to_end
+        end
+      end
+
+      def flush
+        line = @buffer
+        @buffer = +""
+        @cursor = 0
+        line
+      end
+
+      def clear
+        if @echo && @buffer.length.positive?
+          move_to_start
+          @channel.print("\e[K")
+        end
+
+        @buffer = +""
+        @cursor = 0
+      end
+
+      private
+
+      def cursor_at_start?
+        @cursor.zero?
+      end
+
+      def cursor_at_end?
+        @cursor == @buffer.length
+      end
+
+      def insert(char)
+        if cursor_at_end?
+          @buffer << char
+          @cursor += 1
+          @channel.print(char) if @echo
+          return
+        end
+
+        @buffer.insert(@cursor, char)
+        @cursor += 1
+        redraw_from_cursor if @echo
+      end
+
+      def backspace
+        return if cursor_at_start?
+
+        @cursor -= 1
+        @buffer.slice!(@cursor)
+
+        if @echo
+          @channel.print("\b")
+          redraw_from_cursor
+        end
+      end
+
+      def delete
+        return if cursor_at_end?
+
+        @buffer.slice!(@cursor)
+        redraw_from_cursor if @echo
+      end
+
+      def move_left
+        return if cursor_at_start?
+
+        @cursor -= 1
+        @channel.print("\e[D") if @echo
+      end
+
+      def move_right
+        return if cursor_at_end?
+
+        @cursor += 1
+        @channel.print("\e[C") if @echo
+      end
+
+      def move_to_start
+        return if cursor_at_start?
+
+        @channel.print("\e[#{@cursor}D") if @echo && @cursor > 0
+        @cursor = 0
+      end
+
+      def move_to_end
+        return if cursor_at_end?
+
+        distance = @buffer.length - @cursor
+        @channel.print("\e[#{distance}C") if @echo && distance > 0
+        @cursor = @buffer.length
+      end
+
+      def redraw_from_cursor
+        rest = @buffer[@cursor..]
+
+        @channel.print(rest)
+        @channel.print("\e[K")
+        @channel.print("\e[#{rest.length}D") if rest.empty?
+      end
+    end
+  end
+end

data/lib/crussh/handler.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/rescuable"
+
+module Crussh
+  class Handler
+    include ActiveSupport::Callbacks
+    include ActiveSupport::Rescuable
+
+    define_callbacks :handle
+
+    class << self
+      def before(*methods, **options, &block)
+        set_callback(:handle, :before, *methods, **options, &block)
+      end
+
+      def after(*methods, **options, &block)
+        set_callback(:handle, :after, *methods, **options, &block)
+      end
+
+      def around(*methods, **options, &block)
+        set_callback(:handle, :around, *methods, **options, &block)
+      end
+    end
+
+    def initialize(channel, session, ...)
+      @channel = channel
+      @session = session
+
+      setup(...)
+    end
+
+    def setup(...); end
+
+    def call
+      run_callbacks(:handle) { handle }
+    rescue => e
+      rescue_with_handler(e) || raise
+    end
+
+    def resize(...); end
+
+    private
+
+    attr_reader :session
+
+    def user = session.user
+    def config = session.config
+    def pty = channel.pty
+    def pty? = channel.pty?
+    def env = channel.env
+
+    def logger
+      # TODO: Some sort of logging context
+      @logger ||= Logger
+    end
+
+    def puts(...) = channel.puts(...)
+    def print(...) = channel.print(...)
+    def gets(...) = channel.gets(...)
+    def read(...) = channel.read(...)
+    def write(...) = channel.write(...)
+
+    def close = channel.close
+    def send_eof = channel.send_eof
+    def exit_status(...) = channel.exit_status(...)
+    def exit_signal(...) = channel.exit_signal(...)
+
+    def each_event(...) = channel.each(...)
+
+    def each_key(&block)
+      return enum_for(:each_key) unless block_given?
+
+      parser = Channel::KeyParser.new
+
+      each_event do |event|
+        case event
+        when Channel::Data
+          event.each_key(parser: parser, &block)
+        when Channel::WindowChange
+          resize(event.width, event.height) if respond_to?(:resize, true)
+        when Channel::EOF
+          yield :eof
+        when Channel::Closed
+          return
+        end
+      end
+    end
+
+    def each_line(prompt: "", echo: true)
+      return enum_for(:each_line, prompt:, echo:) unless block_given?
+
+      buffer = LineBuffer.new(channel, echo:)
+      print_prompt(prompt)
+
+      each_key do |key|
+        case key
+        when :enter
+          puts if echo
+          line = buffer.flush
+          yield line unless line.empty?
+          print_prompt(prompt)
+        when :interrupt
+          puts if echo
+          buffer.clear
+          print_prompt(prompt)
+        when :eof
+          puts if echo
+          return
+        else
+          buffer.handle(key)
+        end
+      end
+    end
+
+    def print_prompt(prompt)
+      case prompt
+      when String then print(prompt)
+      when Proc then print(prompt.call)
+      end
+    end
+
+    protected
+
+    attr_reader(:channel)
+  end
+end

data/lib/crussh/heartbeat.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Crussh
+  class Heartbeat
+    KEEPALIVE_REQUEST = "keepalive@openssh.com"
+
+    def initialize(session, interval:, max:)
+      @session = session
+      @interval = interval
+      @max = max
+      @missed = 0
+      @last_activity = Time.now
+      @task = nil
+    end
+
+    attr_reader :missed
+
+    def start(task: Async::Task.current)
+      return if @interval.nil?
+      return if @task&.running?
+
+      @task = task.async do
+        loop do
+          sleep(@interval)
+
+          if time_since_last_activity >= @interval
+            @missed += 1
+
+            if session_unresponsive?
+              @session.disconnect(:connection_lost, "Keepalive timeout")
+              break
+            end
+
+            send_keepalive
+          end
+        end
+      end
+    end
+
+    def stop
+      @task&.stop
+    end
+
+    def record_activity!
+      @last_activity = Time.now
+      @missed = 0
+    end
+
+    private
+
+    def send_keepalive
+      message = Protocol::GlobalRequest.new(
+        request_type: KEEPALIVE_REQUEST,
+      )
+      @session.write_packet(message)
+    rescue IOError, Errno::ECONNRESET, ConnectionClosed
+      stop
+    end
+
+    def session_unresponsive?
+      @missed > @max
+    end
+
+    def time_since_last_activity
+      Time.now - @last_activity
+    end
+  end
+end

data/lib/crussh/kex/algorithm.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Kex
+    class Algorithm
+      attr_reader :shared_secret
+
+      def skip_exchange?
+        false
+      end
+
+      def digest(data)
+        raise NotImplementedError
+      end
+
+      def client_dh_init
+        generate_keypair
+
+        @public_key
+      end
+
+      def server_dh_reply(client_public)
+        generate_keypair
+        compute_shared_secret(client_public)
+
+        @public_key
+      end
+
+      def client_dh_finish(server_public)
+        compute_shared_secret(server_public)
+      end
+
+      def compute_exchange_hash(exchange)
+        writer = Transport::Writer.new
+
+        writer
+          .string(exchange.client_id)
+          .string(exchange.server_id)
+          .string(exchange.client_kexinit)
+          .string(exchange.server_kexinit)
+          .string(exchange.server_host_key)
+          .string(exchange.client_public)
+          .string(exchange.server_public)
+          .mpint(shared_secret)
+
+        digest(writer.to_s)
+      end
+
+      def derive_keys(session_id:, exchange_hash:, cipher:, mac_c2s:, mac_s2c:, we_are_server:)
+        if we_are_server
+          {
+            iv_send: derive_key("B", cipher.block_size, session_id, exchange_hash),
+            iv_recv: derive_key("A", cipher.block_size, session_id, exchange_hash),
+            key_send: derive_key("D", cipher.key_length, session_id, exchange_hash),
+            key_recv: derive_key("C", cipher.key_length, session_id, exchange_hash),
+            mac_send: derive_key("F", mac_s2c&.key_length || 0, session_id, exchange_hash),
+            mac_recv: derive_key("E", mac_c2s&.key_length || 0, session_id, exchange_hash),
+          }
+        else
+          {
+            iv_send: derive_key("A", cipher.block_size, session_id, exchange_hash),
+            iv_recv: derive_key("B", cipher.block_size, session_id, exchange_hash),
+            key_send: derive_key("C", cipher.key_length, session_id, exchange_hash),
+            key_recv: derive_key("D", cipher.key_length, session_id, exchange_hash),
+            mac_send: derive_key("E", mac_c2s&.key_length || 0, session_id, exchange_hash),
+            mac_recv: derive_key("F", mac_s2c&.key_length || 0, session_id, exchange_hash),
+          }
+        end
+      end
+
+      private
+
+      def derive_key(letter, needed_length, session_id, exchange_hash)
+        return "".b if needed_length == 0
+
+        writer = Transport::Writer.new
+        k_encoded = writer.mpint(shared_secret).to_s
+
+        key = digest(k_encoded + exchange_hash + letter + session_id)
+        key += digest(k_encoded + exchange_hash + key) while key.bytesize < needed_length
+
+        key[0, needed_length]
+      end
+    end
+  end
+end

data/lib/crussh/kex/curve25519.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "x25519"
+
+module Crussh
+  module Kex
+    class Curve25519 < Algorithm
+      PUBLIC_KEY_SIZE = 32
+      PRIVATE_KEY_SIZE = 32
+
+      def digest(data)
+        Digest::SHA256.digest(data)
+      end
+
+      def generate_keypair
+        @private_key = X25519::Scalar.generate
+        @public_key = @private_key.public_key.to_bytes
+      end
+
+      def compute_shared_secret(their_public_key)
+        raise KexError, "Invalid public key size" if their_public_key.bytesize != PUBLIC_KEY_SIZE
+
+        their_key = X25519::MontgomeryU.new(their_public_key)
+        shared = @private_key.diffie_hellman(their_key)
+
+        @shared_secret = shared.to_bytes.unpack1("H*").to_i(16)
+      end
+    end
+  end
+end

data/lib/crussh/kex/exchange.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Crussh
+  module Kex
+    # TODO: Technically this is just for the server,
+    # so maybe we move it to be in the server module scope
+    class Exchange
+      PING_EXTENSION = "ping@openssh.com"
+      SERVER_SIGNATURE_ALGORITHMS = "server-sig-algs"
+
+      def initialize(session)
+        @session = session
+        @session_id = session.id
+        @received_messages = Set.new
+        @extra_messages_before_kexinit = 0
+      end
+
+      attr_reader :algorithms, :session_id
+
+      def config = @session.config
+      def strict_kex? = @session.strict_kex?
+      def initial? = @session_id.nil?
+
+      def initial(client_version:)
+        @client_version = client_version
+        @client_kexinit_payload = read_initial_kexinit
+
+        client_kexinit = Protocol::KexInit.parse(@client_kexinit_payload)
+
+        validate_strictness!(client_kexinit)
+
+        perform_full_key_exchange(client_kexinit)
+
+        if client_supports_ext_info?(client_kexinit)
+          send_ext_info
+        end
+      end
+
+      def start_rekey
+        server_kexinit = Protocol::KexInit.from_preferred(config.preferred)
+        @server_kexinit_payload = server_kexinit.serialize
+        @session.write_raw_packet(server_kexinit)
+
+        @client_kexinit_payload = @session.read_raw_packet
+        client_kexinit = Protocol::KexInit.parse(@client_kexinit_payload)
+
+        negotiate_and_exchange(client_kexinit, server_kexinit)
+      end
+
+      def rekey(client_kexinit_payload:)
+        @client_kexinit_payload = client_kexinit_payload
+        client_kexinit = Protocol::KexInit.parse(@client_kexinit_payload)
+
+        perform_full_key_exchange(client_kexinit)
+      end
+
+      private
+
+      def perform_full_key_exchange(client_kexinit)
+        server_kexinit = Protocol::KexInit.from_preferred(config.preferred)
+        @server_kexinit_payload = server_kexinit.serialize
+        @session.write_raw_packet(server_kexinit)
+
+        negotiate_and_exchange(client_kexinit, server_kexinit)
+      end
+
+      def validate_strictness!(client_kexinit)
+        @session.strict_kex = client_supports_strict?(client_kexinit)
+
+        if strict_kex? && @extra_messages_before_kexinit.positive?
+          raise ProtocolError, "Strict KEX: KEXINIT was not the first message"
+        end
+      end
+
+      def negotiate_and_exchange(client_kexinit, server_kexinit)
+        @algorithms = Negotiator.new(client_kexinit, server_kexinit).negotiate
+
+        perform_dh_exchange
+        derive_and_enable_keys
+      end
+
+      def perform_dh_exchange
+        packet = read_kex_packet(Protocol::KEX_ECDH_INIT)
+        kex_dh_init = Protocol::KexEcdhInit.parse(packet)
+        client_public = kex_dh_init.public_key
+
+        @kex_algorithm = Kex.from_name(@algorithms.kex)
+        server_public = @kex_algorithm.server_dh_reply(client_public)
+
+        parameters = Parameters.new(
+          client_id: @client_version.to_s,
+          server_id: config.server_id.to_s,
+          client_kexinit: @client_kexinit_payload,
+          server_kexinit: @server_kexinit_payload,
+          server_host_key: host_key.public_key_blob,
+          client_public: client_public,
+          server_public: server_public,
+          shared_secret: @kex_algorithm.shared_secret,
+        )
+
+        @exchange_hash = @kex_algorithm.compute_exchange_hash(parameters)
+        signature = host_key.sign(@exchange_hash)
+
+        kex_ecdh_reply = Protocol::KexEcdhReply.new(
+          public_host_key: host_key.public_key_blob,
+          public_key: server_public,
+          signature: signature,
+        )
+
+        @session.write_raw_packet(kex_ecdh_reply)
+        @session.write_raw_packet(Protocol::NewKeys.new)
+
+        packet = read_kex_packet(Protocol::NEWKEYS)
+        Protocol::NewKeys.parse(packet)
+
+        @session_id ||= @exchange_hash
+      end
+
+      def derive_and_enable_keys
+        cipher = Cipher.from_name(@algorithms.cipher_server_to_client)
+
+        keys = @kex_algorithm.derive_keys(
+          session_id: @session_id,
+          exchange_hash: @exchange_hash,
+          cipher: cipher,
+          mac_c2s: nil,
+          mac_s2c: nil,
+          we_are_server: true,
+        )
+
+        opening_key = cipher.make_opening_key(key: keys[:key_recv])
+        sealing_key = cipher.make_sealing_key(key: keys[:key_send])
+
+        @session.enable_encryption(opening_key, sealing_key)
+        @session.reset_sequence if strict_kex?
+        @session.algorithms = @algorithms
+
+        Logger.info(self, "Keys exchanged", cipher: @algorithms.cipher_server_to_client)
+      end
+
+      def send_ext_info
+        signature_algorithms = config.preferred.host_key.join(",")
+
+        extensions = {
+          SERVER_SIGNATURE_ALGORITHMS => signature_algorithms,
+          PING_EXTENSION => "0",
+        }
+
+        ext_info = Protocol::ExtInfo.new(extensions: extensions)
+        @session.write_packet(ext_info)
+      end
+
+      def read_kex_packet(expected_type)
+        validate_sequence_hasnt_wrapped! if strict_kex? && initial?
+
+        packet = @session.read_raw_packet
+        message_type = packet.getbyte(0)
+
+        if strict_kex? && initial?
+          unless kex_message?(message_type)
+            raise ProtocolError, "Strict KEX: unexpected message type #{message_type} during initial KEX"
+          end
+
+          if @received_messages.include?(message_type)
+            raise ProtocolError, "Strict KEX: duplicate message type #{message_type}"
+          end
+
+          @received_messages.add(message_type)
+        else
+          while message_type == Protocol::IGNORE || message_type == Protocol::DEBUG
+            packet = @session.read_raw_packet
+            message_type = packet.getbyte(0)
+          end
+        end
+
+        unless message_type == expected_type
+          raise ProtocolError, "Unexpected message type #{message_type}, expected #{expected_type}"
+        end
+
+        packet
+      end
+
+      def read_initial_kexinit
+        packet = @session.read_raw_packet
+        message_type = packet.getbyte(0)
+
+        while message_type == Protocol::IGNORE || message_type == Protocol::DEBUG
+          @extra_messages_before_kexinit += 1
+          packet = @session.read_raw_packet
+          message_type = packet.getbyte(0)
+        end
+
+        unless message_type == Protocol::KEXINIT
+          raise ProtocolError, "Expected KEXINIT, got message type #{message_type}"
+        end
+
+        @received_messages.add(Protocol::KEXINIT)
+
+        packet
+      end
+
+      def validate_sequence_hasnt_wrapped!
+        return unless @session.sequence_wrapped?
+
+        raise ProtocolError, "Strict KEX: sequence number wrapped during initial KEX"
+      end
+
+      def client_supports_strict?(client_kexinit)
+        client_kexinit.kex_algorithms.include?(STRICT_CLIENT)
+      end
+
+      def client_supports_ext_info?(client_kexinit)
+        client_kexinit.kex_algorithms.include?(EXT_INFO_CLIENT)
+      end
+
+      def kex_message?(type)
+        case type
+        when Protocol::KEXINIT, Protocol::NEWKEYS,
+             Protocol::KEX_ECDH_INIT, Protocol::KEX_ECDH_REPLY
+          # TODO: Add other KEX message types when implementing those algorithms:
+          # - SSH_MSG_KEXDH_INIT (30), SSH_MSG_KEXDH_REPLY (31) for DH
+          # - SSH_MSG_KEX_DH_GEX_* for DH group exchange
+          true
+        else
+          false
+        end
+      end
+
+      def host_key
+        @host_key ||= config.host_keys.find { |key| key.algorithm == @algorithms.host_key }
+      end
+    end
+  end
+end