crypt 2.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52adac97c724e6cda38884007042b2eda55fc299
-  data.tar.gz: a017aaec965e38ea808116495ddc84ed94048f94
+  metadata.gz: c26c671cabb4969a940b582444ad370d623e18b2
+  data.tar.gz: db5d9d98b3519d5b7ae97098db35946ef612f192
 SHA512:
-  metadata.gz: 97bb5b0bed207146235d0285d78c6435cee219544eee140c8c9aa86b7d70b7437ad657d930f44a3cdaa3face1ef937f62ff16e58e6dd58daa3b84a088714050b
-  data.tar.gz: 51fec804a2c85eba54a33c81ee4b980636cb9a8e6015c033260acc26812eac511d99f569f13f7802b776038e0bb760cf71ad3f4d8d73ecd1b14e49a9960e79ce
+  metadata.gz: 042e0eaa49184aff6932e6697ec475dec5592d1a55c9c34444e4ebabbc5bcbdacb0ad6b07cb2cad4b2e16490a0ede0955b143c815e4e43b81d78e6d93ddae609
+  data.tar.gz: 9250d375de4633729a07357d5489497cd92d0f72994882f3833e01ab2aff8dd0e64942a6a918fae9b180cbfca753348e9484529c8092dcc63564276c84f95f09

data/{crypt → lib/crypt}/blowfish-tables.rb

@@ -1,5 +1,61 @@
-# blowfish-tables.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
+#The Crypt library is a pure-ruby implementation of a number of popular encryption algorithms.
+#Block cyphers currently available include Blowfish, GOST, IDEA, and Rijndael (AES).
+#Cypher Block Chaining (CBC) has been implemented.
+#
+#Crypt is written entirely in ruby so deployment is simple - no platform concerns,
+#no library dependencies, nothing to compile.
+#
+#Performance is what you would expect from a pure-ruby implementation: it is adequate for shorter messages
+#but I wouldn't try to encrypt my whole disk with it. If performance is critical then you might want to try
+#ezcrypto's (http://ezcrypto.rubyforge.org) interface to OpenSSL.
+#
+#v.2.2.0 released 23 Sep 2015 fixes a defect in IDEA and replaces tests with specs.
+#
+#    require 'crypt/blowfish'
+#    blowfish = Crypt::Blowfish.new("A key up to 56 bytes long")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = blowfish.encrypt_block(plainBlock)
+#    decryptedBlock = blowfish.decrypt_block(encryptedBlock)
+#		 string = "This is a string which is not a multiple of 8 characters long"
+#    encryptedString = bf.encrypt_string(string)
+#    decryptedString = bf.decrypt_string(encryptedString)
+#		bf.encrypt_file('plain.txt', 'crypt.txt')
+#    bf.decrypt_file('crypt.txt', 'decrypt.txt')
+#
+#    require 'crypt/gost' 
+#    # a key shorter than 32 bytes will be padded out with zeroes
+#    gost = Crypt::Gost.new("This is a contrived 32 byte key!")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = gost.encrypt_block(plainBlock)
+#    decryptedBlock = gost.decrypt_block(encryptedBlock)
+#
+#    require 'crypt/idea' 
+#    idea = Crypt::IDEA.new("A key up to 56 bytes long")
+#    plainBlock = "ABCD1234"
+#    encryptedBlock = idea.encrypt_block(plainBlock)
+#    decryptedBlock = idea.decrypt_block(encryptedBlock)
+#
+#    require 'crypt/rijndael' 
+#    rijndael = Crypt::Rijndael.new("A key 16, 24, or 32 bytes length")
+#    plainBlock = "ABCDEFGH12345678"
+#    encryptedBlock = rijndael.encrypt_block(plainBlock)
+#    decryptedBlock = rijndael.decrypt_block(encryptedBlock)
+#
+#Cipher-block chaining (CBC) is supported for each algorithm:
+#
+#    blowfish = Crypt::Blowfish.new("A sample key better than this one")
+#    blowfish.encrypt_file('plain.txt', 'crypt.txt')
+#    blowfish.decrypt_file('crypt.txt', 'plain.txt')
+#
+#You can also read from a plain text stream,
+#encrypt and write to an encrypted output stream, or treat a string as a stream:
+#
+#    f = File.new('plain.txt', 'r')
+#    g = TCPSocket.new('encrypted.example.com', 2222)
+#    blowfish.encrypt_stream(f, g)
+# 
+#    plainText = "This is plain text."
+#    encrypted = blowfish.encrypt_string(plainText)
 module Crypt
 module BlowfishTables
   
