watobo 0.9.19 → 0.9.20

data/lib/watobo/interceptor.rb

@@ -1,25 +1,13 @@
-# .
+#.
 # interceptor.rb
-# 
-# Copyright 2013 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
-# .
-%w( proxy transparent ).each do |lib|
-  require "watobo/interceptor/#{lib}"
-end
+#.
+# Copyright 2014 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
 
+%w( proxy transparent ).each do |lib|
+  require "watobo/interceptor/#{lib}"
+end
+

data/lib/watobo/interceptor/proxy.rb

@@ -1,214 +1,213 @@
-# .
+#.
 # proxy.rb
-# 
-# Copyright 2013 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
-# .
-# @private
-module Watobo#:nodoc: all
-  module Interceptor
-    #
-    class Proxy
-
-      include Watobo::Constants
-
-      attr :port
-
-      attr_accessor :proxy_mode
-
-     # attr_accessor :contentLength
-      #attr_accessor :contentTypes
-      attr_accessor :target
-      #attr :www_auth
-      attr_accessor :client_certificates
-      def self.transparent?
-        return true if ( Watobo::Conf::Interceptor.proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT ) > 0
-        return false
-      end
-
-      def server
-        @bind_addr
-      end
-
-      def subscribe(event, &callback)
-        (@event_dispatcher_listeners[event] ||= []) << callback
-      end
-
-      def clearEvents(event)
-        @event_dispatcher_listener[event].clear
-      end
-
-      def getResponseFilter()
-        YAML.load(YAML.dump(@response_filter_settings))
-      end
-
-      def getRequestFilter()
-        YAML.load(YAML.dump(@request_filter_settings))
-      end
-
-      def setResponseFilter(new_settings)
-        @response_filter_settings.update new_settings unless new_settings.nil?
-      end
-
-      def setRequestFilter(new_settings)
-        @request_filter_settings.update new_settings unless new_settings.nil?
-      # puts @request_filter_settings.to_yaml
-      end
-
-      def clear_request_carvers
-        @request_carvers.clear unless @request_carvers.nil?
-
-      end
-
-      def clear_response_carvers
-        @response_carvers.clear unless @response_carvers.nil?
-      end
-
-      def addPreview(response)
-        preview_id = Digest::MD5.hexdigest(response.join)
-        @preview[preview_id] = response
-        return preview_id
-      end
+#.
+# Copyright 2014 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
 
-      def stop()
-        begin
-          puts "[#{self.class}] stop"
-          if @t_server.respond_to? :status
-            puts @t_server.status
-            Thread.kill @t_server
-          @intercept_srv.close
-          end
-        rescue IOError => bang
-          puts bang
-          puts bang.backtrace if $DEBUG
-        end
-      end
-
-      #
-      # R U N
-      #
-
-      def self.start(settings = {})
-        proxy = Proxy.new(settings)
-        proxy.start
-        proxy
-      end
+# @private
+module Watobo#:nodoc: all
+  module Interceptor
+    #
+    class Proxy
+
+      include Watobo::Constants
+
+      attr :port
+
+      attr_accessor :proxy_mode
+
+     # attr_accessor :contentLength
+      #attr_accessor :contentTypes
+      attr_accessor :target
+      #attr :www_auth
+      attr_accessor :client_certificates
+      def self.transparent?
+        return true if ( Watobo::Conf::Interceptor.proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT ) > 0
+        return false
+      end
+
+      def server
+        @bind_addr
+      end
+
+      def subscribe(event, &callback)
+        (@event_dispatcher_listeners[event] ||= []) << callback
+      end
+
+      def clearEvents(event)
+        @event_dispatcher_listener[event].clear
+      end
+
+      def getResponseFilter()
+        YAML.load(YAML.dump(@response_filter_settings))
+      end
+
+      def getRequestFilter()
+        YAML.load(YAML.dump(@request_filter_settings))
+      end
+
+      def setResponseFilter(new_settings)
+        @response_filter_settings.update new_settings unless new_settings.nil?
+      end
+
+      def setRequestFilter(new_settings)
+        @request_filter_settings.update new_settings unless new_settings.nil?
+      # puts @request_filter_settings.to_yaml
+      end
+
+      def clear_request_carvers
+        @request_carvers.clear unless @request_carvers.nil?
+
+      end
+
+      def clear_response_carvers
+        @response_carvers.clear unless @response_carvers.nil?
+      end
+
+      def addPreview(response)
+        preview_id = Digest::MD5.hexdigest(response.join)
+        @preview[preview_id] = response
+        return preview_id
+      end
+
+      def stop()
+        begin
+          puts "[#{self.class}] stop"
+          if @t_server.respond_to? :status
+            puts @t_server.status
+            Thread.kill @t_server
+          @intercept_srv.close
+          end
+        rescue IOError => bang
+          puts bang
+          puts bang.backtrace if $DEBUG
+        end
+      end
+
+      #
+      # R U N
+      #
+
+      def self.start(settings = {})
+        proxy = Proxy.new(settings)
+        proxy.start
+        proxy
+      end
 
       def start()
