watobo 0.9.8.677

data/lib/watobo/core/active_check.rb

@@ -0,0 +1,404 @@
+# .
+# active_check.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  class ActiveCheck  < Watobo::Session    # Base Class for Passive Checks
+
+    attr :info
+    attr :numChecks
+
+    #   @@running_checks = 0
+    @@max_checks = 5
+    @@check_count = 0
+    @@pool = []
+    @@pool_mutex = Mutex.new
+    @@pool_cv = ConditionVariable.new
+
+    @@status = :running # :running, :paused, :canceled
+    @@lock = Mutex.new
+    
+    def addFinding(request, response, details)
+      @@lock.synchronize {
+
+        t = Time.now
+        now = t.strftime("%m/%d/%Y@%H:%M:%S")
+
+        new_details = Hash.new
+        new_details.update(@finding)
+
+        new_details.update(details)
+        new_details[:tstamp] = now
+
+        id_string = ''
+        id_string << request.site
+        id_string << request.path
+        id_string << new_details[:test_item] if new_details[:test_item]
+        id_string << new_details[:class] if new_details[:class]
+        id_string << new_details[:title]  if new_details[:title]
+
+        if id_string == '' then
+        id_string = rand(10000)
+        end
+        #
+        new_details[:fid] = Digest::MD5.hexdigest(id_string)
+
+        new_details[:module] = self.class.to_s
+        # new_details[:module] = Module.nesting[]
+
+        new_details[:chat_id] = new_details[:chat].id
+        new_details.delete(:chat)
+
+        new_finding = Watobo::Finding.new(request, response, new_details)
+        #  puts new_finding
+        notify(:new_finding, new_finding)
+      }
+    end
+
+    def reset()
+      # should be overridden, if counters or status information are used!!!
+    end
+
+    def resetCounters()
+      @numChecks = 0
+      @counters = Hash.new
+      @progress = 0
+      reset()
+    end
+
+    def updateCounters(chat, *prefs)
+      @settings[:excluded_parms] = prefs[:excluded_parms] if prefs.is_a? Hash and prefs[:excluded_parms]
+      @counters[chat.id] = getCheckCount(chat)
+      @numChecks += @counters[chat.id]
+
+    #puts "#{chat.id} : #{@numChecks}"
+    end
+
+    def urlParmNames(chat)
+      begin
+        pnames = chat.request.get_parm_names
+        # puts @settings.to_yaml
+        if @settings.has_key? :excluded_parms
+          @settings[:excluded_parms].each do |p|
+            pnames.delete(p)
+          end
+        end
+      rescue => bang
+      puts "! settings 'excluded_parms' missing !"
+      #  puts @project.settings.to_yaml
+      puts bang
+      puts bang.backtrace if $DEBUG
+      end
+      return pnames
+    end
+
+    def postParmNames(chat)
+      pnames = chat.request.post_parm_names
+      begin
+        @settings[:excluded_parms].each do |p|
+          pnames.delete(p)
+        end
+      rescue => bang
+      puts "! settings 'excluded_parms' missing !"
+      #  puts @project.settings.to_yaml
+      puts bang
+      puts bang.backtrace if $DEBUG
+      end
+      return pnames
+    end
+
+    def getCheckCount(chat)
+      count = 0
+      generateChecks(chat) do |check|
+        count += 1 if check.respond_to? :call
+      end
+      count
+    end
+
+    def maxChecks=(m)
+      @@max_checks = m
+    end
+
+    def maxChecks()
+      @@max_checks
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(status)
+      @enabled = status.is_a? TrueClass|FalseClass
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def checksRunning?
+      begin
+        puts @inner_pool.size
+        return true if @inner_pool.size > 0
+        return false
+      rescue => bang
+      p bang
+      p bang.backtrace
+      end
+    end
+
+    def disable
+      @enable = false
+    end
+
+    def generateChecks(chat)
+      raise "Missing method generateChecks()!!!"
+    end
+
+    def waitLogin(state)
+      @@login_in_progress = state
+      @inner_pool_cv.signal if state == false
+    end
+
+    def continue()
+      @@pool.each do |thr|
+      #  puts "Stopping #{thr}"
+        begin
+          thr.run if not thr.run?
+        rescue
+        puts "could not continue thread #{thr}"
+        end
+      end
+    end
+
+    def cancel()
+      @@status = :stopped
+      @inner_pool.each do |thr|
+        begin
+          if thr.alive?
+          puts "Stopping #{thr}" if $DEBUG
+
+          Thread.kill( thr ) #.kill if not thr.kill?
+
+          end
+          @inner_pool.delete(thr)
+        rescue => bang
+        puts "could not kill thread #{thr}"
+        puts bang
+        puts bang.backtrace if $DEBUG
+        end
+      end
+      @inner_pool_cv.signal
+
+    end
+
+    def stop()
+      # TODO: real stop/pause function
+      cancel()
+    end
+
+    def fileExists?(request, prefs={})
+      begin
+        t_request, t_response = doRequest(request, prefs)
+        #puts t_response.status
+        return true, t_request, t_response if t_response.status =~ /^403/
+        return false, t_request, t_response if t_response.status =~ /^40\d/
+
+        puts @settings[:custom_error_patterns] if $debug_active_check
+
+        if @settings.has_key? :custom_error_patterns
+          @settings[:custom_error_patterns].each do |pat|
+          # puts pat
+            t_response.headers.each do |hl|
+              return false if hl =~ /#{pat}/
+            end
+            # puts t_response.body.class
+            unless t_response.body.nil?
+              #  puts "* check body"
+              #  puts t_response.body
+              return false if t_response.body =~ /#{pat}/
+            end
+          end
+        end
+        # if t_request.path_ext != ""
+        #TODO: Check for custom error pages
+        # end
+
+        return true, t_request, t_response
+      rescue => bang
+      end
+      return false, nil, nil
+    end
+
+    # +++ run_checks  +++
+    # + function: wrapper function for doRequest(r). Needed for additional checks like smartchecks.
+    #
+    # :run_passive_checks false,
+    # :do_login
+
+    def run_checks(chat, opts={})
+      begin
+      # reset() # reset variables first
+        @@status = :running
+        check_opts = { :run_passive_checks => false}
+        check_opts.update opts
+        @settings.update opts
+
+        updateSessionSettings(opts)
+        #  puts @session.to_yaml
+
+        @@proxy = opts[:proxy] if opts[:proxy]
+     #   @@max_checks = opts[:max_parallel_checks] if opts.has_key? :max_parallel_checks
+     @@max_checks = Watobo::Conf::Scanner.max_parallel_checks
+
+        do_test(chat) { |request, response|
+          begin
+           
+            if request and response then
+              if check_opts[:run_passive_checks] then
+
+              nc = Watobo::Chat.new(request, response, :id => 0)
+              #   @project.runPassiveChecks(nc)
+
+              end
+
+            end
+          rescue => bang
+          puts bang
+          puts bang.backtrace if $DEBUG
+          end
+
+        }
+
+      rescue => bang
+      puts bang
+      puts bang.backtrace if $DEBUG
+
+      end
+
+    end
+
+    def do_test(chat, &block)
+      # puts chat.request.site
+      tlist = []
+      @inner_pool = []
+      dummy = Hash.new
+      generateChecks(chat) do |check|
+        dummy[chat.id] ||= 0
+        dummy[chat.id] += 1
+        puts dummy.to_yaml
+        unless @@status == :stopped
+          @@pool_mutex.synchronize do
+            while  @@check_count > @@max_checks or @@login_in_progress
+              puts "[#{self.class.to_s.gsub(/Watobo::Modules::Active::/,'')}] do_test on chat [#{chat.id}]: waiting .. #{@@check_count}/#{@@max_checks}" if $DEBUG
+              @@pool_cv.wait(@@pool_mutex)
+            end
+            @@check_count += 1
+          end
+
+          @inner_pool << Thread.new(check) { |c|
+            begin
+
+              if c.respond_to? :call
+              request, response = c.call            
+              yield request, response if block_given?
+              
+              end
+            rescue => bang
+            # puts "!!!ERROR: running check in #{self.class}"
+              puts bang
+              puts bang.backtrace if $DEBUG
+              # raise
+            ensure
+
+              @@pool_mutex.synchronize do
+                @@check_count -= 1
+                notify(:check_finished, self, request, response)
+                #@inner_pool.delete Thread.current
+              end
+            @@pool_cv.signal
+
+            end
+          }
+         # puts "[#{self.class.to_s.gsub(/Watobo::Modules::Active::/,'')}] [#{chat.id}]: INNER POOL - #{@inner_pool.length} " 
+        end
+      end
+
+      @inner_pool.each {|t| t.join }
+      puts ">>>>  #{self.class} on chat[#{chat.id}] ... finished!\n"
+    end
+
+    def initialize(session_name=nil, prefs={})
+      #@project = project
+      super(session_name, prefs)
+
+      @enabled = true
+      # @status = "ready"
+      @counters = Hash.new
+
+      #TODO: change @settings to @session, if no bugs!
+      @settings = @session
+      #    @settings = {
+      #      :custom_error_patterns => [],
+      #      :excluded_parms => []
+      #    }
+
+      @@max_checks = prefs[:max_parallel_checks] unless prefs[:max_parallel_checks].nil?
+      @running_chats = []
+
+      @numChecks = 0
+      @progress = 0
+      @check_threads = []
+
+      @inner_pool = []
+      @inner_pool_mutex = Mutex.new
+      @inner_pool_cv = ConditionVariable.new
+
+      @checks_cv = ConditionVariable.new
+      @checks_mutex = Mutex.new
+
+      @info = {
+        :check_name => '',    # name of check which briefly describes functionality, will be used for tree and progress views
+        :check_group => 'Misc',   # groupname of check, will be used to group checks, e.g. :Generic, SAP, :Enumeration
+        :description => '',   # description of checkfunction
+        :author => "not modified", # author of check
+        :version => "unversioned",   # check version
+        :target => nil               # reserved
+
+      }
+
+      @finding = {
+        :title => 'untitled',          # [String] title name, used for finding tree
+        :check_pattern => nil,         # [String] regex of vulnerability check if possible, will be used for highlighting
+        :proof_pattern => nil,         # [String] regex of finding proof if possible, will be used for highlighting
+        :threat => '',        # threat of vulnerability, e.g. loss of information
+        :measure => '',       # measure
+        :class => "undefined",# [String] vulnerability class, e.g. Stored XSS, SQL-Injection, ...
+        :subclass => nil,     # reserved
+        :type => FINDING_TYPE_UNDEFINED,         # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN
+        :chat => nil,         # related chat must be linked
+        :rating=> VULN_RATING_UNDEFINED,  #
+        :cvss => "n/a",       # CVSS Base Vector
+        :icon => nil,     # Icon Type
+        :timestamp => nil         # timestamp
+      }
+
+    end
+  end
+end

data/lib/watobo/core/cookie.rb

@@ -0,0 +1,69 @@
+# .
+# cookie.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  
+  
+#Set-Cookie: mycookie=b41dc9e55d6163f78321996b10c940edcec1b4e55a76464c4e9d25e160ac0ec5b769806b; path=/; secure
+
+  class Cookie
+    
+    attr :name
+    attr :value
+    attr :path
+    attr :secure
+    attr :http_only
+    
+    def name_value
+    "#{@name}=#{@value}"  
+    end
+    
+    def initialize(prefs)
+      @value = nil
+      @name = nil
+      @secure = false
+      @http_only = false
+      @path = nil
+      
+      if prefs.is_a? String
+        # remove Set-Cookie: from string
+      #  puts "* create new Cookie"
+      #  puts ">> #{prefs}"
+        cs = prefs.gsub(/^Set-Cookie:/,'').strip.split(";").map{ |c| c.strip }
+        @name, @value = cs.shift.split("=") 
+        cs.each do |o|
+          if o =~ /^path=(.*)/
+            @path = $1
+          end
+          
+          @secure = true if o =~ /secure/i
+          @http_only = true if o =~ /httponly/i
+        end
+      elsif prefs.is_a? Hash
+        #TODO: create cookie with hash-settings
+      else
+        raise ArgumentError, "Need hash (:name, :value, ...) or string (Set-Cookie:...)"
+      end
+    end
+  end
+  
+  
+end

