ciphr 0.0.1

data/bin/ciphr

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'ciphr'
+require 'slop'
+
+Slop.parse do
+  banner "Usage: #{File.basename $0} [options] [spec]"
+  on :h, :help
+  on :v, :verbose
+  on :n, :'no-newline'
+  on :N, :'newline'
+  on :x, :'xargs-mode'
+  on :'0', :null
+
+  run do |opts, args|
+    Ciphr::FunctionRegistry.global.setup
+    if opts[:help] || args.size == 0
+        puts opts
+        if opts[:verbose]
+            puts "Available Functions: aliases ([args])"
+            Ciphr::FunctionRegistry.global.functions.flat_map{|c,vs| vs.map{|v| [c,v] }}.each{|a|
+                c,v = a
+                puts "  #{v[0].map{|v|v.to_s}.join(", ")} (#{c.params.map{|p| p.to_s}.join(", ")})"
+            }
+        end
+    else
+      newline = opts[:newline] || opts[:'xargs-mode'] || STDOUT.tty? && ! opts[:'no-newline']
+      spec = args.join(" ")
+      begin
+        parsed = Ciphr::Parser.new.parse(spec)
+        if opts[:'xargs-mode']
+          delim = opts['null'] ? "\x00" : "\n"
+          $stdin.each_line(delim) do |line|
+            transformed = Ciphr::Transformer.new(StringIO.new(line.tr(delim,''))).apply(parsed)
+            $stdout.print transformed.read
+            puts if newline
+          end
+        else 
+          transformed = Ciphr::Transformer.new($stdin).apply(parsed)
+          while (chunk = transformed.read(256)) && ! $stdout.closed?
+            begin
+              $stdout.print(chunk)
+            rescue Errno::EPIPE 
+              break
+            end
+          end
+          puts if newline 
+        end
+      rescue Parslet::ParseFailed => e
+        $stderr.puts e.cause
+        $stderr.puts spec
+        $stderr.puts " " * (e.cause.pos) + "^"
+      rescue Ciphr::FunctionRegistry::InvalidFunctionError => e
+        $stderr.puts "invalid function '#{e.name}'"
+      end
+    end
+  end
+end
+
+
+
+

data/ciphr.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ciphr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ciphr"
+  spec.version       = Ciphr::VERSION
+  spec.authors       = ["Chris Frohoff"]
+  spec.email         = ["chris@frohoff.org"]
+  spec.description   = "" 
+  spec.summary       = "gem for composing (en|de)coding, digest, cipher operations" 
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = Dir['**/*'] 
+  spec.executables   << 'ciphr' 
+  spec.test_files    =  Dir['test/**/*', 'spec/**/*'] 
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.5.0"
+  spec.add_development_dependency "rspec", "~> 3.4.0"
+  #spec.add_development_dependency 'coveralls'
+  #spec.add_development_dependency 'codeclimate-test-reporter'
+
+  spec.add_dependency "parslet", "~> 1.5.0"
+  spec.add_dependency "slop", "~> 3.6.0"
+  spec.add_dependency "base32", "~> 0.3.2"
+  #spec.add_dependency "base32-crockford"
+  #spec.add_dependency "zbase32"
+end

data/lib/ciphr.rb

@@ -0,0 +1,35 @@
+require "ciphr/version"
+require "ciphr/functions"
+require "ciphr/stream"
+require "ciphr/parser"
+
+module Ciphr
+	@@init = false
+
+	def self.init()
+		@@init = true
+		Ciphr::FunctionRegistry.global.setup
+	end 
+
+	def self.transform(spec, input = STDIN, output = STDOUT)
+		init if !@@init
+		if input.is_a? String
+			input = StringIO.new(input)
+			input.close_write
+			output = StringIO.new()
+		end
+
+        parsed = Ciphr::Parser.new.parse(spec)
+        transformed = Ciphr::Transformer.new(input).apply(parsed)
+     
+        while chunk = transformed.read(256)
+          output.write chunk
+        end	
+
+        if output.is_a? StringIO
+        	output.string
+        else
+        	nil
+        end
+	end	
+end

