ciphr 0.0.1

data/lib/ciphr/parser.rb

@@ -0,0 +1,77 @@
+require 'parslet'
+
+class Ciphr::Parser < Parslet::Parser
+    def pad(&p)
+        spaces? >> p.call >> spaces?
+    end
+
+    def wrapstr(d)
+        str(d) >> ( str('\\') >> any | str(d).absent? >> any ).repeat.maybe.as(:string) >> str(d)
+    end
+
+    def wrapbraces(bs,&p)
+        exp = str('')
+        bs.each{|b|
+            exp = ( str(b[0]) >> p.call >> str(b[1]) ) | exp
+        }
+        exp
+    end
+
+    rule(:spaces)      { match('\s').repeat(1) }
+    rule(:spaces?)     { spaces.maybe }
+    rule(:name) { (match('[a-z]') >> match('[a-z0-9\-_]').repeat).as(:name) }
+    rule(:literal) { pad { b2 | b8 | b10 | b16 | b64 | string | file } } 
+    rule(:file) { str('@') >> spaces? >> ( string | match('[^ ()\[\]{},|]' ).repeat ).as(:file) }
+    rule(:string) { wrapstr("'") | wrapstr('"') }
+    rule(:b2) { str('0b') >> match('[0-1]').repeat(1).as(:b2) }
+    rule(:b8) { ( match('0').repeat(1) >> match('o').maybe >> match('[0-7]').repeat(1).as(:b8) ) }
+    rule(:b10) { ( match('[1-9]') >> match('[0-9]').repeat ).as(:b10) }
+    rule(:b16) { str('0x') >> match('[0-9a-fA-F]').repeat(1).as(:b16) }
+    rule(:b64) { str('=') >> match('[0-9a-zA-Z+/=]').repeat(1).as(:b64) }
+    rule(:call) { pad { match('[~!^]').maybe.as(:invert) } >> pad { name.as(:name) } >> pad { wrapbraces(['()','[]','{}']) { pad { (expression >> (str(',') >> expression).repeat).maybe.as(:arguments) } }.maybe } }
+    rule(:expression) { ( ( call | literal ) >> ( str('|') | str(' ').repeat >> ( call | literal ) ).repeat ).as(:operations) }
+    root :expression
+end
+
+class Ciphr::Transformer < Parslet::Transform
+    def initialize(input)
+        super()
+        @input = input
+
+        #in ctor to provide instance scope to rule blocks
+        rule(:name => simple(:v)) { v } 
+        rule(:file => simple(:v)) {|d| Ciphr::Functions::Reader::FileReader.new({:file => d[:v].to_s}, [])}
+        #eagerly eval these?
+        #trim to nearest byte vs chunk?
+        rule(:string => simple(:v)) {|d| Ciphr::Functions::Reader::StringReader.new({:string => d[:v]},[]) }
+        rule(:b2 => simple(:v)) {|d| Ciphr::Functions::Base::Base2.new({:radix => 2}, [Ciphr::Functions::Reader::StringReader.new({:string => lpad(d[:v].to_s,8,"0")},[])]).tap{|f| f.invert = true} }
+        rule(:b8 => simple(:v)) {|d| Ciphr::Functions::Base::Base8.new({:radix => 8}, [Ciphr::Functions::Reader::StringReader.new({:string => lpad(d[:v].to_s,8,"0")},[])]).tap{|f| f.invert = true} }
+        rule(:b10 => simple(:v)) {|d| Ciphr::Functions::Radix::Radix.new({:radix => 10}, [Ciphr::Functions::Reader::StringReader.new({:string => d[:v].to_s},[])]).tap{|f| f.invert = true} }
+        rule(:b16 => simple(:v)) {|d| Ciphr::Functions::Base::Base16.new({:radix => 16}, [Ciphr::Functions::Reader::StringReader.new({:string => lpad(d[:v].to_s,2,"0")},[])]).tap{|f| f.invert = true} }
+        rule(:b64 => simple(:v)) {|d| Ciphr::Functions::Base::Base64.new({:chars => "+/="}, [Ciphr::Functions::Reader::StringReader.new({:string => d[:v]},[])]).tap{|f| f.invert = true} }
+        rule(:arguments => sequence(:arguments), :invert => simple(:invert), :name => simple(:name)) {|d| transform_call(d) }
+        rule(:arguments => simple(:arguments), :invert => simple(:invert), :name => simple(:name)) {|d| transform_call(d) }
+        rule(:invert => simple(:invert), :name => simple(:name)) {|d| transform_call(d) }
+        rule(:operations => simple(:operations)) {|d| transform_operations(d)}
+        rule(:operations => sequence(:operations)) {|d| transform_operations(d)}    
+    end
+
+    def lpad(s,n,p)
+        s.size % n == 0 ? s : p * (n - s.size % n) + s
+    end
+
+    def transform_operations(d)
+        operations = [d[:operations]].flatten
+        if operations[0].args.size < operations[0].class.params.size
+            operations.unshift(Ciphr::Functions::Reader::IoReader.new({},[@input]))
+        end
+        operations.inject{|m,f| f.args = [f.args||[]].flatten.unshift(m); f }
+    end
+
+    def transform_call(d)
+        klass, options = Ciphr::FunctionRegistry.global[d[:name].to_s]
+        f = klass.new(options, [d[:arguments]||[]].flatten)
+        f.invert = true if d[:invert]
+        f
+    end
+end