@@ -187,4 +243,4 @@ module BlowfishTables
   
 
 end
-end
+end

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

@@ -1,9 +1,8 @@
-# blowfish.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# blowfish.rb  Richard Kernahan 
 #
 #  Blowfish algorithm by Bruce Schneider
 #  Ported by Richard Kernahan from the reference C code
-
-module Crypt
 class Blowfish
 
   require 'crypt/cbc'

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

@@ -1,6 +1,6 @@
-# cbc.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
 module Crypt
+
+# cbc.rb  Richard Kernahan 
 module CBC
 
   require 'stringio'

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

@@ -1,9 +1,8 @@
+module Crypt
 # gost.rb  
-# Adapted by Richard Kernahan <kernighan_rich@rubyforge.org> 
+# Adapted by Richard Kernahan 
 # from C++ code written by Wei Dai 
 # of the Crypto++ project http://www.eskimo.com/~weidai/cryptlib.html
-
-module Crypt
 class Gost
 
   require 'crypt/cbc'
@@ -137,4 +136,4 @@ class Gost
 
 
 end
-end
+end

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

@@ -1,10 +1,9 @@
-# idea.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# idea.rb  Richard Kernahan 
 
 # IDEA (International Data Encryption Algorithm) by
-# Xuejia Lai and James Massey (1992).  Refer to license info at end.
-# Ported by Richard Kernahan 2005
+# Xuejia Lai and James Massey (1992). Ported by Richard Kernahan 2005
 
-module Crypt
 class IDEA
 
   require 'crypt/cbc'
@@ -12,24 +11,23 @@ class IDEA
 
   require 'digest/md5'
 
-  ULONG   = 0x100000000
   USHORT  = 0x10000
 
   ENCRYPT = 0
   DECRYPT = 1
-
+  
+  attr_accessor(:subkeys)
 
   def block_size
     return(8)
   end
 
-
   def initialize(key128, mode)
     # IDEA is subject to attack unless the key is sufficiently random, so we
     # take an MD5 digest of a variable-length passphrase to ensure a solid key
     if (key128.class == String)
-      digest = Digest::MD5.new().digest(key128)
-      key128 = digest.unpack('n'*8)
+      digest = Digest::MD5.new().digest(key128.b).b()
+      key128 = digest.unpack('n8')
     end
     raise "Key must be 128 bits (8 words)" unless (key128.class == Array) && (key128.length == 8)
     raise "Mode must be IDEA::ENCRYPT or IDEA::DECRYPT" unless ((mode == ENCRYPT) | (mode == DECRYPT))
@@ -39,21 +37,19 @@ class IDEA
       @subkeys = generate_decryption_subkeys(key128)
     end
   end
-
-
+  
   def mul(a, b)
     modulus = 0x10001
     return((1 - b) % USHORT) if (a == 0)
     return((1 - a) % USHORT) if (b == 0)
-    return((a * b) % modulus)
+    return((a * b) % modulus % USHORT)   # fixed with % USHORT
   end
 
-
   def mulInv(x)
     modulus = 0x10001
-    x = x.to_i % USHORT
+    x = x.to_i % 0x10000
     return(x) if (x <= 1)
-    t1 = USHORT / x
+    t1 = modulus / x
     y  = modulus % x
     if (y == 1)
       inv = (1 - t1) & 0xFFFF
@@ -73,7 +69,6 @@ class IDEA
     return(inv)
   end
 
-
   def generate_encryption_subkeys(key)
     encrypt_keys = []
     encrypt_keys[0..7] = key.dup
@@ -85,7 +80,6 @@ class IDEA
     return(encrypt_keys)
   end
 
-
   def generate_decryption_subkeys(key)
     encrypt_keys = generate_encryption_subkeys(key)
     decrypt_keys = []
@@ -97,7 +91,7 @@ class IDEA
       decrypt_keys[i+4] = encrypt_keys.shift % USHORT
       decrypt_keys[i+5] = encrypt_keys.shift % USHORT
       decrypt_keys[i]   = mulInv(encrypt_keys.shift)
-      if (i ==0)
+      if (i == 0)
         decrypt_keys[1] = (-encrypt_keys.shift) % USHORT
         decrypt_keys[2] = (-encrypt_keys.shift) % USHORT
       else
@@ -109,7 +103,6 @@ class IDEA
     return(decrypt_keys)
   end
 
-
   def crypt_pair(l, r)
     word = [l, r].pack('NN').unpack('nnnn')
     k = @subkeys[0..51]
