passw3rd 0.2.2 → 0.2.3

data/lib/passw3rd/password_client.rb

@@ -31,19 +31,14 @@ module Passw3rd
     opts.on('-p', '--password-dir PATH', 'Read and write password files to this directory (default is ~/)') do |opt|
       password_dir = opt
       ::Passw3rd::PasswordService.password_file_dir = password_dir
-      if !File.directory?(File.expand_path(password_dir))
+      unless File.directory?(File.expand_path(password_dir))
         raise "#{password_dir} must be a directory"
       end      
     end
 
     opts.on('-g', '--generate-key [PATH]', 'generate key/iv and store in PATH, defaults to the home directory') do |opt|
       gen_key_path = opt
-      if gen_key_path.nil?
-        gen_key_path = ENV["HOME"]
-      end
-      if !File.directory?(File.expand_path(gen_key_path))
-        raise "#{opt} is not a directory"
-      end
+      gen_key_path ||= ::Passw3rd::PasswordService.key_file_dir
     end
 
     opts.on_tail("-h", "--help", "Show this message") do
@@ -55,8 +50,8 @@ module Passw3rd
 
     # generate key/IV
     if gen_key_path
-     ::Passw3rd::PasswordService.create_key_iv_file(gen_key_path)
-      puts "generated keys in #{gen_key_path}"
+      path = ::Passw3rd::PasswordService.create_key_iv_file(gen_key_path)
+      puts "generated keys in #{path}"
     end
 
     # decrypt password_file using the key/IV in key_path

data/lib/passw3rd/password_service.rb

@@ -11,17 +11,17 @@ module Passw3rd
     class << self
       attr_writer :password_file_dir
       def password_file_dir
-        defined?(@password_file_dir) ? @password_file_dir : ENV.fetch("HOME")
+        @password_file_dir || ENV['passw3rd-password_file_dir'] || Dir.getwd
       end
 
       attr_writer :key_file_dir
       def key_file_dir
-        defined?(@key_file_dir) ? @key_file_dir : ENV.fetch("HOME")
+        @key_file_dir || ENV['passw3rd-key_file_dir'] || Dir.getwd
       end
 
       def cipher_name= (cipher_name)
         raise "Hey man, you can only use #{APPROVED_CIPHERS}, you supplied #{cipher_name}" if cipher_name.nil? || !APPROVED_CIPHERS.include?(cipher_name)
-        @cipher_name = cipher_name
+        @cipher_name = ENV['passw3rd-cipher_name'] || cipher_name
       end
 
       def cipher_name
@@ -33,23 +33,23 @@ module Passw3rd
       instance_eval &block
     end
 
-    def self.get_password (password_file, options = {:key_path => key_file_dir, :force => false})
+    def self.get_password (password_file, options = {:key_path => self.key_file_dir, :force => true})
       uri = _parse_uri(password_file)
-      encoded_password = Base64.decode64(open(uri) { |f| f.read })
+      encoded_password = read_file(uri)
       decrypt(encoded_password, options[:key_path])
     rescue => e
       raise ArgumentError, "Could not decrypt passw3rd file #{password_file} - #{e}" if options[:force]
     end
 
-    def self.write_password_file(password, output_path, key_path = key_file_dir)
+    def self.write_password_file(password, output_path, key_path = self.key_file_dir)
       enc_password = encrypt(password, key_path)
       base64pw = Base64.encode64(enc_password) 
       path = File.join(password_file_dir, output_path)
-      open(path, 'w') { |f| f.write base64pw }
+      write_file(path, base64pw)
       path
     end
 
-    def self.encrypt(password, key_path = key_file_dir)
+    def self.encrypt(password, key_path = self.key_file_dir)
       raise ArgumentError, "password cannot be blank" if password.to_s.empty?
 
       cipher = cipher_setup(:encrypt, key_path)
@@ -62,7 +62,7 @@ module Passw3rd
       end
     end
 
-    def self.decrypt(cipher_text, key_path = key_file_dir)
+    def self.decrypt(cipher_text, key_path = self.key_file_dir)
       cipher = cipher_setup(:decrypt, key_path)
       begin
         d = cipher.update(cipher_text)
@@ -102,9 +102,9 @@ module Passw3rd
       end
     end
 
-    def self.create_key_iv_file(path=nil)
+    def self.create_key_iv_file(path = nil)
       unless path
-        path = ::Passw3rd::PasswordService.key_file_dir || ENV['HOME']
+        path = ::Passw3rd::PasswordService.key_file_dir
       end    
 
       # d'oh!
@@ -113,8 +113,8 @@ module Passw3rd
       key = cipher.random_key
 
       begin
-        File.open(key_path, 'w') {|f| f.write(key.unpack("H*").join) }
-        File.open(iv_path, 'w') {|f| f.write(iv.unpack("H*").join) }
+        File.open(self.key_path(path), 'w') {|f| f.write(key.unpack("H*").join) }
+        File.open(self.iv_path(path), 'w') {|f| f.write(iv.unpack("H*").join) }
       rescue
         puts "Couldn't write key/IV to #{path}\n"
         raise $!
@@ -122,23 +122,23 @@ module Passw3rd
       path
     end
     
-    def self.key_path
-      File.join(::Passw3rd::PasswordService.key_file_dir, KEY_FILE)
+    def self.key_path(path= self.key_file_dir)
+      File.join(path || self.key_file_dir, KEY_FILE)
     end
     
-    def self.iv_path
-      File.join(::Passw3rd::PasswordService.key_file_dir, IV_FILE)
+    def self.iv_path(path = ::Passw3rd::PasswordService.key_file_dir)
+      File.join(path || self.key_file_dir, IV_FILE)
     end      
 
     protected
     
