buby 1.3.3-java → 1.5.0-java

data/lib/buby/context_menu_factory.rb

@@ -0,0 +1,35 @@
+class Buby
+  # Extensions can implement this interface and then call
+  # <code>IBurpExtenderCallbacks.registerContextMenuFactory()</code> to register
+  # a factory for custom context menu items.
+  #
+  class ContextMenuFactory
+    include Java::Burp::IContextMenuFactory
+
+    # This method will be called by Burp when the user invokes a context menu
+    # anywhere within Burp. The factory can then provide any custom context
+    # menu items that should be displayed in the context menu, based on the
+    # details of the menu invocation.
+    # Implementations should call super
+    #
+    # @param [IContextMenuInvocation] invocation An object the extension can
+    #   query to obtain details of the context menu invocation.
+    # @return [Array<JMenuItem>] A list of custom menu items (which may include
+    #   sub-menus, checkbox menu items, etc.) that should be displayed.
+    #   Extensions may return +nil+ from this method, to indicate that no menu
+    #   items are required.
+    #
+    def self.createMenuItems invocation
+      pp [:got_create_menu_items, invocation] if $DEBUG
+      Buby::Implants::ContextMenuInvocation.implant invocation
+      nil
+    end
+
+    # (see ContextMenuFactory.createMenuItems)
+    def createMenuItems invocation
+      pp [:got_create_menu_items, invocation] if $DEBUG
+      Buby::Implants::ContextMenuInvocation.implant invocation
+      nil
+    end
+  end
+end

data/lib/buby/cookie.rb

@@ -0,0 +1,37 @@
+require 'cgi'
+
+class Buby
+  # This class is used to hold details about an HTTP cookie. Implements the
+  # +burp.ICookie+ interface
+  #
+  class Cookie < CGI::Cookie
+    include Java::Burp::ICookie
+
+    # This method is used to retrieve the domain for which the cookie is in
+    # scope. 
+    #
+    # @return [String] The domain for which the cookie is in scope.
+    def getDomain
+      @domain
+    end
+
+    # This method is used to retrieve the expiration time for the cookie.
+    #
+    # @return [java.util.Date] The expiration time for the cookie, or +nil+ if
+    #   none is set (i.e., for non-persistent session cookies).
+    #
+    def getExpiration; @expires; end
+
+    # This method is used to retrieve the name of the cookie.
+    #
+    # @return [String] The name of the cookie.
+    #
+    def getName; @name; end
+
+    # This method is used to retrieve the value of the cookie.
+    # 
+    # @return [String] The value of the cookie.
+    #
+    def getValue; join("&"); end
+  end
+end

data/lib/buby/extender.rb

