File: //lib/python2.7/site-packages/rsa/pkcs1.pyc
�
N$�_c @ s� d Z d d l Z d d l Z d d l m Z d d l m Z m Z m Z i d d 6d d 6d d
6d d 6d
d 6d d 6Z i e j
d 6e j d 6e j d
6e j
d 6e j d 6e j d 6Z d e f d � � YZ d e f d � � YZ d e f d � � YZ d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d! � Z d" d# d$ d% d d d g Z e! d& k r�d' GHd d l" Z" xR e d( � D]D Z# e" j$ � \ Z% Z& e% r�Pn e# d) d* k r�e# r�d+ e# GHq�q�Wd, GHn d S(- sb Functions for PKCS#1 version 1.5 encryption and signing
This module implements certain functionality from PKCS#1 version 1.5. For a
very clear example, read http://www.di-mgt.com.au/rsa_alg.html#pkcs1schemes
At least 8 bytes of random padding is used when encrypting a message. This makes
these methods much more secure than the ones in the ``rsa`` module.
WARNING: this module leaks information when decryption fails. The exceptions
that are raised contain the Python traceback information, which can be used to
deduce where in the process the failure occurred. DO NOT PASS SUCH INFORMATION
to your users.
i����N( t range( t commont transformt cores 0 0 *�H��
t MD5s 0!0 + s SHA-1s 0-0
`�He s SHA-224s 010
`�He s SHA-256s 0A0
`�He 0s SHA-384s 0Q0
`�He @s SHA-512t CryptoErrorc B s e Z d Z RS( s- Base class for all exceptions in this module.( t __name__t
__module__t __doc__( ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyR 9 s t DecryptionErrorc B s e Z d Z RS( s Raised when decryption fails.( R R R ( ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyR = s t VerificationErrorc B s e Z d Z RS( s Raised when verification fails.( R R R ( ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyR
A s c C s� | d } t | � } | | k r; t d | | f � � n d } | | d } xY t | � | k r� | t | � } t j | d � } | j d d � } | | | } qR Wt | � | k s� t � d j d | d | g � S( s Pads the message for encryption, returning the padded message.
:return: 00 02 RANDOM_DATA 00 MESSAGE
>>> block = _pad_for_encryption(b'hello', 16)
>>> len(block)
16
>>> block[0:2]
b'\x00\x02'
>>> block[-6:]
b'\x00hello'
i s; %i bytes needed for message, but there is only space for %it i i t t ( t lent
OverflowErrort ost urandomt replacet AssertionErrort join( t messaget
target_lengtht
max_msglengtht msglengtht paddingt padding_lengtht needed_bytest new_padding( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt _pad_for_encryptionE s"
c C sf | d } t | � } | | k r; t d | | f � � n | | d } d j d | d d | g � S( sj Pads the message for signing, returning the padded message.
The padding is always a repetition of FF bytes.
:return: 00 01 PADDING 00 MESSAGE
>>> block = _pad_for_signing(b'hello', 16)
>>> len(block)
16
>>> block[0:2]
b'\x00\x01'
>>> block[-6:]
b'\x00hello'
>>> block[2:-6]
b'\xff\xff\xff\xff\xff\xff\xff\xff'
i s; %i bytes needed for message, but there is only space for %ii R t s �R ( R R R ( R R R R R ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt _pad_for_signings s
c C sa t j | j � } t | | � } t j | � } t j | | j | j � } t j | | � } | S( s� Encrypts the given message using PKCS#1 v1.5
:param message: the message to encrypt. Must be a byte string no longer than
``k-11`` bytes, where ``k`` is the number of bytes needed to encode
the ``n`` component of the public key.
:param pub_key: the :py:class:`rsa.PublicKey` to encrypt with.
:raise OverflowError: when the message is too large to fit in the padded
block.
>>> from rsa import key, common
>>> (pub_key, priv_key) = key.newkeys(256)
>>> message = b'hello'
>>> crypto = encrypt(message, pub_key)
The crypto text should be just as long as the public key 'n' component:
>>> len(crypto) == common.byte_size(pub_key.n)
True
(
R t byte_sizet nR R t bytes2intR t encrypt_intt et int2bytes( R t pub_keyt keylengtht paddedt payloadt encryptedt block( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt encrypt� s c C s� t j | j � } t j | � } | j | � } t j | | � } t | � | k rc t d � � n | d d !d k r� t d � � n y | j d d � } Wn t
k
r� t d � � n X| | d S( sa Decrypts the given message using PKCS#1 v1.5
The decryption is considered 'failed' when the resulting cleartext doesn't
start with the bytes 00 02, or when the 00 byte between the padding and
the message cannot be found.
:param crypto: the crypto text as returned by :py:func:`rsa.encrypt`
:param priv_key: the :py:class:`rsa.PrivateKey` to decrypt with.
:raise DecryptionError: when the decryption fails. No details are given as
to why the code thinks the decryption fails, as this would leak
information about the private key.
>>> import rsa
>>> (pub_key, priv_key) = rsa.newkeys(256)
It works with strings:
>>> crypto = encrypt(b'hello', pub_key)
>>> decrypt(crypto, priv_key)
b'hello'
And with binary data:
>>> crypto = encrypt(b'\x00\x00\x00\x00\x01', pub_key)
>>> decrypt(crypto, priv_key)
b'\x00\x00\x00\x00\x01'
Altering the encrypted information will *likely* cause a
:py:class:`rsa.pkcs1.DecryptionError`. If you want to be *sure*, use
:py:func:`rsa.sign`.
.. warning::
Never display the stack trace of a
:py:class:`rsa.pkcs1.DecryptionError` exception. It shows where in the
code the exception occurred, and thus leaks information about the key.
It's only a tiny bit of information, but every bit makes cracking the
keys easier.
>>> crypto = encrypt(b'hello', pub_key)
>>> crypto = crypto[0:5] + b'X' + crypto[6:] # change a byte
>>> decrypt(crypto, priv_key)
Traceback (most recent call last):
...
rsa.pkcs1.DecryptionError: Decryption failed
s Decryption failedi i R
R i ( R R R! R R" t blinded_decryptR% R R t indext
ValueError( t cryptot priv_keyt blocksizeR* t decryptedt cleartextt sep_idx( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt decrypt� s 3
c
C s� | t k r t d | � � n t | } | | } t j | j � } t | | � } t j | � } | j | � } t j | | � } | S( s� Signs a precomputed hash with the private key.
Hashes the message, then signs the hash with the given key. This is known
as a "detached signature", because the message itself isn't altered.
:param hash_value: A precomputed hash to sign (ignores message). Should be set to
None if needing to hash and sign message.
:param priv_key: the :py:class:`rsa.PrivateKey` to sign with
:param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
:return: a message signature block.
:raise OverflowError: if the private key is too small to contain the
requested hash.
s Invalid hash method: %s(
t HASH_ASN1R/ R R R! R R R" t blinded_encryptR% (
t
hash_valueR1 t hash_methodt asn1codeR4 R' R( R) R* R+ ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt sign_hash s
c C s t | | � } t | | | � S( s� Signs the message with the private key.
Hashes the message, then signs the hash with the given key. This is known
as a "detached signature", because the message itself isn't altered.
:param message: the message to sign. Can be an 8-bit string or a file-like
object. If ``message`` has a ``read()`` method, it is assumed to be a
file-like object.
:param priv_key: the :py:class:`rsa.PrivateKey` to sign with
:param hash_method: the hash method used on the message. Use 'MD5', 'SHA-1',
'SHA-224', SHA-256', 'SHA-384' or 'SHA-512'.
:return: a message signature block.
:raise OverflowError: if the private key is too small to contain the
requested hash.
( t compute_hashR< ( R R1 R: t msg_hash( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt sign" s c C s� t j | j � } t j | � } t j | | j | j � } t j | | � } t | � } t
| | � } t | | } t | | � }
t
| � | k r� t d � � n |
| k r� t d � � n | S( sJ Verifies that the signature matches the message.
The hash method is detected automatically from the signature.
:param message: the signed message. Can be an 8-bit string or a file-like
object. If ``message`` has a ``read()`` method, it is assumed to be a
file-like object.
:param signature: the signature block, as created with :py:func:`rsa.sign`.
:param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
:raise VerificationError: when the signature doesn't match the message.
:returns: the name of the used hash.
s Verification failed( R R R! R R" R t decrypt_intR$ R% t _find_method_hashR= R7 R R R
( R t signatureR& R' R* R3 t clearsigt method_namet message_hashR4 t expected( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt verify8 s c C sX t j | j � } t j | � } t j | | j | j � } t j | | � } t | � S( s� Returns the hash name detected from the signature.
If you also want to verify the message, use :py:func:`rsa.verify()` instead.
It also returns the name of the used hash.
:param signature: the signature block, as created with :py:func:`rsa.sign`.
:param pub_key: the :py:class:`rsa.PublicKey` of the person signing the message.
:returns: the name of the used hash.
(
R R R! R R" R R@ R$ R% RA ( RB R& R' R* R3 RC ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt find_signature_hash^ s
c c sQ xJ t rL | j | � } t | � } | d k r4 Pn | V| | k r Pq q Wd S( s� Generator, yields each block of ``blocksize`` bytes in the input file.
:param infile: file to read and separate in blocks.
:param blocksize: block size in bytes.
:returns: a generator that yields the contents of each block
i N( t Truet readR ( t infileR2 R+ t
read_bytes( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt yield_fixedblocksq s c C s� | t k r t d | � � n t | } | � } t | d � r} t | j d � r} x4 t | d � D] } | j | � qc Wn
| j | � | j � S( s4 Returns the message digest.
:param message: the signed message. Can be an 8-bit string or a file-like
object. If ``message`` has a ``read()`` method, it is assumed to be a
file-like object.
:param method_name: the hash method, must be a key of
:py:const:`HASH_METHODS`.
s Invalid hash method: %sRJ t __call__i ( t HASH_METHODSR/ t hasattrRJ RM t updatet digest( R RD t methodt hasherR+ ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyR= � s
!
c C s= x* t j � D] \ } } | | k r
| Sq
Wt d � � d S( s� Finds the hash method.
:param clearsig: full padded ASN1 and hash.
:return: the used hash method.
:raise VerificationFailed: when the hash method cannot be found
s Verification failedN( R7 t itemsR
( RC t hashnameR; ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyRA � s R, R6 R? RG t __main__s' Running doctests 1000x or until failurei� id i s %i timess
Doctests done(' R t hashlibR t rsa._compatR t rsaR R R R7 t md5t sha1t sha224t sha256t sha384t sha512RO t ExceptionR R R
R R R, R6 R< R? RG RH RM R= RA t __all__R t doctestt countt testmodt failurest tests( ( ( s- /usr/lib/python2.7/site-packages/rsa/pkcs1.pyt <module> sX
. " K " &