📄 gnupg.cpython-310.pyc

Size: 59,267 bytes
Path: //opt/saltstack/salt/lib/python3.10/site-packages/__pycache__/gnupg.cpython-310.pyc
Modified: 2026-06-18 13:40:19
o

�j;�@s�dZddlZddlmZddlZddlZddlZddlZddlm	Z	m
Z
ddlZddlZdZ
dZdZdZejdkrQzdd	lmZmZmZWneyPdZYnwzed
ZeZeZeefZWneyqdZeZeZefZYnwe�e�Z e j!s�e �"e�#��d
Z$ej%jdkr�d
d�Z&n	e�'d�Z(dd�Z&e�)�Z*dd�Z+dd�Z,dd�Z-dd�Z.dd�Z/dd�Z0dd�Z1Gdd �d e2�Z3Gd!d"�d"e3�Z4Gd#d$�d$e3�Z5e�'d%ej6�Z7d&d'd(d)d*d+d,�Z8Gd-d.�d.e3�Z9d/d0�Z:Gd1d2�d2e3e;�Z<Gd3d4�d4e<�Z=Gd5d6�d6e=�Z>Gd7d8�d8e2�Z?d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdH�Z@dIdJ�ZAGdKdL�dLe4e?�ZBGdMdN�dNe3�ZCGdOdP�dPe3�ZDGdQdR�dReC�ZEGdSdT�dTe3�ZFGdUdV�dVeF�ZGGdWdX�dXe3e?�ZHe�'dY�IdZ��ZJe�'d[ej6�ZKe�'d\�ZLGd]d^�d^e2�ZMdS)_a� A wrapper for the GnuPG `gpg` command.

Portions of this module are derived from A.M. Kuchling's well-designed
GPG.py, using Richard Jones' updated version 1.3, which can be found
in the pycrypto CVS repository on Sourceforge:

http://pycrypto.cvs.sourceforge.net/viewvc/pycrypto/gpg/GPG.py

This module is *not* forward-compatible with amk's; some of the
old interface has changed.  For instance, since I've added decrypt
functionality, I elected to initialize with a 'gnupghome' argument
instead of 'keyring', so that gpg can find both the public and secret
keyrings.  I've also altered some of the returned objects in order for
the caller to not have to know as much about the internals of the
result classes.

While the rest of ISconf is released under the GPL, I am releasing
this single file under the same terms that A.M. Kuchling used for
pycrypto.

Steve Traugott, stevegt@terraluna.org
Thu Jun 23 21:27:20 PDT 2005

This version of the module has been modified from Steve Traugott's version
(see http://trac.t7a.org/isconf/browser/trunk/lib/python/isconf/GPG.py) by
Vinay Sajip to make use of the subprocess module (Steve's version uses os.fork()
and so does not work on Windows). Renamed to gnupg.py to avoid confusion with
the previous versions.

Modifications Copyright (C) 2008-2023 Vinay Sajip. All rights reserved.

For the full documentation, see https://docs.red-dove.com/python-gnupg/ or
https://gnupg.readthedocs.io/
�N)�StringIO)�Popen�PIPEz0.5.2zVinay Sajipz$12-Dec-2023 07:52:07$�nt)�STARTUPINFO�STARTF_USESHOWWINDOW�SW_HIDEFT�ntpathcCsd|S)Nz"%s"���sr
r
�9/opt/saltstack/salt/lib/python3.10/site-packages/gnupg.py�shell_quoteTsrz[^\w%+,./:=@-]cCsLt|t�s
tdt|���|sd}|St�|�s|}|Sd|�dd�}|S)au
        Quote text so that it is safe for POSIX command shells.

        For example, "*.py" would be converted to "'*.py'". If the text is considered safe it is returned unquoted.

        Args:
            s (str): The value to quote
        Returns:
            str: A safe version of the input, from the point of view of POSIX
                 command shells.
        zExpected string type, got %sz''z'%s'�'z'\'')�
isinstance�string_types�	TypeError�type�UNSAFE�search�replace)r�resultr
r
r
r]s

��cCstst|t�r|�t�}|S)z7
    Legacy function which is a no-op on Python 3.
    )�_py3kr�	text_type�encode�
fsencodingrr
r
r
�no_quote�s
rcCs�|dksJ�d}ttjd�rtjj}nd}	z|�|�}Wnty-tjddd�Yn1w|s1n-|t|�7}z|�	|�Wnt
yO|�	|�|��Ynty\t�d�Ynwqz|�
�Wntyttjd	dd�Ynwt�d
|�dS)Nr�encoding�asciiTz Exception occurred while reading�)�exc_infozError sending dataz)Exception occurred while closing: ignoredzclosed output, %d bytes sent)�hasattr�sys�stdinr�read�	Exception�logger�warning�len�write�UnicodeErrorr�	exception�close�IOError�debug)�instream�	outstream�buffer_size�sent�enc�datar
r
r
�
_copy_data�s<
�
���r5cCsB|dksJ�tjt|||fd�}d|_t�d|||�|��|S)Nr��target�argsTzdata copier: %r, %r, %r)�	threading�Threadr5�daemonr&r.�start)r/r0r1�wrr
r
r
�_threaded_copy_data�sr>cCs*d|}|�|�}|�|�t�d�dS)Nz%s
zWrote passphrase)rr)r&r.)�stream�
passphraserr
r
r
�_write_passphrase�s

rAcCst|ttttf�S�N)r�list�tuple�set�	frozenset)�instancer
r
r
�_is_sequence��rHcCs8z
ddlm}||�}W|Styt|�}Y|Sw)Nr)�BytesIO)�iorJ�ImportErrorr)rrJ�rvr
r
r
�_make_memory_stream�s
�
�rNcCs>trt|t�r|�|�}t|�St|�tur|�|�}t|�SrB)rr�strrrrN)rrr
r
r
�_make_binary_stream�s

�
rPc@s eZdZdZdd�Zdd�ZdS)�
StatusHandlerzA
    The base class for handling status messages from `gpg`.
    cCs
||_dS)zq
        Initialize an instance.

        Args:
            gpg (GPG): The :class:`GPG` instance in use.
        N)�gpg��selfrRr
r
r
�__init__�s
zStatusHandler.__init__cCst�)a.
        Handle status messages from the `gpg` child process. These are lines of the format

            [GNUPG:] <key> <value>

        Args:
            key (str): Identifies what the status message is.
            value (str): Identifies additional data, which differs depending on the key.
        )�NotImplementedError�rT�key�valuer
r
r
�
handle_status�s
zStatusHandler.handle_statusN)�__name__�
__module__�__qualname__�__doc__rUrZr
r
r
r
rQ�s	rQc@speZdZdZdZdZdZdZdZdZ	eeeeee	d�Z
d	d
ddd
�ZddiZdZ
dd�Zdd�ZeZdd�ZdS)�VerifyzJ
    This class handles status messages during signature verificaton.
    rr����)�
