integer-obfuscator 0.1.0

data/.document

@@ -0,0 +1,3 @@
+lib/**/*.rb
+-
+MIT-LICENSE.txt skip32.c.md

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+.yardoc
+Gemfile.lock
+doc

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2011 John Nishinaga and Pat Deegan, PhD & Associates, LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Integer Obfuscator
+
+This is a tool for obfuscating 32-bits integers.  More specifically,
+`IntegerObfuscator` will one-to-one transform a 32-bit integer to another
+32-bit integer using a 32-bit block cipher based on SKIPJACK.
+
+This is useful when you want to transform sequentially generated
+IDs (e.g. database IDs) into integers that don't have an obvious ordering.
+
+## Installation
+
+    gem install integer-obfuscator
+
+## Example
+
+    require 'rubygems'
+    require 'integer_obfuscator'
+    
+    c = IntegerObfuscator.new("my secret key")
+    c.obfuscate(1)            # => 418026769
+    c.obfuscate(2)            # => 1524067781
+    c.obfuscate(3)            # => 1476269236
+    c.unobfuscate(418026769)  # => 1
+    c.unobfuscate(1524067781) # => 2
+    c.unobfuscate(1476269236) # => 3
+
+## Warnings
+
+This code...
+
+1. is not intended to be cryptographically secure.
+3. is slow (i.e., pure Ruby implementation).
+4. only handles integers up to 32-bits in size.
+
+## References
+
+This is based directly on the Perl Crypt::Skip32 module and the Greg Rose's
+original C implementation.
+
+* <http://search.cpan.org/~esh/Crypt-Skip32-0.15/lib/Crypt/Skip32.pm>
+* <http://www.qualcomm.com.au/PublicationsDocs/skip32.c>
+
+## Copyright and License
+
+Copyright (c) 2010-2011 Pat Deegan, PhD & Associates, LLC. Released under
+the MIT license. See the license file for details.

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler.setup
+
+Bundler::GemHelper.install_tasks
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/integer-obfuscator.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "integer_obfuscator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "integer-obfuscator"
+  s.version     = IntegerObfuscator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Nishinaga"]
+  s.email       = ["jingoro@casa-z.org"]
+  s.homepage    = "https://github.com/patdeegan/integer-obfuscator"
+  s.summary     = "integer-obfuscator-#{IntegerObfuscator::VERSION}"
+  s.description = "Obfuscate 32-bit Integers using a 32-bit block cipher based on SKIPJACK"
+
+  s.rubyforge_project = "integer-obfuscator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'bluecloth'
+  s.add_development_dependency 'rspec'
+
+end

data/lib/cipher/skip32.rb

@@ -0,0 +1,134 @@
+module Cipher
+  
+  # A 32-bit version of the SKIPJACK cipher.  This interface is not intended to be
+  # compatible with the OpenSSL::Cipher modules.
+  class Skip32
+    
+    class Error < RuntimeError
+    end
+    
+    # @param key [String] the key
+    # @raise [Error] if `key` is too short
+    def initialize(key)
+      raise Error, "key length too short" if key.length < key_len
+      @key = key.unpack("C*")
+    end
+    
+    # Encrypts `block` and returns the result
+    # @return [String] the encrypted block
+    # @raise [Error] if `block` is too short
+    def encrypt(block)
+      buffer = unpack(block)
+      skip32(@key, buffer, true)
+      pack(buffer)
+    end
+    
+    # Decrypts `block` and returns the result
+    # @return [String] the decrypted block
+    # @raise [Error] if `block` is too short
+    def decrypt(block)
+      buffer = unpack(block)
+      skip32(@key, buffer, false)
+      pack(buffer)
+    end
+    
+    # Returns a string representation of the object
+    # @return [String] a string representation of the object
+    def inspect
+      "#<Cipher::Skip32:#{object_id}>"
+    end
+    
+    # Returns the block size
+    # @return [Integer] the block size
+    def block_size
+      4
+    end
+    
+    # Returns the key length
+    # @return [Integer] the key length
+    def key_len
+      10
+    end
+
+    private
+    
+      # @param block [String] the block to unpack
+      # @return [Array] the resulting buffer
+      # @raise [Error] if `block` is too short
+      def unpack(block)
+        raise Error, "block length too short" if block.length < block_size
+        block.unpack("C*")
+      end
+
+      # @param buffer [Array] the buffer to pack
+      # @return [String] the resulting block
+      def pack(buffer)
+        buffer.pack("C*")
+      end
+      
+      # The Feistel table
+      FTABLE = [
+        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,
+        0x96,0x84,0x6b,0xba,0xf2,0x63,0x9a,0x19,0x7c,0xae,0xe5,0xf5,0xf7,0x16,0x6a,0xa2,
+        0x39,0xb6,0x7b,0x0f,0xc1,0x93,0x81,0x1b,0xee,0xb4,0x1a,0xea,0xd0,0x91,0x2f,0xb8,
+        0x55,0xb9,0xda,0x85,0x3f,0x41,0xbf,0xe0,0x5a,0x58,0x80,0x5f,0x66,0x0b,0xd8,0x90,
+        0x35,0xd5,0xc0,0xa7,0x33,0x06,0x65,0x69,0x45,0x00,0x94,0x56,0x6d,0x98,0x9b,0x76,
+        0x97,0xfc,0xb2,0xc2,0xb0,0xfe,0xdb,0x20,0xe1,0xeb,0xd6,0xe4,0xdd,0x47,0x4a,0x1d,
+        0x42,0xed,0x9e,0x6e,0x49,0x3c,0xcd,0x43,0x27,0xd2,0x07,0xd4,0xde,0xc7,0x67,0x18,
+        0x89,0xcb,0x30,0x1f,0x8d,0xc6,0x8f,0xaa,0xc8,0x74,0xdc,0xc9,0x5d,0x5c,0x31,0xa4,
+        0x70,0x88,0x61,0x2c,0x9f,0x0d,0x2b,0x87,0x50,0x82,0x54,0x64,0x26,0x7d,0x03,0x40,
+        0x34,0x4b,0x1c,0x73,0xd1,0xc4,0xfd,0x3b,0xcc,0xfb,0x7f,0xab,0xe6,0x3e,0x5b,0xa5,
+        0xad,0x04,0x23,0x9c,0x14,0x51,0x22,0xf0,0x29,0x79,0x71,0x7e,0xff,0x8c,0x0e,0xe2,
+        0x0c,0xef,0xbc,0x72,0x75,0x6f,0x37,0xa1,0xec,0xd3,0x8e,0x62,0x8b,0x86,0x10,0xe8,
+        0x08,0x77,0x11,0xbe,0x92,0x4f,0x24,0xc5,0x32,0x36,0x9d,0xcf,0xf3,0xa6,0xbb,0xac,
+        0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
+      ]
+
+      # A Ruby translation of the `skip32.c` `g` function.
+      # @see http://www.qualcomm.com.au/PublicationsDocs/skip32.c
+      def g(key, k, w)
+        g1 = (w>>8)&0xff
+        g2 = w&0xff
+
+        g3 = FTABLE[g2 ^ key[(4*k)%10]] ^ g1
+        g4 = FTABLE[g3 ^ key[(4*k+1)%10]] ^ g2
+        g5 = FTABLE[g4 ^ key[(4*k+2)%10]] ^ g3
+        g6 = FTABLE[g5 ^ key[(4*k+3)%10]] ^ g4
+
+        (g5<<8) + g6
+      end
+  
+      # A Ruby translation of the `skip32.c` `skip32` function.
+      # @see http://www.qualcomm.com.au/PublicationsDocs/skip32.c
+      def skip32(key, buf, encrypt)
+        # sort out direction
+        if encrypt
+          kstep = 1; k = 0
+        else
+          kstep = -1; k = 23
+        end
+    
+        # pack into words
+        wl = (buf[0] << 8) + buf[1]
+        wr = (buf[2] << 8) + buf[3]
+      
+        # 24 feistel rounds, doubled up
+        1.upto(24/2) do
+          wr ^= g(key, k, wl) ^ k
+          k += kstep
+          wl ^= g(key, k, wr) ^ k
+          k += kstep
+        end
+    
+        # implicitly swap halves while unpacking
+        buf[0] = wr >> 8; buf[1] = wr & 0xFF
+        buf[2] = wl >> 8; buf[3] = wl & 0xFF
+    
+        nil
+      end
+
+  end # class Skip32
+
+end # module Cipher

