Class: Rex::Socket::Parameters

Inherits:
Object
  • Object
show all
Defined in:
lib/rex/socket/parameters.rb

Overview

This class represents the set of parameters that are used to create a socket, whether it be a server or client socket.

Defined Under Namespace

Classes: UnitTest

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(hash) ⇒ Parameters

Initializes the attributes from the supplied hash. The following hash keys can be specified.

PeerHost / PeerAddr

The remote host to connect to.

PeerPort

The remote port to connect to.

LocalHost / LocalAddr

The local host to communicate from, if any.

LocalPort

The local port to communicate from, if any.

Bare

Create a bare socket.

Server

Whether or not this should be a server.

SSL

Whether or not SSL should be used.

SSLVersion

Specify SSL2, SSL3, or TLS1 (SSL3 is default)

SSLCert

A file containing an SSL certificate (for server sockets)

Proxies

List of proxies to use.

Proto

The underlying protocol to use.

IPv6

Force the use of IPv6.

Comm

The underlying Comm class to use to create the socket for this parameter set.

Context

A context hash that can allow users of this parameter class instance to determine who is responsible for requesting that a socket be created.

Retries

The number of times a connection should be retried.

Timeout

The number of seconds before a connection should time out



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/rex/socket/parameters.rb', line 102

def initialize(hash)
	if (hash['PeerHost'])
		self.peerhost = hash['PeerHost']
	elsif (hash['PeerAddr'])
		self.peerhost = hash['PeerAddr']
	else
		self.peerhost = nil
	end

	if (hash['LocalHost'])
		self.localhost = hash['LocalHost']
	elsif (hash['LocalAddr'])
		self.localhost = hash['LocalAddr']
	else
		self.localhost = '0.0.0.0'
	end

	if (hash['PeerPort'])
		self.peerport = hash['PeerPort'].to_i
	else
		self.peerport = 0
	end

	if (hash['LocalPort'])
		self.localport = hash['LocalPort'].to_i
	else
		self.localport = 0
	end

	if (hash['Bare'])
		self.bare = hash['Bare']
	else
		self.bare = false
	end

	if (hash['SSL'] and hash['SSL'].to_s =~ /^(t|y|1)/i)
		self.ssl = true
	else
		self.ssl = false
	end

	if (hash['SSLVersion'] and hash['SSLVersion'].to_s =~ /^(SSL2|SSL3|TLS1)$/i)
		self.ssl_version = hash['SSLVersion']
	end

	if (hash['SSLCert'] and ::File.file?(hash['SSLCert']))
		begin
			self.ssl_cert = ::File.read(hash['SSLCert'])
		rescue ::Exception => e
			elog("Failed to read cert: #{e.class}: #{e}", LogSource)
		end
	end

	if hash['Proxies']
		self.proxies = hash['Proxies'].split('-').map{|a| a.strip}.map{|a| a.split(':').map{|b| b.strip}}
	end

	# The protocol this socket will be using
	if (hash['Proto'])
		self.proto = hash['Proto'].downcase
	else
		self.proto = 'tcp'
	end

	# Whether or not the socket should be a server
	self.server    = hash['Server'] || false

	# The communication subsystem to use to create the socket
	self.comm      = hash['Comm']

	# The context that was passed in, if any.
	self.context   = hash['Context'] || {}

	# If no comm was supplied, try to use the comm that is best fit to
	# handle the provided host based on the current routing table.
	if( self.server )
		if (self.comm == nil and self.localhost)
			self.comm  = Rex::Socket::SwitchBoard.best_comm(self.localhost)
		end
	else
		if (self.comm == nil and self.peerhost)
			self.comm  = Rex::Socket::SwitchBoard.best_comm(self.peerhost)
		end
	end

	# If we still haven't found a comm, we default to the local comm.
	self.comm      = Rex::Socket::Comm::Local if (self.comm == nil)

	# If we are a UDP server, turn off the server flag as it was only set when
	# creating the UDP socket in order to avail of the switch board above.
	if( self.server and self.proto == 'udp' )
		self.server = false
	end

	# The number of connection retries to make (client only)
	if hash['Retries']
		self.retries = hash['Retries'].to_i
	else
		self.retries = 0
	end

	# The number of seconds before a connect attempt times out (client only)
	if hash['Timeout']
		self.timeout = hash['Timeout'].to_i
	else
		self.timeout = 5
	end

	# Whether to force IPv6 addressing
	self.v6        = hash['IPv6'] || false
end

Instance Attribute Details

#bare ⇒ Object

Whether or not this is a bare (non-extended) socket instance that should be created.



331
332
333
 
# File 'lib/rex/socket/parameters.rb', line 331

def bare
  @bare
end

#comm ⇒ Object

The Comm class that should be used to create the underlying socket.



314
315
316
 
# File 'lib/rex/socket/parameters.rb', line 314

def comm
  @comm
end

#context ⇒ Object

The context hash that was passed in to the structure.



318
319
320
 
