ciphr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e70f6b9ae3a9a53aa202128b800df0272bc0f9d0
+  data.tar.gz: 750425aee3a673a2f97cfc17e4a50332f45cdf43
+SHA512:
+  metadata.gz: 612d14a6513c7656311c132cb6b58a8babfd0bbc9bd81958daa4d40e9dd8adfd504df37c6e2fe919fd6f6455f9109afb1dba5d1d32503c11d3aa8ad9c8f18eca
+  data.tar.gz: 6dc7c4137ce5b4adf216f4b808f25b16825eddad0a6b3944179fed4c899680ae52d1532991ab51388ebdcf27c6f0468032a9e335e9ff061ecede2d84c5b27dcf

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ciphr.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    ciphr (0.0.1)
+      base32 (~> 0.3.2)
+      parslet (~> 1.5.0)
+      slop (~> 3.6.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base32 (0.3.2)
+    blankslate (2.1.2.4)
+    diff-lcs (1.2.5)
+    parslet (1.5.0)
+      blankslate (~> 2.0)
+    rake (10.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  ciphr!
+  rake (~> 10.5.0)
+  rspec (~> 3.4.0)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chris Frohoff
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,316 @@
+# Ciphr
+
+Ciphr is a CLI tool for performing and composing encoding, decoding, encryption,
+decryption, hashing, and other various operations on streams of data. It takes
+provided data, file data, or data from stdin, and executes a pipeline of 
+functions on the data stream, writing the resulting data to stdout. It was 
+designed primarily for use in the information security domain, mostly for quick
+or casual data manipulation for forensics, penetration testing, or 
+capture-the-flag events; it likely could have other unforseen uses, but should 
+be presumed to be an experimental toy as no effort was made to make included 
+cryptographic functions robust against attacks (timing attacks, etc), and it is 
+recommended not to use any included functions in any on-line security 
+mechanisms.
+
+## Examples
+
+```console
+$ ciphr '"abc"'
+abc
+$ ciphr '"abc"' hex
+616263
+$ ciphr '"abc"' hex ~hex
+abc
+$ ciphr '"616263"' ~hex
+abc
+$ ciphr 0x616263
+abc
+$ ciphr 0x616263 hex
+616263
+$ ciphr 0b10101010 bin
+10101010
+$ ciphr 0b10101010 hex
+aa
+$ ciphr 255 hex
+ff
+$ ciphr 65
+A
+$ ciphr '""' md5 hex
+d41d8cd98f00b204e9800998ecf8427e
+$ echo -n "" | ciphr md5 hex
+d41d8cd98f00b204e9800998ecf8427e
+$ ciphr '"abc"' sha1 hex
+a9993e364706816aba3e25717850c26c9cd0d89d
+$ echo -n "abc" | ciphr sha1 | xxd -ps
+a9993e364706816aba3e25717850c26c9cd0d89d
+$ echo -n "abc" | ciphr 'xor["abc"] hex'
+000000
+$ echo -n "abc" | ciphr xor[0x01] hex
+606362
+$ echo -n "abc" | ciphr xor[0x01]
+`cb
+$ echo -n "abc" | ciphr xor[0x020304]
+cag
+$ echo -n "abc" | ciphr 'aes128cbc["super secret key"] hex'
+1e98110410ea0aa59a31ddc462d720d07e1e01268e405ee9fba29b3f91752e0c
+$ echo -n "abc" | ciphr 'aes128cbc["super secret key"] hex ~hex ~aes128cbc["super secret key"]'
+abc
+$ ciphr @/etc/hosts
+127.0.0.1       localhost
+$ ciphr @/etc/hosts md5 hex
+8f4491642052129e98cc211b4f32d9c5
+$ ciphr @/etc/hosts xor[0x01]
+036/1/1/mnb`minru
+$ ciphr @/etc/hosts aes-128-cbc[@/etc/hosts] hex
+3033c8627781ae2152d0b25f1acd3397161d5e8462164716539502ad908163e13eec1a73ee03ba89a877ac49fd04d7a3
+$ ciphr @/etc/hosts aes-128-cbc[@/etc/hosts] ~aes-128-cbc[@/etc/hosts]
+127.0.0.1       localhost
+$ ciphr @/etc/hosts aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef] hex
+92638d3f10a303938b48bd4a108744ed4216c99b005ddc19cce752af53ef089be1e43a446fda55c4e76036f31612459f
+$ ciphr @/etc/hosts aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef] ~aes-128-cbc[0xdeadbeefdeadbeefdeadbeefdeadbeef]
+127.0.0.1       localhost
+```
+
+## Installation
+
+Must be cloned and installed until it gets into rubygems.org after being cleaned
+up
+
+Requires bundler to be installed (`gem install bundler`)
+
+```shell
+git clone https://github.com/frohoff/ciphr.git
+cd ciphr
+bundle install
+bundle exec rake install
+```
+
+## Usage
+
+```shell
+$ ciphr -v -h
+Usage: ciphr [options] [spec]
+    -h, --help
+    -v, --verbose
+    -n, --no-newline
+    -N, --newline
+    -x, --xargs-mode
+    -0, --null
+Available Functions: aliases ([args])
+  md4 (input)
+  md5 (input)
+  sha (input)
+  sha1 (input)
+  sha224 (input)
+  sha256 (input)
+  sha384 (input)
+  sha512 (input)
+  hmac-md4, hmacmd4 (input, key)
+  hmac-md5, hmacmd5 (input, key)
+  hmac-sha, hmacsha (input, key)
+  hmac-sha1, hmacsha1 (input, key)
+  hmac-sha224, hmacsha224 (input, key)
+  hmac-sha256, hmacsha256 (input, key)
+  hmac-sha384, hmacsha384 (input, key)
+  hmac-sha512, hmacsha512 (input, key)
+  aes-128-cbc, aes128cbc (input, key)
+  aes-128-cbc-hmac-sha1, aes128cbchmacsha1 (input, key)
+  aes-128-cbc-hmac-sha256, aes128cbchmacsha256 (input, key)
+  aes-128-cfb, aes128cfb (input, key)
+  aes-128-cfb1, aes128cfb1 (input, key)
+  aes-128-cfb8, aes128cfb8 (input, key)
+  aes-128-ctr, aes128ctr (input, key)
+  aes-128-ecb, aes128ecb (input, key)
+  aes-128-ofb, aes128ofb (input, key)
+  aes-128-xts, aes128xts (input, key)
+  aes-192-cbc, aes192cbc (input, key)
+  aes-192-cfb, aes192cfb (input, key)
+  aes-192-cfb1, aes192cfb1 (input, key)
+  aes-192-cfb8, aes192cfb8 (input, key)
+  aes-192-ctr, aes192ctr (input, key)
+  aes-192-ecb, aes192ecb (input, key)
+  aes-192-ofb, aes192ofb (input, key)
+  aes-256-cbc, aes256cbc (input, key)
+  aes-256-cbc-hmac-sha1, aes256cbchmacsha1 (input, key)
+  aes-256-cbc-hmac-sha256, aes256cbchmacsha256 (input, key)
+  aes-256-cfb, aes256cfb (input, key)
+  aes-256-cfb1, aes256cfb1 (input, key)
+  aes-256-cfb8, aes256cfb8 (input, key)
+  aes-256-ctr, aes256ctr (input, key)
+  aes-256-ecb, aes256ecb (input, key)
+  aes-256-ofb, aes256ofb (input, key)
+  aes-256-xts, aes256xts (input, key)
+  aes128 (input, key)
+  aes192 (input, key)
+  aes256 (input, key)
+  bf (input, key)
+  bf-cbc, bfcbc (input, key)
+  bf-cfb, bfcfb (input, key)
+  bf-ecb, bfecb (input, key)
+  bf-ofb, bfofb (input, key)
+  camellia-128-cbc, camellia128cbc (input, key)
+  camellia-128-cfb, camellia128cfb (input, key)
+  camellia-128-cfb1, camellia128cfb1 (input, key)
+  camellia-128-cfb8, camellia128cfb8 (input, key)
+  camellia-128-ecb, camellia128ecb (input, key)
+  camellia-128-ofb, camellia128ofb (input, key)
+  camellia-192-cbc, camellia192cbc (input, key)
+  camellia-192-cfb, camellia192cfb (input, key)
+  camellia-192-cfb1, camellia192cfb1 (input, key)
+  camellia-192-cfb8, camellia192cfb8 (input, key)
+  camellia-192-ecb, camellia192ecb (input, key)
+  camellia-192-ofb, camellia192ofb (input, key)
+  camellia-256-cbc, camellia256cbc (input, key)
+  camellia-256-cfb, camellia256cfb (input, key)
+  camellia-256-cfb1, camellia256cfb1 (input, key)
+  camellia-256-cfb8, camellia256cfb8 (input, key)
+  camellia-256-ecb, camellia256ecb (input, key)
+  camellia-256-ofb, camellia256ofb (input, key)
+  camellia128 (input, key)
+  camellia192 (input, key)
+  camellia256 (input, key)
+  cast (input, key)
+  cast-cbc, castcbc (input, key)
+  cast5-cbc, cast5cbc (input, key)
+  cast5-cfb, cast5cfb (input, key)
+  cast5-ecb, cast5ecb (input, key)
+  cast5-ofb, cast5ofb (input, key)
+  des (input, key)
+  des-cbc, descbc (input, key)
+  des-cfb, descfb (input, key)
+  des-cfb1, descfb1 (input, key)
+  des-cfb8, descfb8 (input, key)
+  des-ecb, desecb (input, key)
+  des-ede, desede (input, key)
+  des-ede-cbc, desedecbc (input, key)
+  des-ede-cfb, desedecfb (input, key)
+  des-ede-ofb, desedeofb (input, key)
+  des-ede3, desede3 (input, key)
+  des-ede3-cbc, desede3cbc (input, key)
+  des-ede3-cfb, desede3cfb (input, key)
+  des-ede3-cfb1, desede3cfb1 (input, key)
+  des-ede3-cfb8, desede3cfb8 (input, key)
+  des-ede3-ofb, desede3ofb (input, key)
+  des-ofb, desofb (input, key)
+  des3 (input, key)
+  desx (input, key)
+  desx-cbc, desxcbc (input, key)
+  rc2 (input, key)
+  rc2-40-cbc, rc240cbc (input, key)
+  rc2-64-cbc, rc264cbc (input, key)
+  rc2-cbc, rc2cbc (input, key)
+  rc2-cfb, rc2cfb (input, key)
+  rc2-ecb, rc2ecb (input, key)
+  rc2-ofb, rc2ofb (input, key)
+  rc4 (input, key)
+  rc4-40, rc440 (input, key)
+  rc4-hmac-md5, rc4hmacmd5 (input, key)
+  seed (input, key)
+  seed-cbc, seedcbc (input, key)
+  seed-cfb, seedcfb (input, key)
+  seed-ecb, seedecb (input, key)
+  seed-ofb, seedofb (input, key)
+  aes-128-ccm, aes128ccm (input, key)
+  aes-128-gcm, aes128gcm (input, key)
+  aes-192-ccm, aes192ccm (input, key)
+  aes-192-gcm, aes192gcm (input, key)
+  aes-256-ccm, aes256ccm (input, key)
+  aes-256-gcm, aes256gcm (input, key)
+  blowfish (input, key)
+  id-aes128-ccm, idaes128ccm (input, key)
+  id-aes128-gcm, idaes128gcm (input, key)
+  id-aes128-wrap, idaes128wrap (input, key)
+  id-aes192-ccm, idaes192ccm (input, key)
+  id-aes192-gcm, idaes192gcm (input, key)
+  id-aes192-wrap, idaes192wrap (input, key)
+  id-aes256-ccm, idaes256ccm (input, key)
+  id-aes256-gcm, idaes256gcm (input, key)
+  id-aes256-wrap, idaes256wrap (input, key)
+  id-smime-alg-cms3deswrap, idsmimealgcms3deswrap (input, key)
+  b2, base2, bin, binary (input)
+  b8, base8, oct, octal (input)
+  b16, base16, hex, hexidecimal (input)
+  b32, base32, b32-std, base32-std (input)
+  b64, base64, b64-psq, b64-std, base64-psq, base64-std (input)
+  b64-ps, b64-utf7, base64-ps, base64-utf7 (input)
+  b64-ph, b64-file, base64-ph, base64-file (input)
+  b64-hu, b64-url, base64-hu, base64-url (input)
+  b64-duh, b64-yui, base64-duh, base64-yui (input)
+  b64-dh, b64-xml-name, base64-dh, base64-xml-name (input)
+  b64-uc, b64-xml-id, base64-uc, base64-xml-id (input)
+  b64-uh, b64-prog-id-1, base64-uh, base64-prog-id-1 (input)
+  b64-du, b64-prog-id-2, base64-du, base64-prog-id-2 (input)
+  b64-xh, b64-regex, base64-xh, base64-regex (input)
+  r2, rad2, radix2 (input)
+  r3, rad3, radix3 (input)
+  r4, rad4, radix4 (input)
+  r5, rad5, radix5 (input)
+  r6, rad6, radix6 (input)
+  r7, rad7, radix7 (input)
+  r8, rad8, radix8 (input)
+  r9, rad9, radix9 (input)
+  r10, rad10, radix10 (input)
+  r11, rad11, radix11 (input)
+  r12, rad12, radix12 (input)
+  r13, rad13, radix13 (input)
+  r14, rad14, radix14 (input)
+  r15, rad15, radix15 (input)
+  r16, rad16, radix16 (input)
+  r17, rad17, radix17 (input)
+  r18, rad18, radix18 (input)
+  r19, rad19, radix19 (input)
+  r20, rad20, radix20 (input)
+  r21, rad21, radix21 (input)
+  r22, rad22, radix22 (input)
+  r23, rad23, radix23 (input)
+  r24, rad24, radix24 (input)
+  r25, rad25, radix25 (input)
+  r26, rad26, radix26 (input)
+  r27, rad27, radix27 (input)
+  r28, rad28, radix28 (input)
+  r29, rad29, radix29 (input)
+  r30, rad30, radix30 (input)
+  r31, rad31, radix31 (input)
+  r32, rad32, radix32 (input)
+  r33, rad33, radix33 (input)
+  r34, rad34, radix34 (input)
+  r35, rad35, radix35 (input)
+  r36, rad36, radix36 (input)
+  deflate (input)
+  gzip, gz (input)
+  and-trunc (input, input)
+  or-trunc (input, input)
+  xor-trunc (input, input)
+  and (input, input)
+  or (input, input)
+  xor (input, input)
+  not (input)
+  url, uri, cgi (input)
+  cat, catenate (input)
+  repack (input, ch1, ch2)
+  tr, translate (input, ch1, ch2)
+  repl, replace (input, search, replace)
+  rc4-ruby (input, key)
+
+
+```
+
+## Developing
+Check out code:
+```shell
+git clone https://github.com/frohoff/ciphr.git
+cd ciphr
+```
+
+Run command from exploded gem/project directory:
+```shell
+bundle exec ruby -Ilib bin/ciphr [args]
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/TODO

@@ -0,0 +1,320 @@
+TODO:
+==========================
+
+Document use of bash anon named pipes with @ syntax
+spaces in various places in grammar (between @ and filename, spaces inside of [] and () for calls)
+
+xor hangs with large keyfiles
+Context objects, Classes method_missing delegate to singleton instance
+TTY handling: default trailing newline, colors/escapes for non-printable
+tr, replace functions
+interleave/concat multiple streams
+vararg functions
+switch endianness
+
+fix
+-----------
+bug in b64 decoding of HFF= => HFE=
+
+robustness
+-----------
+* graceful handling of mismatched data size (key size, base64 chunks, xor)
+* errors for bad function name or args
+* case insensitivity for ~b16
+* high level classification of functions (util, bitwise, hash, cipher, mac, etc)
+* handling of optional arguments (IVs/nonces, # rounds, etc) without breaking pipe argument prepending
+* escape/encode non-printable chars if outputting to tty http://blog.bogojoker.com/2009/04/check-if-your-ruby-script-is-in-a-pipe/
+* description for functions in help
+
+completeness
+-----------
+base64 variants
+* %/url, b32, ascii85, escape-sequence (\x, String.dump), xml/html
+* bitwise ops: variants for mismatched lengths?
+
+
+features
+---------------
+functions
+  bitwise ops
+    shift right/left (circular rotate vs fill)
+    not/and/or (similar to xor)
+  hashes  
+    crc/adler
+    crypt/scrypt/bcrypt/pbkdf
+  ciphers
+    substitution: caeser/rot/dvorak/vigenère/affine/atbash/avgad/albam
+    physical: rotor/enigma
+  byte ops
+    prepend/append
+    indexed head/tail/substring
+    reverse bits/nibbles/bytes	
+    repeat bytes
+  compression
+    gzip/deflate/lz*/bzip2/snappy/rle
+      http://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv
+  generators
+    random bytes
+
+revamp streams
+  http://readruby.io/io
+  https://github.com/javanthropus/io-like
+  https://github.com/javanthropus/stream
+  https://github.com/rubygems/rubygems/blob/master/lib/rubygems/package/digest_io.rb
+  https://github.com/krypt/binyo
+  https://gist.github.com/tlrobinson/967710
+  https://www.ruby-forum.com/topic/58563
+  https://github.com/jdleesmiller/event_state
+  https://github.com/slagyr/statemachine/
+namespacing in case of simple name collisions
+string literals
+  alternative quotes (a la ruby/perl/python, %q[] %Q{} qq() """ ''') http://en.wikibooks.org/wiki/Ruby_Programming/Alternate_quotes
+  allow \xXX escaping
+extension mechanism (via other gems or simple files)
+varargs for functions
+non pipe statements variable writing/reading
+
+
+random ideas
+-------------
+`strings` extraction
+regex search/replace support
+fn for executing shell/ruby
+multi-round hash support
+
+
+cleanliness
+-----------
+refactor variable buffering (probably will improve perf)
+break up functions
+
+goals and philosophy
+==========================
+functions on streams of bytes
+kiss: crypto, hashes, bitwise ops, encodings, compression, simple transforms
+most complex use case: generate rails cookie from marshalled data and secret
+strive for streaming impls and low memory usage even for large input documents
+pull/read (vs push/write) based API
+shell friendly syntax
+maximum portability, no native gem deps
+extensible via external gems adding functions
+
+
+
+scratch notes
+==========================
+
+
+reverse(input,chunksize=1,boundarysize=nil)
+cat(input1,input2,...,inputn)
+
+ruby -e 'puts ["c","s"].product(["i","y"]).product(["ph","f"]).product(["r","er","yr","ir"]).map{|a| a.flatten.join}'
+ciphr
+cipher
+ciphyr
+ciphir
+cifr
+cifer
+cifyr
+cifir
+cyphr
+cypher
+cyphyr
+cyphir
+cyfr
+cyfer
+cyfyr
+cyfir
+siphr
+sipher
+siphyr
+siphir
+sifr
+sifer
+sifyr
+sifir
+syphr
+sypher
+syphyr
+syphir
+syfr
+syfer
+syfyr
+syfir
+
+
+
+
+Gem::Specification.find_all.to_a.select{|s| s.dependencies.any?{|d| d.name=='slop'}}.map{|s| s.name}
+https://codeclimate.com/github/cloudfoundry/vmc/VMC::Plugin/source_listing.js?line_end=53&line_start=11&path=lib%2Fvmc%2Fplugin.rb
+https://github.com/mmozuras/pronto
+http://stackoverflow.com/questions/11827950/create-an-extensible-ruby-gem
+https://bitbucket.org/ged/strelka/src/dc4b6998813161ab4c94656ce144aa36a85ab65e/lib/strelka/discovery.rb
+
+
+
+
+http://weblog.rubyonrails.org/2009/9/1/gem-packaging-best-practices/
+https://gist.github.com/rtomayko/54177
+
+
+
+
+11111111 | 11111111 | 11111111
+111 | 111 | 111 | 111 | 111 | 111 | 111 | 111 
+
+1 2 3 4 5 6 7 8*1 2 3 4 5 6 7 8*1 2 3 4 5 6 7 8
+1 2 3*1 2 3*1 2 3*1 2 3*1 2 3*1 2 3*1 2 3*1 2 3
+
+
+~b64,hmac(abcd,~b64),b16,xor(deef,~b64)
+~des
+
+=abcd/^hex/b64/hmac[=abcd/^b64]=/
+
+{abcd},~hex,b64/hmac-sha1[[{abcd},b64]]
+
+=abcd ~hex hmac[=foo] ?key
+
+~[],?@^#{}
+
+
+0x01
+
+
+
+foo#bar^baz[]
+foo;bar|baz()
+
+(foo|bar)|baz
+
+((foo)|bar)|baz
+
+assign var:		?varname
+ref var:		#varname
+literal:		=value
+separator:		" "
+file reference:	@filepath
+
+% in url
+used in b64: 	_-:!/.+=
+shell ok: 		~,.-_{}[]/?%#@^+=:
+shell not ok: 	()|!$&*\;'"<>` 
+
+	sh 	b64
+`		x
+~	x 	x
+!	
+@	x 	x
+#	x 	x
+$	 	x
+%	x 	x
+^	x 	x
+&	 	x
+*	 	x
+()	 	x
+-	x 	
+_	x 	
+=	x 	b
++	x 	
+[]	x 	x
+{}	x 	x
+;	 	x
+:	x 	
+'		x
+"	 	x
+,	x 	x
+.	x 	
+/	x 
+<>	 	x
+?	x 	x
+
+
+
+x(a)|y(b)|z(c)
+
+
+
+					z
+			
+			y				c
+	
+		x		b
+
+	a
+
+
+
+
+
+
+         file
+           |
+           V
+         ~hex
+           |
+           V
+stdin --> aes --> hex --> stdout
+
+
+         file1   file2
+           |       |
+           V       V
+         ~hex    ~hex
+           |       |
+           V       V
+stdin --> aes --> aes -> hex --> stdout
+
+
+stdin --> md5 --> hex --> stdout
+
+
+stdin --> md5 --> md5 --> ... -> md5 --> hex --> stdout
+
+
+
+
+base64: read multiple loop
+  input.read(4) {|bytes,eof|
+    output.write(encode(bytes))
+  }
+
+cipher: read full init, read arbitrary loop, special end
+  key.read() {|bytes,eof|
+    @bytes = bytes
+  }
+  input.read(256) {|bytes,eof|
+    output.write(cipher.update)
+  }
+
+xor-repeat: read full init, read arbitrary loop
+  key.read() {|bytes,eof|}
+
+
+xor-trunc: read arbitrary loop
+  key.read(1) && input.read(1) {
+
+  }
+
+
+md5: read arbitrary loop, special end
+
+hmac: read full init, read arbitrary loop, special end
+
+def pump
+  if input.size >= 1 && key.size >= 1
+    output.write(input.read(1) ^ key.read(1))
+  end
+end
+
+
+
+IDEAS:
+
+method_missing for arguments in function body
+  
+
++ for concat
+* for repeat
+^ for recurse
+