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.

catacomb/__init__.py: Don't print secret bits of keys by default.

Introduce a `PRINT_SECRETS' flag which can easily be twiddled (e.g., in
IPython) to control whether obvious secrets are printed literally or
censored (the default).  This is intended to make accidental leakage a
bit less likely, rather than as a security feature.

catacomb/__init__.py: Add `_clsname' for printing class names.

Replace both the ugly `type(me).__name__' rune, and literal class names.

catacomb/__init__.py: Abstract out common printing for `KeyData' subclasses.

Introduce `_guts' to return the thing that each subclass encapsulates.
`KeyDataStructured' is a special snowflake which I'm willing to handle
separately.

pubkey.c: Change the arguments to {DSA,KCDSA}{Pub,Priv}.

  * Don't allow a private-key `u' argument to `*Pub'.

  * Have the private key argument `u' precede the public key `p' to
    `*Priv'.

  * Make the public key optional to `*Priv', and compute it correctly if
    not provided.

This is an incompatible change, but I've resolved not to care.  The old
interface was obviously crazy.

catacomb/__init__.py: Print group elements properly.

Slightly grim: add a method to group objects to export their elements as
some useful type, and then call that from the element print function.

catacomb/__init__.py: Print groups properly.

catacomb/__init__.py: Add printing for points on known curves.

Now the coordinates print correctly as field elements.

group.c: Make element `toec()' method return point on correct curve.

Rather than a generic point.  Now it will print correctly.

catacomb/__init__.py: Abstract out common pretty-printing patterns.

Don't hardwire indentation levels from header lengths; don't hardwire
type names; hide away the ugly `type(me).__name__' rune.

catacomb/__init__.py: Support IPython's pretty-printer.

Add `_repr_pretty_' methods to many types to improve presentation.
Also, sneakily add a bunch of printing methods to the key-management
classes.

catacomb/__init__.py: Support `len' on `_groupmap' objects.

catacomb/__init__.py: Use `%#x' rather than `hex' now.

The reason `%x' used not to work is the recently-fixed bug whereby
conversions to `int' raised exceptions rather than returning `long'.

Merge branches 'mdw/latin-ietf' and 'mdw/curve25519'

* mdw/latin-ietf:
  algorithms.py: Support the IETF versions of ChaCha etc. with 96-bit nonce.

* mdw/curve25519:
  pubkey.c, catacomb/__init__.py: Add bindings for Hamburg's X448.
  pubkey.c, ...: Support Bernstein's `Ed25519' signature scheme.
  pubkey.c, ...: Support Bernstein's `X25519' key-agreement algorithm.

algorithms.py: Support the IETF versions of ChaCha etc. with 96-bit nonce.

pubkey.c, catacomb/__init__.py: Add bindings for Hamburg's X448.

pubkey.c, ...: Support Bernstein's `Ed25519' signature scheme.

pubkey.c, ...: Support Bernstein's `X25519' key-agreement algorithm.

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'.

group.c: Track Catacomb group internals change.

catacomb/__init__.py: Add a simple implementation of NaCl `secretbox'.

algorithms.c: Add binding for `poly1305_flushzero'.

algorithms.c: Fix Poly1305 `hashu...' and `hashbuf...' methods.

Hash the input number or length, not the size of the field.

bytestring.c, catacomb/__init__.py: Compare for equality in constant time.

There's an explicit `ctstreq' function which just does what you wanted.
Also, `ByteString' objects now have a rich-compare method which always
compares for equality in constant time.  Ordering comparisons are
variable time still.

There's a little chicanery to retain the hash function from `str'.

Also add a simple `check' method to `GHash' and `Poly1305Hash' which
compares a hsah or MAC tag in constant time and returns a boolean
result.

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.

*.c: Declare `PY_SSIZE_T_CLEAN'.

Now we can process large strings on 64-bit targets.  Err, win?

algorithms.c: Add bindings for HSalsa20/r and HChaCha/r.

algorithms.c: Add support for Poly1305.

catacomb-python.h, util.c: Support for declaring types with weird metatypes.

algorithms.c: Reorder the `ghash' definitions.

algorithms.c: Fix docstring for `GCHash.hashsz'.

algorithms.c: Set required size on GMAC objects.

The Python interpreter catches this in debug mode.  Also, it's really
bad.

rand.c, algorithms.py: Support random access protocol of Latin-dance PRFs.

Add a new superclass for random bit generators based on Latin-dance
PRFs (Salsa20, ChaCha, etc.) which exposes the `seek'/`tell' random
access protocol to Python.

util.c: Add conversions between Python objects and `kludge64'.

catacomb-python.h: Don't inhibit 64-bit type detection any more.

We'll be using `kludge64', and the definition must properly match up
with the library.

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.

util.c: Zap spurious whitespace.

*.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.

Release 1.1.1.

bytestring.c: Use `Py_ssize_t' for collecting buffer lengths.

On 64-bit platforms, this is a 64-bit long, so if we pass an int to
`PyObject_AsReadBuffer', it will clobber the next word too.

Release 1.1.0.1.

debian/control: Fix the Build-Depends.

debian/source/format: Apparently we need one of these nowadays.

Release 1.1.0.

Require a shiny new library version.

