gdata.Crypto.PublicKey.RSA
index
/usr/local/google/home/afshar/src/external-gdata-release/google3/src/gdata/Crypto/PublicKey/RSA.py

#   RSA.py : RSA encryption/decryption
#
#  Part of the Python Cryptography Toolkit
#
# Distribute and use freely; there are no restrictions on further
# dissemination and usage except those imposed by the laws of your
# country of residence.  This software is provided "as is" without
# warranty of fitness for use or suitability for any purpose, express
# or implied. Use at your own risk or not at all.
#

 
Modules
       
Crypto.PublicKey._fastmath
Crypto.Util.number
Crypto.PublicKey.pubkey

 
Classes
       
Crypto.PublicKey.pubkey.pubkey
RSAobj
RSAobj
RSAobj_c
exceptions.Exception(exceptions.BaseException)
_fastmath.error

 
class RSAobj(Crypto.PublicKey.pubkey.pubkey)
     Methods defined here:
can_blind(self)
can_blind() : bool
Return a Boolean value recording whether this algorithm can
blind data.  (This does not imply that this
particular key object has the private information required to
to blind a message.)
has_private(self)
has_private() : bool
Return a Boolean denoting whether the object contains
private components.
publickey(self)
publickey(): RSAobj
Return a new key object containing only the public key information.
size(self)
size() : int
Return the maximum number of bits that can be handled by this key.

Data and other attributes defined here:
keydata = ['n', 'e', 'd', 'p', 'q', 'u']

Methods inherited from Crypto.PublicKey.pubkey.pubkey:
__eq__(self, other)
__eq__(other): 0, 1
Compare us to other for equality.
__getstate__(self)
To keep key objects platform-independent, the key data is
converted to standard Python long integers before being
written out.  It will then be reconverted as necessary on
restoration.
__init__(self)
__ne__(self, other)
__ne__(other): 0, 1
Compare us to other for inequality.
__setstate__(self, d)
On unpickling a key object, the key data is converted to the big
number representation being used, whether that is Python long
integers, MPZ objects, or whatever.
blind(self, M, B)
blind(M : string|long, B : string|long) : string|long
Blind message M using blinding factor B.
can_encrypt(self)
can_encrypt() : bool
Return a Boolean value recording whether this algorithm can
encrypt data.  (This does not imply that this
particular key object has the private information required to
to decrypt a message.)
can_sign(self)
can_sign() : bool
Return a Boolean value recording whether this algorithm can
generate signatures.  (This does not imply that this
particular key object has the private information required to
to generate a signature.)
decrypt(self, ciphertext)
decrypt(ciphertext:tuple|string|long): string
Decrypt 'ciphertext' using this key.
encrypt(self, plaintext, K)
encrypt(plaintext:string|long, K:string|long) : tuple
Encrypt the string or integer plaintext.  K is a random
parameter required by some algorithms.
sign(self, M, K)
sign(M : string|long, K:string|long) : tuple
Return a tuple containing the signature for the message M.
K is a random parameter required by some algorithms.
unblind(self, M, B)
unblind(M : string|long, B : string|long) : string|long
Unblind message M using blinding factor B.
validate(self, M, signature)
# alias to compensate for the old validate() name
verify(self, M, signature)
verify(M:string|long, signature:tuple) : bool
Verify that the signature is valid for the message M;
returns true if the signature checks out.

 
class RSAobj_c(Crypto.PublicKey.pubkey.pubkey)
     Methods defined here:
__getattr__(self, attr)
__getstate__(self)
__init__(self, key)
__setstate__(self, state)
can_blind(self)
has_private(self)
publickey(self)
size(self)

Data and other attributes defined here:
keydata = ['n', 'e', 'd', 'p', 'q', 'u']

