Warning: session_start(): Session cannot be started after headers have already been sent in /home/tvrreohg/public_html/manga.php on line 13
3
1j @ s0 d dl Z d dlZd dlZd dlmZmZ d dlmZmZm Z m
Z
m Z m Z d dl
mZmZmZmZmZmZmZmZmZmZ ddlmZ ddlmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z# G dd d Z$d
Z%e&e&d d d
Z'G dd dZ(G dd dZ)G dd deZ*G dd de+eZ,G dd dZ-G dd dZ.dS ) N)EnumIntEnum)AnyDictOptionalTupleUnioncast)
CryptAES CryptBase
CryptIdentityCryptRC4aes_cbc_decryptaes_cbc_encryptaes_ecb_decryptaes_ecb_encrypt rc4_decrypt rc4_encrypt )logger_warning) ArrayObjectByteStringObjectDictionaryObject
NameObject NumberObject PdfObject StreamObjectTextStringObjectcreate_string_objectc @ s@ e Zd ZeeeddddZeedddZeeddd ZdS )
CryptFilterN) stm_crypt str_cryptef_cryptreturnc C s || _ || _|| _d S )N)r r! r" )selfr r! r" r% 2/tmp/pip-build-_d5lkt3n/pypdf/pypdf/_encryption.py__init__= s zCryptFilter.__init__)objr# c s t |tr jj|j}t|}t |trD jj|j }t|}nt |trt }|j| |j j
j|j x"|j D ]\}} j
|||< q|W |}nZt |trt }x"|j D ]\}} j
|||< qW |}n t |trt fdd|D }|S )Nc 3 s | ]} j |V qd S )N)encrypt_object).0x)r$ r% r& [ s z-CryptFilter.encrypt_object..)
isinstancer r! Zencryptoriginal_bytesr Zget_encoded_bytesr updateset_datar _dataitemsr) r r )r$ r( dataobj2keyvaluer% )r$ r& r) G s*
zCryptFilter.encrypt_objectc C s t |ttfr&| jj|j}t|}nt |trf| jj|j |_ x|j
D ]\}}| j |||< qJW nbt |t rxV|j
D ]\}}| j |||< qzW n2t |t
rx&tt|D ]}| j || ||< qW |S )N)r- r r r! Zdecryptr. r r r r1 r2 decrypt_objectr r rangelen)r$ r( r3 r5 r6 ir% r% r& r7 ^ s
zCryptFilter.decrypt_object)__name__
__module__ __qualname__r r' r r) r7 r% r% r% r& r < s r s (N^NuAd NV.. h>/ dSiz)r3 r# c C s | t d d S )N )_PADDING)r3 r% r% r& _paddingu s r@ c @ s e Zd ZeeeeeeeeedddZeeeeedddZeeeeeddd Z eeeeed
d d Z
eeeeeeeeeed
ddZ eeeeeeeeeed ddZ dS )AlgV4)passwordrevkey_sizeo_entryP id1_entrymetadata_encryptedr# c C s t | }tj|}|j| |jtjd| |j| |dkrP| rP|jd |j } |d }
|dkrx&tdD ]} tj| d|
j } qrW | d|
S )u
Algorithm 2: Computing an encryption key.
a) Pad or truncate the password string to exactly 32 bytes. If the
password string is more than 32 bytes long,
use only its first 32 bytes; if it is less than 32 bytes long, pad it
by appending the required number of
additional bytes from the beginning of the following padding string:
< 28 BF 4E 5E 4E 75 8A 41 64 00 4E 56 FF FA 01 08
2E 2E 00 B6 D0 68 3E 80 2F 0C A9 FE 64 53 69 7A >
That is, if the password string is n bytes long, append
the first 32 - n bytes of the padding string to the end
of the password string. If the password string is empty
(zero-length), meaning there is no user password,
substitute the entire padding string in its place.
b) Initialize the MD5 hash function and pass the result of step (a)
as input to this function.
c) Pass the value of the encryption dictionary’s O entry to the
MD5 hash function. ("Algorithm 3: Computing
the encryption dictionary’s O (owner password) value" shows how the
O value is computed.)
d) Convert the integer value of the P entry to a 32-bit unsigned binary
number and pass these bytes to the
MD5 hash function, low-order byte first.
e) Pass the first element of the file’s file identifier array (the value
of the ID entry in the document’s trailer
dictionary; see Table 15) to the MD5 hash function.
f) (Security handlers of revision 4 or greater) If document metadata is
not being encrypted, pass 4 bytes with
the value 0xFFFFFFFF to the MD5 hash function.
g) Finish the hash.
h) (Security handlers of revision 3 or greater) Do the following
50 times: Take the output from the previous
MD5 hash and pass the first n bytes of the output as input into a new
MD5 hash, where n is the number of
bytes of the encryption key as defined by the value of the encryption
dictionary’s Length entry.
i) Set the encryption key to the first n bytes of the output from the
final MD5 hash, where n shall always be 5
for security handlers of revision 2 but, for security handlers of
revision 3 or greater, shall depend on the
value of the encryption dictionary’s Length entry.
Args:
password: The encryption secret as a bytes-string
rev: The encryption revision (see PDF standard)
key_size: The size of the key in bytes
o_entry: The owner entry
P: A set of flags specifying which operations shall be permitted
when the document is opened with user access. If bit 2 is set to 1,
all other bits are ignored and all operations are permitted.
If bit 2 is set to 0, permission for operations are based on the
values of the remaining flags defined in Table 24.
id1_entry:
metadata_encrypted: A boolean indicating if the metadata is encrypted.
Returns:
The u_hash digest of length key_size
zx tdD ]}tj|j }q(W |d|d }|S )u
Algorithm 3: Computing the encryption dictionary’s O (owner password) value.
a) Pad or truncate the owner password string as described in step (a)
of "Algorithm 2: Computing an encryption key".
If there is no owner password, use the user password instead.
b) Initialize the MD5 hash function and pass the result of step (a) as
input to this function.
c) (Security handlers of revision 3 or greater) Do the following 50 times:
Take the output from the previous
MD5 hash and pass it as input into a new MD5 hash.
d) Create an RC4 encryption key using the first n bytes of the output
from the final MD5 hash, where n shall
always be 5 for security handlers of revision 2 but, for security
handlers of revision 3 or greater, shall
depend on the value of the encryption dictionary’s Length entry.
e) Pad or truncate the user password string as described in step (a) of
"Algorithm 2: Computing an encryption key".
f) Encrypt the result of step (e), using an RC4 encryption function with
the encryption key obtained in step (d).
g) (Security handlers of revision 3 or greater) Do the following 19 times:
Take the output from the previous
invocation of the RC4 function and pass it as input to a new
invocation of the function; use an encryption
key generated by taking each byte of the encryption key obtained in
step (d) and performing an XOR
(exclusive or) operation between that byte and the single-byte value
of the iteration counter (from 1 to 19).
h) Store the output from the final invocation of the RC4 function as
the value of the O entry in the encryption dictionary.
Args:
owner_password:
rev: The encryption revision (see PDF standard)
key_size: The size of the key in bytes
Returns:
The RC4 key
rK rL NrJ )r@ rM rN rQ r8 )rW rC rD rR Z
o_hash_digestrU rc4_keyr% r% r& compute_O_value_key s )zAlgV4.compute_O_value_key)rX
user_passwordrC r# c sV t |}t| |}|dkrRx6tddD ]( tt fdd| D }t||}q&W |S )z
See :func:`compute_O_value_key`.
Args:
rc4_key:
user_password:
rev: The encryption revision (see PDF standard)
Returns:
The RC4 encrypted
rK r c 3 s | ]}| A V qd S )Nr% )r* r+ )r: r% r& r, s z(AlgV4.compute_O_value..)r@ r r8 bytes bytearray)rX rZ rC rR rc4_encr5 r% )r: r& compute_O_value s
zAlgV4.compute_O_value)r5 rC rG r# c sx |dkrt | t}|S tjt}|j| t | |j }x6tddD ]( tt fdd| D }t ||}qDW t |S )u
Algorithm 4: Computing the encryption dictionary’s U (user password) value.
(Security handlers of revision 2)
a) Create an encryption key based on the user password string, as
described in "Algorithm 2: Computing an encryption key".
b) Encrypt the 32-byte padding string shown in step (a) of
"Algorithm 2: Computing an encryption key", using an RC4 encryption
function with the encryption key from the preceding step.
c) Store the result of step (b) as the value of the U entry in the
encryption dictionary.
Args:
key:
rev: The encryption revision (see PDF standard)
id1_entry:
Returns:
The value
r r[ c 3 s | ]}| A V qd S )Nr% )r* r+ )r: r% r& r, N s z(AlgV4.compute_U_value..)
r r? rM rN r/ rQ r8 r\ r] r@ )r5 rC rG r6 rS r^ rX r% )r: r& compute_U_value s
zAlgV4.compute_U_value) rZ rC rD rE u_entryrF rG rH r# c
C sT t j| ||||||}t j|||} |dkrD| dd } |dd }| |krPd}|S )uq
Algorithm 6: Authenticating the user password.
a) Perform all but the last step of "Algorithm 4: Computing the
encryption dictionary’s U (user password) value (Security handlers of
revision 2)" or "Algorithm 5: Computing the encryption dictionary’s U
(user password) value (Security handlers of revision 3 or greater)"
using the supplied password string.
b) If the result of step (a) is equal to the value of the encryption
dictionary’s U entry (comparing on the first 16 bytes in the case of
security handlers of revision 3 or greater), the password supplied is
the correct user password. The key obtained in step (a) (that is, in
the first step of "Algorithm 4: Computing the encryption
dictionary’s U (user password) value
(Security handlers of revision 2)" or
"Algorithm 5: Computing the encryption dictionary’s U (user password)
value (Security handlers of revision 3 or greater)") shall be used
to decrypt the document.
Args:
user_password: The user password as a bytes stream
rev: The encryption revision (see PDF standard)
key_size: The size of the key in bytes
o_entry: The owner entry
u_entry: The user entry
P: A set of flags specifying which operations shall be permitted
when the document is opened with user access. If bit 2 is set to 1,
all other bits are ignored and all operations are permitted.
If bit 2 is set to 0, permission for operations are based on the
values of the remaining flags defined in Table 24.
id1_entry:
metadata_encrypted: A boolean indicating if the metadata is encrypted.
Returns:
The key
rK N )rA rV ra )
rZ rC rD rE rb rF rG rH r5 u_valuer% r% r& verify_user_passwordR s / zAlgV4.verify_user_password) rW rC rD rE rb rF rG rH r# c sx t j| ||}|dkr"t||} n>|} x8tdddD ]( tt fdd|D }
t|
| } q4W t j| |||||||S )uM
Algorithm 7: Authenticating the owner password.
a) Compute an encryption key from the supplied password string, as
described in steps (a) to (d) of
"Algorithm 3: Computing the encryption dictionary’s O (owner password)
value".
b) (Security handlers of revision 2 only) Decrypt the value of the
encryption dictionary’s O entry, using an RC4
encryption function with the encryption key computed in step (a).
(Security handlers of revision 3 or greater) Do the following 20 times:
Decrypt the value of the encryption dictionary’s O entry (first iteration)
or the output from the previous iteration (all subsequent iterations),
using an RC4 encryption function with a different encryption key at
each iteration. The key shall be generated by taking the original key
(obtained in step (a)) and performing an XOR (exclusive or) operation
between each byte of the key and the single-byte value of the
iteration counter (from 19 to 0).
c) The result of step (b) purports to be the user password.
Authenticate this user password using
"Algorithm 6: Authenticating the user password".
If it is correct, the password supplied is the correct owner password.
Args:
owner_password:
rev: The encryption revision (see PDF standard)
key_size: The size of the key in bytes
o_entry: The owner entry
u_entry: The user entry
P: A set of flags specifying which operations shall be permitted
when the document is opened with user access. If bit 2 is set to 1,
all other bits are ignored and all operations are permitted.
If bit 2 is set to 0, permission for operations are based on the
values of the remaining flags defined in Table 24.
id1_entry:
metadata_encrypted: A boolean indicating if the metadata is encrypted.
Returns:
bytes
r` r c 3 s | ]}| A V qd S )Nr% )r* r+ )r: r% r& r, s z.AlgV4.verify_owner_password..rh )rA rY r r8 r\ r] rf ) rW rC rD rE rb rF rG rH rX rZ r5 r% )r: r& verify_owner_password s 3 zAlgV4.verify_owner_passwordN)
r; r< r= staticmethodr\ intboolrV rY r_ ra rf ri r% r% r% r& rA y sF K2;0rA c
@ s e Zd ZeeeeeeedddZeeeeeedddZeeeeeeddd Zeeeee e d
d d Z
eeeeeee e e e f d
ddZ
eeeeeeef dddZeeeeeeeef dddZeeee edddZdS )AlgV5)RrB o_valueoe_valuere r# c C s |dd }t j| ||dd |dd |dd kr ( 0 rd c s s | ]
}d V qdS )r Nr% )r* rU r% r% r& r, s z.AlgV5.verify_owner_password..rc )rm calculate_hashr\ r8 r )rn rB ro rp re ivtmp_keyr5 r% r% r& ri s = zAlgV5.verify_owner_password)rn rB re ue_valuer# c C sn |dd }t j| ||dd d|dd kr4dS tdd tdD }t j| ||dd d}t|||S )
a"
See :func:`verify_owner_password`.
Args:
R: A number specifying which revision of the standard security
handler shall be used to interpret this dictionary
password: The user password
u_value: A 32-byte string, based on the user password, that shall be
used in determining whether to prompt the user for a password
and, if so, whether a valid user or owner password was entered.
ue_value:
Returns:
bytes
Nrq r> rr rd c s s | ]
}d V qdS )r Nr% )r* rU r% r% r& r, 3 s z-AlgV5.verify_user_password..rc rs )rm rt r\ r8 r )rn rB re rw ru rv r% r% r& rf s $zAlgV5.verify_user_password)rn rB saltudatar# c C s t j|| | j }| dk r"|S d}x|d7 }|| | }t|d d |dd |d }t jt jt jft|d d d }||j }|dkr(|d |d kr(P q(W |d d S ) N r r rc r> @ rK rh )rM sha256rQ r sha384sha512sum) rn rB rx ry kcountZk1eZhash_fnr% r% r& rt 7 s zAlgV5.calculate_hash)r5 permsprH r# c C s> |rdnd}t jd|d | d }t| |}||dd kS )at
See :func:`verify_owner_password` and :func:`compute_perms_value`.
Args:
key: The owner password
perms:
p: A set of flags specifying which operations shall be permitted
when the document is opened with user access.
If bit 2 is set to 1, all other bits are ignored and all
operations are permitted.
If bit 2 is set to 0, permission for operations are based on
the values of the remaining flags defined in Table 24.
metadata_encrypted:
Returns:
A boolean
T Fz.)secrets token_bytesrm rt r\ r8 r )
rn rB r5 random_bytesval_saltkey_saltre rv ru rw r% r% r& ra | s
zAlgV5.compute_U_value)rn rB r5 re r# c C s| t jd}|dd }|dd }tj| |||| | }tj| |||dd }tdd tdD } t|| |}
||
fS )u
Algorithm 3.9 Computing the encryption dictionary’s O (owner password)
and OE (owner encryption key) values.
1. Generate 16 random bytes of data using a strong random number
generator. The first 8 bytes are the Owner Validation Salt. The
second 8 bytes are the Owner Key Salt. Compute the 32-byte SHA-256
hash of the password concatenated with the Owner Validation Salt and
then concatenated with the 48-byte U string as generated in
Algorithm 3.8. The 48-byte string consisting of the 32-byte hash
followed by the Owner Validation Salt followed by the Owner Key Salt
is stored as the O key.
2. Compute the 32-byte SHA-256 hash of the password concatenated with
the Owner Key Salt and then concatenated with the 48-byte U string as
generated in Algorithm 3.8. Using this hash as the key,
encrypt the file encryption key using AES-256 in CBC mode with
no padding and an initialization vector of zero.
The resulting 32-byte string is stored as the OE key.
Args:
R:
password:
key:
u_value: A 32-byte string, based on the user password, that shall be
used in determining whether to prompt the user for a password
and, if so, whether a valid user or owner password was entered.
Returns:
A tuple (O value, OE value)
rc NrJ rs c s s | ]
}d V qdS )r Nr% )r* rU r% r% r& r, s z(AlgV5.compute_O_value..)r r rm rt r\ r8 r ) rn rB r5 re r r r ro rv ru rp r% r% r& r_ s "
zAlgV5.compute_O_value)r5 r rH r# c C s@ |rdnd}t jd}tjd|d | d | }t| |}|S )u
Algorithm 3.10 Computing the encryption dictionary’s Perms
(permissions) value.
1. Extend the permissions (contents of the P integer) to 64 bits by
setting the upper 32 bits to all 1’s.
(This allows for future extension without changing the format.)
2. Record the 8 bytes of permission in the bytes 0-7 of the block,
low order byte first.
3. Set byte 8 to the ASCII value ' T ' or ' F ' according to the
EncryptMetadata Boolean.
4. Set bytes 9-11 to the ASCII characters ' a ', ' d ', ' b '.
5. Set bytes 12-15 to 4 bytes of random data, which will be ignored.
6. Encrypt the 16-byte block using AES-256 in ECB mode with an
initialization vector of zero, using the file encryption key as the
key. The result (16 bytes) is stored as the Perms string, and checked
for validity when the file is opened.
Args:
key:
p: A set of flags specifying which operations shall be permitted
when the document is opened with user access. If bit 2 is set to 1,
all other bits are ignored and all operations are permitted.
If bit 2 is set to 0, permission for operations are based on the
values of the remaining flags defined in Table 24.
metadata_encrypted: A boolean indicating if the metadata is encrypted.
Returns:
The perms value
r r rI z tk
r6 | jd}Y q>X n| }|S )Nzlatin-1zutf-8)r- strencode Exception)rB pwdr% r% r& _encode_password s
zEncryption._encode_passwordc C sF | j |}| jdkr | j|n| j|\}}|tjkrB|| _|| _|S )NrI )r r verify_v4 verify_v5r r r r )r$ rB r r5 rcr% r% r& verify s
"
zEncryption.verifyc C sz t j|| j| j| jj| jj| j| j| j }|r8|t
j fS t j || j| j| jj| jj| j| j| j }|rp|t
j
fS dt
jfS )Nrd )rA ri rn r r r r rF rG r r r rf r r )r$ rB r5 r% r% r& r s.
zEncryption.verify_v4c C s t j| j|| jj| jj| jj}tj}|sJt j | j|| jj| jj
}tj }|sXdtj fS t j
|| jj| j| jsztdt ||fS )Nrd z ignore '/Perms' verify failed)rm ri rn r r r r r r rf r r r r r rF r r r; )r$ rB r5 r r% r% r& r s
zEncryption.verify_v5)rZ rW r# c C s | j |}|r| j |nd }|d kr(|}| jdkr@| j|| njtj| jd | _tj| j ||| j| j
| j }|d | j _
|d | j _|d | j _|d | j _|d | j _t }t| j|td< t| j |td < t| j|td
< t| j
|td < td |td
< t| j j
|td< t| j j|td< | jdkrt }td|td< t| j|td< t| jd |td
< t }||td< ||td< td|td< td|td< | jdkr t| j j|td< t| j j|td< t| j j|td< |S )NrI rJ z/Oz/Uz/OEz/UEz/Permsz/Vz/Rz/Lengthz/Pz /Standardz/Filterz/DocOpenz
/AuthEventz/CFMz/StdCFz/CFz/StmFz/StrFr )r r compute_values_v4r r r r rm r rn rF r r r r r r r r r r r r ) r$ rZ rW Zuser_pwdZ owner_pwdr dict_objZstd_cfr r% r% r& write_entry sJ
zEncryption.write_entryc C sn t j|| j| j}t j||| j}t j|| j| j|| j| j| j}t j || j| j}|| _
|| j _ || j _
d S )N)rA rY rn r r_ rV rF rG r ra r r r r )r$ rZ rW rX ro r5 re r% r% r& r # s z Encryption.compute_values_v4)encryption_entryr r# c
C s | j ddkrtdd| kr&tdd}d}d}| j dd}|d(krVtd| d|d kr| d }| j dd}| j dd}| j d|}|dkr|| d }|dkr|| d }|dkr|| d }d)}||krtd| d||k rtd| d||krtd| dtt| d }tt| d } | j d d }
| j d } | d k rZ| jnd!} t } tt| d" j| _tt| d# j| _ | j d$t j| _
| j d%t j| _ | j d&t j| _ t
|||
| | || |||| d' S )*Nz/Filterz /Standardz1only Standard PDF encryption handler is availablez
/SubFilterz/SubFilter NOT supported/V2z/Vr r r` rK rI r z
Encryption V=z NOT supportedz/CFz/StmF /Identityz/StrFz/EFFz/CFM/AESV2/AESV3z StmF Method z NOT supported!z StrF Method z EFF Method z/Rz/Pz/Lengthrr z/EncryptMetadataTz/Oz/Uz/OEz/UEz/Perms) r rn r rF r r r r r r r )r r` rK rI r )r r r r )getNotImplementedErrorr rk r6 r r r. r r r r r r )
r r
stm_filter
str_filter ef_filteralg_verfiltersZallowed_methodsalg_revZ
perm_flagskey_bitsZencrypt_metadatar r% r% r& read6 sh
zEncryption.read)alg permissionsr r# c
C sd | \}}}d\}}}| t jkr*d\}}}n| t jt jfkrDd\}}}t||||d|d |||t d S ) N/V2/AESV2/AESV3T) r rn r rF 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% r% r& makew s$
zEncryption.make)"r; r< r= __doc__rk r rl r\ r r r r' r r r) r7 rj r r r r r r r r r r r r r r r r r r% r% r% r& r sF >
2@r )/rM r rO enumr r typingr r r r r r Zpypdf._crypt_providersr
r r r
r r r r r r _utilsr Zgenericr r r r r r r r r r r? r\ r@ rA rm r tupler r r r% r% r% r& s( 0
,
4 ] "