flatulent 0.0.3 → 0.0.4

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

@@ -1,140 +0,0 @@
-# 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

@@ -1,193 +0,0 @@
-# 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

@@ -1,94 +0,0 @@
-# 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/rails/lib/flatulent/crypt/purerubystringio.rb

@@ -1,378 +0,0 @@
-# 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