ciphr 0.0.1

data/lib/ciphr/functions/bitwise.rb

@@ -0,0 +1,80 @@
+module Ciphr::Functions::Bitwise
+	class BinaryTruncBitwise < Ciphr::Functions::Function
+	  def apply
+	    input,keyinput = @args
+	    Proc.new do
+	      keychunk = keyinput.read(256)
+	      inchunk = input.read(256)
+	      if inchunk && keychunk
+	        a,b=[inchunk,keychunk].sort_by{|x| x.size}
+	        a.bytes.each_with_index.map{|c,i|c.send(@options[:op], b.bytes.to_a[i%b.size])}.pack("c*")
+	      else
+	        nil
+	      end
+	    end
+	  end
+
+	  def self.variants
+	    [
+	      ['and-trunc', {:op=>:&}],
+	      ['or-trunc', {:op=>:|}],
+	      [['xor-trunc'], {:op=>:'^'}]
+	    ]
+	  end
+
+	  def self.params
+	    [:input, :input]
+	  end
+	end
+
+	class BinaryBitwise < Ciphr::Functions::Function
+	  def apply
+	    input,keyinput = @args
+            keyb, inputb = [keyinput.read.bytes.to_a, input.read.bytes.to_a].sort_by{|a| a.size }
+	    Proc.new do
+	      if inputb
+	        resb = inputb.each_with_index.map{|c,i|c.send(@options[:op], keyb[i%keyb.size])}
+                res = resb.pack("c*")
+                inputb = nil
+                res
+	      else
+	        nil
+	      end
+	    end
+	  end
+
+	  def self.variants
+	    [
+	      ['and', {:op=>:&}],
+	      ['or', {:op=>:|}],
+	      [['xor'], {:op=>:'^'}]
+	    ]
+	  end
+
+	  def self.params
+	    [:input, :input]
+	  end
+	end
+
+	class UnaryBitwise < Ciphr::Functions::Function
+	  def apply
+	    input = @args[0]
+	    Proc.new do
+	      inchunk = input.read(1)
+	      if inchunk
+	        inchunk.bytes.map{|b| b = ~b }.pack("c*")
+	      else
+	        nil
+	      end
+	    end
+	  end
+
+	  def self.variants
+	    [ ['not', {}] ]
+	  end
+
+	  def self.params
+	    [:input]
+	  end
+	end
+end

data/lib/ciphr/functions/crypto.rb

@@ -0,0 +1,44 @@
+module Ciphr::Functions::Crypto
+  class RC4Cipher < Ciphr::Functions::InvertibleFunction
+    def apply
+      input, key = @args
+      keybytes = key.read.unpack('c*')
+      s = (0..255).to_a
+      j = 0
+      (0..255).each do |i|
+        j = (j + s[i] + keybytes[i % keybytes.size]) % 256
+        swp = s[i]
+        s[i] = s[j]
+        s[j] = swp
+      end
+      i = 0
+      j = 0
+
+      $stderr.puts("key: #{keybytes.inspect}")  
+
+      Proc.new do
+        byte = input.read(1)
+        if byte
+          i = (i + 1) % 256
+          j = (j + s[i]) % 256
+          swp = s[i]
+          s[i] = s[j]
+          s[j] = swp
+          k = s[(s[i] + s[j]) % 256]
+          m = [(byte.unpack('c*')[0] ^ k)].pack('c*') 
+          m
+        else
+          nil
+        end
+      end
+    end
+
+    def self.variants
+      [[['rc4-ruby'],{}]]
+    end
+
+    def self.params 
+      [:input, :key]
+    end
+  end
+end

data/lib/ciphr/functions/openssl.rb

