arachni 0.3 → 0.4

data/lib/arachni/rpc/server/instance.rb

@@ -0,0 +1,184 @@
+=begin
+                  Arachni
+  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+
+  This is free software; you can copy and distribute and modify
+  this program under the term of the GPL v2.0 License
+  (See LICENSE file for details)
+
+=end
+
+module Arachni
+
+require Options.instance.dir['lib'] + 'rpc/client/instance'
+require Options.instance.dir['lib'] + 'rpc/client/dispatcher'
+
+require Options.instance.dir['lib'] + 'rpc/server/base'
+require Options.instance.dir['lib'] + 'rpc/server/output'
+require Options.instance.dir['lib'] + 'rpc/server/options'
+
+require Options.instance.dir['lib'] + 'rpc/server/framework'
+
+module RPC
+class Server
+
+#
+# RPC Server class
+#
+# Provides an RPC server to assist with general integration and UI development.
+#
+# Only instantiated by the Dispatcher to provide support for multiple
+# and concurent RPC clients/scans.
+#
+# @author: Tasos "Zapotek" Laskos
+#                                      <tasos.laskos@gmail.com>
+#                                      <zapotek@segfault.gr>
+# @version: 0.1.5
+#
+class Instance
+
+    # the output interface for RPC
+    include Arachni::UI::Output
+    include Arachni::Module::Utilities
+
+    #
+    # Initializes the RPC interface, the HTTP(S) server and the framework.
+    #
+    # @param    [Options]    opts
+    #
+    def initialize( opts, token )
+
+        prep_framework
+        banner
+
+        @opts  = opts
+        @token = token
+        @server = Base.new( @opts, token )
+
+        @opts.datastore[:token] = token
+
+        debug! if @opts.debug
+
+
+        if logfile = @opts.reroute_to_logfile
+            reroute_to_file( @opts.dir['logs'] +
+                "Instance - #{Process.pid}-#{@opts.rpc_port}.log" )
+        else
+            reroute_to_file( false )
+        end
+
+        set_handlers
+
+        # trap interrupts and exit cleanly when required
+        [ 'QUIT', 'INT' ].each {
+            |signal|
+            trap( signal ){ shutdown } if Signal.list.has_key?( signal )
+        }
+
+        run
+    end
+
+    #
+    # Flushes the output buffer and returns all pending system messages.
+    #
+    # All messages are classified based on their type.
+    #
+    # @return   [Array<Hash>]
+    #
+    def output( &block )
+        @framework.output( &block )
+    end
+
+    #
+    # Makes the server go bye-bye...Lights out!
+    #
+    def shutdown
+        print_status( 'Shutting down...' )
+
+        t = []
+        @framework.instances.each {
+            |instance|
+            # Don't know why but this works better than EM's stuff
+            t << Thread.new {
+                @framework.instance_eval{
+                    connect_to_instance( instance ).service.shutdown!
+                }
+            }
+        }
+
+        t.join
+
+        @server.shutdown
+        return true
+    end
+    alias :shutdown! :shutdown
+
+    def alive?
+        @server.alive?
+    end
+
+    private
+
+    #
+    # Starts the HTTPS server and the RPC service.
+    #
+    def run
+        print_status( 'Starting the server...' )
+        # start the show!
+        @server.run
+    end
+
+    def dispatcher
+        @dispatcher ||=
+            Arachni::RPC::Client::Dispatcher.new( @opts, @opts.datastore[:dispatcher_url] )
+    end
+
+    #
+    # Initialises the RPC framework.
+    #
+    def prep_framework
+        @framework = Arachni::RPC::Server::Framework.new( Options.instance )
+    end
+
+    #
+    # Outputs the Arachni banner.<br/>
+    # Displays version number, revision number, author details etc.
+    #
+    def banner
+
+        puts 'Arachni - Web Application Security Scanner Framework v' +
+            @framework.version + ' [' + @framework.revision + ']
+       Author: Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+                                      <zapotek@segfault.gr>
+               (With the support of the community and the Arachni Team.)
+
+       Website:       http://github.com/Zapotek/arachni
+       Documentation: http://github.com/Zapotek/arachni/wiki'
+        puts
+        puts
+
+    end
+
+    #
+    # Starts the RPC service and attaches it to the HTTP(S) server.<br/>
+    # It also prepares all the RPC handlers.
+    #
+    def set_handlers
+        @server.add_async_check {
+            |method|
+            # methods that expect a block are async
+            method.parameters.flatten.include?( :block )
+        }
+
+        @server.add_handler( "service",   self )
+        @server.add_handler( "framework", @framework )
+        @server.add_handler( "opts",      @framework.opts )
+        @server.add_handler( "modules",   @framework.modules )
+        @server.add_handler( "plugins",   @framework.plugins )
+    end
+
+end
+
+end
+end
+end

