crypt 1.1.3 → 1.1.4

data/crypt/cbc.rb

@@ -36,7 +36,7 @@ module CBC
       cryptStream.write(encrypted)
       chain = encrypted
     end
-    
+   
     # write the final block
     # At most block_size()-1 bytes can be part of the message. 
     # That means the final byte can be used to store the number of meaningful
@@ -44,13 +44,13 @@ module CBC
     block = '' if block.nil?
     buffer = block.split('')
     remainingMessageBytes = buffer.length
+    # we use 7-bit characters to avoid possible strange behavior on the Mac
     remainingMessageBytes.upto(block_size()-2) { buffer << rand(128).chr }
     buffer << remainingMessageBytes.chr
     block = buffer.join('')
     block = block ^ chain
     encrypted = encrypt_block(block)
     cryptStream.write(encrypted)
-    chain = encrypted
   end
   
   
@@ -77,7 +77,7 @@ module CBC
       aFile = File.new(filename, mode)
     rescue
       puts "Sorry. There was a problem opening the file <#{filename}>."
-      aFile.close unless aFile.closed?
+      aFile.close() unless aFile.nil?
       raise
     end
     return(aFile)
@@ -85,8 +85,8 @@ module CBC
   
   
   def encrypt_file(plainFilename, cryptFilename)
-    plainFile = carefully_open_file(plainFilename, 'br')
-    cryptFile = carefully_open_file(cryptFilename, 'bw+')
+    plainFile = carefully_open_file(plainFilename, 'rb')
+    cryptFile = carefully_open_file(cryptFilename, 'wb+')
     encrypt_stream(plainFile, cryptFile)
     plainFile.close unless plainFile.closed?
     cryptFile.close unless cryptFile.closed?
@@ -94,8 +94,8 @@ module CBC
   
   
   def decrypt_file(cryptFilename, plainFilename)
-    cryptFile = carefully_open_file(cryptFilename, 'br')
-    plainFile = carefully_open_file(plainFilename, 'bw+')
+    cryptFile = carefully_open_file(cryptFilename, 'rb')
+    plainFile = carefully_open_file(plainFilename, 'wb+')
     decrypt_stream(cryptFile, plainFile)
     cryptFile.close unless cryptFile.closed?
     plainFile.close unless plainFile.closed?

data/crypt/idea.rb

@@ -53,7 +53,7 @@ class IDEA
     modulus = 0x10001
     x = x.to_i % USHORT
     return(x) if (x <= 1)
-    t1 = 0x10000 / x
+    t1 = USHORT / x
     y  = modulus % x
     if (y == 1)
       inv = (1 - t1) & 0xFFFF
@@ -76,7 +76,7 @@ class IDEA
   
   def generate_encryption_subkeys(key)
     encrypt_keys = []
