/opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey
Edit: /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyc (14807B)
Bd\Rc @ s d Z d Z d d d d d g Z d d k Z e i d d
j o" e i d d j o d d k Tn d d
k l Z l Z l Z d d k
l Z y d d k l Z Wn e
j
o
d Z n Xd e i f d YZ d e f d YZ e Z e i Z e i Z e i Z d S( sx DSA public-key signature algorithm.
DSA_ is a widespread public-key signature algorithm. Its security is
based on the discrete logarithm problem (DLP_). Given a cyclic
group, a generator *g*, and an element *h*, it is hard
to find an integer *x* such that *g^x = h*. The problem is believed
to be difficult, and it has been proved such (and therefore secure) for
more than 30 years.
The group is actually a sub-group over the integers modulo *p*, with *p* prime.
The sub-group order is *q*, which is prime too; it always holds that *(p-1)* is a multiple of *q*.
The cryptographic strength is linked to the magnitude of *p* and *q*.
The signer holds a value *x* (*0
>> from Crypto.Random import random
>>> from Crypto.PublicKey import DSA
>>> from Crypto.Hash import SHA
>>>
>>> message = "Hello"
>>> key = DSA.generate(1024)
>>> h = SHA.new(message).digest()
>>> k = random.StrongRandom().randint(1,key.q-1)
>>> sig = key.sign(h,k)
>>> ...
>>> if key.verify(h,sig):
>>> print "OK"
>>> else:
>>> print "Incorrect signature"
.. _DSA: http://en.wikipedia.org/wiki/Digital_Signature_Algorithm
.. _DLP: http://www.cosic.esat.kuleuven.be/publications/talk-78.pdf
.. _ECRYPT: http://www.ecrypt.eu.org/documents/D.SPA.17.pdf
s $Id$t generatet constructt errort DSAImplementationt _DSAobjiNi i i ( t *( t _DSAt _slowmatht pubkey( t Random( t _fastmathc B s e Z d Z d d d d d g Z d Z d Z d Z d Z d
Z d Z d Z
d
Z d Z d Z
d Z d Z d Z d Z d Z d Z d Z d Z d Z RS( sl Class defining an actual DSA key.
:undocumented: __getstate__, __setstate__, __repr__, __getattr__
t yt gt pt qt xc C s | | _ | | _ d S( N( t implementationt key( t selfR R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt __init__s s c C sA | | i j o t | i | St d | i i | f d S( Ns %s object has no %r attribute( t keydatat getattrR t AttributeErrort __class__t __name__( R t attrname( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt __getattr__w s c C s t i i | | | S( s Sign a piece of data with DSA.
:Parameter M: The piece of data to sign with DSA. It may
not be longer in bit size than the sub-group order (*q*).
:Type M: byte string or long
:Parameter K: A secret number, chosen randomly in the closed
range *[1,q-1]*.
:Type K: long (recommended) or byte string (not recommended)
:attention: selection of *K* is crucial for security. Generating a
random number larger than *q* and taking the modulus by *q* is
**not** secure, since smaller values will occur more frequently.
Generating a random number systematically smaller than *q-1*
(e.g. *floor((q-1)/8)* random bytes) is also **not** secure. In general,
it shall not be possible for an attacker to know the value of `any
bit of K`__.
:attention: The number *K* shall not be reused for any other
operation and shall be discarded immediately.
:attention: M must be a digest cryptographic hash, otherwise
an attacker may mount an existential forgery attack.
:Return: A tuple with 2 longs.
.. __: http://www.di.ens.fr/~pnguyen/pub_NgSh00.htm
( R t sign( R t Mt K( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR s c C s t i i | | | S( sE Verify the validity of a DSA signature.
:Parameter M: The expected message.
:Type M: byte string or long
:Parameter signature: The DSA signature to verify.
:Type signature: A tuple with 2 longs as return by `sign`
:Return: True if the signature is correct, False otherwise.
( R t verify( R R t signature( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR s c C s t d d S( Ns DSA cannot encrypt( t TypeError( R t cR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt _encrypt s c C s t d d S( Ns DSA cannot decrypt( R ( R R! ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt _decrypt s c C s t d d S( Ns DSA cannot blind( R ( R t mt r( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt _blind s c C s t d d S( Ns DSA cannot unblind( R ( R R$ R% ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt _unblind s c C s | i i | | S( N( R t _sign( R R$ t k( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR( s c C s" | \ } } | i i | | | S( N( R t _verify( R R$ t sigR% t s( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR* s c C s
| i i S( N( R t has_private( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR- s c C s
| i i S( N( R t size( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR. s c C s t S( N( t False( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt can_blind s c C s t S( N( R/ ( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt can_encrypt s c C s t S( N( t True( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt can_sign s c C s4 | i i | i i | i i | i i | i i f S( N( R R R R R R
R ( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt publickey s c C sN h } xA | i D]6 } y t | i | | | t ,(
R R9 R. R7 R R- R R t idt join( R t attrsR) ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt __repr__ s
"
( R t
__module__t __doc__R R R R R R" R# R& R' R( R* R- R. R0 R1 R3 R4 R6 R> RD ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR ` s*
c B sG e Z d Z d Z d Z d d d Z d d d Z d Z RS( s
A DSA key factory.
This class is only internally used to implement the methods of the
`Crypto.PublicKey.DSA` module.
c K s | i d d } | d j o' t d j o
t | _ q t | _ n; | o* t d j o
t | _ q t d n
t | _ | i i | _ | i d d | _ d | _ d S( s Create a new DSA key factory.
:Keywords:
use_fast_math : bool
Specify which mathematic library to use:
- *None* (default). Use fastest math available.
- *True* . Use fast math.
- *False* . Use slow math.
default_randfunc : callable
Specify how to collect random data:
- *None* (default). Use Random.new().read().
- not *None* . Use the specified function directly.
:Raise RuntimeError:
When **use_fast_math** =True but fast math is not available.
t
use_fast_maths fast math module not availablet default_randfuncN( t gett NoneR
R: R t RuntimeErrorR t _default_randfunct _current_randfunc( R t kwargsRG ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR s
c C s? | d j o | S| i d j o t i i | _ n | i S( N( RJ RM R t newt read( R t randfunc( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt
_get_randfunc! s
c C sQ x7 d D]/ } | d
d | j o | i | | | Sq Wt d | f d
S( s Randomly generate a fresh, new DSA key.
:Parameters:
bits : int
Key length, or size (in bits) of the DSA modulus
*p*.
It must be a multiple of 64, in the closed
interval [512,1024].
randfunc : callable
Random number generation function; it should accept
a single integer N and return a string of random data
N bytes long.
If not specified, a new one will be instantiated
from ``Crypto.Random``.
progress_func : callable
Optional function that will be called with a short string
containing the key parameter currently being generated;
it's useful for interactive applications where a user is
waiting for a key to be generated.
:attention: You should always use a cryptographically secure random number generator,
such as the one defined in the ``Crypto.Random`` module; **don't** just use the
current time and the ``random`` module.
:Return: A DSA key object (`_DSAobj`).
:Raise ValueError:
When **bits** is too little, too big, or not a multiple of 64.
i i i i i i i i i i i@ sN Number of bits in p must be a multiple of 64 between 512 and 1024, not %d bitsN( i i i i i i i i i ( t _generatet
ValueError( R t bitsRQ t
progress_funct i( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR ( s
! c C s^ | i | } t i | | | } | i i | i | i | i | i | i } t
| | S( N( RR R t generate_pyR: R; R R R
R R R ( R RU RQ RV t rft objR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyRS S s -c C s | i i | } t | | S( s Construct a DSA key from a tuple of valid DSA components.
The modulus *p* must be a prime.
The following equations must apply:
- p-1 = 0 mod q
- g^x = y mod p
- 0 < x < q
- 1 < g < p
:Parameters:
tup : tuple
A tuple of long integers, with 4 or 5 items
in the following order:
1. Public key (*y*).
2. Sub-group generator (*g*).
3. Modulus, finite field order (*p*).
4. Sub-group order (*q*).
5. Private key (*x*). Optional.
:Return: A DSA key object (`_DSAobj`).
( R: R; R ( R t tupR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR Y s N( R RE RF R RR RJ R RS R ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyR s * +( RF t __revision__t __all__t syst version_infot Crypto.Util.py21compatt Crypto.PublicKeyR R R t CryptoR R
t ImportErrorRJ R t objectR t _implR R R ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/DSA.pyt N s" (