hsmr 0.0.2 → 0.1.0

data/doc/encryption.txt

@@ -0,0 +1,63 @@
+#Encrypt (ECB)               1234000000000000
+#Key Used Was              0123456789ABCDEFFEDCBA9876543210 (08D7B4) Odd
+#The Result Is                 D4718F4CA902C2A3
+
+
+key="0123456789ABCDEFFEDCBA9876543210"
+pin="1234000000000000"
+
+def encpin(key, pin)
+  @key = key.unpack('a2'*(key.length/2)).map{|x| x.hex}.pack('c'*(key.length/2))
+  @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
+  return des.update(@pin).unpack('H*').first.upcase
+end
+
+def pvv(key, tsp)
+  @key = key.unpack('a2'*(key.length/2)).map{|x| x.hex}.pack('c'*(key.length/2))
+  @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
+  result = des.update(@pin).unpack('H*').first.upcase
+end
+
+
+pin=[]
+pin[0]="1234000000000000"
+pin[1]="8881000000000000"
+pin[2]="9254000000000000"
+pin[3]="1927000000000000"
+pin[4]="8363000000000000"
+
+key=[]
+key[0]="0123456789ABCDEFFEDCBA9876543210"
+key[1]="BA942A01EC6EABCD107346CB61F4F4FE"
+key[2]="4A3DB34F255EA743ECDA19D0945ECB31"
+
+puts "  result  | key | pin"
+key.each do |k|
+  pin.each do |p|
+    result = encpin(k,p)
+    puts "#{result} | #{k} | #{p}"
+  end
+end
+
+RESULT           | KEY                              | PIN
+D4718F4CA902C2A3 | 0123456789ABCDEFFEDCBA9876543210 | 1234000000000000
+9EE1F2989B005F6A | 0123456789ABCDEFFEDCBA9876543210 | 8881000000000000
+30D7E71ADB09B2F6 | 0123456789ABCDEFFEDCBA9876543210 | 9254000000000000
+F7DE2452CC64FC6D | 0123456789ABCDEFFEDCBA9876543210 | 1927000000000000
+A947B12F1E7F345A | 0123456789ABCDEFFEDCBA9876543210 | 8363000000000000
+5DFA5CE9EDCF20D9 | BA942A01EC6EABCD107346CB61F4F4FE | 1234000000000000
+9E22FC9F1539BF54 | BA942A01EC6EABCD107346CB61F4F4FE | 8881000000000000
+B30A6DE41326C0FE | BA942A01EC6EABCD107346CB61F4F4FE | 9254000000000000
+E905C2F4E94638B7 | BA942A01EC6EABCD107346CB61F4F4FE | 1927000000000000
+FE18700A5357D343 | BA942A01EC6EABCD107346CB61F4F4FE | 8363000000000000
+77B3EAD1F9CEAB4E | 4A3DB34F255EA743ECDA19D0945ECB31 | 1234000000000000
+BF0E37A91DA9D878 | 4A3DB34F255EA743ECDA19D0945ECB31 | 8881000000000000
+43A8D24E4DAC0D5C | 4A3DB34F255EA743ECDA19D0945ECB31 | 9254000000000000
+4D367C663AB681F1 | 4A3DB34F255EA743ECDA19D0945ECB31 | 1927000000000000
+33D63EC052648F5B | 4A3DB34F255EA743ECDA19D0945ECB31 | 8363000000000000

data/doc/parity.txt

@@ -0,0 +1,14 @@
+41A2AC14A90C583741A2AC14A90C5837
+40A2AD15A80D583740A2AD15A80D5837
+
+F2AEDAE3FEE90DC2921F01341F54D37F
+F2AEDAE3FEE90DC2921F01341F54D37F
+
+80EFEC4895855B06B4015041C3F9F61F
+80EFEC4994855B07B5015140C2F8F71F
+
+4D3DE6AA837AA60A413DDD6CBCB12C82
+4C3DE6AB837AA70B403DDC6DBCB02C83
+
+1E74C6914F41E5EFD9969A0B134EF819
+1F75C7914F40E5EFD9979B0B134FF819

data/doc/test values.txt

@@ -0,0 +1,24 @@
+K = 2323 2323 2323 2323 4545 4545 4545 4545 
+KVC = 3A42D7 
+
+K = 4545 4545 4545 4545 2323 2323 2323 2323 
+KVC = AC5700 
+
+K = 6767 6767 6767 6767 6767 6767 6767 6767 
+KVC = B0B563
+
+Card: 1234123412341234
+KL: 0123456789ABCDEF
+KR: 0123456789ABCDEF
+
+PVKI: 1
+PIN : 1234
+PVV : 8056
+
+PVKI: 2
+PIN : 1234
+PVV : 2485
+
+PVKI: 1
+PIN : 4592
+PVV : 6495

