Server : Apache/2.4.52 (Ubuntu) System : Linux webserver 6.8.0-49-generic #49~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Wed Nov 6 17:42:15 UTC 2 x86_64 User : www-data ( 33) PHP Version : 8.1.2-1ubuntu2.21 Disable Function : NONE Directory : /lib/python3/dist-packages/twisted/conch/client/__pycache__/ |
o
�b�M � @ sP d Z ddlZddlZddlmZmZmZ ddlm Z ddl
m Z ddl m
Z
ddlmZmZmZ ddlmZ dd lmZmZmZ dd
lmZ dd lmZ dd l m Z dd
l m Z ddl m!Z! e� Z"dd� Z#dd� Z$G dd� d�Z%e
e�G dd� de%��Z&e
e�G dd� d��Z'dd� Z(e
e�G dd � d e%e!��Z)G d d � d �Z*G d d � d �Z+dS )!zE
An implementation of the OpenSSH known_hosts database.
@since: 8.2
� N)�Error�
a2b_base64�
b2a_base64)�closing)�sha1)� implementer)�HostKeyChanged� InvalidEntry�UserRejectedKey)�IKnownHostEntry)� BadKeyError�FingerprintFormats�Key)�defer)�Logger)� nativeString)� secureRandom)� FancyEqMixinc C s t | ��� S )z�
Encode a binary string as base64 with no trailing newline.
@param s: The string to encode.
@type s: L{bytes}
@return: The base64-encoded string.
@rtype: L{bytes}
)r �strip)�s� r �A/usr/lib/python3/dist-packages/twisted/conch/client/knownhosts.py�
_b64encode s
r c C sz | � dd�}t|�dkrt� �|\}}}|� dd�}t|�dkr*|\}}|�d�}n|d }d}t�t|��}||||fS )a�
Extract common elements of base64 keys from an entry in a hosts file.
@param string: A known hosts file entry (a single line).
@type string: L{bytes}
@return: a 4-tuple of hostname data (L{bytes}), ssh key type (L{bytes}), key
(L{Key}), and comment (L{bytes} or L{None}). The hostname data is
simply the beginning of the line up to the first occurrence of
whitespace.
@rtype: L{tuple}
N� � � �
r )�split�lenr �rstripr �
fromStringr ) �string�elements� hostnames�keyType�
keyAndComment�splitkey� keyString�comment�keyr r r �_extractCommon- s
r* c @ s e Zd ZdZdd� Zdd� ZdS )�
_BaseEntrya�
Abstract base of both hashed and non-hashed entry objects, since they
represent keys and key types the same way.
@ivar keyType: The type of the key; either ssh-dss or ssh-rsa.
@type keyType: L{bytes}
@ivar publicKey: The server public key indicated by this line.
@type publicKey: L{twisted.conch.ssh.keys.Key}
@ivar comment: Trailing garbage after the key line.
@type comment: L{bytes}
c C s || _ || _|| _d S �N)r$ � publicKeyr( )�selfr$ r- r( r r r �__init__X s
z_BaseEntry.__init__c C s
| j |kS )a
Check to see if this entry matches a given key object.
@param keyObject: A public key object to check.
@type keyObject: L{Key}
@return: C{True} if this entry's key matches C{keyObject}, C{False}
otherwise.
@rtype: L{bool}
)r- )r. � keyObjectr r r �
matchesKey] s
z_BaseEntry.matchesKeyN)�__name__�
__module__� __qualname__�__doc__r/ r1 r r r r r+ I s r+ c s< e Zd ZdZ� fdd�Zedd� �Zdd� Zdd � Z� Z S )
�
PlainEntryz�
A L{PlainEntry} is a representation of a plain-text entry in a known_hosts
file.
@ivar _hostnames: the list of all host-names associated with this entry.
@type _hostnames: L{list} of L{bytes}
c s || _ t� �|||� d S r, )�
_hostnames�superr/ )r. r# r$ r- r( �� __class__r r r/ u s zPlainEntry.__init__c C s( t |�\}}}}| |�d�|||�}|S )a�
Parse a plain-text entry in a known_hosts file, and return a
corresponding L{PlainEntry}.
@param string: a space-separated string formatted like "hostname
key-type base64-key-data comment".
@type string: L{bytes}
@raise DecodeError: if the key is not valid encoded as valid base64.
@raise InvalidEntry: if the entry does not have the right number of
elements and is therefore invalid.
@raise BadKeyError: if the key, once decoded from base64, is not
actually an SSH key.
@return: an IKnownHostEntry representing the hostname and key in the
input line.
@rtype: L{PlainEntry}
� ,)r* r )�clsr! r# r$ r) r( r. r r r r y s zPlainEntry.fromStringc C s t |t�r
|�d�}|| jv S )aT
Check to see if this entry matches a given hostname.
@param hostname: A hostname or IP address literal to check against this
entry.
@type hostname: L{bytes}
@return: C{True} if this entry is for the given hostname or IP address,
C{False} otherwise.
@rtype: L{bool}
�utf-8)�
isinstance�str�encoder7 �r. �hostnamer r r � matchesHost� s
zPlainEntry.matchesHostc C s> d� | j�| jt| j�� �g}| jdur|�| j� d� |�S )a
Implement L{IKnownHostEntry.toString} by recording the comma-separated
hostnames, key type, and base-64 encoded key.
@return: The string representation of this entry, with unhashed hostname
information.
@rtype: L{bytes}
r; N� )�joinr7 r$ r r- �blobr( �append�r. �fieldsr r r �toString� s
�
zPlainEntry.toString)
r2 r3 r4 r5 r/ � classmethodr rC rJ �
__classcell__r r r9 r r6 k s
r6 c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �
UnparsedEntryz�
L{UnparsedEntry} is an entry in a L{KnownHostsFile} which can't actually be
parsed; therefore it matches no keys and no hosts.
c C �
|| _ dS )zv
Create an unparsed entry from a line in a known_hosts file which cannot
otherwise be parsed.
N)�_string)r. r! r r r r/ � s
zUnparsedEntry.__init__c C � dS �z'
Always returns False.
Fr rA r r r rC � � zUnparsedEntry.matchesHostc C rP rQ r )r. r) r r r r1 � rR zUnparsedEntry.matchesKeyc C s | j �d�S )a
Returns the input line, without its newline if one was given.
@return: The string representation of this entry, almost exactly as was
used to initialize this entry but without a trailing newline.
@rtype: L{bytes}
r )rO r �r. r r r rJ � s zUnparsedEntry.toStringN)r2 r3 r4 r5 r/ rC r1 rJ r r r r rM � s rM c C s4 t j| td�}t|t�r|�d�}|�|� |�� S )z�
Return the SHA-1 HMAC hash of the given key and string.
@param key: The HMAC key.
@type key: L{bytes}
@param string: The string to be hashed.
@type string: L{bytes}
@return: The keyed hash value.
@rtype: L{bytes}
)� digestmodr= )�hmac�HMACr r> r? r@ �update�digest)r) r! �hashr r r �
_hmacedString� s
rZ c sD e Zd ZdZdZdZ� fdd�Zedd� �Zdd � Z d
d � Z
� Z S ) � HashedEntrya�
A L{HashedEntry} is a representation of an entry in a known_hosts file
where the hostname has been hashed and salted.
@ivar _hostSalt: the salt to combine with a hostname for hashing.
@ivar _hostHash: the hashed representation of the hostname.
@cvar MAGIC: the 'hash magic' string used to identify a hashed line in a
known_hosts file as opposed to a plaintext one.
s |1|)� _hostSalt� _hostHashr$ r- r( c s || _ || _t� �|||� d S r, )r\ r] r8 r/ )r. �hostSalt�hostHashr$ r- r( r9 r r r/ s zHashedEntry.__init__c
C s^ t |�\}}}}|t| j�d� �d�}t|�dkr t� �|\}}| t|�t|�|||�} | S )a#
Load a hashed entry from a string representing a line in a known_hosts
file.
@param string: A complete single line from a I{known_hosts} file,
formatted as defined by OpenSSH.
@type string: L{bytes}
@raise DecodeError: if the key, the hostname, or the is not valid
encoded as valid base64
@raise InvalidEntry: if the entry does not have the right number of
elements and is therefore invalid, or the host/hash portion contains
more items than just the host and hash.
@raise BadKeyError: if the key, once decoded from base64, is not
actually an SSH key.
@return: The newly created L{HashedEntry} instance, initialized with the
information from C{string}.
N� |r )r* r �MAGICr r r )
r< r! �stuffr$ r) r( � saltAndHashr^ r_ r. r r r r s zHashedEntry.fromStringc C s t �t| j|�| j�S )a�
Implement L{IKnownHostEntry.matchesHost} to compare the hash of the
input to the stored hash.
@param hostname: A hostname or IP address literal to check against this
entry.
@type hostname: L{bytes}
@return: C{True} if this entry is for the given hostname or IP address,
C{False} otherwise.
@rtype: L{bool}
)rU �compare_digestrZ r\ r] rA r r r rC ' s
�zHashedEntry.matchesHostc C sR | j d�t| j�t| j�g� | jt| j�� �g}| jdur$|� | j� d�|�S )z�
Implement L{IKnownHostEntry.toString} by base64-encoding the salt, host
hash, and key.
@return: The string representation of this entry, with the hostname part
hashed.
@rtype: L{bytes}
r` NrD )
ra rE r r\ r] r$ r- rF r( rG rH r r r rJ 8 s
� �
zHashedEntry.toString) r2 r3 r4 r5 ra �compareAttributesr/ rK r rC rJ rL r r r9 r r[ � s
r[ c @ sX e Zd ZdZdd� Zedd� �Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z e dd� �Z
dS )�KnownHostsFileaz
A structured representation of an OpenSSH-format ~/.ssh/known_hosts file.
@ivar _added: A list of L{IKnownHostEntry} providers which have been added
to this instance in memory but not yet saved.
@ivar _clobber: A flag indicating whether the current contents of the save
path will be disregarded and potentially overwritten or not. If
C{True}, this will be done. If C{False}, entries in the save path will
be read and new entries will be saved by appending rather than
overwriting.
@type _clobber: L{bool}
@ivar _savePath: See C{savePath} parameter of L{__init__}.
c C s g | _ || _d| _dS )a$
Create a new, empty KnownHostsFile.
Unless you want to erase the current contents of C{savePath}, you want
to use L{KnownHostsFile.fromPath} instead.
@param savePath: The L{FilePath} to which to save new entries.
@type savePath: L{FilePath}
TN)�_added� _savePath�_clobber)r. �savePathr r r r/ ] s
zKnownHostsFile.__init__c C s | j S )z<
@see: C{savePath} parameter of L{__init__}
)rh rS r r r rj k s zKnownHostsFile.savePathc c s� � | j D ]}|V q| jrdS z| j�� }W n
ty Y dS w |�5 |D ])}z|�tj�r5t�|�}nt �|�}W n t
t t fyK t
|�}Y nw |V q&W d � dS 1 s[w Y dS )aK
Iterate over the host entries in this file.
@return: An iterable the elements of which provide L{IKnownHostEntry}.
There is an element for each entry in the file as well as an element
for each added but not yet saved entry.
@rtype: iterable of L{IKnownHostEntry} providers
N)rg ri rh �open�OSError�
startswithr[ ra r r6 � DecodeErrorr r rM )r. �entry�fp�liner r r � iterentriesr s. �
�
� ��"�zKnownHostsFile.iterentriesc C sx t | �� t| j� �D ].\}}|�|�r9|j|�� kr9|�|�r# dS |dk r,d}d}n|d }| j}t |||��q dS )a
Check for an entry with matching hostname and key.
@param hostname: A hostname or IP address literal to check for.
@type hostname: L{bytes}
@param key: The public key to check for.
@type key: L{Key}
@return: C{True} if the given hostname and key are present in this file,
C{False} if they are not.
@rtype: L{bool}
@raise HostKeyChanged: if the host key found for the given hostname
does not match the given key.
Tr Nr F)
� enumeraterr r rg rC r$ �sshTyper1 rh r )r. rB r) �lineidxro rq �pathr r r �
hasHostKey� s
�zKnownHostsFile.hasHostKeyc s. t ��j� ��}� ����fdd�}|�|�S )a�
Verify the given host key for the given IP and host, asking for
confirmation from, and notifying, the given UI about changes to this
file.
@param ui: The user interface to request an IP address from.
@param hostname: The hostname that the user requested to connect to.
@param ip: The string representation of the IP address that is actually
being connected to.
@param key: The public key of the server.
@return: a L{Deferred} that fires with True when the key has been
verified, or fires with an errback when the key either cannot be
verified or has changed.
@rtype: L{Deferred}
c s� | r!�� ���s ��d��� t��f � ����� ��� | S � ���fdd�}��� }|dkr4d}dt� �t��|�jtjd�f }�� |�
t � � ��}|�
|�S )NzZWarning: Permanently added the %s host key for IP address '%s' to the list of known hosts.c s. | r�� � �� �� ��� ��� | S t� �r, )�
addHostKey�saver
)�response)rB �ipr) r. r r �promptResponse� s zGKnownHostsFile.verifyHostKey.<locals>.gotHasKey.<locals>.promptResponse�EC�ECDSAz�The authenticity of host '%s (%s)' can't be established.
%s key fingerprint is SHA256:%s.
Are you sure you want to continue connecting (yes/no)? )�format)rw �warn�typer rx ry � fingerprintr
�
SHA256_BASE64�promptr@ �sys�getdefaultencoding� addCallback)�resultr| �keytyper� �proceed�rB r{ r) r. �uir r � gotHasKey� s0 �� ���
z/KnownHostsFile.verifyHostKey.<locals>.gotHasKey)r �
maybeDeferredrw r� )r. r� rB r{ r) �hhkr� r r� r �
verifyHostKey� s
*z KnownHostsFile.verifyHostKeyc C s6 t d�}|�� }t|t||�||d�}| j�|� |S )a�
Add a new L{HashedEntry} to the key database.
Note that you still need to call L{KnownHostsFile.save} if you wish
these changes to be persisted.
@param hostname: A hostname or IP address literal to associate with the
new entry.
@type hostname: L{bytes}
@param key: The public key to associate with the new entry.
@type key: L{Key}
@return: The L{HashedEntry} that was added.
@rtype: L{HashedEntry}
� N)r rt r[ rZ rg rG )r. rB r) �saltr$ ro r r r rx � s
zKnownHostsFile.addHostKeyc C s� | j �� }|�� s
|�� | jrd}nd}| j �|�� }| jr2|�d�dd� | jD ��d � g | _W d � n1 s<w Y d| _dS )zM
Save this L{KnownHostsFile} to the path it was loaded from.
�wb�abr c S s g | ]}|� � �qS r )rJ )�.0ro r r r �
<listcomp> s z'KnownHostsFile.save.<locals>.<listcomp>NF) rh �parent�isdir�makedirsri rk rg �writerE )r. �p�mode� hostsFileObjr r r ry s
�� �
zKnownHostsFile.savec C s | |�}d|_ |S )a�
Create a new L{KnownHostsFile}, potentially reading existing known
hosts information from the given file.
@param path: A path object to use for both reading contents from and
later saving to. If no file exists at this path, it is not an
error; a L{KnownHostsFile} with no entries is returned.
@type path: L{FilePath}
@return: A L{KnownHostsFile} initialized with entries from C{path}.
@rtype: L{KnownHostsFile}
F)ri )r< rv �
knownHostsr r r �fromPath s zKnownHostsFile.fromPathN)r2 r3 r4 r5 r/ �propertyrj rr rw r� rx ry rK r� r r r r rf L s
!Brf c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � ConsoleUIz�
A UI object that can ask true/false questions and post notifications on the
console, to be used during key verification.
c C rN )aA
@param opener: A no-argument callable which should open a console
binary-mode file-like object to be used for reading and writing.
This initializes the C{opener} attribute.
@type opener: callable taking no arguments and returning a read/write
file-like object
N)�opener)r. r� r r r r/ 9 s
zConsoleUI.__init__c s" t �d�}� �fdd�}|�|�S )a�
Write the given text as a prompt to the console output, then read a
result from the console input.
@param text: Something to present to a user to solicit a yes or no
response.
@type text: L{bytes}
@return: a L{Deferred} which fires with L{True} when the user answers
'yes' and L{False} when the user answers 'no'. It may errback if
there were any I/O errors.
Nc s~ t � �� ��/}|��� |�� �� �� }|dkr" W d � dS |dkr/ W d � dS |�d� q
1 s8w Y d S )NTs yess noFs Please type 'yes' or 'no': )r r� r� �readliner �lower)�ignored�f�answer�r. �textr r �bodyR s
��
��z ConsoleUI.prompt.<locals>.body)r �succeedr� )r. r� �dr� r r� r r� C s
zConsoleUI.promptc C s` z t | �� ��}|�|� W d � W dS 1 sw Y W dS ty/ t�d� Y dS w )z�
Notify the user (non-interactively) of the provided text, by writing it
to the console.
@param text: Some information the user is to be made aware of.
@type text: L{bytes}
NzFailed to write to console)r r� r� � Exception�log�failure)r. r� r� r r r r� ` s &� �zConsoleUI.warnN)r2 r3 r4 r5 r/ r� r� r r r r r� 3 s
r� ),r5 rU r� �binasciir rn r r �
contextlibr �hashlibr �zope.interfacer �twisted.conch.errorr r r
�twisted.conch.interfacesr �twisted.conch.ssh.keysr r
r �twisted.internetr �twisted.loggerr �twisted.python.compatr �twisted.python.randbytesr �twisted.python.utilr r� r r* r+ r6 rM rZ r[ rf r� r r r r �<module> s:
"L$Z h