crypt 1.1.4 → 2.0

data/crypt/rijndael.rb

@@ -11,48 +11,48 @@ class Rijndael
 
   require 'crypt/cbc'
   include Crypt::CBC
-  
+
   require 'crypt/rijndael-tables'
   include Crypt::RijndaelTables
-  
-  
+
+
   def initialize(userKey, keyBits = 256, blockBits = 128)
     case keyBits
-      when 128 
+      when 128
         @keyWords = 4
-      when 192 
+      when 192
         @keyWords = 6
       when 256
         @keyWords = 8
       else raise "The key must be 128, 192, or 256 bits long."
     end
-    
+
     case (keyBits >= blockBits) ? keyBits : blockBits
-      when 128 
+      when 128
         @rounds = 10
-      when 192 
+      when 192
         @rounds = 12
       when 256
         @rounds = 14
       else raise "The key and block sizes must be 128, 192, or 256 bits long."
     end
-   
+
     case blockBits
-      when 128 
+      when 128
         @blockSize = 16
         @blockWords = 4
         @shiftIndex = 0
-      when 192 
+      when 192
         @blockSize = 24
         @blockWords = 6
         @shiftIndex = 1
-      when 256 
+      when 256
         @blockSize = 32
         @blockWords = 8
         @shiftIndex = 2
       else raise "The block size must be 128, 192, or 256 bits long."
     end
-    
+
     uk = userKey.unpack('C'*userKey.length)
     maxUsefulSizeOfUserKey = (keyBits/8)
     uk = uk[0..maxUsefulSizeOfUserKey-1]    # truncate
@@ -68,22 +68,22 @@ class Rijndael
     @roundKeys = generate_key_schedule(@key, keyBits, blockBits)
   end
 
-  
+
   def block_size
     return(@blockSize) # needed for CBC
   end
-  
-  
+
+
   def mul(a, b)
     if ((a ==0) | (b == 0))
-      result = 0 
+      result = 0
     else
       result = AlogTable[(LogTable[a] + LogTable[b]) % 255]
     end
     return(result)
   end
