buby 1.3.3-java → 1.5.0-java

data/lib/buby/{extends → implants}/http_request_response.rb

@@ -1,7 +1,9 @@
 require 'uri'
 
 class Buby
+  # @todo bring IHttpRequestResponse into the now.
 
+  # @deprecated no longer needed in JRuby
   class HttpRequestResponseList < BubyArrayWrapper
     def initialize(obj)
       HttpRequestResponseHelper.implant(obj[0]) if obj.size > 0
@@ -10,11 +12,15 @@ class Buby
 
   end
 
-
+  # @deprecated This will change to the new Buby::Implants style in the next
+  #   release. The interface methods will be overwritten to be Ruby-like
+  #   themselves. If the standard Java implententation is still desired, use the
+  #   +__method+ version (e.g. +#__response+ or +#__request+).
   module HttpRequestResponseHelper
 
     # returns the response as a Ruby String object - returns an empty string
     # if response is nil.
+    # @deprecated
     def response_str
       return response().nil? ? "" : ::String.from_java_bytes(response())
     end
@@ -45,6 +51,7 @@ class Buby
 
     # Returns the full request as a Ruby String - returns an empty string if 
     # request is nil.
+    # @deprecated
     def request_str
       return request().nil? ? "" : ::String.from_java_bytes(request())
     end

data/lib/buby/implants/intercepted_proxy_message.rb

