crypt 1.1.3 → 2.2.1

data/{crypt → lib/crypt}/rijndael.rb

@@ -1,4 +1,5 @@
-# rijndael.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+require 'crypt/cbc'
+# rijndael.rb  Richard Kernahan 
 
 # Adapted from the reference C implementation:
 #   rijndael-alg-ref.c   v2.2   March 2002
@@ -6,53 +7,51 @@
 #   authors: Paulo Barreto and Vincent Rijmen
 #   This code is placed in the public domain.
 
+require 'crypt/rijndael-tables'
+
 module Crypt
 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 +67,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 +91,8 @@ class Rijndael
   }
   return(blockArray)
   end
-  
-  
+
+
   def shift_rows(blockArray, direction)
     tmp = []
     1.upto(3) { |i|  # row zero remains unchanged
@@ -106,8 +105,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 +116,8 @@ class Rijndael
     }
     return(blockArray)
   end
-  
-  
+
+
   def mix_columns(blockArray)
     mixed = [[], [], [], []]
     0.upto(@blockWords-1) { |j|
@@ -131,22 +130,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 +161,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 +183,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 +199,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 +215,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/lib/crypt/stringxor.rb

@@ -0,0 +1,17 @@
+class String
+
+  def ^(aString)
+    a = self.b.unpack('C'*(self.length))
+    b = aString.b.unpack('C'*(aString.length))
+    if (b.length < a.length)
+      (a.length - b.length).times { b << 0 }
+    end
+    xor = "".b()
+    0.upto(a.length-1) { |pos|
+      x = a[pos] ^ b[pos]
+      xor << x.chr()
+    }
+    return(xor)
+  end
+
+end

data/specs/blowfish.rb

@@ -0,0 +1,80 @@
+require 'crypt/blowfish'
+require 'fileutils'
+
+describe "Crypt::Blowfish" do
+	
+	it "has a blocksize of 8" do
+		bf = Crypt::Blowfish.new("Who is John Galt?")  # Schneier's test key
+		expect(bf.block_size).to eql(8)
+	end
+	
+	it "requires a key of 1-56 bytes" do
+		expect {
+			b0 = Crypt::Blowfish.new("")
+		}.to raise_error(RuntimeError)
+		expect {
+			b1 = Crypt::Blowfish.new("1")
+		}.not_to raise_error()
+		expect {
+			b56 = Crypt::Blowfish.new("1"*56)
+		}.not_to raise_error()
+		expect {
+			b57 = Crypt::Blowfish.new("1"*57)
+		}.to raise_error(RuntimeError)
+	end
+	
+	it "encrypts and decrypts 4-byte pairs" do
+		bf = Crypt::Blowfish.new("Who is John Galt?")
+		orig_l, orig_r = [0xfedcba98, 0x76543210]
+		l, r = bf.encrypt_pair(orig_l, orig_r)
+		expect(l).to eql(0xcc91732b)
+		expect(r).to eql(0x8022f684)
+		l, r = bf.decrypt_pair(l, r)
+		expect(l).to eql(orig_l)
+		expect(r).to eql(orig_r)
+	end
+	
+	it "encrypts and decrypts 8-byte blocks" do
+		bf = Crypt::Blowfish.new("Who is John Galt?")
+    block = "8 byte\u00cd"   # unicode string of 8 bytes
+    encryptedBlock = bf.encrypt_block(block)
+    expect(encryptedBlock).to eql("\xC4G\xD3\xFD7\xF4\x1E\xD0".b())
+    decryptedBlock = bf.decrypt_block(encryptedBlock)
+    expect(decryptedBlock).to eql(block)
+	end
+	
+	it "encrypts and decrypts strings" do
+		length = 30 + rand(26)
+    userkey = ""
+    length.times { userkey << rand(256).chr }
+    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)
+    expect(decryptedString).to eql(string)
+    secondstring = "This is another string to check repetitive use."
+    encryptedString = bf.encrypt_string(secondstring)
+    decryptedString = bf.decrypt_string(encryptedString)
+    expect(decryptedString).to eql(secondstring)
+	end
+	
+	it "encrypts and decrypts a file" do
+		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()
+    bf = Crypt::Blowfish.new("Who is John Galt?")
+    bf.encrypt_file('plain.txt', 'crypt.txt')
+    bf.decrypt_file('crypt.txt', 'decrypt.txt')
+    decryptFile = File.new('decrypt.txt', 'rb')
+    decryptText = decryptFile.readlines().join('').chomp()
+    decryptFile.close()
+    expect(decryptText).to eql(plainText)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+	end
+	
+end
+
+

