U
vfj
@ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m
Z
ddl m Z d\Z
Zz ddl
Z
W n& ek
r Z zeZW 5 dZ[X Y nX ddlmZmZ d ZG d
d d Zd d
ZG dd dZG dd deZdS )z2
Configuration file (aka ``ssh_config``) support.
N)sha1)StringIO)partial)NN )CouldNotCanonicalizeConfigParseError c @ s e Zd ZdZedZddddddd d
gdgdd d ddd
d gd ddd gddd gdd dddddd d
g d
Zdd Ze dd Z
e dd Z e dd Z dd Z
dd Zd2d d Zd d Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 ZdS )3 SSHConfiga
Representation of config information as stored in the format used by
OpenSSH. Queries can be made via `lookup`. The format is described in
OpenSSH's ``ssh_config`` man page. This class is provided primarily as a
convenience to posix users (since the OpenSSH format is a de-facto
standard on posix) but should work fine on Windows too.
.. versionadded:: 1.6
z(\w+)(?:\s*=\s*|\s+)(.+)%C%h%l%L%n%p%r%u~%d)Z controlpathhostname identityfile proxycommandZ proxyjump
match-execc C s
g | _ dS )a
Create a new OpenSSH config object.
Note: the newer alternate constructors `from_path`, `from_file` and
`from_text` are simpler to use, as they parse on instantiation. For
example, instead of::
config = SSHConfig()
config.parse(open("some-path.config")
you could::
config = SSHConfig.from_file(open("some-path.config"))
# Or more directly:
config = SSHConfig.from_path("some-path.config")
# Or if you have arbitrary ssh_config text from some other source:
config = SSHConfig.from_text("Host foo\n\tUser bar")
N)_config)self r @/opt/alt/python38/lib/python3.8/site-packages/paramiko/config.py__init__H s zSSHConfig.__init__c C s | t|S )zg
Create a new, parsed `SSHConfig` from ``text`` string.
.. versionadded:: 2.7
) from_filer )clstextr r r from_text] s zSSHConfig.from_textc
C s* t |}| |W 5 Q R S Q R X dS )zr
Create a new, parsed `SSHConfig` from the file found at ``path``.
.. versionadded:: 2.7
N)openr )r pathflor r r from_pathf s
zSSHConfig.from_pathc C s | }| | |S )zp
Create a new, parsed `SSHConfig` from file-like object ``flo``.
.. versionadded:: 2.7
)parse)r r# objr r r r p s
zSSHConfig.from_filec C sR dgi d}|D ].}| }|r|dr.qt| j|}|sNtd||d }|d}|dkr| j
| di i}|d kr| ||d < n| ||d
< q|d kr| d krd
|d |< q|dr|
dr|dd }|dkr(||d kr|d |
| n|g|d |< q||d kr||d |< q| j
| d
S )z
Read an OpenSSH config from the given file object.
:param file_obj: a file-like object to read the config file from
*)hostconfig#zUnparsable line {}r )r( matchr) r( matchesr noneN")r Z localforwardZ
remoteforward)strip
startswithrer, SETTINGS_REGEXr formatgrouplowerr append
_get_hosts _get_matchesendswith)r Zfile_objcontextliner, keyvaluer r r r% { s6
zSSHConfig.parsec C s | j |d}d|kr ||d< |dddk}t|dd}|r|d|kr|d }| |||}||d< | j ||d
d
d }n| j ||d d
d }|S )
a
Return a dict (`SSHConfigDict`) of config options for a given hostname.
The host-matching rules of OpenSSH's ``ssh_config`` man page are used:
For each parameter, the first obtained value will be used. The
configuration files contain sections separated by ``Host`` and/or
``Match`` specifications, and that section is only applied for hosts
which match the given patterns or keywords
Since the first obtained value for each parameter is used, more host-
specific declarations should be given near the beginning of the file,
and general defaults at the end.
The keys in the returned dict are all normalized to lowercase (look for
``"port"``, not ``"Port"``. The values are processed according to the
rules for substitution variable expansion in ``ssh_config``.
Finally, please see the docs for `SSHConfigDict` for deeper info on
features such as optional type conversion methods, e.g.::
conf = my_config.lookup('myhost')
assert conf['passwordauthentication'] == 'yes'
assert conf.as_bool('passwordauthentication') is True
.. note::
If there is no explicitly configured ``HostName`` value, it will be
set to the being-looked-up hostname, which is as close as we can
get to OpenSSH's behavior around that particular option.
:param str hostname: the hostname to lookup
.. versionchanged:: 2.5
Returns `SSHConfigDict` objects instead of dict literals.
.. versionchanged:: 2.7
Added canonicalization support.
.. versionchanged:: 2.7
Added ``Match`` support.
.. versionchanged:: 3.3
Added ``Match final`` support.
)r r ZcanonicalizehostnameN)yesalwaysZcanonicalizemaxdotsr .ZcanonicaldomainsT) canonicalfinalF)_lookupgetintcountsplit canonicalize)r r optionsZcanonZmaxdotsdomainsr r r lookup s, * zSSHConfig.lookupNFc s d krt | jD ]}| |dg |sH| |dg |||sHq|d D ]T\ } kr|d k rx|d d n| < qT dkrT fdd|D qTq|r| |S )Nr( r- r) r c 3 s | ]}| kr|V qd S Nr .0xr> rK r r s z$SSHConfig._lookup..)
SSHConfigDictr _pattern_matchesrF _does_matchitemsextend_expand_variables)r r rK rC rD r< r? r rR r rE s0
zSSHConfig._lookupc C s d}|D ]^}d ||}t||}|dk r4|d }n&zt|}W n tjk
rX Y nX |r| S q|dddkr||S t|dS )ag
Return canonicalized version of ``hostname``.
:param str hostname: Target hostname.
:param options: An `SSHConfigDict` from a previous lookup pass.
:param domains: List of domains (e.g. ``["paramiko.org"]``).
:returns: A canonicalized hostname if one was found, else ``None``.
.. versionadded:: 2.7
Fz{}.{}Nr Zcanonicalizefallbacklocalr@ )r5 _addressfamily_host_lookupsocket
gethostbynamegaierrorrF r )r r rK rL founddomain candidateZfamily_specificr r r rJ s
zSSHConfig.canonicalizec C s$ t }| jD ]}||d q |S )z
Return the set of literal hostnames defined in the SSH config (both
explicit hostnames and wildcard entries).
r( )setr update)r hostsentryr r r
get_hostnamesE s
zSSHConfig.get_hostnamesc C sZ t |dr|d}d}|D ]8}|drDt||dd rD dS t||r d}q |S )NrI ,F!r T)hasattrrI r2 fnmatch)r patternstargetr, patternr r r rU O s
zSSHConfig._pattern_matchesc C sV g }|d d }t }|rR|d} d }
|dd } |dd } | d | d }
}|
dkrn| || rndS |
dkr||}
n|
d krd
S |
d kr| p|}| ||}
n|
d kr| ||}
nn|
dkr| p|}| ||}
nP|
d
kr| ||}
n:|
dkr*| ||d|}td krttj |dd
dj
}
|
d k rF| |
| rFdS | | q|S )Nr r usertypeparamrC FrD allTr( Z originalhostZ localuserexecr stdout)Zhidewarn) getpassgetuserpoprF _should_failrU _tokenizeinvokeinvoke_import_errorrunokr8 )r Z
match_listtarget_hostnamerC rD rK Zmatched
candidatesZlocal_usernamer` ZpassedZconfigured_hostZconfigured_usertype_ro Zhostvalrm Zexec_cmdr r r rV ` sP
zSSHConfig._does_matchc C s |d r |S | S )Nnegater )r Z
would_passr` r r r rw s zSSHConfig._should_failc C s | |}|s|S |}|dkr*|d|}d|kr<|d }nt}t }d|krZ|d } n|} t dd }
t||
} t j
d} |
| t | | }
t
|
| ||
| ||| || d
}|}| D ]"\}}||krq||t|}q|S )a
Tokenize a string based on current config/hostname data.
:param config: Current config data.
:param target_hostname: Original target connection hostname.
:param key: Config key being tokenized (used to filter token list).
:param value: Config value being tokenized.
:returns: The tokenized version of the input ``value`` string.
r portrm rB r r )
r
r r r
r r r r r r )_allowed_tokensrF SSH_PORTrt ru r[ gethostnamerI LazyFqdnosr"
expanduserreprr encode hexdigestrW replacestr)r r) r} r> r? Zallowed_tokensZconfigured_hostnamer rm Z
remoteuserZlocal_hostnameZ
local_fqdnhomedirZtohashZ replacementsZ tokenizedfindr r r r rx sD
zSSHConfig._tokenizec C s | j |g S )aJ
Given config ``key``, return list of token strings to tokenize.
.. note::
This feels like it wants to eventually go away, but is used to
preserve as-strict-as-possible compatibility with OpenSSH, which
for whatever reason only applies some tokens to some config keys.
)TOKENS_BY_CONFIG_KEYrF r r> r r r r s zSSHConfig._allowed_tokensc C sr |D ]h}|| dkrqt | j|||}t|| tr\t|| D ]\}}|||| |< q@q||| ||< q|S )aA
Return a dict of config options with expanded substitutions
for a given original & current target hostname.
Please refer to :doc:`/api/config` for details.
:param dict config: the currently parsed config
:param str hostname: the hostname whose config is being looked up
N)r rx
isinstancelist enumerate)r r) r} kZ tokenizerir? r r r rY s
zSSHConfig._expand_variablesc C s4 z t |W S tk
r. td|Y nX dS )z>
Return a list of host_names from host value.
zUnparsable host {}N)shlexrI
ValueErrorr r5 )r r( r r r r9 s zSSHConfig._get_hostsc s$ g }t |}|rdddd}|d}|drFd|d< |dd }||d < |d
krb|| q|sttd ||d|d < || qd
d |D }d|kr d tt fdd|tt fdd| }}d}t |rd}n$d|kr|
d|
dkrd}|dk r t||S )z
Parse a specific Match config line into a list-of-dicts for its values.
Performs some parse-time validation as well.
NF)rn ro r r rg Tr r rn )rp rC rD z'Missing parameter to Match '{}' keywordro c S s g | ] }|d qS )rn r rO r r r
s z*SSHConfig._get_matches..rp )rp rC c s | kS rN r rQ Z allowabler r " z(SSHConfig._get_matches..c s | kS rN r r r r r r # r z>Match does not allow 'all' mixed with anything but 'canonical'rC z-Match does not allow 'all' before 'canonical') r rI rv r2 r8 r r5 r filteranyindex) r r, r- tokensr keywordsr| baderrr r r r: s@
zSSHConfig._get_matches)NFF)__name__
__module__ __qualname____doc__r3 compiler4 r r classmethodr r$ r r% rM rE rJ re rU rV rw rx r rY r9 r: r r r r r . s:
<B
#)
8> r c C sh | dd }|dkr dS z0tj}|dkr2tj}t| d|tjtjtjW S tj k
rb Y nX dS )a
Try looking up ``hostname`` in an IPv4 or IPv6 specific manner.
This is an odd duck due to needing use in two divergent use cases. It looks
up ``AddressFamily`` in ``options`` and if it is ``inet`` or ``inet6``,
this function uses `socket.getaddrinfo` to perform a family-specific
lookup, returning the result if successful.
In any other situation -- lookup failure, or ``AddressFamily`` being
unspecified or ``any`` -- ``None`` is returned instead and the caller is
expected to do something situation-appropriate like calling
`socket.gethostbyname`.
:param str hostname: Hostname to look up.
:param options: `SSHConfigDict` instance w/ parsed options.
:returns: ``getaddrinfo``-style tuples, or ``None``, depending.
Z
addressfamilyr NZinet)
rF r7 r[ AF_INET6AF_INET getaddrinfo
SOCK_DGRAM
IPPROTO_IP AI_CANONNAMEr] )r rK address_familyfamilyr r r rZ / s" rZ c @ s" e Zd ZdZdddZdd ZdS )r z7
Returns the host's fqdn on request as string.
Nc C s d | _ || _|| _d S rN )fqdnr) r( )r r) r( r r r r Y s zLazyFqdn.__init__c C sl | j d krfd }t| j| j}|d k rP|D ]&}|\}}}}}|r(d|kr(|} qPq(|d kr`t }|| _ | j S )NrB )r rZ r( r) r[ getfqdn) r r resultsresafsocktypeproto canonnamesar r r __str__^ s
zLazyFqdn.__str__)N)r r r r r r r r r r r T s
r c @ s e Zd ZdZdd Zdd ZdS )rT a
A dictionary wrapper/subclass for per-host configuration structures.
This class introduces some usage niceties for consumers of `SSHConfig`,
specifically around the issue of variable type conversions: normal value
access yields strings, but there are now methods such as `as_bool` and
`as_int` that yield casted values instead.
For example, given the following ``ssh_config`` file snippet::
Host foo.example.com
PasswordAuthentication no
Compression yes
ServerAliveInterval 60
the following code highlights how you can access the raw strings as well as
usefully Python type-casted versions (recalling that keys are all
normalized to lowercase first)::
my_config = SSHConfig()
my_config.parse(open('~/.ssh/config'))
conf = my_config.lookup('foo.example.com')
assert conf['passwordauthentication'] == 'no'
assert conf.as_bool('passwordauthentication') is False
assert conf['compression'] == 'yes'
assert conf.as_bool('compression') is True
assert conf['serveraliveinterval'] == '60'
assert conf.as_int('serveraliveinterval') == 60
.. versionadded:: 2.5
c C s" | | }t |tr|S | dkS )a
Express given key's value as a boolean type.
Typically, this is used for ``ssh_config``'s pseudo-boolean values
which are either ``"yes"`` or ``"no"``. In such cases, ``"yes"`` yields
``True`` and any other value becomes ``False``.
.. note::
If (for whatever reason) the stored value is already boolean in
nature, it's simply returned.
.. versionadded:: 2.5
r@ )r boolr7 )r r> valr r r as_bool s
zSSHConfigDict.as_boolc C s t | | S )z
Express given key's value as an integer, if possible.
This method will raise ``ValueError`` or similar if the value is not
int-appropriate, same as the builtin `int` type.
.. versionadded:: 2.5
)rG r r r r as_int s zSSHConfigDict.as_intN)r r r r r r r r r r rT z s !rT )r ri rt r r3 r r[ hashlibr ior functoolsr ry rz ImportErroreZ
ssh_exceptionr r r r rZ r dictrT r r r r s0 %&