rex 2.0.8 → 2.0.9

data/lib/rex/exploitation/cmdstager/echo.rb

@@ -27,9 +27,12 @@ class CmdStagerEcho < CmdStagerBase
   #
   def generate(opts = {})
     opts[:temp] = opts[:temp] || '/tmp/'
-    opts[:temp].gsub!(/\\/, "/")
-    opts[:temp] = opts[:temp].shellescape
-    opts[:temp] << '/' if opts[:temp][-1,1] != '/'
+
+    unless opts[:temp].empty?
+      opts[:temp].gsub!(/\\/, '/')
+      opts[:temp] = opts[:temp].shellescape
+      opts[:temp] << '/' if opts[:temp][-1,1] != '/'
+    end
 
     # by default use the 'hex' encoding
     opts[:enc_format] = opts[:enc_format] || 'hex'

data/lib/rex/exploitation/egghunter.rb

@@ -46,7 +46,7 @@ class Egghunter
         startreg      = opts[:startreg]
         searchforward = opts[:searchforward]
 
-        raise RuntimeError, "Invalid egg string! Need #{esize} bytes." if opts[:eggtag].length != 4
+        raise RuntimeError, "Invalid egg string! Need 4 bytes." if opts[:eggtag].length != 4
         marker = "0x%x" % opts[:eggtag].unpack('V').first
 
         checksum = checksum_stub(payload, badchars, opts)

data/lib/rex/google/geolocation.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'json'
+
+module Rex
+  module Google
+    # @example
+    #   g = Rex::Google::Geolocation.new
+    #   g.add_wlan("00:11:22:33:44:55", "example", -80)
+    #   g.fetch!
+    #   puts g, g.google_maps_url
+    class Geolocation
+      GOOGLE_API_URI = "https://maps.googleapis.com/maps/api/browserlocation/json?browser=firefox&sensor=true&"
+
+      attr_accessor :accuracy
+      attr_accessor :latitude
+      attr_accessor :longitude
+
+      def initialize
+        @uri = URI.parse(URI.encode(GOOGLE_API_URI))
+        @wlan_list = []
+      end
+
+      # Ask Google's Maps API for the location of a given set of BSSIDs (MAC
+      # addresses of access points), ESSIDs (AP names), and signal strengths.
+      def fetch!
+        @uri.query << @wlan_list.take(10).join("&wifi=")
+        request = Net::HTTP::Get.new(@uri.request_uri)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+        http.use_ssl = true
+        response = http.request(request)
+
+        if response && response.code == '200'
+          results = JSON.parse(response.body)
+          self.latitude = results["location"]["lat"]
+          self.longitude = results["location"]["lng"]
+          self.accuracy = results["accuracy"]
+        else
+          msg = "Failure connecting to Google for location lookup."
+          msg += " Code #{response.code} for query #{@uri}" if response
+          fail msg
+        end
+      end
+
+      # Add an AP to the list to send to Google when {#fetch!} is called.
+      #
+      # Turns out Google's API doesn't really care about ESSID or signal strength
+      # as long as you have BSSIDs. Presumably adding them will make it more
+      # accurate? Who knows.
+      #
+      # @param mac [String] in the form "00:11:22:33:44:55"
+      # @param ssid [String] ESSID associated with the mac
+      # @param signal_strength [String] a thing like
+      def add_wlan(mac, ssid = nil, signal_strength = nil)
+        @wlan_list.push(URI.encode("mac:#{mac.upcase}|ssid:#{ssid}|ss=#{signal_strength.to_i}"))
+      end
+
+      def google_maps_url
+        "https://maps.google.com/?q=#{latitude},#{longitude}"
+      end
+
+      def to_s
+        "Google indicates the device is within #{accuracy} meters of #{latitude},#{longitude}."
+      end
+    end
+  end
+end

data/lib/rex/io/bidirectional_pipe.rb

@@ -87,10 +87,6 @@ class BidirectionalPipe < Rex::Ui::Text::Input
     print_line('[+] ' + msg)
   end
 
-  def print_debug(msg='')
-    print_line('[!] ' + msg)
-  end
-
   def flush
   end
 

data/lib/rex/java/serialization.rb

@@ -51,5 +51,7 @@ module Rex
   end
 end
 
+require 'rex/java/serialization/decode_error'
+require 'rex/java/serialization/encode_error'
 require 'rex/java/serialization/model'
 require 'rex/java/serialization/builder'

data/lib/rex/java/serialization/decode_error.rb