TRUST_EXPIRED�TRUST_UNDEFINED�TRUST_NEVER�TRUST_MARGINAL�TRUST_FULLY�TRUST_ULTIMATEzpermission deniedzfile existszfile not foundznot a directory)r�#�Q�a�zincorrect passphraseNcCsvt�||�d|_d|_|_|_d|_|_d|_d|_d|_	d|_
d|_d|_d|_
d|_d|_i|_g|_dS�NF)rQrU�valid�fingerprint�
creation_date�	timestamp�signature_id�key_id�username�
key_status�status�pubkey_fingerprint�expire_timestamp�
sig_timestamp�
trust_text�trust_level�sig_info�problemsrSr
r
r
rUs
zVerify.__init__cC�|jSrB)ro�rTr
r
r
�__nonzero__%�zVerify.__nonzero__cs��fdd�}|�jvr!|�_�j|�_|�j�jd�d�_dS|dvr.t�d||�dS|dkr[d�_d�_|�dd	�\�_	�_
�j��j�j	�j
d
��|�j	�j
�jd�dS|dkr�d�_|��}|dd
�\�_	}}}�_
t|�dkr~|d�_d�_|�j	�j
�j�jd��j��j�j	�j
�jd��dS|dkr�d�_d�_|�dd	�\�_	�_
|�j	�j
�jd��j��j�j	�j
d
��dS|dkr�d�_d�_|�dd	�\�_	�_
|�j	�j
�jd�dS|dk�r)|��}|dd�\}}	}
}||	|
|f\�_�_�_�_t|�dk�r|d�_d�_|||	|
|�j�jd�dS|dk�rJ|��\}}	}
|	|
d��j|<||	|
�_�_�_
dS|d k�red�_|�_	d!�_�j��j�j	d"��dS|d#k�r�d�_|�_	d$�_�j��j�j	d"��dS|d%v�r�d�_|��d&�_	|d'k�r�d(�_nd)�_�j�_|�j�j	d"��j��j�j	d"��dS|d*v�r d�_|d+k�r�d,�_dSd-|}|�d.d	�\}}|���rt|�d/@}�jj�r�|�jjv�r�d0|�jj|f}n!t|d1@�}|d2@}|�r�j}n�j}||v�rd0|||f}�j�s|�_dSdS|d3k�r-d�_d4�_dS|d5v�r4dS|d6v�r>d�_dSt�d7||�dS)8Ncs2�j}|r�j|}|�|�dSt�d|�dS)Nz!Ignored due to missing sig iD: %s)rsr}�updater&r.)�kwargs�sig_id�infor�r
r
�update_sig_info,s

z-Verify.handle_status.<locals>.update_sig_info)r|r{��WARNING�ERROR�potential problem: %s: %sZBADSIGFz
signature badr)rw�keyid�user)r�rurwZERRSIGrc��zsignature error)r�rrrprw)rwr�rrrpZEXPSIGzsignature expiredZGOODSIGTzsignature goodZVALIDSIGrb�
�	zsignature valid)rprqrrZexpiryrxrwZSIG_ID)rqrrZ	NO_PUBKEYz
no public key)rwr�Z	NO_SECKEY�
no secret key)�	EXPKEYSIGZ	REVKEYSIGrr�zsigning key has expiredzsigning key was revoked)�
UNEXPECTED�FAILUREr�zunexpected dataz
error - %s� i����%s: %si�i��NODATAz signature expected but not found)ZDECRYPTION_INFOZ	PLAINTEXTZPLAINTEXT_LENGTH�
BEGIN_SIGNING�KEY_CONSIDERED)ZNEWSIGzmessage ignored: %r, %r)�TRUST_LEVELSr{r|rsr&r'rorw�splitrtrur~�appendrrr(rprqrzryrxr}rv�rsplit�isdigit�intrR�	error_map�bool�GPG_SYSTEM_ERROR_CODES�GPG_ERROR_CODESr.)rTrXrYr��parts�algo�	hash_algo�clsrprqZsig_tsZ	expire_tsr�rr�messageZ	operation�codeZsystem_error�mappingr
r�r
rZ*s�


��

�

�










�




zVerify.handle_status)r[r\r]r^rdrerfrgrhrir�r�r��
returncoderUr��__bool__rZr
r
r
r
r_�s6���r_c@sbeZdZdZd��ZdZdd�Zdd�ZeZ	dd	d
ddd
d�Z
dddddd�Zdd�Zdd�Z
dS)�ImportResultz?
    This class handles status messages during key import.
    z�count no_user_id imported imported_rsa unchanged n_uids n_subk n_sigs n_revoc sec_read sec_imported
            sec_dups not_importedNcCs4t�||�g|_g|_|jD]}t||d�qdS)Nr)rQrU�results�fingerprints�counts�setattr)rTrRrr
r
r
rU�s
�zImportResult.__init__cCst|jo|j�SrB)r��not_importedr�r�r
r
r
r��rIzImportResult.__nonzero__zNot actually changedzEntirely new keyzNew user IDszNew signatureszNew subkeyszContains private key)�0�1�2�4�8Z16zNo specific reason givenzInvalid CertificatezIssuer Certificate missingzCertificate Chain too longzError storing certificate)r�r�r��3r�cCs�|dvr
t�d||�dS|dvrdS|dkr#|j�dddd��dS|dkre|��\}}g}t|j���D]\}}t|�t|�Bt|�krK|�|�q6d	�	|�d	}|j�|||d
��|j
�|�dS|dkr�z|��\}}Wn
ty~|}d}Ynw|j�|||j|d��dS|d
kr�|��}	t
|j�D]\}
}t||t|	|
��q�dS|dkr�|j�dddd��dS|dkr�|j�dddd��dS|dkr�|j�dddd��dSt�d||�dS)Nr�r�)ZIMPORTEDr�r�r�zNo valid data found)rpZproblem�textZ	IMPORT_OK�
)rp�okr�ZIMPORT_PROBLEMz	<unknown>Z
IMPORT_RES�
KEYEXPIREDzKey expired�
SIGEXPIREDzSignature expiredr�z
Other failure�message ignored: %s, %s)r&r'r�r�r�rC�	ok_reason�itemsr��joinr�r%�problem_reason�	enumerater�r�r.)rTrXrY�reasonrpZreasonsr�r�Z
reasontextZ
import_res�i�countr
r
r
rZ�sH
���zImportResult.handle_statuscCs4g}|�d|j�|jr|�d|j�d�|�S)zi
        Return a summary indicating how many keys were imported and how many were not imported.
        z%d importedz%d not imported�, )r�Zimportedr�r�)rTrr
r
r
�summary�s

zImportResult.summary)r[r\r]r^r�r�r�rUr�r�r�r�rZr�r
r
r
r
r��s0��
�%r�z\\x([0-9a-f][0-9a-f])r��
����)z\nz\rz\fz\vz\bz\0c@seZdZdZdZdd�ZdS)�
SendResultz@
    This class handles status messages during key sending.
    NcCst�d||�dS)NzSendResult: %s: %s)r&r.rWr
r
r
rZrIzSendResult.handle_status)r[r\r]r^r�rZr
r
r
r
r�sr�cCs8t|�D]\}}|t|�kr||||<qd||<qdS)NZunavailable)r�r()r7Z
fieldnamesr8r��varr
r
r
�_set_fieldss

