Source code for insights.parsers.ssh

SshDConfig - file ``/etc/ssh/sshd_config``

The ``ssh`` module provides parsing for the ``sshd_config``
file.  The ``SshDConfig`` class implements the parsing and
provides a ``list`` of all configuration lines present in
the file.

Sample input is provided in the *Examples*.

    >>> sshd_config_input = '''
    ... #	$OpenBSD: sshd_config,v 1.93 2014/01/10 05:59:19 djm Exp $
    ... Port 22
    ... #AddressFamily any
    ... ListenAddress
    ... Port 22
    ... ListenAddress
    ... #ListenAddress ::
    ... # The default requires explicit activation of protocol 1
    ... #Protocol 2
    ... Protocol 1
    ... '''.strip()
    >>> from insights.tests import context_wrap
    >>> shared = {SshDConfig: SshDConfig(context_wrap(sshd_config_input))}
    >>> sshd_config = shared[SshDConfig]
    >>> 'Port' in sshd_config
    >>> 'PORT' in sshd_config
    >>> 'AddressFamily' in sshd_config
    >>> sshd_config['port']
    ['22', '22']
    >>> sshd_config['Protocol']
    >>> [line for line in sshd_config if line.keyword == 'Port']
    [KeyValue(keyword='Port', value='22', kw_lower='port'), KeyValue(keyword='Port', value='22', kw_lower='port')]
    >>> sshd_config.last('ListenAddress')
    >>> sshd_config.get_line('ListenAddress')
    >>> sshd_config.get_values('ListenAddress')
    ['', '']
    >>> sshd_config.get_values('ListenAddress', default='')
    ['', '']
    >>> sshd_config.get_values('ListenAddress', join_with=',')
from collections import namedtuple
from .. import Parser, parser, get_active_lines
from insights.specs import Specs
import re

# optional whitespace, at least one non-whitespace (the keyword), at least one whitespace (space), a plus literal, anything
PLUS_PATTERN = re.compile(r'^\s*\S+\s+\+.*$')

[docs]@parser(Specs.sshd_config) class SshDConfig(Parser): """Parsing for ``/etc/ssh/sshd_config`` file. Properties: lines (list): List of `KeyValue` namedtupules for each line in the configuration file. keywords (set): Set of keywords present in the configuration file, each keyword has been converted to lowercase. """ KeyValue = namedtuple('KeyValue', ['keyword', 'value', 'kw_lower', 'line']) """namedtuple: Represent name value pair as a namedtuple with case .""" # Note about "+" options. In some openssh versions and for some keywords, # a "+" at the beginning of the value list signifies that the values are # added to the default list of values. # IT IS NOT DETECTED AND PARSED HERE. # `parse_content()` doesn't split the individual values because some # keywords don't have a list of values (just one string). # See the docstring in `line_uses_plus()` for more details. # Re: BZ#1697477 # Config lines may also be delimited by `=`, and values may be quoted # with `"`. Here it is assumed that config lines are well-formed.
[docs] def parse_content(self, content): self.lines = [] for line in get_active_lines(content): line_splits = [s.strip() for s in re.split(r"[\s=]+", line, 1)] kw, val = line_splits[0], line_splits[1].strip('"') if \ len(line_splits) == 2 else '' self.lines.append(self.KeyValue( kw, val, kw.lower(), line )) self.keywords = set([k.kw_lower for k in self.lines])
def __contains__(self, keyword): """ (bool) Is this keyword found in the configuration file? """ return keyword.lower() in self.keywords def __iter__(self): """ (iter) Yields a list of all the lines in the configuration file that actually contained a configuration option. """ for line in self.lines: yield line def __getitem__(self, keyword): """ (list) Get all values of this keyword. """ kw = keyword.lower() if kw in self.keywords: return [kv.value for kv in self.lines if kv.kw_lower == kw]
[docs] def get(self, keyword): """ Get all declarations of this keyword in the configuration file. Returns: (list): a list of named tuples with the following properties: - ``keyword`` - the keyword as given on that line - ``value`` - the value of the keyword - ``kw_lower`` - the keyword converted to lower case - ``line`` - the complete line as found in the config file """ kw = keyword.lower() return [kv for kv in self.lines if kv.kw_lower == kw]
[docs] def get_values(self, keyword, default='', join_with=None, split_on=None): """ Get all the values assigned to this keyword. Firstly, if the keyword is not found in the configuration file, the value of the ``default`` option is used (defaulting to ``''``). Then, if the ``join_with`` option is given, this string is used to join the values found on each separate definition line. Otherwise, each separate definition line is returned as a string. Finally, if the ``split_on`` option is given, this string is used to split the combined string above into a list. Otherwise, the combined string is returned as is. """ kw = keyword.lower() if kw in self.keywords: vals = [kv.value for kv in self.lines if kv.kw_lower == kw] else: vals = [default] # Should we join them together? if join_with is None: return vals # OK, join them together. val_str = join_with.join(vals) # Should we now split them? if split_on is None: return val_str else: return val_str.split(split_on)
[docs] def get_line(self, keyword, default=''): """ (str): Get the line with the last declarations of this keyword in the configuration file, optionally pretending that we had a line with the default value and a comment informing the user that this was a created default line. This is a hack, but it's commonly used in the sshd configuration because of the many lines that are commonly omitted because they have their default value. Parameters: keyword(str): Keyword to find default: optional value to supply if not found """ lines = self.get(keyword) if lines: return lines[-1].line else: return "{keyword} {value} # Implicit default".format( keyword=keyword, value=default )
[docs] def line_uses_plus(self, keyword): """ (union[bool, None]): Get the line with the last declarations of this keyword in the configuration file and returns whether the "+" option syntax is used. A "+" before the list of values denotes that the values are appended to the openssh defaults for the particular keyword. Returns True if the "+" is used, False if a line with the keyword was found but it doesn't use the "+" or None if such a line doesn't exist. Reasoning for the implementation: * The "+" means "added to the defaults". * The defaults depend on the particular openssh-server version and the parser doesn't know the version. * Therefore, it is infeasible to add the evaluation logic for "+" into `get_values()`. * Adding the logic into a combiner would mean a requirement that the combiner has a complete database of all defaults in all openssh-server version - infeasible again. * Not every keyword allows the use of "+" - it wouldn't make sense to parse "+" into `KeyValue` as it would make meaningless parsing for some options and meaningful for others. Building a database which options in which openssh-server versions support it or not would be infeasible. * The way chosen as the most sensible is this - `line_uses_plus()` used selectively by a rule for those options that support it, and it is up to the developer of such a rule to check it for those options manually. Parameters: keyword(str): Keyword to find """ lines = self.get(keyword) if lines: found_line = lines[-1].line match = PLUS_PATTERN.match(found_line) return bool(match) else: return None
[docs] def last(self, keyword, default=None): """ str: Returns the value of the last keyword found in config. Parameters: keyword(str): Keyword to find default: optional value to supply if not found """ entries = self.__getitem__(keyword) if entries: return entries[-1] else: return default