-    encrypt_keys[0..7] = key
+    encrypt_keys[0..7] = key.dup
     8.upto(51) { |i|
       a = ((i + 1) % 8 > 0) ? (i-7)  : (i-15)
       b = ((i + 2) % 8 < 2) ? (i-14) : (i-6)

data/crypt/purerubystringio.rb

@@ -0,0 +1,378 @@
+# Thanks to Binky DaClown who wrote this pure-ruby implementation 
+# http://rubyforge.org/projects/prstringio/
+# Apparently CBC does not work well with the C-based stringio
+
+module Crypt
+class PureRubyStringIO
+
+	include Enumerable
+
+	SEEK_CUR = IO::SEEK_CUR
+	SEEK_END = IO::SEEK_END
+	SEEK_SET = IO::SEEK_SET
+
+	@@relayMethods = [:<<, :all?, :any?, :binmode, :close, :close_read, :close_write, :closed?, :closed_read?,
+	                  :closed_write?, :collect, :detect, :each, :each_byte, :each_line, :each_with_index,
+	                  :entries, :eof, :eof?, :fcntl, :fileno, :find, :find_all, :flush, :fsync, :getc, :gets,
+	                  :grep, :include?, :inject, :isatty, :length, :lineno, :lineno=, :map, :max, :member?,
+	                  :min, :partition, :path, :pid, :pos, :pos=, :print, :printf, :putc, :puts, :read,
+	                  :readchar, :readline, :readlines, :reject, :rewind, :seek, :select, :size, :sort,
+	                  :sort_by, :string, :string=, :sync, :sync=, :sysread, :syswrite, :tell, :truncate, :tty?,
+	                  :ungetc, :write, :zip]
+
+	def self.open(string="", mode="r+")
+		if block_given? then
+			sio = new(string, mode)
+			rc = yield(sio)
+			sio.close
+			rc
+		else
+			new(string, mode)
+		end
+	end
+
+	def <<(obj)
+		requireWritable
+		write obj
+		self
+	end
+
+	def binmode
+		self
+	end
+
+	def close
+		requireOpen
+		@sio_closed_read = true
+		@sio_closed_write = true
+		self
+	end
+
+	def close_read
+		raise IOError, "closing non-duplex IO for reading", caller if closed_read?
+		@sio_closed_read = true
+		self
+	end
+
+	def close_write
+		raise IOError, "closing non-duplex IO for writing", caller if closed_write?
+		@sio_closed_read = true
+		self
+	end
+
+	def closed?
+		closed_read? && closed_write?
+	end
+
+	def closed_read?
+		@sio_closed_read
+	end
+
+	def closed_write?
+		@sio_closed_write
+	end
+
+	def each(sep_string=$/, &block)
+		requireReadable
+		@sio_string.each(sep_string, &block)
+		@sio_pos = @sio_string.length
+	end
+
+	def each_byte(&block)
+		requireReadable
+		@sio_string.each_byte(&block)
+		@sio_pos = @sio_string.length
+	end
+
+	def eof
+		requireReadable { @sio_pos >= @sio_string.length }
+	end
+
+	def fcntl(integer_cmd, arg)
+		raise NotImplementedError, "The fcntl() function is unimplemented on this machine", caller
+	end
+
+	def fileno
+		nil
+	end
+
+	def flush
+		self
+	end
+
+	def fsync
+		0
+	end
+
+	def getc
+		requireReadable
+		char = @sio_string[@sio_pos]
+		@sio_pos +=  1 unless char.nil?
+		char
+	end
+
+	def gets(sep_string=$/)
+		requireReadable
+		@sio_lineno += 1
+		pstart = @sio_pos
+		@sio_pos = @sio_string.index(sep_string, @sio_pos) || [@sio_string.length, @sio_pos].max
+		@sio_string[pstart..@sio_pos]
+	end
+
+	def initialize(string="", mode="r+")
+		@sio_string = string.to_s
+		@sio_lineno = 0
+		@mode = mode
+		@relay = nil
+		case mode.delete("b")
+		when "r"
+			@sio_closed_read = false
+			@sio_closed_write = true
+			@sio_pos = 0
+		when "r+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = 0
+		when "w"
+			@sio_closed_read = true
+			@sio_closed_write = false
+			@sio_pos = 0
+			@sio_string.replace("")
+		when "w+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = 0
+			@sio_string.replace("")
+		when "a"
+			@sio_closed_read = true
+			@sio_closed_write = false
+			@sio_pos = @sio_string.length
+		when "a+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = @sio_string.length
+		else
+			raise ArgumentError, "illegal access mode #{mode}", caller
+		end
+	end
+
+	def isatty
+		flase
+	end
+
+	def length
+		@sio_string.length
+	end
+
+	def lineno
+		@sio_lineno
+	end
+
+	def lineno=(integer)
+		@sio_lineno = integer
+	end
+
+	def path
+		nil
+	end
+
+	def pid
+		nil
+	end
+
+	def pos
+		@sio_pos
+	end
+
+	def pos=(integer)
+		raise Errno::EINVAL, "Invalid argument", caller if integer < 0
+		@sio_pos = integer
+	end
+
+	def print(*args)
+		requireWritable
+		args.unshift($_) if args.empty
+		args.each { |obj| write(obj) }
+		write($\) unless $\.nil?
+		nil
+	end
+
+	def printf(format_string, *args)
+		requireWritable
+		write format(format_string, *args)
+		nil
+	end
+
+	def putc(obj)
+		requireWritable
+		write(obj.is_a?(Numeric) ? sprintf("%c", obj) : obj.to_s[0..0])
+		obj
+	end
+
+	def puts(*args)
+		requireWritable
+		args.unshift("") if args.empty?
+		args.each { |obj|
+			write obj
+			write $/
+		}
+		nil
+	end
+
+	def read(length=nil, buffer=nil)
+		requireReadable
+		len = length || [@sio_string.length - @sio_pos, 0].max
+		raise ArgumentError, "negative length #{len} given", caller if len < 0
+		buffer ||= ""
+		pstart = @sio_pos
+		@sio_pos += len
+		buffer.replace(@sio_string[pstart..@sio_pos])
+		buffer.empty? && !length.nil? ? nil : buffer
+	end
+
+	def readchar
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		getc
+	end
+
+	def readline
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		gets
+	end
+
+	def readlines(sep_string=$/)
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		rc = []
+		until eof
+			rc << gets(sep_string)
+		end
+		rc
+	end
+
+	def reopen(string, mode=nil)
+		if string.is_a?(self.class) then
+			raise ArgumentError, "wrong number of arguments (2 for 1)", caller if !mode.nil?
+			@relay = string
+			instance_eval(%Q{
+				class << self
+					@@relayMethods.each { |name|
+						define_method(name, ObjectSpace._id2ref(#{@relay.object_id}).method(("original_" + name.to_s).to_sym).to_proc)
+					}
+				end
+			})
+		else
+			raise ArgumentError, "wrong number of arguments (1 for 2)", caller if mode.nil?
+			class << self
+				@@relayMethods.each { |name|
+					alias_method(name, "original_#{name}".to_sym)
+					public name
+				}
+				@relay = nil
+			end unless @relay.nil?
+			@sio_string = string.to_s
+			@mode = mode
+		end
+	end
+
+	def rewind
+		@sio_pos = 0
+		@sio_lineno = 0
+	end
+
+	def seek(amount, whence=SEEK_SET)
+		if whence == SEEK_CUR then
+			offset += @sio_pos
+		elsif whence == SEEK_END then
+			offset += size
+		end
+		@sio_pos = offset
+	end
+
+	def string
+		@sio_string
+	end
+	
+	def string=(newstring)
+		@sio_string = newstring
+	end
+
+	def sync
+		true
+	end
+
+	def sync=(boolean)
+		boolean
+	end
+
+	def sysread(length=nil, buffer=nil)
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		read(length, buffer)
+	end
+
+	def syswrite(string)
+		requireWritable
+		addition = "\000" * (@sio_string.length - @sio_pos) + string.to_s
+		@sio_string[@sio_pos..(addition.length - 1)] = addition
+		@sio_pos +=  addition.size
+		addition.size
+	end
+
+	#In ruby 1.8.4 truncate differs from the docs in two ways.
+	#First, if an integer greater that the length is given then the string is expanded to the new integer
+	#length. As this expansion seems to contain junk characters instead of nulls I suspect this may be a
+	#flaw in the C code which could cause a core dump if abused/used.
+	#Second, the documentation states that  truncate returns 0. It returns the integer instead.
+	#This implementation follows the documentation in the first instance as I suspect this will be fixed
+	#in the C code. In the second instance, it follows the actions of the C code instead of the docs.
+	#This was decided as it causes no immedeate harm and this ruby implentation is to be as compatable
+	#as possible with the C version. Should the C version change to match the docs the ruby version
+	#will be simple to update as well. 
+	def truncate(integer)
+		requireWritable
+		raise Errno::EINVAL, "Invalid argument - negative length", caller if integer < 0
+		@sio_string[[integer, @sio_string.length].max..-1] = ""
+		integer
+	end
+
+	def ungetc(integer)
+		requireWritable
+		if @sio_pos > 0 then
+			@sio_pos -= 1
+			putc(integer)
+			@sio_pos -= 1
+		end
+	end
+
+	alias :each_line :each
+	alias :eof? :eof
+	alias :size :length
+	alias :tty? :isatty
+	alias :tell :pos
+	alias :write :syswrite
+
+	protected
+	@@relayMethods.each { |name|
+		alias_method("original_#{name}".to_sym, name)
+		protected "original_#{name}".to_sym
+	}
+
+	private
+
+	def requireReadable
+		raise IOError, "not opened for reading", caller[1..-1] if @sio_closed_read
+	end
+
+	def requireWritable
+		raise IOError, "not opened for writing", caller[1..-1] if @sio_closed_write
+	end
+
+	def requireOpen
+		raise IOError, "closed stream", caller[1..-1] if @sio_closed_read && @sio_closed_write
+	end
+
+end
+end

data/test/break-idea.rb

@@ -0,0 +1,61 @@
+# 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

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

@@ -0,0 +1,89 @@
+# testblowfish.rb  bryllig
+
+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 = "norandom"
+    encryptedBlock = bf.encrypt_block(block)
+    assert_equal("\236\353k\321&Q\"\220", 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

@@ -0,0 +1,75 @@
+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\377\005\e3`", 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

@@ -0,0 +1,76 @@
+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 = "norandom"
+    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) 
+    decryptedBlock = idea_de.decrypt_block(encryptedBlock)
+    assert_equal(block, decryptedBlock)
+  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

@@ -0,0 +1,67 @@
+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 = "\341q\214NIj\023u\343\330s\323\354$g\277"
+      encryptedBlock = rijndael.encrypt_block(block)
+      assert_equal("\024\246^\332T\323x`\323yB\352\2159\212R", encryptedBlock)
+      decryptedBlock = rijndael.decrypt_block(encryptedBlock)
+      assert_equal(block, 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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: crypt
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
-date: 2006-08-05
+  version: 1.1.4
+date: 2006-08-06
 summary: "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. Twofish,
@@ -36,9 +36,16 @@ files:
   - crypt/gost.rb
   - crypt/idea.rb
   - crypt/noise.rb
+  - crypt/purerubystringio.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
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []