fun_with_passwords 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmE0NWE2NGNiZWY2MWRlMjcyNmNiYzFhMjU1MDM4YThkYmY0ZTJjZA==
+  data.tar.gz: !binary |-
+    YTNlZTk5MTFkNjg1YzhjNWI5OTkwYTZiNmQyZmEyZTYxMDFmZjYzNw==
+SHA512:
+  metadata.gz: !binary |-
+    MDVkZWMxZTY2MmVkMTQ3MWU2MDcxZjU2MTI2MzRhNTliZGZkOWE3NGQ1M2Fk
+    NWJiYWE1MTcxMGQwODdhYjE2YTc0NzZiY2NjMDU3ZjlhMjI1NTBmY2ZmN2Yy
+    MDBjMDkxYzFhNjk3YjYzNDZiZDFjNjYzMTgxZDYzYTJiN2I3NGU=
+  data.tar.gz: !binary |-
+    ZWY1OGZiYjU5ODY2ODUzMjJmMGNiMmVkOTE4MGU2YWJmN2JkNjZiNmFiYTZm
+    ZmFlNWQ2YWQyNzdhNmM1YmM2NGEzNzhjMDhjYzQ1ZTFjM2E1YTEzYTAwYzI0
+    MWFhZWY3NjYxMjQ1NDFiN2Y0ODFlYWZmMDFmZTgxNTgzOGRkMmU=

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", "~> 3.5"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.5"
+  gem "jeweler", "~> 2.0"
+  gem "debugger", "~> 1.6"
+end
+
+gem "fun_with_files", "~> 0"
+gem "fun_with_configurations", "~> 0"
+gem "fun_with_version_strings", "~> 0"
+gem "highline", "~> 1.6"
+gem "xdg", "~> 2.2"

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Bryce Anderson
+
+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.rdoc

@@ -0,0 +1,22 @@
+= fun_with_passwords
+
+Creates an encrypted password store that your applications can access.
+
+Keychain.
+
+
+== Contributing to fun_with_passwords
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Bryce Anderson. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "fun_with_passwords"
+  gem.homepage = "http://github.com/darthschmoo/fun_with_passwords"
+  gem.license = "MIT"
+  gem.summary = "Create an encrypted password store that your scripts can access."
+  gem.description = "Because passwords are obnoxious."
+  gem.email = "keeputahweird@gmail.com"
+  gem.authors = ["Bryce Anderson"]
+  # dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fun_with_passwords #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/bin/fwpass

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require_relative File.join( "..", "lib", "fun_with_passwords" )
+
+FunWith::Passwords::CommandLine.new( ARGV ).run
+

data/lib/fun_with/passwords/command_line.rb