data/lib/ciphr/stream.rb

@@ -0,0 +1,49 @@
+module Ciphr
+  class Stream
+    def initialize(reader)
+      @reader = reader
+      @buffer = ""
+      @eof = false
+    end
+
+    def read(n=nil) #fix this
+      if n
+        init
+        while @buffer.size < n && !@eof 
+          fill
+        end
+        if @buffer.size > 0
+          ret = @buffer[0,n]
+          @buffer = @buffer[n..-1] || ''
+        else 
+          ret = nil
+        end
+        ret
+      else
+        buff = ""
+        while chunk=read(256)
+          buff+=chunk
+        end
+        buff 
+      end
+    end
+
+    def prepend(str)
+      @buffer = str + @buffer
+    end
+
+    private
+      def fill
+        data = @reader.call
+        @eof = true if !data
+        @buffer = @buffer + data if data
+      end
+
+      def init #hack
+        if !@init
+          @init = true
+          @reader = @reader.apply if @reader.respond_to?(:apply)
+        end
+      end
+  end
+end

data/lib/ciphr/version.rb

@@ -0,0 +1,3 @@
+module Ciphr
+  VERSION = "0.0.1"
+end

data/spec/ciphr_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr do
+  describe :transform do
+    it "works for some simple test cases" do
+        Ciphr.transform("md5 hex","").should be == "d41d8cd98f00b204e9800998ecf8427e"
+        Ciphr.transform("b64 ~b64","foobar").should be == "foobar"
+        Ciphr.transform("b2 b16 ~b16 ~b2","foobar").should be == "foobar"
+        Ciphr.transform('"foobar"',"").should be == "foobar"
+        Ciphr.transform('=ABBB b64',"").should be == "ABBB"        
+        Ciphr.transform('0x41',"").should be == "A"
+        Ciphr.transform('0b01000001',"").should be == "A"
+        Ciphr.transform('0x43 xor[0x01]',"").should be == "B"
+        Ciphr.transform('0x4343 xor[0x01]',"").should be == "BB"
+        Ciphr.transform('0x01 xor[0x4343]',"").should be == "BB"
+        Ciphr.transform('0x00 url', "").should be == '%00'
+        Ciphr.transform('"foo" cat', "").should be == 'foo'
+    end
+  end
+end

