Given that the timestamp is already a 64-bit unsigned big-endian
integer, the spec will remain viable for over 500,000 years.

This allows us to more precisely compare token creation timestamps
against revocation event timestamps (which already have microsecond
precision). This helps us avoid a race condition wherein a token can be
created *after* a revocation event, but appear to be created *before*
it, thus matching the revocation event and being considered invalid.
After this change, the specification is still vulnerable to this race
condition, but the time window to reproduce it is narrowed to a single
microsecond, instead of a single second.

Closes fernet#12

Closes fernet#3

This is mostly intended to further explain the change in version 0x81.

This will ensure that Github will render the spec on the repository's
homepage (the repo is already called "spec", after all!).

I think I wrote this thinking there was only one difference between the
two versions, my grammar followed suit, but the statement should be more
generic to handle more than just two versions and more than just one
difference between the existing two versions.

TODOs are serving as placeholders for actual 0x81 tokens, which I've
neither created by hand nor written an implementation to produce, yet.

I accidentally put them in the TZ, whoops!

I rebuilt the valid 0x80 tokens in the acceptance tests manually using
the following function to convert them. This explicitly illustrates the
differences between 0x80 and 0x81.

import base64
import hashlib
import hmac
import struct

def upgrade_to_81(x80_token, secret):
    """Upgrade an 0x80 token to 0x81 given a new timestamp and secret."""
    # Decode the 0x80 version token.
    x80_bytes = base64.urlsafe_b64decode(x80_token)

    # Unpack the timestamp so we can manipulate it.
    seconds = struct.unpack('>Q', x80_bytes[1:9])

    # Convert seconds to microseconds, and add some microseconds.
    microseconds = int(seconds * 1e6) + 123456

    x81_bytes = '\x81'  # New version identifier.
    x81_bytes += struct.pack(">Q", microseconds)
    x81_bytes += x80_bytes[9:-32]
    x81_bytes += hmac.new(
        base64.b64decode(secret)[16:],
        x81_bytes,
        hashlib.sha256).digest()

    return base64.urlsafe_b64encode(x81_bytes)