clandestine 0.0.1 → 0.1.0

data/spec/safe_authentication_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'clandestine/safe_authentication'
+
+module Clandestine
+  describe SafeAuthentication do
+    let(:safe) { double('safe') }
+
+    describe '#authenticate' do
+      context 'correct password' do
+        it 'yields safe' do
+          SafeAuthentication.stub(:authenticated?) { true }
+          SafeAuthentication.authenticate(safe, 'password').should eq true
+        end
+      end
+
+      context 'incorrect password' do
+        it 'raises error' do
+          SafeAuthentication.stub(:authenticated?) { false }
+          error = $stderr
+          $stderr = StringIO.new
+          expect {
+            SafeAuthentication.authenticate(safe, 'password')
+          }.to raise_error SystemExit
+          $stderr.string.should eq "Invalid password!\n"
+          $stderr = error
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,3 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper.rb"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-
-require 'clandestine'
 require 'rspec'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clandestine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Alec Tower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-13 00:00:00.000000000 Z
+date: 2014-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -24,20 +24,48 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  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: bcrypt-ruby
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2'
 description: A ruby command line tool for storing encrypted passwords on *nix systems
 email:
 - alectower@gmail.com
@@ -55,15 +83,25 @@ files:
 - bin/clandestine
 - clandestine.gemspec
 - lib/clandestine.rb
-- lib/clandestine/config.rb
+- lib/clandestine/clandestine_error.rb
+- lib/clandestine/command_line_options.rb
+- lib/clandestine/command_line_runner.rb
+- lib/clandestine/commands.rb
+- lib/clandestine/commands/add.rb
+- lib/clandestine/commands/delete.rb
+- lib/clandestine/commands/get.rb
+- lib/clandestine/commands/remove_safe.rb
+- lib/clandestine/commands/update.rb
 - lib/clandestine/crypt.rb
-- lib/clandestine/guard.rb
+- lib/clandestine/io.rb
+- lib/clandestine/password_generator.rb
 - lib/clandestine/safe.rb
+- lib/clandestine/safe_authentication.rb
+- lib/clandestine/safe_location.rb
 - lib/clandestine/version.rb
-- spec/config_spec.rb
+- spec/commands_spec.rb
 - spec/crypt_spec.rb
-- spec/guard_spec.rb
-- spec/safe_spec.rb
+- spec/safe_authentication_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/uniosx/clandestine
 licenses: []
@@ -90,8 +128,8 @@ specification_version: 4
 summary: A ruby command line tool that uses AES-256-CBC encryption to store passwords.
   It provides easy storage and retrieval on *nix systems
 test_files:
-- spec/config_spec.rb
+- spec/commands_spec.rb
 - spec/crypt_spec.rb
-- spec/guard_spec.rb
-- spec/safe_spec.rb
+- spec/safe_authentication_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/clandestine/config.rb

@@ -1,25 +0,0 @@
-module Clandestine
-  module Config
-    CONFIG_PATH = "#{ENV['HOME']}/.pswds"
-    
-    def change_safe_location(new_location)
-      if new_location
-        FileUtils.mkpath File.dirname new_location unless Dir.exists? File.dirname new_location
-        old_file = File.readlink CONFIG_PATH if File.symlink? CONFIG_PATH
-        if IO.readlines(CONFIG_PATH).empty? 
-          File.new new_location, 'w' unless File.exists? new_location
-        else 
-          FileUtils.copy_file(CONFIG_PATH, new_location, true) unless File.exists? new_location
-        end
-        FileUtils.ln_s(new_location, CONFIG_PATH, :force => true)
-        FileUtils.rm_f old_file if old_file
-      else
-        if File.symlink? CONFIG_PATH
-          puts "Current safe location is #{File.readlink CONFIG_PATH}"
-        else
-          puts "Current safe location is #{CONFIG_PATH}"
-        end
-      end
-    end
-  end
-end

data/lib/clandestine/guard.rb