@@ -145,7 +138,6 @@ class IDEA
     return(encrypted)
   end
 
-
   def decrypt_block(block)
     xl, xr = block.unpack('NN')
     xl, xr = crypt_pair(xl, xr)
@@ -153,40 +145,6 @@ class IDEA
     return(decrypted)
   end
 
-
 end
 end
 
-  # LICENSE INFORMATION
-  #
-  # This software product contains the IDEA algorithm as described and claimed in
-  # US patent 5,214,703, EPO patent 0482154 (covering Austria, France, Germany,
-  # Italy, the Netherlands, Spain, Sweden, Switzerland, and the UK), and Japanese
-  # patent application 508119/1991, "Device for the conversion of a digital block
-  # and use of same" (hereinafter referred to as "the algorithm").  Any use of
-  # the algorithm for commercial purposes is thus subject to a license from Ascom
-  # Systec Ltd. of CH-5506 Maegenwil (Switzerland), being the patentee and sole
-  # owner of all rights, including the trademark IDEA.
-  #
-  # Commercial purposes shall mean any revenue generating purpose including but
-  # not limited to:
-  #
-  # i) Using the algorithm for company internal purposes (subject to a site
-  #    license).
-  #
-  # ii) Incorporating the algorithm into any software and distributing such
-  #     software and/or providing services relating thereto to others (subject to
-  #     a product license).
-  #
-  # iii) Using a product containing the algorithm not covered by an IDEA license
-  #      (subject to an end user license).
-  #
-  # All such end user license agreements are available exclusively from Ascom
-  # Systec Ltd and may be requested via the WWW at http://www.ascom.ch/systec or
-  # by email to idea@ascom.ch.
-  #
-  # Use other than for commercial purposes is strictly limited to non-revenue
-  # generating data transfer between private individuals.  The use by government
-  # agencies, non-profit organizations, etc is considered as use for commercial
-  # purposes but may be subject to special conditions.  Any misuse will be
-  # prosecuted.

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

@@ -1,9 +1,9 @@
-# crypt/rattle.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+module Crypt
+# crypt/noise.rb  Richard Kernahan 
 
 # add_noise - take a message and intersperse noise to make a new noisy message of given byte-length
 # remove_noise - take a noisy message and extract the message
 
-module Crypt
 module Noise
 
   def add_noise(newLength)

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

@@ -1,6 +1,5 @@
-# rijndael-tables.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
 module Crypt
