Class: Buby

Inherits:
Object
  • Object
show all
Defined in:
lib/buby.rb,
lib/buby/extends/scan_issue.rb,
lib/buby/extends/buby_array_wrapper.rb,
lib/buby/extends/http_request_response.rb

Overview

Buby is a mash-up of the commercial security testing web proxy PortSwigger Burp Suite(tm) allowing you to add scripting to Burp. Burp is driven from and tied to JRuby with a Java extension using the BurpExtender API.

The Buby class is an abstract implementation of a BurpExtender ruby handler. Included are several abstract event handlers used from the BurpExtender java implementation:

  • evt_extender_init

  • evt_proxy_message

  • evt_command_line_args

  • evt_register_callbacks

  • evt_application_closing

Buby also supports the newer event handlers available in Burp 1.2.09 and up:

  • evt_http_message

  • evt_scan_issue

This class also exposes several methods to access Burp functionality and user interfaces through the IBurpExtenderCallbacks interface (note, several abbreviated aliases also exist for each):

  • doActiveScan

  • doPassiveScan

  • excludeFromScope

  • includeInScope

  • isInScope

  • issueAlert

  • makeHttpRequest

  • sendToIntruder

  • sendToRepeater

  • sendToSpider

Buby also provides front-end ruby methods for the various callback methods supported by Burp. New callbacks have been cropping up in newer Burp versions frequently.

Available since Burp 1.2.09:

  • getProxyHistory

  • getSiteMap

  • restoreState

  • saveState

  • getParameters

  • getHeaders

Available since Burp 1.2.15:

  • getScanIssues

Available since Burp 1.2.17:

  • exitSuite

If you wish to access any of the IBurpExtenderCallbacks methods directly. You can use 'burp_callbacks' to obtain a reference.

Credit:

  • Burp and Burp Suite are trade-marks of PortSwigger Ltd.

    Copyright 2011 PortSwigger Ltd. All rights reserved.
    See http://portswigger.net for license terms.
  • This ruby library and the accompanying BurpExtender.java implementation were written by Eric Monti @ Matasano Security.

    Matasano claims no professional or legal affiliation with PortSwigger LTD. nor do we sell or officially endorse any of their products.

    However, this author would like to express his personal and professional respect and appreciation for their making available the BurpExtender extension API. The availability of this interface in an already great tool goes a long way to make Burp Suite a truly first-class application.

  • Forgive the name. It won out over "Burb" and "BurpRub". It's just easier to type and say out-loud. Mike Tracy gets full credit as official Buby-namer.

Defined Under Namespace

Modules: HttpRequestResponseHelper, ScanIssueHelper Classes: BubyArrayWrapper, HttpRequestResponseList, ScanIssuesList

Constant Summary

VERSION =
if File.file?(f=::File.expand_path(File.join(::File.dirname(__FILE__), "../VERSION")))
  File.read(f).chomp
end
LIBPATH =

:stopdoc:

::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
PATH =
::File.dirname(LIBPATH) + ::File::SEPARATOR
ACTION_FOLLOW_RULES =
BurpExtender::ACTION_FOLLOW_RULES
ACTION_DO_INTERCEPT =
BurpExtender::ACTION_DO_INTERCEPT
ACTION_DONT_INTERCEPT =
BurpExtender::ACTION_DONT_INTERCEPT
ACTION_DROP =
BurpExtender::ACTION_DROP
ACTION_FOLLOW_RULES_AND_REHOOK =
BurpExtender::ACTION_FOLLOW_RULES_AND_REHOOK
ACTION_DO_INTERCEPT_AND_REHOOK =
BurpExtender::ACTION_DO_INTERCEPT_AND_REHOOK
ACTION_DONT_INTERCEPT_AND_REHOOK =
BurpExtender::ACTION_DONT_INTERCEPT_AND_REHOOK

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Buby) initialize(other = nil)

:startdoc:



94
95
96
97
98
99
100
# File 'lib/buby.rb', line 94

def initialize(other=nil)
  if other
    raise "arg 0 must be another kind of Buby" unless other.is_a? Buby
    @burp_extender = other.burp_extender
    @burp_callbacks = other.burp_callbacks
  end