@@ -0,0 +1,11 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      class DecodeError < ::RuntimeError
+
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/encode_error.rb

@@ -0,0 +1,11 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      class EncodeError < ::RuntimeError
+
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model.rb

@@ -15,9 +15,11 @@ module Rex
         autoload :Field,          'rex/java/serialization/model/field'
         autoload :LongUtf,        'rex/java/serialization/model/long_utf'
         autoload :NewArray,       'rex/java/serialization/model/new_array'
+        autoload :ProxyClassDesc, 'rex/java/serialization/model/proxy_class_desc'
         autoload :NewClassDesc,   'rex/java/serialization/model/new_class_desc'
         autoload :NewEnum,        'rex/java/serialization/model/new_enum'
         autoload :NewObject,      'rex/java/serialization/model/new_object'
+        autoload :NewClass,       'rex/java/serialization/model/new_class'
         autoload :NullReference,  'rex/java/serialization/model/null_reference'
         autoload :Reference,      'rex/java/serialization/model/reference'
         autoload :Reset,          'rex/java/serialization/model/reset'

data/lib/rex/java/serialization/model/annotation.rb

@@ -24,7 +24,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             loop do
               content = decode_content(io, stream)
@@ -38,9 +38,9 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Annotation
           #
           # @return [String] if serialization suceeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
-            raise ::RuntimeError, 'Failed to serialize Annotation with empty contents' if contents.empty?
+            raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Annotation with empty contents' if contents.empty?
 
             encoded = ''
 

data/lib/rex/java/serialization/model/block_data.rb

@@ -26,10 +26,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(1)
-            raise RuntimeError, 'Failed to unserialize BlockData' if raw_length.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData' if raw_length.nil?
             self.length = raw_length.unpack('C')[0]
 
             if length == 0
@@ -37,7 +37,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise RuntimeError, 'Failed to unserialize BlockData'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
               end
             end
 

data/lib/rex/java/serialization/model/block_data_long.rb

@@ -26,11 +26,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(4)
             if raw_length.nil? || raw_length.length != 4
-              raise ::RuntimeError, 'Failed to unserialize BlockDataLong'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockDataLong'
             end
             self.length = raw_length.unpack('N')[0]
 
@@ -39,7 +39,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise ::RuntimeError, 'Failed to unserialize BlockData'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
               end
             end
 

data/lib/rex/java/serialization/model/class_desc.rb

@@ -21,13 +21,13 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             content = decode_content(io, stream)
-            allowed_contents = [NullReference, NewClassDesc, Reference]
+            allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
 
             unless allowed_contents.include?(content.class)
-              raise ::RuntimeError, 'ClassDesc unserialize failed'
+              raise Rex::Java::Serialization::DecodeError, 'ClassDesc unserialize failed'
             end
 
             self.description = content
@@ -37,13 +37,13 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::ClassDesc
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             encoded = ''
-            allowed_contents = [NullReference, NewClassDesc, Reference]
+            allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
 
             unless allowed_contents.include?(description.class)
-              raise ::RuntimeError, 'Failed to serialize ClassDesc'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize ClassDesc'
             end
 
             encoded << encode_content(description)

data/lib/rex/java/serialization/model/contents.rb

@@ -11,10 +11,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed or unsupported content
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed or unsupported content
           def decode_content(io, stream)
             opcode = io.read(1)
-            raise ::RuntimeError, 'Failed to unserialize content' if opcode.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content' if opcode.nil?
             opcode = opcode.unpack('C')[0]
             content = nil
 
@@ -28,7 +28,7 @@ module Rex
             when TC_OBJECT
               content = NewObject.decode(io, stream)
             when TC_CLASS
-              content = ClassDesc.decode(io, stream)
+              content = NewClass.decode(io, stream)
             when TC_ARRAY
               content = NewArray.decode(io, stream)
             when TC_STRING
@@ -42,17 +42,17 @@ module Rex
             when TC_CLASSDESC
               content = NewClassDesc.decode(io, stream)
             when TC_PROXYCLASSDESC
-              raise ::RuntimeError, 'Failed to unserialize unsupported TC_PROXYCLASSDESC content'
+              content = ProxyClassDesc.decode(io, stream)
             when TC_REFERENCE
               content = Reference.decode(io, stream)
             when TC_NULL
               content = NullReference.decode(io, stream)
             when TC_EXCEPTION
-              raise ::RuntimeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
             when TC_RESET
               content = Reset.decode(io, stream)
             else