�r�c@sHeZdZdZdZd��ZdZdd�Zdd�Z	d	d
�Z
dd�Zd
d�ZdS)�
SearchKeysz?
    This class handles status messages during key search.
    rz#type keyid algo length date expiresNcCs"t�||�d|_g|_g|_dSrB)rQrU�curkeyr��uidsrSr
r
r
rU3�
zSearchKeys.__init__cCs&i}t||j|�g|d<g|d<|S)�Z
        Internal method used to update the instance from a `gpg` status message.
        r��sigs)r��FIELDS)rTr8rr
r
r
�
get_fields9s
zSearchKeys.get_fieldscCs|�|�|_}|�|�dS)r�N)r�r�r��rTr8r�r
r
r
�pubCszSearchKeys.pubcCsX||j}t�dd�|�}t��D]
\}}|�||�}q|jd�|�|j�|�dS)r�cSstt|�d�d��S)Nr�)�chrr��group)�mr
r
r
�<lambda>O�z SearchKeys.uid.<locals>.<lambda>r�N)	�	UID_INDEX�ESCAPE_PATTERN�sub�
BASIC_ESCAPESr�rr�r�r�)rTr8�uid�k�vr
r
r
r�Js
zSearchKeys.uidcCsdSrBr
rWr
r
r
rZUszSearchKeys.handle_status)
r[r\r]r^r�r�r�r�rUr�r�r�rZr
r
r
r
r�'s
r�csleZdZdZdZd��Z�fdd�Zdd�ZeZ	Z
dd	�Zd
d�Zdd
�Z
dd�Zdd�Zdd�Z�ZS)�ListKeysa�
    This class handles status messages during listing keys and signatures.

    Handle pub and uid (relating the latter to the former).

    We don't care about (info from GnuPG DETAILS file):

    crt = X.509 certificate
    crs = X.509 certificate and private key available
    uat = user attribute (same as user id except for field 10).
    sig = signature
    rev = revocation signature
    pkd = public key data (special field format, see below)
    grp = reserved for gpgsm
    rvk = revocation key
    r�z�type trust length algo keyid date expires dummy ownertrust uid sig cap issuer flag token hash curve compliance updated origin keygripcs tt|��|�d|_i|_dSrn)�superr�rU�	in_subkey�key_maprS��	__class__r
r
rUos
zListKeys.__init__cCsL|�|�|_}|dr|d�|d�|d=g|d<|�|�d|_dS)r�r�r��subkeysFN)r�r�r�r�r�r
r
r
rXts

zListKeys.keycCst|d}||jvr|jjrtd|��|js)||jd<|j�|�|j|j|<dS||jddd<|j|j|<dS)r�r�z$Unexpected fingerprint collision: %srpr����r`N)r�rR�check_fingerprint_collisions�
ValueErrorr�r�r�r�)rTr8�fpr
r
r
�fpr�s
zListKeys.fprcCs2|d}|js||jd<dS||jddd<dS)r�r�Zkeygripr�r�raN)r�r�)rTr8�grpr
r
r
r��szListKeys.grpcCs.|�di�}i}t||j|�|||d<dS)NZsubkey_inforb)�
setdefaultr�r�)rTr�r8Zinfo_mapr�r
r
r
�_collect_subkey_info�szListKeys._collect_subkey_infocC�<|d|dddg}|jd�|�|�|j|�d|_dS)r�rbrmNr�T�r�r�r�r��rTr8Zsubkeyr
r
r
r��s
zListKeys.subcCs8|ddddg}|jd�|�|�|j|�d|_dS)r�rbNr�Tr�r�r
r
r
�ssb�s
zListKeys.ssbcCs&|jd�|d|d|df�dS)r�r�rbr�r�N)r�r�)rTr8r
r
r
�sig�s&zListKeys.sig)r[r\r]r^r�r�r�rUrXr�Zsecr�r�r�r�r�r��
__classcell__r
r
r�r
r�Ys�
	r�c@seZdZdZdd�ZdS)�ScanKeyszB
    This class handles status messages during scanning keys.
    cCr�)r�rbr�Nr�Tr�r�r
r
r
r��s
zScanKeys.subN)r[r\r]r^r�r
r
r
r
r��sr�c@s,eZdZdd�ZereZdSeZdd�ZdS)�TextHandlercCs|j�|jj|jj�SrB)r4�decoderRr�
decode_errorsr�r
r
r
�_as_text�szTextHandler._as_textcCrrB)r4r�r
r
r
�__str__�r�zTextHandler.__str__N)r[r\r]rrrZ__unicode__r
r
r
r
r��sr�zno specific reason givenz	not foundzambiguous specificationzwrong key usage�key revoked�key expiredzno crl knownzcrl too oldzpolicy mismatchznot a secret keyzkey not trustedzmissing certificatezmissing issuer certificatezkey disabledzsyntax error in specification)rrr`rarbrcr�r��r�r�rm��
�cCsv|��}t|�dkr|dd�\}}n|d}d}d|}zt|�}t�||�}Wnty4|}Ynwd||fS)Nr`rz
<no ident>zunexpected return code %rz%s:%s)r�r(r��_INVALID_KEY_REASONS�getr�)rr�r��identZ
unexpectedrXrr
r
r
�&_determine_invalid_recipient_or_signer�s�r
c@s,eZdZdZdd�Zdd�ZeZdd�ZdS)	�CryptzN
    This class handles status messages during encryption and decryption.
    cCs.t�||�d|_d|_d|_d|_d|_dS)N�F)r_rUr4r�rw�
status_detailrtrSr
r
r
rUs
zCrypt.__init__cC�
t|j�SrB)r�r�r�r
r
r
r�
�
zCrypt.__nonzero__cCs�|dvr
t�d||�dS|dkr|jdvrd|_dSdS|dvr,|�dd���|_dS|d	kr<|jd
kr:d|_dSdS|dkrEd
|_dS|dkrU|jd
krSd|_dSdS|dkr^d|_dS|dkrjd|_d|_dS|dkrvd|_d|_dS|dkr�|js�d|_nd|j|_t|�|_dS|dkr�d|_dS|dkr�d|_dS|dkr�d|_dS|d kr�|�dd!�d"|_	dS|d#vr�dSt
�|||�dS)$Nr�r�r�)�decryption failedzno data was provided)�NEED_PASSPHRASE�BAD_PASSPHRASE�GOOD_PASSPHRASEZMISSING_PASSPHRASE�KEY_NOT_CREATEDZNEED_PASSPHRASE_PIN�_r��DECRYPTION_FAILEDr�rZNEED_PASSPHRASE_SYMzneed symmetric passphraseZBEGIN_DECRYPTIONzdecryption incompleteZBEGIN_ENCRYPTIONzencryption incompleteZDECRYPTION_OKAYz
decryption okTZEND_ENCRYPTIONz
encryption ok�INV_RECPzinvalid recipientzinvalid recipient: %sr�r�SIG_CREATEDzsig createdr�zsig expiredZENC_TOrr)�USERID_HINTZGOODMDCZEND_DECRYPTIONZCARDCTRLZBADMDCZ
SC_OP_FAILUREZ
SC_OP_SUCCESSZPINENTRY_LAUNCHED)r&r'rwr�lowerr�r
rr�rtr_rZrWr
r
r
rZsT

�

�


�





zCrypt.handle_statusN)r[r\r]r^rUr�r�rZr
r
r
r
rsrc@�8eZdZdZdZdd�Zdd�ZeZdd�Zd	d
�Z	dS)�GenKeyzC
    This class handles status messages during key generation.
    NcC�"t�||�d|_d|_d|_dS�Nr�rQrUrrprwrSr
r
r
rUHr�zGenKey.__init__cCrrB�r�rpr�r
r
r
r�NrzGenKey.__nonzero__cCrrB�rpr�r
r
r
rSr�zGenKey.__str__cCs�|dvr
t�d||�dS|dkr$|��}|dd�\|_|_d|_dS|dkr3|�dd���|_dS|d	vr9dSt�d
||�dS)Nr�r��KEY_CREATEDr`r�rrr�)ZPROGRESSrr�)	r&r'r�rrprwrrr.)rTrXrYr�r
r
r
rZVs
zGenKey.handle_status�
r[r\r]r^r�rUr�r�rrZr
r
r
r
rA�rc@r)�	AddSubkeyzD
    This class handles status messages during subkey addition.
    NcCr r!r"rSr
