otherinbox-crypt19 1.2.1

data/lib/crypt/cbc.rb

@@ -0,0 +1,119 @@
+require 'stringio'
+require 'crypt/stringxor'
+
+module Crypt
+  module CBC
+  
+    ULONG = 0x100000000
+  
+    # When this module is mixed in with an encryption class, the class
+    # must provide three methods: encrypt_block(block) and decrypt_block(block)
+    # and block_size()
+  
+  
+    def generate_initialization_vector(words)
+      srand(Time.now.to_i)
+      vector = ""
+      words.times {
+        vector << [rand(ULONG)].pack('N')
+      }
+      return(vector)
+    end
+  
+  
+    def encrypt_stream(plain_stream, crypt_stream)
+      # Cypher-block-chain mode
+    
+      init_vector = generate_initialization_vector(block_size() / 4)
+      chain = encrypt_block(init_vector)
+      crypt_stream.write(chain)
+
+      while ((block = plain_stream.read(block_size())) && (block.length == block_size()))
+        block = block ^ chain 
+        encrypted = encrypt_block(block)
+        crypt_stream.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
+      # bytes in the final block
+      block = '' if block.nil?
+      buffer = block.split('')
+      remaining_message_bytes = buffer.length
+      buffer << remaining_message_bytes.chr * (block_size() - remaining_message_bytes)
+      block = buffer.join('')
+      block = block ^ chain
+      encrypted = encrypt_block(block)
+      crypt_stream.write(encrypted)
+    end
+  
+  
+    def decrypt_stream(crypt_stream, plain_stream)
+      # Cypher-block-chain mode
+      chain = crypt_stream.read(block_size())
+
+      while (block = crypt_stream.read(block_size()))
+        decrypted = decrypt_block(block)
+        plain_text = decrypted ^ chain
+        plain_stream.write(plain_text) unless crypt_stream.eof?
+        chain = block
+      end
+    
+      # write the final block, omitting the padding
+      buffer = plain_text.split('')
+      remaining_message_bytes = buffer.last.unpack('C').first
+      remaining_message_bytes.times { plain_stream.write(buffer.shift) }
+    end
+  
+  
+    def carefully_open_file(filename, mode)
+      begin
+        a_file = File.new(filename, mode)
+      rescue
+        puts "Sorry. There was a problem opening the file <#{filename}>."
+        a_file.close() unless a_file.nil?
+        raise
+      end
+      return(a_file)
+    end
+  
+  
+    def encrypt_file(plain_filename, crypt_filename)
+      plain_file = carefully_open_file(plain_filename, 'rb')
+      crypt_file = carefully_open_file(crypt_filename, 'wb+')
+      encrypt_stream(plain_file, crypt_file)
+      plain_file.close unless plain_file.closed?
+      crypt_file.close unless crypt_file.closed?
+    end
+  
+  
+    def decrypt_file(crypt_filename, plain_filename)
+      crypt_file = carefully_open_file(crypt_filename, 'rb')
+      plain_file = carefully_open_file(plain_filename, 'wb+')
+      decrypt_stream(crypt_file, plain_file)
+      crypt_file.close unless crypt_file.closed?
+      plain_file.close unless plain_file.closed?
+    end
+  
+  
+    def encrypt_string(plain_text)
+      plain_stream = StringIO.new(plain_text)
+      crypt_stream = StringIO.new('')
+      encrypt_stream(plain_stream, crypt_stream)
+      crypt_text = crypt_stream.string
+      return(crypt_text)
+    end
+  
+  
+    def decrypt_string(crypt_text)
+      crypt_stream = StringIO.new(crypt_text)
+      plain_stream = StringIO.new('')
+      decrypt_stream(crypt_stream, plain_stream)
+      plain_text = plain_stream.string
+      return(plain_text)
+    end
+  
+  end
+end

data/lib/crypt/gost.rb

