cryptopp 0.0.4

data/ext/jserpent.cpp

@@ -0,0 +1,22 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "jserpent.h"
+
+#if ENABLED_SERPENT_CIPHER
+
+BlockCipher* JSerpent::getEncryptionObject()
+{
+	return new SerpentEncryption((byte*) itsKey.data(), itsKeylength);
+}
+
+BlockCipher* JSerpent::getDecryptionObject()
+{
+	return new SerpentDecryption((byte*) itsKey.data(), itsKeylength);
+}
+
+#endif

data/ext/jserpent.h

@@ -0,0 +1,31 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JSERPENT_H__
+#define __JSERPENT_H__
+
+#include "jconfig.h"
+
+#if ENABLED_SERPENT_CIPHER
+
+#include "jcipher_t.h"
+
+// Crypto++ headers...
+
+#include "serpent.h"
+
+using namespace CryptoPP;
+
+class JSerpent : public JCipher_Template<Serpent_Info, SERPENT_CIPHER>
+{
+	protected:
+		BlockCipher* getEncryptionObject();
+		BlockCipher* getDecryptionObject();
+};
+
+#endif
+#endif

data/ext/jsha.h

@@ -0,0 +1,122 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JSHA_H__
+#define __JSHA_H__
+
+#include "jconfig.h"
+
+#if ENABLED_SHA1_HASH || ENABLED_SHA256_HASH || (defined(WORD64_AVAILABLE) && (ENABLED_SHA384_HASH || ENABLED_SHA512_HASH)) || \
+    ENABLED_SHA1_HMAC || ENABLED_SHA256_HMAC || (defined(WORD64_AVAILABLE) && (ENABLED_SHA384_HMAC || ENABLED_SHA512_HMAC))
+
+#if ENABLED_SHA1_HASH || ENABLED_SHA256_HASH || (defined(WORD64_AVAILABLE) && (ENABLED_SHA384_HASH || ENABLED_SHA512_HASH))
+#include "jhash_t.h"
+#endif
+
+#if ENABLED_SHA1_HMAC || ENABLED_SHA256_HMAC || (defined(WORD64_AVAILABLE) && (ENABLED_SHA384_HMAC || ENABLED_SHA512_HMAC))
+#include "jhmac_t.h"
+#endif
+
+
+// Crypto++ headers...
+
+#include "sha.h"
+
+using namespace CryptoPP;
+
+#if ENABLED_SHA1_HASH
+class JSHA1 : public JHash_Template<SHA1, SHA1_HASH>
+{
+	public:
+		JSHA1(string plaintext = "") : JHash_Template<SHA1, SHA1_HASH>(plaintext) { }
+
+		static string getHashName() { return "SHA1"; }
+};
+
+typedef JSHA1 JSHA;
+#endif
+
+#if ENABLED_SHA256_HASH
+class JSHA256 : public JHash_Template<SHA256, SHA256_HASH>
+{
+	public:
+		JSHA256(string plaintext = "") : JHash_Template<SHA256, SHA256_HASH>(plaintext) { }
+
+		static string getHashName() { return "SHA-256"; }
+};
+#endif
+
+#ifdef WORD64_AVAILABLE
+#if ENABLED_SHA384_HASH
+class JSHA384 : public JHash_Template<SHA384, SHA384_HASH>
+{
+	public:
+		JSHA384(string plaintext = "") : JHash_Template<SHA384, SHA384_HASH>(plaintext) { }
+
+		static string getHashName() { return "SHA-384"; }
+};
+#endif
+
+#if ENABLED_SHA512_HASH
+class JSHA512 : public JHash_Template<SHA512, SHA512_HASH>
+{
+	public:
+		JSHA512(string plaintext = "") : JHash_Template<SHA512, SHA512_HASH>(plaintext) { }
+
+		static string getHashName() { return "SHA-512"; }
+};
+#endif
+#endif
+
+
+#if ENABLED_SHA1_HMAC
+class JSHA1_HMAC : public JHMAC_Template<SHA1, SHA1_HMAC>
+{
+	public:
+		JSHA1_HMAC(string plaintext = "") : JHMAC_Template<SHA1, SHA1_HMAC>(plaintext) { }
+
+		static string getHashName() { return "SHA1-HMAC"; }
+};
+
+typedef JSHA1_HMAC JSHA_HMAC;
+#endif
+
+#if ENABLED_SHA256_HMAC
+class JSHA256_HMAC : public JHMAC_Template<SHA256, SHA256_HMAC>
+{
+	public:
+		JSHA256_HMAC(string plaintext = "") : JHMAC_Template<SHA256, SHA256_HMAC>(plaintext) { }
+
+		static string getHashName() { return "SHA-256-HMAC"; }
+};
+#endif
+
+#ifdef WORD64_AVAILABLE
+#if ENABLED_SHA384_HMAC
+class JSHA384_HMAC : public JHMAC_Template<SHA384, SHA384_HMAC>
+{
+	public:
+		JSHA384_HMAC(string plaintext = "") : JHMAC_Template<SHA384, SHA384_HMAC>(plaintext) { }
+
+		static string getHashName() { return "SHA-384-HMAC"; }
+};
+#endif
+
+#if ENABLED_SHA512_HMAC
+class JSHA512_HMAC : public JHMAC_Template<SHA512, SHA512_HMAC>
+{
+	public:
+		JSHA512_HMAC(string plaintext = "") : JHMAC_Template<SHA512, SHA512_HMAC>(plaintext) { }
+
+		static string getHashName() { return "SHA-512-HMAC"; }
+};
+#endif
+#endif
+
+
+#endif
+#endif

