HEX

File: //usr/lib/python3/dist-packages/gpg/__pycache__/core.cpython-310.pyc
o

]��`��@sddlmZmZmZddlZddlZddlZddlZddlm	Z	ddl
mZmZddlm
Z
ddlm
Z
ddlmZ[[[	Gd	d
�d
e�ZGdd�de�ZGd
d�de�Zdd�Zdd�Zdd�Zdd�Zdd�Zd%dd�Ze�dd�Zdd�Zd%dd �Zd!d"�Zd#d$�ZdS)&�)�absolute_import�print_function�unicode_literalsN�)�gpgme)�
errorcheck�
GPGMEError)�	constants)�errors)�utilcs�eZdZdZdd�Z�fdd�Zdd�Zdd	�Zd
d�Ze	dd
��Z
e	dd��Zdd�Z	e
�Zddd�Ze�d�Zdd�Z�fdd�Z�ZS)�GpgmeWrapperz>Base wrapper class

    Not to be instantiated directly.

    cCsd|_||_dS�N)�_callback_excinfo�wrapped)�selfr�r�*/usr/lib/python3/dist-packages/gpg/core.py�__init__3s
zGpgmeWrapper.__init__csd�tt|���|j�S)Nz	<{}/{!r}>)�format�superr�__repr__r�r��	__class__rrr7s�zGpgmeWrapper.__repr__csPd�t�jj�g}�fdd��jD�}|r |�d�d�|���d�d�|��S)Nz{}.{}csg|]	}t�|�r|�qSr)�getattr��.0�frrr�
<listcomp>=�z(GpgmeWrapper.__str__.<locals>.<listcomp>z({})� z<{}>)r�__name__r�_boolean_properties�append�join)r�acc�flagsrrr�__str__;s
zGpgmeWrapper.__str__cCstt|j��Sr
)�hash�reprrrrrr�__hash__C�zGpgmeWrapper.__hash__cCs |durdSt|j�t|j�kS)NF)r)r)r�otherrrr�__eq__FszGpgmeWrapper.__eq__cC�t��)z]The name of the c type wrapped by this class

        Must be set by child classes.

        ��NotImplementedErrorrrrr�_ctypeL�zGpgmeWrapper._ctypecCr.)zgThe common prefix of c functions wrapped by this class

        Must be set by child classes.

        r/rrrr�_cprefixUr2zGpgmeWrapper._cprefixcCr.)z�Must be implemented by child classes.

        This function must return a trueish value for all c functions
        returning gpgme_error_t.r/�r�namerrr�_errorcheck^szGpgmeWrapper._errorcheckFNcs�ttd�|j|���ttd�|j|����fdd�}�fdd�}t||d�|�d�}t|j||�|r<||t|��dS||�S)	Nz{}get_{}z{}set_{}cst�|j��Sr
)�boolr)�slf)�get_funcrr�getlr+z1GpgmeWrapper.__wrap_boolean_property.<locals>.getcs�|jt|��dSr
)rr7)r8�value)�set_funcrr�set_osz2GpgmeWrapper.__wrap_boolean_property.<locals>.set_z{} flag)�doc)rrrr3�property�setattrrr7)r�key�do_setr;r:r=�pr)r9r<r�__wrap_boolean_propertyhsz$GpgmeWrapper.__wrap_boolean_propertyz$gpgme_([^(]*)\(([^,]*), (.*\) -> .*)cs�|ddks�jdur
dS|�jvr��|�S�j|�tt�������r.��fdd��n�fdd��t�d�}|rC�j�d|�}nd}|�_t	�j
|����fd	d
�}||_|S)z7On-the-fly generation of wrapper methods and propertiesr�_Ncs,�|jg|�R�}|jrt�|�t|��Sr
)rrr�gpg_raise_callback_exceptionr�r8�args�result)�funcr5rr�	_funcwrap�s

z+GpgmeWrapper.__getattr__.<locals>._funcwrapcs&�|jg|�R�}|jrt�|�|Sr
)rrrrFrG)rJrrrK�s
�__doc__z\2.\1(\3cs��g|�R�Sr
r)rH)rKrrr�wrapper�sz)GpgmeWrapper.__getattr__.<locals>.wrapper)r3r"�$_GpgmeWrapper__wrap_boolean_propertyrrr6�_munge_docstring�subrLr@r)rrA�doc_origr>rMr)rKrJr5rr�__getattr__|s$





zGpgmeWrapper.__getattr__cs2||jvr|�|d|�dStt|��||�dS)z#On-the-fly generation of propertiesTN)r"rNrr�__setattr__)rrAr;rrrrS�s
zGpgmeWrapper.__setattr__)FN)r!�
__module__�__qualname__rLrrr'r*r-r?r1r3r6�setr"rN�re�compilerOrRrS�
__classcell__rrrrr,s$



-rc	s`eZdZdZdddgejejddf�fdd�	Zdd�Zdd	�Z	gd
ddddddd
f	dd�Z
ded
d�Zdejfdd�Z
ddgfdd�Zdd�Zdfdd�Zdfdd�Zdfdd�Zddejjjdfdd�Z			
						dgdd�Z			
				dhd d!�Zd"d#�Zd$d%�Zdid&d'�Zd(d)�Z			djd*d+�Zdkd,d-�Zed.d/��Zej d0d/��Zed1d2��Z!e!j d3d2��Z!ed4d5��Z"e"j d6d5��Z"ed7d8��Z#e#j d9d8��Z#d:Z$d;Z%d<d=�Z&hd>�Z'd?d@�Z(dAdB�Z)dCdD�Z*dEdF�Z+dGdH�Z,dldIdJ�Z-dKdL�Z.dMdN�Z/dfdOdP�Z0dQdR�Z1dfdSdT�Z2dUdV�Z3dfdWdX�Z4dYdZ�Z5ed[d\��Z6d]d^�Z7dmd_d`�Z8dadb�Z9dcdd�Z:�Z;S)n�ContextaContext for cryptographic operations

    All cryptographic operations in GPGME are performed within a
    context, which contains the internal state of the operation as
    well as configuration parameters.  By using several contexts you
    can run several cryptographic operations in parallel, with
    different configuration.

    Access to a context must be synchronized.

    FNc	
