twofish 1.0.2 → 1.0.3

data/lib/twofish/mode.rb

@@ -0,0 +1,33 @@
+class Twofish
+
+  # Encryption modes.
+  #
+  # The only currently implemented modes are ECB (Electronic Code Book)
+  # and CBC (Cipher Block Chaining).
+  module Mode
+
+    # Electronic code book mode.
+    ECB = :ecb
+
+    # Cipher block chaining mode.
+    CBC = :cbc
+
+    # Array of all known modes.
+    ALL = [ CBC, ECB ]
+
+    # Default mode (ECB).
+    DEFAULT = ECB
+
+    # Takes a string or symbol and returns the lowercased
+    # symbol representation if this is a recognized mode.
+    # Otherwise, throws ArgumentError.
+    def self.validate(mode)
+      mode_sym = mode.nil? ? DEFAULT : mode.to_s.downcase.to_sym
+      raise ArgumentError, "unknown cipher mode #{mode.inspect}" unless ALL.include? mode_sym
+      mode_sym
+    end
+
+  end
+
+end
+

data/lib/twofish/padding.rb

@@ -0,0 +1,75 @@
+class Twofish
+  
+  # Implements padding modes to make plaintext into a complete
+  # number of blocks before encryption and to remove that padding
+  # after successful decryption.
+  #
+  # The only implemented padding schemes are :none and
+  # :zero_byte. Note that zero byte padding is potentially
+  # dangerous because if the plaintext terminates in
+  # zero bytes then these will be erroneously removed by #unpad.
+  # A more sensible padding scheme should be used in this case.
+  module Padding
+
+    # Use no padding.
+    NONE = :none
+
+    # Use zero byte padding.
+    ZERO_BYTE = :zero_byte
+
+    # Array of all known paddings.
+    ALL = [ NONE, ZERO_BYTE ]
+
+    # Default padding (none).
+    DEFAULT = NONE
+
+    # Takes a string or symbol and returns the lowercased
+    # symbol representation if this is a recognized padding scheme.
+    # Otherwise, throws ArgumentError.
+    def self.validate(scheme)
+      scheme_sym = scheme.nil? ? DEFAULT : scheme.to_s.downcase.to_sym
+      raise ArgumentError, "unknown padding scheme #{scheme.inspect}" unless ALL.include? scheme_sym
+      scheme_sym
+    end
+
+    # Pad the given plaintext to a complete number of blocks,
+    # returning a new string. See #pad!.
+    def self.pad(plaintext, block_size, scheme=DEFAULT)
+      self.pad!(plaintext.dup, block_size, scheme)
+    end
+
+    # Pad the given plaintext to a complete number of blocks,
+    # returning a new string. If the padding scheme is :none
+    # and the plaintext is not a whole number of blocks then
+    # ArgumentError is thrown.
+    def self.pad!(plaintext, block_size, scheme=DEFAULT)
+      remainder = plaintext.length % block_size
+      case validate(scheme)
+      when NONE
+        raise ArgumentError, "no padding scheme specified and plaintext length is not a multiple of the block size" unless remainder.zero?
+        plaintext
+      when ZERO_BYTE
+        remainder.zero? ? plaintext : plaintext << "\0" * (block_size - remainder)
+      end
+    end
+
+    # Unpad the given plaintext using the given scheme, returning
+    # a new string. See #unpad!.
+    def self.unpad(plaintext, block_size, scheme=DEFAULT)
+      self.unpad!(plaintext.dup, block_size, scheme)
+    end
+
+    # Unpad the given plaintext in place using the given scheme.
+    def self.unpad!(plaintext, block_size, scheme=DEFAULT)
+      case validate(scheme)
+      when NONE
+        plaintext.dup
+      when ZERO_BYTE
+        plaintext.sub(/\000+\Z/, '')
+      end
+    end
+
+  end
+
+end
+

data/test/benchmark.rb

@@ -0,0 +1,17 @@
+
+require 'benchmark'
+
+require 'twofish'
+
+m = 10000
+n = 100000
+key = ['5d9d4eeffa9151575524f115815a12e0'].pack('H*')
+block = ['e75449212beef9f4a390bd860a640941'].pack('H*')
+tf = Twofish.new(key)
+
+Benchmark.bm(7) do |x|
+  x.report('new') { m.times do ; Twofish.new(key) ; end }
+  x.report('encrypt') { n.times do ; tf.encrypt(block) ; end }
+  x.report('decrypt') { n.times do ; tf.decrypt(block) ; end }
+end
+