-  
-  
+
+
   def add_round_key(blockArray, roundKey)
   0.upto(3) { |i|
     0.upto(@blockWords) { |j|
@@ -92,8 +92,8 @@ class Rijndael
   }
   return(blockArray)
   end
-  
-  
+
+
   def shift_rows(blockArray, direction)
     tmp = []
     1.upto(3) { |i|  # row zero remains unchanged
@@ -106,8 +106,8 @@ class Rijndael
     }
     return(blockArray)
   end
-  
-  
+
+
   def substitution(blockArray, sBox)
     # replace every byte of the input with the byte at that position in the S-box
     0.upto(3) { |i|
@@ -117,8 +117,8 @@ class Rijndael
     }
     return(blockArray)
   end
-  
-  
+
+
   def mix_columns(blockArray)
     mixed = [[], [], [], []]
     0.upto(@blockWords-1) { |j|
@@ -131,22 +131,22 @@ class Rijndael
     }
     return(mixed)
   end
-  
-  
+
+
   def inverse_mix_columns(blockArray)
     unmixed = [[], [], [], []]
     0.upto(@blockWords-1) { |j|
       0.upto(3) { |i|
         unmixed[i][j] = mul(0xe, blockArray[i][j]) ^
-          mul(0xb, blockArray[(i + 1) % 4][j]) ^                
+          mul(0xb, blockArray[(i + 1) % 4][j]) ^
           mul(0xd, blockArray[(i + 2) % 4][j]) ^
           mul(0x9, blockArray[(i + 3) % 4][j])
       }
     }
      return(unmixed)
   end
-  
-  
+
+
   def generate_key_schedule(k, keyBits, blockBits)
     tk = k[0..3][0..@keyWords-1]  # using slice to get a copy instead of a reference
     keySched = []
@@ -162,7 +162,7 @@ class Rijndael
     end
     # while not enough round key material collected, calculate new values
     rconIndex = 0
-    while (t < (@rounds+1)*@blockWords) 
+    while (t < (@rounds+1)*@blockWords)
       0.upto(3) { |i|
         tk[i][0] ^= S[tk[(i + 1) % 4][@keyWords - 1]]
       }
@@ -184,8 +184,8 @@ class Rijndael
           tk[i][@keyWords/2] ^= S[tk[i][@keyWords/2 - 1]]
         }
         (@keyWords/2 + 1).upto(@keyWords - 1) { |j|
-          0.upto(3) { |i| 
-            tk[i][j] ^= tk[i][j-1] 
+          0.upto(3) { |i|
+            tk[i][j] ^= tk[i][j-1]
           }
         }
       end
@@ -200,8 +200,8 @@ class Rijndael
     end
     return(keySched)
   end
-  
-  
+
+
   def encrypt_byte_array(blockArray)
     blockArray = add_round_key(blockArray, @roundKeys[0])
     1.upto(@rounds - 1) { |round|
@@ -216,54 +216,59 @@ class Rijndael
     blockArray = add_round_key(blockArray, @roundKeys[@rounds])
     return(blockArray)
   end
-  
-  
+
+
   def encrypt_block(block)
+    block = block.force_encoding("ASCII-8BIT") if block.is_a?(String) # affordance
     raise "block must be #{@blockSize} bytes long" if (block.length() != @blockSize)
     blockArray = [[], [], [], []]
     0.upto(@blockSize - 1) { |pos|
-      blockArray[pos % 4][pos / 4] = block[pos]
+      b = block[pos]
+      b = b.ord unless b.is_a?(Fixnum)
+      blockArray[pos % 4][pos / 4] = b
     }
     encryptedBlock = encrypt_byte_array(blockArray)
-    encrypted = ""
+    encrypted = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     0.upto(@blockSize - 1) { |pos|
       encrypted << encryptedBlock[pos % 4][pos / 4]
     }
     return(encrypted)
   end
-  
-  
+
+
   def decrypt_byte_array(blockArray)
     # first special round without inverse_mix_columns
     # add_round_key is an involution - applying it a second time returns the original result
-    blockArray = add_round_key(blockArray, @roundKeys[@rounds]) 
+    blockArray = add_round_key(blockArray, @roundKeys[@rounds])
     blockArray = substitution(blockArray,Si)   # using inverse S-box
     blockArray = shift_rows(blockArray,1)
     (@rounds-1).downto(1) { |round|
       blockArray = add_round_key(blockArray, @roundKeys[round])
       blockArray = inverse_mix_columns(blockArray)
-      blockArray = substitution(blockArray, Si) 
+      blockArray = substitution(blockArray, Si)
       blockArray = shift_rows(blockArray, 1)
     }
     blockArray = add_round_key(blockArray, @roundKeys[0])
     return(blockArray)
   end
-  
-  
+
+
   def decrypt_block(block)
     raise "block must be #{@blockSize} bytes long" if (block.length() != @blockSize)
     blockArray = [[], [], [], []]
     0.upto(@blockSize - 1) { |pos|
-      blockArray[pos % 4][pos / 4] = block[pos]
+      b = block[pos]
+      b = b.ord() unless b.is_a?(Fixnum)  # make sure we have a byte, not a single-char string
+      blockArray[pos % 4][pos / 4] = b
     }
     decryptedBlock = decrypt_byte_array(blockArray)
-    decrypted = ""
+    decrypted = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     0.upto(@blockSize - 1) { |pos|
       decrypted << decryptedBlock[pos % 4][pos / 4]
     }
     return(decrypted)
   end
-  
-  
+
+
+end
 end
-end

data/crypt/stringxor.rb

@@ -2,26 +2,26 @@
 
 module Crypt
 module StringXor
-  
-  
+
+
   def ^(aString)
     a = self.unpack('C'*(self.length))
     b = aString.unpack('C'*(aString.length))
     if (b.length < a.length)
       (a.length - b.length).times { b << 0 }
     end
-    xor = ""
+    xor = "".force_encoding("ASCII-8BIT")  # stop ruby 2 using Unicode
     0.upto(a.length-1) { |pos|
       x = a[pos] ^ b[pos]
       xor << x.chr()
     }
     return(xor)
   end
-  
-  
+
+
 end
 end
 
 class String
   include Crypt::StringXor
-end
+end

data/test/test-blowfish.rb

@@ -1,4 +1,5 @@
-# testblowfish.rb  bryllig
+# test-blowfish.rb
+# updated 11-Feb-2014 for ruby 2.0
 
 require 'test/unit'
 require 'crypt/blowfish'
@@ -6,14 +7,14 @@ require 'crypt/cbc'
 require 'fileutils'
 
 class TestBlowfish < Test::Unit::TestCase
-  
+
   def setup
      @bf = Crypt::Blowfish.new("Who is John Galt?")  # Schneier's test key
   end
-  
+
   def teardown
   end
-  
+
   def test_block_size
     assert_equal(8, @bf.block_size(), "Wrong block size")
   end
@@ -34,8 +35,8 @@ class TestBlowfish < Test::Unit::TestCase
   end
 
   def test_pair
-    bf = Crypt::Blowfish.new("Who is John Galt?")  
-    orig_l, orig_r = [0xfedcba98, 0x76543210] 
+    bf = Crypt::Blowfish.new("Who is John Galt?")
+    orig_l, orig_r = [0xfedcba98, 0x76543210]
     l, r = bf.encrypt_pair(orig_l, orig_r)
     assert_equal(0xcc91732b, l)
     assert_equal(0x8022f684, r)
@@ -45,19 +46,19 @@ class TestBlowfish < Test::Unit::TestCase
   end
 
   def test_block
-    bf = Crypt::Blowfish.new("Who is John Galt?") 
-    block = "norandom"
+    bf = Crypt::Blowfish.new("Who is John Galt?")
+    block = "8 byte\u00cd"   # unicode string of 8 bytes
     encryptedBlock = bf.encrypt_block(block)
-    assert_equal("\236\353k\321&Q\"\220", encryptedBlock)
+    assert_equal("\xC4G\xD3\xFD7\xF4\x1E\xD0".force_encoding('ASCII-8BIT'), encryptedBlock)
     decryptedBlock = bf.decrypt_block(encryptedBlock)
     assert_equal(block, decryptedBlock)
   end
-  
+
   def test_string
     length = 30 + rand(26)
     userkey = ""
     length.times { userkey << rand(256).chr }
-    bf = Crypt::Blowfish.new(userkey) 
+    bf = Crypt::Blowfish.new(userkey)
     string = "This is a string which is not a multiple of 8 characters long"
     encryptedString = bf.encrypt_string(string)
     decryptedString = bf.decrypt_string(encryptedString)
@@ -66,9 +67,9 @@ class TestBlowfish < Test::Unit::TestCase
     encryptedString = bf.encrypt_string(secondstring)
     decryptedString = bf.decrypt_string(encryptedString)
     assert_equal(secondstring, decryptedString)
-    
+
   end
-  
+
   def test_file
     plainText = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
     plainFile = File.new('plain.txt', 'wb+')

data/test/test-gost.rb

@@ -1,3 +1,5 @@
+# updated 11-Feb-2014 for ruby 2.0
+
 require 'test/unit'
 require 'crypt/gost'
 require 'fileutils'
@@ -9,7 +11,7 @@ class TestGost < Test::Unit::TestCase
 
 	def teardown
 	end
-	
+
     def test_init
 	  assert_nothing_raised(RuntimeError) {
         gost = Crypt::Gost.new("Whatever happened to Yuri Gagarin?")
@@ -18,15 +20,15 @@ class TestGost < Test::Unit::TestCase
         gost = Crypt::Gost.new("Whatever happened to Yuri?")
       }
     end
-    
+
   def test_block_size
     gost = Crypt::Gost.new("Whatever happened to Yuri?")
     assert_equal(8, gost.block_size(), "Wrong block size")
   end
 
   def test_pair
-    gost = Crypt::Gost.new("Whatever happened to Yuri?") 
-    orig_l, orig_r = [0xfedcba98, 0x76543210] 
+    gost = Crypt::Gost.new("Whatever happened to Yuri?")
+    orig_l, orig_r = [0xfedcba98, 0x76543210]
     l, r = gost.encrypt_pair(orig_l, orig_r)
     assert_equal(0xaefaf8f4, l)
     assert_equal(0xe24891b0, r)
@@ -36,31 +38,31 @@ class TestGost < Test::Unit::TestCase
   end
 
   def test_block
-    gost = Crypt::Gost.new("Whatever happened to Yuri?") 
+    gost = Crypt::Gost.new("Whatever happened to Yuri?")
     block = "norandom"
     encryptedBlock = gost.encrypt_block(block)
-    assert_equal(".Vy\377\005\e3`", encryptedBlock)
+    assert_equal(".Vy\xFF\x05\e3`".force_encoding('ASCII-8BIT'), encryptedBlock)
     decryptedBlock = gost.decrypt_block(encryptedBlock)
     assert_equal(block, decryptedBlock)
   end
-	
+
   def test_string
     length = 25 + rand(12)
     userkey = ""
     length.times { userkey << rand(256).chr }
-    gost = Crypt::Gost.new(userkey) 
+    gost = Crypt::Gost.new(userkey)
     string = "This is a string which is not a multiple of 8 characters long"
     encryptedString = gost.encrypt_string(string)
     decryptedString = gost.decrypt_string(encryptedString)
     assert_equal(string, decryptedString)
   end
-  
+
   def test_file
     plainText = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
     plainFile = File.new('plain.txt', 'wb+')
     plainFile.puts(plainText)
     plainFile.close()
-    gost = Crypt::Gost.new("Whatever happened to Yuri?") 
+    gost = Crypt::Gost.new("Whatever happened to Yuri?")
     gost.encrypt_file('plain.txt', 'crypt.txt')
     gost.decrypt_file('crypt.txt', 'decrypt.txt')
     decryptFile = File.new('decrypt.txt', 'rb')
@@ -72,4 +74,4 @@ class TestGost < Test::Unit::TestCase
     FileUtils.rm('decrypt.txt')
   end
 
-end
+end

data/test/test-idea.rb

@@ -1,3 +1,5 @@
+# updated 11-Feb-2014 for ruby 2.0 - changed expected values representation
+
 require 'test/unit'
 require 'crypt/idea'
 require 'fileutils'
@@ -9,60 +11,61 @@ class TestIdea < Test::Unit::TestCase
 
 	def teardown
 	end
-	
+
     def test_init
 	  assert_nothing_raised(RuntimeError) {
-        idea_en = Crypt::IDEA.new("Who was John Galt and where's my breakfast?", Crypt::IDEA::ENCRYPT)  
+        idea_en = Crypt::IDEA.new("Who was John Galt and where's my breakfast?", Crypt::IDEA::ENCRYPT)
       }
     end
-    
+
   def test_block_size
-    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT) 
+    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
     assert_equal(8, idea_en.block_size(), "Wrong block size")
   end
 
   def test_pair
-    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT) 
-    orig_l, orig_r = [0xfedcba98, 0x76543210] 
+    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
+    orig_l, orig_r = [0xfedcba98, 0x76543210]
     l, r = idea_en.crypt_pair(orig_l, orig_r)
     assert_equal(0x05627e79, l)
     assert_equal(0x69476521, r)
-    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT) 
+    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT)
     l, r = idea_de.crypt_pair(l, r)
     assert_equal(orig_l, l)
     assert_equal(orig_r, r)
   end
 
   def test_block
-    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT) 
-    block = "norandom"
+    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
+    block = "8 byte\u00cd"   # unicode string of 8 bytes
     encryptedBlock = idea_en.encrypt_block(block)
-    assert_equal("\235\003\326u\001\330\361\t", encryptedBlock)
-    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT) 
+    expected = "\xFA\xB1P\tk\xB0\x1C\xE1".force_encoding("ASCII-8BIT")
+    assert_equal(expected, encryptedBlock)
+    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT)
     decryptedBlock = idea_de.decrypt_block(encryptedBlock)
-    assert_equal(block, decryptedBlock)
+    assert_equal(block, decryptedBlock.force_encoding("UTF-8"))
   end
-	
+
   def test_string
     length = 25 + rand(12)
     userkey = ""
     length.times { userkey << rand(256).chr }
-    idea_en = Crypt::IDEA.new(userkey, Crypt::IDEA::ENCRYPT) 
+    idea_en = Crypt::IDEA.new(userkey, Crypt::IDEA::ENCRYPT)
     string = "This is a string which is not a multiple of 8 characters long"
     encryptedString = idea_en.encrypt_string(string)
-    idea_de = Crypt::IDEA.new(userkey, Crypt::IDEA::DECRYPT) 
+    idea_de = Crypt::IDEA.new(userkey, Crypt::IDEA::DECRYPT)
     decryptedString = idea_de.decrypt_string(encryptedString)
     assert_equal(string, decryptedString)
   end
-  
+
   def test_file
     plainText = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
     plainFile = File.new('plain.txt', 'wb+')
     plainFile.puts(plainText)
     plainFile.close()
-    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT) 
+    idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
     idea_en.encrypt_file('plain.txt', 'crypt.txt')
-    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT) 
+    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT)
     idea_de.decrypt_file('crypt.txt', 'decrypt.txt')
     decryptFile = File.new('decrypt.txt', 'rb')
     decryptText = decryptFile.readlines().join('').chomp()
@@ -73,4 +76,4 @@ class TestIdea < Test::Unit::TestCase
     FileUtils.rm('decrypt.txt')
   end
 
-end
+end