end

Class Method Details

+ (Boolean) burp_loaded?

Checks the Java namespace to see if Burp has been loaded.

Returns:

  • (Boolean)


831
832
833
834
835
836
837
838
# File 'lib/buby.rb', line 831

def self.burp_loaded?
  @burp_loaded ||= begin
    java_import 'burp.StartBurp'
    true
  rescue NameError
    false
  end
end

+ (Object) libpath(*args)

Returns the library path for the module. If any arguments are given, they will be joined to the end of the libray path using File.join.



846
847
848
# File 'lib/buby.rb', line 846

def self.libpath( *args )
  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
end

+ (Object) load_burp(jar_path)

Attempts to load burp with require and confirm it provides the required class in the Java namespace.

Returns: true/false depending on whether the required jar provides us the required class

Raises: may raise the usual require exceptions if jar_path is bad.



825
826
827
828
# File 'lib/buby.rb', line 825

def self.load_burp(jar_path)
  require jar_path
  return burp_loaded?
end

+ (Object) path(*args)

Returns the lpath for the module. If any arguments are given, they will be joined to the end of the path using File.join.



854
855
856
# File 'lib/buby.rb', line 854

def self.path( *args )
  args.empty? ? PATH : ::File.join(PATH, args.flatten)
end

+ (Object) require_all_libs_relative_to(fname, dir = nil)

Utility method used to require all files ending in .rb that lie in the directory below this file that has the same name as the filename passed in. Optionally, a specific directory name can be passed in such that the filename does not have to be equivalent to the directory.



863
864
865
866
867
868
869
# File 'lib/buby.rb', line 863

def self.require_all_libs_relative_to( fname, dir = nil )
  dir ||= ::File.basename(fname, '.*')
  search_me = ::File.expand_path(
      ::File.join(::File.dirname(fname), dir, '**', '*.rb'))

  Dir.glob(search_me).sort.each {|rb| require rb}
end

+ (Object) start_burp(h_class = nil, init_args = nil, args = nil)

Starts burp using a supplied handler class,

h_class = Buby or a derived class. instance of which will become handler.
args = arguments to Burp
init_args = arguments to the handler constructor

Returns the handler instance


811
812
813
814
815
816
# File 'lib/buby.rb', line 811

def self.start_burp(h_class=nil, init_args=nil, args=nil)
  h_class ||= self
  init_args ||= []
  args ||= []
  h_class.new(*init_args).start_burp(args)
end

Instance Method Details

- (Object) _check_and_callback(meth, *args)

This method is a __send__ callback gate for the IBurpExtenderCallbacks reference. It first checks to see if a method is available before calling with the specified arguments, and raises an exception if it is unavailable.

  • meth = string or symbol name of method

  • args = variable length array of arguments to pass to meth



257
258
259
260
261
262
263
# File 'lib/buby.rb', line 257

def _check_and_callback(meth, *args)
  cb = _check_cb
  unless cb.respond_to?(meth)
    raise "#{meth} is not available in your version of Burp"
  end
  cb.__send__ meth, *args
end

- (Object) _check_cb

Internal method to check for the existence of the burp_callbacks reference before doing anything with it.



120
121
122
# File 'lib/buby.rb', line 120

def _check_cb
  @burp_callbacks or raise "Burp callbacks have not been set"
end

- (Object) activate!

Makes this handler the active Ruby handler object for the BurpExtender Java runtime. (there can be only one!)



104
105
106
# File 'lib/buby.rb', line 104

def activate!
  BurpExtender.set_handler(self)
end

- (Object) addToSiteMap(item) Also known as: add_to_site_map

This method can be used to add an item to Burp's site map with the specified request/response details. This will overwrite the details of any existing matching item in the site map.

This method is only available with Burp 1.3.09+

Parameters:

  • item

    Details of the item to be added to the site map



380
381
382
# File 'lib/buby.rb', line 380

def addToSiteMap(item)
  _check_and_callback(:addToSiteMap, item)
end

