lint_fu 0.5.0 → 0.5.3

data/README.rdoc

@@ -14,7 +14,9 @@ will sometimes report false positives.
 
 = Example
 
-$ rake lint
+$ gem install lint_fu
+$ cd ~/my_project
+$ lint_fu
 
 
-Copyright (c) 2009 Tony Spataro, released under the MIT license
+Copyright (c) 2009-2011 Tony Spataro, released under the MIT license

data/bin/lint_fu

@@ -1,92 +1,8 @@
 #!/usr/bin/env ruby
 
-basedir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+basedir = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(basedir) unless $LOAD_PATH.include?(basedir)
 
 require 'lint_fu'
 
-def timed(activity)
-  print activity, '...'
-  STDOUT.flush
-  t0 = Time.now.to_i
-  yield
-  t1 = Time.now.to_i
-  dt = t1-t0
-  if dt > 0
-    puts "done (#{t1-t0} sec)"
-    STDOUT.flush
-  else
-    puts "done"
-    STDOUT.flush
-  end
-rescue Exception => e
-  puts 'error!' #ensure we print a newline
-  raise e
-end
-
-app_root = File.expand_path('.')
-
-#Only define the Rake tasks if the plugin loaded successfully
-@scm    = LintFu::SourceControlProvider.for_directory(app_root)
-
-#Build a model of the application we are scanning.
-timed("Build a model of the application") do
-  builder = LintFu::Rails::ModelApplicationBuilder.new(app_root)
-  @application = builder.model_elements[0]
-  raise LintFu::ProviderError.new("Unable to identify the source control provider for #{app_root}") unless @scm
-end
-
-#Using the model we built, scan the controllers for security bugs.
-timed("Scan the application") do
-  builder = LintFu::Rails::ScanBuilder.new(app_root)
-  @scan = builder.scan(@application)
-end
-
-@genuine_issues = @scan.issues.select { |i| !@scan.blessed?(i) }
-if @genuine_issues.empty?
-  puts "Clean scan: no issues found. Skipping report."
-  exit(0)
-end
-
-#CruiseControl.rb integration: write our report to the CC build artifacts folder
-output_dir = ENV['CC_BUILD_ARTIFACTS'] || app_root
-mkdir_p output_dir unless File.directory?(output_dir)
-
-flavor   = ENV['FORMAT'] || 'html'
-typename = "#{flavor}_report".camelize
-
-#Use a filename (or STDOUT) for our report that corresponds to its format
-case flavor
-  when 'html'
-    output_name = File.join(output_dir, 'lint.html')
-    output      = File.open(output_name, 'w')
-  when 'text'
-    output = STDOUT
-  else
-    puts "Unrecognized output format #{flavor} (undefined type #{typename})"
-    exit -1
-end
-
-klass    = LintFu.const_get(typename.to_sym)
-
-timed("Generate report") do
-  klass.new(@scan, @scm, @genuine_issues).generate(output)
-  output.close
-end
-
-#Support automation jobs that need to distinguish between failure due to
-#broken environment and failure to due issues that were genuinely found by
-#the lint task.
-if ENV['STATUS_IF_ISSUES']
-  if(@genuine_issues.size > 0)
-    retval = ENV['STATUS_IF_ISSUES'].to_i
-  else
-    retval = 0
-  end
-else
-  retval = [@genuine_issues.size, 255].min
-end
-
-system("open #{output_name}") if (output != STDOUT && STDOUT.tty?)
-
-exit( retval )
+exit( LintFu::CLI.run )

data/lib/lint_fu/blessing.rb

@@ -0,0 +1,40 @@
+module LintFu
+  class Blessing
+    VERBOSE_BLESSING_COMMENT = /#\s*(lint|security)\s*[-:]\s*not\s*a?n?\s*([a-z0-9 ]*?) ?(as|because|;)\s*(.*)\s*/i
+    BLESSING_COMMENT         = /#\s*(lint|security)\s*[-:]\s*not\s*a?n?\s*([a-z0-9 ]*?)\s*/i
+
+    attr_accessor :issue_class, :sexp, :reason
+
+    def initialize(issue_class, sexp=nil, reason=nil)
+      @issue_class = issue_class
+      @reason = reason
+    end
+
+    def applies_to?(klass)
+      klass = klass.class unless klass.is_a?(Class)
+
+      while klass
+        return true if klass.name.index(self.issue_class)
+        klass = klass.superclass
+      end
+
+      return false
+    end
+
+    def self.parse(comments, sexp=nil)
+      comments = [comments] unless comments.kind_of?(Array)
+      blessings = []
+
+      comments.each do |line|
+        match = VERBOSE_BLESSING_COMMENT.match(line)
+        match = BLESSING_COMMENT.match(line) unless match
+        next unless match
+        issue_class = match[2].downcase.split(/\s+/).join('_').camelize
+        reason      = match[3]
+        blessings << Blessing.new(issue_class, sexp, reason)
+      end
+
+      return blessings
+    end
+  end
+end

