sftp_server 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e6579fc72d42db229fdc52951724810a74e81661
+  data.tar.gz: a73bb16cb690daa050997e727c195740e70c841b
+SHA512:
+  metadata.gz: c27a18a11ed53b0c762c48d6c43f2ba495bcb8ca18f85ce561ae8550be0d84df7d1220bd4ec0d1795dc32fb2abcd42cdacfc3ce20d4b346b574c456f20def542
+  data.tar.gz: 840fa2cfe4cc9ae5de894a94b03e07d1d8b98679d1d8f996226db9ff382feb025fb5fd561555b79f3a278789e6e7807f72b25d18a6256ffac70babcdd2783d8b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sftp_server.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 M. Scott Ford
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,33 @@
+# SFTPServer
+
+A simple SFTP server for testing clients:
+
+Uses libssh via FFI to create an SFTP server. Useful for testing interactions with a remote SFTP server.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sftp_server'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sftp_server
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/corgibytes/sftp_server/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/sftp_server.rb

@@ -0,0 +1,2 @@
+require 'sftp_server/version'
+require 'sftp_server/server'

data/lib/sftp_server/c/api.rb

@@ -0,0 +1,13 @@
+require 'ffi'
+
+module SFTPServer
+  module C
+    module API
+      extend FFI::Library
+      ffi_lib_flags :now, :global
+      ffi_lib 'c'
+
+      attach_function :opendir, [:string], :pointer
+    end
+  end
+end

data/lib/sftp_server/server.rb