@@ -0,0 +1,104 @@
+require 'openssl'
+
+module Ciphr::Functions::OpenSSL
+  OPENSSL_DIGESTS = %w(md4 md5 sha sha1 sha224 sha256 sha384 sha512) # no md2
+  #TODO: fail/ignore gracefully with error/warning if openssl unavailable
+
+  class OpenSslDigest < Ciphr::Functions::Function
+    def self.variants
+      OPENSSL_DIGESTS.map{|d| [d, {:variant => d}]}
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      input = args[0]
+      digester = OpenSSL::Digest.new(@options[:variant])
+      while chunk = input.read(256)
+        digester.update(chunk)
+      end
+      digest = digester.digest
+      Proc.new do
+        d = digest
+        digest = nil
+        d
+      end
+    end
+  end
+
+  class OpenSslHmac < OpenSslDigest
+    def self.variants
+      OPENSSL_DIGESTS.map{|d| [["hmac-#{d}", "hmac#{d}"], {:variant => d}]}        
+    end
+
+    def self.params 
+      [:input, :key]
+    end
+
+    # reuse code from Digest.apply
+    def apply
+      input, key = @args
+      digester = OpenSSL::HMAC.new(key.read, @options[:variant])
+      while chunk = input.read(256)
+        digester.update(chunk)
+      end
+      digest = digester.digest
+      Proc.new do
+        d = digest
+        digest = nil
+        d
+      end
+    end
+  end
+
+
+
+  class OpenSslCipher < Ciphr::Functions::InvertibleFunction
+    def apply
+      input, key = @args
+      cipher = OpenSSL::Cipher.new(@options[:variant])
+      cipher.send(invert ? :decrypt : :encrypt)
+      cipher.key = key.read
+      random_iv = cipher.random_iv
+      if random_iv.size > 0
+        cipher.iv = invert ? input.read(random_iv.size) : random_iv
+      end
+      Proc.new do
+        if ! invert && random_iv
+          begin
+            random_iv
+          ensure
+            random_iv = nil
+          end
+        else
+          chunk = input.read(256)
+          if cipher
+            if chunk
+              cipher.update(chunk)
+            else
+              begin
+                cipher.final
+              ensure
+                cipher = nil
+              end
+            end
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def self.variants
+      OpenSSL::Cipher.ciphers.map{|c| c.downcase}.uniq.map do |c|
+        [[c, c.gsub(/-/, "")], {:variant => c}]
+      end
+    end
+
+    def self.params 
+      [:input, :key]
+    end
+  end
+end

data/lib/ciphr/functions/reader.rb

@@ -0,0 +1,44 @@
+# strictly used by parser classes for literals/wiring
+# TODO: disable registration
+
+module Ciphr::Functions::Reader
+  class StringReader < Ciphr::Functions::Function
+    def apply
+      StringProc.new(options[:string])
+    end
+
+    class StringProc #extend Proc?
+      def initialize(str)
+        @str = str
+      end
+
+      def call
+        begin
+          @str
+        ensure
+          @str = nil
+        end
+      end
+    end      
+  end
+
+  class FileReader < Ciphr::Functions::Function
+    def apply
+      f = File.open(options[:file], "r")
+      Proc.new do
+        chunk = f.read(256)
+        f.close if ! chunk
+        chunk
+      end
+    end
+  end
+
+  class IoReader < Ciphr::Functions::Function
+    def apply
+      input = args[0]
+      Proc.new do
+        input.read(256)
+      end
+    end
+  end    
+end

data/lib/ciphr/functions/simple.rb

@@ -0,0 +1,121 @@
+module Ciphr::Functions::Simple
+  class Cat < Ciphr::Functions::Function
+    def self.variants
+      [[['cat','catenate'], {}]]
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      inputs = @args
+      i = 0
+      chunk = nil
+      Proc.new do
+        chunk = inputs[i].read(256)
+        if ! chunk
+          i += 1
+          chunk = inputs[i] && inputs[i].read(256)
+        end
+        #while !(chunk = inputs[i].read(256)) && i < inputs.size
+        #  i++
+        #end 
+        chunk
+      end
+    end
+  end 
+
+  class Repack < Ciphr::Functions::Function
+    def apply
+      input, ch1in, ch2in = @args
+      content, ch1, ch2 = [input.read, ch1in.read, ch2in.read]
+      Proc.new do
+        if content
+          begin
+            content.unpack(ch1).pack(ch2)
+          ensure
+            content = nil
+          end
+        else
+          nil
+        end
+      end
+    end
+
+    def self.variants
+      [ [['repack'], {}] ]
+    end
+
+    def self.params
+      [:input,:ch1,:ch2]
+    end
+  end
+
+  class Translate < Ciphr::Functions::Function
+    def apply
+      input, ch1in, ch2in = @args
+      ch1, ch2 = [ch1in.read, ch2in.read]
+      Proc.new do
+        inchunk = input.read(1)
+        if inchunk
+          inchunk.tr(ch1, ch2)
+        else
+          nil
+        end
+      end
+    end
+
+    def self.variants
+      [ [['tr','translate'], {}] ]
+    end
+
+    def self.params
+      [:input,:ch1,:ch2]
+    end
+  end
+
+  class Replace < Ciphr::Functions::Function
+    def apply
+      input, searchin, replacein = @args
+      search, replace = [searchin.read, replacein.read]
+      buf = ""
+      Proc.new do
+        if buf.size == search.size && search.size > 0
+          buf = ""
+          replace
+        else
+          inchunk = input.read(1)
+          if inchunk 
+            if inchunk == search[buf.size]
+              buf += inchunk
+              ""
+            else
+              buf += inchunk
+              input.prepend(buf[1,buf.size])
+              ret = buf[0]
+              buf = ""
+              ret
+            end
+          else
+            if buf.size > 0
+              ret = buf
+              buf = ""
+              ret
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    def self.variants
+      [ [['repl','replace'], {}] ]
+    end
+
+    def self.params
+      [:input,:search,:replace]
+    end
+  end
+end

