Messy little program for salted Blam Engine SHA1 checksums.

main.cpp

#include "TinySHA1.hpp"
#include <iostream>
#include <fstream>
#include <string>
#include <cctype>
#include <vector>

unsigned char Salt[34] =
{
	0xED, 0xD4, 0x30, 0x09, 0x66, 0x6D, 0x5C, 0x4A, 0x5C, 0x36, 0x57, 0xFA, 0xB4, 0x0E, 0x02, 0x2F,
	0x53, 0x5A, 0xC6, 0xC9, 0xEE, 0x47, 0x1F, 0x01, 0xF1, 0xA4, 0x47, 0x56, 0xB7, 0x71, 0x4F, 0x1C,
	0x36, 0xEC
};

int main(int argc, char* argv[])
{
	bool UseSalt = false;
	std::ifstream fIn;

	if( argc > 3 || argc < 2 )
	{
		std::cout << "Usage: BlamSHA1.exe (filename) [s]" << std::endl;
		std::cout << "\tUse s option to enable salt." << std::endl;
		std::exit(1);
	}

	std::vector<std::string> Arguments(argv + 1, argv + argc);

	if( argc == 3 )
	{
		if( std::tolower(Arguments[1][0]) == 's')
		{
			UseSalt = true;
		}
		else
		{
			std::cout << "Unknown option: " << Arguments[1] << std::endl;
			std::exit(1);
		}
	}

	fIn.open(Arguments[0],std::ios::binary | std::ios::ate);
	size_t size = fIn.tellg();
	fIn.seekg(0, std::ios::beg);

	if( !fIn.good() )
	{
		std::cout << "Unable to open file for reading" << std::endl;
		std::exit(1);
	}

	char* FileData = new char[size];

	fIn.read(FileData, size);
	fIn.close();


	sha1::SHA1 Hash;
	
	if( UseSalt )
	{
		Hash.processBytes(Salt,34);
	}

	Hash.processBytes(FileData, size);
	delete [] FileData;
	uint32_t digest[5];
	Hash.getDigest(digest);

	char HashResult[48];
	sprintf(HashResult, "%08X%08X%08X%08X%08X", digest[0], digest[1], digest[2], digest[3], digest[4]);
	std::cout << HashResult << std::endl;

	return 0;
}

TinySHA1.hpp

/*
*
* TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based
* on the implementation in boost::uuid::details.
*
* SHA1 Wikipedia Page: http://en.wikipedia.org/wiki/SHA-1
*
* Copyright (c) 2012-22 SAURAV MOHAPATRA <[email protected]>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef _TINY_SHA1_HPP_
#define _TINY_SHA1_HPP_
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stdint.h>
namespace sha1
{
	class SHA1
	{
	public:
		typedef uint32_t digest32_t[5];
		typedef uint8_t digest8_t[20];
		inline static uint32_t LeftRotate(uint32_t value, size_t count) {
			return (value << count) ^ (value >> (32 - count));
		}
		SHA1(){ reset(); }
		virtual ~SHA1() {}
		SHA1(const SHA1& s) { *this = s; }
		const SHA1& operator = (const SHA1& s) {
			memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t));
			memcpy(m_block, s.m_block, 64);
			m_blockByteIndex = s.m_blockByteIndex;
			m_byteCount = s.m_byteCount;
			return *this;
		}
		SHA1& reset() {
			m_digest[0] = 0x67452301;
			m_digest[1] = 0xEFCDAB89;
			m_digest[2] = 0x98BADCFE;
			m_digest[3] = 0x10325476;
			m_digest[4] = 0xC3D2E1F0;
			m_blockByteIndex = 0;
			m_byteCount = 0;
			return *this;
		}
		SHA1& processByte(uint8_t octet) {
			this->m_block[this->m_blockByteIndex++] = octet;
			++this->m_byteCount;
			if( m_blockByteIndex == 64 ) {
				this->m_blockByteIndex = 0;
				processBlock();
			}
			return *this;
		}
		SHA1& processBlock(const void* const start, const void* const end) {
			const uint8_t* begin = static_cast<const uint8_t*>(start);
			const uint8_t* finish = static_cast<const uint8_t*>(end);
			while( begin != finish ) {
				processByte(*begin);
				begin++;
			}
			return *this;
		}
		SHA1& processBytes(const void* const data, size_t len) {
			const uint8_t* block = static_cast<const uint8_t*>(data);
			processBlock(block, block + len);
			return *this;
		}
		const uint32_t* getDigest(digest32_t digest) {
			size_t bitCount = this->m_byteCount * 8;
			processByte(0x80);
			if( this->m_blockByteIndex > 56 ) {
				while( m_blockByteIndex != 0 ) {
					processByte(0);
				}
				while( m_blockByteIndex < 56 ) {
					processByte(0);
				}
			}
			else {
				while( m_blockByteIndex < 56 ) {
					processByte(0);
				}
			}
			processByte(0);
			processByte(0);
			processByte(0);
			processByte(0);
			processByte(static_cast<unsigned char>((bitCount >> 24) & 0xFF));
			processByte(static_cast<unsigned char>((bitCount >> 16) & 0xFF));
			processByte(static_cast<unsigned char>((bitCount >> 8) & 0xFF));
			processByte(static_cast<unsigned char>((bitCount)& 0xFF));

			memcpy(digest, m_digest, 5 * sizeof(uint32_t));
			return digest;
		}
		const uint8_t* getDigestBytes(digest8_t digest) {
			digest32_t d32;
			getDigest(d32);
			size_t di = 0;
			digest[di++] = ((d32[0] >> 24) & 0xFF);
			digest[di++] = ((d32[0] >> 16) & 0xFF);
			digest[di++] = ((d32[0] >> 8) & 0xFF);
			digest[di++] = ((d32[0]) & 0xFF);

			digest[di++] = ((d32[1] >> 24) & 0xFF);
			digest[di++] = ((d32[1] >> 16) & 0xFF);
			digest[di++] = ((d32[1] >> 8) & 0xFF);
			digest[di++] = ((d32[1]) & 0xFF);

			digest[di++] = ((d32[2] >> 24) & 0xFF);
			digest[di++] = ((d32[2] >> 16) & 0xFF);
			digest[di++] = ((d32[2] >> 8) & 0xFF);
			digest[di++] = ((d32[2]) & 0xFF);

			digest[di++] = ((d32[3] >> 24) & 0xFF);
			digest[di++] = ((d32[3] >> 16) & 0xFF);
			digest[di++] = ((d32[3] >> 8) & 0xFF);
			digest[di++] = ((d32[3]) & 0xFF);

			digest[di++] = ((d32[4] >> 24) & 0xFF);
			digest[di++] = ((d32[4] >> 16) & 0xFF);
			digest[di++] = ((d32[4] >> 8) & 0xFF);
			digest[di++] = ((d32[4]) & 0xFF);
			return digest;
		}

	protected:
		void processBlock() {
			uint32_t w[80];
			for( size_t i = 0; i < 16; i++ ) {
				w[i] = (m_block[i * 4 + 0] << 24);
				w[i] |= (m_block[i * 4 + 1] << 16);
				w[i] |= (m_block[i * 4 + 2] << 8);
				w[i] |= (m_block[i * 4 + 3]);
			}
			for( size_t i = 16; i < 80; i++ ) {
				w[i] = LeftRotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1);
			}

			uint32_t a = m_digest[0];
			uint32_t b = m_digest[1];
			uint32_t c = m_digest[2];
			uint32_t d = m_digest[3];
			uint32_t e = m_digest[4];

			for( std::size_t i = 0; i<80; ++i ) {
				uint32_t f = 0;
				uint32_t k = 0;

				if( i<20 ) {
					f = (b & c) | (~b & d);
					k = 0x5A827999;
				}
				else if( i<40 ) {
					f = b ^ c ^ d;
					k = 0x6ED9EBA1;
				}
				else if( i<60 ) {
					f = (b & c) | (b & d) | (c & d);
					k = 0x8F1BBCDC;
				}
				else {
					f = b ^ c ^ d;
					k = 0xCA62C1D6;
				}
				uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i];
				e = d;
				d = c;
				c = LeftRotate(b, 30);
				b = a;
				a = temp;
			}

			m_digest[0] += a;
			m_digest[1] += b;
			m_digest[2] += c;
			m_digest[3] += d;
			m_digest[4] += e;
		}
	private:
		digest32_t m_digest;
		uint8_t m_block[64];
		size_t m_blockByteIndex;
		size_t m_byteCount;
	};
}
#endif