@@ -0,0 +1,417 @@
+require 'sftp_server/ssh/api'
+require 'sftp_server/c/api'
+
+require 'pry'
+
+module SFTPServer
+  class Server
+    attr_accessor :user_name
+    attr_accessor :password
+    attr_accessor :rsa_key
+    attr_accessor :dsa_key
+    attr_accessor :port
+    attr_accessor :listen_address
+    attr_accessor :verbose
+
+    def initialize(options = {})
+      @user_name = options[:user_name]
+      @password = options[:password]
+      @rsa_key = options[:rsa_key]
+      @dsa_key = options[:dsa_key]
+      @port = options[:port]
+      @listen_address = options[:listen_address]
+      @verbose = options[:verbose]
+
+      @authenticated = false
+      @handles = {}
+    end
+
+    def set_bind_option(sshbind, key_type, key_value, value_type, value_value)
+      result = SSH::API.ssh_bind_options_set(
+        sshbind, key_type, key_value, value_type, value_value
+      )
+      fail SSH::API.ssh_get_error(sshbind) if result < 0
+    end
+
+    def bind_listen(bind)
+      result = SSH::API.ssh_bind_listen(bind)
+      fail SSH::API.ssh_get_error(bind) if result < 0
+    end
+
+    def bind_accept(bind, session)
+      result = SSH::API.ssh_bind_accept(bind, session)
+      fail SSH::API.ssh_get_error(bind) if result < 0
+    end
+
+    def handle_key_exchange(session)
+      result = SSH::API.ssh_handle_key_exchange(session)
+      fail SSH::API.ssh_get_error(session) if result < 0
+    end
+
+    def handle_auth(message)
+    end
+
+    def respond_auth_required(message)
+      SSH::API.ssh_message_auth_set_methods(message, SSH::API::MessageAuthTypes::SSH_AUTH_METHOD_PASSWORD)
+      SSH::API.ssh_message_reply_default(message)
+    end
+
+    def sftp_channel_request(session)
+      sftp_channel_requested = false
+      while !sftp_channel_requested
+        message = SSH::API.ssh_message_get(session)
+        if message
+          message_type = SSH::API.ssh_message_type(message)
+          log "open sftp session message_type: #{message_type}"
+          if message_type == SSH::API::MessageTypes::SSH_REQUEST_CHANNEL
+            message_subtype = SSH::API.ssh_message_subtype(message)
+            log "open sftp session message_subtype: #{message_subtype}"
+
+            case message_subtype
+            when SSH::API::ChannelRequestTypes::SSH_CHANNEL_REQUEST_ENV
+              env_name = SSH::API.ssh_message_channel_request_env_name(message)
+              log "request env name: #{env_name}"
+
+              env_value = SSH::API.ssh_message_channel_request_env_value(message)
+              log "request env value: #{env_value}"
+            when SSH::API::ChannelRequestTypes::SSH_CHANNEL_REQUEST_SUBSYSTEM
+              subsystem_name = SSH::API.ssh_message_channel_request_subsystem(message)
+              log "request subsystem: #{subsystem_name}"
+              if subsystem_name == 'sftp'
+                SSH::API.ssh_message_channel_request_reply_success(message)
+                sftp_channel_requested = true
+              end
+            end
+          end
+        end
+
+        unless sftp_channel_requested
+          SSH::API.ssh_message_reply_default(message)
+        end
+        SSH::API.ssh_message_free(message)
+      end
+      sftp_channel_requested
+    end
+
+    def log(message)
+      puts(message) if verbose
+    end
+
+    def open_channel(session)
+      channel = nil
+      while channel.nil?
+        message = SSH::API.ssh_message_get(session)
+        next unless message
+
+        message_type = SSH::API.ssh_message_type(message)
+        log "channel message_type: #{message_type}"
+        next unless message_type > -1
+
+        case message_type
+        when SSH::API::MessageTypes::SSH_REQUEST_CHANNEL_OPEN
+          message_subtype = SSH::API.ssh_message_subtype(message)
+          log "channel message_subtype: #{message_subtype}"
+          if message_subtype == SSH::API::ChannelTypes::SSH_CHANNEL_SESSION
+            channel = SSH::API.ssh_message_channel_request_open_reply_accept(message)
+            break
+          end
+        else
+          SSH::API.ssh_message_reply_default(message)
+        end
+        SSH::API.ssh_message_free(message)
+      end
+      channel
+    end
+
+    def authenticate(session)
+      authenticated = false
+      while !authenticated
+        message = SSH::API.ssh_message_get(session)
+        next unless message
+
+        message_type = SSH::API.ssh_message_type(message)
+        log "message_type: #{message_type}"
+        next unless message_type > -1
+
+        case message_type
+        when SSH::API::MessageTypes::SSH_REQUEST_AUTH
+          log "auth"
+          message_subtype = SSH::API.ssh_message_subtype(message)
+          log "auth message_subtype: #{message_subtype}"
+          case message_subtype
+          when SSH::API::MessageAuthTypes::SSH_AUTH_METHOD_PASSWORD
+            request_user_name = SSH::API.ssh_message_auth_user(message)
+            request_password = SSH::API.ssh_message_auth_password(message)
+            log user_name
+            log password
+            if user_name == request_user_name && password == request_password
+              SSH::API.ssh_message_auth_reply_success(message, 0)
+              SSH::API.ssh_message_free(message)
+              authenticated = true
+              break
+            else
+              SSH::API.ssh_message_reply_default(message)
+              next
+            end
+          else
+            respond_auth_required(message) unless @authenticated
+          end
+        else
+          SSH::API.ssh_message_reply_default(message)
+        end
+      end
+      authenticated
+    end
+
+    def init_sftp_session(sftp_session)
+      result = SSH::API.sftp_server_init(sftp_session)
+      fail SSH::API.ssh_get_error(sftp_session) unless result == 0
+    end
+
+    def sftp_message_loop(sftp_session)
+      while true
+        client_message = SSH::API.sftp_get_client_message(sftp_session)
+        log "client_message: #{client_message}"
+        return if client_message.null?
+
+        client_message_type = SSH::API.sftp_client_message_get_type(client_message)
+        next unless client_message_type
+        log "client_message_type: #{client_message_type}"
+
+        case client_message_type
+        when SSH::API::SFTPCommands::SSH_FXP_REALPATH
+          log "realpath"
+
+          file_name = SSH::API.sftp_client_message_get_filename(client_message)
+          log "file_name: #{file_name}"
+
+          long_file_name = File.expand_path(file_name)
+
+          SSH::API.sftp_reply_names_add(client_message, long_file_name, long_file_name, SSH::API::SFTPAttributes.new.to_ptr)
+          SSH::API.sftp_reply_names(client_message)
+        when SSH::API::SFTPCommands::SSH_FXP_OPENDIR
+          log "opendir"
+
+          dir_name = SSH::API.sftp_client_message_get_filename(client_message)
+          long_dir_name = File.expand_path(dir_name)
+          log "long_dir_name: #{long_dir_name}"
+
+          @handles[long_dir_name] = :open
+
+          long_dir_name_pointer = FFI::MemoryPointer.from_string(long_dir_name)
+          handle = SSH::API.sftp_handle_alloc(sftp_session, long_dir_name_pointer)
+
+          SSH::API.sftp_reply_handle(client_message, handle)
+        when SSH::API::SFTPCommands::SSH_FXP_READDIR
+          log "readdir"
+
+          client_message_data = SSH::API::SFTPClientMessage.new(client_message)
+          handle = SSH::API.sftp_handle(sftp_session, client_message_data[:handle])
+          long_dir_name = handle.read_string
+          log "long_dir_name: #{long_dir_name}"
+
+          if @handles[long_dir_name] == :open
+            Dir.entries(long_dir_name).each do |entry|
+              SSH::API.sftp_reply_names_add(
+                client_message,
+                entry,
+                entry,
+                SSH::API::SFTPAttributes.new.to_ptr
+              )
+            end
+            @handles[long_dir_name] = :read
+            SSH::API.sftp_reply_names(client_message)
+          else
+            SSH::API.sftp_reply_status(client_message, SSH::API::SFTPStatus::SSH_FX_EOF, 'End-of-file encountered')
+          end
+        when SSH::API::SFTPCommands::SSH_FXP_CLOSE
+          log 'close'
+
+          client_message_data = SSH::API::SFTPClientMessage.new(client_message)
+          handle = SSH::API.sftp_handle(sftp_session, client_message_data[:handle])
+          long_dir_name = handle.read_string
+          log "long_dir_name: #{long_dir_name}"
+
+          @handles.delete(long_dir_name)
+
+          SSH::API.sftp_reply_status(client_message, SSH::API::SFTPStatus::SSH_FX_OK, 'Success')
+        when SSH::API::SFTPCommands::SSH_FXP_LSTAT
+          log 'lstat'
+
+          file_name = SSH::API.sftp_client_message_get_filename(client_message)
+          log "file_name: #{file_name}"
+
+          long_file_name = File.expand_path(file_name)
+
+          file_stat = File.lstat(long_file_name)
+
+          attributes = SSH::API::SFTPAttributes.new
+
+          attributes[:flags] = 0
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_SIZE
+          attributes[:size] = file_stat.size
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_UIDGID
+          attributes[:uid] = file_stat.uid
+          attributes[:gid] = file_stat.gid
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_PERMISSIONS
+          attributes[:permissions] = file_stat.mode
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_ACMODTIME
+          attributes[:atime] = file_stat.atime.to_i
+          attributes[:mtime] = file_stat.mtime.to_i
+
+          SSH::API.sftp_reply_attr(client_message, attributes.to_ptr)
+        when SSH::API::SFTPCommands::SSH_FXP_STAT
+          log 'stat'
+
+          file_name = SSH::API.sftp_client_message_get_filename(client_message)
+          log "file_name: #{file_name}"
+
+          long_file_name = File.expand_path(file_name)
+
+          file_stat = File.stat(long_file_name)
+
+          attributes = SSH::API::SFTPAttributes.new
+
+          attributes[:flags] = 0
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_SIZE
+          attributes[:size] = file_stat.size
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_UIDGID
+          attributes[:uid] = file_stat.uid
+          attributes[:gid] = file_stat.gid
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_PERMISSIONS
+          attributes[:permissions] = file_stat.mode
+          attributes[:flags] |= SSH::API::Attributes::SSH_FILEXFER_ATTR_ACMODTIME
+          attributes[:atime] = file_stat.atime.to_i
+          attributes[:mtime] = file_stat.mtime.to_i
+
+          SSH::API.sftp_reply_attr(client_message, attributes.to_ptr)
+        when SSH::API::SFTPCommands::SSH_FXP_OPEN
+          log 'open'
+
+          file_name = SSH::API.sftp_client_message_get_filename(client_message)
+          long_file_name = File.expand_path(file_name)
+          log "long_file_name: #{long_file_name}"
+
+          client_message_data = SSH::API::SFTPClientMessage.new(client_message)
+          message_flags = client_message_data[:flags]
+          flags = 0
+          if (message_flags & SSH::API::Flags::SSH_FXF_READ == SSH::API::Flags::SSH_FXF_READ) &&
+            (message_flags & SSH::API::Flags::SSH_FXF_WRITE == SSH::API::Flags::SSH_FXF_WRITE)
+            flags = File::Constants::RDWR
+          elsif (message_flags & SSH::API::Flags::SSH_FXF_READ == SSH::API::Flags::SSH_FXF_READ)
+            flags = File::Constants::RDONLY
+          elsif (message_flags & SSH::API::Flags::SSH_FXF_WRITE == SSH::API::Flags::SSH_FXF_WRITE)
+            flags = File::Constants::WRONLY
+          end
+
+          if (message_flags & SSH::API::Flags::SSH_FXF_APPEND == SSH::API::Flags::SSH_FXF_APPEND)
+            flags |= File::Constants::APPEND
+          end
+
+          if (message_flags & SSH::API::Flags::SSH_FXF_CREAT == SSH::API::Flags::SSH_FXF_CREAT)
+            flags |= File::Constants::CREAT
+          end
+
+          if (message_flags & SSH::API::Flags::SSH_FXF_TRUNC == SSH::API::Flags::SSH_FXF_TRUNC)
+            flags |= File::Constants::TRUNC
+          end
+
+          if (message_flags & SSH::API::Flags::SSH_FXF_EXCL == SSH::API::Flags::SSH_FXF_EXCL)
+            flags |= File::Constants::EXCL
+          end
+
+          @handles[long_file_name] = File.open(long_file_name, flags)
+
+          long_file_name_pointer = FFI::MemoryPointer.from_string(long_file_name)
+          handle = SSH::API.sftp_handle_alloc(sftp_session, long_file_name_pointer)
+
+          SSH::API.sftp_reply_handle(client_message, handle)
+        when SSH::API::SFTPCommands::SSH_FXP_READ
+          log 'read'
+
+          client_message_data = SSH::API::SFTPClientMessage.new(client_message)
+          handle = SSH::API.sftp_handle(sftp_session, client_message_data[:handle])
+          long_file_name = handle.read_string
+          log "long_file_name: #{long_file_name}"
+
+          file = @handles[long_file_name]
+          if file
+            file.seek(client_message_data[:offset])
+            data = file.read(client_message_data[:len])
+            if data
+              buffer = FFI::MemoryPointer.new(:char, data.size)
+              buffer.put_bytes(0, data)
+              SSH::API.sftp_reply_data(client_message, buffer, data.size)
+            else
+              SSH::API.sftp_reply_status(client_message, SSH::API::SFTPStatus::SSH_FX_EOF, 'End-of-file encountered')
+            end
+          end
+        when SSH::API::SFTPCommands::SSH_FXP_WRITE
+          log 'write'
+
+          client_message_data = SSH::API::SFTPClientMessage.new(client_message)
+          handle = SSH::API.sftp_handle(sftp_session, client_message_data[:handle])
+          long_file_name = handle.read_string
+          log "long_file_name: #{long_file_name}"
+
+          file = @handles[long_file_name]
+          if file
+            file.seek(client_message_data[:offset])
+            buffer = SSH::API.sftp_client_message_get_data(client_message)
+            file.write(buffer.read_string)
+            SSH::API.sftp_reply_status(client_message, SSH::API::SFTPStatus::SSH_FX_OK, 'Success')
+          end
+        end
+
+        SSH::API.sftp_client_message_free(client_message)
+      end
+    end
+
+    def close_channel(channel)
+      result = SSH::API.ssh_channel_close(channel)
+      fail SSH::API.ssh_get_error(channel) if result < 0
+    end
+
+    def free_channel(channel)
+      result = SSH::API.ssh_channel_free(channel)
+      fail SSH::API.ssh_get_error(channel) if result < 0
+    end
+
+    def disconnect_session(session)
+      result = SSH::API.ssh_disconnect(session)
+      fail SSH::API.ssh_get_error(session) if result < 0
+    end
+
+    def free_bind(bind)
+      result = SSH::API.ssh_bind_free(bind)
+      fail SSH::API.ssh_get_error(bind) if result < 0
+    end
+
+    def open
+      ssh_bind = SSH::API.ssh_bind_new
+      session = SSH::API.ssh_new
+
+      set_bind_option(ssh_bind, :int, SSH::API::BindOptions::SSH_BIND_OPTIONS_BINDADDR, :string, listen_address) if listen_address
+      set_bind_option(ssh_bind, :int, SSH::API::BindOptions::SSH_BIND_OPTIONS_BINDPORT_STR, :string, port) if port
+      set_bind_option(ssh_bind, :int, SSH::API::BindOptions::SSH_BIND_OPTIONS_RSAKEY, :string, rsa_key) if rsa_key
+      set_bind_option(ssh_bind, :int, SSH::API::BindOptions::SSH_BIND_OPTIONS_DSAKEY, :string, dsa_key) if dsa_key
+
+      bind_listen(ssh_bind)
+      bind_accept(ssh_bind, session)
+      handle_key_exchange(session)
+
+      if authenticate(session)
+        channel = open_channel(session)
+        if channel
+          if sftp_channel_request(session)
+            sftp_session = SSH::API.sftp_server_new(session, channel)
+            init_sftp_session(sftp_session)
+            sftp_message_loop(sftp_session)
+          end
+        end
+        close_channel(channel)
+        free_channel(channel)
+      end
+    end
+  end
+end