fuzzr 0.9.9

data/lib/fuzz/log.rb

@@ -0,0 +1,97 @@
+#--------------------------------------------------------------------
+# @file    log.rb
+# @author  Martin Corino
+#
+# @brief   Fuzz logging support
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+require 'fuzz/console'
+
+module Fuzz
+
+  #
+  # Default Reporting/Logging
+  #
+  class Reporter
+    def initialize(output = Fuzz::Console)
+      @output = output
+      klass = class << self; self; end
+      klass.__send__(:include, @output.colorizer_include)
+    end
+
+    attr_reader :output
+
+    def log_error(msg)
+      output.error_println 'Fuzz - ', red(bold 'ERROR'), ' : ', msg
+    end
+
+    def log_warning(msg)
+      output.error_println 'Fuzz - ', yellow(bold 'WARNING'), ' : ', msg
+    end
+
+    def log_info(msg)
+      output.println 'Fuzz - ', msg
+    end
+
+    def show_error(msg)
+      log_error(msg)
+    end
+
+    def show_warning(msg)
+      log_error(msg)
+    end
+
+    def show_msg(msg)
+      log(msg)
+    end
+  end
+
+  module LogMethods
+    def log_fatal(msg, rc=1)
+      Fuzz.reporter.log_error(msg)
+      exit rc
+    end
+
+    def log_error(msg)
+      Fuzz.reporter.log_error(msg)
+    end
+
+    def log_warning(msg)
+      Fuzz.reporter.log_warning(msg)
+    end
+
+    def log_info(msg)
+      Fuzz.reporter.log_info(msg)
+    end
+
+    def log(lvl, msg)
+      Fuzz.reporter.log_info(msg) if lvl <= verbosity
+    end
+
+    def show_error(msg)
+      Fuzz.reporter.show_error(msg)
+    end
+
+    def show_warning(msg)
+      Fuzz.reporter.show_warning(msg)
+    end
+
+    def show_msg(msg)
+      Fuzz.reporter.show_msg(msg)
+    end
+
+    def verbosity
+      Fuzz.verbosity
+    end
+
+    def verbose?
+      verbosity > 1
+    end
+
+    def silent?
+      verbosity < 1
+    end
+  end
+
+end # Fuzz

data/lib/fuzz/options.rb

