__init__(self, keysize=1024, algo_pub=3, **kwargs)
(Constructor)

Create a new key. The arguments passed to this function have the
following meaning:
    
    keysize - Integer specifying the size in bits of the key to
              create.
    algo_pub - One of the PUBLICKEY_* constants, specifies the
               public key algorithm to use.
    **kwargs - All extra keyword arguments are used to set key
               attributes.
               
All values have safe defaults; in case you instantiate this class
without specifying any parameters, an RSA key of length 1024 bits
is created, with no key arguments set.

__cmp__(self, other)
(Comparison operator)

__delitem__(self, name)
(Index deletion operator)

__getitem__(self, name)
(Indexing operator)

__hash__(self)
(Hashing function)

__iter__(self)

__new__(S, ...)

Returns:

a new object with type S, a subtype of T

__setitem__(self, name, value)
(Index assignment operator)

canDecrypt(self)

canEncrypt(self)

canSign(self)

canVerify(self)

cryptSize(self)

decrypt(self, encdata, wrap=True, *args, **kwargs)

Decrypt string data as passed in using data. The string must have
been created by the encrypt() method of this class for decryption
to succeed. The parameters passed in have the following meaning:

    data - String data to be decrypted.
    wrap - Defaults to True. In case you use a Key derived class
           such as AsciiKey, specifies whether the decrypted data
           should be unwrapped before decrypting it.
    *args, **kwargs - All extra arguments are passed to the
                      unwrapping functions declared by the current
                      Key(-derived) class.

encrypt(self, data, wrap=True, *args, **kwargs)

Encrypt string data as passed in using data. The string data may
not be longer than self.cryptSize() for encryption to succeed. The
parameters passed in have the following meaning:

    data - String data to be encrypted.
    wrap - Defaults to True. In case you use a Key derived class
           such as AsciiKey, specifies whether the encrypted data
           should be wrapped after storing it.
    *args, **kwargs - All extra arguments are passed to the
                      wrapping functions declared by the current
                      Key(-derived) class.

hasPrivate(self)

hasPublic(self)

keySize(self)

publicKey(self)

sign(self, data, hash_algo=5, wrap=True, *args, **kwargs)

Create a new signature for the data that is passed in. The
signature is a string, which is returned. The parameters passed
in have the following meaning:

    data - String data to be signed.
    hash_algo - Hash algorithm to use to hash the data before
                signing it. Special value HASH_NONE for hash_algo
                means that no hashing of the data is done before
                signing it.
    wrap - Defaults to True. In case you use a Key derived class
           such as AsciiKey, specifies whether the signature data
           should be wrapped on return.
    *args, **kwargs - All extra arguments are passed to the
                      wrapping functions declared by the current
                      Key(-derived) class.

storeKey(self, wrap=True, *args, **kwargs)

Stores a key to a string of bytes. The arguments passed to this
function have the following meaning:
    
    wrap - Defaults to True. In case you use a Key derived class
           such as SecureKey or AsciiKey, specifies whether the
           keydata should be wrapped after storing it.
    *args, **kwargs - All extra arguments are passed to the
                      wrapping functions declared by the current
                      Key(-derived) class.

This function stores all key arguments to the key stream, even
when the key only contains a public key. In case the key contains
only a public key, the data is stored as PUBKEYDATA nevertheless
(even though private key arguments are stored to the stream), so
that e.g. SecureKey doesn't do encryption on the key. This means
that by using this function, you may leak private key arguments
that have been set on a public key (these are Untrusted anyway).

storePublicKey(self, wrap=True, *args, **kwargs)

Stores only the public key of this key to a string of bytes. The
arguments passed to this function have the following meaning:

    wrap - Defaults to True. In case you use a Key derived class
           such as SecureKey or AsciiKey, specifies whether the
           keydata should be wrapped after storing it.
    *args, **kwargs - All extra arguments are passed to the
                      wrapping functions declared by the current
                      Key(-derived) class.
                      
This function only stores public key arguments to the output
stream.

update(self, args)

verify(self, data, signature, wrap=True, *args, **kwargs)

Verify the signature of the passed in string. The signature must
have been created by the sign() method.

    data - String data to be verified.
    signature - Signature of the string data which was returned by
                the sign() function.
    wrap - Defaults to True. In case you use a Key derived class
           such as AsciiKey, specifies whether the signature data
           should be unwrapped before trying to verify it.
    *args, **kwargs - All extra arguments are passed to the
                      unwrapping functions declared by the current
                      Key(-derived) class.

_isPrivate(self, key)

_Key__createKey(self, keysize)

_Key__decrypt(self, data)

_Key__encrypt(self, data)

_Key__getEncPrime(self)

_Key__getID(self)

_Key__serialize(self, private=True, network=False, *args, **kwargs)

_Key__sign(self, data)

_Key__unserialize(self, serstate, *args, **kwargs)

_Key__verify(self, data, signature)