data/hsmr.gemspec

@@ -7,22 +7,17 @@ Gem::Specification.new do |s|
   s.version     = HSMR::VERSION
   s.authors     = ["Dan Milne"]
   s.email       = ["d@nmilne.com"]
-  s.homepage    = ""
   s.homepage    = 'https://github.com/dkam/hsmr'
   s.summary     = %q{HSM commands in Ruby}
   s.description = %q{A collection of methods usually implemented in a HSM (Hardware Security Module)}
   s.license     = 'MIT'
+  s.required_ruby_version = '>= 3.1'
 
   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", '~> 13'
-  s.add_development_dependency "guard-test", "~> 2"
-  s.add_development_dependency "factory_bot", "~> 6"
+  s.add_development_dependency "minitest", "~> 5.25"
 end

data/lib/hsmr/component.rb

@@ -1,38 +1,26 @@
 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)
+      elsif key.is_a? String
+        key = key.gsub(/ /,'')
       else
-        key=key.gsub(/ /,'')
-        #raise TypeError, "Component argument expected" unless other.is_a? Component
+        raise TypeError, "expected a String or nil, got #{key.class}"
       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

@@ -6,51 +6,33 @@ module HSMR
     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 ArgumentError, "at least one component is required" if init.is_a?(Array) && init.empty?
 
-        raise TypeError, "Component argument expected" unless init.first.is_a? Component
-      
-        @key=HSMR::xor(init.pop, init).key
-    
-      elsif init.is_a? Component
+      # A single element array is just that element
+      init = init.first if init.is_a?(Array) && init.length == 1
+
+      case init
+      when Array
+        components = init.collect {|c| c.is_a?(HSMR::Component) ? c : HSMR::Component.new(c) }
+        @key = HSMR::xor(components.pop, *components).key
+      when 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))
+      when String
+        @key = from_hex(init)
+      when nil
+        @key = from_hex(generate(length))
+      else
+        raise TypeError, "expected a String, Array, Component or nil, got #{init.class}"
       end
+
       @length = @key.length
-    end 
+    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
+    private
 
+    def from_hex(hex)
+      hex = hex.gsub(/ /,'')
+      hex.unpack('a2'*(hex.length/2)).map{|x| x.hex}.pack('c'*(hex.length/2))
+    end
   end
 end

data/lib/hsmr/version.rb

@@ -1,3 +1,3 @@
 module HSMR
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/hsmr.rb

@@ -1,4 +1,5 @@
 require 'openssl'
+require 'securerandom'
 require 'hsmr/component'
 require 'hsmr/key'
 
@@ -8,18 +9,36 @@ module HSMR
   DOUBLE=128
   TRIPLE=192
 
+  # Returns a DES cipher, keyed and set to :encrypt or :decrypt, in :cbc (the
+  # default) or :ecb mode.
+  #
+  # Single DES ("des-cbc" / "des-ecb") moved into OpenSSL 3's legacy provider
+  # and is not available by default. Triple DES with K1=K2=K3 is identical to
+  # single DES, so single length keys are widened to 24 bytes and run through
+  # des-ede3 instead.
+  def self.des(key, direction, mode = :cbc)
+    algorithm, material = case key.length
+                          when 8  then ["des-ede3", key * 3]
+                          when 16 then ["des-ede",  key]
+                          when 24 then ["des-ede3", key]
+                          else raise ArgumentError, "key length should be 8, 16 or 24 bytes, got #{key.length}"
+                          end
+
+    des = OpenSSL::Cipher.new(mode == :cbc ? "#{algorithm}-cbc" : algorithm)
+    direction == :decrypt ? des.decrypt : des.encrypt
+    des.key = material
+    des
+  end
+
   ## Mixin functionality
   
   def kcv()
-    des = OpenSSL::Cipher.new("des-cbc") if @key.length == 8
-    des = OpenSSL::Cipher.new("des-ede-cbc") if @key.length == 16
-    des.encrypt
-    des.key=@key
+    des = HSMR.des(@key, :encrypt)
     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
+    SecureRandom.hex(length / 8).upcase
   end
 
 
@@ -28,43 +47,25 @@ module HSMR
   end
 
   def parity
-    'even' unless odd_parity?
-    'odd'
+    odd_parity? ? 'odd' : 'even'
   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.
+    # 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. Every byte has to be odd, not just the first one.
 