# File 'lib/rex/socket/parameters.rb', line 318

def context
  @context
end

#localhost ⇒ Object Also known as: localaddr

The local host. Equivalent to the LocalHost parameter hash key.



296
297
298
 
# File 'lib/rex/socket/parameters.rb', line 296

def localhost
  @localhost
end

#localport ⇒ Object

The local port. Equivalent to the LocalPort parameter hash key.



300
301
302
 
# File 'lib/rex/socket/parameters.rb', line 300

def localport
  @localport
end

#peerhost ⇒ Object Also known as: peeraddr

The remote host information, equivalent to the PeerHost parameter hash key.



288
289
290
 
# File 'lib/rex/socket/parameters.rb', line 288

def peerhost
  @peerhost
end

#peerport ⇒ Object

The remote port. Equivalent to the PeerPort parameter hash key.



292
293
294
 
# File 'lib/rex/socket/parameters.rb', line 292

def peerport
  @peerport
end

#proto ⇒ Object

The protocol to to use, such as TCP. Equivalent to the Proto parameter hash key.



305
306
307
 
# File 'lib/rex/socket/parameters.rb', line 305

def proto
  @proto
end

#proxies ⇒ Object

Returns the value of attribute proxies.



350
351
352
 
# File 'lib/rex/socket/parameters.rb', line 350

def proxies
  @proxies
end

#retries ⇒ Object

The number of attempts that should be made.



322
323
324
 
# File 'lib/rex/socket/parameters.rb', line 322

def retries
  @retries
end

#server ⇒ Object

Whether or not this is a server. Equivalent to the Server parameter hash key.



310
311
312
 
# File 'lib/rex/socket/parameters.rb', line 310

def server
  @server
end

#ssl ⇒ Object

Whether or not SSL should be used to wrap the connection.



335
336
337
 
# File 'lib/rex/socket/parameters.rb', line 335

def ssl
  @ssl
end

#ssl_cert ⇒ Object

The SSL certificate, in pem format, stored as a string. See SslTcpServer#make_ssl



343
344
345
 
# File 'lib/rex/socket/parameters.rb', line 343

def ssl_cert
  @ssl_cert
end

#ssl_version ⇒ Object

What version of SSL to use (SSL2, SSL3, TLS1)



339
340
341
 
# File 'lib/rex/socket/parameters.rb', line 339

def ssl_version
  @ssl_version
end

#timeout ⇒ Object

The number of seconds before a connection attempt should time out.



326
327
328
 
# File 'lib/rex/socket/parameters.rb', line 326

def timeout
  @timeout
end

#v6 ⇒ Object

Whether we should use IPv6



347
348
349
 
# File 'lib/rex/socket/parameters.rb', line 347

def v6
  @v6
end

Class Method Details

.from_hash(hash) ⇒ Object

Creates an instance of the Parameters class using the supplied hash.



21
22
23
 
# File 'lib/rex/socket/parameters.rb', line 21

def self.from_hash(hash)
	return self.new(hash)
end

Instance Method Details

#bare? ⇒ Boolean

Returns true if the socket is a bare socket that does not inherit from any extended Rex classes.

Returns:

  • (Boolean) 


259
260
261
 
# File 'lib/rex/socket/parameters.rb', line 259

def bare?
	return (bare == true)
end

#client? ⇒ Boolean

Returns true if this represents parameters for a client.

Returns:

  • (Boolean) 


230
231
232
 
# File 'lib/rex/socket/parameters.rb', line 230

def client?
	return (server == false)
end

#ip? ⇒ Boolean

Returns true if the protocol for the parameters is IP.

Returns:

  • (Boolean) 


251
252
253
 
# File 'lib/rex/socket/parameters.rb', line 251

def ip?
	return (proto == 'ip')
end

#server? ⇒ Boolean

Returns true if this represents parameters for a server.

Returns:

  • (Boolean) 


223
224
225
 
# File 'lib/rex/socket/parameters.rb', line 223

def server?
	return (server == true)
end

#ssl? ⇒ Boolean

Returns true if SSL has been requested.

Returns:

  • (Boolean) 


266
267
268
 
# File 'lib/rex/socket/parameters.rb', line 266

def ssl?
	return ssl
end

#tcp? ⇒ Boolean

Returns true if the protocol for the parameters is TCP.

Returns:

  • (Boolean) 


237
238
239
 
# File 'lib/rex/socket/parameters.rb', line 237

def tcp?
	return (proto == 'tcp')
end

#udp? ⇒ Boolean

Returns true if the protocol for the parameters is UDP.

Returns:

  • (Boolean) 


244
245
246
 
# File 'lib/rex/socket/parameters.rb', line 244

def udp?
	return (proto == 'udp')
end

#v6? ⇒ Boolean

Returns true if IPv6 has been enabled

Returns:

  • (Boolean) 


273
274
275
 
# File 'lib/rex/socket/parameters.rb', line 273

def v6?
	return v6
end