otherinbox-crypt19 1.2.1

data/lib/crypt/stringxor.rb

@@ -0,0 +1,23 @@
+module Crypt
+  module StringXor
+  
+    def ^(a_string)
+      a = self.unpack('C'*(self.length))
+      b = a_string.unpack('C'*(a_string.length))
+      if (b.length < a.length)
+        (a.length - b.length).times { b << 0 }
+      end
+      xor = ""
+      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/blowfish_test.rb

@@ -0,0 +1,84 @@
+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 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"
+    encrypted_block = bf.encrypt_block(block)
+    assert_equal("\236\353k\321&Q\"\220", encrypted_block)
+    decrypted_block = bf.decrypt_block(encrypted_block)
+    assert_equal(block, decrypted_block)
+  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"
+    encrypted_string = bf.encrypt_string(string)
+    decrypted_string = bf.decrypt_string(encrypted_string)
+    assert_equal(string, decrypted_string)
+    secondstring = "This is another string to check repetitive use."
+    encrypted_string = bf.encrypt_string(secondstring)
+    decrypted_string = bf.decrypt_string(encrypted_string)
+    assert_equal(secondstring, decrypted_string)
+    
+  end
+  
+  def test_file
+    plain_text = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
+    plain_file = File.new('plain.txt', 'wb+')
+    plain_file.puts(plain_text)
+    plain_file.close()
+    bf = Crypt::Blowfish.new("Who is John Galt?")
+    bf.encrypt_file('plain.txt', 'crypt.txt')
+    bf.decrypt_file('crypt.txt', 'decrypt.txt')
+    decrypt_file = File.new('decrypt.txt', 'rb')
+    decrypt_text = decrypt_file.readlines().join('').chomp()
+    decrypt_file.close()
+    assert_equal(plain_text, decrypt_text)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+  end
+
+end

data/test/gost_test.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'crypt/gost'
+require 'fileutils'
+
+class TestGost < Test::Unit::TestCase
+
+  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"
+    encrypted_block = gost.encrypt_block(block)
+    assert_equal(".Vy\377\005\e3`", encrypted_block)
+    decrypted_block = gost.decrypt_block(encrypted_block)
+    assert_equal(block, decrypted_block)
+  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"
+    encrypted_string = gost.encrypt_string(string)
+    decrypted_string = gost.decrypt_string(encrypted_string)
+    assert_equal(string, decrypted_string)
+  end
+  
+  def test_file
+    plain_text = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
+    plain_file = File.new('plain.txt', 'wb+')
+    plain_file.puts(plain_text)
+    plain_file.close()
+    gost = Crypt::Gost.new("Whatever happened to Yuri?") 
+    gost.encrypt_file('plain.txt', 'crypt.txt')
+    gost.decrypt_file('crypt.txt', 'decrypt.txt')
+    decrypt_file = File.new('decrypt.txt', 'rb')
+    decrypt_text = decrypt_file.readlines().join('').chomp()
+    decrypt_file.close()
+    assert_equal(plain_text, decrypt_text)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+  end
+
+end

data/test/idea_test.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'crypt/idea'
+require 'fileutils'
+
+class TestIdea < Test::Unit::TestCase
+
+  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"
+    encrypted_block = idea_en.encrypt_block(block)
+    assert_equal("\235\003\326u\001\330\361\t", encrypted_block)
+    idea_de = Crypt::IDEA.new("Who is John Galt", Crypt::IDEA::DECRYPT) 
+    decrypted_block = idea_de.decrypt_block(encrypted_block)
+    assert_equal(block, decrypted_block)
+  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"
+    encrypted_string = idea_en.encrypt_string(string)
+    idea_de = Crypt::IDEA.new(userkey, Crypt::IDEA::DECRYPT) 
+    decryptedString = idea_de.decrypt_string(encrypted_string)
+    assert_equal(string, decryptedString)
+  end
+  
+  def test_file
+    plain_text = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
+    plain_file = File.new('plain.txt', 'wb+')
+    plain_file.puts(plain_text)
+    plain_file.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')
+    decrypt_file = File.new('decrypt.txt', 'rb')
+    decrypt_text = decrypt_file.readlines().join('').chomp()
+    decrypt_file.close()
+    assert_equal(plain_text, decrypt_text)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+  end
+
+end