- (Object) burp_callbacks

Returns the internal reference to the IBupExtenderCallbacks instance. This reference gets set from Java through the evt_register_callbacks method. It is exposed to allow you to access the IBurpExtenderCallbacks instance directly if you so choose.



116
# File 'lib/buby.rb', line 116

def burp_callbacks; @burp_callbacks; end

- (Object) burp_extender

Returns the internal reference to the BurpExtender instance. This reference gets set from Java through the evt_extender_init method.



110
# File 'lib/buby.rb', line 110

def burp_extender; @burp_extender; end

- (Object) doActiveScan(host, port, https, req, ip_off) Also known as: do_active_scan, active_scan

Send an HTTP request to the Burp Scanner tool to perform an active vulnerability scan.

* host = The hostname of the remote HTTP server.
* port = The port of the remote HTTP server.
* https = Flags whether the protocol is HTTPS or HTTP.
* req  = The full HTTP request. (String or Java bytes[])
* ip_off = A list of index pairs representing the
* positions of the insertion points that should be scanned. Each item in
* the list must be an int[2] array containing the start and end offsets
* for the insertion point. *1.4+* only


135
136
137
138
# File 'lib/buby.rb', line 135

def doActiveScan(host, port, https, req, ip_off)
  req = req.to_java_bytes if req.is_a? String
  getBurpVersion ? _check_cb.doActiveScan(host, port, https, req, ip_off) : _check_cb.doActiveScan(host, port, https, req)
end

- (Object) doPassiveScan(host, port, https, req, rsp) Also known as: do_passive_scan, passive_scan

Send an HTTP request and response to the Burp Scanner tool to perform a passive vulnerability scan.

* host = The hostname of the remote HTTP server.
* port = The port of the remote HTTP server.
* https = Flags whether the protocol is HTTPS or HTTP.
* req  = The full HTTP request. (String or Java bytes[])
* rsp  = The full HTTP response. (String or Java bytes[])


149
150
151
152
153
# File 'lib/buby.rb', line 149

def doPassiveScan(host, port, https, req, rsp)
  req = req.to_java_bytes if req.is_a? String
  rsp = rsp.to_java_bytes if rsp.is_a? String
  _check_cb.doPassiveScan(host, port, https, req, rsp)
end

- (Object) evt_application_closing

This method is called by BurpExtender right before closing the application. Implementations can use this method to perform cleanup tasks such as closing files or databases before exit.



695
696
697
# File 'lib/buby.rb', line 695

def evt_application_closing 
  pp([:got_app_close]) if $DEBUG
end

- (Object) evt_command_line_args(args)

This method is called by the BurpExtender implementation Burp startup. The args parameter contains main()'s argv command-line arguments array.

Note: This maps to the 'setCommandLineArgs' method in the java implementation of BurpExtender.

The return value is ignored.



461
462
463
# File 'lib/buby.rb', line 461

def evt_command_line_args args
  pp([:got_args, args]) if $DEBUG
end

- (Object) evt_extender_init(ext)

This method is called by the BurpExtender java implementation upon initialization of the BurpExtender instance for Burp. The args parameter is passed with a instance of the newly initialized BurpExtender instance so that implementations can access and extend its public interfaces.

The return value is ignored.



449
450
451
452
# File 'lib/buby.rb', line 449

def evt_extender_init ext
  @burp_extender = ext
  pp([:got_extender, ext]) if $DEBUG
end

- (Object) evt_http_message(tool_name, is_request, message_info)

This method is invoked whenever any of Burp's tools makes an HTTP request or receives a response. This is effectively a generalised version of the pre-existing evt_proxy_message method, and can be used to intercept and modify the HTTP traffic of all Burp tools.

IMPORTANT: This event handler is only used in Burp version 1.2.09 and higher.

Note: this method maps to the processHttpMessage BurpExtender Java method.

This method should be overridden if you wish to implement functionality relating to generalized requests and responses from any BurpSuite tool.

You may want to use evt_proxy_message if you only intend to work on proxied messages. Note, however, the IHttpRequestResponse Java object is not used in evt_proxy_message and gives evt_http_message a somewhat nicer interface to work with.

