flatulent 0.0.1 → 0.0.2

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

data/rails/lib/flatulent/crypt/rijndael-tables.rb

@@ -0,0 +1,117 @@
+# rijndael-tables.rb  Richard Kernahan <kernighan_rich@rubyforge.org>
+
+module Crypt
+module RijndaelTables
+
+LogTable = [
+  0,   0,  25,   1,  50,   2,  26, 198,  75, 199,  27, 104,  51, 238, 223,   3, 
+100,   4, 224,  14,  52, 141, 129, 239,  76, 113,   8, 200, 248, 105,  28, 193, 
+125, 194,  29, 181, 249, 185,  39, 106,  77, 228, 166, 114, 154, 201,   9, 120, 
+101,  47, 138,   5,  33,  15, 225,  36,  18, 240, 130,  69,  53, 147, 218, 142, 
+150, 143, 219, 189,  54, 208, 206, 148,  19,  92, 210, 241,  64,  70, 131,  56, 
+102, 221, 253,  48, 191,   6, 139,  98, 179,  37, 226, 152,  34, 136, 145,  16, 
+126, 110,  72, 195, 163, 182,  30,  66,  58, 107,  40,  84, 250, 133,  61, 186, 
+ 43, 121,  10,  21, 155, 159,  94, 202,  78, 212, 172, 229, 243, 115, 167,  87, 
+175,  88, 168,  80, 244, 234, 214, 116,  79, 174, 233, 213, 231, 230, 173, 232, 
+ 44, 215, 117, 122, 235,  22,  11, 245,  89, 203,  95, 176, 156, 169,  81, 160, 
+127,  12, 246, 111,  23, 196,  73, 236, 216,  67,  31,  45, 164, 118, 123, 183, 
+204, 187,  62,  90, 251,  96, 177, 134,  59,  82, 161, 108, 170,  85,  41, 157, 
+151, 178, 135, 144,  97, 190, 220, 252, 188, 149, 207, 205,  55,  63,  91, 209, 
+ 83,  57, 132,  60,  65, 162, 109,  71,  20,  42, 158,  93,  86, 242, 211, 171, 
+ 68,  17, 146, 217,  35,  32,  46, 137, 180, 124, 184,  38, 119, 153, 227, 165, 
+103,  74, 237, 222, 197,  49, 254,  24,  13,  99, 140, 128, 192, 247, 112,   7
+]
+
+AlogTable = [
+  1,   3,   5,  15,  17,  51,  85, 255,  26,  46, 114, 150, 161, 248,  19,  53, 
+ 95, 225,  56,  72, 216, 115, 149, 164, 247,   2,   6,  10,  30,  34, 102, 170, 
+229,  52,  92, 228,  55,  89, 235,  38, 106, 190, 217, 112, 144, 171, 230,  49, 
+ 83, 245,   4,  12,  20,  60,  68, 204,  79, 209, 104, 184, 211, 110, 178, 205, 
+ 76, 212, 103, 169, 224,  59,  77, 215,  98, 166, 241,   8,  24,  40, 120, 136, 
+131, 158, 185, 208, 107, 189, 220, 127, 129, 152, 179, 206,  73, 219, 118, 154, 
+181, 196,  87, 249,  16,  48,  80, 240,  11,  29,  39, 105, 187, 214,  97, 163, 
+254,  25,  43, 125, 135, 146, 173, 236,  47, 113, 147, 174, 233,  32,  96, 160, 
+251,  22,  58,  78, 210, 109, 183, 194,  93, 231,  50,  86, 250,  21,  63,  65, 
+195,  94, 226,  61,  71, 201,  64, 192,  91, 237,  44, 116, 156, 191, 218, 117, 
+159, 186, 213, 100, 172, 239,  42, 126, 130, 157, 188, 223, 122, 142, 137, 128, 
+155, 182, 193,  88, 232,  35, 101, 175, 234,  37, 111, 177, 200,  67, 197,  84, 
+252,  31,  33,  99, 165, 244,   7,   9,  27,  45, 119, 153, 176, 203,  70, 202, 
+ 69, 207,  74, 222, 121, 139, 134, 145, 168, 227,  62,  66, 198,  81, 243,  14, 
+ 18,  54,  90, 238,  41, 123, 141, 140, 143, 138, 133, 148, 167, 242,  13,  23, 
+ 57,  75, 221, 124, 132, 151, 162, 253,  28,  36, 108, 180, 199,  82, 246,   1
+]
+
+S = [
+ 99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118, 
+202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 
+183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 216,  49,  21, 
+  4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117, 
+  9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,  47, 132, 
+ 83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,  57,  74,  76,  88, 207, 
+208, 239, 170, 251,  67,  77,  51, 133,  69, 249,   2, 127,  80,  60, 159, 168, 
+ 81, 163,  64, 143, 146, 157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 
+205,  12,  19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25, 115, 
+ 96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20, 222,  94,  11, 219, 
+224,  50,  58,  10,  73,   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121, 
+231, 200,  55, 109, 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 
+186, 120,  37,  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138, 
+112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158, 
+225, 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223, 
+140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,  22
+]
+
+Si = [
+ 82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129, 243, 215, 251, 
+124, 227,  57, 130, 155,  47, 255, 135,  52, 142,  67,  68, 196, 222, 233, 203, 
+ 84, 123, 148,  50, 166, 194,  35,  61, 238,  76, 149,  11,  66, 250, 195,  78, 
+  8,  46, 161, 102,  40, 217,  36, 178, 118,  91, 162,  73, 109, 139, 209,  37, 
+114, 248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 204,  93, 101, 182, 146, 
+108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  70,  87, 167, 141, 157, 132, 
+144, 216, 171,   0, 140, 188, 211,  10, 247, 228,  88,   5, 184, 179,  69,   6, 
+208,  44,  30, 143, 202,  63,  15,   2, 193, 175, 189,   3,   1,  19, 138, 107, 
+ 58, 145,  17,  65,  79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 
+150, 172, 116,  34, 231, 173,  53, 133, 226, 249,  55, 232,  28, 117, 223, 110, 
+ 71, 241,  26, 113,  29,  41, 197, 137, 111, 183,  98,  14, 170,  24, 190,  27, 
+252,  86,  62,  75, 198, 210, 121,  32, 154, 219, 192, 254, 120, 205,  90, 244, 
+ 31, 221, 168,  51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95, 
+ 96,  81, 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147, 201, 156, 239, 
+160, 224,  59,  77, 174,  42, 245, 176, 200, 235, 187,  60, 131,  83, 153,  97, 
+ 23,  43,   4, 126, 186, 119, 214,  38, 225, 105,  20,  99,  85,  33,  12, 125, 
+]
+
+IG = [
+[0x0e, 0x09, 0x0d, 0x0b], 
+[0x0b, 0x0e, 0x09, 0x0d], 
+[0x0d, 0x0b, 0x0e, 0x09], 
+[0x09, 0x0d, 0x0b, 0x0e] 
+]
+
+Rcon = [ 
+  0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 
+  0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 
+  0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 
+  0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 
+  0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91
+]
+
+Shifts = [
+  [
+     [0, 0],
+     [1, 3],
+     [2, 2],
+     [3, 1]
+  ], [  
+     [0, 0],
+     [1, 5],
+     [2, 4],
+     [3, 3]
+  ], [
+     [0, 0],
+     [1, 7],
+     [3, 5],
+     [4, 4]
+  ]
+]
+
+end
+end