data/lib/watobo/core/fuzz_gen.rb

@@ -0,0 +1,160 @@
+# .
+# fuzz_gen.rb
+# 
+# Copyright 2012 by siberas, http://www.siberas.de
+# 
+# This file is part of WATOBO (Web Application Tool Box)
+#        http://watobo.sourceforge.com
+# 
+# WATOBO is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation version 2 of the License.
+# 
+# WATOBO is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with WATOBO; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# .
+module Watobo
+  
+    # base class for generators
+    class FuzzGenerator
+      attr :numRequests
+      attr :name
+      attr :genType
+      attr :actions
+      attr :info
+      
+      def is_generator?
+        true
+      end
+
+      def run(imr=nil)
+        result = Hash.new
+
+        result.update imr if imr
+
+        generate do |value|
+          rv = value
+          @actions.each do |p|
+            rv = p.func.call(rv)
+          end
+          result[@fuzzer_tag.name] = rv
+          yield result
+
+        end
+      end
+
+      def addAction(proc)
+        @actions.push proc
+      end
+
+      def removeAction(action)
+        @actions.delete(action)
+      end
+
+      def generate
+        return true
+      end
+
+      def initialize(fuzzer_tag)
+        @actions = []
+        @numRequests = 0
+        @fuzzer_tag = fuzzer_tag
+        @genType = "Undefined"
+        @info = "undefined"
+      end
+
+    end
+
+    class FuzzFile < FuzzGenerator
+      def generate
+        return if not @filename
+        fh = File.open(@filename)
+        fh.each_line do |line|
+          line.chomp!
+          yield line if not line.empty?
+        end
+      end
+
+      def initialize(fuzzer_tag, filename)
+        super(fuzzer_tag)
+        @genType = "File-Input"
+        @filename = ""
+        @numRequests = 0
+        if File.exists?(filename) then
+          @filename = filename
+          File.open(filename) do |fh|
+            fh.each_line do |l|
+              @numRequests += 1
+            end
+          end
+        else
+          @numRequests = 0
+        end
+
+        @info = "Filename: #{@filename}"
+
+      end
+
+    end
+
+    class FuzzList < FuzzGenerator
+      def generate(&block)
+        @list.each do |item|
+          yield item if block_given?
+        end
+      end
+
+      def initialize(fuzzer_tag, list)
+        @list = list
+        super(fuzzer_tag)
+        @genType = "List-Input"
+        @numRequests = @list.length
+        @info = "#{@numRequests} values"
+      end
+    end
+
+    class FuzzCounter < FuzzGenerator
+      attr_reader :start, :stop, :count, :step
+      
+      def generate
+        return false if @start.nil?
+        return false if @stop.nil? and @count.nil?
+
+        if @stop == 0 and @count > 0 then
+          @stop = @start + @count
+        end
+
+        return 0 if @start == @stop
+
+        @start.step(@stop, @step) do |i|
+          yield i.to_s
+        end
+
+      end
+
+      def initialize(fuzzer_tag, prefs)
+        super(fuzzer_tag)
+        @genType = "Counter"
+        @start = prefs[:start]
+        @stop =  prefs[:stop]
+
+        @count = prefs[:count] || 0
+        @step = ( prefs[:step] and prefs[:step] != 0 ) ? prefs[:step] : 1
+
+        if @stop < @start and @step > 0 then
+          @step = @step * -1
+        end
+        @info = "start=#{@start}/stop=#{@stop}/step=#{@step}"
+        @numRequests = (( @stop - @start ) / @step).abs
+
+      end
+
+    end
+
+end