zweifische 1.0.1

data/ext/zweifische/twofish.h

@@ -0,0 +1,35 @@
+#ifndef _h_twofish
+
+#define _h_twofish
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define u32 unsigned int
+#define BYTE unsigned char
+
+struct twofish;
+
+struct twofish *twofish_256_ecb_init(BYTE key[], BYTE iv[16]);
+struct twofish *twofish_256_cbc_init(BYTE key[], BYTE iv[16]);
+
+struct twofish *twofish_192_ecb_init(BYTE key[], BYTE iv[16]);
+struct twofish *twofish_192_cbc_init(BYTE key[], BYTE iv[16]);
+
+struct twofish *twofish_128_ecb_init(BYTE key[], BYTE iv[16]);
+struct twofish *twofish_128_cbc_init(BYTE key[], BYTE iv[16]);
+
+void twofish_free(struct twofish **pctx);
+
+int twofish_encrypt_update(struct twofish *ctx, BYTE plain_text[], u32 text_len, BYTE crypted_text[], u32 crypt_len);
+int twofish_encrypt_final(struct twofish *ctx, BYTE plain_text[], u32 text_len, BYTE crypted_text[], u32 crypt_len);
+
+int twofish_decrypt_update(struct twofish *ctx, BYTE crypted_text[], u32 crypted_len, BYTE plain_text[], u32 text_len);
+int twofish_decrypt_final(struct twofish *ctx, BYTE crypted_text[], u32 crypted_len, BYTE plain_text[], u32 text_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/zweifische/zweifische.c

@@ -0,0 +1,184 @@
+#include <ruby.h>
+#include "twofish.h"
+
+#define LEN_ERR_MSG "Provided string must have length at least 16 bytes. " \
+    "You may consider to use any available padding schemes under "         \
+    "Zweifische (e.g. z.encrypt(data, pad: Zweifische::ZeroPadding)), "    \
+    "or you can just explicitly provide string with (multiple of) "        \
+    "16 bytes in length."
+
+#define LEN_PADDED_ERR_MSG "There's error in string length, it should has "\
+    "(multiple of) 16 bytes in length after padding, but it's not."
+
+#define assert_string_type(key) if (TYPE(key) != T_STRING) { rb_raise(rb_eTypeError, "type should be string"); }
+
+#define GET_C_STRPTR(val, str) { assert_string_type(val); str = (unsigned char *)StringValuePtr(val); } while (0)
+
+#define GET_C_STRPTR_AND_LEN(val, str, strlen) { GET_C_STRPTR(val, str); strlen = RSTRING_LEN(val); } while (0)
+
+void cipher_free(void *st);
+
+static const rb_data_type_t twofish_ctx_type = {
+    "twofish_ctx",
+    { 0, cipher_free, 0, },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+void cipher_free(void *st)
+{
+    struct twofish *twofish_ctx = (struct twofish *)st;
+    twofish_free(&twofish_ctx);
+}
+
+#define CIPHER_ECB_INIT(self, key, len) {                                    \
+    unsigned char *sKey;                                                     \
+    struct twofish *ctx;                                                     \
+    VALUE twofish_ctx;                                                       \
+                                                                             \
+    GET_C_STRPTR(key, sKey);                                                 \
+                                                                             \
+    ctx = twofish_##len##_ecb_init(sKey, (void *)0);                         \
+                                                                             \
+    twofish_ctx = TypedData_Wrap_Struct(rb_cData, &twofish_ctx_type, ctx);   \
+    rb_ivar_set(self, rb_intern("twofish_ctx"), twofish_ctx);                \
+                                                                             \
+    return Qnil;                                                             \
+}
+
+static VALUE cipher_256_ecb_init(VALUE self, VALUE key) CIPHER_ECB_INIT(self, key, 256)
+static VALUE cipher_192_ecb_init(VALUE self, VALUE key) CIPHER_ECB_INIT(self, key, 192)
+static VALUE cipher_128_ecb_init(VALUE self, VALUE key) CIPHER_ECB_INIT(self, key, 128)
+
+
+#define CIPHER_CBC_INIT(self, key, iv, len) {                               \
+    unsigned char *sKey;                                                    \
+    unsigned char *sIV;                                                     \
+    struct twofish *ctx;                                                    \
+    VALUE twofish_ctx;                                                      \
+                                                                            \
+    GET_C_STRPTR(key, sKey);                                                \
+                                                                            \
+    GET_C_STRPTR(iv, sIV);                                                  \
+                                                                            \
+    ctx = twofish_##len##_cbc_init(sKey, sIV);                              \
+                                                                            \
+    twofish_ctx = TypedData_Wrap_Struct(rb_cData, &twofish_ctx_type, ctx);  \
+    rb_ivar_set(self, rb_intern("twofish_ctx"), twofish_ctx);               \
+                                                                            \
+    return Qnil;                                                            \
+}
+
+static VALUE cipher_256_cbc_init(VALUE self, VALUE key, VALUE iv) CIPHER_CBC_INIT(self, key, iv, 256)
+static VALUE cipher_192_cbc_init(VALUE self, VALUE key, VALUE iv) CIPHER_CBC_INIT(self, key, iv, 192)
+static VALUE cipher_128_cbc_init(VALUE self, VALUE key, VALUE iv) CIPHER_CBC_INIT(self, key, iv, 128)
+
+
+#define CIPHER_OP(self, data, operation) {                                                    \
+    unsigned char *sData, *targetData;                                            \
+    unsigned int lData, lTargetData;                                              \
+    int result;                                                                   \
+    struct twofish *ctx;                                                          \
+    VALUE twofish_ctx, targetText;                                                \
+                                                                                  \
+    GET_C_STRPTR_AND_LEN(data, sData, lData);                                     \
+                                                                                  \
+    twofish_ctx = rb_ivar_get(self, rb_intern("twofish_ctx"));                    \
+    TypedData_Get_Struct(twofish_ctx, struct twofish, &twofish_ctx_type, ctx);    \
+                                                                                  \
+    lTargetData = ((lData / 16) + 1) * 16;                                        \
+    targetData = ALLOC_N(unsigned char, lTargetData);                             \
+    result = operation(ctx, sData, lData, targetData, lTargetData);               \
+                                                                                  \
+    if (result < 0) {                                                             \
+        rb_raise(rb_eRuntimeError, LEN_ERR_MSG);                                  \
+    }                                                                             \
+                                                                                  \
+    targetText = rb_str_new((const char *)targetData, result);                    \
+    xfree(targetData);                                                            \
+    return targetText;                                                            \
+}
+
+static VALUE cipher_encrypt_update(VALUE self, VALUE data) CIPHER_OP(self, data, twofish_encrypt_update)
+static VALUE cipher_encrypt_final(VALUE self, VALUE data) CIPHER_OP(self, data, twofish_encrypt_final)
+
+static VALUE cipher_encrypt_final_with_pad(VALUE self, VALUE data, VALUE pad)
+{
+    unsigned char *sData, *targetData;
+    unsigned int lData, lTargetData;
+    int result;
+    struct twofish *ctx;
+    VALUE twofish_ctx, crypted_text;
+
+    GET_C_STRPTR_AND_LEN(data, sData, lData);
+
+    twofish_ctx = rb_ivar_get(self, rb_intern("twofish_ctx"));
+    TypedData_Get_Struct(twofish_ctx, struct twofish, &twofish_ctx_type, ctx);
+
+    lTargetData = ((lData / 16) + 1) * 16;
+    targetData = ALLOC_N(unsigned char, lTargetData);
+    result = twofish_encrypt_final(ctx, sData, lData, targetData, lTargetData);
+
+    if (result < 0) {
+        VALUE padlen = INT2FIX(-1 * result);
+        VALUE padstr = rb_funcallv_public(pad, rb_intern("pad"), 1, &padlen);
+
+        rb_str_append(data, padstr);
+        GET_C_STRPTR_AND_LEN(data, sData, lData);
+        xfree(targetData);
+
+        lTargetData = ((lData / 16) + 1) * 16;
+        targetData = ALLOC_N(unsigned char, lTargetData);
+        result = twofish_encrypt_final(ctx, sData, lData, targetData, lTargetData);
+
+        if (result < 0) {
+            rb_raise(rb_eRuntimeError, LEN_PADDED_ERR_MSG);
+        }
+    }
+
+    crypted_text = rb_str_new((const char *)targetData, result);
+    xfree(targetData);
+
+    return crypted_text;
+}
+
+static VALUE cipher_decrypt_update(VALUE self, VALUE crypted) CIPHER_OP(self, crypted, twofish_decrypt_update)
+static VALUE cipher_decrypt_final(VALUE self, VALUE crypted) CIPHER_OP(self, crypted, twofish_decrypt_final)
+
+void Init_zweifische()
+{
+    VALUE mZweifische,
+          cCipher256ecb,
+          cCipher256cbc,
+          cCipher192ecb,
+          cCipher192cbc,
+          cCipher128ecb,
+          cCipher128cbc;
+
+    mZweifische = rb_define_module("Zweifische");
+
+    cCipher256ecb = rb_define_class_under(mZweifische, "Cipher256ecb", rb_cObject);
+    rb_define_method(cCipher256ecb, "initialize", cipher_256_ecb_init, 1);
+
+    rb_define_method(cCipher256ecb, "encrypt_update", cipher_encrypt_update, 1);
+    rb_define_method(cCipher256ecb, "c_encrypt_final", cipher_encrypt_final, 1);
+    rb_define_method(cCipher256ecb, "c_encrypt_final_with_pad", cipher_encrypt_final_with_pad, 2);
+
+    rb_define_method(cCipher256ecb, "decrypt_update", cipher_decrypt_update, 1);
+    rb_define_method(cCipher256ecb, "c_decrypt_final", cipher_decrypt_final, 1);
+
+    cCipher256cbc = rb_define_class_under(mZweifische, "Cipher256cbc", cCipher256ecb);
+    rb_define_method(cCipher256cbc, "initialize", cipher_256_cbc_init, 2);
+
+    cCipher192ecb = rb_define_class_under(mZweifische, "Cipher192ecb", cCipher256ecb);
+    rb_define_method(cCipher192ecb, "initialize", cipher_192_ecb_init, 1);
+
+    cCipher192cbc = rb_define_class_under(mZweifische, "Cipher192cbc", cCipher256ecb);
+    rb_define_method(cCipher192cbc, "initialize", cipher_192_cbc_init, 2);
+
+    cCipher128ecb = rb_define_class_under(mZweifische, "Cipher128ecb", cCipher256ecb);
+    rb_define_method(cCipher128ecb, "initialize", cipher_128_ecb_init, 1);
+
+    cCipher128cbc = rb_define_class_under(mZweifische, "Cipher128cbc", cCipher256ecb);
+    rb_define_method(cCipher128cbc, "initialize", cipher_128_cbc_init, 2);
+}

data/lib/zweifische.rb

@@ -0,0 +1,13 @@
+require "zweifische/version"
+
+module Zweifische
+end
+
+require "zweifische/ansi_x_923_padding"
+require "zweifische/iso_iec_7816_4_padding"
+require "zweifische/pkcs7_padding"
+require "zweifische/zero_padding"
+
+require "zweifische/zweifische"
+
+require "zweifische/cipher_256_ecb"

data/lib/zweifische/ansi_x_923_padding.rb

@@ -0,0 +1,36 @@
+module Zweifische
+  class AnsiX923Padding
+    class << self
+      def pad(num)
+        raise ArgumentError.new("max pad is 16 bytes") if num > 15 || num < 0
+        return "" if num == 0
+        0x00.chr * (num - 1) + num.chr
+      end
+
+      def unpad(text)
+        numpad = numpad(text)
+        if assert_pad(text, numpad, 0x00.chr)
+          return text[0..(-1 * (numpad + 1))]
+        end
+        text
+      end
+       
+      private
+
+      def assert_pad(text, numpad, char)
+        text
+          .split("")
+          .reverse[1..numpad - 1]
+          .all? { |c| c.eql?(char) }
+      end
+
+      def numpad(text)
+        text
+          .force_encoding(Encoding::ASCII_8BIT)
+          .split("")
+          .last
+          .ord
+      end
+    end
+  end
+end

