scrypty 0.0.1 → 0.0.2

data/README.md

@@ -42,6 +42,21 @@ Example:
     decrypted = Scrypty.decrypt(encrypted, password, maxmem, maxmemfrac, maxtime)
     puts "Decrypted data: #{decrypted.inspect}"
 
+    orig_fn = "foo.txt"
+    enc_fn = "foo.dat"
+    dec_fn = "foo-dec.txt"
+
+    File.open(orig_fn, "w") { |f| f.print("my data") }
+    Scrypty.encrypt_file(orig_fn, enc_fn, password, maxmem, maxmemfrac, maxtime)
+    puts "Encrypted file: #{File.read(enc_fn).inspect}"
+    Scrypty.decrypt_file(enc_fn, dec_fn, password, maxmem, maxmemfrac, maxtime)
+    puts "Decrypted file: #{File.read(dec_fn).inspect}"
+
+## See also
+
+* [scrypt by Colin Percival](http://www.tarsnap.com/scrypt.html)
+* [libscrypt (ChromiumOS source tree)](http://git.chromium.org/gitweb/?p=chromiumos/third_party/libscrypt.git;a=summary)
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1 +1,20 @@
 require "bundler/gem_tasks"
+require "rake/clean"
+
+file "ext/Makefile" => "ext/extconf.rb" do
+  Dir.chdir("ext") do
+    ruby "extconf.rb"
+  end
+end
+
+file "ext/scrypty_ext.so" => FileList["ext/*.c", "ext/*.h", "ext/Makefile"] do
+  Dir.chdir("ext") do
+    sh "make"
+  end
+end
+
+desc "Compile the scrypty extension"
+task :compile => "ext/scrypty_ext.so"
+
+CLEAN.clear
+CLEAN.include(["ext/*.o", "ext/*.so", "ext/extconf.h", "ext/Makefile"])

data/ext/ruby_ext.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/io.h>
 #include <stdio.h>
 #include "scryptenc.h"
 
@@ -83,14 +84,15 @@ raise_scrypty_error(errorcode)
   }
 }
 
-VALUE
-scrypty_encrypt(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
+static VALUE
+scrypty_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime, encrypt)
   VALUE rb_obj;
   VALUE rb_data;
   VALUE rb_password;
   VALUE rb_maxmem;
   VALUE rb_maxmemfrac;
   VALUE rb_maxtime;
