ciphr 0.0.2 → 0.0.4

data/lib/ciphr/functions/bitwise.rb

@@ -1,80 +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
+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

@@ -1,44 +1,42 @@
-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
+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
+
+      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

@@ -1,104 +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
+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