naoki 1.0.1-x86-linux

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+EXT_CONF = 'ext/extconf.rb'
+MAKEFILE = 'ext/Makefile'
+MODULE = 'ext/data_secure.so'
+SRC = Dir.glob('ext/*.c')
+SRC << MAKEFILE
+
+CLEAN.include ['ext/*.o', 'ext/*.bundle', MODULE]
+CLOBBER.include ['ext/mkmf.log', MAKEFILE]
+
+file MAKEFILE => EXT_CONF do |t|
+  Dir::chdir(File::dirname(EXT_CONF)) do
+    unless sh "ruby #{File::basename(EXT_CONF)}"
+      $stderr.puts "Failed to run extconf"
+      break
+    end
+  end
+end
+
+file MODULE => SRC do |t|
+  Dir::chdir(File::dirname(EXT_CONF)) do
+    unless sh "make"
+      $stderr.puts "make failed"
+      break
+    end
+  end
+end
+
+desc "Build the native library"
+task :build => MODULE
+
+
+PKG_FILES = FileList[
+    "Rakefile", "ext/*.[ch]", "ext/extconf.rb", "ext/*.so"
+]
+
+SPEC = Gem::Specification.new do |s|
+    s.name = "naoki"
+    s.version = "1.0.1"
+    s.platform = Gem::Platform::CURRENT
+    s.homepage = ""
+    s.summary = "C bindings for SafeNet DataSecure ICAPI"
+    s.files = PKG_FILES
+    s.required_ruby_version = '>= 1.9.2'
+    s.extensions = "ext/extconf.rb"
+    s.authors = ["Chris Apolzon", "Liron Yahdav"]
+    s.email = ["apolzon@gmail.com"]
+    s.description = "C Bindings for SafeNet DataSecure ICAPI"
+end
+
+Rake::GemPackageTask.new(SPEC) do |pkg|
+    pkg.need_tar = true
+    pkg.need_zip = true
+end

data/ext/binding.c

