arachni 0.4.0.4 → 0.4.1

data/spec/arachni/plugin/manager_spec.rb

@@ -0,0 +1,174 @@
+require_relative '../../spec_helper'
+
+describe Arachni::Plugin::Manager do
+    before( :all ) do
+        opts = Arachni::Options.instance
+        opts.dir['plugins'] = spec_path + 'fixtures/plugins/'
+
+        @plugins = Arachni::Framework.new( Arachni::Options.instance ).plugins
+    end
+
+    after( :all ) { @plugins.clear }
+
+    describe '#load_default' do
+        it 'should load default plugins' do
+            @plugins.should be_empty
+            @plugins.load_default
+            @plugins.include?( 'default' ).should be_true
+            @plugins.clear
+        end
+        it 'should be aliased to #load_defaults' do
+            @plugins.should be_empty
+            @plugins.load_defaults
+            @plugins.include?( 'default' ).should be_true
+        end
+    end
+
+    describe '#default' do
+        it 'should return the default plugins' do
+            @plugins.default.include?( 'default' ).should be_true
+        end
+        it 'should be aliased to #defaults' do
+            @plugins.defaults.include?( 'default' ).should be_true
+        end
+    end
+
+    describe '#run' do
+        context 'when gem dependencies are met' do
+            it 'should run loaded plugins' do
+                @plugins.run
+                @plugins.block
+                @plugins.results['default'][:results].should be_true
+            end
+        end
+        context 'when gem dependencies are not met' do
+            it 'should raise exception' do
+                raised = false
+                begin
+                    @plugins.load( 'bad' )
+                    @plugins.run
+                    @plugins.block
+                rescue
+                    raised = true
+                end
+                raised.should be_true
+            end
+        end
+    end
+
+    describe '#sane_env?' do
+        context 'when gem dependencies are met' do
+            it 'should return true' do
+                @plugins.sane_env?( @plugins['default'] ).should == true
+            end
+        end
+        context 'when gem dependencies are not met' do
+            it 'should raise exception' do
+                @plugins.sane_env?( @plugins['bad'] ).include?( :gem_errors ).should be_true
+                @plugins.delete( 'bad' )
+            end
+        end
+    end
+
+    describe '#create' do
+        it 'should return a plugin instance' do
+            @plugins.create( 'default' ).instance_of?( @plugins['default'] ).should be_true
+        end
+    end
+
+    describe '#busy?' do
+        context 'when plugins are running' do
+            it 'should return true' do
+                @plugins.run
+                @plugins.busy?.should be_true
+                @plugins.block
+            end
+        end
+        context 'when plugins have finished' do
+            it 'should return false' do
+                @plugins.run
+                @plugins.block
+                @plugins.busy?.should be_false
+            end
+        end
+    end
+
+    describe '#job_names' do
+        context 'when plugins are running' do
+            it 'should return the names of the running plugins' do
+                @plugins.run
+                @plugins.job_names.should == @plugins.keys
+                @plugins.block
+            end
+        end
+        context 'when plugins have finished' do
+            it 'should return an empty array' do
+                @plugins.run
+                @plugins.block
+                @plugins.job_names.should be_empty
+            end
+        end
+    end
+
+    describe '#jobs' do
+        context 'when plugins are running' do
+            it 'should return the names of the running plugins' do
+                @plugins.run
+                @plugins.jobs.first.instance_of?( Thread ).should be_true
+                @plugins.block
+            end
+        end
+        context 'when plugins have finished' do
+            it 'should return an empty array' do
+                @plugins.run
+                @plugins.block
+                @plugins.jobs.should be_empty
+            end
+        end
+    end
+
+    describe '#kill' do
+        context 'when a plugin is running' do
+            it 'should kill a running plugin' do
+                @plugins.load( 'loop' )
+                @plugins.run
+                ret = @plugins.kill( 'loop' )
+                @plugins.block
+
+                ret.should be_true
+                @plugins.delete( 'loop' )
+            end
+        end
+
+        context 'when plugin is not running' do
+            it 'should return false' do
+                @plugins.run
+                @plugins.block
+                @plugins.kill( 'default' ).should be_false
+            end
+        end
+    end
+
+    describe '#get' do
+        context 'when a plugin is running' do
+            it 'should return its thread' do
+                @plugins.load( 'loop' )
+                @plugins.run
+                @plugins.get( 'loop' ).is_a?( Thread ).should be_true
+                @plugins.kill( 'loop' )
+                @plugins.block
+
+                @plugins.delete( 'loop' )
+            end
+        end
+
+        context 'when plugin is not running' do
+            it 'should return nil' do
+                @plugins.run
+                @plugins.block
+                @plugins.get( 'default' ).should be_nil
+            end
+        end
+    end
+
+end