@@ -0,0 +1,208 @@
+#--------------------------------------------------------------------
+# @file    options.rb
+# @author  Martin Corino
+#
+# @brief   Options module for fuzz
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+
+require 'ostruct'
+require 'yaml'
+require 'fuzz/log'
+
+module Fuzz
+
+  FUZZRC = '.fuzzrc'
+  FUZZRC_GLOBAL = File.expand_path(File.join(ENV['HOME'] || ENV['HOMEPATH'] || '~', FUZZRC))
+
+  OPTIONS = OpenStruct.new
+
+  class << OPTIONS
+
+    include Fuzz::LogMethods
+
+    def options
+      self
+    end
+
+    class Config < OpenStruct
+
+      include Fuzz::LogMethods
+
+      def initialize(hash=nil)
+        super
+        @table = _merge(_defaults, @table)
+      end
+
+      def options
+        Fuzz.options
+      end
+
+      def merge(from)
+        _merge(@table, from)
+        self
+      end
+
+      def load(rcpath)
+        log(3, "Loading #{FUZZRC} from #{rcpath}")
+        _cfg = YAML.load(IO.read(rcpath))
+        log(4, "Read from #{rcpath}: [#{_cfg}]")
+        # handle automatic env var expansion in fzzr_paths
+        _cfg[:fzzr_paths] = (_cfg[:fzzr_paths] || []).collect do |p|
+          log(5, "Examining fzzr_path [#{p}]")
+          # for paths coming from rc files environment vars are immediately expanded and
+          p.gsub!(/\$([^\s\/]+)/) { |m| ENV[$1] }
+          log(6, "Expanded fzzr_path [#{p}]")
+          # resulting relative paths converted to absolute paths
+          if File.directory?(p)   # relative to working dir?
+            p = File.expand_path(p)
+          else                    # relative to rc location?
+            _fp = File.expand_path(File.join(File.dirname(rcpath), p))
+            log(4, "Ignoring invalid fuzzer search path #{p} configured in #{rcpath}") unless File.directory?(_fp)
+            p = _fp
+          end
+          log(4, "Adding fuzzer search path: #{p}")
+          p
+        end
+        merge(_cfg)
+      end
+
+      def save(rcpath)
+        File.open(rcpath, 'w') {|f| f << YAML.dump(@table) }
+      end
+
+      protected
+
+      def _defaults
+        {
+          :brix_paths => []
+        }
+      end
+
+      def _merge(to, from)
+        from.each_pair do |(k,v)|
+          k = k.to_sym
+          if to.has_key?(k)
+            case to[k]
+            when Array
+              to[k].concat v
+            when Hash
+              to[k].merge!(v)
+            when OpenStruct
+              _merge(to[k].__send__(:table), v)
+            else
+              to[k] = v
+            end
+          else
+            to[k] = v
+          end
+        end
+        to
+      end
+
+    end
+
+    protected
+
+    def _defaults
+      {
+        :verbose => (ENV['FUZZ_VERBOSE'] || 1).to_i,
+        :recurse => true,
+        :apply_fix => false,
+        :config => Config.new({
+          :follow_symlink => true,
+          :exts => [],
+          :filenames => [],
+          :excludes => [],
+          :add_files => false,
+          :fzzr_paths => [],
+          :fzzr_opts => {},
+          :fzzr_excludes => []
+        })
+      }
+    end
+
+    def _rc_paths
+      @rc_paths ||= []
+    end
+    def _loaded_rc_paths
+      @loaded_rc_paths ||= []
+    end
+
+    def _add_rcpath(path)
+      if _loaded_rc_paths.include?(File.expand_path(path))
+        log(3, "ignoring already loaded rc : #{path}")
+      else
+        log(3, "adding rc path : #{path}")
+        _rc_paths << path
+      end
+      _rc_paths
+    end
+
+    public
+
+    def reset
+      @table.clear
+      @table.merge!(_defaults)
+      _rc_paths.clear
+      _rc_paths << FUZZRC_GLOBAL
+      _loaded_rc_paths.clear
+      (ENV['FUZZRC'] || '').split(/:|;/).each do |p|
+        _add_rcpath(p)
+      end
+    end
+
+    def load_config
+      # first collect config from known (standard and configured) locations
+      _rc_paths.collect {|path| File.expand_path(path) }.each do |rcp|
+        log(3, "Testing rc path #{rcp}")
+        if File.readable?(rcp) && !_loaded_rc_paths.include?(rcp)
+          _cfg = Config.new.load(rcp)
+          self[:config].merge(_cfg)
+          _loaded_rc_paths << rcp
+        else
+          log(3, "Ignoring #{File.readable?(rcp) ? 'already loaded' : 'inaccessible'} rc path #{rcp}")
+        end
+      end
+      # now scan working path for any rc files unless specified otherwise
+      unless self[:no_rc_scan]
+        _cwd = File.expand_path(Dir.getwd)
+        log(3, "scanning working path #{_cwd} for rc files")
+        # first collect any rc files found
+        _rcpaths = []
+        begin
+          _rcp = File.join(_cwd, FUZZRC)
+          if File.readable?(_rcp) && !_loaded_rc_paths.include?(_rcp)
+            _rcpaths << _rcp
+          else
+            log(3, "Ignoring #{File.readable?(_rcp) ? 'already loaded' : 'inaccessible'} rc path #{_rcp}")
+          end
+          break if /\A(.:(\\|\/)|\.|\/)\Z/ =~ _cwd
+          _cwd = File.dirname(_cwd)
+        end while true
+        # now load them in reverse order
+        _rcpaths.reverse.each do |_rcp|
+          _cfg = Config.new.load(_rcp)
+          self[:config].merge(_cfg)
+          _loaded_rc_paths << _rcp
+        end
+      end
+      # lastly merge config specified by user on commandline
+      self[:config].merge(user_config)
+    end
+
+    def add_config(rcpath)
+      log_fatal("inaccessible rc path specified : #{rcpath}") unless File.readable?(rcpath)
+      _add_rcpath(rcpath)
+    end
+
+    def user_config
+      @user_config ||= Config.new
+    end
+
+  end # OPTIONS class
+
+  OPTIONS.reset # initialize
+
+end # Fuzz

data/lib/fuzz/screen.rb

