cryptopp 0.0.4

data/ext/jhash_t.h

@@ -0,0 +1,121 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JHASH_T_H__
+#define __JHASH_T_H__
+
+#include "jhash.h"
+
+#include "files.h"
+
+using namespace CryptoPP;
+
+template <typename HASH, enum HashEnum TYPE>
+class JHash_Template : public JHash
+{
+	public:
+		JHash_Template(string plaintext = "");
+		enum HashEnum getHashType() const;
+		bool hash();
+		bool validate();
+		bool validate(string plaintext, string hashtext);
+		string hashRubyIO(VALUE* in, bool hex = true);
+
+		/* This is deprecated. It was used before using RubyIO. Use it
+		   if you're using this code in something other than the CryptoPP Ruby
+		   extension... */
+		//string hashFile(const string filename, bool hex = true);
+};
+
+#define HASH_TYPE TYPE
+
+template <typename HASH, enum HashEnum TYPE>
+JHash_Template<HASH, TYPE>::JHash_Template(string plaintext) : JHash(plaintext)
+{
+	itsHashModule = new HASH;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+HashEnum JHash_Template<HASH, TYPE>::getHashType() const
+{
+	return TYPE;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHash_Template<HASH, TYPE>::hash()
+{
+	itsHashtext.erase();
+
+	StringSource s(itsPlaintext, true, new HashFilter(*itsHashModule, new StringSink(itsHashtext)));
+	return true;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHash_Template<HASH, TYPE>::validate()
+{
+	return validate(itsPlaintext, itsHashtext);
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHash_Template<HASH, TYPE>::validate(string plaintext, string hashtext)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	return itsHashModule->VerifyDigest((const byte*) hashtext.data(), (const byte*) plaintext.data(), plaintext.length());
+}
+
+template <typename HASH, enum HashEnum TYPE>
+string JHash_Template<HASH, TYPE>::hashRubyIO(VALUE* in, bool hex)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	string retval;
+	try {
+		if (hex) {
+			RubyIOSource f(&in, true, new HashFilter(*itsHashModule, new HexEncoder(new StringSink(retval), false)));
+		}
+		else {
+			RubyIOSource f(&in, true, new HashFilter(*itsHashModule, new StringSink(retval)));
+		}
+	}
+	catch (Exception e) {
+		throw e;
+	}
+	return retval;
+}
+
+
+/* This is deprecated. It was used before using RubyIO. Use it
+   if you're using this code in something other than the CryptoPP Ruby
+   extension... */
+/*template <typename HASH, enum HashEnum TYPE>
+string JHash_Template<HASH, TYPE>::hashFile(const string filename, bool hex)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	string retval;
+	try {
+		if (hex) {
+			FileSource f(filename.c_str(), true, new HashFilter(*itsHashModule, new HexEncoder(new StringSink(retval), false)));
+		}
+		else {
+			FileSource f(filename.c_str(), true, new HashFilter(*itsHashModule, new StringSink(retval)));
+		}
+	}
+	catch (FileStore::OpenErr e) {
+		throw e;
+	}
+	return retval;
+}*/
+
+#endif

data/ext/jhaval.h

@@ -0,0 +1,64 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JHAVAL_H__
+#define __JHAVAL_H__
+
+#include "jconfig.h"
+
+#if ENABLED_HAVAL_HASH || ENABLED_HAVAL3_HASH || ENABLED_HAVAL4_HASH || ENABLED_HAVAL5_HASH
+
+#include "jhash_t.h"
+
+// Crypto++ headers...
+
+#include "haval.h"
+
+using namespace CryptoPP;
+
+#if ENABLED_HAVAL_HASH
+class JHAVAL : public JHash_Template<HAVAL, HAVAL_HASH>
+{
+	public:
+		JHAVAL(string plaintext = "") : JHash_Template<HAVAL, HAVAL_HASH>(plaintext) { }
+
+		static string getHashName() { return "HAVAL"; }
+};
+#endif
+
+#if ENABLED_HAVAL3_HASH
+class JHAVAL3 : public JHash_Template<HAVAL3, HAVAL3_HASH>
+{
+	public:
+		JHAVAL3(string plaintext = "") : JHash_Template<HAVAL3, HAVAL3_HASH>(plaintext) { }
+
+		static string getHashName() { return "HAVAL3"; }
+};
+#endif
+
+#if ENABLED_HAVAL4_HASH
+class JHAVAL4 : public JHash_Template<HAVAL4, HAVAL4_HASH>
+{
+	public:
+		JHAVAL4(string plaintext = "") : JHash_Template<HAVAL4, HAVAL4_HASH>(plaintext) { }
+
+		static string getHashName() { return "HAVAL4"; }
+};
+#endif
+
+#if ENABLED_HAVAL5_HASH
+class JHAVAL5 : public JHash_Template<HAVAL5, HAVAL5_HASH>
+{
+	public:
+		JHAVAL5(string plaintext = "") : JHash_Template<HAVAL5, HAVAL5_HASH>(plaintext) { }
+
+		static string getHashName() { return "HAVAL5"; }
+};
+#endif
+
+#endif
+#endif

data/ext/jhelpers.cpp

@@ -0,0 +1,90 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "jhelpers.h"
+
+using namespace CryptoPP;
+
+string bin2hex(const string bin, const bool uppercase)
+{
+	string retval;
+	StringSource(bin, true, new HexEncoder(new StringSink(retval), uppercase));
+	return retval;
+}
+
+string hex2bin(const string hex)
+{
+	string retval;
+	StringSource(hex, true, new HexDecoder(new StringSink(retval)));
+	return retval;
+}
+
+char* bin2hex(const char* bin, size_t length, const bool uppercase)
+{
+	char* retval = new char[length * 2 + 1];
+	StringSource(bin, true, new HexEncoder(new ArraySink((byte*) retval, length * 2), uppercase));
+	return retval;
+}
+
+char* hex2bin(const char* hex, size_t length)
+{
+	char* retval = new char[length / 2 + 1];
+	StringSource(hex, true, new HexDecoder(new ArraySink((byte*) retval, length / 2)));
+	return retval;
+}
+
+string generateIV(const unsigned int size, const enum RNGEnum rng)
+{
+	string retval;
+	RandomNumberGenerator* randPool = NULL;
+
+	#ifdef NONBLOCKING_RNG_AVAILABLE
+	if (rng == NON_BLOCKING_RNG) {
+		randPool = new NonblockingRng;
+	}
+	#endif
+
+	#if defined(NONBLOCKING_RNG_AVAILABLE) && defined(BLOCKING_RNG_AVAILABLE)
+	else
+	#endif
+
+	#ifdef BLOCKING_RNG_AVAILABLE
+	if (rng == BLOCKING_RNG) {
+		randPool = new BlockingRng;
+	}
+	#endif
+
+	if (rng == RAND_RNG) {
+		for (unsigned int i = 0; i < size; i++) {
+			retval += (char)(255.0 * rand() / RAND_MAX);
+		}
+	}
+	else if (randPool != NULL) {
+		for (unsigned int i = 0; i < size; i++) {
+			retval += (char) randPool->GenerateByte();
+		}
+		delete randPool;
+	}
+
+	return retval;
+}
+
+unsigned int checkBounds(unsigned int length, unsigned int min, unsigned int max, unsigned short int multiple)
+{
+	if (min == max) {
+		return min;
+	}
+	else if (length < min) {
+		return min;
+	}
+	else if (length > max) {
+		return max;
+	}
+	else {
+		return (length + multiple - 1) - ((length + multiple - 1) % multiple);
+	}
+}

data/ext/jhelpers.h

@@ -0,0 +1,38 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JHELPERS_H__
+#define __JHELPERS_H__
+
+#include <string>
+#include <cctype>
+
+// Crypto++ headers...
+
+#include "hex.h"
+#include "osrng.h"
+
+#include "jconstants.h"
+
+typedef unsigned char byte;
+
+using namespace std;
+
+string bin2hex(const string bin, const bool uppercase = false);
+string hex2bin(const string hex);
+
+char* bin2hex(const char* bin, size_t length, const bool uppercase = false);
+char* hex2bin(const char* hex, size_t length);
+
+string generateIV(const unsigned int size, const enum RNGEnum rng = DEFAULT_RNG);
+
+// used to check the bounds of things like keylengths,
+// rounds to perform, etc.:
+
+unsigned int checkBounds(unsigned int length, unsigned int min, unsigned int max, unsigned short int multiple = 1);
+
+#endif

data/ext/jhmac.cpp

@@ -0,0 +1,44 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "jhmac.h"
+
+unsigned int JHMAC::getKeylength() const
+{
+	return itsKeylength;
+}
+
+string JHMAC::getKey(const bool hex) const
+{
+	if (hex) {
+		return bin2hex(itsKey);
+	}
+	else {
+		return itsKey;
+	}
+}
+
+unsigned int JHMAC::setKeylength(const unsigned int keylength)
+{
+	itsKeylength = checkBounds(keylength, 0, UINT_MAX);
+
+	return itsKeylength;
+}
+
+unsigned int JHMAC::setKey(const string key, const bool hex)
+{
+	if (hex) {
+		itsKey = hex2bin(key);
+	}
+	else {
+		itsKey = key;
+	}
+
+	itsKey.resize(setKeylength(itsKey.length()));
+
+	return itsKeylength;
+}

data/ext/jhmac.h

@@ -0,0 +1,34 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JHMAC_H__
+#define __JHMAC_H__
+
+#include "jhash.h"
+
+using namespace CryptoPP;
+
+class JHMAC : public JHash
+{
+	public:
+		JHMAC(string plaintext = "") : JHash(plaintext)
+		{
+			itsKeylength = 16;
+		}
+
+		unsigned int getKeylength() const;
+		string getKey(const bool hex = false) const;
+
+		unsigned int setKeylength(const unsigned int keylength);
+		unsigned int setKey(const string key, const bool hex = false);
+
+	protected:
+		string itsKey;
+		unsigned int itsKeylength;
+};
+
+#endif

data/ext/jhmac_t.h

@@ -0,0 +1,125 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JHMAC_T_H__
+#define __JHMAC_T_H__
+
+#include "jhmac.h"
+
+// Crypto++ headers...
+
+#include "hmac.h"
+
+using namespace CryptoPP;
+
+template <typename HASH, enum HashEnum TYPE>
+class JHMAC_Template : public JHMAC
+{
+	public:
+		JHMAC_Template(string plaintext = "");
+		inline enum HashEnum getHashType() const;
+		bool hash();
+		bool validate();
+		bool validate(string plaintext, string hashtext);
+		string hashRubyIO(VALUE* in, bool hex = true);
+
+		/* This is deprecated. It was used before using php_streams. Use it
+		   if you're using this code in something other than the cryptopp PHP
+		   extension...*/
+		//string hashFile(const string filename, bool hex = true);
+};
+
+template <typename HASH, enum HashEnum TYPE>
+JHMAC_Template<HASH, TYPE>::JHMAC_Template(string plaintext) : JHMAC(plaintext)
+{
+	itsHashModule = new HMAC<HASH>;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+HashEnum JHMAC_Template<HASH, TYPE>::getHashType() const
+{
+	return TYPE;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHMAC_Template<HASH, TYPE>::hash()
+{
+	((HMAC<HASH>*) itsHashModule)->SetKey((byte*) itsKey.data(), itsKeylength);
+	itsHashtext.erase();
+	StringSource s(itsPlaintext, true, new HashFilter(*itsHashModule, new StringSink(itsHashtext)));
+	return true;
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHMAC_Template<HASH, TYPE>::validate()
+{
+	return validate(itsPlaintext, itsHashtext);
+}
+
+template <typename HASH, enum HashEnum TYPE>
+bool JHMAC_Template<HASH, TYPE>::validate(string plaintext, string hashtext)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	((HMAC<HASH>*) itsHashModule)->SetKey((byte*) itsKey.data(), itsKeylength);
+
+	return itsHashModule->VerifyDigest((const byte*) hashtext.data(), (const byte*) plaintext.data(), plaintext.length());
+}
+
+template <typename HASH, enum HashEnum TYPE>
+string JHMAC_Template<HASH, TYPE>::hashRubyIO(VALUE* in, bool hex)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	((HMAC<HASH>*) itsHashModule)->SetKey((byte*) itsKey.data(), itsKeylength);
+	string retval;
+	try {
+		if (hex) {
+			RubyIOSource f(&in, true, new HashFilter(*itsHashModule, new HexEncoder(new StringSink(retval), false)));
+		}
+		else {
+			RubyIOSource f(&in, true, new HashFilter(*itsHashModule, new StringSink(retval)));
+		}
+	}
+	catch (Exception e) {
+		throw e;
+	}
+	return retval;
+}
+
+
+/* This is deprecated. It was used before using php_streams. Use it
+   if you're using this code in something other than the cryptopp PHP
+   extension... */
+/*template <typename HASH, enum HashEnum TYPE>
+string JHMAC_Template<HASH, TYPE>::hashFile(const string filename, bool hex)
+{
+	if (itsHashModule == NULL) {
+		throw;
+	}
+
+	((HMAC<HASH>*) itsHashModule)->SetKey((byte*) itsKey.data(), itsKeylength);
+	string retval;
+	try {
+		if (hex) {
+			FileSource f(filename.c_str(), true, new HashFilter(*itsHashModule, new HexEncoder(new StringSink(retval), false)));
+		}
+		else {
+			FileSource f(filename.c_str(), true, new HashFilter(*itsHashModule, new StringSink(retval)));
+		}
+	}
+	catch (FileStore::OpenErr e) {
+		throw e;
+	}
+	return retval;
+}*/
+
+#endif