data/lib/lint_fu/checker.rb

@@ -1,11 +1,57 @@
 module LintFu
   class Checker
+    SUPPRESSION_COMMENT = /#\s*lint\s*[-:]\s*(suppress|ignore) (.*)/i
+
     attr_reader :scan, :context, :file
 
     def initialize(scan, context, file=nil)
-      @scan           = scan
-      @context = context
-      @file           = file
+      @scan       = scan
+      @context    = context
+      @file       = file
+      @suppressed = []
+    end
+
+    # This class responds to any method beginning with "observe_" in order to provide
+    # a default callback for every kind of Sexp it might encounter.
+    def method_missing(meth, *args)
+      return true if meth.to_s =~ /^observe_/
+      super(meth, *args)
+    end
+
+    def observe_class_begin(sexp)
+      enter_suppression_scope(sexp)
+    end
+
+    def observe_class_end(sexp)
+      leave_suppression_scope(sexp)
+    end
+
+    protected
+
+    def suppressed?(klass)
+      basename = klass.name.split('::').last
+      @suppressed.any? { |s| s.include?(basename) }
+    end
+
+    private
+
+    def enter_suppression_scope(sexp)
+      set = Set.new
+
+      if (comments = sexp.preceding_comments)
+        comments.each do |line|
+          match = SUPPRESSION_COMMENT.match(line)
+          next unless match
+          list = match[2].split(/\s*(,|and)\s*/)
+          list.each { |s| set << s.gsub(/\s+/, '_').camelize }
+        end
+      end
+
+      @suppressed.push set
+    end
+
+    def leave_suppression_scope(sexp)
+      @suppressed.pop      
     end
   end
 end

data/lib/lint_fu/cli/command.rb

@@ -0,0 +1,48 @@
+module LintFu::CLI
+  # Base class for CLI commands
+  class Command
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      raise NotImplementedError
+    end
+
+    protected
+
+    def app_root
+      File.expand_path('.')      
+    end
+
+    def scm
+      @scm ||= LintFu::SourceControlProvider.for_directory(app_root)
+      raise LintFu::ProviderError.new("Unable to identify the source control provider for #{app_root}") unless @scm
+      @scm
+    end
+
+    def say(*args)
+      LintFu::CLI.say(*args)
+    end
+
+    def timed(activity)
+      print activity, '...'
+      STDOUT.flush
+      t0 = Time.now.to_i
+      yield
+      t1 = Time.now.to_i
+      dt = t1-t0
+      if dt > 0
+        puts "done (#{t1-t0} sec)"
+        STDOUT.flush
+      else
+        puts "done"
+        STDOUT.flush
+      end
+    rescue Exception => e
+      print 'error!' unless e.is_a?(SignalException)
+      puts
+      raise e
+    end
+  end
+end

data/lib/lint_fu/cli/prune.rb

@@ -0,0 +1,78 @@
+module LintFu::CLI
+  class Prune < Command
+    RUBY_FILE_EXT = /\.rb[a-z]?/
+
+    def run
+      #Build a model of the application we are scanning.
+      timed("Build a model of the application") do
+        builder = LintFu::Plugins::Rails.context_builder_for(self.app_root)
+        builder.build
+        @application = builder.eide.first
+      end
+
+      #Using the model we built, scan the controllers for security bugs.
+      timed("Scan the application") do
+        @scan = LintFu::Scan.new(self.app_root)
+        #TODO generalize/abstract this, same as we did for context builders
+        builder = LintFu::Plugins::Rails.issue_builder_for(self.app_root)
+        builder.build(@application, @scan)
+      end
+
+      blessings       = []
+      blessing_ranges = nil
+      useless         = []
+
+      timed("Find all annotations") do
+        recurse(self.app_root, blessings)
+
+        blessing_ranges = blessings.map do |triple|
+          file, line, comment = triple[0], triple[1], triple[2]
+          next LintFu::FileRange.new(file, line, line, comment)
+        end
+      end
+
+      timed("Cross-check annotations against issues") do
+        issue_ranges = @scan.issues.map do |issue|
+          issue.sexp.preceding_comment_range
+        end
+        issue_ranges.compact!
+
+        blessing_ranges.each do |b|
+          useless << b unless issue_ranges.any? { |r| r.include?(b) }
+        end
+      end
+
+      say "Found #{useless.size} extraneous annotations (out of #{blessings.size} total)."
+
+      useless.each do |range|
+        filename = File.relative_path(self.app_root, range.filename)
+        say "#{filename}:#{range.line}"
+      end
+
+      say "WARNING: I did not actually prune these; you need to do it yourself!!"
+
+      return 0
+    end
+
+    protected
+
+    def recurse(dir, results)
+      dir = File.expand_path(dir)
+      Dir.glob(File.join(dir, '*')).each do |dirent|
+        if File.directory?(dirent)
+          recurse(dirent, results)
+        elsif dirent =~ RUBY_FILE_EXT
+          find_blessings(dirent, File.readlines(dirent), results)
+        end
+      end
+    end
+
+    def find_blessings(file, lines, results)
+      lines.each_with_index do |line, i|
+        blessing = LintFu::Blessing.parse(line)
+        next if blessing.empty?
+        results << [file, i+1, line] 
+      end
+    end
+  end
+end

