Merge lp:~jderose/filestore/dbase32 into lp:filestore

[Jason Gerard DeRose]

For details, see this bug:

https://bugs.launchpad.net/filestore/+bug/1130156

Changes include:

* Use compatibility functions from `dbase32.rfc3548` so that it will be very easy to switch to Dbase32, in particular use `isb32()` instead of set operations with B32ALPHABET; we can just replace with `isdb32()` when needed

* Removed protocol selection-by-ID-length functionality, for now; this was incomplete and as we have a demanding migration ahead of us, I backed this feature out so we have less complexity to deal with during the migration

* `Protocol.hash_root()` now returns a binary digest instead of a Base32 encoded ID, and `filestore.protocols` is now completely encoding agnostic, does nothing with encoding itself

* `Protocol.hash_leaf()` now transforms *leaf_index* into the key bytes rather than relying on `Protocol._hash_leaf()` to do this

* Likewise, `Protocol.hash_root()` now transforms *file_size* into the key bytes rather than relying on `Protocol._hash_root()` to do this

* `Protocol` is now a base class without any hashing implementation itself; real implementations are now in the `SkeinProtocol` and `OldSkeinProtocol` subclasses

* Changed V1 to use a 240-bit digest and DBase32 encoding, updated test vectors accordingly

* Split old test-vectors.json file (which contained both V0 and V1) into separate V0.json and V1.json files

* Added MD5SUMS.json with md5sums of various values used by the test vectors; these are helpful for debugging an implementation, as mention in the specification

* Huge refactor of the unit tests for `filestore.protocols`; in particular, no digest values are in the unit tests anymore; instead, digests come from the JSON data files only, making it much easier to tweak a protocol without having to make huge changes in the unit tests

* misc.build_vectors() now takes optional *encoder* kwarg, which defaults to `db32enc`, so the test vector building is no longer hard-coded to a specific encoding

[Jason Gerard DeRose (jderose)]

As this diff is pretty sprawling and noisy, you can probably understand the key changes more easily by just looking at filestore/protocols.py:

http://bazaar.launchpad.net/~jderose/filestore/dbase32/view/head:/filestore/protocols.py

[David Jordan (dmj726)]

Approve.

review: Approve

=== modified file 'debian/control'
--- debian/control	2013-02-18 11:42:49 +0000
+++ debian/control	2013-02-19 15:39:24 +0000
@@ -6,7 +6,7 @@
     python3-all-dev (>= 3.3),
     python3-sphinx,
     python3-skein (>= 0.7.1),
-    python3-dbase32 (>= 0.3),
+    python3-dbase32 (>= 0.4),
 Standards-Version: 3.9.3
 X-Python3-Version: >= 3.2
 Homepage: https://launchpad.net/filestore
@@ -15,7 +15,7 @@
 Architecture: any
 Depends: ${python3:Depends}, ${shlibs:Depends}, ${misc:Depends},
     python3-skein (>= 0.7.1),
-    python3-dbase32 (>= 0.3),
+    python3-dbase32 (>= 0.4),
 Description: Dmedia hashing protocol and file layout
  This is the heart of Dmedia.  It has been split out of Dmedia to make it easier
  to review, and in hopes that other apps might use the hashing protocol and
 
=== modified file 'filestore/__init__.py'
--- filestore/__init__.py	2013-02-18 12:41:32 +0000
+++ filestore/__init__.py	2013-02-19 15:39:24 +0000
@@ -76,15 +76,17 @@
 from os import path
 import io
 import stat
-from base64 import b32encode, b64encode
+from base64 import b64encode
 from threading import Thread
 from queue import Queue
 from collections import namedtuple
 import logging
 
 from dbase32 import random_id
+from dbase32.rfc3548 import b32enc, isb32
 
-from .protocols import VERSION0, VERSION1
+from .protocols import TYPE_ERROR
+from .protocols import VERSION0 as PROTOCOL
 
 try:
     from _filestore import fallocate, fastread
@@ -100,13 +102,10 @@
 
 log = logging.getLogger('filestore')
 
-LEAF_SIZE = 8 * 1024 * 1024  # 8 MiB leaf size
+LEAF_SIZE = 8388608  # 8 MiB leaf size
 DIGEST_BITS = 240
-DIGEST_BYTES = DIGEST_BITS // 8
-DIGEST_B32LEN = DIGEST_BITS // 5
-
-ALLOWED_B32LEN = (48, 56)
-PROTOCOL = VERSION0
+DIGEST_BYTES = 30
+DIGEST_B32LEN = 48
 
 # Handy constants for file layout:
 DOTNAME = '.dmedia'
@@ -130,9 +129,6 @@
 
 IO_READABLE = (io.BufferedReader, io.BufferedRandom)
 
-# Provide very clear TypeError messages:
-TYPE_ERROR = '{}: need a {!r}; got a {!r}: {!r}'
-
 # For the README.txt in .dmedia directories:
 README = """This directory is automatically managed by Dmedia.
 
@@ -155,13 +151,13 @@
 
     For example:
 
-    >>> b32encode(hash_leaf(2, b'XYZ'))
-    b'D7GIW5I5NB6SLJC5ALAX4WU7S7CNYUB3ULMECPY67FFQG4F7'
+    >>> b32enc(hash_leaf(2, b'XYZ'))
+    'D7GIW5I5NB6SLJC5ALAX4WU7S7CNYUB3ULMECPY67FFQG4F7'
 
     :param leaf_index: an ``int`` >= 0
     :param leaf_data: optional ``bytes`` instance with contents of this leaf
     """
-    return VERSION0.hash_leaf(leaf_index, leaf_data)
+    return PROTOCOL.hash_leaf(leaf_index, leaf_data)
 
 
 def hash_root(file_size, leaf_hashes):
@@ -177,15 +173,7 @@
     :param leaf_hashes: a ``bytes`` instance that is the concatenated leaf
         hashes produced by `hash_leaf()`
     """
-    return VERSION0.hash_root(file_size, leaf_hashes)
-
-
-def get_protocol(_id):
-    check_id(_id)
-    if len(_id) == 48:
-        return VERSION0
-    assert len(_id) == 56
-    return VERSION1
+    return b32enc(PROTOCOL.hash_root(file_size, leaf_hashes))
 
 
 class Hasher:
@@ -193,10 +181,9 @@
     A helper to keep track of state as you hash leaf after leaf.
     """
 
-    __slots__ = ('protocol', 'file_size', 'leaf_index', 'array', 'closed')
+    __slots__ = ('file_size', 'leaf_index', 'array', 'closed')
 
-    def __init__(self, protocol=PROTOCOL):
-        self.protocol = protocol
+    def __init__(self):
         self.file_size = 0
         self.leaf_index = 0
         self.array = bytearray()
@@ -211,9 +198,9 @@
             raise Exception('Expected leaf.index {}, got {}'.format(
                     self.leaf_index, leaf.index)
             )
-        if len(leaf.data) < self.protocol.leaf_size:
+        if len(leaf.data) < LEAF_SIZE:
             self.closed = True
-        leaf_hash = self.protocol.hash_leaf(leaf.index, leaf.data)
+        leaf_hash = PROTOCOL.hash_leaf(leaf.index, leaf.data)
         self.array.extend(leaf_hash)
         self.file_size += len(leaf.data)
         self.leaf_index += 1
@@ -223,7 +210,7 @@
         self.closed = True
         leaf_hashes = bytes(self.array)
         return ContentHash(
-            self.protocol.hash_root(self.file_size, leaf_hashes),
+            b32enc(PROTOCOL.hash_root(self.file_size, leaf_hashes)),
             self.file_size,
             leaf_hashes
         )
@@ -345,12 +332,12 @@
     """
     if not isinstance(_id, str):
         raise TypeError(TYPE_ERROR.format('_id', str, type(_id), _id))
-    if not (len(_id) in  ALLOWED_B32LEN and set(_id).issubset(B32ALPHABET)):
+    if not (len(_id) == DIGEST_B32LEN and isb32(_id)):
         raise IDError(_id)
     return _id
 
 
-def check_leaf_hashes(leaf_hashes, protocol=PROTOCOL):
+def check_leaf_hashes(leaf_hashes):
     """
     Verify that *leaf_hashes* is a ``bytes`` instance of correct length.
 
@@ -372,7 +359,7 @@
                 'leaf_hashes', bytes, type(leaf_hashes), leaf_hashes
             )
         )
-    if len(leaf_hashes) == 0 or len(leaf_hashes) % protocol.digest_bytes != 0:
+    if len(leaf_hashes) == 0 or len(leaf_hashes) % DIGEST_BYTES != 0:
         raise LeafHashesError(leaf_hashes)
     return leaf_hashes
 
@@ -400,12 +387,11 @@
     22
 
     """
-    protocol = get_protocol(_id)
-    computed = protocol.hash_root(file_size, leaf_hashes)
+    computed = hash_root(file_size, leaf_hashes)
     if _id != computed:
         raise RootHashError(_id, file_size, leaf_hashes, computed)
     if unpack:
-        leaf_hashes = tuple(iter_leaf_hashes(leaf_hashes, protocol))
+        leaf_hashes = tuple(iter_leaf_hashes(leaf_hashes))
     return ContentHash(_id, file_size, leaf_hashes)
 
 
@@ -439,7 +425,7 @@
 #################################################
 # Utility functions for working with leaf_hashes:
 
-def enumerate_leaf_hashes(leaf_hashes, protocol=PROTOCOL):
+def enumerate_leaf_hashes(leaf_hashes):
     """
     Enumerate *leaf_hashes*.
 
@@ -451,13 +437,12 @@
     [(0, b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'), (1, b'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB')]
 
     """
-    check_leaf_hashes(leaf_hashes, protocol)
-    digest_bytes = protocol.digest_bytes
-    for i in range(len(leaf_hashes) // digest_bytes):
-        yield (i, leaf_hashes[i*digest_bytes : (i+1)*digest_bytes])
-
-
-def iter_leaf_hashes(leaf_hashes, protocol=PROTOCOL):
+    check_leaf_hashes(leaf_hashes)
+    for i in range(len(leaf_hashes) // DIGEST_BYTES):
+        yield (i, leaf_hashes[i*DIGEST_BYTES : (i+1)*DIGEST_BYTES])
+
+
+def iter_leaf_hashes(leaf_hashes):
     """
     Iterate through *leaf_hashes*.
 
@@ -469,13 +454,12 @@
     [b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', b'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB']
 
     """
-    check_leaf_hashes(leaf_hashes, protocol)
-    digest_bytes = protocol.digest_bytes
-    for i in range(len(leaf_hashes) // digest_bytes):
-        yield leaf_hashes[i*digest_bytes : (i+1)*digest_bytes]
-
-
-def get_leaf_hash(leaf_hashes, i, protocol=PROTOCOL):
+    check_leaf_hashes(leaf_hashes)
+    for i in range(len(leaf_hashes) // DIGEST_BYTES):
+        yield leaf_hashes[i*DIGEST_BYTES : (i+1)*DIGEST_BYTES]
+
+
+def get_leaf_hash(leaf_hashes, i):
     """
     Return a slice containing the i-th leaf_hash from *leaf_hashes*.
 
@@ -490,8 +474,9 @@
     b''
 
     """
-    digest_bytes = protocol.digest_bytes
-    return leaf_hashes[i*digest_bytes : (i+1)*digest_bytes]
+    start = i * DIGEST_BYTES
+    stop = start + DIGEST_BYTES
+    return leaf_hashes[start:stop]
 
 
 def missing_leaves(fp, leaf_hashes):
@@ -764,7 +749,7 @@
     thread.join()  # Make sure batch_reader() terminates
 
 
-def hash_fp(src_fp, dst_fp=None, protocol=PROTOCOL):
+def hash_fp(src_fp, dst_fp=None):
     """
     Compute content hash of open file *src_fp*, optionally writing *dst_fp*.
 
@@ -777,7 +762,7 @@
     :param src_fp: A file opened in mode "rb" or "r+b"
     :param dst_fp: An optional file opened in mode "wd"
     """
-    hasher = Hasher(protocol)
+    hasher = Hasher()
     for leaf in reader_iter(src_fp):
         hasher.hash_leaf(leaf)
         if dst_fp:
@@ -907,9 +892,7 @@
             subdir = path.join(self.basedir, 'files', prefix)
             for name in sorted(os.listdir(subdir)):
                 _id = prefix + name
-                if len(_id) not in ALLOWED_B32LEN:
-                    continue
-                if not set(_id).issubset(B32ALPHABET):
+                if len(_id) != DIGEST_B32LEN or not isb32(_id):
                     continue
                 fullname = path.join(subdir, name)            
                 st = os.lstat(fullname)
@@ -1109,7 +1092,7 @@
             a ContentHash namedtuple
         """
         src_fp = self.open(_id)
-        c = hash_fp(src_fp, protocol=get_protocol(_id))
+        c = hash_fp(src_fp)
         if c.id != _id:
             raise self.move_to_corrupt(src_fp, _id, bad_id=c.id)
         if return_fp:
 
=== added file 'filestore/data/MD5SUMS.json'
--- filestore/data/MD5SUMS.json	1970-01-01 00:00:00 +0000
+++ filestore/data/MD5SUMS.json	2013-02-19 15:39:24 +0000
@@ -0,0 +1,23 @@
+{
+    "files": {
+        "A": "7fc56270e7a70fa81a5935b72eacbe29",
+        "B": "d2bad3eedb424dd352d65eafbf6c79ba",
+        "C": "5dd3531303dd6764acb93e5f171a4ab8",
+        "CA": "0722f8dc36d75acb602dcee8d0427ce0",
+        "CB": "77264eb6eed7777a1ee03e2601fc9f64",
+        "CC": "1fbfabdaafff31967f9a95f3a3d3c642"
+    },
+    "integers": {
+        "0": "cfcd208495d565ef66e7dff9f98764da",
+        "1": "c4ca4238a0b923820dcc509a6f75849b",
+        "16777215": "48ac8929ffdc78a66090d179ff1237d5",
+        "16777216": "e3e330499348f791337e9da6b534a386",
+        "8388607": "32433904a755e2b9eb82cf167723b34f",
+        "8388608": "03926fda4e223707d290ac06bb996653",
+        "8388609": "e9b74719ce6b80c5337148d12725db03"
+    },
+    "personalization": {
+        "leaf": "8aee35e23a5a74147b230f12123ca82e",
+        "root": "0445d91d37383f5384023d49e71cc629"
+    }
+}
 
=== added file 'filestore/data/V0.json'
--- filestore/data/V0.json	1970-01-01 00:00:00 +0000
+++ filestore/data/V0.json	2013-02-19 15:39:24 +0000
@@ -0,0 +1,24 @@
+{
+    "leaf_hashes": {
+        "A": [
+            "C23GME2TRCBFM2PA3VIZPUOD5DFYAQLQY2VR46ZKBMH4S4WL",
+            "BWRAN4NJSXYJS6V3YQNNV2EKLEEGNAK5VPSIYZKOBXJ3PPJF"
+        ],
+        "B": [
+            "NLJ2OHB45MJELINPXJCTBCI7VT3424GRTN36BDP5Z3NE2W5Z",
+            "ALAA376NIW54WR5N6JY2EPR6VFJI7AC2V7PJCRETDIGRQJDN"
+        ],
+        "C": [
+            "ZQ6RUCU75DHFODZEGNL66QJUM34A3UA53TG2YK7LHRU4SUTF",
+            "MCZHG4NBL5VWKCQIARDXR6IHN34ALIDH7OVYAZ5TNDLXIKA4"
+        ]
+    },
+    "root_hashes": {
+        "A": "O4NQ4LFNI2UCMKOSWWGPRZXSNEPW2M6OOTBFM3AHTBK35D67",
+        "B": "NW6IMGBAU4NTZDQRHGIZA7VYV5CBZ5TUXADHZE43N4GDZGKK",
+        "C": "TRXCE6PVSJTHQX7H4KV7A7F5DKCMSETLMNANNCJIVT624WLU",
+        "CA": "QSUCTH4LJU3B7QG7IJ3FC7HNE4TXDPZVQEJ36B4A45ATTXDM",
+        "CB": "3FWPZ6RBPXGBSTFBNPK5IOCO7DUMSKR5YTWJ3HM2KI4AEF2O",
+        "CC": "CX2K52LIUTT6SSMFHR7NUI6YIJLO3SGKLSRIL6IDY4BP7HUZ"
+    }
+}
 
=== added file 'filestore/data/V1.json'
--- filestore/data/V1.json	1970-01-01 00:00:00 +0000
+++ filestore/data/V1.json	2013-02-19 15:39:24 +0000
@@ -0,0 +1,24 @@
+{
+    "leaf_hashes": {
+        "A": [
+            "3M3IHYG9TV3UWTIFI37LN5OVYFEB3PDIAUAQ7OKOQF84MIQT",
+            "VACOMMVCMJP9QBIUIEMMYAPXOWRYDFW3JQUJB4NGNMF48IIW"
+        ],
+        "B": [
+            "YSRG5KWP5IKWCXTHNN58PY7KSEUJ6JYKDA4RT3F7T8UATQC7",
+            "V6QX3QUDUNE9PVJVF8HBUP4RBKY7AXRJ7MBPWASIKTVWYVUD"
+        ],
+        "C": [
+            "C8BNKNHHPCSONGE785HTVTIXCHFBCT5SY9GYRDELHQ3BVEHV",
+            "EEOJR9LHS46469EYDUWYWOK7BXW5Y486SNEG9KTSHSSPNIMQ"
+        ]
+    },
+    "root_hashes": {
+        "A": "6VKN463LEKJMD3OP87UYVU5V65XXOSG3HCT3Q6NDJD58TQXK",
+        "B": "GJDVCPR3JPBFABMGP6PDUBOVQIXX5YLF9PG49SSDJVQEKLOR",
+        "C": "NXIA8BHKVQTD9ACIPT3J7QUYM96FYWJBBEL34YKTA6CKE9IC",
+        "CA": "L66Y5M37PX93NBYYWCSSKW6QQBEYH76OOJFUQJ7FQEA7IB9S",
+        "CB": "SFKVIEOWCIKENPMKDEAGATIA9DGH54LF9BW5LCOW7F9YN9BL",
+        "CC": "VCPN5J8EI4G5PH5A4CUWSPCRTEWGD65PB4WMTGQ7CEVJ6XLO"
+    }
+}
 
=== removed file 'filestore/data/test-vectors.json'
--- filestore/data/test-vectors.json	2013-01-15 04:18:38 +0000
+++ filestore/data/test-vectors.json	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-{
-    "48": {
-        "leaf_hashes": {
-            "A": [
-                "C23GME2TRCBFM2PA3VIZPUOD5DFYAQLQY2VR46ZKBMH4S4WL",
-                "BWRAN4NJSXYJS6V3YQNNV2EKLEEGNAK5VPSIYZKOBXJ3PPJF"
-            ],
-            "B": [
-                "NLJ2OHB45MJELINPXJCTBCI7VT3424GRTN36BDP5Z3NE2W5Z",
-                "ALAA376NIW54WR5N6JY2EPR6VFJI7AC2V7PJCRETDIGRQJDN"
-            ],
-            "C": [
-                "ZQ6RUCU75DHFODZEGNL66QJUM34A3UA53TG2YK7LHRU4SUTF",
-                "MCZHG4NBL5VWKCQIARDXR6IHN34ALIDH7OVYAZ5TNDLXIKA4"
-            ]
-        },
-        "root_hashes": {
-            "A": "O4NQ4LFNI2UCMKOSWWGPRZXSNEPW2M6OOTBFM3AHTBK35D67",
-            "B": "NW6IMGBAU4NTZDQRHGIZA7VYV5CBZ5TUXADHZE43N4GDZGKK",
-            "C": "TRXCE6PVSJTHQX7H4KV7A7F5DKCMSETLMNANNCJIVT624WLU",
-            "CA": "QSUCTH4LJU3B7QG7IJ3FC7HNE4TXDPZVQEJ36B4A45ATTXDM",
-            "CB": "3FWPZ6RBPXGBSTFBNPK5IOCO7DUMSKR5YTWJ3HM2KI4AEF2O",
-            "CC": "CX2K52LIUTT6SSMFHR7NUI6YIJLO3SGKLSRIL6IDY4BP7HUZ"
-        }
-    },
-    "56": {
-        "leaf_hashes": {
-            "A": [
-                "XZ5I6KJTUSOIWVCEBOKUELTADZUXNHOAYO77NKKHWCIW3HYGYOPMX5JN",
-                "TEC7754ZNM26MTM6YQFI6TMVTTK4RKQEMPAGT2ROQZUBPUIHSJU2DDR3"
-            ],
-            "B": [
-                "P67PVKU3SCCQHNIRMR2Z5NICEMIP36WCFJG4AW6YBAE6UI4K6BVLY3EI",
-                "ZIFO5S2OYYPZAUN6XQWTWZGCDATXCGR2JYN7UIAX54WMVWETMIUFG7WM"
-            ],
-            "C": [
-                "RW2GJFIGPQF5WLR53UAK77TPHNRFKMUBYRB23JFS4G2RFRRNHW6OX4CR",
-                "XBVLPYBUX6QD2DKPJTYVUXT23K3AAUAW5J4RMQ543NQNDAHORQJ7GBDE"
-            ]
-        },
-        "root_hashes": {
-            "A": "FWV6OJYI36C5NN5DC4GS2IGWZXFCZCGJGHK35YV62LKAG7D2Z4LO4Z2S",
-            "B": "OB756PX5V32JMKJAFKIAJ4AFSFPA2WLNIK32ELNO4FJLJPEEEN6DCAAJ",
-            "C": "QSOHXCDH64IQBOG2NM67XEC6MLZKKPGBTISWWRPMCFCJ2EKMA2SMLY46",
-            "CA": "BQ5UTB33ML2VDTCTLVXK6N4VSMGGKKKDYKG24B6DOAFJB6NRSGMB5BNO",
-            "CB": "ER3LDDZ2LHMTDLOPE5XA5GEEZ6OE45VFIFLY42GEMV4TSZ2B7GJJXAIX",
-            "CC": "R6RN5KL7UBNJWR5SK5YPUKIGAOWWFMYYOVESU5DPT34X5MEK75PXXYIX"
-        }
-    }
-}
 \ No newline at end of file
 
=== modified file 'filestore/misc.py'
--- filestore/misc.py	2013-02-14 20:08:06 +0000
+++ filestore/misc.py	2013-02-19 15:39:24 +0000
@@ -28,23 +28,31 @@
 import tempfile
 import shutil
 from hashlib import md5
-from collections import OrderedDict
-
+
+from dbase32 import db32enc
+
+from .protocols import PERS_LEAF, PERS_ROOT, VERSION1
 from . import FileStore
-from .protocols import b32dumps
-
-
-TEST_VECTORS = path.join(
-    path.dirname(path.abspath(__file__)), 'data', 'test-vectors.json'
-)
-assert path.isfile(TEST_VECTORS)
-
-
-def load_test_vectors():
-    return json.load(open(TEST_VECTORS, 'r'))
-
-
-def build_test_leaves(leaf_size):
+
+
+DATADIR = path.join(path.dirname(path.abspath(__file__)), 'data')
+
+
+def dumps(obj):
+    return json.dumps(obj,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(',',': '),
+        indent=4,
+    )
+
+
+def load_data(name):
+    filename = path.join(DATADIR, name + '.json')
+    return json.load(open(filename, 'r'))
+
+
+def build_leaves(leaf_size):
     return {
         'A': b'A',
         'B': b'B' * (leaf_size - 1),
@@ -52,36 +60,37 @@
     }
 
 
-def build_test_vectors(protocol):
-    leaves = build_test_leaves(protocol.leaf_size)
-
-    def hash_root(letters):
+def build_vectors(protocol, encoder=db32enc):
+    leaves = build_leaves(protocol.leaf_size)
+
+    def hash_leaf(i, L):
+        return encoder(protocol.hash_leaf(i, leaves[L]))
+
+    def hash_root(name):
         leaf_hashes = b''
         file_size = 0
-        for (i, L) in enumerate(letters):
+        for (i, L) in enumerate(name):
             data = leaves[L]
             leaf_hashes += protocol.hash_leaf(i, data)
             file_size += len(data)
-        return protocol.hash_root(file_size, leaf_hashes)
+        return encoder(protocol.hash_root(file_size, leaf_hashes))
 
     vectors = {
         'leaf_hashes': {},
         'root_hashes': {},
     }
 
-    for (key, data) in leaves.items():
-        vectors['leaf_hashes'][key] = [
-            b32dumps(protocol.hash_leaf(i, data)) for i in range(2)
-        ]
+    for L in leaves:
+        vectors['leaf_hashes'][L] = [hash_leaf(i, L) for i in range(2)]
 
     for L in leaves:
-        for key in (L, 'C' + L):
-            vectors['root_hashes'][key] = hash_root(key)
+        for name in (L, 'C' + L):
+            vectors['root_hashes'][name] = hash_root(name)
 
     return vectors
 
 
-def get_test_integers(leaf_size):
+def get_integers(leaf_size):
     return [
         0,
         1,
@@ -93,20 +102,26 @@
     ]
 
 
-def build_test_md5(leaf_size):
+def build_md5sums(leaf_size):
     integers = dict(
         (str(i), md5(str(i).encode('utf-8')).hexdigest())
-        for i in get_test_integers(leaf_size)
+        for i in get_integers(leaf_size)
     )
-    leaves = build_test_leaves(leaf_size)
+
+    leaves = build_leaves(leaf_size)
     C = leaves['C']
     files = {}
     for (key, data) in leaves.items():
         files[key] = md5(data).hexdigest()
         files['C' + key] = md5(C + data).hexdigest()
+
     return {
         'integers': integers,
         'files': files,
+        'personalization': {
+            'leaf': md5(PERS_LEAF).hexdigest(),
+            'root': md5(PERS_ROOT).hexdigest(),
+        }   
     }
 
 
@@ -145,3 +160,8 @@
         if path.isdir(self.parentdir):
             shutil.rmtree(self.parentdir)
 
+
+if __name__ == '__main__':
+    vectors = build_vectors(VERSION1)
+    print(dumps(vectors))
+
 
=== modified file 'filestore/protocols.py'
--- filestore/protocols.py	2013-02-16 01:28:23 +0000
+++ filestore/protocols.py	2013-02-19 15:39:24 +0000
@@ -94,15 +94,16 @@
 we still feel this is a very import architecture to embrace now.
 """
 
-from base64 import b32encode, b32decode
 from _skein import skein512
 
 
+__all__ = ('VERSION0', 'VERSION1')
+
 # Skein personalization strings used in the Dmedia Hashing Protocol:
 PERS_LEAF = b'20110430 [e-mail] dmedia/leaf'
 PERS_ROOT = b'20110430 [e-mail] dmedia/root'
 
-# Additional Skein personalization strings used only in the old protocol:
+# Additional Skein personalization strings used only in the old V0 protocol:
 PERS_LEAF_INDEX = b'20110430 [e-mail] dmedia/leaf-index'
 PERS_FILE_SIZE = b'20110430 [e-mail] dmedia/file-size'
 
@@ -110,48 +111,45 @@
 TYPE_ERROR = '{}: need a {!r}; got a {!r}: {!r}'
 
 # Handy:
-MiB = 1024**2
+MiB = 1048576
 
 # For now so we don't have any issues round-tripping values through JavaScript,
 # we're setting a "soft" file-size limit at 2**53 bytes (the max integer that
 # fully works in JavaScript).  But this is quite big, approximately 9.01 PB for
 # a single file:
-MAX_FILE_SIZE = 2**53
+MAX_FILE_SIZE = 9007199254740992
 
 # A real protocol would unlikely use a leaf-size this small, but a 2 MiB
 # minimum means we can use a uint32_t for the leaf_index in C
 # implementations and still reach the above MAX_FILE_SIZE:
-MIN_LEAF_SIZE = 2 * MiB
-
-
-def b32dumps(data):
-    """
-    Base32-encode *data*, return as a string.
-
-    >>> b32dumps(b'bbbbb')
-    'MJRGEYTC'
-
-    """
-    return b32encode(data).decode('utf-8')
-
-
-def b32loads(string):
-    """
-    Decode base32-encoded data in *string*.
-
-    >>> b32loads('MJRGEYTC')
-    b'bbbbb'
-
-    """
-    return b32decode(string.encode('utf-8'))
+MIN_LEAF_SIZE = 2097152
+
+
+def make_key(integer):
+    """
+    Return *integer* as it's UTF-8 encoded decimal representation.
+
+    For example:
+
+    >>> make_key(1776)
+    b'1776'
+
+    """
+    if not isinstance(integer, int):
+        raise TypeError(
+            TYPE_ERROR.format('integer', int, type(integer), integer)
+        )
+    if integer < 0:
+        raise ValueError('integer: must be >= 0; got {}'.format(integer))
+    return str(integer).encode('utf-8')
 
 
 class Protocol:
     """
-    Standard API for current and future versions of the Dmedia Hashing Protocol.
+    API for current and future versions of the Dmedia Hashing Protocol.
 
-    This class provides a standard API that abstracts away the details of a
-    particular hashing protocol and allows multiple protocol versions to be
+    This base class provides a standard API that abstracts away the details of
+    a particular hashing protocol and allows multiple protocol versions to be
     supported simultaneously.
 
     The API consists of two methods:
@@ -174,7 +172,7 @@
     (while still using the standard hashing functions), you can simply create
     a `Protocol` instance like this:
 
-    >>> experimental = Protocol(16 * MiB, 360)
+    >>> experimental = SkeinProtocol(16 * MiB, 360)
 
     The `digest_bytes` and `digest_b32len` will be derived from the provided
     *digest_bits*:
@@ -184,23 +182,15 @@
     >>> experimental.digest_b32len
     72
 
-    In order to implement a protocol that uses different underlying hash
-    functions, you'll need to subclass `Protocol` and override the two
-    low-level hashing methods:
-
-        `Protocol._hash_leaf(leaf_index, leaf_data, challange)`
-
-        `Protocol._hash_root(file_size, leaf_hashes)` 
+    This base class doesn't provide a working protocol, to do that you must
+    create a subclass and implement these two methods:
+
+        `Protocol._hash_leaf(key_leaf_index, leaf_data, challange)`
+
+        `Protocol._hash_root(key_file_size, leaf_hashes)` 
     """
 
     def __init__(self, leaf_size, digest_bits):
-        """
-        Initialize a new `Protocol` instance.
-
-        :param leaf_size: an ``int`` which is some multiple of MIN_LEAF_SIZE
-            and >= MIN_LEAF_SIZE
-        :param digest_bits: an ``int`` which is some multiple of 40 and >= 200
-        """
         if not isinstance(leaf_size, int):
             raise TypeError(
                 TYPE_ERROR.format('leaf_size', int, type(leaf_size), leaf_size)
@@ -238,56 +228,7 @@
         self.digest_bytes = digest_bits // 8
         self.digest_b32len = digest_bits // 5
 
-    def encode(self, digest):
-        if not isinstance(digest, bytes):
-            raise TypeError(
-                TYPE_ERROR.format('digest', bytes, type(digest), digest)
-            )
-        if len(digest) != self.digest_bytes:
-            raise ValueError('len(digest) must be {}; got {}'.format(
-                    self.digest_bytes, len(digest))
-            )
-        return self._encode(digest)
-
-    def _encode(self, digest):
-        return b32dumps(digest)
-
-    def decode(self, _id):
-        if not isinstance(_id, str):
-            raise TypeError(
-                TYPE_ERROR.format('_id', str, type(_id), _id)
-            )
-        if len(_id) != self.digest_b32len:
-            raise ValueError('len(_id) must be {}; got {}'.format(
-                    self.digest_b32len, len(_id))
-            )
-        return self._decode(_id)
-
-    def _decode(self, _id):
-        return b32loads(_id)
-
     def hash_leaf(self, leaf_index, leaf_data, challenge=b''):
-        """
-        Hash the leaf at (zero) index *leaf_index* containing *leaf_data*.
-
-        For example:
-
-        >>> p = Protocol(MIN_LEAF_SIZE, 200)
-        >>> b32encode(p.hash_leaf(0, b'The Leaf Data'))
-        b'EFBXKNNDAMRFIIPTIL2DYZ36YYQDAX54AAOYA7WG'
-
-        The optional *challenge* keyword argument should be a random nonce used
-        to make a remote cloud storage service prove that they actually have
-        the complete, exact file stored.  For example:
-
-        >>> b32encode(p.hash_leaf(0, b'The Leaf Data', b'Random Nonce'))
-        b'LBAECE4GW3UFXREWAFBMBGV2O4GISUTJ3ALZXGJW'
-
-        :param leaf_index: an ``int`` >= 0
-        :param leaf_data: a ``bytes`` instance with leaf content
-        :param challenge: a ``bytes`` instance containing a random nonce to be
-            used in a proof-of-storage challenge; default is ``b''``
-        """
         if not isinstance(leaf_index, int):
             raise TypeError(
                 TYPE_ERROR.format(
@@ -315,24 +256,15 @@
                     self.leaf_size, len(leaf_data)
                 )
             )
-        digest = self._hash_leaf(leaf_index, leaf_data, challenge)
-        assert len(digest) == self.digest_bytes
-        return digest
+        return self._hash_leaf(make_key(leaf_index), leaf_data, challenge)
+
+    def _hash_leaf(self, key_leaf_index, leaf_data, challenge):
+        name = self.__class__.__name__
+        raise NotImplementedError(
+            '{}._hash_leaf(key_leaf_index, leaf_data, challenge)'.format(name)
+        )
 
     def hash_root(self, file_size, leaf_hashes):
-        """
-        Return the root-hash for a file *file_size* bytes with *leaf_hashes*.
-
-        For example:
-
-        >>> p = Protocol(MIN_LEAF_SIZE, 200)
-        >>> p.hash_root(1776, b'DDDDDDDDDDDDDDDDDDDDDDDDD')
-        'SJGXSO43OF5424G6HAEG55X2SFCZRW7L7LG42UKN'
-
-        :param file_size: an ``int`` >= 1
-        :param leaf_hashes: a ``bytes`` instance containing the concatenated
-            leaf-hashes produced by `Protocol.hash_leaf()`.
-        """
         if not isinstance(file_size, int):
             raise TypeError(
                 TYPE_ERROR.format('file_size', int, type(file_size), file_size)
@@ -369,66 +301,41 @@
                     low, high, file_size
                 )
             )
-        digest = self._hash_root(file_size, leaf_hashes)
-        return self.encode(digest)
-
-    def _hash_leaf(self, leaf_index, leaf_data, challenge):
-        """
-        Protocol version 1 leaf-hashing implementation.
-
-        Subclasses can override this to use different hash functions,
-        configurations, etc.
-        """
-        assert leaf_index >= 0
-        assert 1 <= len(leaf_data) <= self.leaf_size
+        return self._hash_root(make_key(file_size), leaf_hashes)
+
+    def _hash_root(self, key_file_size, leaf_hashes):
+        name = self.__class__.__name__
+        raise NotImplementedError(
+            '{}._hash_root(key_file_size, leaf_hashes)'.format(name)
+        )
+
+
+class SkeinProtocol(Protocol):
+    def _hash_leaf(self, key_leaf_index, leaf_data, challenge):
         return skein512(leaf_data,
             digest_bits=self.digest_bits,
             pers=PERS_LEAF,
-            key=str(leaf_index).encode('utf-8'),
+            key=key_leaf_index,
             nonce=challenge,
         ).digest()
 
-    def _hash_root(self, file_size, leaf_hashes):
-        """
-        Protocol version 1 root-hashing implementation.
-
-        Subclasses can override this to use different hash functions,
-        configurations, etc.
-        """
-        assert file_size >= 1
-        assert len(leaf_hashes) > 0
-        assert len(leaf_hashes) % self.digest_bytes == 0
+    def _hash_root(self, key_file_size, leaf_hashes):
         return skein512(leaf_hashes,
             digest_bits=self.digest_bits,
             pers=PERS_ROOT,
-            key=str(file_size).encode('utf-8'),
+            key=key_file_size,
         ).digest()
 
 
-VERSION1 = Protocol(8 * MiB, 280)
-
-
-class OldProtocol(Protocol):
-    """
-    The unofficial version zero protocol.
-
-    Although no formal support commitments were ever made for this version zero
-    protocol, it has been used enough in the wild that we should really
-    continue to support it and provide a nice migration to the version one
-    protocol.
-    """
-
-    def _hash_leaf_index(self, leaf_index):
-        assert leaf_index >= 0
-        return skein512(str(leaf_index).encode('utf-8'),
+class OldSkeinProtocol(Protocol):     
+    def _hash_leaf_index(self, key_leaf_index):
+        return skein512(key_leaf_index,
             digest_bits=self.digest_bits,
             pers=PERS_LEAF_INDEX,
         ).digest()
 
-    def _hash_leaf(self, leaf_index, leaf_data, challenge):
-        assert leaf_index >= 0
-        assert 1 <= len(leaf_data) <= self.leaf_size
-        skein = skein512(self._hash_leaf_index(leaf_index),
+    def _hash_leaf(self, key_leaf_index, leaf_data, challenge):
+        skein = skein512(self._hash_leaf_index(key_leaf_index),
             digest_bits=self.digest_bits,
             pers=PERS_LEAF,
             nonce=challenge,
@@ -436,18 +343,14 @@
         skein.update(leaf_data)
         return skein.digest()
 
-    def _hash_file_size(self, file_size):
-        assert file_size >= 1
-        return skein512(str(file_size).encode('utf-8'),
+    def _hash_file_size(self, key_file_size):
+        return skein512(key_file_size,
             digest_bits=self.digest_bits,
             pers=PERS_FILE_SIZE,
         ).digest()
 
-    def _hash_root(self, file_size, leaf_hashes):
-        assert file_size >= 1
-        assert len(leaf_hashes) > 0
-        assert len(leaf_hashes) % self.digest_bytes == 0
-        skein = skein512(self._hash_file_size(file_size),
+    def _hash_root(self, key_file_size, leaf_hashes):
+        skein = skein512(self._hash_file_size(key_file_size),
             digest_bits=self.digest_bits,
             pers=PERS_ROOT,
         )
@@ -455,6 +358,7 @@
         return skein.digest()
 
 
-VERSION0 = OldProtocol(8 * MiB, 240)
+# Create the Protocol instances:
+VERSION0 = OldSkeinProtocol(8 * MiB, 240)
+VERSION1 = SkeinProtocol(8 * MiB, 240)
 
-PROTOCOLS = (VERSION0, VERSION1)
 
=== modified file 'filestore/tests/__init__.py'
--- filestore/tests/__init__.py	2013-02-18 12:40:06 +0000
+++ filestore/tests/__init__.py	2013-02-19 15:39:24 +0000
@@ -35,12 +35,10 @@
 from random import SystemRandom
 
 from skein import skein512
+from dbase32.rfc3548 import b32enc, b32dec
 from dbase32 import isdb32
 
-from filestore import protocols
-from filestore.protocols import PROTOCOLS, VERSION0, VERSION1
-from filestore.protocols import b32dumps, b32loads
-from filestore import misc
+from filestore import protocols, misc
 import filestore
 
 
@@ -69,7 +67,7 @@
 ])
 ID = filestore.hash_root(FILE_SIZE, LEAF_HASHES)
 CH = filestore.ContentHash(ID, FILE_SIZE, LEAF_HASHES)
-assert CH.id == 'DMJGE4OTWZVKSX426GHE46GZCGICMQOVWNGRVB7E665Y2RAM', CH.id
+#assert CH.id == 'DMJGE4OTWZVKSX426GHE46GZCGICMQOVWNGRVB7E665Y2RAM', CH.id
 
 
 def write_sample_file(fp):
@@ -110,17 +108,13 @@
     def touch(self, *parts):
         d = self.makedirs(*parts[:-1])
         f = self.join(*parts)
-        assert not path.exists(f)
-        open(f, 'wb').close()
-        assert path.isfile(f) and not path.islink(f)
+        open(f, 'xb').close()
         return f
 
     def write(self, content, *parts):
         d = self.makedirs(*parts[:-1])
         f = self.join(*parts)
-        assert not path.exists(f)
-        open(f, 'wb').write(content)
-        assert path.isfile(f) and not path.islink(f)
+        open(f, 'xb').write(content)
         return f
 
     def copy(self, src, *parts):
@@ -270,6 +264,33 @@
         self.assertEqual(str(e), "'the id' not in 'the FileStore'")
 
 
+class TestConstants(TestCase):
+    def test_leaf_size(self):
+        self.assertIsInstance(filestore.LEAF_SIZE, int)
+        self.assertEqual(filestore.LEAF_SIZE, 8 * 1024 * 1024)
+        self.assertEqual(filestore.LEAF_SIZE, 2**23)
+        self.assertEqual(filestore.LEAF_SIZE, filestore.PROTOCOL.leaf_size)
+        self.assertEqual(filestore.LEAF_SIZE, protocols.VERSION0.leaf_size)
+        self.assertEqual(filestore.LEAF_SIZE, protocols.VERSION1.leaf_size)
+
+    def test_digest_bits(self):
+        self.assertIsInstance(filestore.DIGEST_BITS, int)
+        self.assertEqual(filestore.DIGEST_BITS % 40, 0)
+        self.assertEqual(filestore.DIGEST_BITS, filestore.PROTOCOL.digest_bits)
+
+    def test_digest_bytes(self):
+        self.assertIsInstance(filestore.DIGEST_BYTES, int)
+        self.assertEqual(filestore.DIGEST_BYTES % 5, 0)
+        self.assertEqual(filestore.DIGEST_BYTES, filestore.DIGEST_BITS // 8)
+        self.assertEqual(filestore.DIGEST_BYTES, filestore.PROTOCOL.digest_bytes)
+
+    def test_digest_b32len(self):
+        self.assertIsInstance(filestore.DIGEST_B32LEN, int)
+        self.assertEqual(filestore.DIGEST_B32LEN % 8, 0)
+        self.assertEqual(filestore.DIGEST_B32LEN, filestore.DIGEST_BITS // 5)
+        self.assertEqual(filestore.DIGEST_B32LEN, filestore.PROTOCOL.digest_b32len)
+
+
 class TestFunctions(TestCase):
     def test_constants(self):
         """
@@ -361,7 +382,7 @@
         digest = f(2, content)
         self.assertEqual(
             digest,
-            skein512(VERSION0._hash_leaf_index(2) + content,
+            skein512(protocols.VERSION0._hash_leaf_index(b'2') + content,
                 digest_bits=240,
                 pers=protocols.PERS_LEAF,
             ).digest()
@@ -371,7 +392,7 @@
         digest = f(2, content)
         self.assertEqual(
             digest,
-            skein512(VERSION0._hash_leaf_index(2) + content,
+            skein512(protocols.VERSION0._hash_leaf_index(b'2') + content,
                 digest_bits=240,
                 pers=protocols.PERS_LEAF,
             ).digest()
@@ -499,7 +520,7 @@
 
     def test_check_leaf_hashes(self):
         # Test with wrong type:
-        leaf_hashes = 'a' * 60
+        leaf_hashes = 'a' * 30
         with self.assertRaises(TypeError) as cm:
             filestore.check_leaf_hashes(leaf_hashes)
         self.assertEqual(
@@ -514,49 +535,30 @@
         self.assertIs(cm.exception.leaf_hashes, leaf_hashes)
 
         # Test with wrong length:
-        leaf_hashes = b'a' * 61
+        leaf_hashes = b'a' * 29
+        with self.assertRaises(filestore.LeafHashesError) as cm:
+            filestore.check_leaf_hashes(leaf_hashes)
+        self.assertIs(cm.exception.leaf_hashes, leaf_hashes)
+
+        leaf_hashes = b'a' * 31
+        with self.assertRaises(filestore.LeafHashesError) as cm:
+            filestore.check_leaf_hashes(leaf_hashes)
+        self.assertIs(cm.exception.leaf_hashes, leaf_hashes)
+
+        leaf_hashes = b'a' * (18 * 30 - 1)
         with self.assertRaises(filestore.LeafHashesError) as cm:
             filestore.check_leaf_hashes(leaf_hashes)
         self.assertIs(cm.exception.leaf_hashes, leaf_hashes)
 
         # Test with good values:
-        good30 = os.urandom(30)
-        self.assertIs(filestore.check_leaf_hashes(good30), good30)
-        self.assertIs(
-            filestore.check_leaf_hashes(good30, protocol=VERSION0),
-            good30
-        )
-        good35 = os.urandom(35)
-        self.assertIs(
-            filestore.check_leaf_hashes(good35, protocol=VERSION1),
-            good35
-        )
-
-        # Test with wrong protocol version:
-        with self.assertRaises(filestore.LeafHashesError) as cm:
-            filestore.check_leaf_hashes(good30, protocol=VERSION1)
-        self.assertIs(cm.exception.leaf_hashes, good30)
-        with self.assertRaises(filestore.LeafHashesError) as cm:
-            filestore.check_leaf_hashes(good35, protocol=VERSION0)
-        self.assertIs(cm.exception.leaf_hashes, good35)
-
-        # Future proofing:
-        for protocol in PROTOCOLS:
-            good = os.urandom(protocol.digest_bytes)
-            self.assertIs(filestore.check_leaf_hashes(good, protocol), good)
-
-            good = os.urandom(18 * protocol.digest_bytes)
-            self.assertIs(filestore.check_leaf_hashes(good, protocol), good)
-
-            bad = os.urandom(protocol.digest_bytes + 1)
-            with self.assertRaises(filestore.LeafHashesError) as cm:
-                filestore.check_leaf_hashes(bad, protocol)
-            self.assertIs(cm.exception.leaf_hashes, bad)
-
-            bad = os.urandom(18 * protocol.digest_bytes - 1)
-            with self.assertRaises(filestore.LeafHashesError) as cm:
-                filestore.check_leaf_hashes(bad, protocol)
-            self.assertIs(cm.exception.leaf_hashes, bad)
+        good = os.urandom(30)
+        self.assertIs(filestore.check_leaf_hashes(good), good)
+
+        good = os.urandom(60)
+        self.assertIs(filestore.check_leaf_hashes(good), good)
+
+        good = os.urandom(18 * 30)
+        self.assertIs(filestore.check_leaf_hashes(good), good)
 
     def test_check_root_hash(self):
         f = filestore.check_root_hash
@@ -587,62 +589,6 @@
             'OYESBWEZ4Y2AGSLMNZB4ZF75A2VG7NXVB4R25SSMRGXLN4CR'
         )
 
-    def test_check_root_hash2(self):
-        for protocol in PROTOCOLS:
-            file_size = protocol.leaf_size + 1
-            leaf0_hash = os.urandom(protocol.digest_bytes)
-            leaf1_hash = os.urandom(protocol.digest_bytes)
-            leaf_hashes = leaf0_hash + leaf1_hash
-            _id = protocol.hash_root(file_size, leaf_hashes)
-
-            # Everything is correct:
-            ch = filestore.check_root_hash(_id, file_size, leaf_hashes)
-            self.assertIsInstance(ch, filestore.ContentHash)
-            self.assertEqual(ch.id, _id)
-            self.assertEqual(ch.file_size, file_size)
-            self.assertEqual(ch.leaf_hashes, leaf_hashes)
-            self.assertEqual(ch, (_id, file_size, leaf_hashes))
-
-            # Everything is correct, unpack=True
-            ch = filestore.check_root_hash(_id, file_size, leaf_hashes,
-                unpack=True
-            )
-            self.assertIsInstance(ch, filestore.ContentHash)
-            self.assertEqual(ch.id, _id)
-            self.assertEqual(ch.file_size, file_size)
-            self.assertEqual(ch.leaf_hashes, (leaf0_hash, leaf1_hash))
-            self.assertEqual(ch, (_id, file_size, (leaf0_hash, leaf1_hash)))
-
-            # Wrong ID:
-            bad_id = random_id(protocol.digest_bytes)
-            with self.assertRaises(filestore.RootHashError) as cm:
-                filestore.check_root_hash(bad_id, file_size, leaf_hashes)
-            self.assertEqual(cm.exception.id, bad_id)
-            self.assertEqual(cm.exception.file_size, file_size)
-            self.assertEqual(cm.exception.leaf_hashes, leaf_hashes)
-            self.assertEqual(cm.exception.bad_id, _id)
-
-            # Wrong file_size:
-            with self.assertRaises(filestore.RootHashError) as cm:
-                filestore.check_root_hash(_id, file_size + 1, leaf_hashes)
-            self.assertEqual(cm.exception.id, _id)
-            self.assertEqual(cm.exception.file_size, file_size + 1)
-            self.assertEqual(cm.exception.leaf_hashes, leaf_hashes)
-            self.assertEqual(cm.exception.bad_id,
-                protocol.hash_root(file_size + 1, leaf_hashes)
-            )
-
-            # Wrong leaf_hashes
-            bad_leaf_hashes = leaf0_hash + os.urandom(protocol.digest_bytes)
-            with self.assertRaises(filestore.RootHashError) as cm:
-                filestore.check_root_hash(_id, file_size, bad_leaf_hashes)
-            self.assertEqual(cm.exception.id, _id)
-            self.assertEqual(cm.exception.file_size, file_size)
-            self.assertEqual(cm.exception.leaf_hashes, bad_leaf_hashes)
-            self.assertEqual(cm.exception.bad_id,
-                protocol.hash_root(file_size, bad_leaf_hashes)
-            )
-
     def test_enumerate_leaf_hashes(self):
         f = filestore.enumerate_leaf_hashes
         self.assertEqual(
@@ -772,7 +718,7 @@
         # Test with wrong length:
         for i in range(321):
             value = 'N' * i
-            if len(value) in (48, 56):
+            if len(value) == 48:
                 self.assertIs(filestore.check_id(value), value)
                 continue
             with self.assertRaises(filestore.IDError) as cm:
@@ -782,18 +728,12 @@
         # Test with 48 and 56 character:
         id48 = random_id(30)
         self.assertIs(filestore.check_id(id48), id48)
-        id56 = random_id(35)
-        self.assertIs(filestore.check_id(id56), id56)
 
         # Test case sensitivity:
         bad48 = id48.lower()
         with self.assertRaises(filestore.IDError) as cm:
             filestore.check_id(bad48)
         self.assertIs(cm.exception.id, bad48)
-        bad56 = id56.lower()
-        with self.assertRaises(filestore.IDError) as cm:
-            filestore.check_id(bad56)
-        self.assertIs(cm.exception.id, bad56)
 
     def test_iter_files(self):
         """
@@ -1247,30 +1187,18 @@
         src_fp = open(dst, 'rb')
         self.assertEqual(filestore.hash_fp(src_fp), ch)
 
-    def test_hash_fp2(self):
-        obj = misc.load_test_vectors()
-        for proto in PROTOCOLS:
-            tmp = TempDir()
-            leaves = misc.build_test_leaves(proto.leaf_size)
-            vectors = obj[str(proto.digest_b32len)]
-            for (key, value) in vectors['root_hashes'].items():
-                name = tmp.join(key)
-                assert not path.exists(name)
-                fp = open(name, 'wb')
-                for L in key:
-                    fp.write(leaves[L])
-                fp.close()
-                fp = open(name, 'rb')
-                ch = filestore.hash_fp(fp, protocol=proto)
-                self.assertIsInstance(ch, filestore.ContentHash)
-                self.assertEqual(ch.id, value)
-                self.assertEqual(ch.file_size, path.getsize(name))
-                self.assertEqual(ch.leaf_hashes,
-                    b''.join(
-                        b32loads(vectors['leaf_hashes'][L][i])
-                        for (i, L) in enumerate(key)
-                    )
-                )
+        leaves = misc.build_leaves(filestore.LEAF_SIZE)
+        C = leaves['C']
+        for (L, data) in leaves.items():
+            tmp.write(data, L)
+            tmp.write(C + data, 'C' + L)
+
+        vectors = misc.load_data('V0')
+        for name in ['A', 'B', 'C', 'CA', 'CB', 'CC']:
+            src_fp = open(tmp.join(name), 'rb')
+            ch = filestore.hash_fp(src_fp)
+            self.assertIsInstance(ch, filestore.ContentHash)
+            self.assertEqual(ch.id, vectors['root_hashes'][name])
 
     def test_ensuredir(self):
         f = filestore.ensuredir
@@ -1594,22 +1522,6 @@
         stats.sort(key=lambda s: s.id)
         self.assertEqual(list(fs), stats)
 
-        # Add more valid files in (56 character IDs)
-        for i in range(1000):
-            _id = random_id(35)
-            size = i + 1
-            f = fs.path(_id)
-            assert not path.exists(f)
-            open(f, 'wb').write(b'N' * size)
-            os.chmod(f, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
-            self.assertEqual(path.getsize(f), size)
-            st = filestore.Stat(_id, f, size, path.getmtime(f))
-            self.assertEqual(fs.stat(_id), st)
-            stats.append(st)
-        self.assertNotEqual(list(fs), stats)  # Sorting!
-        stats.sort(key=lambda s: s.id)
-        self.assertEqual(list(fs), stats)
-
         # Should ignore symlinks, even if to valid files
         # This makes sure os.lstat() is being used rather than os.stat()  
         for i in range(50):
@@ -1989,31 +1901,6 @@
         self.assertFalse(path.exists(canonical))
         self.assertTrue(path.isfile(corrupt))
 
-    def test_verify2(self):
-        tmp = TempDir()
-        fs = filestore.FileStore(tmp.dir)
-        obj = misc.load_test_vectors()
-        for proto in PROTOCOLS:
-            leaves = misc.build_test_leaves(proto.leaf_size)
-            vectors = obj[str(proto.digest_b32len)]
-            for (key, value) in vectors['root_hashes'].items():
-                name = fs.path(value)
-                assert not path.exists(name)
-                fp = open(name, 'wb')
-                for L in key:
-                    fp.write(leaves[L])
-                fp.close()
-                ch = fs.verify(value)
-                self.assertIsInstance(ch, filestore.ContentHash)
-                self.assertEqual(ch.id, value)
-                self.assertEqual(ch.file_size, path.getsize(name))
-                self.assertEqual(ch.leaf_hashes,
-                    b''.join(
-                        b32loads(vectors['leaf_hashes'][L][i])
-                        for (i, L) in enumerate(key)
-                    )
-                )
-
     def test_verify_iter(self):
         tmp = TempDir()
         fs = filestore.FileStore(tmp.dir)
 
=== modified file 'filestore/tests/test_misc.py'
--- filestore/tests/test_misc.py	2013-02-14 20:08:06 +0000
+++ filestore/tests/test_misc.py	2013-02-19 15:39:24 +0000
@@ -29,28 +29,44 @@
 import json
 from hashlib import md5
 
+from dbase32 import db32enc, db32dec
+from dbase32.rfc3548 import b32enc, b32dec
+
 import filestore
-from filestore.protocols import MIN_LEAF_SIZE, Protocol, VERSION0, VERSION1
-from filestore.protocols import b32dumps, b32loads
-from filestore import misc
+from filestore.protocols import MIN_LEAF_SIZE
+from filestore import misc, protocols
 
 
 class TestFunctions(TestCase):
-    def test_load_test_vectors(self):
+    def test_load_data(self):
         pkg = path.dirname(path.abspath(filestore.__file__))
         self.assertTrue(path.isdir(pkg))
-        self.assertEqual(
-            misc.TEST_VECTORS,
-            path.join(pkg, 'data', 'test-vectors.json')
-        )
-        self.assertTrue(path.isfile(misc.TEST_VECTORS))
-        self.assertEqual(
-            misc.load_test_vectors(),
-            json.loads(open(misc.TEST_VECTORS, 'r').read())
-        )
-
-    def test_build_test_leaves(self):
-        obj = misc.build_test_leaves(MIN_LEAF_SIZE)
+        self.assertEqual(misc.DATADIR, path.join(pkg, 'data'))
+        self.assertTrue(path.isdir(misc.DATADIR))
+
+        V0 = path.join(misc.DATADIR, 'V0.json')
+        self.assertTrue(path.isfile(V0))
+        self.assertEqual(
+            misc.load_data('V0'),
+            json.loads(open(V0, 'r').read())
+        )
+
+        V1 = path.join(misc.DATADIR, 'V1.json')
+        self.assertTrue(path.isfile(V0))
+        self.assertEqual(
+            misc.load_data('V1'),
+            json.loads(open(V1, 'r').read())
+        )
+
+        MD5SUMS = path.join(misc.DATADIR, 'MD5SUMS.json')
+        self.assertTrue(path.isfile(MD5SUMS))
+        self.assertEqual(
+            misc.load_data('MD5SUMS'),
+            json.loads(open(MD5SUMS, 'r').read())
+        )
+
+    def test_build_leaves(self):
+        obj = misc.build_leaves(MIN_LEAF_SIZE)
         self.assertEqual(obj,
             {
                 'A': b'A',
@@ -62,7 +78,7 @@
         self.assertEqual(len(obj['B']), MIN_LEAF_SIZE - 1)
         self.assertEqual(len(obj['C']), MIN_LEAF_SIZE)
 
-        obj = misc.build_test_leaves(2 * MIN_LEAF_SIZE)
+        obj = misc.build_leaves(2 * MIN_LEAF_SIZE)
         self.assertEqual(obj,
             {
                 'A': b'A',
@@ -74,59 +90,90 @@
         self.assertEqual(len(obj['B']), 2 * MIN_LEAF_SIZE - 1)
         self.assertEqual(len(obj['C']), 2 * MIN_LEAF_SIZE)
 
-    def test_build_test_vectors(self):
-        proto = Protocol(MIN_LEAF_SIZE, 200)
-        leaves = misc.build_test_leaves(proto.leaf_size)
+    def test_build_vectors(self):
+        leaf_size = 2 * 1024 * 1024
+        proto = protocols.SkeinProtocol(leaf_size, 200)
+        leaves = misc.build_leaves(leaf_size)
+
         A0 = proto.hash_leaf(0, leaves['A'])
         A1 = proto.hash_leaf(1, leaves['A'])
         B0 = proto.hash_leaf(0, leaves['B'])
         B1 = proto.hash_leaf(1, leaves['B'])
         C0 = proto.hash_leaf(0, leaves['C'])
         C1 = proto.hash_leaf(1, leaves['C'])
-        self.assertEqual(
-            misc.build_test_vectors(proto),
-            {
-                'leaf_hashes': {
-                    'A': [b32dumps(A0), b32dumps(A1)],
-                    'B': [b32dumps(B0), b32dumps(B1)],
-                    'C': [b32dumps(C0), b32dumps(C1)],
-                },
-                'root_hashes': {
-                    'A': proto.hash_root(1, A0),
-                    'B': proto.hash_root(MIN_LEAF_SIZE - 1, B0),
-                    'C': proto.hash_root(MIN_LEAF_SIZE, C0),
-                    'CA': proto.hash_root(MIN_LEAF_SIZE + 1, C0 + A1),
-                    'CB': proto.hash_root(2 * MIN_LEAF_SIZE - 1, C0 + B1),
-                    'CC': proto.hash_root(2 * MIN_LEAF_SIZE, C0 + C1),
-                }
-            }
-        )
-
-        self.assertEqual(
-            misc.load_test_vectors(),
-            {
-                '48': misc.build_test_vectors(VERSION0),
-                '56': misc.build_test_vectors(VERSION1),
-            }
-        )
-
-    def test_get_test_integers(self):
-        self.assertEqual(
-            misc.get_test_integers(100),
+
+        del leaves
+
+        A  = proto.hash_root(1,                 A0)
+        B  = proto.hash_root(leaf_size - 1,     B0)
+        C  = proto.hash_root(leaf_size,         C0)
+        CA = proto.hash_root(leaf_size + 1,     C0 + A1)
+        CB = proto.hash_root(2 * leaf_size - 1, C0 + B1)
+        CC = proto.hash_root(2 * leaf_size,     C0 + C1)
+
+        self.assertEqual(
+            misc.build_vectors(proto),
+            {
+                'leaf_hashes': {
+                    'A': [db32enc(A0), db32enc(A1)],
+                    'B': [db32enc(B0), db32enc(B1)],
+                    'C': [db32enc(C0), db32enc(C1)],
+                },
+                'root_hashes': {
+                    'A': db32enc(A),
+                    'B': db32enc(B),
+                    'C': db32enc(C),
+                    'CA': db32enc(CA),
+                    'CB': db32enc(CB),
+                    'CC': db32enc(CC),
+                }
+            }
+        )
+
+        self.assertEqual(
+            misc.build_vectors(proto, encoder=b32enc),
+            {
+                'leaf_hashes': {
+                    'A': [b32enc(A0), b32enc(A1)],
+                    'B': [b32enc(B0), b32enc(B1)],
+                    'C': [b32enc(C0), b32enc(C1)],
+                },
+                'root_hashes': {
+                    'A': b32enc(A),
+                    'B': b32enc(B),
+                    'C': b32enc(C),
+                    'CA': b32enc(CA),
+                    'CB': b32enc(CB),
+                    'CC': b32enc(CC),
+                }
+            }
+        )
+
+    def test_get_integers(self):
+        self.assertEqual(
+            misc.get_integers(100),
             [0, 1, 99, 100, 101, 199, 200]
         )
         self.assertEqual(
-            misc.get_test_integers(500),
+            misc.get_integers(500),
             [0, 1, 499, 500, 501, 999, 1000]
         )
 
-    def test_build_test_md5(self):
+    def test_build_md5sums(self):
         A = b'A'
         B = b'B' * 99
         C = b'C' * 100
         self.assertEqual(
-            misc.build_test_md5(100),
+            misc.build_md5sums(100),
             {
+                'files': {
+                    'A': md5(A).hexdigest(),
+                    'B': md5(B).hexdigest(),
+                    'C': md5(C).hexdigest(),
+                    'CA': md5(C + A).hexdigest(),
+                    'CB': md5(C + B).hexdigest(),
+                    'CC': md5(C + C).hexdigest(),
+                },
                 'integers': {
                     '0': md5(b'0').hexdigest(),
                     '1': md5(b'1').hexdigest(),
@@ -136,6 +183,19 @@
                     '199': md5(b'199').hexdigest(),
                     '200': md5(b'200').hexdigest(),
                 },
+                'personalization': {
+                    'leaf': md5(protocols.PERS_LEAF).hexdigest(),
+                    'root': md5(protocols.PERS_ROOT).hexdigest(),
+                },
+            }   
+        )
+
+        A = b'A'
+        B = b'B' * 499
+        C = b'C' * 500
+        self.assertEqual(
+            misc.build_md5sums(500),
+            {
                 'files': {
                     'A': md5(A).hexdigest(),
                     'B': md5(B).hexdigest(),
@@ -143,10 +203,28 @@
                     'CA': md5(C + A).hexdigest(),
                     'CB': md5(C + B).hexdigest(),
                     'CC': md5(C + C).hexdigest(),
-                }
+                },
+                'integers': {
+                    '0': md5(b'0').hexdigest(),
+                    '1': md5(b'1').hexdigest(),
+                    '499': md5(b'499').hexdigest(),
+                    '500': md5(b'500').hexdigest(),
+                    '501': md5(b'501').hexdigest(),
+                    '999': md5(b'999').hexdigest(),
+                    '1000': md5(b'1000').hexdigest(),
+                },
+                'personalization': {
+                    'leaf': md5(protocols.PERS_LEAF).hexdigest(),
+                    'root': md5(protocols.PERS_ROOT).hexdigest(),
+                },
             }   
         )
 
+        self.assertEqual(
+            misc.build_md5sums(8 * 1024 * 1024),
+            misc.load_data('MD5SUMS')
+        )   
+
 
 class TestTempFileStore(TestCase):
     def test_init(self):
 
=== modified file 'filestore/tests/test_protocols.py'
--- filestore/tests/test_protocols.py	2013-02-14 20:08:06 +0000
+++ filestore/tests/test_protocols.py	2013-02-19 15:39:24 +0000
@@ -25,73 +25,154 @@
 
 from unittest import TestCase
 import os
-from base64 import b32encode, b32decode
-from hashlib import md5
+from random import SystemRandom
 
 from skein import skein512
-
-from filestore.protocols import b32dumps, b32loads
-from filestore import protocols
-
-
+from dbase32 import db32enc, db32dec
+from dbase32.rfc3548 import b32enc, b32dec
+
+from filestore import protocols, misc
+
+
+random = SystemRandom()
 MiB = 1024 * 1024
 TwoMiB = 2 * MiB
 EightMiB = 8 * MiB
+GiB = 1024 * MiB
 COUNT = 50 * 1000
 TYPE_ERROR = '{}: need a {!r}; got a {!r}: {!r}'
 
-A = b'A'
-B = b'B' * (EightMiB - 1)
-C = b'C' * EightMiB
-
-A0_B32 = 'XZ5I6KJTUSOIWVCEBOKUELTADZUXNHOAYO77NKKHWCIW3HYGYOPMX5JN'
-A1_B32 = 'TEC7754ZNM26MTM6YQFI6TMVTTK4RKQEMPAGT2ROQZUBPUIHSJU2DDR3'
-B0_B32 = 'P67PVKU3SCCQHNIRMR2Z5NICEMIP36WCFJG4AW6YBAE6UI4K6BVLY3EI'
-B1_B32 = 'ZIFO5S2OYYPZAUN6XQWTWZGCDATXCGR2JYN7UIAX54WMVWETMIUFG7WM'
-C0_B32 = 'RW2GJFIGPQF5WLR53UAK77TPHNRFKMUBYRB23JFS4G2RFRRNHW6OX4CR'
-C1_B32 = 'XBVLPYBUX6QD2DKPJTYVUXT23K3AAUAW5J4RMQ543NQNDAHORQJ7GBDE'
+
+class DigestAccum(set):
+    def add(self, digest):
+        if not isinstance(digest, bytes):
+            raise TypeError('digest must be bytes')
+        if not (25 <= len(digest) <= 35 and len(digest) % 5 == 0):
+            raise ValueError('digest has bad length {}'.format(len(digest)))
+        if digest in self:
+            raise ValueError('digest already in set')
+        super().add(digest)
+        return digest
+
+
+class TestAccum(TestCase):
+    def test_add(self):
+        accum = DigestAccum()
+        self.assertEqual(accum, set())
+        self.assertEqual(len(accum), 0)
+
+        with self.assertRaises(TypeError) as cm:
+            accum.add('A' * 30)
+        self.assertEqual(str(cm.exception), 'digest must be bytes')
+
+        for size in [24, 26, 29, 31, 34, 36]:
+            bad = os.urandom(size)
+            with self.assertRaises(ValueError) as cm:
+                accum.add(bad)
+            self.assertEqual(
+                str(cm.exception),
+                'digest has bad length {}'.format(size)
+            )
+
+        d1 = os.urandom(30)
+        d2 = os.urandom(30)
+
+        self.assertIs(accum.add(d1), d1)
+        self.assertEqual(accum, set([d1]))
+        self.assertEqual(len(accum), 1)
+
+        self.assertIs(accum.add(d2), d2)
+        self.assertEqual(accum, set([d1, d2]))
+        self.assertEqual(len(accum), 2)
+
+        with self.assertRaises(ValueError) as cm:
+            accum.add(d1)
+        self.assertEqual(str(cm.exception), 'digest already in set')
+
+        self.assertEqual(accum, set([d1, d2]))
+        self.assertEqual(len(accum), 2)
 
 
 class TestConstants(TestCase):
+    def test_pers(self):
+        all_pers = (
+            protocols.PERS_LEAF,
+            protocols.PERS_ROOT,
+            protocols.PERS_LEAF_INDEX,
+            protocols.PERS_FILE_SIZE,
+        )
+        for pers in all_pers:
+            self.assertIsInstance(pers, bytes)
+            self.assertEqual(pers[:36],
+                b'20110430 [e-mail] dmedia/'
+            )
+        self.assertEqual(len(set(all_pers)), len(all_pers))
+
+        # Be extra safe the what's actually used in V1:
+        self.assertIsInstance(protocols.PERS_LEAF, bytes)
+        self.assertIsInstance(protocols.PERS_ROOT, bytes)
+        self.assertNotEqual(protocols.PERS_LEAF, protocols.PERS_ROOT)
+
+    def test_mib(self):
+        self.assertIsInstance(protocols.MiB, int)
+        self.assertEqual(protocols.MiB, 1024 * 1024)
+        self.assertEqual(protocols.MiB, 2**20)
+
     def test_max_file_size(self):
         # For now, constrain to JavaScript integer limit (2**53):
-        self.assertEqual(protocols.MAX_FILE_SIZE, 9007199254740992)
+        self.assertIsInstance(protocols.MAX_FILE_SIZE, int)
         self.assertEqual(protocols.MAX_FILE_SIZE, 2**53)
 
     def test_min_leaf_size(self):
-        self.assertEqual(protocols.MIN_LEAF_SIZE, 2 * MiB)
+        self.assertIsInstance(protocols.MIN_LEAF_SIZE, int)
+        self.assertEqual(protocols.MIN_LEAF_SIZE, 2 * 1024 * 1024)
+        self.assertEqual(protocols.MIN_LEAF_SIZE, 2**21)
         self.assertEqual(protocols.MIN_LEAF_SIZE,
             protocols.MAX_FILE_SIZE // 2**32
         )
 
 
 class TestFunctions(TestCase):
-    def test_b32dumps(self):
-        self.assertEqual(b32dumps(b'\x00\x00\x00\x00\x00'), 'AAAAAAAA')
-        self.assertEqual(b32dumps(b'\xff\xff\xff\xff\xff'), '77777777')
-        self.assertEqual(b32dumps(b'\x00' * 35), 'A' * 56)
-        self.assertEqual(b32dumps(b'\xff' * 35), '7' * 56)
-        for i in range(1000):
-            data = os.urandom(15)
-            self.assertEqual(
-                b32dumps(data),
-                b32encode(data).decode('utf-8')
-            )
-
-    def test_b32loads(self):
-        self.assertEqual(b32loads('AAAAAAAA'), b'\x00\x00\x00\x00\x00')
-        self.assertEqual(b32loads('77777777'), b'\xff\xff\xff\xff\xff')
-        self.assertEqual(b32loads('A' * 56), b'\x00' * 35)
-        self.assertEqual(b32loads('7' * 56), b'\xff' * 35)
-        for i in range(1000):
-            data = os.urandom(15)
-            b32 = b32encode(data)
-            self.assertEqual(b32loads(b32.decode('utf-8')), data)
-            self.assertEqual(b32decode(b32), data)
-
-class ProtocolTestCase(TestCase):
-    def check_hash_leaf(self, proto):
-
+    def test_make_key(self):
+        with self.assertRaises(TypeError) as cm:
+            protocols.make_key(1.0)
+        self.assertEqual(
+            str(cm.exception),
+            TYPE_ERROR.format('integer', int, float, 1.0)
+        )
+        with self.assertRaises(TypeError) as cm:
+            protocols.make_key('1')
+        self.assertEqual(
+            str(cm.exception),
+            TYPE_ERROR.format('integer', int, str, '1')
+        )
+
+        with self.assertRaises(ValueError) as cm:
+            protocols.make_key(-1)
+        self.assertEqual(
+            str(cm.exception),
+            'integer: must be >= 0; got -1'
+        )
+        with self.assertRaises(ValueError) as cm:
+            protocols.make_key(-17)
+        self.assertEqual(
+            str(cm.exception),
+            'integer: must be >= 0; got -17'
+        )
+
+        self.assertEqual(protocols.make_key(0), b'0')
+        self.assertEqual(protocols.make_key(1), b'1')
+        self.assertEqual(protocols.make_key(1776), b'1776')
+        for i in range(1000):
+            n = random.randint(0, 16 * GiB)
+            self.assertEqual(protocols.make_key(n), repr(n).encode('ascii'))
+
+
+class BaseTestCase1(TestCase):
+    def setUp(self):
+        self._checks = []
+
+    def check_hash_leaf_validation(self, proto):
         # Test with wrong leaf_index type:
         with self.assertRaises(TypeError) as cm:
             proto.hash_leaf(0.0, None)
@@ -165,63 +246,9 @@
             )
         )
 
-        # Smallest possible leaf, index=0
-        accum = set()
-        leaf_data = b'D'
-        digest = proto.hash_leaf(0, leaf_data)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(0, leaf_data, b''), digest)
-
-        # Smallest possible leaf, index=1
-        digest = proto.hash_leaf(1, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(1, leaf_data, b''), digest)
-
-        # Largest possible leaf, index=0
-        leaf_data = b'D' * proto.leaf_size
-        digest = proto.hash_leaf(0, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(0, leaf_data, b''), digest)
-
-        # Largest possible leaf, index=1
-        digest = proto.hash_leaf(1, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(1, leaf_data, b''), digest)
-
-        # Test with challenge, smallest leaf, index=0:
-        challenge = os.urandom(16)
-        leaf_data = b'D'
-        digest = proto.hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(0, leaf_data, challenge), digest)
-
-        # Test with challenge, smallest leaf, index=1:
-        digest = proto.hash_leaf(1, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(1, leaf_data, challenge), digest)
-
-        # Test with challenge, largest leaf, index=0:
-        leaf_data = b'D' * proto.leaf_size
-        digest = proto.hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(0, leaf_data, challenge), digest)
-
-        # Test with challenge, largest leaf, index=1:
-        digest = proto.hash_leaf(1, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(proto._hash_leaf(1, leaf_data, challenge), digest)
-
-        # Make sure we didn't goof
-        self.assertEqual(len(accum), 8)
-
-    def check_hash_root(self, proto):
+        self._checks.append('hash_leaf_validation')
+
+    def check_hash_root_validation(self, proto):
         # Test with wrong file_size type:
         with self.assertRaises(TypeError) as cm:
             proto.hash_root(1.0, None)
@@ -321,99 +348,10 @@
             )
         )
 
-        # Test with good file_size and leaf_hashes
-        accum = set()
-        leaf_hashes = b'D' * proto.digest_bytes
-        _id = proto.hash_root(1, leaf_hashes)
-        self.assertNotIn(_id, accum)
-        accum.add(_id)
-        self.assertEqual(
-            proto._hash_root(1, leaf_hashes),
-            b32decode(_id.encode('utf-8'))
-        )
-
-        _id = proto.hash_root(2, leaf_hashes)
-        self.assertNotIn(_id, accum)
-        accum.add(_id)
-        self.assertEqual(
-            proto._hash_root(2, leaf_hashes),
-            b32decode(_id.encode('utf-8'))
-        )
-
-        leaf_hashes = b'AB' * proto.digest_bytes
-        _id = proto.hash_root(proto.leaf_size + 1, leaf_hashes)
-        self.assertNotIn(_id, accum)
-        accum.add(_id)
-        self.assertEqual(
-            proto._hash_root(proto.leaf_size + 1, leaf_hashes),
-            b32decode(_id.encode('utf-8'))
-        )
-
-        _id = proto.hash_root(proto.leaf_size + 2, leaf_hashes)
-        self.assertNotIn(_id, accum)
-        accum.add(_id)
-        self.assertEqual(
-            proto._hash_root(proto.leaf_size + 2, leaf_hashes),
-            b32decode(_id.encode('utf-8'))
-        )
-
-        # Make sure we didn't goof
-        self.assertEqual(len(accum), 4)
-
-    def sanity_check_hash_leaf(self, proto):
-        """
-        Random value sanity check on Protocol._hash_leaf().
-        """
-
-        # Sanity check on our crytographic claim that the
-        # leaf-hash is tied to the leaf-index:
-        leaf_data = os.urandom(16)
-        accum = set(
-            proto._hash_leaf(i, leaf_data, b'')
-            for i in range(COUNT)
-        )
-        self.assertEqual(len(accum), COUNT)
-
-        # Sanity check on our crytographic claim that the
-        # leaf-hash is tied to the leaf-data:
-        accum = set(
-            proto._hash_leaf(21, os.urandom(16), b'')
-            for i in range(COUNT)
-        )
-        self.assertEqual(len(accum), COUNT)
-
-        # Sanity check on our crytographic claim that the
-        # leaf-hash is tied to the challenge:
-        accum = set(
-            proto._hash_leaf(21, leaf_data, os.urandom(16))
-            for i in range(COUNT)
-        )
-        self.assertEqual(len(accum), COUNT)
-
-    def sanity_check_hash_root(self, proto):
-        """
-        Random value sanity check on Protocol._hash_root().
-        """
-
-        # Sanity check on our crytographic claim that the
-        # root-hash is tied to the file-size:
-        leaf_hashes = os.urandom(proto.digest_bytes)
-        accum = set(
-            proto._hash_root(size, leaf_hashes)
-            for size in range(1, COUNT + 1)
-        )
-        self.assertEqual(len(accum), COUNT)
-
-        # Sanity check on our crytographic claim that the
-        # root-hash is tied to the leaf-hashes:
-        accum = set(
-            proto._hash_root(314159, os.urandom(proto.digest_bytes))
-            for i in range(COUNT)
-        )
-        self.assertEqual(len(accum), COUNT)
-
-
-class TestProtocol(ProtocolTestCase):
+        self._checks.append('hash_root_validation')
+
+
+class TestProtocol(BaseTestCase1):
     def test_init(self):
         # Wrong `leaf_size` type:
         with self.assertRaises(TypeError) as cm:
@@ -474,7 +412,7 @@
         self.assertEqual(proto.digest_bytes, 25)
         self.assertEqual(proto.digest_b32len, 40)
 
-        # Test with the actual v0 protocol values:
+        # Test with the actual v1 protocol values:
         proto = protocols.Protocol(8 * MiB, 240)
         self.assertEqual(proto.leaf_size, 8 * MiB)
         self.assertEqual(proto.max_leaf_count, 1073741824)
@@ -483,928 +421,891 @@
         self.assertEqual(proto.digest_bytes, 30)
         self.assertEqual(proto.digest_b32len, 48)
 
-        # Test with the actual v1 protocol values:
-        proto = protocols.Protocol(8 * MiB, 280)
-        self.assertEqual(proto.leaf_size, 8 * MiB)
-        self.assertEqual(proto.max_leaf_count, 1073741824)
-        self.assertEqual(proto.max_leaf_count, 2**30)
+        # Test with possible future values:
+        proto = protocols.Protocol(16 * MiB, 280)
+        self.assertEqual(proto.leaf_size, 16 * MiB)
+        self.assertEqual(proto.max_leaf_count, 536870912)
+        self.assertEqual(proto.max_leaf_count, 2**29)
         self.assertEqual(proto.digest_bits, 280)
         self.assertEqual(proto.digest_bytes, 35)
         self.assertEqual(proto.digest_b32len, 56)
 
-    def test_encode(self):
-        proto = protocols.Protocol(TwoMiB, 200)
-
-        # Wrong type:
-        digest = 'A' * 25
-        with self.assertRaises(TypeError) as cm:
-            proto.encode(digest)
-        self.assertEqual(
-            str(cm.exception),
-            TYPE_ERROR.format('digest', bytes, str, digest)
-        )
-
-        # Wrong length:
-        digest = b'A' * 30
-        with self.assertRaises(ValueError) as cm:
-            proto.encode(digest)
-        self.assertEqual(str(cm.exception), 'len(digest) must be 25; got 30')
-
-        digest = os.urandom(25)
-        self.assertEqual(proto.encode(digest), b32dumps(digest))
-
-    def test_decode(self):
-        proto = protocols.Protocol(TwoMiB, 200)
-
-        # Wrong type:
-        _id = b'A' * 40
-        with self.assertRaises(TypeError) as cm:
-            proto.decode(_id)
-        self.assertEqual(
-            str(cm.exception),
-            TYPE_ERROR.format('_id', str, bytes, _id)
-        )
-
-        # Wrong length:
-        _id = 'A' * 48
-        with self.assertRaises(ValueError) as cm:
-            proto.decode(_id)
-        self.assertEqual(str(cm.exception), 'len(_id) must be 40; got 48')
-
-        digest = os.urandom(25)
-        _id = b32dumps(digest)
-        self.assertEqual(proto.decode(_id), digest)
-
-        # Test round-trip:
-        for i in range(100):
-            digest = os.urandom(25)
-            self.assertEqual(proto.decode(proto.encode(digest)), digest)
-
-    def test_hash_leaf(self):
-        proto = protocols.Protocol(TwoMiB, 200)
+    def test_hash_leaf(self):
+        proto = protocols.Protocol(TwoMiB, 200)
+        self.check_hash_leaf_validation(proto)
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_leaf(0, b'data')
+        self.assertEqual(
+            str(cm.exception),
+            'Protocol._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_leaf(0, b'data', b'secret')
+        self.assertEqual(
+            str(cm.exception),
+            'Protocol._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto._hash_leaf(0, b'data', b'secret')
+        self.assertEqual(
+            str(cm.exception),
+            'Protocol._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+
+        class Example(protocols.Protocol):
+            pass
+
+        proto = Example(TwoMiB, 200)
+        self.check_hash_leaf_validation(proto)
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_leaf(0, b'data')
+        self.assertEqual(
+            str(cm.exception),
+            'Example._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_leaf(0, b'data', b'secret')
+        self.assertEqual(
+            str(cm.exception),
+            'Example._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto._hash_leaf(0, b'data', b'secret')
+        self.assertEqual(
+            str(cm.exception),
+            'Example._hash_leaf(key_leaf_index, leaf_data, challenge)'
+        )
+
+        class FooProtocol(protocols.Protocol):
+            def _hash_leaf(self, *args):
+                assert not hasattr(self, '_call')
+                assert not hasattr(self, '_ret')
+                self._call = args
+                self._ret = os.urandom(self.digest_bytes)
+                return self._ret
+
+        foo = FooProtocol(TwoMiB, 200)
+        self.check_hash_leaf_validation(foo)
+        digest = foo.hash_leaf(0, b'data')
+        self.assertEqual(foo._call, (b'0', b'data', b''))
+        self.assertIs(digest, foo._ret)
+
+        foo = FooProtocol(TwoMiB, 200)
+        digest = foo.hash_leaf(17, b'more data', b'secret')
+        self.assertEqual(foo._call, (b'17', b'more data', b'secret'))
+        self.assertIs(digest, foo._ret)
+
+        for i in range(100):
+            index = random.randint(0, MiB)
+            length = random.randint(1, TwoMiB)
+            data = os.urandom(1) * length
+
+            foo = FooProtocol(TwoMiB, 200)
+            digest = foo.hash_leaf(index, data)
+            self.assertEqual(foo._call,
+                (str(index).encode('utf-8'), data, b'')
+            )
+            self.assertIs(digest, foo._ret)
+
+            nonce = os.urandom(16)
+            foo = FooProtocol(TwoMiB, 200)
+            digest = foo.hash_leaf(index, data, nonce)
+            self.assertEqual(foo._call,
+                (str(index).encode('utf-8'), data, nonce)
+            )
+            self.assertIs(digest, foo._ret)
+
+    def test_hash_root(self):
+        proto = protocols.Protocol(TwoMiB, 200)
+        self.check_hash_root_validation(proto)
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_root(1, b'A' * 25)
+        self.assertEqual(
+            str(cm.exception),
+            'Protocol._hash_root(key_file_size, leaf_hashes)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto._hash_root(1, b'A' * 25)
+        self.assertEqual(
+            str(cm.exception),
+            'Protocol._hash_root(key_file_size, leaf_hashes)'
+        )
+
+        class Example(protocols.Protocol):
+            pass
+
+        proto = Example(TwoMiB, 200)
+        self.check_hash_root_validation(proto)
+        with self.assertRaises(NotImplementedError) as cm:
+            proto.hash_root(1, b'A' * 25)
+        self.assertEqual(
+            str(cm.exception),
+            'Example._hash_root(key_file_size, leaf_hashes)'
+        )
+        with self.assertRaises(NotImplementedError) as cm:
+            proto._hash_root(1, b'A' * 25)
+        self.assertEqual(
+            str(cm.exception),
+            'Example._hash_root(key_file_size, leaf_hashes)'
+        )
+
+        class FooProtocol(protocols.Protocol):
+            def _hash_root(self, *args):
+                assert not hasattr(self, '_call')
+                assert not hasattr(self, '_ret')
+                self._call = args
+                self._ret = os.urandom(self.digest_bytes)
+                return self._ret
+
+        foo = FooProtocol(TwoMiB, 200)
+        self.check_hash_root_validation(foo)
+        digest = foo.hash_root(1, b'A' * 25)
+        self.assertEqual(foo._call, (b'1', b'A' * 25))
+        self.assertIs(digest, foo._ret)
+
+        for i in range(100):
+            size = random.randint(1, GiB)
+            count = size // TwoMiB
+            if size % TwoMiB:
+                count += 1
+            data = os.urandom(25) * count
+
+            foo = FooProtocol(TwoMiB, 200)
+            digest = foo.hash_root(size, data)
+            self.assertEqual(foo._call,
+                (str(size).encode('utf-8'), data)
+            )
+            self.assertIs(digest, foo._ret)
+
+
+class BaseTestCase2(BaseTestCase1):
+    def check_hash_leaf_simple(self, proto):
+        accum = DigestAccum()
+        small = b'D'  # Smallest possible leaf
+        large = b'D' * proto.leaf_size  # Largest possible leaf
+
+        # Smallest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, small))
+        self.assertEqual(proto._hash_leaf(b'0', small, b''), digest)
+
+        # Smallest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, small))
+        self.assertEqual(proto._hash_leaf(b'1', small, b''), digest)
+
+        # Largest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, large))
+        self.assertEqual(proto._hash_leaf(b'0', large, b''), digest)
+
+        # Largest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, large))
+        self.assertEqual(proto._hash_leaf(b'1', large, b''), digest)
+
+        # Test with challenge, smallest leaf, index=0:
+        digest = accum.add(proto.hash_leaf(0, small, b'secret'))
+        self.assertEqual(proto._hash_leaf(b'0', small, b'secret'), digest)
+
+        # Test with challenge, smallest leaf, index=1:
+        digest = accum.add(proto.hash_leaf(1, small, b'secret'))
+        self.assertEqual(proto._hash_leaf(b'1', small, b'secret'), digest)
+
+        # Test with challenge, largest leaf, index=0:
+        digest = accum.add(proto.hash_leaf(0, large, b'secret'))
+        self.assertEqual(proto._hash_leaf(b'0', large, b'secret'), digest)
+
+        # Test with challenge, largest leaf, index=1:
+        digest = accum.add(proto.hash_leaf(1, large, b'secret'))
+        self.assertEqual(proto._hash_leaf(b'1', large, b'secret'), digest)
+
+        # Make sure we didn't goof
+        self.assertEqual(len(accum), 8)
+        for digest in accum:
+            self.assertEqual(len(digest), proto.digest_bytes)
+        safety = set()
+        for index in [0, 1]:
+            for data in [small, large]:
+                for challenge in [b'', b'secret']:
+                    safety.add(proto.hash_leaf(index, data, challenge))
+        self.assertEqual(safety, accum)
+
+        self._checks.append('hash_leaf_simple')
+
+    def check_hash_root_simple(self, proto):
+        accum = DigestAccum()
+        one = b'D' * proto.digest_bytes
+        two = b'AB' * proto.digest_bytes
+
+        digest = accum.add(proto.hash_root(1, one))
+        self.assertEqual(proto._hash_root(b'1', one), digest)
+
+        digest = accum.add(proto.hash_root(2, one))
+        self.assertEqual(proto._hash_root(b'2', one), digest)
+
+        size = proto.leaf_size + 1
+        digest = accum.add(proto.hash_root(size, two))
+        self.assertEqual(
+            proto._hash_root(str(size).encode('utf-8'), two),
+            digest
+        )
+
+        size = proto.leaf_size + 2
+        digest = accum.add(proto.hash_root(size, two))
+        self.assertEqual(
+            proto._hash_root(str(size).encode('utf-8'), two),
+            digest
+        )
+
+        size = proto.leaf_size * 2
+        digest = accum.add(proto.hash_root(size, two))
+        self.assertEqual(
+            proto._hash_root(str(size).encode('utf-8'), two),
+            digest
+        )
+
+        # Make sure we didn't goof
+        self.assertEqual(len(accum), 5)
+        for digest in accum:
+            self.assertEqual(len(digest), proto.digest_bytes)
+        safety = set([
+            proto.hash_root(1, one),
+            proto.hash_root(2, one),
+            proto.hash_root(proto.leaf_size + 1, two),
+            proto.hash_root(proto.leaf_size + 2, two),
+            proto.hash_root(proto.leaf_size * 2, two),
+        ])
+        self.assertEqual(safety, accum)
+
+        self._checks.append('hash_root_simple')
+
+    def check_hash_leaf_crypto(self, proto):
+        """
+        Random value sanity check on Protocol.hash_leaf().
+        """
+
+        # Sanity check on our cryptographic claim that the
+        # leaf-hash is tied to the leaf-index:
+        leaf_data = os.urandom(16)
+        accum = set(
+            proto.hash_leaf(i, leaf_data, b'')
+            for i in range(COUNT)
+        )
+        self.assertEqual(len(accum), COUNT)
+
+        # Sanity check on our cryptographic claim that the
+        # leaf-hash is tied to the leaf-data:
+        accum = set(
+            proto.hash_leaf(21, os.urandom(16), b'')
+            for i in range(COUNT)
+        )
+        self.assertEqual(len(accum), COUNT)
+
+        # Sanity check on our cryptographic claim that the
+        # leaf-hash is tied to the challenge:
+        accum = set(
+            proto.hash_leaf(21, leaf_data, os.urandom(16))
+            for i in range(COUNT)
+        )
+        self.assertEqual(len(accum), COUNT)
+
+        self._checks.append('hash_leaf_crypto')
+
+    def check_hash_root_crypto(self, proto):
+        """
+        Random value sanity check on Protocol.hash_root().
+        """
+
+        # Sanity check on our cryptographic claim that the
+        # root-hash is tied to the file-size:
+        leaf_hashes = os.urandom(proto.digest_bytes)
+        accum = set(
+            proto.hash_root(size, leaf_hashes)
+            for size in range(1, COUNT + 1)
+        )
+        self.assertEqual(len(accum), COUNT)
+
+        # Sanity check on our cryptographic claim that the
+        # root-hash is tied to the leaf-hashes:
+        accum = set(
+            proto.hash_root(314159, os.urandom(proto.digest_bytes))
+            for i in range(COUNT)
+        )
+        self.assertEqual(len(accum), COUNT)
+
+        self._checks.append('hash_root_crypto')
+
+    def check_hash_leaf(self, proto):
+        self.check_hash_leaf_validation(proto)
+        self.check_hash_leaf_simple(proto)
+        self.check_hash_leaf_crypto(proto)
+
+    def check_hash_root(self, proto):
+        self.check_hash_root_validation(proto)
+        self.check_hash_root_simple(proto)
+        self.check_hash_root_crypto(proto)
+
+
+class TestSkeinProtocol(BaseTestCase2):
+    def test_hash_leaf(self):
+        proto = protocols.SkeinProtocol(TwoMiB, 200)
         self.check_hash_leaf(proto)
-        self.sanity_check_hash_leaf(proto)
-
-        # Smallest possible leaf, index=0
-        accum = set()
-        leaf_data = b'D'
-        digest = proto.hash_leaf(0, leaf_data)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                key=b'0',
-            ).digest()
-        )
-        self.assertEqual(proto._hash_leaf(0, leaf_data, b''), digest)
-
-        # Smallest possible leaf, index=1
-        digest = proto.hash_leaf(1, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(proto._hash_leaf(1, leaf_data, b''), digest)
-
-        # Largest possible leaf, index=0
-        leaf_data = b'D' * TwoMiB
-        digest = proto.hash_leaf(0, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                key=b'0',
-            ).digest()
-        )
-        self.assertEqual(proto._hash_leaf(0, leaf_data, b''), digest)
-
-        # Largest possible leaf, index=1
-        digest = proto.hash_leaf(1, leaf_data)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(proto._hash_leaf(1, leaf_data, b''), digest)
+        self.assertEqual(self._checks, [
+            'hash_leaf_validation',
+            'hash_leaf_simple',
+            'hash_leaf_crypto',
+        ])
+
+        accum = DigestAccum()
+        small = b'A'  # Smallest possible leaf
+        large = b'B' * proto.leaf_size  # Largest possible leaf
+
+        # Smallest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, small))
+        self.assertEqual(digest,
+            skein512(small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                key=b'0',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', small, b''), digest)
+
+        # Smallest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, small))
+        self.assertEqual(digest,
+            skein512(small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                key=b'1',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', small, b''), digest)
+
+        # Largest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, large))
+        self.assertEqual(digest,
+            skein512(large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                key=b'0',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', large, b''), digest)
+
+        # Largest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, large))
+        self.assertEqual(digest,
+            skein512(large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                key=b'1',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', large, b''), digest)
 
         # Test with challenge, smallest leaf, index=0:
-        challenge = os.urandom(16)
-        leaf_data = b'D'
-        digest = proto.hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
+        digest = accum.add(proto.hash_leaf(0, small, b'secret'))
+        self.assertEqual(digest,
+            skein512(small,
                 digest_bits=200,
                 pers=protocols.PERS_LEAF,
                 key=b'0',
-                nonce=challenge,
+                nonce=b'secret',
             ).digest()
         )
-        self.assertEqual(proto._hash_leaf(0, leaf_data, challenge), digest)
+        self.assertEqual(proto._hash_leaf(b'0', small, b'secret'), digest)
 
         # Test with challenge, smallest leaf, index=1:
-        digest = proto.hash_leaf(1, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
+        digest = accum.add(proto.hash_leaf(1, small, b'secret'))
+        self.assertEqual(digest,
+            skein512(small,
                 digest_bits=200,
                 pers=protocols.PERS_LEAF,
                 key=b'1',
-                nonce=challenge,
+                nonce=b'secret',
             ).digest()
         )
-        self.assertEqual(proto._hash_leaf(1, leaf_data, challenge), digest)
+        self.assertEqual(proto._hash_leaf(b'1', small, b'secret'), digest)
 
         # Test with challenge, largest leaf, index=0:
-        leaf_data = b'D' * TwoMiB
-        digest = proto.hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
+        digest = accum.add(proto.hash_leaf(0, large, b'secret'))
+        self.assertEqual(digest,
+            skein512(large,
                 digest_bits=200,
                 pers=protocols.PERS_LEAF,
                 key=b'0',
-                nonce=challenge,
+                nonce=b'secret',
             ).digest()
         )
-        self.assertEqual(proto._hash_leaf(0, leaf_data, challenge), digest)
+        self.assertEqual(proto._hash_leaf(b'0', large, b'secret'), digest)
 
         # Test with challenge, largest leaf, index=1:
-        digest = proto.hash_leaf(1, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_data,
+        digest = accum.add(proto.hash_leaf(1, large, b'secret'))
+        self.assertEqual(digest,
+            skein512(large,
                 digest_bits=200,
                 pers=protocols.PERS_LEAF,
                 key=b'1',
-                nonce=challenge,
+                nonce=b'secret',
             ).digest()
         )
-        self.assertEqual(proto._hash_leaf(1, leaf_data, challenge), digest)
+        self.assertEqual(proto._hash_leaf(b'1', large, b'secret'), digest)
 
         # Make sure we didn't goof
+        safety = set()
+        for index in [0, 1]:
+            for data in [small, large]:
+                for challenge in [b'', b'secret']:
+                    safety.add(proto.hash_leaf(index, data, challenge))
+        self.assertEqual(safety, accum)
         self.assertEqual(len(accum), 8)
+        for digest in accum:
+            self.assertEqual(len(digest), 25)
 
     def test_hash_root(self):
-        proto = protocols.Protocol(TwoMiB, 200)
+        proto = protocols.SkeinProtocol(TwoMiB, 200)
         self.check_hash_root(proto)
-        self.sanity_check_hash_root(proto)
+        self.assertEqual(self._checks, [
+            'hash_root_validation',
+            'hash_root_simple',
+            'hash_root_crypto',
+        ])
 
-        accum = set()
+        accum = DigestAccum()
+        one = b'D' * 25
+        two = b'D' * 50
 
         # Smallest file-size possible for one leaf:
-        leaf_hashes = b'D' * 25
-        digest = proto._hash_root(1, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_hashes,
+        digest = accum.add(proto.hash_root(1, one))
+        self.assertEqual(digest,
+            skein512(one,
                 digest_bits=200,
                 pers=protocols.PERS_ROOT,
                 key=b'1',
             ).digest()
         )
-        self.assertEqual(
-            proto.hash_root(1, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
+        self.assertEqual(proto._hash_root(b'1', one), digest)
 
         # Largest file-size possible for one leaf:
-        digest = proto._hash_root(TwoMiB, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_hashes,
+        digest = accum.add(proto.hash_root(TwoMiB, one))
+        self.assertEqual(digest,
+            skein512(one,
                 digest_bits=200,
                 pers=protocols.PERS_ROOT,
                 key=b'2097152',
             ).digest()
         )
-        self.assertEqual(
-            proto.hash_root(TwoMiB, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
+        self.assertEqual(proto._hash_root(b'2097152', one), digest)
 
         # Smallest file-size possible for two leaves:
-        leaf_hashes = b'D' * 50
-        digest = proto._hash_root(TwoMiB + 1, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_hashes,
+        digest = accum.add(proto.hash_root(TwoMiB + 1, two))
+        self.assertEqual(digest,
+            skein512(two,
                 digest_bits=200,
                 pers=protocols.PERS_ROOT,
                 key=b'2097153',
             ).digest()
         )
-        self.assertEqual(
-            proto.hash_root(TwoMiB + 1, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
+        self.assertEqual(proto._hash_root(b'2097153', two), digest)
 
         # Largest file-size possible for two leaves:
-        digest = proto._hash_root(2 * TwoMiB, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(
-            digest,
-            skein512(leaf_hashes,
+        digest = accum.add(proto.hash_root(2 * TwoMiB, two))
+        self.assertEqual(digest,
+            skein512(two,
                 digest_bits=200,
                 pers=protocols.PERS_ROOT,
                 key=b'4194304',
             ).digest()
         )
-        self.assertEqual(
-            proto.hash_root(2 * TwoMiB, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
+        self.assertEqual(proto._hash_root(b'4194304', two), digest)
 
         # Make sure we didn't goof
         self.assertEqual(len(accum), 4)
-
-
-class TestVersionOne(ProtocolTestCase):
-
-    def test_md5(self):
-        # To aid debugging, md5sums of UTF-8 strings needed by test vectors
-        self.assertEqual(
-            md5(protocols.PERS_LEAF).hexdigest(),
-            '8aee35e23a5a74147b230f12123ca82e'
-        )
-        self.assertEqual(
-            md5(protocols.PERS_ROOT).hexdigest(),
-            '0445d91d37383f5384023d49e71cc629'
-        )
-        self.assertEqual(
-            md5(str(0).encode('utf-8')).hexdigest(),
-            'cfcd208495d565ef66e7dff9f98764da'
-        )
-        self.assertEqual(
-            md5(str(1).encode('utf-8')).hexdigest(),
-            'c4ca4238a0b923820dcc509a6f75849b'
-        )
-        self.assertEqual(
-            md5(str(8388607).encode('utf-8')).hexdigest(),
-            '32433904a755e2b9eb82cf167723b34f'
-        )
-        self.assertEqual(
-            md5(str(8388608).encode('utf-8')).hexdigest(),
-            '03926fda4e223707d290ac06bb996653'
-        )
-        self.assertEqual(
-            md5(str(8388609).encode('utf-8')).hexdigest(),
-            'e9b74719ce6b80c5337148d12725db03'
-        )
-        self.assertEqual(
-            md5(str(16777215).encode('utf-8')).hexdigest(),
-            '48ac8929ffdc78a66090d179ff1237d5'
-        )
-        self.assertEqual(
-            md5(str(16777216).encode('utf-8')).hexdigest(),
-            'e3e330499348f791337e9da6b534a386'
-        )
-
-        # To aid debugging, md5sums of the test vector files:
-        self.assertEqual(
-            md5(A).hexdigest(),
-            '7fc56270e7a70fa81a5935b72eacbe29'
-        )
-        self.assertEqual(
-            md5(B).hexdigest(),
-            'd2bad3eedb424dd352d65eafbf6c79ba'
-        )
-        self.assertEqual(
-            md5(C).hexdigest(),
-            '5dd3531303dd6764acb93e5f171a4ab8'
-        )
-        self.assertEqual(
-            md5(C + A).hexdigest(),
-            '0722f8dc36d75acb602dcee8d0427ce0'
-        )
-        self.assertEqual(
-            md5(C + B).hexdigest(),
-            '77264eb6eed7777a1ee03e2601fc9f64'
-        )
-        self.assertEqual(
-            md5(C + C).hexdigest(),
-            '1fbfabdaafff31967f9a95f3a3d3c642'
-        )
-
+        safety = set([
+            proto.hash_root(1, one),
+            proto.hash_root(TwoMiB, one),
+            proto.hash_root(TwoMiB + 1, two),
+            proto.hash_root(TwoMiB * 2, two),
+        ])
+        self.assertEqual(safety, accum)
+        for digest in accum:
+            self.assertEqual(len(digest), 25)
+
+
+class TestOldSkeinProtocol(BaseTestCase2):
     def test_hash_leaf(self):
-        proto = protocols.VERSION1
-
+        proto = protocols.OldSkeinProtocol(TwoMiB, 200)
         self.check_hash_leaf(proto)
-        self.sanity_check_hash_leaf(proto)
-
-        # A0
-        digest = proto._hash_leaf(0, A, b'')
-        self.assertEqual(digest, b32loads(A0_B32))
-        self.assertEqual(
-            digest,
-            skein512(A,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'0',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(0, A), digest)
-
-        # A1
-        digest = proto._hash_leaf(1, A, b'')
-        self.assertEqual(digest, b32loads(A1_B32))
-        self.assertEqual(
-            digest,
-            skein512(A,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(1, A), digest)
-
-        # B0
-        digest = proto._hash_leaf(0, B, b'')
-        self.assertEqual(digest, b32loads(B0_B32))
-        self.assertEqual(
-            digest,
-            skein512(B,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'0',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(0, B), digest)
-
-        # B1
-        digest = proto._hash_leaf(1, B, b'')
-        self.assertEqual(digest, b32loads(B1_B32))
-        self.assertEqual(
-            digest,
-            skein512(B,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(1, B), digest)
-
-        # C0
-        digest = proto._hash_leaf(0, C, b'')
-        self.assertEqual(digest, b32loads(C0_B32))
-        self.assertEqual(
-            digest,
-            skein512(C,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'0',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(0, C), digest)
-
-        # C1
-        digest = proto._hash_leaf(1, C, b'')
-        self.assertEqual(digest, b32loads(C1_B32))
-        self.assertEqual(
-            digest,
-            skein512(C,
-                digest_bits=280,
-                pers=protocols.PERS_LEAF,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(proto.hash_leaf(1, C), digest)
+        self.assertEqual(self._checks, [
+            'hash_leaf_validation',
+            'hash_leaf_simple',
+            'hash_leaf_crypto',
+        ])
+
+        accum = DigestAccum()
+        small = b'A'  # Smallest possible leaf
+        large = b'B' * proto.leaf_size  # Largest possible leaf
+        key0 = proto._hash_leaf_index(b'0')
+        key1 = proto._hash_leaf_index(b'1')
+
+        # Smallest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, small))
+        self.assertEqual(digest,
+            skein512(key0 + small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', small, b''), digest)
+
+        # Smallest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, small))
+        self.assertEqual(digest,
+            skein512(key1 + small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', small, b''), digest)
+
+        # Largest leaf, index=0
+        digest = accum.add(proto.hash_leaf(0, large))
+        self.assertEqual(digest,
+            skein512(key0 + large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', large, b''), digest)
+
+        # Largest leaf, index=1
+        digest = accum.add(proto.hash_leaf(1, large))
+        self.assertEqual(digest,
+            skein512(key1 + large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', large, b''), digest)
+
+        # Test with challenge, smallest leaf, index=0:
+        digest = accum.add(proto.hash_leaf(0, small, b'secret'))
+        self.assertEqual(digest,
+            skein512(key0 + small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                nonce=b'secret',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', small, b'secret'), digest)
+
+        # Test with challenge, smallest leaf, index=1:
+        digest = accum.add(proto.hash_leaf(1, small, b'secret'))
+        self.assertEqual(digest,
+            skein512(key1 + small,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                nonce=b'secret',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', small, b'secret'), digest)
+
+        # Test with challenge, largest leaf, index=0:
+        digest = accum.add(proto.hash_leaf(0, large, b'secret'))
+        self.assertEqual(digest,
+            skein512(key0 + large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                nonce=b'secret',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'0', large, b'secret'), digest)
+
+        # Test with challenge, largest leaf, index=1:
+        digest = accum.add(proto.hash_leaf(1, large, b'secret'))
+        self.assertEqual(digest,
+            skein512(key1 + large,
+                digest_bits=200,
+                pers=protocols.PERS_LEAF,
+                nonce=b'secret',
+            ).digest()
+        )
+        self.assertEqual(proto._hash_leaf(b'1', large, b'secret'), digest)
+
+        # Make sure we didn't goof
+        safety = set()
+        for index in [0, 1]:
+            for data in [small, large]:
+                for challenge in [b'', b'secret']:
+                    safety.add(proto.hash_leaf(index, data, challenge))
+        self.assertEqual(safety, accum)
+        self.assertEqual(len(accum), 8)
+        for digest in accum:
+            self.assertEqual(len(digest), 25)
 
     def test_hash_root(self):
-        proto = protocols.VERSION1
-
+        proto = protocols.OldSkeinProtocol(TwoMiB, 200)
         self.check_hash_root(proto)
-        self.sanity_check_hash_root(proto)
-
-        A0 = b32loads(A0_B32)
-        A1 = b32loads(A1_B32)
-        B0 = b32loads(B0_B32)
-        B1 = b32loads(B1_B32)
-        C0 = b32loads(C0_B32)
-        C1 = b32loads(C1_B32)
-
-        # A
-        digest = proto._hash_root(1, A0)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'FWV6OJYI36C5NN5DC4GS2IGWZXFCZCGJGHK35YV62LKAG7D2Z4LO4Z2S'
-        )
-        self.assertEqual(
-            digest,
-            skein512(A0,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'1',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(1, A0),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # B
-        digest = proto._hash_root(8388607, B0)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'OB756PX5V32JMKJAFKIAJ4AFSFPA2WLNIK32ELNO4FJLJPEEEN6DCAAJ'
-        )
-        self.assertEqual(
-            digest,
-            skein512(B0,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'8388607',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(8388607, B0),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # C
-        digest = proto._hash_root(8388608, C0)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'QSOHXCDH64IQBOG2NM67XEC6MLZKKPGBTISWWRPMCFCJ2EKMA2SMLY46'
-        )
-        self.assertEqual(
-            digest,
-            skein512(C0,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'8388608',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(8388608, C0),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # CA
-        digest = proto._hash_root(8388609, C0 + A1)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'BQ5UTB33ML2VDTCTLVXK6N4VSMGGKKKDYKG24B6DOAFJB6NRSGMB5BNO'
-        )
-        self.assertEqual(
-            digest,
-            skein512(C0 + A1,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'8388609',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(8388609, C0 + A1),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # CB
-        digest = proto._hash_root(16777215, C0 + B1)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'ER3LDDZ2LHMTDLOPE5XA5GEEZ6OE45VFIFLY42GEMV4TSZ2B7GJJXAIX'
-        )
-        self.assertEqual(
-            digest,
-            skein512(C0 + B1,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'16777215',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(16777215, C0 + B1),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # CC
-        digest = proto._hash_root(16777216, C0 + C1)
-        self.assertEqual(
-            b32encode(digest).decode('utf-8'),
-            'R6RN5KL7UBNJWR5SK5YPUKIGAOWWFMYYOVESU5DPT34X5MEK75PXXYIX'
-        )
-        self.assertEqual(
-            digest,
-            skein512(C0 + C1,
-                digest_bits=280,
-                pers=protocols.PERS_ROOT,
-                key=b'16777216',
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(16777216, C0 + C1),
-            b32encode(digest).decode('utf-8')
-        )
-
-
-class TestOldProtocol(TestCase):
+        self.assertEqual(self._checks, [
+            'hash_root_validation',
+            'hash_root_simple',
+            'hash_root_crypto',
+        ])
+
+        accum = DigestAccum()
+        one = b'D' * 25
+        two = b'D' * 50
+        key1 = proto._hash_file_size(b'1')
+        key2 = proto._hash_file_size(b'2097152')
+        key3 = proto._hash_file_size(b'2097153')
+        key4 = proto._hash_file_size(b'4194304')
+
+        # Smallest file-size possible for one leaf:
+        digest = accum.add(proto.hash_root(1, one))
+        self.assertEqual(digest,
+            skein512(key1 + one,
+                digest_bits=200,
+                pers=protocols.PERS_ROOT,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_root(b'1', one), digest)
+
+        # Largest file-size possible for one leaf:
+        digest = accum.add(proto.hash_root(TwoMiB, one))
+        self.assertEqual(digest,
+            skein512(key2 + one,
+                digest_bits=200,
+                pers=protocols.PERS_ROOT,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_root(b'2097152', one), digest)
+
+        # Smallest file-size possible for two leaves:
+        digest = accum.add(proto.hash_root(TwoMiB + 1, two))
+        self.assertEqual(digest,
+            skein512(key3 + two,
+                digest_bits=200,
+                pers=protocols.PERS_ROOT,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_root(b'2097153', two), digest)
+
+        # Largest file-size possible for two leaves:
+        digest = accum.add(proto.hash_root(2 * TwoMiB, two))
+        self.assertEqual(digest,
+            skein512(key4 + two,
+                digest_bits=200,
+                pers=protocols.PERS_ROOT,
+            ).digest()
+        )
+        self.assertEqual(proto._hash_root(b'4194304', two), digest)
+
+        # Make sure we didn't goof
+        self.assertEqual(len(accum), 4)
+        safety = set([
+            proto.hash_root(1, one),
+            proto.hash_root(TwoMiB, one),
+            proto.hash_root(TwoMiB + 1, two),
+            proto.hash_root(TwoMiB * 2, two),
+        ])
+        self.assertEqual(safety, accum)
+        for digest in accum:
+            self.assertEqual(len(digest), 25)
+
     def test_hash_leaf_index(self):
-        proto = protocols.OldProtocol(TwoMiB, 200)
-        accum = set()
-        key = proto._hash_leaf_index(0)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'0',
-                digest_bits=200,
-                pers=protocols.PERS_LEAF_INDEX,
-            ).digest()
-        )
-
-        key = proto._hash_leaf_index(17)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'17',
-                digest_bits=200,
-                pers=protocols.PERS_LEAF_INDEX,
-            ).digest()
-        )
-        self.assertEqual(len(accum), 2)
-
-        count = 25 * 1000
-        accum = set(
-            proto._hash_leaf_index(i) for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
-
-        #############################################
-        # Again, this time with different digest_bits
-        proto = protocols.OldProtocol(TwoMiB, 240)
-        accum = set()
-        key = proto._hash_leaf_index(0)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'0',
-                digest_bits=240,
-                pers=protocols.PERS_LEAF_INDEX,
-            ).digest()
-        )
-
-        key = proto._hash_leaf_index(17)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'17',
-                digest_bits=240,
-                pers=protocols.PERS_LEAF_INDEX,
-            ).digest()
-        )
-        self.assertEqual(len(accum), 2)
-
-        count = 25 * 1000
-        accum = set(
-            proto._hash_leaf_index(i) for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
-
-    def test_hash_leaf(self):
-        challenge = b'secret foo bar'
-        proto = protocols.OldProtocol(TwoMiB, 200)
-        key0 = proto._hash_leaf_index(0)
-        key17 = proto._hash_leaf_index(17)
-
-        accum = set()
-
-        # Min leaf size, index=0
-        leaf_data = b'D'
-        digest = proto._hash_leaf(0, leaf_data, b'')
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key0 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-            ).digest()
-        )
-
-        # Min leaf size, index=17
-        digest = proto._hash_leaf(17, leaf_data, b'')
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key17 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-            ).digest()
-        )
-
-        # With challenge, min leaf size, index=0
-        digest = proto._hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key0 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                nonce=challenge,
-            ).digest()
-        )
-
-        # With challenge, min leaf size, index=17
-        digest = proto._hash_leaf(17, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key17 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                nonce=challenge,
-            ).digest()
-        )
-
-        # Max leaf size, index=0
-        leaf_data = b'D' * TwoMiB
-        digest = proto._hash_leaf(0, leaf_data, b'')
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key0 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-            ).digest()
-        )
-
-        # Max leaf size, index=17
-        digest = proto._hash_leaf(17, leaf_data, b'')
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key17 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-            ).digest()
-        )
-
-        # With challenge, max leaf size, index=0
-        digest = proto._hash_leaf(0, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key0 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                nonce=challenge,
-            ).digest()
-        )
-
-        # With challenge, max leaf size, index=17
-        digest = proto._hash_leaf(17, leaf_data, challenge)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key17 + leaf_data,
-                digest_bits=200,
-                pers=protocols.PERS_LEAF,
-                nonce=challenge,
-            ).digest()
-        )
-
-        # Make sure we didn't goof:
-        self.assertEqual(len(accum), 8)
-
-        # A 25k value sanity check on our crytographic claim that the
-        # leaf-hash is tied to the leaf-index:
-        count = 25 * 1000
-        leaf_data = os.urandom(32)
-        accum = set(
-            proto._hash_leaf(i, leaf_data, b'')
-            for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
-
-        # A 25k random value sanity check on our crytographic claim that the
-        # leaf-hash is tied to the leaf-data:
-        accum = set(
-            proto._hash_leaf(21, os.urandom(32), b'')
-            for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
-
-        # A 25k random value sanity check on our crytographic claim that the
-        # leaf-hash is tied to the challenge:
-        accum = set(
-            proto._hash_leaf(21, leaf_data, os.urandom(16))
-            for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
+        proto = protocols.OldSkeinProtocol(TwoMiB, 200)
+        accum = DigestAccum()
+        for key in [b'0', b'1', b'17', b'18', b'21']:
+            digest = accum.add(proto._hash_leaf_index(key))
+            self.assertEqual(digest,
+                skein512(key,
+                    digest_bits=200,
+                    pers=protocols.PERS_LEAF_INDEX,
+                ).digest()
+            )
+        self.assertEqual(len(accum), 5)
 
     def test_hash_file_size(self):
-        proto = protocols.OldProtocol(TwoMiB, 200)
-        accum = set()
-
-        key = proto._hash_file_size(1)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'1',
-                digest_bits=200,
-                pers=protocols.PERS_FILE_SIZE,
-            ).digest()
-        )
-
-        key = proto._hash_file_size(18)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'18',
-                digest_bits=200,
-                pers=protocols.PERS_FILE_SIZE,
-            ).digest()
-        )
-        self.assertEqual(len(accum), 2)
-
-        count = 25 * 1000
-        accum = set(
-            proto._hash_file_size(size) for
-            size in range(1, count + 1)
-        )
-        self.assertEqual(len(accum), count)
-
-        #############################################
-        # Again, this time with different digest_bits
-        proto = protocols.OldProtocol(TwoMiB, 240)
-        accum = set()
-
-        key = proto._hash_file_size(1)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'1',
-                digest_bits=240,
-                pers=protocols.PERS_FILE_SIZE,
-            ).digest()
-        )
-
-        key = proto._hash_file_size(18)
-        self.assertNotIn(key, accum)
-        accum.add(key)
-        self.assertEqual(key,
-            skein512(b'18',
-                digest_bits=240,
-                pers=protocols.PERS_FILE_SIZE,
-            ).digest()
-        )
-        self.assertEqual(len(accum), 2)
-
-        count = 25 * 1000
-        accum = set(
-            proto._hash_file_size(size) for
-            size in range(1, count + 1)
-        )
-        self.assertEqual(len(accum), count)
-
-    def test_hash_root(self):
-        proto = protocols.OldProtocol(TwoMiB, 200)
-        key1 = proto._hash_file_size(1)
-        key18 = proto._hash_file_size(18)
-        keyM = proto._hash_file_size(TwoMiB)
-        keyM1 = proto._hash_file_size(TwoMiB + 1)
-        keyM18 = proto._hash_file_size(TwoMiB + 18)
-        key2M = proto._hash_file_size(2 * TwoMiB)
-
-        accum = set()
-
-        # One leaf, file_size=1
-        leaf_hashes = b'D' * 25
-        digest = proto._hash_root(1, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key1 + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(1, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # One leaf, file_size=18
-        digest = proto._hash_root(18, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key18 + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(18, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # One leaf, file_size=TwoMiB
-        digest = proto._hash_root(TwoMiB, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(keyM + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(TwoMiB, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # Two leaves, file_size=(TwoMiB + 1)
-        leaf_hashes = b'D' * 50
-        digest = proto._hash_root(TwoMiB + 1, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(keyM1 + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(TwoMiB + 1, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # Two leaves, file_size=(TwoMiB + 18)
-        digest = proto._hash_root(TwoMiB + 18, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(keyM18 + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(TwoMiB + 18, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # Two leaves, file_size=(2 * TwoMiB)
-        digest = proto._hash_root(2 * TwoMiB, leaf_hashes)
-        self.assertNotIn(digest, accum)
-        accum.add(digest)
-        self.assertEqual(digest,
-            skein512(key2M + leaf_hashes,
-                digest_bits=200,
-                pers=protocols.PERS_ROOT,
-            ).digest()
-        )
-        self.assertEqual(
-            proto.hash_root(2 * TwoMiB, leaf_hashes),
-            b32encode(digest).decode('utf-8')
-        )
-
-        # Make sure we didn't goof:
-        self.assertEqual(len(accum), 6)
-
-        # A 25k value sanity check on our crytographic claim that the
-        # root-hash is tied to the file-size:
-        count = 25 * 1000
-        leaf_hashes = b'D' * 25
-        accum = set(
-            proto._hash_root(size, leaf_hashes)
-            for size in range(1, count + 1)
-        )
-        self.assertEqual(len(accum), count)
-
-        # A 25k random value sanity check on our crytographic claim that the
-        # root-hash is tied to the leaf-hashes:
-        accum = set(
-            proto._hash_root(21, os.urandom(25))
-            for i in range(count)
-        )
-        self.assertEqual(len(accum), count)
+        proto = protocols.OldSkeinProtocol(TwoMiB, 200)
+        accum = DigestAccum()
+        for key in [b'1', b'2', b'2097152', b'2097153', b'4194304']:
+            digest = accum.add(proto._hash_file_size(key))
+            self.assertEqual(digest,
+                skein512(key,
+                    digest_bits=200,
+                    pers=protocols.PERS_FILE_SIZE,
+                ).digest()
+            )
+        self.assertEqual(len(accum), 5)
+
+
+class Test_VERSION0(BaseTestCase2):
+    proto = protocols.VERSION0
+
+    def test_hash_leaf(self):
+        self.check_hash_leaf(self.proto)
+        self.assertEqual(self._checks, [
+            'hash_leaf_validation',
+            'hash_leaf_simple',
+            'hash_leaf_crypto',
+        ])
+
+        leaves = misc.build_leaves(EightMiB)
+        vectors = misc.load_data('V0')
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(0, leaves['A'])),
+            vectors['leaf_hashes']['A'][0]
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(1, leaves['A'])),
+            vectors['leaf_hashes']['A'][1]
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(0, leaves['B'])),
+            vectors['leaf_hashes']['B'][0]
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(1, leaves['B'])),
+            vectors['leaf_hashes']['B'][1]
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(0, leaves['C'])),
+            vectors['leaf_hashes']['C'][0]
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_leaf(1, leaves['C'])),
+            vectors['leaf_hashes']['C'][1]
+        )
+
+    def test_hash_root(self):
+        self.check_hash_root(self.proto)
+        self.assertEqual(self._checks, [
+            'hash_root_validation',
+            'hash_root_simple',
+            'hash_root_crypto',
+        ])
+
+        vectors = misc.load_data('V0')
+        A0 = b32dec(vectors['leaf_hashes']['A'][0])
+        A1 = b32dec(vectors['leaf_hashes']['A'][1])
+        B0 = b32dec(vectors['leaf_hashes']['B'][0])
+        B1 = b32dec(vectors['leaf_hashes']['B'][1])
+        C0 = b32dec(vectors['leaf_hashes']['C'][0])
+        C1 = b32dec(vectors['leaf_hashes']['C'][1])
+        self.assertEqual(
+            b32enc(self.proto.hash_root(1, A0)),
+            vectors['root_hashes']['A']
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_root(EightMiB - 1, B0)),
+            vectors['root_hashes']['B']
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_root(EightMiB , C0)),
+            vectors['root_hashes']['C']
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_root(EightMiB + 1, C0 + A1)),
+            vectors['root_hashes']['CA']
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_root(2 * EightMiB - 1, C0 + B1)),
+            vectors['root_hashes']['CB']
+        )
+        self.assertEqual(
+            b32enc(self.proto.hash_root(2 * EightMiB , C0 + C1)),
+            vectors['root_hashes']['CC']
+        )
+
+    def test_vectors(self):
+        V0 = misc.load_data('V0')
+        self.assertEqual(misc.build_vectors(self.proto, b32enc), V0)
+
+
+class Test_VERSION1(BaseTestCase2):
+    proto = protocols.VERSION1
+
+    def test_hash_leaf(self):
+        self.check_hash_leaf(self.proto)
+        self.assertEqual(self._checks, [
+            'hash_leaf_validation',
+            'hash_leaf_simple',
+            'hash_leaf_crypto',
+        ])
+
+        leaves = misc.build_leaves(EightMiB)
+        vectors = misc.load_data('V1')
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(0, leaves['A'])),
+            vectors['leaf_hashes']['A'][0]
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(1, leaves['A'])),
+            vectors['leaf_hashes']['A'][1]
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(0, leaves['B'])),
+            vectors['leaf_hashes']['B'][0]
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(1, leaves['B'])),
+            vectors['leaf_hashes']['B'][1]
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(0, leaves['C'])),
+            vectors['leaf_hashes']['C'][0]
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_leaf(1, leaves['C'])),
+            vectors['leaf_hashes']['C'][1]
+        )
+
+    def test_hash_root(self):
+        self.check_hash_root(self.proto)
+        self.assertEqual(self._checks, [
+            'hash_root_validation',
+            'hash_root_simple',
+            'hash_root_crypto',
+        ])
+
+        vectors = misc.load_data('V1')
+        A0 = db32dec(vectors['leaf_hashes']['A'][0])
+        A1 = db32dec(vectors['leaf_hashes']['A'][1])
+        B0 = db32dec(vectors['leaf_hashes']['B'][0])
+        B1 = db32dec(vectors['leaf_hashes']['B'][1])
+        C0 = db32dec(vectors['leaf_hashes']['C'][0])
+        C1 = db32dec(vectors['leaf_hashes']['C'][1])
+        self.assertEqual(
+            db32enc(self.proto.hash_root(1, A0)),
+            vectors['root_hashes']['A']
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_root(EightMiB - 1, B0)),
+            vectors['root_hashes']['B']
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_root(EightMiB , C0)),
+            vectors['root_hashes']['C']
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_root(EightMiB + 1, C0 + A1)),
+            vectors['root_hashes']['CA']
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_root(2 * EightMiB - 1, C0 + B1)),
+            vectors['root_hashes']['CB']
+        )
+        self.assertEqual(
+            db32enc(self.proto.hash_root(2 * EightMiB , C0 + C1)),
+            vectors['root_hashes']['CC']
+        )
+
+    def test_vectors(self):
+        V1 = misc.load_data('V1')
+        self.assertEqual(misc.build_vectors(self.proto, db32enc), V1)
+        self.assertNotEqual(misc.build_vectors(self.proto, b32enc), V1)
+        self.assertNotEqual(misc.build_vectors(protocols.VERSION0, db32enc), V1)
+        self.assertNotEqual(misc.build_vectors(protocols.VERSION0, b32enc), V1)
+
+    def test_md5sums(self):
+        MD5SUMS = misc.load_data('MD5SUMS')
+        self.assertEqual(misc.build_md5sums(self.proto.leaf_size), MD5SUMS)
+
 
=== modified file 'setup.py'
--- setup.py	2013-02-18 12:58:01 +0000
+++ setup.py	2013-02-19 15:39:24 +0000
@@ -67,7 +67,7 @@
         'filestore',
         'filestore.tests'
     ],
-    package_data={'filestore': ['data/test-vectors.json']},
+    package_data={'filestore': ['data/*.json']},
     scripts=['dmediasum'],
     cmdclass={'test': Test},
     ext_modules=[_filestore],