wasp_general.crypto package

Submodules

wasp_general.crypto.aes module

class wasp_general.crypto.aes.WAES(mode)

Bases: object

PyCrypto AES-encryption wrapper

cipher()

Generate AES-cipher

Returns:Crypto.Cipher.AES.AESCipher

decrypt(data, decode=False)

Decrypt the given data with cipher that is got from AES.cipher call.

Parameters:

• data – data to decrypt
• decode – whether to decode bytes to str or not

Returns:

bytes or str (depends on decode flag)

encrypt(data)

Encrypt the given data with cipher that is got from AES.cipher call.

Parameters:data – data to encrypt Returns:bytes

mode()

Return AES mode

Returns:WAESMode

class wasp_general.crypto.aes.WAESMode(key_size, block_cipher_mode, init_sequence, padding=None)

Bases: object

This class specifies modes of AES encryption. It describes secret key (size and value), block cipher mode of operation, padding object (WBlockPadding instance), required initialization values. Note, padding is required if source data isn’t aligned to block size.

For byte-sequence generation (that is used as secret key and initialization values) it is possible to use wasp_general.crypto.kdf.WPBKDF2. wasp_general.crypto.kdf.WPBKDF2 is a wrapper for PBKDF2 function (KDF function that safely generates byte-sequence from the given password and salt)

Currently, only two cipher mode of operation are implemented: ‘CBC’ and ‘CTR’

see also: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation

class SequenceChopper(key_size, block_cipher_mode, sequence)

Bases: object

Helper, that chops the given byte-sequence into several separate objects (like secret key, initialization vector or initialization counter values). The exact values depend on AES key size and block cipher mode of operation.

If length of the given byte-sequence is greater then it is required, then extra bytes discard and this extra-bytes don’t take part in any calculation

initialization_counter_value()

Return initialization counter value generated from the initial byte-sequence if it is required by the current block cipher mode of operation. If it doesn’t require - then None is returned

Returns:int or None

initialization_vector()

Return initialization vector generated from the initial byte-sequence if it is required by the current block cipher mode of operation. If it doesn’t require - then None is returned

Returns:bytes or None

classmethod required_sequence_length(key_size, block_cipher_mode)

Calculate required byte-sequence length

Parameters:

• key_size – AES secret length
• block_cipher_mode – name of block cipher mode of operation to calculate for

Returns:

int

secret()

Return AES secret generated from the initial byte-sequence

Returns:bytes

classmethod init_sequence_length(key_size, block_cipher_mode)

Return required byte-sequence length

Parameters:

• key_size – secret size
• block_cipher_mode – name of block cipher mode of operation

Returns:

int

initialization_counter_value()

Return currently used initialization counter value or None if counter is not used

Returns:int or None

initialization_vector()

Return currently used initialization vector or None if vector is not used

Returns:bytes or None

key_size()

Return cipher secret key size

Returns:int

mode()

Return block cipher mode of operation name

Returns:

padding()

Return padding object

Returns:WBlockPadding or None

classmethod parse_cipher_name(name)

Parse cipher name (name like ‘aes_256_cbc’ or ‘AES-128-CTR’). Also this method validates If the cipher is supported by this class. If no - exception is raised

Parameters:name – name to parse Returns:tuple where the first element is a key size in bytes (int) and the second element - block cipher mode

of operation (str) (for example: (16, ‘AES-CTR’) or (24, ‘AES-CBC’))

pyaes_args()

Generate and return position-dependent arguments, that are used in AES.new() method

Returns:tuple

pyaes_kwargs()

Generate and return position-independent (named) arguments, that are used in AES.new() method

Returns:dict

class wasp_general.crypto.aes.WBlockPadding

Bases: object

Padding/reverse padding class prototype

pad(data, block_size)

Pad given data to given size

Parameters:

• data – data to pad
• block_size – size to pad

Returns:

bytes

reverse_pad(data, block_size)

Remove pads and return original data

Parameters:

• data – data to remove pads from
• block_size – size data aligned to

Returns:

bytes

class wasp_general.crypto.aes.WPKCS7Padding

Bases: wasp_general.crypto.aes.WBlockPadding

PKCS7 Padding implementation

see also: https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7

pad(data, block_size)

WBlockPadding.pad() method implementation

reverse_pad(data, block_size)

WBlockPadding.reverse_pad() method implementation

class wasp_general.crypto.aes.WShiftPadding(padding=None)

Bases: wasp_general.crypto.aes.WSimplePadding

Same as WSimplePadding class, but also randomly shifts original data.

reverse_pad(data, block_size)

WBlockPadding.reverse_pad() method implementation

class wasp_general.crypto.aes.WSimplePadding(padding=None)

Bases: wasp_general.crypto.aes.WBlockPadding

Class that pads given data with specified ASCII character

pad(data, block_size)

WBlockPadding.pad() method implementation

padding_symbol()

Return character with witch data is padded

Returns:bytes

reverse_pad(data, block_size)

WBlockPadding.reverse_pad() method implementation

class wasp_general.crypto.aes.WZeroPadding

Bases: wasp_general.crypto.aes.WSimplePadding

Zero padding implementation (just alias for WSimplePadding() object)

see also: https://en.wikipedia.org/wiki/Padding_(cryptography)#Zero_padding

wasp_general.crypto.hash module

class wasp_general.crypto.hash.WHash

Bases: object

Class that aggregates different hash-generators. This class is should be used if there is a need to address digest generator by its name. As a result - generator (WHashGeneratorProto) is returned.

static available_digests(family=None, name=None)

Return names of available generators

Parameters:

• family – name of hash-generator family to select
• name – name of hash-generator to select

Returns:

set of int

static available_generators(family=None, name=None)

Return names of available generators

Parameters:

• family – name of hash-generator family to select
• name – name of hash-generator to select (parameter may be used for availability check)

Returns:

tuple of str

static generator(name)

Return generator by its name

Parameters:name – name of hash-generator Returns:WHashGeneratorProto class

static generator_by_digest(family, digest_size)

Return generator by hash generator family name and digest size

Parameters:family – name of hash-generator family Returns:WHashGeneratorProto class

class wasp_general.crypto.hash.WHashGeneratorProto

Bases: object

Prototype for hash-generator.

note: there is commonly used feature that most hash generator objects have - digest_size attribute. So it is better to create this attribute.

digest()

Return current digest

Returns:bytes

classmethod generator_digest_size()

Return generator digest size

Returns:int

classmethod generator_family()

Return name of hash-function family (like: ‘SHA’)

Returns:str or None (if no available)

classmethod generator_name()

Return hash-function name

Returns:str

hexdigest()

Return current digest in hex-alike string

Returns:str

classmethod new(data=None)

Return new generator and hash the specified data (if defined)

Parameters:data – data to hash Returns:WHashGeneratorProto

update(data)

Update digest by hashing the specified data

Parameters:data – data to hash Returns:None

class wasp_general.crypto.hash.WMD5

Bases: wasp_general.crypto.hash.WPyCryptoHashAdapter

MD5 hash-generator

class wasp_general.crypto.hash.WPyCryptoHashAdapter

Bases: wasp_general.crypto.hash.WHashGeneratorProto

Class that adapts the specified PyCrypto hashing class to WHashGeneratorProto implementation

digest()

WHashGeneratorProto.digest() implementation

classmethod generator_digest_size()

WHashGeneratorProto.generator_digest_size() implementation

classmethod generator_family()

WHashGeneratorProto.generator_family() implementation

classmethod generator_name()

WHashGeneratorProto.generator_name() implementation

classmethod new(data=None)

WHashGeneratorProto.new() implementation

pycrypto()

In rare cases original PyCrypto object is required. In most cases this method should be avoided, as it is can be removed at any time.

One of an example of this method usage is PyCrypto HMAC (and so WHMAC). They require, that hash-generator object must have “copy” method to be implemented. But I have not found a way to make HMAC work.

Returns:PyCrypto Hash object

update(data)

WHashGeneratorProto.update() implementation

class wasp_general.crypto.hash.WSHA1

Bases: wasp_general.crypto.hash.WSHAFamily

SHA1 hash-generator

class wasp_general.crypto.hash.WSHA224

Bases: wasp_general.crypto.hash.WSHAFamily

SHA224 hash-generator

class wasp_general.crypto.hash.WSHA256

Bases: wasp_general.crypto.hash.WSHAFamily

SHA256 hash-generator

class wasp_general.crypto.hash.WSHA384

Bases: wasp_general.crypto.hash.WSHAFamily

SHA384 hash-generator

class wasp_general.crypto.hash.WSHA512

Bases: wasp_general.crypto.hash.WSHAFamily

SHA512 hash-generator

class wasp_general.crypto.hash.WSHAFamily

Bases: wasp_general.crypto.hash.WPyCryptoHashAdapter