@@ -0,0 +1,53 @@
+class Buby
+  module Implants
+
+    # This interface is used to represent an HTTP message that has been
+    # intercepted by Burp Proxy. Extensions can register an +IProxyListener+ to
+    # receive details of proxy messages using this interface.
+    #
+    module InterceptedProxyMessage
+      FOLLOW_RULES              = Java::Burp::IInterceptedProxyMessage::ACTION_FOLLOW_RULES
+      DO_INTERCEPT              = Java::Burp::IInterceptedProxyMessage::ACTION_DO_INTERCEPT
+      DONT_INTERCEPT            = Java::Burp::IInterceptedProxyMessage::ACTION_DONT_INTERCEPT
+      DROP                      = Java::Burp::IInterceptedProxyMessage::ACTION_DROP
+      FOLLOW_RULES_AND_REHOOK   = Java::Burp::IInterceptedProxyMessage::ACTION_FOLLOW_RULES_AND_REHOOK
+      DO_INTERCEPT_AND_REHOOK   = Java::Burp::IInterceptedProxyMessage::ACTION_DO_INTERCEPT_AND_REHOOK
+      DONT_INTERCEPT_AND_REHOOK = Java::Burp::IInterceptedProxyMessage::ACTION_DONT_INTERCEPT_AND_REHOOK
+
+      # This method retrieves details of the intercepted message.
+      #
+      # @return [IHttpRequestResponse] object containing details of the
+      # intercepted message.
+      #
+      # @todo IHttpRequestResponse
+      def getMessageInfo
+        __getMessageInfo.tap{|msg| Buby::HttpRequestResponseHelper.implant(msg)}
+      end
+
+      # Install ourselves into the current +IInterceptedProxyMessage+ java class
+      # @param [IInterceptedProxyMessage] message
+      #
+      def self.implant(message)
+        unless message.implanted? || message.nil?
+          pp [:implanting, message, message.class] if $DEBUG
+          message.class.class_exec(message) do |message|
+            a_methods = %w{
+              getMessageInfo
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::InterceptedProxyMessage
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::InterceptedProxyMessage.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        message
+      end
+    end
+  end
+end

data/lib/buby/implants/intruder_attack.rb

@@ -0,0 +1,42 @@
+class Buby
+  module Implants
+    # This interface is used to hold details about an Intruder attack.
+    #
+    module IntruderAttack
+      # This method is used to retrieve the request template for the attack.
+      #
+      # @return [String] The request template for the attack.
+      #
+      def getRequestTemplate
+        pp [:got_getRequestTemplate] if $DEBUG
+        String.from_java_bytes __getRequestTemplate
+      end
+
+      # Install ourselves into the current +IIntruderAttack+ java class
+      # @param [IIntruderAttack] attack
+      #
+      def self.implant(attack)
+        unless attack.implanted? || attack.nil?
+          pp [:implanting, attack, attack.class] if $DEBUG
+          attack.class.class_exec(attack) do |attack|
+            a_methods = %w{
+              getRequestTemplate
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::IntruderAttack
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::IntruderAttack.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        attack
+      end
+      
+    end
+  end
+end

data/lib/buby/implants/jruby.rb

@@ -0,0 +1,64 @@
+class Buby
+  module Implants
+    module Object
+      def implanted?(klass = nil)
+        self.class.ancestors.include?(klass)
+      end
+
+      def unique_methods regular = true
+        klass = self.class
+        meths = self.methods regular
+        while (klass != ::Object)
+          meths -= JRuby.reference(klass).getMethods.each_with_object([]){|meth, arr| arr << meth.first.intern if meth.last.kind_of?(Java::OrgJrubyInternalRuntimeMethods::AliasMethod)}
+          klass = klass.superclass
+        end
+        meths
+      end
+    end
+
+    unless [].respond_to?(:each_with_object)
+      module Enumerable
+        # XXX backport for 1.8.7
+        def each_with_object(memo)
+          inject(memo) do |memo, item|
+            yield item, memo
+            memo
+          end
+        end
+      end
+    end
+
+    module JavaClass
+      def ruby_names_for_java_method meth
+        self_java_ref = JRuby.reference(self).javaClass
+        target_methods = self_java_ref.getMethods.group_by{|jmeth| jmeth.name}[meth.to_s]
+        Java::OrgJrubyJavasupport::JavaUtil.getRubyNamesForJavaName(target_methods.first.name, target_methods)
+      end
+
+      # copies wrapper_id method to java_id and all ruby-like aliases
+      # used to re-attach java method proxies to new call wrapper
+      #
+      # @param java_id target java method (the original java method name)
+      def rewrap_java_method java_id
+        ruby_names_for_java_method(java_id).each do |ruby_name|
+          alias_method(ruby_name, java_id) unless wrapper_id == ruby_name
+        end
+      end
+    end
+  end
+end
+
+class Object
+  include Buby::Implants::Object
+end
+
+module Enumerable
+  include Buby::Implants::Enumerable unless [].respond_to?(:each_with_object)
+end
+
+module Java
+  class JavaClass
+    include Buby::Implants::JavaClass
+  end
+end
+

data/lib/buby/implants/message_editor.rb

@@ -0,0 +1,70 @@
+class Buby
+  module Implants
+    # This interface is used to provide extensions with an instance of Burp's
+    # HTTP message editor, for the extension to use in its own UI. Extensions
+    # should call {Buby#createMessageEditor} to obtain an instance of this
+    # interface.
+    #
+    module MessageEditor
+      # This method is used to display an HTTP message in the editor.
+      #
+      # @param [Array<byte>, String] message The HTTP message to be displayed.
+      # @param [Boolean] isRequest Flags whether the message is an HTTP request
+      #   or response.
+      # @return [void]
+      #
+      def setMessage(message, isRequest)
+        message = message.to_java_bytes if message.respond_to? :to_java_bytes
+        message = message.to_java :byte if message.kind_of? Array
+        __setMessage(message, isRequest)
+      end
+
+      # This method is used to retrieve the currently displayed message, which
+      # may have been modified by the user.
+      #
+      # @return [String] The currently displayed HTTP message.
+      #
+      def getMessage
+        String.from_java_bytes __getMessage
+      end
+
+      # This method returns the data that is currently selected by the user.
+      #
+      # @return [String, nil] The data that is currently selected by the user,
+      #   or +nil+ if no selection is made.
+      #
+      def getSelectedData
+        ret = __getSelectedData
+        ret ? String.from_java_bytes(ret) : ret
+      end
+
+      # Install ourselves into the current +IMessageEditor+ java class
+      # @param [IMessageEditor] editor
+      #
+      def self.implant(editor)
+        unless editor.implanted? || editor.nil?
+          pp [:implanting, editor, editor.class] if $DEBUG
+          editor.class.class_exec(editor) do |editor|
+            a_methods = %w{
+              setMessage
+              getMessage
+              getSelectedData
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::MessageEditor
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::MessageEditor.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        editor
+      end
+      
+    end
+  end
+end

data/lib/buby/implants/message_editor_controller.rb

@@ -0,0 +1,60 @@
+class Buby
+  module Implants
+    # This interface is used by an +IMessageEditor+ to obtain details about the
+    # currently displayed message. Extensions that create instances of Burp's
+    # HTTP message editor can optionally provide an implementation of
+    # +IMessageEditorController+, which the editor will invoke when it requires
+    # further information about the current message (for example, to send it to
+    # another Burp tool). Extensions that provide custom editor tabs via an
+    # +IMessageEditorTabFactory+ will receive a reference to an
+    # +IMessageEditorController+ object for each tab instance they generate,
+    # which the tab can invoke if it requires further information about the
+    # current message.
+    #
+    module MessageEditorController
+      # This method is used to retrieve the HTTP request associated with the
+      # current message (which may itself be a response).
+      #
+      # @return [String] The HTTP request associated with the current message.
+      #
+      def getRequest
+        String.from_java_bytes __getRequest
+      end
+
+      # This method is used to retrieve the HTTP response associated with the
+      # current message (which may itself be a request).
+      #
+      # @return [String] The HTTP response associated with the current message.
+      #
+      def getResponse
+        String.from_java_bytes __getResponse
+      end
+
+      # Install ourselves into the current +IMessageEditorController+ java class
+      # @param [IMessageEditorController] controller
+      #
+      def self.implant(controller)
+        unless controller.implanted? || controller.nil?
+          pp [:implanting, controller, controller.class] if $DEBUG
+          controller.class.class_exec(controller) do |controller|
+            a_methods = %w{
+              getRequest
+              getResponse
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::MessageEditorController
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::MessageEditorController.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        controller
+      end
+    end
+  end
+end

data/lib/buby/implants/parameter.rb

@@ -0,0 +1,84 @@
+class Buby
+  module Implants
+    # This interface is used to hold details about an HTTP request parameter.
+    # 
+    module Parameter
+
+      # This method is used to retrieve the start offset of the parameter name
+      # within the HTTP request.
+      #
+      # @return [Fixnum, nil] The start offset of the parameter name within
+      #   the HTTP request, or +nil+ if the parameter is not associated with a
+      #   specific request.
+      #
+      def getNameStart
+        ret = __getNameStart
+        ret == -1 ? nil : ret
+      end
+
+      # This method is used to retrieve the end offset of the parameter name
+      # within the HTTP request.
+      #
+      # @return [Fixnum, nil] The end offset of the parameter name within the
+      #   HTTP request, or +nil+ if the parameter is not associated with a
+      #   specific request.
+      #
+      def getNameEnd
+        ret = __getNameEnd
+        ret == -1 ? nil : ret
+      end
+
+      # This method is used to retrieve the start offset of the parameter
+      # value within the HTTP request.
+      #
+      # @return [Fixnum, nil] The start offset of the parameter value within
+      #   the HTTP request, or +nil+ if the parameter is not associated with a
+      #   specific request.
+      #
+      def getValueStart
+        ret = __getValueStart
+        ret == -1 ? nil : ret
+      end
+
+      # This method is used to retrieve the end offset of the parameter value
+      # within the HTTP request.
+      #
+      # @return [Fixnum, nil] The end offset of the parameter value within the
+      #   HTTP request, or +nil+ if the parameter is not associated with a
+      #   specific request.
+      #
+      def getValueEnd
+        ret = __getValueEnd
+        ret == -1 ? nil : ret
+      end
+
+      # Install ourselves into the current +IParameter+ java class
+      # @param [IParameter] parameter
+      #
+      def self.implant(parameter)
+        unless parameter.implanted? || parameter.nil?
+          pp [:implanting, parameter, parameter.class] if $DEBUG
+          parameter.class.class_exec(parameter) do |parameter|
+            a_methods = %w{
+              getNameStart
+              getNameEnd
+              getValueEnd
+              getValueStart
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::Parameter
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::Parameter.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        parameter
+      end
+    end
+  end
+end

data/lib/buby/implants/request_info.rb

@@ -0,0 +1,47 @@
+require 'uri'
+
+class Buby
+  module Implants
+    # This interface is used to retrieve key details about an HTTP request.
+    # Extensions can obtain an +IRequestInfo+ object for a given request by
+    # calling {Buby#analyzeRequest}.
+    #
+    module RequestInfo
+
+      # This method is used to obtain the parameters contained in the request.
+      #
+      # @return [Array<IParameter>] The parameters contained in the request.
+      #
+      def getParameters
+        __getParameters.tap{|parm| Buby::Implants::Parameter.implant parm.first}
+      end
+
+      
+      # Install ourselves into the current +IRequestInfo+ java class
+      # @param [IRequestInfo] info
+      #
+      def self.implant(info)
+        unless info.implanted? || info.nil?
+          pp [:implanting, info, info.class] if $DEBUG
+          info.class.class_exec(info) do |info|
+            a_methods = %w{
+              getParameters
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::RequestInfo
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::RequestInfo.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        info
+      end
+      
+    end
+  end
+end