Simplified QKeccakHash and added self-test function.

etc/Prerequisites/keccak/src/qkeccakhash.cpp

@@ -28,173 +28,158 @@
 
 #include "keccakimpl.cpp"
 
-QKeccakHash::QKeccakHash() :
+QKeccakHash::QKeccakHash()
-  mState(0),
-  mHashBitLength(0)
 {
-}
+	m_initialized = false;
-
+	m_state = new KeccakImpl::hashState;
-QKeccakHash::QKeccakHash(const QString &asciiMessage, HashBits hashBits) :
+	memset(m_state, 0, sizeof(KeccakImpl::hashState));
-  mState(0),
+	m_hashResult.clear();
-  mHashBitLength(0)
-{
-  if (!setHashBitLength(hashBits))
-    return;
-  
-  bool success = false;
-  QByteArray msg = asciiMessage.toAscii();
-  
-  mState = new KeccakImpl::hashState;
-  if (KeccakImpl::Init(mState, mHashBitLength) == KeccakImpl::SUCCESS)
-  {
-    if (KeccakImpl::Update(mState, (KeccakImpl::BitSequence*)msg.constData(), msg.size()*8) == KeccakImpl::SUCCESS)
-    {
-      if (KeccakImpl::Final(mState, (KeccakImpl::BitSequence*)mHashResult.data()) == KeccakImpl::SUCCESS)
-        success = true;
-    }
-  }
-  delete mState;
-  mState = 0;
-  
-  if (!success)
-  {
-    mHashResult.clear();
-    qDebug() << "QKeccakHash::QKeccakHash(): hash construction failed";
-  }
 }
 
 QKeccakHash::~QKeccakHash()
 {
-  if (mState)
+	m_hashResult.clear();
-    delete mState;
-}
 
-QByteArray QKeccakHash::toRaw() const
+	if(m_state)
-{
-  return mHashResult;
-}
-
-QByteArray QKeccakHash::toHex() const
-{
-  return mHashResult.toHex();
-}
-
-QString QKeccakHash::toHexString() const
-{
-  return QString(mHashResult.toHex());
-}
-
-bool QKeccakHash::file(const QString &fileName, HashBits hashBits, int blockSize)
-{
-  if (isBatchRunning() || blockSize < 1)
-    return false;
-  if (!setHashBitLength(hashBits))
-    return false;
-  QFile file(fileName);
-  if (file.open(QFile::ReadOnly))
 	{
-    qint64 fileSize = file.size();
+		delete m_state;
-    qint64 readBytes = 0;
+		m_state = NULL;
-    if (!startBatch())
-      return false;
-    bool success = true;
-    char *buffer = new char[blockSize];
-    // repeatedly read blockSize bytes of the file to buffer and pass it to putBatch:
-    while (file.error() == QFile::NoError)
-    {
-      readBytes = file.read(buffer, qMin(fileSize-file.pos(), (qint64)blockSize)); // read till end of file to buffer, but not more than blockSize bytes
-      if (readBytes > 0)
-      {
-        if (!putBatch(buffer, readBytes))
-        {
-          success = false;
-          break;
 	}
-        if (readBytes < blockSize) // that was the last block
+}
-          break;
+
-      } else // error occured
+bool QKeccakHash::init(HashBits hashBits)
+{
+	if(m_initialized)
 	{
-        success = false;
+		qWarning("QKeccakHash has already been initialized!");
-        break;
+		return false;
 	}
-    }
-    delete buffer;
-    if (!stopBatch())
-      success = false;
-    return success;
-  } else
-    return false;
-}
 
-bool QKeccakHash::startBatch(HashBits hashBits)
+	m_hashResult.clear();
-{
+	memset(m_state, 0, sizeof(KeccakImpl::hashState));
-  if (isBatchRunning())
+	int hashBitLength = 0;
-    return false;
-  if (!setHashBitLength(hashBits))
-    return false;
-  mState = new KeccakImpl::hashState;
-  bool success = KeccakImpl::Init(mState, mHashBitLength) == KeccakImpl::SUCCESS;
-  if (!success)
-  {
-    delete mState;
-    mState = 0;
-    mHashResult.clear();
-  }
-  return success;
-}
 