Parameters:

  • tool_name = a string name of the tool that generated the message

  • is_request = boolean true = request / false = response

  • message_info = an instance of the IHttpRequestResponse Java class with methods for accessing and manipulating various attributes of the message.



670
671
672
673
# File 'lib/buby.rb', line 670

def evt_http_message(tool_name, is_request, message_info)
  HttpRequestResponseHelper.implant(message_info)
  pp([:got_http_message, tool_name, is_request, message_info]) if $DEBUG
end

- (Object) evt_proxy_message(msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, message, action)

This method is called by BurpExtender while proxying HTTP messages and before passing them through the Burp proxy. Implementations can use this method to implement arbitrary processing upon HTTP requests and responses such as interception, logging, modification, and so on.

The 'is_req' parameter indicates whether it is a response or request.

Note: This method maps to the 'processProxyMessage' method in the java implementation of BurpExtender.

See also, evt_proxy_message_raw which is actually called before this in the BurpExtender processProxyMessage handler.

Below are the parameters descriptions based on the IBurpExtender javadoc. Where applicable, decriptions have been modified for local parameter naming and other ruby-specific details added.

  • msg_ref: An identifier which is unique to a single request/response pair. This can be used to correlate details of requests and responses and perform processing on the response message accordingly. This number also corresponds to the Burp UI's proxy "history" # column.

  • is_req: (true/false) Flags whether the message is a client request or a server response.

  • rhost: The hostname of the remote HTTP server.

  • rport: The port of the remote HTTP server.

  • is_https: Flags whether the protocol is HTTPS or HTTP.

  • http_meth: The method verb used in the client request.

  • url: The requested URL. Set in both the request and response.

  • resourceType: The filetype of the requested resource, or nil if the resource has no filetype.

  • status: The HTTP status code returned by the server. This value is nil for request messages.

  • req_content_type: The content-type string returned by the server. This value is nil for request messages.

  • message: The full HTTP message.

    **Ruby note:

    For convenience, the message is received and returned as a ruby 
    String object. Internally within Burp it is handled as a java byte[] 
    array. See also the notes about the return object below.
  • action: An array containing a single integer, allowing the implementation to communicate back to Burp Proxy a non-default interception action for the message. The default value is ACTION_FOLLOW_RULES (or 0). Possible values include:

    ACTION_FOLLOW_RULES = 0
    ACTION_DO_INTERCEPT = 1
    ACTION_DONT_INTERCEPT = 2
    ACTION_DROP = 3

    Refer to the BurpExtender.java source comments for more details.

Return Value:

Implementations should return either (a) the same object received
in the message paramater, or (b) a different object containing a 
modified message.

**IMPORTANT RUBY NOTE: Always be sure to return a new object if making modifications to messages.

Explanation: The (a) and (b) convention above is followed rather literally during type conversion on the return value back into the java BurpExtender.

When determining whether a change has been made in the message or not, the decision is made based on whether the object returned is the same as the object submitted in the call to evt_proxy_message.

So, for example, using in-place modification of the message using range substring assignments or destructive method variations like String.sub!() and String.gsub! alone won't work because the same object gets returned to BurpExtender.

In short, this means that if you want modifications to be made, be sure to return a different String than the one you got in your handler.

So for example this code won't do anything at all:

...
message.sub!(/^GET /, "HEAD ")
return message

Nor this:

message[0..4] = "HEAD "
return message

But this will

...
return message.sub(/^GET /, "HEAD ")

And so will this

...
message[0..4] = "HEAD "
return message.dup


625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
# File 'lib/buby.rb', line 625

def evt_proxy_message msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, message, action
  pp([ (is_req)? :got_proxy_request : :got_proxy_response,
       [:msg_ref, msg_ref], 
       [:is_req, is_req], 
       [:rhost, rhost], 
       [:rport, rport], 
       [:is_https, is_https], 
       [:http_meth, http_meth], 
       [:url, url], 
       [:resourceType, resourceType], 
       [:status, status], 
       [:req_content_type, req_content_type], 
       [:message, message], 
       [:action, action[0]] ]) if $DEBUG
  
  return message