@@ -0,0 +1,156 @@
+class Buby
+  # This is the JRuby implementation of IBurpExtender for use as a JRuby
+  # extension. This class handles the type conversions and other ruby sugar.
+  # {BurpExtender} further extends this by adding additional things during
+  # startup, like setting up Buby as the handler class and starting console
+  # tabs.
+  # 
+  # @note This class, unlike the Java implementation, does not fire the
+  #   deprecated evt_* callbacks, only the new versions.
+  #
+  # @todo move implant logic to extender interfaces
+  module Extender
+    include Java::Burp::IBurpExtender
+    include Java::Burp::IExtensionStateListener
+    include Java::Burp::IProxyListener
+    include Java::Burp::IHttpListener
+    include Java::Burp::IScannerListener
+    include Java::Burp::IScopeChangeListener
+    include Java::Burp::IContextMenuFactory
+
+    # @group Buby internals
+    # Internal reference to ruby handler class (usually {Buby})
+    @@handler = nil
+
+    # Returns the internal Ruby handler reference. 
+    #
+    # The handler is the ruby class or module used for proxying BurpExtender 
+    # events into a ruby runtime. Usually, this is Buby or a subclass.
+    #
+    def self.handler
+      @@handler
+    end
+
+    # Sets an internal reference to the ruby handler class or module to use for
+    # proxied BurpExtender events into a ruby runtime.
+    #
+    # Generally, this should probably be called in {#registerExtenderCallbacks}.
+    # However, it is also possible to set this afterwards and even swap in new
+    # objects during runtime.
+    #
+    def self.handler=(hndlr)
+      @@handler = hndlr
+    end
+
+    def handler
+      @@handler
+    end
+
+    def handler= hndlr
+      @@handler = hndlr
+    end
+
+    # @group Burp extender
+    # This callback usually fires before the handler is set.
+    #
+    def initialize *args
+      @@handler.extender_initialize(*args) if @@handler.respond_to? :extender_inititialize
+    end
+
+    # This method is invoked when the extension is loaded. It registers an
+    # instance of the +IBurpExtenderCallbacks+ interface, providing methods that
+    # may be invoked by the extension to perform various actions.
+    #
+    # @param [IBurpExtenderCallbacks] callbacks Burp's Java object for querying
+    #   Burp's data.
+    # @return [void]
+    #
+    def registerExtenderCallbacks(callbacks)
+      @callbacks = callbacks
+      callbacks.issueAlert("[#{self.class}] registering JRuby handler callbacks")
+      callbacks.registerExtensionStateListener(self)
+      callbacks.registerHttpListener(self)
+      callbacks.registerScannerListener(self)
+      callbacks.registerContextMenuFactory self
+      callbacks.registerScopeChangeListener self
+      @@handler.register_callbacks(callbacks) if @@handler.respond_to? :register_callbacks
+    end
+
+    # @group Listeners
+    # This method is called when the extension is unloaded. This, in turn, calls
+    # {Buby#extension_unloaded} on the handler instance
+    #
+    def extensionUnloaded
+      @@handler.extension_unloaded if @@handler.respond_to? :extension_unloaded
+    end
+
+    # This method is invoked when an HTTP message is being processed by the
+    # Proxy and calls {Buby#process_proxy_message} on the handler.
+    #
+    # @param [Boolean] messageIsRequest Indicates whether the HTTP message is a
+    #   request or a response.
+    # @param [IInterceptedProxyMessage] message An +IInterceptedProxyMessage+
+    #   object that extensions can use to query and update details of the
+    #   message, and control whether the message should be intercepted and
+    #   displayed to the user for manual review or modification.
+    # @return [void]
+    #
+    def processProxyMessage(messageIsRequest, message)
+      @@handler.process_proxy_message(messageIsRequest, message) if @@handler.respond_to? :process_proxy_message
+    end
+
+    # This method is invoked when an HTTP request is about to be issued, and
+    # when an HTTP response has been received.
+    #
+    # @param [Fixnum] toolFlag A flag indicating the Burp tool that issued the
+    #   request. Burp tool flags are defined in the +IBurpExtenderCallbacks+
+    #   interface.
+    # @param [Boolean] messageIsRequest Flags whether the method is being
+    #   invoked for a request or response.
+    # @param [IHttpRequestResponse] messageInfo Details of the request /
+    #   response to be processed. Extensions can call the setter methods on this
+    #   object to update the current message and so modify Burp's behavior.
+    # @return [void]
+    #
+    def processHttpMessage(toolFlag, messageIsRequest, messageInfo)
+      @@handler.process_http_message(toolFlag, messageIsRequest, messageInfo) if @@handler.respond_to? :process_http_message
+    end
+
+    # This method is invoked when a new issue is added to Burp Scanner's
+    # results.
+    #
+    # @param [IScanIssue] issue An +IScanIssue+ object that the extension can
+    #   query to obtain details about the new issue.
+    #
+    def newScanIssue(issue)
+      @@handler.new_scan_issue(issue) if @@handler.respond_to? :new_scan_issue
+    end
+
+    # This method will be called by Burp when the user invokes a context menu
+    # anywhere within Burp. The factory can then provide any custom context menu
+    # items that should be displayed in the context menu, based on the details
+    # of the menu invocation.
+    #
+    # @param [IContextMenuInvocation] invocation An object the extension can
+    #   query to obtain details of the context menu invocation.
+    # @return [Array<JMenuItem>, nil] A list of custom menu items (which may
+    #   include sub-menus, checkbox menu items, etc.) that should be displayed.
+    #   Extensions may return +nil+ from this method, to indicate that no menu
+    #   items are required.
+    #
+    # @abstract
+    def createMenuItems invocation
+      @@handler.create_menu_items(invocation) if @@handler.respond_to? :create_menu_items
+    end
+
+    # This method is invoked whenever a change occurs to Burp's suite-wide
+    # target scope.
+    #
+    # @return [void]
+    #
+    # @abstract
+    def scopeChanged
+      @@handler.scope_changed if @@handler.respond_to? :scope_changed
+    end
+  end
+end