data/specs/gost.rb

@@ -0,0 +1,48 @@
+require 'crypt/gost'
+require 'fileutils'
+
+describe "Crypt::Gost" do
+
+	it "has a blocksize of 8" do
+		gost = Crypt::Gost.new("Whatever happened to Yuri Gagarin?")
+		expect(gost.block_size).to eql(8)
+	end
+	
+	it "encrypts and decrypts 8-byte blocks" do
+		gost = Crypt::Gost.new("Whatever happened to Yuri?")
+    block = "norandom"
+    encryptedBlock = gost.encrypt_block(block)
+    expect(encryptedBlock).to eql(".Vy\xFF\x05\e3`".b())
+    decryptedBlock = gost.decrypt_block(encryptedBlock)
+    expect(decryptedBlock).to eql(block)
+	end
+	
+	it "encrypts and decrypts strings" do
+		length = 25 + rand(12)
+    userkey = ""
+    length.times { userkey << rand(256).chr }
+    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)
+    expect(decryptedString).to eql(string)
+	end
+	
+	it "encrypts and decrypts a file" do
+		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.encrypt_file('plain.txt', 'crypt.txt')
+    gost.decrypt_file('crypt.txt', 'decrypt.txt')
+    decryptFile = File.new('decrypt.txt', 'rb')
+    decryptText = decryptFile.readlines().join('').chomp()
+    decryptFile.close()
+    expect(decryptText).to eql(plainText)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+	end
+
+end

data/specs/idea.rb

