I was pretty surprised and pleased when ToorCon finally released videos of the talks at ToorCamp 2009. At this years ToorCon: San Diego DVDs of the talks, pressed by MediaArchives, were handed out. Thanks to Mr. Pierce for grabbing a copy of my talk on Ronin and getting it back to me for transcoding/uploading. The full talk has been transcoded to Ogg Theora and uploaded to vimeo.com. If you have a Vimeo account, you can download the original ogg file as well.

ToorCamp: Ronin – A Platform for Publish and Mayhem

Original slides can be found here, in XHTML form.

Thanks go out to flatline and evoltech for going with me to ToorCamp, providing transportation and helping hitch-hike back when our van broke down. Also extra thanks to evoltech for letting me use his SUV sized laptop to run the slides on.

Update:

Evoltech correctly pointed out that the Wordlist::Builders::Website example was incorrect. The Website.build method must take a path argument and then any additional options.

For a while now people have asked/told me that I should write a Wordlist library for Ruby. People have also brought up the need to build wordlists from existing corpora; such as the text from a website. After seeing varying attempts at this task, I finally got serious and released Wordlist 0.1.0.

Currently, the design of the Wordlist Ruby library is quite simple. Wordlist::Builder is the base class for all wordlist builders. It handles parsing text, filtering out duplicate words, and writing the unique words to a file. The Builder class stores the CRC32 hash of each word in a Hash, mapping the word length to the Set of CRC32 hashes. Using a bucket system for the CRC32 hashes, keeps both word lookup time and memory usage to a minimum.

Wordlist::Builder.build('list.txt') do |builder|
  builder.parse(some_text)
  builder.parse_file('some/file.txt')
end

Wordlist also provides Wordlist::Builders::Website, which uses Spidr to completely spider a host, and build a wordlist from the inner-text recovered from every visited page.

require 'wordlist/builders/website'

Wordlist::Builders::Website.build('list.txt',:host => 'www.example.com')

Wordlist doesn’t just build wordlists, it can also enumerate them. Wordlist defines Wordlist::List as the base class for all wordlist readers. Per convenience, Wordlist also defines Wordlist::FlatFile which handles the enumeration of flat-file wordlists.

list = Wordlist::FlatFile.new('list.txt')
list.each_word do |word|
  puts word
end

The Wordlist::List also provides methods for defining text-mutation rules, which are applied in series to each enumerated word.

list.mutate 'o', '0'
list.mutate '@', 0x41
list.mutate(/[hax]/i) { |match| match.swapcase }

list.each_mutation do |word|
  puts word
end

A mutation rule takes a String or Regexp (which is used to match a sub-string within a word) and another String, Integer or block which is used as a replacement for the matched sub-string. A mutation rule will perform every possible combination of sub-string replacement, passing each mutated word to the next mutation rule, and so on.

One can install Wordlist using rubygems, by simply running the following command:

$ sudo gem install wordlist

The git repository for Wordlist is located on GitHub.

As of 0.1.0, Wordlist is fairly simple but it gets the job done. The library was fun to design and test, as it involved borrowing some techniques typically used in blind-fuzzing. Expect more features and updates to Wordlist as time goes on.

The long wait is over. Ronin 0.3.0, code-named “big-push”, has finally been released.

DataMapper 0.10.0

Ronin was probably one of the first big Ruby apps to upgrade to DataMapper 0.10.0. As a result of this, we had to postpone the release of Ronin 0.3.0, until DataMapper 0.10.0 had finished it’s rigorous two month Q/A cycle.

Once DataMapper 0.10.0 had been released, the two months of Q/A and almost a complete rewrite of the code-base really showed itself. I think @dkubb, @dbussink, @snusnu, @xshay, @myabc, @rsim, @namelessjon, @knowtheory and everyone else who helped with 0.10.0 deserves applause for their hard work and dedication.

YARD