-bool QKeccakHash::putBatch(const QByteArray &ba)
-{
-  return putBatch(ba.constData(), ba.size());
-}
-
-bool QKeccakHash::putBatch(const char *data, int size)
-{
-  if (!isBatchRunning() || mHashBitLength == 0)
-    return false;
-  bool success = KeccakImpl::Update(mState, (KeccakImpl::BitSequence*)data, size*8) == KeccakImpl::SUCCESS;
-  if (!success)
-  {
-    delete mState;
-    mState = 0;
-    mHashResult.clear();
-  }
-  return success;
-}
-
-bool QKeccakHash::stopBatch()
-{
-  if (!isBatchRunning() || mHashBitLength == 0)
-    return false;
-  bool success = KeccakImpl::Final(mState, (KeccakImpl::BitSequence*)mHashResult.data()) == KeccakImpl::SUCCESS;
-  delete mState;
-  mState = 0;
-  if (!success)
-    mHashResult.clear();
-  return success;
-}
-
-bool QKeccakHash::isBatchRunning() const
-{
-  return mState;
-}
-
-bool QKeccakHash::setHashBitLength(HashBits hashBits)
-{
 	switch (hashBits)
 	{
-    case hb224: mHashBitLength = 224; break;
+		case hb224: hashBitLength = 224; break;
-    case hb256: mHashBitLength = 256; break;
+		case hb256: hashBitLength = 256; break;
-    case hb384: mHashBitLength = 384; break;
+		case hb384: hashBitLength = 384; break;
-    case hb512: mHashBitLength = 512; break;
+		case hb512: hashBitLength = 512; break;
-    default: 
+		default: throw "Invalid hash length!!";
+	}
+
+	if(KeccakImpl::Init(m_state, hashBitLength) != KeccakImpl::SUCCESS)
 	{
-      mHashBitLength = 0;
+		qWarning("KeccakImpl::Init() has failed unexpectedly!");
-      qDebug() << "QKeccakHash::setHashBitLength(): invalid hash bit value" << (int)hashBits << ", must be hb224, hb256, hb384 or hb512";
 		return false;
 	}
-  }
+	
-  mHashResult.fill(0, mHashBitLength/8);
+	m_hashResult.fill(char(0), hashBitLength/8);
+	m_initialized = true;
+
 	return true;
 }
 