data/spec/functions_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr::FunctionRegistry do
+  describe :setup do
+    it "sets up the specified functions" do
+        Ciphr::FunctionRegistry.global.setup([Ciphr::Functions::Base::Base2, Ciphr::Functions::Simple::Cat])
+        Ciphr::FunctionRegistry.global.functions.should == 
+            [
+                [Ciphr::Functions::Base::Base2, [[["b2", "base2", "bin", "binary"], {}]]], 
+                [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]]
+            ]
+        Ciphr::FunctionRegistry.global.function_aliases.should == 
+            {
+                "b2"=>[Ciphr::Functions::Base::Base2, {}], 
+                "base2"=>[Ciphr::Functions::Base::Base2, {}], 
+                "bin"=>[Ciphr::Functions::Base::Base2, {}], 
+                "binary"=>[Ciphr::Functions::Base::Base2, {}],                 
+                "cat"=>[Ciphr::Functions::Simple::Cat, {}], 
+                "catenate"=>[Ciphr::Functions::Simple::Cat, {}]
+            }
+    end
+    it "sets up the automatically registered functions" do
+        Ciphr::FunctionRegistry.global.setup
+        Ciphr::FunctionRegistry.global.functions.should include(
+            [Ciphr::Functions::Base::Base2, [[["b2", "base2","bin","binary"], {}]]])
+        Ciphr::FunctionRegistry.global.functions.should include( 
+            [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]])
+    end
+  end
+end

data/spec/randomizer_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'ciphr'
+
+# considerations:
+# invertable
+# deterministic
+# padded
+# zero-input
+
+describe Ciphr::Functions do
+  r = Random.new(0) #deterministic
+  tests = [""] + (1..50).map do |i|
+    mag = r.rand(4)+1
+    len = r.rand(10**mag)
+    #len = (0.00001*r.rand(100000)**1.7).floor
+    #$stderr.puts len
+    r.bytes(len)
+  end
+
+  # temporarily disable randomization
+  tests = [""," ", "\x00", "\x00 A"]
+  
+  Ciphr::FunctionRegistry.global.setup
+  #TODO: run shorter/smaller tests first
+  
+  #TODO: decompose property tests into small, composable tests
+  functions = Ciphr::FunctionRegistry.global.functions
+  functions.find_all{|f| f[0].params.size == 1}.each do |f|
+    f[1].each do |v|
+      tests.each do |t|
+        it "#{v[0][0]} #{t.inspect}" do
+          result = Ciphr.transform(v[0][0],t)
+          if f[0] != Ciphr::Functions::Simple::Cat && t != ""
+            expect(result).not_to eq(t)
+          end
+          if f[0].invertable? && t != ""
+            inv = Ciphr.transform("~" + v[0][0],result)
+            #FIXME: need to enforce consistent encoding
+            inv,t = [inv,t].map{|s| s.force_encoding('binary')}
+            case f[0].aligned # FIXME: this is horrible
+            when :left
+              expect(inv).to start_with(t)
+            when :right
+              expect(t).to end_with(inv) # FIXME: horribly backwards
+            else
+              expect(inv).to eq(t)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+#require 'coveralls'
+#require "codeclimate-test-reporter"
+#Coveralls.wear!
+#CodeClimate::TestReporter.start

data/spec/stream_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr::Stream do
+  describe :read do
+    it "returns nil after proc does" do
+      s = Ciphr::Stream.new Proc.new { nil }
+      s.read(1).should be == nil
+    end
+
+    it "buffers and returns data as requested" do
+      fills = ["abc", "def", "ghi"]
+      s = Ciphr::Stream.new Proc.new { fills.shift }
+      s.read(1).should be == "a"
+      s.read(3).should be == "bcd"
+      s.read(1).should be == "e"
+      s.read(2).should be == "fg"
+      s.read(4).should be == "hi"
+      s.read(1).should be == nil
+    end
+
+    it "can prepend data and read it back out" do
+      fills = ["abc", "def", "ghi"]
+      s = Ciphr::Stream.new Proc.new { fills.shift }
+      s.read(1).should be == "a"
+      s.read(3).should be == "bcd"
+      s.prepend("cd")
+      s.read(1).should be == "c"
+      s.read(1).should be == "d"
+      s.read(1).should be == "e"
+      s.prepend("cde")
+      s.read(3).should be == "cde"
+      s.read(2).should be == "fg"
+      s.read(4).should be == "hi"
+      s.read(1).should be == nil
+    end
+  end
+end