As of 0.3.0, Ronin has successfully moved to YARD based documentation. The new Ronin API docs can be found in the usual location. YARD really helped improve the detail of the Ronin API docs, allowing developers to specify method arguments, accepted object-types, yield arguments, possible exceptions and return-types.

Additionally, YARD handlers were added to Ronin that parsed and regenerated documentation for DataMapper properties/relations. These additional YARD handlers helped improve documentation coverage for Ronin models, such as Ronin::Arch or Ronin::Exploits::Exploit.

Ronin::UI::CommandLine

Ronin::UI::CommandLine was almost entirely refactored in 0.3.0. Ronin::UI::CommandLine::Command was rewritten to use Thor. Switching to Thor greatly simplified the ronin commands, making it easier to write new commands. A good example of this, is the source-code for the install command from before and after 0.3.0.

Another benefit to using Thor, albeit cosmetic, was being able to use Thor’s ANSI color-output. Normal output will now appear in green, warnings in yellow and error messages in red.

New convenience methods were also added to Ronin::UI::CommandLine::Command to help format and print various data: indent, print_title, print_array and print_hash.

Ronin::UI::Output

As of 0.3.0, Ronin::UI::Diagnostics and Ronin::UI::Verbose were replaced with the brand new Ronin::UI::Output module. Ronin::UI::Output is designed to delegate how output is handled. By default all output is sent to Ronin::UI::Output::Handler, which prints the output to the terminal. One can override the default output handler by using Ronin::UI::Output.handler=, to specify the new handler module; which must define print_info, print_debug, print_warning and print_error methods.

Ronin::UI::Output also provides the Helpers module, which can be included into any class and adds the print_info, print_debug, print_warning and print_error methods.

New Convenience Methods

New TCP and UDP networking methods were added to 0.3.0. Now one can easily create TCP/UDP servers using, Net.tcp_server, Net.tcp_server_session, Net.tcp_single_server, Net.udp_server and Net.udp_server_session.

Ronin::Network::HTTP::Proxy was also added to 0.3.0. The Ronin::Network::HTTP::Proxy helps parse and represent HTTP proxy addresses, and is now used by Ronin::Network::HTTP.proxy and all :proxy options.

proxy = Network::HTTP::Proxy.parse('148.233.239.24:80')
# => #<Ronin::Network::HTTP::Proxy: 148.233.239.24:80>

The Proxy class can also be used to test a proxy.

proxy.valid?
# => true
proxy.lag
# => 0.003881

Ronin::Platform

The overlay.xsl file got a make-over in 0.3.0. overlay.xsl is a XML StyleSheet, which helps render ronin.xml files from Overlays into proper XHTML when they are viewed in a web-browser. Now ronin.xml files should appear more like a standard "About" web-page.

Reloading Overlays/Extensions while ronin is running became possible with the addition of Ronin::Platform.reload!. Now if an Extension is modified, one can simply call Platform.reload! and get the updated version.

Ronin Extensions gained convenience methods for defining reader/writer methods to instance variables: attr_reader, attr_writer and attr_accessor. They can be used in Ronin Extensions, just as one would use them in a class.

ronin_extension do

  attr_accessor :var
  attr_reader :result

  setup do
    @var = 5
    @result = nil
  end
  ...
end

Ronin Extensions also gained their own on-demand temp directory. When Ronin::Platform::Extension#tmp_dir is called, a temp directory specifically for the extension will be created within ~/.ronin/tmp/, and the path of the new temp directory will be returned.

Upgrading

As always, the rubygem files for Ronin 0.3.0 are available on rubyforge.org. One can update Ronin using rubygems by simplying running:

$ gem update ronin

Likewise, one can also install Ronin using rubygems:

$ gem install ronin

Also, as of Ronin 0.3.0 all releases of Ronin will also be made available on gemcutter.org.

As I’ve begun to get increasing amounts of email from other developers and users, I’ve wondered whether it’s time to setup some mailing-lists.

Well, thanks to the efforts of Franck D’agostini, Spidr now has a mailing-list. I hope this mailing-list will help foster interesting discussions between users/developers and possible improvements to Spidr.

I also took the liberty of setting up an IRC channel for Spidr, since IRC is still a mainstay of developers (although I like XMPP a little more). Just join #spidr on irc.freenode.net.

Seeing the potential for how mailing-lists can help a project, I also setup a Google Group for Ronin. Obvious Privacy Warning: Since Google indexes pretty much everything, sketchy discussions relating to Ronin should probably happen somewhere beyond Google’s reach, for one’s own security and privacy.

So yeah, let’s see what will happen.

After a period of refactoring, Spidr 0.2.0 (code-named “solid”) has been released. Many things we’re added to this release, along with some very important bug-fixes and optimizations.

Major changes

Spidr, along with many of my other projects, has moved to YARD based documentation. YARD’s tag based documentation format really helped me annotate every method within Spidr. The new YARD docs can be found in the usual location.

Also following suite with many of my other projects, you can now find Spidr on the awesome and easy to use gemcutter.org.

Spidr should be a little faster now. Thanks to the work of justfalter, HTTP sessions with unique hosts/ports are now cached and resued. HTTP sessions no longer have to be re-initialized upon every request. Also, the history and failures lists are now Ruby Sets, yielding improved lookup times for checking if a link has been previously visted.

The code-base of Spidr should be a little more organized. Many methods within Spidr::Agent were grouped by functionality and moved to separate modules (Events and Filters) which are included back into Spidr::Agent.

The Spidr::Actions module was also added, which adds action methods that control spidering from within every_url, every_page, every_failed_url, all_headers event hooks. The pause! method will pause the spider, while skip_page! and skip_link! can manipulate the processing of pages/links.

The Spidr::Page#search, Spidr::Page#at, Spidr::Page#title methods were also added. These methods should make Spidr::Page feel alittle more like WWW::Mechanize::Page, allowing one to search the DOM (parsed by Nokogiri) with XPath/CSS-path expressions.

Lastly, many new examples which highlight some of the less-than-trivial things you can do with Spidr have been added to the website and docs.

Important bug-fixes

Spidr::Agent should now properly handle the spidering of SSL protected websites. Also thanks to justfalter, HTTPS sessions are now properly initialized and stored in the HTTP session cache; so the SSL-handshake only need be performed once per unique host/port.

Spidr::Agent#get_page will now correctly send the URI query along with the URI path for HTTP requests. Thanks go out to Damian Steer for reporting this.

Spidr::Page#doc now returns a Nokogiri::XML::Document object for RSS/RDF/Atom pages, allowing one to properly search RSS/Atom feeds.

Spidr::Page#code will now return the HTTP Status code as an Integer.

Spidr::Page#links now properly handles the HTTP Location header.

The URI expansion/normalization performed by Spidr::Page#to_absolute was greatly improved. Spidr::Page#to_absolute will now properly preserve trailing ‘/’ characters on URI paths.

Shout Outs

A big thanks to everyone who helped with Spidr 0.2.0 by reporting bugs and testing new code. I hope this release will help users get more out of Spidr.

Over the past couple of months, I’ve been researching and playing with various up-and-coming Ruby libraries/services. So I thought it would be useful for other developers if I wrote something up.

Sinatra

If you already haven’t heard, Sinatra is cool sauce. Sinatra is a Ruby Domain Specific Language for creating web-apps that can fit in a single file.

# myapp.rb
require 'rubygems'
require 'sinatra'
get '/' do
  'Hello world!'
end

$ gem install sinatra
$ ruby myapp.rb

It’s that easy. But let’s say you want to create an app accessible as a Class, just inherit Sinatra::Base.

require 'rubygems'
require 'sinatra'

class MyApp < Sinatra::Base

  get '/' do
    'Hello world!'
  end

end