@@ -0,0 +1,156 @@
+require 'crypt/idea'
+require 'fileutils'
+
+describe "Crypt::IDEA" do
+
+	it "encrypts and decrypts 4-byte pairs" do
+		enc = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::ENCRYPT)
+		dec = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::DECRYPT)
+		origL = 0x385a41f2 
+		origR = 0xe03e5930
+		cl, cr = enc.crypt_pair(origL, origR)
+		dl, dr = dec.crypt_pair(cl, cr)
+		expect(dl).to eql(origL)
+		expect(dr).to eql(origR)
+	end
+
+	it "encrypts and decrypts 8-byte blocks" do
+		enc = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::ENCRYPT)
+		dec = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::DECRYPT)
+    block = "norandom"
+    encryptedBlock = enc.encrypt_block(block)
+    expect(encryptedBlock).to eql("\xC2lzEU\x81\e_".b())
+    decryptedBlock = dec.decrypt_block(encryptedBlock)
+    expect(decryptedBlock).to eql(block)
+	end
+	
+	it "encrypts and decrypts strings" do
+    enc = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::ENCRYPT)
+		dec = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::DECRYPT)
+    string = "This is a string which is not a multiple of 8 characters long"
+    encryptedString = enc.encrypt_string(string)
+    decryptedString = dec.decrypt_string(encryptedString)
+    expect(decryptedString).to eql(string)
+	end
+	
+	it "encrypts and decrypts a file" do
+		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()
+    enc = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::ENCRYPT)
+		dec = Crypt::IDEA.new("Nothing can stop an idea whose time has come", Crypt::IDEA::DECRYPT)
+    enc.encrypt_file('plain.txt', 'crypt.txt')
+    dec.decrypt_file('crypt.txt', 'decrypt.txt')
+    decryptFile = File.new('decrypt.txt', 'rb')
+    decryptText = decryptFile.readlines().join('').chomp()
+    decryptFile.close()
+    expect(decryptText).to eql(plainText)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+	end
+	
+	def h(s)
+		[s].pack("H*")
+	end
+	
+	def n8(s)
+		h(s).unpack("n8")
+	end
+	
+	def conform(key, plain, cipher)
+		enc = Crypt::IDEA.new("", Crypt::IDEA::ENCRYPT)
+		enc.subkeys = enc.generate_encryption_subkeys(key)
+		dec = Crypt::IDEA.new("", Crypt::IDEA::ENCRYPT)
+		dec.subkeys = dec.generate_decryption_subkeys(key)
+		encryptedBlock = enc.encrypt_block(plain)
+    expect(encryptedBlock).to eql(cipher.b())
+		decryptedBlock = dec.decrypt_block(encryptedBlock)
+    expect(decryptedBlock).to eql(plain)
+	end
+		
+	def conform_dec(key, cipher, plain)
+		dec = Crypt::IDEA.new("", Crypt::IDEA::ENCRYPT)
+		dec.subkeys = dec.generate_decryption_subkeys(key)
+		decryptedBlock = dec.decrypt_block(cipher)
+    expect(decryptedBlock).to eql(plain)
+	end
+		
+	it "conforms to enceryption test vectors" do
+		conform([0x8000,0,0,0,0,0,0,0], h("0000000000000000"), h("B1F5F7F87901370F"))
+		conform([0x4000,0,0,0,0,0,0,0], h("0000000000000000"), h("B3927DFFB6358626"))
+		conform([0x2000,0,0,0,0,0,0,0], h("0000000000000000"), h("E987E0029FB99785"))
+		conform([0x1000,0,0,0,0,0,0,0], h("0000000000000000"), h("754A03CE08DB7DAA"))
+		conform([0x0800,0,0,0,0,0,0,0], h("0000000000000000"), h("F015F9FB0CFC7E1C"))
+		conform([0x0400,0,0,0,0,0,0,0], h("0000000000000000"), h("69C9FE6007B8FCDF"))
+		conform([0x0200,0,0,0,0,0,0,0], h("0000000000000000"), h("8DA7BC0E63B40DD0"))
+		conform([0x0100,0,0,0,0,0,0,0], h("0000000000000000"), h("2C49BF7DE28C666B"))
+		conform([  0x80,0,0,0,0,0,0,0], h("0000000000000000"), h("9A4717E8F935712B"))
+		conform([0,0x8000,0,0,0,0,0,0], h("0000000000000000"), h("95A96731978C1B9A"))
+		conform([0,0,0x8000,0,0,0,0,0], h("0000000000000000"), h("398BD9A59E9F5DDB"))
+		conform([0,0,0,0x8000,0,0,0,0], h("0000000000000000"), h("AC1D8708AF0A37EE"))
+		conform([0,0,0,0,0x8000,0,0,0], h("0000000000000000"), h("FAE3FA7B8DB08800"))
+		conform([0,0,0,0,0,0x8000,0,0], h("0000000000000000"), h("B5803F82C0633F01"))
+		conform([0,0,0,0,0,  0x10,0,0], h("0000000000000000"), h("9E25090B7D4EF24E"))
+		conform([0,0,0,0,0,   0x8,0,0], h("0000000000000000"), h("EF62C1109F374AA8"))
+		conform([0,0,0,0,0,   0x2,0,0], h("0000000000000000"), h("5F0CCFE5EB0F19A8"))
+		conform([0xffff,0xffff,0xffff,0xffff,0xffff,0x1,0x000f,0xffff], h("0000000000000000"), h("2E4329C12455430B"))
+		# had problems with bits 95 to 108 inclusive, fixed by final % USHORT on mul()
+		conform([0,0,0,0,0,   0x1,0,0], h("0000000000000000"), h("FCC40014010D617C"))
+		conform([0,0,0,0,0,0,0x8000,0], h("0000000000000000"), h("705D780834A498DA"))
+		conform([0,0,0,0,0,0,0x4000,0], h("0000000000000000"), h("9BCA7BF025B38A68"))
+		conform([0,0,0,0,0,0,0x2000,0], h("0000000000000000"), h("5CF67D0181CB01C1"))
+		conform([0,0,0,0,0,0,0x1000,0], h("0000000000000000"), h("ECDE3D81820381C1"))
+		conform([0,0,0,0,0,0,  0x80,0], h("0000000000000000"), h("C781050DC4110220"))
+		conform([0,0,0,0,0,0,  0x40,0], h("0000000000000000"), h("6DFD0287EC4C0110"))
+		conform([0,0,0,0,0,0,  0x20,0], h("0000000000000000"), h("3B8A017EFB61800E"))
+		conform([0,0,0,0,0,0,  0x10,0], h("0000000000000000"), h("A08F7F81FF627FC0"))
+		conform([0,0,0,0,0,0,   0x8,0], h("0000000000000000"), h("00503FC1AFB93FE0"))
+		conform([0,0,0,0,0,0,   0x1,0], h("0000000000000000"), h("46D371477F33B152"))
+		conform([0,0,0,0,0,0,0,0x8000], h("0000000000000000"), h("BE67AC7DA294CA7C"))
+		conform([0,0,0,0,0,0,0,0], h("8000000000000000"), h("8001000180008000"))
+		conform([0,0,0,0,0,0,0,0], h("0080000000000000"), h("9181E3014C80C980"))
+		conform([0,0,0,0,0,0,0,0], h("0000800000000000"), h("0001800180008000"))
+		conform([0,0,0,0,0,0,0,0], h("0000000200000000"), h("FF49003BFF26FFAA"))
+		conform([0,0,0,0,0,0,0,0], h("0000000004000000"), h("100100014C00E000"))
+		conform([0,0,0,0,0,0,0,0], h("0000000000040000"), h("01110001FE4C00E0"))
+		conform([0,0,0,0,0,0,0,0], h("0000000000001000"), h("8001C001E0009000"))
+		conform([0,0,0,0,0,0,0,0], h("0000000000000100"), h("C8012C018E009900"))
+		conform([0,0,0,0,0,0,0,0], h("0000000000000040"), h("32010B012380E640"))
+		conform([0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101,0x0101], h("0101010101010101"), h("E3F8AFF7A3795615"))
+		conform([0x7777,0x7777,0x7777,0x7777,0x7777,0x7777,0x7777,0x7777], h("7777777777777777"), h("D2E486D93304B9B6"))
+		conform([0xF7F7,0xF7F7,0xF7F7,0xF7F7,0xF7F7,0xF7F7,0xF7F7,0xF7F7], h("F7F7F7F7F7F7F7F7"), h("8E13C368F53E55AF"))
+		conform([1,0x203,0x405,0x607,0x809,0xa0b,0xc0d,0xe0f], h("0011223344556677"), h("F526AB9A62C0D258"))
+	end
+	
+	it "conforms to decryption test vectors" do
+		conform_dec(n8("80000000000000000000000000000000"), h("0000000000000000"), h("78071EE87F0130E8"))
+		conform_dec(n8("00008000000000000000000000000000"), h("0000000000000000"), h("14D47C44835EEB99"))
+		conform_dec(n8("00000000800000000000000000000000"), h("0000000000000000"), h("CEA444C8CE44C2C2"))
+		conform_dec(n8("00000000000000000080000000000000"), h("0000000000000000"), h("6A9EF2F77DE21D8E"))
+		conform_dec(n8("00000000000000000000000800000000"), h("0000000000000000"), h("E698BE39AEA13C79"))
+		conform_dec(n8("00000000000000000000000000400000"), h("0000000000000000"), h("0579E00B945ED0B2"))
+		conform_dec(n8("00000000000000000000000000080000"), h("0000000000000000"), h("F0903DB58BEFF8CF"))
+		conform_dec(n8("00000000000000000000000000000040"), h("0000000000000000"), h("F75986F389F08110"))
+		conform_dec(n8("00000000000000000000000000000000"), h("8000000000000000"), h("8001000180008000"))
+		conform_dec(n8("00000000000000000000000000000000"), h("0002000000000000"), h("FE47FF8D0132FF26"))
+		conform_dec(n8("00000000000000000000000000000000"), h("0000000000200000"), h("08810001F2600700"))
+		conform_dec(n8("00000000000000000000000000000000"), h("0000000000000400"), h("2001B00138006400"))
+		conform_dec(n8("11111111111111111111111111111111"), h("1111111111111111"), h("3A1D3B4DB127C8B7"))
+		conform_dec(n8("52525252525252525252525252525252"), h("5252525252525252"), h("B255918917D30DB6"))
+		conform_dec(n8("66666666666666666666666666666666"), h("6666666666666666"), h("C9248B00868D8651"))
+		conform_dec(n8("ABABABABABABABABABABABABABABABAB"), h("ABABABABABABABAB"), h("5A4C4870F25A207F"))
+		conform_dec(n8("000102030405060708090A0B0C0D0E0F"), h("0011223344556677"), h("DB2D4A92AA68273F"))
+		conform_dec(n8("2BD6459F82C5B300952C49104881FF48"), h("EA024714AD5C4D84"), h("F129A6601EF62A47"))
+	end
+	
+	it "calculates multiplicative inverses" do
+		idea = Crypt::IDEA.new("", Crypt::IDEA::ENCRYPT)
+		expect(idea.mulInv(0)).to eql(0)
+		(1..0xffff).each { |i|
+			expect(i * idea.mulInv(i) % 0x10001).to eql(1)
+		}	
+	end
+
+end