@@ -0,0 +1,138 @@
+# adapted from C++ code written by Wei Dai 
+# of the Crypto++ project http://www.eskimo.com/~weidai/cryptlib.html
+
+require 'crypt/cbc'
+
+module Crypt
+  class Gost
+
+    include CBC
+  
+    ULONG   = 0x100000000
+  
+    def block_size
+      return(8)
+    end
+  
+  
+    def initialize(user_key)
+  
+      # These are the S-boxes given in Applied Cryptography 2nd Ed., p. 333
+      @sBox = [
+        [4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3],
+        [14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9],
+        [5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11],
+        [7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3],
+        [6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2],
+        [4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14],
+        [13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12],
+        [1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12]
+      ]
+
+      # These are the S-boxes given in the GOST source code listing in Applied
+  	  # Cryptography 2nd Ed., p. 644.  They appear to be from the DES S-boxes
+      # [13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 ],
+      # [ 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 ],
+      # [12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 ],
+      # [ 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 ],
+      # [ 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 ],
+      # [10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 ],
+      # [15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 ],
+      # [14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 ] 
+    
+      # precalculate the S table
+      @s_table = precalculate_s_table()
+    
+      # derive the 32-byte key from the user-supplied key
+      user_key_length = user_key.length
+      @key = user_key[0..31].unpack('C'*32)
+      if (user_key_length < 32)
+        user_key_length.upto(31) { @key << 0 }
+      end
+    end
+  
+  
+    def precalculate_s_table()
+      s_table = [[], [], [], []]
+      0.upto(3) { |i|
+        0.upto(255) { |j|
+          t = @sBox[2*i][j % 16] | (@sBox[2*i+1][j/16] << 4)
+          u = (8*i + 11) % 32
+          v = (t << u) | (t >> (32-u))
+          s_table[i][j] = (v % ULONG)
+        } 
+      }
+      return(s_table)
+    end
+  
+  
+    def f(long_word)
+      long_word = long_word % ULONG
+      a, b, c, d = [long_word].pack('L').unpack('CCCC')
+      return(@s_table[3][d] ^ @s_table[2][c] ^ @s_table[1][b] ^ @s_table[0][a])
+    end
+  
+  
+    def encrypt_pair(xl, xr)
+      3.times {
+        xr ^= f(xl+@key[0])
+        xl ^= f(xr+@key[1])
+        xr ^= f(xl+@key[2])
+        xl ^= f(xr+@key[3])
+        xr ^= f(xl+@key[4])
+        xl ^= f(xr+@key[5])
+        xr ^= f(xl+@key[6])
+        xl ^= f(xr+@key[7])
+      }
+      xr ^= f(xl+@key[7])
+      xl ^= f(xr+@key[6])
+      xr ^= f(xl+@key[5])
+      xl ^= f(xr+@key[4])
+      xr ^= f(xl+@key[3])
+      xl ^= f(xr+@key[2])
+      xr ^= f(xl+@key[1])
+      xl ^= f(xr+@key[0])
+      return([xr, xl])
+    end
+  
+  
+    def decrypt_pair(xl, xr)
+      xr ^= f(xl+@key[0])
+      xl ^= f(xr+@key[1])
+      xr ^= f(xl+@key[2])
+      xl ^= f(xr+@key[3])
+      xr ^= f(xl+@key[4])
+      xl ^= f(xr+@key[5])
+      xr ^= f(xl+@key[6])
+      xl ^= f(xr+@key[7])
+      3.times {
+        xr ^= f(xl+@key[7])
+        xl ^= f(xr+@key[6])
+        xr ^= f(xl+@key[5])
+        xl ^= f(xr+@key[4])
+        xr ^= f(xl+@key[3])
+        xl ^= f(xr+@key[2])
+        xr ^= f(xl+@key[1])
+        xl ^= f(xr+@key[0])
+      }
+      return([xr, xl])
+    end
+  
+  
+    def encrypt_block(block)
+      xl, xr = block.unpack('NN')
+      xl, xr = encrypt_pair(xl, xr)
+      encrypted = [xl, xr].pack('NN')
+      return(encrypted)
+    end
+  
+  
+    def decrypt_block(block)
+      xl, xr = block.unpack('NN')
+      xl, xr = decrypt_pair(xl, xr)
+      decrypted = [xl, xr].pack('NN')
+      return(decrypted)
+    end
+
+  end
+end

data/lib/crypt/idea.rb