+  int encrypt;
 {
   VALUE rb_out;
   char *data, *password, *out;
@@ -135,15 +137,26 @@ scrypty_encrypt(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxti
     rb_raise(rb_eTypeError, "fifth argument (maxtime) must be a Fixnum or Float");
   }
 
-  out_len = data_len + 128;
-  rb_out = rb_str_new(NULL, out_len);
-  out = RSTRING_PTR(rb_out);
+  if (encrypt) {
+    out_len = data_len + 128;
+    rb_out = rb_str_new(NULL, out_len);
+    out = RSTRING_PTR(rb_out);
+
+    errorcode = scryptenc_buf((const uint8_t *) data, data_len,
+        (uint8_t *) out, (const uint8_t *) password, password_len,
+        maxmem, maxmemfrac, maxtime);
+  }
+  else {
+    rb_out = rb_str_new(NULL, data_len);
+    out = RSTRING_PTR(rb_out);
+
+    errorcode = scryptdec_buf((const uint8_t *) data, data_len,
+        (uint8_t *) out, &out_len, (const uint8_t *) password, password_len,
+        maxmem, maxmemfrac, maxtime);
+  }
 
-  errorcode = scryptenc_buf((const uint8_t *) data, data_len,
-      (uint8_t *) out, (const uint8_t *) password, password_len,
-      maxmem, maxmemfrac, maxtime);
   if (errorcode) {
-    raise_scrypt_error(errorcode);
+    raise_scrypty_error(errorcode);
   }
   rb_str_set_len(rb_out, out_len);
 
@@ -151,7 +164,7 @@ scrypty_encrypt(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxti
 }
 
 VALUE
-scrypty_decrypt(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
+scrypty_encrypt_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
   VALUE rb_obj;
   VALUE rb_data;
   VALUE rb_password;
@@ -159,69 +172,133 @@ scrypty_decrypt(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxti
   VALUE rb_maxmemfrac;
   VALUE rb_maxtime;
 {
-  VALUE rb_out;
-  char *data, *password, *out;
-  size_t data_len, password_len, out_len, maxmem;
+  return scrypty_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac,
+      rb_maxtime, 1);
+}
+
+VALUE
+scrypty_decrypt_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
+  VALUE rb_obj;
+  VALUE rb_data;
+  VALUE rb_password;
+  VALUE rb_maxmem;
+  VALUE rb_maxmemfrac;
+  VALUE rb_maxtime;
+{
+  return scrypty_buffer(rb_obj, rb_data, rb_password, rb_maxmem, rb_maxmemfrac,
+      rb_maxtime, 0);
+}
+
+VALUE
+scrypty_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime, encrypt)
+  VALUE rb_obj;
+  VALUE rb_infn;
+  VALUE rb_outfn;
+  VALUE rb_password;
+  VALUE rb_maxmem;
+  VALUE rb_maxmemfrac;
+  VALUE rb_maxtime;
+  int encrypt;
+{
+  VALUE rb_infile, rb_outfile;
+  FILE *in, *out;
+  rb_io_t *in_p, *out_p;
+  char *password;
+  size_t password_len;
+  int errorcode, maxmem;
   double maxmemfrac, maxtime;
-  int errorcode;
 
-  if (TYPE(rb_data) == T_STRING) {
-    data = RSTRING_PTR(rb_data);
-    data_len = (size_t) RSTRING_LEN(rb_data);
-  }
-  else {
-    rb_raise(rb_eTypeError, "first argument (data) must be a String");
-  }
+  rb_infile = rb_file_open_str(rb_infn, "rb");
+  rb_outfile = rb_file_open_str(rb_outfn, "wb");
 
   if (TYPE(rb_password) == T_STRING) {
     password = RSTRING_PTR(rb_password);
     password_len = (size_t) RSTRING_LEN(rb_password);
   }
   else {
-    rb_raise(rb_eTypeError, "second argument (password) must be a String");
+    rb_raise(rb_eTypeError, "third argument (password) must be a String");
   }
 
   if (TYPE(rb_maxmem) == T_FIXNUM) {
     maxmem = FIX2INT(rb_maxmem);
   }
   else {
-    rb_raise(rb_eTypeError, "third argument (maxmem) must be a Fixnum");
+    rb_raise(rb_eTypeError, "fourth argument (maxmem) must be a Fixnum");
   }
 
   if (FIXNUM_P(rb_maxmemfrac) || TYPE(rb_maxmemfrac) == T_FLOAT) {
     maxmemfrac = NUM2DBL(rb_maxmemfrac);
   }
   else {
-    rb_raise(rb_eTypeError, "fourth argument (maxmemfrac) must be a Fixnum or Float");
+    rb_raise(rb_eTypeError, "fifth argument (maxmemfrac) must be a Fixnum or Float");
   }
 
   if (FIXNUM_P(rb_maxtime) || TYPE(rb_maxtime) == T_FLOAT) {
     maxtime = NUM2DBL(rb_maxtime);
   }
   else {
-    rb_raise(rb_eTypeError, "fifth argument (maxtime) must be a Fixnum or Float");
+    rb_raise(rb_eTypeError, "sixth argument (maxtime) must be a Fixnum or Float");
   }
 
-  rb_out = rb_str_new(NULL, data_len);
-  out = RSTRING_PTR(rb_out);
+  GetOpenFile(rb_infile, in_p);
+  in = rb_io_stdio_file(in_p);
+  GetOpenFile(rb_outfile, out_p);
+  out = rb_io_stdio_file(out_p);
+
+  if (encrypt) {
+    errorcode = scryptenc_file(in, out, (const uint8_t *) password,
+        password_len, maxmem, maxmemfrac, maxtime);
+  }
+  else {
+    errorcode = scryptdec_file(in, out, (const uint8_t *) password,
+        password_len, maxmem, maxmemfrac, maxtime);
+  }
+  rb_io_close(rb_infile);
+  rb_io_close(rb_outfile);
 
-  errorcode = scryptdec_buf((const uint8_t *) data, data_len,
-      (uint8_t *) out, &out_len, (const uint8_t *) password, password_len,
-      maxmem, maxmemfrac, maxtime);
   if (errorcode) {
     raise_scrypty_error(errorcode);
   }
-  rb_str_set_len(rb_out, out_len);
 
-  return rb_out;
+  return Qnil;
+}
+
+VALUE
+scrypty_encrypt_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
+  VALUE rb_obj;
+  VALUE rb_infn;
+  VALUE rb_outfn;
+  VALUE rb_password;
+  VALUE rb_maxmem;
+  VALUE rb_maxmemfrac;
+  VALUE rb_maxtime;
+{
+  return scrypty_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem,
+      rb_maxmemfrac, rb_maxtime, 1);
+}
+
+VALUE
+scrypty_decrypt_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem, rb_maxmemfrac, rb_maxtime)
+  VALUE rb_obj;
+  VALUE rb_infn;
+  VALUE rb_outfn;
+  VALUE rb_password;
+  VALUE rb_maxmem;
+  VALUE rb_maxmemfrac;
+  VALUE rb_maxtime;
+{
+  return scrypty_file(rb_obj, rb_infn, rb_outfn, rb_password, rb_maxmem,
+      rb_maxmemfrac, rb_maxtime, 0);
 }
 
 void
 Init_scrypty_ext(void)
 {
   mScrypty = rb_define_module("Scrypty");
-  rb_define_singleton_method(mScrypty, "encrypt", scrypty_encrypt, 5);
-  rb_define_singleton_method(mScrypty, "decrypt", scrypty_decrypt, 5);
+  rb_define_singleton_method(mScrypty, "encrypt", scrypty_encrypt_buffer, 5);
+  rb_define_singleton_method(mScrypty, "decrypt", scrypty_decrypt_buffer, 5);
+  rb_define_singleton_method(mScrypty, "encrypt_file", scrypty_encrypt_file, 6);
+  rb_define_singleton_method(mScrypty, "decrypt_file", scrypty_decrypt_file, 6);
 
   eScryptyError = rb_define_class_under(mScrypty, "Exception", rb_eException);
   eMemoryLimitError = rb_define_class_under(mScrypty, "MemoryLimitError", eScryptyError);

data/lib/scrypty/version.rb

@@ -1,3 +1,3 @@
 module Scrypty
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/scrypty.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["viking@pillageandplunder.net"]
   gem.description   = %q{Uses the scrypt algorithm by Colin Percival to encrypt/decrypt data}
   gem.summary       = %q{Utility to encrypt/decrypt data with the scrypt algorithm}
-  gem.homepage      = "https://github.com/viking/scrypt-full"
+  gem.homepage      = "https://github.com/viking/scrypty"
 
   gem.files         = `git ls-files`.split($/)
   gem.extensions    = gem.files.grep(%r{extconf.rb})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scrypty
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -45,7 +45,7 @@ files:
 - lib/scrypty.rb
 - lib/scrypty/version.rb
 - scrypty.gemspec
-homepage: https://github.com/viking/scrypt-full
+homepage: https://github.com/viking/scrypty
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -70,4 +70,3 @@ signing_key:
 specification_version: 3
 summary: Utility to encrypt/decrypt data with the scrypt algorithm
 test_files: []
-has_rdoc: