dstruct 0.0.1

data/lib/rex/proto/http/server.rb

@@ -0,0 +1,385 @@
+# -*- coding: binary -*-
+require 'rex/socket'
+require 'rex/proto/http'
+require 'rex/proto/http/handler'
+
+module Rex
+module Proto
+module Http
+
+###
+#
+# Runtime extension of the HTTP clients that connect to the server.
+#
+###
+module ServerClient
+
+  #
+  # Initialize a new request instance.
+  #
+  def init_cli(server)
+    self.request   = Request.new
+    self.server    = server
+    self.keepalive = false
+  end
+
+  #
+  # Resets the parsing state.
+  #
+  def reset_cli
+    self.request.reset
+  end
+
+  #
+  # Transmits a response and adds the appropriate headers.
+  #
+  def send_response(response)
+    # Set the connection to close or keep-alive depending on what the client
+    # can support.
+    response['Connection'] = (keepalive) ? 'Keep-Alive' : 'close'
+
+    # Add any other standard response headers.
+    server.add_response_headers(response)
+
+    # Send it off.
+    put(response.to_s)
+  end
+
+  #
+  # The current request context.
+  #
+  attr_accessor :request
+  #
+  # Boolean that indicates whether or not the connection supports keep-alive.
+  #
+  attr_accessor :keepalive
+  #
+  # A reference to the server the client is associated with.
+  #
+  attr_accessor :server
+
+end
+
+###
+#
+# Acts as an HTTP server, processing requests and dispatching them to
+# registered procs.  Some of this server was modeled after webrick.
+#
+###
+class Server
+
+  include Proto
+
+  #
+  # A hash that associated a file extension with a mime type for use as the
+  # content type of responses.
+  #
+  ExtensionMimeTypes =
+    {
+      "rhtml" => "text/html",
+      "html"  => "text/html",
+      "htm"   => "text/htm",
+      "jpg"   => "image/jpeg",
+      "jpeg"  => "image/jpeg",
+      "jpeg"  => "image/jpeg",
+      "gif"   => "image/gif",
+      "png"   => "image/png",
+      "bmp"   => "image/bmp",
+      "txt"   => "text/plain",
+      "css"   => "text/css",
+      "ico"   => "image/x-icon",
+    }
+
+  #
+  # The default server name that will be returned in the Server attribute of
+  # a response.
+  #
+  DefaultServer = "Rex"
+
+  #
+  # Initializes an HTTP server as listening on the provided port and
+  # hostname.
+  #
+  def initialize(port = 80, listen_host = '0.0.0.0', ssl = false, context = {}, comm = nil, ssl_cert = nil, ssl_compression = false)
+    self.listen_host     = listen_host
+    self.listen_port     = port
+    self.ssl             = ssl
+    self.context         = context
+    self.comm            = comm
+    self.ssl_cert        = ssl_cert
+    self.ssl_compression = ssl_compression
+    self.listener        = nil
+    self.resources       = {}
+    self.server_name     = DefaultServer
+  end
+
+  # More readable inspect that only shows the url and resources
+  # @return [String]
+  def inspect
+    resources_str = resources.keys.map{|r| r.inspect }.join ", "
+
+    "#<#{self.class} http#{ssl ? "s" : ""}://#{listen_host}:#{listen_port} [ #{resources_str} ]>"
+  end
+
+  #
+  # Returns the hardcore alias for the HTTP service
+  #
+  def self.hardcore_alias(*args)
+    "#{(args[0] || '')}#{(args[1] || '')}"
+  end
+
+  #
+  # HTTP server.
+  #
+  def alias
+    super || "HTTP Server"
+  end
+
+  #
+  # Listens on the defined port and host and starts monitoring for clients.
+  #
+  def start
+
+    self.listener = Rex::Socket::TcpServer.create(
+      'LocalHost' => self.listen_host,
+      'LocalPort' => self.listen_port,
+      'Context'   => self.context,
+      'SSL'		=> self.ssl,
+      'SSLCert'	=> self.ssl_cert,
+      'SSLCompression' => self.ssl_compression,
+      '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.listener.start
+  end
+
+  #
+  # Terminates the monitor thread and turns off the listener.
+  #
+  def stop
+    self.listener.stop
+    self.listener.close
+  end
+
+
+  #
+  # Waits for the HTTP service to terminate
+  #
+  def wait
+    self.listener.wait if self.listener
+  end
+
+  #
+  # Closes the supplied client, if valid.
+  #
+  def close_client(cli)
+    listener.close_client(cli)
+  end
+
+  #
+  # Mounts a directory or resource as being serviced by the supplied handler.
+  #
+  def mount(root, handler, long_call = false, *args)
+    resources[root] = [ handler, long_call, args ]
+  end
+
+  #
+  # Remove the mount point.
+  #
+  def unmount(root)
+    resources.delete(root)
+  end
+
+  #
+  # Adds a resource handler, such as one for /, which will be called whenever
+  # the resource is requested.  The ``opts'' parameter can have any of the
+  # following:
+  #
+  # Proc      (proc) - The procedure to call when a request comes in for this resource.
+  # LongCall  (bool) - Hints to the server that this resource may have long
+  #                    request processing times.
+  #
+  def add_resource(name, opts)
+    if (resources[name])
+      raise RuntimeError,
+        "The supplied resource '#{name}' is already added.", caller
+    end
+
+    # If a procedure was passed, mount the resource with it.
+    if (opts['Proc'])
+      mount(name, Handler::Proc, false, opts['Proc'], opts['VirtualDirectory'])
+    else
+      raise ArgumentError, "You must specify a procedure."
+    end
+  end
+
+  #
+  # Removes the supplied resource handler.
+  #
+  def remove_resource(name)
+    self.resources.delete(name)
+  end
+
+  #
+  # Adds Server headers and stuff.
+  #
+  def add_response_headers(resp)
+    resp['Server'] = self.server_name if not resp['Server']
+  end
+
+  #
+  # Returns the mime type associated with the supplied file.  Right now the
+  # set of mime types is fairly limited.
+  #
+  def mime_type(file)
+    type = nil
+
+    if (file =~ /\.(.+?)$/)
+      type = ExtensionMimeTypes[$1.downcase]
+    end
+
+    type || "text/plain"
+  end
+
+  #
+  # Sends a 404 error to the client for a given request.
+  #
+  def send_e404(cli, request)
+    resp = Response::E404.new
+
+    resp['Content-Type'] = 'text/html'
+
+    resp.body =
+      "<html><head>" +
+      "<title>404 Not Found</title>" +
+      "</head><body>" +
+      "<h1>Not found</h1>" +
+      "The requested URL #{html_escape(request.resource)} was not found on this server.<p><hr>" +
+      "</body></html>"
+
+    # Send the response to the client like what
+    cli.send_response(resp)
+  end
+
+  attr_accessor :listen_port, :listen_host, :server_name, :context, :comm
+  attr_accessor :ssl, :ssl_cert, :ssl_compression
+  attr_accessor :listener, :resources
+
+protected
+
+  #
+  # Extends new clients with the ServerClient module and initializes them.
+  #
+  def on_client_connect(cli)
+    cli.extend(ServerClient)
+
+    cli.init_cli(self)
+  end
+
+  #
+  # Processes data coming in from a client.
+  #
+  def on_client_data(cli)
+    begin
+      data = cli.read(65535)
+
+      raise ::EOFError if not data
+      raise ::EOFError if data.empty?
+
+      case cli.request.parse(data)
+        when Packet::ParseCode::Completed
+          dispatch_request(cli, cli.request)
+          cli.reset_cli
+
+        when Packet::ParseCode::Partial
+          # Return and wait for the on_client_data handler to be called again
+          # The Request object tracks the state of the request for us
+          return
+
+        when Packet::ParseCode::Error
+          close_client(cli)
+      end
+    rescue EOFError
+      if (cli.request.completed?)
+        dispatch_request(cli, cli.request)
+
+        cli.reset_cli
+      end
+
+      close_client(cli)
+    end
+  end
+
+  #
+  # Dispatches the supplied request for a given connection.
+  #
+  def dispatch_request(cli, request)
+    # Is the client requesting keep-alive?
+    if ((request['Connection']) and
+       (request['Connection'].downcase == 'Keep-Alive'.downcase))
+      cli.keepalive = true
+    end
+
+    # Search for the resource handler for the requested URL.  This is pretty
+    # inefficient right now, but we can spruce it up later.
+    p    = nil
+    len  = 0
+    root = nil
+
+    resources.each_pair { |k, val|
+      if (request.resource =~ /^#{k}/ and k.length > len)
+        p    = val
+        len  = k.length
+        root = k
+      end
+    }
+
+    if (p)
+      # Create an instance of the handler for this resource
+      handler = p[0].new(self, *p[2])
+
+      # If the handler class requires a relative resource...
+      if (handler.relative_resource_required?)
+        # Substituted the mount point root in the request to make things
+        # relative to the mount point.
+        request.relative_resource = request.resource.gsub(/^#{root}/, '')
+        request.relative_resource = '/' + request.relative_resource if (request.relative_resource !~ /^\//)
+      end
+
+
+      # If we found the resource handler for this resource, call its
+      # procedure.
+      if (p[1] == true)
+        Rex::ThreadFactory.spawn("HTTPServerRequestHandler", false) {
+          handler.on_request(cli, request)
+        }
+      else
+        handler.on_request(cli, request)
+      end
+    else
+      elog("Failed to find handler for resource: #{request.resource}",
+        LogSource)
+
+      send_e404(cli, request)
+    end
+
+    # If keep-alive isn't enabled for this client, close the connection
+    if (cli.keepalive == false)
+      close_client(cli)
+    end
+  end
+
+end
+
+end
+end
+end
+

data/lib/rex/proto/iax2.rb

@@ -0,0 +1,2 @@
+# -*- coding: binary -*-
+require 'rex/proto/iax2/client'

data/lib/rex/proto/iax2/call.rb

@@ -0,0 +1,326 @@
+# -*- coding: binary -*-
+module Rex
+module Proto
+module IAX2
+class Call
+
+  attr_accessor :client
+  attr_accessor :oseq, :iseq
+  attr_accessor :scall, :dcall
+  attr_accessor :codec, :state
+  attr_accessor :ring_start, :ring_finish
+  attr_accessor :itime
+  attr_accessor :queue
+  attr_accessor :audio_hook
+  attr_accessor :audio_buff
+  attr_accessor :time_limit
+  attr_accessor :busy
+
+  attr_accessor :caller_name
+  attr_accessor :caller_number
+  attr_accessor :dtmf
+
+
+  def initialize(client, src_id)
+    self.client = client
+    self.scall  = src_id
+    self.dcall  = 0
+    self.iseq   = 0
+    self.oseq   = 0
+    self.state  = nil
+
+    self.itime  = ::Time.now
+    self.queue  = ::Queue.new
+
+    self.audio_buff = []
+
+    self.busy = false
+    self.dtmf = ''
+  end
+
+
+  def dprint(msg)
+    self.client.dprint(msg)
+  end
+
+  def wait_for(*stypes)
+    begin
+      ::Timeout.timeout( IAX_DEFAULT_TIMEOUT ) do
+        while (res = self.queue.pop )
+          if stypes.include?(res[1])
+            return res
+          end
+        end
+      end
+    rescue ::Timeout::Error
+      return nil
+    end
+  end
+
+  # Register with the IAX endpoint
+  def register
+    self.client.send_regreq(self)
+    res = wait_for( IAX_SUBTYPE_REGAUTH, IAX_SUBTYPE_REGREJ )
+    return if not res
+
+    if res[1] == IAX_SUBTYPE_REGREJ
+      reason = res[2][IAX_IE_REGREJ_CAUSE] || "Unknown Reason"
+      dprint("REGREJ: #{reason}")
+      # Acknowledge the REGREJ
+      self.client.send_ack(self)
+      return
+    end
+
+    chall = nil
+    if res[2][14] == "\x00\x03" and res[2][IAX_IE_CHALLENGE_DATA]
+      self.dcall = res[0][0]
+      chall = res[2][IAX_IE_CHALLENGE_DATA]
+    end
+
+    if chall.nil?
+      dprint("REGAUTH: No challenge data received")
+      return
+    end
+
+    self.client.send_regreq_chall_response(self, chall)
+    res = wait_for( IAX_SUBTYPE_REGACK, IAX_SUBTYPE_REGREJ )
+    return if not res
+
+    if res[1] == IAX_SUBTYPE_REGREJ
+      reason = res[2][IAX_IE_REGREJ_CAUSE] || "Unknown Reason"
+      dprint("REGREJ: #{reason}")
+      return
+    end
+
+    if res[2][IAX_IE_APPARENT_ADDR]
+      r_fam, r_port, r_addr = res[2][IAX_IE_APPARENT_ADDR].unpack('nnA4')
+      r_addr = r_addr.unpack("C*").map{|x| x.to_s }.join(".")
+      dprint("REGACK: Registered from address #{r_addr}:#{r_port}")
+    end
+
+    # Acknowledge the REGACK
+    self.client.send_ack(self)
+
+    self.state = :registered
+
+    true
+  end
+
+  def dial(number)
+    self.client.send_new(self, number)
+    res = wait_for(IAX_SUBTYPE_AUTHREQ, IAX_SUBTYPE_ACCEPT)
+    return if not res
+
+    # Handle authentication if its requested
+    if res[1] == IAX_SUBTYPE_AUTHREQ
+      chall = nil
+      if res[2][14] == "\x00\x03" and res[1][15]
+        self.dcall = res[0][0]
+        chall = res[2][15]
+      end
+
+      self.client.send_authrep_chall_response(self, chall)
+      res = wait_for( IAX_SUBTYPE_ACCEPT)
+      return if not res
+    end
+
+    self.codec = res[2][IAX_IE_DESIRED_CODEC].unpack("N")[0]
+    self.state = :ringing
+    self.ring_start = ::Time.now.to_i
+    self.client.send_ack(self)
+    true
+  end
+
+  def hangup
+    self.client.send_hangup(self)
+    self.state = :hangup
+    true
+  end
+
+  def ring_time
+    (self.ring_finish || Time.now).to_i - self.ring_start.to_i
+  end
+
+  def timestamp
+    (( ::Time.now - self.itime) * 1000.0 ).to_i & 0xffffffff
+  end
+
+  def process_elements(data,off=0)
+    res = {}
+    while( off < data.length )
+      ie_type = data[off    ,1].unpack("C")[0]
+      ie_len  = data[off + 1,2].unpack("C")[0]
+      res[ie_type] = data[off + 2, ie_len]
+      off += ie_len + 2
+    end
+    res
+  end
+
+  # Handling incoming control packets
+  # TODO: Enforce sequence order to prevent duplicates from breaking our state
+  def handle_control(pkt)
+    src_call, dst_call, tstamp, out_seq, inp_seq, itype = pkt.unpack('nnNCCC')
+
+    # Scrub the high bits out of the call IDs
+    src_call ^= 0x8000 if (src_call & 0x8000 != 0)
+    dst_call ^= 0x8000 if (dst_call & 0x8000 != 0)
+
+    phdr = [ src_call, dst_call, tstamp, out_seq, inp_seq, itype ]
+
+    info  = nil
+    stype = pkt[11,1].unpack("C")[0]
+    info  = process_elements(pkt, 12) if [IAX_TYPE_IAX, IAX_TYPE_CONTROL].include?(itype)
+
+    if dst_call != self.scall
+      dprint("Incoming packet to inactive call: #{dst_call} vs #{self.scall}: #{phdr.inspect} #{stype.inspect} #{info.inspect}")
+      return
+    end
+
+    # Increment the received sequence number
+    self.iseq = (self.iseq + 1) & 0xff
+
+    if self.state == :hangup
+      dprint("Packet received after hangup, replying with invalid")
+      self.client.send_invalid(self)
+      return
+    end
+
+    # Technically these all require an ACK reply
+    # NEW, HANGUP, REJECT, ACCEPT, PONG, AUTHREP, REGREL, REGACK, REGREJ, TXREL
+
+    case itype
+    when IAX_TYPE_DTMF_BEGIN
+      self.dprint("DTMF BEG: #{pkt[11,1]}")
+      self.dtmf << pkt[11,1]
+
+    when IAX_TYPE_DTMF_END
+      self.dprint("DTMF END: #{pkt[11,1]}")
+
+    when IAX_TYPE_CONTROL
+      case stype
+      when IAX_CTRL_HANGUP
+        dprint("HANGUP")
+        self.client.send_ack(self)
+        self.state = :hangup
+
+      when IAX_CTRL_RINGING
+        dprint("RINGING")
+        self.client.send_ack(self)
+
+      when IAX_CTRL_BUSY
+        dprint("BUSY")
+        self.busy  = true
+        self.state = :hangup
+        self.client.send_ack(self)
+
+      when IAX_CTRL_ANSWER
+        dprint("ANSWER")
+        if self.state == :ringing
+          self.state = :answered
+          self.ring_finish = ::Time.now.to_i
+        end
+        self.client.send_ack(self)
+
+      when IAX_CTRL_PROGRESS
+        dprint("PROGRESS")
+
+      when IAX_CTRL_PROCEED
+        dprint("PROCEED")
+
+      when 255
+        dprint("STOP SOUNDS")
+      end
+      # Acknowledge all control packets
+      # self.client.send_ack(self)
+
+    when IAX_TYPE_IAX
+
+      dprint( ["RECV", phdr, stype, info].inspect )
+      case stype
+      when IAX_SUBTYPE_HANGUP
+        self.state = :hangup
+        self.client.send_ack(self)
+      when IAX_SUBTYPE_LAGRQ
+        # Lagrps echo the timestamp
+        self.client.send_lagrp(self, tstamp)
+      when IAX_SUBTYPE_ACK
+        # Nothing to do here
+      when IAX_SUBTYPE_PING
+        # Pongs echo the timestamp
+        self.client.send_pong(self, tstamp)
+      when IAX_SUBTYPE_PONG
+        self.client.send_ack(self)
+      else
+        dprint( ["RECV-QUEUE", phdr, stype, info].inspect )
+        self.queue.push( [phdr, stype, info ] )
+      end
+
+    when IAX_TYPE_VOICE
+      v_codec = stype
+      if self.state == :answered
+        handle_audio(pkt)
+      end
+      self.client.send_ack(self)
+
+    when nil
+      dprint("Invalid control packet: #{pkt.unpack("H*")[0]}")
+    end
+  end
+
+
+  # Encoded audio from the client
+  def handle_audio(pkt)
+    # Ignore audio received before the call is answered (ring ring)
+    return if self.state != :answered
+
+    # Extract the data from the packet (full or mini)
+    data = audio_packet_data(pkt)
+
+    # Decode the data into linear PCM frames
+    buff = decode_audio_frame(data)
+
+    # Call the caller-provided hook if its exists
+    if self.audio_hook
+      self.audio_buff(buff)
+    # Otherwise append the frame to the buffer
+    else
+      self.audio_buff << buff
+    end
+  end
+
+  def each_audio_frame(&block)
+    self.audio_buff.each do |frame|
+      block.call(frame)
+    end
+  end
+
+  def decode_audio_frame(buff)
+    case self.codec
+
+    # Convert u-law into signed PCM
+    when IAX_CODEC_G711_MULAW
+      Rex::Proto::IAX2::Codecs::MuLaw.decode(buff)
+
+    # Convert a-law into signed PCM
+    when IAX_CODEC_G711_ALAW
+      Rex::Proto::IAX2::Codecs::ALaw.decode(buff)
+
+    # Linear little-endian signed PCM is our native format
+    when IAX_CODEC_LINEAR_PCM
+      buff
+
+    # Unsupported codec, return empty
+    else
+      dprint("UNKNOWN CODEC: #{self.codec.inspect}")
+      ''
+    end
+  end
+
+  def audio_packet_data(pkt)
+    (pkt[0,1].unpack("C")[0] & 0x80 == 0) ? pkt[4,pkt.length-4] : pkt[12,pkt.length-12]
+  end
+
+end
+end
+end
+end