-        @wait_queue = Queue.new
-
-        if transparent?
-          Watobo::Interceptor::Transparent.start
-        end
-
-        begin
-          @intercept_srv = TCPServer.new(@bind_addr, @port)
-          @intercept_srv.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1 )
-
-        rescue => bang
-          puts "\n!!!Could not start InterceptProxy"
-          puts bang
-          return nil
-        end
-        puts "\n* Intercepor started on #{@bind_addr}:#{@port}"
-        session_list = []
-        puts "!!! TRANSPARENT MODE ENABLED !!!" if transparent?
-
-        @t_server = Thread.new(@intercept_srv) { |server|
-        while (new_session = server.accept)
+        @wait_queue = Queue.new
+
+        if transparent?
+          Watobo::Interceptor::Transparent.start
+        end
+
+        begin
+          @intercept_srv = TCPServer.new(@bind_addr, @port)
+          @intercept_srv.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1 )
+
+        rescue => bang
+          puts "\n!!!Could not start InterceptProxy"
+          puts bang
+          return nil
+        end
+        puts "\n* Intercepor started on #{@bind_addr}:#{@port}"
+        session_list = []
+        puts "!!! TRANSPARENT MODE ENABLED !!!" if transparent?
+
+        @t_server = Thread.new(@intercept_srv) { |server|
+        while (new_session = server.accept)
           #  new_session.sync = true
-          new_sender = Watobo::Session.new(@target)
-          Thread.new(new_sender, new_session) { |sender, session|
-
+          new_sender = Watobo::Session.new(@target)
+          Thread.new(new_sender, new_session) { |sender, session|
+
             c_sock = Watobo::HTTPSocket::ClientSocket.connect(session)
             
-            #puts "ClientSocket: #{c_sock}"
+            #puts "ClientSocket: #{c_sock}"
             Thread.exit if c_sock.nil?
             
             #
             # loop for reusing client connections
             
-            max_loop = 0
-            loop do
-            flags = []
+            max_loop = 0
+            loop do
+            flags = []
             begin
               
             # puts "#{c_sock} - read request"
              request = c_sock.request
+             
+             #if request.is_multipart?
+             #  puts request
+             #  puts request.body.to_s.length
+             #  puts request.body.to_s.unpack("H*")[0]
+             #end
             
              if request.nil? or request.empty? then
-                print "c/"
-                c_sock.close
-                Thread.exit
-              end
+                print "c/"
+                c_sock.close
+                Thread.exit
+              end
               
               url = ( request.url.to_s.length > 65 ) ? request.url.to_s.slice(0,65) + "..." : request.url.to_s
-              puts "\n[I] #{url}"
-
-            rescue => bang
-              puts "!!! Error reading client request "
-              puts bang
-              puts bang.backtrace
-             # puts request.class
-             # puts request
-             c_sock.close
-             Thread.exit
-            #break
+              puts "\n[I] #{url}"
+
+            rescue => bang
+              puts "!!! Error reading client request "
+              puts bang
+              puts bang.backtrace
+             # puts request.class
+             # puts request
+             c_sock.close
+             Thread.exit
+            #break
             end
-
-            # check if preview is requested
-            if request.host =='watobo.localhost' or request.first =~ /WATOBOPreview/ then
+            
+             if request.host =~ /safebrowsing.*google\.com/
+               c_sock.close
+               Thread.exit
+             end
+
+            # check if preview is requested
+            if request.host =='watobo.localhost' or request.first =~ /WATOBOPreview/ then
               if request.first =~ /WATOBOPreview=([0-9a-zA-Z]*)/ then
-                hashid = $1
-                response = @preview[hashid]
-
-                if response then
-                  c_sock.write response.join
-                  c_sock.close
-                end
-              end
-            #next
-            Thread.exit
-            end
-
-            request_intercepted = false
-            # no preview, check if interception request is turned on
-            if Watobo::Interceptor.rewrite_requests? then
-              Interceptor::RequestCarver.shape(request, flags)
-              puts "FLAGS >>"
-              puts flags
-            end
-
-            if @target and Watobo::Interceptor.intercept_requests? then
-              if matchRequestFilter(request)
-                @awaiting_requests += 1
-                request_intercepted = true
-
-                if @target.respond_to? :addRequest
-                  Watobo.print_debug "send request to target"
-                  @target.addRequest(request, Thread.current)
-                  Thread.stop
-                else
-                  p "! no target for editing request"
-                end
-              @awaiting_requests -= 1
-              end
-            end
+                hashid = $1
+                response = @preview[hashid]
+
+                if response then
+                  c_sock.write response.join
+                  c_sock.close
+                end
+              end
+            #next
+            Thread.exit
+            end
+
+            request_intercepted = false
+            # no preview, check if interception request is turned on
+            if Watobo::Interceptor.rewrite_requests? then
+              Interceptor::RequestCarver.shape(request, flags)
+              puts "FLAGS >>"
+              puts flags
+            end
+
+            if @target and Watobo::Interceptor.intercept_requests? then
+              if matchRequestFilter(request)
+                @awaiting_requests += 1
+                request_intercepted = true
+
+                if @target.respond_to? :addRequest
+                  Watobo.print_debug "send request to target"
+                  @target.addRequest(request, Thread.current)
+                  Thread.stop
+                else
+                  p "! no target for editing request"
+                end
+              @awaiting_requests -= 1
+              end
+            end
            
            begin
              s_sock, req, resp = sender.sendHTTPRequest(request, :update_sids => true, 
@@ -216,115 +215,115 @@ module Watobo#:nodoc: all
                                                                  :update_contentlength => true, 
                                                                  :www_auth => @www_auth 
                                                                 # :client_certificates => @client_certificates
-                                                                 )
+                                                                 )
             if s_sock.nil? then
-              puts "s_sock is nil! bye, bye, ..."
-              puts request if $DEBUG
-              c_sock.write resp.join unless resp.nil?
+              puts "s_sock is nil! bye, bye, ..."
+              puts request if $DEBUG
+              c_sock.write resp.join unless resp.nil?
               c_sock.close
-              Thread.exit
+              Thread.exit
+            end
+
+            rescue => bang
+              puts bang
+              puts bang.backtrace if $DEBUG
+              c_sock.close
+              Thread.exit
             end
-
-            rescue => bang
-              puts bang
-              puts bang.backtrace if $DEBUG
-              c_sock.close
-              Thread.exit
-            end
-
-            # check if response should be passed throug
+           
+            # check if response should be passed throug
             #Thread.current.exit if isPassThrough?(req, resp, s_sock, c_sock)
             if isPassThrough?(req, resp, s_sock, c_sock)
               Watobo::HTTPSocket.close s_sock
               c_sock.close                
               Thread.exit
-            end
-            #p "no pass-through"
-
-            begin
-            # puts "* got response status: #{resp.status}"
-              missing_credentials = false
+            end
+            #p "no pass-through"
+
+            begin
+            # puts "* got response status: #{resp.status}"
+              missing_credentials = false
               rs = resp.status
-              auth_type = AUTH_TYPE_NONE
+              auth_type = AUTH_TYPE_NONE
               if rs =~ /^(401|407)/ then
-                
-                missing_credentials = true
-               
-                resp.each do |rl|
-                  if rl =~ /^(Proxy|WWW)-Authenticate: Basic/i
-                    auth_type = AUTH_TYPE_BASIC
-                  break
-                  elsif rl =~ /^(Proxy|WWW)-Authenticate: NTLM/i
-                    auth_type = AUTH_TYPE_NTLM
-                  break
-                  end
-                end
-                # when auth type not basic assume it's ntlm -> ntlm credentials must be set in watobo
-                unless auth_type == AUTH_TYPE_NONE
-                  if auth_type == AUTH_TYPE_NTLM
-                    if rs =~ /^401/ then
-                      resp.push "WATOBO: Server requires (NTLM) authorization, please set WWW_Auth Credentials!"
-                      resp.shift
-                      resp.unshift "HTTP/1.1 200 OK\r\n"
-                    else
-                      resp.push "WATOBO: Proxy requires (NTLM) authorization, please set Proxy Credentials!"
-                      resp.shift
-                      resp.unshift "HTTP/1.1 200 OK\r\n"
-                    end
-                  end
-                #else
-
-                #resp.push "WATOBO: Unknown authorization type.<br><br>\r\n" + resp.join("<br>\r\n")
-                #resp.shift
-                #resp.unshift "HTTP/1.1 200 OK\r\n"
-                #resp.fix_content_length
-
-                end
+                
+                missing_credentials = true
+               
+                resp.each do |rl|
+                  if rl =~ /^(Proxy|WWW)-Authenticate: Basic/i
+                    auth_type = AUTH_TYPE_BASIC
+                  break
+                  elsif rl =~ /^(Proxy|WWW)-Authenticate: NTLM/i
+                    auth_type = AUTH_TYPE_NTLM
+                  break
+                  end
+                end
+                # when auth type not basic assume it's ntlm -> ntlm credentials must be set in watobo
+                unless auth_type == AUTH_TYPE_NONE
+                  if auth_type == AUTH_TYPE_NTLM
+                    if rs =~ /^401/ then
+                      resp.push "WATOBO: Server requires (NTLM) authorization, please set WWW_Auth Credentials!"
+                      resp.shift
+                      resp.unshift "HTTP/1.1 200 OK\r\n"
+                    else
+                      resp.push "WATOBO: Proxy requires (NTLM) authorization, please set Proxy Credentials!"
+                      resp.shift
+                      resp.unshift "HTTP/1.1 200 OK\r\n"
+                    end
+                  end
+                #else
+
+                #resp.push "WATOBO: Unknown authorization type.<br><br>\r\n" + resp.join("<br>\r\n")
+                #resp.shift
+                #resp.unshift "HTTP/1.1 200 OK\r\n"
+                #resp.fix_content_length
+
+                end
               end
               
-              unless auth_type == AUTH_TYPE_UNKNOWN or req.method =~ /^head/i
-                # don't try to read body if request method is HEAD
+              unless auth_type == AUTH_TYPE_UNKNOWN or req.method =~ /^head/i
+                # don't try to read body if request method is HEAD
                 sender.readHTTPBody(s_sock, resp, req, :update_sids => true)
-                Watobo::HTTPSocket.close s_sock
-              end
-              
-            rescue => bang
-              puts "!!! could not send request !!!"
-              puts bang
-              puts bang.backtrace if $DEBUG
-            #  puts "* Error sending request"
-            end
-
-            begin
-              # Watobo::Response.create resp
-              resp = Watobo::Response.new resp
-             # puts "* unchunk response ..."
-              resp.unchunk
-              # puts "* unzip response ..."
-              resp.unzip
-
-              if Watobo::Interceptor.rewrite_responses? then
-                 Interceptor::ResponseCarver.shape(resp, flags)
+                Watobo::HTTPSocket.close s_sock
               end
-
-              if @target and Watobo::Interceptor.intercept_responses? then
-                if matchResponseFilter(resp)
-                  #  if resp.content_type =~ /text/ or resp.content_type =~ /application\/javascript/ then
-                  if @target.respond_to? :modifyResponse
-                    @target.modifyResponse(resp, Thread.current)
-                    Thread.stop
-                  else
-                    p "! no target for editing response"
-                  end
-                end
-              end
-
+                            
+            rescue => bang
+              puts "!!! could not send request !!!"
+              puts bang
+              puts bang.backtrace if $DEBUG
+            #  puts "* Error sending request"
+            end
+
+            begin
+              # Watobo::Response.create resp
+              #resp = Watobo::Response.new resp
+             # puts "* unchunk response ..."
+              resp.unchunk!
+              # puts "* unzip response ..."
+              resp.unzip!
+
+              if Watobo::Interceptor.rewrite_responses? then
+                 Interceptor::ResponseCarver.shape(resp, flags)
+              end
+
+              if @target and Watobo::Interceptor.intercept_responses? then
+                if matchResponseFilter(resp)
+                  #  if resp.content_type =~ /text/ or resp.content_type =~ /application\/javascript/ then
+                  if @target.respond_to? :modifyResponse
+                    @target.modifyResponse(resp, Thread.current)
+                    Thread.stop
+                  else
+                    p "! no target for editing response"
+                  end
+                end
+              end
+
              # puts ">> SEND TO CLIENT"
          #    puts ">>C<< - Close: #{request.connection_close?}"
-             #request.headers("Connection"){ |h| puts h }
+             #request.headers("Connection"){ |h| puts h }
              
-             if missing_credentials
-               resp.set_header("Connection", "close")
+             if missing_credentials
+               resp.set_header("Connection", "close")
              elsif request.connection_close? or resp.content_length < 0 or max_loop > 4
               # resp.set_header("Proxy-Connection","close")
                resp.set_header("Connection","close")
@@ -333,32 +332,32 @@ module Watobo#:nodoc: all
                resp.set_header("Keep-Alive", "max=4, timeout=120")
              end
              
-             resp_data = resp.join
+             resp_data = resp.join
              c_sock.write resp_data
             
             # puts "---"
             # puts resp_data.unpack("H*")[0]
             # puts "==="
-             
-            rescue Errno::ECONNRESET
-              print "x"
-              #  puts "!!! ERROR (Reset): reading body"
-              #  puts "* last data seen on socket: #{buf}"
-              #return
-            rescue Errno::ECONNABORTED
-              print "x"
-              #return
-            rescue => bang
-              puts "!!! Error (???) in Client Communication:"
-              puts bang
-              puts bang.class
-              puts bang.backtrace #if $DEBUG
-            #return
-            end
-
-           chat = Chat.new(request.copy, resp.copy, :source => CHAT_SOURCE_INTERCEPT)
-
-           Watobo::Chats.add chat
+             
+            rescue Errno::ECONNRESET
+              print "x"
+              #  puts "!!! ERROR (Reset): reading body"
+              #  puts "* last data seen on socket: #{buf}"
+              #return
+            rescue Errno::ECONNABORTED
+              print "x"
+              #return
+            rescue => bang
+              puts "!!! Error (???) in Client Communication:"
+              puts bang
+              puts bang.class
+              puts bang.backtrace #if $DEBUG
+            #return
+            end
+
+           chat = Chat.new(request.copy, resp.copy, :source => CHAT_SOURCE_INTERCEPT)
+
+           Watobo::Chats.add chat
            
            # TODO: place check into ClientSocket, because headers must be checked and changed too
            # e.g. if c_sock.open?
@@ -369,341 +368,341 @@ module Watobo#:nodoc: all
            print "o"
            max_loop += 1
 
-           end
-          }
-
-        end
-      }
-      end
-
-      def refresh_www_auth
-        @www_auth = Watobo::Conf::Scanner.www_auth
-      end
-
-      def initialize(settings=nil)
-        @event_dispatcher_listeners = Hash.new
-        begin
-
-          puts
-          puts "=== Initialize Interceptor/Proxy ==="
-
-          #Watobo::Interceptor.proxy_mode = INTERCEPT_NONE
-
-          init_instance_vars
-
-          @awaiting_requests = 0
-          @awaiting_responses = 0
-
-          @request_filter_settings = {
-          :site_in_scope => false,
-          :method_filter => '(get|post|put)',
-          :negate_method_filter => false,
-          :negate_url_filter => false,
-          :url_filter => '',
-          :file_type_filter => '(jpg|gif|png|jpeg|bmp)',
-          :negate_file_type_filter => true,
-
-          :parms_filter => '',
-          :negate_parms_filter => false
-          #:regex_location => 0, # TODO: HEADER_LOCATION, BODY_LOCATION, ALL
-
-        }
-
-          @response_filter_settings = {
-          :content_type_filter => '(text|script)',
-          :negate_content_type_filter => false,
-          :response_code_filter => '2\d{2}',
-          :negate_response_code_filter => false,
-          :request_intercepted => false,
-          :content_printable => true,
-          :enable_printable_check => false
-        }
-
-          @preview = Hash.new
-          @preview['ProxyTest'] = ["HTTP/1.0 200 OK\r\nServer: Watobo-Interceptor\r\nConnection: close\r\nContent-Type: text/html; charset=iso-8859-1\r\n\r\n<html><body>PROXY_OK</body></html>"]
-
-          @dh_key = Watobo::CA.dh_key
-
-        rescue => bang
-          puts "!!!could not read certificate files:"
-          puts bang
-          puts bang.backtrace if $DEBUG
-        end
-
-      end
-
-      private
-
-      def init_instance_vars
-        @www_auth = Watobo::Conf::Scanner.www_auth
-        @fake_certs = {}
-        @client_certificates = {}
-        @target = nil
-      #  @sender = Watobo::Session.new(@target)
-
-        @bind_addr = Watobo::Conf::Interceptor.bind_addr
-       # puts "> Server: #{@bind_addr}"
-        @port = Watobo::Conf::Interceptor.port
-       # puts "> Port: #{@port}"
-        @proxy_mode = Watobo::Conf::Interceptor.proxy_mode
-
-        pt = Watobo::Conf::Interceptor.pass_through
-        @contentLength = pt[:content_length]
-       # puts "> PT-ContentLength: #{@contentLength}"
-        @contentTypes = pt[:content_types]
-       # puts "> PT-ContentTypes: #{@contentTypes}"
-      end
-
-      #
-      #
-      # matchContentType(content_type)
-      #
-      #
-      def matchContentType?(content_type)
-        @contentTypes.each do |p|
-          return true if content_type =~ /#{p}/
-        end
-        return false
-      end
-
-      #
-      #
-      # matchRequestFilter(request)
-      #
-      #
-      def matchRequestFilter(request)
-        match_url = true
-        # puts @request_filter_settings.to_yaml
-        url_filter = @request_filter_settings[:url_filter]
-        if url_filter != ''
-          match_url = false
-          if request.url.to_s =~ /#{url_filter}/i
-          match_url = true
-          end
-          if @request_filter_settings[:negate_url_filter] == true
-          match_url = ( match_url == true ) ? false : true
-          end
-        end
-
-        return false if match_url == false
-
-        match_method = true
-        method_filter = @request_filter_settings[:method_filter]
-        if method_filter != ''
-          match_method = false
-          if request.method =~ /#{method_filter}/i
-          match_method = true
-          end
-
-          if @request_filter_settings[:negate_method_filter] == true
-          match_method = ( match_method == true ) ? false : true
-          end
-        end
-
-        return false if match_method == false
-
-        match_ftype = true
-        ftype_filter = @request_filter_settings[:file_type_filter]
-        if ftype_filter != ''
-          match_ftype = false
-          if request.doctype != '' and request.doctype =~ /#{ftype_filter}/i
-          match_ftype = true
-          end
-          if @request_filter_settings[:negate_file_type_filter] == true
-          match_ftype = ( match_ftype == true ) ? false : true
-          end
-        end
-        return false if match_ftype == false
-
-        match_parms = true
-        parms_filter = @request_filter_settings[:parms_filter]
-        if parms_filter != ''
-        #  puts "!PARMS FILTER: #{parms_filter}"
-          match_parms = false
-          puts request.parms
-          match_parms = request.parms.find {|x| x =~ /#{parms_filter}/ }
-          match_parms = ( match_parms.nil? ) ? false : true
-          if @request_filter_settings[:negate_parms_filter] == true
-          match_parms = ( match_parms == true ) ? false : true
-          end
-        end
-        return false if match_parms == false
-
-        true
-      end
-
-      #
-      #
-      # matchResponseFilter(response)
-      #
-      #
-
-      def matchResponseFilter(response)
-        match_ctype = true
-        ct_filter = @response_filter_settings[:content_type_filter]
-        unless ct_filter.empty?
-          match_ctype = false
-          negate = @response_filter_settings[:negate_content_type_filter]
-          if response.content_type =~ /#{ct_filter}/
-          match_ctype = true
-
-          end
-          if negate == true
-          match_ctype = ( match_ctype == true ) ? false : true
-          end
-        end
-        return false if match_ctype == false
-        #puts "* pass ctype filter"
-        match_rcode = true
-        rcode_filter = @response_filter_settings[:response_code_filter]
-        negate = @response_filter_settings[:negate_response_code_filter]
-        unless rcode_filter.empty?
-          match_rcode = false
-          puts rcode_filter
-          puts response.responseCode
-          if response.responseCode =~ /#{rcode_filter}/
-          match_rcode = true
-          end
-          if negate == true
-          match_rcode = ( match_rcode == true ) ? false : true
-          end
-        end
-        return false if match_rcode == false
-        #puts "* pass rcode filter"
-        true
-      end
-
-      #
-      #
-      # pass_through(server, client, maxbytes)
-      #
-      #
-      def pass_through(server, client, maxbytes = 0)
-       
-        bytes_read = 0
-        while 1
-          begin
-          #timeout(2) do
-            buf = nil
-            buf = server.readpartial(2048)
-            #end
-          rescue EOFError
-          #client.write buf if buf
+           end
+          }
+
+        end
+      }
+      end
+
+      def refresh_www_auth
+        @www_auth = Watobo::Conf::Scanner.www_auth
+      end
+
+      def initialize(settings=nil)
+        @event_dispatcher_listeners = Hash.new
+        begin
+
+          puts
+          puts "=== Initialize Interceptor/Proxy ==="
+
+          #Watobo::Interceptor.proxy_mode = INTERCEPT_NONE
+
+          init_instance_vars
+
+          @awaiting_requests = 0
+          @awaiting_responses = 0
+
+          @request_filter_settings = {
+          :site_in_scope => false,
+          :method_filter => '(get|post|put)',
+          :negate_method_filter => false,
+          :negate_url_filter => false,
+          :url_filter => '',
+          :file_type_filter => '(jpg|gif|png|jpeg|bmp)',
+          :negate_file_type_filter => true,
+
+          :parms_filter => '',
+          :negate_parms_filter => false
+          #:regex_location => 0, # TODO: HEADER_LOCATION, BODY_LOCATION, ALL
+
+        }
+
+          @response_filter_settings = {
+          :content_type_filter => '(text|script)',
+          :negate_content_type_filter => false,
+          :response_code_filter => '2\d{2}',
+          :negate_response_code_filter => false,
+          :request_intercepted => false,
+          :content_printable => true,
+          :enable_printable_check => false
+        }
+
+          @preview = Hash.new
+          @preview['ProxyTest'] = ["HTTP/1.0 200 OK\r\nServer: Watobo-Interceptor\r\nConnection: close\r\nContent-Type: text/html; charset=iso-8859-1\r\n\r\n<html><body>PROXY_OK</body></html>"]
+
+          @dh_key = Watobo::CA.dh_key
+
+        rescue => bang
+          puts "!!!could not read certificate files:"
+          puts bang
+          puts bang.backtrace if $DEBUG
+        end
+
+      end
+
+      private
+
+      def init_instance_vars
+        @www_auth = Watobo::Conf::Scanner.www_auth
+        @fake_certs = {}
+        @client_certificates = {}
+        @target = nil
+      #  @sender = Watobo::Session.new(@target)
+
+        @bind_addr = Watobo::Conf::Interceptor.bind_addr
+       # puts "> Server: #{@bind_addr}"
+        @port = Watobo::Conf::Interceptor.port
+       # puts "> Port: #{@port}"
+        @proxy_mode = Watobo::Conf::Interceptor.proxy_mode
+
+        pt = Watobo::Conf::Interceptor.pass_through
+        @contentLength = pt[:content_length]
+       # puts "> PT-ContentLength: #{@contentLength}"
+        @contentTypes = pt[:content_types]
+       # puts "> PT-ContentTypes: #{@contentTypes}"
+      end
+
+      #
+      #
+      # matchContentType(content_type)
+      #
+      #
+      def matchContentType?(content_type)
+        @contentTypes.each do |p|
+          return true if content_type =~ /#{p}/
+        end
+        return false
+      end
+
+      #
+      #
+      # matchRequestFilter(request)
+      #
+      #
+      def matchRequestFilter(request)
+        match_url = true
+        # puts @request_filter_settings.to_yaml
+        url_filter = @request_filter_settings[:url_filter]
+        if url_filter != ''
+          match_url = false
+          if request.url.to_s =~ /#{url_filter}/i
+          match_url = true
+          end
+          if @request_filter_settings[:negate_url_filter] == true
+          match_url = ( match_url == true ) ? false : true
+          end
+        end
+
+        return false if match_url == false
+
+        match_method = true
+        method_filter = @request_filter_settings[:method_filter]
+        if method_filter != ''
+          match_method = false
+          if request.method =~ /#{method_filter}/i
+          match_method = true
+          end
+
+          if @request_filter_settings[:negate_method_filter] == true
+          match_method = ( match_method == true ) ? false : true
+          end
+        end
+
+        return false if match_method == false
+
+        match_ftype = true
+        ftype_filter = @request_filter_settings[:file_type_filter]
+        if ftype_filter != ''
+          match_ftype = false
+          if request.doctype != '' and request.doctype =~ /#{ftype_filter}/i
+          match_ftype = true
+          end
+          if @request_filter_settings[:negate_file_type_filter] == true
+          match_ftype = ( match_ftype == true ) ? false : true
+          end
+        end
+        return false if match_ftype == false
+
+        match_parms = true
+        parms_filter = @request_filter_settings[:parms_filter]
+        if parms_filter != ''
+        #  puts "!PARMS FILTER: #{parms_filter}"
+          match_parms = false
+          puts request.parms
+          match_parms = request.parms.find {|x| x =~ /#{parms_filter}/ }
+          match_parms = ( match_parms.nil? ) ? false : true
+          if @request_filter_settings[:negate_parms_filter] == true
+          match_parms = ( match_parms == true ) ? false : true
+          end
+        end
+        return false if match_parms == false
+
+        true
+      end
+
+      #
+      #
+      # matchResponseFilter(response)
+      #
+      #
+
+      def matchResponseFilter(response)
+        match_ctype = true
+        ct_filter = @response_filter_settings[:content_type_filter]
+        unless ct_filter.empty?
+          match_ctype = false
+          negate = @response_filter_settings[:negate_content_type_filter]
+          if response.content_type =~ /#{ct_filter}/
+          match_ctype = true
+
+          end
+          if negate == true
+          match_ctype = ( match_ctype == true ) ? false : true
+          end
+        end
+        return false if match_ctype == false
+        #puts "* pass ctype filter"
+        match_rcode = true
+        rcode_filter = @response_filter_settings[:response_code_filter]
+        negate = @response_filter_settings[:negate_response_code_filter]
+        unless rcode_filter.empty?
+          match_rcode = false
+          puts rcode_filter
+          puts response.responseCode
+          if response.responseCode =~ /#{rcode_filter}/
+          match_rcode = true
+          end
+          if negate == true
+          match_rcode = ( match_rcode == true ) ? false : true
+          end
+        end
+        return false if match_rcode == false
+        #puts "* pass rcode filter"
+        true
+      end
+
+      #
+      #
+      # pass_through(server, client, maxbytes)
+      #
+      #
+      def pass_through(server, client, maxbytes = 0)
+       
+        bytes_read = 0
+        while 1
+          begin
+          #timeout(2) do
+            buf = nil
+            buf = server.readpartial(2048)
+            #end
+          rescue EOFError
+          #client.write buf if buf
           #print "~]"
          # msg = "\n[pass_through] EOF - "
          # msg += buf.nil? ? "nil" : buf.size
-         #   puts msg
-            return if buf.nil?
-          rescue Errno::ECONNRESET
-          # puts "!!! ERROR (Reset): reading body"
+         #   puts msg
+            return if buf.nil?
+          rescue Errno::ECONNRESET
+          # puts "!!! ERROR (Reset): reading body"
           # puts "* last data seen on socket: #{buf}"
          # msg = "!R - "
          # msg += buf.nil? ? "nil" : buf.size
          # msg << " !\n"
-         #   puts msg
-            
-            return if buf.nil?
-          rescue Timeout::Error
-          #puts "!!! ERROR (Timeout): reading body"
-          #puts "* last data seen on socket:"
-          #client.write buf if buf
-            print "T"
-            return 
-          rescue => bang
-            puts "!!! could not read body !!!"
-            puts bang
-            puts bang.class
-            puts bang.backtrace if $DEBUG
-          # puts "* last data seen on socket:"
-          # print "~]"
-          #client.write buf if buf
-          return
-          end
-
-          begin
-            return if buf.nil?
-           # print "~"
-            client.write buf
-            bytes_read += buf.length
-           # puts "#{server} #{bytes_read} of #{maxbytes}"
-            if maxbytes > 0 and bytes_read >= maxbytes
-              #print "~]"
-               return
-            end
-          rescue Errno::ECONNRESET
-            #print "~x]"
-            #  puts "!!! ERROR (Reset): reading body"
-            #  puts "* last data seen on socket: #{buf}"
-            return
-          rescue Errno::ECONNABORTED
-           # print "~x]"
-            return
-          rescue Errno::EPIPE
-           # print "~x]"
-            return
-          rescue => bang
-            puts "!!! client communication broken !!!"
-            puts bang
-            puts bang.class
-            puts bang.backtrace if $DEBUG
-          return
-          end
-        end
-      end
-
-      def transparent?
-        ( @proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT ) > 0
-      end
-
-     def isPassThrough?(request, response, s_sock, c_sock)
+         #   puts msg
+            
+            return if buf.nil?
+          rescue Timeout::Error
+          #puts "!!! ERROR (Timeout): reading body"
+          #puts "* last data seen on socket:"
+          #client.write buf if buf
+            print "T"
+            return 
+          rescue => bang
+            puts "!!! could not read body !!!"
+            puts bang
+            puts bang.class
+            puts bang.backtrace if $DEBUG
+          # puts "* last data seen on socket:"
+          # print "~]"
+          #client.write buf if buf
+          return
+          end
+
+          begin
+            return if buf.nil?
+           # print "~"
+            client.write buf
+            bytes_read += buf.length
+           # puts "#{server} #{bytes_read} of #{maxbytes}"
+            if maxbytes > 0 and bytes_read >= maxbytes
+              #print "~]"
+               return
+            end
+          rescue Errno::ECONNRESET
+            #print "~x]"
+            #  puts "!!! ERROR (Reset): reading body"
+            #  puts "* last data seen on socket: #{buf}"
+            return
+          rescue Errno::ECONNABORTED
+           # print "~x]"
+            return
+          rescue Errno::EPIPE
+           # print "~x]"
+            return
+          rescue => bang
+            puts "!!! client communication broken !!!"
+            puts bang
+            puts bang.class
+            puts bang.backtrace if $DEBUG
+          return
+          end
+        end
+      end
+
+      def transparent?
+        ( @proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT ) > 0
+      end
+
+     def isPassThrough?(request, response, s_sock, c_sock)
         begin
-         # return false if true
-          reason = nil
-          clen = response.content_length
-          # no pass-through necessary if request method is HEAD
-          return false if request.method =~ /^head/i
-
-          if matchContentType?(response.content_type) then
-            # first forward headers
-            #c_sock.write response.join
-            reason = []
-            reason.push "---> WATOBO: PASS_THROUGH <---"
-            reason.push "Reason: Content-Type = #{response.content_type}"
-          elsif clen > @contentLength
-            # puts "PASS-THROUGH: #{response.content_length}"
-            #c_sock.write response.join
-            reason = []
-            reason.push "---> WATOBO: PASS_THROUGH <---"
-            reason.push "Reason: Content-Length > #{@contentLength} (#{response.content_length})"
-          end
-
+         # return false if true
+          reason = nil
+          clen = response.content_length
+          # no pass-through necessary if request method is HEAD
+          return false if request.method =~ /^head/i
+
+          if matchContentType?(response.content_type) then
+            # first forward headers
+            #c_sock.write response.join
+            reason = []
+            reason.push "---> WATOBO: PASS_THROUGH <---"
+            reason.push "Reason: Content-Type = #{response.content_type}"
+          elsif clen > @contentLength
+            # puts "PASS-THROUGH: #{response.content_length}"
+            #c_sock.write response.join
+            reason = []
+            reason.push "---> WATOBO: PASS_THROUGH <---"
+            reason.push "Reason: Content-Length > #{@contentLength} (#{response.content_length})"
+          end
+
           return false if reason.nil?
          
           response.remove_header("Keep-Alive")
           response.set_header("Connection", "close")
           
           c_sock.write response.join
-          
-          reason.push "* DO MANUAL REQUEST TO GET FULL RESPONSE *"
-          response.push reason.join("\n")
-          chat = Watobo::Chat.new(request, response, :source => CHAT_SOURCE_INTERCEPT)
-          #notify(:new_interception, chat)
-          Watobo::Chats.add chat
-
-          pass_through(s_sock, c_sock, clen)
-          #  puts "* Close Server Socket..."
-          #closeSocket(c_sock)
-          #  puts "* Close Client Socket..."
-          #closeSocket(s_sock)
-          #  puts "... done."
-          return true
-        rescue => bang
-          puts bang
-          puts bang.backtrace if $DEBUG
+          
+          reason.push "* DO MANUAL REQUEST TO GET FULL RESPONSE *"
+          response.push reason.join("\n")
+          chat = Watobo::Chat.new(request, response, :source => CHAT_SOURCE_INTERCEPT)
+          #notify(:new_interception, chat)
+          Watobo::Chats.add chat
+
+          pass_through(s_sock, c_sock, clen)
+          #  puts "* Close Server Socket..."
+          #closeSocket(c_sock)
+          #  puts "* Close Client Socket..."
+          #closeSocket(s_sock)
+          #  puts "... done."
+          return true
+        rescue => bang
+          puts bang
+          puts bang.backtrace if $DEBUG
         end
-        return false
-      end
-
-    end
-  end
-end
+        return false
+      end
+
+    end
+  end
+end