I found the URL param parsing and request routing on-par with that of Merb/Rails. I also enjoyed the halt and pass methods, which will cause Sinatra to re-route a request to other handlers.

Defining helper methods which can be used within request handlers was as easy as creating a module with some instance methods, then registering the module using the helpers method.

module Helpers
  module Rendering
    include Rack::Utils

    alias h escape_html
  end
end

class MyApp < Sinatra::Base

  helpers Helpers::Rendering

end

Sinatra is built on top of Rack, so reviewing the Rack API might not hurt. The current Rack::Request object can be accessed via the request method. The return value of a request handler can be a String, Array of Strings or even a Rack::Response object. Sinatra also provides the Rack call method, which can be overridden for more custom request routing (such as vhost routing to other Rack apps). Given Sinatra’s API Documentation, it’s fairly easy to customize and extend your Sinatra app.

Thor

Thor is an alternative to Rake or Sake. Thor makes it very easy to define tasks as methods, and define command-line options/arguments for those tasks using a succinct syntax.

Thor tasks can be invoked via the thor command, or loading the Thor class and calling the start method directly.

I also noticed that Rails3 is using Thor::Group and Thor::Actions, to create code generators.

While documentation is scarce for Thor, I fould it's code-base fairly readable.

FFI

There's an easier way to write Ruby extensions to C libraries. It's called FFI, or Foreign Function Interface. Ruby FFI is a rubygem (named ffi) by Wayne Meissner which wraps around libffi, to provide a Ruby interface to load libraries, attach functions, variables and mapping in Structs/Unions/enums/callbacks.

To create a Ruby interface to a library, simply create a module which extends FFI::Library and attach some functions as module methods.

module FFI
  module TRE
    extend FFI::Library

    ffi_lib 'tre' # finds and loads the library

    # attaches a function named tre_regcomp, and defines the
    # types for it's arguments and return value.
    attach_function :tre_regcomp, [:pointer, :pointer, :int], :int
    # ...
  end
end

More examples can be found here.

If you need to quickly write bindings for a library, give FFI a shot. Another benefit of having FFI Ruby bindings, is that they will work seamlessly with JRuby and Rubinius, on any platform that is supported by libffi.

YARD

YARD is an alternative to the defacto RDoc documentation generation, that allows one to annotate code using a @tag based syntax and Markdown/Textile/RDoc formatting. YARD stores all the gathered documentation information in a Marshalable data-store file (.yardoc), which opens the door to on-the-fly documentation searching. YARD can also export it's data to XML or XHTML+CSS+jQuery.

Want to use YARD in your project? Drop this task into your Rakefile.

YARD::Rake::YardocTask.new do |t|
  t.files   = ['lib/**/*.rb']
  t.options = [
    '--protected',
    '--files', 'History.txt',
    '--title', 'MyProject'
  ]
end

task :docs => :yardoc

$ rake docs && firefox doc/index.html

Want to use YARD on someone else's (github) project, checkout rdoc.info, it's built on YARD and Ruby 1.8.7.

YARD can also be extended to detect and document meta-programming methods which define other methods at runtime. For example, this YARD handler (for Ruby 1.9.x) which documents parameter method-calls from the Parameters library.

Loren Segal's slides from his YARD presentation at Montreal.rb are also worth checking out.

Gemcutter

Gemcutter provides easy and fun RubyGem hosting, which is open-source and aims to become the the default gem hosting solution for Ruby. Did I mention that it looks classy (thanks to a redesign by ThoughtBot)?

Publishing gems to Gemcutter is as easy as running:

gem push pkg/my_project-0.1.0.gem

The gem push command can override previously uploaded versions of a gem. No more going into Rubyforge's File Admin panel to delete mistakenly uploaded versions, just run gem push again.

Also, Gemcutter is a Sinatra app running on Heruko.

Update: As CG points out, I forgot to post the slides from the ToorCamp presentation. Here they are in XHTML form.

