id_shuffler 0.0.6 → 0.0.8

data/ext/id_shuffler/id_shuffler.c

@@ -13,9 +13,15 @@
  *
  * - the feistel network round function returns 15 bits instead of 16
  *
- * - use uint32_t explicitely where necessary to ensure 32-bit numbers
+ * - use uint32_t explicitly where necessary to ensure 32-bit numbers
  *   on 64-bit platforms
  *
+ * - use uint8_t also, instead of char, to ensure unsignedness as well as
+ *   express that we're not really treating them are chars, but as small
+ *   numbers. the original code used vanilla char which resulted in
+ *   compile-time differences in output depending on the compiler/platform
+ *   etc.
+ *
  * - use 6-digits of 'crockford' base-32 armor on the shuffled ids. this not
  *   only prevents them from looking completely like numbers but also ensures
  *   they are a constant length, which is very handy for the sake of future
@@ -31,9 +37,7 @@
  *
  */
 
-const int i = 1;
-
-const unsigned char ftable[256] = { 
+const uint8_t ftable[256] = { 
 0xa3,0xd7,0x09,0x83,0xf8,0x48,0xf6,0xf4,0xb3,0x21,0x15,0x78,0x99,0xb1,0xaf,0xf9,
 0xe7,0x2d,0x4d,0x8a,0xce,0x4c,0xca,0x2e,0x52,0x95,0xd9,0x1e,0x4e,0x38,0x44,0x28,
 0x0a,0xdf,0x02,0xa0,0x17,0xf1,0x60,0x68,0x12,0xb7,0x7a,0xc3,0xe9,0xfa,0x3d,0x53,
@@ -52,7 +56,7 @@ const unsigned char ftable[256] = {
 0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
 };
 
-uint32_t g(unsigned char key[10], int k, uint32_t w)
+uint32_t g(uint8_t key[10], uint8_t k, uint32_t w)
 {
     uint8_t g1, g2, g3, g4, g5, g6;
 
@@ -67,25 +71,11 @@ uint32_t g(unsigned char key[10], int k, uint32_t w)
     return (((g5<<8) + g6) & 32767); /* clip result to 15 bits */
 }
 
-static VALUE r_is_big_endian(VALUE self) {
-  return ULONG2NUM(is_bigendian());
-}
-
-static VALUE r_g1(VALUE self) {
-  unsigned char key[10] = {1,2,3,4,5,6,7,8,9,10};
-  return ULONG2NUM(g(key,1,1));
-}
-
-static VALUE r_g2(VALUE self) {
-  unsigned char key[10] = {1,2,3,4,5,6,7,8,9,10};
-  return ULONG2NUM(g(key,1,32767));
-}
-
-uint32_t skip30(unsigned char key[10], uint32_t num, int encrypt)
+uint32_t skip30(uint8_t key[10], uint32_t num, int encrypt)
 {
-    int         k; /* round number */
-    int         i; /* round counter */
-    int         kstep;
+    uint8_t     k; /* round number */
+    uint8_t     i; /* round counter */
+    int8_t      kstep;
     uint32_t    wl, wr;
 
     /* sort out direction */
@@ -109,44 +99,6 @@ uint32_t skip30(unsigned char key[10], uint32_t num, int encrypt)
     return (wr << 15) + (wl);
 }
 
-static VALUE r_skip1(VALUE self) {
-  unsigned char key[10] = {1,2,3,4,5,6,7,8,9,10};
-  return ULONG2NUM(skip30(key,1,1));
-}
-
-static VALUE r_skip2(VALUE self) {
-  unsigned char key[10] = {1,2,3,4,5,6,7,8,9,10};
-  return ULONG2NUM(skip30(key,32767,1));
-}
-
-static VALUE r_skip3(VALUE self, VALUE original_num) {
-  unsigned char key[10] = {1,2,3,4,5,6,7,8,9,10};
-  unsigned long original_ulong;
-  original_ulong = NUM2ULONG(original_num);
-  uint32_t original = original_ulong;
-  return ULONG2NUM(skip30(key,original,1));
-}
-
-static VALUE r_skip4(VALUE self, VALUE original_num, VALUE key_str) {
-  unsigned char *key = StringValuePtr(key_str);
-  unsigned long original_ulong;
-  original_ulong = NUM2ULONG(original_num);
-  uint32_t original = original_ulong;
-  return ULONG2NUM(skip30(key,original,1));
-}
-
-//uint32_t little_endian_swap(uint32_t num)
-//{
-//  if (is_bigendian()) {
-//    return num;
-//  } else {
-//    return ((num>>24)&0xff) | // move byte 3 to byte 0
-//           ((num<<8)&0xff0000) | // move byte 1 to byte 2
-//           ((num>>8)&0xff00) | // move byte 2 to byte 1
-//           ((num<<24)&0xff000000); // byte 0 to byte 3
-//  }
-//}
-
 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. */
@@ -154,7 +106,7 @@ static VALUE r_base32_shuffle(VALUE self, VALUE original_num, VALUE key_str) {
   /* convert from ruby objects */
   unsigned long original_ulong;
   original_ulong = NUM2ULONG(original_num);
-  unsigned char *key = StringValuePtr(key_str);
+  uint8_t *key = StringValuePtr(key_str);
 
   /* bounds check the id */
   if (original_ulong >= (1 << 30)) {
@@ -168,13 +120,12 @@ static VALUE r_base32_shuffle(VALUE self, VALUE original_num, VALUE key_str) {
 
   /* encrypt */
   uint32_t original = original_ulong;
-  //uint32_t shuffled = skip30(key, little_endian_swap(original), 1);
   uint32_t shuffled = skip30(key, original, 1);
 
   /* base-32 encode the result using "crockford 32" alphabet */
   unsigned char buf[6];
   unsigned char *digits = "0123456789abcdefghjkmnpqrstvwxyz";
-  int cpos;
+  uint8_t cpos;
   for (cpos = 0; cpos < 6; cpos ++) {
     buf[cpos] = digits[((shuffled >> (5*(5-cpos))) & 31)];
   }
@@ -183,20 +134,6 @@ static VALUE r_base32_shuffle(VALUE self, VALUE original_num, VALUE key_str) {
   return rb_str_new(buf,6);
 }
 
-static VALUE r_b32(VALUE self, VALUE original_num) {
-  unsigned char buf[6];
-  unsigned char *digits = "0123456789abcdefghjkmnpqrstvwxyz";
-  int cpos;
-  unsigned long original_ulong;
-  original_ulong = NUM2ULONG(original_num);
-  uint32_t original = original_ulong;
-  for (cpos = 0; cpos < 6; cpos ++) {
-    buf[cpos] = digits[((original >> (5*(5-cpos))) & 31)];
-  }
-  return rb_str_new(buf,6);
-}
-
-
 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. */
@@ -206,12 +143,12 @@ static VALUE r_base32_unshuffle(VALUE self, VALUE shuffled_str, VALUE key_str) {
    * -> "a" etc.  */
 
   /* convert from ruby string to char buf */
-  unsigned char *b32 = StringValuePtr(shuffled_str);
+  uint8_t *b32 = StringValuePtr(shuffled_str);
   if (RSTRING_LEN(shuffled_str) != 6) {
     /* must be 6 base-32 digits */
     return INT2NUM(-1);
   }
-  unsigned char *key = StringValuePtr(key_str);
+  uint8_t *key = StringValuePtr(key_str);
   if (RSTRING_LEN(key_str) < 10) {
     return rb_str_new2("invalid key length");
   }
@@ -220,11 +157,11 @@ static VALUE r_base32_unshuffle(VALUE self, VALUE shuffled_str, VALUE key_str) {
   uint32_t shuffled = 0;
   unsigned char *found;
   unsigned char *digits = "0123456789abcdefghjkmnpqrstvwxyz";
-  int cpos = 0;
+  uint8_t cpos = 0;
   for (cpos = 0; cpos < 6; cpos++) {
     found = strchr(digits,b32[cpos]);
     if (found) {
-      int pos = (found - digits);
+      uint8_t pos = (found - digits);
       shuffled = shuffled + (pos << (5 * (5-cpos)));
     } else {
       /* not valid "crockford" base-32 */
@@ -233,28 +170,51 @@ static VALUE r_base32_unshuffle(VALUE self, VALUE shuffled_str, VALUE key_str) {
   }
 
   /* decrypt */
-  //uint32_t original = little_endian_swap( skip30(key, shuffled, 0) );
   uint32_t original = skip30(key, shuffled, 0);
 
   /* return a ruby number */
   return ULONG2NUM(original);
 }
 
+/* like above, but no base 32: */
+
+static VALUE r_shuffle(VALUE self, VALUE original_num, VALUE key_str) {
+  unsigned long original_ulong;
+  original_ulong = NUM2ULONG(original_num);
+  uint8_t *key = StringValuePtr(key_str);
+  if (original_ulong >= (1 << 30)) {
+    return rb_str_new2("input integer exceeds 30-bit maximum");
+  }
+  if (RSTRING_LEN(key_str) < 10) {
+    return rb_str_new2("invalid key length");
+  }
+  uint32_t original = original_ulong;
+  uint32_t shuffled = skip30(key, original, 1);
+  return ULONG2NUM(shuffled);
+}
+
+static VALUE r_unshuffle(VALUE self, VALUE shuffled_num, VALUE key_str) {
+  unsigned long shuffled_ulong;
+  shuffled_ulong = NUM2ULONG(shuffled_num);
+  uint8_t *key = StringValuePtr(key_str);
+  if (RSTRING_LEN(key_str) < 10) {
+    return rb_str_new2("invalid key length");
+  }
+  uint32_t shuffled = shuffled_ulong;
+  uint32_t original = skip30(key, shuffled, 0);
+  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. the ruby module
    * in id_shuffler.rb should be the only one to ever call these, clients
    * should use the module's interface */
   VALUE klass = rb_define_class("IdShuffler", rb_cObject);
-  rb_define_singleton_method(klass, "shuffle_with_raw_key", r_base32_shuffle, 2);
-  rb_define_singleton_method(klass, "unshuffle_with_raw_key", r_base32_unshuffle, 2);
-  rb_define_singleton_method(klass, "is_bigendian", r_is_big_endian,0);
-  rb_define_singleton_method(klass, "g1", r_g1,0);
-  rb_define_singleton_method(klass, "g2", r_g2,0);
-  rb_define_singleton_method(klass, "skip1", r_skip1,0);
-  rb_define_singleton_method(klass, "skip2", r_skip2,0);
-  rb_define_singleton_method(klass, "skip3", r_skip3,1);
-  rb_define_singleton_method(klass, "skip4", r_skip4,2);
-  rb_define_singleton_method(klass, "b32", r_b32,1);
+  rb_define_singleton_method(klass, "b32_shuffle_with_raw_key", r_base32_shuffle, 2);
+  rb_define_singleton_method(klass, "b32_unshuffle_with_raw_key", r_base32_unshuffle, 2);
+  /* and the non-base32 versions, which are only used for testing and inspection */
+  rb_define_singleton_method(klass, "shuffle_with_raw_key", r_shuffle, 2);
+  rb_define_singleton_method(klass, "unshuffle_with_raw_key", r_unshuffle, 2);
 }
 

data/lib/id_shuffler.rb

@@ -9,6 +9,8 @@ require 'digest/md5'
 
 class IdShuffler
 
+  VERSION = "0.0.8"
+
   def initialize(key)
     @key = Digest::MD5.digest(key)
   end
@@ -22,11 +24,21 @@ class IdShuffler
   # - unshuffle_with_raw_key
 
   def shuffle(i)
-    self.class.shuffle_with_raw_key(i.to_i, @key)
+    self.class.b32_shuffle_with_raw_key(i.to_i, @key)
   end
 
   def unshuffle(s)
-    self.class.unshuffle_with_raw_key(s.to_s, @key)
+    self.class.b32_unshuffle_with_raw_key(s.to_s, @key)
+  end
+
+  # and now these, too, for testing.
+  
+  def i_shuffle(i)
+    self.class.shuffle_with_raw_key(i.to_i, @key)
+  end
+
+  def i_unshuffle(i)
+    self.class.unshuffle_with_raw_key(i.to_i, @key)
   end
 
   # these class methods are here for convenience but they are slower because the
@@ -34,11 +46,258 @@ class IdShuffler
   # key.
 
   def self.shuffle(i, key)
-    shuffle_with_raw_key(i.to_i, Digest::MD5.digest(key))
+    b32_shuffle_with_raw_key(i.to_i, Digest::MD5.digest(key))
   end
 
   def self.unshuffle(s, key)
-    unshuffle_with_raw_key(s.to_s, Digest::MD5.digest(key))
+    b32_unshuffle_with_raw_key(s.to_s, Digest::MD5.digest(key))
+  end
+
+  def self.i_shuffle(i, key)
+    shuffle_with_raw_key(i.to_i, Digest::MD5.digest(key))
+  end
+
+  def self.i_unshuffle(i, key)
+    unshuffle_with_raw_key(i.to_i, Digest::MD5.digest(key))
+  end
+
+  # a sanity check using precomputed values. returns true if tests pass.
+  def self.test(verbose = false)
+    keys = %w{
+    9628461411983823
+    1734283002173318
+    016326850581415475
+    6484228424403272
+    061268721086567
+    13691235382636435
+    3211531955213043
+    11726965179508919
+    7766920746107023
+    5595470614030541
+    8801161592508207
+    3061758398848765
+    4245735393732285
+    23026931842058007
+    17291255562103658
+    5341931588780643
+    7960006634049325
+    023251244403061144
+    37605530799342857
+    27669384149797127
+    9437905104510069
+    4114673054649628
+    20168465656121792
+    5482562496994766
+    7324290711933842
+    009976875465969703
+    7168968770799556
+    8149447986805111
+    08491242832314072
+    8223714655402778
+    3876565402541112
+    46733376760423295
+    5298977054488807
+    5935723180013883
+    0317512792098289
+    9310742102954396
+    17829324559545612
+    6746884367300644
+    3535616496028713
+    5127263511285141
+    3164406333857237
+    0343119765601525
+    011512965180400236
+    15982217865696302
+    443806710798218
+    12100659169950201
+    147579537614696
+    8322004794028289
+    5514473449313436
+    16312956181460625
+    650702449763699
+    9498182202542627
+    10722624566120331
+    4883115307765591
+    20424102208596506
+    5142750054579913
+    05537581122671387
+    20762553275459616
+    04917099540401215
+    07918051495924183
+    2522783158673356
+    4111833188359838
+    6774194800874695
+    7660083998825198
+    31163333711689467
+    15678056488782888
+    265278223696121
+    41643913578769354
+    6030043722242956
+    2960307106289347
+    5549096461395291
+    8915190041698866
+    4057759730209265
+    8018734599400228
+    5543421583995795
+    9979325828812361
+    5617682617366149
+    15112497024998717
+    4689113002173503
+    7874401856697474
+    20106075965085923
+    5965386545158813
+    4814632612885722
+    22075362777051932
+    23472709637587308
+    10373982789260561
+    09897287005029487
+    4768655223208501
+    6849139321392613
+    29168126625962554
+    7833789806365968
+    7114460449930401
+    8385015784891404
+    7960586688341696
+    7048858419071817
+    9921461615055903
+    6129622811680446
+    6516458355309123
+    20860516685452057
+    6474867677950523
+    }
+
+    expect = %w{
+    69h72p 211328086 
+    99adag 311768400 
+    8501gw 273679900 
+    w1pk93 941313315 
+    1w46c9 63052169  
+    st2ww4 866218884 
+    z7d2mk 1047956115
+    svmb8v 867839259 
+    c1c4ab 404099403 
+    1xzam9 64989833  
+    3a2fng 111230640 
+    5wrbd0 197930400 
+    5rvmr1 193843969 
+    zc6xvc 1052997484
+    byvpxv 401464251 
+    whcgh9 957760041 
+    t0txmv 873297563 
+    2rvjn6 93178534  
+    2km7gg 87694864  
+    8kccv7 288764775 
+    0pjh06 23675910  
+    vvcc35 934686821 
+    d9xtqk 446622451 
+    44sz7b 139263211 
+    j04s48 604136584 
+    ynds7p 1029104886
+    56348t 174166298 
+    kg6vdw 654536124 
+    evvn76 498980070 
+    38qnz4 109828068 
+    x98cf6 982790630 
+    6w25ba 230757738 
+    pv42jt 766642778 
+    19snhy 43832894  
+    gbghn5 548947621 
+    nc2p2s 717314137 
+    n9bwzc 714470380 
+    4y9sjn 165996117 
+    n375hx 708023869 
+    q6rnnv 778852027 
+    r4vwq6 810414822 
+    016hdm 1263028   
+    d004px 436212445 
+    6a4qbb 211967339 
+    nf55ec 720541132 
+    7y47vk 266477427 
+    betn9j 384652594 
+    4jgmwy 153637790 
+    9f01fc 317720044 
+    bsstgf 396159503 
+    x7crj6 980836934 
+    g5ba33 542484579 
+    r1ngmj 807060114 
+    12emzz 36131839  
+    ejj7cd 489233805 
+    kezz0c 653261836 
+    3agtj4 111700548 
+    jcc9h3 616965667 
+    m4tkd9 676154793 
+    7jg3n0 254283424 
+    jmg1sv 625477435 
+    z1gk1q 1041779767
+    mg61bq 688063863 
+    f39p9d 506779949 
+    d0nr82 436920578 
+    sy0w1f 870346799 
+    bmqyag 390854992 
+    khftn1 655878817 
+    7xp5ef 266016207 
+    mhb4bd 689279341 
+    1mvtwf 55438223  
+    sae8m0 849814144 
+    1y55ac 65181004  
+    512d2y 168899678 
+    faegj3 514277955 
+    47x2v6 142510950 
+    jxf340 634883200 
+    5xvyzy 199097342 
+    0qttna 24996522  
+    865qrn 274915093 
+    akdyyb 355924939 
+    sa2dy1 849426369 
+    t6keqv 879344379 
+    6zgqsk 234381107 
+    jqhtfq 628681207 
+    vbpw6r 918253784 
+    q9np1b 781899819 
+    70bwc3 235270531 
+    sw21qn 868288245 
+    mn4dsk 693253939 
+    y9s1ze 1016891374
+    mxrtpk 702311123 
+    95bew4 307608452 
+    2ksg3g 87867504  
+    zhr2ym 1058802644
+    mvjv77 700017895 
+    97svdz 310177215 
+    92js4d 304702605 
+    fdybg4 517942788 
+    azgfjm 368590420 
+    }
+
+    if verbose
+      puts "IdShuffler version: #{VERSION}"
+      printf "orig -> shuf32 (shuf int) [expect shuf32 (shuf int)] -> unshuf32 (unshuf) : result\n"
+    end
+    n = 0
+    idx = 0
+    all_pass = true
+    keys.each do |key|
+      shuffled = self.shuffle(n,key)
+      unshuffled = self.unshuffle(shuffled,key)
+      i_shuffled = self.i_shuffle(n,key)
+      i_unshuffled = self.i_unshuffle(i_shuffled,key)
+      expect_shuffled = expect[idx * 2]
+      expect_i_shuffled = expect[idx * 2 + 1].to_i
+      pass = (n == unshuffled && n == i_unshuffled && shuffled == expect_shuffled && i_shuffled == expect_i_shuffled)
+      if verbose
+        printf "%d -> %s (%d) [expect %s (%d)] -> %d (%d) : %s\n", n, shuffled, i_shuffled, expect_shuffled, expect_i_shuffled, unshuffled, i_unshuffled, (pass ? "PASS" : "FAIL")
+      end
+      n = i_shuffled
+      idx += 1
+      all_pass = all_pass && pass
+    end
+    if all_pass
+      puts "ALL PASSED" if verbose
+      return true
+    else
+      puts "FAILED" if verbose
+      return false
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: id_shuffler
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-20 00:00:00.000000000 Z
+date: 2013-06-12 00:00:00.000000000 Z
 dependencies: []
 description: ! '