r
r
rUlr�zAddSubkey.__init__cCrrBr#r�r
r
r
r�rrzAddSubkey.__nonzero__cCrrBr$r�r
r
r
rwr�zAddSubkey.__str__cCsN|dvr
t�d||�dS|dkr|��\|_|_d|_dSt�d||�dS)Nr�r�r%r�r�)r&r'r�rrprwr.rWr
r
r
rZzs
zAddSubkey.handle_statusr&r
r
r
r
r(er'r(cs eZdZdZ�fdd�Z�ZS)�ExportResultz?
    This class handles status messages during key export.
    cs"|dvrdStt|��||�dS)N)ZEXPORTEDZ
EXPORT_RES)r�r)rZrWr�r
r
rZ�szExportResult.handle_status)r[r\r]r^rZr�r
r
r�r
r)�sr)c@sDeZdZdZdZdd�Zdd�Zddd	d
�Zdd�Zd
d�Z	e	Z
dS)�DeleteResultzA
    This class handles status messages during key deletion.
    NcCst�||�d|_dS�Nr�)rQrUrwrSr
r
r
rU�s
zDeleteResult.__init__cCrrB�rwr�r
r
r
r�r�zDeleteResult.__str__zNo such keyzMust delete secret key firstzAmbiguous specification)r�r�r�cCs2|dkr|j�|d|�|_dSt�d||�dS)NZDELETE_PROBLEMzUnknown error: %rr�)r�rrwr&r.rWr
r
r
rZ�szDeleteResult.handle_statuscCs
|jdkSr+r,r�r
r
r
r��rzDeleteResult.__nonzero__)r[r\r]r^r�rUrr�rZr�r�r
r
r
r
r*�s�r*c@seZdZdZdS)�TrustResultzF
    This class handles status messages during key trust setting.
    N)r[r\r]r^r
r
r
r
r-�sr-c@s0eZdZdZdZdd�Zdd�ZeZdd�ZdS)	�Signz<
    This class handles status messages during signing.
    NcCs:t�||�d|_d|_d|_d|_d|_d|_d|_dSrB)	rQrUrr�rprwrrtrurSr
r
r
rU�s
z
Sign.__init__cCs
|jduSrBr$r�r
r
r
r��rzSign.__nonzero__cCs�|dvr
t�d||�dS|dvrd|_dS|dkrd|_dS|dkr6|��\|_}|_}|_|_d|_dS|d	krF|�d
d�\|_|_	dS|dkrOd
|_dS|dvrg|jsZd|_nd|j|_t
|�|_dS|dvrmdSt�d||�dS)N)r�r�r�r�)r�r�rZ
KEYREVOKEDrrzsignature createdrr�rrzbad passphrase)ZINV_SGNRrzinvalid signerzinvalid signer: %s)rrr�r�)
r&r'rwr�rr�rrrprtrur
rr.)rTrXrYr�r�r
r
r
rZ�s*



zSign.handle_status)	r[r\r]r^r�rUr�r�rZr
r
r
r
r.�s
r.z^cfg:version:(\d+(\.\d+)*)rz
[0-9a-f]+$zgpg: public key is (\w+)c@s�eZdZdZdZdZdZeee	e
eee
eeeeeed�
Z									dZdd	�Zd
d�Zd[dd
�Zdd�Zd\dd�Zd]dd�Zdd�Zdd�Zd^dd�Zdd�Zdd�Zdd �Z 			!				d_d"d#�Z!d$d%�Z"d`d&d'�Z#dad(d)�Z$d]d*d+�Z%d,d-�Z&d.d/�Z'd0d1�Z(dbd2d3�Z)		!			!	dcd4d5�Z*d6d7�Z+d8d9�Z,ddd:d;�Z-d<d=�Z.d>d?�Z/dedAdB�Z0dCdD�Z1dEdF�Z2dfdJdK�Z3				!			dgdLdM�Z4dNdO�Z5dPdQ�Z6dhdRdS�Z7dTdU�Z8dadVdW�Z9dXdY�Z:dS)i�GPGzL
    This class provides a high-level programmatic interface for `gpg`.
    N�stricti@)
�crypt�delete�generate�	addSubkey�import�sendrC�scanr�sign�trust�verify�exportrRFc	Csz||_||_||_|rtj�|�std|��|r!t|t�r!|g}||_	|r.t|t�r.|g}||_
||_||_t|t
�r?|g}||_d|_d|_|rXtj�|j�sXt�|jd�z	|�ddg�}	Wntyvd|j}
t�|
�t|
��w|jd|�}|j|	||	jd	�|	jd
kr�td|	j|jf��t�|j�}|s�d|_nd�d
�}
t dd�|�!�d
�"|
�D��|_d|_#dS)a9Initialize a GPG process wrapper.

        Args:
            gpgbinary (str): A pathname for the GPG binary to use.

            gnupghome (str): A pathname to where we can find the public and private keyrings. The default is
                             whatever `gpg` defaults to.

            keyring (str|list): The name of alternative keyring file to use, or a list of such keyring files. If
                                specified, the default keyring is not used.

            options (list): A list of additional options to pass to the GPG binary.

            secret_keyring (str|list): The name of an alternative secret keyring file to use, or a list of such
                                       keyring files.

            env (dict): A dict of environment variables to be used for the GPG subprocess.
        z.gnupghome should be a directory (it isn't): %sNzlatin-1i�z
--list-config�
--with-colonsz1Unable to run gpg (%s) - it may not be available.r:�r#rzError invoking gpg: %s: %s�.rcS�g|]}t|��qSr
)r���.0rr
r
r
�
<listcomp>Tr�z GPG.__init__.<locals>.<listcomp>F)$�	gpgbinary�	gnupghome�env�os�path�isdirr�rr�keyring�secret_keyring�verbose�	use_agentrO�options�on_datar�makedirs�_open_subprocess�OSErrorr&r+�
result_map�_collect_outputr#r��stderr�
VERSION_RE�matchr4�versionrrD�groupsr�r�)rTrCrDrKrLrIrMrJrE�p�msgrr��dotr
r
r
rUsN




�

"
zGPG.__init__cCs|jddddg}dtjvr|�ddg�|r(t|d�r(|jd	kr(d
dg|dd�<|�gd
��|jr<|�dt|j�g�|jrS|�	d�|jD]}|�dt|�g�qG|j
re|j
D]}|�dt|�g�qY|rn|�ddg�|jrv|�	d�|jr|�|j�|�|�|S)aN
        Make a list of command line elements for GPG. The value of ``args``
        will be appended. The ``passphrase`` argument needs to be True if
        a passphrase will be sent to `gpg`, else False.

        Args:
            args (list[str]): A list of arguments.
            passphrase (str): The passphrase to use.
        z--status-fdr�z--no-ttyz--no-verboseZ	DEBUG_IPCz--debugZipcrW�r`rz--pinentry-modeZloopbackr)�--fixed-list-modez--batchr<z	--homedirz--no-default-keyringz	--keyringz--secret-keyringz--passphrase-fdr�z--use-agent)