data/spec/arachni/report/base_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../../spec_helper'
+
+describe Arachni::Report::Base do
+    before( :all ) do
+        opts = Arachni::Options.instance
+        opts.dir['reports'] = spec_path + 'fixtures/reports/base_spec'
+
+        @framework = Arachni::Framework.new( Arachni::Options.instance )
+        @reports   = @framework.reports
+    end
+
+    describe '#auditstore' do
+        it 'should return the provided auditstore' do
+            auditstore = @framework.auditstore
+            @reports.run_one( :with_outfile, auditstore ).auditstore.
+                should == auditstore
+        end
+    end
+
+    describe '#outfile' do
+        it 'should return the outfile in options' do
+            outfile = 'blahfile'
+            @reports.run_one( :with_outfile, @framework.auditstore,
+                              'outfile' => outfile
+            ).outfile.should == outfile
+        end
+    end
+
+    describe '#format_plugin_results' do
+        it 'should run the formatters of appropriate plugin' do
+            store = @framework.auditstore
+            store.plugins["foobar"] = { :results => 'Blah!' }
+
+            @reports.run_one( 'with_formatters', store )
+            IO.read( 'with_formatters' ).should == { 'foobar' => 'Blah!' }.to_s
+            File.delete( 'with_formatters' )
+        end
+    end
+
+    describe '.has_outfile?' do
+        context 'when the report has an outfile option' do
+            it 'should return true' do
+                @reports[:with_outfile].has_outfile?.should be_true
+            end
+        end
+        context 'when the report does not have an outfile option' do
+            it 'should return false' do
+                @reports[:without_outfile].has_outfile?.should be_false
+            end
+        end
+    end
+
+end

data/spec/arachni/report/manager_spec.rb

@@ -0,0 +1,82 @@
+require_relative '../../spec_helper'
+
+describe Arachni::Report::Manager do
+    before( :all ) do
+        opts = Arachni::Options.instance
+        opts.dir['reports'] = spec_path + '/fixtures/reports/manager_spec/'
+
+        @framework = Arachni::Framework.new( Arachni::Options.instance )
+        @reports   = @framework.reports
+        @reports.load( '*' )
+    end
+
+    after( :all ){ @reports.clear }
+
+    describe '#run' do
+        context 'without the run_afr opt' do
+            it 'should run loaded reports including the AFR one' do
+                @reports.run( @framework.auditstore )
+
+                File.exist?( 'afr' ).should be_true
+                File.delete( 'afr' )
+
+                @reports.keys.each do |name|
+                    File.exist?( name ).should be_true
+                    File.delete( name )
+                end
+            end
+        end
+        context 'with the run_afr opt set to true' do
+            it 'should run loaded reports including the AFR one' do
+                @reports.run( @framework.auditstore, true )
+                File.exist?( 'afr' ).should be_true
+                File.delete( 'afr' )
+
+                @reports.keys.each do |name|
+                    File.exist?( name ).should be_true
+                    File.delete( name )
+                end
+            end
+        end
+        context 'with run_afr opt set to false' do
+            it 'should run loaded reports without the AFR one' do
+                @reports.run( @framework.auditstore, false )
+                File.exist?( 'afr' ).should be_false
+
+                @reports.keys.each do |name|
+                    File.exist?( name ).should be_true
+                    File.delete( name )
+                end
+            end
+        end
+    end
+
+    describe '#run_one' do
+        it 'should run a report by name' do
+            @reports.run_one( 'foo', @framework.auditstore )
+
+            File.exist?( 'foo' ).should be_true
+            File.delete( 'foo' )
+        end
+
+        context 'when passed options' do
+            it 'should override Options.reports' do
+                Arachni::Options.reports[:foo] = { 'outfile' => 'stuff1' }
+                opts = { 'outfile' => 'stuff' }
+                report = @reports.run_one :foo, @framework.auditstore, opts
+                report.options.should eq opts
+                File.delete( 'foo' )
+            end
+        end
+
+        context 'when not passed options' do
+            it 'should fallback to Options.reports' do
+                opts = Arachni::Options.reports[:foo] = { 'outfile' => 'stuff2' }
+                report = @reports.run_one :foo, @framework.auditstore
+                report.options.should eq opts
+                File.delete( 'foo' )
+            end
+        end
+    end
+
+end

data/spec/arachni/rpc/client/base_spec.rb

