Metadata-Version: 2.0
Name: pprp
Version: 0.2.0
Summary: A pure-Python Rijndael (AES) and PBKDF2 library. Python2.7- and Python3-compatible.
Home-page: https://github.com/dsoprea/RijndaelPbkdf
Author: Dustin Oprea
Author-email: myselfasunder@gmail.com
License: GPL 2
Keywords: rijdael pbkdf2
Platform: UNKNOWN

--------
Overview
--------

This package was a remedy to there being no PyPI-published, pure-Python 
Rijndael (AES) implementations, and that nothing available, in general, was 
compatible with both Python2 *and* Python3. The same is true of the PBKDF2 
key-expansion algorithm.

The encrypter expects a source generator (which yields individual blocks). The 
encrypter and decrypter functions are written as generators. Decrypted data has 
PKCS7 padding. A utility function is provided to trim this 
(*trim_pkcs7_padding*).

The implementation includes Python2 and Python3 implementations of both 
Rijndael and PBKDF2, and chooses the version when loaded.

This project is also referred to as *pprp*, which stands for "Pure Python 
Rijndael and PBKDF2".


------------
Installation
------------

Install via *pip*::

    $ sudo pip install pprp


-------
Example
-------

Encrypt and decrypt the data, and compare the results. This example works in 
both Python 2 and 3.

Top imports and defines::

    import io
    import os.path
    import hashlib

    import pprp

    # Make the strings the right type for the current Python version.
    def trans(text):
        return text.encode('ASCII') if sys.version_info[0] >= 3 else text

    passphrase = trans('password')
    salt = trans('salt')
    block_size = 16
    key_size = 32
    data = "this is a test" * 100

Do the key-expansion::

    key = pprp.pbkdf2(passphrase, salt, key_size)

Define the source generator (we'll give this to the encrypter)::

    def source_gen():
        for i in range(0, len(data), block_size):
            block = data[i:i + block_size]
            len_ = len(block)

            if len_ > 0:
                yield block.encode('ASCII')

            if len_ < block_size:
                break

Connect the encryptor to the decryptor::

    encrypted_gen = pprp.rjindael_encrypt_gen(key, source_gen(), block_size)

Run, sink the output into an IO stream, and trim the padding off the last 
block::

    s = io.BytesIO()
    ends_at = 0
    for block in pprp.rjindael_decrypt_gen(key, encrypted_gen, block_size):
        ends_at += block_size
        if ends_at >= len(data):
            block = pprp.trim_pkcs7_padding(block)

        s.write(block)

    decrypted = s.getvalue()

Check the result::

    assert data == decrypted.decode('ASCII')