sz|rd|_nt��}	tt�|	��t�|	�}t�|	�d|_tt|��	|�||_
||_||_||_
||_||_||_dS)aConstruct a context object

        Keyword arguments:
        armor		-- enable ASCII armoring (default False)
        textmode	-- enable canonical text mode (default False)
        offline		-- do not contact external key sources (default False)
        signers		-- list of keys used for signing (default [])
        pinentry_mode	-- pinentry mode (default PINENTRY_MODE_DEFAULT)
        protocol	-- protocol to use (default PROTOCOL_OpenPGP)
        home_dir        -- state directory (default is the engine default)

        FTN)�ownr�new_gpgme_ctx_t_pr�	gpgme_new�gpgme_ctx_t_p_value�delete_gpgme_ctx_t_prrZr�armor�textmode�offline�signers�
pinentry_mode�protocol�home_dir)
rr`rarbrcrdrerrf�tmprrrr�s


zContext.__init__cCs&|s|durdS|�dtj�|��S)zxRead helper

        Helper function to retrieve the results of an operation, or
        None if SINK is given.
        Nr)�seek�os�SEEK_SET�read)r�sink�datarrr�__read__�szContext.__read__cCs
d�|�S)Nz�Context(armor={0.armor}, textmode={0.textmode}, offline={0.offline}, signers={0.signers}, pinentry_mode={0.pinentry_mode}, protocol={0.protocol}, home_dir={0.home_dir}))rrrrrr�s�zContext.__repr__Tc
s�|r|nt�}d}||tjO}||tjO}||tjO}||	tjO}||
tjO}�durK|j}
t|dd�}tj	|_d�fdd�	}|�
|�z}z|rX|�||||�n|�||||�WnSt
jy�}zF|��}|rt|��nd}|�||�||f}|��t
jkr�|jr�t
j|j|j|d��|��t
jkr�|��}|jr�t
j|j|j|d��||_|�d}~wwW�dur�|
|_|r�|j
|dd��n�dur�|
|_|r�|j
|dd��www|��}|jr�J�|r�|��nd}|r�|jr�J�|�||�||fS)	a%Encrypt data

        Encrypt the given plaintext for the given recipients.  If the
        list of recipients is empty, the data is encrypted
        symmetrically with a passphrase.

        The passphrase can be given as parameter, using a callback
        registered at the context, or out-of-band via pinentry.

        Keyword arguments:
        recipients	-- list of keys to encrypt to
        sign		-- sign plaintext (default True)
        sink		-- write result to sink instead of returning it
        passphrase	-- for symmetric encryption
        always_trust	-- always trust the keys (default False)
        add_encrypt_to	-- encrypt to configured additional keys (default False)
        prepare		-- (ui) prepare for encryption (default False)
        expect_sign	-- (ui) prepare for signing (default False)
        compress	-- compress plaintext (default True)

        Returns:
        ciphertext	-- the encrypted data (or None if sink is given)
        result		-- additional information about the encryption
        sign_result	-- additional information about the signature(s)

        Raises:
        InvalidRecipients -- if encryption using a particular key failed
        InvalidSigners	-- if signing using a particular key failed
        GPGMEError	-- as signaled by the underlying library

        rN�_passphrase_cbc��Sr
r��hint�desc�prev_bad�hook��
passphraserr�
passphrase_cb-�z&Context.encrypt.<locals>.passphrase_cb��error�resultsrr
)�Datar	�ENCRYPT_ALWAYS_TRUST�ENCRYPT_NO_ENCRYPT_TO�ENCRYPT_PREPARE�ENCRYPT_EXPECT_SIGN�ENCRYPT_NO_COMPRESSrdr�PINENTRY_MODE_LOOPBACK�set_passphrase_cb�op_encrypt_sign�
op_encryptr
r�op_encrypt_result�op_sign_resultrn�getcode�UNUSABLE_PUBKEY�invalid_recipients�InvalidRecipientsr{�UNUSABLE_SECKEY�invalid_signers�InvalidSignersr|)r�	plaintext�
recipients�signrlrw�always_trust�add_encrypt_to�prepare�expect_sign�compress�
ciphertextr&�old_pinentry_mode�old_passphrase_cbrx�erI�
sig_resultr|rrvr�encrypt�st*
���������
zContext.encryptc
s>d}d}|r|nt�}�dur(|j}	t|dd�}
tj|_d�fdd�	}|�|�zfz+t|t�r2|}n|dur@tj	dt
d�d}n|}d}|rM|�||�n|�||�Wn&t
jyz}z|��}
|rh|��}nd}|�||�|
|f|_|�d}~wwW�dur�|	|_|
r�|j|
d	d��n�dur�|	|_|
r�|j|
d	d��www|��}
|r�|��}nd}|�||�|
|f}|
jr�t
j|
j|d
��|�r|r�ttdd�|j��|_|du�rg}|D]3}d}|jD]#}|jD]}|jtj@d
kr�q�|j�r|j|jk�rd}|�rnq�|�s|�|�q�|�rt
j|||d
��|S)a=Decrypt data

        Decrypt the given ciphertext and verify any signatures.  If
        VERIFY is an iterable of keys, the ciphertext must be signed
        by all those keys, otherwise a MissingSignatures error is
        raised.  Note: if VERIFY is an empty iterable, that is treated
        the same as passing verify=True (that is, verify signatures
        and return data about any valid signatures found, but no
        signatures are required and no MissingSignatures error will be
        raised).

        The filter_signatures argument can be used to force this
        function to return signatures that are not fully trusted - for
        example because they were made by unknown keys.

        If the ciphertext is symmetrically encrypted using a
        passphrase, that passphrase can be given as parameter, using a
        callback registered at the context, or out-of-band via
        pinentry.

        Keyword arguments:
        sink            -- write result to sink instead of returning it
        passphrase      -- for symmetric decryption
        verify          -- check signatures (boolean or iterable of keys,
                           see above) (default True)
        filter_signatures  -- if this function should filter out signatures
                           that are not completely OK (default True)

        Returns:
        plaintext       -- the decrypted data (or None if sink is given)
        result          -- additional information about the decryption
        verify_result   -- additional information about the valid
                           signature(s) found

        Raises:
        UnsupportedAlgorithm -- if an unsupported algorithm was used
        MissingSignatures    -- if expected signatures are missing or bad
        GPGMEError           -- as signaled by the underlying library

        FNrocrpr
rrqrvrrrx�ryz&Context.decrypt.<locals>.passphrase_cbzTctx.decrypt called with verify=None, should be bool or iterable (treating as False).��categoryTr�r|cSs|jtjkSr
��statusr
�NO_ERROR)�srrr�<lambda>�sz!Context.decrypt.<locals>.<lambda>rr
)r}rdrr	r�r��
isinstancer7�warnings�warn�DeprecationWarning�op_decrypt_verify�
op_decryptr
r�op_decrypt_result�op_verify_resultrnr|�unsupported_algorithm�UnsupportedAlgorithm�list�filter�
signatures�subkeys�summary�SIGSUM_VALID�can_sign�fprr#�MissingSignatures)rr�rlrw�verify�filter_signatures�do_sig_verification�
required_keysr�r�r�rxr�rI�
verify_resultr|�missingrA�ok�subkey�sigrrvr�decryptYs�)

��
���
���
�


�
��zContext.decryptc
Cs�|r|nt�}z	|�|||�Wn4tjyD}z'|�||�|��f}|��tjkr;|djr;tj	|dj|j
|d��||_|�d}~ww|��}|jrNJ�|�||�|fS)aSign data

        Sign the given data with either the configured default local
        key, or the 'signers' keys of this context.

        Keyword arguments:
        mode		-- signature mode (default: normal, see below)
        sink		-- write result to sink instead of returning it

        Returns:
        either
          signed_data	-- encoded data and signature (normal mode)
          signature	-- only the signature data (detached mode)
          cleartext	-- data and signature as text (cleartext mode)
            (or None if sink is given)
        result		-- additional information about the signature(s)

        Raises:
        InvalidSigners	-- if signing using a particular key failed
        GPGMEError	-- as signaled by the underlying library

        rrzN)r}�op_signr
rrnr�r�r�r�r�r{r|)rrmrl�mode�
signeddatar�r|rIrrrr��s&
���
zContext.signc

Cs@|rd}n|r	|nt�}z|r|�||d�n|�|d|�Wntjy9}z
|�||�|��f|_|�d}~ww|�||�|��f}tdd�|djD��rYtj	|d|d��t
�}|D]3}	d}
|	jD]$}|djD]}|jt
j@dkrwql|jr�|j|jkr�d}
nql|
r�nqe|
s�|�|	�q^|r�tj|d||d��|S)	a�Verify signatures

        Verify signatures over data.  If VERIFY is an iterable of
        keys, the ciphertext must be signed by all those keys,
        otherwise an error is raised.

        Keyword arguments:
        signature	-- detached signature data
        sink		-- write result to sink instead of returning it

        Returns:
        data		-- the plain data
            (or None if sink is given, or we verified a detached signature)
        result		-- additional information about the signature(s)

        Raises:
        BadSignatures	-- if a bad signature is encountered
        MissingSignatures -- if expected signatures are missing or bad
        GPGMEError	-- as signaled by the underlying library

        Ncss�|]	}|jtjkVqdSr
r�)rr�rrr�	<genexpr>'s�z!Context.verify.<locals>.<genexpr>rr�FrT)r}�	op_verifyr
rrnr�r|�anyr��
BadSignaturesr�r�r�r	r�r�r�r#r�)
r�signed_data�	signaturerlr�rmr�r|r�rAr�r�r�rrrr�sL���
��
�
�zContext.verifyc
Cs�z|�|�|��}|jdkrtj}ntj}WnEty\}z9|tjkr1|j	dkr-tj
}n%tj}n!|tkr@t
|d�dur@tj}n|tkrOt
|d�durOtj}ntj}WYd}~nd}~ww|tjkrf|}|S|}|S)a�Import data

        Imports the given data into the Context.

        Returns:
                -- an object describing the results of imported or updated
                   keys

        Raises:
        TypeError      -- Very rarely.
        GPGMEError     -- as signaled by the underlying library:

                          Import status errors, when they occur, will usually
                          be of NODATA.  NO_PUBKEY indicates something
                          managed to run the function without any
                          arguments, while an argument of None triggers
                          the first NODATA of errors.GPGME in the
                          exception.
        rzNo data�decodeT�encodeN)�	op_import�op_import_result�
consideredr	�STATUS_IMPORT_PROBLEM�STATUS_KEY_CONSIDERED�	Exceptionr
r�code_str�
STATUS_NODATA�STATUS_FILE_ERROR�	TypeError�hasattr�STATUS_NO_PUBKEY�STATUS_ERROR)rrmrIr�r��
import_resultrrr�
key_import>s0

�

��

�zContext.key_importc
Cslt�}d}z|�|||�|�dtj�|��}Wnty'}z|�d}~wwt|�dkr2|}|Sd}|S)aQExport keys.

        Exports public keys matching the pattern specified.  If no
        pattern is specified then exports all available keys.

        Keyword arguments:
        pattern	-- return keys matching pattern (default: all keys)

        Returns:
                -- A key block containing one or more OpenPGP keys in
                   either ASCII armoured or binary format as determined
                   by the Context().  If there are no matching keys it
                   returns None.

        Raises:
        GPGMEError     -- as signaled by the underlying library.
        rN)r}�	op_exportrhrirjrkr�len�r�patternrmr��	pk_resultr�rIrrr�
key_exportms���zContext.key_exportc
C�nt�}tj}z|�|||�|�dtj�|��}Wnty(}z|�d}~wwt	|�dkr3|}|Sd}|S)ayExport keys.

        Exports public keys matching the pattern specified in a
        minimised format.  If no pattern is specified then exports all
        available keys.

        Keyword arguments:
        pattern	-- return keys matching pattern (default: all keys)

        Returns:
                -- A key block containing one or more minimised OpenPGP
                   keys in either ASCII armoured or binary format as
                   determined by the Context().  If there are no matching
                   keys it returns None.

        Raises:
        GPGMEError     -- as signaled by the underlying library.
        rN)
r}r�GPGME_EXPORT_MODE_MINIMALr�rhrirjrkrr�r�rrr�key_export_minimal�s���zContext.key_export_minimalc
Cr�)a�Export secret keys.

        Exports secret keys matching the pattern specified.  If no
        pattern is specified then exports or attempts to export all
        available secret keys.

        IMPORTANT: Each secret key to be exported will prompt for its
        passphrase via an invocation of pinentry and gpg-agent.  If the
        passphrase is not entered or does not match then no data will be
        exported.  This is the same result as when specifying a pattern
        that is not matched by the available keys.

        Keyword arguments:
        pattern	-- return keys matching pattern (default: all keys)

        Returns:
                -- On success a key block containing one or more OpenPGP
                   secret keys in either ASCII armoured or binary format
                   as determined by the Context().
                -- On failure while not raising an exception, returns None.

        Raises:
        GPGMEError     -- as signaled by the underlying library.
        rN)
r}r�GPGME_EXPORT_MODE_SECRETr�rhrirjrkrr�)rr�rmr��	sk_resultr�rIrrr�key_export_secret�s���zContext.key_export_secretccsh�|s|�|�|�||�nt|t�st|d�}|�|d�|��}|r.|V|��}|s%|��dS)aList keys

        Keyword arguments:
        pattern	-- return keys matching pattern (default: all keys)
        secret	-- return only secret keys (default: False)
        mode    -- keylist mode (default: list local keys)
        source  -- read keys from source instead from the keyring
                       (all other options are ignored in this case)

        Returns:
                -- an iterator returning key objects

        Raises:
        GPGMEError	-- as signaled by the underlying library
        )�filerN)�set_keylist_mode�op_keylist_startr�r}�op_keylist_from_data_start�op_keylist_next�op_keylist_end)rr��secretr��sourcerArrr�keylist�s�


�zContext.keylistrc
st���r|j}t|dd�}tj|_d�fdd�	}
|�|
�zZ|�||d|d|r,tjj	nd|r3tjj
ndB|r;tjjndB|rCtjjndB�durMtjj
ndB|rSdntjjB|
r]tjjndB�Wt���ru||_|ru|j|dd��|��St���r�||_|r�|j|dd��www)a	Create a primary key

        Create a primary key for the user id USERID.

        ALGORITHM may be used to specify the public key encryption
        algorithm for the new key.  By default, a reasonable default
        is chosen.  You may use "future-default" to select an
        algorithm that will be the default in a future implementation
        of the engine.  ALGORITHM may be a string like "rsa", or
        "rsa2048" to explicitly request an algorithm and a key size.

        EXPIRES_IN specifies the expiration time of the key in number
        of seconds since the keys creation.  By default, a reasonable
        expiration time is chosen.  If you want to create a key that
        does not expire, use the keyword argument EXPIRES.

        SIGN, ENCRYPT, CERTIFY, and AUTHENTICATE can be used to
        request the capabilities of the new key.  If you don't request
        any, a reasonable set of capabilities is selected, and in case
        of OpenPGP, a subkey with a reasonable set of capabilities is
        created.

        If PASSPHRASE is None (the default), then the key will not be
        protected with a passphrase.  If PASSPHRASE is a string, it
        will be used to protect the key.  If PASSPHRASE is True, the
        passphrase must be supplied using a passphrase callback or
        out-of-band with a pinentry.

        Keyword arguments:
        algorithm    -- public key algorithm, see above (default: reasonable)
        expires_in   -- expiration time in seconds (default: reasonable)
        expires      -- whether or not the key should expire (default: True)
        sign         -- request the signing capability (see above)
        encrypt      -- request the encryption capability (see above)
        certify      -- request the certification capability (see above)
        authenticate -- request the authentication capability (see above)
        passphrase   -- protect the key with a passphrase (default: no
                        passphrase)
        force        -- force key creation even if a key with the same userid
                        exists (default: False)

        Returns:
                     -- an object describing the result of the key creation

        Raises:
        GPGMEError   -- as signaled by the underlying library

        roNcrpr
rrqrvrrrx@ryz)Context.create_key.<locals>.passphrase_cbrrr
)r�is_a_stringrdrr	r�r��op_createkey�create�SIGN�ENCR�CERT�AUTH�NOPASSWD�NOEXPIRE�FORCE�op_genkey_result)r�userid�	algorithm�
expires_in�expiresr�r��certify�authenticaterw�forcer�r�rxrrvr�
create_keysL
;
�������

��zContext.create_keyc	
s�t���r|j}	t|dd�}
tj|_d�fdd�	}|�|�zI|�||d||r+tjj	nd|r2tjj
ndB|r:tjjndB�durDtjjndB|rJdntjj
B�Wt���rd|	|_|
rd|j|
dd��|��St���r||	|_|
r}|j|
dd��www)a@Create a subkey

        Create a subkey for the given KEY.  As subkeys are a concept
        of OpenPGP, calling this is only valid for the OpenPGP
        protocol.

        ALGORITHM may be used to specify the public key encryption
        algorithm for the new subkey.  By default, a reasonable
        default is chosen.  You may use "future-default" to select an
        algorithm that will be the default in a future implementation
        of the engine.  ALGORITHM may be a string like "rsa", or
        "rsa2048" to explicitly request an algorithm and a key size.

        EXPIRES_IN specifies the expiration time of the subkey in
        number of seconds since the subkeys creation.  By default, a
        reasonable expiration time is chosen.  If you want to create a
        subkey that does not expire, use the keyword argument EXPIRES.

        SIGN, ENCRYPT, and AUTHENTICATE can be used to request the
        capabilities of the new subkey.  If you don't request any, an
        encryption subkey is generated.

        If PASSPHRASE is None (the default), then the subkey will not
        be protected with a passphrase.  If PASSPHRASE is a string, it
        will be used to protect the subkey.  If PASSPHRASE is True,
        the passphrase must be supplied using a passphrase callback or
        out-of-band with a pinentry.

        Keyword arguments:
        algorithm    -- public key algorithm, see above (default: reasonable)
        expires_in   -- expiration time in seconds (default: reasonable)
        expires      -- whether or not the subkey should expire (default: True)
        sign         -- request the signing capability (see above)
        encrypt      -- request the encryption capability (see above)
        authenticate -- request the authentication capability (see above)
        passphrase   -- protect the subkey with a passphrase (default: no
                        passphrase)

        Returns:
                     -- an object describing the result of the subkey creation

        Raises:
        GPGMEError   -- as signaled by the underlying library

        roNcrpr
rrqrvrrrx�ryz,Context.create_subkey.<locals>.passphrase_cbrrr
)rr�rdrr	r�r��op_createsubkeyr�r�r�r�r�r�r�)rrAr�r�rr�r�rrwr�r�rxrrvr�
create_subkey[sB
6
�����

��zContext.create_subkeycC�|�||d�dS)z�Add a UID

        Add the uid UID to the given KEY.  Calling this function is
        only valid for the OpenPGP protocol.

        Raises:
        GPGMEError   -- as signaled by the underlying library

        rN)�	op_adduid�rrA�uidrrr�key_add_uid��
zContext.key_add_uidcCr)z�Revoke a UID

        Revoke the uid UID from the given KEY.  Calling this function
        is only valid for the OpenPGP protocol.

        Raises:
        GPGMEError   -- as signaled by the underlying library

        rN)�	op_revuidr	rrr�key_revoke_uid�rzContext.key_revoke_uidcCsbd}|dust�|�rn|tjjO}d�|�}|s|tjjO}|r'|tjjO}|�||||�dS)a�Sign a key

        Sign a key with the current set of signing keys.  Calling this
        function is only valid for the OpenPGP protocol.

        If UIDS is None (the default), then all UIDs are signed.  If
        it is a string, then only the matching UID is signed.  If it
        is a list of strings, then all matching UIDs are signed.  Note
        that a case-sensitive exact string comparison is done.

        EXPIRES_IN specifies the expiration time of the signature in
        seconds.  If EXPIRES_IN is False, the signature does not
        expire.

        Keyword arguments:
        uids         -- user ids to sign, see above (default: sign all)
        expires_in   -- validity period of the signature in seconds
                                               (default: do not expire)
        local        -- create a local, non-exportable signature
                                               (default: False)

        Raises:
        GPGMEError   -- as signaled by the underlying library

        rN�
)	rr�r	�keysign�LFSEPr$r��LOCAL�
op_keysign)rrA�uidsr��localr&rrr�key_sign�s
zContext.key_signcCs|�||�dS)z�Set a keys' TOFU policy

        Set the TOFU policy associated with KEY to POLICY.  Calling
        this function is only valid for the OpenPGP protocol.

        Raises:
        GPGMEError   -- as signaled by the underlying library

        N)�op_tofu_policy)rrA�policyrrr�key_tofu_policy�s
zContext.key_tofu_policyc		Cs�t�|�s
t|t�r
|}n
d�dd�|D��}t��}t�|j||r)t	�
|�|fnd|r3t	�
|�|fnd|r=t	�
|�|fnd|�}|jrIt�|�t
|�t�|�}t�|�|dkr_t|�SdS)a�Issue a raw assuan command

        This function can be used to issue a raw assuan command to the
        engine.

        If command is a string or bytes, it will be used as-is.  If it
        is an iterable of strings, it will be properly escaped and
        joined into an well-formed assuan command.

        Keyword arguments:
        data_cb		-- a callback receiving data lines
        inquire_cb	-- a callback providing more information
        status_cb	-- a callback receiving status lines

        Returns:
        result		-- the result of command as GPGMEError

        Raises:
        GPGMEError	-- as signaled by the underlying library

        r css�|]}t�|�VqdSr
)r�percent_escaperrrrr�s�z*Context.assuan_transact.<locals>.<genexpr>Nr)rr�r��bytesr$r�new_gpgme_error_t_p�gpgme_op_assuan_transact_extr�weakref�refrrFr�gpgme_error_t_p_value�delete_gpgme_error_t_pr)	r�command�data_cb�
inquire_cb�	status_cb�cmd�errptr�errr�rrr�assuan_transact�s,����


zContext.assuan_transactcCsr|durtd��|durt�}|rt�|�||f}nt�|�|f}t�|j||||�}|jr3t�|�t	|�dS)a�Interact with the engine

        This method can be used to edit keys and cards interactively.
        KEY is the key to edit, FUNC is called repeatedly with two
        unicode arguments, 'keyword' and 'args'.  See the GPGME manual
        for details.

        Keyword arguments:
        sink		-- if given, additional output is written here
        flags		-- use constants.INTERACT_CARD to edit a card

        Raises:
        GPGMEError	-- as signaled by the underlying library

        NzFirst argument cannot be None)
�
ValueErrorr}rrr�gpgme_op_interactrrrFr)rrArJrlr&�	fnc_value�
opaquedatarIrrr�interact-s�
zContext.interactcs�fdd�t����D�S)zKeys used for signingcsg|]}��|��qSr)�signers_enum�r�irrrrQsz#Context.signers.<locals>.<listcomp>)�range�
signers_countrrrrrcNszContext.signerscCs8|j}|��z
|D]}|�|�q
WdS||_�r
)rc�
signers_clear�signers_add)rrc�oldrArrrrcSs�cC�|��S)z
Pinentry mode)�get_pinentry_moderrrrrd^�zContext.pinentry_modecCs|�|�dSr
)�set_pinentry_mode�rr;rrrrdcscCr7)zProtocol to use)�get_protocolrrrrregr9zContext.protocolcCstt�|��|�|�dSr
)rr�gpgme_engine_check_version�set_protocolr;rrrrelscCs|jjS)zEngine's home directory)�engine_inforfrrrrrfqr9zContext.home_dircCs|j|j|d�dS)N)rf)�set_engine_inforer;rrrrfvs�gpgme_ctx_t�gpgme_cCs|�d�r|�d�p|dvS)�?This function should list all functions returning gpgme_error_t�	gpgme_op_�_result>r]�gpgme_cancel�
gpgme_get_key�gpgme_set_locale�gpgme_set_sender�gpgme_get_sig_key�gpgme_signers_add�gpgme_cancel_async�gpgme_set_ctx_flag�gpgme_set_protocol�gpgme_set_keylist_mode�gpgme_set_sub_protocol�gpgme_sig_notation_add�gpgme_set_pinentry_mode�gpgme_ctx_set_engine_info)�
startswith�endswithr4rrrr6}s

��zContext._errorcheck>r`rbracCsTtsdS|��|��|��|jr$|jr&tjr(t�|j�d|_dSdSdSdSr
)r�_free_passcb�_free_progresscb�_free_statuscbr[r�
gpgme_releaserrrr�__del__�s
�zContext.__del__cC�|Sr
rrrrr�	__enter__�ryzContext.__enter__cC�|��dSr
�rZ�r�typer;�tbrrr�__exit__��zContext.__exit__co�<�|j|i|��|��}|r|V|��}|s|��dSr
)r�r�r�)rrH�kwargsrArrr�op_keylist_all����zContext.op_keylist_allc
Cs�t��}ztt�|j|��t�|�}Wntjy2}zd}|��tj	kr(|�WYd}~nd}~wwt�
|�|rAdd�|_|SdS)z~Returns the next key in the list created
        by a call to op_keylist_start().  The object returned
        is of type Key.NcS�
t�|�Sr
�r�gpgme_key_unrefrrrrr���
z)Context.op_keylist_next.<locals>.<lambda>)r�new_gpgme_key_t_pr�gpgme_op_keylist_nextr�gpgme_key_t_p_valuer
rr��EOF�delete_gpgme_key_t_prZ)r�ptrrA�excprrrr��s ���

�zContext.op_keylist_nextc
Cs�t��}z
tt�|j|||��Wntjy,}z|��tjkr&t�	|��|�d}~wwt�
|�}t�|�|s;J�dd�|_|S)a&Get a key given a fingerprint

        Keyword arguments:
        secret		-- to request a secret key

        Returns:
                        -- the matching key

        Raises:
        KeyError	-- if the key was not found
        GPGMEError	-- as signaled by the underlying library

        NcSrhr
rirrrrr��rkz!Context.get_key.<locals>.<lambda>)
rrlrrGrr
rr�ro�KeyNotFoundrnrprZ)rr�r�rqr�rArrr�get_key�s
��


zContext.get_keycordr
)�op_trustlist_start�op_trustlist_next�op_trustlist_end)rrHre�trustrrr�op_trustlist_all�rgzContext.op_trustlist_allc
Csrt��}ztt�|j|��t�|�}Wntjy1}zd}|��tj	kr'�WYd}~nd}~wwt�
|�|S)z�Returns the next trust item in the list created
        by a call to op_trustlist_start().  The object returned
        is of type TrustItem.N)r�new_gpgme_trust_item_t_pr�gpgme_op_trustlist_nextr�gpgme_trust_item_t_p_valuer