-    def self.load_key(path=::Passw3rd::PasswordService.key_file_dir) 
+    def self.load_key(path = ::Passw3rd::PasswordService.key_file_dir)
       begin
-        key = IO.readlines(File.expand_path(self.key_path))[0]
-        iv = IO.readlines(self.iv_path)[0]
-      rescue Errno::ENOENT
-        puts "Couldn't read key/iv from #{path}.  Have they been generated?\n"
-        raise $!
+        key = IO.readlines(File.expand_path(self.key_path(path)))[0]
+        iv = IO.readlines(File.expand_path(self.iv_path(path)))[0]
+      rescue StandardError => e
+        puts "Couldn't read key/iv from #{self.key_path(path)}.  Have they been generated?\n"
+        raise e
       end
 
       {:key => [key].pack("H*"), :iv => [iv].pack("H*")}
@@ -160,5 +160,13 @@ module Passw3rd
         File.join(password_file_dir, password_file)
       end
     end
+
+    def self.read_file uri
+      Base64.decode64(open(uri) { |f| f.read })
+    end
+
+    def self.write_file path, value
+      open(path, 'w') { |f| f.write value }
+    end
   end
 end

data/lib/passw3rd/version.rb

@@ -1,3 +1,3 @@
 module Passw3rd
-  Version = VERSION = '0.2.2'
+  Version = VERSION = '0.2.3'
 end

data/test/password_service_test.rb

@@ -7,12 +7,16 @@ require File.expand_path('../../lib/passw3rd.rb',  __FILE__)
 class PasswordServiceTest < Test::Unit::TestCase
   def setup
     @random_string = sudorandumb
-    ::Passw3rd::PasswordService.key_file_dir = Dir.tmpdir
-    ::Passw3rd::PasswordService.password_file_dir = Dir.tmpdir    
+  end
+
+  def setup_sandbox(path = Dir.tmpdir)
+    ::Passw3rd::PasswordService.key_file_dir = path
+    ::Passw3rd::PasswordService.password_file_dir = path
     ::Passw3rd::PasswordService.create_key_iv_file
   end
   
   def test_enc_dec
+    setup_sandbox
     enc = ::Passw3rd::PasswordService.encrypt(@random_string)
     dec = ::Passw3rd::PasswordService.decrypt(enc)
     
@@ -28,6 +32,7 @@ class PasswordServiceTest < Test::Unit::TestCase
   end
 
   def test_set_and_get_password
+    setup_sandbox
     password_file = ::Passw3rd::PasswordService.write_password_file(@random_string, "test")
     decrypted = ::Passw3rd::PasswordService.get_password("test")
     assert_equal(@random_string, decrypted)
@@ -35,18 +40,22 @@ class PasswordServiceTest < Test::Unit::TestCase
 
   def test_set_and_get_password_custom_dir
     dir = "#{Dir.tmpdir}/#{sudorandumb}"
-    
-    FileUtils.mkdir_p(dir)
     ::Passw3rd::PasswordService.password_file_dir = dir
+    ::Passw3rd::PasswordService.key_file_dir = dir
 
-    password_file_path = ::Passw3rd::PasswordService.write_password_file(@random_string, "test2")
-    assert_match(Regexp.new(dir), password_file_path)
-    
-    decrypted = ::Passw3rd::PasswordService.get_password("test2")
-    assert_equal(@random_string, decrypted)
-    FileUtils.rm_rf(dir)
+    assert_passw3rd_cycle(dir)
   end  
 
+  def test_with_env_vars
+    ::Passw3rd::PasswordService.key_file_dir = nil
+    ::Passw3rd::PasswordService.password_file_dir = nil
+    dir = "#{Dir.tmpdir}/#{sudorandumb}"
+    ENV['passw3rd-password_file_dir'] = dir
+    ENV['passw3rd-key_file_dir'] = dir
+
+    assert_passw3rd_cycle(dir)
+  end
+
   def test_configure_with_block
    ::Passw3rd::PasswordService.configure do |c|
       c.password_file_dir = Dir.tmpdir
@@ -60,4 +69,18 @@ class PasswordServiceTest < Test::Unit::TestCase
   def sudorandumb
     Digest::SHA1.hexdigest(Time.now.to_s.split(//).sort_by{rand}.join)
   end
+
+  def assert_passw3rd_cycle dir
+    FileUtils.mkdir_p(dir)
+    path = ::Passw3rd::PasswordService.create_key_iv_file
+
+    id = sudorandumb
+    password_file_path = ::Passw3rd::PasswordService.write_password_file(@random_string, "test#{id}")
+    assert_match(Regexp.new(dir), password_file_path)
+    
+    decrypted = ::Passw3rd::PasswordService.get_password("test#{id}")
+    assert_equal(@random_string, decrypted)
+
+    FileUtils.rm_rf(dir)
+  end
 end

metadata

@@ -1,25 +1,33 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: passw3rd
-version: !ruby/object:Gem::Version
-  version: 0.2.2
+version: !ruby/object:Gem::Version 
+  hash: 17
   prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 3
+  version: 0.2.3
 platform: ruby
-authors:
+authors: 
 - Neil Matatall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-09 00:00:00.000000000Z
+
+date: 2011-11-16 00:00:00 Z
 dependencies: []
-description: Generate a key/iv file, generate passwords, and store encrypted files
-  in source control, keep the key/iv safe!
-email:
+
+description: Generate a key/iv file, generate passwords, and store encrypted files in source control, keep the key/iv safe!
+email: 
 - neil.matatall@gmail.com
-executables:
+executables: 
 - passw3rd
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - README.md
 - LICENSE
 - EXAMPLES.md
@@ -34,27 +42,36 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/oreoshake/passw3rd
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A simple "keep the passwords out of source code and config files".
 test_files: []
-has_rdoc: 
+