cryptopp 0.0.4

data/ext/cryptopp.cpp

@@ -0,0 +1,285 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#include "ruby.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "jbase.h"
+#include "jhash.h"
+#include "jconfig.h"
+
+#include "cryptopp_ruby_api.h"
+
+using namespace std;
+
+VALUE rb_mCryptoPP;
+VALUE rb_eCryptoPP_Error;
+VALUE rb_cCryptoPP_Cipher;
+VALUE rb_cCryptoPP_Digest;
+VALUE rb_cCryptoPP_Digest_HMAC;
+
+#define CIPHER_ALGORITHM_X(klass, r, c, s) \
+	VALUE rb_cCryptoPP_Cipher_ ## r ;
+#include "defs/ciphers.def"
+
+#define CHECKSUM_ALGORITHM_X(klass, r, c, s) \
+	VALUE rb_cCryptoPP_Digest_ ## r ;
+#include "defs/checksums.def"
+
+#define HASH_ALGORITHM_X(klass, r, c, s) \
+	VALUE rb_cCryptoPP_Digest_ ## r ;
+#include "defs/hashes.def"
+
+#define HMAC_ALGORITHM_X(klass, r, c, s) \
+	VALUE rb_cCryptoPP_Digest_HMAC_ ## r ;
+#include "defs/hmacs.def"
+
+/* Marking function for garbage collector. */
+void cipher_mark(JBase *c)
+{
+}
+
+/* Free up memory. */
+void cipher_free(JBase *c)
+{
+	delete c;
+}
+
+/* Marking function for garbage collector. */
+void hash_mark (JHash *c)
+{
+}
+
+/* Free up memory. */
+void hash_free (JHash *c)
+{
+	delete c;
+}
+
+
+#define CRYPTOPP_VALUE_FUNC(f) \
+	RUBY_METHOD_FUNC(f)
+#define CRYPTOPP_DEFINE_CONST(klass, n, c) \
+	rb_define_const(klass, n, INT2NUM(c));
+#define CRYPTOPP_MODULE_METHOD(m, n, f, a) \
+	rb_define_module_function(m, n, CRYPTOPP_VALUE_FUNC(f), a);
+#define CRYPTOPP_CLASS_METHOD(c, n, f, a) \
+	rb_define_method(rb_cCryptoPP_ ## c, n, CRYPTOPP_VALUE_FUNC(f), a);
+#define CRYPTOPP_MODULE_METHOD_ALIAS(m, n, o) \
+	rb_define_alias(rb_singleton_class(m), n, o);
+#define CRYPTOPP_CLASS_METHOD_ALIAS(c, n, o) \
+	rb_define_alias(rb_cCryptoPP_ ## c, n, o);
+
+/* The extension initialization function. */
+extern "C" void Init_cryptopp()
+{
+	/**
+	 * This is the main CryptoPP module. All of the various Cipher, Digest
+	 * and HMAC classes are found here.
+	 *
+	 * The CryptoPP module contains a handful of module methods that can be
+	 * used to create new ciphers, digests and HMACs and provide information
+	 * on the environment and configuration CryptoPP is running with.
+	 */
+	rb_mCryptoPP             = rb_define_module("CryptoPP");
+
+	/**
+	 * Exception class.
+	 */
+	rb_eCryptoPP_Error       = rb_define_class_under(rb_mCryptoPP, "CryptoPPError", rb_eStandardError);
+
+	/**
+	 * The base cipher class. This class is not meant to be used directly. It
+	 * merely serves as the base class for all CryptoPP ciphers.
+	 *
+	 * Ciphers can be created either by using the
+	 * <tt>CryptoPP#cipher_factory</tt> factory method or by instantiating
+	 * the classes directly. For instance, the following are equivalent:
+	 *
+	 *	cipher = CryptoPP.cipher_factory(:aes)
+	 *	cipher = CryptoPP::AES.new
+	 *
+	 * Options include:
+	 *
+	 * * <tt>:plaintext</tt> and <tt>:plaintext_hex</tt> - set the plaintext. You
+	 *   can only use one at a time.
+	 * * <tt>:ciphertext</tt> and <tt>:ciphertext_hex</tt> - set the ciphertext.
+	 *   You can only use one at a time.
+	 * * <tt>:key</tt> and <tt>:key_hex</tt> - set the key. You can only use one
+	 *   at a time.
+	 * * <tt>:key_length</tt> - set the length of the key. Normally this is done
+	 *   automatically, but you can force a different key length if necessary.
+	 * * <tt>:effective_key_length</tt> - sets the effective key length on RC2
+	 *   ciphers.
+	 * * <tt>:rounds</tt> - sets the number of rounds a cipher performs on
+	 *   block ciphers that support them.
+	 * * <tt>:rng</tt> - sets the random number generator to be used for things
+	 *   like creating initialization vectors and such. Not all operating
+	 *   systems and environments will support all RNGs. You can check which
+	 *   ones are supported with <tt>CryptoPP#rng_available?</tt>. Possible
+	 *   values are :blocking, :non_blocking and :rand.
+	 *
+	 * All of these options have their equivalent setter and getter methods
+	 * if you need to modify them after initialization.
+	 */
+	rb_cCryptoPP_Cipher      = rb_define_class_under(rb_mCryptoPP, "Cipher", rb_cObject);
+
+	/**
+	 * The base Digest class. This class is not meant to be used directly. It
+	 * merely serves as the base class for all CryptoPP Digests and HMACs.
+	 */
+	rb_cCryptoPP_Digest      = rb_define_class_under(rb_mCryptoPP, "Digest", rb_cObject);
+
+	/**
+	 * The base HMAC class. This class is not meant to be used directly. It
+	 * merely serves as the base class for all CryptoPP HMACs.
+	 */
+	rb_cCryptoPP_Digest_HMAC = rb_define_class_under(rb_mCryptoPP, "HMAC", rb_cCryptoPP_Digest);
+
+	rb_undef_alloc_func(rb_cCryptoPP_Cipher);
+	rb_undef_alloc_func(rb_cCryptoPP_Digest);
+	rb_undef_alloc_func(rb_cCryptoPP_Digest_HMAC);
+
+	rb_define_const(rb_mCryptoPP, "VERSION",           rb_str_new2("0.0.2"));
+	rb_define_const(rb_mCryptoPP, "CRYPTOPP_VERSION",  INT2NUM(CRYPTOPP_VERSION));
+
+#	define CIPHER_ALGORITHM_X(klass, r, c, s) \
+		rb_cCryptoPP_Cipher_ ## r = rb_define_class_under(rb_mCryptoPP, # klass, rb_cCryptoPP_Cipher); \
+		rb_define_singleton_method((rb_cCryptoPP_Cipher_ ## r), "new", CRYPTOPP_VALUE_FUNC(rb_cipher_ ## r ##_new), -1);
+#	include "defs/ciphers.def"
+
+#	define CHECKSUM_ALGORITHM_X(klass, r, c, s) \
+		rb_cCryptoPP_Digest_ ## r = rb_define_class_under(rb_mCryptoPP, # klass, rb_cCryptoPP_Digest); \
+		rb_define_singleton_method((rb_cCryptoPP_Digest_ ## r), "new", CRYPTOPP_VALUE_FUNC(rb_digest_ ## r ##_new), -1);
+#	include "defs/checksums.def"
+
+#	define HASH_ALGORITHM_X(klass, r, c, s) \
+		rb_cCryptoPP_Digest_ ## r = rb_define_class_under(rb_mCryptoPP, # klass, rb_cCryptoPP_Digest); \
+		rb_define_singleton_method((rb_cCryptoPP_Digest_ ## r), "new", CRYPTOPP_VALUE_FUNC(rb_digest_ ## r ##_new), -1);
+#	include "defs/hashes.def"
+
+#	define HMAC_ALGORITHM_X(klass, r, c, s) \
+		rb_cCryptoPP_Digest_HMAC_ ## r = rb_define_class_under(rb_mCryptoPP, # klass, rb_cCryptoPP_Digest_HMAC); \
+		rb_define_singleton_method((rb_cCryptoPP_Digest_HMAC_ ## r), "new", CRYPTOPP_VALUE_FUNC(rb_digest_hmac_ ## r ##_new), -1);
+#	include "defs/hmacs.def"
+
+	rb_define_module_function(rb_mCryptoPP, "cipher_list",      RUBY_METHOD_FUNC(rb_module_cipher_list),     0); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "cipher_name",      RUBY_METHOD_FUNC(rb_module_cipher_name),     1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "block_mode_name",  RUBY_METHOD_FUNC(rb_module_block_mode_name), 1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "padding_name",     RUBY_METHOD_FUNC(rb_module_padding_name),    1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "rng_name",         RUBY_METHOD_FUNC(rb_module_rng_name),        1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "cipher_enabled?",  RUBY_METHOD_FUNC(rb_module_cipher_enabled),  1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "rng_available?",   RUBY_METHOD_FUNC(rb_module_rng_available),   1); /* in ciphers.cpp */
+
+	rb_define_module_function(rb_mCryptoPP, "cipher_factory",   RUBY_METHOD_FUNC(rb_module_cipher_factory),        -1); /* in ciphers.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_factory",   RUBY_METHOD_FUNC(rb_module_digest_factory),        -1); /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "hmac_factory",     RUBY_METHOD_FUNC(rb_module_hmac_factory),   -1); /* in digests.cpp */
+
+	rb_define_module_function(rb_mCryptoPP, "digest_enabled?",    RUBY_METHOD_FUNC(rb_module_digest_enabled), 1); /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_name",        RUBY_METHOD_FUNC(rb_module_digest_name),    1); /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_list",        RUBY_METHOD_FUNC(rb_module_digest_list),    0); /* in digests.cpp */
+
+	rb_define_alias(rb_singleton_class(rb_mCryptoPP), "hash_enabled?", "digest_enabled?");
+	rb_define_alias(rb_singleton_class(rb_mCryptoPP), "hash_name",     "digest_name");
+	rb_define_alias(rb_singleton_class(rb_mCryptoPP), "hash_list",     "digest_list");
+
+	rb_define_module_function(rb_mCryptoPP, "digest",          RUBY_METHOD_FUNC(rb_module_digest),     -1); /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_hex",      RUBY_METHOD_FUNC(rb_module_digest_hex), -1); /* in digests.cpp */
+
+	rb_define_alias(rb_singleton_class(rb_mCryptoPP), "hexdigest", "digest_hex");
+
+	rb_define_module_function(rb_mCryptoPP, "digest_io",     RUBY_METHOD_FUNC(rb_module_digest_io),         -1); /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_io_hex", RUBY_METHOD_FUNC(rb_module_digest_io_hex),     -1); /* in digests.cpp */
+
+	rb_define_module_function(rb_mCryptoPP, "digest_hmac",     RUBY_METHOD_FUNC(rb_module_hmac_digest),        -1);  /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "digest_hmac_hex", RUBY_METHOD_FUNC(rb_module_hmac_digest_hex),    -1);  /* in digests.cpp */
+	rb_define_module_function(rb_mCryptoPP, "hmac_list",       RUBY_METHOD_FUNC(rb_module_hmac_list),           0);  /* in digests.cpp */
+
+	rb_define_method(rb_cCryptoPP_Cipher, "rand_iv",            RUBY_METHOD_FUNC(rb_cipher_rand_iv),            1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "iv=",                RUBY_METHOD_FUNC(rb_cipher_iv_eq),              1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "iv_hex=",            RUBY_METHOD_FUNC(rb_cipher_iv_hex_eq),          1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "iv",                 RUBY_METHOD_FUNC(rb_cipher_iv),                 0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "iv_hex",             RUBY_METHOD_FUNC(rb_cipher_iv_hex),             0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "block_mode=",        RUBY_METHOD_FUNC(rb_cipher_block_mode_eq),      1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "block_mode",         RUBY_METHOD_FUNC(rb_cipher_block_mode),         0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "padding=",           RUBY_METHOD_FUNC(rb_cipher_padding_eq),         1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "padding",            RUBY_METHOD_FUNC(rb_cipher_padding),            0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "rng=",               RUBY_METHOD_FUNC(rb_cipher_rng_eq),             1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "rng",                RUBY_METHOD_FUNC(rb_cipher_rng),                0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "plaintext=",         RUBY_METHOD_FUNC(rb_cipher_plaintext_eq),       1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "plaintext_hex=",     RUBY_METHOD_FUNC(rb_cipher_plaintext_hex_eq),   1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "plaintext",          RUBY_METHOD_FUNC(rb_cipher_plaintext),          0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "plaintext_hex",      RUBY_METHOD_FUNC(rb_cipher_plaintext_hex),      0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "ciphertext=",        RUBY_METHOD_FUNC(rb_cipher_ciphertext_eq),      1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "ciphertext_hex=",    RUBY_METHOD_FUNC(rb_cipher_ciphertext_hex_eq),  1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "ciphertext",         RUBY_METHOD_FUNC(rb_cipher_ciphertext),         0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "ciphertext_hex",     RUBY_METHOD_FUNC(rb_cipher_ciphertext_hex),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key=",               RUBY_METHOD_FUNC(rb_cipher_key_eq),             1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key_hex=",           RUBY_METHOD_FUNC(rb_cipher_key_hex_eq),         1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key",                RUBY_METHOD_FUNC(rb_cipher_key),                0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key_hex",            RUBY_METHOD_FUNC(rb_cipher_key_hex),            0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key_length=",        RUBY_METHOD_FUNC(rb_cipher_key_length_eq),      1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "key_length",         RUBY_METHOD_FUNC(rb_cipher_key_length),         0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "default_key_length", RUBY_METHOD_FUNC(rb_cipher_default_key_length), 0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "max_key_length",     RUBY_METHOD_FUNC(rb_cipher_max_key_length),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "min_key_length",     RUBY_METHOD_FUNC(rb_cipher_min_key_length),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "mult_key_length",    RUBY_METHOD_FUNC(rb_cipher_mult_key_length),    0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "valid_key_length",   RUBY_METHOD_FUNC(rb_cipher_valid_key_length),   1); /* in ciphers.cpp */
+#	if ENABLED_RC2_CIPHER
+	rb_define_method(rb_cCryptoPP_Cipher_RC2, "effective_key_length=", RUBY_METHOD_FUNC(rb_cipher_effective_key_length_eq), 1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher_RC2, "effective_key_length",  RUBY_METHOD_FUNC(rb_cipher_effective_key_length),    0); /* in ciphers.cpp */
+#	endif
+	rb_define_method(rb_cCryptoPP_Cipher, "block_size",          RUBY_METHOD_FUNC(rb_cipher_block_size),      1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "rounds=",             RUBY_METHOD_FUNC(rb_cipher_rounds_eq),       1); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "rounds",              RUBY_METHOD_FUNC(rb_cipher_rounds),          0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "algorithm_name",      RUBY_METHOD_FUNC(rb_cipher_algorithm_name),  0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "block_mode_name",     RUBY_METHOD_FUNC(rb_cipher_block_mode_name), 0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "padding_name",        RUBY_METHOD_FUNC(rb_cipher_padding_name),    0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "rng_name",            RUBY_METHOD_FUNC(rb_cipher_rng_name),        0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "cipher_type",         RUBY_METHOD_FUNC(rb_cipher_cipher_type),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "encrypt",             RUBY_METHOD_FUNC(rb_cipher_encrypt),         0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "encrypt_hex",         RUBY_METHOD_FUNC(rb_cipher_encrypt_hex),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "decrypt",             RUBY_METHOD_FUNC(rb_cipher_decrypt),         0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "decrypt_hex",         RUBY_METHOD_FUNC(rb_cipher_decrypt_hex),     0); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "encrypt_io",          RUBY_METHOD_FUNC(rb_cipher_encrypt_io),      2); /* in ciphers.cpp */
+	rb_define_method(rb_cCryptoPP_Cipher, "decrypt_io",          RUBY_METHOD_FUNC(rb_cipher_decrypt_io),      2); /* in ciphers.cpp */
+
+	rb_define_method(rb_cCryptoPP_Digest, "digest",              RUBY_METHOD_FUNC(rb_digest_digest),             0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "digest_hex",          RUBY_METHOD_FUNC(rb_digest_digest_hex),         0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "digest=",             RUBY_METHOD_FUNC(rb_digest_digest_eq),          1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "digest_hex=",         RUBY_METHOD_FUNC(rb_digest_digest_hex_eq),      1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "plaintext",           RUBY_METHOD_FUNC(rb_digest_plaintext),          0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "plaintext=",          RUBY_METHOD_FUNC(rb_digest_plaintext_eq),       1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "plaintext_hex",       RUBY_METHOD_FUNC(rb_digest_plaintext_hex),      0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "plaintext_hex=",      RUBY_METHOD_FUNC(rb_digest_plaintext_hex_eq),   1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "calculate",           RUBY_METHOD_FUNC(rb_digest_calculate),          0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "calculate_hex",       RUBY_METHOD_FUNC(rb_digest_calculate_hex),      0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "digest_io",           RUBY_METHOD_FUNC(rb_digest_digest_io),          1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "digest_io_hex",       RUBY_METHOD_FUNC(rb_digest_digest_io_hex),      1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "update",              RUBY_METHOD_FUNC(rb_digest_update),             1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "to_s",                RUBY_METHOD_FUNC(rb_digest_digest_hex),         0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "inspect",             RUBY_METHOD_FUNC(rb_digest_inspect),            0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "==",                  RUBY_METHOD_FUNC(rb_digest_equals),             1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "algorithm_name",      RUBY_METHOD_FUNC(rb_digest_algorithm_name),     0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "clear",               RUBY_METHOD_FUNC(rb_digest_clear),              0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest, "validate",            RUBY_METHOD_FUNC(rb_digest_validate),           0); /* in digests.cpp */
+
+	rb_define_alias(rb_cCryptoPP_Digest, "hexdigest", "digest_hex");
+	rb_define_alias(rb_cCryptoPP_Digest, "hexdigest=", "digest_hex=");
+	rb_define_alias(rb_cCryptoPP_Digest, "<<", "update");
+	rb_define_alias(rb_cCryptoPP_Digest, "valid?", "validate");
+
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key=",           RUBY_METHOD_FUNC(rb_digest_hmac_key_eq),        1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key_hex=",       RUBY_METHOD_FUNC(rb_digest_hmac_key_hex_eq),    1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key",            RUBY_METHOD_FUNC(rb_digest_hmac_key),           0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key_hex",        RUBY_METHOD_FUNC(rb_digest_hmac_key_hex),       0); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key_length=",    RUBY_METHOD_FUNC(rb_digest_hmac_key_length_eq), 1); /* in digests.cpp */
+	rb_define_method(rb_cCryptoPP_Digest_HMAC, "key_length",     RUBY_METHOD_FUNC(rb_digest_hmac_key_length),    0); /* in digests.cpp */
+}

data/ext/cryptopp_ruby_api.h

@@ -0,0 +1,139 @@
+
+/*
+ * Copyright (c) 2002-2010 J Smith <dark.panda@gmail.com>
+ * Crypto++ copyright (c) 1995-2010 Wei Dai
+ * See COPYING for the extact license
+ */
+
+#ifndef __CRYPTOPP_RUBY_API_H__
+#define __CRYPTOPP_RUBY_API_H__
+
+#include "ruby.h"
+
+extern VALUE rb_mCryptoPP;
+extern VALUE rb_eCryptoPP_Error;
+extern VALUE rb_cCryptoPP_Cipher;
+extern VALUE rb_cCryptoPP_Digest;
+extern VALUE rb_cCryptoPP_Digest_HMAC;
+
+#define CIPHER_ALGORITHM_X(klass, r, c, s) \
+	extern VALUE rb_cCryptoPP_Cipher_ ## r ;
+#include "defs/ciphers.def"
+
+#define CHECKSUM_ALGORITHM_X(klass, r, c, s) \
+	extern VALUE rb_cCryptoPP_Digest_ ## r ;
+#include "defs/checksums.def"
+
+#define HASH_ALGORITHM_X(klass, r, c, s) \
+	extern VALUE rb_cCryptoPP_Digest_ ## r ;
+#include "defs/hashes.def"
+
+#define HMAC_ALGORITHM_X(klass, r, c, s) \
+	extern VALUE rb_cCryptoPP_Digest_HMAC_ ## r ;
+#include "defs/hmacs.def"
+
+VALUE rb_module_cipher_factory(int argc, VALUE *argv, VALUE self);
+#define CIPHER_ALGORITHM_X(klass, r, n, s) \
+VALUE rb_cipher_ ## r ##_new(int argc, VALUE *argv, VALUE self);
+#include "defs/ciphers.def"
+VALUE rb_cipher_rand_iv(VALUE self, VALUE l);
+VALUE rb_cipher_iv_eq(VALUE self, VALUE iv);
+VALUE rb_cipher_iv_hex_eq(VALUE self, VALUE iv);
+VALUE rb_cipher_iv(VALUE self);
+VALUE rb_cipher_iv_hex(VALUE self);
+VALUE rb_cipher_block_mode_eq(VALUE self, VALUE m);
+VALUE rb_cipher_block_mode(VALUE self);
+VALUE rb_cipher_padding_eq(VALUE self, VALUE p);
+VALUE rb_cipher_padding(VALUE self);
+VALUE rb_cipher_rng_eq(VALUE self, VALUE r);
+VALUE rb_cipher_rng(VALUE self);
+VALUE rb_cipher_plaintext_eq(VALUE self, VALUE plaintext);
+VALUE rb_cipher_plaintext_hex_eq(VALUE self, VALUE plaintext);
+VALUE rb_cipher_plaintext(VALUE self);
+VALUE rb_cipher_plaintext_hex(VALUE self);
+VALUE rb_cipher_ciphertext_eq(VALUE self, VALUE ciphertext);
+VALUE rb_cipher_ciphertext_hex_eq(VALUE self, VALUE ciphertext);
+VALUE rb_cipher_ciphertext(VALUE self);
+VALUE rb_cipher_ciphertext_hex(VALUE self);
+VALUE rb_cipher_key_eq(VALUE self, VALUE key);
+VALUE rb_cipher_key_hex_eq(VALUE self, VALUE key);
+VALUE rb_cipher_key(VALUE self);
+VALUE rb_cipher_key_hex(VALUE self);
+VALUE rb_cipher_key_length_eq(VALUE self, VALUE l);
+VALUE rb_cipher_key_length(VALUE self);
+VALUE rb_cipher_default_key_length(VALUE self);
+VALUE rb_cipher_min_key_length(VALUE self);
+VALUE rb_cipher_max_key_length(VALUE self);
+VALUE rb_cipher_mult_key_length(VALUE self);
+VALUE rb_cipher_valid_key_length(VALUE self, VALUE l);
+VALUE rb_cipher_effective_key_length_eq(VALUE self, VALUE l);
+VALUE rb_cipher_effective_key_length(VALUE self);
+VALUE rb_cipher_block_size(VALUE self);
+VALUE rb_cipher_rounds_eq(VALUE self, VALUE r);
+VALUE rb_cipher_rounds(VALUE self);
+VALUE rb_cipher_encrypt(VALUE self);
+VALUE rb_cipher_encrypt_hex(VALUE self);
+VALUE rb_cipher_decrypt(VALUE self);
+VALUE rb_cipher_decrypt_hex(VALUE self);
+VALUE rb_cipher_encrypt_io(VALUE self, VALUE in, VALUE out);
+VALUE rb_cipher_decrypt_io(VALUE self, VALUE in, VALUE out);
+VALUE rb_module_cipher_name(VALUE self, VALUE c);
+VALUE rb_cipher_algorithm_name(VALUE self);
+VALUE rb_module_block_mode_name(VALUE self, VALUE m);
+VALUE rb_cipher_block_mode_name(VALUE self);
+VALUE rb_module_padding_name(VALUE self, VALUE p);
+VALUE rb_cipher_padding_name(VALUE self);
+VALUE rb_module_rng_name(VALUE self, VALUE r);
+VALUE rb_cipher_rng_name(VALUE self);
+VALUE rb_cipher_cipher_type(VALUE self);
+VALUE rb_module_cipher_enabled(VALUE self, VALUE c);
+VALUE rb_module_rng_available(VALUE self, VALUE r);
+VALUE rb_module_cipher_list(VALUE self);
+VALUE rb_module_digest_factory(int argc, VALUE *argv, VALUE self);
+#define CHECKSUM_ALGORITHM_X(klass, r, n, s) \
+VALUE rb_digest_ ## r ##_new(int argc, VALUE *argv, VALUE self);
+#include "defs/checksums.def"
+
+#define HASH_ALGORITHM_X(klass, r, n, s) \
+VALUE rb_digest_ ## r ##_new(int argc, VALUE *argv, VALUE self);
+#include "defs/hashes.def"
+VALUE rb_digest_update(VALUE self, VALUE plaintext);
+VALUE rb_digest_digest(VALUE self);
+VALUE rb_digest_digest_hex(VALUE self);
+VALUE rb_digest_plaintext(VALUE self);
+VALUE rb_digest_plaintext_hex(VALUE self);
+VALUE rb_digest_plaintext_eq(VALUE self, VALUE plaintext);
+VALUE rb_digest_plaintext_hex_eq(VALUE self, VALUE plaintext);
+VALUE rb_digest_calculate(VALUE self);
+VALUE rb_digest_calculate_hex(VALUE self);
+VALUE rb_digest_digest_eq(VALUE self, VALUE digest);
+VALUE rb_digest_digest_hex_eq(VALUE self, VALUE digest);
+VALUE rb_digest_inspect(VALUE self);
+VALUE rb_digest_equals(VALUE self, VALUE compare);
+VALUE rb_module_digest(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_digest_hex(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_digest_io(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_digest_io_hex(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_digest_enabled(VALUE self, VALUE d);
+VALUE rb_module_digest_name(VALUE self, VALUE h);
+VALUE rb_digest_algorithm_name(VALUE self);
+VALUE rb_digest_clear(VALUE self);
+VALUE rb_digest_validate(VALUE self);
+VALUE rb_digest_digest_io(VALUE self, VALUE io);
+VALUE rb_digest_digest_io_hex(VALUE self, VALUE io);
+VALUE rb_module_digest_list(VALUE self);
+VALUE rb_module_hmac_factory(int argc, VALUE *argv, VALUE self);
+#define HMAC_ALGORITHM_X(klass, r, n, s) \
+VALUE rb_digest_hmac_ ## r ##_new(int argc, VALUE *argv, VALUE self);
+#include "defs/hmacs.def"
+VALUE rb_digest_hmac_key_eq(VALUE self, VALUE key);
+VALUE rb_digest_hmac_key_hex_eq(VALUE self, VALUE key);
+VALUE rb_digest_hmac_key(VALUE self);
+VALUE rb_digest_hmac_key_hex(VALUE self);
+VALUE rb_digest_hmac_key_length_eq(VALUE self, VALUE l);
+VALUE rb_digest_hmac_key_length(VALUE self);
+VALUE rb_module_hmac_digest(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_hmac_digest_hex(int argc, VALUE *argv, VALUE self);
+VALUE rb_module_hmac_list(VALUE self);
+
+#endif

data/ext/defs/block_modes.def

@@ -0,0 +1,10 @@
+
+// C++ constant, Ruby Symbol
+BLOCK_MODE_X(ECB,     ecb)
+BLOCK_MODE_X(CBC,     cbc)
+BLOCK_MODE_X(CBC_CTS, cbc_cts)
+BLOCK_MODE_X(CFB,     cfb)
+BLOCK_MODE_X(CTR,     ctr)
+BLOCK_MODE_X(OFB,     ofb)
+
+#undef BLOCK_MODE_X

data/ext/defs/checksums.def

@@ -0,0 +1,10 @@
+#if ENABLED_ADLER32_CHECKSUM || defined(CHECKSUM_ALGORITHM_X_FORCE)
+CHECKSUM_ALGORITHM_X(Adler32, ADLER32, JAdler32, adler32)
+#endif
+
+#if ENABLED_CRC32_CHECKSUM || defined(CHECKSUM_ALGORITHM_X_FORCE)
+CHECKSUM_ALGORITHM_X(CRC32, CRC32, JCRC32, crc32)
+#endif
+
+#undef CHECKSUM_ALGORITHM_X
+#undef CHECKSUM_ALGORITHM_X_FORCE

data/ext/defs/ciphers.def

@@ -0,0 +1,136 @@
+
+// Ruby class name, constant, C++ class name, a Symbol
+#if ENABLED_ARC4_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(ARC4, ARC4, JARC4, arc4)
+#endif
+
+#if ENABLED_PANAMA_LITTLE_ENDIAN_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(PanamaCipherLE, PANAMA_LITTLE_ENDIAN, JPanamaCipherLE, panama_le)
+#endif
+
+#if ENABLED_PANAMA_BIG_ENDIAN_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(PanamaCipherBE, PANAMA_BIG_ENDIAN, JPanamaCipherBE, panama_be)
+#endif
+
+#if ENABLED_MARC4_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(MARC4, MARC4, JMARC4, marc4)
+#endif
+
+#if ENABLED_SEAL_LITTLE_ENDIAN_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SEAL_BE, SEAL_LITTLE_ENDIAN, JSEAL_LE, seal_le)
+#endif
+
+#if ENABLED_SEAL_BIG_ENDIAN_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SEAL_LE, SEAL_BIG_ENDIAN, JSEAL_BE, seal_be)
+#endif
+
+#if ENABLED_THREEWAY_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Threeway, THREEWAY, J3Way, threeway)
+#endif
+
+#if ENABLED_AES_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(AES, AES, JAES, aes)
+#endif
+
+#if ENABLED_BLOWFISH_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Blowfish, BLOWFISH, JBlowfish, blowfish)
+#endif
+
+#if ENABLED_CAMELLIA_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Camellia, CAMELLIA, JCamellia, camellia)
+#endif
+
+#if ENABLED_CAST128_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(CAST128, CAST128, JCAST128, cast128)
+#endif
+
+#if ENABLED_CAST256_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(CAST256, CAST256, JCAST256, cast256)
+#endif
+
+#if ENABLED_DES_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(DES, DES, JDES, des)
+#endif
+
+#if ENABLED_DES_EDE2_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(DES_EDE2, DES_EDE2, JDES_EDE2, des_ede2)
+#endif
+
+#if ENABLED_DES_EDE3_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(DES_EDE3, DES_EDE3, JDES_EDE3, des_ede3)
+#endif
+
+#if ENABLED_DES_XEX3_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(DES_XEX3, DES_XEX3, JDES_XEX3, des_xex3)
+#endif
+
+#if ENABLED_DIAMOND2_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Diamond2, DIAMOND2, JDiamond2, diamond2)
+#endif
+
+#if ENABLED_DIAMOND2_LITE_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Diamond2Lite, DIAMOND2_LITE, JDiamond2Lite, diamond2lite)
+#endif
+
+#if ENABLED_GOST_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(GOST, GOST, JGOST, gost)
+#endif
+
+#if ENABLED_IDEA_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(IDEA, IDEA, JIDEA, idea)
+#endif
+
+#if ENABLED_MARS_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(MARS, MARS, JMARS, mars)
+#endif
+
+#if ENABLED_RC2_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(RC2, RC2, JRC2, rc2)
+#endif
+
+#if ENABLED_RC5_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(RC5, RC5, JRC5, rc5)
+#endif
+
+#if ENABLED_RC6_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(RC6, RC6, JRC6, rc6)
+#endif
+
+#if ENABLED_SAFER_K_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SAFER_K, SAFER_K, JSAFER_K, safer_k)
+#endif
+
+#if ENABLED_SAFER_SK_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SAFER_SK, SAFER_SK, JSAFER_SK, safer_sk)
+#endif
+
+#if ENABLED_SERPENT_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Serpent, SERPENT, JSerpent, serpent)
+#endif
+
+#if ENABLED_SHACAL2_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SHACAL2, SHACAL2, JSHACAL2, shacal2)
+#endif
+
+#if ENABLED_SHARK_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SHARK, SHARK, JSHARK, shark)
+#endif
+
+#if ENABLED_SKIPJACK_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(SKIPJACK, SKIPJACK, JSKIPJACK, skipjack)
+#endif
+
+#if ENABLED_SQUARE_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Square, SQUARE, JSquare, square)
+#endif
+
+#if ENABLED_TEA_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(TEA, TEA, JTEA, tea)
+#endif
+
+#if ENABLED_TWOFISH_CIPHER || defined(CIPHER_ALGORITHM_X_FORCE)
+CIPHER_ALGORITHM_X(Twofish, TWOFISH, JTwofish, twofish)
+#endif
+
+#undef CIPHER_ALGORITHM_X
+#undef CIPHER_ALGORITHM_X_FORCE