inspec 1.31.0 → 1.45.9

data/lib/resources/port.rb

@@ -59,9 +59,11 @@ module Inspec::Resources
       os = inspec.os
       if os.linux?
         LinuxPorts.new(inspec)
-      elsif %w{darwin aix}.include?(os[:family])
+      elsif os.aix?
         # AIX: see http://www.ibm.com/developerworks/aix/library/au-lsof.html#resources
         #      and https://www-01.ibm.com/marketing/iwm/iwm/web/reg/pick.do?source=aixbp
+        AixPorts.new(inspec)
+      elsif os.darwin?
         # Darwin: https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man8/lsof.8.html
         LsofPorts.new(inspec)
       elsif os.windows?
@@ -263,11 +265,150 @@ module Inspec::Resources
     end
   end
 
+  class AixPorts < PortsInfo
+    def info
+      ports_via_netstat || ports_via_lsof
+    end
+
+    def ports_via_lsof
+      return nil unless inspec.command('lsof').exist?
+      LsofPorts.new(inspec).info
+    end
+
+    def ports_via_netstat
+      return nil unless inspec.command('netstat').exist?
+
+      cmd = inspec.command('netstat -Aan | grep LISTEN')
+      return nil unless cmd.exit_status.to_i.zero?
+
+      ports = []
+      # parse all lines
+      cmd.stdout.each_line do |line|
+        port_info = parse_netstat_line(line)
+
+        # only push protocols we are interested in
+        next unless %w{tcp tcp6 udp udp6}.include?(port_info['protocol'])
+        ports.push(port_info)
+      end
+
+      ports
+    end
+
+    def parse_netstat_line(line)
+      # parse each line
+      # 1 - Socket, 2 - Proto, 3 - Receive-Q, 4 - Send-Q, 5 - Local address, 6 - Foreign Address, 7 - State
+      parsed = /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)?\s+(\S+)/.match(line)
+      return {} if parsed.nil?
+
+      # parse ip4 and ip6 addresses
+      protocol = parsed[2].downcase
+
+      # detect protocol if not provided
+      protocol += '6' if parsed[5].count(':') > 1 && %w{tcp udp}.include?(protocol)
+      protocol.chop! if %w{tcp4 upd4}.include?(protocol)
+
+      # extract host and port information
+      host, port = parse_net_address(parsed[5], protocol)
+      return {} if host.nil?
+
+      # extract PID
+      cmd = inspec.command("rmsock #{parsed[1]} tcpcb")
+      parsed_pid = /^The socket (\S+) is being held by proccess (\d+) \((\S+)\)/.match(cmd.stdout)
+      return {} if parsed_pid.nil?
+      process = parsed_pid[3]
+      pid = parsed_pid[2]
+      pid = pid.to_i if pid =~ /^\d+$/
+
+      {
+        'port'     => port,
+        'address'  => host,
+        'protocol' => protocol,
+        'process'  => process,
+        'pid'      => pid,
+      }
+    end
+
+    def parse_net_address(net_addr, protocol)
+      # local/foreign addresses on AIX use a '.' to separate the addresss
+      # from the port
+      address, _sep, port = net_addr.rpartition('.')
+      if protocol.eql?('tcp6') || protocol.eql?('udp6')
+        ip6addr = address
+        # AIX uses the wildcard character for ipv6 addresses listening on
+        # all interfaces.
+        ip6addr = '::' if ip6addr =~ /^\*$/
+
+        # v6 addresses need to end in a double-colon when using
+        # shorthand notation. netstat ends with a single colon.
+        # IPAddr will fail to properly parse an address unless it
+        # uses a double-colon for short-hand notation.
+        ip6addr += ':' if ip6addr =~ /\w:$/
+
+        begin
+          ip_parser = IPAddr.new(ip6addr)
+        rescue IPAddr::InvalidAddressError
+          # This IP is not parsable. There appears to be a bug in netstat
+          # output that truncates link-local IP addresses:
+          # example: udp6 0 0 fe80::42:acff:fe11::123 :::* 0 54550 3335/ntpd
+          # actual link address: inet6 fe80::42:acff:fe11:5/64 scope link
+          #
+          # in this example, the "5" is truncated making the netstat output
+          # an invalid IP address.
+          return [nil, nil]
+        end
+
+        # Check to see if this is a IPv4 address in a tcp6/udp6 line.
+        # If so, don't put brackets around the IP or URI won't know how
+        # to properly handle it.
+        # example: f000000000000000 tcp6       0      0 127.0.0.1.8005          *.*                    LISTEN
+        if ip_parser.ipv4?
+          ip_addr = URI("addr://#{ip6addr}:#{port}")
+          host = ip_addr.host
+        else
+          ip_addr = URI("addr://[#{ip6addr}]:#{port}")
+          host = ip_addr.host[1..ip_addr.host.size-2]
+        end
+      else
+        ip4addr = address
+        # In AIX the wildcard character is used to match all interfaces
+        ip4addr = '0.0.0.0' if ip4addr =~ /^\*$/
+        ip_addr = URI("addr://#{ip4addr}:#{port}")
+        host = ip_addr.host
+      end
+
+      [host, port.to_i]
+    end
+  end
+
   # extract port information from netstat