Update: @sanitybit discovered that parameters 0.1.7, which is required by ronin 0.2.4, was not released. Parameters 0.1.7 has now been released.

As promised in the Ronin: A Platform for Publishing and Mayhem talk at ToorCamp, Ronin 0.2.4 has finally been released. I was wanting to release 0.2.4 before ToorCamp, and hand out copies while there, but due to time constraints I had to wait till after the event.

$ gem update

Signed RubyGems

All released versions of Ronin, from 0.2.4 onward, will be signed. You can download the public certificate used to verify all of my gems here. A more in depth explanation of RubyGem Signing is given in Chapter 21 of the RubyGems Manual.

Bug Fixes

Mr. evoltech discovered and fixed a bug in the lookup of command names containing dashes, which was causing issues with the ronin-gen commands. flatline also improved the reliability of the caching of exploits from Overlays, now any exceptions raised during the caching of each exploit will be ignored.

Bytes and Chars

The 0.2.4 release now comes with new convenience methods to make working with byte and char Arrays easier:

[0x41, 0x41, 0x42].chars
# => ["A", "A", "B"]

["A", "B"].bytes
# => [0x41, 0x42]

[0x41, 0x41, 0x41].char_string
# => "AAB"

Un-Hexdumping

The File.unhexdump method was also added, making it even easier to un-hexdump those dumps.

Exceptions

Occasionally one needs to run some code which may raise exceptions, but you might not care about such exceptions, and would rather have them printed out. The catch_all method does exactly that. catch_all will catch all exceptions and print abbreviated back-traces.

require 'resolv'

catch_all do
  Resolv.getaddress('www.wired.com')
end

Another note-worth change in 0.2.4, was the renaming of the try method to attempt; so as not to conflict with JRuby’s try method.

HTTP

The Net.http_request method was added, allowing one to make arbitrary HTTP Requests, just specify the :method option.

Net.http_request(:host => 'www.example.com', :method => :head)

Templates::Erb

The Templates::Erb module was added in 0.2.4, providing convenience methods for rendering Embedded Ruby (ERB) templates.

Scanners::Scanner

The Scanners::Scanner module was also added in 0.2.4. The Scanner module can be included into any class and allows one to define multiple scanner rules by name, which are ran against each target, returning results in real-time via a callback.

An example usage of Scanners::Scanner would be to add scanner rules to all IPAddr objects, having each IP address within a netmask scanned.

require 'ronin/scanners/scanner'
require 'ronin/extensions/ip_addr'

class IPAddr

  include Ronin::Scanners::Scanner

  scanner(:dns) do |ip,results|
    Resolve.getnames(ip).each do |name|
      results.call(name)
    end
  end

  def each_target(&block)
    each(&block)
  end

end

First we include Ronin::Scanners::Scanner into the IPAddr class. Then we define a simple scanner rule to perform reverse DNS lookup on an IP address and returns the results using the result callback. Finally we define the each_target method which enumerates over each IP address in the netmask, passing each to the block to be scanned.

To run all scanner rules on an IPAddr range:

ip = IPAddr.new('10.1.1.1/24')
ip.scan

To only run the DNS scanner rule:

ip.dns_scan

The SQL Injection, LFI and RFI scanning code has now been ported to use Scanners::Scanner.

Accessible Extensions

Extensions from Overlays are now more accessible. Within the Ronin console, they can be accessed as local variables:

puts milw0rm.remote.first_page

This is all thanks to the new Ronin#method_missing method; which catches missing instance method calls, and attempts to load the appropriate extension.

Command Name Changes

The ls and rm ronin commands have now been renamed to list and remove, respectively.

To list all installed Overlays:

$ ronin list

To remove (but not delete) an Overlay:

$ ronin remove overlay-name

New Dorks

ronin-dorks 0.1.2 saw the addition of the intext, allintext, string_intext, all_strings_intext, intitle, allintitle, string_intitle methods to Web::Dorks. The new intext and intitle convenience methods should simplify the creation of future dorks.

