File: //usr/lib/python3/dist-packages/duplicity/__pycache__/gpg.cpython-310.pyc
o
��`.E � @ s4 d Z ddlmZ ddlmZ ddlmZ ddlZddlZddlZddlZddl Z ddl
Z
ddl m Z ddl m
Z
ddl mZ dd l mZ zdd
lmZ dd lmZ W n eyg dd lmZ dd lmZ Y nw d
ZG dd� de�ZG dd� de�ZG dd� de�Z d!dd�Zd"dd�Z d#d d �Z d$d d �Z dS )%z�
duplicity's gpg interface, builds upon Frank Tobin's GnuPGInterface
which is now patched with some code for iterative threaded execution
see duplicity's README for details
� )�next)�str)�objectN)�config)� gpginterface)�tempdir)�util)�sha1)�md5)�newi c @ s e Zd ZdZdS )�GPGErrorz!
Indicate some GPG Error
N)�__name__�
__module__� __qualname__�__doc__� r r �//usr/lib/python3/dist-packages/duplicity/gpg.pyr 5 s r c @ s4 e Zd ZdZ ddd�ZejZed�Zdd� Z dS ) �
GPGProfilezF
Just hold some GPG settings, avoid passing tons of arguments
Nc C s� |du st |tdjf�sJ �|| _|| _|| _d| _|dur)t |t�s%J �|| _ng | _|dur;t |t�s7J �|| _ ng | _ | �
t j �| _
dS )a>
Set all data with initializer
passphrase is the passphrase. If it is None (not ""), assume
it hasn't been set. sign_key can be blank if no signing is
indicated, and recipients should be a list of keys. For all
keys, the format should be an hex key like 'AA0E73D2'.
N� )�
isinstancer � __class__�
passphrase�signing_passphrase�sign_key�encrypt_secring�list�
recipients�hidden_recipients�get_gpg_versionr �
gpg_binary� gpg_version)�selfr r r r r r r �__init__@ s
zGPGProfile.__init__sU ^gpg.*\(GnuPG(?:/MacGPG2)?\) (?P<maj>[0-9]+)\.(?P<min>[0-9]+)\.(?P<bug>[0-9]+)(-.+)?$c C s� t �� }|d ur ||_tjr tj�� D ] }|jj�|� q|j dgdgd�}|j
d � � � � }| j
�|�}|d urMt|�d��t|�d��t|�d��fS td||f ��)Nz --version�stdout)�
create_fhs�maj�min�bugz/failed to determine gnupg version of %s from %s)r �GnuPG�callr � gpg_options�split�options�
extra_args�append�run�handles�readline�rstrip� _version_re�search�int�groupr )r! �binary�gnupg�opt�res�line�mr r r r a s (zGPGProfile.get_gpg_version)NNNN)
r
r r r r" �re�compile�rcr3 r r r r r r < s
� r c @ sZ e Zd ZdZdd� Zddd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dS )�GPGFilezI
File-like object that encrypts decrypts another file on the fly
c
C s� d| _ d| _tjt�� �� d�| _tjt�� �� d�| _|| _ d| _
t � � }t
jdur/t
j|_d|j_|jj�d� |jj�d� |jdd� dkrUt
jrT|jj�d� n%|jdd � d
kr_n|jdd � d krst
jsr|jj�d � ntd
|j ��t
jr�t
j�� D ] }|jj�|� q�g }|jr�|j|j_|�d� |r�|jr�|jr�|j}n|j }|du r�d}|�r|j r�|j |j_ |�d� |j r�|j |j_ |�d� |j s�|j s�|�d� |jj�d� t
jr�dg}nddg}|j |||� d�| j| jd�d�} t
j�s| j!d �"|� | j!d �#� | j!d | _$n[|j �s |j �r,|j%�r,|�d� |�|j%� tjt�� �� d�| _ t
j�r?dg}nddg}|j dg||� d�| j | j| jd �d�} t
j�sj| j!d �"|� | j!d �#� | j!d | _&| | _'|| _(dS ) a�
GPGFile initializer
If recipients is set, use public key encryption and encrypt to
the given keys. Otherwise, use symmetric encryption.
encrypt_path is the Path of the gpg encrypted file. Right now
only symmetric encryption/decryption is supported.
If passphrase is false, do not set passphrase - GPG program
should prompt for it.
N)�dirr z--no-secmem-warningz--ignore-mdc-error� �rB z --use-agent� )rD r )rD rB z--pinentry-mode=loopbackz Unsupported GNUPG version, %sz--signr z --encryptz --symmetricz --force-mdc�stdinr �wb)r# �stderr�logger)r$ �
attach_fhsz--secret-keyringr# z --decrypt�rb)rE �statusrG rH ))� status_fp�closed�tempfile�
TemporaryFiler �defaultrA � logger_fp� stderr_fp�name�
byte_countr r( r r r) r, �meta_interactiver- r. r � use_agentr r* r+ r � default_keyr r r r r/ �openr0 �write�close� gpg_inputr �
gpg_output� gpg_process�encrypt)
r! r^ � encrypt_path�profiler8 r9 �cmdlistr � gnupg_fhs�p1r r r r" x s�
��
��
��
zGPGFile.__init__���c C sP z| j �|�}|d ur| jt|�7 _W |S W |S ty' | �� Y |S w �N)r\ �readrT �len� Exception�
gpg_failed)r! �lengthr: r r r rf � s � �
�z GPGFile.readc C sp z)| j �|�}|d ur'tjjdkr| j|7 _W |S | jt|�7 _W |S W |S ty7 | �� Y |S w )N� ) r[ rY �sys� version_info�majorrT rg rh ri )r! �bufr: r r r rY � s �� �
�z
GPGFile.writec C s | j S re )rT �r! r r r �tell� s z GPGFile.tellc C sH | j rJ �|| jksJ d|| jf ��|| jkr"| �|| j � d S d S )Nz%d < %d)r^ rT rf )r! �offsetr r r �seek s
�z GPGFile.seekc C s� d}|d7 }| j | jfD ]6}|�d� |D ],}z|t|�� t�� d�d 7 }W q tyA } z||�� d 7 }W Y d }~qd }~ww q |d7 }|�d�dksRt |��d S )
NzGPG Failed, see log below:
z ===== Begin GnuPG log =====
r �replace�
z===== End GnuPG log =====
zinvalid packet (ctb=14)rd r )
rQ rR rs r �strip�locale�getpreferredencodingrh �findr )r! �msg�fpr; �er r r ri s
���zGPGFile.gpg_failedc C s | j r4z| j�� W n
ty | �� Y nw | jr | �� z| j�� W nZ ty3 | �� Y nNw d}|rPz| j �
t �}W n
tyM | �� Y nw |s8z| j �� W n
tyd | �� Y nw | jrl| �� z| j�� W n
ty� | �� Y nw | j �� | j
�� d| _d S )NrB )r^ r[ rZ rh ri rL �
set_signaturer] �waitr\ rf � blocksizerQ rR rM )r! r: r r r rZ sH � � �� � �
z
GPGFile.closec C s^ | j �d� | j �� }t�d|tj�}|sd| _dS t|�d��dks%J �|�d�� � | _dS )z�
Set self.signature to signature keyID
This only applies to decrypted files. If the file was not
signed, set self.signature to None.
r s ^\[GNUPG:\] GOODSIG ([0-9A-F]*)NrB � )
rL rs rf r= r4 �M� signaturerg r6 �decode)r! �
status_buf�matchr r r r} : s
�
zGPGFile.set_signaturec C s | j sJ �| jS )z=
Return keyID of signature, or None if none
)rM r� rp r r r �
get_signatureK s
zGPGFile.get_signatureN)rd )
r
r r r r" rf rY rq rs ri rZ r} r� r r r r r@ t s
r " r@ � � � @ c s� ddl m} � fdd�}� fdd�}|d }|| } td|�� �|�}
d} zD | |� } | | �� k r3nz| �� j}
W n tyE d } Y nw |
�|
� q'|
�| � � � | sc|� }||k rc||| |
� |
�
� | W S t yu |
�
� � w )
aJ
Write GPG compressed file of given size
This function writes a gpg compressed file by reading from the
input iter and writing to filename. When it has read an amount
close to the size limit, it "tops off" the incoming data with
incompressible data, to try to hit the limit exactly.
block_iter should have methods .next(size), which returns the next
block of data, which should be at most size bytes long. Also
.get_footer() returns a string to write at the end of the input
file. The footer should have max length max_footer_size.
Because gpg uses compression, we don't assume that putting
bytes_in bytes into gpg will result in bytes_out = bytes_in out.
However, do assume that bytes_out <= bytes_in approximately.
Returns true if succeeded in writing until end of block_iter.
r )�pathc s. t � d�}t�||j| �| ksJ �|�� dS )z�
Add bytelen of incompressible data to to_gpg_fp
In this case we take the incompressible data from the
beginning of filename (it should contain enough because size
>> largest block size).
rJ N)rX r � copyfileobjr[ rZ )�bytelen�file�incompressible_fp��filenamer r �top_offm s
z GPGWriteFile.<locals>.top_offc s t �� �jS re )�os�stat�st_sizer r� r r �get_current_sizey s z&GPGWriteFile.<locals>.get_current_sizei � TrB ) � duplicityr� r@ �Path�
get_read_size�__next__�data�
StopIterationrY �
get_footerrZ rh )�
block_iterr� r` �size�max_footer_sizer� r� r� � target_size� data_sizer� �at_end_of_blockiter� bytes_to_gor� �cursizer r� r � GPGWriteFileS s>
�
� �r� Tc
C s� G dd� dt �}|t|d��}|rt�ddd|�}n|}d} ||j }|| �� k r+nzt| �} W n ty< d}Y nw |�| j � q |�
� sL|�
� rNJ �|S ) a�
Write gzipped compressed file of given size
This is like the earlier GPGWriteFile except it writes a gzipped
file instead of a gpg'd file. This function is somewhat out of
place, because it doesn't deal with GPG at all, but it is very
similar to GPGWriteFile so they might as well be defined together.
The input requirements on block_iter and the output is the same as
GPGWriteFile (returns true if wrote until end of block_iter).
c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) z"GzipWriteFile.<locals>.FileCountedzP
Wrapper around file object that counts number of bytes written
c S s || _ d| _d S )Nr )�fileobjrT )r! r� r r r r" � s
z+GzipWriteFile.<locals>.FileCounted.__init__c S s" | j �|�}| jt|�7 _|S re )r� rY rT rg )r! ro �resultr r r rY � s z(GzipWriteFile.<locals>.FileCounted.writec S s
| j �� S re )r� rZ rp r r r rZ � s
z(GzipWriteFile.<locals>.FileCounted.closeN)r
r r r r" rY rZ r r r r � FileCounted� s
r� rF N� r TrB ) r rX �gzip�GzipFilerT r� r r� rY r� rZ )
r� r� r� �gzippedr� � file_counted�outfiler� r� � new_blockr r r �
GzipWriteFile� s(
� � r� Fc C s t | |||�S )a�
Write plain uncompressed file of given size
This is like the earlier GPGWriteFile except it writes a gzipped
file instead of a gpg'd file. This function is somewhat out of
place, because it doesn't deal with GPG at all, but it is very
similar to GPGWriteFile so they might as well be defined together.
The input requirements on block_iter and the output is the same as
GPGWriteFile (returns true if wrote until end of block_iter).
)r� )r� r� r� r� r r r �PlainWriteFile� s r� rB c C sv |� d�}| dkr
t� }n| dkrt� }nJ d| f �� |�t�}|s%n|�|� q |�� r1J �|r7|�� S |�� S )z�
Return hash of path
hash should be "MD5" or "SHA1". The output will be in hexadecimal
form if hex is true, and in text (base64) otherwise.
rJ �SHA1�MD5r zUnknown hash %s) rX r r
rf r �updaterZ � hexdigest�digest)�hashr� �hexr{ �hash_objro r r r �get_hash� s
� r� )r� r� )r� T)r� FrC ) r �builtinsr r r r� rl rN r= r� rw r� r r r r �hashlibr r
� ImportError�shar r rh r r r@ r� r� r� r� r r r r �<module> s@ �8 a
�
G
3