ruby-des 1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.swp

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Robert Sosinski (http://www.robertsosinski.com)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,53 @@
+RubyDES
+=======
+
+RubyDES is a full Ruby implementation of the Data Encryption Standard.  The purpose of this 
+project was to allow Ruby programmers interested in cryptography a glimpse of how a robust 
+cryptographic algorithm functions in a language they understand.
+
+The best way to understand the RubyDES source code is by following along with a FIPS 46, 
+which you can find at http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf
+
+NOTE: DES is deprecated, and as such, you should not use this implementation in any project you 
+are developing.  I highly recommend the AES, TwoFish or Serpent algorithms through the OpenSSL 
+library instead.
+
+Running RubyDES
+===============
+
+Using RubyDES is pretty easy.  First, construct a new data and key block.
+
+    data = RubyDES::Block.new('mysecret')
+    key  = RubyDES::Block.new('hushhush')
+
+Then, build a new `RubyDES::Ctx` object and supply the data and key block.
+
+    des = RubyDES::Ctx.new(data, key)
+
+Finally, let it go.
+
+    encrypted_data = des.encrypt
+
+You will then be returned a DES encrypted block that is completely secure against eavesdropping 
+(if it were still 1997).
+
+To decrypt an encrypted data block, just build a new `RubyDES::Ctx` object in similar 
+fashion as before.
+
+    un_des = RubyDES::Ctx.new(encrypted_data, key)
+
+And run the DES with the key schedule reversed.
+
+    decrypted_data = un_des.decrypt
+
+You can then check to see if it all worked.
+
+    data.bit_array.eql?(decrypted_data.bit_array)
+
+Enjoy!
+
+Feedback
+========
+
+If you have any questions, comments or just want to talk shop about crypto, feel free to reach me 
+through my website at http://www.robertsosinski.com.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => ["test"]

data/lib/ruby-des.rb

@@ -0,0 +1,91 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'ruby-des/feistel'
+require 'ruby-des/key_schedule'
+require 'ruby-des/xor'
+
+module RubyDES
+  IP_L = [0x3a, 0x32, 0x2a, 0x22, 0x1a, 0x12, 0x0a, 0x02,
+          0x3c, 0x34, 0x2c, 0x24, 0x1c, 0x14, 0x0c, 0x04,
+          0x3e, 0x36, 0x2e, 0x26, 0x1e, 0x16, 0x0e, 0x06,
+          0x40, 0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08]
+  
+  IP_R = [0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01,
+          0x3b, 0x33, 0x2b, 0x23, 0x1b, 0x13, 0x0b, 0x03,
+          0x3d, 0x35, 0x2d, 0x25, 0x1d, 0x15, 0x0d, 0x05,
+          0x3f, 0x37, 0x2f, 0x27, 0x1f, 0x17, 0x0f, 0x07]
+  
+  FP = [0x28, 0x08, 0x30, 0x10, 0x38, 0x18, 0x40, 0x20,
+        0x27, 0x07, 0x2f, 0x0f, 0x37, 0x17, 0x3f, 0x1f,
+        0x26, 0x06, 0x2e, 0x0e, 0x36, 0x16, 0x3e, 0x1e,
+        0x25, 0x05, 0x2d, 0x0d, 0x35, 0x15, 0x3d, 0x1d,
+        0x24, 0x04, 0x2c, 0x0c, 0x34, 0x14, 0x3c, 0x1c,
+        0x23, 0x03, 0x2b, 0x0b, 0x33, 0x13, 0x3b, 0x1b,
+        0x22, 0x02, 0x2a, 0x0a, 0x32, 0x12, 0x3a, 0x1a,
+        0x21, 0x01, 0x29, 0x09, 0x31, 0x11, 0x39, 0x19]
+  
+  class Ctx
+    attr_reader :data, :key
+    
+    def initialize(data, key)
+      unless data.is_a?(RubyDES::Block) and key.is_a?(RubyDES::Block)
+        raise "RubyDES::InvalidBlockFormat: Data and key must be a Block object."
+      end
+      
+      @data = data
+      @key  = key
+    end
+    
+    def encrypt
+      self.run(:encrypt)
+    end
+    
+    def decrypt
+      self.run(:decrypt)
+    end
+    
+    protected
+    
+    def run(operation)
+      l = [] # l[0] is the IP_1_L permutation of the data block, l[1..16] are the results of each round of encryption.
+      r = [] # r[0] is the IP_1_R permutation of the data block, r[1..16] are the results of each round of encryption.
+      
+      l << IP_L.collect{|p| data.bit_array[p - 1]}
+      r << IP_R.collect{|p| data.bit_array[p - 1]}
+      
+      case operation
+      when :encrypt
+        k = KeySchedule.new(key.bit_array).sub_keys
+      when :decrypt
+        k = KeySchedule.new(key.bit_array).sub_keys.reverse
+      end
+      
+      16.times do |i|
+        l << r[i]
+        r << XOR.run(Feistel.run(r[i], k[i]), l[i])
+      end
+      
+      return RubyDES::Block.new(FP.collect{|p| (r.last + l.last)[p - 1]})
+    end
+  end
+  
+  class Block
+    attr_reader :string, :bit_array
+    
+    def initialize(input)
+      if input.is_a?(String)
+        raise "RubyDES::InvalidStringLength: Input String must contain (8) characters." unless input.length.eql?(8)
+        
+        @string    = input
+        @bit_array = input.unpack('B*').join.split('').collect{|b| b.to_i}
+      elsif input.is_a?(Array)
+        raise "RubyDES::InvalidArraySize: Input Array must contain (64) bits." unless input.size.eql?(64)
+        
+        @string    = input.join.to_a.pack('B*')
+        @bit_array = input
+      else
+        raise "RubyDES::InvalidFormat: Input must be a String or an Array."
+      end
+    end
+  end
+end

data/lib/ruby-des/feistel.rb

@@ -0,0 +1,89 @@
+module Feistel
+  E = [0x20, 0x01, 0x02, 0x03, 0x04, 0x05,
+       0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+       0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+       0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
+       0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+       0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+       0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+       0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x01]
+
+  P = [0x10, 0x07, 0x14, 0x15,
+       0x1d, 0x0c, 0x1c, 0x11,
+       0x01, 0x0f, 0x17, 0x1a,
+       0x05, 0x12, 0x1f, 0x0a,
+       0x02, 0x08, 0x18, 0x0e,
+       0x20, 0x1b, 0x03, 0x09,
+       0x13, 0x0d, 0x1e, 0x06,
+       0x16, 0x0b, 0x04, 0x19]
+  
+  S1 = [0x0e, 0x04, 0x0d, 0x01, 0x02, 0x0f, 0x0b, 0x08, 0x03, 0x0a, 0x06, 0x0c, 0x05, 0x09, 0x00, 0x07,
+        0x00, 0x0f, 0x07, 0x04, 0x0e, 0x02, 0x0d, 0x01, 0x0a, 0x06, 0x0c, 0x0b, 0x09, 0x05, 0x03, 0x08,
+        0x04, 0x01, 0x0e, 0x08, 0x0d, 0x06, 0x02, 0x0b, 0x0f, 0x0c, 0x09, 0x07, 0x03, 0x0a, 0x05, 0x00,
+        0x0f, 0x0c, 0x08, 0x02, 0x04, 0x09, 0x01, 0x07, 0x05, 0x0b, 0x03, 0x0e, 0x0a, 0x00, 0x06, 0x0d]
+  
+  S2 = [0x0f, 0x01, 0x08, 0x0e, 0x06, 0x0b, 0x03, 0x04, 0x09, 0x07, 0x02, 0x0d, 0x0c, 0x00, 0x05, 0x0a,
+        0x03, 0x0d, 0x04, 0x07, 0x0f, 0x02, 0x08, 0x0e, 0x0c, 0x00, 0x01, 0x0a, 0x06, 0x09, 0x0b, 0x05,
+        0x00, 0x0e, 0x07, 0x0b, 0x0a, 0x04, 0x0d, 0x01, 0x05, 0x08, 0x0c, 0x06, 0x09, 0x03, 0x02, 0x0f,
+        0x0d, 0x08, 0x0a, 0x01, 0x03, 0x0f, 0x04, 0x02, 0x0b, 0x06, 0x07, 0x0c, 0x00, 0x05, 0x0e, 0x09]
+  
+  S3 = [0x0a, 0x00, 0x09, 0x0e, 0x06, 0x03, 0x0f, 0x05, 0x01, 0x0d, 0x0c, 0x07, 0x0b, 0x04, 0x02, 0x08,
+        0x0d, 0x07, 0x00, 0x09, 0x03, 0x04, 0x06, 0x0a, 0x02, 0x08, 0x05, 0x0e, 0x0c, 0x0b, 0x0f, 0x01,
+        0x0d, 0x06, 0x04, 0x09, 0x08, 0x0f, 0x03, 0x00, 0x0b, 0x01, 0x02, 0x0c, 0x05, 0x0a, 0x0e, 0x07,
+        0x01, 0x0a, 0x0d, 0x00, 0x06, 0x09, 0x08, 0x07, 0x04, 0x0f, 0x0e, 0x03, 0x0b, 0x05, 0x02, 0x0c]
+  
+  S4 = [0x07, 0x0d, 0x0e, 0x03, 0x00, 0x06, 0x09, 0x0a, 0x01, 0x02, 0x08, 0x05, 0x0b, 0x0c, 0x04, 0x0f,
+        0x0d, 0x08, 0x0b, 0x05, 0x06, 0x0f, 0x00, 0x03, 0x04, 0x07, 0x02, 0x0c, 0x01, 0x0a, 0x0e, 0x09,
+        0x0a, 0x06, 0x09, 0x00, 0x0c, 0x0b, 0x07, 0x0d, 0x0f, 0x01, 0x03, 0x0e, 0x05, 0x02, 0x08, 0x04,
+        0x03, 0x0f, 0x00, 0x06, 0x0a, 0x01, 0x0d, 0x08, 0x09, 0x04, 0x05, 0x0b, 0x0c, 0x07, 0x02, 0x0e]
+  
+  S5 = [0x02, 0x0c, 0x04, 0x01, 0x07, 0x0a, 0x0b, 0x06, 0x08, 0x05, 0x03, 0x0f, 0x0d, 0x00, 0x0e, 0x09,
+        0x0e, 0x0b, 0x02, 0x0c, 0x04, 0x07, 0x0d, 0x01, 0x05, 0x00, 0x0f, 0x0a, 0x03, 0x09, 0x08, 0x06,
+        0x04, 0x02, 0x01, 0x0b, 0x0a, 0x0d, 0x07, 0x08, 0x0f, 0x09, 0x0c, 0x05, 0x06, 0x03, 0x00, 0x0e,
+        0x0b, 0x08, 0x0c, 0x07, 0x01, 0x0e, 0x02, 0x0d, 0x06, 0x0f, 0x00, 0x09, 0x0a, 0x04, 0x05, 0x03]
+  
+  S6 = [0x0c, 0x01, 0x0a, 0x0f, 0x09, 0x02, 0x06, 0x08, 0x00, 0x0d, 0x03, 0x04, 0x0e, 0x07, 0x05, 0x0b,
+        0x0a, 0x0f, 0x04, 0x02, 0x07, 0x0c, 0x09, 0x05, 0x06, 0x01, 0x0d, 0x0e, 0x00, 0x0b, 0x03, 0x08,
+        0x09, 0x0e, 0x0f, 0x05, 0x02, 0x08, 0x0c, 0x03, 0x07, 0x00, 0x04, 0x0a, 0x01, 0x0d, 0x0b, 0x06,
+        0x04, 0x03, 0x02, 0x0c, 0x09, 0x05, 0x0f, 0x0a, 0x0b, 0x0e, 0x01, 0x07, 0x06, 0x00, 0x08, 0x0d]
+  
+  S7 = [0x04, 0x0b, 0x02, 0x0e, 0x0f, 0x00, 0x08, 0x0d, 0x03, 0x0c, 0x09, 0x07, 0x05, 0x0a, 0x06, 0x01,
+        0x0d, 0x00, 0x0b, 0x07, 0x04, 0x09, 0x01, 0x0a, 0x0e, 0x03, 0x05, 0x0c, 0x02, 0x0f, 0x08, 0x06,
+        0x01, 0x04, 0x0b, 0x0d, 0x0c, 0x03, 0x07, 0x0e, 0x0a, 0x0f, 0x06, 0x08, 0x00, 0x05, 0x09, 0x02,
+        0x06, 0x0b, 0x0d, 0x08, 0x01, 0x04, 0x0a, 0x07, 0x09, 0x05, 0x00, 0x0f, 0x0e, 0x02, 0x03, 0x0c]
+  
+  S8 = [0x0d, 0x02, 0x08, 0x04, 0x06, 0x0f, 0x0b, 0x01, 0x0a, 0x09, 0x03, 0x0e, 0x05, 0x00, 0x0c, 0x07,
+        0x01, 0x0f, 0x0d, 0x08, 0x0a, 0x03, 0x07, 0x04, 0x0c, 0x05, 0x06, 0x0b, 0x00, 0x0e, 0x09, 0x02,
+        0x07, 0x0b, 0x04, 0x01, 0x09, 0x0c, 0x0e, 0x02, 0x00, 0x06, 0x0a, 0x0d, 0x0f, 0x03, 0x05, 0x08,
+        0x02, 0x01, 0x0e, 0x07, 0x04, 0x0a, 0x08, 0x0d, 0x0f, 0x0c, 0x09, 0x00, 0x03, 0x05, 0x06, 0x0b]
+  
+  S = [S1, S2, S3, S4, S5, S6, S7, S8]
+  
+  def self.run(r, k)    
+    b = [] # b[0..7] is e_xor_k prepped as 8 6-bit arrays for s-box substitution.
+    m = [] # m[0..7] is the row of the value when performing a s-box lookup.
+    n = [] # n[0..7] is the column of the value when performing a s-box lookup.
+    
+    e = E.collect{|p| r[p - 1]} # Expand r (right half data block) using E.
+    
+    e_xor_k = XOR.run(e, k) # X-or e (expanded r) with k (the sub key).
+    
+    # Break e_xor_k into 8 6-bit arrays and find both m (s-box row) and n (s-box column) for the s-box lookup.
+    8.times do |i|
+      b << []
+        6.times do 
+        b[i] << e_xor_k.shift
+      end
+      
+      m << [b[i].first, b[i].last].join.to_i(2) * 16 # [1, 0, 1, 0, 1, 0] => [1, 0] => 2 => 32 => 3rd row.
+      n << b[i][1..4].join.to_i(2) # [1, 0, 1, 0, 1, 0] => [0, 1, 0, 1] => 5 => 6th column.
+    end
+    
+    # Substitute every 6-bit array with the 4-bit array specified by the appropriate s-box.
+    8.times do |i|
+        b[i] = S[i][m[i] + n[i]].to_s(2).rjust(4, '0').split('').collect{|bit| bit.to_i}
+    end
+        
+    return P.collect{|p| b.flatten[p - 1]}
+  end
+end

data/lib/ruby-des/key_schedule.rb

@@ -0,0 +1,51 @@
+class KeySchedule
+  attr_accessor :sub_keys
+  attr_reader :key
+  
+  PC_1_L = [0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09,
+            0x01, 0x3a, 0x32, 0x2a, 0x22, 0x1a, 0x12,
+            0x0a, 0x02, 0x3b, 0x33, 0x2b, 0x23, 0x1b,
+            0x13, 0x0b, 0x03, 0x3c, 0x34, 0x2c, 0x24]
+  
+  PC_1_R = [0x3f, 0x37, 0x2f, 0x27, 0x1f, 0x17, 0x0f,
+            0x07, 0x3e, 0x36, 0x2e, 0x26, 0x1e, 0x16,
+            0x0e, 0x06, 0x3d, 0x35, 0x2d, 0x25, 0x1d,
+            0x15, 0x0d, 0x05, 0x1c, 0x14, 0x0c, 0x04]
+  
+  PC_2 = [0x0e, 0x11, 0x0b, 0x18, 0x01, 0x05,
+          0x03, 0x1c, 0x0f, 0x06, 0x15, 0x0a,
+          0x17, 0x13, 0x0c, 0x04, 0x1a, 0x08,
+          0x10, 0x07, 0x1b, 0x14, 0x0d, 0x02,
+          0x29, 0x34, 0x1f, 0x25, 0x2f, 0x37,
+          0x1e, 0x28, 0x33, 0x2d, 0x21, 0x30,
+          0x2c, 0x31, 0x27, 0x38, 0x22, 0x35,
+          0x2e, 0x2a, 0x32, 0x24, 0x1d, 0x20]
+
+  ROTATIONS = [1, 1, 2, 2, 2, 2, 2, 2,
+                  1, 2, 2, 2, 2, 2, 2, 1]
+  
+  def initialize(key)
+    @key = key
+    
+    c = [] # c[0] is the PC_1_L permutation of the key, c[1..16] are the results of each left shift.
+    d = [] # d[0] is the PC_1_R permutation of the key, d[1..16] are the results of each left shift.
+    k = [] # k[0..15] are the sub keys created by combining c[i] and d[i] and permuting with PC_2.
+    
+    c << PC_1_L.collect{|p| key[p - 1]}
+    d << PC_1_R.collect{|p| key[p - 1]}
+    
+    16.times do |i|
+      c << c[i]
+      d << d[i]
+      
+      ROTATIONS[i].times do
+        c[i + 1] << c[i + 1].shift
+        d[i + 1] << d[i + 1].shift
+      end
+      
+      k << PC_2.collect{|p| (c[i + 1] + d[i + 1])[p - 1]}
+    end
+    
+    @sub_keys = k
+  end
+end

data/lib/ruby-des/xor.rb

@@ -0,0 +1,11 @@
+module XOR
+  def self.run(x, y)
+    output = []
+    
+    x.size.times do |i|
+      output << (x[i] ^ y[i])
+    end
+    
+    return output
+  end
+end

data/test/ctx.yml

@@ -0,0 +1,17 @@
+decrypted_bit_array: [0, 1, 1, 1, 0, 0, 1, 1,
+                      0, 1, 1, 0, 0, 1, 0, 1,
+                      0, 1, 1, 0, 0, 0, 1, 1,
+                      0, 1, 1, 1, 0, 1, 0, 1,
+                      0, 1, 1, 1, 0, 0, 1, 0,
+                      0, 1, 1, 0, 1, 0, 0, 1,
+                      0, 1, 1, 1, 0, 1, 0, 0,
+                      0, 1, 1, 1, 1, 0, 0, 1]
+
+encrypted_bit_array: [0, 0, 0, 0, 1, 0, 1, 0,
+                      1, 1, 0, 1, 1, 1, 1, 0,
+                      0, 1, 0, 1, 0, 0, 1, 0,
+                      1, 0, 1, 0, 0, 1, 0, 0,
+                      0, 1, 1, 1, 0, 0, 1, 0,
+                      0, 0, 0, 0, 0, 1, 0, 1,
+                      0, 0, 0, 0, 0, 0, 1, 0,
+                      0, 1, 0, 1, 0, 0, 0, 1]

data/test/ctx_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class CtxTest < Test::Unit::TestCase
+  fixtures :ctx
+  
+  def setup
+    @data = RubyDES::Block.new('security')
+    @key  = RubyDES::Block.new('ruby-des')
+  end
+  
+  def test_run
+    encrypted_data = RubyDES::Ctx.new(@data, @key).encrypt
+    
+    assert_equal ctx(:encrypted_bit_array), encrypted_data.bit_array
+    
+    decrypted_data = RubyDES::Ctx.new(encrypted_data, @key).decrypt
+    
+    assert_equal ctx(:decrypted_bit_array), decrypted_data.bit_array
+  end
+end

data/test/feistel.yml

@@ -0,0 +1,18 @@
+half_block: [0, 0, 0, 0, 0, 0, 0, 0,
+             1, 1, 1, 1, 1, 1, 1, 1,
+             1, 0, 1, 0, 0, 0, 0, 0,
+             0, 0, 0, 1, 0, 1, 0, 1]
+
+sub_key: [1, 0, 1, 0, 1, 1,
+          0, 1, 1, 1, 0, 1,
+          1, 0, 1, 1, 0, 1,
+          1, 1, 1, 1, 1, 1,
+          1, 1, 1, 0, 1, 0,
+          0, 0, 0, 1, 0, 0,
+          0, 0, 0, 1, 1, 0,
+          1, 0, 1, 1, 1, 1]
+
+output: [1, 0, 0, 1, 1, 1, 0, 0,
+         0, 1, 1, 0, 0, 1, 0, 0,
+         0, 1, 0, 1, 1, 1, 1, 0,
+         1, 0, 1, 1, 0, 0, 0, 0]

data/test/feistel_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class FeistelTest < Test::Unit::TestCase
+  fixtures :feistel
+  
+  def test_run
+    assert_equal feistel(:output), Feistel.run(feistel(:half_block), feistel(:sub_key))
+  end
+end

data/test/key_schedule.yml

@@ -0,0 +1,152 @@
+test_key: [1, 1, 1, 0, 0, 1, 0, 1,
+           1, 1, 1, 0, 1, 0, 1, 0,
+           1, 1, 0, 0, 0, 1, 0, 0,
+           1, 1, 1, 1, 0, 0, 1, 0,
+           0, 1, 0, 1, 1, 0, 1, 1,
+           1, 1, 0, 0, 1, 0, 0, 0,
+           1, 1, 0, 0, 1, 0, 1, 1,
+           1, 1, 1, 0, 0, 1, 1, 0]
+
+sub_key_1: [1, 0, 1, 0, 1, 1,
+            0, 1, 1, 1, 0, 1,
+            1, 0, 1, 1, 0, 1,
+            1, 1, 1, 1, 1, 1,
+            1, 1, 1, 0, 1, 0,
+            0, 0, 0, 1, 0, 0,
+            0, 0, 0, 1, 1, 0,
+            1, 0, 1, 1, 1, 1]
+
+sub_key_2: [1, 0, 1, 0, 1, 1,
+            1, 1, 1, 1, 1, 1,
+            0, 1, 1, 1, 1, 1,
+            0, 1, 1, 0, 1, 0,
+            0, 0, 1, 0, 0, 1,
+            1, 1, 1, 1, 1, 0,
+            1, 1, 0, 1, 0, 0,
+            1, 1, 0, 0, 0, 0]
+
+sub_key_3: [0, 1, 1, 1, 1, 1,
+            1, 0, 0, 1, 0, 1,
+            0, 1, 1, 1, 1, 1,
+            0, 1, 1, 1, 1, 1,
+            0, 0, 1, 0, 1, 0,
+            0, 1, 0, 0, 1, 0,
+            1, 1, 0, 1, 0, 1,
+            0, 1, 0, 0, 1, 0]
+
+sub_key_4: [0, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 0, 1,
+            1, 0, 0, 1, 0, 1,
+            0, 1, 1, 0, 0, 1,
+            1, 1, 1, 0, 1, 1,
+            0, 1, 1, 1, 0, 0,
+            0, 0, 0, 0, 0, 0,
+            0, 1, 0, 1, 1, 0]
+
+sub_key_5: [0, 0, 0, 0, 1, 1,
+            1, 1, 1, 1, 1, 0,
+            1, 0, 0, 1, 1, 1,
+            1, 1, 1, 1, 1, 1,
+            0, 1, 0, 0, 0, 1,
+            0, 1, 0, 1, 0, 0,
+            0, 1, 1, 0, 1, 1,
+            0, 0, 1, 1, 1, 0]
+
+sub_key_6: [1, 0, 1, 1, 1, 1,
+            1, 1, 0, 1, 1, 0,
+            1, 1, 0, 1, 1, 0,
+            0, 1, 1, 1, 1, 1,
+            1, 0, 0, 1, 1, 1,
+            0, 0, 1, 0, 0, 1,
+            0, 0, 0, 0, 1, 1,
+            0, 0, 1, 1, 0, 1]
+
+sub_key_7: [0, 1, 1, 1, 1, 1,
+            1, 1, 0, 0, 1, 0,
+            1, 1, 1, 1, 1, 0,
+            1, 0, 1, 0, 0, 1,
+            1, 0, 0, 0, 0, 0,
+            1, 0, 1, 1, 0, 1,
+            0, 1, 1, 0, 1, 1,
+            1, 0, 0, 1, 0, 1]
+
+sub_key_8: [1, 1, 0, 1, 1, 0,
+            1, 1, 1, 0, 1, 1,
+            1, 1, 0, 0, 1, 0,
+            1, 1, 1, 1, 0, 1,
+            0, 0, 0, 1, 1, 0,
+            1, 0, 1, 0, 1, 0,
+            1, 1, 1, 1, 1, 0,
+            1, 0, 0, 0, 0, 1]
+
+sub_key_9: [1, 0, 0, 1, 1, 0,
+            0, 1, 1, 1, 1, 0,
+            1, 1, 0, 0, 1, 1,
+            1, 0, 1, 1, 1, 1,
+            0, 0, 1, 0, 0, 1,
+            0, 0, 0, 1, 1, 1,
+            0, 0, 0, 0, 0, 0,
+            1, 1, 1, 1, 1, 1]
+
+sub_key_10: [1, 1, 1, 1, 0, 0,
+             0, 1, 0, 1, 1, 0,
+             1, 1, 1, 1, 1, 0,
+             1, 1, 1, 1, 1, 0,
+             1, 0, 1, 0, 0, 1,
+             1, 1, 0, 0, 0, 1,
+             1, 0, 0, 0, 1, 1,
+             1, 0, 0, 1, 1, 0]
+
+sub_key_11: [1, 1, 1, 1, 0, 1,
+             0, 0, 1, 0, 1, 1,
+             1, 1, 1, 1, 1, 0,
+             1, 0, 0, 1, 0, 1,
+             1, 0, 0, 0, 0, 1,
+             0, 0, 1, 0, 0, 0,
+             1, 0, 1, 1, 1, 1,
+             1, 1, 0, 0, 1, 1]
+
+sub_key_12: [1, 1, 0, 1, 0, 0,
+             1, 1, 1, 0, 1, 1,
+             1, 1, 1, 0, 0, 1,
+             1, 1, 0, 1, 1, 1,
+             0, 0, 0, 1, 0, 1,
+             1, 1, 1, 0, 0, 0,
+             1, 1, 1, 0, 0, 1,
+             0, 1, 0, 1, 0, 1]
+
+sub_key_13: [1, 1, 1, 0, 1, 1,
+             0, 1, 1, 1, 1, 1,
+             0, 1, 1, 0, 1, 1,
+             1, 1, 0, 1, 1, 0,
+             0, 1, 0, 1, 1, 0,
+             1, 1, 1, 0, 0, 0,
+             0, 1, 0, 1, 1, 1,
+             0, 1, 0, 0, 0, 0]
+
+sub_key_14: [1, 1, 1, 1, 0, 1,
+             1, 0, 1, 1, 0, 1,
+             0, 1, 1, 1, 1, 1,
+             1, 0, 1, 1, 1, 0,
+             0, 0, 0, 0, 1, 0,
+             0, 1, 1, 1, 1, 0,
+             0, 1, 0, 1, 0, 0,
+             0, 0, 1, 1, 0, 1]
+
+sub_key_15: [1, 1, 1, 1, 1, 0,
+             1, 0, 1, 1, 0, 1,
+             0, 0, 1, 1, 0, 1,
+             1, 1, 0, 0, 1, 1,
+             0, 1, 1, 0, 1, 0,
+             1, 0, 0, 1, 1, 1,
+             0, 1, 0, 0, 1, 0,
+             0, 0, 0, 1, 0, 0]
+
+sub_key_16: [1, 1, 1, 1, 1, 1,
+             1, 1, 1, 1, 1, 1,
+             1, 0, 1, 0, 0, 1,
+             1, 1, 0, 0, 1, 1,
+             0, 0, 0, 1, 1, 0,
+             1, 0, 1, 0, 1, 1,
+             1, 0, 0, 0, 0, 1,
+             1, 1, 0, 0, 1, 1]

data/test/key_schedule_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class KeyScheduleTest < Test::Unit::TestCase
+  fixtures :key_schedule
+  
+  def setup
+    @key_schedule = KeySchedule.new(key_schedule(:test_key))
+  end
+  
+  def test_class
+    assert_kind_of KeySchedule, @key_schedule
+  end
+  
+  def test_test_key
+    assert_kind_of Array, @key_schedule.key
+    assert_equal key_schedule(:test_key), @key_schedule.key
+  end
+  
+  def test_sub_keys
+    assert_kind_of Array, @key_schedule.sub_keys
+    assert_equal key_schedule(:sub_key_1), @key_schedule.sub_keys[0]
+    assert_equal key_schedule(:sub_key_2), @key_schedule.sub_keys[1]
+    assert_equal key_schedule(:sub_key_3), @key_schedule.sub_keys[2]
+    assert_equal key_schedule(:sub_key_4), @key_schedule.sub_keys[3]
+    assert_equal key_schedule(:sub_key_5), @key_schedule.sub_keys[4]
+    assert_equal key_schedule(:sub_key_6), @key_schedule.sub_keys[5]
+    assert_equal key_schedule(:sub_key_7), @key_schedule.sub_keys[6]
+    assert_equal key_schedule(:sub_key_8), @key_schedule.sub_keys[7]
+    assert_equal key_schedule(:sub_key_9), @key_schedule.sub_keys[8]
+    assert_equal key_schedule(:sub_key_10), @key_schedule.sub_keys[9]
+    assert_equal key_schedule(:sub_key_11), @key_schedule.sub_keys[10]
+    assert_equal key_schedule(:sub_key_12), @key_schedule.sub_keys[11]
+    assert_equal key_schedule(:sub_key_13), @key_schedule.sub_keys[12]
+    assert_equal key_schedule(:sub_key_14), @key_schedule.sub_keys[13]
+    assert_equal key_schedule(:sub_key_15), @key_schedule.sub_keys[14]
+    assert_equal key_schedule(:sub_key_16), @key_schedule.sub_keys[15]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__) + "../lib")
+
+require 'test/unit'
+require 'yaml'
+require 'ruby-des'
+
+class Test::Unit::TestCase
+  @@fixtures = {}
+  def self.fixtures(*list)
+    list.each do |fixture|
+      self.class_eval do
+        define_method(fixture) do |item|
+          @@fixtures[fixture] ||= File.exists?("#{fixture.to_s}.yml") ? YAML::load_file("#{fixture.to_s}.yml") : YAML::load_file("test/#{fixture.to_s}.yml")
+          @@fixtures[fixture][item.to_s]
+        end
+      end
+    end
+  end
+end

