version 6

Author: stbrumme

crc32.cpp

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // crc32.cpp
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
@@ -379,7 +379,7 @@ void CRC32::add(const void* data, size_t numBytes)
 }
 
 
-/// return latest hash as 16 hex characters
+/// return latest hash as 8 hex characters
 std::string CRC32::getHash()
 {
   // convert hash to string
@@ -395,7 +395,6 @@ std::string CRC32::getHash()
   hashBuffer[5] = dec2hex[(m_hash >>  8) & 15];
   hashBuffer[6] = dec2hex[(m_hash >>  4) & 15];
   hashBuffer[7] = dec2hex[ m_hash        & 15];
-
   // zero-terminated string
   hashBuffer[8] = 0;
 
@@ -404,6 +403,16 @@ std::string CRC32::getHash()
 }
 
 
+/// return latest hash as bytes
+void CRC32::getHash(unsigned char buffer[CRC32::HashBytes])
+{
+  buffer[0] = (m_hash >> 24) & 0xFF;
+  buffer[1] = (m_hash >> 16) & 0xFF;
+  buffer[2] = (m_hash >>  8) & 0xFF;
+  buffer[3] =  m_hash        & 0xFF;
+}
+
+
 /// compute CRC32 of a memory block
 std::string CRC32::operator()(const void* data, size_t numBytes)
 {

crc32.h

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // crc32.h
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
@@ -32,10 +32,18 @@ typedef unsigned __int32 uint32_t;
     while (more data available)
       crc32.add(pointer to fresh data, number of new bytes);
     std::string myHash3 = crc32.getHash();
+
+    Note:
+    You can find code for the faster Slicing-by-16 algorithm on my website, too:
+    http://create.stephan-brumme.com/crc32/
+    Its unrolled version is about twice as fast but its look-up table doubled in size as well.
   */
 class CRC32 //: public Hash
 {
 public:
+  /// hash is 4 bytes long
+  enum { HashBytes = 4 };
+
   /// same as reset()
   CRC32();
 
@@ -47,8 +55,10 @@ class CRC32 //: public Hash
   /// add arbitrary number of bytes
   void add(const void* data, size_t numBytes);
 
-  /// return latest hash as 16 hex characters
+  /// return latest hash as 8 hex characters
   std::string getHash();
+  /// return latest hash as bytes
+  void        getHash(unsigned char buffer[HashBytes]);
 
   /// restart
   void reset();

digest.cpp

@@ -1,9 +1,11 @@
 // //////////////////////////////////////////////////////////
 // digest.cpp
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
+// g++ -O3 digest.cpp crc32.cpp md5.cpp sha1.cpp sha256.cpp keccak.cpp sha3.cpp -o digest
+
 #include "crc32.h"
 #include "md5.h"
 #include "sha1.h"
@@ -14,12 +16,13 @@
 #include <iostream>
 #include <fstream>
 
+
 int main(int argc, char** argv)
 {
   // syntax check
   if (argc < 2 || argc > 3)
   {
-    std::cout << "./digest filename [--md5|--sha1|--sha256|--crc|--keccak|--sha3]" << std::endl;
+    std::cout << "./digest filename [--crc|--md5|--sha1|--sha256|--keccak|--sha3]" << std::endl;
     return 1;
   }
 

hash.h

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // hash.h
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
@@ -20,7 +20,7 @@ class Hash
   /// add arbitrary number of bytes
   virtual void add(const void* data, size_t numBytes) = 0;
 
-  /// return latest hash as 16 hex characters
+  /// return latest hash as hex characters
   virtual std::string getHash() = 0;
 
   /// restart

hmac.h

@@ -0,0 +1,83 @@
+// //////////////////////////////////////////////////////////
+// hmac.h
+// Copyright (c) 2015 Stephan Brumme. All rights reserved.
+// see http://create.stephan-brumme.com/disclaimer.html
+//
+
+#pragma once
+
+// based on http://tools.ietf.org/html/rfc2104
+// see also http://en.wikipedia.org/wiki/Hash-based_message_authentication_code
+
+/** Usage:
+    std::string msg = "The quick brown fox jumps over the lazy dog";
+    std::string key = "key";
+    std::string md5hmac  = hmac< MD5  >(msg, key);
+    std::string sha1hmac = hmac< SHA1 >(msg, key);
+    std::string sha2hmac = hmac<SHA256>(msg, key);
+
+    Note:
+    To keep my code simple, HMAC computation currently needs the whole message at once.
+    This is in contrast to the hashes MD5, SHA1, etc. where an add() method is available
+    for incremental computation.
+    You can use any hash for HMAC as long as it provides:
+    - constant HashMethod::BlockSize (typically 64)
+    - constant HashMethod::HashBytes (length of hash in bytes, e.g. 20 for SHA1)
+    - HashMethod::add(buffer, bufferSize)
+    - HashMethod::getHash(unsigned char buffer[HashMethod::BlockSize])
+  */
+
+#include <string>
+#include <cstring> // memcpy
+
+/// compute HMAC hash of data and key using MD5, SHA1 or SHA256
+template <typename HashMethod>
+std::string hmac(const void* data, size_t numDataBytes, const void* key, size_t numKeyBytes)
+{
+  // initialize key with zeros
+  unsigned char usedKey[HashMethod::BlockSize] = {0};
+
+  // adjust length of key: must contain exactly blockSize bytes
+  if (numKeyBytes <= HashMethod::BlockSize)
+  {
+    // copy key
+    memcpy(usedKey, key, numKeyBytes);
+  }
+  else
+  {
+    // shorten key: usedKey = hashed(key)
+    HashMethod keyHasher;
+    keyHasher.add(key, numKeyBytes);
+    keyHasher.getHash(usedKey);
+  }
+
+  // create initial XOR padding
+  for (size_t i = 0; i < HashMethod::BlockSize; i++)
+    usedKey[i] ^= 0x36;
+
+  // inside = hash((usedKey ^ 0x36) + data)
+  unsigned char inside[HashMethod::HashBytes];
+  HashMethod insideHasher;
+  insideHasher.add(usedKey, HashMethod::BlockSize);
+  insideHasher.add(data,    numDataBytes);
+  insideHasher.getHash(inside);
+
+  // undo usedKey's previous 0x36 XORing and apply a XOR by 0x5C
+  for (size_t i = 0; i < HashMethod::BlockSize; i++)
+    usedKey[i] ^= 0x5C ^ 0x36;
+
+  // hash((usedKey ^ 0x5C) + hash((usedKey ^ 0x36) + data))
+  HashMethod finalHasher;
+  finalHasher.add(usedKey, HashMethod::BlockSize);
+  finalHasher.add(inside,  HashMethod::HashBytes);
+
+  return finalHasher.getHash();
+}
+
+
+/// convenience function for std::string
+template <typename HashMethod>
+std::string hmac(const std::string& data, const std::string& key)
+{
+  return hmac<HashMethod>(data.c_str(), data.size(), key.c_str(), key.size());
+}

keccak.cpp

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // keccak.cpp
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
@@ -222,11 +222,11 @@ void Keccak::processBuffer()
   // add a "1" byte
   m_buffer[offset++] = 1;
   // fill with zeros
-  while (offset < blockSize - 1)
+  while (offset < blockSize)
     m_buffer[offset++] = 0;
 
   // and add a single set bit
-  m_buffer[blockSize - 1] = 0x80;
+  m_buffer[blockSize - 1] |= 0x80;
 
   processBlock(m_buffer);
 }

keccak.h

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // keccak.h
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 

md5.cpp

@@ -1,6 +1,6 @@
 // //////////////////////////////////////////////////////////
 // md5.cpp
-// Copyright (c) 2014 Stephan Brumme. All rights reserved.
+// Copyright (c) 2014,2015 Stephan Brumme. All rights reserved.
 // see http://create.stephan-brumme.com/disclaimer.html
 //
 
@@ -316,72 +316,49 @@ void MD5::processBuffer()
 }
 
 
-/// return latest hash as 16 hex characters
+/// return latest hash as 32 hex characters
 std::string MD5::getHash()
 {
-  // convert hash to string
-  static const char dec2hex[16+1] = "0123456789abcdef";
+  // compute hash (as raw bytes)
+  unsigned char rawHash[HashBytes];
+  getHash(rawHash);
+
+  // convert to hex string
+  std::string result;
+  result.reserve(2 * HashBytes);
+  for (int i = 0; i < HashBytes; i++)
+  {
+    static const char dec2hex[16+1] = "0123456789abcdef";
+    result += dec2hex[(rawHash[i] >> 4) & 15];
+    result += dec2hex[ rawHash[i]       & 15];
+  }
+
+  return result;
+}
+
 
+/// return latest hash as bytes
+void MD5::getHash(unsigned char buffer[MD5::HashBytes])
+{
   // save old hash if buffer is partially filled
-  uint32_t oldHash[4];
-  oldHash[0] = m_hash[0];
-  oldHash[1] = m_hash[1];
-  oldHash[2] = m_hash[2];
-  oldHash[3] = m_hash[3];
+  uint32_t oldHash[HashValues];
+  for (int i = 0; i < HashValues; i++)
+    oldHash[i] = m_hash[i];
 
   // process remaining bytes
   processBuffer();
 
-  // create hash string
-  char hashBuffer[4*8+1];
-
-  hashBuffer[ 0] = dec2hex[(m_hash[0] >>  4) & 15];
-  hashBuffer[ 1] = dec2hex[ m_hash[0]        & 15];
-  hashBuffer[ 2] = dec2hex[(m_hash[0] >> 12) & 15];
-  hashBuffer[ 3] = dec2hex[(m_hash[0] >>  8) & 15];
-  hashBuffer[ 4] = dec2hex[(m_hash[0] >> 20) & 15];
-  hashBuffer[ 5] = dec2hex[(m_hash[0] >> 16) & 15];
-  hashBuffer[ 6] = dec2hex[ m_hash[0] >> 28      ];
-  hashBuffer[ 7] = dec2hex[(m_hash[0] >> 24) & 15];
-
-  hashBuffer[ 8] = dec2hex[(m_hash[1] >>  4) & 15];
-  hashBuffer[ 9] = dec2hex[ m_hash[1]        & 15];
-  hashBuffer[10] = dec2hex[(m_hash[1] >> 12) & 15];
-  hashBuffer[11] = dec2hex[(m_hash[1] >>  8) & 15];
-  hashBuffer[12] = dec2hex[(m_hash[1] >> 20) & 15];
-  hashBuffer[13] = dec2hex[(m_hash[1] >> 16) & 15];
-  hashBuffer[14] = dec2hex[ m_hash[1] >> 28      ];
-  hashBuffer[15] = dec2hex[(m_hash[1] >> 24) & 15];
-
-  hashBuffer[16] = dec2hex[(m_hash[2] >>  4) & 15];
-  hashBuffer[17] = dec2hex[ m_hash[2]        & 15];
-  hashBuffer[18] = dec2hex[(m_hash[2] >> 12) & 15];
-  hashBuffer[19] = dec2hex[(m_hash[2] >>  8) & 15];
-  hashBuffer[20] = dec2hex[(m_hash[2] >> 20) & 15];
-  hashBuffer[21] = dec2hex[(m_hash[2] >> 16) & 15];
-  hashBuffer[22] = dec2hex[ m_hash[2] >> 28      ];
-  hashBuffer[23] = dec2hex[(m_hash[2] >> 24) & 15];
-
-  hashBuffer[24] = dec2hex[(m_hash[3] >>  4) & 15];
-  hashBuffer[25] = dec2hex[ m_hash[3]        & 15];
-  hashBuffer[26] = dec2hex[(m_hash[3] >> 12) & 15];
-  hashBuffer[27] = dec2hex[(m_hash[3] >>  8) & 15];
-  hashBuffer[28] = dec2hex[(m_hash[3] >> 20) & 15];
-  hashBuffer[29] = dec2hex[(m_hash[3] >> 16) & 15];
-  hashBuffer[30] = dec2hex[ m_hash[3] >> 28      ];
-  hashBuffer[31] = dec2hex[(m_hash[3] >> 24) & 15];
-
-  // zero-terminated string
-  hashBuffer[32] = 0;
-
-  // restore old hash
-  m_hash[0] = oldHash[0];
-  m_hash[1] = oldHash[1];
-  m_hash[2] = oldHash[2];
-  m_hash[3] = oldHash[3];
-
-  // convert to std::string
-  return hashBuffer;
+  unsigned char* current = buffer;
+  for (int i = 0; i < HashValues; i++)
+  {
+    *current++ =  m_hash[i]        & 0xFF;
+    *current++ = (m_hash[i] >>  8) & 0xFF;
+    *current++ = (m_hash[i] >> 16) & 0xFF;
+    *current++ = (m_hash[i] >> 24) & 0xFF;
+
+    // restore old hash
+    m_hash[i] = oldHash[i];
+  }
 }
 
 

md5.h

@@ -37,6 +37,9 @@ typedef unsigned __int64 uint64_t;
 class MD5 //: public Hash
 {
 public:
+  /// split into 64 byte blocks (=> 512 bits), hash is 16 bytes long
+  enum { BlockSize = 512 / 8, HashBytes = 16 };
+
   /// same as reset()
   MD5();
 
@@ -48,8 +51,10 @@ class MD5 //: public Hash
   /// add arbitrary number of bytes
   void add(const void* data, size_t numBytes);
 
-  /// return latest hash as 16 hex characters
+  /// return latest hash as 32 hex characters
   std::string getHash();
+  /// return latest hash as bytes
+  void        getHash(unsigned char buffer[HashBytes]);
 
   /// restart
   void reset();
@@ -60,15 +65,14 @@ class MD5 //: public Hash
   /// process everything left in the internal buffer
   void processBuffer();
 
-  /// split into 64 byte blocks (=> 512 bits)
-  enum { BlockSize = 512 / 8 };
-
   /// size of processed data in bytes
   uint64_t m_numBytes;
   /// valid bytes in m_buffer
   size_t   m_bufferSize;
   /// bytes not processed yet
   uint8_t  m_buffer[BlockSize];
+
+  enum { HashValues = HashBytes / 4 };
   /// hash, stored as integers
-  uint32_t m_hash[4];
+  uint32_t m_hash[HashValues];
 };