id_shuffler 0.0.0

data/ext/id_shuffler/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+create_makefile('id_shuffler/id_shuffler')
+

data/ext/id_shuffler/id_shuffler.c

@@ -0,0 +1,110 @@
+#include <ruby.h>
+
+static VALUE r_base32_shuffle(VALUE self, VALUE original_num, VALUE key_str) {
+  // takes a number and a key string as input and returns a base-32 encoded
+  // shuffled id.
+
+  // convert from ruby objects to local long/string
+  unsigned long original;
+  original = NUM2ULONG(original_num);
+  char *key = StringValuePtr(key_str);
+  // bounds check the id
+  if (original >= (1 << 30)) {
+    return rb_str_new2("");
+  }
+  // initialize the feistel network and lfsr
+  unsigned int keypos, key_len;
+  unsigned long l, r, r_orig;
+  unsigned long lfsr_bit, lfsr_outbit, lfsr_num;
+  l = (original >> 15) & 32767;
+  r = original & 32767;
+  key_len = strlen(key);
+  // apply the feistel network in a loop over each char in key. the round
+  // function uses the key char as the taps mask for a single iteration of an
+  // lfsr.
+  for (keypos = 0; keypos < key_len; keypos++) {
+    r_orig = r;
+    lfsr_num = r+key[keypos];
+    lfsr_outbit = 0;
+    for (lfsr_bit = 0; lfsr_bit < 15; lfsr_bit++) {
+      if ((key[keypos] & (1 >> lfsr_bit)) > 0) {
+        lfsr_outbit = lfsr_outbit ^ ((lfsr_num & (1 >> lfsr_bit)) >> lfsr_bit);
+      }
+    }
+    lfsr_num = (lfsr_num >> 1) + (lfsr_outbit << 14);
+    lfsr_num = lfsr_num & 32767;
+    r = (l ^ lfsr_num);
+    l = r_orig;
+  }
+  // base32 encode the result
+  unsigned long shuffled;
+  shuffled = (l << 15) + r;
+  char buf[6];
+  char *digits = "0123456789abcdefghijklmnopqrstuv";
+  int cpos;
+  for (cpos = 0; cpos < 6; cpos ++) {
+    buf[cpos] = digits[((shuffled >> (5*(5-cpos))) & 31)];
+  }
+  // return a ruby string
+  return rb_str_new2(buf);
+}
+
+static VALUE r_base32_unshuffle(VALUE self, VALUE shuffled_str, VALUE key_str) {
+  // take the a base-32 encoded ruby string and a key string, decodes and
+  // unshuffles it, producing the original number.
+
+  // convert from ruby string to local buf
+  char *b32 = StringValuePtr(shuffled_str);
+  char *key = StringValuePtr(key_str);
+  // remove base32 encoding
+  unsigned int shuffled = 0;
+  char *found;
+  char *digits = "0123456789abcdefghijklmnopqrstuv";
+  if (strlen(b32) != 6) {
+    return INT2NUM(-1);
+  }
+  int cpos = 0;
+  for (cpos = 0; cpos < 6; cpos++) {
+    found = strchr(digits,b32[cpos]);
+    if (found) {
+      int pos = (found - digits);
+      shuffled = shuffled + (pos << (5 * (5-cpos)));
+    } else {
+      return INT2NUM(-1);
+    }
+  }
+  // iterate the feistel network in reverse
+  int keypos,key_len;
+  unsigned long l, r, l_orig;
+  unsigned long lfsr_bit, lfsr_outbit, lfsr_num;
+  l = (shuffled >> 15) & 32767;
+  r = shuffled & 32767;
+  key_len = strlen(key);
+  for (keypos = (key_len - 1); keypos >= 0; keypos--) {
+    l_orig = l;
+    lfsr_num = l+key[keypos];
+    lfsr_outbit = 0;
+    for (lfsr_bit = 0; lfsr_bit < 15; lfsr_bit++) {
+      if ((key[keypos] & (1 >> lfsr_bit)) > 0) {
+        lfsr_outbit = lfsr_outbit ^ ((lfsr_num & (1 >> lfsr_bit)) >> lfsr_bit);
+      }
+    }
+    lfsr_num = (lfsr_num >> 1) + (lfsr_outbit << 14);
+    lfsr_num = lfsr_num & 32767;
+    l = (r ^ lfsr_num);
+    r = l_orig;
+	}
+  // return the resulting original number as a ruby fixnum
+  unsigned long original;
+	original = (l << 15) + r;
+  return ULONG2NUM(original);
+}
+
+void Init_id_shuffler(void) {
+  // add two class methods to our IdShuffler class: shuffle and unshuffle, each
+  // of which take the object to be [unshuffled] and the key.
+	VALUE klass = rb_define_class("IdShuffler", rb_cObject);
+	rb_define_singleton_method(klass, "shuffle", r_base32_shuffle, 2);
+	rb_define_singleton_method(klass, "unshuffle", r_base32_unshuffle, 2);
+}
+

data/lib/id_shuffler.rb

@@ -0,0 +1,28 @@
+# load the c extension
+require 'id_shuffler/id_shuffler'
+
+# key strings are hashed via md5 to make them a good length (the shuffle algo
+# iterates once per character in the key) as well as to provide good spread of
+# bits per character (whearas a plain text ascii key would only use a narrow
+# range of bits)
+require 'digest/md5'
+
+class IdShuffler
+
+  def initialize(key)
+    @key = Digest::MD5.digest(key)
+  end
+
+  def key=(key)
+    @key = Digest::MD5.digest(key)
+  end
+
+  def shuffle(i)
+    self.class.shuffle(i.to_i, @key)
+  end
+
+  def unshuffle(s)
+    self.class.unshuffle(s.to_s, @key)
+  end
+
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: id_shuffler
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Josh Whiting
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-20 00:00:00.000000000 Z
+dependencies: []
+description: ! '
+
+  An efficient solution to use when it is undesirable to expose internal database
+
+  ids, IdShuffler converts integers like 123 into strings like ''q34nr1'', and
+
+  vice-versa, using a very lightweight integer scrambling algorithm plus
+
+  ''Crockford 32'' encoding. It is built as a native C extension and so is very
+
+  fast. The algorithm takes a string key as a seed, so you can use different
+
+  keys for different id spaces and thus obtain different slugs for the same
+
+  initial integer. This is not a security solution and I am not a cryptographer;
+
+  it should be assumed a determined individual can unshuffle the ids without
+
+  knowing the key used to generate them. Also note these are 30-bit ids, so the
+
+  library can only represent values up to approximately 1 billion
+
+  (1,073,741,823).
+
+
+  This gem is still under development in so far as I have not written tests or
+
+  documentation for it.
+
+
+'
+email: josh@protagonistlabs.com
+executables: []
+extensions:
+- ext/id_shuffler/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/id_shuffler.rb
+- ext/id_shuffler/id_shuffler.c
+- ext/id_shuffler/extconf.rb
+homepage: http://rubygems.org/gems/id_shuffler
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Turns private database ids into lightly-encrypted public-facing strings
+test_files: []