@@ -0,0 +1,190 @@
+# IDEA (International Data Encryption Algorithm) by 
+# Xuejia Lai and James Massey (1992).  Refer to license info at the end of this file.
+
+require 'digest/md5'
+require 'crypt/cbc'
+
+module Crypt
+  class IDEA
+  
+    include Crypt::CBC
+  
+    ULONG   = 0x100000000
+    USHORT  = 0x10000
+  
+    ENCRYPT = 0
+    DECRYPT = 1
+  
+  
+    def block_size
+      return(8)
+    end
+  
+  
+    def initialize(key128, mode)
+      # IDEA is subject to attack unless the key is sufficiently random, so we
+      # take an MD5 digest of a variable-length passphrase to ensure a solid key
+      if (key128.class == String)  
+        digest = Digest::MD5.digest(key128)
+        key128 = digest.unpack('n'*8)
+      end
+      raise "Key must be 128 bits (8 words)" unless (key128.class == Array) && (key128.length == 8)
+      raise "Mode must be IDEA::ENCRYPT or IDEA::DECRYPT" unless ((mode == ENCRYPT) | (mode == DECRYPT))
+      if (mode == ENCRYPT)
+        @subkeys = generate_encryption_subkeys(key128)
+      else (mode == DECRYPT)
+        @subkeys = generate_decryption_subkeys(key128)
+      end
+    end
+  
+  
+    def mul(a, b)
+      modulus = 0x10001
+      return((1 - b) % USHORT) if (a == 0)
+      return((1 - a) % USHORT) if (b == 0)
+      return((a * b) % modulus)
+    end
+  
+  
+    def mul_inv(x)
+      modulus = 0x10001
+      x = x.to_i % USHORT
+      return(x) if (x <= 1)
+      t1 = USHORT / x
+      y  = modulus % x
+      if (y == 1)
+        inv = (1 - t1) & 0xFFFF
+        return(inv)
+      end
+      t0 = 1
+      while (y != 1)
+        q = x / y
+        x = x % y
+        t0 = t0 + (q * t1)
+        return(t0) if (x == 1)
+        q = y / x
+        y = y % x
+        t1 = t1 + (q * t0)
+      end
+      inv = (1 - t1) & 0xFFFF
+      return(inv)
+    end
+  
+  
+    def generate_encryption_subkeys(key)
+      encrypt_keys = []
+      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)
+        encrypt_keys[i] = ((encrypt_keys[a] << 9) | (encrypt_keys[b] >> 7)) % USHORT
+      }
+      return(encrypt_keys)
+    end
+  
+  
+    def generate_decryption_subkeys(key)
+      encrypt_keys = generate_encryption_subkeys(key)
+      decrypt_keys = []
+      decrypt_keys[48] = mul_inv(encrypt_keys.shift)
+      decrypt_keys[49] = (-encrypt_keys.shift) % USHORT
+      decrypt_keys[50] = (-encrypt_keys.shift) % USHORT
+      decrypt_keys[51] = mul_inv(encrypt_keys.shift)
+      42.step(0, -6) { |i|
+        decrypt_keys[i+4] = encrypt_keys.shift % USHORT
+        decrypt_keys[i+5] = encrypt_keys.shift % USHORT
+        decrypt_keys[i]   = mul_inv(encrypt_keys.shift)
+        if (i ==0)
+          decrypt_keys[1] = (-encrypt_keys.shift) % USHORT
+          decrypt_keys[2] = (-encrypt_keys.shift) % USHORT
+        else
+          decrypt_keys[i+2] = (-encrypt_keys.shift) % USHORT
+          decrypt_keys[i+1] = (-encrypt_keys.shift) % USHORT
+        end
+        decrypt_keys[i+3] = mul_inv(encrypt_keys.shift)
+      }
+      return(decrypt_keys)
+    end
+  
+  
+    def crypt_pair(l, r)
+      word = [l, r].pack('NN').unpack('nnnn')
+      k = @subkeys[0..51]
+      8.downto(1) { |i|
+        word[0] = mul(word[0], k.shift)
+        word[1] = (word[1] + k.shift) % USHORT
+        word[2] = (word[2] + k.shift) % USHORT
+        word[3] = mul(word[3], k.shift)
+        t2 = word[0] ^ word[2]
+        t2 = mul(t2, k.shift)
+        t1 = (t2 + (word[1] ^ word[3])) % USHORT
+        t1 = mul(t1, k.shift)
+        t2 = (t1 + t2) % USHORT
+        word[0] ^= t1
+        word[3] ^= t2
+        t2 ^= word[1]
+        word[1] = word[2] ^ t1
+        word[2] = t2
+      }
+      result = []
+      result << mul(word[0], k.shift)
+      result << (word[2] + k.shift) % USHORT
+      result << (word[1] + k.shift) % USHORT
+      result << mul(word[3], k.shift)
+      two_longs = result.pack('nnnn').unpack('NN')
+      return(two_longs)
+    end
+  
+    def encrypt_block(block)
+      xl, xr = block.unpack('NN')
+      xl, xr = crypt_pair(xl, xr)
+      encrypted = [xl, xr].pack('NN')
+      return(encrypted)
+    end
+  
+  
+    def decrypt_block(block)
+      xl, xr = block.unpack('NN')
+      xl, xr = crypt_pair(xl, xr)
+      decrypted = [xl, xr].pack('NN')
+      return(decrypted)
+    end
+
+
+  end
+end
+
+
+# IDEA LICENSE INFORMATION
+#
+# This software product contains the IDEA algorithm as described and claimed in
+# US patent 5,214,703, EPO patent 0482154 (covering Austria, France, Germany,
+# Italy, the Netherlands, Spain, Sweden, Switzerland, and the UK), and Japanese
+# patent application 508119/1991, "Device for the conversion of a digital block
+# and use of same" (hereinafter referred to as "the algorithm").  Any use of
+# the algorithm for commercial purposes is thus subject to a license from Ascom
+# Systec Ltd. of CH-5506 Maegenwil (Switzerland), being the patentee and sole
+# owner of all rights, including the trademark IDEA.
+# 
+# Commercial purposes shall mean any revenue generating purpose including but
+# not limited to:
+# 
+# i) Using the algorithm for company internal purposes (subject to a site
+#    license).
+# 
+# ii) Incorporating the algorithm into any software and distributing such
+#     software and/or providing services relating thereto to others (subject to
+#     a product license).
+# 
+# iii) Using a product containing the algorithm not covered by an IDEA license
+#      (subject to an end user license).
+# 
+# All such end user license agreements are available exclusively from Ascom
+# Systec Ltd and may be requested via the WWW at http://www.ascom.ch/systec or
+# by email to idea@ascom.ch.
+# 
+# Use other than for commercial purposes is strictly limited to non-revenue
+# generating data transfer between private individuals.  The use by government
+# agencies, non-profit organizations, etc is considered as use for commercial
+# purposes but may be subject to special conditions.  Any misuse will be
+# prosecuted.

