inspec-core 2.1.67

data/lib/utils/file_reader.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# author: ERAMOTO Masaya
+
+module FileReader
+  def read_file_content(path, allow_empty = false)
+    # these are currently ResourceSkipped to maintain consistency with the resource
+    # pre-refactor (which used skip_resource). These should likely be changed to
+    # ResourceFailed during a major version bump.
+    file = inspec.file(path)
+    if !file.file?
+      raise Inspec::Exceptions::ResourceSkipped, "Can't find file: #{path}"
+    end
+
+    raw_content = file.content
+    if raw_content.nil?
+      raise Inspec::Exceptions::ResourceSkipped, "Can't read file: #{path}"
+    end
+
+    if !allow_empty && raw_content.empty?
+      raise Inspec::Exceptions::ResourceSkipped, "File is empty: #{path}"
+    end
+
+    raw_content
+  end
+end

data/lib/utils/filter.rb

@@ -0,0 +1,273 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Stephan Renatus
+# author: Christoph Hartmann
+
+module FilterTable
+  module Show; end
+
+  class ExceptionCatcher
+    def initialize(original_resource, original_exception)
+      @original_resource = original_resource
+      @original_exception = original_exception
+    end
+
+    # This method is called via the runner and signals RSpec to output a block
+    # showing why the resource was skipped. This prevents the resource from
+    # being added to the test collection and being evaluated.
+    def resource_skipped?
+      @original_exception.is_a?(Inspec::Exceptions::ResourceSkipped)
+    end
+
+    # This method is called via the runner and signals RSpec to output a block
+    # showing why the resource failed. This prevents the resource from
+    # being added to the test collection and being evaluated.
+    def resource_failed?
+      @original_exception.is_a?(Inspec::Exceptions::ResourceFailed)
+    end
+
+    def resource_exception_message
+      @original_exception.message
+    end
+
+    # Capture message chains and return `ExceptionCatcher` objects
+    def method_missing(*)
+      self
+    end
+
+    # RSpec will check the object returned to see if it responds to a method
+    # before calling it. We need to fake it out and tell it that it does. This
+    # allows it to skip past that check and fall through to #method_missing
+    def respond_to?(_method)
+      true
+    end
+
+    def to_s
+      @original_resource.to_s
+    end
+    alias inspect to_s
+  end
+
+  class Trace
+    def initialize
+      @chain = []
+    end
+
+    %w{== != >= > < <= =~ !~}.each do |m|
+      define_method m.to_sym do |*args|
+        res = Trace.new
+        @chain.push([[m.to_sym] + args, res])
+        res
+      end
+    end
+
+    def method_missing(*args)
+      res = Trace.new
+      @chain.push([args, res])
+      res
+    end
+
+    def self.to_ruby(trace)
+      chain = trace.instance_variable_get(:@chain)
+      return '' if chain.empty?
+      ' ' + chain.map do |el|
+        m = el[0][0]
+        args = el[0].drop(1)
+        nxt = to_ruby(el[1])
+        next m.to_s + nxt if args.empty?
+        next m.to_s + ' ' + args[0].inspect + nxt if args.length == 1
+        m.to_s + '(' + args.map(&:inspect).join(', ') + ')' + nxt
+      end.join(' ')
+    end
+  end
+
+  class Table
+    attr_reader :params, :resource
+    def initialize(resource, params, filters)
+      @resource = resource
+      @params = params
+      @params = [] if @params.nil?
+      @filters = filters
+    end
+
+    def where(conditions = {}, &block)
+      return self if !conditions.is_a?(Hash)
+      return self if conditions.empty? && !block_given?
+
+      filters = ''
+      table = @params
+      conditions.each do |field, condition|
+        filters += " #{field} == #{condition.inspect}"
+        table = filter_lines(table, field, condition)
+      end
+
+      if block_given?
+        table = table.find_all { |e| new_entry(e, '').instance_eval(&block) }
+        src = Trace.new
+        src.instance_eval(&block)
+        filters += Trace.to_ruby(src)
+      end
+
+      self.class.new(@resource, table, @filters + filters)
+    end
+
+    def new_entry(*_)
+      raise "#{self.class} must not be used on its own. It must be inherited "\
+           'and the #new_entry method must be implemented. This is an internal '\
+           'error and should not happen.'
+    end
+
+    def entries
+      f = @resource.to_s + @filters.to_s + ' one entry'
+      @params.map do |line|
+        new_entry(line, f)
+      end
+    end
+
+    def get_field(field)
+      @params.map do |line|
+        line[field]
+      end
+    end
+
+    def to_s
+      @resource.to_s + @filters
+    end
+
+    alias inspect to_s
+
+    private
+
+    def matches_float(x, y)
+      return false if x.nil?
+      return false if !x.is_a?(Float) && (x =~ /\A[-+]?(\d+\.?\d*|\.\d+)\z/).nil?
+      x.to_f == y
+    end
+
+    def matches_int(x, y)
+      return false if x.nil?
+      return false if !x.is_a?(Integer) && (x =~ /\A[-+]?\d+\z/).nil?
+      x.to_i == y
+    end
+
+    def matches_regex(x, y)
+      return x == y if x.is_a?(Regexp)
+      !x.to_s.match(y).nil?
+    end
+
+    def matches(x, y)
+      x === y # rubocop:disable Style/CaseEquality
+    end
+
+    def filter_lines(table, field, condition)
+      m = case condition
+          when Float   then method(:matches_float)
+          when Integer then method(:matches_int)
+          when Regexp  then method(:matches_regex)
+          else              method(:matches)
+          end
+
+      table.find_all do |line|
+        next unless line.key?(field)
+        m.call(line[field], condition)
+      end
+    end
+  end
+
+  class Factory
+    Connector = Struct.new(:field_name, :block, :opts)
+
+    def initialize
+      @accessors = []
+      @connectors = {}
+      @resource = nil
+    end
+
+    def connect(resource, table_accessor) # rubocop:disable Metrics/AbcSize
+      # create the table structure
+      connectors = @connectors
+      struct_fields = connectors.values.map(&:field_name)
+      connector_blocks = connectors.map do |method, c|
+        [method.to_sym, create_connector(c)]
+      end
+
+      # the struct to hold single items from the #entries method
+      entry_struct = Struct.new(*struct_fields.map(&:to_sym)) do
+        attr_accessor :__filter
+        def to_s
+          @__filter || super
+        end
+      end unless struct_fields.empty?
+
+      # the main filter table
+      table = Class.new(Table) {
+        connector_blocks.each do |x|
+          define_method x[0], &x[1]
+        end
+
+        define_method :new_entry do |hashmap, filter = ''|
+          return entry_struct.new if hashmap.nil?
+          res = entry_struct.new(*struct_fields.map { |x| hashmap[x] })
+          res.__filter = filter
+          res
+        end
+      }
+
+      # Define all access methods with the parent resource
+      # These methods will be configured to return an `ExceptionCatcher` object
+      # that will always return the original exception, but only when called
+      # upon. This will allow method chains in `describe` statements to pass the
+      # `instance_eval` when loaded and only throw-and-catch the exception when
+      # the tests are run.
+      accessors = @accessors + @connectors.keys
+      accessors.each do |method_name|
+        resource.send(:define_method, method_name.to_sym) do |*args, &block|
+          begin
+            filter = table.new(self, method(table_accessor).call, ' with')
+            filter.method(method_name.to_sym).call(*args, &block)
+          rescue Inspec::Exceptions::ResourceFailed, Inspec::Exceptions::ResourceSkipped => e
+            FilterTable::ExceptionCatcher.new(resource, e)
+          end
+        end
+      end
+    end
+
+    def add_accessor(method_name)
+      if method_name.nil?
+        throw RuntimeError, "Called filter.add_delegator for resource #{@resource} with method name nil!"
+      end
+      @accessors.push(method_name)
+      self
+    end
+
+    def add(method_name, opts = {}, &block)
+      if method_name.nil?
+        throw RuntimeError, "Called filter.add for resource #{@resource} with method name nil!"
+      end
+
+      @connectors[method_name.to_sym] =
+        Connector.new(opts[:field] || method_name, block, opts)
+      self
+    end
+
+    private
+
+    def create_connector(c)
+      return ->(cond = Show) { c.block.call(self, cond) } if !c.block.nil?
+
+      lambda { |condition = Show, &cond_block|
+        if condition == Show && !block_given?
+          r = where(nil).get_field(c.field_name)
+          r = r.flatten.uniq.compact if c.opts[:style] == :simple
+          r
+        else
+          where({ c.field_name => condition }, &cond_block)
+        end
+      }
+    end
+  end
+
+  def self.create
+    Factory.new
+  end
+end