Methods inherited from Crypto.PublicKey.pubkey.pubkey:
__eq__(self, other)
__eq__(other): 0, 1
Compare us to other for equality.
__ne__(self, other)
__ne__(other): 0, 1
Compare us to other for inequality.
blind(self, M, B)
blind(M : string|long, B : string|long) : string|long
Blind message M using blinding factor B.
can_encrypt(self)
can_encrypt() : bool
Return a Boolean value recording whether this algorithm can
encrypt data.  (This does not imply that this
particular key object has the private information required to
to decrypt a message.)
can_sign(self)
can_sign() : bool
Return a Boolean value recording whether this algorithm can
generate signatures.  (This does not imply that this
particular key object has the private information required to
to generate a signature.)
decrypt(self, ciphertext)
decrypt(ciphertext:tuple|string|long): string
Decrypt 'ciphertext' using this key.
encrypt(self, plaintext, K)
encrypt(plaintext:string|long, K:string|long) : tuple
Encrypt the string or integer plaintext.  K is a random
parameter required by some algorithms.
sign(self, M, K)
sign(M : string|long, K:string|long) : tuple
Return a tuple containing the signature for the message M.
K is a random parameter required by some algorithms.
unblind(self, M, B)
unblind(M : string|long, B : string|long) : string|long
Unblind message M using blinding factor B.
validate(self, M, signature)
# alias to compensate for the old validate() name
verify(self, M, signature)
verify(M:string|long, signature:tuple) : bool
Verify that the signature is valid for the message M;
returns true if the signature checks out.

 
class error(exceptions.Exception)
    
Method resolution order:
error
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.Exception:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data and other attributes inherited from exceptions.Exception:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
object = class RSAobj(Crypto.PublicKey.pubkey.pubkey)
     Methods defined here:
can_blind(self)
can_blind() : bool
Return a Boolean value recording whether this algorithm can
blind data.  (This does not imply that this
particular key object has the private information required to
to blind a message.)
has_private(self)
has_private() : bool
Return a Boolean denoting whether the object contains
private components.
publickey(self)
publickey(): RSAobj
Return a new key object containing only the public key information.
size(self)
size() : int
Return the maximum number of bits that can be handled by this key.

Data and other attributes defined here:
keydata = ['n', 'e', 'd', 'p', 'q', 'u']

Methods inherited from Crypto.PublicKey.pubkey.pubkey:
__eq__(self, other)
__eq__(other): 0, 1
Compare us to other for equality.
__getstate__(self)
To keep key objects platform-independent, the key data is
converted to standard Python long integers before being
written out.  It will then be reconverted as necessary on
restoration.
__init__(self)
__ne__(self, other)
__ne__(other): 0, 1
Compare us to other for inequality.
__setstate__(self, d)
On unpickling a key object, the key data is converted to the big
number representation being used, whether that is Python long
integers, MPZ objects, or whatever.
blind(self, M, B)
blind(M : string|long, B : string|long) : string|long
Blind message M using blinding factor B.
can_encrypt(self)
can_encrypt() : bool
Return a Boolean value recording whether this algorithm can
encrypt data.  (This does not imply that this
particular key object has the private information required to
to decrypt a message.)
can_sign(self)
can_sign() : bool
Return a Boolean value recording whether this algorithm can
generate signatures.  (This does not imply that this
particular key object has the private information required to
to generate a signature.)
decrypt(self, ciphertext)
decrypt(ciphertext:tuple|string|long): string
Decrypt 'ciphertext' using this key.
encrypt(self, plaintext, K)
encrypt(plaintext:string|long, K:string|long) : tuple
Encrypt the string or integer plaintext.  K is a random
parameter required by some algorithms.
sign(self, M, K)
sign(M : string|long, K:string|long) : tuple
Return a tuple containing the signature for the message M.
K is a random parameter required by some algorithms.
unblind(self, M, B)
unblind(M : string|long, B : string|long) : string|long
Unblind message M using blinding factor B.
validate(self, M, signature)
# alias to compensate for the old validate() name
verify(self, M, signature)
verify(M:string|long, signature:tuple) : bool
Verify that the signature is valid for the message M;
returns true if the signature checks out.

 
Functions
       
construct = construct_c(tuple)
construct_c(tuple)
construct_py = construct(tuple)
construct(tuple:(long,) : RSAobj
Construct an RSA object from a 2-, 3-, 5-, or 6-tuple of numbers.
generate = generate_c(bits, randfunc, progress_func=None)
generate_c(bits, randfunc, progress_func=None)
generate_py = generate(bits, randfunc, progress_func=None)
generate(bits:int, randfunc:callable, progress_func:callable)
 
Generate an RSA key of length 'bits', using 'randfunc' to get
random data and 'progress_func', if present, to display
the progress of the key generation.

 
Data
        __revision__ = '$Id: RSA.py,v 1.20 2004/05/06 12:52:54 akuchling Exp $'