Initial commit of SHA1 implementation.  Contains python script test.py
to test the implementation against the SHAVS informal test vectors.
Contains a prototype in python of the SHA1 implementation (proto.py).
Prototype passes all the short tests, I have not tested against the
long and pseudorandom test sets yet.
- All the SHAVS tests (short, long and pseudorandom) are now completing
  successfully for the python prototype SHA-1 implementation.

- Added more command-line args to the test script.

- Ready to start working on the C++ implementation of SHA-1.
- Project for C++ implementation created.

- Makefiles added - building both the main project and the unit test
  binaries, running the unit tests on every compile.

- Unit test framework added, with unit tests for the hex string
  inserter and extractor, and basic sanity tests for sha1::hash added.

- Implemented hex string inserter and extractor, passing the unit
  tests.
- Semi working implementation of the SHA1 algorithm in C++.
  Succesfully calculates some of the test hashes, fails others (fails
  about 10 of the 65 short message tests from SHAVS, 55 of 65 long
  message tests, and the pseudo-generated message test).

- Decided to implement the hash algorithm entirely in terms of
  uint32_t manipulation.  As all the bitwise and arithmetical
  operations in the hash algorithm operate on this type alone, its
  guaranteed to work whether the machine architecture is big-endian or
  little-endian.  At the start and end of the hash operation, I
  convert the hash represented as an array of uint32 values to a
  bitstream, and vice-versa for each block of the original message.
- C++ implementation passes all byte-oriented SHAVS tests (and much
  faster than the python prototype!).

- Discovered that python prototype fails on bit-oriented SHAVS tests -
  length of non byte-oriented messages is set in multiples of 4 when
  initialising a BitArray with a hex string.  Still works perfectly on
  byte-oriented messages though.
- Refactored the hex string extractor code into an istream derived
  hexstream class, made it work more correctly, and made the code more
  clear.

- Still need to improve it to handle bad state and io exceptions being
  thrown.
- Basic handling of binary files.  Much slower than sha1sum on largish
  files (e.g. 20MB).

- Improvements to hexstream, though have realised this strategy may
  not work as using an istream pointer means that the subclass
  extractor for vector<unsigned char> won't be found.
Clean up before trying to remove big binary zips.
Merge branch 'master' of https://github.com/fruitnuke/shack
Clean up after 3 years. Remove tracedog which is no longer so easily available (requires windows to extract even though it's 'cross-platform'. A couple of changes to help build with latest boost program_options shared lib.