cryptopp 0.0.4 → 0.0.5

data/ext/jsha3_blocksizes.h

@@ -0,0 +1,73 @@
+// sha3.h - written and placed in the public domain by Wei Dai
+//
+// This is a patched version of sha3.h that includes definitions for the
+// BLOCKSIZE constants that appear to be missing from the header file.
+// See http://sourceforge.net/apps/trac/cryptopp/ticket/31 for details.
+
+#ifndef CRYPTOPP_JSHA3_BLOCKSIZES_H
+#define CRYPTOPP_JSHA3_BLOCKSIZES_H
+
+#include "cryptlib.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+/// <a href="http://en.wikipedia.org/wiki/SHA-3">SHA-3</a>
+class SHA3 : public HashTransformation
+{
+public:
+  SHA3(unsigned int digestSize) : m_digestSize(digestSize) {Restart();}
+  unsigned int DigestSize() const {return m_digestSize;}
+  std::string AlgorithmName() const {return "SHA-3-" + IntToString(m_digestSize*8);}
+  unsigned int OptimalDataAlignment() const {return GetAlignmentOf<word64>();}
+
+  void Update(const byte *input, size_t length);
+  void Restart();
+  void TruncatedFinal(byte *hash, size_t size);
+
+protected:
+  inline unsigned int r() const {return 200 - 2 * m_digestSize;}
+
+  FixedSizeSecBlock<word64, 25> m_state;
+  unsigned int m_digestSize, m_counter;
+};
+
+class SHA3_224 : public SHA3
+{
+public:
+  CRYPTOPP_CONSTANT(DIGESTSIZE = 28)
+  CRYPTOPP_CONSTANT(BLOCKSIZE = 144)
+  SHA3_224() : SHA3(DIGESTSIZE) {}
+  static const char * StaticAlgorithmName() {return "SHA-3-224";}
+};
+
+class SHA3_256 : public SHA3
+{
+public:
+  CRYPTOPP_CONSTANT(DIGESTSIZE = 32)
+  CRYPTOPP_CONSTANT(BLOCKSIZE = 136)
+  SHA3_256() : SHA3(DIGESTSIZE) {}
+  static const char * StaticAlgorithmName() {return "SHA-3-256";}
+};
+
+class SHA3_384 : public SHA3
+{
+public:
+  CRYPTOPP_CONSTANT(DIGESTSIZE = 48)
+  CRYPTOPP_CONSTANT(BLOCKSIZE = 104)
+  SHA3_384() : SHA3(DIGESTSIZE) {}
+  static const char * StaticAlgorithmName() {return "SHA-3-384";}
+};
+
+class SHA3_512 : public SHA3
+{
+public:
+  CRYPTOPP_CONSTANT(DIGESTSIZE = 64)
+  CRYPTOPP_CONSTANT(BLOCKSIZE = 72)
+  SHA3_512() : SHA3(DIGESTSIZE) {}
+  static const char * StaticAlgorithmName() {return "SHA-3-512";}
+};
+
+NAMESPACE_END
+
+#endif

data/ext/jshacal2.cpp

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

data/ext/jshacal2.h

@@ -1,8 +1,8 @@
 
 /*
- * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
- * Crypto++ copyright (c) 1995-2010 Wei Dai
- * See COPYING for the extact license
+ * Copyright (c) 2002-2014 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2013 Wei Dai
+ * See MIT-LICENSE for the extact license
  */
 
 #ifndef __JSHACAL2_H__
@@ -22,9 +22,9 @@ using namespace CryptoPP;
 
 class JSHACAL2 : public JCipher_Template<SHACAL2_Info, SHACAL2_CIPHER>
 {
-	protected:
-		BlockCipher* getEncryptionObject();
-		BlockCipher* getDecryptionObject();
+  protected:
+    BlockCipher* getEncryptionObject();
+    BlockCipher* getDecryptionObject();
 };
 
 #endif

data/ext/jshark.cpp

@@ -1,24 +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
+ * Copyright (c) 2002-2014 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2013 Wei Dai
+ * See MIT-LICENSE 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);
+  return new SHARKEncryption((byte*) itsKey.data(), itsKeylength, itsRounds);
 }
 
 BlockCipher* JSHARK::getDecryptionObject()
 {
-	return new SHARKDecryption((byte*) itsKey.data(), itsKeylength, itsRounds);
+  return new SHARKDecryption((byte*) itsKey.data(), itsKeylength, itsRounds);
 }
 
 #endif
-#endif

data/ext/jshark.h

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

data/ext/jsink.cpp

@@ -1,90 +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
+ * Copyright (c) 2002-2014 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2013 Wei Dai
+ * See MIT-LICENSE 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;
+  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;
-	}
+  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;
-	}
+  if (!m_stream) {
+    transferBytes = 0;
+    return 0;
+  }
 
-	lword size = transferBytes;
-	transferBytes = 0;
+  lword size = transferBytes;
+  transferBytes = 0;
 
-	if (m_waiting) {
-		goto output;
-	}
+  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);
+  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;
+      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_LEN(buffer));
+      m_len = RSTRING_LEN(buffer);
+    }
+    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);
+  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");
-	}
+  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));
+  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);
-	}
+  if (messageEnd) {
+    rb_funcall(*m_stream, rb_intern("flush"), 0);
+  }
 
-	return 0;
+  return 0;
 }

data/ext/jsink.h

@@ -1,8 +1,8 @@
 
 /*
- * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
- * Crypto++ copyright (c) 1995-2010 Wei Dai
- * See COPYING for the extact license
+ * Copyright (c) 2002-2014 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2013 Wei Dai
+ * See MIT-LICENSE for the extact license
  */
 
 #ifndef __JSINK_H__
@@ -13,142 +13,146 @@
 
 extern "C" {
 #include "ruby.h"
+
+#if defined(RUBY_VERSION_CODE) && RUBY_VERSION_CODE >= 190
+#include "ruby/io.h"
+#else
 #include "rubyio.h"
+#endif
 }
 
 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;
+  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 abstract methods are purposely no-ops here...
+    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();
-		}
+  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;
+  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