Current File : //usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyc
�
Bd\Rc @ s� d Z d Z d d g Z d d l Z d d l m Z d d l m Z m Z m Z d d l
Td d d � � YZ d
� Z d � Z
d S(
sr
RSA digital signature protocol according to PKCS#1 v1.5
See RFC3447__ or the `original RSA Labs specification`__.
This scheme is more properly called ``RSASSA-PKCS1-v1_5``.
For example, a sender may authenticate a message using SHA-1 like
this:
>>> from Crypto.Signature import PKCS1_v1_5
>>> from Crypto.Hash import SHA
>>> from Crypto.PublicKey import RSA
>>>
>>> message = 'To be signed'
>>> key = RSA.importKey(open('privkey.der').read())
>>> h = SHA.new(message)
>>> signer = PKCS1_v1_5.new(key)
>>> signature = signer.sign(h)
At the receiver side, verification can be done using the public part of
the RSA key:
>>> key = RSA.importKey(open('pubkey.der').read())
>>> h = SHA.new(message)
>>> verifier = PKCS1_v1_5.new(key)
>>> if verifier.verify(h, signature):
>>> print "The signature is authentic."
>>> else:
>>> print "The signature is not authentic."
:undocumented: __revision__, __package__
.. __: http://www.ietf.org/rfc/rfc3447.txt
.. __: http://www.rsa.com/rsalabs/node.asp?id=2125
s $Id$t newt PKCS115_SigSchemei����N( t ceil_div( t DerSequencet DerNullt DerOctetString( t *c B s2 e Z d Z d � Z d � Z d � Z d � Z RS( sL This signature scheme can perform PKCS#1 v1.5 RSA signature or verification.c C s
| | _ d S( s Initialize this PKCS#1 v1.5 signature scheme object.
:Parameters:
key : an RSA key object
If a private half is given, both signature and verification are possible.
If a public half is given, only verification is possible.
N( t _key( t selft key( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyt __init__G s c C s
| j j � S( sC Return True if this cipher object can be used for signing messages.( R t has_private( R ( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyt can_signQ s c C sm t j j j | j j � } t | d � } t | | � } | j j | � } t d � | t
| � | } | S( sz Produce the PKCS#1 v1.5 signature of a message.
This function is named ``RSASSA-PKCS1-V1_5-SIGN``, and is specified in
section 8.2.1 of RFC3447.
:Parameters:
mhash : hash object
The hash that was carried out over the message. This is an object
belonging to the `Crypto.Hash` module.
:Return: The signature encoded as a string.
:Raise ValueError:
If the RSA key length is not sufficiently long to deal with the given
hash algorithm.
:Raise TypeError:
If the RSA key has no private half.
i i ( t Cryptot Utilt numbert sizeR t nR t EMSA_PKCS1_V1_5_ENCODEt decryptt bchrt len( R t mhasht modBitst kt emt mt S( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyt signU s c C s� t j j j | j j � } t | d � } t | � | k r@ d S| j j | d � d } t d � | t | � | } y t
| | � } Wn t k
r� d SX| | k S( s� Verify that a certain PKCS#1 v1.5 signature is authentic.
This function checks if the party holding the private half of the key
really signed the message.
This function is named ``RSASSA-PKCS1-V1_5-VERIFY``, and is specified in
section 8.2.2 of RFC3447.
:Parameters:
mhash : hash object
The hash that was carried out over the message. This is an object
belonging to the `Crypto.Hash` module.
S : string
The signature that needs to be validated.
:Return: True if verification is correct. False otherwise.
i i ( R
R R R R R R R t encryptR R t
ValueError( R R R R R R t em1t em2( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyt verifyu s
( t __name__t
__module__t __doc__R
R R R! ( ( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyR D s
c C s� t | j t � j � g � } t | j � � } t | j � | j � g � j � } | t | � d k r� t d t | � � � n t d � | t | � d } t d � | t d � | S( s@
Implement the ``EMSA-PKCS1-V1_5-ENCODE`` function, as defined
in PKCS#1 v2.1 (RFC3447, 9.2).
``EMSA-PKCS1-V1_5-ENCODE`` actually accepts the message ``M`` as input,
and hash it internally. Here, we expect that the message has already
been hashed instead.
:Parameters:
hash : hash object
The hash object that holds the digest of the message being signed.
emLen : int
The length the final encoding must have, in bytes.
:attention: the early standard (RFC2313) stated that ``DigestInfo``
had to be BER-encoded. This means that old signatures
might have length tags in indefinite form, which
is not supported in DER. Such encoding cannot be
reproduced by this function.
:attention: the same standard defined ``DigestAlgorithm`` to be
of ``AlgorithmIdentifier`` type, where the PARAMETERS
item is optional. Encodings for ``MD2/4/5`` without
``PARAMETERS`` cannot be reproduced by this function.
:Return: An ``emLen`` byte long string that encodes the hash.
i s8 Selected hash algorith has a too long digest (%d bytes).i� i t i (
R t oidR t encodeR t digestR R R t b( t hasht emLent
digestAlgoR( t
digestInfot PS( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyR � s 0 c C s
t | � S( sH Return a signature scheme object `PKCS115_SigScheme` that
can be used to perform PKCS#1 v1.5 signature or verification.
:Parameters:
key : RSA key object
The key to use to sign or verify the message. This is a `Crypto.PublicKey.RSA` object.
Signing is only possible if *key* is a private RSA key.
( R ( R ( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyR � s
( ( R$ t __revision__t __all__t Crypto.Util.numberR
R t Crypto.Util.asn1R R R t Crypto.Util.py3compatR R R ( ( ( sA /usr/lib64/python2.7/site-packages/Crypto/Signature/PKCS1_v1_5.pyt <module>: s
_ >
Mini Shell