NoSuchAlgorithmExceptions. Key generation is *slow* - I guess that's a
good sign. ;-)

CryptoModule with provider methods.

consist of independently encrypted and authenticated packets (Ack,
Batch, Subscriptions and Transports so far).

depending on the value of the first byte, so that an object's initial
tag is included in the data seen by the ObjectReader. Digests and
signatures can therefore be calculated over objects by their readers
without any risk of ambiguity.

authentication will make them redundant.

expected type, and re-throw as FormatException.

for easier testing.

by registering ObjectReaders with the Reader.

Defined some user-defined tags for protocol elements. Currently they're just adding redundancy, but in future they'll be used for parsing nested elements.

A more efficient encoding for short strings, raws, lists and maps. Now we can encode a list of three small integers in 4 bytes like MessagePack does, should that ever turn out to be useful.

platform.

Don't store subscription or transport updates that are older than those already received. Also some small changes to DatabaseComponent impls for readability.

Retrieve messages from the database in raw form to avoid creating unnecessary short-lived objects. Added timestamps to headers.

New retransmission mechanism, which does away with the need for bundle IDs and should cope better with high bandwidth-delay product links.

Rewrote the bundle reading and writing code to eliminate copying. Signatures and digests are now calculated on the fly as the data is read or written. This is a little bit tricky in the case of reading because ReaderImpl uses a lookahead byte, so the signature and message digest need to lag one byte behind.

Added accessors for the amount of raw data read and written by readers and writers - this fixes a fixme in MessageParserImpl.

Builders for incoming and outgoing headers and batches. The protocol and serial components can now be used to serialise, sign, deserialise and verify real bundles (except for message parsing).

Protocol refactoring. Each bundle now consists of a signed header and zero or more signed batches. There is no overall signature on the bundle, since the bundle's contents may need to be processed before the entire bundle has been read. The protocol does not prevent an adversary from removing batches from a bundle, reordering batches, moving them from one bundle to another, etc. However, since each batch is signed and acknowledged independently, no such guarantees are required. Bundle IDs will go away when the retransmission mechanism is changed.