-              raise ::RuntimeError, 'Failed to unserialize content'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content'
             end
 
             content
@@ -62,7 +62,7 @@ module Rex
           #
           # @param content [Rex::Java::Serialization::Model::Element] the content to serialize
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode_content(content)
             encoded = ''
 
@@ -75,7 +75,7 @@ module Rex
               encoded << [TC_ENDBLOCKDATA].pack('C')
             when NewObject
               encoded << [TC_OBJECT].pack('C')
-            when ClassDesc
+            when NewClass
               encoded << [TC_CLASS].pack('C')
             when NewArray
               encoded << [TC_ARRAY].pack('C')
@@ -87,6 +87,8 @@ module Rex
               encoded << [TC_ENUM].pack('C')
             when NewClassDesc
               encoded << [TC_CLASSDESC].pack('C')
+            when ProxyClassDesc
+              content = [TC_PROXYCLASSDESC].pack('C')
             when NullReference
               encoded << [TC_NULL].pack('C')
             when Reset
@@ -94,7 +96,7 @@ module Rex
             when Reference
               encoded << [TC_REFERENCE].pack('C')
             else
-              raise ::RuntimeError, 'Failed to serialize content'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
             end
 
             encoded << content.encode
@@ -105,6 +107,7 @@ module Rex
           #
           # @param content [Rex::Java::Serialization::Model::Element] the content to print
           # @return [String]
+          # @raise [Rex::Java::Serialization::EncodeError] if the content is unknown
           def print_content(content)
             str = ''
 
@@ -119,6 +122,8 @@ module Rex
               str << "#{print_class(content)} { #{content.to_s} }"
             when ClassDesc
               str << "#{print_class(content)} { #{content.to_s} }"
+            when NewClass
+              str << "#{print_class(content)} { #{content.to_s} }"
             when NewArray
               str << "#{print_class(content)} { #{content.to_s} }"
             when Utf
@@ -129,6 +134,8 @@ module Rex
               str << "#{print_class(content)} { #{content.to_s} }"
             when NewClassDesc
               str << "#{print_class(content)} { #{content.to_s} }"
+            when ProxyClassDesc
+              str << "#{print_class(content)} { #{content.to_s} }"
             when NullReference
               str << "#{print_class(content)}"
             when Reset
@@ -136,7 +143,7 @@ module Rex
             when Reference
               str << "#{print_class(content)} { #{content.to_s} }"
             else
-              raise ::RuntimeError, 'Failed to serialize content'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
             end
 
             str

data/lib/rex/java/serialization/model/field.rb

@@ -11,13 +11,13 @@ module Rex
           include Rex::Java::Serialization::Model::Contents
 
           # @!attribute type
-          #   @return [String] The type of the field.
+          # @return [String] The type of the field.
           attr_accessor :type
           # @!attribute name
-          #   @return [Rex::Java::Serialization::Model::Utf] The name of the field.
+          # @return [Rex::Java::Serialization::Model::Utf] The name of the field.
           attr_accessor :name
           # @!attribute field_type
-          #   @return [Rex::Java::Serialization::Model::Utf] The type of the field on object types.
+          # @return [Rex::Java::Serialization::Model::Utf] The type of the field on object types.
           attr_accessor :field_type
 
           # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
@@ -32,12 +32,12 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @faise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             code = io.read(1)
 
             unless code && is_valid?(code)
-              raise ::RuntimeError, 'Failed to unserialize Field'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field'
             end
 
             self.type = TYPE_CODES[code]
@@ -53,14 +53,14 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Field
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless name.kind_of?(Rex::Java::Serialization::Model::Utf)
-              raise ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             unless is_type_valid?
-              raise ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             encoded = ''
@@ -138,11 +138,12 @@ module Rex
           # Serializes the `field_type` attribute.
           #
           # @return [String]
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
           def encode_field_type
             allowed_contents = [Utf, Reference]
 
             unless allowed_contents.include?(field_type.class)
-              raise ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             encoded = encode_content(field_type)
@@ -154,13 +155,13 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Java::Serialization::Model::Utf]
-          # @raise [RuntimeError] if unserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if unserialization doesn't succeed
           def decode_field_type(io)
             allowed_contents = [Utf, Reference]
             type = decode_content(io, stream)
 
             unless allowed_contents.include?(type.class)
-              raise ::RuntimeError, 'Failed to unserialize Field field_type'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field field_type'
             end
 
             type