yawPyCrypto.AdvKey.SecureKey

Package yawPyCrypto :: Module AdvKey :: Class SecureKey

[show private | hide private]

Class SecureKey

     object --+        
              |        
       IFlatten --+    
                  |    
     object --+   |    
              |   |    
AlgoDefinitions --+    
                  |    
                Key --+
                      |
                     SecureKey

SecureKey is a Key derived class which offers encryption of private key data using the Blowfish cipher, with a specified password. Any key function which returns a string representation of the key can take a keyword argument, called password, which is used as the passphrase with which the key is encrypted (the passphrase is first passed though a hashing function). On decryption, you have to pass the same passphrase, otherwise the key data is not readable.

Method Summary
	`__init__(self, keysize, algo_pub, *kwargs)` Create a new key. (inherited from `Key`)*
	`__cmp__(self, other)` Compares two keys. (inherited from `Key`)
	`__delitem__(self, name)` Deletes the specified key argument from this key. (inherited from `Key`)
	`__getitem__(self, name)` Loads the key attribute name from the current key object, and unserializes it. (inherited from `Key`)
	`__hash__(self)` Returns a hash value of a key instance. (inherited from `Key`)
	`__iter__(self)` Return an iterator over all names of key arguments. (inherited from `Key`)
a new object with type S, a subtype of T	`__new__(S, ...)`
	`__setitem__(self, name, value)` Sets the passed in keyword argument called name to the value that is passed in along. (inherited from `Key`)
	`canDecrypt(self)` Returns a boolean whether this key can decrypt data. (inherited from `Key`)
	`canEncrypt(self)` Returns a boolean whether this key can encrypt data. (inherited from `Key`)
	`canSign(self)` Returns a boolean whether this key can sign data. (inherited from `Key`)
	`canVerify(self)` Returns a boolean whether this key can verify signed data. (inherited from `Key`)
	`cryptSize(self)` Returns the maximum string length of data which can be encrypted or signed. (inherited from `Key`)
	`decrypt(self, encdata, wrap, args, kwargs)` Decrypt string data as passed in using data. (inherited from `Key`)*
	`encrypt(self, data, wrap, args, kwargs)` Encrypt string data as passed in using data. (inherited from `Key`)*
	`hasPrivate(self)` Checks whether this key has a private key part. (inherited from `Key`)
	`hasPublic(self)` Checks whether this key has a public key part. (inherited from `Key`)
	`keySize(self)` Returns the key's keysize in bits. (inherited from `Key`)
	`publicKey(self)` Returns a new key object which contains only the public key associated with the current key, and only public key arguments. (inherited from `Key`)
	`sign(self, data, hash_algo, wrap, args, kwargs)` Create a new signature for the data that is passed in. (inherited from `Key`)*
	`storeKey(self, wrap, args, kwargs)` Stores a key to a string of bytes. (inherited from `Key`)*
	`storePublicKey(self, wrap, args, kwargs)` Stores only the public key of this key to a string of bytes. (inherited from `Key`)*
	`update(self, args)` Dictionary style updating for a Key instance. (inherited from `Key`)
	`verify(self, data, signature, wrap, args, kwargs)` Verify the signature of the passed in string. (inherited from `Key`)*
	`_IFlatten__serialize(self, args, kwargs)` (inherited from `IFlatten`)*
	`_IFlatten__unserialize(self, args, kwargs)` (inherited from `IFlatten`)*
	`_isPrivate(self, key)` Function which is called to check whether the current key argument should be treated as a private key argument (and as such is stored only on a call to storeKey()). (inherited from `Key`)
	`_Key__createKey(self, keysize)` Function used to create a new key for this Key object. (inherited from `Key`)
	`_Key__decrypt(self, data)` Decrypt the passed in PyCrypto output of encryption, and return the decrypted string. (inherited from `Key`)
	`_Key__encrypt(self, data)` Encrypt data as passed in, and return the PyCrypto output of the encrypted data. (inherited from `Key`)
	`_Key__getEncPrime(self)` Function used to get an encryption prime as required by the El Gamal public key encryption algorithm. (inherited from `Key`)
	`_Key__getID(self)` Returns the yawPyCrypto ID of the current key object. (inherited from `Key`)
	`_Key__serialize(self, private, network, args, kwargs)` Function called by the Flatten serialization library to serialize a key instance. (inherited from `Key`)*
	`_Key__sign(self, data)` Function that returns a PyCrypto signature for the data that is passed in. (inherited from `Key`)
	`_Key__unserialize(self, serstate, args, kwargs)` Function called by the Flatten serialization library to unserialize a key instance from the dictionary passed in as serstate. (inherited from `Key`)*
	`_Key__verify(self, data, signature)` Function that verifies a PyCrypto signature for the data that is passed in. (inherited from `Key`)
	`_secureUnwrap(selfcls, data, datatype, password, args, *kwargs)` Unwrapping function for unwrapping private key data with an encryption using the cipher Blowfish (normally).
	`_secureWrap(selfcls, data, datatype, password, args, *kwargs)` Wrapping function for wrapping private key data with an encryption using the cipher Blowfish.

Class Variable Summary
`list`	`_unwrappers`
`list`	`_wrappers`

Method Details

new(S, ...)

Returns:: a new object with type S, a subtype of T

_secureUnwrap(selfcls, data, datatype, password=None, *args, **kwargs)

Unwrapping function for unwrapping private key data with an encryption using the cipher Blowfish (normally). The password which is used to unwrap the data is passed as the keyword argument password. The password is first hashed (normally using HASH_SHA), then a Blowfish cipher is created, and the object is decrypted. Blowfish is considered as a strong block cipher; in case you wish to use a different cipher, please derive your own key class from this object.

_secureWrap(selfcls, data, datatype, password=None, *args, **kwargs)

Wrapping function for wrapping private key data with an encryption using the cipher Blowfish. The password which is used to wrap the data is passed as the keyword argument password. The password is first hashed (normally using HASH_SHA), then a Blowfish cipher is created and the object is encrypted. Blowfish is considered as a strong block cipher; in case you wish to use a different cipher, please derive your own key class from this object.

Class Variable Details

_unwrappers

Type:

list

Value:

[(200, <function _secureUnwrap at 0x40228f44>)]

_wrappers