+# rijndael-tables.rb  
 module RijndaelTables
 
 LogTable = [
@@ -114,4 +113,4 @@ Shifts = [
 ]
 
 end
-end
+end

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,16 +7,14 @@
 #   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

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

metadata

@@ -1,60 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: crypt
 version: !ruby/object:Gem::Version
-  version: '2.0'
+  version: 2.2.0
 platform: ruby
 authors:
 - Richard Kernahan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2015-09-23 00:00:00.000000000 Z
 dependencies: []
 description: The Crypt library is a pure-ruby implementation of a number of popular
   encryption algorithms. Block cyphers currently include Blowfish, GOST, IDEA, and
   Rijndael (AES). Cypher Block Chaining (CBC) has been implemented, and unicode is
   supported.
-email: kernighan_rich@rubyforge.org
+email: recdev@finalstep.com.au
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- crypt/blowfish-tables.rb
-- crypt/blowfish.rb
-- crypt/cbc.rb
-- crypt/gost.rb
-- crypt/idea.rb
-- crypt/noise.rb
-- crypt/rijndael-tables.rb
-- crypt/rijndael.rb
-- crypt/stringxor.rb
-- test/break-idea.rb
-- test/devServer.rb
-- test/test-blowfish.rb
-- test/test-gost.rb
-- test/test-idea.rb
-- test/test-rijndael.rb
-homepage: http://crypt.rubyforge.org/
+- lib/crypt/blowfish-tables.rb
+- lib/crypt/blowfish.rb
+- lib/crypt/cbc.rb
+- lib/crypt/gost.rb
+- lib/crypt/idea.rb
+- lib/crypt/noise.rb
+- lib/crypt/rijndael-tables.rb
+- lib/crypt/rijndael.rb
+- lib/crypt/stringxor.rb
+- specs/blowfish.rb
+- specs/gost.rb
+- specs/idea.rb
+- specs/rijndael.rb
+homepage: http://crypt.finalstep.com.au/
 licenses:
 - MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
-- .
+- "."
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: crypt
-rubygems_version: 2.1.10
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Pure-ruby cryptographic library including Blowfish, GOST, IDEA, and Rijndael

data/crypt/stringxor.rb

@@ -1,27 +0,0 @@
-# stringxor.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-
-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 = "".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

data/test/break-idea.rb

@@ -1,61 +0,0 @@
-# break-idea.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
-# prove that IDEA is broken and try to find out why
-
-require 'crypt/idea'
-require 'crypt/blowfish'
-
-# generate evidence for defect in IDEA implementation
-#  idea_en = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
-#  idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT)
-#  srand()
-#  puts "Finding pairs that fail to encrypt:"
-#  while(true) 
-#    origL = rand(Crypt::IDEA::ULONG)
-#    origR = rand(Crypt::IDEA::ULONG)
-#    cl, cr = idea_en.crypt_pair(origL, origR)
-#    dl, dr = idea_de.crypt_pair(cl, cr)
-#    if ((origL != dl) | (origR != dr))
-#      cl, cr = idea_en.crypt_pair(origL, origR)
-#      dl, dr = idea_de.crypt_pair(cl, cr)
-#      if ((origL != dl) | (origR != dr))
-#       printf("[0x%-9x , 0x%-9x]\n", origL, origR)
-#       $stdout.flush()
-#      end
-#    end
-#  end
-#  fatalPairs = [
-#    [0x5bb809a4, 0x804d4aba ],
-#    [0xead99b1 , 0xf64a62dd ],
-#    [0x50d72345, 0x4f6036d9 ],
-#    [0x32d41b94, 0x796a2eb5 ],
-#    [0x5d8a606e, 0x33befad  ],
-#    [0x87b9dd21, 0xf5d9e7ce ],
-#    [0xd96be22c, 0x68fe08c9 ],
-#    [0x452131e8, 0xe687bd5  ],
-#    [0x827d9308, 0x512ace3d ],
-#    [0x5f0931d1, 0xb3b5c5c1 ],
-#    [0xd6dc1475, 0xf8964e8b ],
-#    [0xb7d7bba6, 0x8b8652e9 ],
-#    [0x2f42b24b, 0x6a889e95 ],
-#    [0x4e6eaebb, 0x99816f1  ]
-#  ]
-#  fatalPairs.each { |pair|
-#    origL, origR = pair
-#    cl, cr = idea_en.crypt_pair(origL, origR)
-#    dl, dr = idea_de.crypt_pair(cl, cr)
-#    if ((origL != dl) | (origR != dr))
-#      puts "still broken"
-#    end
-#  }
-#idea = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::ENCRYPT)
-#(-3..0x10003).each { |a|
-#  inv = idea.mulInv(a)
-#  product = idea.mul(a, inv)
-#  if product != 1
-#    puts "a=#{a}  inv=#{inv} mul(a,inv)=#{product}"
-#    $stdout.flush()
-#  end
-#}
-
-
-

data/test/devServer.rb

@@ -1,16 +0,0 @@
-# run the crypt website
-
-require 'webrick'
-include WEBrick
-
-serverConfig = {
-  :Port => 80,
-  :Logger => WEBrick::Log.new($stderr, WEBrick::Log::ERROR),
-  :AccessLog => [[$stderr, WEBrick::AccessLog::COMBINED_LOG_FORMAT]]
-}
-server = WEBrick::HTTPServer.new(serverConfig)
-server.mount("/", HTTPServlet::FileHandler, "C:/workspace/Crypt/site/", {:FancyIndexing => true})
-server.mount("/crypt", HTTPServlet::FileHandler, "C:/workspace/Crypt/crypt/", {:FancyIndexing => true})
-
-server.start
-

data/test/test-blowfish.rb

@@ -1,90 +0,0 @@
-# test-blowfish.rb
-# updated 11-Feb-2014 for ruby 2.0
-
-require 'test/unit'
-require 'crypt/blowfish'
-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
-
-  def test_initialize
-    assert_raise(RuntimeError) {
-      b0 = Crypt::Blowfish.new("")
-    }
-    assert_nothing_raised() {
-      b1 = Crypt::Blowfish.new("1")
-    }
-    assert_nothing_raised() {
-      b56 = Crypt::Blowfish.new("1"*56)
-    }
-    assert_raise(RuntimeError) {
-      b57 = Crypt::Blowfish.new("1"*57)
-    }
-  end
-
-  def test_pair
-    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)
-    l, r = bf.decrypt_pair(l, r)
-    assert_equal(orig_l, l)
-    assert_equal(orig_r, r)
-  end
-
-  def test_block
-    bf = Crypt::Blowfish.new("Who is John Galt?")
-    block = "8 byte\u00cd"   # unicode string of 8 bytes
-    encryptedBlock = bf.encrypt_block(block)
-    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)
-    string = "This is a string which is not a multiple of 8 characters long"
-    encryptedString = bf.encrypt_string(string)
-    decryptedString = bf.decrypt_string(encryptedString)
-    assert_equal(string, decryptedString)
-    secondstring = "This is another string to check repetitive use."
-    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+')
-    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()
-    assert_equal(plainText, decryptText)
-    FileUtils.rm('plain.txt')
-    FileUtils.rm('crypt.txt')
-    FileUtils.rm('decrypt.txt')
-  end
-
-end