end

- (Object) evt_proxy_message_raw(msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, message, action)

Seems we need to specifically render our 'message' to a string here in ruby. Otherwise there's flakiness when converting certain binary non-ascii sequences. As long as we do it here, it should be fine.

Note: This method maps to the 'processProxyMessage' method in the java implementation of BurpExtender.

This method just handles the conversion to and from evt_proxy_message which expects a message string



495
496
497
498
499
500
501
502
503
# File 'lib/buby.rb', line 495

def evt_proxy_message_raw msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, message, action
  pp [:evt_proxy_message_raw_hit, msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, message, action ] if $DEBUG

  str_msg = String.from_java_bytes(message)
  ret = evt_proxy_message(msg_ref, is_req, rhost, rport, is_https, http_meth, url, resourceType, status, req_content_type, str_msg, action)

  message = ret.to_java_bytes if ret.object_id != str_msg.object_id
  return message
end

- (Object) evt_register_callbacks(cb)

This method is called by BurpExtender on startup to register Burp's IBurpExtenderCallbacks interface object.

This maps to the 'registerExtenderCallbacks' method in the Java implementation of BurpExtender.

The return value is ignored.



472
473
474
475
476
# File 'lib/buby.rb', line 472

def evt_register_callbacks cb
  @burp_callbacks = cb
  cb.issueAlert("[JRuby::#{self.class}] registered callback")
  pp([:got_callbacks, cb]) if $DEBUG
end

- (Object) evt_scan_issue(issue)

This method is invoked whenever Burp Scanner discovers a new, unique issue, and can be used to perform customised reporting or logging of detected issues.

IMPORTANT: This event handler is only used in Burp version 1.2.09 and higher.

Note: this method maps to the BurpExtender Java method.

Parameters:

  • issue = an instance of the IScanIssue Java class with methods for viewing information on the scan issue that was generated.



687
688
689
690
# File 'lib/buby.rb', line 687

def evt_scan_issue(issue)
  ScanIssueHelper.implant(issue)
  pp([:got_scan_issue, issue]) if $DEBUG
end

- (Object) excludeFromScope(url) Also known as: exclude_from_scope, exclude_scope

Exclude the specified URL from the Suite-wide scope.

* url = The URL to exclude from the Suite-wide scope.


159
160
161
162
# File 'lib/buby.rb', line 159

def excludeFromScope(url)
  url = java.net.URL.new(url) if url.is_a? String
  _check_cb.excludeFromScope(url)
end

- (Object) exitSuite(prompt_user = false) Also known as: exit_suite, close

Shuts down Burp programatically. If the method returns the user cancelled the shutdown prompt.



350
351
352
# File 'lib/buby.rb', line 350

def exitSuite(prompt_user=false)
  _check_and_callback(:exitSuite, prompt_user ? true : false)
end

- (Object) getBurpVersion Also known as: burp_version

This method can be used to determine the version of the loaded burp at runtime. This is included in the Javadoc for the extension interfaces but not the supplied interface files.

Returns:

  • String array containing the product name, major version, and minor version.



432
433
434
435
436
437
438
# File 'lib/buby.rb', line 432

def getBurpVersion
  begin
    _check_and_callback(:getBurpVersion)
  rescue
    nil
  end
end

- (Object) getHeaders(msg) Also known as: headers, get_headers

Parses a raw HTTP message (request or response ) and returns an associative array containing the headers as they are structured in the 'Headers' tab in the Burp request/response viewer UI.

IMPORTANT: This method is only available with Burp 1.2.09 and higher.

msg = raw request/response (String or Java bytes[])



341
342
343
344
# File 'lib/buby.rb', line 341

def getHeaders(msg)
  msg = msg.to_java_bytes if msg.is_a? String
  _check_and_callback(:getHeaders, msg)
end

- (Object) getParameters(req) Also known as: parameters, get_parameters

Parses a raw HTTP request message and returns an associative array containing parameters as they are structured in the 'Parameters' tab in the Burp request UI.