Merge branches 'mdw/pwsafe' and 'mdw/ec-ptcmpr'

* mdw/pwsafe:
  pwsafe: New command `xfer' to transfer data to a new database backend.
  catacomb/pwsafe.py: Add a backend based on SQLite.
  catacomb/pwsafe.py, pwsafe: Make GDBM support conditional.
  catacomb/pwsafe.py: New Git-friendly `DirectoryStorageBackend'.
  catacomb/pwsafe.py: New FlatFileStorageBackend class.
  catacomb/pwsafe.py: Add a new ABRUPTP argument to `close' methods.
  catacomb/pwsafe.py, pwsafe: Dispatching for multiple backends.
  catacomb/pwsafe.py: Split out the GDBM-specifics from StorageBackend.
  catacomb/pwsafe.py: Factor database handling out into a StorageBackend.
  catacomb/pwsafe.py: Commentary fix.
  pwsafe: Abolish the `chomp' function, and only chomp when reading stdin.
  catacomb/pwsafe.py: Make `PW' be a context manager, and use it.
  pwsafe: Get the master passphrase before the new password.
  pwsafe: Report password mismatch as an error, not an exception.
  pwsafe: Some simple reformatting.
  catacomb/pwsafe.py, pwsafe: Replace `PW''s MODE parameter with WRITEP flag.
  catacomb/pwsafe.py: Abolish the `PWIter' class.
  pwsafe: Eliminate the `dump' subcommand.
  pwsafe: Present the list of commands in alphabetical order.
  pwsafe: Don't produce a backtrace on decryption failure.

* mdw/ec-ptcmpr:
  catacomb.c, ec.c: Bindings for the new EC2OSP/OS2ECP functions.

pwsafe: New command `xfer' to transfer data to a new database backend.

This works at the StorageBackend level, and doesn't require any secrets
to do its thing.

catacomb/pwsafe.py: Add a backend based on SQLite.

catacomb/pwsafe.py, pwsafe: Make GDBM support conditional.

Only offer the GDBM backend if the module is actually available.  Also,
make the new `flat file' backend be the default, since it's the only one
which is guaranteed to exist.

catacomb/pwsafe.py: New Git-friendly `DirectoryStorageBackend'.

catacomb/pwsafe.py: New FlatFileStorageBackend class.

No external dependencies required.

catacomb/pwsafe.py: Add a new ABRUPTP argument to `close' methods.

New backends might want to commit changes at close time, and an abrupt
close shouldn't do that.

catacomb/pwsafe.py, pwsafe: Dispatching for multiple backends.

This commit introduces a number of tightly related changes.

  * Have concrete backends declare a `NAME' attribute.  This lets users
    name them, and lets us determine which classes are concrete.

  * Introduce a metaclass which registers concrete StorageClass
    subclasses.

  * Extend the `_open' protocol, so that it can raise the new
    StorageBackendRefusal exception to indicate that some other backend
    should try to open the given file.

  * Introduce a `StorageBackend.open' method which examines all
    registered backends and gives each of them an opportunity to open
    the file in some priority order.

  * Add a new method for looking up backends by name.

  * introduce a new DBCLS parameter to `PW.create', which is the backend
    class to use when creating a new database.

  * Introduce a new option to the `create' command to choose the
    database backend by name.

There's only one backend at the moment, though that will change soon.

catacomb/pwsafe.py: Split out the GDBM-specifics from StorageBackend.

For now, use the GDBM-based backend explicitly and unconditionally,
because there isn't another one anyway.

catacomb/pwsafe.py: Factor database handling out into a StorageBackend.

This doesn't (currently) affect the external interface.

catacomb/pwsafe.py: Commentary fix.

pwsafe: Abolish the `chomp' function, and only chomp when reading stdin.

We have `S.rstrip()' instead.

catacomb.c, ec.c: Bindings for the new EC2OSP/OS2ECP functions.

Use ValueError instead of SyntaxError throughout.

SyntaxError has a much more specific meaning, and some software, such as
`ipython', expect it to carry lots of other detailed information.

So abolish the `SYNERR' macro, and use `VALERR' instead consistently.  I
wish I had an excuse for this blunder, but I don't.

catacomb/pwsafe.py: Make `PW' be a context manager, and use it.

pwsafe: Get the master passphrase before the new password.

This saves lots of repeating the new password if the user is prone to
typing the master password wrongly.  Like I am.

pwsafe: Report password mismatch as an error, not an exception.

pwsafe: Some simple reformatting.

catacomb/pwsafe.py, pwsafe: Replace `PW''s MODE parameter with WRITEP flag.

This abstracts away from the GDBM interface slightly, and makes it a bit
more convenient for other implementations.

catacomb/pwsafe.py: Abolish the `PWIter' class.

There's no identifiable advantage to writing all of that out longhand
over a simple generator.  So do that instead.

pwsafe: Eliminate the `dump' subcommand.

Its functionality will be replaced later.

Also, remove some functions which existed only to support `dump'.

pwsafe: Present the list of commands in alphabetical order.

Previously they were in whatever dictionary order.  Hopeless.

algorithms.py, rand.c: Support `Latin dances' stream ciphers.

catacomb/__init__.py: Trim `/' from identifiers names.

algorithms.py, rand.c: Move constant definitions and so on to `rand.c'.