twofish 1.0.0

data/test/test_twofish.rb

@@ -0,0 +1,290 @@
+
+require 'test/unit'
+require 'twofish'
+
+# Define some useful constants and test some basic properties.
+class TestBasics < Test::Unit::TestCase
+
+  NULL_KEY_16_BYTES = ("\0" * 16).freeze
+  NULL_KEY_24_BYTES = ("\0" * 24).freeze
+  NULL_KEY_32_BYTES = ("\0" * 32).freeze
+  NULL_BLOCK = ("\0" * Twofish::BLOCK_SIZE).freeze
+  BLOCK_SIZE = Twofish::BLOCK_SIZE
+
+  def test_16_byte_key_size
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    assert_equal(tf.key_size, 16)
+  end
+
+  def test_24_byte_key_size
+    tf = Twofish.new(NULL_KEY_24_BYTES)
+    assert_equal(tf.key_size, 24)
+  end
+
+  def test_32_byte_key_size
+    tf = Twofish.new(NULL_KEY_32_BYTES)
+    assert_equal(tf.key_size, 32)
+  end
+
+  def test_invalid_key_size
+    assert_raise ArgumentError do
+      Twofish.new('short key')
+    end
+  end
+
+  def test_block_size
+    assert(16, BLOCK_SIZE)
+  end
+
+  def test_default_mode
+    assert_equal(Mode::DEFAULT, Mode::ECB)
+  end
+
+end
+
+# Test the encryption vectors as given in the specification
+# using block encryption (Electronic Code Book mode).
+# On the way we check that each encrypted block successfully
+# decrypts to the given plaintext.
+class TestEcbEncryption < TestBasics
+
+  def test_16_byte_key_encryption
+    assert_equal(
+      pack_bytes('5d9d4eeffa9151575524f115815a12e0'),
+      repeated_block_encrypt(NULL_KEY_16_BYTES, NULL_BLOCK, 49)
+    )
+  end
+
+  def test_24_byte_key_encryption
+    assert_equal(
+      pack_bytes('e75449212beef9f4a390bd860a640941'),
+      repeated_block_encrypt(NULL_KEY_24_BYTES, NULL_BLOCK, 49)
+    )
+  end
+
+  def test_32_byte_key_encryption
+    assert_equal(
+      pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205'),
+      repeated_block_encrypt(NULL_KEY_32_BYTES, NULL_BLOCK, 49)
+    )
+  end
+
+  def test_padding_exception
+    plaintext = 'short' # < BLOCKSIZE == 16 bytes
+    key = pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205')
+    tf = Twofish.new(key)
+    assert_raise ArgumentError do
+      ciphertext = tf.encrypt(plaintext)
+    end
+  end
+
+  def test_null_in_plaintext
+    plaintext = "xxxxxxx\0\0yyyyyyy"
+    key = pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205')
+    tf = Twofish.new(key)
+    ciphertext = tf.encrypt(plaintext)
+    assert_equal(plaintext, tf.decrypt(ciphertext))
+  end
+
+  private
+
+  # Convert ASCII hex representation into binary.
+  def pack_bytes(byte_string)
+    [byte_string].pack('H*')
+  end
+
+  # Repeatedly encrypt the given plain text n times
+  # with the same key.
+  def repeated_block_encrypt(key, plain, iterations)
+    key_length = key.length
+    iterations.times do
+      tf = Twofish.new(key)
+      cipher = tf.encrypt(plain)
+      assert_equal(plain, tf.decrypt(cipher))
+      key = (plain + key)[0, key_length]
+      plain = cipher
+    end
+    plain
+  end
+
+end
+
+# Test the Cipher Block Chaining mode.
+class TestCbcEncryption < TestBasics
+
+  #                 123456781234567812345678123456781234567812
+ #LONG_PLAINTEXT = 'this message is longer than the block size'
+ #LONG_CIPHERTEXT = ['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'].pack('H*')
+ #KEY = ['5d9d4eeffa9151575524f115815a12e0'].pack('H*')
+ #IV = ['e75449212beef9f4a390bd860a640941'].pack('H*')
+  LONG_PLAINTEXT = ("\0"*32).freeze
+  LONG_CIPHERTEXT = ['9f589f5cf6122c32b6bfec2f2ae8c35ad491db16e7b1c39e86cb086b789f5419'].pack('H*').freeze
+
+  def test_encryption_decryption_random_iv
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    ciphertext = tf.encrypt(LONG_PLAINTEXT)
+    iv = tf.iv
+    tf2 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :iv => iv)
+    assert_equal(LONG_PLAINTEXT, tf2.decrypt(ciphertext))
+  end
+
+  def test_encryption_given_null_iv
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :iv => NULL_BLOCK)
+    ciphertext = tf.encrypt(LONG_PLAINTEXT)
+    assert_equal(LONG_PLAINTEXT.size, ciphertext.size)
+    assert_equal(LONG_CIPHERTEXT, ciphertext)
+  end
+
+  def test_decryption_given_null_iv
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :iv => NULL_BLOCK)
+    assert_equal(LONG_PLAINTEXT, tf.decrypt(LONG_CIPHERTEXT))
+  end
+
+  def test_encryption_decryption_incomplete_block
+    tf1 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :padding => :zero_byte)
+    plaintext = 'abcdefghijklmnopqrst'
+    ciphertext = tf1.encrypt(plaintext)
+    iv = tf1.iv
+    tf2 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :iv => iv, :padding => :zero_byte)
+    assert_equal(plaintext, tf2.decrypt(ciphertext))
+  end
+
+end
+
+class TestInitializationVector < TestBasics
+
+  def test_nil_iv_for_ecb_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :ecb)
+    assert_equal(nil, tf.iv)
+  end
+
+  def test_cannot_assign_iv_ecb_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :ecb)
+    assert_raise ArgumentError do
+      tf.iv = '1234567812345678'
+    end
+  end
+
+  def test_assign_bad_iv
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    assert_raise ArgumentError do
+      tf.iv = '1234'
+    end
+  end
+
+  def test_generated_length
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    assert_equal(BLOCK_SIZE, tf.iv.length)
+  end
+
+  def test_generated_not_srand
+    tf1 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    tf2 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    assert_not_equal(tf1.iv, tf2.iv)
+  end
+
+end
+
+# Test the available encryption modes.
+class TestModes < TestBasics
+
+  def test_default_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    assert_equal(:ecb, tf.mode)
+  end
+
+  def test_unknown_mode
+    assert_raise ArgumentError do
+      tf = Twofish.new(NULL_KEY_16_BYTES)
+      tf.mode = :unknown
+    end
+  end
+
+  def test_unknown_mode_constructor
+    assert_raise ArgumentError do
+      Twofish.new(NULL_KEY_16_BYTES, :mode => :unknown)
+    end
+  end
+
+  def test_cbc_mode_constructor_string
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => 'cbc')
+    assert_equal(:cbc, tf.mode)
+  end
+
+  def test_cbc_mode_constructor_symbol
+    tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
+    assert_equal(:cbc, tf.mode)
+  end
+
+  def test_ecb_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    tf.mode = :ecb
+    assert_equal(:ecb, tf.mode)
+  end
+
+  def test_cbc_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    tf.mode = :cbc
+    assert_equal(:cbc, tf.mode)
+  end
+
+  def test_symbolize_mode
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    tf.mode = 'ecb'
+    assert_equal(:ecb, tf.mode)
+  end
+
+end
+
+class TestPadding < TestBasics
+
+  TO_PAD = 'abcdef'.freeze
+
+  def test_cipher_zero_byte_padding
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    tf.padding = :zero_byte
+    assert_equal(:zero_byte, tf.padding)
+  end
+
+  def test_cipher_zero_byte_padding_constructor
+    tf = Twofish.new(NULL_KEY_16_BYTES, :padding => :zero_byte)
+    assert_equal(:zero_byte, tf.padding)
+  end
+
+  def test_cipher_unknown_padding
+    tf = Twofish.new(NULL_KEY_16_BYTES)
+    assert_raise ArgumentError do
+      tf.padding = :unknown
+    end
+  end
+
+  def test_cipher_unknown_padding_constructor
+    assert_raise ArgumentError do
+      Twofish.new(NULL_KEY_16_BYTES, :padding => :unknown)
+    end
+  end
+
+  def test_symbolize_padding
+    assert_equal(:zero_byte, Padding::validate('zero_byte'))
+  end
+
+  def test_pad_none
+    assert_raise ArgumentError do
+      Padding::pad(TO_PAD, BLOCK_SIZE, :none)
+    end
+  end
+
+  def test_unpad_none
+    assert_equal(TO_PAD+"\0"*10, Padding::unpad(TO_PAD+"\0"*10, BLOCK_SIZE, :none))
+  end
+
+  def test_pad_zero_byte
+    assert_equal(TO_PAD+"\0"*10, Padding::pad(TO_PAD, BLOCK_SIZE, :zero_byte))
+  end
+
+  def test_unpad_zero_byte
+    assert_equal(TO_PAD, Padding::unpad(TO_PAD+"\0"*10, BLOCK_SIZE, :zero_byte))
+  end
+
+end
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: twofish
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Martin Carpenter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-26 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Twofish symmetric cipher in pure Ruby with ECB and CBC cipher modes derived from an original Perl implementation by Guido Flohr
+email: mcarpenter@free.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- Rakefile
+- README.rdoc
+files: 
+- lib/twofish.rb
+- test/test_twofish.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://mcarpenter.org/projects/twofish
+licenses: 
+- BSD
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Twofish symmetric cipher in pure Ruby
+test_files: []
+