IMPORTANT: This method is only available with Burp 1.2.09 and higher.

req = raw request (String or Java bytes[])



326
327
328
329
# File 'lib/buby.rb', line 326

def getParameters(req)
  req = req.to_java_bytes if req.is_a? String
  _check_and_callback(:getParameters, req)
end

- (Object) getProxyHistory Also known as: proxy_history, get_proxy_history

Returns a Java array of IHttpRequestResponse objects pulled directly from the Burp proxy history.



268
269
270
# File 'lib/buby.rb', line 268

def getProxyHistory
  HttpRequestResponseList.new(_check_and_callback(:getProxyHistory))
end

- (Object) getScanIssues(urlprefix = nil) Also known as: scan_issues, get_scan_issues

This method returns all of the current scan issues for URLs matching the specified literal prefix. The prefix can be nil to match all issues.

IMPORTANT: This method is only available with Burp 1.2.15 and higher.



289
290
291
# File 'lib/buby.rb', line 289

def getScanIssues(urlprefix=nil)
  ScanIssuesList.new( _check_and_callback(:getScanIssues, urlprefix) )
end

- (Object) getSiteMap(urlprefix = nil) Also known as: site_map, get_site_map

Returns a Java array of IHttpRequestResponse objects pulled directly from the Burp site map for all urls matching the specified literal prefix. The prefix can be nil to return all objects.



278
279
280
# File 'lib/buby.rb', line 278

def getSiteMap(urlprefix=nil)
  HttpRequestResponseList.new(_check_and_callback(:getSiteMap, urlprefix))
end

- (Object) harvest_cookies_from_history(cookie = nil, urlrx = nil, statefile = nil)

Harvest cookies from a session's proxy history.

Params:

cookie    = optional: name of cookie to harvest
urlrx     = optional: regular expression to match urls against
statefile = optional: filename for a burp session file to temporarily load
            and harvest from.

Takes an optional block as additional 'select' criteria for cookies. The block return value of true/false will determine whether a cookie string is selected.



783
784
785
786
787
788
789
790
791
792
793
# File 'lib/buby.rb', line 783

def harvest_cookies_from_history(cookie=nil, urlrx=nil, statefile=nil)
  ret = []
  search_proxy_history(statefile, urlrx) do |hrr|
    if heads=hrr.rsp_headers
      ret += heads.select do |h| 
        h[0].downcase == 'set-cookie' and (not block_given? or yield(h[1]))
      end.map{|h| h[1]}
    end
  end
  return ret
end

- (Object) includeInScope(url) Also known as: include_in_scope, include_scope

Include the specified URL in the Suite-wide scope.

* url = The URL to exclude in the Suite-wide scope.


168
169
170
171
# File 'lib/buby.rb', line 168

def includeInScope(url)
  url = java.net.URL.new(url) if url.is_a? String
  _check_cb.includeInScope(url)
end

- (Object) isInScope(url) Also known as: is_in_scope, in_scope?

Query whether a specified URL is within the current Suite-wide scope.

* url = The URL to query

Returns: true / false



179
180
181
182
# File 'lib/buby.rb', line 179

def isInScope(url)
  url = java.net.URL.new(url) if url.is_a? String
  _check_cb.isInScope(url)
end

- (Object) issueAlert(msg) Also known as: issue_alert, alert

Display a message in the Burp Suite alerts tab.

* msg =  The alert message to display.


188
189
190
# File 'lib/buby.rb', line 188

def issueAlert(msg)
  _check_cb.issueAlert(msg.to_s)
end

- (Object) loadConfig(conf) Also known as: load_config, config=

This method causes Burp to load a new configuration from the Map of name/value Strings provided. Any settings not specified in the Map will be restored to their default values. To selectively update only some settings and leave the rest unchanged, you should first call saveConfig to obtain Burp's current configuration, modify the relevant items in the Map, and then call loadConfig with the same Map.

configuration.

This method is only available with Burp 1.3.09+

Parameters:

  • config

    A map of name/value Strings to use as Burp's new



410
411
412
# File 'lib/buby.rb', line 410