data/lib/integer_obfuscator.rb

@@ -0,0 +1,47 @@
+require 'digest/sha1'
+require 'cipher/skip32'
+require 'integer_obfuscator/version'
+
+# Obfuscates or unobfuscates 32-bit integers using a 32-bit block cipher based on SKIPJACK.
+class IntegerObfuscator
+  
+  class RangeError < ArgumentError
+    def initialize(i)
+      super("#{i.inspect} is not a 32-bit integer")
+    end
+  end
+  
+  MAX_SIZE = (2 ** 32) - 1
+  
+  # Creates an obfuscator
+  # @param key [String] the key used to obfuscate/unobfuscate integers
+  def initialize(key)
+    shakey = Digest::SHA1.digest(key)[0...10]
+    @c = Cipher::Skip32.new(shakey)
+  end
+  
+  # Obfuscates an integer
+  # @param i [Integer] the integer to obfuscate
+  # @return [Integer] the obfuscated integer
+  # @raise [RangeError] if `i` is not a 32-bit integer
+  def obfuscate(i)
+    require_32bit_integer(i)
+    @c.encrypt([i].pack("I")).unpack("I").first
+  end
+  
+  # Unobfuscates an integer
+  # @param i [Integer] the integer to unobfuscate
+  # @return [Integer] the unobfuscated integer
+  # @raise [RangeError] if `i` is not a 32-bit integer
+  def unobfuscate(i)
+    require_32bit_integer(i)
+    @c.decrypt([i].pack("I")).unpack("I").first
+  end
+  
+  private
+  
+    def require_32bit_integer(i)
+      raise RangeError.new(i) if (i > MAX_SIZE || i < 0)
+    end
+    
+end

data/lib/integer_obfuscator/version.rb

@@ -0,0 +1,3 @@
+class IntegerObfuscator
+  VERSION = '0.1.0'
+end

data/skip32.c.md

@@ -0,0 +1,128 @@
+From <http://www.qualcomm.com.au/PublicationsDocs/skip32.c>.
+
+    /* 
+       SKIP32 -- 32 bit block cipher based on SKIPJACK.
+       Written by Greg Rose, QUALCOMM Australia, 1999/04/27.
+
+       In common: F-table, G-permutation, key schedule.
+       Different: 24 round feistel structure.
+       Based on:  Unoptimized test implementation of SKIPJACK algorithm 
+                  Panu Rissanen <bande@lut.fi>
+
+       SKIPJACK and KEA Algorithm Specifications 
+       Version 2.0 
+       29 May 1998
+
+       Not copyright, no rights reserved.
+    */
+
+    typedef unsigned char   BYTE; /* 8 bits */
+    typedef unsigned short  WORD; /* 16 bits */
+
+    const BYTE 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,
+    0x96,0x84,0x6b,0xba,0xf2,0x63,0x9a,0x19,0x7c,0xae,0xe5,0xf5,0xf7,0x16,0x6a,0xa2,
+    0x39,0xb6,0x7b,0x0f,0xc1,0x93,0x81,0x1b,0xee,0xb4,0x1a,0xea,0xd0,0x91,0x2f,0xb8,
+    0x55,0xb9,0xda,0x85,0x3f,0x41,0xbf,0xe0,0x5a,0x58,0x80,0x5f,0x66,0x0b,0xd8,0x90,
+    0x35,0xd5,0xc0,0xa7,0x33,0x06,0x65,0x69,0x45,0x00,0x94,0x56,0x6d,0x98,0x9b,0x76,
+    0x97,0xfc,0xb2,0xc2,0xb0,0xfe,0xdb,0x20,0xe1,0xeb,0xd6,0xe4,0xdd,0x47,0x4a,0x1d,
+    0x42,0xed,0x9e,0x6e,0x49,0x3c,0xcd,0x43,0x27,0xd2,0x07,0xd4,0xde,0xc7,0x67,0x18,
+    0x89,0xcb,0x30,0x1f,0x8d,0xc6,0x8f,0xaa,0xc8,0x74,0xdc,0xc9,0x5d,0x5c,0x31,0xa4,
+    0x70,0x88,0x61,0x2c,0x9f,0x0d,0x2b,0x87,0x50,0x82,0x54,0x64,0x26,0x7d,0x03,0x40,
+    0x34,0x4b,0x1c,0x73,0xd1,0xc4,0xfd,0x3b,0xcc,0xfb,0x7f,0xab,0xe6,0x3e,0x5b,0xa5,
+    0xad,0x04,0x23,0x9c,0x14,0x51,0x22,0xf0,0x29,0x79,0x71,0x7e,0xff,0x8c,0x0e,0xe2,
+    0x0c,0xef,0xbc,0x72,0x75,0x6f,0x37,0xa1,0xec,0xd3,0x8e,0x62,0x8b,0x86,0x10,0xe8,
+    0x08,0x77,0x11,0xbe,0x92,0x4f,0x24,0xc5,0x32,0x36,0x9d,0xcf,0xf3,0xa6,0xbb,0xac,
+    0x5e,0x6c,0xa9,0x13,0x57,0x25,0xb5,0xe3,0xbd,0xa8,0x3a,0x01,0x05,0x59,0x2a,0x46
+    };
+
+    WORD
+    g(BYTE *key, int k, WORD w)
+    {
+        BYTE g1, g2, g3, g4, g5, g6;
+
+        g1 = (w>>8)&0xff;
+        g2 = w&0xff;
+
+        g3 = ftable[g2 ^ key[(4*k)%10]] ^ g1;
+        g4 = ftable[g3 ^ key[(4*k+1)%10]] ^ g2;
+        g5 = ftable[g4 ^ key[(4*k+2)%10]] ^ g3;
+        g6 = ftable[g5 ^ key[(4*k+3)%10]] ^ g4;
+
+        return ((g5<<8) + g6);
+    }
+
+    void
+    skip32(BYTE key[10], BYTE buf[4], int encrypt)
+    {
+        int         k; /* round number */
+        int         i; /* round counter */
+        int         kstep;
+        WORD        wl, wr;
+
+        /* sort out direction */
+        if (encrypt)
+            kstep = 1, k = 0;
+        else
+            kstep = -1, k = 23;
+
+        /* pack into words */
+        wl = (buf[0] << 8) + buf[1];
+        wr = (buf[2] << 8) + buf[3];
+
+        /* 24 feistel rounds, doubled up */
+        for (i = 0; i < 24/2; ++i) {
+            wr ^= g(key, k, wl) ^ k;
+            k += kstep;
+            wl ^= g(key, k, wr) ^ k;
+            k += kstep;
+        }
+
+        /* implicitly swap halves while unpacking */
+        buf[0] = wr >> 8;   buf[1] = wr & 0xFF;
+        buf[2] = wl >> 8;   buf[3] = wl & 0xFF;
+    }
+
+    #include <stdio.h>
+    int main(int ac, char *av[])
+    {
+        BYTE        in[4] = { 0x33,0x22,0x11,0x00 };
+        BYTE        key[10] = { 0x00,0x99,0x88,0x77,0x66,0x55,0x44,0x33,0x22,0x11 };
+        int         i, encrypt;
+        int         bt;
+
+        if (ac == 1) {
+            skip32(key, in, 1);
+            printf("%02x%02x%02x%02x\n", in[0], in[1], in[2], in[3]);
+            if (in[0] != 0x81 || in[1] != 0x9d || in[2] != 0x5f || in[3] != 0x1f) {
+                printf("819d5f1f is the answer! Didn't encrypt correctly!\n");
+                return 1;
+            }
+            skip32(key, in, 0);
+            if (in[0] != 0x33 || in[1] != 0x22 || in[2] != 0x11 || in[3] != 0x00) {
+                printf("%02x%02x%02x%02x\n", in[0], in[1], in[2], in[3]);
+                printf("33221100 is the answer! Didn't decrypt correctly!\n");
+                return 1;
+            }
+        }
+        else if (ac != 4) {
+            fprintf(stderr, "usage: %s e/d kkkkkkkkkkkkkkkkkkkk dddddddd\n", av[0]);
+            return 1;
+        }
+        else {
+            encrypt = av[1][0] == 'e';
+            for (i = 0; i < 10; ++i) {
+                sscanf(&av[2][i*2], "%02x", &bt);
+                key[i] = bt;
+            }
+            for (i = 0; i < 4; ++i) {
+                sscanf(&av[3][i*2], "%02x", &bt);
+                in[i] = bt;
+            }
+            skip32(key, in, encrypt);
+            printf("%02x%02x%02x%02x\n", in[0], in[1], in[2], in[3]);
+        }
+        return 0;
+    }

data/test/helper.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+require "test/unit"
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'integer_obfuscator'

data/test/test_integer_obfuscator.rb

@@ -0,0 +1,42 @@
+require "helper"
+
+class TestIntegerObfuscator < Test::Unit::TestCase
+  
+  def setup
+    @c = IntegerObfuscator.new("my secret key")
+  end
+  
+  def test_obfuscation
+    assert_equal 418026769, @c.obfuscate(1)
+  end
+  
+  def test_unobfuscation
+    assert_equal 1, @c.unobfuscate(418026769)
+  end
+  
+  def test_1000_obfuscation_deobfuscates
+    0.upto(1000) do |i|
+      assert_equal i, @c.unobfuscate(@c.obfuscate(i))
+    end
+  end
+  
+  def test_does_not_allow_negative_values
+    assert_raises IntegerObfuscator::RangeError do
+      @c.obfuscate(-1)
+    end
+    assert_raises IntegerObfuscator::RangeError do
+      @c.unobfuscate(-1)
+    end
+  end
+  
+  def test_does_not_allow_big_integers
+    bigint = (2 ** 32) + 1
+    assert_raises IntegerObfuscator::RangeError do
+      @c.obfuscate(bigint)
+    end
+    assert_raises IntegerObfuscator::RangeError do
+      @c.unobfuscate(bigint)
+    end
+  end
+
+end

data/test/test_skip32.rb

@@ -0,0 +1,20 @@
+require "helper"
+
+class TestSkip32 < Test::Unit::TestCase
+
+  def setup
+    @key       = [ 0x00,0x99,0x88,0x77,0x66,0x55,0x44,0x33,0x22,0x11 ].pack("C*")
+    @c         = Cipher::Skip32.new(@key)
+    @block     = [ 0x33,0x22,0x11,0x00 ].pack("C*")
+    @enc_block = [ 0x81,0x9d,0x5f,0x1f ].pack("C*")
+  end
+
+  def test_original_encrypt
+    assert_equal @enc_block, @c.encrypt(@block)
+  end
+  
+  def test_original_decrypt
+    assert_equal @block, @c.decrypt(@enc_block)
+  end
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: integer-obfuscator
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- John Nishinaga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-22 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: yard
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: bluecloth
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rspec
+  version_requirements: *id003
+description: Obfuscate 32-bit Integers using a 32-bit block cipher based on SKIPJACK
+email: 
+- jingoro@casa-z.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .document
+- .gitignore
+- .yardopts
+- Gemfile
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- integer-obfuscator.gemspec
+- lib/cipher/skip32.rb
+- lib/integer_obfuscator.rb
+- lib/integer_obfuscator/version.rb
+- skip32.c.md
+- test/helper.rb
+- test/test_integer_obfuscator.rb
+- test/test_skip32.rb
+has_rdoc: true
+homepage: https://github.com/patdeegan/integer-obfuscator
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: integer-obfuscator
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: integer-obfuscator-0.1.0
+test_files: 
+- test/helper.rb
+- test/test_integer_obfuscator.rb
+- test/test_skip32.rb