hsmr 0.0.1

data/.gitignore

@@ -0,0 +1,44 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+*.swp
+*.un~

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## v0.0.1
+
+* Initial release
+* Key / Componet features
+  * Create Keys and Components
+  * XOR Keys and Components together
+  * Find Key Check Values (kcv)
+  * Determine and change key parity
+* Encrypt / Decrypt PIN Blocks
+* Generate IBM3624 PINs
+* Generate PVV, CVV & CVV2 values

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hsmr.gemspec
+gemspec
+
+#group :development do
+#  gem 'rb-fsevent', :require => false if RUBY_PLATFORM =~ /darwin/i
+#  gem 'growl', :require => false if RUBY_PLATFORM =~ /darwin/i
+#  gem 'guard-test'
+#  gem 'factory_girl'
+#end

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :test do
+  watch(%r{lib/(.+)\.rb})      { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{test/.+_test\.rb})
+  watch('test/test_helper.rb') { "test" }
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Dan Milne
+
+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,67 @@
+HSMR [![Build Status](https://secure.travis-ci.org/dkam/hsmr.png)](http://travis-ci.org/dkam/hsmr)
+===========
+
+HSMR is a collection of cryptographic commands usually implemented on a HSM (Hardware Security Module). These 
+are implemented for your education or for testing purposes and should not be used to replace an actual HSM.
+
+Installation
+-------------
+
+One day I'll learn how to make gems. Until then, git clone is the only way to use this softawre.
+
+Usage
+---------
+
+    require './lib/hsmr'
+    require './lib/key'
+    require './lib/component'
+
+    # Create a Key
+    > key=HSMR::Key.new("4CA2161637D0133E5E151AEA45DA2A12")
+    => 4CA2 1616 37D0 133E 5E15 1AEA 45DA 2A12 
+    > key.key
+    => "L\xA2\x16\x167\xD0\x13>^\x15\x1A\xEAE\xDA*\x12" 
+    > key.to_s
+    => "4CA2 1616 37D0 133E 5E15 1AEA 45DA 2A12" 
+    > key.kcv
+    => "7B0898" 
+    > key.parity
+    => "odd" 
+  
+    # Generate a PVV
+
+    pan="5999997890123412"
+    pin="1234"
+    pvki="1"
+    pvv = HSMR.pvv(key, pan, pvki, pin)
+    => "0798"
+
+Features
+---------
+
+* Key / Componet features
+  * Create Keys and Components
+  * XOR Keys and Components together
+  * Find Key Check Values (kcv)
+  * Determine and change key parity
+* Encrypt / Decrypt PIN Blocks
+* Generate IBM3624 PINs
+* Generate PVV, CVV & CVV2 values
+
+
+Development
+-----------
+
+* Source hosted on GitHub.
+* Report issues on GitHub Issues.
+* Pull requests are awesome! Please include test::unit tests
+
+Author
+==========
+
+Dan Milne, http://da.nmilne.com, http://booko.com.au
+
+Copyright
+----------
+
+Copyright (c) 2010 Dan Milne. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+task :test
+
+task :default => :test

data/hsmr.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hsmr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hsmr"
+  s.version     = HSMR::VERSION
+  s.authors     = ["Dan Milne"]
+  s.email       = ["d@nmilne.com"]
+  s.homepage    = ""
+  s.summary     = %q{HSM commands in Ruby}
+  s.description = %q{A collection of methods usually implemented in a HSM (Hardware Security Module)}
+
+  s.rubyforge_project = "hsmr"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  
+  s.add_development_dependency "rake"
+  s.add_development_dependency "guard-test"
+  s.add_development_dependency "factory_girl"
+end

data/lib/hsmr.rb

@@ -0,0 +1,267 @@
+require 'openssl'
+require 'hsmr/component'
+require 'hsmr/key'
+
+module HSMR
+  # Key Lengths
+  SINGLE=64
+  DOUBLE=128
+  TRIPLE=192
+
+  ## Mixin functionality
+  
+  def kcv()
+    des = OpenSSL::Cipher::Cipher.new("des-cbc") if @key.length == 8
+    des = OpenSSL::Cipher::Cipher.new("des-ede-cbc") if @key.length == 16
+    des.encrypt
+    des.key=@key
+    des.update("\x00"*8).unpack('H*').first[0...6].upcase
+  end
+
+  def generate(length)
+    (0...(length/4)).collect { rand(16).to_s(16).upcase }.join
+  end
+
+
+  def to_s
+    @key.unpack('H4'*(@key.length/2)).join(" ").upcase
+  end
+
+  def parity
+    'even' unless odd_parity?
+    'odd'
+  end
+
+  def odd_parity?
+    # http://www.cryptosys.net/3des.html
+    # http://csrc.nist.gov/publications/nistpubs/800-67/SP800-67.pdf
+    #
+    # The eight error detecting bits are set to make the parity of each 8-bit 
+    # byte of the key odd. That is, there is an odd number of "1"s in each 8-bit byte.
+
+    #3.to_s(2).count('1')
+    #@key.unpack("H2").first.to_i(16).to_s(2)
+
+    working=@key.unpack('H2'*(@key.length))
+    working.each do |o| 
+      freq = o.to_i(16).to_s(2).count('1').to_i
+      if( freq%2 == 0)
+        #puts "#{o} is #{o.to_i(16).to_s(2).count('1').to_i } - even" 
+        return false
+      else
+        return true
+        #puts "#{o} is #{o.to_i(16).to_s(2).count('1').to_i } - odd" 
+      end
+    end      
+  end
+
+  def self.encrypt(data, key)
+    unless key.length == 8 || key.length == 16 || key.length ==24
+      raise TypeError, "key length should be 8, 16 or 24 bytes" 
+    end
+    des = OpenSSL::Cipher::Cipher.new("des-cbc") if key.length == 8
+    des = OpenSSL::Cipher::Cipher.new("des-ede-cbc") if key.length == 16
+    des = OpenSSL::Cipher::Cipher.new("des-ede3-cbc") if key.length == 24
+
+    des.encrypt
+    des.key=key.key
+    to_hex( des.update(to_binary(data)) )
+  end
+
+  def set_odd_parity
+    return self if self.odd_parity? == true
+        
+    working=@key.unpack('H2'*(@key.length))
+    working.each_with_index do |o,i|
+      freq = o.to_i(16).to_s(2).count('1').to_i
+      if( freq%2 == 0)
+        c1 = o[0].chr
+        c2 = case o[1].chr
+          when "0" then "1"
+          when "1" then "0"
+          when "2" then "3"
+          when "3" then "2"
+          when "4" then "5"
+          when "5" then "4"
+          when "6" then "7"
+          when "7" then "6"
+          when "8" then "9"
+          when "9" then "8"
+          when "a" then "b"
+          when "b" then "a"
+          when "c" then "d"
+          when "d" then "c"
+          when "e" then "f"
+          when "f" then "e"
+        end
+        working[i]="#{c1}#{c2}"
+      end
+    end
+    @key = working.join.unpack('a2'*(working.length)).map{|x| x.hex}.pack('c'*(working.length))
+    return self
+  end
+
+  def xor(other)
+    other=Component.new(other) if other.is_a? String
+    #other=Component.new(other.to_s) if other.is_a? Key
+
+    unless (other.is_a? Component ) or ( other.is_a? Key )
+      raise TypeError, "Component argument expected" 
+    end
+    
+    @a = @key.unpack('C2'*(@key.length/2))
+    @b = other.key.unpack('C2'*(other.length/2))
+    
+    resultant = Key.new( @a.zip(@b).
+                        map {|x,y| x^y}.
+                        map {|z| z.to_s(16) }.
+                        map {|c| c.length == 1 ? '0'+c : c }.
+                        join.upcase )
+    resultant
+  end
+  
+  def xor!(_key)
+    @key = xor(_key).key
+  end
+
+  ## Module Methods
+
+  def self.to_binary(data)
+    data.unpack('a2'*(data.length/2)).map{|x| x.hex}.pack('c'*(data.length/2))
+  end
+
+  def self.to_hex(data)
+    data.unpack('H*').first.upcase
+  end
+
+  def self.encrypt_pin(key, pin)
+    @pin = pin.unpack('a2'*(pin.length/2)).map{|x| x.hex}.pack('c'*(pin.length/2))
+    des = OpenSSL::Cipher::Cipher.new("des-ede")
+    des.encrypt
+    des.key=key.key
+    return des.update(@pin).unpack('H*').first.upcase
+  end
+  
+  def self.decrypt_pin(key, pinblock)
+    @pinblock = pinblock.unpack('a2'*(pinblock.length/2)).map{|x| x.hex}.pack('c'*(pinblock.length/2))
+    des = OpenSSL::Cipher::Cipher.new("des-ede")
+    des.decrypt
+    des.padding=0
+    des.key=key.key
+    result = des.update(@pinblock)
+    result << des.final
+    result.unpack('H*').first.upcase
+  end
+  
+  def self.ibm3624(key, account, plength=4, dtable="0123456789012345" )
+    
+    validation_data = account.unpack('a2'*(account.length/2)).map{|x| x.hex}.pack('c'*(account.length/2))
+
+    #des = OpenSSL::Cipher::Cipher.new("des-ede-cbc")
+    des = OpenSSL::Cipher::Cipher.new("des-cbc")
+    des.encrypt
+    des.key=key.key
+    return HSMR::decimalise(des.update(validation_data).unpack('H*').first, :ibm, dtable)[0...plength]
+    
+  end
+  
+  def self.decimalise(value, method=:visa, dtable="0123456789012345" )
+
+    result = []
+    if method == :ibm  
+      ##
+      # The IBM method
+      ##
+      value.each_char do |c| 
+        result << dtable[c.to_i(16),1].to_i
+      end
+      
+    elsif method == :visa
+      
+      value.each_char do |c|
+        result << c.to_i if numeric?(c)
+      end
+    
+      value.upcase.each_char do |c|
+        result << dtable[c.to_i(16),1].to_i unless numeric?(c)
+      end
+      
+    end
+    
+    return result
+  end
+    
+  def self.pvv(key, account, pvki, pin)
+    tsp = account.to_s[4,11] + pvki.to_s + pin.to_s
+    @tsp = tsp.unpack('a2'*(tsp.length/2)).map{|x| x.hex}.pack('c'*(tsp.length/2))
+    des = OpenSSL::Cipher::Cipher.new("des-ede")
+    des.encrypt
+    des.key=key.key
+    result = des.update(@tsp).unpack('H*').first.upcase
+    decimalise(result, :visa)[0..3].join
+  end
+
+  def self.cvv(key_a, key_b, pan, exp, svc)
+    # http://www.m-sinergi.com/hairi/doc.html
+    # For CVV2 use SVC 000
+    # For CVV3 SVC is 502
+    # For iCVV use SVC of 999
+    #
+    #raise ArgumentError "PAN" 
+
+    data1 = pan
+    data2 = "#{exp}#{svc}".ljust(16, '0')
+
+    result = encrypt(data1, key_a)
+    result = result.xor(data2)
+
+    result1 = encrypt(result, HSMR::Key.new(key_a.to_s + key_b.to_s) )
+   
+    return HSMR.decimalise( result1 )[0,3].join
+  end
+  
+  def self.xor(component1, *rest)
+    return if rest.length == 0
+    
+    component1 = Component.new(component1) unless component1.is_a? Component
+    raise TypeError, "Component argument expected" unless component1.is_a? Component
+    
+    #@components=[]
+    #rest.each {|c| components << ((c.is_a? HSMR::Component) ? c : HSMR::Component.new(c) ) }
+    #components.each {|c| raise TypeError, "Component argument expected" unless c.is_a? Component }
+    #resultant = component1.xor(components.pop)
+    #components.each {|c| resultant.xor!(c) }
+
+    rest.collect! {|c| ( (c.is_a? HSMR::Component) ? c : HSMR::Component.new(c) ) }
+    rest.each {|c| raise TypeError, "Component argument expected" unless c.is_a? HSMR::Component }
+    resultant = component1.xor(rest.pop)
+    rest.each {|c| resultant.xor!(c) }
+
+    return(resultant)
+  end
+  
+  def self.numeric?(object)
+    ## Method to determine if an object is a numeric type.
+    true if Float(object) rescue false
+  end
+end
+
+
+class String
+  def xor(other)
+    if other.empty?
+      self
+    else
+      a1        = self.unpack("a2"*(self.length/2)).map {|x| x.hex }
+      a2        = other.unpack("a2"*(other.length/2)).map {|x| x.hex }
+      #a2 *= 2   while a2.length < a1.length
+
+      #a1.zip(a2).collect{|c1,c2| c1^c2}.pack("C*")
+      a1.zip(a2).
+      map {|x,y| x^y}.
+      map {|z| z.to_s(16) }.
+      map {|c| c.length == 1 ? '0'+c : c }.
+      join.upcase      
+    end
+  end
+end

data/lib/hsmr/component.rb

@@ -0,0 +1,38 @@
+module HSMR
+  class Component
+    include HSMR
+    attr_reader :key
+    attr_reader :length
+
+    def component
+      @key
+    end
+    
+    def initialize(key=nil, length=DOUBLE)
+      ## Should check for odd parity
+      if key.nil?
+        key = generate(length)
+      else
+        key=key.gsub(/ /,'')
+        #raise TypeError, "Component argument expected" unless other.is_a? Component
+      end
+      @key = key.unpack('a2'*(key.length/2)).map{|x| x.hex}.pack('c'*(key.length/2))
+      @length = @key.length
+      @key = @key
+    end
+    
+#    def xor(other)
+#      other = Component.new(other) unless other.is_a? Component
+#      raise TypeError, "Component argument expected" unless other.is_a? Component
+#      
+#      @a = @key.unpack('C2'*(@key.length/2))
+#      @b = other.component.unpack('C2'*(other.component.length/2))
+#
+#      #result = @a.zip(@b).map {|x,y| x^y}.map {|z| z.to_s(16) }.join.upcase
+#      result = @a.zip(@b).map {|x,y| x^y}.map {|z| z.to_s(16) }.map {|c| c.length == 1 ? '0'+c : c }.join.upcase
+#
+#      Key.new(result)
+#    end
+
+  end
+end

data/lib/hsmr/key.rb

@@ -0,0 +1,56 @@
+module HSMR
+  class Key
+    include HSMR
+
+    attr_reader :key
+    attr_reader :length
+
+    def initialize(init=nil, length=DOUBLE)
+      return nil if (init.is_a? Array ) && (init.length == 0) 
+      
+      init = init.first if (init.is_a? Array) && (init.length == 1)
+      
+      if init.is_a? Array
+        init.collect! {|c| ( (c.is_a? HSMR::Component) ? c : HSMR::Component.new(c) ) }
+
+        raise TypeError, "Component argument expected" unless init.first.is_a? Component
+      
+        @key=HSMR::xor(init.pop, init).key
+    
+      elsif init.is_a? Component
+        @key = init.component
+      elsif init.is_a? String
+        key=init.gsub(/ /,'')
+        @key = key.unpack('a2'*(key.length/2)).map{|x| x.hex}.pack('c'*(key.length/2))
+      elsif key.nil?
+        key = generate(length)
+        @key = key.unpack('a2'*(key.length/2)).map{|x| x.hex}.pack('c'*(key.length/2))
+      end
+      @length = @key.length
+    end 
+
+    #def xor(other)
+    #  other=Component.new(other) if other.is_a? String
+    #  other=Component.new(other.to_s) if other.is_a? Key
+#
+#      puts "other is #{other.class} - #{other.key}"
+#      
+#      raise TypeError, "Component argument expected" unless other.is_a? Component
+#      
+#      @a = @key.unpack('C2'*(@key.length/2))
+#      @b = other.component.unpack('C2'*(other.length/2))
+#      
+#      resultant = Key.new( @a.zip(@b).
+#                          map {|x,y| x^y}.
+#                          map {|z| z.to_s(16) }.
+#                          map {|c| c.length == 1 ? '0'+c : c }.
+#                          join.upcase )
+#      resultant
+#    end
+#    
+#    def xor!(_key)
+#      @key = xor(_key).key
+#    end
+
+  end
+end

data/lib/hsmr/version.rb

@@ -0,0 +1,3 @@
+module HSMR
+  VERSION = "0.0.1"
+end

data/spec/hsmr_spec.rb

@@ -0,0 +1,181 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Generate Component" do
+	it "should generate a component" do
+	  component_1 = HSMR::Component.new(nil, HSMR::SINGLE)
+	  component_2 = HSMR::Component.new(nil, HSMR::DOUBLE)
+	  component_3 = HSMR::Component.new(nil, HSMR::TRIPLE)	  	
+
+	  component_1.length.should == 8
+	  component_2.length.should == 16
+	  component_3.length.should == 24	  	    
+  end
+end
+
+describe "Calculate component KCV" do
+  
+  it "should calculate single length component KCV values" do 
+    component_1 = HSMR::Component.new("6DBF C180 4A01 5BAD")
+    component_1.kcv.should == "029E60"
+
+    component_2 = HSMR::Component.new("5D80 0497 B319 8591")
+    component_2.kcv.should == "3B86C3"
+
+    component_3 = HSMR::Component.new("B0C7 7CDC 7354 97C7")
+    component_3.kcv.should == "7A77BC"
+
+    component_4 = HSMR::Component.new("DAE0 86FE D6EA 0BEA")
+    component_4.kcv.should == "2E6191"
+
+    component_5 = HSMR::Component.new("682C 8315 F4BF FBC1")
+    component_5.kcv.should == "62B336"
+
+    component_6 = HSMR::Component.new("5715 F289 04BC B62F")
+    component_6.kcv.should == "3CBA88"
+
+    component_7 = HSMR::Component.new("D0C4 29AE C4A8 02B5")
+    component_7.kcv.should == "33AF02"
+
+    component_8 = HSMR::Component.new("7049 D0F7 4A97 15B6")
+    component_8.kcv.should == "AC1399"
+
+    component_9 = HSMR::Component.new("BC91 D698 157A A4E5")
+    component_9.kcv.should == "295491"
+
+    component_10 = HSMR::Component.new("64AB 8568 7A0E 322F")
+    component_10.kcv.should == "D9F7B3"
+  end
+
+  it "should calculate double length component KCV values" do 
+    component_1 = HSMR::Component.new("ADE3 9B38 0DBC DF38 AE02 AECE 64B3 4373")
+    component_1.kcv.should == "3002D5"
+
+    component_2 = HSMR::Component.new("B64A EF86 460D DF5B 57B3 D53D AD37 52A1")
+    component_2.kcv.should == "1F7C07"
+
+    component_3 = HSMR::Component.new("5B89 6E29 76EC 9745 15B5 238C 8CFE 3D23")
+    component_3.kcv.should == "DE78F2"
+
+    component_4 = HSMR::Component.new("5E61 CB20 D540 1FC7 58EC CDC8 B558 E9B9")
+    component_4.kcv.should == "FED957"
+
+    component_5 = HSMR::Component.new("23DF CEB9 BF94 ADA8 91E9 580B 8C8F 5BEF")
+    component_5.kcv.should == "902085"
+
+    component_6 = HSMR::Component.new("DFEF 61C8 2037 3DA4 CE9B 92CD 89E9 B334")
+    component_6.kcv.should == "E45EB7"
+
+    component_7 = HSMR::Component.new("6746 9E4C FE83 F831 F23E 9D9E 9D9E 9DB3")
+    component_7.kcv.should == "813B7B"
+
+    component_8 = HSMR::Component.new("23E5 496E DF94 0BD5 9734 B07A BF26 B9E6")
+    component_8.kcv.should == "E7C48F"
+
+    component_9 = HSMR::Component.new("974F 26BC CB2A ECD5 434F 1CDC 64DF A275")
+    component_9.kcv.should == "E27250"
+
+    component_10 = HSMR::Component.new("E57A DF5B CEA7 F42A DFD9 E554 07A2 F891")
+    component_10.kcv.should == "50E3F8"
+  end
+end
+
+describe "Calculate key KCV" do
+  
+  it "should calculate single length key KCV values" do 
+    key_1 = HSMR::Key.new("6DBF C180 4A01 5BAD")
+    key_1.kcv.should == "029E60"
+
+    key_2 = HSMR::Key.new("5D80 0497 B319 8591")
+    key_2.kcv.should == "3B86C3"
+
+    key_3 = HSMR::Key.new("B0C7 7CDC 7354 97C7")
+    key_3.kcv.should == "7A77BC"
+
+    key_4 = HSMR::Key.new("DAE0 86FE D6EA 0BEA")
+    key_4.kcv.should == "2E6191"
+
+    key_5 = HSMR::Key.new("682C 8315 F4BF FBC1")
+    key_5.kcv.should == "62B336"
+
+    key_6 = HSMR::Key.new("5715 F289 04BC B62F")
+    key_6.kcv.should == "3CBA88"
+
+    key_7 = HSMR::Key.new("D0C4 29AE C4A8 02B5")
+    key_7.kcv.should == "33AF02"
+
+    key_8 = HSMR::Key.new("7049 D0F7 4A97 15B6")
+    key_8.kcv.should == "AC1399"
+
+    key_9 = HSMR::Key.new("BC91 D698 157A A4E5")
+    key_9.kcv.should == "295491"
+
+    key_10 = HSMR::Key.new("64AB 8568 7A0E 322F")
+    key_10.kcv.should == "D9F7B3"
+  end
+  it "should calculate double length key KCV values" do 
+    key_1 = HSMR::Key.new("ADE3 9B38 0DBC DF38 AE02 AECE 64B3 4373")
+    key_1.kcv.should == "3002D5"
+
+    key_2 = HSMR::Key.new("B64A EF86 460D DF5B 57B3 D53D AD37 52A1")
+    key_2.kcv.should == "1F7C07"
+
+    key_3 = HSMR::Key.new("5B89 6E29 76EC 9745 15B5 238C 8CFE 3D23")
+    key_3.kcv.should == "DE78F2"
+
+    key_4 = HSMR::Key.new("5E61 CB20 D540 1FC7 58EC CDC8 B558 E9B9")
+    key_4.kcv.should == "FED957"
+
+    key_5 = HSMR::Key.new("23DF CEB9 BF94 ADA8 91E9 580B 8C8F 5BEF")
+    key_5.kcv.should == "902085"
+
+    key_6 = HSMR::Key.new("DFEF 61C8 2037 3DA4 CE9B 92CD 89E9 B334")
+    key_6.kcv.should == "E45EB7"
+
+    key_7 = HSMR::Key.new("6746 9E4C FE83 F831 F23E 9D9E 9D9E 9DB3")
+    key_7.kcv.should == "813B7B"
+
+    key_8 = HSMR::Key.new("23E5 496E DF94 0BD5 9734 B07A BF26 B9E6")
+    key_8.kcv.should == "E7C48F"
+
+    key_9 = HSMR::Key.new("974F 26BC CB2A ECD5 434F 1CDC 64DF A275")
+    key_9.kcv.should == "E27250"
+
+    key_10 = HSMR::Key.new("E57A DF5B CEA7 F42A DFD9 E554 07A2 F891")
+    key_10.kcv.should == "50E3F8"
+  end
+end
+
+describe "Calculate parity" do
+  it "should detect odd_parity in a key" do
+    odd_key  = HSMR::Key.new("41A2AC14A90C583741A2AC14A90C5837")
+    odd_key.odd_parity?.should == false     
+  end
+  
+  it "should set double length key parity to odd" do 
+    odd_key  = HSMR::Key.new("41A2AC14A90C583741A2AC14A90C5837")
+
+    odd_key.set_odd_parity
+    
+    even_key = HSMR::Key.new("40A2AD15A80D583740A2AD15A80D5837")
+    
+    odd_key.key.should == even_key.key
+    
+  end
+  
+  it "should detect odd_parity in a component" do
+    odd_component  = HSMR::Component.new("41A2AC14A90C583741A2AC14A90C5837")
+    odd_component.odd_parity?.should == false     
+  end
+  
+  it "should set double length component parity to odd" do 
+    odd_component  = HSMR::Component.new("41A2AC14A90C583741A2AC14A90C5837")
+    
+    odd_component.set_odd_parity
+    
+    even_component = HSMR::Component.new("40A2AD15A80D583740A2AD15A80D5837")
+        
+    odd_component.component.should == even_component.component
+        
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'hsmr'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/test/hsmr_test.rb

@@ -0,0 +1,182 @@
+require 'test_helper'
+
+class TestHSMR < Test::Unit::TestCase
+
+  def test_generate_a_component 
+	  component_1 = HSMR::Component.new(nil, HSMR::SINGLE)
+	  component_2 = HSMR::Component.new(nil, HSMR::DOUBLE)
+	  component_3 = HSMR::Component.new(nil, HSMR::TRIPLE)	  	
+
+	  assert_equal 8,  component_1.length
+    assert_equal 16, component_2.length
+    assert_equal 24, component_3.length
+  end
+
+  def test_caclulation_of_single_length_component_KCV_values
+    component_1 = HSMR::Component.new("6DBF C180 4A01 5BAD")
+    assert_equal "029E60", component_1.kcv
+
+    component_2 = HSMR::Component.new("5D80 0497 B319 8591")
+    assert_equal "3B86C3", component_2.kcv
+
+    component_3 = HSMR::Component.new("B0C7 7CDC 7354 97C7")
+    assert_equal "7A77BC", component_3.kcv
+
+    component_4 = HSMR::Component.new("DAE0 86FE D6EA 0BEA")
+    assert_equal "2E6191", component_4.kcv
+
+    component_5 = HSMR::Component.new("682C 8315 F4BF FBC1")
+    assert_equal "62B336", component_5.kcv
+
+    component_6 = HSMR::Component.new("5715 F289 04BC B62F")
+    assert_equal "3CBA88", component_6.kcv
+
+    component_7 = HSMR::Component.new("D0C4 29AE C4A8 02B5")
+    assert_equal "33AF02", component_7.kcv
+
+    component_8 = HSMR::Component.new("7049 D0F7 4A97 15B6")
+    assert_equal "AC1399", component_8.kcv
+
+    component_9 = HSMR::Component.new("BC91 D698 157A A4E5")
+    assert_equal "295491", component_9.kcv
+
+    component_10 = HSMR::Component.new("64AB 8568 7A0E 322F")
+    assert_equal  "D9F7B3", component_10.kcv
+  end
+
+  def test_should_calculate_double_length_key_KCV_values
+    key_1 = HSMR::Key.new("ADE3 9B38 0DBC DF38 AE02 AECE 64B3 4373")
+    assert_equal "3002D5", key_1.kcv
+
+    key_2 = HSMR::Key.new("B64A EF86 460D DF5B 57B3 D53D AD37 52A1")
+    assert_equal "1F7C07", key_2.kcv
+
+    key_3 = HSMR::Key.new("5B89 6E29 76EC 9745 15B5 238C 8CFE 3D23")
+    assert_equal "DE78F2", key_3.kcv
+
+    key_4 = HSMR::Key.new("5E61 CB20 D540 1FC7 58EC CDC8 B558 E9B9")
+    assert_equal "FED957", key_4.kcv
+
+    key_5 = HSMR::Key.new("23DF CEB9 BF94 ADA8 91E9 580B 8C8F 5BEF")
+    assert_equal "902085", key_5.kcv
+
+    key_6 = HSMR::Key.new("DFEF 61C8 2037 3DA4 CE9B 92CD 89E9 B334")
+    assert_equal "E45EB7", key_6.kcv
+
+    key_7 = HSMR::Key.new("6746 9E4C FE83 F831 F23E 9D9E 9D9E 9DB3")
+    assert_equal "813B7B", key_7.kcv
+
+    key_8 = HSMR::Key.new("23E5 496E DF94 0BD5 9734 B07A BF26 B9E6")
+    assert_equal "E7C48F", key_8.kcv
+
+    key_9 = HSMR::Key.new("974F 26BC CB2A ECD5 434F 1CDC 64DF A275")
+    assert_equal "E27250", key_9.kcv
+
+    key_10 = HSMR::Key.new("E57A DF5B CEA7 F42A DFD9 E554 07A2 F891")
+    assert_equal "50E3F8", key_10.kcv
+  end
+
+  def test_should_detect_odd_parity_in_a_key
+    parity=[]
+    #            Odd              Even
+    parity << %W{ 0123456789ABCDEF 0022446688AACCEE }
+    parity << %W{ FEDCBA9876543210 FFDDBB9977553311 }
+    parity << %W{ 89ABCDEF01234567 88AACCEE00224466 }
+    parity << %W{ 40A2AD15A80D583740A2AD15A80D5837 41A2AC14A90C583741A2AC14A90C5837 }
+
+    # Test determining the parity
+    parity.each do |pair|
+      assert_equal true,  HSMR::Key.new(pair[0]).odd_parity?
+      assert_equal false, HSMR::Key.new(pair[1]).odd_parity?
+
+      assert_equal true,  HSMR::Component.new(pair[0]).odd_parity?
+      assert_equal false, HSMR::Component.new(pair[1]).odd_parity?
+    end
+
+    # Test converting even to odd parity
+    parity.each do |pair|
+      odd_key = HSMR::Key.new(pair[0])
+      even_key = HSMR::Key.new(pair[0])
+      
+      even_key.set_odd_parity
+      assert_equal odd_key,  odd_key
+    end
+  end
+  
+  def test_converting_string_to_ascii_works
+    key_string = "E57A DF5B CEA7 F42A DFD9 E554 07A2 F891"
+    key = HSMR::Key.new(key_string)
+
+    assert_equal key.to_s, key_string 
+
+    key_string = "E57A DF5B CEA7 F42A DFD9 E554 07A2 F891"
+    comp = HSMR::Component.new(key_string)
+
+    assert_equal comp.to_s, key_string 
+  end
+
+  def test_CVC_CVC2_calculations
+    cases = []
+              #  Component 1      Component 2      PAN                 EXP  SCode  CVC
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5656565656565656    1010 ___   922 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5656565656565656    1010 000   922 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5683739237489383838 1010 000   367 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 568367393472639     1010 000   067 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5683673934726394    1010 000   409 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5683673934726394    1010 050   CVV248 or CVC409 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5683673934726394    1010 101   CVV501 or CVC409 }
+    cases << %W{ 1234567890ABCDEF FEDCBA1234567890 5683673934726394    1010 102   CVV206 or CVC409 }
+
+    kl = "0123456789ABCDEF" 
+    kr = "FEDCBA1234567890"
+
+
+    #HSMR.cvv(kl, kr, "4509494222049051", "0907", "1010")
+  end
+
+  def test_PIN_PVV_CVV_and_CVV2_generation
+    cases=[]
+    #            Account          Exp  PIN  PVV  CVV2 CVV PGK1             PGK2             PVKI PVK1             PVK2             CVKA             CVKB             DEC
+    #            0                1    2    3    4    5    6                7                8    9                10               11               12               13 
+    cases << %W{ 5560501200002101 1010 4412 6183 134  317 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002111 1010 4784 0931 561  924 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002121 1010 1040 4895 462  673 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002131 1010 3680 6373 826  267 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002101 1110 4412 6183 900  155 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002111 1110 4784 0931 363  513 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002121 1110 1040 4895 952  937 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002131 1110 3680 6373 667  522 3737373737373737 0000000000000000 2    1111111111111111 1111111111111111 1111111111111111 1111111111111111 0123456789012345}
+    cases << %W{ 5560501200002101 1010 9907 7527 777  473 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002111 1010 2345 0658 638  553 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002121 1010 8245 8196 085  480 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002131 1010 3812 2948 591  546 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002101 1110 9907 7527 349  994 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002111 1110 2345 0658 245  266 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002121 1110 8245 8196 441  115 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+    cases << %W{ 5560501200002131 1110 3812 2948 126  768 0123456789ABCDEF FEDCBA9876543210 2    7BB19E3D56A1237E 29F7C8FA379EE25C 007A5048DB9531B3 0322DA78AB2F85E1 0123456789012345}
+
+    cases.each do |c|
+      ibm1=HSMR::Component.new(c[6])
+      ibm2=HSMR::Component.new(c[7])
+      ibm=ibm1.xor(ibm2)
+      
+      pvk=HSMR::Key.new(c[9]+c[10])
+      
+      pin = HSMR::ibm3624(ibm, c[0], 4, c[13]).join
+      pvv = HSMR::pvv(pvk, c[0], c[8], pin)
+
+      assert_equal pin, c[2]
+      assert_equal pin.to_i, c[2].to_i
+      assert_equal pvv, c[3]
+      assert_equal pvv.to_i, c[3].to_i
+
+      cvv = HSMR::cvv(HSMR::Key.new(c[11]),  HSMR::Key.new(c[12]), c[0], c[1], '0')
+      cvv2 = HSMR::cvv(HSMR::Key.new(c[11]),  HSMR::Key.new(c[12]), c[0], c[1], '101')
+
+      assert_equal c[4].to_i, cvv2.to_i
+      assert_equal c[5].to_i, cvv.to_i
+
+      #puts "#{pin} == #{c[2]} ? #{pin.to_i == c[2].to_i} | #{pvv} == #{c[3]} ? #{pvv.to_i == c[3].to_i}"
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require "test/unit"
+require "hsmr"

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: hsmr
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Dan Milne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: guard-test
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+description: A collection of methods usually implemented in a HSM (Hardware Security Module)
+email: 
+- d@nmilne.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hsmr.gemspec
+- lib/hsmr.rb
+- lib/hsmr/component.rb
+- lib/hsmr/key.rb
+- lib/hsmr/version.rb
+- spec/hsmr_spec.rb
+- spec/spec_helper.rb
+- test/hsmr_test.rb
+- test/test_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -754850866914746297
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -754850866914746297
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: hsmr
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: HSM commands in Ruby
+test_files: 
+- spec/hsmr_spec.rb
+- spec/spec_helper.rb
+- test/hsmr_test.rb
+- test/test_helper.rb