algorithms.c: Add missing guard for `del' to property `set' functions.

Continuing the work of 9444777c58c60253afdabf5b45011440845770e0.

util.c: Make `default' arguments optional in `get', `setdefault', `pop'.

Alas, `pop' is a little trickier than the others.

util.c: Fix sense of error check in `popitem'.

rand.c, pgen.c: Invalidate random generators from pgen events.

I've not actually seen a crash from a Python program which keeps hold of
the random generator from a prime-generation event and tries to use it
after the operation has finished, but it was certainly possible.

Arrange for the event object to retain the random generator object (so
it always hands out the same one when requested), and invalidates it
when the event is itself invalidated.

This also involves messing with the `grand' code to cope with the idea
of invalidated random generators.

(cherry picked from commit d65d80d7c096e6afc500270ee29909f64869e5dc)

ec.c: Pass a dummy length argument to `PyObject_AsReadBuffer'.

Otherwise it just raises a `SystemException'.  So this code never
worked.

catacomb-python.h, *.c: Fix how Python `pgen' handlers handle exceptions.

Oh, this was a mess.  The old code would convert an exception from a
Python handler into `PGEN_ABORT', and hope that the exception state was
still available when the overall operation ended.

This doesn't work.  In particular, steppers and testers are finalized by
calling them with `PGEN_DONE', and the interpreter doesn't like
re-entering Python with an exception set.  (In debug builds, this is an
assertion failure.)

Overhaul all of this nonsense.

  * Add a collection of utilities for saving and restoring the exception
    state.

  * Add a hook, in the `catacomb' module, for reporting `lost'
    exceptions, for the case where further exceptions are raised while
    responding to a first exception.

  * Use a larger `pypgev' structure to track the state of a Python event
    handler through the framework.  This structure holds a reference to
    the Python object itself, and a slot for recording an exception.

  * When a Python handler fails, stash the exception state in the slot
    provided by the `pypgev' structure if there isn't one already, and
    clear the pending exception.  If there is already an exception in
    the slot, then report the new exception through the hook described
    above.

  * Once a `pgen' operation completes, if it raised any exceptions at
    all, then the first of these is left in the exception slot.  If it
    fails otherwise, then we supply a generic exception.

pgen.c (pgev_python): Delete pointless refcount manipulation.

catacomb/__init__.py: Awful bodge for symbol conflict.

It seems that, in Debian jessie and later, the main Python binary now
exports `md5_init' and friends.  Unfortunately, this overrides
Catacomb's existing `md5_init' with a rather different version, and the
result is a segfault (on i386) or wrong answers (on amd64).