@@ -0,0 +1,184 @@
+module FunWith
+  module Passwords
+    ACTION_KEYWORDS_TO_ACTIONS = {
+          "init"       => :initialize,
+          "initialize" => :initialize,
+          "new"        => :initialize,
+          "create"     => :initialize,
+          "add"        => :add,
+          "insert"     => :add,
+          "remove"     => :remove,
+          "rm"         => :remove,
+          "rmv"        => :remove,
+          "drop"       => :remove,
+          "delete"     => :delete,
+          "del"        => :delete,
+          "display"    => :display,
+          "disp"       => :display,
+          "reveal"     => :display,
+          "show"       => :display,
+          "view"       => :display,
+          "help"       => :help,
+          "h"          => :help,
+          "rekey"      => :rekey
+        }
+    
+    class CommandLine
+      def initialize( args )
+        @args = args
+        @result = CommandLineResult.new( @args.dup )  # false shuts it up
+        
+        parse_args()
+        
+        @console = Console.new
+      end
+      
+      def verbose( verbosity = nil )
+        @verbose = verbosity unless verbosity.nil?
+        @result.verbose( @verbose )
+        !!@verbose
+      end
+      
+      def run
+        return @result if @result.failed?
+        
+        case @action
+        when :initialize
+          if @file.exist?
+            @result.puts "File #{@file} already exists"
+            @result.fail!
+            return @result
+          end
+          
+          get_master_key()
+          @keychain = Keychain.new( :keys => {}, :master_key => @master_key, :file => @file )
+          @keychain.save
+          @result.puts( "Saved new password file at #{@file}" )
+        when :add
+          unlock()
+          if @keychain[@key].nil? || Console.new.confirm( "Replace current password for key #{@key}?" )
+            @keychain[@key] = @pass
+            @keychain.save
+          end
+        when :remove
+          unlock()
+          pass = @keychain.delete( @key )
+          
+          if pass.fwf_blank?
+            @result.puts "No such key as #{@key}. No action taken."
+            return @result
+          end
+          
+          @keychain.save
+        when :display
+          unlock()
+          for key, pass in @keychain
+            @result.puts "#{key} : #{pass}"
+          end
+        when :rekey
+          unlock()
+          new_key = @new_master_key || Console.ask_for_asterisks( "Enter the NEW master key for #{@file}? " )
+          @keychain.save( new_key )
+        when :help
+          print_help
+        end
+        
+        return @result
+      rescue OpenSSL::Cipher::CipherError => e
+        @result.stderr( "Cipher error, probably bad master password given. message: #{e.message}")
+        @result.fail!
+        @result
+      end
+      
+      protected
+      
+      def parse_args()
+        if @args.length == 0
+          @action = :help
+        else
+          @action = ACTION_KEYWORDS_TO_ACTIONS[ (keyword = @args.shift) ]
+                    
+          
+          case @action
+          when nil
+            @result.puts_error( "Unrecognized keyword #{keyword}" )
+            @result.fail!
+            print_help
+          when :add
+            @key, @pass = key_and_pass( @args.shift )
+          when :remove
+            @key = @args.shift
+          when :display
+            # do nothing
+          else
+            # do nothing
+          end
+          
+          while @args.length > 0
+            arg = @args.shift
+            
+            if m = /^--file=(.*)$/.match(arg)
+              @file = unquote( m[1] ).fwf_filepath.expand
+            elsif m = /--master=(.*)$/.match(arg)
+              @master_key = unquote( m[1] )
+            elsif m = /--new_master=(.*)$/.match(arg)
+              @new_master_key = unquote( m[1] )
+            elsif arg == "--quiet"
+              @verbose = false
+              @result.verbose( false )
+            else
+              @result.puts_error( "Unrecognized option #{arg}" )
+              @result.fail!
+            end
+          end
+          
+          @file ||= FileStore.default_file
+        end
+      end      
+      
+      
+      def unquote( str )
+        if str =~ /^(?<q>["']).*(?<q>)$/
+          str[1..-2]
+        else
+          str
+        end
+      end
+      
+      def print_help
+        @result.puts "\tfwpass new (opts) (create new password file)"
+        @result.puts "\tfwpass add <KEY>=<PASS> (opts)    (add a key to an existing password file)"
+        @result.puts "\tfwpass rm <KEY> (opts)   (remove a key from a password file)"
+        @result.puts "\tfwpass show (opts)   (show contents of password file)"
+        @result.puts "\tfwpass rekey (opts)    (swap the master key for a new one.  must know the current key)"
+        @result.puts "\tOptions:"
+        @result.puts "\t\t--file=<PASSWORD_FILE> (default file: #{FileStore.default_file})"
+        @result.puts "\t\t--master=<PASSWORD> ('master key' to unlock the password file)"
+        @result.puts "\t\t--new_master=<PASSWORD> (the new 'master key' that will unlock the file hereafter) (option ignored except by rekey command)"
+      end
+    
+      def get_master_key
+        @master_key ||= @console.ask_for_master_key(@file)
+      end
+      
+      def unlock
+        get_master_key()
+        @keychain = Keychain.new( :master_key => @master_key, :file => @file ).unlock
+      end
+      
+      def key_and_pass( str )
+        # matches things like "key"='password' key="P4s5w0rd"
+        # regexp = /^(?<q1>["']?)(?<key>.*)(?<q1>)=(?<q2>["']?)(?<pass>.*)(?<q2>)$/
+        regexp = /^(?<key>(?<q1>["']?).*?(?<q1>))=(?<pass>(?<q2>["']?).*(?<q2>))$/    # wrong: reruns expression
+        regexp = /^(?<key>(?<q1>["']?).*?\k<q1>)=(?<pass>(?<q2>["']?).*\k<q2>)$/     # right: looks for the matched text
+        match_data = regexp.match( str )
+
+        if match_data
+          [unquote(match_data["key"]), unquote(match_data["pass"])]
+        else
+          [nil, nil]
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/command_line_result.rb

@@ -0,0 +1,56 @@
+module FunWith
+  module Passwords
+    class CommandLineResult
+      attr_reader :success, :output, :errors, :args
+      
+      def initialize( args )
+        @args = args
+        @errors = []
+        @output = ""
+      end
+      
+      def stderr( msg )
+        STDERR.puts( msg ) if @verbose
+        @errors << msg
+      end
+      
+      def stdout( msg )
+        STDOUT.write( msg ) if @verbose
+        @output << msg
+      end
+      
+      def puts( msg )
+        stdout( msg + "\n" )
+      end
+      
+      def puts_error( msg )
+        stderr( msg + "\n" )
+      end
+      
+      def fail!
+        @success = false
+      end
+      
+      def failed?
+        @success == false
+      end
+      
+      def succeed!
+        @success = true
+      end
+      
+      def success?
+        @success
+      end
+      
+      def verbose( verbosity = nil )
+        @verbose = !!verbosity unless verbosity.nil?
+        @verbose
+      end
+      
+      def verbose?
+        
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/console.rb

@@ -0,0 +1,42 @@
+module FunWith
+  module Passwords
+    class Console
+      attr_accessor :pre_inputs
+      
+      def initialize
+        @pre_inputs = []
+      end
+      
+      def ask_for_password( key = nil )
+        key ||= ask( "Enter the key associated with the password: ")
+        pass = ask_for_asterisks( "Enter the password for key #{key}: " )
+        [key, pass]
+      end
+      
+      def ask_for_master_key( file )
+        ask_for_asterisks( "Enter the master key to unlock #{file}: " )
+      end
+
+      def ask_for_new_master_key( file )
+        ask_for_asterisks( "Enter the NEW master key for #{file}: " )
+      end
+
+      def confirm( q )
+        ask( "#{q} (Y/N)").upcase == "Y"
+      end
+      
+      def ask_for_asterisks( msg )
+        ask( msg ){ |q| q.echo = "*" }
+      end
+      
+      protected
+      def ask( *args, &block )
+        if @pre_inputs.fwf_blank?
+          HighLine.ask( *args, &block )
+        else
+          @pre_inputs.shift
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/crypt.rb

@@ -0,0 +1,38 @@
+module FunWith
+  module Passwords
+    class Crypt
+      IV = "b2f7zaf14kagpd3j76ulddjxytvhjnzvna7diacozrui7afx4d7kj0cxj4ch1of1z7in376vah4kwkarwls0vbtosraovy7d4ci"
+
+      def self.decrypt( encrypted_message, key )
+        cipher = OpenSSL::Cipher::AES256.new( :CBC )
+        cipher.decrypt
+        cipher.key = self.stretch_key(key)
+        cipher.iv  = IV
+        
+        msg = cipher.update( encrypted_message )
+        msg << cipher.final
+        msg
+      end
+      
+      def self.encrypt( plaintext, key )
+        cipher = OpenSSL::Cipher::AES256.new( :CBC )
+        cipher.encrypt
+        cipher.key = self.stretch_key(key)
+        cipher.iv  = IV
+        
+        encrypted_message = cipher.update( plaintext )
+        encrypted_message << cipher.final
+        encrypted_message
+      end
+      
+      
+      protected
+      # Only advantage of doing this is lengthening short, insecure master passwords to
+      # randomish-looking key of length needed by the crypto cipher.  Short passwords?
+      # Still insecure.  Film at 11.
+      def self.stretch_key( key )
+        (Digest::MD5.hexdigest(key) + Digest::MD5.hexdigest(key.reverse) ).to_i(16).to_s(36)
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/file_store.rb

@@ -0,0 +1,78 @@
+module FunWith
+  module Passwords
+
+    # The FileStore knows only where to save itself, and how to encrypt
+    # and decrypt the file.  The contents of a file are a mystery for
+    # Keychain to deal with
+    class FileStore
+      DEFAULT_DIR = XDG['CONFIG'].fwf_filepath.join("fun_with_passwords")
+      DEFAULT_EXT = "aes256.dat"
+      DEFAULT_FILENAME = "password_store"
+          
+      attr_accessor :password_file, :key_chain
+      
+      def self.default_file
+        DEFAULT_DIR.join( "#{DEFAULT_FILENAME}.#{DEFAULT_EXT}" )
+      end
+
+      # if the key is nil, waits until a password is requested or added to decrypt password file
+      def initialize( filename = nil )
+        @password_file = expand_filepath( filename )
+        @password_file.touch
+      end
+      
+      # sends back a Keychain that knows where its store is
+      def unlock( master_key )
+        if @password_file.file? && !@password_file.empty?
+          YAML.load( Crypt.decrypt( @password_file.read, master_key ) )
+        else
+          {}
+        end
+      end
+      # 
+      # def initialize_key_chain_if_needed( keychain_keys, master_key )
+      #   unless @key_chain
+      #     @key_chain = Keychain.new( :keys => keychain_keys, :master_key => master_key )
+      #     @key_chain.file_store = self
+      #   end
+      # end
+      
+      def save( yaml, master_key )
+        encrypted_message = Crypt.encrypt( yaml, master_key )
+        @password_file.write( encrypted_message )
+        true
+      rescue Exception => e
+        false
+      end
+      
+      protected
+      # Just the filename?  Send it to the default directory.
+      # nil?  Use the default filename and default directory.
+      # Only a directory given?  append default filename
+      # It's an existing file?  Overwrite, I suppose.
+      # doesn't exist?  Assume filename if a dot is included
+      def expand_filepath( filename = nil )
+        if filename.nil?
+          return DEFAULT_DIR.join( "#{DEFAULT_FILENAME}.#{DEFAULT_EXT}" )
+        end
+        
+        file = filename.fwf_filepath
+        
+        if file.directory?
+          return file.join( "#{DEFAULT_FILENAME}.#{DEFAULT_EXT}" )
+        elsif file.file?
+          return file 
+        end
+        
+        file = file.expand
+        
+        if file.directory?
+          return file.join( "#{DEFAULT_FILENAME}.#{DEFAULT_EXT}" )
+        else
+          file.touch
+          return file
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/keychain.rb

@@ -0,0 +1,105 @@
+module FunWith
+  module Passwords
+    class Keychain
+      NAMESPACE_CHAR = ":"
+      
+      attr_accessor :file_store
+      
+      # Load an existing
+      def self.load( master_key, opts = {} )
+        file = opts[:file] || FileStore.default_file
+        master_key = Console.new.ask_for_master_key if master_key == :new
+        self.new( :file => file, :master_key => master_key ).unlock
+      end
+      
+      def initialize( opts = {} )
+        @options = opts
+        set_keys
+        set_master_key
+        set_file_store
+      end
+      
+      # if no new master key is given, save with the old one.
+      def save( master_key = nil)
+        @master_key = master_key if master_key
+        if @file_store
+          @file_store.save( @keys.to_yaml, @master_key )
+        else
+          false
+        end
+      end
+      
+      def unlock( master_key = nil )
+        @master_key = master_key if master_key
+        
+        if @file_store
+          set_keys( @file_store.unlock( @master_key ) )
+        end
+        
+        self
+      end
+      
+      def set_options
+        if @opts[:interactive]
+          @ask_on_fail = true
+        end
+      end
+      
+      # After @keys is set, subsequent set_keys(nil) calls have no effect.
+      def set_keys( hash = nil )
+        if hash
+          @keys = hash
+        else
+          @keys ||= @options[:keys] || {}
+          @options.delete(:keys)
+        end
+      end
+      
+      def set_master_key( key = nil )
+        if key
+          @master_key = key
+        else
+          @master_key ||= @options.delete(:master_key)
+          @master_key ||= Console.new.ask_for_master_key if @ask_on_fail
+        end
+      end
+
+      def set_file_store
+        @file_store = FileStore.new( @options[:file] ) if @options[:file]
+      end
+      
+      def []=( key, password )
+        @keys[key] = password
+      end
+
+      def []( key )
+        password = @keys[key]
+                
+        if !password && @ask_on_fail
+          password = Console.new.ask_for_password( key )
+          self[key] = password  
+        end
+        
+        password
+      end
+      
+      def each( &block )
+        if block_given?
+          @keys.each(&block)
+        else
+          @keys.each
+        end
+      end
+      
+      def delete( key )
+        @keys.delete( key )
+      end
+      
+      def printout
+        self.each do |key, password|
+          puts "#{key}: #{password}"
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/passwords/password.rb

@@ -0,0 +1,14 @@
+# It seems this isn't used.
+#
+# module FunWith
+#   module Files
+#     class Password
+#       attr_accessor :label, :password
+#       
+#       def initialize( label, password )
+#         @label = label
+#         @password = password
+#       end
+#     end
+#   end
+# end

data/lib/fun_with_passwords.rb

@@ -0,0 +1,19 @@
+require 'fun_with_files'
+require 'fun_with_configurations'
+require 'fun_with_version_strings'
+require 'highline/import'
+require 'xdg'
+require 'openssl'
+require 'yaml'
+
+module FunWith
+  module Passwords
+  end
+end
+
+FunWith::Files::RootPath.rootify( FunWith::Passwords, __FILE__.fwf_filepath.dirname.up )
+FunWith::VersionStrings.versionize( FunWith::Passwords )
+
+FunWith::Passwords.root( "lib","fun_with" ).requir
+
+

data/test/data/kvpair_successes.txt

@@ -0,0 +1,9 @@
+k=v|k|v
+key=value|key|value
+'key'='value'|key|value
+key='value'|key|value
+key="value"|key|value
+"key"=value|key|value
+"key"='value'|key|value
+"site=flow.xmission.com"='xjJ3~=""'|site=flow.xmission.com|xjJ3~=""
+godzilla:v:tokyo="&&^32='*h<>!="|godzilla:v:tokyo|&&^32='*h<>!=

data/test/helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler'
+require 'debugger'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'fun_with_passwords'
+
+class Test::Unit::TestCase
+end
+
+class FunWith::Passwords::TestCase < Test::Unit::TestCase
+  include FunWith::Passwords
+  def tmpdir( &block )
+    FunWith::Files::FilePath.tmpdir do |tmp|
+      @tmpdir = tmp
+      warn( "temporary dir not writable.  Some tests may fail." ) unless @tmpdir.directory? && @tmpdir.writable?
+      yield
+    end
+  end
+end

data/test/test_command_line.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+class TestCommandLine < FunWith::Passwords::TestCase  
+  should "test basics" do
+    tmpdir do
+      file = @tmpdir.join( 'passwords.aes256.dat' )
+      file_arg = "--file=#{file}"
+      master_arg = "--master=pass1"
+      master_arg2 = "--master=pass2"
+      new_master_arg = "--new_master=pass2"
+      bad_password = "--master=wrong"
+      refute file.exist?
+      # how to simulate user entering password...
+      run_console( ["new", file_arg, master_arg, "--quiet"] )
+      assert file.exist?
+      
+      run_console( ["add", "site1:mysql=pass1", file_arg, master_arg, "--quiet"] )
+      run_console( ["add", "site2:mysql=pass2", file_arg, master_arg, "--quiet"] )
+
+      run_console( ["show", file_arg, master_arg, "--quiet"] ) do |result|
+        assert_equal "site1:mysql : pass1\nsite2:mysql : pass2", result.output.strip
+      end
+      
+      run_console( ["rekey", file_arg, master_arg, new_master_arg])
+      
+      run_console( ["rm", "site1:mysql", file_arg, master_arg2, "--quiet"] )
+      run_console( ["rm", "site2:mysql", file_arg, master_arg2, "--quiet"] )
+      
+      run_console( ["rm", "site2:mysql", file_arg, bad_password, "--quiet"] ) do |result|
+        assert_match /Cipher error/, result.errors.first
+        refute result.success?
+      end
+      
+      
+      # puts "\tfwpass new <OPTIONAL_FILENAME>   (create new password file)"
+      # puts "\tfwpass add key=password <OPTIONAL_FILENAME>   (add a key to an existing password file)"
+      # puts "\tfwpass rm key <OPTIONAL_FILENAME>   (remove a key from a password file)"
+      # puts "\tfwpass show <OPTIONAL_FILENAME>   (show contents of password file)"
+      # puts "\tfwpass rekey <OPTIONAL_FILENAME>   (swap the master key for a new one.  must know the current key)"
+      # puts "\t(default file: #{FileStore.default_file})"
+    end
+  end
+  
+  should "properly parse key=value pairs" do
+    successes = FunWith::Passwords.root("test", "data", "kvpair_successes.txt").read.split("\n")
+    
+    cmd = CommandLine.new(["help"])
+    
+    for line in successes
+      str, expected_key, expected_pass = line.split("|")
+      
+      actual_key, actual_pass = cmd.send( :key_and_pass, str )
+
+      refute actual_key.nil?
+      refute actual_pass.nil?
+      refute actual_key.fwf_blank?
+      refute actual_pass.fwf_blank?
+      
+      assert_equal( expected_key, actual_key )
+      assert_equal( expected_pass, actual_pass )
+      
+    end
+  end
+  
+  
+  
+  def run_console( args, &block )
+    result = CommandLine.new( args ).run
+    
+    if block_given?
+      yield result
+    else
+      result
+    end
+  end
+end

data/test/test_crypt.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class TestCrypt < FunWith::Passwords::TestCase
+  should "encrypt and decrypt using Crypt functions" do
+    message = "secret message"
+    key = "secret key"
+    
+    encrypted_message = Crypt.encrypt( message, key )
+    assert_not_equal( message, encrypted_message )
+    decrypted_message = Crypt.decrypt( encrypted_message, key )
+    assert_equal( message, decrypted_message )
+  end
+end

data/test/test_fun_with_passwords.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class TestFunWithPasswords < FunWith::Passwords::TestCase  
+  should "test basics" do
+    assert defined?( FunWith::Passwords )    # utterly useless test
+    assert defined?( FunWith::Passwords::Console )
+    assert defined?( FunWith::Passwords::Crypt )
+  end
+  
+  should "test fun_with_files integrating properly" do
+    assert defined?(FunWith::Files)
+    assert defined?(FunWith::Files::FilePath)
+    assert [].fwf_blank?
+  end
+end

data/test/test_keychain.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+class TestKeychain < FunWith::Passwords::TestCase
+  KEYHASH = { "hey:sailor" => "password",
+              "orangutan"  => "marigold",
+              "hitch:hiker:steve" => "hoboname"
+            }
+  
+  def setup
+    @keychain = Keychain.new( :keys => KEYHASH.clone, :master_key => "master_key" )
+  end
+         
+  should "get the correct keys" do
+    assert_equal( "password", @keychain["hey:sailor"] )
+    assert_equal( "marigold", @keychain["orangutan"] )
+  end
+  
+  should "update a key" do
+    @keychain["orangutan"] = "password_orangutan"
+    @keychain["hey:sailor"] = "password_sailor"
+    
+    assert_equal( "password_orangutan", @keychain["orangutan"] )
+    assert_equal( "password_sailor", @keychain["hey:sailor"] )
+    assert_equal( @keychain["hitch:hiker:steve"], "hoboname")
+  end
+  
+  should "test each(){}" do
+    expected = [["hey:sailor", "password"], ["orangutan", "marigold"], ["hitch:hiker:steve", "hoboname"]]
+
+    i = 0
+    @keychain.each do |item|
+      assert_equal( expected[i], item )
+      i += 1
+    end
+  end
+  
+  should "write passwords to a file and read them back" do
+    tmpdir do
+      assert @keychain.file_store.nil?
+      pwfile = @tmpdir.join("password_store.aes256.dat")
+      assert !pwfile.exist?
+      
+      @keychain.file_store = FileStore.new(@tmpdir)
+      assert_equal( pwfile, @keychain.file_store.password_file )
+      
+      @keychain.save
+      assert @keychain.file_store.password_file.exist?
+
+      @keychain = Keychain.load( "master_key", :file => pwfile )
+      @keychain.unlock
+      
+      assert_equal( "password", @keychain["hey:sailor"] )
+      assert_equal( "marigold", @keychain["orangutan"] )
+    end
+  end
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: fun_with_passwords
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Bryce Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fun_with_files
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fun_with_configurations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fun_with_version_strings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: xdg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Because passwords are obnoxious.
+email: keeputahweird@gmail.com
+executables:
+- fwpass
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/fwpass
+- lib/fun_with/passwords/command_line.rb
+- lib/fun_with/passwords/command_line_result.rb
+- lib/fun_with/passwords/console.rb
+- lib/fun_with/passwords/crypt.rb
+- lib/fun_with/passwords/file_store.rb
+- lib/fun_with/passwords/keychain.rb
+- lib/fun_with/passwords/password.rb
+- lib/fun_with_passwords.rb
+- test/data/kvpair_successes.txt
+- test/helper.rb
+- test/test_command_line.rb
+- test/test_crypt.rb
+- test/test_fun_with_passwords.rb
+- test/test_keychain.rb
+homepage: http://github.com/darthschmoo/fun_with_passwords
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Create an encrypted password store that your scripts can access.
+test_files: []