File Manager
Viewing File: parser.rb
require "inspec/resources/command"
module Inspec
module Utils
module PasswdParser
# Parse /etc/passwd files.
#
# @param [String] content the raw content of /etc/passwd
# @return [Array] Collection of passwd entries
def parse_passwd(content)
content.to_s.split("\n").map do |line|
next if line[0] == "#"
parse_passwd_line(line)
end.compact
end
# Parse a line of /etc/passwd
#
# @param [String] line a line of /etc/passwd
# @return [Hash] Map of entries in this line
def parse_passwd_line(line)
x = line.split(":")
{
# rubocop:disable Layout/AlignHash
"user" => x[0],
"password" => x[1],
"uid" => x[2],
"gid" => x[3],
"desc" => x[4],
"home" => x[5],
"shell" => x[6],
}
end
end
module CommentParser
# Parse a line with a command. For example: `a = b # comment`.
# Retrieves the actual content.
#
# @param [String] raw the content lines you want to be parsed
# @param [Hash] opts optional configuration
# @return [Array] contains the actual line and the position of the line end
def parse_comment_line(raw, opts)
idx_nl = raw.index("\n")
idx_comment = raw.index(opts[:comment_char])
idx_nl = raw.length if idx_nl.nil?
idx_comment = idx_nl + 1 if idx_comment.nil?
line = ""
# is a comment inside this line
if idx_comment < idx_nl && idx_comment != 0
line = raw[0..(idx_comment - 1)]
# in case we don't allow comments at the end
# of an assignment/statement, ignore it and fall
# back to treating this as a regular line
if opts[:standalone_comments] && !is_empty_line(line)
line = raw[0..(idx_nl - 1)]
end
# if there is no comment in this line
elsif idx_comment > idx_nl && idx_nl != 0
line = raw[0..(idx_nl - 1)]
end
[line, idx_nl]
end
end
module LinuxMountParser
# this parses the output of mount command (only tested on linux)
# this method expects only one line of the mount output
def parse_mount_options(mount_line, compatibility = false)
if includes_whitespaces?(mount_line)
# Device-/Sharenames and Mountpoints including whitespaces require special treatment:
# We use the keyword ' type ' to split up and rebuild the desired array of fields
type_split = mount_line.split(" type ")
fs_path = type_split[0]
other_opts = type_split[1]
fs, path = fs_path.match(%r{^(.+?)\son\s(/.+?)$}).captures
mount = [fs, "on", path, "type"]
mount.concat(other_opts.scan(/\S+/))
else
# ... otherwise we just split the fields by whitespaces
mount = mount_line.scan(/\S+/)
end
# parse device and type
mount_options = { device: mount[0], type: mount[4] }
if compatibility == false
# parse options as array
mount_options[:options] = mount[5].gsub(/\(|\)/, "").split(",")
else
Inspec.deprecate(:mount_parser_serverspec_compat, "Parsing mount options in this fashion is deprecated")
mount_options[:options] = {}
mount[5].gsub(/\(|\)/, "").split(",").each do |option|
name, val = option.split("=")
if val.nil?
val = true
elsif val =~ /^\d+$/
# parse numbers
val = val.to_i
end
mount_options[:options][name.to_sym] = val
end
end
mount_options
end
# Device-/Sharename or Mountpoint includes whitespaces?
def includes_whitespaces?(mount_line)
ws = mount_line.match(/^(.+)\son\s(.+)\stype\s.*$/)
ws.captures[0].include?(" ") || ws.captures[1].include?(" ")
end
end
module BsdMountParser
# this parses the output of mount command (only tested on freebsd)
# this method expects only one line of the mount output
def parse_mount_options(mount_line, _compatibility = false)
return {} if mount_line.nil? || mount_line.empty?
mount = mount_line.chomp.split(" ", 4)
options = mount[3].tr("()", "").split(", ")
# parse device and type
{ device: mount[0], type: options.shift, options: options }
end
end
module SolarisNetstatParser
# takes this as a input and parses the values
# UDP: IPv4
# Local Address Remote Address State
# -------------------- -------------------- ----------
# *.* Unbound
def parse_netstat(content) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
return [] if content.nil? || content.empty?
protocol = nil
column_widths = nil
ports = []
cache_name_line = nil
content.each_line do |line|
# find header, its delimiter
if line =~ /TCP:|UDP:|SCTP:/
# get protocol
protocol = line.split(":")[0].chomp.strip.downcase
# determine version tcp, tcp6, udp, udp6
proto_version = line.split(":")[1].chomp.strip
protocol += "6" if proto_version == "IPv6"
# reset names cache
column_widths = nil
cache_name_line = nil
names = nil
# calulate width of a column based on the horizontal line
elsif line =~ /^[- ]+$/
column_widths = columns(line)
# parse header values from line
elsif column_widths.nil? && !line.nil?
# we do not know the width at this point of time, therefore we need to cache
cache_name_line = line
# content line
elsif !column_widths.nil? && !line.nil? && !line.chomp.empty?
# default row
port = split_columns(column_widths, line).to_a.map { |v| v.chomp.strip }
# parse the header names
# TODO: names should be optional
names = split_columns(column_widths, cache_name_line).to_a.map { |v| v.chomp.strip.downcase.tr(" ", "-").gsub(/[^\w-]/, "_") }
info = {
"protocol" => protocol.downcase,
}
# generate hash for each line and use the names as keys
names.each_index do |i|
info[names[i]] = port[i] if i != 0
end
ports.push(info)
end
end
ports
end
private
# takes a line like "-------------------- -------------------- ----------"
# as input and calculates the length of each column
def columns(line)
# find all columns
m = line.scan(/-+/)
# calculate the length each column
m.map { |x| x.length } # rubocop:disable Style/SymbolProc
end
# takes a line and the width of the columns to extract the values
def split_columns(columns, line)
# generate regex based on columns
sep = '\\s'
length = columns.length
arr = columns.map.with_index do |x, i|
reg = "(.{#{x}})#{sep}" # add seperator between columns
reg = "(.{,#{x}})#{sep}" if i == length - 2 # make the pre-last one optional
reg = "(.{,#{x}})" if i == length - 1 # use , to say max value
reg
end
# extracts the columns
line.match(Regexp.new(arr.join))
end
end
# This parser for xinetd (extended Internet daemon) configuration files
module XinetdParser
def xinetd_include_dir(dir)
return [] if dir.nil?
unless inspec.file(dir).directory?
raise Inspec::Exceptions::ResourceSkipped, "Can't find folder: #{dir}"
end
files = inspec.command("find #{dir} -type f").stdout.split("\n")
files.map { |file| parse_xinetd(read_content(file)) }
end
def parse_xinetd(raw) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
return {} if raw.nil?
require "inspec/utils/simpleconfig"
res = {}
cur_group = nil
simple_conf = []
rest = raw + "\n"
until rest.empty?
# extract content line
nl = rest.index("\n") || (rest.length - 1)
comment = rest.index("#") || (rest.length - 1)
dst_idx = comment < nl ? comment : nl
inner_line = dst_idx == 0 ? "" : rest[0..dst_idx - 1].strip
# update unparsed content
rest = rest[nl + 1..-1]
next if inner_line.empty?
if inner_line == "}"
if cur_group == "defaults"
res[cur_group] = SimpleConfig.new(simple_conf.join("\n"))
else
res[cur_group] ||= []
res[cur_group].push(SimpleConfig.new(simple_conf.join("\n")))
end
cur_group = nil
elsif rest.lstrip[0] == "{"
cur_group = inner_line
simple_conf = []
rest = rest[rest.index("\n") + 1..-1]
elsif cur_group.nil?
# parse all included files
others = xinetd_include_dir(inner_line[/includedir (.+)/, 1])
# complex merging of included configurations, as multiple services
# may be defined with the same name but different configuration
others.each do |ores|
ores.each do |k, v|
res[k] ||= []
res[k].concat(v)
end
end
else
simple_conf.push(inner_line)
end
end
res
end
end
end
end