@@ -0,0 +1,85 @@
+#--------------------------------------------------------------------
+# @file    screen.rb
+# @author  Martin Corino
+#
+# @brief   Fuzz screen wrapper
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+require 'fuzz/system'
+
+module Fuzz
+
+  class Screen
+
+    class Color
+      def initialize(code)
+        @code = code
+      end
+      attr_reader :code
+      def to_s
+        ''
+      end
+      alias :to_str :to_s
+    end
+
+    COLORS = {
+      black:    [Color.new("\e[30m"), Color.new("\e[m")],
+      red:      [Color.new("\e[31m"), Color.new("\e[m")],
+      green:    [Color.new("\e[32m"), Color.new("\e[m")],
+      yellow:   [Color.new("\e[33m"), Color.new("\e[m")],
+      blue:     [Color.new("\e[34m"), Color.new("\e[m")],
+      magenta:  [Color.new("\e[34m"), Color.new("\e[m")],
+      bold:     [Color.new("\e[1m"),  Color.new("\e[m")],
+      reverse:  [Color.new("\e[7m"),  Color.new("\e[m")],
+      underline:[Color.new("\e[4m"),  Color.new("\e[m")]
+    }
+
+    module ColorizeMethods
+      def self.included(mod)
+        Screen::COLORS.keys.each do |color|
+          mod.module_eval <<-EOT, __FILE__, __LINE__+1
+            def #{color}(s)
+              [Fuzz::Screen::COLORS[:#{color}].first, s, Fuzz::Screen::COLORS[:#{color}].last]
+            end
+          EOT
+        end
+      end
+    end
+
+    def initialize(output = STDOUT, input = STDIN, errout = STDERR)
+      @output = output
+      @input = input
+      @errout = errout
+      @colorize = output.tty? && Fuzz::Sys.has_ansi?
+    end
+
+    attr_reader :input, :output, :errout
+
+    def colorize?
+      @colorize
+    end
+
+    def output_cols
+      80
+    end
+
+    def print(*args)
+      output.print args.flatten.collect {|a| (colorize? && Color === a) ? a.code : a }.join
+    end
+
+    def println(*args)
+      output.puts args.flatten.collect {|a| (colorize? && Color === a) ? a.code : a }.join
+    end
+
+    def error_print(*args)
+      errout.print args.flatten.collect {|a| (colorize? && Color === a) ? a.code : a }.join
+    end
+
+    def error_println(*args)
+      errout.puts args.flatten.collect {|a| (colorize? && Color === a) ? a.code : a }.join
+    end
+
+  end # Screen
+
+end # Fuzz

data/lib/fuzz/system.rb

@@ -0,0 +1,57 @@
+#--------------------------------------------------------------------
+# @file    system.rb
+# @author  Martin Corino
+#
+# @brief   System support for Fuzz
+#
+# @copyright Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+require 'fileutils'
+
+module Fuzz
+
+  module Sys
+
+    module SysMethods
+
+      def mswin?
+        /mingw/ =~ RUBY_PLATFORM ? true : false
+      end
+
+      def has_ansi?
+        # only ANSI escape code support on Windows
+        # if ANSICON (https://github.com/adoxa/ansicon) installed
+        (!mswin?) || ENV['ANSICON']
+      end
+
+      def in_dir(dir, &block)
+        STDERR.puts "cd #{dir}" if Fuzz.verbose?
+        rc = if Fuzz.dryrun?
+          yield if block_given?
+        else
+          Dir.chdir(dir, &block)
+        end
+        STDERR.puts "cd -" if Fuzz.verbose?
+        rc
+      end
+      def mv(src, tgt)
+        FileUtils.move(src, tgt, :verbose => Fuzz.verbose?)
+      end
+
+      def cp(src, tgt)
+        FileUtils.copy(src, tgt, :verbose => Fuzz.verbose?)
+      end
+
+      def chmod(mode, path)
+        FileUtils.chmod(mode, path, :verbose => Fuzz.verbose?)
+      end
+
+    end # SysMethods
+
+    class << self
+      include Sys::SysMethods
+    end
+
+  end # Sys
+
+end # Fuzz

data/lib/fuzz/version.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# -------------------------------------------------------------------
+# version.rb - TAOX11 fuzz checker
+#
+# Author: Martin Corino
+#
+# Copyright (c) Remedy IT Expertise BV
+# -------------------------------------------------------------------
+
+module Fuzz
+
+  FUZZ_VERSION_MAJOR = 0
+  FUZZ_VERSION_MINOR = 9
+  FUZZ_VERSION_RELEASE = 9
+  FUZZ_VERSION = "#{FUZZ_VERSION_MAJOR}.#{FUZZ_VERSION_MINOR}.#{FUZZ_VERSION_RELEASE}"
+  FUZZ_COPYRIGHT = "Copyright (c) 2012-#{Time.now.year} Remedy IT Expertise BV, The Netherlands".freeze
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: fuzzr
+version: !ruby/object:Gem::Version
+  version: 0.9.9
+platform: ruby
+authors:
+- Martin Corino
+- Johnny Willemsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-11 00:00:00.000000000 Z
+dependencies: []
+description: Fuzzer
+email: mcorino@remedy.nl
+executables:
+- fuzz
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- LICENSE
+- README.rdoc
+- bin/fuzz
+- fuzzers/check_ace_error.excludes
+- fuzzers/check_ace_error.rb
+- fuzzers/check_catch_ex_as_const.rb
+- fuzzers/check_cout_cerr.excludes
+- fuzzers/check_cout_cerr.rb
+- fuzzers/check_executablebit.rb
+- fuzzers/check_exit_keyword.excludes
+- fuzzers/check_exit_keyword.rb
+- fuzzers/check_fileheader.excludes
+- fuzzers/check_fileheader.rb
+- fuzzers/check_filename.excludes
+- fuzzers/check_filename.rb
+- fuzzers/check_id_tag.rb
+- fuzzers/check_new_delete.excludes
+- fuzzers/check_new_delete.rb
+- fuzzers/check_printf_keyword.excludes
+- fuzzers/check_printf_keyword.rb
+- fuzzers/check_taox11_namespace.excludes
+- fuzzers/check_taox11_namespace.rb
+- lib/fuzz/console.rb
+- lib/fuzz/fuzz.rb
+- lib/fuzz/fuzzers/check_whitespace.rb
+- lib/fuzz/fzzr.rb
+- lib/fuzz/log.rb
+- lib/fuzz/options.rb
+- lib/fuzz/screen.rb
+- lib/fuzz/system.rb
+- lib/fuzz/version.rb
+homepage: https://github.com/RemedyIT/fuzzr
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/RemedyIT/fuzzr/issues
+  source_code_uri: https://github.com/RemedyIT/fuzzr
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: fuzzr
+test_files: []