masked_id 0.0.2 → 0.0.3

data/lib/masked_id.rb

@@ -1,4 +1,5 @@
-require_relative 'masked_id/baffler'
+require 'masked_id/baffler'
+require 'masked_id/model_extensions'
 
 def mask_id
   include MaskedId
@@ -10,13 +11,5 @@ module MaskedId
   def masked_id
     MaskedId::Baffler.baffle_id(self.id, self.class.name.to_i(36))
   end
-    
-  module ModelExtensions
-
-    def find_by_masked_id(id)
-      self.find(MaskedId::Baffler.debaffle_id(id, self.name.to_i(36)))
-    end
-
-  end
 
 end

data/lib/masked_id/baffler.rb

@@ -0,0 +1,21 @@
+#require_relative 'scatter_swap'
+module MaskedId
+  class Baffler
+  
+    def self.baffle_id(original_id, baffler_id)
+      original_id * baffler_id
+      #ScatterSwap.hash(original_id, baffler_id)
+    end
+
+    def self.debaffle_id(baffled_id, baffler_id)
+      baffled_id / baffler_id
+      #ScatterSwap.reverse_hash(baffled_id, baffler_id)
+    end
+
+    def debaffle_param(symbol)
+      params[symbol] = debaffle_id(symbol).to_s if params[symbol]
+    end
+
+  end
+
+end

data/lib/masked_id/scatter_swap.rb

@@ -0,0 +1,140 @@
+module MaskedId
+  class ScatterSwap
+    # This is the hashing function behind ObfuscateId.
+    # https://github.com/namick/obfuscate_id
+    #
+    # Designing a hash function is a bit of a black art and
+    # being that I don't have math background, I must resort
+    # to this simplistic swaping and scattering of array elements.
+    #
+    # After writing this and reading/learning some elemental hashing techniques,
+    # I realize this library is what is known as a Minimal perfect hash function:
+    # http://en.wikipedia.org/wiki/Perfect_hash_function#Minimal_perfect_hash_function
+    #
+    # I welcome all improvements :-)
+    #
+    # If you have some comments or suggestions, please contact me on github
+    # https://github.com/namick
+    #
+    # - nathan amick
+    # 
+    #
+    # This library is built for integers that can be expressed with 10 digits:
+    # It zero pads smaller numbers... so the number one is expressed with:
+    # 0000000001
+    # The biggest number it can deal with is:
+    # 9999999999
+    #
+    # Since we are working with a limited sequential set of input integers, 10 billion,
+    # this algorithm will suffice for simple id obfuscation for many web apps.
+    # The largest value that Ruby on Rails default id, Mysql INT type, is just over 2 billion (2147483647)
+    # which is the same as 2 to the power of 31 minus 1, but considerably less than 10 billion.
+    #
+    # ScatterSwap is an integer hash function designed to have:
+    # - zero collisions ( http://en.wikipedia.org/wiki/Perfect_hash_function )
+    # - achieve avalanche ( http://en.wikipedia.org/wiki/Avalanche_effect )
+    # - reversable
+    #
+    # We do that by combining two distinct strategies.
+    #
+    # 1. Scattering - whereby we take the whole number, slice it up into 10 digits
+    # and rearange their places, yet retaining the same 10 digits.  This allows
+    # us to preserve the sum of all the digits, regardless of order.  This sum acts
+    # as a key to reverse this scattering effect.
+    # 
+    # 2. Swapping - when dealing with many sequential numbers that we don't want
+    # to look similar, scattering wont do us much good because so many of the
+    # digits are the same; it deoesn't help to scatter 9 zeros around, so we need
+    # to swap out each of those zeros for something else.. something different
+    # for each place in the 10 digit array; for this, we need a map so that we
+    # can reverse it.
+
+    # Convience class method pointing to the instance method
+    def self.hash(plain_integer, spin = 0)
+      new(plain_integer, spin).hash
+    end
+
+    # Convience class method pointing to the instance method
+    def self.reverse_hash(hashed_integer, spin = 0)
+      new(hashed_integer, spin).reverse_hash
+    end
+
+    def initialize(original_integer, spin = 0)
+      @original_integer = original_integer
+      @spin = spin
+      zero_pad  = original_integer.to_s.rjust(10, '0')
+      @working_array = zero_pad.split("").collect {|d| d.to_i}
+    end
+
+    attr_accessor :working_array
+
+    # obfuscates an integer up to 10 digits in length
+    def hash
+      swap
+      scatter
+      completed_string
+    end
+
+    # de-obfuscates an integer
+    def reverse_hash
+      unscatter
+      unswap
+      completed_string
+    end
+
+    def completed_string
+      @working_array.join
+    end
+
+    # We want a unique map for each place in the original number
+    def swapper_map(index)
+      array = (0..9).to_a
+      10.times.collect.with_index do |i|
+        array.rotate!(index + i ^ spin).pop
+      end
+    end
+
+    # Using a unique map for each of the ten places,
+    # we swap out one number for another
+    def swap
+      @working_array = @working_array.collect.with_index do |digit, index|
+        swapper_map(index)[digit]
+      end
+    end
+
+    # Reverse swap
+    def unswap
+      @working_array = @working_array.collect.with_index do |digit, index|
+        swapper_map(index).rindex(digit)
+      end
+    end
+
+    # Rearrange the order of each digit in a reversable way by using the 
+    # sum of the digits (which doesn't change regardless of order)
+    # as a key to record how they were scattered
+    def scatter
+      sum_of_digits = @working_array.inject(:+).to_i
+      @working_array = 10.times.collect do 
+        @working_array.rotate!(spin ^ sum_of_digits).pop
+      end
+    end
+
+    # Reverse the scatter
+    def unscatter
+      scattered_array = @working_array
+      sum_of_digits = scattered_array.inject(:+).to_i
+      @working_array = []
+      @working_array.tap do |unscatter| 
+        10.times do
+          unscatter.push scattered_array.pop
+          unscatter.rotate! (sum_of_digits ^ spin) * -1
+        end
+      end
+    end
+
+    # Add some spice so that different apps can have differently mapped hashes
+    def spin
+      @spin || 0
+    end
+  end
+end

metadata

@@ -1,47 +1,65 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: masked_id
-version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
-authors:
+authors: 
 - William Basmayor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-12 00:00:00.000000000 Z
+
+date: 2013-02-05 00:00:00 +08:00
+default_executable: 
 dependencies: []
-description: Masks the original ID of a class with a unique obfuscated value per object
-  type.
-email:
+
+description: Masks the original ID of a class with a unique obfuscated value per object type.
+email: 
 - wbasmayor@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/masked_id.rb
+- lib/masked_id/baffler.rb
+- lib/masked_id/scatter_swap.rb
+has_rdoc: true
 homepage: 
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+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'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Unique ID masking by class.
 test_files: []
+