-    #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      
+    @key.each_byte.all? { |b| b.to_s(2).count("1").odd? }
   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.new("des-cbc") if key.length == 8
-    des = OpenSSL::Cipher.new("des-ede-cbc") if key.length == 16
-    des = OpenSSL::Cipher.new("des-ede3-cbc") if key.length == 24
-
-    des.encrypt
-    des.key=key.key
+    des = HSMR.des(key.key, :encrypt)
     to_hex( des.update(to_binary(data)) )
   end
 
@@ -136,18 +137,14 @@ module HSMR
 
   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.new("des-ede")
-    des.encrypt
-    des.key=key.key
+    des = HSMR.des(key.key, :encrypt, :ecb)
     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.new("des-ede")
-    des.decrypt
+    des = HSMR.des(key.key, :decrypt, :ecb)
     des.padding=0
-    des.key=key.key
     result = des.update(@pinblock)
     result << des.final
     result.unpack('H*').first.upcase
@@ -157,10 +154,7 @@ module HSMR
     
     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.new("des-cbc")
-    des.encrypt
-    des.key=key.key
+    des = HSMR.des(key.key, :encrypt)
     return HSMR::decimalise(des.update(validation_data).unpack('H*').first, :ibm, dtable)[0...plength]
     
   end
@@ -194,9 +188,7 @@ module HSMR
   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.new("des-ede")
-    des.encrypt
-    des.key=key.key
+    des = HSMR.des(key.key, :encrypt, :ecb)
     result = des.update(@tsp).unpack('H*').first.upcase
     decimalise(result, :visa)[0..3].join
   end
@@ -209,8 +201,12 @@ module HSMR
     #
     #raise ArgumentError "PAN" 
 
-    data1 = pan
-    data2 = "#{exp}#{svc}".ljust(16, '0')
+    # The PAN, expiry and service code are concatenated and zero padded to 32
+    # digits, then split in half. Assuming the PAN alone fills the first half
+    # only holds for 16 digit PANs.
+    block = "#{pan}#{exp}#{svc}".ljust(32, '0')
+    data1 = block[0, 16]
+    data2 = block[16, 16]
 
     result = encrypt(data1, key_a)
     result = result.xor(data2)

data/test/hsmr_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TestHSMR < Test::Unit::TestCase
+class TestHSMR < Minitest::Test
 
   def test_generate_a_component 
 	  component_1 = HSMR::Component.new(nil, HSMR::SINGLE)
@@ -86,11 +86,11 @@ class TestHSMR < Test::Unit::TestCase
 
     # 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 HSMR::Key.new(pair[0]).odd_parity?
+      refute 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?
+      assert HSMR::Component.new(pair[0]).odd_parity?
+      refute HSMR::Component.new(pair[1]).odd_parity?
     end
 
     # Test converting even to odd parity
@@ -116,22 +116,27 @@ class TestHSMR < Test::Unit::TestCase
   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"
+    # doc/CVC.examples.txt. This test previously built the table below and then
+    # asserted nothing at all.
+    ka = HSMR::Key.new("1234567890ABCDEF")
+    kb = HSMR::Key.new("FEDCBA1234567890")
 
-
-    #HSMR.cvv(kl, kr, "4509494222049051", "0907", "1010")
+              #  PAN                 EXP  SCode CVC
+    cases = []
+    cases << %W{ 5656565656565656    1010 ""    922 }
+    cases << %W{ 5656565656565656    1010 000   922 }
+    cases << %W{ 5683739237489383838 1010 000   367 }
+    cases << %W{ 568367393472639     1010 000   067 }
+    cases << %W{ 5683673934726394    1010 000   409 }
+    cases << %W{ 5683673934726394    1010 050   248 }
+    cases << %W{ 5683673934726394    1010 101   501 }
+    cases << %W{ 5683673934726394    1010 102   206 }
+
+    cases.each do |pan, exp, svc, expected|
+      svc = "" if svc == %q{""}
+      assert_equal expected, HSMR::cvv(ka, kb, pan, exp, svc),
+                   "PAN #{pan} (#{pan.length} digits), service code #{svc.inspect}"
+    end
   end
 
   def test_PIN_PVV_CVV_and_CVV2_generation
@@ -179,4 +184,144 @@ class TestHSMR < Test::Unit::TestCase
       #puts "#{pin} == #{c[2]} ? #{pin.to_i == c[2].to_i} | #{pvv} == #{c[3]} ? #{pvv.to_i == c[3].to_i}"
     end
   end
+  def test_key_rejects_unusable_input
+    # Previously any unexpected type silently returned a freshly generated
+    # random key rather than raising.
+    assert_raises(TypeError)     { HSMR::Key.new(123) }
+    assert_raises(TypeError)     { HSMR::Key.new(:oops) }
+    assert_raises(TypeError)     { HSMR::Component.new(123) }
+    assert_raises(ArgumentError) { HSMR::Key.new([]) }
+  end
+
+  def test_key_generates_a_usable_key_when_given_nothing
+    key = HSMR::Key.new
+    assert_equal 16, key.length
+    assert_equal 16, key.key.length
+    assert_match(/\A[0-9A-F ]+\z/, key.to_s)
+
+    assert_equal 8, HSMR::Key.new(nil, HSMR::SINGLE).length
+    assert_equal 24, HSMR::Key.new(nil, HSMR::TRIPLE).length
+
+    refute_equal HSMR::Key.new.to_s, HSMR::Key.new.to_s
+  end
+
+  def test_key_does_not_mutate_the_component_array_it_is_given
+    components = [HSMR::Component.new("0123456789ABCDEF"), HSMR::Component.new("FEDCBA9876543210")]
+    HSMR::Key.new(components)
+    assert_equal 2, components.length
+  end
+
+  # Vectors below are from the HSM notes in doc/ -- values produced by a real
+  # HSM, not by this library.
+
+  def test_PIN_block_encryption_matches_known_HSM_values
+    # doc/encryption.txt
+    vectors = [
+      %W{ 0123456789ABCDEFFEDCBA9876543210 1234000000000000 D4718F4CA902C2A3 },
+      %W{ 0123456789ABCDEFFEDCBA9876543210 8881000000000000 9EE1F2989B005F6A },
+      %W{ 0123456789ABCDEFFEDCBA9876543210 9254000000000000 30D7E71ADB09B2F6 },
+      %W{ 0123456789ABCDEFFEDCBA9876543210 1927000000000000 F7DE2452CC64FC6D },
+      %W{ 0123456789ABCDEFFEDCBA9876543210 8363000000000000 A947B12F1E7F345A },
+      %W{ BA942A01EC6EABCD107346CB61F4F4FE 1234000000000000 5DFA5CE9EDCF20D9 },
+      %W{ BA942A01EC6EABCD107346CB61F4F4FE 8881000000000000 9E22FC9F1539BF54 },
+      %W{ BA942A01EC6EABCD107346CB61F4F4FE 9254000000000000 B30A6DE41326C0FE },
+      %W{ BA942A01EC6EABCD107346CB61F4F4FE 1927000000000000 E905C2F4E94638B7 },
+      %W{ BA942A01EC6EABCD107346CB61F4F4FE 8363000000000000 FE18700A5357D343 },
+      %W{ 4A3DB34F255EA743ECDA19D0945ECB31 1234000000000000 77B3EAD1F9CEAB4E },
+      %W{ 4A3DB34F255EA743ECDA19D0945ECB31 8881000000000000 BF0E37A91DA9D878 },
+      %W{ 4A3DB34F255EA743ECDA19D0945ECB31 9254000000000000 43A8D24E4DAC0D5C },
+      %W{ 4A3DB34F255EA743ECDA19D0945ECB31 1927000000000000 4D367C663AB681F1 },
+      %W{ 4A3DB34F255EA743ECDA19D0945ECB31 8363000000000000 33D63EC052648F5B },
+    ]
+
+    vectors.each do |hex_key, pinblock, expected|
+      key = HSMR::Key.new(hex_key)
+      assert_equal expected, HSMR::encrypt_pin(key, pinblock)
+      assert_equal pinblock, HSMR::decrypt_pin(key, expected)
+    end
+  end
+
+  def test_setting_odd_parity_fixes_every_byte
+    # doc/parity.txt. The third pair starts with an odd byte but has even bytes
+    # later on -- odd_parity? used to check only the first byte and leave it be.
+    [%W{ 41A2AC14A90C583741A2AC14A90C5837 40A2AD15A80D583740A2AD15A80D5837 },
+     %W{ F2AEDAE3FEE90DC2921F01341F54D37F F2AEDAE3FEE90DC2921F01341F54D37F },
+     %W{ 80EFEC4895855B06B4015041C3F9F61F 80EFEC4994855B07B5015140C2F8F71F },
+     %W{ 4D3DE6AA837AA60A413DDD6CBCB12C82 4C3DE6AB837AA70B403DDC6DBCB02C83 },
+     %W{ 1E74C6914F41E5EFD9969A0B134EF819 1F75C7914F40E5EFD9979B0B134FF819 }].each do |input, expected|
+      assert_equal expected, HSMR::Key.new(input).set_odd_parity.to_s.gsub(" ", "")
+      assert HSMR::Key.new(expected).odd_parity?
+    end
+  end
+
+  def test_odd_parity_checks_every_byte_not_just_the_first
+    # First byte 0x80 is odd, but later bytes are not.
+    refute HSMR::Key.new("80EFEC4895855B06B4015041C3F9F61F").odd_parity?
+    assert_equal "even", HSMR::Key.new("80EFEC4895855B06B4015041C3F9F61F").parity
+    assert_equal "odd",  HSMR::Key.new("0123456789ABCDEF").parity
+  end
+
+  def test_double_length_key_KCV_values_from_HSM_notes
+    # doc/test values.txt and doc/HSM Stuff/me test send key.txt
+    [%W{ 23232323232323234545454545454545 3A42D7 },
+     %W{ 45454545454545452323232323232323 AC5700 },
+     %W{ 67676767676767676767676767676767 B0B563 },
+     %W{ B5199D109D46E6914AB96D6E7F7CDAA8 F0916F },
+     %W{ AE9232A20276E0D03B16EC4C2C01CBC7 FB599F },
+     %W{ 25F491A467FDF7CEB3B0E6135BA78C0D 098FA4 }].each do |hex_key, kcv|
+      assert_equal kcv, HSMR::Key.new(hex_key).kcv
+    end
+  end
+
+  def test_PVV_generation_across_PVK_indexes
+    # doc/test values.txt -- the other PVV test only ever uses PVKI 2.
+    pvk = HSMR::Key.new("0123456789ABCDEF" * 2)
+
+    assert_equal "8056", HSMR::pvv(pvk, "1234123412341234", "1", "1234")
+    assert_equal "2485", HSMR::pvv(pvk, "1234123412341234", "2", "1234")
+    assert_equal "6495", HSMR::pvv(pvk, "1234123412341234", "1", "4592")
+  end
+
+  def test_des_rejects_keys_of_the_wrong_length
+    assert_raises(ArgumentError) { HSMR.des("short", :encrypt) }
+  end
+  def test_README_examples_still_hold
+    # Every value shown in README.md, so the docs cannot drift from the code.
+    key = HSMR::Key.new("4CA2161637D0133E5E151AEA45DA2A12")
+
+    assert_equal "4CA2 1616 37D0 133E 5E15 1AEA 45DA 2A12", key.to_s
+    assert_equal "7B0898", key.kcv
+    assert_equal "even", key.parity
+    refute key.odd_parity?
+    assert_equal 8, HSMR::Key.new(nil, HSMR::SINGLE).length
+
+    # Parity bits sit outside the DES key schedule, so the kcv is unchanged
+    kcv_before = key.kcv
+    assert_equal "4CA2 1616 37D0 133E 5E15 1AEA 45DA 2A13", key.set_odd_parity.to_s
+    assert_equal kcv_before, key.kcv
+
+    c1 = HSMR::Component.new("0123456789ABCDEF")
+    c2 = HSMR::Component.new("FEDCBA9876543210")
+    assert_equal "0123 4567 89AB CDEF", c1.to_s
+    assert_equal "D5D44F", c1.kcv
+    combined = HSMR::Key.new([c1, c2])
+    assert_equal "FFFF FFFF FFFF FFFF", combined.to_s
+    assert_equal "CAAAAF", combined.kcv
+
+    zmk = HSMR::Key.new("0123456789ABCDEFFEDCBA9876543210")
+    block = HSMR.encrypt_pin(zmk, "041274FFFFFFFFFF")
+    assert_equal "CFB709CC37D9262A", block
+    assert_equal "041274FFFFFFFFFF", HSMR.decrypt_pin(zmk, block)
+
+    pgk = HSMR::Key.new("3737373737373737")
+    assert_equal "4412", HSMR.ibm3624(pgk, "5560501200002101", 4, "0123456789012345").join
+
+    pvk = HSMR::Key.new("4CA2161637D0133E5E151AEA45DA2A12")
+    assert_equal "0798", HSMR.pvv(pvk, "5999997890123412", "1", "1234")
+
+    cvk_a = HSMR::Key.new("1111111111111111")
+    cvk_b = HSMR::Key.new("1111111111111111")
+    assert_equal "317", HSMR.cvv(cvk_a, cvk_b, "5560501200002101", "1010", "0")
+    assert_equal "134", HSMR.cvv(cvk_a, cvk_b, "5560501200002101", "1010", "101")
+  end
 end

data/test/test_helper.rb

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