data/test/test-gost.rb

@@ -1,77 +0,0 @@
-# updated 11-Feb-2014 for ruby 2.0
-
-require 'test/unit'
-require 'crypt/gost'
-require 'fileutils'
-
-class TestGost < Test::Unit::TestCase
-
-	def setup
-	end
-
-	def teardown
-	end
-
-    def test_init
-	  assert_nothing_raised(RuntimeError) {
-        gost = Crypt::Gost.new("Whatever happened to Yuri Gagarin?")
-      }
-	  assert_nothing_raised(RuntimeError) {
-        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]
-    l, r = gost.encrypt_pair(orig_l, orig_r)
-    assert_equal(0xaefaf8f4, l)
-    assert_equal(0xe24891b0, r)
-    l, r = gost.decrypt_pair(l, r)
-    assert_equal(orig_l, l)
-    assert_equal(orig_r, r)
-  end
-
-  def test_block
-    gost = Crypt::Gost.new("Whatever happened to Yuri?")
-    block = "norandom"
-    encryptedBlock = gost.encrypt_block(block)
-    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)
-    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.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()
-    assert_equal(plainText, decryptText)
-    FileUtils.rm('plain.txt')
-    FileUtils.rm('crypt.txt')
-    FileUtils.rm('decrypt.txt')
-  end
-
-end

data/test/test-idea.rb

@@ -1,79 +0,0 @@
-# updated 11-Feb-2014 for ruby 2.0 - changed expected values representation
-
-require 'test/unit'
-require 'crypt/idea'
-require 'fileutils'
-
-class TestIdea < Test::Unit::TestCase
-
-	def setup
-	end
-
-	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)
-      }
-    end
-
-  def test_block_size
-    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]
-    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)
-    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 = "8 byte\u00cd"   # unicode string of 8 bytes
-    encryptedBlock = idea_en.encrypt_block(block)
-    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.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)
-    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)
-    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.encrypt_file('plain.txt', 'crypt.txt')
-    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()
-    decryptFile.close()
-    assert_equal(plainText, decryptText)
-    FileUtils.rm('plain.txt')
-    FileUtils.rm('crypt.txt')
-    FileUtils.rm('decrypt.txt')
-  end
-
-end

data/test/test-rijndael.rb

@@ -1,69 +0,0 @@
-# updated 11-Feb-2014 for ruby 2.0 - convert test strings into byte arrays, expected value representation
-
-require 'test/unit'
-require 'crypt/rijndael'
-require 'fileutils'
-
-class TestRijndael < Test::Unit::TestCase
-
-	def setup
-	end
-
-	def teardown
-	end
-
-  def test_init
-    assert_raise(RuntimeError) {
-        rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 64)
-      }
-    assert_raise(RuntimeError) {
-        rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 64)
-      }
-  end
-
-  def test_block_size
-    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 256)
-    assert_equal(32, rijndael.block_size)
-    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 256, 128)
-    assert_equal(16, rijndael.block_size)
-  end
-
-  def test_block
-    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)
-    assert_equal("\x8E\x88\x03\xB8> PnwR)\x93\x1A\xC9:\xC4".force_encoding("ASCII-8BIT"), encryptedBlock)
-    decryptedBlock = rijndael.decrypt_block(encryptedBlock)
-    assert_equal(block.force_encoding("ASCII-8BIT"), decryptedBlock)
-    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 256)
-    assert_raise(RuntimeError) {
-      encryptedBlock = rijndael.encrypt_block(block)
-    }
-  end
-
-  def test_string
-    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)
-    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()
-    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?")
-    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()
-    assert_equal(plainText, decryptText)
-    FileUtils.rm('plain.txt')
-    FileUtils.rm('crypt.txt')
-    FileUtils.rm('decrypt.txt')
-  end
-
-end