data/test/xor.yml

@@ -0,0 +1,26 @@
+e: [1, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 1,
+    0, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1,
+    1, 1, 0, 1, 0, 0,
+    0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1, 0,
+    1, 0, 1, 0, 1, 0]
+
+sub_key: [1, 0, 1, 0, 1, 1,
+          0, 1, 1, 1, 0, 1,
+          1, 0, 1, 1, 0, 1,
+          1, 1, 1, 1, 1, 1,
+          1, 1, 1, 0, 1, 0,
+          0, 0, 0, 1, 0, 0,
+          0, 0, 0, 1, 1, 0,
+          1, 0, 1, 1, 1, 1]
+
+e_xor_sub_key: [0, 0, 1, 0, 1, 1,
+                0, 1, 1, 1, 0, 0,
+                1, 1, 0, 0, 1, 0,
+                0, 0, 0, 0, 0, 0,
+                0, 0, 1, 1, 1, 0,
+                0, 0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0, 1]

data/test/xor_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class XORTest < Test::Unit::TestCase
+  fixtures :xor
+  
+  def test_run
+    assert_equal xor(:e_xor_sub_key), XOR.run(xor(:e), xor(:sub_key))
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-des
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Robert Sosinski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-04 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/ruby-des.rb
+- lib/ruby-des/feistel.rb
+- lib/ruby-des/key_schedule.rb
+- lib/ruby-des/xor.rb
+- test/ctx.yml
+- test/ctx_test.rb
+- test/feistel.yml
+- test/feistel_test.rb
+- test/key_schedule.yml
+- test/key_schedule_test.rb
+- test/test_helper.rb
+- test/xor.yml
+- test/xor_test.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ruby-des
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: This gem make use DES Data Encryption.
+test_files: 
+- test/ctx.yml
+- test/ctx_test.rb
+- test/feistel.yml
+- test/feistel_test.rb
+- test/key_schedule.yml
+- test/key_schedule_test.rb
+- test/test_helper.rb
+- test/xor.yml
+- test/xor_test.rb