+bool QKeccakHash::addData(const QByteArray &data)
+{
+	return addData(data.constData(), data.size());
+}
+
+bool QKeccakHash::addData(const char *data, int size)
+{
+	if(!m_initialized)
+	{
+		qWarning("QKeccakHash has not been initialized yet!");
+		return false;
+	}
+	
+	if(KeccakImpl::Update(m_state, (KeccakImpl::BitSequence*)data, size*8) != KeccakImpl::SUCCESS)
+	{
+		qWarning("KeccakImpl::Update() has failed unexpectedly!");
+		m_hashResult.clear();
+		m_initialized = false;
+		return false;
+	}
+	
+	return true;
+}
+
+const QByteArray &QKeccakHash::finalize()
+{
+	if(!m_initialized)
+	{
+		qWarning("QKeccakHash has not been initialized yet!");
+		m_hashResult.clear();
+		return m_hashResult;
+	}
+
+	if(KeccakImpl::Final(m_state, (KeccakImpl::BitSequence*)m_hashResult.data()) != KeccakImpl::SUCCESS)
+	{
+		qWarning("KeccakImpl::Final() has failed unexpectedly!");
+		m_hashResult.clear();
+	}
+
+	m_initialized = false;
+	return m_hashResult;
+}
+
+bool QKeccakHash::selfTest(void)
+{
+	QKeccakHash hash;
+	const QByteArray input("The quick brown fox jumps over the lazy dog");
+	bool passed[4] = {false, false, false, false};
+
+	if(hash.init(QKeccakHash::hb224))
+	{
+		if(hash.addData(input))
+		{
+			QByteArray result = hash.finalize();
+			if(!result.isEmpty())
+			{
+				passed[0] = (_stricmp(result.toHex().constData(), "310aee6b30c47350576ac2873fa89fd190cdc488442f3ef654cf23fe") == 0);
+				if(!passed[0]) qWarning("QKeccakHash self-test: Test #1 failed !!!");
+			}
+		}
+	}
+
+	if(hash.init(QKeccakHash::hb256))
+	{
+		if(hash.addData(input))
+		{
+			QByteArray result = hash.finalize();
+			if(!result.isEmpty())
+			{
+				passed[1] = (_stricmp(result.toHex().constData(), "4d741b6f1eb29cb2a9b9911c82f56fa8d73b04959d3d9d222895df6c0b28aa15") == 0);
+				if(!passed[1]) qWarning("QKeccakHash self-test: Test #2 failed !!!");
+			}
+		}
+	}
+	
+	if(hash.init(QKeccakHash::hb384))
+	{
+		if(hash.addData(input))
+		{
+			QByteArray result = hash.finalize();
+			if(!result.isEmpty())
+			{
+				passed[2] = (_stricmp(result.toHex().constData(), "283990fa9d5fb731d786c5bbee94ea4db4910f18c62c03d173fc0a5e494422e8a0b3da7574dae7fa0baf005e504063b3") == 0);
+				if(!passed[2]) qWarning("QKeccakHash self-test: Test #3 failed !!!");
+			}
+		}
+	}
+
+	if(hash.init(QKeccakHash::hb512))
+	{
+		if(hash.addData(input))
+		{
+			QByteArray result = hash.finalize();
+			if(!result.isEmpty())
+			{
+				passed[3] = (_stricmp(result.toHex().constData(), "d135bb84d0439dbac432247ee573a23ea7d3c9deb2a968eb31d47c4fb45f1ef4422d6c531b5b9bd6f449ebcc449ea94d0a8f05f62130fda612da53c79659f609") == 0);
+				if(!passed[3]) qWarning("QKeccakHash self-test: Test #4 failed !!!");
+			}
+		}
+	}
+
+	return (passed[0] && passed[1] && passed[2] && passed[3]);
+}

etc/Prerequisites/keccak/src/qkeccakhash.h

@@ -33,21 +33,22 @@
 // Section from KeccakSponge.h
 // needed here, since hashState needs to be explicitly 32-byte aligned and therefore can't be
 // transformed into a class (in order to forward declarate) like in the other hash wrappers.