-  class LinuxPorts < PortsInfo
+  class LinuxPorts < PortsInfo # rubocop:disable Metrics/ClassLength
+    ALLOWED_PROTOCOLS = %w{tcp tcp6 udp udp6}.freeze
+
     def info
+      ports_via_ss || ports_via_netstat
+    end
+
+    def ports_via_ss
+      return nil unless inspec.command('ss').exist?
+
+      cmd = inspec.command('ss -tulpen')
+      return nil unless cmd.exit_status.to_i.zero?
+
+      ports = []
+
+      cmd.stdout.each_line do |line|
+        parsed_line = parse_ss_line(line)
+        ports << parsed_line unless parsed_line.nil?
+      end
+
+      ports
+    end
+
+    def ports_via_netstat
+      return nil unless inspec.command('netstat').exist?
+
       cmd = inspec.command('netstat -tulpen')
-      return nil if cmd.exit_status.to_i != 0
+      return nil unless cmd.exit_status.to_i.zero?
 
       ports = []
       # parse all lines
@@ -362,6 +503,113 @@ module Inspec::Resources
         'pid'      => pid,
       }
     end
+
+    def tokenize_ss_line(line)
+      # iproute-2.6.32-54.el6 output:
+      # Netid State      Recv-Q Send-Q  Local Address:Port Peer Address:Port
+      # udp   UNCONN     0      0       *:111              *:*                 users:(("rpcbind",1123,6)) ino=8680 sk=ffff8801390cf7c0
+      # tcp   LISTEN     0      128     *:22               *:*                 users:(("sshd",3965,3)) ino:11604 sk:ffff88013a3b5800
+      #
+      # iproute-2.6.32-20.el6 output:
+      # Netid            Recv-Q Send-Q  Local Address:Port Peer Address:Port
+      # udp              0      0       *:111              *:*                 users:(("rpcbind",1123,6)) ino=8680 sk=ffff8801390cf7c0
+      # tcp              0      128     *:22               *:*                 users:(("sshd",3965,3)) ino:11604 sk:ffff88013a3b5800
+      tokens = line.split(/\s+/, 7)
+      if tokens[1] =~ /^\d+$/ # iproute-2.6.32-20
+        {
+          netid: tokens[0],
+          local_addr: tokens[3],
+          process_info: tokens[5],
+        }
+      else # iproute-2.6.32-54
+        {
+          netid: tokens[0],
+          local_addr: tokens[4],
+          process_info: tokens[6],
+        }
+      end
+    end
+
+    def parse_ss_line(line)
+      # parsed = line.split(/\s+/, 7)
+      parsed = tokenize_ss_line(line)
+
+      # ss only returns "tcp" and "udp" as the protocol. However, netstat would return
+      # "tcp6" and "udp6" as necessary. In order to maintain backward compatibility, we
+      # will manually modify the protocol value if the line we're parsing is an IPv6
+      # entry.
+      process_info = parsed[:process_info]
+      protocol = parsed[:netid]
+      protocol += '6' if process_info.include?('v6only:1')
+      return nil unless ALLOWED_PROTOCOLS.include?(protocol)
+
+      # parse the Local Address:Port
+      # examples:
+      #   *:22
+      #   :::22
+      #   10.0.2.15:1234
+      #   ::ffff:10.0.2.15:9300
+      #   fe80::a00:27ff:fe32:ed09%enp0s3:9200
+      parsed_net_address = parsed[:local_addr].match(/(\S+):(\*|\d+)$/)
+      return nil if parsed_net_address.nil?
+      host = parsed_net_address[1]
+      port = parsed_net_address[2]
+      return nil if host.nil? && port.nil?
+
+      # For backward compatibility with the netstat output, ensure the
+      # port is stored as an integer
+      port = port.to_i
+
+      # for those "v4-but-listed-in-v6" entries, strip off the
+      # leading IPv6 value at the beginning
+      # example: ::ffff:10.0.2.15:9200
+      host.delete!('::ffff:') if host.start_with?('::ffff:')
+
+      # if there's an interface name in the local address, which is common for
+      # IPv6 listeners, strip that out too.
+      # example: fe80::a00:27ff:fe32:ed09%enp0s3
+      host = host.split('%').first
+
+      # if host is "*", replace with "0.0.0.0" to maintain backward compatibility with
+      # the netstat-provided data
+      host = '0.0.0.0' if host == '*'
+
+      # in case process list parsing is not successfull
+      process = nil
+      pid = nil
+
+      # parse process and pid from the process list
+      #
+      # remove the "users:((" and  "))" parts
+      # input: users:((\"nginx\",pid=583,fd=8),(\"nginx\",pid=582,fd=8),(\"nginx\",pid=580,fd=8),(\"nginx\",pid=579,fd=8))
+      # res: \"nginx\",pid=583,fd=8),(\"nginx\",pid=582,fd=8),(\"nginx\",pid=580,fd=8),(\"nginx\",pid=579,fd=8
+      process_list_match = parsed[:process_info].match(/users:\(\((.+)\)\)/)
+      if process_list_match
+        # list entires are seperated by "," the braces can also be removed
+        # input: \"nginx\",pid=583,fd=8),(\"nginx\",pid=582,fd=8),(\"nginx\",pid=580,fd=8),(\"nginx\",pid=579,fd=8
+        # res: ["\"nginx\",pid=583,fd=8", "\"nginx\",pid=582,fd=8", "\"nginx\",pid=580,fd=8", "\"nginx\",pid=579,fd=8"]
+        process_list = process_list_match[1].split('),(')
+        # To stay backwards compatible with netstat we need to select
+        # the last element in the resulting array.
+        # res: "\"nginx\",pid=579,fd=8"
+
+        # parse the process name from the process list
+        process_match = process_list.last.match(/^\"(\S+)\"/)
+        process = process_match.nil? ? nil : process_match[1]
+
+        # parse the PID from the process list
+        pid_match = process_list.last.match(/pid=(\d+)/)
+        pid = pid_match.nil? ? nil : pid_match[1].to_i
+      end
+
+      {
+        'port'     => port,
+        'address'  => host,
+        'protocol' => protocol,
+        'process'  => process,
+        'pid'      => pid,
+      }
+    end
   end
 
   # extracts information from sockstat

data/lib/resources/postgres.rb

@@ -86,7 +86,7 @@ module Inspec::Resources
       if data_dir_loc.nil?
         warn 'Unable to find the PostgreSQL data_dir in expected location(s), please
         execute "psql -t -A -p <port> -h <host> -c "show hba_file";" as the PostgreSQL
-        DBA to find the non-starndard data_dir location.'
+        DBA to find the non-standard data_dir location.'
       end
       data_dir_loc
     end

data/lib/resources/postgres_session.rb

@@ -52,7 +52,7 @@ module Inspec::Resources
       cmd = inspec.command(psql_cmd)
       out = cmd.stdout + "\n" + cmd.stderr
       if cmd.exit_status != 0 || out =~ /could not connect to .*/ || out.downcase =~ /^error:.*/
-        skip_resource "Can't read run query #{query.inspect} on postgres_session: #{out}"
+        Lines.new(out, "PostgreSQL query with errors: #{query}")
       else
         Lines.new(cmd.stdout.strip, "PostgreSQL query: #{query}")
       end

data/lib/resources/processes.rb

@@ -4,9 +4,10 @@
 # author: Christoph Hartmann
 
 require 'utils/filter'
+require 'ostruct'
 
 module Inspec::Resources
-  class Processes < Inspec.resource(1)
+  class Processes < Inspec.resource(1) # rubocop:disable Metrics/ClassLength
     name 'processes'
     desc 'Use the processes InSpec audit resource to test properties for programs that are running on the system.'
     example "
@@ -15,12 +16,18 @@ module Inspec::Resources
         its('users') { should eq ['mysql'] }
         its('states') { should include 'S' }
       end
+
       describe processes(/.+/).where { label != 'unconfined' && pid < 1000 } do
         its('users') { should cmp [] }
       end
+
+      # work with all processes
+      describe processes do
+        its('entries.length') { should be <= 100 }
+      end
     "
 
-    def initialize(grep)
+    def initialize(grep = /.*/)
       @grep = grep
       # turn into a regexp if it isn't one yet
       if grep.class == String
@@ -80,39 +87,118 @@ module Inspec::Resources
       os = inspec.os
 
       if os.linux?
-        command = 'ps axo label,pid,pcpu,pmem,vsz,rss,tty,stat,start,time,user:32,command'
-        regex = /^([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+(\w{3} \d{2}|\d{2}:\d{2}:\d{2})\s+([^ ]+)\s+([^ ]+)\s+(.*)$/
+        command, regex, field_map = ps_configuration_for_linux
       elsif os.windows?
         command = '$Proc = Get-Process -IncludeUserName | Where-Object {$_.Path -ne $null } | Select-Object PriorityClass,Id,CPU,PM,VirtualMemorySize,NPM,SessionId,Responding,StartTime,TotalProcessorTime,UserName,Path | ConvertTo-Csv -NoTypeInformation;$Proc.Replace("""","").Replace("`r`n","`n")'
         # Wanted to use /(?:^|,)([^,]*)/; works on rubular.com not sure why here?
         regex = /^(.+),(.+),(.+),(.+),(.+),(.+),(.+),(.+),(.+),(.+),(.+),(.+)$/
+        field_map = {
+          pid: 2,
+          cpu: 3,
+          mem: 4,
+          vsz: 5,
+          rss: 6,
+          tty: 7,
+          stat: 8,
+          start: 9,
+          time: 10,
+          user: 11,
+          command: 12,
+        }
       else
         command = 'ps axo pid,pcpu,pmem,vsz,rss,tty,stat,start,time,user,command'
         regex = /^\s*([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+(.*)$/
+        field_map = {
+          pid: 1,
+          cpu: 2,
+          mem: 3,
+          vsz: 4,
+          rss: 5,
+          tty: 6,
+          stat: 7,
+          start: 8,
+          time: 9,
+          user: 10,
+          command: 11,
+        }
       end
-      build_process_list(command, regex, os)
+      build_process_list(command, regex, field_map)
     end
 
-    Process = Struct.new(:label, :pid,
-                         :cpu, :mem, :vsz,
-                         :rss, :tty, :stat,
-                         :start, :time, :user, :command)
+    def ps_configuration_for_linux
+      if busybox_ps?
+        command = 'ps -o pid,vsz,rss,tty,stat,time,ruser,args'
+        regex = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/
+        field_map = {
+          pid: 1,
+          vsz: 2,
+          rss: 3,
+          tty: 4,
+          stat: 5,
+          time: 6,
+          user: 7,
+          command: 8,
+        }
+      else
+        command = 'ps axo label,pid,pcpu,pmem,vsz,rss,tty,stat,start,time,user:32,command'
+        regex = /^(.+?)\s+(\d+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+([^ ]+)\s+(\w{3} \d{2}|\d{2}:\d{2}:\d{2})\s+([^ ]+)\s+([^ ]+)\s+(.*)$/
+        field_map = {
+          label: 1,
+          pid: 2,
+          cpu: 3,
+          mem: 4,
+          vsz: 5,
+          rss: 6,
+          tty: 7,
+          stat: 8,
+          start: 9,
+          time: 10,
+          user: 11,
+          command: 12,
+        }
+      end
+
+      [command, regex, field_map]
+    end
+
+    def busybox_ps?
+      @busybox_ps ||= inspec.command('ps --help').stderr.include?('BusyBox')
+    end
 
-    def build_process_list(command, regex, os)
+    def build_process_list(command, regex, field_map)
       cmd = inspec.command(command)
       all = cmd.stdout.split("\n")[1..-1]
       return [] if all.nil?
-      lines = all.map do |line|
-        line.match(regex)
+
+      # map all the process lines into match objects, fetch the available fields,
+      # and then build an OpenStruct of the process data for each process
+      all.map do |line|
+        line = line.match(regex)
+
+        # skip this line if we couldn't match the regular expression
+        next if line.nil?
+
+        # skip this entry if there's no command for this line
+        next if line[field_map[:command]].nil?
+
+        # build a hash of process data that we'll turn into a struct for FilterTable
+        process_data = {}
+        [:label, :pid, :cpu, :mem, :vsz, :rss, :tty, :stat, :start, :time, :user, :command].each do |param|
+          # not all operating systems support all fields, so skip the field if we don't have it
+          process_data[param] = line[field_map[param]] if field_map.key?(param)
+        end
+
+        # ensure pid, vsz, and rss are integers for backward compatibility
+        [:pid, :vsz, :rss].each do |int_param|
+          process_data[int_param] = process_data[int_param].to_i if process_data.key?(int_param)
+        end
+
+        # strip any newlines off the command
+        process_data[:command].strip!
+
+        # return an OpenStruct of the process for future use by FilterTable
+        OpenStruct.new(process_data)
       end.compact
-      lines.map do |m|
-        a = m.to_a[1..-1] # grab all matching groups
-        a.unshift(nil) unless os.linux? || os.windows?
-        a[1] = a[1].to_i
-        a[4] = a[4].to_i
-        a[5] = a[5].to_i
-        Process.new(*a)
-      end
     end
   end
 end

data/lib/resources/registry_key.rb

@@ -106,10 +106,19 @@ module Inspec::Resources
     end
 
     # returns nil, if not existant or value
-    def method_missing(meth)
+    def method_missing(*keys)
+      # allow the use of array syntax in an `its` block so that users
+      # can use it to query for keys with . characters in them
+      if keys.is_a?(Array)
+        keys.shift if keys[0] == :[]
+        key = keys.first
+      else
+        key = keys
+      end
+
       # get data
       val = registry_key(@options[:path])
-      registry_property_value(val, meth)
+      registry_property_value(val, key)
     end
 
     def to_s

data/lib/resources/service.rb

@@ -349,40 +349,21 @@ module Inspec::Resources
         description: nil,
         installed: true,
         running: running,
-        enabled: info_enabled(status, service_name),
+        enabled: info_enabled(service_name),
         type: 'upstart',
       }
     end
 
     private
 
-    def info_enabled(status, service_name)
+    def info_enabled(service_name)
       # check if a service is enabled
-      # http://upstart.ubuntu.com/cookbook/#determine-if-a-job-is-disabled
-      # $ initctl show-config $job | grep -q "^  start on" && echo enabled || echo disabled
-      # Ubuntu 10.04 show-config is not supported
-      # @see http://manpages.ubuntu.com/manpages/maverick/man8/initctl.8.html
-      support_for_show_config = Gem::Version.new('1.3')
-
-      if version >= support_for_show_config
-        config = inspec.command("#{service_ctl} show-config #{service_name}").stdout
-      else # use config file as fallback
-        config = inspec.file("/etc/init/#{service_name}.conf").content
-      end
+      config = inspec.file("/etc/init/#{service_name}.conf").content
 
       # disregard if the config does not exist
       return nil if config.nil?
-      enabled = !config[/^\s*start on/].nil?
-
-      # implement fallback for Ubuntu 10.04
-      if inspec.os[:name] == 'ubuntu' &&
-         inspec.os[:release].to_f >= 10.04 &&
-         inspec.os[:release].to_f < 12.04 &&
-         status.exit_status == 0
-        enabled = true
-      end
 
-      enabled
+      !config.match(/^\s*start on/).nil?
     end
 
     def version
@@ -416,7 +397,7 @@ module Inspec::Resources
       # read all enabled services from runlevel
       # on rhel via: 'chkconfig --list', is not installed by default
       # bash: for i in `find /etc/rc*.d -name S*`; do basename $i | sed -r 's/^S[0-9]+//'; done | sort | uniq
-      enabled_services_cmd = inspec.command('find /etc/rc*.d /etc/init.d/rc*.d -name S*').stdout
+      enabled_services_cmd = inspec.command('find /etc/rc*.d /etc/init.d/rc*.d -name "S*"').stdout
       service_line = %r{rc(?<runlevel>[0-6])\.d/S[^/]*?#{Regexp.escape service_name}$}
       all_services = enabled_services_cmd.split("\n").map { |line|
         service_line.match(line)

data/lib/resources/ssh_conf.rb

@@ -63,7 +63,7 @@ module Inspec::Resources
       end
 
       @content = file.content
-      if @content.empty? && !file.empty?
+      if @content.nil? || (@content.empty? && !file.size.zero?)
         return skip_resource "Can't read file \"#{@conf_path}\""
       end
 

data/lib/resources/ssl.rb

@@ -50,8 +50,6 @@ class SSL < Inspec.resource(1)
         @host = inspec.backend.hostname
       elsif inspec.backend.class.to_s == 'Train::Transports::Local::Connection'
         @host = 'localhost'
-      else
-        raise 'Cannot determine host for SSL test. Please specify it or use a different target.'
       end
     end
     @port = opts[:port] || 443
@@ -60,11 +58,14 @@ class SSL < Inspec.resource(1)
   end
 
   filter = FilterTable.create
+  filter.add(:enabled?) do |x|
+    raise 'Cannot determine host for SSL test. Please specify it or use a different target.' if x.resource.host.nil?
+    x.handshake.values.any? { |i| i['success'] }
+  end
   filter.add_accessor(:where)
         .add_accessor(:entries)
         .add(:ciphers, field: 'cipher')
         .add(:protocols, field: 'protocol')
-        .add(:enabled?) { |x| x.handshake.values.any? { |i| i['success'] } }
         .add(:handshake) { |x|
           groups = x.entries.group_by(&:protocol)
           res = Parallel.map(groups, in_threads: 8) do |proto, e|

data/lib/resources/toml.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 # author: Nolan Davidson
 
-require 'toml'
+require 'tomlrb'
 
 module Inspec::Resources
   class TomlConfig < JsonConfig
@@ -16,7 +16,7 @@ module Inspec::Resources
     "
 
     def parse(content)
-      TOML::Parser.new(content).parsed
+      Tomlrb.parse(content)
     end
 
     def to_s

data/lib/resources/windows_hotfix.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# author: Matt Ray
+
+module Inspec::Resources
+  class WindowsHotfix < Inspec.resource(1)
+    name 'windows_hotfix'
+    desc 'Use the windows_hotfix InSpec audit resource to test if the hotfix has been installed on the Windows system.'
+    example "
+      describe windows_hotfix('KB4012212') do
+        it { should be_installed }
+      end
+    "
+
+    attr_accessor :content
+
+    def initialize(hotfix_id = nil)
+      @id = hotfix_id.upcase
+      @content = nil
+      os = inspec.os
+      return skip_resource 'The `windows_hotfix` resource is not a feature of your OS.' unless os.windows?
+      query = "get-hotfix -id #{@id}"
+      cmd = inspec.powershell(query)
+      @content = cmd.stdout
+    end
+
+    def to_s
+      "Windows Hotfix #{@id}"
+    end
+
+    def installed?
+      return false if @content.nil?
+      @content.include?(@id)
+    end
+  end
+end

data/lib/resources/xinetd.rb

@@ -53,15 +53,14 @@ module Inspec::Resources
       return @contents[path] if @contents.key?(path)
       file = inspec.file(path)
       if !file.file?
-        return skip_resource "Can't find file \"#{path}\""
+        raise Inspec::Exceptions::ResourceSkipped, "Can't find file: #{path}"
       end
 
-      @contents[path] = file.content
-      if @contents[path].nil? || @contents[path].empty?
-        return skip_resource "Can't read file \"#{path}\""
+      if file.content.nil? || file.content.empty?
+        raise Inspec::Exceptions::ResourceSkipped, "Can't read file: #{path}"
       end
 
-      @contents[path]
+      @contents[path] = file.content
     end
 
     def read_params
@@ -69,7 +68,6 @@ module Inspec::Resources
       flat_params = parse_xinetd(read_content)
       # we need to map service data in order to use it with filtertable
       params = { 'services' => {} }
-
       # map services that were defined and map it to the service hash
       flat_params.each do |k, v|
         name = k[/^service (.+)$/, 1]