flatulent 0.0.1 → 0.0.2

data/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/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

data/lib/flatulent/crypt/purerubystringio.rb

@@ -0,0 +1,378 @@
+# Thanks to Binky DaClown who wrote this pure-ruby implementation 
+# http://rubyforge.org/projects/prstringio/
+# Apparently CBC does not work well with the C-based stringio
+
+module Crypt
+class PureRubyStringIO
+
+	include Enumerable
+
+	SEEK_CUR = IO::SEEK_CUR
+	SEEK_END = IO::SEEK_END
+	SEEK_SET = IO::SEEK_SET
+
+	@@relayMethods = [:<<, :all?, :any?, :binmode, :close, :close_read, :close_write, :closed?, :closed_read?,
+	                  :closed_write?, :collect, :detect, :each, :each_byte, :each_line, :each_with_index,
+	                  :entries, :eof, :eof?, :fcntl, :fileno, :find, :find_all, :flush, :fsync, :getc, :gets,
+	                  :grep, :include?, :inject, :isatty, :length, :lineno, :lineno=, :map, :max, :member?,
+	                  :min, :partition, :path, :pid, :pos, :pos=, :print, :printf, :putc, :puts, :read,
+	                  :readchar, :readline, :readlines, :reject, :rewind, :seek, :select, :size, :sort,
+	                  :sort_by, :string, :string=, :sync, :sync=, :sysread, :syswrite, :tell, :truncate, :tty?,
+	                  :ungetc, :write, :zip]
+
+	def self.open(string="", mode="r+")
+		if block_given? then
+			sio = new(string, mode)
+			rc = yield(sio)
+			sio.close
+			rc
+		else
+			new(string, mode)
+		end
+	end
+
+	def <<(obj)
+		requireWritable
+		write obj
+		self
+	end
+
+	def binmode
+		self
+	end
+
+	def close
+		requireOpen
+		@sio_closed_read = true
+		@sio_closed_write = true
+		self
+	end
+
+	def close_read
+		raise IOError, "closing non-duplex IO for reading", caller if closed_read?
+		@sio_closed_read = true
+		self
+	end
+
+	def close_write
+		raise IOError, "closing non-duplex IO for writing", caller if closed_write?
+		@sio_closed_read = true
+		self
+	end
+
+	def closed?
+		closed_read? && closed_write?
+	end
+
+	def closed_read?
+		@sio_closed_read
+	end
+
+	def closed_write?
+		@sio_closed_write
+	end
+
+	def each(sep_string=$/, &block)
+		requireReadable
+		@sio_string.each(sep_string, &block)
+		@sio_pos = @sio_string.length
+	end
+
+	def each_byte(&block)
+		requireReadable
+		@sio_string.each_byte(&block)
+		@sio_pos = @sio_string.length
+	end
+
+	def eof
+		requireReadable { @sio_pos >= @sio_string.length }
+	end
+
+	def fcntl(integer_cmd, arg)
+		raise NotImplementedError, "The fcntl() function is unimplemented on this machine", caller
+	end
+
+	def fileno
+		nil
+	end
+
+	def flush
+		self
+	end
+
+	def fsync
+		0
+	end
+
+	def getc
+		requireReadable
+		char = @sio_string[@sio_pos]
+		@sio_pos +=  1 unless char.nil?
+		char
+	end
+
+	def gets(sep_string=$/)
+		requireReadable
+		@sio_lineno += 1
+		pstart = @sio_pos
+		@sio_pos = @sio_string.index(sep_string, @sio_pos) || [@sio_string.length, @sio_pos].max
+		@sio_string[pstart..@sio_pos]
+	end
+
+	def initialize(string="", mode="r+")
+		@sio_string = string.to_s
+		@sio_lineno = 0
+		@mode = mode
+		@relay = nil
+		case mode.delete("b")
+		when "r"
+			@sio_closed_read = false
+			@sio_closed_write = true
+			@sio_pos = 0
+		when "r+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = 0
+		when "w"
+			@sio_closed_read = true
+			@sio_closed_write = false
+			@sio_pos = 0
+			@sio_string.replace("")
+		when "w+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = 0
+			@sio_string.replace("")
+		when "a"
+			@sio_closed_read = true
+			@sio_closed_write = false
+			@sio_pos = @sio_string.length
+		when "a+"
+			@sio_closed_read = false
+			@sio_closed_write = false
+			@sio_pos = @sio_string.length
+		else
+			raise ArgumentError, "illegal access mode #{mode}", caller
+		end
+	end
+
+	def isatty
+		flase
+	end
+
+	def length
+		@sio_string.length
+	end
+
+	def lineno
+		@sio_lineno
+	end
+
+	def lineno=(integer)
+		@sio_lineno = integer
+	end
+
+	def path
+		nil
+	end
+
+	def pid
+		nil
+	end
+
+	def pos
+		@sio_pos
+	end
+
+	def pos=(integer)
+		raise Errno::EINVAL, "Invalid argument", caller if integer < 0
+		@sio_pos = integer
+	end
+
+	def print(*args)
+		requireWritable
+		args.unshift($_) if args.empty
+		args.each { |obj| write(obj) }
+		write($\) unless $\.nil?
+		nil
+	end
+
+	def printf(format_string, *args)
+		requireWritable
+		write format(format_string, *args)
+		nil
+	end
+
+	def putc(obj)
+		requireWritable
+		write(obj.is_a?(Numeric) ? sprintf("%c", obj) : obj.to_s[0..0])
+		obj
+	end
+
+	def puts(*args)
+		requireWritable
+		args.unshift("") if args.empty?
+		args.each { |obj|
+			write obj
+			write $/
+		}
+		nil
+	end
+
+	def read(length=nil, buffer=nil)
+		requireReadable
+		len = length || [@sio_string.length - @sio_pos, 0].max
+		raise ArgumentError, "negative length #{len} given", caller if len < 0
+		buffer ||= ""
+		pstart = @sio_pos
+		@sio_pos += len
+		buffer.replace(@sio_string[pstart..@sio_pos])
+		buffer.empty? && !length.nil? ? nil : buffer
+	end
+
+	def readchar
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		getc
+	end
+
+	def readline
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		gets
+	end
+
+	def readlines(sep_string=$/)
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		rc = []
+		until eof
+			rc << gets(sep_string)
+		end
+		rc
+	end
+
+	def reopen(string, mode=nil)
+		if string.is_a?(self.class) then
+			raise ArgumentError, "wrong number of arguments (2 for 1)", caller if !mode.nil?
+			@relay = string
+			instance_eval(%Q{
+				class << self
+					@@relayMethods.each { |name|
+						define_method(name, ObjectSpace._id2ref(#{@relay.object_id}).method(("original_" + name.to_s).to_sym).to_proc)
+					}
+				end
+			})
+		else
+			raise ArgumentError, "wrong number of arguments (1 for 2)", caller if mode.nil?
+			class << self
+				@@relayMethods.each { |name|
+					alias_method(name, "original_#{name}".to_sym)
+					public name
+				}
+				@relay = nil
+			end unless @relay.nil?
+			@sio_string = string.to_s
+			@mode = mode
+		end
+	end
+
+	def rewind
+		@sio_pos = 0
+		@sio_lineno = 0
+	end
+
+	def seek(amount, whence=SEEK_SET)
+		if whence == SEEK_CUR then
+			offset += @sio_pos
+		elsif whence == SEEK_END then
+			offset += size
+		end
+		@sio_pos = offset
+	end
+
+	def string
+		@sio_string
+	end
+	
+	def string=(newstring)
+		@sio_string = newstring
+	end
+
+	def sync
+		true
+	end
+
+	def sync=(boolean)
+		boolean
+	end
+
+	def sysread(length=nil, buffer=nil)
+		requireReadable
+		raise EOFError, "End of file reached", caller if eof?
+		read(length, buffer)
+	end
+
+	def syswrite(string)
+		requireWritable
+		addition = "\000" * (@sio_string.length - @sio_pos) + string.to_s
+		@sio_string[@sio_pos..(addition.length - 1)] = addition
+		@sio_pos +=  addition.size
+		addition.size
+	end
+
+	#In ruby 1.8.4 truncate differs from the docs in two ways.
+	#First, if an integer greater that the length is given then the string is expanded to the new integer
+	#length. As this expansion seems to contain junk characters instead of nulls I suspect this may be a
+	#flaw in the C code which could cause a core dump if abused/used.
+	#Second, the documentation states that  truncate returns 0. It returns the integer instead.
+	#This implementation follows the documentation in the first instance as I suspect this will be fixed
+	#in the C code. In the second instance, it follows the actions of the C code instead of the docs.
+	#This was decided as it causes no immedeate harm and this ruby implentation is to be as compatable
+	#as possible with the C version. Should the C version change to match the docs the ruby version
+	#will be simple to update as well. 
+	def truncate(integer)
+		requireWritable
+		raise Errno::EINVAL, "Invalid argument - negative length", caller if integer < 0
+		@sio_string[[integer, @sio_string.length].max..-1] = ""
+		integer
+	end
+
+	def ungetc(integer)
+		requireWritable
+		if @sio_pos > 0 then
+			@sio_pos -= 1
+			putc(integer)
+			@sio_pos -= 1
+		end
+	end
+
+	alias :each_line :each
+	alias :eof? :eof
+	alias :size :length
+	alias :tty? :isatty
+	alias :tell :pos
+	alias :write :syswrite
+
+	protected
+	@@relayMethods.each { |name|
+		alias_method("original_#{name}".to_sym, name)
+		protected "original_#{name}".to_sym
+	}
+
+	private
+
+	def requireReadable
+		raise IOError, "not opened for reading", caller[1..-1] if @sio_closed_read
+	end
+
+	def requireWritable
+		raise IOError, "not opened for writing", caller[1..-1] if @sio_closed_write
+	end
+
+	def requireOpen
+		raise IOError, "closed stream", caller[1..-1] if @sio_closed_read && @sio_closed_write
+	end
+
+end
+end