data/test/test_twofish.rb

@@ -37,7 +37,7 @@ class TestBasics < Test::Unit::TestCase
   end
 
   def test_default_mode
-    assert_equal(Mode::DEFAULT, Mode::ECB)
+    assert_equal(Twofish::Mode::DEFAULT, Twofish::Mode::ECB)
   end
 
 end
@@ -74,7 +74,7 @@ class TestEcbEncryption < TestBasics
     key = pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205')
     tf = Twofish.new(key)
     assert_raise ArgumentError do
-      ciphertext = tf.encrypt(plaintext)
+      tf.encrypt(plaintext)
     end
   end
 
@@ -86,6 +86,29 @@ class TestEcbEncryption < TestBasics
     assert_equal(plaintext, tf.decrypt(ciphertext))
   end
 
+  def test_utf8_plaintext_invalid_length
+    # this string is 16 chars in length, but 18 bytes
+    plaintext = pack_bytes('72c3a973657276c3a96573') + # 11 bytes, 9 chars
+      '1234567' # 7 bytes, 7 chars
+    plaintext.force_encoding('UTF-8')
+    key = pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205')
+    tf = Twofish.new(key)
+    assert_raise ArgumentError do
+      tf.encrypt(plaintext)
+    end
+  end
+
+  def test_utf8_plaintext
+    # this string is 16 bytes in length (but 14 chars)
+    plaintext = pack_bytes('72c3a973657276c3a96573') + # 11 bytes, 9 chars
+      '12345' # 5 bytes, 5 chars
+    plaintext.force_encoding('UTF-8')
+    key = pack_bytes('37fe26ff1cf66175f5ddf4c33b97a205')
+    tf = Twofish.new(key)
+    ciphertext = tf.encrypt(plaintext)
+    assert_equal(plaintext.force_encoding('ASCII-8BIT'), tf.decrypt(ciphertext))
+  end
+
   private
 
   # Convert ASCII hex representation into binary.
@@ -122,10 +145,13 @@ class TestCbcEncryption < TestBasics
 
   def test_encryption_decryption_random_iv
     tf = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc)
-    ciphertext = tf.encrypt(LONG_PLAINTEXT)
+    plaintext = LONG_PLAINTEXT
+    ciphertext = tf.encrypt(plaintext)
+    assert_equal(LONG_PLAINTEXT, plaintext)
     iv = tf.iv
     tf2 = Twofish.new(NULL_KEY_16_BYTES, :mode => :cbc, :iv => iv)
     assert_equal(LONG_PLAINTEXT, tf2.decrypt(ciphertext))
+    assert_equal(LONG_PLAINTEXT, plaintext)
   end
 
   def test_encryption_given_null_iv
@@ -265,29 +291,29 @@ class TestPadding < TestBasics
   end
 
   def test_symbolize_padding
-    assert_equal(:zero_byte, Padding::validate('zero_byte'))
+    assert_equal(:zero_byte, Twofish::Padding::validate('zero_byte'))
   end
 
   def test_pad_none
     assert_raise ArgumentError do
-      Padding::pad(TO_PAD, BLOCK_SIZE, :none)
+      Twofish::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))
+    assert_equal(TO_PAD+"\0"*10, Twofish::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))
+    assert_equal(TO_PAD+"\0"*10, Twofish::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))
+    assert_equal(TO_PAD, Twofish::Padding::unpad(TO_PAD+"\0"*10, BLOCK_SIZE, :zero_byte))
   end
 
   def test_pad_block_size_zero_byte
     to_pad = TO_PAD * BLOCK_SIZE
-    assert_equal(to_pad, Padding::pad(to_pad, BLOCK_SIZE, :zero_byte))
+    assert_equal(to_pad, Twofish::Padding::pad(to_pad, BLOCK_SIZE, :zero_byte))
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twofish
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-21 00:00:00.000000000Z
+date: 2012-03-08 00:00:00.000000000 Z
 dependencies: []
 description: Twofish symmetric cipher in pure Ruby with ECB and CBC cipher modes derived
   from an original Perl implementation by Guido Flohr
@@ -22,6 +22,10 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - lib/twofish.rb
+- lib/twofish/mode.rb
+- lib/twofish/padding.rb
+- lib/string.rb
+- test/benchmark.rb
 - test/test_twofish.rb
 - LICENSE
 - Rakefile