data/lib/lint_fu/cli/scan.rb

@@ -0,0 +1,78 @@
+module LintFu::CLI
+  class Scan < Command
+    def run
+      #Build a model of the application we are scanning.
+      timed("Build a model of the application") do
+        builder = LintFu::Plugins::Rails.context_builder_for(self.app_root)
+
+        unless builder
+          say "Cannot determine context builder for #{File.basename(self.app_root)}."
+          say "Either this application uses a framework that is unsupported by LintFu,"
+          say "or a bug is preventing us from recognizing the application framework."
+          say "Sorry!"
+          exit(-1)
+        end
+
+        builder.build
+        @application = builder.eide.first
+      end
+
+      #Using the model we built, scan the controllers for security bugs.
+      timed("Scan the application") do
+        @scan = LintFu::Scan.new(self.app_root)
+        #TODO generalize/abstract this, same as we did for context builders
+        builder = LintFu::Plugins::Rails.issue_builder_for(self.app_root)
+        builder.build(@application, @scan)
+      end
+
+      @genuine_issues = @scan.issues.select { |i| !@scan.blessed?(i) }
+      if @genuine_issues.empty?
+        say "Clean scan: no issues found. Skipping report."
+        exit(0)
+      end
+
+      #CruiseControl.rb integration: write our report to the CC build artifacts folder
+      output_dir = ENV['CC_BUILD_ARTIFACTS'] || self.app_root
+      mkdir_p output_dir unless File.directory?(output_dir)
+
+      flavor   = ENV['FORMAT'] || 'html'
+      typename = "#{flavor}_report".camelize
+
+      #Use a filename (or STDOUT) for our report that corresponds to its format
+      case flavor
+        when 'html'
+          output_name = File.join(output_dir, 'lint.html')
+          output      = File.open(output_name, 'w')
+        when 'text'
+          output = STDOUT
+        else
+          say "Unrecognized output format #{flavor} (undefined type #{typename})"
+          exit -1
+      end
+
+      klass    = LintFu.const_get(typename.to_sym)
+
+      timed("Generate report") do
+        klass.new(@scan, self.scm, @genuine_issues).generate(output)
+        output.close
+      end
+
+      #Support automation jobs that need to distinguish between failure due to
+      #broken environment and failure to due issues that were genuinely found by
+      #the lint task.
+      if ENV['STATUS_IF_ISSUES']
+        if(@genuine_issues.size > 0)
+          retval = ENV['STATUS_IF_ISSUES'].to_i
+        else
+          retval = 0
+        end
+      else
+        retval = [@genuine_issues.size, 255].min
+      end
+
+      system("open #{output_name}") if (output != STDOUT && STDOUT.tty?)
+
+      return retval
+    end
+  end
+end

data/lib/lint_fu/cli.rb

@@ -0,0 +1,52 @@
+module LintFu
+  module CLI
+    BANNER = <<EOS
+Lint-fu finds security defects in Ruby code.
+
+Usage:
+       lint_fu [options]
+where [options] are:
+EOS
+
+    def self.run
+      commands = []
+      ObjectSpace.each_object(Class) do |c|
+        commands << c.to_s.underscore if c.superclass == Command
+      end
+
+      opts = Trollop::options do
+        version "Lint-Fu #{Gem.loaded_specs['lint_fu'].version} (c) 2011 Tony Spataro"
+        banner BANNER
+        stop_on commands
+      end
+
+      cmd_name = ARGV.shift || 'scan'
+      sym = cmd_name.camelize.to_sym
+
+      begin
+        klass = const_get(sym)
+        raise NameError unless klass.superclass == Command
+      rescue NameError => e
+        Trollop::die "Unknown command #{cmd_name}"
+      end
+
+      cmd = klass.new(opts)
+      return cmd.run
+    rescue Interrupt => e
+      say "Interrupt; exiting without completing task."
+      exit(-1)
+    end
+    def self.say(*args)
+      puts(*args)
+    end
+  end
+end
+
+# The base class (Command) should be loaded first
+require 'lint_fu/cli/command'
+
+# Everyone else can be loaded automagically
+cli_dir = File.expand_path('../cli', __FILE__)
+Dir[File.join(cli_dir, '*.rb')].each do |file|
+  require file
+end