rCrF�environ�extendr!rWrDrrIr�rJrLrM)rTr8r@�cmd�fnr
r
r
�	make_argsZs0







z
GPG.make_argsc	Csvddlm}|�||�}|jrt||��tsd}n	t�}t|_t|_	t
|dttt||jd�}t
�d|j||��|S)Nr)�list2cmdlineF)�shellr#�stdoutrT�startupinforEr�)�
subprocessrcrbrK�printrrZdwFlagsrZwShowWindowrrrEr&r.�pid)rTr8r@Zdebug_printr`�sirr
r
r
rP}szGPG._open_subprocesscCs�g}	|��}t|�dkrnB|�|�|��}|jrt|�t�d|�|dd�dkrO|dd�}|�dd�}|d}t|�dkrG|d}nd}|�	||�qd�
|�|_dS)NTrz%sr�z	[GNUPG:] rr)�readliner(r��rstriprKrhr&r.r�rZr�rT)rTr?r�lines�line�L�keywordrYr
r
r
�_read_response�s(

�zGPG._read_response�cCs�|dksJ�g}	|�|�}t|�dkr|r||�ntr(t�d|dd��d}|r2||�du}|r9|�|�q	trGt|���|�|_	dSd�|�|_	dS)NrTz	chunk: %r�Fr)
r$r(�log_everythingr&r.r�rrr�r4)rTr?rrNr1�chunksr4r�r
r
r
�
_read_data�s&

�
zGPG._read_datac
Cst�|j�|j�}tj|j||fd�}d|_t�	d|�|�
�|j}tj|j|||j
|jfd�}d|_t�	d|�|�
�|��|��|durO|�d�|��|j|_}	|	dkrct�d|	�|durwz|��Wn	tyvYnw|��|��|	S)	a
        Drain the subprocesses output streams, writing the collected output to the result. If a writer thread (writing
        to the subprocess) is given, make sure it's joined before returning. If a stdin stream is given, close it
        before returning.
        r6Tzstderr reader: %rzstdout reader: %rN�{�G�z�?rz&gpg returned a non-zero error code: %d)�codecs�	getreaderrrTr9r:rqr;r&r.r<rervrNr1r��waitr�r'r,r-)
rT�processr�writerr#rTZrrreZdr�rcr
r
r
rS�s6
�zGPG._collect_outputcCs
t|d�S)z�
        A simplistic check for a file-like object.

        Args:
            fileobj (object): The object to test.
        Returns:
            bool: ``True`` if it's a file-like object, else ``False``.
        r$)r!)rT�fileobjr
r
r
�
is_valid_file�s
	zGPG.is_valid_filecCsN|�|�r	|}|St|t�std|��tj�|�s td|��t|d�}|S)NzNot a valid file or path: %szNo such file: %s�rb)	rr�
path_typesrrFrG�existsr��open)rT�fileobj_or_pathrr
r
r
�_get_fileobj�s

�
zGPG._get_fileobjc
	Cs�|�|�}z@|�||du�}|st�|j�|j�}n|j}|r&t|||j�t|||j�}	|�	|||	|�|W|	�
d�||urE|��SS|	�
d�||urT|��ww)z;Handle a call to GPG - pass input data, collect output dataNrw)r�rPrx�	getwriterrr#rAr>r1rSr�r,)
rTr8r�rr@�binaryr~rYr#r|r
r
r
�
_handle_io�s&


�
�
�zGPG._handle_iocK�*t||j�}|j|fi|��}|��|S)a�
        Sign a message. This method delegates most of the work to the `sign_file()` method.

        Args:
            message (str|bytes): The data to sign.
            kwargs (dict): Keyword arguments, which are passed to `sign_file()`:

                * keyid (str): The key id of the signer.

                * passphrase (str): The passphrase for the key.

                * clearsign (bool): Whether to use clear signing.

                * detach (bool): Whether to produce a detached signature.

                * binary (bool): Whether to produce a binary signature.

                * output (str): The path to write a detached signature to.

                * extra_args (list[str]): Additional arguments to pass to `gpg`.
        )rPr�	sign_filer,)rTr�r��frr
r
r
r8szGPG.signcCs.tj�|�r|�dg�|�dt|�g�dS)a:
        If writing to a file which exists, avoid a confirmation message by
        updating the *args* value in place to set the output path and avoid
        any cpmfirmation prompt.

        Args:
            args (list[str]): A list of arguments.
            output (str): The path to the outpur file.
        �--yesz--outputN)rFrGr�r_r)rTr8�outputr
r
r
�set_output_without_confirmation0s
z#GPG.set_output_without_confirmationcCsd|vod|vod|vS)a�
        Confirm that the passphrase doesn't contain newline-type characters - it is passed in a pipe to `gpg`,
        and so not checking could lead to spoofing attacks by passing arbitrary text after passphrase and newline.

        Args:
            passphrase (str): The passphrase to test.

        Returns:
            bool: ``True`` if it's a valid passphrase, else ``False``.
        r�r�r�r
)rTr@r
r
r
�is_valid_passphrase?szGPG.is_valid_passphraseTc		CsT|r|�|�std��t�d|�|rdg}	ndg}	|r"|	�d�n|r)|	�d�|r4|	�dt|�g�|r<|�|	|�|rC|	�|�|jd|�}
|�	|�}|�
|	|d	u�}z7z|j}
|ret|
||j
�t||
|j�}Wnty}t�d
�d	}YnwW|r�|�d�||ur�|��n|r�|�d�||ur�|��ww|�||
||
�|
S)a]
        Sign data in a file or file-like object.

        Args:
            fileobj_or_path (str|file): The file or file-like object to sign.

            keyid (str): The key id of the signer.

            passphrase (str): The passphrase for the key.

            clearsign (bool): Whether to use clear signing.

            detach (bool): Whether to produce a detached signature.

            binary (bool): Whether to produce a binary signature.

            output (str): The path to write a detached signature to.

            extra_args (list[str]): Additional arguments to pass to `gpg`.
        �Invalid passphrasez
sign_file: %sz-sz-saz
--detach-signz--clearsign�
--default-keyr8Nzerror writing messagerw)r�r�r&r.r�r_rr�rRr�rPr#rArr>r1r-�loggingr+r�r,rS)rTr�r�r@Z	clearsign�detachr�r��
extra_argsr8rr~rYr#r|r
r
r
r�LsR



��
��

�z
GPG.sign_filecKr�)a�
        Verify the signature on the contents of the string *data*. This method delegates most of the work to
        `verify_file()`.

        Args:
            data (str|bytes): The data to verify.
            kwargs (dict): Keyword arguments, which are passed to `verify_file()`:

                * fileobj_or_path (str|file): A path to a signature, or a file-like object containing one.

                * data_filename (str): If the signature is a detached one, the path to the data that was signed.

                * close_file (bool): If a file-like object is passed in, whether to close it.

                * extra_args (list[str]): Additional arguments to pass to `gpg`.
        )rPr�verify_filer,)rTr4r�r�rr
r
r
r:�sz
GPG.verifyc	Cs�t�d||�|jd|�}dg}|r|�|�|dur'|j|||dd�|St�d�ddl}|jd	d
�\}}	|��}
|rB|��t�d|
�t	�
||
�t	�|�|�t|	��|�t|��z|�
|�}|j|||jd�Wt	�|	�|St	�|	�w)
a�
        Verify a signature.

        Args:
            fileobj_or_path (str|file): A path to a signature, or a file-like object containing one.

            data_filename (str): If the signature is a detached one, the path to the data that was signed.

            close_file (bool): If a file-like object is passed in, whether to close it.

            extra_args (list[str]): Additional arguments to pass to `gpg`.
        zverify_file: %r, %rr:�--verifyNT�r�zHandling detached verificationr�pygpg-��prefixzWrote to temp file: %rr=)r&r.rRr_r��tempfile�mkstempr$r,rFr)r�rrPrSr#�remove)rTr�Z
data_filenameZ
close_filer�rr8r��fdrarrYr
r
r
r��s2


�


�zGPG.verify_filecCsht�d||dd��|jd|�}dg}|r|�|�|�t|�dg�t|�}|j|||dd�|S)	a
        Verify the signature in sig_filename against data in memory

        Args:
            sig_filename (str): The path to a signature.

            data (str|bytes): The data to be verified.

            extra_args (list[str]): Additional arguments to pass to `gpg`.
        zverify_data: %r, %r ...Nr�r:r��-Tr�)r&r.rRr_rrNr�)rTZsig_filenamer4r�rr8r?r
r
r
�verify_data�s
zGPG.verify_datacCsp|jd|�}t�d|dd��t||j�}dg}|r!|�|�|j||||dd�t�d|j�|��|S)	a
        Import the key_data into our keyring.

        Args:
            key_data (str|bytes): The key data to import.

            passphrase (str): The passphrase to use.

            extra_args (list[str]): Additional arguments to pass to `gpg`.
        r5zimport_keys: %rNrs�--importT�r@r�zimport_keys result: %r)	rRr&r.rPrr_r��__dict__r,)rT�key_datar�r@rr4r8r
r
r
�import_keys�s
zGPG.import_keyscKsDt|d��}|j|��fi|��Wd�S1swYdS)z�
        Import the key data in key_path into our keyring.

        Args:
            key_path (str): A path to the key data to be imported.
        r�N)r�r�r$)rTZkey_pathr�r�r
r
r
�import_keys_file�s$�zGPG.import_keys_filecO�|jd|�}t�d|�td|j�}dt|�g}d|vr$|�|d�|�d�|�dd�|D��|j|||d	d
�t�d|j	�|�
�|S)z�
        Import one or more keys from a keyserver.

        Args:
            keyserver (str): The key server hostname.

            keyids (str): A list of key ids to receive.
        r5z
recv_keys: %rr�--keyserverr�z--recv-keyscSr?r
�r�rAr�r
r
r
rBr�z!GPG.recv_keys.<locals>.<listcomp>Tr�zrecv_keys result: %r�rRr&r.rPrrr_r�r�r�r,�rT�	keyserver�keyidsr�rr4r8r
r
r
�	recv_keys	s	
z
GPG.recv_keyscOr�)z�
        Send one or more keys to a keyserver.

        Args:
            keyserver (str): The key server hostname.

            keyids (list[str]): A list of key ids to send.
        r6z
send_keys: %rrr�r�z--send-keyscSr?r
r�r�r
r
r
rB5r�z!GPG.send_keys.<locals>.<listcomp>Tr�zsend_keys result: %rr�r�r
r
r
�	send_keys!s

z
GPG.send_keyscCs|r|�|�std��d}|r |jdkr|dur|rtd��d}t|�r,dd�|D�}nt|�g}|r:d	d�|D�}d
|g}|rL|jdkrL|�dd�|�|�|jd
|�}|r_|jdkro|�|�}	|j	|	||	j
d�|Std|j�}
z|j
||
||dd�W|
��|S|
��w)a9
        Delete the indicated keys.

        Args:
            fingerprints (str|list[str]): The keys to delete.

            secret (bool): Whether to delete secret keys.

            passphrase (str): The passphrase to use.

            expect_passphrase (bool): Whether a passphrase is expected.

            exclamation_mode (bool): If specified, a `'!'` is appended to each fingerprint. This deletes only a subkey
                                     or an entire key, depending on what the fingerprint refers to.

        .. note:: Passphrases

           Since GnuPG 2.1, you can't delete secret keys without providing a passphrase. However, if you're expecting
           the passphrase to go to `gpg` via pinentry, you should specify expect_passphrase=False. (It's only checked
           for GnuPG >= 2.1).
        r�rXr\NzHFor GnuPG >= 2.1, deleting secret keys needs a passphrase to be providedz
secret-keycSr?r
r�r@r
r
r
rBZr�z#GPG.delete_keys.<locals>.<listcomp>cSsg|]}|d�qS)�!r
)rAr�r
r
r
rB_r�z--delete-%srr�r2r=rTr�)r�r�rWrHr�insertr_rRrPrSr#rPrr�r,)rTr��secretr@�expect_passphraseZexclamation_mode�whichr8rrYr�r
r
r
�delete_keys;s6



�
�zGPG.delete_keysc
CsL|r|�|�std��d}|r d}|jdkr |dur |r td��t|�r,dd�|D�}nt|�g}d	|g}	|r=|	�d
�|rF|	�ddg�|rN|�|	|�|	�|�|jd
|�}
|ra|jdkrp|�	|	�}|j
||
|jd�ntd|j
�}z|j|	||
|dd�W|��n|��wt�d|
jdd��|
j}
|r�|
�|j
|j�}
|
S)at
        Export the indicated keys. A 'keyid' is anything `gpg` accepts.

        Args:
            keyids (str|list[str]): A single keyid or a list of them.

            secret (bool): Whether to export secret keys.

            armor (bool): Whether to ASCII-armor the output.

            minimal (bool): Whether to pass `--export-options export-minimal` to `gpg`.

            passphrase (str): The passphrase to use.

            expect_passphrase (bool): Whether a passphrase is expected.

            output (str): If specified, the path to write the exported key(s) to.

        .. note:: Passphrases

           Since GnuPG 2.1, you can't export secret keys without providing a passphrase. However, if you're expecting
           the passphrase to go to `gpg` via pinentry, you should specify expect_passphrase=False. (It's only checked
           for GnuPG >= 2.1).
        r�rz-secret-keyr\NzIFor GnuPG >= 2.1, exporting secret keys needs a passphrase to be providedcSr?r
r�r�r
r
r
rB�r�z#GPG.export_keys.<locals>.<listcomp>z
--export%s�--armorz--export-optionszexport-minimalr;r=Tr�zexport_keys result[:100]: %r�d)r�r�rWrHrr�r_r�rRrPrSr#rPrr�r,r&r.r4rr)
rTr�r��armorZminimalr@r�r�r�r8rrYr�r
r
r
�export_keysrs> 




zGPG.export_keyscCs�|j�|j|j���}d��}|D]/}|jrt|�t�	d|�
��|s'|S|���d�}|s1q|d}||vr@t||�|�q|S)Nzpub uid sec fpr sub ssb sig grp�line: %r�:r)
r4rrr�
splitlinesr�rKrhr&r.rl�strip�getattr)rTrrm�valid_keywordsrnrorpr
r
r
�_decode_result�s"��zGPG._decode_resultcCs*|j||�}|j|||jd�|�|�S)Nr=)rRrSr#r�)rTrY�kindrr
r
r
�_get_list_output�s
zGPG._get_list_outputcCsl|rd}n|r	dnd}d|ddg}|jdkr|�d�|r+t|t�r&|g}|�|�|�|�}|�|d�S)	aZ
        List the keys currently in the keyring.

        Args:
            secret (bool): Whether to list secret keys.

            keys (str|list[str]): A list of key ids to match.

            sigs (bool): Whether to include signature information.

        Returns:
            list[dict]: A list of dictionaries with key information.
        zsecret-keysr��keysz	--list-%s�
--fingerprintr\z--with-keygriprC)rWr�rrr_rPr�)rTr�r�r�r�r8rYr
r
r
�	list_keys�s




z
GPG.list_keyscCsJ|jdkr
gd�}n	t�d�gd�}|�t|��|�|�}|�|d�S)a
        List details of an ascii armored or binary key file without first importing it to the local keyring.

        Args:
            filename (str): The path to the file containing the key(s).

        .. warning:: Warning:
            Care is needed. The function works on modern GnuPG by running:

                $ gpg --dry-run --import-options import-show --import filename

            On older versions, it does the *much* riskier:

                $ gpg --with-fingerprint --with-colons filename
        r\�z	--dry-runz--import-optionszimport-showr��TTrying to list packets, but if the file is not a keyring, might accidentally decrypt�z--with-fingerprintr<r]r7)rWr&r'r�rrPr�)rT�filenamer8rYr
r
r
�	scan_keys�s



z
GPG.scan_keyscCs�|jd|�}t�d|dd��t||j�}|jdkr!gd�}n	t�d�gd�}|j|||d	d
�t�d|j�|�	�|�
|�S)a�
        List details of an ascii armored or binary key without first importing it to the local keyring.

        Args:
            key_data (str|bytes): The key data to import.

        .. warning:: Warning:
            Care is needed. The function works on modern GnuPG by running:

                $ gpg --dry-run --import-options import-show --import filename

            On older versions, it does the *much* riskier:

                $ gpg --with-fingerprint --with-colons filename
        r7z
scan_keys: %rNrsr\r�r�r�Tr�zscan_keys result: %r)rRr&r.rPrrWr'r�r�r,r�)rTr�rr4r8r
r
r
�
scan_keys_mems



zGPG.scan_keys_mem�pgp.mit.educCs�|��}t�|�r
d|}ddt|�g}|r|�|�|�dt|�g�|�|�}|jd|�}|j|||jd�|j	�
|j|j��
�}ddg}|D]-}	|jrSt|	�t�d	|	���|	s^qJ|	���d
�}
|
shqJ|
d}||vrwt||�|
�qJ|S)a

        search a keyserver by query (using the `--search-keys` option).

        Args:
            query(str): The query to use.

            keyserver (str): The key server hostname.

            extra_args (list[str]): Additional arguments to pass to `gpg`.
        �0xr�r�z
--search-keysrr=r�r�r�r�r)r��
HEX_DIGITS_RErVrr_rPrRrSr#r4rrrr�rKrhr&r.rlr�r�)rT�queryr�r�r8rYrrmr�rnrorpr
r
r
�search_keys)s4


�zGPG.search_keyscCs>dg}|jd|�}t||j�}|j|||dd�|��|S)z�
        Generate a key; you might use `gen_key_input()` to create the input.

        Args:
            input (str): The input to the key creation operation.
        z	--gen-keyr3Tr�)rRrPrr�r,)rT�inputr8rr�r
r
r
�gen_keyPszGPG.gen_keyc	Ksi}|�dd�}t|���D]\}}|�dd���}t|���r$|||<q|�dd�d|vr5|�dd	�|�d
d�tj	�
d�pHtj	�
d
�pHd}t��}|�dd|�dd�|f�d|�d�}t|���D]\}}|d||f7}qh|r{|d7}|d7}|S)z�
        Generate `--gen-key` input  (see `gpg` documentation in DETAILS).

        Args:
            kwargs (dict): A list of keyword arguments.
        Returns:
            str: A string suitable for passing to the `gen_key()` method.
        �
no_protectionFrr�zKey-TypeZRSAZ	key_curvez
Key-Lengthiz	Name-RealzAutogenerated KeyZLOGNAME�USERNAME�unspecifiedz
Name-Emailz%s@%sr�z
Key-Type: %s
z%s: %s
z%no-protection
z%commit
)
�poprCr�r�titlerOr�r�rFr^r�socket�gethostname)	rTr�Zparmsr�rX�valZlogname�hostname�outr
r
r
�
gen_key_input^s*
�zGPG.gen_key_input�rsa�encryptr�c	Cs||jddkrtd��|std��|r|�|�std��d|||t|�g}|jd|�}td|j�}|j||||d	d
�|S)ae
        Add subkeys to a master key,

        Args:
            master_key (str): The master key.

            master_passphrase (str): The passphrase for the master key.

            algorithm (str): The key algorithm to use.

            usage (str): The desired uses for the subkey.

            expire (str): The expiration date of the subkey.
        rr`zNot available in GnuPG 1.xz#No master key fingerprint specifiedr�z--quick-add-keyr4rTr�)	rWrVr�r�rOrRrPrr�)	rTZ
master_keyZmaster_passphrase�	algorithm�usageZexpirer8rr�r
r
r
�
add_subkey�szGPG.add_subkeyc

Cs|r|�|�std��dg}
|r!dg}
|dur |
�dt|�g�n|s'td��t|�s.|f}|D]}|
�dt|�g�q0|rC|
�d�|rK|�|
|�|durU|
�d	�n|ra|
�d	d
t|�g�|rj|
�ddg�|	rq|
�|	�|jd
|�}|j|
|||dd�t	�
d|jdd��|S)a*
        Encrypt data in a file or file-like object.

        Args:
            fileobj_or_path (str|file): A path to a file or a file-like object containing the data to be encrypted.

            recipients (str|list): A key id of a recipient of the encrypted data, or a list of such key ids.

            sign (str): If specified, the key id of a signer to sign the encrypted data.

            always_trust (bool): Whether to always trust keys.

            passphrase (str): The passphrase to use for a signature.

            armor (bool): Whether to ASCII-armor the output.

            output (str): A path to write the encrypted output to.

            symmetric (bool): Whether to use symmetric encryption,

            extra_args (list[str]): A list of additional arguments to pass to `gpg`.
        r�z	--encryptz--symmetricTz
--cipher-algoz2No recipients specified with asymmetric encryptionz--recipientr�z--signr��
--trust-model�alwaysr1r�zencrypt result[:100]: %rNr�)r�r�r_rrHr�r�rRr�r&r.r4)
rTr��
recipientsr8�always_trustr@r�r�Z	symmetricr�r8Z	recipientrr
r
r
�encrypt_file�s< �

zGPG.encrypt_filecKs,t||j�}|j||fi|��}|��|S)a�
        Encrypt the message contained in the string *data* for *recipients*. This method delegates most of the work to
        `encrypt_file()`.

        Args:
            data (str|bytes): The data to encrypt.

            recipients (str|list[str]): A key id of a recipient of the encrypted data, or a list of such key ids.

            kwargs (dict): Keyword arguments, which are passed to `encrypt_file()`:
                * sign (str): If specified, the key id of a signer to sign the encrypted data.

                * always_trust (bool): Whether to always trust keys.

                * passphrase (str): The passphrase to use for a signature.

                * armor (bool): Whether to ASCII-armor the output.

                * output (str): A path to write the encrypted output to.

                * symmetric (bool): Whether to use symmetric encryption,

                * extra_args (list[str]): A list of additional arguments to pass to `gpg`.
        )rPrr�r,)rTr4r�r�rr
r
r
r��szGPG.encryptcKr�)ac
        Decrypt the data in *message*. This method delegates most of the work to
        `decrypt_file()`.

        Args:
            message (str|bytes): The data to decrypt. A default key will be used for decryption.

            kwargs (dict): Keyword arguments, which are passed to `decrypt_file()`:

                * always_trust: Whether to always trust keys.

                * passphrase (str): The passphrase to use.

                * output (str): If specified, the path to write the decrypted data to.

                * extra_args (list[str]): A list of extra arguments to pass to `gpg`.
        )rPr�decrypt_filer,�rTr�r�r4rr