-namespace KeccakImpl {
+namespace KeccakImpl
-#define KeccakPermutationSize 1600
+{
-#define KeccakPermutationSizeInBytes (KeccakPermutationSize/8)
+	#define KeccakPermutationSize 1600
-#define KeccakMaximumRate 1536
+	#define KeccakPermutationSizeInBytes (KeccakPermutationSize/8)
-#define KeccakMaximumRateInBytes (KeccakMaximumRate/8)
+	#define KeccakMaximumRate 1536
+	#define KeccakMaximumRateInBytes (KeccakMaximumRate/8)
 
-#if defined(__GNUC__)
+	#if defined(__GNUC__)
-#define ALIGN __attribute__ ((aligned(32)))
+	#define ALIGN __attribute__ ((aligned(32)))
-#elif defined(_MSC_VER)
+	#elif defined(_MSC_VER)
-#define ALIGN __declspec(align(32))
+	#define ALIGN __declspec(align(32))
-#else
+	#else
-#define ALIGN
+	#define ALIGN
-#endif
+	#endif
 
-ALIGN typedef struct spongeStateStruct {
+	ALIGN typedef struct spongeStateStruct {
 		ALIGN unsigned char state[KeccakPermutationSizeInBytes];
 		ALIGN unsigned char dataQueue[KeccakMaximumRateInBytes];
 		unsigned int rate;
@@ -56,8 +57,8 @@ ALIGN typedef struct spongeStateStruct {
 		unsigned int fixedOutputLength;
 		int squeezing;
 		unsigned int bitsAvailableForSqueezing;
-} spongeState;
+	} spongeState;
-typedef spongeState hashState;
+	typedef spongeState hashState;
 }
 // End Section from KeccakSponge.h
 
@@ -65,23 +66,21 @@ class QKeccakHash
 {
 public:
 	enum HashBits {hb224, hb256, hb384, hb512};
+	
 	QKeccakHash();
-  QKeccakHash(const QString &asciiMessage, HashBits hashBits=hb256);
 	~QKeccakHash();
-  QByteArray toRaw() const;
+	
-  QByteArray toHex() const;
+	static bool selfTest(void);
-  QString toHexString() const;
+
-  bool file(const QString &fileName, HashBits hashBits=hb256, int blockSize=8388608); // 8 KiB default blockSize
+	bool init(HashBits hashBits=hb256);
-  bool startBatch(HashBits hashBits=hb256);
+	bool addData(const QByteArray &data);
-  bool putBatch(const QByteArray &ba);
+	bool addData(const char *data, int size);
-  bool putBatch(const char *data, int size);
+	const QByteArray &finalize();
-  bool stopBatch();
+
-  bool isBatchRunning() const;
 protected:
-  bool setHashBitLength(HashBits hashBits);
+	bool m_initialized;
-  KeccakImpl::hashState *mState;
+	KeccakImpl::hashState *m_state;
-  QByteArray mHashResult;
+	QByteArray m_hashResult;
-  int mHashBitLength;
 };
 
 #endif // QKECCAKHASH_H

src/Config.h

@@ -30,7 +30,7 @@
 #define VER_LAMEXP_MINOR_LO					7
 #define VER_LAMEXP_TYPE						Alpha
 #define VER_LAMEXP_PATCH					4
-#define VER_LAMEXP_BUILD					1197
+#define VER_LAMEXP_BUILD					1198
 
 ///////////////////////////////////////////////////////////////////////////////
 // Tool versions (minimum expected versions!)

src/LockedFile.cpp

@@ -63,22 +63,20 @@ static QByteArray fileHash(QFile &file)
 	{
 		QKeccakHash keccak;
 
-		QByteArray data = file.readAll();
+		const QByteArray data = file.readAll();
-		QByteArray seed = QByteArray::fromHex(g_seed);
+		const QByteArray seed = QByteArray::fromHex(g_seed);
-		QByteArray salt = QByteArray::fromHex(g_salt);
+		const QByteArray salt = QByteArray::fromHex(g_salt);
 	
-		if(keccak.startBatch(QKeccakHash::hb384))
+		if(keccak.init(QKeccakHash::hb384))
 		{
-			bool ok[3];
+			bool ok = true;
-			ok[0] = keccak.putBatch(seed);
+			ok = ok && keccak.addData(seed);
-			ok[1] = keccak.putBatch(data);
+			ok = ok && keccak.addData(data);
-			ok[2] = keccak.putBatch(salt);
+			ok = ok && keccak.addData(salt);
-			if(ok[0] && ok[1] && ok[2])
+			if(ok)
 			{
-				if(keccak.stopBatch())
+				const QByteArray digest = keccak.finalize();
-				{
+				if(!digest.isEmpty()) hash = digest.toHex();
-					hash = keccak.toHex();
-				}
 			}
 		}
 	}
@@ -224,3 +222,11 @@ const QString &LockedFile::filePath()
 {
 	return m_filePath;
 }
+
+void LockedFile::selfTest()
+{
+	if(!QKeccakHash::selfTest())
+	{
+		qFatal("QKeccakHash self-test has failed!");
+	}
+}

src/LockedFile.h

@@ -32,6 +32,8 @@ public:
 
 	const QString &filePath();
 
+	static void selfTest();
+
 private:
 	QString m_filePath;
 	void *m_fileHandle;

src/Thread_Initialization.cpp

@@ -217,6 +217,7 @@ void InitializationThread::run()
 		pool->setMaxThreadCount(idealThreadCount * 2);
 	}
 	
+	LockedFile::selfTest();
 	ExtractorTask::clearFlags();
 
 	QTime timer;