So, as an unpleasant bodge (while this broken thing makes its way
through Debian, see bug #868366), try to force the `RTLD_DEEPBIND' flag
when loading the module.  This is unfortunate, because Python doesn't
actually advertise this flag, at least in my version.

(cherry picked from commit a3ae4a9f590ef84d8e6eac0bc94873a9fd943073)

catacomb/__init__.py: Rearrange the imports.

Sort the ordinary Python imports into alphabetical order (by module
name, rather than by import, if I'm only taking one or two symbols).
Move the main extension import into its own section, because it's going
to grow.

(cherry picked from commit 378ceeef4e0663d913cb448c32022522d39e7848)

catacomb/__init__.py: Import `sys' as a whole.

We're only using `argv' in one place, so this isn't a significant
hardship.  And I'll want more things from `sys' soon.

(cherry picked from commit c04b289c577a5cdf6d5dd641f7b541d90a93adff)

mp.c, util.c: Use `Py_ssize_t' for lengths.

Missed some from the earlier pass.

mp.c: Fix crash converting elliptic curve point-at-infinity to integer.

pgen.c, rand.c: Check correct variable when rejecting delete operations.

rand.c (BBSPriv.generate): Release the event handler afterwards.

mp.c: Return the result of `GFN' transformations as `GF'.

And not `MP', which is simply wrong.

mp.c: Don't leak the field polynomial.

mp.c: Release the `GFN' object through channels on error.

If the given element turns out not to actually generate a normal basis
then we have to give up constructing the `GFN' object and raise an
exception.  In turns out that debug versions of Python get really
unhappy if you try to free objects which still have nonzero reference
counts, so:

  * use `Py_DECREF' to free the object on error; and

  * mark the object (by leaving `p' null) so that we don't actually
    free the conversion matrices if they're weren't set up.

mp.c: Check that CRT moduli are pairwise coprime.

mp.c: Arrange to free `xx' on exit.

mp.c: Check that CRT moduli are actually positive.

field.c: Convert external-format field element to hex/octal.

Rather than going through the effort of calculating the external
representation of the field element and then returning the internal
version.

field.c: Return the binary-field polynomial as, err, a polynomial.

Sharing the extraction code with the prime-field case means it gets
returned as an integer.

rand.c: Add missing return-value mnemonic in docstring.

*.c: Consistently show keyword arguments as optional in docstrings.

pgen.c: Add missing `EV' arg in `PrimeGenEventHandler' method docstrings.

mp.c: Fix Jacobi symbol notation in docstring.

mp.c: Describe `MP' and `GF' conversion semantics.

mp.c: Spell `MP' and `GF' in the correct case in docstrings.

group.c: Fix capitalization of `ECPt' in docstring.

ec.c: Add missing optional argument to docstring.

field.c: Fix misleading docstrings.

It seems that the `value' and `_value' properties have always been able
to return `GF' for binary field elements.

buffer.c: Fix docstrings.

util.c: Fix docstrings for generic-map iterator classes.

group.c: Fix docstring keyword for `G.checkgroup'.

ec.c (ecpt_pyrichcompare): Fix point comparisons.

Previously we'd just reject comparisons of points with different curves.
Instead, support comparing curveless points with curvy ones by just
comparing the points coordinatewise.

Unfortunately, to make equality be transitive, this means permitting
comparisons between points on different curves, which is unpleasant.

ec.c (ecpt_pyhash): Fix hashing.

Previously, hashing a curveless point would just crash, which is
surprisingly bad form.  Replace this mess with a simpler thing which
just converts the point to external form and hashes the coordinates.

field.c, mp.c: Hash `GF' and `FE' objects the same as `MP'.

They can be compared for equality, and so they must hash the same way.

mp.c: Factor out and export `mphash'.

ec.c (ec2osp, os2ecp): Collect flags correctly.

Previously `ec2osp' collected an `int', which probably wasn't completely
terrible, and `os2ecp' collected a float, which probably was.

ec.c: Fix reported function name in `ec2osp'.

ec.c: Fix keyword-argument list for `os2ecp'.

ec.c (eccurve_pyrichcompare): Check that second operand has correct type.

A segfault waiting to happen, which has been lurking since the
beginning.

ec.c (ecpt_pymul): Don't leak the scalar value.

ec.c: Don't drop through into an error case.

ec.c: Fix three-argument point construction.

This has been wrong literally forever.

buffer.c: Don't advertise `WBUF.putecpt' as a keyword method.

catacomb/__init__.py (BaseRat, MP, GF): Add missing true-division methods.

Since these all produce exact (rational) results, they satisfy the true-
division requirements.

catacomb/__init__.py (BaseRat): Add missing reverse-multiplication method.

catacomb/__init__.py (BaseRat): Make comparisons actually work.

This was broken in 83c77564338b3e410eb2ca2db3d35173dd6666cc.

buffer.c (wbmeth_putblkN): Check input block size.

Otherwise the C code fails an assertion.

buffer.c: Return 64-bit values, even if they're too big for `getulong'.

util.c: Use Python's machinery for handling 64-bit integers.

Where available.

util.c: Augment `convu64' to collect its argument via `kludge64'.

Otherwise integers too large for `unsigned long' get rejected with an
error, even though they ought to be acceptable as a `uint64'.

key.c, pgen.c: Add missing guards for `del' to property `set' functions.

*.py: Use `str.replace' rather than `str.translate'.

It seems that the `None' argument to `str.translate' was a brief
experiment added in 2.6 which didn't survive into 3.0.

buffer.c: Fix typoed variable name in `assert'.

Evidently I've never actually compiled this code with the assertions
turned on before.

(cherry picked from commit a11849068dd55f5997365984cce759c0f2d7caeb)

Release 1.2.1.1.

debian/control: Build-depend on `python-all-dev', not explicit versions.

debian/: Use `dh_python2' for packaging.

setup.py: Fix the advertised package URL.

Unfortunately the old URL was terrible both because it was poorly chosen
and because it was broken long ago (if indeed it ever worked in the
first place).

Merge remote-tracking branch 'origin/HEAD'

* origin/HEAD:
  catacomb/pwsafe.py: Fix stupid error which breaks `delete'.

catacomb/pwsafe.py: Fix stupid error which breaks `delete'.

Release 1.2.1.

pubkey.c (dsa_setup): Make sure `u' is None or an MP object.

Don't just store the caller's object and hope for the best.

pubkey.c: Fix keyword-argument order for KCDSAPriv constructor.

ec.c: Fix embarrassing use-after-free in EC point hashing.

The hashed data is sometimes (unpredictably) mangled by freeing causing
hash mismatches, which is annoying.  Also, obviously incorrect.

Release 1.2.0.

pubkey.c: Allow RSA key generation with user-chosen public exponent.

New feature in the underlying library.

mp.c: Add binding for `leastcongruent' function.

pubkey.c: Add support for Ed448 signatures, following RFC8032.

catacomb/__init__.py: Settle on SHAKE256 for X448 box-key generation.

This matches Ed448 hashing, which is probably a good thing.

pubkey.c: Support the `ed2559ctx' signature scheme from RFC8032.

Main difference is the addition of a personalization string.

In the wrapper classes, forward unknown keyword arguments on to the
underlying implementation.

pubkey.c: Capture Ed25519 binding in a macro.

Now we can add more EdDSA instances with similar shapes without too much
trouble.

Also, slightly sneakily, make EdDSA verification functions take keyword
arguments.

catacomb/__init__.py: Add `beginhash', `endhash' to the EdDSA interface.

This is consistent with the other DSA-ish classes.

catacomb/__init__.py: Refactor the XDH and EdDSA classes.

  * Introduce `_BasePub' and `_BasePriv' underneath the existing
    classes, and move obvious common functionality like size checking
    and printing into them.  Push key-generation down here too.

  * Use `KeySZ' objects for key length checking rather than just the
    bare constants.  In particular, this means that `Ed25519Priv' isn't
    fussy about key sizes, preserving this feature of the underlying
    implementation.

  * Split the implementation of pretty-printing into more pieces.  In
    particular, now `_BasePriv' only needs to implement the printing of
    the private key rather than the whole lot.  (Plain `__repr__' is
    still duplicated, but the code is smaller and this is more
    tolerable.)

  * Rename `_Boxy...' to `_XDH...', since this appears to be the generic
    term I'm using for such things now.

pubkey.c: Factor out commonality between X25519 and X448.

Add support for SHA3 and related algorithms.

This comes in three tranches.

  * There are the basic generic-interface algorithms for SHA3-*, SHAKE*,
    KMAC*, etc., which basically just turn up by themselves, and the
    RNGs based on SHAKE and KMAC which took a little more work.

  * There's a full implementation of the cSHAKE128 and cSHAKE256 XOFs as
    a new kind of object.

  * Based on this, there's a full KMAC implementation, with the fiddly
    bits in Python (but all the heavy lifting is done in C), with
    variable-length tag and everything.  Other constructions, e.g.,
    TupleHash, can easily be made in the same way.

Annoyingly, KMAC can't just be made from SHAKE by multiple inheritance
because Python gets confused about how it's supposed to construct the
objects, and, in particular, which `__new__' methods are OK to use.  It
seems that the relevant code is trying to use the `HEAPTYPE' flag as a
proxy for whether a type is implemented in C, which doesn't work for our
classes.  So there's a bunch of ugly delegation to do.

algorithms.c: Add basic support for Keccak[1600, n].

This takes the form of a simple object which encapsulates the
Keccak[1600, n] state and allows mix and extract operations (which
correspond to the I/O portions of absorb/squeeze and duplexing) and
step, which actually invokes the permutation to advance the state.

None of this keeps track of rate or capacity limits beyond the obvious
memory-safety checks, so you can really screw yourself if you're not
careful.

algorithms.py: Support SHA512/224 and SHA512/256.

algorithms.py: Cope better with algs with funny characters in their names.

Defend against `/' in names when making include-file names, and defend
against `/' and `-' when forming identifier names.

rand.c, algorithms.py: Change how kinds of RNGs are distinguished.

Rather than a set of flags, assign them numbers and use `switch'.  It
doesn't seem like the flags are helpfully marking out sets of RNGs, and
this approach scales better to handling more kinds.

bytestring.c, catacomb/__init__.py: Introduce and use `zero' method.

Seems like strings of zero bytes are especially useful.  Add a class
method to `ByteString' to generate them efficiently, and use it to make
the magic `Z128' constant.

catacomb/__init__.py: Calculate `X25519_BASE' and `X448_BASE'.

Easier on the eyes and brain.

utils.c: Raise exceptions from `convTHING' with null arguments.

This can happen as a result of using `convTHING' in an attribute `set'
function, and the Python program trying to `del' the attribute.
Unfortunately, these conversion functions are already being used in this
context, and it leads to segfaults, e.g., from

  del C.Key(C.KeyFile('', C.KOPEN_WRITE | C.KOPEN_NOFILE), 0, 'k').exptime

Easy fix.

bytestring.c: Use `arg' rather than `args' for argument tuples.

catacomb/__init__.py: Rename stupidly named arguments.

I don't know where I got `*kw' from.  Sorry.

catacomb/__init__.py: Fix bungled `unbox' method of `_BoxyPriv'.

Merge branch '1.1.x'

* 1.1.x:
  Release 1.1.2.
  catacomb/__init__.py: Fix up cipher etc. names better.
  algorithms.c: Support the new 16-bit key-size descriptors.
  group.c: Track Catacomb group internals change.
  utils.c: Raise exceptions from `convTHING' with null arguments.
  Return `long' objects when `int' is requested but the value won't fit.
  bytestring.c: Check for cached hash more carefully.
  rand.c: Careful range checking on `block' and `mp'.
  *.c: Fix docstrings for methods.
  Further fixing to use `Py_ssize_t' in place of int.

Conflicts:
debian/control (already wanted later catacomb-dev)
group.c (no need for compatibility with older Catacombs)

Release 1.1.2.

catacomb/__init__.py: Fix up cipher etc. names better.

Now `sha512/256', for example, will have the right name.

algorithms.c: Support the new 16-bit key-size descriptors.

group.c: Track Catacomb group internals change.

utils.c: Raise exceptions from `convTHING' with null arguments.

This can happen as a result of using `convTHING' in an attribute `set'
function, and the Python program trying to `del' the attribute.
Unfortunately, these conversion functions are already being used in this
context, and it leads to segfaults, e.g., from

  del C.Key(C.KeyFile('', C.KOPEN_WRITE | C.KOPEN_NOFILE), 0, 'k').exptime

Easy fix.

Return `long' objects when `int' is requested but the value won't fit.

Mostly, Python handles the error from the `int' conversion and falls
back to long, but there's something weird in iteration, where if you say

for i in ...:
  print '%d' % x

then the loop finishes and /then/ you get an exception for the overflow
from the failed conversion of x to an `int'.

Follow Python's actual behaviour: have `mp_tolong_checked' take an extra
argument indicating whether to throw an exception, and modify most of
the call sites to fall back to a conversion based on `mp_topylong'.

bytestring.c: Check for cached hash more carefully.

The `CACHE_HASH' symbol has been missing for years because the feature
is always on nowadays.  Amazingly, I never noticed.

rand.c: Careful range checking on `block' and `mp'.

  * For `mp', don't allow the `or' mask to be wider than the requested
    result.

  * For `range', insist that the limit is strictly positive, so that the
    output range is actually inhabited.

These parallel currently unreleased fixes to the underlying library,
which are required for things to work properly; so bump the dependency.

*.c: Fix docstrings for methods.

Mostly fixing method names andarguments broken by bad copy-and-paste
editing.

Further fixing to use `Py_ssize_t' in place of int.

This addresses the remaining compiler warnings when building for 64-bit
targets.

algorithms.c: Check whether `setiv' and `bdry' are implemented before calling.

Oops, easy segfault.

catacomb/__init__.py: Add printing for more key types.

Now that we have secret suppression, it's not an attractive nuisance to
print key material for public keys like RSA, DSA, KCDSA, and XDH.  So do
that.

Digging key material out of symmetric crypto objects is really hard, so
we don't try to do that.