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



101
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
 
# File 'lib/rex/socket/parameters.rb', line 101

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.



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

def bare
  @bare
end

#comm ⇒ Object

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



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

def comm
  @comm
end

#context ⇒ Object

The context hash that was passed in to the structure.



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

def context
  @context
end

#localhost ⇒ Object Also known as: localaddr

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



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

def localhost
  @localhost
end

#localport ⇒ Object

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



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

def localport
  @localport
end

#peerhost ⇒ Object Also known as: peeraddr

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



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

def peerhost
  @peerhost
end

#peerport ⇒ Object

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



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

def peerport
  @peerport
end

#proto ⇒ Object

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



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

def proto
  @proto
end

#proxies ⇒ Object

Returns the value of attribute proxies.



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

def proxies
  @proxies
end

#retries ⇒ Object

The number of attempts that should be made.



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

def retries
  @retries
end

#server ⇒ Object

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



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

def server
  @server
end

#ssl ⇒ Object

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



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

def ssl
  @ssl
end

#ssl_cert ⇒ Object

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



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

def ssl_cert
  @ssl_cert
end

#ssl_version ⇒ Object

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



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

def ssl_version
  @ssl_version
end

#timeout ⇒ Object

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



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

def timeout
  @timeout
end

#v6 ⇒ Object

Whether we should use IPv6



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

def v6
  @v6
end

Class Method Details

.from_hash(hash) ⇒ Object

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



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

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) 


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

def bare?
	return (bare == true)
end

#client? ⇒ Boolean

Returns true if this represents parameters for a client.

Returns:

  • (Boolean) 


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

def client?
	return (server == false)
end

#ip? ⇒ Boolean

Returns true if the protocol for the parameters is IP.

Returns:

  • (Boolean) 


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

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

#server? ⇒ Boolean

Returns true if this represents parameters for a server.

Returns:

  • (Boolean) 


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

def server?
	return (server == true)
end

#ssl? ⇒ Boolean

Returns true if SSL has been requested.

Returns:

  • (Boolean) 


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

def ssl?
	return ssl
end

#tcp? ⇒ Boolean

Returns true if the protocol for the parameters is TCP.

Returns:

  • (Boolean) 


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

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

#udp? ⇒ Boolean

Returns true if the protocol for the parameters is UDP.

Returns:

  • (Boolean) 


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

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

#v6? ⇒ Boolean

Returns true if IPv6 has been enabled

Returns:

  • (Boolean) 


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

def v6?
	return v6
end