Class: Rex::Proto::Ssh::Server

Inherits:
Object
  • Object
show all
Includes:
Rex::Proto
Defined in:
lib/rex/proto/ssh/server.rb

Overview

Acts as an SSH server, accepting clients and extending them with Connections

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(port = 22, listen_host = '0.0.0.0', context = {}, comm = nil, ssh_opts = Ssh::Connection.default_options, cc_cb = nil, cd_cb = nil) ⇒ Server

Initializes an SSH server as listening on the provided port and hostname.


46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/rex/proto/ssh/server.rb', line 46

def initialize(port = 22, listen_host = '0.0.0.0', context = {}, comm = nil,
  ssh_opts = Ssh::Connection.default_options, cc_cb = nil, cd_cb = nil)

  self.listen_host            = listen_host
  self.listen_port            = port
  self.context                = context
  self.comm                   = comm
  self.listener               = nil
  self.server_options         = ssh_opts
  self.on_client_connect_proc = cc_cb
  self.on_client_data_proc    = cd_cb
end

Instance Attribute Details

#clients ⇒ Object

Returns the value of attribute clients


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def clients
  @clients
end

#comm ⇒ Object

Returns the value of attribute comm


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def comm
  @comm
end

#context ⇒ Object

Returns the value of attribute context


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def context
  @context
end

#listen_host ⇒ Object

Returns the value of attribute listen_host


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def listen_host
  @listen_host
end

#listen_port ⇒ Object

Returns the value of attribute listen_port


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def listen_port
  @listen_port
end

#listener ⇒ Object

Returns the value of attribute listener


133
134
135
 
# File 'lib/rex/proto/ssh/server.rb', line 133

def listener
  @listener
end

#monitor_thread ⇒ Object

Returns the value of attribute monitor_thread


132
133
134
 
# File 'lib/rex/proto/ssh/server.rb', line 132

def monitor_thread
  @monitor_thread
end

#on_client_connect_proc ⇒ Object

Returns the value of attribute on_client_connect_proc


133
134
135
 
# File 'lib/rex/proto/ssh/server.rb', line 133

def on_client_connect_proc
  @on_client_connect_proc
end

#on_client_data_proc ⇒ Object

Returns the value of attribute on_client_data_proc


133
134
135
 
# File 'lib/rex/proto/ssh/server.rb', line 133

def on_client_data_proc
  @on_client_data_proc
end

#server_options ⇒ Object

Returns the value of attribute server_options


133
134
135
 
# File 'lib/rex/proto/ssh/server.rb', line 133

def server_options
  @server_options
end

Class Method Details

.hardcore_alias(*args) ⇒ Object

Returns the hardcore alias for the SSH service


68
69
70
 
# File 'lib/rex/proto/ssh/server.rb', line 68

def self.hardcore_alias(*args)
  "#{(args[0])}#{(args[1])}"
end

Instance Method Details

#alias ⇒ Object

SSH server.


75
76
77
 
# File 'lib/rex/proto/ssh/server.rb', line 75

def alias
  super || "SSH Server"
end

#close_client(cli) ⇒ Object

Closes the supplied client, if valid.


126
127
128
129
 
# File 'lib/rex/proto/ssh/server.rb', line 126

def close_client(cli)
  clients.delete(cli)
  listener.close_client(cli.parent)
end

#enqueue_client(cli) ⇒ Object (protected)

Waits for SSH client to “grow a pair” of FDs and adds a ChannelFD object derived from the client's Connection Channel's FDs to the Ssh::Server's clients array

Parameters:


181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/rex/proto/ssh/server.rb', line 181

def enqueue_client(cli)
  Rex::ThreadFactory.spawn("ChannelFDWaiter", false) do
    begin
      Timeout::timeout(15) do
        while cli.connection.open_channel_keys.empty? do
          sleep 0.02
        end
        self.clients.push(Ssh::ChannelFD.new(cli))
      end
    rescue Timeout::Error
      elog("Unable to find channel FDs for client #{cli}")
    end
  end
end

#inspect ⇒ String

More readable inspect that only shows the url and resources

Returns:

  • (String) 

61
62
63
 
# File 'lib/rex/proto/ssh/server.rb', line 61

def inspect
  "#<#{self.class} ssh://#{listen_host}:#{listen_port}>"
end

#monitor_clients ⇒ Object (protected)

Watches FD channel abstractions, removes closed instances, checks for read data on clients if client data callback is defined, invokes the callback if possible, sleeps otherwise.


156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/rex/proto/ssh/server.rb', line 156

def monitor_clients
  loop do
    self.clients.delete_if {|c| c.closed? }
    if self.on_client_data_proc
      if clients.any? { |cli|
        cli.has_read_data? and self.on_client_data_proc.call(cli)}
        next
      else
        sleep 0.05
      end
    else
      sleep 0.5
    end
  end
rescue => e
  wlog(e)
end

#on_client_connect(cli) ⇒ Object (protected)

Extends new clients with the ServerClient module and initializes them.


140
141
142
143
144
145
146
147
148
149
 
# File 'lib/rex/proto/ssh/server.rb', line 140

def on_client_connect(cli)
  cli.extend(ServerClient)

  cli.init_cli(self)
  if self.on_client_connect_proc
    self.on_client_connect_proc.call(cli)
  else
    enqueue_client(cli)
  end
end

#start(srvsock = nil) ⇒ Object

Listens on the defined port and host and starts monitoring for clients.


83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/rex/proto/ssh/server.rb', line 83

def start(srvsock = nil)

  self.listener = srvsock.is_a?(Rex::Socket::TcpServer) ? srvsock : Rex::Socket::TcpServer.create(
    'LocalHost' => self.listen_host,
    'LocalPort' => self.listen_port,
    'Context'   => self.context,
    'Comm'      => self.comm
  )

  # Register callbacks
  self.listener.on_client_connect_proc = Proc.new { |cli|
    on_client_connect(cli)
  }
  # self.listener.on_client_data_proc = Proc.new { |cli|
  #   on_client_data(cli)
  # }
  self.clients         = []
  self.monitor_thread  = Rex::ThreadFactory.spawn("SshServerClientMonitor", false) {
    monitor_clients
  }
  self.listener.start
end

#stop ⇒ Object

Terminates the monitor thread and turns off the listener.


109
110
111
112
113
 
# File 'lib/rex/proto/ssh/server.rb', line 109

def stop
  self.listener.stop
  self.listener.close
  self.clients = []
end

#wait ⇒ Object

Waits for the SSH service to terminate


119
120
121
 
# File 'lib/rex/proto/ssh/server.rb', line 119

def wait
  self.listener.wait if self.listener
end