ffxcodec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba22c48b71bd085c4a3dce71253019c04e9d0779
+  data.tar.gz: 14ad93e6127517bc027501c512b108c6682b7479
+SHA512:
+  metadata.gz: 459359ebd5bb8e2ee4aef9ff97e31731be15146faa70f511092a4a33ffb23b4e54dec54107b668f35f60e2150f4687b80f37641b04f32854b0c9979dc8e7fc54
+  data.tar.gz: 27b2a249060cff63d1dd17207a81e6065a0eea449c17465a19a15f5d0d8b6e5097d7002aef8ed2b183628fc331122fc16d363dab9d4764299eaeee1a4ea15471

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/test/reports/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ffxcodec.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2016, J. Brandt Buckley
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,104 @@
+# FFXCodec
+
+Encodes two unsigned integers into a single, larger (32 or 64-bit) integer.
+
+Optionally, it can encrypt/decrypt the resulting integer using an implementation of the AES-FFX [format-preserving cipher][1].
+
+Has no external dependencies.  Everything is done with the stdlib.
+
+
+## Usage
+
+Start by divvying up the 32 or 64 bits that will make up the resulting integer:
+
+    ffx = FFXCodec.new(16, 16)  # divide 32-bit int equally
+    ffx = FFXCodec.new(40, 24)  # divide 64-bit int into a 40 and 24-bit int
+
+Then, encode and decode accordingly:
+
+    ffx.encode(1234567890, 4)          #=> 165828720871684
+    ffx.decode(165828720871684)        #=> [1234567890, 4]
+
+Optionally, you can enable encryption by setting a `key` and `tweak`:
+
+    ffx.setup_encryption("2b7e151628aed2a6abf7158809cf4f3c", "9876543210")
+    ffx.encode(797980150281, 5427652)  #=> 7692035069140451684
+    ffx.decode(7692035069140451684)    #=> [797980150281, 5427652]
+
+
+### Putting it all together
+
+Example **without encryption** (40 and 24-bit integers into 64-bit):
+
+    ffx = FFXCodec.new(40, 24)
+    ffx.encode(1234567890, 4)          #=> 165828720871684
+    ffx.decode(165828720871684)        #=> [1234567890, 4]
+
+Example **with encryption** (40 and 24-bit integers into 64-bit):
+
+    ffx = FFXCodec.new(40, 24)
+    ffx.setup_encryption("2b7e151628aed2a6abf7158809cf4f3c", "9876543210")
+    ffx.encode(797980150281, 5427652)  #=> 7692035069140451684
+    ffx.decode(7692035069140451684)    #=> [797980150281, 5427652]
+
+
+## Installation
+
+To install:
+
+    gem install ffxcodec
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ffxcodec'
+```
+
+
+## FAQ
+
+Q. Does this only work with unsigned integers?
+
+A. It could be made to work with signed integers, but it wasn't built or tested with that use case in mind.
+
+
+Q. What is a tweak?
+
+A. It's kind of like a salt. The [initial FFX spec][2] has a good description.
+
+
+## Alternatives
+
+Encoding:
+- "Mortonizing" / Z-Order Curve
+
+Encryption:
+- [BPS][3] (PDF)
+- [Hasty Pudding cipher][4]
+
+## Warning
+
+The AES-FFX implementation is experimental.  It was cooked up for this proof of concept.
+
+The tests included are based on the NIST reference vectors, but the published vectors only cover radix 10 and 36.
+
+Additionally, FFX is still a DRAFT specification.  Thus, it cannot yet be considered cryptographically secure.
+
+Don't use this for anything beyond basic obfuscation.
+
+
+## Known Issues
+
+- Assumes little-endian.
+- Assumes 64-bit capable.
+
+
+## Author
+
+- J. Brandt Buckley <brandt@runlevel1.com>
+
+
+[1]: https://en.wikipedia.org/wiki/Format-preserving_encryption
+[2]: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/ffx/ffx-spec.pdf
+[3]: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/bps/bps-spec.pdf
+[4]: https://en.wikipedia.org/wiki/Hasty_Pudding_cipher

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ffxcodec"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ffxcodec

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "ffxcodec"
+
+examples = <<-EOF
+Examples:
+
+- Encode:
+  ffxcodec --alloc=40:24 1234567890 4
+
+- Decode:
+  ffxcodec --alloc=40:24 20712612157194244
+
+- Encrypted encode:
+  ffxcodec --alloc=40:24 --key=2b7e151628aed2a6abf7158809cf4f3c --tweak=FZNT4F22E5QA5QUM 1234567890 4
+
+- Encrypted decode:
+  ffxcodec --alloc=40:24 --key=2b7e151628aed2a6abf7158809cf4f3c --tweak=FZNT4F22E5QA5QUM 5539580373534012574
+EOF
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: ffxcodec [options] [args]"
+
+  opts.on("-aLEFT:RIGHT", "--alloc LEFT:RIGHT", "Bit allocation - must add up to 32/64 (REQUIRED)") do |b|
+    left, right = b.split(":").map(&:to_i)
+    options[:l_alloc] = left
+    options[:r_alloc] = right
+  end
+
+  opts.on("-kKEY", "--key KEY", "Hex key to encrypt with (use with --tweak)") do |k|
+    options[:key] = k
+  end
+
+  opts.on("-tTWEAK", "--tweak TWEAK", "Tweak to encrypt with (use with --key)") do |t|
+    options[:tweak] = t
+  end
+
+  opts.on("-m", "--maximums", "Show max integers for the given allocation and exit") do
+    options[:maximum] = true
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    puts ""
+    puts examples
+    exit
+  end
+end.parse!
+
+if options[:l_alloc].nil? || options[:r_alloc].nil?
+  warn "Must provide left and right bit allocation like: --alloc=40:24"
+  exit 2
+end
+
+ffx = FFXCodec.new(options[:l_alloc], options[:r_alloc])
+
+if options[:maximum]
+  l_max, r_max = ffx.maximums
+  puts "Left max: #{l_max}"
+  puts "Right max: #{r_max}"
+  exit
+end
+
+if options[:key] || options[:tweak]
+  if [options[:key], options[:tweak]].any?(&:nil?)
+    warn "Must use --key with --tweak to enable encryption"
+    exit 2
+  end
+  ffx.setup_encryption(options[:key], options[:tweak])
+end
+
+case ARGV.count
+when 1
+  encoded = ARGV[0].to_i
+  userid, listid = ffx.decode(encoded)
+  puts "User ID: #{userid}"
+  puts "List ID: #{listid}"
+when 2
+  userid = ARGV[0].to_i
+  listid = ARGV[1].to_i
+  encoded = ffx.encode(userid, listid)
+  puts "Encoded: #{encoded}"
+else
+  warn "Wrong number of values provided to encode or decode."
+  exit 2
+end

data/exe/ffxcodec-demo

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require "ffxcodec"
+require "pp"
+
+a_val = 1234567890
+b_val = 4
+a_size = 40
+b_size = 24
+key = "2b7e151628aed2a6abf7158809cf4f3c"
+tweak = "9876543210"
+
+ffx = FFXCodec.new(a_size, b_size)  # divide 64-bit int into a 40 and 24-bit int
+
+unencrypted_encoded = ffx.encode(a_val, b_val)
+unencrypted_decoded = ffx.decode(unencrypted_encoded)
+
+ffx.setup_encryption(key, tweak)
+
+encrypted_encoded = ffx.encode(a_val, b_val)
+encrypted_decoded = ffx.decode(encrypted_encoded)
+
+puts "Input A: #{a_val}"
+puts "Input B: #{b_val}"
+puts "Input A bit allocation: #{a_size}"
+puts "Input B bit allocation: #{b_size}"
+puts "Encoded Size (Type): #{ffx.size} bytes (#{ffx.bit_length}-bit unsigned integer)"
+puts ""
+puts "Without Encryption:"
+puts "- Encoded: #{unencrypted_encoded}"
+puts "- Decoded: #{unencrypted_decoded.inspect}"
+puts ""
+puts "With Encryption: (Key: #{key}, Tweak: #{tweak})"
+puts "- Encoded: #{encrypted_encoded}"
+puts "- Decoded: #{encrypted_decoded.inspect}"

data/ffxcodec.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ffxcodec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ffxcodec'
+  spec.version       = FFXCodec::VERSION
+  spec.authors       = ['J. Brandt Buckley']
+  spec.email         = ['brandt@runlevel1.com']
+  spec.license       = 'BSD-2-Clause'
+
+  spec.summary       = 'Encodes two integers into one with optional encryption'
+  spec.description   = 'Encodes two unsigned integers into a single, larger (32 or 64-bit) integer with optional AES-FFX encryption.'
+  spec.homepage      = 'https://github.com/brandt/ffxcodec'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/lib/ffxcodec/core_ext/string.rb

@@ -0,0 +1,40 @@
+class String
+  # XOR operation on String
+  #
+  # @param [String] other string to XOR with
+  # @raises [ArgumentError] if other string isn't the same length
+  # @return [String] result of XOR operation
+  # rubocop:disable AbcSize
+  def ^(other)
+    # rubocop:disable RedundantSelf, SignalException
+    b1 = self.unpack("C*")
+    b2 = other.unpack("C*")
+    raise ArgumentError, "Strings must be the same length" unless b1.size == b2.size
+    longest = [b1.length, b2.length].max
+    b1 = [0] * (longest - b1.length) + b1
+    b2 = [0] * (longest - b2.length) + b2
+    b1.zip(b2).map { |a, b| a ^ b }.pack("C*")
+  end
+
+  # Split down the middle into two parts (right-biased)
+  #
+  # @return [Array<String>] the original string split into two. If length was
+  #   odd, then the second string will have an extra character.
+  def bisect
+    n = self.size
+    l = n / 2
+    [self[0...l], self[l...n]]
+  end
+
+  # Prepend zeroes until string is of the given length
+  #
+  # @note if string was already longer than the given length, no action taken
+  #
+  # @param [Integer] length we want the resulting string to be
+  # @return [String] prepended with '0's until the given length is reached
+  def prepad_zeros(length)
+    str = self
+    str.insert(0, '0') while str.length < length
+    str
+  end
+end

data/lib/ffxcodec/encoder.rb

@@ -0,0 +1,120 @@
+class FFXCodec
+  # Encode two integers into one larger integer and decode back
+  class Encoder
+    # @return [Fixnum] size of encoded integer in bits (32 or 64)
+    attr_reader :size
+
+    # @return [Fixnum] maximum unsigned value representable by left integer
+    attr_reader :a_max
+
+    # @return [Fixnum] maximum unsigned value representable by right integer
+    attr_reader :b_max
+
+    # @param [Fixnum] a_size the number of bits allocated to the left integer
+    # @param [Fixnum] b_size the number of bits allocated to the right integer
+    def initialize(a_size = 32, b_size = 32)
+      @a_size = a_size
+      @b_size = b_size
+      @a_max, @b_max = maximums(a_size, b_size)
+      @size = a_size + b_size
+      check_size
+    end
+
+    # Combine two unsigned integers into a single, larger unsigned integer
+    #
+    # @param [Fixnum] a value to encode
+    # @param [Fixnum] b value to encode
+    #
+    # @example Encode 40 and 24-bit integers into a single 64-bit integer
+    #   i = Encoder.new(40, 24)
+    #   i.encode(1234567890, 4)      #=> 20712612157194244
+    #
+    # @return [Fixnum, Bignum] encoded integer
+    def encode(a, b)
+      check_ab_bounds(a, b)
+      i = (a << @b_size) ^ b
+      interlace(i)
+    end
+
+    # Separate an unsigned integer into two smaller unsigned integers
+    #
+    # @example Decode an encoded 64-bit integer into 40 and 24-bit integers
+    #   i = Encoder.new(40, 24)
+    #   i.decode(20712612157194244)  #=> [1234567890, 4]
+    #
+    # @param [Fixnum, Bignum] c encoded value to decode
+    # @return [Array<Fixnum>] decoded integers
+    def decode(c)
+      i = interlace(c)
+      a = i >> @b_size
+      b = (i ^ (a << @b_size))
+      [a, b]
+    end
+
+    private
+
+    # Interlace / deinterlace bytes
+    #
+    # Running this on a number toggles interlacing (a reorder of the bits).
+    #
+    # This reorders the bytes in an integer.  We do this to avoid a possible
+    # reduction in the effectiveness of our encryption resulting from the fact
+    # that we encode input by concatenating the bits of two potentially equally
+    # sized integers and the way a maximally-balanced Feistel splits the input
+    # in half.
+    #
+    # Technically we only need to do this when encryption is enabled and the
+    # integer is evenly divided.  However, this imparts almost no performance
+    # penalty.  Ruby can perform ~1 million of these operations in 2 sec for
+    # random 64-bit values and 0.5 sec for random 32-bit values.
+    #
+    # @param [Fixnum, Bignum] n interlaced or uninterlaced value
+    # @return [Fixnum, Bignum] interlaced value if input wasn't interlaced
+    # @return [Fixnum, Bignum] deinterlaced value if input was interlaced
+    # rubocop:disable AbcSize
+    def interlace(n)
+      # rubocop:disable SpaceAroundOperators, MultilineOperationIndentation
+      if @size == 32
+        n        & 0xFF0000FF | # 0, 3
+        (n >> 8) & 0x0000FF00 | # 1
+        (n << 8) & 0x00FF0000   # 2
+      else
+        n         & 0xFF00FF0000FF00FF | # 0, 2, 5, 7
+        (n >> 40) & 0x000000000000FF00 | # 1
+        (n >> 8)  & 0x00000000FF000000 | # 3
+        (n << 8)  & 0x000000FF00000000 | # 4
+        (n << 40) & 0x00FF000000000000   # 6
+      end
+    end
+
+    # Calculate the maximum values representable in the given number of bits
+    #
+    # @param [Fixnum] a_size number of bits allocated to left integer
+    # @param [Fixnum] b_size number of bits allocated to right integer
+    # @return [Array<Fixnum>] maximum representable values for each integer
+    def maximums(a_size, b_size)
+      a_max = (1 << a_size) - 1
+      b_max = (1 << b_size) - 1
+      [a_max, b_max]
+    end
+
+    # @param [Fixnum] a left integer to be encoded
+    # @param [Fixnum] b right integer to be encoded
+    # @raise [ArgumentError] if the given values fall outside our maximums
+    # @return [void]
+    def check_ab_bounds(a, b)
+      if a > @a_max || a < 0
+        fail ArgumentError, "LHS #{@a_size}-bit value out of bounds: #{a}"
+      elsif b > @b_max || b < 0
+        fail ArgumentError, "RHS #{@b_size}-bit value out of bounds: #{b}"
+      end
+    end
+
+    # @raise [ArgumentError] if the combined bit count isn't 32 or 64 bits
+    # @return [void]
+    def check_size
+      return if @size == 32 || @size == 64
+      fail ArgumentError, "Combined size must be 32 or 64 bits"
+    end
+  end
+end

data/lib/ffxcodec/encrypt.rb

@@ -0,0 +1,223 @@
+require "openssl"
+
+class FFXCodec
+  # Implementation of AES-FFX mode format-preserving encryption
+  #
+  # Cipher device encrypts integers where the resulting ciphertext has the same
+  # number of digits in the given base (radix).
+  #
+  # @note WARNING: This was cooked up as an experimental proof of concept.
+  #   It hasn't been tested thoroughly and shouldn't be considered secure.
+  #
+  # @note Format-preserving != integer-size-preserving in base 10 (see below)
+  #
+  # The format-preserving characteristic of this cipher is best thought of as
+  # preserving the number of digits, not the integer size.  For instance, in
+  # base 10, 4294967295 and 4294967296 would be considered to have the same
+  # format, but the first is a 32-bit unsigned integer and the second is 64.
+  #
+  # So given base 10 input that fits within a 32 or 64-bit integer, it's
+  # possible for the AES-FFX cipher to return a number that contains the same
+  # number of base 10 digits but exceeds the largest number that can be
+  # represented in 32 or 64 bits respectively.
+  #
+  # You can work around this by using radix 2 so that the cipher returns an
+  # equal number of bits.  As with all modes, you must supply input as a
+  # stringified integer in the base you've specified.
+  #
+  # Be aware that when you convert between bases, leading zeros are sometimes
+  # dropped by the converter.  You must supply the same number of digits to the
+  # decrypter as you did to the encrypter or you'll get a different value.  The
+  # encrypt and decrypt methods prepend zeros until the input is is of the
+  # length specified during initialization.
+  #
+  class Encrypt
+    # @param [Fixnum] length of input
+    attr_accessor :length
+
+    # @note This is set to 10 by the spec.  Don't change it unless you know
+    #   what you're doing.
+    # @param [Fixnum] rounds of encryption / decryption to run input through
+    attr_accessor :rounds
+
+    # @return [Fixnum] radix of the input
+    attr_reader :radix
+
+    # @param [String] key for AES as a hexadecimal string
+    # @param [String] tweak for AES
+    # @param [Fixnum] length of the input
+    # @param [Fixnum] radix of the input
+    def initialize(key, tweak, length, radix = 10)
+      self.key   = key
+      self.tweak = tweak
+      self.radix = radix
+      @length    = length
+      @rounds    = 10
+    end
+
+    # @param [String] key for AES as a hexadecimal string
+    def key=(key)
+      hexkey = [key].pack('H*')
+      fail ArgumentError, "key must be a 16-byte hexidecimal" if hexkey.length != 16
+      @key = hexkey
+    end
+
+    # @param [String] tweak tweak for AES
+    def tweak=(tweak)
+      fail ArgumentError, "tweak length must be under (2^32) - 1" if tweak.length > ((1 << 32) - 1)
+      @tweak = tweak
+    end
+
+    # @param [Fixnum] num radix of the input
+    def radix=(num)
+      fail ArgumentError, "radix must be between 2 and 2^16" if num > 65536
+      @radix = num
+    end
+
+    # Encrypt
+    #
+    # @param [String] input unencrypted, stringifed integer of base @radix
+    #
+    # @example Encrypt
+    #   e = Encrypt.new("4fb450a9c27dd07f22ef56413432c94a", "FZNT4F22E5QA5QUM")
+    #   e.encrypt(1234567890)  #=> "1224011974"
+    #
+    # @return [Fixnum, Bignum] encrypted integer
+    def encrypt(input)
+      a, b = input.prepad_zeros(@length).bisect
+      0.upto(@rounds - 1) do |iter|
+        f = feistel_round(input.size, iter, b)
+        c = block_addition(a, f)
+        a = b
+        b = c
+      end
+      a + b
+    end
+
+    # Decrypt
+    #
+    # @param [String] input encrypted, stringifed integer of base @radix
+    #
+    # @example Decrypt
+    #   e = Encrypt.new("4fb450a9c27dd07f22ef56413432c94a", "FZNT4F22E5QA5QUM")
+    #   e.decrypt(1224011974)  #=> "1234567890"
+    #
+    # @return [Fixnum, Bignum] unencrypted integer
+    def decrypt(input)
+      a, b = input.prepad_zeros(@length).bisect
+      (@rounds - 1).downto(0) do |iter|
+        c = b
+        b = a
+        f = feistel_round(input.size, iter, b)
+        lmin  = [c.size, f.size].min
+        a = block_subtraction(lmin, c, f)
+      end
+      a + b
+    end
+
+    private
+
+    # Computes the block-wise radix addition of x and y
+    def block_addition(a, b)
+      sum = a.to_i(@radix) + b.to_i(@radix)
+      sum %= (@radix**a.size)
+      sum.to_s(@radix).prepad_zeros(a.size)
+    end
+
+    # Computes the block-wise radix subtraction of x and y
+    def block_subtraction(n, x, y)
+      diff        = x.to_i(@radix) - y.to_i(@radix)
+      mod         = @radix**n
+      block_diff  = diff % mod
+      block_diff += mod if block_diff < 0
+      out         = block_diff.to_s(@radix)
+      return out unless out.length < n
+      out.prepad_zeros(n)
+    end
+
+    def num_radix(str, length)
+      n = str.to_i(@radix)
+      n_bitcount = ('0' * (length * 8)) + n.to_s(2)
+      n_bitcount = n_bitcount[-(length * 8)..-1]
+      [n_bitcount].pack('B*')
+    end
+
+    def aes(block)
+      aes = OpenSSL::Cipher::Cipher.new('aes-128-ecb')
+      aes.encrypt
+      aes.key = @key
+      aes.update(block)
+    end
+
+    def cbc_mac(block)
+      fail "invalid block size" unless (block.size % 16 == 0)
+      y = "\0" * 16
+      i = 0
+      while i < block.size
+        x = block[i...(i + 16)]
+        y = aes(x ^ y)
+        i += 16
+      end
+      y
+    end
+
+    def byte_array_to_int(block)
+      block.bytes.inject(0) { |memo, b| (memo << 8) + b }
+    end
+
+    # Creates the first half of the IV
+    #
+    # Concatenated with Q in the feistel round.
+    #
+    # p <- [vers] | [method] | [addition] | [radix] | [rnds(n)] | [split(n)] | [n] | [t]
+    def generate_p(input_len)
+      vers     = 1
+      method   = 2
+      addition = 1
+      split_n  = input_len / 2
+      [vers, method, addition].pack('CCC') +
+        [@radix].pack('N')[1..3] +
+        [@rounds].pack('C') +
+        [split_n].pack('C') +
+        [input_len].pack('N') +
+        [@tweak.length].pack('N')
+    end
+
+    # Creates the second half of the IV
+    #
+    # Concatenated with P in the feistel round.
+    #
+    # q <- tweak | [0]^((-t-b-1) mod 16) | [roundNum] | [numradix(B)]
+    def generate_q(b, blk_len, round)
+      round_num = [round].pack('C')
+      @tweak + "\0" * ((-@tweak.size - blk_len - 1) % 16) + round_num + num_radix(b, blk_len)
+    end
+
+    # Y <- first d+4 bytes of (Y | AESK(Y XOR [1]16) | AESK(Y XOR [2]16) | AESK(Y XOR [3]16)...)
+    def generate_y(blk_len, iv_p, iv_q)
+      d = 4 * (blk_len / 4.0).ceil
+      y = cbc_mac(iv_p + iv_q)
+      byte_array_to_int(y[0...(d + 4)])
+    end
+
+    # b <- ceil(ceil(beta * log_2(radix)) / 8)
+    def block_length(input_len)
+      beta = (input_len / 2.0).ceil
+      ((beta * Math.log(@radix) / Math.log(2)).ceil / 8.0).ceil
+    end
+
+    # Runs the given block through the modified feistel network
+    def feistel_round(input_len, iter, b)
+      blk_len = block_length(input_len)
+      iv_p = generate_p(input_len)
+      iv_q = generate_q(b, blk_len, iter)
+
+      # z = y mod r^m
+      y = generate_y(blk_len, iv_p, iv_q)
+      m = (iter % 2).zero? ? (input_len / 2) : (input_len / 2.0).ceil
+      z = y % (@radix**m)
+
+      z.to_s(@radix).prepad_zeros(m)
+    end
+  end
+end

data/lib/ffxcodec/version.rb

@@ -0,0 +1,3 @@
+class FFXCodec
+  VERSION = "0.1.0"
+end

data/lib/ffxcodec.rb

@@ -0,0 +1,119 @@
+require "ffxcodec/version"
+require "ffxcodec/core_ext/string"
+require "ffxcodec/encrypt"
+require "ffxcodec/encoder"
+
+# Encode / decode two integers into a single integer with optional encryption
+#
+# The resulting value is a single 32 or 64-bit unsigned integer (your choice),
+# even when encrypted.
+#
+# Works by divvying up the bits of the single integer between the two component
+# integers and running it through AES-FFX format-preserving cipher (optional).
+class FFXCodec
+  # @param [Fixnum] a_size the number of bits allocated to the left integer
+  # @param [Fixnum] b_size the number of bits allocated to the right integer
+  def initialize(a_size, b_size)
+    @encoder = Encoder.new(a_size, b_size)
+  end
+
+  # Setup encryption
+  #
+  # Auto-enables encryption after encoding and decryption before decoding.
+  #
+  # @param [String] key for AES as a hexadecimal string
+  # @param [String] tweak for AES
+  # @return [void]
+  def setup_encryption(key, tweak)
+    @crypto = Encrypt.new(key, tweak, @encoder.size, 2)
+  end
+
+  # Turn off encryption
+  #
+  # @return [void]
+  def disable_encryption
+    @crypto = false
+  end
+
+  # Encode two integers into a single integer
+  #
+  # @param [Fixnum] a value to encode
+  # @param [Fixnum] b value to encode
+  #
+  # @example Encode 40 and 24-bit integers into an unencrypted 64-bit integer
+  #   ffx = FFXCodec.new(40, 24)
+  #   ffx.encode(1234567890, 4)          #=> 165828720871684
+  #
+  # @example Encode 40 and 24-bit integers into an encrypted 64-bit integer
+  #   ffx = FFXCodec.new(40, 24)
+  #   ffx.setup_encryption("2b7e151628aed2a6abf7158809cf4f3c", "9876543210")
+  #   ffx.encode(797980150281, 5427652)  #=> 7692035069140451684
+  #
+  # @return [Fixnum, Bignum] encoded integer if encryption not setup
+  # @return [Fixnum, Bignum] encrypted encoded integer if encryption setup
+  def encode(a, b)
+    c = @encoder.encode(a, b)
+    @crypto ? encrypt(c) : c
+  end
+
+  # Decode an integer into its two component integers
+  #
+  # @note input will automatically be decrypted if encryption was setup
+  # @param [Fixnum, Bignum] c value to decode
+  #
+  # @example Decode unencrypted integer into component 40 and 24-bit integers
+  #   ffx = FFXCodec.new(40, 24)
+  #   ffx.decode(165828720871684)        #=> [1234567890, 4]
+  #
+  # @example Decode encrypted integer into component 40 and 24-bit integers
+  #   ffx = FFXCodec.new(40, 24)
+  #   ffx.setup_encryption("2b7e151628aed2a6abf7158809cf4f3c", "9876543210")
+  #   ffx.decode(7692035069140451684)    #=> [797980150281, 5427652]
+  #
+  # @return [Array<Fixnum>] component integers
+  def decode(c)
+    input = @crypto ? decrypt(c) : c
+    @encoder.decode(input)
+  end
+
+  # Show maximum representable base 10 value for each field
+  #
+  # @example Maximums for a 32-bit integer split into 24 and 8-bit components
+  #   ffx = FFXCodec.new(24, 8)
+  #   ffx.maximums  #=> [16777215, 255]
+  #
+  # @example Maximums for a 64-bit integer split into two 32-bit components
+  #   ffx = FFXCodec.new(32, 32)
+  #   ffx.maximums  #=> [4294967295, 4294967295]
+  #
+  # @return [Array<Fixnum>] maximum representable component integers
+  def maximums
+    [@encoder.a_max, @encoder.b_max]
+  end
+
+  # Show size of the resulting integer in bytes
+  #
+  # @return [Fixnum] size of the combined integer in bytes
+  def size
+    @encoder.size / 8
+  end
+
+  # Show size of the resulting integer in bits
+  #
+  # @return [Fixnum] size of the combined integer in bits
+  def bit_length
+    @encoder.size
+  end
+
+  private
+
+  # @param [Fixnum, Bignum] value to encrypt
+  def encrypt(value)
+    @crypto.encrypt(value.to_s(2)).to_i(2)
+  end
+
+  # @param [Fixnum, Bignum] value to decrypt
+  def decrypt(value)
+    @crypto.decrypt(value.to_s(2)).to_i(2)
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: ffxcodec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- J. Brandt Buckley
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Encodes two unsigned integers into a single, larger (32 or 64-bit) integer
+  with optional AES-FFX encryption.
+email:
+- brandt@runlevel1.com
+executables:
+- ffxcodec
+- ffxcodec-demo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/ffxcodec
+- exe/ffxcodec-demo
+- ffxcodec.gemspec
+- lib/ffxcodec.rb
+- lib/ffxcodec/core_ext/string.rb
+- lib/ffxcodec/encoder.rb
+- lib/ffxcodec/encrypt.rb
+- lib/ffxcodec/version.rb
+homepage: https://github.com/brandt/ffxcodec
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Encodes two integers into one with optional encryption
+test_files: []
+has_rdoc: