flatulent 0.0.1 → 0.0.2

data/rails/lib/flatulent/crypt/blowfish.rb

@@ -0,0 +1,109 @@
+# blowfish.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+#
+#  Blowfish algorithm by Bruce Schneider
+#  Ported by Richard Kernahan from the reference C code
+module Crypt
+class Blowfish
+  
+  require 'crypt/cbc'
+  include Crypt::CBC
+  
+  require 'crypt/blowfish-tables'
+  include Crypt::BlowfishTables
+  
+  ULONG = 0x100000000
+  
+  def block_size
+    return(8)
+  end
+  
+  
+  def initialize(key)
+    @key = key
+    raise "Bad key length: the key must be 1-56 bytes." unless (key.length.between?(1,56))
+    @pArray = []
+    @sBoxes = []
+    setup_blowfish()
+  end
+  
+  
+  def f(x)
+    a, b, c, d = [x].pack('N').unpack('CCCC')
+    y = (@sBoxes[0][a] + @sBoxes[1][b]) % ULONG
+    y = (y ^ @sBoxes[2][c]) % ULONG
+    y = (y + @sBoxes[3][d]) % ULONG
+    return(y)
+  end
+  
+  
+  def setup_blowfish()
+    @sBoxes = Array.new(4) { |i| INITIALSBOXES[i].clone }
+    @pArray = INITIALPARRAY.clone
+    keypos = 0
+    0.upto(17) { |i|
+      data = 0
+      4.times {
+        data = ((data << 8) | @key[keypos]) % ULONG
+        keypos = (keypos.next) % @key.length
+      }
+      @pArray[i] = (@pArray[i] ^ data) % ULONG
+    }
+    l = 0
+    r = 0
+    0.step(17, 2) { |i|
+      l, r = encrypt_pair(l, r)
+      @pArray[i]   = l
+      @pArray[i+1] = r
+    }
+    0.upto(3) { |i|
+      0.step(255, 2) { |j|
+        l, r = encrypt_pair(l, r)
+        @sBoxes[i][j]   = l
+        @sBoxes[i][j+1] = r
+      }
+    }
+  end
+  
+  def encrypt_pair(xl, xr)
+    0.upto(15) { |i|
+        xl = (xl ^ @pArray[i]) % ULONG
+        xr = (xr ^ f(xl)) % ULONG
+        xl, xr = [xl, xr].reverse
+    }
+    xl, xr = [xl, xr].reverse
+    xr = (xr ^ @pArray[16]) % ULONG
+    xl = (xl ^ @pArray[17]) % ULONG
+    return([xl, xr])
+  end
+  
+  
+  def decrypt_pair(xl, xr)
+    17.downto(2) { |i|
+        xl = (xl ^ @pArray[i]) % ULONG
+        xr = (xr ^ f(xl)) % ULONG
+        xl, xr = [xl, xr].reverse
+    }
+    xl, xr = [xl, xr].reverse
+    xr = (xr ^ @pArray[1]) % ULONG
+    xl = (xl ^ @pArray[0]) % ULONG
+    return([xl, xr])
+  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/rails/lib/flatulent/crypt/cbc.rb

@@ -0,0 +1,123 @@
+# cbc.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+
+module Crypt
+module CBC
+  
+  require 'stringio'
+  require 'crypt/stringxor'
+  
+  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(plainStream, cryptStream)
+    # Cypher-block-chain mode
+    
+    initVector = generate_initialization_vector(block_size() / 4)
+    chain = encrypt_block(initVector)
+    cryptStream.write(chain)
+
+    while ((block = plainStream.read(block_size())) && (block.length == block_size()))
+      block = block ^ chain 
+      encrypted = encrypt_block(block)
+      cryptStream.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('')
+    remainingMessageBytes = buffer.length
+    # we use 7-bit characters to avoid possible strange behavior on the Mac
+    remainingMessageBytes.upto(block_size()-2) { buffer << rand(128).chr }
+    buffer << remainingMessageBytes.chr
+    block = buffer.join('')
+    block = block ^ chain
+    encrypted = encrypt_block(block)
+    cryptStream.write(encrypted)
+  end
+  
+  
+  def decrypt_stream(cryptStream, plainStream)
+    # Cypher-block-chain mode
+    chain = cryptStream.read(block_size())
+
+    while (block = cryptStream.read(block_size()))
+      decrypted = decrypt_block(block)
+      plainText = decrypted ^ chain
+      plainStream.write(plainText) unless cryptStream.eof?
+      chain = block
+    end
+    
+    # write the final block, omitting the padding
+    buffer = plainText.split('')
+    remainingMessageBytes = buffer.last.unpack('C').first
+    remainingMessageBytes.times { plainStream.write(buffer.shift) }
+  end
+  
+  
+  def carefully_open_file(filename, mode)
+    begin
+      aFile = File.new(filename, mode)
+    rescue
+      puts "Sorry. There was a problem opening the file <#{filename}>."
+      aFile.close() unless aFile.nil?
+      raise
+    end
+    return(aFile)
+  end
+  
+  
+  def encrypt_file(plainFilename, cryptFilename)
+    plainFile = carefully_open_file(plainFilename, 'rb')
+    cryptFile = carefully_open_file(cryptFilename, 'wb+')
+    encrypt_stream(plainFile, cryptFile)
+    plainFile.close unless plainFile.closed?
+    cryptFile.close unless cryptFile.closed?
+  end
+  
+  
+  def decrypt_file(cryptFilename, plainFilename)
+    cryptFile = carefully_open_file(cryptFilename, 'rb')
+    plainFile = carefully_open_file(plainFilename, 'wb+')
+    decrypt_stream(cryptFile, plainFile)
+    cryptFile.close unless cryptFile.closed?
+    plainFile.close unless plainFile.closed?
+  end
+  
+  
+  def encrypt_string(plainText)
+    plainStream = StringIO.new(plainText)
+    cryptStream = StringIO.new('')
+    encrypt_stream(plainStream, cryptStream)
+    cryptText = cryptStream.string
+    return(cryptText)
+  end
+  
+  
+  def decrypt_string(cryptText)
+    cryptStream = StringIO.new(cryptText)
+    plainStream = StringIO.new('')
+    decrypt_stream(cryptStream, plainStream)
+    plainText = plainStream.string
+    return(plainText)
+  end
+  
+end
+end