data/lib/{rpc/xml → arachni/rpc}/server/module/manager.rb

@@ -1,6 +1,6 @@
 =begin
                   Arachni
-  Copyright (c) 2010-2011 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 
   This is free software; you can copy and distribute and modify
   this program under the term of the GPL v2.0 License
@@ -13,14 +13,13 @@ module Arachni
 require Options.instance.dir['lib'] + 'module/manager'
 
 module RPC
-module XML
-module Server
+class Server
 
 module Module
 
 #
 # We need to extend the original Manager and redeclare its inherited methods
-# which are required over XMLRPC.
+# which are required over RPC.
 #
 # @author: Tasos "Zapotek" Laskos
 #                                      <tasos.laskos@gmail.com>
@@ -37,9 +36,13 @@ class Manager < ::Arachni::Module::Manager
         super( opts )
     end
 
-end
+    def load( mods )
+        super( mods )
+        @opts.mods = mods
+    end
 
 end
+
 end
 end
 end

data/lib/arachni/rpc/server/node.rb

@@ -0,0 +1,267 @@
+=begin
+                  Arachni
+  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+
+  This is free software; you can copy and distribute and modify
+  this program under the term of the GPL v2.0 License
+  (See LICENSE file for details)
+
+=end
+
+
+module Arachni
+
+require Options.instance.dir['lib'] + 'rpc/server/output'
+
+module RPC
+class Server
+
+class Dispatcher
+
+#
+# Dispatcher node class, helps maintain a list of all available Dispatchers in the grid
+# and announce itself to neighbouring Dispatchers.
+#
+# As soon as a new Node is fired up it checks-in with its neighbour and grabs
+# a list of all available peers.
+#
+# As soon as it receives the peer list it then announces itself to them.
+#
+# Upon convergence there will be a grid of Dispatchers each one with its own copy
+# of all available Dispatcher URLs.
+#
+# @author: Tasos "Zapotek" Laskos
+#                                      <tasos.laskos@gmail.com>
+#                                      <zapotek@segfault.gr>
+# @version: 0.1
+#
+class Node
+
+    include Arachni::UI::Output
+
+    #
+    # Initializes the node by:
+    # * Adding the neighbour (if the user has supplied one) to the peer list
+    # * Getting the neighbour's peer list and appending them to its own
+    # * Announces itself to the neighbour and instructs it to propagate our URL to the others
+    #
+    # @param    [Arachni::Options]    opts
+    # @param    [String]              logfile   were to send the output
+    #
+    def initialize( opts, logfile )
+        @opts = opts
+
+        reroute_to_file( logfile )
+
+        print_status( 'Initing grid node...' )
+
+        @dead_nodes = []
+        @neighbours = Set.new
+        @nodes_info_cache = []
+
+        if neighbour = @opts.neighbour
+            add_neighbour( neighbour )
+
+            peer = connect_to_peer( neighbour )
+            peer.node.neighbours {
+                |urls|
+                urls.each {
+                    |url|
+                    @neighbours << url if url != @opts.datastore[:dispatcher_url]
+                }
+            }
+
+            peer.node.add_neighbour( @opts.datastore[:dispatcher_url], true ){
+                |res|
+
+                if res.rpc_exception?
+                    print_info( 'Neighbour seems dead: ' + neighbour )
+                    remove_neighbour( neighbour )
+                end
+            }
+        end
+
+        print_status( 'Node ready.' )
+
+        log_updated_neighbours
+
+        ::EM.add_periodic_timer( 60 ) {
+            ::EM.defer {
+                ping
+                check_for_comebacks
+            }
+        }
+    end
+
+    #
+    # Adds a neighbour to the peer list
+    #
+    # @param    [String]    node_url    URL of a neighbouring node
+    # @param    [Boolean]   propagate   wether or not to announce the new node
+    #                                    to the ones in the peer list
+    #
+    def add_neighbour( node_url, propagate = false )
+        # we don't want ourselves in the Set
+        return false if node_url == @opts.datastore[:dispatcher_url]
+
+        print_status 'Adding neighbour: ' + node_url
+
+        @neighbours << node_url
+        log_updated_neighbours
+        announce( node_url ) if propagate
+
+        return true
+    end
+
+
+    #
+    # Returns all neighbour/node/peer URLs
+    #
+    # @return   [Array]
+    #
+    def neighbours
+        @neighbours.to_a
+    end
+
+    def remove_neighbour( node_url )
+        @neighbours -= [node_url]
+        @dead_nodes << node_url
+    end
+
+    def neighbours_with_info( &block )
+        raise( "This method requires a block!" ) if !block_given?
+
+        @neighbours_cmp = ''
+        if @nodes_info_cache.empty? || @neighbours_cmp != neighbours.to_s
+
+            @neighbours_cmp = neighbours.to_s
+
+            ::EM::Iterator.new( neighbours ).map( proc {
+                |neighbour, iter|
+
+                connect_to_peer( neighbour ).node.info {
+                    |info|
+
+                    if info.rpc_exception?
+                        print_info( 'Neighbour seems dead: ' + neighbour )
+                        remove_neighbour( neighbour )
+                        log_updated_neighbours
+
+                        iter.return( nil )
+                    else
+                        iter.return( info )
+                    end
+                }
+            }, proc {
+                |nodes|
+                @nodes_info_cache = nodes.compact
+                block.call( @nodes_info_cache )
+            })
+        else
+            block.call( @nodes_info_cache )
+        end
+    end
+
+    #
+    # Returns node specific info:
+    # * Bandwidth Pipe ID
+    # * Weight
+    # * Nickname
+    # * Cost
+    #
+    # @return    [Hash]
+    #
+    def info
+        return {
+            'url'        => @opts.datastore[:dispatcher_url],
+            'pipe_id'    => @opts.pipe_id,
+            'weight'     => @opts.weight,
+            'nickname'   => @opts.nickname,
+            'cost'       => @opts.cost
+        }
+    end
+
+    private
+
+    def log_updated_neighbours
+        print_info 'Updated neighbours:'
+
+        if !neighbours.empty?
+            neighbours.each {
+                |node|
+                print_info( '---- ' + node )
+            }
+        else
+            print_info( '<empty>' )
+        end
+    end
+
+    def ping
+        neighbours.each {
+            |neighbour|
+            connect_to_peer( neighbour ).alive? {
+                |res|
+                if res.rpc_exception?
+                    remove_neighbour( neighbour )
+                    print_status( "Found dead neighbour: #{neighbour} " )
+                end
+            }
+        }
+    end
+
+    def check_for_comebacks
+        d_nodes = @dead_nodes.dup
+        d_nodes.each {
+            |url|
+            connect_to_peer( url ).alive? {
+                |res|
+
+                if !res.rpc_exception?
+                    print_status( 'Dispatcher came back to life: ' + url )
+
+                    ([@opts.datastore[:dispatcher_url]] | neighbours ).each {
+                        |node|
+                        neighbour.node.add_neighbour( node ){}
+                    }
+
+                    add_neighbour( url )
+                    @dead_nodes -= [url]
+                end
+            }
+        }
+    end
+
+    #
+    # Announces the node to the ones in the peer list
+    #
+    # @param    [String]    node    URL
+    #
+    def announce( node )
+        print_status 'Advertising: ' + node
+
+        neighbours.each {
+            |peer|
+            next if peer == node
+
+            print_info '---- to: ' + peer
+            connect_to_peer( peer ).node.add_neighbour( node ) {
+                |res|
+                if res.rpc_exception?
+                    remove_neighbour( peer )
+                end
+            }
+        }
+
+    end
+
+    def connect_to_peer( url )
+        Arachni::RPC::Client::Dispatcher.new( @opts, url )
+    end
+
+end
+
+end
+
+end
+end
+end