data/lib/buby/http_listener.rb

@@ -0,0 +1,29 @@
+class Buby
+  # Extensions can implement this interface and then call
+  # {Buby#registerHttpListener} to register an HTTP listener. The listener will
+  # be notified of requests and responses made by any Burp tool. Extensions can
+  # perform custom analysis or modification of these messages by registering an
+  # HTTP listener.
+  # 
+  class HttpListener
+    include Java::Burp::IHttpListener
+
+    # This method is invoked when an HTTP request is about to be issued, and
+    # when an HTTP response has been received.
+    #
+    # @param [Fixnum, Symbol] toolFlag A flag indicating the Burp tool that
+    #   issued the request. Burp tool flags are defined in the
+    #   +IBurpExtenderCallbacks+ interface and {Buby}.
+    # @param [Boolean] messageIsRequest Flags whether the method is being
+    #   invoked for a request or response.
+    # @param [IHttpRequestResponse] messageInfo Details of the request/response
+    #   to be processed. Extensions can call the setter methods on this object
+    #   to update the current message and so modify Burp's behavior.
+    #
+    # @todo move HttpRequestResponse to new implant scheme
+    def processHttpMessage(toolFlag, messageIsRequest, messageInfo)
+      pp [:got_processHttpMessage, toolFlag, messageIsRequest, messageInfo] if $DEBUG
+      Buby::HttpRequestResponseHelper.implant(messageInfo)
+    end
+  end
+end

data/lib/buby/implants/context_menu_invocation.rb

@@ -0,0 +1,113 @@
+class Buby
+  module Implants
+    # This interface is used when Burp calls into an extension-provided
+    # <code>IContextMenuFactory</code> with details of a context menu
+    # invocation. The custom context menu factory can query this interface to
+    # obtain details of the invocation event, in order to determine what menu
+    # items should be displayed.
+    # This module is used to extend the JRuby proxy class returned by Burp.
+    #
+    module ContextMenuInvocation
+      # Context menu is being invoked in a request editor.
+      CONTEXT_MESSAGE_EDITOR_REQUEST = 0;
+
+      # Context menu is being invoked in a response editor.
+      CONTEXT_MESSAGE_EDITOR_RESPONSE = 1;
+
+      # Context menu is being invoked in a non-editable request viewer.
+      CONTEXT_MESSAGE_VIEWER_REQUEST = 2;
+
+      # Context menu is being invoked in a non-editable response viewer.
+      CONTEXT_MESSAGE_VIEWER_RESPONSE = 3;
+
+      # Context menu is being invoked in the Target site map tree.
+      CONTEXT_TARGET_SITE_MAP_TREE = 4;
+
+      # Context menu is being invoked in the Target site map table.
+      CONTEXT_TARGET_SITE_MAP_TABLE = 5;
+
+      # Context menu is being invoked in the Proxy history.
+      CONTEXT_PROXY_HISTORY = 6;
+
+      # Context menu is being invoked in the Scanner results.
+      CONTEXT_SCANNER_RESULTS = 7;
+
+      # Context menu is being invoked in the Intruder payload positions editor.
+      CONTEXT_INTRUDER_PAYLOAD_POSITIONS = 8;
+
+      # Context menu is being invoked in an Intruder attack results.
+      CONTEXT_INTRUDER_ATTACK_RESULTS = 9;
+
+      # Context menu is being invoked in a search results window.
+      CONTEXT_SEARCH_RESULTS = 10;
+
+      # This method can be used to retrieve details of the HTTP requests /
+      # responses that were shown or selected by the user when the context menu
+      # was invoked.
+      #
+      # @note For performance reasons, the objects returned from this method are
+      #   tied to the originating context of the messages within the Burp UI.
+      #   For example, if a context menu is invoked on the Proxy intercept
+      #   panel, then the +IHttpRequestResponse+ returned by this method will
+      #   reflect the current contents of the interception panel, and this will
+      #   change when the current message has been forwarded or dropped. If your
+      #   extension needs to store details of the message for which the context
+      #   menu has been invoked, then you should query those details from the
+      #   +IHttpRequestResponse+ at the time of invocation, or you should use
+      #   +IBurpExtenderCallbacks.saveBuffersToTempFiles()+ to create a
+      #   persistent read-only copy of the +IHttpRequestResponse+.
+      #
+      # @return [Array<IHttpRequestResponse>,nil] An array of objects
+      #   representing the items that were shown or selected by the user when
+      #   the context menu was invoked. This method returns +nil+ if no messages
+      #   are applicable to the invocation.
+      #
+      def getSelectedMessages
+        pp [:got_get_selected_messages] if $DEBUG
+        hrrl = __getSelectedMessages
+        HttpRequestResponseHelper.implant(hrrl.first)
+        hrrl
+      end
+
+      # This method can be used to retrieve details of the Scanner issues that
+      # were selected by the user when the context menu was invoked.
+      #
+      # @return [Array<IScanIssue>,nil] The issues that were selected by the
+      #   user when the context menu was invoked. This method returns +nil+ if
+      #   no Scanner issues are applicable to the invocation.
+      #
+      def getSelectedIssues
+        pp [:got_get_selected_issues] if $DEBUG
+        sil = __getSelectedIssues
+        ScanIssueHelper.implant(sil.first)
+        sil
+      end
+
+      # Install ourselves into the current +IContextMenuInvocation+ java class
+      # @param [IContextMenuInvocation] invocation
+      #
+      def self.implant(invocation)
+        unless invocation.implanted? || invocation.nil?
+          pp [:implanting, invocation, invocation.class] if $DEBUG
+          invocation.class.class_exec(invocation) do |invocation|
+            a_methods = %w{
+              getSelectedMessages
+              getSelectedIssues
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::ContextMenuInvocation
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::ContextMenuInvocation.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        invocation
+      end
+    end
+  end
+end

data/lib/buby/implants/cookie.rb

@@ -0,0 +1,47 @@
+class Buby
+  module Implants
+    # This interface is used to hold details about an HTTP cookie.
+    #
+    # @note This module is used to extend the ICookie interface implementation
+    #   java class at runtime.
+    module Cookie
+      # This method is used to retrieve the expiration time for the cookie.
+      #
+      # @return [Time] The expiration time for the cookie, or +nil+ if none is
+      #   set (i.e., for non-persistent session cookies).
+      #
+      def getExpiration
+        ret = __getExpiration
+        ret.nil? ? ret : Time.at(ret.time/1000.0)
+      end
+
+      # Install ourselves into the current +ICookie+ java class
+      # @param [ICookie] cookie instance
+      #
+      def self.implant(cookie)
+        unless cookie.implanted? || cookie.nil?
+          pp [:implanting, cookie, cookie.class] if $DEBUG
+          cookie.class.class_exec(cookie) do |cookie|
+            a_methods = %w{
+              getExpiration
+            }
+            a_methods.each do |meth|
+              pp ["__" + meth, self] if $DEBUG
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::Cookie
+            a_methods.each do |meth|
+              pp [meth, self] if $DEBUG
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                pp [ruby_meth, meth, self] if $DEBUG
+                define_method ruby_meth, Buby::Implants::Cookie.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        cookie
+      end
+    end
+  end
+end

data/lib/buby/implants/extension_helpers.rb

@@ -0,0 +1,286 @@
+class Buby
+  module Implants
+    # This interface contains a number of helper methods, which extensions can
+    # use to assist with various common tasks that arise for Burp extensions.
+    #
+    # Extensions can call +IBurpExtenderCallbacks.getHelpers()+ to obtain an
+    # instance of this interface.
+    # This module is used to extend the JRuby proxy class returned by Burp.
+    #
+    module ExtensionHelpers
+      # This method can be used to analyze an HTTP request, and obtain various
+      # key details about it. The resulting +IRequestInfo+ object
+      # will not include the full request URL.
+      #
+      # @overload analyzeRequest(request)
+      #   Analyze a +HttpRequestResponse+ object.
+      #   @param [IHttpRequestResponse] request The request to be analyzed.
+      # @overload analyzeRequest(httpService, request)
+      #   Analyze a request from a +HttpService+ object, and a +String+ or
+      #     +byte[]+.
+      #   @param [IHttpService] http_service HTTP service description
+      #   @param [String, Array<byte>] request The request to be analyzed
+      # @overload analyzeRequest(request)
+      #   Analyze a +String+ or +byte[]+ request. To obtain the full URL, use one
+      # of the other overloaded {#analyzeRequest} methods.
+      #   @param [String, Array<byte>] request The request to be analyzed
+      # @return [IRequestInfo] object (wrapped with Ruby goodness)
+      #   that can be queried to obtain details about the request.
+      #
+      def analyzeRequest(*args)
+        pp [:got_analyze_request, *args] if $DEBUG
+        args[-1] = args[-1].to_java_bytes if args[-1].respond_to? :to_java_bytes
+        Buby::Implants::RequestInfo.implant(__analyzeRequest(*args))
+      end
+
+      # This method can be used to analyze an HTTP response, and obtain various
+      # key details about it.
+      #
+      # @param [String, Array<byte>] response The response to be analyzed.
+      # @return [IResponseInfo] object (wrapped with Ruby goodness) that can be
+      #   queried to obtain details about the response.
+      #
+      def analyzeResponse(response)
+        pp [:got_analyze_response, response] if $DEBUG
+        response = response.to_java_bytes if response.respond_to? :to_java_bytes
+        Buby::Implants::ResponseInfo.implant(__analyzeResponse(response))
+      end
+
+      # This method can be used to retrieve details of a specified parameter
+      # within an HTTP request. <b>Note:</b> Use {#analyzeRequest} to obtain
+      # details of all parameters within the request.
+      #
+      # @param [String, Array<byte>] request The request to be inspected for the
+      #   specified parameter.
+      # @param [String] parameter_name The name of the parameter to retrieve.
+      # @return [IParameter] object that can be queried to obtain details
+      #   about the parameter, or +nil+ if the parameter was not found.
+      #
+      def getRequestParameter(request, parameter_name)
+        pp [:got_get_request_parameter, parameter_name, request] if $DEBUG
+        request = request.to_java_bytes if request.respond_to? :to_java_bytes
+        Buby::Implants::Parameter.implant(__getRequestParameter(request, parameter_name))
+      end
+
+      # This method searches a piece of data for the first occurrence of a
+      # specified pattern. It works on byte-based data in a way that is similar
+      # to the way the native Java method +String.indexOf()+ works on
+      # String-based data.
+      # @note This method is only wrapped for testing purposes. There are better ways to do this in the JRuby runtime.
+      #
+      # @param [String, Array<byte>] data The data to be searched.
+      # @param [String, Array<byte>] pattern The pattern to be searched for.
+      # @param [Boolean] case_sensitive Flags whether or not the search is case-sensitive.
+      # @param [Fixnum] from The offset within +data+ where the search should begin.
+      # @param [Fixnum] to The offset within +data+ where the search should end.
+      # @return The offset of the first occurrence of the pattern within the specified bounds, or nil if no match is found.
+      #
+      def indexOf(data, pattern, case_sensitive, from, to)
+        pp [:got_index_of, case_sensitive, from, to, data, pattern] if $DEBUG
+        data = data.to_java_bytes if data.respond_to?(:to_java_bytes)
+        pattern = pattern.to_java_bytes if data.respond_to?(:to_java_bytes)
+        ret = __indexOf(data, pattern, case_sensitive, from, to)
+        ret == -1 ? nil : ret
+      end
+
+      # This method builds an HTTP message containing the specified headers and
+      # message body. If applicable, the Content-Length header will be added or
+      # updated, based on the length of the body.
+      #
+      # @param [Array<String>] headers A list of headers to include in the message.
+      # @param [String, Array<byte>] body The body of the message, or +nil+ if the message has an empty body.
+      # @return [String] The resulting full HTTP message.
+      #
+      def buildHttpMessage(headers, body)
+        pp [:got_build_http_message, headers, body] if $DEBUG
+        body = body.to_java_bytes if body.respond_to?(:to_java_bytes)
+        String.from_java_bytes(__buildHttpMessage(headers, body))
+      end
+
+      # This method creates a GET request to the specified URL. The headers used
+      # in the request are determined by the Request headers settings as
+      # configured in Burp Spider's options.
+      #
+      # @param [URL, #to_s] url The URL to which the request should be made.
+      # @return [String] A request to the specified URL.
+      #
+      def buildHttpRequest(url)
+        pp [:got_build_http_request, url] if $DEBUG
+        url = Java::JavaNet::URL.new url.to_s unless url.kind_of?(Java::JavaNet::URL)
+        String.from_java_bytes __buildHttpRequest(url)
+      end
+
+      # This method adds a new parameter to an HTTP request, and if appropriate
+      # updates the Content-Length header.
+      #
+      # @param [String, Array<byte>, IHttpRequestResponse] request The request
+      #   to which the parameter should be added.
+      # @param [IParameter, Hash] parameter An +IParameter+ object containing
+      #   details of the parameter to be added. Supported parameter types are:
+      #   * +PARAM_URL+
+      #   * +PARAM_BODY+
+      #   * +PARAM_COOKIE+
+      # @return [String] A new HTTP request with the new parameter added.
+      #
+      # @todo Switch IHttpRequestResponse to new Buby::Implants functionality (2.0)
+      def addParameter(request, parameter)
+        pp [:got_addParameter, parameter, request] if $DEBUG
+        request = request.request if request.kind_of? Java::Burp::IHttpRequestResponse
+        request = request.to_java_bytes if request.respond_to? :to_java_bytes
+        parameter = Buby::Parameter::Base.new parameter if parameter.kind_of? Hash
+        String.from_java_bytes(__addParameter(request, parameter))
+      end
+
+      # This method removes a parameter from an HTTP request, and if appropriate
+      # updates the Content-Length header.
+      #
+      # @param [String, Array<byte>, IHttpRequestResponse] request The request
+      #   from which the parameter should be removed.
+      # @param [IParameter, Hash] parameter Object containing details of the
+      #   parameter to be removed. Supported parameter types are:
+      #   * +PARAM_URL+
+      #   * +PARAM_BODY+
+      #   * +PARAM_COOKIE+
+      # @return [String] A new HTTP request with the parameter removed.
+      #
+      # @todo Switch IHttpRequestResponse to new Buby::Implants functionality (2.0)
+      def removeParameter(request, parameter);
+        pp [:got_addParameter, parameter, request] if $DEBUG
+        request = request.request if request.kind_of? Java::Burp::IHttpRequestResponse
+        request = request.to_java_bytes if request.respond_to? :to_java_bytes
+        parameter = Buby::Parameter::Base.new parameter if parameter.kind_of? Hash
+        String.from_java_bytes(__removeParameter(request, parameter))
+      end
+
+      # This method updates the value of a parameter within an HTTP request, and
+      # if appropriate updates the Content-Length header.
+      # @note: This method can only be used to update the value of an existing
+      #   parameter of a specified type. If you need to change the type of an
+      #   existing parameter, you should first call {#removeParameter} to remove
+      #   the parameter with the old type, and then call {#addParameter} to add
+      #   a parameter with the new type.
+      #
+      # @param [String, Array<byte>, IHttpRequestResponse] request The request
+      #   containing the parameter to be updated.
+      # @param [IParameter, Hash] parameter Object containing details of the
+      #   parameter to be updated. Supported parameter types are:
+      #   * +PARAM_URL+
+      #   * +PARAM_BODY+
+      #   * +PARAM_COOKIE+
+      # @return [String] A new HTTP request with the parameter updated.
+      #
+      # @todo Switch IHttpRequestResponse to new Buby::Implants functionality (2.0)
+      def updateParameter(request, parameter)
+        pp [:got_updateParameter, parameter, request] if $DEBUG
+        request = request.request if request.kind_of? Java::Burp::IHttpRequestResponse
+        request = request.to_java_bytes if request.respond_to? :to_java_bytes
+        parameter = Buby::Parameter::Base.new parameter if parameter.kind_of? Hash
+        String.from_java_bytes(__updateParameter(request, parameter))
+      end
+
+      # This method can be used to toggle a request's method between GET and
+      # POST. Parameters are relocated between the URL query string and message
+      # body as required, and the Content-Length header is created or removed as
+      # applicable.
+      #
+      # @param [String, Array<byte>, IHttpRequestResponse] request The HTTP
+      #  request whose method should be toggled.
+      # @return [String} A new HTTP request using the toggled method.
+      #
+      # @todo Switch IHttpRequestResponse to new Buby::Implants functionality (2.0)
+      def toggleRequestMethod(request)
+        pp [:got_toggleRequestMethod, request] if $DEBUG
+        request = request.request if request.kind_of? Java::Burp::IHttpRequestResponse
+        request = request.to_java_bytes if request.respond_to? :to_java_bytes
+        String.from_java_bytes(__toggleRequestMethod(request))
+      end
+
+      # This method constructs an +IHttpService+ object based on the
+      # details provided.
+      #
+      # @overload buildHttpService(host, port, protocol)
+      #   @param [String] host The HTTP service host.
+      #   @param [Fixnum] port The HTTP service port.
+      #   @param [String] protocol The HTTP service protocol.
+      # @overload buildHttpService(host, port, use_https)
+      #   @param [String] host The HTTP service host.
+      #   @param [Fixnum] port The HTTP service port.
+      #   @param [Boolean] use_https Flags whether the HTTP service protocol is HTTPS or HTTP.
+      # @return [IHttpService] object based on the details provided.
+      #
+      def buildHttpService(host, port, protocol)
+        pp [:got_buildHttpService, host, port, protocol] if $DEBUG
+        Buby::Implants::HttpService.implant(__buildHttpService(host, port, protocol))
+      end
+
+      # This method constructs an +IParameter+ object based on the details
+      #   provided.
+      #
+      # @param [String] name The parameter name.
+      # @param [String] value The parameter value.
+      # @param [Fixnum] type The parameter type, as defined in the
+      #   +IParameter+ interface.
+      # @return [IParameter] object based on the details provided.
+      def buildParameter(name, value, type)
+        pp [:got_buildParameter, name, value, type] if $DEBUG
+        Buby::Implants::Parameter.implant(__buildParameter(name, value, type))
+      end
+
+      # This method constructs an +IScannerInsertionPoint+ object based on the
+      #  details provided. It can be used to quickly create a simple insertion
+      #  point based on a fixed payload location within a base request.
+      #
+      # @param [String] insertion_point_name The name of the insertion point.
+      # @param [String, Array<byte>, IHttpRequestResponse] base_request The request from which to
+      #  build scan requests.
+      # @param [Fixnum] from The offset of the start of the payload location.
+      # @param [Fixnum] to The offset of the end of the payload location.
+      # @return [IScannerInsertionPoint] object based on the details provided.
+      #
+      # @todo Switch IHttpRequestResponse to new Buby::Implants functionality (2.0)
+      def makeScannerInsertionPoint(insertion_point_name, base_request, from, to)
+        pp [:got_makeScannerInsertionPoint, insertion_point_name, base_request, from, to] if $DEBUG
+        base_request = base_request.request if base_request.kind_of? Java::Burp::IHttpRequestResponse
+        base_request = base_request.to_java_bytes if base_request.respond_to? :to_java_bytes
+        Buby::Implants::ScannerInsertionPoint.implant(__makeScannerInsertionPoint(insertion_point_name, base_request, from, to))
+      end
+
+      # Install ourselves into the current +IExtensionHelpers+ java class
+      # @param [IExtensionHelpers] helpers
+      #
+      def self.implant(helpers)
+        unless helpers.implanted? || helpers.nil?
+          pp [:implanting, helpers, helpers.class] if $DEBUG
+          helpers.class.class_exec(helpers) do |helpers|
+            a_methods = %w{
+              analyzeRequest
+              analyzeResponse
+              getRequestParameter
+              indexOf
+              buildHttpMessage
+              buildHttpRequest
+              addParameter
+              removeParameter
+              updateParameter
+              toggleRequestMethod
+              buildHttpService
+              buildParameter
+              makeScannerInsertionPoint            
+            }
+            a_methods.each do |meth|
+              alias_method "__"+meth.to_s, meth
+            end
+            include Buby::Implants::ExtensionHelpers
+            a_methods.each do |meth|
+              java_class.ruby_names_for_java_method(meth).each do |ruby_meth|
+                define_method ruby_meth, Buby::Implants::ExtensionHelpers.instance_method(meth)
+              end
+            end
+            include Buby::Implants::Proxy
+          end
+        end
+        helpers
+      end
+    end
+  end
+end