Module: Rex::Socket
- Included in:
- Proto::DHCP::Server, Ip, Tcp, TcpServer, Udp
- Defined in:
- lib/rex/socket.rb,
lib/rex/socket/comm.rb,
lib/rex/socket/range_walker.rb,
lib/rex/socket/switch_board.rb,
lib/rex/socket/subnet_walker.rb
Overview
Base class for all sockets.
Defined Under Namespace
Modules: Comm, Ip, SslTcp, SslTcpServer, Tcp, TcpServer, Udp Classes: Parameters, Range, RangeWalker, SubnetWalker, SwitchBoard, UnitTest
Constant Summary collapse
- MATCH_IPV6 =
Common Regular Expressions
/^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/
- MATCH_IPV4 =
/^\s*(?:(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2}))\s*$/
- MATCH_IPV4_PRIVATE =
/^\s*(?:10\.|192\.168|172.(?:1[6-9]|2[0-9]|3[01])\.|169\.254)/
- @@support_ipv6 =
Cache our IPv6 support flag
nil
Instance Attribute Summary collapse
-
#context ⇒ Object
readonly
Contextual information that describes the source and other instance-specific attributes.
-
#ipv ⇒ Object
readonly
The IP version of the socket.
-
#localhost ⇒ Object
readonly
The local host of the connected socket.
-
#localport ⇒ Object
readonly
The local port of the connected socket.
-
#peerhost ⇒ Object
readonly
The peer host of the connected socket.
-
#peerport ⇒ Object
readonly
The peer port of the connected socket.
Class Method Summary collapse
-
.addr_atoc(mask) ⇒ Object
Converts an ASCII IP address to a CIDR mask.
-
.addr_atoi(addr) ⇒ Object
Converts a ascii address into an integer.
-
.addr_atoi_list(addr) ⇒ Object
Converts a ascii address into a list of addresses.
-
.addr_aton(addr) ⇒ Object
Converts a ascii address to network byte order.
-
.addr_ctoa(cidr) ⇒ Object
Resolves a CIDR bitmask into a dotted-quad.
-
.addr_itoa(addr, v6 = false) ⇒ Object
Converts an integer address into ascii.
-
.addr_iton(addr, v6 = false) ⇒ Object
Converts an integer into a network byte order address.
-
.addr_ntoa(addr) ⇒ Object
Converts a network byte order address to ascii.
-
.addr_ntoi(addr) ⇒ Object
Converts a network byte order address to an integer.
-
.bit2netmask(bitmask, ipv6 = false) ⇒ Object
Converts a bitmask (28) into a netmask (255.255.255.240).
-
.cidr_crack(cidr, v6 = false) ⇒ Object
Converts a CIDR subnet into an array (base, bcast).
-
.compress_address(addr) ⇒ Object
Implement zero compression for IPv6 addresses.
-
.create(opts = {}) ⇒ Object
Create a socket instance using the supplied parameter hash.
-
.create_ip(opts = {}) ⇒ Object
Create a IP socket using the supplied parameter hash.
-
.create_param(param) ⇒ Object
Create a socket using the supplied Rex::Socket::Parameter instance.
-
.create_tcp(opts = {}) ⇒ Object
Create a TCP socket using the supplied parameter hash.
-
.create_tcp_server(opts = {}) ⇒ Object
Create a TCP server socket using the supplied parameter hash.
-
.create_udp(opts = {}) ⇒ Object
Create a UDP socket using the supplied parameter hash.
-
.dotted_ip?(addr) ⇒ Boolean
Checks to see if the supplied address is in “dotted” form.
-
.from_sockaddr(saddr) ⇒ Object
Returns the address family, host, and port of the supplied sockaddr as [ af, host, port ].
-
.getaddress(addr, accept_ipv6 = true) ⇒ Object
Wrapper for Resolv.getaddress that takes special care to see if the supplied address is already a dotted quad, for instance.
-
.getaddresses(addr, accept_ipv6 = true) ⇒ Object
Wrapper for Resolv.getaddress that takes special care to see if the supplied address is already a dotted quad, for instance.
-
.gethostbyname(host) ⇒ Object
Wrapper for Socket.gethostbyname which takes into account whether or not an IP address is supplied.
-
.ipv6_link_address(intf) ⇒ Object
Identifies the link-local address of a given interface (if IPv6 is enabled).
-
.ipv6_mac(intf) ⇒ Object
Identifies the mac address of a given interface (if IPv6 is enabled).
-
.is_internal?(addr) ⇒ Boolean
Return true if
addr
is within the ranges specified in RFC1918, or RFC5735/RFC3927. -
.is_ipv4?(addr) ⇒ Boolean
Determine whether this is an IPv4 address.
-
.is_ipv6?(addr) ⇒ Boolean
Determine whether this is an IPv6 address.
-
.net2bitmask(netmask) ⇒ Object
Converts a netmask (255.255.255.240) into a bitmask (28).
-
.portlist_to_portspec(parr) ⇒ Object
Converts a port list like [1,2,3,4,5,100] into a range specification like “1-5,100”.
- .portspec_crack(pspec) ⇒ Object
-
.portspec_to_portlist(pspec) ⇒ Object
Converts a port specification like “80,21-23,443” into a sorted, unique array of valid port numbers like [21,22,23,80,443].
-
.resolv_nbo(host) ⇒ Object
Resolves a host to raw network-byte order.
-
.resolv_nbo_i(host) ⇒ Object
Resolves a host to a network-byte order ruby integer.
-
.resolv_nbo_i_list(host) ⇒ Object
Resolves a host to a list of network-byte order ruby integers.
-
.resolv_nbo_list(host) ⇒ Object
Resolves a host to raw network-byte order.
-
.resolv_to_dotted(host) ⇒ Object
Resolves a host to a dotted address.
-
.source_address(dest = '8.8.8.8', comm = ::Rex::Socket::Comm::Local) ⇒ Object
This method does NOT send any traffic to the destination, instead, it uses a “bound” UDP socket to determine what source address we would use to communicate with the specified destination.
-
.support_ipv6? ⇒ Boolean
Determine whether we support IPv6.
-
.tcp_socket_pair ⇒ Object
Create a TCP socket pair.
-
.to_sockaddr(ip, port) ⇒ Object
Create a sockaddr structure using the supplied IP address, port, and address family.
-
.udp_socket_pair ⇒ Object
Create a UDP socket pair using native ruby UDP sockets.
Instance Method Summary collapse
-
#fd ⇒ Object
By default, all sockets are themselves selectable file descriptors.
-
#getlocalname ⇒ Object
Wrapper around getsockname.
-
#getpeername ⇒ Object
Return peer connection information.
-
#getsockname ⇒ Object
Returns local connection information.
-
#initsock(params = nil) ⇒ Object
Initialize general socket parameters.
-
#type? ⇒ Boolean
Returns a string that indicates the type of the socket, such as ‘tcp’.
Instance Attribute Details
#context ⇒ Object
Contextual information that describes the source and other instance-specific attributes. This comes from the param.context attribute.
775 776 777 |
# File 'lib/rex/socket.rb', line 775 def context @context end |
#ipv ⇒ Object
The IP version of the socket
769 770 771 |
# File 'lib/rex/socket.rb', line 769 def ipv @ipv end |
#localhost ⇒ Object
The local host of the connected socket.
761 762 763 |
# File 'lib/rex/socket.rb', line 761 def localhost @localhost end |
#localport ⇒ Object
The local port of the connected socket.
765 766 767 |
# File 'lib/rex/socket.rb', line 765 def localport @localport end |
#peerhost ⇒ Object
The peer host of the connected socket.
753 754 755 |
# File 'lib/rex/socket.rb', line 753 def peerhost @peerhost end |
#peerport ⇒ Object
The peer port of the connected socket.
757 758 759 |
# File 'lib/rex/socket.rb', line 757 def peerport @peerport end |
Class Method Details
.addr_atoc(mask) ⇒ Object
Converts an ASCII IP address to a CIDR mask. Returns nil if it’s not convertable.
319 320 321 322 323 324 325 326 327 328 329 |
# File 'lib/rex/socket.rb', line 319 def self.addr_atoc(mask) mask_i = resolv_nbo_i(mask) cidr = nil 0.upto(32) do |i| if ((1 << i)-1) << (32-i) == mask_i cidr = i break end end return cidr end |
.addr_atoi(addr) ⇒ Object
Converts a ascii address into an integer
350 351 352 |
# File 'lib/rex/socket.rb', line 350 def self.addr_atoi(addr) resolv_nbo_i(addr) end |
.addr_atoi_list(addr) ⇒ Object
Converts a ascii address into a list of addresses
357 358 359 |
# File 'lib/rex/socket.rb', line 357 def self.addr_atoi_list(addr) resolv_nbo_i_list(addr) end |
.addr_aton(addr) ⇒ Object
Converts a ascii address to network byte order
380 381 382 |
# File 'lib/rex/socket.rb', line 380 def self.addr_aton(addr) resolv_nbo(addr) end |
.addr_ctoa(cidr) ⇒ Object
Resolves a CIDR bitmask into a dotted-quad. Returns nil if it’s not convertable.
335 336 337 338 |
# File 'lib/rex/socket.rb', line 335 def self.addr_ctoa(cidr) return nil unless (0..32) === cidr.to_i addr_itoa(((1 << cidr)-1) << 32-cidr) end |
.addr_itoa(addr, v6 = false) ⇒ Object
Converts an integer address into ascii
364 365 366 367 368 369 370 371 372 373 374 375 |
# File 'lib/rex/socket.rb', line 364 def self.addr_itoa(addr, v6=false) nboa = addr_iton(addr, v6) # IPv4 if (addr < 0x100000000 and not v6) addr_ntoa(nboa) # IPv6 else addr_ntoa(nboa) end end |
.addr_iton(addr, v6 = false) ⇒ Object
Converts an integer into a network byte order address
445 446 447 448 449 450 451 452 453 454 455 456 |
# File 'lib/rex/socket.rb', line 445 def self.addr_iton(addr, v6=false) if(addr < 0x100000000 and not v6) return [addr].pack('N') else w = [] w[0] = (addr >> 96) & 0xffffffff w[1] = (addr >> 64) & 0xffffffff w[2] = (addr >> 32) & 0xffffffff w[3] = addr & 0xffffffff return w.pack('N4') end end |
.addr_ntoa(addr) ⇒ Object
Converts a network byte order address to ascii
387 388 389 390 391 392 393 394 395 396 397 398 399 |
# File 'lib/rex/socket.rb', line 387 def self.addr_ntoa(addr) # IPv4 if (addr.length == 4) return addr.unpack('C4').join('.') end # IPv6 if (addr.length == 16) return compress_address(addr.unpack('n8').map{ |c| "%x" % c }.join(":")) end raise RuntimeError, "Invalid address format" end |
.addr_ntoi(addr) ⇒ Object
Converts a network byte order address to an integer
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 |
# File 'lib/rex/socket.rb', line 425 def self.addr_ntoi(addr) bits = addr.unpack("N*") if (bits.length == 1) return bits[0] end if (bits.length == 4) val = 0 bits.each_index { |i| val += ( bits[i] << (96 - (i * 32)) ) } return val end raise RuntimeError, "Invalid address format" end |
.bit2netmask(bitmask, ipv6 = false) ⇒ Object
Converts a bitmask (28) into a netmask (255.255.255.240)
511 512 513 514 515 516 517 518 519 |
# File 'lib/rex/socket.rb', line 511 def self.bit2netmask(bitmask, ipv6=false) if bitmask > 32 or ipv6 i = ((~((2 ** (128 - bitmask)) - 1)) & (2**128-1)) n = Rex::Socket.addr_iton(i, true) return Rex::Socket.addr_ntoa(n) else [ (~((2 ** (32 - bitmask)) - 1)) & 0xffffffff ].pack('N').unpack('CCCC').join('.') end end |
.cidr_crack(cidr, v6 = false) ⇒ Object
Converts a CIDR subnet into an array (base, bcast)
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 |
# File 'lib/rex/socket.rb', line 461 def self.cidr_crack(cidr, v6=false) tmp = cidr.split('/') tst,scope = tmp[0].split("%",2) scope = "%" + scope if scope scope ||= "" addr = addr_atoi(tst) bits = 32 mask = 0 use6 = false if (addr > 0xffffffff or v6 or cidr =~ /:/) use6 = true bits = 128 end mask = (2 ** bits) - (2 ** (bits - tmp[1].to_i)) base = addr & mask stop = base + (2 ** (bits - tmp[1].to_i)) - 1 return [self.addr_itoa(base, use6) + scope, self.addr_itoa(stop, use6) + scope] end |
.compress_address(addr) ⇒ Object
Implement zero compression for IPv6 addresses. Uses the compression method from Marco Ceresa’s IPAddress GEM github.com/bluemonk/ipaddress/blob/master/lib/ipaddress/ipv6.rb
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 |
# File 'lib/rex/socket.rb', line 406 def self.compress_address(addr) return addr unless is_ipv6?(addr) addr = addr.dup while true break if addr.sub!(/\A0:0:0:0:0:0:0:0\Z/, '::') break if addr.sub!(/\b0:0:0:0:0:0:0\b/, ':') break if addr.sub!(/\b0:0:0:0:0:0\b/, ':') break if addr.sub!(/\b0:0:0:0:0\b/, ':') break if addr.sub!(/\b0:0:0:0\b/, ':') break if addr.sub!(/\b0:0:0\b/, ':') break if addr.sub!(/\b0:0\b/, ':') break end addr.sub(/:{3,}/, '::') end |
.create(opts = {}) ⇒ Object
Create a socket instance using the supplied parameter hash.
39 40 41 |
# File 'lib/rex/socket.rb', line 39 def self.create(opts = {}) return create_param(Rex::Socket::Parameters.from_hash(opts)) end |
.create_ip(opts = {}) ⇒ Object
Create a IP socket using the supplied parameter hash.
74 75 76 |
# File 'lib/rex/socket.rb', line 74 def self.create_ip(opts = {}) return create_param(Rex::Socket::Parameters.from_hash(opts.merge('Proto' => 'ip'))) end |
.create_param(param) ⇒ Object
Create a socket using the supplied Rex::Socket::Parameter instance.
46 47 48 |
# File 'lib/rex/socket.rb', line 46 def self.create_param(param) return param.comm.create(param) end |
.create_tcp(opts = {}) ⇒ Object
Create a TCP socket using the supplied parameter hash.
53 54 55 |
# File 'lib/rex/socket.rb', line 53 def self.create_tcp(opts = {}) return create_param(Rex::Socket::Parameters.from_hash(opts.merge('Proto' => 'tcp'))) end |
.create_tcp_server(opts = {}) ⇒ Object
Create a TCP server socket using the supplied parameter hash.
60 61 62 |
# File 'lib/rex/socket.rb', line 60 def self.create_tcp_server(opts = {}) return create_tcp(opts.merge('Server' => true)) end |
.create_udp(opts = {}) ⇒ Object
Create a UDP socket using the supplied parameter hash.
67 68 69 |
# File 'lib/rex/socket.rb', line 67 def self.create_udp(opts = {}) return create_param(Rex::Socket::Parameters.from_hash(opts.merge('Proto' => 'udp'))) end |
.dotted_ip?(addr) ⇒ Boolean
Checks to see if the supplied address is in “dotted” form
136 137 138 139 140 141 142 143 144 |
# File 'lib/rex/socket.rb', line 136 def self.dotted_ip?(addr) # Match IPv6 return true if (support_ipv6? and addr =~ MATCH_IPV6) # Match IPv4 return true if (addr =~ MATCH_IPV4) false end |
.from_sockaddr(saddr) ⇒ Object
Returns the address family, host, and port of the supplied sockaddr as
- af, host, port
278 279 280 281 282 283 284 285 |
# File 'lib/rex/socket.rb', line 278 def self.from_sockaddr(saddr) port, host = ::Socket::unpack_sockaddr_in(saddr) af = ::Socket::AF_INET if (support_ipv6?() and is_ipv6?(host)) af = ::Socket::AF_INET6 end return [ af, host, port ] end |
.getaddress(addr, accept_ipv6 = true) ⇒ Object
Wrapper for Resolv.getaddress that takes special care to see if the supplied address is already a dotted quad, for instance. This is necessary to prevent calls to gethostbyaddr (which occurs on windows). These calls can be quite slow. This also fixes an issue with the Resolv.getaddress() call being non-functional on Ruby 1.9.1 (Win32).
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 |
# File 'lib/rex/socket.rb', line 165 def self.getaddress(addr, accept_ipv6 = true) begin if addr =~ MATCH_IPV4 or (accept_ipv6 and addr =~ MATCH_IPV6) return addr end res = ::Socket.gethostbyname(addr) return nil if not res # Shift the first three elements out rname = res.shift ralias = res.shift rtype = res.shift # Rubinius has a bug where gethostbyname returns dotted quads instead of # NBO, but that's what we want anyway, so just short-circuit here. if res[0] =~ MATCH_IPV4 || res[0] =~ MATCH_IPV6 res.each { |r| # if the caller doesn't mind ipv6, just return whatever we have return r if accept_ipv6 # otherwise, take the first v4 address return r if r =~ MATCH_IPV4 } # didn't find one return nil end # Reject IPv6 addresses if we don't accept them if not accept_ipv6 res.reject!{|nbo| nbo.length != 4} end # Make sure we have at least one name return nil if res.length == 0 # Return the first address of the result self.addr_ntoa( res[0] ) rescue ::ArgumentError # Win32 bug nil end end |
.getaddresses(addr, accept_ipv6 = true) ⇒ Object
Wrapper for Resolv.getaddress that takes special care to see if the supplied address is already a dotted quad, for instance. This is necessary to prevent calls to gethostbyaddr (which occurs on windows). These calls can be quite slow. This also fixes an issue with the Resolv.getaddress() call being non-functional on Ruby 1.9.1 (Win32).
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 |
# File 'lib/rex/socket.rb', line 214 def self.getaddresses(addr, accept_ipv6 = true) begin if addr =~ MATCH_IPV4 or (accept_ipv6 and addr =~ MATCH_IPV6) return [addr] end res = ::Socket.gethostbyname(addr) return [] if not res # Shift the first three elements out rname = res.shift ralias = res.shift rtype = res.shift # Reject IPv6 addresses if we don't accept them if not accept_ipv6 res.reject!{|nbo| nbo.length != 4} end # Make sure we have at least one name return [] if res.length == 0 # Return an array of all addresses res.map{ |addr| self.addr_ntoa(addr) } rescue ::ArgumentError # Win32 bug [] end end |
.gethostbyname(host) ⇒ Object
Wrapper for Socket.gethostbyname which takes into account whether or not an IP address is supplied. If it is, then reverse DNS resolution does not occur. This is done in order to prevent delays, such as would occur on Windows.
249 250 251 252 253 254 255 256 257 258 259 |
# File 'lib/rex/socket.rb', line 249 def self.gethostbyname(host) if (is_ipv4?(host)) return [ host, [], 2, host.split('.').map{ |c| c.to_i }.pack("C4") ] end if is_ipv6?(host) host, scope_id = host.split('%', 2) end ::Socket.gethostbyname(host) end |
.ipv6_link_address(intf) ⇒ Object
Identifies the link-local address of a given interface (if IPv6 is enabled)
613 614 615 616 617 |
# File 'lib/rex/socket.rb', line 613 def self.ipv6_link_address(intf) r = source_address("FF02::1%#{intf}") return if not (r and r =~ /^fe80/i) r end |
.ipv6_mac(intf) ⇒ Object
Identifies the mac address of a given interface (if IPv6 is enabled)
622 623 624 625 626 627 |
# File 'lib/rex/socket.rb', line 622 def self.ipv6_mac(intf) r = ipv6_link_address(intf) return if not r raw = addr_aton(r)[-8, 8] (raw[0,3] + raw[5,3]).unpack("C*").map{|c| "%.2x" % c}.join(":") end |
.is_internal?(addr) ⇒ Boolean
Return true if addr
is within the ranges specified in RFC1918, or RFC5735/RFC3927
150 151 152 153 154 155 156 |
# File 'lib/rex/socket.rb', line 150 def self.is_internal?(addr) if self.dotted_ip?(addr) addr =~ MATCH_IPV4_PRIVATE else false end end |
.is_ipv4?(addr) ⇒ Boolean
Determine whether this is an IPv4 address
122 123 124 |
# File 'lib/rex/socket.rb', line 122 def self.is_ipv4?(addr) ( addr =~ MATCH_IPV4 ) ? true : false end |
.is_ipv6?(addr) ⇒ Boolean
Determine whether this is an IPv6 address
129 130 131 |
# File 'lib/rex/socket.rb', line 129 def self.is_ipv6?(addr) ( addr =~ MATCH_IPV6 ) ? true : false end |
.net2bitmask(netmask) ⇒ Object
Converts a netmask (255.255.255.240) into a bitmask (28). This is the lame kid way of doing it.
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 |
# File 'lib/rex/socket.rb', line 490 def self.net2bitmask(netmask) nmask = resolv_nbo(netmask) imask = addr_ntoi(nmask) bits = 32 if (imask > 0xffffffff) bits = 128 end 0.upto(bits-1) do |bit| p = 2 ** bit return (bits - bit) if ((imask & p) == p) end 0 end |
.portlist_to_portspec(parr) ⇒ Object
Converts a port list like [1,2,3,4,5,100] into a range specification like “1-5,100”
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 |
# File 'lib/rex/socket.rb', line 553 def self.portlist_to_portspec(parr) ranges = [] range = [] lastp = nil parr.uniq.sort{|a,b| a<=>b}.map{|a| a.to_i}.each do |n| next if (n < 1 or n > 65535) if not lastp range = [n] lastp = n next end if lastp == n - 1 range << n else ranges << range range = [n] end lastp = n end ranges << range ranges.delete(nil) ranges.uniq.map{|x| x.length == 1 ? "#{x[0]}" : "#{x[0]}-#{x[-1]}"}.join(",") end |
.portspec_crack(pspec) ⇒ Object
522 523 524 |
# File 'lib/rex/socket.rb', line 522 def self.portspec_crack(pspec) portspec_to_portlist(pspec) end |
.portspec_to_portlist(pspec) ⇒ Object
Converts a port specification like “80,21-23,443” into a sorted, unique array of valid port numbers like [21,22,23,80,443]
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 |
# File 'lib/rex/socket.rb', line 530 def self.portspec_to_portlist(pspec) ports = [] # Build ports array from port specification pspec.split(/,/).each do |item| start, stop = item.split(/-/).map { |p| p.to_i } start ||= 0 stop ||= item.match(/-/) ? 65535 : start start, stop = stop, start if stop < start start.upto(stop) { |p| ports << p } end # Sort, and remove dups and invalid ports ports.sort.uniq.delete_if { |p| p < 1 or p > 65535 } end |
.resolv_nbo(host) ⇒ Object
Resolves a host to raw network-byte order.
290 291 292 |
# File 'lib/rex/socket.rb', line 290 def self.resolv_nbo(host) self.gethostbyname( Rex::Socket.getaddress(host, true) )[3] end |
.resolv_nbo_i(host) ⇒ Object
Resolves a host to a network-byte order ruby integer.
304 305 306 |
# File 'lib/rex/socket.rb', line 304 def self.resolv_nbo_i(host) addr_ntoi(resolv_nbo(host)) end |
.resolv_nbo_i_list(host) ⇒ Object
Resolves a host to a list of network-byte order ruby integers.
311 312 313 |
# File 'lib/rex/socket.rb', line 311 def self.resolv_nbo_i_list(host) resolv_nbo_list(host).map{|addr| addr_ntoi(addr) } end |
.resolv_nbo_list(host) ⇒ Object
Resolves a host to raw network-byte order.
297 298 299 |
# File 'lib/rex/socket.rb', line 297 def self.resolv_nbo_list(host) Rex::Socket.getaddresses(host).map{|addr| self.gethostbyname(addr)[3] } end |
.resolv_to_dotted(host) ⇒ Object
Resolves a host to a dotted address.
343 344 345 |
# File 'lib/rex/socket.rb', line 343 def self.resolv_to_dotted(host) addr_ntoa(addr_aton(host)) end |
.source_address(dest = '8.8.8.8', comm = ::Rex::Socket::Comm::Local) ⇒ Object
This method does NOT send any traffic to the destination, instead, it uses a “bound” UDP socket to determine what source address we would use to communicate with the specified destination. The destination defaults to Google’s DNS server to make the standard behavior determine which IP we would use to communicate with the internet.
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 |
# File 'lib/rex/socket.rb', line 593 def self.source_address(dest='8.8.8.8', comm = ::Rex::Socket::Comm::Local) begin s = self.create_udp( 'PeerHost' => dest, 'PeerPort' => 31337, 'Comm' => comm ) r = s.getsockname[1] s.close # Trim off the trailing interface ID for link-local IPv6 return r.split('%').first rescue ::Exception return '127.0.0.1' end end |
.support_ipv6? ⇒ Boolean
Determine whether we support IPv6
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
# File 'lib/rex/socket.rb', line 102 def self.support_ipv6? return @@support_ipv6 if not @@support_ipv6.nil? @@support_ipv6 = false if (::Socket.const_defined?('AF_INET6')) begin s = ::Socket.new(::Socket::AF_INET6, ::Socket::SOCK_DGRAM, ::Socket::IPPROTO_UDP) s.close @@support_ipv6 = true rescue end end return @@support_ipv6 end |
.tcp_socket_pair ⇒ Object
Create a TCP socket pair.
sf: This create a socket pair using native ruby sockets and will work on Windows where ::Socket.pair is not implemented. Note: OpenSSL requires native ruby sockets for its io.
Note: Even though sub-threads are smashing the parent threads local, there
is no concurrent use of the same locals and this is safe.
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 |
# File 'lib/rex/socket.rb', line 638 def self.tcp_socket_pair lsock = nil rsock = nil laddr = '127.0.0.1' lport = 0 threads = [] mutex = ::Mutex.new threads << Rex::ThreadFactory.spawn('TcpSocketPair', false) { server = nil mutex.synchronize { threads << Rex::ThreadFactory.spawn('TcpSocketPairClient', false) { mutex.synchronize { rsock = ::TCPSocket.new( laddr, lport ) } } server = ::TCPServer.new(laddr, 0) if (server.getsockname =~ /127\.0\.0\.1:/) # JRuby ridiculousness caddr, lport = server.getsockname.split(":") caddr = caddr[1,caddr.length] lport = lport.to_i else # Sane implementations where Socket#getsockname returns a # sockaddr lport, caddr = ::Socket.unpack_sockaddr_in( server.getsockname ) end } lsock, saddr = server.accept server.close } threads.each { |t| t.join } return [lsock, rsock] end |
.to_sockaddr(ip, port) ⇒ Object
Create a sockaddr structure using the supplied IP address, port, and address family
265 266 267 268 269 270 271 272 |
# File 'lib/rex/socket.rb', line 265 def self.to_sockaddr(ip, port) if (ip == '::ffff:0.0.0.0') ip = support_ipv6?() ? '::' : '0.0.0.0' end return ::Socket.pack_sockaddr_in(port, ip) end |
.udp_socket_pair ⇒ Object
Create a UDP socket pair using native ruby UDP sockets.
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 |
# File 'lib/rex/socket.rb', line 678 def self.udp_socket_pair laddr = '127.0.0.1' lsock = ::UDPSocket.new lsock.bind( laddr, 0 ) rsock = ::UDPSocket.new rsock.bind( laddr, 0 ) rsock.connect( *lsock.addr.values_at(3,1) ) lsock.connect( *rsock.addr.values_at(3,1) ) return [lsock, rsock] end |
Instance Method Details
#fd ⇒ Object
By default, all sockets are themselves selectable file descriptors.
718 719 720 |
# File 'lib/rex/socket.rb', line 718 def fd self end |
#getlocalname ⇒ Object
Wrapper around getsockname
732 733 734 |
# File 'lib/rex/socket.rb', line 732 def getlocalname getsockname end |
#getpeername ⇒ Object
Return peer connection information.
739 740 741 |
# File 'lib/rex/socket.rb', line 739 def getpeername return Socket.from_sockaddr(super) end |
#getsockname ⇒ Object
Returns local connection information.
725 726 727 |
# File 'lib/rex/socket.rb', line 725 def getsockname Socket.from_sockaddr(super) end |
#initsock(params = nil) ⇒ Object
Initialize general socket parameters.
704 705 706 707 708 709 710 711 712 713 |
# File 'lib/rex/socket.rb', line 704 def initsock(params = nil) if (params) self.peerhost = params.peerhost self.peerport = params.peerport self.localhost = params.localhost self.localport = params.localport self.context = params.context || {} self.ipv = params.v6 ? 6 : 4 end end |
#type? ⇒ Boolean
Returns a string that indicates the type of the socket, such as ‘tcp’.
746 747 748 |
# File 'lib/rex/socket.rb', line 746 def type? raise NotImplementedError, "Socket type is not supported." end |