@@ -0,0 +1,151 @@
+#include "icapi.h"
+#include "ruby.h"
+
+static I_O_Session gSession;
+
+static VALUE open_session(VALUE self, VALUE username, VALUE password) {
+  int return_code;
+  return_code = I_C_OpenSession(&gSession, I_T_Auth_Password, RSTRING_PTR(username), RSTRING_PTR(password));
+
+  if(return_code != I_E_OK) {
+    I_C_Fini();
+    rb_raise(rb_eException, "I_C_OpenSession error: %s\n", I_C_GetErrorString(return_code));
+  }
+}
+
+static VALUE close_session() {
+  I_C_CloseSession(gSession);
+  I_C_Fini();
+}
+
+static VALUE configure(VALUE self, VALUE properties_file) {
+  int return_code;
+  return_code = I_C_Initialize(I_T_Init_File, RSTRING_PTR(properties_file));
+
+  if(return_code != I_E_OK) {
+    rb_raise(rb_eException, "I_C_Initialize error: %s\n", I_C_GetErrorString(return_code));
+  }
+}
+
+static VALUE encrypt(VALUE self, VALUE rb_algorithm, VALUE rb_key_name, VALUE rb_initialization_vector, VALUE rb_input_data) {
+  char *input_data = RSTRING_PTR(rb_input_data);
+  char *initialization_vector = RSTRING_PTR(rb_initialization_vector);
+  char *key_name = RSTRING_PTR(rb_key_name);
+  char *algorithm = RSTRING_PTR(rb_algorithm); 
+  
+  I_O_CipherSpec cipherspec;
+  int initialization_vector_length, input_data_length;
+  I_T_UINT encrypted_data_length;
+  I_T_BYTE *encrypted_data;
+  int return_code;
+
+  input_data_length = strlen(input_data);
+  initialization_vector_length = strlen(initialization_vector);
+
+  return_code = I_C_CreateCipherSpec(algorithm, key_name, &cipherspec);
+
+  if (return_code != I_E_OK) {
+    close_session();
+    rb_raise(rb_eException, "I_C_CreateCipherSpec error: %s\n", I_C_GetErrorString(return_code));
+  }
+
+  return_code = I_C_CalculateEncipheredSizeForKey(gSession,
+      cipherspec, I_T_Operation_Encrypt, input_data_length, &encrypted_data_length);
+
+  if(return_code != I_E_OK) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "I_C_CalculateEncipheredSizeForKey error: %s\n", I_C_GetErrorString(return_code));
+  }
+
+  encrypted_data = (I_T_BYTE *)malloc(encrypted_data_length);
+
+  if(!encrypted_data) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "Failed to allocate %d bytes.\n", (int)encrypted_data_length);
+  }
+
+  return_code = I_C_Crypt(gSession, cipherspec, I_T_Operation_Encrypt,
+    initialization_vector, initialization_vector_length, input_data,
+    input_data_length, (I_T_BYTE*)encrypted_data, &encrypted_data_length);
+
+  if(return_code != I_E_OK) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "I_C_Crypt() error: %s\n", I_C_GetErrorString(return_code));
+  } 
+
+  I_C_DeleteCipherSpec(cipherspec);
+
+  VALUE result = rb_str_new(encrypted_data, encrypted_data_length);
+  free(encrypted_data);
+  return result;
+}
+
+static VALUE decrypt(VALUE self, VALUE rb_algorithm, VALUE rb_key_name, VALUE rb_initialization_vector, VALUE rb_encrypted_data, VALUE rb_encrypted_data_length)
+{
+  char *algorithm = RSTRING_PTR(rb_algorithm);
+  char *key_name = RSTRING_PTR(rb_key_name);
+  char *initialization_vector = RSTRING_PTR(rb_initialization_vector);
+  char *encrypted_data = RSTRING_PTR(rb_encrypted_data);
+  int initialization_vector_length = strlen(initialization_vector);
+  int encrypted_data_length = NUM2INT(rb_encrypted_data_length); 
+  
+  I_O_CipherSpec cipherspec;
+  I_T_UINT decrypted_data_length;
+  I_T_BYTE *decrypted_data;
+  int return_code;
+
+  return_code = I_C_CreateCipherSpec("AES/CBC/PKCS5Padding", "stg-encrypt-test1", &cipherspec);
+
+  if(return_code != I_E_OK) {
+    close_session();
+    rb_raise(rb_eException, "I_C_CreateCipherSpec error: %s\n", I_C_GetErrorString(return_code));
+  }
+
+  return_code = I_C_CalculateOutputSizeForKey(gSession,
+      cipherspec, I_T_Operation_Decrypt, encrypted_data_length, &decrypted_data_length);
+
+  if(return_code != I_E_OK) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "I_C_CalculateOutputSizeForKey error: %s\n", I_C_GetErrorString(return_code));
+  }
+
+  decrypted_data = (I_T_BYTE*)malloc(decrypted_data_length);
+
+  if(!decrypted_data) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "Failed to allocate %d bytes.\n", (int)decrypted_data_length);
+  }
+
+  return_code = I_C_Crypt(gSession, cipherspec, I_T_Operation_Decrypt,
+      initialization_vector, initialization_vector_length, 
+      encrypted_data, encrypted_data_length, (I_T_BYTE*)decrypted_data, &decrypted_data_length);
+
+  if(return_code != I_E_OK) {
+    I_C_DeleteCipherSpec(cipherspec);
+    close_session();
+    rb_raise(rb_eException, "I_C_Crypt() error: %s\n", I_C_GetErrorString(return_code));
+  }
+
+  I_C_DeleteCipherSpec(cipherspec);
+
+  VALUE result = rb_str_new(decrypted_data, decrypted_data_length);
+  free(decrypted_data);
+  return result;
+}
+
+void Init_data_secure() {
+  int return_code;
+  VALUE DataSecureWrapperModule = rb_define_module("DataSecureWrapper");
+
+  rb_define_module_function(DataSecureWrapperModule, "configure", configure, 1);
+  rb_define_module_function(DataSecureWrapperModule, "open", open_session, 2);
+  rb_define_module_function(DataSecureWrapperModule, "encrypt", encrypt, 4);
+  rb_define_module_function(DataSecureWrapperModule, "decrypt", decrypt, 5);
+  rb_define_module_function(DataSecureWrapperModule, "close", close_session, 0);	
+}
+

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+have_library('ICAPI','I_C_Initialize') || exit
+create_makefile("data_secure")