Class that represent SHA-family hash-generators

wasp_general.crypto.hex module

class wasp_general.crypto.hex.WHex(byte_sequence)

Bases: object

binascii.hexlify wrapper. Converts bytes to hex-string

class wasp_general.crypto.hex.WUnHex(string)

Bases: object

binascii.unhexlify wrapper. Converts string to bytes

wasp_general.crypto.hmac module

class wasp_general.crypto.hmac.WHMAC(digest_generator_name=None)

Bases: object

Class that wraps PyCrypto HMAC implementation

see also https://en.wikipedia.org/wiki/Hash-based_message_authentication_code

digest_generator()

Return hash-generator

Returns:PyCrypto class

hash(key, message=None)

Return digest of the given message and key

Parameters:

• key – secret HMAC key
• message – code (message) to authenticate

Returns:

bytes

classmethod hmac(name)

Return new WHMAC object by the given algorithm name like ‘HMAC-SHA256’ or ‘HMAC_SHA1’

Parameters:name – name of HMAC algorithm Returns:WHMAC

wasp_general.crypto.kdf module

class wasp_general.crypto.kdf.WPBKDF2(key, salt=None, derived_key_length=None, iterations_count=None, hmac=None)

Bases: object

Wrapper for PyCrypto PBKDF2 implementation with NIST recommendation and HMAC is used as pseudorandom function

NIST recommendation can be read here: http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf (Recommendation for Password-Based Key Derivation)

derived_key()

Return derived key

Returns:bytes

classmethod generate_salt(length=None)

Generate salt that can be used by this object

Parameters:length – target salt length Returns:bytes

salt()

Return salt value (that was given in constructor or created automatically)

Returns:bytes

wasp_general.crypto.random module

wasp_general.crypto.random.random_bits(bits_count)

Random generator (PyCrypto getrandbits wrapper). The result is a non-negative value.

Parameters:bits_count – random bits to generate Returns:int

wasp_general.crypto.random.random_bytes(bytes_count)

Generate random bytes sequence. (PyCrypto getrandbits wrapper)

Parameters:bytes_count – sequence length Returns:bytes

wasp_general.crypto.random.random_int(maximum_value)

Random generator (PyCrypto getrandbits wrapper). The result is a non-negative value.

Parameters:maximum_value – maximum integer value Returns:int

wasp_general.crypto.rsa module

class wasp_general.crypto.rsa.WRSA

Bases: object

PyCrypto RSA-encryption wrapper

static decrypt(binary_chain, private_key, sha_digest_size=32)

Decrypt data with key and PKCS1 OAEP protocol

Parameters:

• binary_chain – data to decrypt
• private_key – private key
• sha_digest_size – SHA digest size

Returns:

bytes

static encrypt(binary_chain, key, sha_digest_size=32)

Encrypt data with key and PKCS1 OAEP protocol

Parameters:

• binary_chain – data to encrypt
• key – must be public key or private key with builtin public
• sha_digest_size – SHA digest size

Returns:

bytes

static export_key(key, password=None)

Export key in PEM-format

Parameters:

• key – key to export
• password – If it is not None, then result will be encrypt with given password. Suitable only for private key. With public keys this argument does nothing

Returns:

bytes

static generate_private(key_length=2048)

Generate new private key (corresponding public key is included)

Parameters:key_length – same as bits argument in Crypto.PublicKey.RSA.generate function (it must be a multiple of 256, and no smaller than 1024) Returns:WRSA.wrapped_class

static generate_public(private_key)

Get public key from private one

Parameters:private_key – source private key Returns:RSA.wrapper_class

static import_key(pem_text, password=None)

Import key written in PEM-format

Parameters:

• pem_text – PEM data
• password – Password with witch PEM-data is encrypted

Returns:

RSA.wrapped_class

static string_decrypt(binary_data, private_key, text_encoding=None, sha_digest_size=32)

Decrypt binary data with given private key and PKCS1 OAEP protocol

Parameters:

• binary_data – data to decrypt
• private_key – private key
• text_encoding – source string encoding
• sha_digest_size – SHA digest size

Returns:

str

static string_encrypt(text, key, sha_digest_size=32)

Encrypt text with given public key and PKCS1 OAEP protocol

Parameters:

• text – text to encrypt
• key – public key or private key with builtin public
• sha_digest_size – SHA digest size

Returns:

bytes

wrapped_class

RSA wrapped class

alias of _RSAobj

Module contents