data/tests/commands.sh

@@ -0,0 +1,30 @@
+cat | while read line; do subline=`echo $line | sed -r "s/ciphr/bundle exec ruby -Ilib bin\/ciphr/g"`; echo '$' $line; eval "$subline"; done << EOF
+ciphr '"abc"'
+ciphr '"abc"' hex
+ciphr '"abc"' hex ~hex
+ciphr '"616263"' ~hex
+ciphr 0x616263
+ciphr 0x616263 hex
+ciphr 0b10101010 bin
+ciphr 0b10101010 hex
+ciphr 255 hex
+ciphr 65
+ciphr '""' md5 hex
+echo -n "" | ciphr md5 hex
+ciphr '"abc"' sha1 hex
+echo -n "abc" | ciphr sha1 | xxd -ps
+echo -n "abc" | ciphr 'xor["abc"] hex'
+echo -n "abc" | ciphr xor[0x01] hex
+echo -n "abc" | ciphr xor[0x01]
+echo -n "abc" | ciphr xor[0x020304]
+echo -n "abc" | ciphr 'aes128cbc["super secret key"] hex'
+echo -n "abc" | ciphr 'aes128cbc["super secret key"] hex ~hex ~aes128cbc["super secret key"]'
+ciphr @/etc/hosts
+ciphr @/etc/hosts md5 hex
+ciphr @/etc/hosts xor[0x01]
+ciphr @/etc/hosts aes-128-cbc[@/etc/hosts]
+ciphr @/etc/hosts aes-128-cbc[@/etc/hosts] hex
+ciphr @/etc/hosts aes-128-cbc[@/etc/hosts] ~aes-128-cbc[@/etc/hosts]
+ciphr @/etc/hosts aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef] hex
+ciphr @/etc/hosts aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef] ~aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef]
+EOF

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: ciphr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Frohoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+description: ''
+email:
+- chris@frohoff.org
+executables:
+- ciphr
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- bin/ciphr
+- ciphr.gemspec
+- lib/ciphr.rb
+- lib/ciphr/function_registry.rb
+- lib/ciphr/functions.rb
+- lib/ciphr/functions/base_radix.rb
+- lib/ciphr/functions/bitwise.rb
+- lib/ciphr/functions/crypto.rb
+- lib/ciphr/functions/openssl.rb
+- lib/ciphr/functions/reader.rb
+- lib/ciphr/functions/simple.rb
+- lib/ciphr/functions/url.rb
+- lib/ciphr/functions/zlib.rb
+- lib/ciphr/parser.rb
+- lib/ciphr/stream.rb
+- lib/ciphr/version.rb
+- pkg/ciphr-0.0.1.gem
+- spec/ciphr_spec.rb
+- spec/functions_spec.rb
+- spec/randomizer_spec.rb
+- spec/spec_helper.rb
+- spec/stream_spec.rb
+- tests/commands.sh
+- tests/output.r26.2.0.0.bin
+- tests/output.r26.2.1.1.bin
+- tests/output.r30.2.0.0.bin
+- tests/output.r30.2.1.1.bin
+- tests/output.r34.2.0.0.bin
+- tests/output.r34.2.1.1.bin
+- tests/testcase.r26.bin
+- tests/testcase.r30.bin
+- tests/testcase.r34.bin
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: gem for composing (en|de)coding, digest, cipher operations
+test_files:
+- spec/ciphr_spec.rb
+- spec/functions_spec.rb
+- spec/randomizer_spec.rb
+- spec/spec_helper.rb
+- spec/stream_spec.rb
+has_rdoc: