arachni 0.4.0.4 → 0.4.1

data/reports/yaml.rb

@@ -1,49 +1,47 @@
 =begin
-                  Arachni
-  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    Copyright 2010-2012 Tasos 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)
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
 
-=end
+        http://www.apache.org/licenses/LICENSE-2.0
 
-module Arachni
-module Reports
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+=end
 
 #
 # Converts the AuditStore to a Hash which it then dumps in YAML format into a file.
 #
-# @author: Tasos "Zapotek" Laskos
-#                                      <tasos.laskos@gmail.com>
-#                                      <zapotek@segfault.gr>
-# @version: 0.1
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 #
-class YAML < Arachni::Report::Base
+# @version 0.1.1
+#
+class Arachni::Reports::YAML < Arachni::Report::Base
 
     def run
-        print_line( )
-        print_status( 'Dumping audit results in \'' + @options['outfile']  + '\'.' )
+        print_line
+        print_status "Dumping audit results in #{outfile}."
 
-        File.open( @options['outfile'], 'w' ) {
-            |f|
-            f.write( ::YAML::dump( @audit_store.to_h ) )
-        }
+        File.open( options['outfile'], 'w' ) do |f|
+            f.write( auditstore.to_hash.to_yaml )
+        end
 
-        print_status( 'Done!' )
+        print_status 'Done!'
     end
 
     def self.info
         {
-            :name           => 'YAML Report',
-            :description    => %q{Exports the audit results as a YAML file.},
-            :author         => 'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
-            :version        => '0.1',
-            :options        => [ Arachni::Report::Options.outfile( '.yaml' ) ]
+            name:        'YAML Report',
+            description: %q{Exports the audit results as a YAML file.},
+            author:      'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
+            version:     '0.1.1',
+            options:     [ Options.outfile( '.yaml' ) ]
         }
     end
 
 end
-
-end
-end

data/spec/arachni/audit_store_spec.rb

@@ -0,0 +1,223 @@
+require_relative '../spec_helper'
+
+describe Arachni::AuditStore do
+
+    before( :all ) do
+        url = 'http://test.com'
+
+        @opts = Arachni::Options.instance
+        @opts.url = url
+
+        @issue = Arachni::Issue.new(
+            url: url,
+            name: 'blah',
+            mod_name: 'mod',
+            elem: 'link'
+        )
+
+        @plugin_results = { 'name' => { results: 'stuff' } }
+
+        @auditstore_opts = {
+            version:  '0.1',
+            revision: '0.2',
+            options:  @opts.to_h,
+            sitemap:  [@opts.url],
+            issues:   [@issue.deep_clone],
+            plugins:  @plugin_results,
+        }
+
+        @auditstore = Arachni::AuditStore.new(
+            @auditstore_opts.merge(
+                start_datetime: Time.now.asctime,
+                finish_datetime: Time.now.asctime
+            ).deep_clone
+        )
+
+        @clean = Arachni::AuditStore.new( @auditstore_opts )
+    end
+
+    describe '#version' do
+        it 'should return the version number' do
+            @auditstore.version.should == '0.1'
+        end
+    end
+
+    describe '#revision' do
+        it 'should return the revision number' do
+            @auditstore.revision.should == '0.2'
+        end
+    end
+
+    describe '#options' do
+        it 'should return the options as a hash' do
+            h = Arachni::Options.instance.to_h
+            h['url'] = h['url'].to_s
+            ah = @auditstore.options
+            ah['cookies'] = nil
+            h['cookies'] = nil
+            ah.should == h
+        end
+    end
+
+    describe '#sitemap' do
+        it 'should return the sitemap' do
+            @auditstore.sitemap.should == [@opts.url.to_s]
+        end
+    end
+
+    describe '#issues' do
+        it 'should return the issues' do
+            @auditstore.issues.should == [@issue]
+        end
+    end
+
+    describe '#plugins' do
+        it 'should return the plugin results' do
+            @auditstore.plugins.should == @plugin_results
+        end
+    end
+
+    describe '#start_datetime' do
+        it 'should return the start datetime of the scan' do
+            Time.parse( @auditstore.start_datetime ).is_a?( Time ).should be_true
+        end
+        context 'when no start datetime info has been provided' do
+            it 'should revert to Time.now' do
+                Time.parse( @clean.start_datetime ).is_a?( Time ).should be_true
+            end
+        end
+    end
+
+    describe '#finish_datetime' do
+        it 'should return the start finish of the scan' do
+            Time.parse( @auditstore.finish_datetime ).is_a?( Time ).should be_true
+        end
+        context 'when no start datetime info has been provided' do
+            it 'should revert to Time.now' do
+                Time.parse( @clean.finish_datetime ).is_a?( Time ).should be_true
+            end
+        end
+    end
+
+    describe '#delta_time' do
+        it 'should return the time difference between start and finish time' do
+            Time.parse( @auditstore.delta_time ).is_a?( Time ).should be_true
+        end
+    end
+
+    it 'should organize identical issues into variations' do
+        url = 'http://test.com'
+        i = Arachni::Issue.new(
+            url: url,
+            name: 'blah',
+            mod_name: 'mod',
+            elem: 'link',
+            var: 'varname'
+        )
+        issues = [
+            i.deep_clone, i.deep_clone,
+            Arachni::Issue.new(
+                url: url,
+                name: 'blah',
+                mod_name: 'mod',
+                elem: 'link',
+                var: 'varname2'
+            )
+        ]
+        organized = Arachni::AuditStore.new( @auditstore_opts.merge( issues: issues.deep_clone ) ).issues
+        organized.first.variations.size.should == 2
+
+        identical = %w(name url mod_name elem var)
+        organized.first.variations.each do |v|
+            identical.each { |attr| v.send( attr ).should == i.send( attr ) }
+        end
+
+        organized.last.variations.size.should == 1
+        organized.last.variations.each do |v|
+            identical.each { |attr| v.send( attr ).should == issues.last.send( attr ) }
+        end
+    end
+
+    it 'should sort the issues based on severity' do
+        url = 'http://test.com'
+        opts = {
+            url: url,
+            mod_name: 'mod',
+            elem: 'link',
+        }
+        high = Arachni::Issue.new( opts.merge(
+            severity: ::Arachni::Issue::Severity::HIGH,
+            name: 'blah1'
+        ))
+        medium = Arachni::Issue.new( opts.merge(
+            severity: ::Arachni::Issue::Severity::MEDIUM,
+            name: 'blah2'
+        ))
+        low = Arachni::Issue.new( opts.merge(
+            severity: ::Arachni::Issue::Severity::LOW,
+            name: 'blah3'
+        ))
+        info = Arachni::Issue.new( opts.merge(
+            severity: ::Arachni::Issue::Severity::INFORMATIONAL,
+            name: 'blah4'
+        ))
+
+        issues = [low, medium, info, high]
+        sorted = Arachni::AuditStore.new( @auditstore_opts.merge( issues: issues ) ).issues
+        sorted.map { |i| i.severity }.should == [high.severity, medium.severity, low.severity, info.severity]
+    end
+
+    describe '#save' do
+        it 'should serialize and save the object to a file' do
+            filename = 'auditstore'
+            auditstore = ::Arachni::AuditStore.new( @auditstore_opts )
+            auditstore.save( filename )
+
+            loaded = ::Arachni::AuditStore.load( filename )
+            File.delete( filename )
+
+            auditstore.instance_variables.each do |v|
+                if v.to_s != '@issues'
+                    loaded.instance_variable_get( v ).should == auditstore.instance_variable_get( v )
+                else
+                    loaded.issues.size.should == auditstore.issues.size
+                end
+            end
+        end
+    end
+
+    describe '#to_hash' do
+        it 'should return the object as a hash' do
+            h = @auditstore.to_hash
+            h.is_a?( Hash ).should be_true
+
+            h.each do |k, v|
+                if k.to_s != 'issues'
+                    @auditstore.instance_variable_get( "@#{k}".to_sym ).should == v
+                else
+                    @auditstore.issues.size.should == v.size
+                end
+            end
+        end
+        it 'should be aliased to #to_h' do
+            @auditstore.to_hash.should == @auditstore.to_h
+        end
+    end
+
+    describe '#==' do
+        context 'when the auditstores are equal' do
+            it 'should return true' do
+                a = @auditstore.deep_clone
+                a.should == @auditstore
+            end
+        end
+        context 'when the auditstores are not equal' do
+            it 'should return false' do
+                a = @auditstore.deep_clone
+                a.options['url'] = ''
+                a.should_not == @auditstore
+            end
+        end
+    end
+
+end

data/spec/arachni/bloom_filter_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper'
+
+describe Arachni::BloomFilter do
+    before( :all ) do
+        @bf = Arachni::BloomFilter.new
+    end
+
+    describe '#<<' do
+        it 'should add an object and return self' do
+            (@bf << 'test').should == @bf
+        end
+        it 'should be aliased to #add' do
+            @bf.add( 'test2' ).should == @bf
+        end
+    end
+
+    describe '#include?' do
+        context 'when an object is included' do
+            it 'should return true' do
+                @bf.include?( 'test' ).should be_true
+                @bf.include?( 'test2' ).should be_true
+            end
+        end
+        context 'when an object is not included' do
+            it 'should return false' do
+                @bf.include?( 'test3' ).should be_false
+            end
+        end
+    end
+
+    describe '#delete?' do
+        it 'should delete an object and return self' do
+            @bf.include?( 'test' ).should be_true
+            @bf.delete( 'test' ).should be_true
+            @bf.include?( 'test' ).should be_false
+        end
+    end
+
+    describe '#empty?' do
+        context 'when empty' do
+            it 'should return true' do
+                Arachni::BloomFilter.new.empty?.should be_true
+            end
+        end
+        context 'when not empty' do
+            it 'should return false' do
+                @bf.empty?.should be_false
+            end
+        end
+    end
+
+    describe '#size' do
+        it 'should return the size' do
+            bf = Arachni::BloomFilter.new
+            bf.size.should == 0
+            bf << 1
+            bf.size.should == 1
+            bf << 1
+            bf.size.should == 1
+            bf << 2
+            bf.size.should == 2
+        end
+    end
+
+    describe '#clear' do
+        it 'should empty the list' do
+            bf = Arachni::BloomFilter.new
+            bf << 1
+            bf << 2
+            bf.size.should == 2
+            bf.clear
+            bf.size.should == 0
+        end
+    end
+
+end

data/spec/arachni/cache/base_spec.rb

@@ -0,0 +1,275 @@
+require_relative '../../spec_helper'
+
+describe Arachni::Cache::Base do
+
+    before { @cache = Arachni::Cache::Base.new }
+
+    describe '#new' do
+        describe 'max_size' do
+            describe 'nil' do
+                it 'should leave the cache uncapped' do
+                    Arachni::Cache::Base.new.capped?.should be_false
+                end
+            end
+            describe Integer do
+                it 'should impose a limit to the size of the cache' do
+                    Arachni::Cache::Base.new( 10 ).capped?.should be_true
+                end
+            end
+        end
+    end
+
+    describe '#max_size' do
+        context 'when just initialized' do
+            it 'should return nil (unlimited)' do
+                @cache.max_size.should be_nil
+            end
+        end
+        context 'when set' do
+            it 'should return the set value' do
+                (@cache.max_size = 50).should == 50
+                @cache.max_size.should == 50
+            end
+        end
+    end
+
+    describe '#uncap' do
+        it 'should remove the size limit' do
+            @cache.max_size = 1
+            @cache.uncap
+            @cache.max_size = nil
+        end
+    end
+
+    describe '#capped?' do
+        context 'when the cache has no size limit' do
+            it 'should return false' do
+                @cache.uncap
+                @cache.capped?.should be_false
+                @cache.max_size.should be_nil
+            end
+        end
+        context 'when the cache has a size limit' do
+            it 'should return true' do
+                @cache.max_size = 1
+                @cache.capped?.should be_true
+            end
+        end
+    end
+
+    describe '#uncapped?' do
+        context 'when the cache has no size limit' do
+            it 'should return true' do
+                @cache.uncap
+                @cache.uncapped?.should be_true
+                @cache.max_size.should be_nil
+            end
+        end
+        context 'when the cache has a size limit' do
+            it 'should return false' do
+                @cache.max_size = 1
+                @cache.max_size.should == 1
+                @cache.uncapped?.should be_false
+            end
+        end
+    end
+
+    describe '#uncap' do
+        it 'should remove the size limit' do
+            @cache.max_size = 1
+            @cache.uncapped?.should be_false
+            @cache.max_size.should == 1
+
+            @cache.uncap
+            @cache.uncapped?.should be_true
+            @cache.max_size.should be_nil
+        end
+    end
+
+    describe '#max_size=' do
+        it 'should set the maximum size for the cache' do
+            (@cache.max_size = 100).should == 100
+            @cache.max_size.should == 100
+        end
+
+        context 'when passed < 0' do
+            it 'should throw an exception' do
+                raised = false
+                begin
+                    @cache.max_size = 0
+                rescue
+                    raised = true
+                end
+                raised.should be_true
+            end
+        end
+    end
+
+    describe '#size' do
+        context 'when the cache is empty' do
+            it 'should return 0' do
+                @cache.size.should == 0
+            end
+        end
+
+        context 'when the cache is not empty' do
+            it 'should return a value > 0' do
+                @cache['stuff'] = [ 'ff ' ]
+                @cache.size.should > 0
+            end
+        end
+    end
+
+    describe '#empty?' do
+        context 'when the cache is empty' do
+            it 'should return true' do
+                @cache.empty?.should be_true
+            end
+        end
+        context 'when the cache is not empty' do
+            it 'should return false' do
+                @cache['stuff2'] = 'ff'
+                @cache.empty?.should be_false
+            end
+        end
+    end
+
+    describe '#any?' do
+        context 'when the cache is empty' do
+            it 'should return true' do
+                @cache.any?.should be_false
+            end
+        end
+        context 'when the cache is not empty' do
+            it 'should return false' do
+                @cache['stuff3'] = [ 'ff ' ]
+                @cache.any?.should be_true
+            end
+        end
+    end
+
+    describe '#[]=' do
+        it 'should store an object' do
+            v = 'val'
+            (@cache[:key] = v).should == v
+            @cache[:key].should == v
+        end
+        it 'should be an alias of #store' do
+            v = 'val2'
+            @cache.store( :key2, v ).should == v
+            @cache[:key2].should == v
+        end
+    end
+
+    describe '#[]' do
+        it 'should retrieve an object by key' do
+            v = 'val2'
+            @cache[:key] = v
+            @cache[:key].should == v
+            @cache.empty?.should be_false
+        end
+
+        context 'when the key does not exist' do
+            it 'should return nil' do
+                @cache[:some_key].should be_nil
+            end
+        end
+    end
+
+    describe '#fetch_or_store' do
+        context 'when the passed key exists' do
+            it 'should return its value' do
+                old_val = 'my val'
+                new_val = 'new val'
+
+                cache = Arachni::Cache::Base.new
+                cache[:my_key] = old_val
+                cache.fetch_or_store( :my_key ) { new_val }
+
+                cache[:my_key].should == old_val
+            end
+        end
+
+        context 'when the passed key does not exist' do
+            it 'should assign to it the return value of the block return that value' do
+                new_val = 'new val'
+                cache = Arachni::Cache::Base.new
+                cache.fetch_or_store( :my_key ) { new_val }
+
+                cache[:my_key].should == new_val
+            end
+        end
+    end
+
+    describe '#include?' do
+        context 'when the key exists' do
+            it 'should return true' do
+                @cache[:key1] = 'v'
+                @cache.include?( :key1 ).should be_true
+            end
+        end
+        context 'when the key does not exist' do
+            it 'should return false' do
+                @cache.include?( :key2 ).should be_false
+            end
+        end
+    end
+
+    describe '#delete' do
+        context 'when the key exists' do
+            it 'should delete a key and return its value' do
+                v = 'my_val'
+                @cache[:my_key] = v
+                @cache.delete( :my_key ).should == v
+                @cache[:my_key].should be_nil
+                @cache.include?( :my_key ).should be_false
+            end
+        end
+        context 'when the key does not exist' do
+            it 'should return nil' do
+                @cache.delete( :my_key2 ).should be_nil
+            end
+        end
+    end
+
+    describe '#empty?' do
+        context 'when cache is empty' do
+            it 'should return true' do
+                @cache.empty?.should be_true
+            end
+        end
+        context 'when cache is not empty' do
+            it 'should return false' do
+                @cache['ee'] = 'rr'
+                @cache.empty?.should be_false
+            end
+        end
+    end
+
+    describe '#any?' do
+        context 'when cache is empty' do
+            it 'should return false' do
+                @cache.any?.should be_false
+            end
+        end
+        context 'when cache is not empty' do
+            it 'should return true' do
+                @cache['ee'] = 'rr'
+                @cache.any?.should be_true
+            end
+        end
+    end
+
+    describe '#clear' do
+        it 'should empty the cache' do
+            @cache[:my_key2] = 'v'
+            @cache.size.should > 0
+            @cache.empty?.should be_false
+            @cache.clear
+
+            @cache.size.should == 0
+            @cache.empty?.should be_true
+        end
+    end
+
+end