@@ -0,0 +1,157 @@
+require_relative '../../../spec_helper'
+
+require Arachni::Options.instance.dir['lib'] + 'rpc/client/base'
+require Arachni::Options.instance.dir['lib'] + 'rpc/server/base'
+
+require 'ostruct'
+
+class Server
+    def initialize( opts, token = nil, &block )
+        @opts = opts
+        @server = Arachni::RPC::Server::Base.new( @opts, token )
+        @server.add_handler( "foo", self )
+
+        if block_given?
+            start
+            block.call self
+            kill_em
+        end
+    end
+
+    def url
+        "#{@opts.rpc_address}:#{@opts.rpc_port}"
+    end
+
+    def start
+        t = Thread.new { @server.run }
+        sleep( 0.1 ) while !@server.ready?
+    end
+
+    def bar
+        true
+    end
+end
+
+describe Arachni::RPC::Client::Base do
+    before( :all ) do
+        @opts = OpenStruct.new
+        @opts.rpc_address = Arachni::Options.instance.rpc_address.dup
+        @client_class = Arachni::RPC::Client::Base
+    end
+
+    describe '.new' do
+        context 'without SSL options' do
+            it 'should connect successfully to a server' do
+                opts = @opts.dup
+                opts.rpc_port = random_port
+                Server.new( opts ) do |server|
+                    client = @client_class.new( opts, server.url )
+                    client.call( "foo.bar" ).should == true
+                end
+            end
+        end
+
+        context 'with valid SSL options' do
+            it 'should connect successfully to an SSL server' do
+                opts = @opts.dup
+                opts.rpc_port = random_port
+
+                opts.ca = spec_path + 'pems/cacert.pem'
+                opts.node_ssl_pkey = spec_path + 'pems/client/key.pem'
+                opts.node_ssl_cert = spec_path + 'pems/client/cert.pem'
+                opts.ssl_pkey = spec_path + 'pems/server/key.pem'
+                opts.ssl_cert = spec_path + 'pems/server/cert.pem'
+
+                Server.new( opts ) do |server|
+                    client = @client_class.new( opts, server.url )
+                    client.call( "foo.bar" ).should be_true
+                end
+            end
+        end
+
+        context 'with invalid SSL options' do
+            it 'should be unable to connect to an SSL server' do
+                opts = @opts.dup
+                opts.rpc_port = random_port
+
+                opts.ssl_ca = spec_path + 'pems/cacert.pem'
+                opts.node_ssl_pkey = spec_path + 'pems/client/foo-key.pem'
+                opts.node_ssl_cert = spec_path + 'pems/client/foo-cert.pem'
+                opts.ssl_pkey = spec_path + 'pems/server/key.pem'
+                opts.ssl_cert = spec_path + 'pems/server/cert.pem'
+
+                Server.new( opts ) do |server|
+                    raised = false
+                    begin
+                        client = @client_class.new( opts, server.url )
+                        client.call( "foo.bar" )
+                    rescue Arachni::RPC::Exceptions::ConnectionError
+                        raised = true
+                    end
+
+                    raised.should be_true
+                end
+            end
+        end
+
+        context 'with no SSL options' do
+            it 'should be unable to connect to an SSL server' do
+                opts = @opts.dup
+                opts.rpc_port = random_port
+
+                opts.ssl_ca = spec_path + 'pems/cacert.pem'
+                opts.ssl_pkey = spec_path + 'pems/server/key.pem'
+                opts.ssl_cert = spec_path + 'pems/server/cert.pem'
+
+                Server.new( opts ) do |server|
+                    raised = false
+                    begin
+                        client = @client_class.new( OpenStruct.new, server.url )
+                        client.call( "foo.bar" )
+                    rescue Arachni::RPC::Exceptions::SSLPeerVerificationFailed
+                        raised = true
+                    end
+
+                    raised.should be_true
+                end
+            end
+        end
+
+        context 'when a server requires a token' do
+            context 'with a valid token' do
+                it 'should be able to connect' do
+                    opts = @opts.dup
+                    opts.rpc_port = random_port
+                    token = 'secret!'
+
+                    Server.new( opts, token ) do |server|
+                        client = @client_class.new( opts, server.url, token )
+                        client.call( "foo.bar" ).should be_true
+                    end
+                end
+            end
+            context 'with invalid token' do
+                it 'should not be able to connect' do
+                    opts = @opts.dup
+                    opts.rpc_port = random_port
+                    token = 'secret!'
+
+                    Server.new( opts, token ) do |server|
+                        raised = false
+                        begin
+                            client = @client_class.new( OpenStruct.new, server.url )
+                            client.call( "foo.bar" )
+                        rescue Arachni::RPC::Exceptions::InvalidToken
+                            raised = true
+                        end
+
+                        raised.should be_true
+                    end
+                end
+            end
+        end
+
+
+    end
+
+end