data/lib/utils/filter_array.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# copyright: 2015, Chef Software, Inc.
+# author: Stephan Renatus
+
+class FilterArray
+  attr_accessor :rules
+  alias content rules
+
+  def initialize(rules)
+    @rules = rules
+  end
+
+  # allows for chaining
+  # .field('arch', 'b32').field('key', 'access').rules
+  def field(key, value = nil)
+    if value
+      res = rules.find_all { |r| r[key.to_sym] == value }
+      FilterArray.new(res)
+    else
+      rules.map { |h| h[key.to_sym] }.uniq
+    end
+  end
+
+  def method_missing(meth, *args)
+    field(meth, args[0])
+  end
+end

data/lib/utils/find_files.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+# copyright: 2015, Vulcano Security GmbH
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+module FindFiles
+  TYPES = {
+    block: 'b',
+    character: 'c',
+    directory: 'd',
+    pipe: 'p',
+    file: 'f',
+    link: 'l',
+    socket: 's',
+    door: 'D',
+  }.freeze
+
+  # ignores errors
+  def find_files(path, opts = {})
+    find_files_or_warn(path, opts) || []
+  end
+
+  def find_files_or_warn(path, opts = {})
+    depth = opts[:depth]
+    type = TYPES[opts[:type].to_sym] if opts[:type]
+
+    # If `path` contains a `'` we must modify how we quote the `sh -c` argument
+    quote = path.include?("'") ? '"' : '\''
+
+    cmd = "sh -c #{quote}find #{path}"
+    cmd += " -type #{type}" unless type.nil?
+    cmd += " -maxdepth #{depth.to_i}" if depth.to_i > 0
+    cmd += quote
+
+    result = inspec.command(cmd)
+    exit_status = result.exit_status
+
+    unless exit_status == 0
+      warn "find_files(): exit #{exit_status} from `#{cmd}`"
+      return nil
+    end
+
+    result.stdout.split("\n")
+          .map(&:strip)
+          .find_all { |x| !x.empty? }
+  end
+end

data/lib/utils/hash.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+class ::Hash
+  # Inspired by: http://stackoverflow.com/a/9381776
+  def deep_merge(second)
+    merger = proc { |_key, v1, v2|
+      v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2
+    }
+    merge(second, &merger)
+  end
+
+  # converts a deep hash into a flat hash
+  # hash = {
+  #   'a' => 1,
+  #   'b' => {'c' => 2},
+  # }
+  # hash.smash # => {"a"=>1, "b-c"=>2}
+  def smash(prefix = nil)
+    inject({}) do |acc, (key, value)|
+      index = prefix.to_s + key.to_s
+      if value.is_a?(Hash)
+        acc.merge(value.smash(index + '-'))
+      else
+        acc.merge(index => value)
+      end
+    end
+  end
+
+  # deep check if all values are contained
+  def contains(contains)
+    hash = smash
+    contains = contains.smash
+
+    contains.each do |key, val|
+      return false if hash[key] != val
+    end
+    true
+  end
+end

data/lib/utils/json_log.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# author: Christoph Hartmann
+
+require 'json'
+
+# a simple streaming json logger
+class Logger::JSONFormatter < Logger::Formatter
+  def call(severity, time, progname, msg)
+    puts JSON.generate(
+      {
+        'progname'=> progname,
+        'severity'=> severity,
+        'time'=> time,
+        'msg'=> msg,
+      },
+    )
+  end
+end

data/lib/utils/latest_version.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# author: Christoph Hartmann
+
+require 'json'
+require 'net/http'
+
+class LatestInSpecVersion
+  # fetches the latest version from rubygems server
+  def latest
+    uri = URI('https://rubygems.org/api/v1/gems/inspec.json')
+    res = Net::HTTP.start(
+      uri.host, uri.port, use_ssl: uri.scheme == 'https',
+      open_timeout: 0.5, read_timeout: 0.5
+    ) { |http|
+      http.get(uri.path)
+    }
+    inspec_info = JSON.parse(res.body)
+    inspec_info['version']
+  rescue StandardError
+    nil
+  end
+end