data/lib/crypt/noise.rb

@@ -0,0 +1,92 @@
+# add_noise - take a message and intersperse noise to make a new noisy message of given byte-length
+# remove_noise - take a noisy message and extract the message
+
+module Crypt
+  module Noise
+
+    def add_noise(new_length)
+      message = self
+      usable_noisy_message_length = new_length / 9 * 8
+      bitmap_size = new_length / 9
+      remaining_bytes = new_length - usable_noisy_message_length - bitmap_size
+      if (message.length > usable_noisy_message_length)
+        minimumnew_length = (message.length / 8.0).ceil * 9
+        puts "For a clear text of #{message.length} bytes, the minimum obscured length"
+        puts "is #{minimumnew_length} bytes which allows for no noise in the message."
+        puts "You should choose an obscured length of at least double the clear text"
+        puts "length, such as #{message.length / 8 * 32} bytes"
+        raise "Insufficient length for noisy message" 
+      end
+      bitmap = []
+      usable_noisy_message_length.times { bitmap << false }
+      srand(Time.now.to_i)
+      positions_selected = 0
+      while (positions_selected < message.length)
+        position_taken = rand(usable_noisy_message_length)
+        if bitmap[position_taken]
+          next
+        else
+          bitmap[position_taken] = true
+          positions_selected = positions_selected.next
+        end
+      end
+    
+      noisy_message = ""
+      0.upto(bitmap_size-1) { |byte|
+        c = 0
+        0.upto(7) { |bit|
+          c = c + (1<<bit) if bitmap[byte * 8 + bit]
+        }
+        noisy_message << c.chr
+      }
+      pos_in_message = 0
+      0.upto(usable_noisy_message_length-1) { |pos|
+        if bitmap[pos]
+          meaningful_byte = message[pos_in_message]
+          noisy_message << meaningful_byte
+          pos_in_message = pos_in_message.next
+        else
+          noise_byte = rand(256).chr
+          noisy_message << noise_byte
+        end
+      }
+      remaining_bytes.times {
+          noise_byte = rand(256).chr
+          noisy_message << noise_byte
+      }
+      return(noisy_message)
+    end
+  
+  
+    def remove_noise
+      noisy_message = self
+      bitmap_size = noisy_message.length / 9
+      actual_message_length =  bitmap_size * 8
+    
+      actual_message_start = bitmap_size
+      actual_message_finish = bitmap_size + actual_message_length - 1
+      actual_message = noisy_message[actual_message_start..actual_message_finish]
+    
+      bitmap = []
+      0.upto(bitmap_size - 1) { |byte|
+        c = noisy_message[byte]
+        0.upto(7) { |bit|
+          bitmap[byte * 8 + bit] = (c[bit] == 1)
+        }
+      }
+      clear_message = ""
+      0.upto(actual_message_length) { |pos|
+        meaningful = bitmap[pos]
+        if meaningful
+          clear_message << actual_message[pos]
+        end
+      }
+      return(clear_message)
+    end
+  
+  end
+end
+
+class String
+  include Crypt::Noise
+end