def loadConfig(conf)
  _check_and_callback(:loadConfig, conf)
end

- (Object) makeHttpRequest(host, port, https, req) Also known as: make_http_request, make_request

Issue an arbitrary HTTP request and retrieve its response

* host  = The hostname of the remote HTTP server.
* port  = The port of the remote HTTP server.
* https = Flags whether the protocol is HTTPS or HTTP.
* req   = The full HTTP request. (String or Java bytes[])

Returns: The full response retrieved from the remote server.



201
202
203
204
# File 'lib/buby.rb', line 201

def makeHttpRequest(host, port, https, req)
  req = req.to_java_bytes if req.is_a? String
  String.from_java_bytes( _check_cb.makeHttpRequest(host, port, https, req) )
end

- (Object) registerMenuItem(menuItemCaption, menuItemHandler) Also known as: register_menu_item

This method can be used to register a new menu item which will appear on the various context menus that are used throughout Burp Suite to handle user-driven actions.

on the menu item.

This method is only available with Burp 1.3.07 and higher.

Parameters:

  • menuItemCaption

    The caption to be displayed on the menu item.

  • menuItemHandler

    The handler to be invoked when the user clicks



365
366
367
368
# File 'lib/buby.rb', line 365

def registerMenuItem(menuItemCaption, menuItemHandler)
  _check_and_callback(:registerMenuItem, menuItemCaption, menuItemHandler)
  issueAlert("Handler #{menuItemHandler} registered for \"#{menuItemCaption}\"")
end

- (Object) restoreState(filename) Also known as: restore_state

Restores Burp session state from a previously saved state file. See also: saveState

IMPORTANT: This method is only available with Burp 1.2.09 and higher.

  • filename = path and filename of the file to restore from



302
303
304
# File 'lib/buby.rb', line 302

def restoreState(filename)
  _check_and_callback(:restoreState, java.io.File.new(filename))
end

- (Object) saveConfig Also known as: save_config, config

This method causes Burp to save all of its current configuration as a Map of name/value Strings.

configuration.

This method is only available with Burp 1.3.09+

Returns:

  • A Map of name/value Strings reflecting Burp's current



392
393
394
# File 'lib/buby.rb', line 392

def saveConfig
  _check_and_callback(:saveConfig).to_hash
end

- (Object) saveState(filename) Also known as: save_state

Saves the current Burp session to a state file. See also restoreState.

IMPORTANT: This method is only available with Burp 1.2.09 and higher.

  • filename = path and filename of the file to save to



313
314
315
# File 'lib/buby.rb', line 313

def saveState(filename)
  _check_and_callback(:saveState, java.io.File.new(filename))
end

- (Object) search_proxy_history(statefile = nil, urlrx = nil)

Searches the proxy history for the url's matched by the specified regular expression (returns them all if urlrx is nil).

A statefile to search in can optionally be specified or the existing state will be used if statefile is nil.

This method also accepts an optional block which is passed each of the matched history members.



762
763
764
765
766
767
768
769
770
# File 'lib/buby.rb', line 762

def search_proxy_history(statefile=nil, urlrx=nil)
  ret = []
  with_proxy_history(statefile) do |r|
    if (not urlrx) or r.url.to_s =~ urlrx
      ret << r if (not block_given?) or yield(r)
    end
  end
  return ret
end

- (Object) sendToIntruder(host, port, https, req, ip_off) Also known as: send_to_intruder, intruder

Send an HTTP request to the Burp Intruder tool

* host  = The hostname of the remote HTTP server.
* port  = The port of the remote HTTP server.
* https = Flags whether the protocol is HTTPS or HTTP.
* req   = The full HTTP request.  (String or Java bytes[])
* ip_off = A list of index pairs representing the
* positions of the insertion points that should be scanned. Each item in
* the list must be an int[2] array containing the start and end offsets
* for the insertion point. *1.4.04+* only
*


218
219
220
221
222
223
224
225
# File 'lib/buby.rb', line 218

def sendToIntruder(host, port, https, req, ip_off)
  req = req.to_java_bytes if req.is_a? String
  if self.getBurpVersion.to_a[1..-1].join(".") < "1.4.04"
    _check_cb.sendToIntruder(host, port, https, req)
  else
    _check_cb.sendToIntruder(host, port, https, req, ip_off)
  end
end

- (Object) sendToRepeater(host, port, https, req, tab = nil) Also known as: send_to_repeater, repeater

Send an HTTP request to the Burp Repeater tool.

* host  = The hostname of the remote HTTP server.
* port  = The port of the remote HTTP server.
* https = Flags whether the protocol is HTTPS or HTTP.
* req   = The full HTTP request. (String or Java bytes[])
* tab   = The tab caption displayed in Repeater. (default: auto-generated)


235
236
237
238
# File 'lib/buby.rb', line 235

def sendToRepeater(host, port, https, req, tab=nil)
  req = req.to_java_bytes if req.is_a? String
  _check_cb.sendToRepeater(host, port, https, req, tab)
end

- (Object) sendToSpider(url) Also known as: send_to_spider, spider

Send a seed URL to the Burp Spider tool.

* url = The new seed URL to begin spidering from.


244
245
246
247
# File 'lib/buby.rb', line 244

def sendToSpider(url)
  url = java.net.URL.new(url) if url.is_a? String
  _check_cb.sendToSpider(url)
end

- (Object) setProxyInterceptionEnabled(enabled) Also known as: proxy_interception_enabled, proxy_interception=

This method sets the interception mode for Burp Proxy.

be enabled.

Parameters:

  • enabled

    Indicates whether interception of proxy messages should



423
424
425
# File 'lib/buby.rb', line 423

def setProxyInterceptionEnabled(enabled)
  _check_and_callback(:setProxyInterceptionEnabled, enabled)
end

- (Object) start_burp(args = [])

Prepares the java BurpExtender implementation with a reference to self as the module handler and launches burp suite.



799
800
801
802
803
# File 'lib/buby.rb', line 799

def start_burp(args=[])
  activate!()
  Java::Burp::StartBurp.main(args.to_java(:string))
  return self
end

- (Object) with_proxy_history(statefile = nil)

This is a convenience wrapper which can load a given burp state file and lets its caller to perform actions inside of a block on the proxy history contained in the loaded session.

If a statefile argument isn't specified current burp session state is used.

Yields each entry in the proxy history to a block.



721
722
723
724
725
# File 'lib/buby.rb', line 721

def with_proxy_history(statefile=nil)
  with_statefile(statefile) do |this|
    this.proxy_history.each {|h| yield h }
  end
end

- (Object) with_site_map(urlprefix = nil, statefile = nil)

This is a convenience wrapper which can load a given burp state file and lets its caller to perform actions inside of a block on the site map contained in the loaded session.

If a statefile argument isn't specified current burp session state is used.

Yields each entry in the site map to a block.



708
709
710
711
712
# File 'lib/buby.rb', line 708

def with_site_map(urlprefix=nil, statefile=nil)
  with_statefile(statefile) do |this|
    this.site_map(urlprefix).each {|h| yield h }
  end
end

- (Object) with_statefile(statefile = nil) {|_self| ... }

This is a convenience wrapper which loads a given burp statefile and lets its caller perform actions via burp while its loaded on it inside of a block. The old state is restored after the block completes.

It can safely be run with a nil statefile argument in which the current burp session state is used.

Yields:

  • (_self)

Yield Parameters:

  • _self (Buby)

    the object that the method was called on



733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
# File 'lib/buby.rb', line 733

def with_statefile(statefile=nil)
  if statefile
    # save current state:
    old_state=".#{$$}.#{Time.now.to_i}.state.bak"
    self.alert "Saving current state to temp statefile: #{old_state}"
    self.save_state(old_state)
    self.alert "Restoring state: #{statefile}"
    self.restore_state(statefile)
  end

  yield self

  if statefile
    # restore original state
    self.alert "Restoring temp statefile: #{old_state}"
    self.restore_state old_state
    self.alert "Deleting temp state file: #{old_state}"
    File.unlink old_state
  end
end