data/test/rc6_test.rb

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'crypt/rc6'
+require 'fileutils'
+
+class TestRC6 < Test::Unit::TestCase
+  
+  def test_block_size
+    assert_equal(16, Crypt::RC6.new([0]*32).block_size(), "Wrong block size")
+  end
+
+  def test_initialize
+    ["","1", "qwe"].each do |key|
+      assert_raise(RuntimeError) {
+        Crypt::RC6.new(key)
+      }
+    end
+    
+    ["1234567890123456","123456789012345678901234"].each do |key|
+      assert_nothing_raised() {
+        Crypt::RC6.new(key)
+      }
+    end
+  end
+
+  def test_vectors
+    vectors = [
+    [[ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+      [0x00000000, 0x00000000, 0x00000000, 0x00000000],
+      [0x36a5c38f, 0x78f7b156, 0x4edf29c1, 0x1ea44898] ],
+
+    [[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+        0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78],
+      [0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce],
+      [0x2f194e52, 0x23c61547, 0x36f6511f, 0x183fa47e]],
+
+    [[ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+      [0x00000000, 0x00000000, 0x00000000, 0x00000000],
+      [0xcb1bd66c, 0x38300b19, 0x163f8a4e, 0x82ae9086] ],
+
+    [[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+        0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
+        0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0],
+      [0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce],
+      [0xd0298368, 0x0405e519, 0x2ae9521e, 0xd49152f9]],
+
+    [[ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
+      [0x00000000, 0x00000000, 0x00000000, 0x00000000],
+      [0x05bd5f8f, 0xa85fd110, 0xda3ffa93, 0xc27e856e] ],
+
+    [[0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+        0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
+        0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0,
+        0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe],
+      [0x35241302, 0x79685746, 0xbdac9b8a, 0xf1e0dfce],
+      [0x161824c8, 0x89e4d7f0, 0xa116ad20, 0x485d4e67]],
+  ]
+
+    vectors.each_with_index do |vector, i|
+      rc6 = Crypt::RC6.new(vector[0])
+      assert_equal(rc6.encrypt_block(vector[1].pack('N*')), vector[2].pack('N*'))
+      assert_equal(rc6.decrypt_block(vector[2].pack('N*')), vector[1].pack('N*'))
+    end
+
+  end
+
+end

data/test/rijndael_test.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'crypt/rijndael'
+require 'fileutils'
+
+class TestRijndael < Test::Unit::TestCase
+
+  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"
+    encrypted_block = rijndael.encrypt_block(block)
+    assert_equal("\024\246^\332T\323x`\323yB\352\2159\212R", encrypted_block)
+    decrypted_block = rijndael.decrypt_block(encrypted_block)
+    assert_equal(block, decrypted_block)
+    rijndael = Crypt::Rijndael.new("Who is this John Galt guy, anyway?", 128, 256)
+    assert_raise(RuntimeError) {
+      encrypted_block = 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"
+    encrypted_string = rijndael.encrypt_string(string)
+    decrypted_string = rijndael.decrypt_string(encrypted_string)
+    assert_equal(string, decrypted_string)
+  end
+  
+  def test_file
+    plain_text = "This is a multi-line string\nwhich is not a multiple of 8 \ncharacters long."
+    plain_file = File.new('plain.txt', 'wb+')
+    plain_file.puts(plain_text)
+    plain_file.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')
+    decrypt_file = File.new('decrypt.txt', 'rb')
+    decrypt_text = decrypt_file.readlines().join('').chomp()
+    decrypt_file.close()
+    assert_equal(plain_text, decrypt_text)
+    FileUtils.rm('plain.txt')
+    FileUtils.rm('crypt.txt')
+    FileUtils.rm('decrypt.txt')
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: otherinbox-crypt19
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Rudenberg
+- Richard Kernahan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-18 00:00:00.000000000 Z
+dependencies: []
+description: Crypt is a pure-ruby implementation of a number of popular encryption
+  algorithms. Block cyphers currently include Blowfish, GOST, IDEA, Rijndael (AES),
+  and RC6. Cypher Block Chaining (CBC) has been implemented.
+email: jon335@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/crypt/blowfish-tables.rb
+- lib/crypt/blowfish.rb
+- lib/crypt/bytes-compat.rb
+- lib/crypt/cbc.rb
+- lib/crypt/gost.rb
+- lib/crypt/idea.rb
+- lib/crypt/noise.rb
+- lib/crypt/rc6.rb
+- lib/crypt/rijndael-tables.rb
+- lib/crypt/rijndael.rb
+- lib/crypt/stringxor.rb
+- test/blowfish_test.rb
+- test/gost_test.rb
+- test/idea_test.rb
+- test/rc6_test.rb
+- test/rijndael_test.rb
+homepage: http://gemcutter.org/gems/crypt19
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Crypt1.9 is a pure-ruby implementation of several encryption algorithms.
+test_files: []