data/ext/jshacal2.cpp

@@ -0,0 +1,22 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "jshacal2.h"
+
+#if ENABLED_SHACAL2_CIPHER
+
+BlockCipher* JSHACAL2::getEncryptionObject()
+{
+	return new SHACAL2Encryption((byte*) itsKey.data(), itsKeylength);
+}
+
+BlockCipher* JSHACAL2::getDecryptionObject()
+{
+	return new SHACAL2Decryption((byte*) itsKey.data(), itsKeylength);
+}
+
+#endif

data/ext/jshacal2.h

@@ -0,0 +1,31 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JSHACAL2_H__
+#define __JSHACAL2_H__
+
+#include "jconfig.h"
+
+#if ENABLED_SHACAL2_CIPHER
+
+#include "jcipher_t.h"
+
+// Crypto++ headers...
+
+#include "shacal2.h"
+
+using namespace CryptoPP;
+
+class JSHACAL2 : public JCipher_Template<SHACAL2_Info, SHACAL2_CIPHER>
+{
+	protected:
+		BlockCipher* getEncryptionObject();
+		BlockCipher* getDecryptionObject();
+};
+
+#endif
+#endif

data/ext/jshark.cpp

@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "jshark.h"
+
+#ifdef WORD64_AVAILABLE
+#if ENABLED_SHARK_CIPHER
+
+BlockCipher* JSHARK::getEncryptionObject()
+{
+	return new SHARKEncryption((byte*) itsKey.data(), itsKeylength, itsRounds);
+}
+
+BlockCipher* JSHARK::getDecryptionObject()
+{
+	return new SHARKDecryption((byte*) itsKey.data(), itsKeylength, itsRounds);
+}
+
+#endif
+#endif

data/ext/jshark.h

@@ -0,0 +1,33 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JSHARK_H__
+#define __JSHARK_H__
+
+#include "jconfig.h"
+
+#ifdef WORD64_AVAILABLE
+#if ENABLED_SHARK_CIPHER
+
+#include "jcipher_t.h"
+
+// Crypto++ headers...
+
+#include "shark.h"
+
+using namespace CryptoPP;
+
+class JSHARK : public JCipher_Template<SHARK_Info, SHARK_CIPHER, 6, 2, INT_MAX>
+{
+	protected:
+		BlockCipher* getEncryptionObject();
+		BlockCipher* getDecryptionObject();
+};
+
+#endif
+#endif
+#endif

data/ext/jsink.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 "jsink.h"
+
+void RubyIOStore::StoreInitialize(const NameValuePairs& parameters)
+{
+	m_stream = NULL;
+	parameters.GetValue(Name::InputStreamPointer(), m_stream);
+	m_waiting = false;
+}
+
+size_t RubyIOStore::Peek(byte& outByte) const
+{
+	if (!m_stream || rb_funcall(*m_stream, rb_intern("eof?"), 0)) {
+		return 0;
+	}
+	else {
+		return 1;
+	}
+}
+
+
+size_t RubyIOStore::TransferTo2(BufferedTransformation& target, CryptoPP::lword& transferBytes, const std::string& channel, bool blocking)
+{
+	if (!m_stream) {
+		transferBytes = 0;
+		return 0;
+	}
+
+	lword size = transferBytes;
+	transferBytes = 0;
+
+	if (m_waiting) {
+		goto output;
+	}
+
+	while (size && !RTEST(rb_funcall(*m_stream, rb_intern("eof?"), 0))) {
+		{
+			VALUE buffer;
+			size_t spaceSize = 1024;
+			m_space = HelpCreatePutSpace(target, channel, 1, UnsignedMin(size_t(0) - 1, size), spaceSize);
+
+			buffer = rb_funcall(*m_stream, rb_intern("read"), 1, UINT2NUM(STDMIN(size, (lword) spaceSize)));
+			if (TYPE(buffer) != T_STRING) {
+				throw ReadErr();
+			}
+			memcpy(m_space, StringValuePtr(buffer), RSTRING(buffer)->len);
+			m_len = RSTRING(buffer)->len;
+		}
+		size_t blockedBytes;
+		output:
+			blockedBytes = target.ChannelPutModifiable2(channel, m_space, m_len, 0, blocking);
+			m_waiting = blockedBytes > 0;
+			if (m_waiting) {
+				return blockedBytes;
+			}
+			size -= m_len;
+			transferBytes += m_len;
+	}
+	if (!RTEST(rb_funcall(*m_stream, rb_intern("eof?"), 0))) {
+		throw ReadErr();
+	}
+	return 0;
+}
+
+void RubyIOSink::IsolatedInitialize(const NameValuePairs& parameters)
+{
+	m_stream = NULL;
+	parameters.GetValue(Name::OutputStreamPointer(), m_stream);
+}
+
+size_t RubyIOSink::Put2(const byte* inString, size_t length, int messageEnd, bool blocking)
+{
+	if (!m_stream) {
+		throw Err("RubyIOSink: output stream not opened");
+	}
+
+	rb_funcall(*m_stream, rb_intern("write"), 1, rb_str_new((const char*) inString, length));
+
+	if (messageEnd) {
+		rb_funcall(*m_stream, rb_intern("flush"), 0);
+	}
+
+	return 0;
+}

data/ext/jsink.h

@@ -0,0 +1,154 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __JSINK_H__
+#define __JSINK_H__
+
+#include "filters.h"
+#include "argnames.h"
+
+extern "C" {
+#include "ruby.h"
+#include "rubyio.h"
+}
+
+using namespace CryptoPP;
+
+class RubyIOStore : public Store, private FilterPutSpaceHelper
+{
+	public:
+		class Err : public Exception
+		{
+			public:
+				Err(const std::string& s) : Exception(IO_ERROR, s) {}
+		};
+
+		class OpenErr : public Err
+		{
+			public:
+				OpenErr(const std::string& filename) : Err("RubyIOStore: error opening IO stream for reading: " + filename) {}
+		};
+
+		class ReadErr : public Err
+		{
+			public:
+				ReadErr() : Err("RubyIOStore: error reading IO stream") {}
+		};
+
+		RubyIOStore() {}
+
+		RubyIOStore(VALUE** in)
+		{
+			StoreInitialize(MakeParameters(Name::InputStreamPointer(), *in));
+		}
+
+		RubyIOStore(const char* filename)
+		{
+			StoreInitialize(MakeParameters(Name::InputFileName(), filename));
+		}
+
+		VALUE* GetStream()
+		{
+			return m_stream;
+		}
+
+		size_t Peek(byte &outByte) const;
+		size_t TransferTo2(BufferedTransformation &target, CryptoPP::lword &transferBytes, const std::string &channel = NULL_CHANNEL, bool blocking = true);
+
+		// These methods aren't actually used in the PHP extension, but we need to implement them anyway
+		// because they're abstract...
+		size_t CopyRangeTo2(BufferedTransformation& target, CryptoPP::lword& begin, CryptoPP::lword end = ULONG_MAX, const std::string& channel = NULL_CHANNEL, bool blocking = true) const { return 0; }
+		CryptoPP::lword MaxRetrievable() const { return 0L; }
+
+	private:
+		void StoreInitialize(const NameValuePairs &parameters);
+		VALUE* m_stream;
+
+		byte* m_space;
+		unsigned int m_len;
+		bool m_waiting;
+};
+
+class RubyIOSource : public SourceTemplate<RubyIOStore>
+{
+	public:
+		typedef RubyIOStore::Err Err;
+		typedef RubyIOStore::OpenErr OpenErr;
+		typedef RubyIOStore::ReadErr ReadErr;
+
+		RubyIOSource(BufferedTransformation* attachment = NULL) : SourceTemplate<RubyIOStore>(attachment) {}
+
+		RubyIOSource(VALUE** in, bool pumpAll, BufferedTransformation* attachment = NULL) : SourceTemplate<RubyIOStore>(attachment)
+		{
+			SourceInitialize(pumpAll, MakeParameters(Name::InputStreamPointer(), *in));
+		}
+
+		RubyIOSource(const char* filename, bool pumpAll, BufferedTransformation* attachment = NULL, bool binary = true) : SourceTemplate<RubyIOStore>(attachment)
+		{
+			SourceInitialize(pumpAll, MakeParameters(Name::InputFileName(), filename)(Name::InputBinaryMode(), binary));
+		}
+
+		VALUE* GetStream()
+		{
+			return m_store.GetStream();
+		}
+};
+
+
+class RubyIOSink : public Sink
+{
+	public:
+		class Err : public Exception
+		{
+			public:
+				Err(const std::string& s) : Exception(IO_ERROR, s) {}
+		};
+
+		class OpenErr : public Err
+		{
+			public:
+				OpenErr(const std::string &filename) : Err("RubyIOSink: error opening file for writing: " + filename) {}
+		};
+
+		class WriteErr : public Err
+		{
+			public:
+				WriteErr() : Err("RubyIOSink: error writing file") {}
+		};
+
+		RubyIOSink()
+		{
+			m_stream = NULL;
+		}
+
+		RubyIOSink(VALUE** out)
+		{
+			IsolatedInitialize(MakeParameters(Name::OutputStreamPointer(), *out));
+		}
+
+		RubyIOSink(const char* filename, bool binary = true)
+		{
+			IsolatedInitialize(MakeParameters(Name::OutputFileName(), filename)(Name::OutputBinaryMode(), binary));
+		}
+
+		VALUE* GetStream()
+		{
+			return m_stream;
+		}
+
+		void IsolatedInitialize(const NameValuePairs& parameters);
+		size_t Put2(const byte* inString, size_t length, int messageEnd, bool blocking);
+
+		// IsolatedFlush isn't actually used, but needs to be implemented because
+		// it's abstract...
+		bool IsolatedFlush(bool hardFlush, bool blocking) { return false; };
+
+	private:
+		VALUE* m_stream;
+};
+
+#endif