data/lib/zweifische/cipher_256_ecb.rb

@@ -0,0 +1,22 @@
+module Zweifische
+  class Cipher256ecb
+    def encrypt_final(plain_text, pad: nil)
+      if pad && pad.respond_to?(:pad)
+        c_encrypt_final_with_pad(plain_text, pad)
+      else
+        c_encrypt_final(plain_text)
+      end
+    end
+
+    def decrypt_final(crypted_text, pad: nil)
+      plain_text = c_decrypt_final(crypted_text)
+      if pad && pad.respond_to?(:unpad)
+        return pad.unpad(plain_text)
+      end
+      plain_text
+    end
+
+    alias_method :encrypt, :encrypt_final
+    alias_method :decrypt, :decrypt_final
+  end
+end

data/lib/zweifische/iso_iec_7816_4_padding.rb

@@ -0,0 +1,18 @@
+module Zweifische
+  class ISOIEC78164Padding
+    def self.pad(num)
+      raise ArgumentError.new("max pad is 16 bytes") if num > 15 || num < 0
+      return "" if num == 0
+      0x80.chr + (0x00.chr * (num - 1))
+    end
+
+    def self.unpad(text)
+      wpad = text.split("").reverse[0..15]
+      count = wpad.each_with_index do |ch, idx|
+        return text if ch != 0.chr && ch != 0x80.chr
+        break idx if ch == 0x80.chr
+      end
+      text[0..(-1 * (count + 2))]
+    end
+  end
+end

data/lib/zweifische/pkcs7_padding.rb

@@ -0,0 +1,16 @@
+module Zweifische
+  class PKCS7Padding < AnsiX923Padding
+    def self.pad(num)
+      raise ArgumentError.new("max pad is 16 bytes") if num > 15 || num < 0
+      num.chr * num
+    end
+
+    def self.unpad(text)
+      numpad = numpad(text)
+      if assert_pad(text, numpad, numpad.chr)
+        return text[0..(-1 * (numpad + 1))]
+      end
+      text
+    end
+  end
+end

data/lib/zweifische/version.rb

@@ -0,0 +1,3 @@
+module Zweifische
+  VERSION = "1.0.1"
+end

data/lib/zweifische/zero_padding.rb

@@ -0,0 +1,12 @@
+module Zweifische
+  class ZeroPadding
+    def self.pad(num)
+      raise ArgumentError.new("max pad is 16 bytes") if num > 15 || num < 0
+      0x00.chr * num
+    end
+
+    def self.unpad(text)
+      text.gsub(/\x00+\z/, "")
+    end
+  end
+end

data/zweifische.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "zweifische/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "zweifische"
+  spec.version       = Zweifische::VERSION
+  spec.authors       = ["Nurahmadie"]
+  spec.email         = ["nurahmadie@gmail.com"]
+
+  spec.summary       = %q{Ruby binding for @drewcsillag twofish implementation}
+  spec.homepage      = "https://github.com/fudanchii/twofish"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/zweifische/extconf.rb"] 
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler", "> 0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: zweifische
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Nurahmadie
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- nurahmadie@gmail.com
+executables: []
+extensions:
+- ext/zweifische/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/zweifische/LICENSE
+- ext/zweifische/Makefile
+- ext/zweifische/extconf.rb
+- ext/zweifische/tables.h
+- ext/zweifische/twofish.c
+- ext/zweifische/twofish.h
+- ext/zweifische/zweifische.c
+- lib/zweifische.rb
+- lib/zweifische/ansi_x_923_padding.rb
+- lib/zweifische/cipher_256_ecb.rb
+- lib/zweifische/iso_iec_7816_4_padding.rb
+- lib/zweifische/pkcs7_padding.rb
+- lib/zweifische/version.rb
+- lib/zweifische/zero_padding.rb
+- zweifische.gemspec
+homepage: https://github.com/fudanchii/twofish
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Ruby binding for @drewcsillag twofish implementation
+test_files: []