data/lib/ciphr/function_registry.rb

@@ -0,0 +1,47 @@
+module Ciphr
+  class FunctionRegistry
+    def initialize() 
+      @function_classes = []
+      @functions = []
+      @function_aliases = {}
+    end
+
+    def register(klass)
+      @function_classes << klass
+    end
+
+    def setup(classes=@function_classes)
+      @functions = classes.map{|c| [c,c.variants]}.select{|a| a[1] && a[1].size > 0}.map{|a| 
+                        [a[0], a[1].map{|v| [[v[0]].flatten.uniq, v[1]]}]}
+      @function_aliases = Hash[@functions.map{|c,vs| vs.map{|v| [v[0]].flatten.map{|n| [n,[c, v[1]]]}}.flatten(1)}.flatten(1)]
+    end
+
+    def function_aliases
+      @function_aliases
+    end
+
+    def [](name)
+      @function_aliases[name] || (raise InvalidFunctionError.new(name))
+    end
+
+    def functions
+      @functions
+    end
+
+    # http://stackoverflow.com/questions/746207/ruby-design-pattern-how-to-make-an-extensible-factory-class
+    # global instance for load-time registration
+    
+    @@global = FunctionRegistry.new()
+
+    def self.global
+      @@global
+    end
+
+    class InvalidFunctionError < StandardError
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+    end  
+  end
+end

data/lib/ciphr/functions.rb

@@ -0,0 +1,62 @@
+
+#require 'base32/crockford'
+#require 'zbase32'
+require_relative 'function_registry'
+
+module Ciphr::Functions
+  class Function
+    def initialize(options, args)
+      @options = options
+      @args = args
+      @stream = Ciphr::Stream.new(self)
+    end
+    attr_accessor :options, :args #don't like that these are both writable, but c'est la vie
+
+    def self.variants
+      []
+    end
+
+    def self.inherited(subclass)
+      Ciphr::FunctionRegistry.global.register(subclass)
+    end
+
+    def self.params
+      []
+    end
+
+    def self.invertable?
+      false
+    end
+    
+    def self.aligned
+      nil
+    end
+
+    def read(*args)
+      @stream.read(*args)
+    end
+
+    def prepend(*args)
+      @stream.prepend(*args)
+    end
+  end
+
+  class InvertibleFunction < Function
+    @invert = false
+    attr_accessor :invert   
+    
+    def self.invertable?
+      true
+    end 
+  end
+end
+
+require_relative 'functions/openssl'
+require_relative 'functions/base_radix'
+require_relative 'functions/zlib'
+require_relative 'functions/bitwise'
+require_relative 'functions/reader'
+require_relative 'functions/url'
+require_relative 'functions/simple'
+require_relative 'functions/crypto'
+

data/lib/ciphr/functions/base_radix.rb

@@ -0,0 +1,205 @@
+require 'base64'
+require 'base32'
+
+module Ciphr::Functions::Base
+  class Base < Ciphr::Functions::InvertibleFunction
+    def self.aligned
+      :left
+    end      
+  end
+
+  class Base2 < Base
+    def self.variants
+      [[['b2','base2', 'bin','binary'], {}]]
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      input = @args[0]
+      if !invert              
+        Proc.new do
+          chunk = input.read(1)
+          chunk && chunk.unpack("B*")[0]
+        end
+      else
+        Proc.new do
+          chunk = input.read(8)
+          chunk && [chunk].pack("B*")
+        end
+      end
+    end
+  end
+
+  class Base8 < Base
+    def self.variants
+      [[['b8','base8','oct','octal'], {}]]
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      input = @args[0]
+      if !invert              
+        Proc.new do
+          chunk = input.read(3)
+          chunk = chunk && chunk + "\x00"*(3-chunk.size) #pad
+          chunk && chunk.unpack("B*")[0].bytes.to_a.each_slice(3).to_a.map{|a|a.pack("c*").to_i(2).to_s(8)}.join
+        end
+      else
+        Proc.new do
+          chunk = input.read(8)
+          chunk = chunk && chunk + "0"*(8-chunk.size) #pad
+          chunk && chunk.unpack("aaaaaaaa").map{|o| o.to_i.to_s(2).rjust(3,"0")}.join.unpack("a8a8a8").map{|b| b.to_i(2)}.pack("C*")
+        end
+      end
+    end
+  end
+
+  class Base16 < Base
+    def self.variants
+      [[['b16','base16','hex','hexidecimal'], {}]]
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      input = @args[0]
+      if !invert              
+        Proc.new do
+          chunk = input.read(1)
+          chunk && chunk.unpack("H*")[0]
+        end
+      else
+        Proc.new do
+          chunk = input.read(2)
+          chunk && [chunk].pack("H*")
+        end
+      end
+    end
+  end
+
+
+  class Base32 < Base
+    def self.variants
+      [
+        [['b32','base32','b32-std','base32-std'], {:object => ::Base32 }]#, 
+        #broken
+        #[['b32-crockford','base32-crockford'], {:object => ::Base32::Crockford }],
+        #[['b32-z','base32-z'], {:object => ZBase32.new }]
+      ]
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      input = @args[0]
+      if !invert              
+        Proc.new do
+          chunk = input.read(5)
+          chunk && options[:object].encode(chunk)
+        end
+      else
+        Proc.new do
+          chunk = input.read(8)
+          chunk && options[:object].decode(chunk)
+        end
+      end
+    end
+  end
+
+  class Base64 < Base
+    def self.aligned
+      nil # preserves alignment
+    end      
+    
+    def apply    
+      input = @args[0]
+      if !invert
+        Proc.new do
+          chunk = input.read(3)
+          chunk && ::Base64.encode64(chunk).gsub(/\s/,'').tr("+/", options[:chars][0,2]).tr("=", options[:chars][2,3])
+        end
+      else
+        Proc.new do
+          chunk = input.read(4)
+          chunk = chunk && chunk + "="*(4-chunk.size) #pad
+          chunk && ::Base64.decode64(chunk.tr(options[:chars][0,2],"+/").tr(options[:chars][2,3],"=").ljust(4,"="))
+        end
+      end
+    end
+
+    def self.variants
+      chars = {"+"=>"p", "-"=>"h", "_"=>"u", ":"=>"c", "/"=>"s", "." => "d", "!"=>"x", "="=>"q"}
+      types = {"+/=" => ["std"], "+/" => "utf7", "+-" => "file", "-_" => "url", "._-" => "yui", 
+               ".-" => "xml-name", "_:" => "xml-id", "_-" => "prog-id-1", "._" => "prog-id-2", "!-" => "regex"}
+      variants = types.map{|c,n| [["b64","base64"].product([c.chars.map{|c| chars[c] }.join,n]).map{|a| a.join("-")}, {:chars => c}]}
+      std = variants.select{|v| v[0].include? "b64-std"}[0] #add short aliases for standard
+      std[0] = ["b64","base64"].concat(std[0])
+      variants
+    end
+
+    def self.params 
+      [:input]
+    end
+  end    
+
+end
+
+module Ciphr::Functions::Radix
+
+
+  class Radix < Ciphr::Functions::InvertibleFunction
+    def self.aligned
+      :right
+    end
+    
+    def self.variants
+      (2..36).map{|r| [["r#{r}","rad#{r}","radix#{r}"], {:radix => r}]}
+    end
+
+    def self.params
+      [:input]
+    end
+
+    def apply
+      radix = options[:radix]
+      input = @args[0]
+      if !invert     
+        num = 0      
+        while chunk = input.read(1)
+          num = (num << 8) + chunk.bytes.to_a[0]
+        end
+        Proc.new do
+          begin
+            num && num.to_s(radix)
+          ensure
+            num = nil
+          end
+        end
+      else
+        num = input.read().to_i(radix)
+        bytes = []
+        while num > 0
+          bytes.unshift(num & 0xff)
+          num = num >> 8
+        end
+        Proc.new do
+          begin
+            bytes && bytes.pack("c*")
+          ensure
+            bytes = nil
+          end
+        end
+      end
+    end
+  end  
+end