r
r
�decryptszGPG.decryptcCs�|r|�|�std��dg}|r|�||�|r|�ddg�|r&|�|�|jd|�}|j||||dd�t�d|jd	d
��|S)a�
        Decrypt data in a file or file-like object.

        Args:
            fileobj_or_path (str|file): A path to a file or a file-like object containing the data to be decrypted.

            always_trust: Whether to always trust keys.

            passphrase (str): The passphrase to use.

            output (str): If specified, the path to write the decrypted data to.

            extra_args (list[str]): A list of extra arguments to pass to `gpg`.
        r��	--decryptr�r�r1Tr�zdecrypt result[:100]: %rNr�)	r�r�r�r_rRr�r&r.r4)rTr�r�r@r�r�r8rr
r
r
r�/s
zGPG.decrypt_filecKr�)a� Get the list of recipients for an encrypted message. This method delegates most of the work to
        `get_recipients_file()`.

        Args:
            message (str|bytes): The encrypted message.

            kwargs (dict): Keyword arguments, which are passed to `get_recipients_file()`:

                * extra_args (list[str]): A list of extra arguments to pass to `gpg`.
        )rPr�get_recipients_filer,r�r
r
r
�get_recipientsMszGPG.get_recipientscCs`gd�}|r|�|�|jd|�}|j|||dd�g}t�|j�D]
}|�|�d��q#|S)a0
        Get the list of recipients for an encrypted message in a file or file-like object.

        Args:
            fileobj_or_path (str|file): A path to a file or file-like object containing the encrypted data.

            extra_args (list[str]): A list of extra arguments to pass to `gpg`.
        )r�z--list-onlyz-vr1Tr�r)r_rRr��
PUBLIC_KEY_RE�finditerrTr�r�)rTr�r�r8rZidsr�r
r
r
r�]s	
zGPG.get_recipients_filec
	Cs tj}||vrd�t|��}td||f��||d}ddl}zi|jdd�\}}g}t|t�r3|g}|D]}	|�	d|	|f�q5t
j�|�t
j}
t�
d	|
�t
�||
�|j��t
�|�|jd
|�}|�d|g�}|j|||jd�|jdkr�td
|j��Wt
�|�|St
�|�w)aY
        Set the trust level for one or more keys.

        Args:
            fingerprints (str|list[str]): A key id for which to set the trust level, or a list of such key ids.

            trustlevel (str): The trust level. This is one of the following.

                                  * ``'TRUST_EXPIRED'``
                                  * ``'TRUST_UNDEFINED'``
                                  * ``'TRUST_NEVER'``
                                  * ``'TRUST_MARGINAL'``
                                  * ``'TRUST_FULLY'``
                                  * ``'TRUST_ULTIMATE'``
        r�z-Invalid trust level: "%s" (must be one of %s)rrNr�r�z%s:%s:zwriting ownertrust info: %sr9z--import-ownertrustr=z&gpg returned an error - return code %d)r_r�r��sortedr�r�r�rrr�rF�linesepr&r.r)rrr,rRrPrSr#r�r�)
rTr�Z
trustlevelZlevelsZpossr�r�rarmr�rrrYr
r
r
�
trust_keysps4


�
�zGPG.trust_keys)rRNFFNNNN)F)Nrr)NNrn)NNTFFNN)NTNrB)FNTF)FTFNTN)FNF)r�N)Nr�r�r�)NFNTNFN)FNNN);r[r\r]r^r�rr1rr*rr(r�r�r�r�r�r.r-r_r)rRrUrbrPrqrvrSrr�r�r8r�r�r�r:r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r
r
r
r
r/�s��
�O
#

#

�G

'


9
�I

'
5&
�D

r/)Nr^rxrKrr�rF�rer�rgrrr"r9�__version__�
__author__�__date__r�namerrrLZunicoderZ
basestringrr�bytesrOr��	NameError�	getLoggerr[r&�handlers�
addHandler�NullHandlerrtrGr�compiler�getfilesystemencodingrrr5r>rArHrNrP�objectrQr_r��Ir�r�r�r�rCr�r�r�r�r
r
rrr(r)r*r-r.rrUr�r�r/r
r
r
r
�<module>s�#
�
�


!	$		
CW�
2e�A$ 1

⬇️ Download Raw📂 Browse Directory💻 Shell