data/rails/lib/flatulent/crypt/gost.rb

@@ -0,0 +1,140 @@
+# gost.rb  
+# Adapted by Richard Kernahan <kernighan_rich@rubyforge.org> 
+# from C++ code written by Wei Dai 
+# of the Crypto++ project http://www.eskimo.com/~weidai/cryptlib.html
+
+module Crypt
+class Gost
+
+  require 'crypt/cbc'
+  include CBC
+  
+  ULONG   = 0x100000000
+  
+  def block_size
+    return(8)
+  end
+  
+  
+  def initialize(userKey)
+  
+    # 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
+    @sTable = precalculate_S_table()
+    
+    # derive the 32-byte key from the user-supplied key
+    userKeyLength = userKey.length
+    @key = userKey[0..31].unpack('C'*32)
+    if (userKeyLength < 32)
+      userKeyLength.upto(31) { @key << 0 }
+    end
+  end
+  
+  
+  def precalculate_S_table()
+    sTable = [[], [], [], []]
+    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))
+        sTable[i][j] = (v % ULONG)
+      } 
+    }
+    return(sTable)
+  end
+  
+  
+  def f(longWord)
+    longWord = longWord % ULONG
+    a, b, c, d = [longWord].pack('L').unpack('CCCC')
+    return(@sTable[3][d] ^ @sTable[2][c] ^ @sTable[1][b] ^ @sTable[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/rails/lib/flatulent/crypt/idea.rb

@@ -0,0 +1,193 @@
+# idea.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+
+# IDEA (International Data Encryption Algorithm) by 
+# Xuejia Lai and James Massey (1992).  Refer to license info at end.
+# Ported by Richard Kernahan 2005
+
+module Crypt
+class IDEA
+  
+  require 'crypt/cbc'
+  include Crypt::CBC
+
+  require 'digest/md5'
+  
+  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.new(key128).digest
+      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 mulInv(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] = mulInv(encrypt_keys.shift)
+    decrypt_keys[49] = (-encrypt_keys.shift) % USHORT
+    decrypt_keys[50] = (-encrypt_keys.shift) % USHORT
+    decrypt_keys[51] = mulInv(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]   = mulInv(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] = mulInv(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)
+    twoLongs = result.pack('nnnn').unpack('NN')
+    return(twoLongs)
+  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
+
+  # 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/rails/lib/flatulent/crypt/noise.rb

@@ -0,0 +1,94 @@
+# crypt/rattle.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+
+# 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(newLength)
+    message = self
+    usableNoisyMessageLength = newLength / 9 * 8
+    bitmapSize = newLength / 9
+    remainingBytes = newLength - usableNoisyMessageLength - bitmapSize
+    if (message.length > usableNoisyMessageLength)
+      minimumNewLength = (message.length / 8.0).ceil * 9
+      puts "For a clear text of #{message.length} bytes, the minimum obscured length"
+      puts "is #{minimumNewLength} 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 = []
+    usableNoisyMessageLength.times { bitmap << false }
+    srand(Time.now.to_i)
+    positionsSelected = 0
+    while (positionsSelected < message.length)
+      positionTaken = rand(usableNoisyMessageLength)
+      if bitmap[positionTaken]
+        next
+      else
+        bitmap[positionTaken] = true
+        positionsSelected = positionsSelected.next
+      end
+    end
+    
+    noisyMessage = ""
+    0.upto(bitmapSize-1) { |byte|
+      c = 0
+      0.upto(7) { |bit|
+        c = c + (1<<bit) if bitmap[byte * 8 + bit]
+      }
+      noisyMessage << c.chr
+    }
+    posInMessage = 0
+    0.upto(usableNoisyMessageLength-1) { |pos|
+      if bitmap[pos]
+        meaningfulByte = message[posInMessage]
+        noisyMessage << meaningfulByte
+        posInMessage = posInMessage.next
+      else
+        noiseByte = rand(256).chr
+        noisyMessage << noiseByte
+      end
+    }
+    remainingBytes.times {
+        noiseByte = rand(256).chr
+        noisyMessage << noiseByte
+    }
+    return(noisyMessage)
+  end
+  
+  
+  def remove_noise
+    noisyMessage = self
+    bitmapSize = noisyMessage.length / 9
+    actualMessageLength =  bitmapSize * 8
+    
+    actualMessageStart = bitmapSize
+    actualMessageFinish = bitmapSize + actualMessageLength - 1
+    actualMessage = noisyMessage[actualMessageStart..actualMessageFinish]
+    
+    bitmap = []
+    0.upto(bitmapSize - 1) { |byte|
+      c = noisyMessage[byte]
+      0.upto(7) { |bit|
+        bitmap[byte * 8 + bit] = (c[bit] == 1)
+      }
+    }
+    clearMessage = ""
+    0.upto(actualMessageLength) { |pos|
+      meaningful = bitmap[pos]
+      if meaningful
+        clearMessage << actualMessage[pos]
+      end
+    }
+    return(clearMessage)
+  end
+  
+end
+end
+
+class String
+  include Crypt::Noise
+end