ronin.rubyforge.org Open Sourced

Last but not least, the source-code for the ronin.rubyforge.org website has been open-sourced on GitHub. Now if you want to make a correction or add a How-To, just fork it, commit your changes, then send me a pull-request and I’ll upload your changes.

The collaborative editing is already happening, evoltech already wrote up a new badass Contribute page, that explains typical Git(Hub) workflow.

Apologies for not updating this blog more often. I have been very busy preparing for ToorCamp and releasing code.

One of my newer projects is Sketches. The idea for Sketches came from hacking sessions with Ronin. Eventually you need to automate some small task, this requires that you write a small method in the Ronin Console. I would find myself either writing methods directly into the console or cluttering my home directory with small Ruby scripts that I would load into the console. Usually after testing my code, I realized some changes needed to be made, and the code redefined/reloaded.

This became tedious and was cramping my work-flow. I just wanted to write code in my editor of choice and have it reloaded into the console like magic.

I remembered that Utility Belt had the ability to spawn an editor from IRB and load the resulting code after you exited it. Although, Utility Belt wont track the edited files and reload them whenever they change. Also, Utility Belt comes with a lot of OSX/S3 specific features that I didn’t really need.

So I dug up reval.rb, borrowed the name Sketches from Processing’s idea of code “sketches” and one week later I had Sketches working in IRB (and Ronin).

Sketches is easy to install:

$ sudo gem install sketches

Then just drop it into your .irbrc:

require 'sketches'

Sketches.config :editor => 'gvim'

When you want to pop open a new sketch:

sketch

You can also name your sketches:

sketch :foo

See all of your current sketches:

sketches

Don’t worry about closing the editor, sketches will persist until you exit IRB and can be re-opened using the sketch method:

sketch :foo

After posting it to reddit I was surprised to see such an immediate positive reaction to the little project. I even saw posts on Twitter were people were using GNU Screen with vim for the editor command. I never thought of using screen, totally clever.

The wait is over, Ronin 0.2.3 (code-named “faster”) has finally been released. This release contains new code, more specs, some very important architectural changes and a few bug-fixes.

Ronin on Ruby 1.9.1

Probably the most important news in Ronin 0.2.3, is that Ronin is now Ruby 1.9.1 compatible. Ronin can now take advantage of the considerable performance improvements in Ruby 1.9.1-p0. If you tend to do security research and find yourself having to use Ruby 1.9.1, you should look into using Ronin.

Faster Load-Times

Ronin also saw various architectural changes to help reduce load-times. The ronin/models.rb file was removed, which loaded models from the other Ronin libraries before the Database was setup. Now other Ronin libraries can call the Database.update! method, which will run non-destructive auto-migrations on the Database. Ronin::UI::CommandLine saw yet more refactoring. With the new Ronin::UI::CommandLine, sub-commands are loaded on-demand, instead of all at once.

Together these architectural changes have dramatically improved the load-time of Ronin’s console. On systems that rarely run the Ruby interpreter, start-up times for Ronin should look like the following:

$ time (echo exit | (ronin > /dev/null))

real	0m3.841s
user	0m1.141s
sys	0m0.514s

On systems that regularly run the Ruby interpreter (thus caching frequently used memory and data) start-up times for Ronin will be a little quicker:

$ time (echo exit | (ronin > /dev/null))

real	0m1.656s
user	0m1.137s
sys	0m0.478s

New Convenience Methods

In 0.2.3 the IPAddr#each and IPAddr.each methods were added. It’s somewhat common to need to iterate over a range of IP addresses. Say you have a CIDR notation IP address, and need to iterate over every IP address covered by it’s netmask. Simply create a new IPAddr object and call each:

ip = IPAddr.new('10.1.1.1/24')
ip.each do |addr|
  ...
end

Well that’s sort of cool, but what if you have a globbed IP address, similar to the ones nmap accepts? IPAddr.each has you covered:

IPAddr.each('10.1.1-5.*') do |addr|
  ...
end

Both IPAddr#each and IPAddr.each can iterate over IPv6 addresses.

Net.http_powered_by and Net.http_server also got added in 0.2.3. These methods provide quick access to the X-Powered-By and Server HTTP headers, respectively.

Net.http_powered_by(:url => 'http://www.stalkdaily.com/')
# => "PHP/5.2.9"

Net.http_server(:url => 'http://www.darkc0de.com/)
# => "Apache/2.2.11 (Unix) PHP/4.4.9 mod_ssl/2.2.11 OpenSSL/0.9.8c mod_fastcgi/2.4.6 Phusion_Passenger/2.1.2 DAV/2 SVN/1.4.2"

String#pad was also added in 0.2.3. The pad method doesn’t do a lot, it merely pads a String out to a maximum length:

"hello".pad('A', 48)
# => "helloAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

If you hate having to deal with exceptions in Ruby, the try method might prove useful. The try method simple attempts to run a block of code, catching and ignoring any exceptions that were raised:

require 'resolv'

try do
  Resolv.getaddress('might.not.exist.com')
end

Cacheable

Ronin::Objectify was replaced by the new Ronin::Cacheable module. Cacheable provides reliable caching and loading of Contextified objects with Ronin’s Database. Using the new Cacheble module, the data you want cached into the database must be defined in a cache block:

ronin_exploit do
  cache do
    self.name = 'stupidhttpd'
    self.version = '0.2'
    self.author(:name => 'Postmodern')
  end

  ...
end

The use of a cache block creates a separation between the data to be cached and the code which will eventually be loaded.

Overlays

As of 0.2.3, overlays now support the automatic loading of the lib/init.rb file. So if you have code you’d like automatically loaded (maybe extensions to the Array class) from your Overlay, simply require it in the lib/init.rb file.

The loading of Extensions from Overlays became a little more robust in 0.2.3. If an exception is encountered when loading an extension file, the exception will be printed and the file ignored.

Ronin 0.2.2, code-named “theouterlibs”, has been released. This release of Ronin has seen more action in the other libraries which support Ronin.

Ronin::Chars was split out of Ronin into the Chars 0.1.0 library, in order to help other frameworks and code which work with characters.

The ronin-overlay and ronin-ext sub-commands which handled generating skeleton Overlays and Extensions have been moved to the ronin-gen library. The ronin-gen library provides various code-generates which allow other Ronin libraries to create their own custom code-generators.

The R’epertoire library saw significant refactoring after various bugs were uncovered while testing Ronin 0.2.2. Now R’epertoire 0.2.1 has improved Git support, but CVS and Darcs support was removed.

Ronin also saw some minor improvements in 0.2.2. New convenience methods were added for formatting binary data:

• Integer#bytes: returns the bytes that make up the Integer.

  0xff41.bytes(2)
  # => [65, 255]

  0xff41.bytes(4, :big)
  # => [0, 0, 255, 65]

• String#hex_unescape: unescape those annoying hex-escaped Strings.

  "\\x68\\x65\\x6c\\x6c\\x6f".hex_unescape
  # => "hello"

• String#unhexdump: un-hexdump a variety of hexdump formats.

  File.read('data_dump.txt').unhexdump
  # => "..."

Ronin::Static was also added in 0.2.2. The Ronin::Static module handles static resource directories which Ronin can search within for various files and directories. Ronin::Static::Finders provides path/file/directory finder methods that can be included into classes. Ronin Overlays and Extensions can now have static/ directories of their own, which are accessible via the Ronin::Static::Finders methods.

Loaded extensions can now be reloaded on the fly:

Platform.extensions.reload!

Ronin Extensions also can be accessed via constants within the Ronin namespace:

Ronin::HelloWord.name
# => "hello_word"