data/specs/rijndael.rb

@@ -0,0 +1,58 @@
+require 'crypt/rijndael'
+require 'fileutils'
+
+describe "Crypt::Rijndael" do
+
+	it "has a blocksize of 128, 192, or 256 bits" do
+		expect {
+			rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 64)
+		}.to raise_error(RuntimeError)
+		expect {
+			rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 64)
+		}.to raise_error(RuntimeError)
+		rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 256)
+		expect(rijndael.block_size).to eql(32)
+		rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 256, 128)
+		expect(rijndael.block_size).to eql(16)
+	end
+	
+	it "encrypts and decrypts 8-byte blocks" do
+		rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 128)
+    block = "This block \u00cd 16"  # unicode string of 16 bytes
+    encryptedBlock = rijndael.encrypt_block(block)
+    expect(encryptedBlock).to eql("\x8E\x88\x03\xB8> PnwR)\x93\x1A\xC9:\xC4".b())
+    decryptedBlock = rijndael.decrypt_block(encryptedBlock)
+    expect(decryptedBlock).to eql(block)
+    # attempt to encrypt with wrong block size
+    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 256)
+    expect {
+    	encryptedBlock = rijndael.encrypt_block(block)
+    }.to raise_error(RuntimeError)
+	end
+	
+	it "encrypts and decrypts strings" do
+		rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?")
+    string = "This is a string which is not a multiple of 8 characters long"
+    encryptedString = rijndael.encrypt_string(string)
+    decryptedString = rijndael.decrypt_string(encryptedString)
+    expect(decryptedString).to eql(string)
+	end
+	
+	it "encrypts and decrypts a file" do
+		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()
+    rijndael = Crypt::Rijndael.new("Whatever happened to Yuri?")
+    rijndael.encrypt_file('plain.txt', 'crypt.txt')
+    rijndael.decrypt_file('crypt.txt', 'decrypt.txt')
+    decryptFile = File.new('decrypt.txt', 'rb')
+    decryptText = decryptFile.readlines().join('').chomp()
+    decryptFile.close()
+    expect(decryptText).to eql(plainText)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+	end
+
+end