perfect_world 0.1.1 → 0.2.0

data/README.md

@@ -1,5 +1,7 @@
 # Perfect World Manager (pwm)
 
+![build status](https://api.travis-ci.org/ushis/perfect_world.png)
+
 The perfect world manager is the attempt to build a simple but secure
 password manager for the cli.
 

data/bin/pwm

@@ -2,12 +2,21 @@
 
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
-require 'psych'
 require 'optparse'
-require 'gpgme'
-require 'perfect_world'
+
+require 'psych'
+require 'psych/syntax_error'
+
+require 'perfect_world/cli'
+require 'perfect_world/error'
 require 'perfect_world/version'
 
+# Suicide helper.
+def die(message, status = 1)
+  $stderr.puts message
+  exit status
+end
+
 # Lets parse some options.
 options = {}
 
@@ -76,39 +85,26 @@ end
 begin
   parser.parse!
 rescue OptionParser::ParseError
-  $stderr.puts parser.help
-  exit(1)
+  die parser.help
 end
 
-# Load the config file.
-config = File.expand_path(options.fetch(:config, '~/.pwmrc'))
-config = File.file?(config) ? Psych.load_file(config) : {}
+# Load config file
+config_file = File.expand_path(options.fetch(:config, '~/.pwmrc'))
 
-# Override config with options.
-[:clipboard, :database, :gpgdir, :length, :owner].each do |option|
-  config[option.to_s] = options.delete(option) unless options[option].nil?
+begin
+  config = File.exist?(config_file) ? Psych.load_file(config_file) : {}
+rescue SystemCallError, Psych::Exception, Psych::SyntaxError => e
+  die "Couldn't load config file: #{e.message}"
 end
 
-# Set GPG dir.
-if (dir = config.delete('gpgdir'))
-  GPGME::Engine.home_dir = dir
+# Override config with command line options.
+[:clipboard, :database, :gpgdir, :length, :owner].each do |option|
+  config[option.to_s] = options.delete(option) unless options[option].nil?
 end
 
 # Action!
-pwm = PerfectWorld::Manager.new(config)
-
-options.each do |key, value|
-  case key
-  when :backup    then pwm.save(value)
-  when :database  then pwm.print_config('database')
-  when :delete    then pwm.delete(value)
-  when :generate  then pwm.generate(value)
-  when :get       then pwm.get(value)
-  when :length    then pwm.print_config('length')
-  when :list      then pwm.list
-  when :owner     then pwm.print_config('owner')
-  end
+begin
+  PerfectWorld::Cli.new(config).run(options)
+rescue PerfectWorld::Error => e
+  die e.message
 end
-
-# Closing time.
-pwm.close

data/lib/perfect_world.rb

@@ -1 +1 @@
-require 'perfect_world/manager'
+require 'perfect_world/db'

data/lib/perfect_world/cli.rb

@@ -0,0 +1,107 @@
+require 'gpgme'
+require 'clipboard'
+
+require 'perfect_world/db'
+require 'perfect_world/error'
+require 'perfect_world/storage'
+
+module PerfectWorld
+
+  class Cli
+
+    # Default config.
+    CONFIG = {
+      'length' => 64,
+      'database' => File.expand_path('~/.pwm.yml.gpg'),
+      'clipboard' => false
+    }
+
+    # Sets the config.
+    def initialize(config = {})
+      @config = CONFIG.merge(config)
+      GPGME::Engine.home_dir = @config['gpgdir'] if @config.key?('gpgdir')
+    end
+
+    # Loads the database and executes the provided commands.
+    def run(commands)
+      DB.open(@config.fetch('database'), @config['owner']) do |db|
+        commands.each { |cmd, arg| send(cmd, db, arg) }
+      end
+    end
+
+    private
+
+    # Saves db to another location.
+    def backup(db, path)
+      db.save(path, @config['owner'])
+    end
+
+    # Prints the path to the currently used database.
+    def database(_ = nil, _ = nil)
+      print_config('database')
+    end
+
+    # Deletes a password.
+    def delete(db, id)
+      if db.delete(id)
+        puts "Deleted the password for '#{id}'."
+      else
+        password_not_found(id)
+      end
+    end
+
+    # Generats a new password and sends it to stdout.
+    def generate(db, id)
+      print_or_copy_to_clipboard(id, db.generate(id, @config.fetch('length')))
+    rescue Error => e
+      raise Error, "Couldn't create password: #{e.message}"
+    end
+
+    # Fetches the password and sends it to stdout.
+    def get(db, id)
+      print_or_copy_to_clipboard(id, db.fetch(id))
+    rescue KeyError
+      password_not_found(id)
+    end
+
+    # Prints the currently used password length.
+    def length(_ = nil, _ = nil)
+      print_config('length')
+    end
+
+    # Lists all passwords.
+    def list(db, _ = nil)
+      db.each { |id, password| print_password(id, password) }
+    end
+
+    # Prints the current key owner.
+    def owner(_ = nil, _ = nil)
+      puts Storage.find_key(@config['owner']).email
+    end
+
+    # Raises an error with a proper message.
+    def password_not_found(id)
+      raise Error, "Couldn't find the password for '#{id}'."
+    end
+
+    # Prints a password or copies it to the clipboard.
+    def print_or_copy_to_clipboard(id, password)
+      if @config.fetch('clipboard')
+        Clipboard.copy(password)
+        puts "Copied the password for '#{id}' to your clipboard."
+      else
+        print_password(id, password)
+      end
+    end
+
+    # Prints a password.
+    def print_password(id, password)
+      puts "#{password}   #{id}"
+    end
+
+    # Prints a config entry.
+    def print_config(key)
+      puts @config[key]
+    end
+  end
+end

data/lib/perfect_world/db.rb

@@ -0,0 +1,108 @@
+require 'perfect_world/error'
+require 'perfect_world/random'
+require 'perfect_world/storage'
+
+module PerfectWorld
+
+  # Handles the password database.
+  class DB
+
+    def self.open(path, owner = nil)
+      db = File.exist?(path) ? load(path) : new({})
+
+      if block_given?
+        yield(db)
+        db.save(path, owner) if db.changed?
+      else
+        db
+      end
+    end
+
+    # Loads the database.
+    def self.load(path)
+      passwords = Storage.load(path)
+
+      valid?(passwords) ? new(passwords) : raise(CorruptedDatabase, path)
+    rescue Error => e
+      raise Error, "Couldn't load database: #{e.message}"
+    end
+
+    # Checks if a password hash is valid. A valid object is a hash with
+    # string values.
+    #
+    # Returns true if it is valid else false.
+    def self.valid?(data)
+      data.is_a?(Hash) && data.values.all? { |v| v.is_a?(String) }
+    end
+
+    # Inits the db and sets the initial passwords.
+    def initialize(passwords = {})
+      @passwords = passwords
+      @changed = false
+    end
+
+    # Generates a new password and puts it in the database.
+    #
+    #   store.generate(:google, 32)
+    #   #=> "B6m/![)A%fqw,\\ti-d`4\"&0>gl+>$0$Z"
+    #
+    #   store[:google]
+    #   #=> "B6m/![)A%fqw,\\ti-d`4\"&0>gl+>$0$Z"
+    #
+    # Returns the new password.
+    def generate(id, len = 64)
+      @passwords[id] = Random.string(len)
+      @changed = true
+      @passwords[id]
+    end
+
+    # Returns the password for the id or nil, if not found.
+    def [](id)
+      @passwords[id]
+    end
+
+    # Fetches a password from the database. It behaves like Hash#fetch.
+    def fetch(id, *default)
+      @passwords.fetch(id, *default)
+    end
+
+    # Deletes the password from the database.
+    #
+    #   store.delete(:google)
+    #   #=> "B6m/![)A%fqw,\\ti-d`4\"&0>gl+>$0$Z"
+    #
+    #   store[:google]
+    #   #=> nil
+    #
+    # Returns nil if not found.
+    def delete(id)
+      if (password = @passwords.delete(id))
+        @changed = true
+        password
+      end
+    end
+
+    # Returns true, when the database has changed, else false.
+    def changed?
+      @changed
+    end
+
+    # Iterates over all passwords.
+    #
+    #   store.each do |id, password|
+    #     puts "#{password}   #{id}"
+    #   end
+    #
+    # Returns an enumerator, if no block is given.
+    def each(&block)
+      @passwords.each(&block)
+    end
+
+    # Encryptes the database and writes it to disk.
+    def save(path, owner = nil)
+      Storage.dump(@passwords, owner, path)
+    rescue Error => e
+      raise Error, "Couldn't save database: #{e.message}"
+    end
+  end
+end

data/lib/perfect_world/error.rb

@@ -9,4 +9,11 @@ module PerfectWorld
       super("Couldn't find key for '#{owner}'.")
     end
   end
+
+  # Should be raised if a database corruption is detected.
+  class CorruptedDatabase < Error
+    def initialize(database)
+      super("Database seems corrupted: #{database}")
+    end
+  end
 end

data/lib/perfect_world/random.rb

@@ -0,0 +1,27 @@
+require 'securerandom'
+require 'perfect_world/error'
+
+module PerfectWorld
+
+  # Random string generator.
+  module Random
+
+    # Generates a random string with of a specified length (64 by default).
+    #
+    #   PerfectWorld::Random.string(32)
+    #   #=> "XzKk#~c\"Q(e2~8Bb#HO;v$}Jdid16-gO"
+    #
+    # Returns a string.
+    def self.string(len = 64)
+      s = String.new
+
+      while s.length < len
+        s << SecureRandom.random_bytes(len * 3).gsub(/[^[:print:]]/, '')
+      end
+
+      s[0..(len - 1)]
+    rescue SystemCallError, NotImplementedError => e
+      raise Error, e.message
+    end
+  end
+end

data/lib/perfect_world/storage.rb

@@ -0,0 +1,87 @@
+require 'psych'
+require 'psych/syntax_error'
+require 'gpgme'
+require 'perfect_world/error'
+
+module PerfectWorld
+
+  class Storage
+
+    class << self
+
+      # Loads data from an encrypted file.
+      #
+      #   PerfectWorld::Storage.load('path/to/file.yml.gpg')  #=> [1, 2]
+      #
+      # Returns the data.
+      def load(path)
+        open(path) do |file|
+          deserialize(decrypt(file))
+        end
+      end
+
+      # Writes data into an encrypted file.
+      #
+      #   PerfectWorld::Storage.dump([1, 2], 'gpguid', /path/to/file.yml.gpg')
+      #
+      # Raises PerfectWorld::Error on error.
+      def dump(data, recipient, path)
+        commit(encrypt(serialize(data), find_key(recipient)), path)
+      end
+
+      # Finds a secret key in the key ring.
+      #
+      # Returns GPGME::Key or raises PerfectWorld::KeyNotFound.
+      def find_key(term = nil)
+        GPGME::Key.find(:secrect, term).first || raise(KeyNotFound, term)
+      end
+
+      private
+
+      def open(path)
+        File.open(path, 'r') do |f|
+          f.flock(File::LOCK_SH)
+          yield(f)
+        end
+      rescue SystemCallError, IOError => e
+        raise Error, e.message
+      end
+
+      def commit(data, path)
+        File.open(path, File::RDWR|File::CREAT, 0600) do |f|
+          f.flock(File::LOCK_EX)
+          f.truncate(0)
+          f.write(data)
+        end
+      rescue SystemCallError, IOError => e
+        raise Error, e.message
+      end
+
+      def serialize(data)
+        Psych.dump(data)
+      rescue Psych::Exception => e
+        raise Error, e.message
+      end
+
+      def deserialize(data)
+        Psych.load(data)
+      rescue Psych::Exception, Psych::SyntaxError => e
+        raise Error, e.message
+      end
+
+      def encrypt(data, key)
+        GPGME::Crypto.new(key: key).encrypt(data, recipients: key, sign: true)
+      rescue GPGME::Error => e
+        raise Error, e.message
+      end
+
+      def decrypt(data)
+        GPGME::Crypto.new.decrypt(data) do |signature|
+          raise(CorruptedDatabase, 'Invalid signature.') unless signature.valid?
+        end.to_s
+      rescue GPGME::Error => e
+        raise Error, e.message
+      end
+    end
+  end
+end

data/lib/perfect_world/version.rb

@@ -1,3 +1,3 @@
 module PerfectWorld
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: perfect_world
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -36,7 +36,7 @@ cert_chain:
   bjRVQmxyeTVQVzB6ZzY0VEk5L1AzNEFHUXQ2SStUOHMKQnh0dUdkZ0YyMkpt
   M3ZYbGlySkJJSStvMDdIeDV3ZjJEUGRDMTRKRU1UUVZoRVFkc2ZwbU9ub2Q0
   SnpLdWRxNwpES1U9Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K
-date: 2013-02-03 00:00:00.000000000 Z
+date: 2013-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gpgme
@@ -78,10 +78,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/perfect_world/store.rb
+- lib/perfect_world/cli.rb
+- lib/perfect_world/storage.rb
 - lib/perfect_world/version.rb
+- lib/perfect_world/random.rb
+- lib/perfect_world/db.rb
 - lib/perfect_world/error.rb
-- lib/perfect_world/manager.rb
 - lib/perfect_world.rb
 - bin/pwm
 - README.md

data/lib/perfect_world/manager.rb

@@ -1,95 +0,0 @@
-require 'clipboard'
-require 'perfect_world/store'
-require 'perfect_world/error'
-
-module PerfectWorld
-
-  # Manages our perfec world store.
-  class Manager
-
-    # Default options.
-    OPTIONS = {
-      'length' => 64,
-      'database' => File.expand_path('~/.pwm.yml.gpg'),
-      'clipboard' => false
-    }
-
-    # Inits our perfect world.
-    def initialize(options = {})
-      @options = OPTIONS.merge(options)
-      db = @options.fetch('database')
-      @store = File.file?(db) ? Store.load(db) : Store.new({})
-    rescue Error => e
-      die("Couldn't load database: " << e.message)
-    end
-
-    # Fetches the password and sends it to stdout.
-    def get(id)
-      print_or_copy_to_clipboard(id, @store.fetch(id))
-    rescue KeyError
-      not_found(id)
-    end
-
-    # Generats a new password and sends it to stdout.
-    def generate(id)
-      print_or_copy_to_clipboard(id, @store.create(id, @options.fetch('length')))
-    rescue Error => e
-      $stderr.puts("Couldn't create password: " << e.message)
-    end
-
-    # Deletes a password.
-    def delete(id)
-      if @store.delete(id)
-        puts "Deleted the password for '#{id}'."
-      else
-        not_found(id)
-      end
-    end
-
-    # Lists all passwords.
-    def list
-      @store.each { |id, password| print_password(id, password) }
-    end
-
-    # Prints the path to the currently used database.
-    def print_config(key)
-      puts @options[key]
-    end
-
-    def close
-      save(@options.fetch('database')) if @store.changed?
-    end
-
-    def save(database)
-      @store.save(database, @options['owner'])
-    rescue Error => e
-      die("Couldn't save database: " << e.message)
-    end
-
-    private
-
-    def die(message)
-      $stderr.puts(message)
-      exit(1)
-    end
-
-    # Sends a not found message to stderr.
-    def not_found(id)
-      $stderr.puts "Couldn't find the password for '#{id}'."
-    end
-
-    def print_or_copy_to_clipboard(id, password)
-      if @options.fetch('clipboard')
-        Clipboard.copy(password)
-        puts "Copied the password for '#{id}' to your clipboard."
-      else
-        print_password(id, password)
-      end
-    end
-
-    # Prints a password.
-    def print_password(id, password)
-      puts "#{password}   #{id}"
-    end
-  end
-end

data/lib/perfect_world/store.rb

@@ -1,100 +0,0 @@
-require 'securerandom'
-require 'psych'
-require 'gpgme'
-require 'perfect_world/error'
-
-module PerfectWorld
-
-  # Handles the password database.
-  class Store
-
-    # Loads the database and returns a new store.
-    def self.load(database)
-      File.open(database, 'r') do |f|
-        f.flock(File::LOCK_SH)
-        new(Psych.load(GPGME::Crypto.new.decrypt(f).to_s))
-      end
-    rescue SystemCallError, IOError, GPGME::Error, Psych::Exception => e
-      raise Error, e.message
-    end
-
-    # Inits the store and sets the initial passwords.
-    def initialize(passwords = {})
-      @passwords = passwords
-      @changed = false
-    end
-
-    # Generates a new password and puts it in the store.
-    #
-    # Returns the new password.
-    def create(id, len = 64)
-      @passwords[id] = generate(len)
-      @changed = true
-      @passwords[id]
-    end
-
-    # Returns the password for the id or nil, if not found.
-    def [](id)
-      @passwords[id]
-    end
-
-    # Fetches a password from the store. It behaves like Hash#fetch.
-    def fetch(id, *default)
-      @passwords.fetch(id, *default)
-    end
-
-    # Deletes the password from the store.
-    #
-    # Returns nil if not found.
-    def delete(id)
-      if (password = @passwords.delete(id))
-        @changed = true
-        password
-      end
-    end
-
-    # Returns true, when the store has changed, else false.
-    def changed?
-      @changed
-    end
-
-    # Iterates over all passwords.
-    def each(&block)
-      @passwords.each(&block)
-    end
-
-    # Encryptes the database and writes it to disk.
-    def save(database, owner = nil)
-      key = key_for(owner)
-
-      File.open(database, File::RDWR|File::CREAT, 0600) do |f|
-        yaml = Psych.dump(@passwords)
-        f.flock(File::LOCK_EX)
-        f.truncate(0)
-        f << GPGME::Crypto.new(key: key).encrypt(yaml, recipients: key)
-      end
-    rescue SystemCallError, IOError, Psych::Exception, GPGME::Error => e
-      raise Error, e.message
-    end
-
-    # Generates a new password and returns it.
-    def generate(len = 64)
-      password = ''
-
-      begin
-        password << SecureRandom.random_bytes(len * 3).gsub(/[^[:print:]]/, '')
-      end while password.length < len
-
-      password[0..(len - 1)]
-    rescue SystemCallError, NotImplementedError => e
-      raise Error, e.message
-    end
-
-    private
-
-    # Returns the key for an owner.
-    def key_for(owner)
-      GPGME::Key.find(:secret, owner).first || raise(KeyNotFound, owner)
-    end
-  end
-end