rr�ro�delete_gpgme_trust_item_t_p)rrqrxrrrrrrv�s���
zContext.op_trustlist_nextcC�F|durd}n|durt�|�|f}nt�|�||f}t�||�dS)a*Sets the passphrase callback to the function specified by func.

        When the system needs a passphrase, it will call func with three args:
        hint, a string describing the key it needs the passphrase for;
        desc, a string describing the passphrase it needs;
        prev_bad, a boolean equal True if this is a call made after
        unsuccessful previous attempt.

        If hook has a value other than None it will be passed into the func
        as a forth argument.

        Please see the GPGME manual for more information.
        N)rrr�gpg_set_passphrase_cb�rrJru�hookdatarrrr��szContext.set_passphrase_cbcC�tjr
|�d�dSdSr
)rrr�rrrrrV��zContext._free_passcbcCr~)a�Sets the progress meter callback to the function specified by FUNC.
        If FUNC is None, the callback will be cleared.

        This function will be called to provide an interactive update
        of the system's progress.  The function will be called with
        three arguments, type, total, and current.  If HOOK is not
        None, it will be supplied as fourth argument.

        Please see the GPGME manual for more information.

        N)rrr�gpg_set_progress_cbr�rrr�set_progress_cbszContext.set_progress_cbcCr�r
)rr�r�rrrrrW r�zContext._free_progresscbcCr~)aPSets the status callback to the function specified by FUNC.  If
        FUNC is None, the callback will be cleared.

        The function will be called with two arguments, keyword and
        args.  If HOOK is not None, it will be supplied as third
        argument.

        Please see the GPGME manual for more information.

        N)rrr�gpg_set_status_cbr�rrr�
set_status_cb$szContext.set_status_cbcCr�r
)rr�r�rrrrrX8r�zContext._free_statuscbcs4|j��fdd�|��D�}t|�dksJ�|dS)z,Configuration of the engine currently in usecsg|]	}|j�kr|�qSr)rer0�rCrrr@rz'Context.engine_info.<locals>.<listcomp>rr)re�get_engine_infor�)r�infosrr�rr?<szContext.engine_infocCst�|j�S)z�Get engine configuration

        Returns information about all configured and installed
        engines.

        Returns:
        infos		-- a list of engine infos

        )r�gpgme_ctx_get_engine_inforrrrrr�Ds
zContext.get_engine_infocCs|�|||�dS)a6Change engine configuration

        Changes the configuration of the crypto engine implementing
        the protocol 'proto' for the context.

        Keyword arguments:
        file_name	-- engine program file name (unchanged if None)
        home_dir	-- configuration directory (unchanged if None)

        N)�ctx_set_engine_info)r�proto�	file_namerfrrrr@PszContext.set_engine_infocCs8t��}t�|j||�t�|�}t�|�t|�dS)z�Wait for asynchronous call to finish. Wait forever if hang is True.
        Raises an exception on errors.

        Please read the GPGME manual for more information.

        N)rr�
gpgme_waitrr r!r)r�hangrqr�rrr�wait]s


zContext.waitcCs tjdtd�|j||||d�S)a�Start key editing using supplied callback function

        Note: This interface is deprecated and will be removed with
        GPGME 1.8.  Please use .interact instead.  Furthermore, we
        implement this using gpgme_op_interact, so callbacks will get
        called with string keywords instead of numeric status
        messages.  Code that is using constants.STATUS_X or
        constants.status.X will continue to work, whereas code using
        magic numbers will break as a result.

        z"Call to deprecated method op_edit.r�)rlr,)r�r�r�r.)rrArJr,�outrrr�op_editjs�zContext.op_edit)NNTTr
)	NrTFFFFNF)NrTFFFN)NFF)NNN)NrN)F)NN)<r!rTrUrLr	�PINENTRY_MODE_DEFAULT�PROTOCOL_OpenPGPrrnrr�r��SIG_MODE_NORMALr�r�r�r�r�r�r�r�rrrrrrrr)r.r?rc�setterrdrerfr1r3r6r"rZr\rbrfr�rtryrvr�rVr�rWr�rXr?r�r@r�r�rYrrrrrZ�s�
�&	
�
c|+>
/
"
#*
�'
�]
�S
)
�
2!

















rZcs�eZdZdZdZdZdd�Z						d'�fdd	�	Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zd(dd�Z
d(dd�Zd)dd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd*d%d&�Z�ZS)+r}aJData buffer

    A lot of data has to be exchanged between the user and the crypto
    engine, like plaintext messages, ciphertext, signatures and
    information about the keys.  The technical details about
    exchanging the data information are completely abstracted by
    GPGME.  The user provides and receives the data via `gpgme_data_t'
    objects, regardless of the communication protocol between GPGME
    and the crypto engine in use.

    This Data class is the implementation of the GpgmeData objects.

    Please see the information about __init__ for instantiation.

    �gpgme_data_t�gpgme_data_cCs|dvS)rC>	�gpgme_data_read�gpgme_data_seek�gpgme_data_write�gpgme_data_release�gpgme_data_identify�gpgme_data_set_flag�gpgme_data_get_encoding�gpgme_data_get_file_name�gpgme_data_release_and_get_memrr4rrrr6�szData._errorcheckNTcs�tt|��d�d|_|dur|j|�dS|dur"|�||�dS|dur7|dur7|dur7|�|||�dS|durOt�|�rH|�	||�dS|�
|�dS|��dS)a�Initialize a new gpgme_data_t object.

        If no args are specified, make it an empty object.

        If string alone is specified, initialize it with the data
        contained there.

        If file, offset, and length are all specified, file must
        be either a filename or a file-like object, and the object
        will be initialized by reading the specified chunk from the file.

        If cbs is specified, it MUST be a tuple of the form:

        (read_cb, write_cb, seek_cb, release_cb[, hook])

        where the first four items are functions implementing reading,
        writing, seeking the data, and releasing any resources once
        the data object is deallocated.  The functions must match the
        following prototypes:

            def read(amount, hook=None):
                return <a b"bytes" object>

            def write(data, hook=None):
                return <the number of bytes written>

            def seek(offset, whence, hook=None):
                return <the new file position>

            def release(hook=None):
                <return value and exceptions are ignored>

        The functions may be bound methods.  In that case, you can
        simply use the 'self' reference instead of using a hook.

        If file is specified without any other arguments, then
        it must be a filename, and the object will be initialized from
        that file.

        N)rr}r�data_cbs�new_from_cbs�new_from_mem�new_from_filepartrr��
new_from_file�new_from_fd�new)r�stringr��offset�length�cbs�copyrrrr�s/
z
Data.__init__cCsFtsdS|jdurtjrt�|j�|jrt�|�d|_|��dSr
)rrr�rrF�
_free_datacbsrrrrrZ�s
zData.__del__cCr[r
rrrrrr\�ryzData.__enter__cCr]r
r^r_rrrrb�rcz
Data.__exit__cCs
d|_dSr
)�	_data_cbsrrrrr���
zData._free_datacbscCs0t��}tt�|��t�|�|_t�|�dSr
)r�new_gpgme_data_t_pr�gpgme_data_new�gpgme_data_t_p_valuer�delete_gpgme_data_t_p)rrgrrrr��szData.newcCs:t��}tt�||t|�|��t�|�|_t�|�dSr
)rr�r�gpgme_data_new_from_memr�r�rr�)rr�r�rgrrrr��s�zData.new_from_memc
Csrt��}ztt�|||��Wntjy+}z|��tjkr%|s%td��|�d}~wwt�	|�|_
t�|�dS)Nz#delayed reads are not yet supported)rr�r�gpgme_data_new_from_filer
rr��	INV_VALUEr*r�rr�)r�filenamer�rgr�rrrr�s��zData.new_from_filecCsdt��}|durt�|�|||||f}n
t�|�||||f}t�|||�t�|�|_t�|�dSr
)rr�rr�gpg_data_new_from_cbsr�rr�)r�read_cb�write_cb�seek_cb�
release_cbrurgr�rrrr�s��zData.new_from_cbscCs�t��}d}d}t�|�r|}nt�|��|j�}|dur+tdtt	|��t|�f��t
t�|||||��t�|�|_
t�|�dS)z�This wraps the GPGME gpgme_data_new_from_filepart() function.
        The argument "file" may be:

        * a string specifying a file name, or
        * a file-like object supporting the fileno() and the mode attribute.

        Nz"Failed to open file from %s arg %s)rr�rr��fdopen�filenor�r*�strr`r�gpgme_data_new_from_filepartr�rr�)rr�r�r�rgr��fprrrr�s&	
����zData.new_from_filepartcCs6t��}tt�||����t�|�|_t�|�dS)z�This wraps the GPGME gpgme_data_new_from_fd() function.  The
        argument "file" must be a file-like object, supporting the
        fileno() method.

        N)rr�r�gpgme_data_new_from_fdr�r�rr�)rr�rgrrrr�8szData.new_from_fdcC�|�|�dS)z�This wrap around gpgme_data_new_from_stream is an alias for
        new_from_fd() method since in python there's no difference
        between file stream and file descriptor.N)r��rr�rrr�new_from_streamC�zData.new_from_streamcCr�)z�This wrap around gpgme_data_new_from_estream is an alias for
        new_from_fd() method since in python there's no difference
        between file stream and file descriptor, but using fd broke.N)r�r�rrr�new_from_estreamIr�zData.new_from_estreamcCs6t�|j|�}|dkr|jrt�|�|St���|S)zkWrite buffer given as string or bytes.

        If a string is given, it is implicitly encoded using UTF-8.r)rr�rrrFr�fromSyserror)r�buffer�writtenrrr�writeOs
�z
Data.write���cCs�|dkrdS|dkr$z
t�|j|�}W|S|jr#t�|�Y|S�g}	z	t�|jd�}Wn|jr=t�|�n�Yt|�dkrFn|�|�q'd�|�S)z�Read at most size bytes, returned as bytes.

        If the size argument is negative or omitted, read until EOF is reached.

        Returns the data read, or the empty string if there was no data
        to read before EOF was reached.r�Ti�)rr�rrrFr�r#r$)r�sizerI�chunksrrrrk[s2���
�
z	Data.read)NNNNNT)Tr
)r�)r!rTrUrLr1r3r6rrZr\rbr�r�r�r�r�r�r�r�r�r�rkrYrrrrr}{s4�@



r}cCrh)z�Return short algorithm string

    Return a public key algorithm string (e.g. "rsa2048") for a given
    SUBKEY.

    Returns:
    algo      - a string

    )r�gpgme_pubkey_algo_string)r�rrr�pubkey_algo_string�

r�cCrh)z�Return name of public key algorithm

    Return the name of the public key algorithm for a given numeric
    algorithm id ALGO (cf. RFC4880).

    Returns:
    algo      - a string

    )r�gpgme_pubkey_algo_name��algorrr�pubkey_algo_name�r�r�cCrh)z�Return name of hash algorithm

    Return the name of the hash algorithm for a given numeric
    algorithm id ALGO (cf. RFC4880).

    Returns:
    algo      - a string

    )r�gpgme_hash_algo_namer�rrr�hash_algo_name�r�r�cCrh)ztGet protocol description

    Get the string describing protocol PROTO.

    Returns:
    proto     - a string

    )r�gpgme_get_protocol_name�r�rrr�get_protocol_name��
	r�cCrh)z�Return the address spec

    Return the addr-spec (cf. RFC2822 section 4.3) from a user id UID.

    Returns:
    addr_spec - a string

    )r�gpgme_addrspec_from_uid)r
rrr�addrspec_from_uid�r�r�cCrhr
)r�gpgme_check_version)�versionrrr�
check_version�r�r�cCs,z
tt�|��WdStjyYdSw)NTF)rrr=r
rr�rrr�engine_check_version�s�r�cCsLt��}ztt�|��t�|�}Wntjyd}Ynwt�|�|Sr
)r�new_gpgme_engine_info_t_pr�gpgme_get_engine_info�gpgme_engine_info_t_p_valuer
r�delete_gpgme_engine_info_t_p)rq�inforrrr��s�
r�cCstt�|||��dS)a#Changes the default configuration of the crypto engine implementing
    the protocol 'proto'. 'file_name' is the file name of
    the executable program implementing this protocol. 'home_dir' is the
    directory name of the configuration directory (engine's default is
    used if omitted).N)rr�gpgme_set_engine_info)r�r�rfrrrr@�sr@cCstt�d||��dS)z(Sets the default locale used by contextsN)rrrH)r�r;rrr�
set_locale�sr�cCsRt��}t�d||�}t�|�}t�|�|dur!t|�||fSt|�}||fS)aFWait for asynchronous call on any Context  to finish.
    Wait forever if hang is True.

    For finished anynch calls it returns a tuple (status, context):
        status  - status return by asnynchronous call.
        context - context which caused this call to return.

    Please read the GPGME manual of more information.N)rrr�r r!rrZ)r�rq�contextr�rrrr��s	

�r�r
)�
__future__rrrrWrir�rr�rr
rrr	r�objectrrZr}r�r�r�r�r�r�r�r�r@r�r�rrrr�<module>sN	S