@@ -1,217 +0,0 @@
-require 'highline/import'
-
-module Clandestine
-  # Handles user requests and interacts
-  # with the Safe class.
-  #
-  # Main class to interface with user.
-  # The Guard protects the safe by 
-  # authenticating the user, and making sure
-  # data is in the correct format to be
-  # held in the safe.
-  class Guard
-    include Clandestine::Config
-    
-    # Create new guard object with specified safe.
-    # Default safe location is ENV['HOME']/.pswds
-    def initialize(safe = Safe.new)
-      @safe = safe
-    end
-  
-    # Main method that validates arguments
-    # and processes input
-    def on_the_job
-      validate_args ? process_input : print_options
-    end
-  
-    # Checks for the correct switches to be
-    # supplied by user
-    def validate_args
-      if ARGV.size > 0 && ARGV.size < 3
-        @command = ARGV[0]
-        @arg = ARGV[1]
-        (@command =~ /[(-c)]/ && !@arg.nil?) || (@command =~ /[(-a)(-g)(-l)]/ && @arg.nil?)
-      else
-        false
-      end
-    end
-  
-    # Command line options
-    def print_options
-      puts "Clandestine v#{Clandestine::VERSION}\
-            \nOptions: \
-            \n\t-a <key>      ::   add password related to <key> \
-            \n\t-g <key>      ::   get password related to <key> \
-            \n\t-g            ::   get all keys \
-            \n\t-d <key>      ::   delete password related to <key> \
-            \n\t-d            ::   delete all passwords \
-            \n\t-l            ::   print current location of safe \
-            \n\t-l <path>     ::   move safe location to <path> \
-            \n\t-c            ::   change password to safe \
-            \n\t-r            ::   remove safe completely
-            \n\n\tPasswords will be copied to the clipboard for 5 seconds \
-            \n\n"
-    end
-  
-    # Case statement for switches
-    # Main logic method
-    def process_input
-      case @command
-      when "-a"
-        add_value
-      when "-g"
-        get_value
-      when "-d"
-        delete_value
-      when "-l"
-        change_safe_location(@arg)
-      when "-c"
-        change_safe_password
-      when "-r"
-        remove_safe
-      else
-        print_options
-      end
-    end
-    
-    # Adds a new value to the safe
-    # and binds it to the key provided
-    # by the user.
-    def add_value
-      if @arg
-        safe_password = ask("Enter the password for the safe") { |q| q.echo = "*" }
-        key_password = ask("Enter the password for #{@arg}") { |q| q.echo = "*" }
-        add_data "#{@arg}:#{key_password}", safe_password
-      else
-        puts "A key is needed in order to store a password"
-      end
-    end
-    
-    # Retrieves value from safe
-    # that is related to the key
-    # entered by the user
-    def get_value
-      (puts "The safe is empty"; return) if @safe.empty?
-      safe_password = ask("Enter the password for the safe") { |q| q.echo = "*" }
-      case @arg
-      when /^\S+$/
-        data = retrieve_data(safe_password)
-        value = data[@arg] if data
-        if value
-          IO.popen('pbcopy', 'w') {|clipboard| clipboard.print "#{value}"}
-          say("Password on clipboard countdown: ")
-          10.downto(1) do |num|
-            sleep(1)
-            num == 1 ? say("#{num}") : say("#{num} ")
-          end
-          IO.popen('pbcopy', 'w') {|clipboard| clipboard.print ""}
-        else
-          puts "No value found for #{@arg}"
-        end
-      else
-        data = retrieve_data safe_password
-        if data
-          data.each_key { |key| puts key }
-        else
-          puts "Safe is empty"
-        end
-      end
-    end
-    
-    # Removes key and value from safe.
-    def delete_value
-      (puts " The safe is empty"; return) if @safe.empty?
-      case @arg
-      when /^\S+$/
-        safe_password = ask("Enter the password for the safe") { |q| q.echo = "*" }
-        remove_key_value safe_password
-      when nil
-        empty_safe
-      end
-    end
-  
-    # First retrieves old data to see if
-    # the key already exists in the safe,
-    # adds it if not.
-    def add_data(key_value, safe_password)
-      old_data = retrieve_data safe_password
-      if old_data && old_data[@arg]
-        puts "#@arg already exists"
-        return
-      end
-      merge_data(old_data, key_value, safe_password)
-      puts "Successfully added key value pair"
-    end
-    
-    # Merges new key value pair with old data
-    def merge_data(old_data, key_value, safe_password)
-      new_data = ''
-      old_data.each { |key, value| new_data << "#{key}:#{value}\n" } if old_data
-      new_data << "#{key_value}\n" if key_value
-      @safe.lock(new_data, safe_password)
-    end
-  
-    # Retrieves data from safe and returns
-    # it in a key value hash
-    def retrieve_data(safe_password)
-      begin
-        return if !data = @safe.unlock(safe_password)
-        data.split("\n").map {|l| l.split(":")}.map {|k, v| Hash[k => v]}.reduce({}) {|h, i| h.merge i}
-      rescue OpenSSL::Cipher::CipherError
-        puts "You entered an incorrect password"
-        exit(0)
-      end
-    end
-  
-    # Prompts user for delete confirmation
-    # and empties safe if user entered "Y" or "y". 
-    def empty_safe
-      (puts "The safe is already empty"; return) if @safe.empty?
-      puts "Are you sure? (y|Y)"
-      if STDIN.gets =~ /^[yY]{1}$/
-        @safe.empty_safe 
-        puts "Safe was emptied!"
-      else
-        puts "Not empyting safe"
-      end
-    end
-  
-    # Attempts to remove key and value
-    # from safe if it exists.
-    # If new_data is empty, it means that
-    # there is only one key value in the safe,
-    # So the safe needs to be emptied rather
-    # re-storing the new information.
-    def remove_key_value(safe_password)
-      new_data = ''
-      old_data = retrieve_data safe_password
-      if old_data
-        puts "Deleting #@arg and related password"
-        old_data.each { |key, value| new_data << "#{key}:#{value}\n" if key !~ /^#@arg$/ }
-        if new_data.empty?
-          @safe.empty_safe
-        else
-          @safe.lock(new_data, safe_password) 
-        end
-      else
-        puts "Safe is empty"
-      end
-    end
-    
-    # Attempts to change the password for the safe.
-    # If the safe is empty, there is no password to be changed.
-    def change_safe_password
-      (puts "The safe is empty, no password is currently active"; return) if @safe.empty?
-      old_safe_password = ask("Enter the old password for the safe") { |q| q.echo = "*" }
-      new_safe_password = ask("Enter the new password for the safe") { |q| q.echo = "*" }
-      data = retrieve_data old_safe_password
-      puts "Successfully changed password" if (merge_data(data, nil, new_safe_password) if data)
-    end
-    
-    # Removes safe from file system
-    def remove_safe
-      @safe.self_destruct
-      puts "The safe has been removed!"
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Clandestine::Config do
-  include Clandestine::Config
-  before :all do
-    Clandestine::Config::CONFIG_PATH = "#{ENV['HOME']}/.tstpswds"
-    File.new Clandestine::Config::CONFIG_PATH, 'w'
-    self.instance_eval do 
-      @new_location = "#{ENV['HOME']}/Dropbox/.tstpswds"
-      @newer_location = "#{ENV['HOME']}/Dropbox/.tst_pswds"
-    end
-  end
-  after :each do 
-    File.delete Clandestine::Config::CONFIG_PATH if File.exists? Clandestine::Config::CONFIG_PATH
-    File.delete @new_location if File.exists? @new_location
-    File.delete @newer_location if File.exists? @newer_location
-  end
-  it "should change the location of the password file" do
-    change_safe_location @new_location
-    File.exists?(@new_location).should eql true
-    File.symlink?(Clandestine::Config::CONFIG_PATH).should eql true
-  end
-  it "should move default safe location contents to a new safe" do
-    File.open(Clandestine::Config::CONFIG_PATH, 'a') {|f| f << "stuff"}
-    change_safe_location @new_location
-    IO.readlines(@new_location).should eql ["stuff"]
-    IO.readlines(Clandestine::Config::CONFIG_PATH).should eql ["stuff"]
-  end
-  it "should move sym linked safe location contents to a new safe" do
-    File.open(@new_location, 'a') {|f| f << "stuff"}
-    FileUtils.ln_s @new_location, Clandestine::Config::CONFIG_PATH, :force => true
-    change_safe_location @newer_location
-    IO.readlines(Clandestine::Config::CONFIG_PATH).should eql ["stuff"]
-    IO.readlines(@newer_location).should eql ["stuff"]
-  end
-  it "should delete old safe when moving to a new location" do
-    File.open(Clandestine::Config::CONFIG_PATH, 'a') {|f| f << "stuff"}
-    change_safe_location @new_location
-    change_safe_location @newer_location
-    IO.readlines(@newer_location).should eql ["stuff"]
-    File.exists?(@new_location).should eql false
-  end
-  it "should print the current safe location if no argument is supplied" do
-    $stdout.should_receive(:puts).with("Current safe location is #{Clandestine::Config::CONFIG_PATH}")
-    change_safe_location nil
-  end
-end

data/spec/guard_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe Clandestine::Guard do
-  before :each do
-    Clandestine::Guard.instance_eval do
-      attr_accessor :safe, :command, :arg
-    end
-    @guard = Clandestine::Guard.new mock("safe")
-    ARGV.clear
-  end
-  it "should validate 0 args" do
-    @guard.validate_args.should eql false
-  end
-  it "should validate 1 arg" do
-    ARGV << "-g"
-    @guard.validate_args.should eql true
-  end
-  it "should validate > 1 and < 3 args" do
-    ARGV << "-g" << "keys"
-    @guard.validate_args.should eql true
-  end
-  it "should validate >= 3 args" do
-    ARGV << "-g" << "all" << "too many"
-    @guard.validate_args.should eql false
-  end
-  it "should process input after validating args" do
-    @guard.stub(:validate_args).and_return true
-    @guard.should_receive(:validate_args)
-    @guard.should_receive(:process_input)
-    @guard.on_the_job
-  end
-  it "should print options if no args are provided" do
-    @guard.stub(:validate_args).and_return false
-    @guard.should_receive(:print_options)
-    @guard.on_the_job
-  end
-  it "should process the -a switch to add a key and value" do
-    @guard.stub(:ask).and_return("safepassword", "gmailpassword")
-    @guard.stub(:add_data).with("gmail:gmailpassword", "safepassword").and_return "Successfully added key value pair"
-    @guard.command = "-a"
-    @guard.arg = "gmail"
-    @guard.process_input.should eql "Successfully added key value pair" 
-  end
-  it "should process the -g switch with no argument" do
-    @guard.stub(:ask).and_return "safepassword"
-    @guard.stub(:retrieve_data).with("safepassword").and_return nil
-    @guard.safe.should_receive(:empty?).and_return true
-    $stdout.should_receive(:puts).with("The safe is empty")
-    @guard.command = "-g"
-    @guard.process_input
-  end
-  it "should process the -g switch with an argument" do
-    @guard.safe.stub(:empty?).and_return false
-    @guard.stub(:ask).and_return "safepassword"
-    @guard.stub(:retrieve_data).with("safepassword").and_return Hash["gmail" => "gmailpassword"]
-    IO.should_receive(:popen).with('pbcopy', 'w')
-    @guard.should_receive(:sleep).with(1).exactly(10).times
-    IO.should_receive(:popen).with('pbcopy', 'w')
-    @guard.command = "-g"
-    @guard.arg = "gmail"
-    @guard.process_input
-  end
-  it "should process the -d switch with an argument" do
-    @guard.safe.stub(:empty?).and_return false
-    @guard.stub(:remove_key_value).with("safepassword")
-    @guard.stub(:ask).and_return "safepassword"
-    @guard.should_receive(:ask).with("Enter the password for the safe")
-    @guard.should_receive(:remove_key_value).with("safepassword")
-    @guard.command = "-d"
-    @guard.arg = "gmail"
-    @guard.process_input
-  end
-  it "should process the -d switch with no argument" do
-    @guard.safe.stub(:empty?).and_return false
-    @guard.should_receive(:empty_safe)
-    @guard.command = "-d"
-    @guard.arg = nil
-    @guard.process_input
-  end
-  it "should process the -l switch with a path as an argument" do
-    @guard.command = "-l"
-    @guard.arg = "~/.new_safe"
-    @guard.should_receive(:change_safe_location).with("~/.new_safe")
-    @guard.process_input
-  end
-  it "should process the -c switch" do
-    @guard.command = "-c"
-    @guard.should_receive(:change_safe_password)
-    @guard.process_input
-  end
-  it "should process the -r switch" do
-    @guard.command = "-r"
-    @guard.should_receive(:remove_safe)
-    @guard.process_input
-  end
-  it "should add data to safe" do
-    @guard.stub(:retrieve_data).with("fakepassword").and_return nil
-    @guard.safe.stub(:lock).with("gmail:gmailpassword\n", "fakepassword")
-    $stdout.should_receive(:puts).with("Successfully added key value pair")
-    @guard.add_data "gmail:gmailpassword", "fakepassword"
-  end
-  it "should retreive data froms safe" do
-    @guard.safe.stub(:unlock).with("safepassword").and_return("gmail:gmailpassword")
-    @guard.retrieve_data("safepassword").should eql Hash["gmail" => "gmailpassword"]
-  end
-  it "should empty the safe" do 
-    STDIN.stub(:gets).and_return("Y")
-    @guard.safe.stub(:empty?).and_return false
-    $stdout.should_receive(:puts).with("Are you sure? (y|Y)")
-    @guard.safe.should_receive(:empty_safe)
-    $stdout.should_receive(:puts).with("Safe was emptied!")
-    @guard.empty_safe
-  end
-  it "should remove key value from safe" do
-    @guard.stub(:retrieve_data).with("safepassword").and_return Hash["gmail" => "gmailpassword", "facebook" => "facebookpassword"]
-    $stdout.should_receive(:puts).with("Deleting gmail and related password")
-    @guard.safe.should_receive(:lock).with("facebook:facebookpassword\n", "safepassword")
-    @guard.arg = "gmail"
-    @guard.remove_key_value "safepassword"
-  end
-  it "should remove the safe" do
-    @guard.safe.stub(:self_destruct)
-    @guard.safe.should_receive(:self_destruct)
-    $stdout.should_receive(:puts).with("The safe has been removed!")
-    @guard.remove_safe
-  end
-end