data/lib/ciphr/functions/url.rb

@@ -0,0 +1,38 @@
+require 'cgi'
+
+module Ciphr::Functions::URL
+  #TODO: differentiate between URL and CGI encoding (with '+' char)
+  class UrlEncoding < Ciphr::Functions::InvertibleFunction
+    def apply
+      input = @args[0]
+      if !invert
+        Proc.new do
+          chunk = input.read(1)
+          chunk && CGI.escape(chunk)
+        end
+      else
+        Proc.new do
+          chunk = input.read(1)
+          if (chunk == "%")
+            chunk += input.read(2)
+            chunk && CGI.unescape(chunk)
+          elsif chunk == '+'
+            ' '
+          else
+            chunk
+          end
+        end
+      end
+    end
+
+    def self.variants
+      [
+        [['url','uri','cgi'],{}]
+      ]
+    end
+
+    def self.params 
+      [:input]
+    end      
+  end
+end

data/lib/ciphr/functions/zlib.rb

@@ -0,0 +1,94 @@
+require 'zlib'
+
+module Ciphr::Functions::ZLib
+  class Deflate < Ciphr::Functions::InvertibleFunction
+    def apply
+      input = @args[0]
+      zstream = invert ? Zlib::Inflate.new : Zlib::Deflate.new
+      Proc.new do
+        chunk = input.read(256)
+        if chunk
+          if invert
+            zstream.inflate(chunk)
+          else
+            zstream.deflate(chunk,Zlib::SYNC_FLUSH)
+          end
+        else
+          begin
+            #zstream.finish if invert
+          ensure
+            zstream.close
+          end
+        end
+      end
+    end
+
+    def self.variants
+      [
+        [['deflate'], {}]
+      ]
+    end
+
+    def self.params 
+      [:input]
+    end
+  end
+
+
+  class Gzip < Ciphr::Functions::InvertibleFunction
+    class UncloseableIOProxy # hack to prevent GzipWriter from closing StringIO
+      def initialize(delegate)
+        @delegate = delegate
+      end
+      
+      def method_missing(meth, *args, &block)
+        if meth.to_s != "close"
+          @delegate.send(meth, *args, &block)
+        else
+          nil
+        end
+      end
+    end
+    
+    def apply
+      input = @args[0]
+      sio = StringIO.new
+      gz = !invert ? Zlib::GzipWriter.new(UncloseableIOProxy.new(sio)) : Zlib::GzipReader.new(input) 
+      Proc.new do
+        if invert # unzip
+          gz.read(256)
+        else # zip
+          chunk = input.read(256)
+          if chunk
+            gz.write chunk 
+            sio.rewind
+            ret = sio.read
+            sio.rewind
+            sio.truncate(0)
+            ret
+          elsif gz
+            gz.close
+            gz = nil
+            sio.rewind
+            ret = sio.read
+            sio.rewind
+            sio.truncate(0)
+            ret
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def self.variants
+      [
+        [['gzip','gz'], {}]
+      ]
+    end
+
+    def self.params 
+      [:input]
+    end
+  end
+end