| Server IP : 198.244.165.102 / Your IP : 216.73.216.218 [ Web Server : nginx/1.24.0 System : Linux modovh-ub-01 6.8.0-138-generic #138-Ubuntu SMP PREEMPT_DYNAMIC Fri Jul 31 22:41:49 UTC 2026 x86_64 User : colleary ( 1011) PHP Version : 8.3.23 Disable Function : NONE Domains : 2 Domains MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/twisted/conch/__pycache__/ |
Upload File : |
�
oj�U � �P � U d Z ddlZddlZddlZddlmZ ddlmZmZm Z m
Z
m Z m Z m
Z
mZmZ ddlmZmZmZ ddlmZ ddlmZmZ ddlmZ dd lmZ dd
l m Z dd l m Z m Z dd l!m"Z"m#Z# dd
l$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 e'� Z3 G d� dee4e4e5e5e4e4e4f � Z6 G d� de� Z7e
e7 e8d< ddl9Z: ee7e:� Z9 ddl<Z=e=Z< G d� de� Z>de7d e?d e6fd �Z@d e4d e
e> fd �ZAd e4d e
e> fd �ZB ee � G d!� d"� � ZC ee � G d#� d$� � ZD ee � G d%� d&� � ZE e. ed'd(dd� d)eFd$� G d*� d+e� ZGej� j� fd,ee? d-e e?gej� f d e ej� fd.�ZJd/e
e0e d-e e?gej� f d e
ej� fd0�ZK eeG� G d1� d2� � ZL eeG� G d3� d4� � ZM ee � G d5� d6� � ZNy# e;$ r dZ9Y ��Gw xY w# e;$ r dZ<Y ��Nw xY w)7zO
Provide L{ICredentialsChecker} implementations to be used in Conch protocols.
� N)� decodebytes) �IO�Any�Callable�Iterable�Iterator�Mapping�Optional�Tuple�cast)� Interface� implementer�
providedBy)�Version)�Literal�Protocol��error)�keys)�ICredentialsChecker)�ISSHPrivateKey�IUsernamePassword)�UnauthorizedLogin�UnhandledCredentials)�defer)�Logger)�verifyCryptedPassword)�failure�reflect)�deprecatedModuleAttribute)�FilePath)�runAsEffectiveUserc �& � e Zd ZdZedefd�� Zy)�
UserRecordz�
A record in a UNIX-style password database. See L{pwd} for field details.
This corresponds to the undocumented type L{pwd.struct_passwd}, but lacks named
field accessors.
�returnc � � y �N� ��selfs �8/usr/lib/python3/dist-packages/twisted/conch/checkers.py�pw_dirzUserRecord.pw_dir- s � � � N)�__name__�
__module__� __qualname__�__doc__�property�strr, r( r- r+ r$ r$ % s" � �� � �� � � r- r$ c � � e Zd ZdZdedefd�Zy)�UserDBz�
A database of users by name, like the stdlib L{pwd} module.
See L{twisted.python.fakepwd} for an in-memory implementation.
�usernamer% c � � y)zc
Lookup a user record by name.
@raises KeyError: when no such user exists
Nr( �r* r6 s r+ �getpwnamzUserDB.getpwnam9 � � r- N)r. r/ r0 r1 r3 r$ r9 r( r- r+ r5 r5 2 s � �� �� �� r- r5 �pwdc �& � e Zd ZdZded defd�Zy)�CryptedPasswordRecordz�
A sequence where the item at index 1 may be a crypted password.
Both L{pwd.struct_passwd} and L{spwd.struct_spwd} conform to this protocol.
�index� r% c � � y)z+
Get the crypted password.
Nr( )r* r> s r+ � __getitem__z!CryptedPasswordRecord.__getitem__Y r: r- N)r. r/ r0 r1 r r3 rA r( r- r+ r= r= R s � �� ���� �� r- r= �userdbr6 r% c �f � | j |j t j � � � S )a+
Lookup a user by name in a L{pwd}-style database.
@param userdb: The user database.
@param username: Identifying name in bytes. This will be decoded according
to the filesystem encoding, as the L{pwd} module does internally.
@raises KeyError: when the user doesn't exist
)r9 �decode�sys�getfilesystemencoding)rB r6 s r+ � _lookupUserrG _ s% � � �?�?�8�?�?�3�+D�+D�+F�G� H�Hr- c �V � t �yt t t j | � � S )a�
Look up a user in the /etc/passwd database using the pwd module. If the
pwd module is not available, return None.
@param username: the username of the user to return the passwd database
information for.
@returns: A L{pwd.struct_passwd}, where field 1 may contain a crypted
password, or L{None} when the L{pwd} database is unavailable.
@raises KeyError: when no such user exists
N)r; r r= r9 )r6 s r+ �
_pwdGetByNamerI m s# � � �{�� �%�s�|�|�H�'=� >�>r- c �j � t �t j }nyt t t dd|| � � S )a�
Look up a user in the /etc/shadow database using the spwd module. If it is
not available, return L{None}.
@param username: the username of the user to return the shadow database
information for.
@type username: L{str}
@returns: A L{spwd.struct_spwd}, where field 1 may contain a crypted
password, or L{None} when the L{spwd} database is unavailable.
@raises KeyError: when no such user exists
Nr )�spwd�getspnamr r= r" )r6 �fs r+ �_shadowGetByNamerN s0 � � �� �M�M��� �%�'9�!�Q��8�'L� M�Mr- c �$ � e Zd ZdZefZdd�Zd� Zy)�UNIXPasswordDatabaseae
A checker which validates users out of the UNIX password databases, or
databases of a compatible format.
@ivar _getByNameFunctions: a C{list} of functions which are called in order
to validate a user. The default value is such that the C{/etc/passwd}
database will be tried first, followed by the C{/etc/shadow} database.
Nc �. � |� t t g}|| _ y r' )rI rN �_getByNameFunctions)r* �getByNameFunctionss r+ �__init__z UNIXPasswordDatabase.__init__� s � � � %�"/�1A�!B� �#5�� r- c � � |j j t j � � }|j j t j � � }| j
D ]F } ||� }|��|d }|dk( r�t
||� s�'t j |j � c S t j t d� � S # t $ r# t j t d� � cY c S w xY w)Nr? � zinvalid usernamezunable to verify password) r6 rD rE rF �passwordrR r r �succeed�KeyError�failr )r* � credentialsr6 rW �func�pwnam�crypteds r+ �requestAvatarIdz$UNIXPasswordDatabase.requestAvatarId� s� � � �'�'�.�.�s�/H�/H�/J�K�� �'�'�.�.�s�/H�/H�/J�K���,�,� C�D�
C� �X��� �$� #�A�h�G� �"�}� �,�W�h�?� $�}�}�[�-A�-A� B�B� C� �z�z�+�,G�H�I�I�� �
I� �z�z�"3�4F�"G�H�H�
I�s �+C�'C:�9C:r' )r. r/ r0 r1 r �credentialInterfacesrT r_ r( r- r+ rP rP � s � �� .�/��6�
Jr- rP c �R � e Zd ZU dZefZ eee� Z ee
d< d� Z d� Z d� Z
d� Zd� Zy) �SSHPublicKeyDatabasez�
Checker that authenticates SSH public keys, based on public keys listed in
authorized_keys and authorized_keys2 files in user .ssh/ directories.
�_userdbc � � t j | j |� }|j | j |� |j | j � |S r' )r �
maybeDeferred�checkKey� addCallback�_cbRequestAvatarId�
addErrback�_ebRequestAvatarId�r* r[ �ds r+ r_ z$SSHPublicKeyDatabase.requestAvatarId� sC � � � � ��
�
�{� ;�� �
�
�d�-�-�{�;� � � �T�,�,�-��r- c �" � |s t j t d� � S |j s't j t j
� � S t j j |j � }|j |j |j � r |j S t j t d� � S # t $ r6 t j d� t j t d� � cY S w xY w)aC
Check whether the credentials themselves are valid, now that we know
if the key matches the user.
@param validKey: A boolean indicating whether or not the public key
matches a key in the user's authorized_keys file.
@param credentials: The credentials offered by the user.
@type credentials: L{ISSHPrivateKey} provider
@raise UnauthorizedLogin: (as a failure) if the key does not match the
user in C{credentials}. Also raised if the user provides an invalid
signature.
@raise ValidPublicKey: (as a failure) if the key matches the user but
the credentials do not include a signature. See
L{error.ValidPublicKey} for more information.
@return: The user's username, if authentication was successful.
z invalid key�Error while verifying keyzerror while verifying keyzunable to verify key)r �Failurer � signaturer �ValidPublicKeyr �Key�
fromString�blob�verify�sigDatar6 � Exception�_log)r* �validKeyr[ �pubKeys r+ rh z'SSHPublicKeyDatabase._cbRequestAvatarId� s� � �* ��?�?�#4�]�#C�D� D��$�$��?�?�5�#7�#7�#9�:� :�
W� ���,�,�[�-=�-=�>���=�=��!6�!6� �8K�8K�L�&�/�/�/� M�
��� 0�1G� H�I�I�� �
W�� � � 8�9� ���'8�9T�'U�V�V�
W�s �AC �<D�
Dc �� � t | j |j � }t |j � j d� }ddg}|D �cg c] }|j |� �� c}S c c}w )a�
Return a list of L{FilePath} instances for I{authorized_keys} files
which might contain information about authorized keys for the given
credentials.
On OpenSSH servers, the default location of the file containing the
list of authorized public keys is
U{$HOME/.ssh/authorized_keys<http://www.openbsd.org/cgi-bin/man.cgi?query=sshd_config>}.
I{$HOME/.ssh/authorized_keys2} is also returned, though it has been
U{deprecated by OpenSSH since
2001<http://marc.info/?m=100508718416162>}.
@return: A list of L{FilePath} instances to files with the authorized keys.
�.ssh�authorized_keys�authorized_keys2)rG rc r6 r! r, �child)r* r[ �pwent�root�filesrM s r+ �getAuthorizedKeysFilesz+SSHPublicKeyDatabase.getAuthorizedKeysFiles� sZ � � �D�L�L�+�*>�*>�?���� � �%�+�+�F�3��"�$6�7��',�-�!��
�
�1�
�-�-��-s �
A(c �T � t | j |j � dd \ }}| j |� D ]} }|j � s� |j � }|5 |D ]H }|j � }t |� dk r�" t |d � |j k( r ddd� y�J ddd� � y# t $ r@}|j t j k( rt |||j
� }n� Y d}~��d}~ww xY w# t j $ r Y ��w xY w# 1 sw Y ��xY w)zg
Retrieve files containing authorized keys and check against user
credentials.
� � Nr? TF)rG rc r6 r� �exists�open�OSError�errno�EACCESr" �split�lenr rt �binascii�Error) r* r[ �ouid�ogid�filepath�lines�e�l�l2s r+ rf z SSHPublicKeyDatabase.checkKey s* � �
!�� � �{�/C�/C�D�Q�q�I�
��d� �3�3�K�@� !�H��?�?�$��
� �
�
��� �
!� � !�A�����B��2�w��{� �!�&�r�!�u�-��1A�1A�A�#'�
!�
!� B� !�
!�
!� !�( �� �
��7�7�e�l�l�*� .�t�T�8�=�=� I�E�� ��
�� $�>�>� !� �!��
!�
!�sN �
B9� %D �D� D �+D �9 D�6C=�=D�D �D �D �D � D' c � � |j t � s?t j d|j �� t j t d� � S |S )Nz1Unauthorized login due to internal error: {error}r zunable to get avatar id)�checkr rx r �valuer ro )r* rM s r+ rj z'SSHPublicKeyDatabase._ebRequestAvatarId" sF � ��w�w�(�)� �J�J�C�1�7�7�
�
� �?�?�#4�5N�#O�P� P��r- N)r. r/ r0 r1 r r` r r5 r; rc �__annotations__r_ rh r� rf rj r( r- r+ rb rb � s> � ��
+�,���6�3�'�G�V�'�� !J�F.�*�8r- rb c �> � e Zd ZdZd� Zed� � Zd� Zd� Zd� Z d� Z
y) �SSHProtocolCheckera�
SSHProtocolChecker is a checker that requires multiple authentications
to succeed. To add a checker, call my registerChecker method with
the checker and the interface.
After each successful authenticate, I call my areDone method with the
avatar id. To get a list of the successful credentials for an avatar id,
use C{SSHProcotolChecker.successfulCredentials[avatarId]}. If L{areDone}
returns True, the authentication has succeeded.
c � � i | _ i | _ y r' )�checkers�successfulCredentialsr) s r+ rT zSSHProtocolChecker.__init__8 s � ���
�%'��"r- c �H � t | j j � � S r' )�listr� r r) s r+ r` z'SSHProtocolChecker.credentialInterfaces< s � ��D�M�M�&�&�(�)�)r- c �L � |s |j }|D ] }|| j |< � y r' )r` r� )r* �checkerr` �credentialInterfaces r+ �registerCheckerz"SSHProtocolChecker.registerChecker@ s0 � �#�#*�#?�#?� �#7� 9� �18�D�M�M�-� .� 9r- c �l � t |� }|D ]] }| j j |� }|��!t j |j
|� }|j
| j |� c S t j t ddj t t j |� � z � � S )a�
Part of the L{ICredentialsChecker} interface. Called by a portal with
some credentials to check if they'll authenticate a user. We check the
interfaces that the credentials provide against our list of acceptable
checkers. If one of them matches, we ask that checker to verify the
credentials. If they're valid, we call our L{_cbGoodAuthentication}
method to continue.
@param credentials: the credentials the L{Portal} wants us to verify
zNo checker for %sz, )r r� �getr re r_ rg �_cbGoodAuthenticationrZ r �join�mapr �qual)r* r[ �ifac�i�crl s r+ r_ z"SSHProtocolChecker.requestAvatarIdF s� � � �+�&��� N�A��
�
�!�!�!�$�A��}��'�'��(9�(9�;�G���}�}�T�%?�%?��M�M� N�
�z�z� �#�d�i�i��G�L�L�$�0G�&H�H�
�
�
r- c �� � || j vrg | j |< | j | j |� | j |� r| j |= |S t j � �)a
Called if a checker has verified the credentials. We call our
L{areDone} method to see if the whole of the successful authentications
are enough. If they are, we return the avatar ID returned by the first
checker.
)r� �append�areDoner �NotEnoughAuthentication)r* �avatarIdr[ s r+ r� z(SSHProtocolChecker._cbGoodAuthentication] si � � �4�5�5� 5�35�D� &� &�x� 0� �"�"�8�,�3�3�K�@� �<�<�� !��*�*�8�4��O��/�/�1� 1r- c � � y)a
Override to determine if the authentication is finished for a given
avatarId.
@param avatarId: the avatar returned by the first checker. For
this checker to function correctly, all the checkers must
return the same avatar ID.
Tr( )r* r� s r+ r� zSSHProtocolChecker.areDonem s � � r- N) r. r/ r0 r1 rT r2 r` r� r_ r� r� r( r- r+ r� r� + s4 � � �(� �*� �*�9�
�.2� r- r� �Twisted� z�Please use twisted.conch.checkers.SSHPublicKeyChecker, initialized with an instance of twisted.conch.checkers.UNIXAuthorizedKeysFiles instead.c � � e Zd ZdZd� Zy)�IAuthorizedKeysDBzb
An object that provides valid authorized ssh keys mapped to usernames.
@since: 15.0
c � � y)aL
Gets an iterable of authorized keys that are valid for the given
C{avatarId}.
@param avatarId: the ID of the avatar
@type avatarId: valid return value of
L{twisted.cred.checkers.ICredentialsChecker.requestAvatarId}
@return: an iterable of L{twisted.conch.ssh.keys.Key}
Nr( )r� s r+ �getAuthorizedKeysz#IAuthorizedKeysDB.getAuthorizedKeys� r: r- N)r. r/ r0 r1 r� r( r- r+ r� r� � s � ��
r- r� �fileobj�parseKeyc # �� K � | D ]2 }|j � }|s�|j d� r�( ||� �� �4 y# t j $ r"}t j d||�� Y d}~�fd}~ww xY w�w)a
Reads keys from an authorized keys file. Any non-comment line that cannot
be parsed as a key will be ignored, although that particular line will
be logged.
@param fileobj: something from which to read lines which can be parsed
as keys
@param parseKey: a callable that takes bytes and returns a
L{twisted.conch.ssh.keys.Key}, mainly to be used for testing. The
default is L{twisted.conch.ssh.keys.Key.fromString}.
@return: an iterable of L{twisted.conch.ssh.keys.Key}
@since: 15.0
� #z1Unable to parse line {line!r} as a key: {error!s})�liner N)�strip�
startswithr � BadKeyErrorrx r )r� r� r� r� s r+ �readAuthorizedKeyFiler� � su � �� � �
���z�z�|�� �����-�
� �t�n�$�
��
�#�#�
��
�
�G� �� � � ��
�s0 �A3�A3�
;�A3�A0�A+�&A3�+A0�0A3� filepathsc # �$ K � | D ]A }|j � s� |j � 5 }t ||� E d{ ��� ddd� �C y7 �# 1 sw Y �xY w# t $ r,}t j d|j |�� Y d}~��d}~ww xY w�w)a�
Helper function that turns an iterable of filepaths into a generator of
keys. If any file cannot be read, a message is logged but it is
otherwise ignored.
@param filepaths: iterable of L{twisted.python.filepath.FilePath}.
@type filepaths: iterable
@param parseKey: a callable that takes a string and returns a
L{twisted.conch.ssh.keys.Key}
@type parseKey: L{callable}
@return: generator of L{twisted.conch.ssh.keys.Key}
@since: 15.0
Nz"Unable to read {path!r}: {error!s})�pathr )r� r� r� r� rx r r� )r� r� �fprM r� s r+ �_keysFromFilepathsr� � s� � �� �& � X��
�9�9�;�
X��W�W�Y� B�!� 4�Q�� A�A�A�B��X� B��B� B���
X��
�
�?�b�g�g�UV�
�W�W��
X�sT �B�A�A �A
�A �A�B�
A � A �A� B
�!"B�B�B
�
Bc �n � e Zd ZdZdeeeej f ddfd�Z dedeej fd�Z
y)�InMemorySSHKeyDBz�
Object that provides SSH public keys based on a dictionary of usernames
mapped to L{twisted.conch.ssh.keys.Key}s.
@since: 15.0
�mappingr% Nc � � || _ y)z�
Initializes a new L{InMemorySSHKeyDB}.
@param mapping: mapping of usernames to iterables of
L{twisted.conch.ssh.keys.Key}s
N)�_mapping)r* r� s r+ rT zInMemorySSHKeyDB.__init__� s � � ��
r- r6 c �: � | j j |g � S )zd
Look up the authorized keys for a user.
@param username: Name of the user
)r� r� r8 s r+ r� z"InMemorySSHKeyDB.getAuthorizedKeys� s � � �}�}� � ��2�.�.r- ) r. r/ r0 r1 r �bytesr r rr rT r� r( r- r+ r� r� � sI � �� ���x����/A�(A� B� �t� �/�%� /�H�T�X�X�4F� /r- r� c � � e Zd ZU dZeed< dej j fde e de
e gej f fd�Z de de
ej fd �Zy)
�UNIXAuthorizedKeysFilesa
Object that provides SSH public keys based on public keys listed in
authorized_keys and authorized_keys2 files in UNIX user .ssh/ directories.
If any of the files cannot be read, a message is logged but that file is
otherwise ignored.
@since: 15.0
rc NrB r� c �l � |�|| _ || _ yt �t | _ || _ yt d� �)a�
Initializes a new L{UNIXAuthorizedKeysFiles}.
@param userdb: access to the Unix user account and password database
(default is the Python module L{pwd}, if available)
@param parseKey: a callable that takes a string and returns a
L{twisted.conch.ssh.keys.Key}, mainly to be used for testing. The
default is L{twisted.conch.ssh.keys.Key.fromString}.
Nz3No pwd module found, and no userdb argument passed.)rc r; �
ValueError� _parseKey)r* rB r� s r+ rT z UNIXAuthorizedKeysFiles.__init__� s? � � � �!�D�L�
"��� �_� �D�L� "��� � R�S� Sr- r6 r% c �� �� t | j |� }t |j � j d� �ddg}t
�fd�|D � | j � S # t $ r Y yw xY w)Nr( r| r} r~ c 3 �@ �K � | ] }�j |� �� � y �wr' )r )�.0rM r� s �r+ � <genexpr>z<UNIXAuthorizedKeysFiles.getAuthorizedKeys.<locals>.<genexpr> s �� �� �"@�Q�4�:�:�a�=�"@�s � )rG rc rY r! r, r r� r� )r* r6 �passwdr� r� s @r+ r� z)UNIXAuthorizedKeysFiles.getAuthorizedKeys si �� � � �� � �x�8�F� ��
�
�&�,�,�V�4��"�$6�7��!�"@�%�"@�$�.�.�Q�Q�� � �� �s �A � A,�+A,)r. r/ r0 r1 r5 r� r rr rs r
r r� rT r r� r( r- r+ r� r� � sk � �� �O� $(�04���0C�0C�"��� �"� �E�7�D�H�H�,�-�"�.R�%� R�H�T�X�X�4F� Rr- r� c �> � e Zd ZdZefZdeddfd�Zd� Zd� Z d� Z
d � Z y)
�SSHPublicKeyCheckera?
Checker that authenticates SSH public keys, based on public keys listed in
authorized_keys and authorized_keys2 files in user .ssh/ directories.
Initializing this checker with a L{UNIXAuthorizedKeysFiles} should be
used instead of L{twisted.conch.checkers.SSHPublicKeyDatabase}.
@since: 15.0
�keydbr% Nc � � || _ y)zq
Initializes a L{SSHPublicKeyChecker}.
@param keydb: a provider of L{IAuthorizedKeysDB}
N)�_keydb)r* r� s r+ rT z SSHPublicKeyChecker.__init__+ s � � �� r- c � � t j | j |� }|j | j |� |j | j
|� |S r' )r �execute�_sanityCheckKeyrg � _checkKey�
_verifyKeyrk s r+ r_ z#SSHPublicKeyChecker.requestAvatarId3 sA � � �M�M�$�.�.� � <�� �
�
�d�n�n�k�2� �
�
�d�o�o�{�3��r- c � � |j st j � �t j j |j � S )aW
Checks whether the provided credentials are a valid SSH key with a
signature (does not actually verify the signature).
@param credentials: the credentials offered by the user
@type credentials: L{ISSHPrivateKey} provider
@raise ValidPublicKey: the credentials do not include a signature. See
L{error.ValidPublicKey} for more information.
@raise BadKeyError: The key included with the credentials is not
recognized as a key.
@return: the key in the credentials
@rtype: L{twisted.conch.ssh.keys.Key}
)rp r rq r rr rs rt )r* r[ s r+ r� z#SSHPublicKeyChecker._sanityCheckKey9 s7 � �" �$�$��&�&�(� (��x�x�"�"�;�#3�#3�4�4r- c � �� t �fd�| j j |j � D � � r�S t d� �)ab
Checks the public key against all authorized keys (if any) for the
user.
@param pubKey: the key in the credentials (just to prevent it from
having to be calculated again)
@type pubKey:
@param credentials: the credentials offered by the user
@type credentials: L{ISSHPrivateKey} provider
@raise UnauthorizedLogin: If the key is not authorized, or if there
was any error obtaining a list of authorized keys for the user.
@return: C{pubKey} if the key is authorized
@rtype: L{twisted.conch.ssh.keys.Key}
c 3 �( �K � | ] }|�k( �� � y �wr' r( )r� �keyrz s �r+ r� z0SSHPublicKeyChecker._checkKey.<locals>.<genexpr>a s �� �� �
� !�C�6�M�
�s �zKey not authorized)�anyr� r� r6 r )r* rz r[ s ` r+ r� z SSHPublicKeyChecker._checkKeyO sB �� �$ �
�%)�[�[�%B�%B�;�CW�CW�%X�
�
� �M� � 4�5�5r- c � � |j |j |j � r |j S t d� �# t $ r}t d� |�d}~ww xY w)a~
Checks whether the credentials themselves are valid, now that we know
if the key matches the user.
@param pubKey: the key in the credentials (just to prevent it from
having to be calculated again)
@type pubKey: L{twisted.conch.ssh.keys.Key}
@param credentials: the credentials offered by the user
@type credentials: L{ISSHPrivateKey} provider
@raise UnauthorizedLogin: If the key signature is invalid or there
was any error verifying the signature.
@return: The user's username, if authentication was successful
@rtype: L{bytes}
rn NzKey signature invalid.)ru rp rv r6 rw r )r* rz r[ r� s r+ r� z SSHPublicKeyChecker._verifyKeyh sd � �$ H��}�}�[� 2� 2�K�4G�4G�H�"�+�+�+� I�
� 8�9�9�� � H�#�$?�@�a� G�� H�s �1A � A� A�A) r. r/ r0 r1 r r` r� rT r_ r� r� r� r( r- r+ r� r� s: � �� +�,�� � /� �D� �� 5�,6�2:r- r� )Or1 r� r� rE �base64r �typingr r r r r r r
r r �zope.interfacer
r r � incrementalr r r �
twisted.conchr �twisted.conch.sshr �twisted.cred.checkersr �twisted.cred.credentialsr r �twisted.cred.errorr r �twisted.internetr �twisted.loggerr �twisted.plugins.cred_unixr �twisted.pythonr r �twisted.python.deprecater �twisted.python.filepathr! �twisted.python.utilr" rx r3 �intr$ r5 r� r; �_pwd� ImportErrorrK �_spwdr= r� rG rI rN rP rb r� r. r� rr rs r� r� r� r� r� r( r- r+ �<module>r� s� ��
�
� �
� � X� X� X� =� =� � $� � "� 5� F� F� "� !� ;� +� >� ,� 2�
�x��
��s�C��c�3��S�8�9�
� �X� � �f�� � �� �v�t�
�C��� �D�
�H�
� I�� I�%� I�J� I� ?�C� ?�H�-B�$C� ?�$N�s� N�x�0E�'F� N�*
�
�!�%J� %J� "�%J�P
�
�!�j� j� "�j�Z
�
�!�J� J� "�J�Z � �I�r�1�a� � B�
�� � � � �* AE���@S�@S��
��Y��"*�E�7�D�H�H�+<�"=��
�d�h�h���:X����
�&�X�2:�E�7�D�H�H�;L�2M�X�
�d�h�h��X�8
�
� �/� /� �/�6
�
� �+R� +R� �+R�\
�
�!�b:� b:� "�b:��u � �
�C��� � � �D��s$ �H �H � H�H�H%�$H%