pwss 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8f78fcbff78980c4edaffd950cdab7ac876c2f1
+  data.tar.gz: c879c1fe675758b9933c74407d22eaec423e2778
+SHA512:
+  metadata.gz: 3fb10913eda71dd03f138e5355735657a5b0bfe234932405522474bd5ad94bc4545ac6ce14b6b30e8c78496e6afc83f435d40888ba1d64703fced8d4372f8f24
+  data.tar.gz: dd675b3508cc93830808818e97cb21282120b83412a3b86f9c8f8ae4f51a9a9acb0c799d37765e405072e828d3eda0bdb9bac183cd6ac200d3460dd4777ac58f

data/.gitignore

@@ -0,0 +1,20 @@
+*~
+.DS_Store
+
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Adolfo Villafiorita
+
+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.textile

@@ -0,0 +1,135 @@
+h1. Pwss
+
+A password manager in the spirit of "pws":https://github.com/janlelis/pws.
+
+Features:
+
+* Multiple entries can be stored in a single file
+* Entries are "complex" records, including title, username, password, url, description
+* Support for multiple password files
+* The password file can be stored encrypted or not
+* The password file is human-readable and editable (when not encrypted)
+* Decrypt and encrypt commands allow one to operate directly on the password file
+
+h2. Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pwss'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pwss
+
+h2. Usage
+
+*Getting started.* @pwss@ stores passwords in YAML files (also called "password safe" in the following), possibly encrypted.
+
+A typical usage scenario is the following:
+
+# @pwss init@ will create a new encrypted password safe in @~/.pwss.yaml.enc@
+# @pwss add@ will add a new entry to the file
+# @pwss get entry@ will retrieve all entries whose *title* contains @entry@
+
+*Using multiple safes.* If you want to create your password safe in a different location, use the @-f@ (@--filename@) option:
+
+# @pwss -f MYFILE init@
+# @pwss -f MYFILE add@
+# @pwss -f MYFILE get@
+
+*Encrypted and Plain Files.* @pwss@ works equally well with encrypted and plain files.  More in detailes, the file extension determines whether @pwss@ tries to decrypt/encrypt the file or not.  Use @.enc@ to store password safes encrypted; any other extension will leave the file in plain format.
+
+For instance:
+
+<pre>
+  $ pwss -f a.yaml.enc init 
+</pre>
+
+will store the password in to encrypted file @a.yaml.enc@.
+
+By contrast,
+
+<pre>
+  $ pwss -f a.yaml get entry
+</pre>
+
+will try to retrieve @entry@ from file @a.yaml@, which is not encrypted.
+
+Encrypting important passwords is a good idea.  However, if you use @pwss@ to store non-critical infomation, prefer to edit the password safe with a text editor, or use another application for managing encryption and decryption, using @pwss@ with the file in plain format might be more convenient.
+
+*Moving from plain to encrypted.* Use the @encrypt@ and @decrypt@ commands at any time to move from the plain to the encrypted format.
+
+<pre>
+  $ pwss -f YOURFILE encrypt 
+</pre>
+
+will encrypt @YOURFILE@ while @decrypt@ will perform the opposite operation.
+
+*Starting from an Existing File.*  You can also start from an existing file, as long as it is an array of YAML records, each containing, at least, a @title@ and a @password@ field.  (See next section, for the file structure.)
+
+In this scenario, you can use the following commands to get started:
+
+# @pwss -f YOURFILE encrypt@ will encrypt your existing password file
+# @mv YOURFILE.enc ~/.pwss.yaml.enc@ moves the encrypted file to the default location (not necessary, but it simplifies the workflow)
+
+To add entries to the password safe, use the @add@ command.  If you prefer to operate on the file using a text editor, you can also use the @decrypt@ and @encrypt@ commands.
+
+*Getting Help.*
+
+<pre>
+  $ pwss
+</pre>
+
+will show all command options.
+
+h2. Under the Hood
+
+@pwss@ adopts a human-readable format for storing passwords, when the file is not encrypted, of course! (Unless you have mathematical super-powers and can read encrypted text.)
+
+The password files is a YAML file containing an array of entries.  By default, entries have the following records:
+
+* title
+* username
+* password
+* url
+* description
+
+Example
+
+<pre>
+- title: A webservice
+  username: username@example.com
+  password: 1234567890
+  url: http://www.example.com
+  description: >
+    with a password like the one above, who needs a password safe
+
+- title: My email
+  username: username@example.com
+  password: 1234567890
+  url: http://www.example.com
+  description: >
+    Also available via email client, with the following connection parameters
+    smtp.example.com
+    imap.example.com
+</pre>
+
+Notice that only @title@ and @password@ are required.
+
+h2. License and Additional Disclaimer
+
+Licensed under the terms of the MIT License.
+
+*Make sure you backup your important data and do not rely solely on @pwss@ to store your critical data.*
+
+h2. Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/pwss/fork )
+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 @@
+require "bundler/gem_tasks"

data/bin/pwss

@@ -0,0 +1,222 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'mercenary'
+require 'date'
+
+require "pwss"
+require "pwss/version"
+require "pwss/cipher"
+require "pwss/entry"
+require "pwss/fileops"
+
+Mercenary.program(:pwss) do |p|
+  DEFAULT_FILENAME = File.join(Dir.home, ".pwss.yaml.enc")
+
+  p.version Pwss::VERSION
+  p.description <<EOS
+PWSS is a password safe, in the spirit of pws
+
+Features:
+
+* Each entry stores: title, username, password, url, description
+* Many entries per file (or 'safe')
+* Management of different safes
+* Decrypt and encrypt commands to operate directly on safes
+* Safes are human-readable and editable (when not encrypted)
+* Safes can be stored encrypted or not
+EOS
+
+  p.syntax "pwss [global option] <subcommand> [options] args"
+  p.option 'filename', '--filename FILE', '-f FILE', 'Password file'
+
+  p.command(:init) do |c|
+    c.syntax "init"
+    c.description "Init a new password file"
+      
+    c.action do |args, opts|
+      filename = opts['filename']  || DEFAULT_FILENAME
+
+      empty_safe = "# safe created on #{Date.today}\n"
+
+      # check status of input file and encrypt if necessary
+      if FileOps::encrypted? filename then
+        password = Cipher::check_password
+        new_string = Cipher::encrypt empty_safe, password
+      else
+        new_string = empty_safe
+      end
+
+      FileOps::backup(filename) if File.exists?(filename)
+      FileOps::save filename, new_string
+
+      puts "New safe created in #{filename}"
+    end
+  end
+
+  p.command(:list) do |c|
+    c.syntax "list all entries"
+    c.description "List all entries in a safe"
+      
+    c.action do |args, opts|
+      filename = opts['filename']  || DEFAULT_FILENAME
+
+      string, _ = file2string filename
+      entries = YAML::load(string) || Array.new
+
+      Pwss::list entries
+    end
+  end
+
+  p.command(:get) do |c|
+    c.syntax "get string"
+    c.description "Get first entry matching string in title"
+    c.option 'interactive', '--interactive', '-i', 'Wait for user input to clean password.'
+
+    c.action do |args, opts|
+      filename = opts['filename']  || DEFAULT_FILENAME
+      interactive = opts['interactive']
+
+      string, _ = file2string filename
+      entries = YAML::load(string) || Array.new
+
+      Pwss::get args.join(" "), entries, interactive
+    end
+  end
+
+  p.command(:add) do |c|
+    c.syntax "add an entry"
+    c.description "Add an entry to a password safe"
+      
+    c.action do |args, opts|
+      filename = opts['filename'] || DEFAULT_FILENAME
+      string, password = file2string filename
+
+      # ask for a new entry
+      pe = Pwss::Entry.new
+      pe.ask
+
+      # add the entry to the safe
+      entries = YAML::load(string) || Array.new
+      entries << pe.entry
+
+      # check status of input file and encrypt if necessary
+      if FileOps::encrypted? filename then
+        new_string = Cipher::encrypt entries.to_yaml, password
+      else
+        new_string = entries.to_yaml
+      end
+
+      FileOps::backup filename
+      FileOps::save filename, new_string
+    end
+  end
+
+  p.command(:update) do |c|
+    c.syntax "update the password for an entry"
+    c.description "Update the password for an entry"
+
+    c.action do |args, opts|
+      filename = opts['filename'] || DEFAULT_FILENAME
+      string, password = file2string filename
+
+      # load entries and update 
+      entries = YAML::load(string) || Array.new
+      entries = Pwss::update args.join(" "), entries
+
+      # check status of input file and encrypt if necessary
+      if FileOps::encrypted? filename then
+        new_string = Cipher::encrypt entries.to_yaml, password
+      else
+        new_string = entries.to_yaml
+      end
+
+      FileOps::backup filename
+      FileOps::save filename, new_string
+    end
+  end    
+
+
+  p.command(:destroy) do |c|
+    c.syntax "delete an entry"
+    c.description "Permenently delete an entry from a safe"
+      
+    c.action do |args, opts|
+      filename = opts['filename'] || DEFAULT_FILENAME
+
+      string, password = file2string filename
+      entries = YAML::load(string)
+
+      entries = Pwss::destroy args.join(" "), entries
+      
+      # check status of input file and encrypt if necessary
+      if FileOps::encrypted? filename then
+        new_string = Cipher::encrypt entries.to_yaml, password
+      else
+        new_string = entries.to_yaml
+      end
+
+      FileOps::backup filename
+      FileOps::save filename, new_string
+    end
+  end
+  
+
+  #
+  # Operations on the master file
+  #
+
+  p.command(:encrypt) do |c|
+    c.syntax "encrypt"
+    c.description "Encrypt a password safe"
+      
+    c.action do |_, opts|
+      filename = opts['filename'] || DEFAULT_FILENAME.sub(/\.enc$/, "")
+
+      password = Cipher::check_password
+      data = FileOps::load filename
+      encrypted = Cipher::encrypt data, password
+
+      enc_filename = filename + ".enc"
+      FileOps::save enc_filename, encrypted
+      puts "An encrypted copy now lives in #{enc_filename}"
+      puts "You might want to check everything is ok and delete the plain file: #{filename}"
+    end
+  end
+
+  p.command(:decrypt) do |c|
+    c.syntax "decrypt"
+    c.description "Decrypt a password safe"
+      
+    c.action do |_, opts|
+      filename = opts['filename'] || DEFAULT_FILENAME
+
+      password = Cipher::ask_password
+      data = FileOps::load filename
+      decrypted = Cipher::decrypt data, password
+
+      dec_filename = filename.sub(/\.enc$/,"")
+      FileOps::save dec_filename, decrypted
+      puts "A decrypted copy now lives in #{dec_filename}"
+    end
+  end
+
+  p.command(:help) do |c|
+    c.action do |_,_|
+      puts p.to_s
+    end
+  end
+
+  p.default_command(:help)
+
+  # load filename and decrypt, if necessary
+  # return the filename as string and the password (in case you need to save)
+  def file2string filename
+    string = FileOps::load filename
+    if FileOps::encrypted? filename then
+      password = Cipher::ask_password
+      string = Cipher::decrypt string, password
+    end
+    [string, password]
+  end
+end

data/lib/pwss.rb

@@ -0,0 +1,110 @@
+require 'yaml'
+
+#
+# This module reasons at the entries level
+# (list of entry)
+#
+
+module Pwss
+
+  WAITING_PERIOD=30 # seconds
+
+  def self.get search_string, entries, interactive
+    id = choose_entry search_string, entries
+
+    # it causes confusion ... here id is the absolute id
+    # (the one printed by choose_entry is the relative match)
+    # puts "Selected entry:\n"
+    # print_entry id, entries[id]
+
+    #
+    # make the password available and then forget it
+    #
+    password = entries[id]["password"]
+    system("echo #{password} | pbcopy")
+
+    if interactive
+      puts "\nPassword available in clipboard: press any key when you are done."
+      STDIN.getc
+    else
+      puts "\nPassword available in clipboard for #{WAITING_PERIOD} seconds."
+      sleep(WAITING_PERIOD)
+    end
+
+    system("echo ahahahahaha | pbcopy")
+  end
+
+
+  def self.update search_string, entries
+    id = choose_entry search_string, entries
+    password = Cipher::check_password
+    entries[id]["password"] = password
+    entries
+  end
+    
+
+  def self.destroy search_string, entries
+    id = choose_entry search_string, entries
+    entries.delete_at(id) if id != -1
+    entries
+  end
+  
+
+  def self.list entries
+    index = 0
+    entries.each do |element|
+      print_entry index, element
+      index += 1
+    end
+  end
+
+  private
+
+  #
+  # Let the user select an entry from data
+  # (data is a YAML string with an array of entries)
+  #
+  def self.choose_entry search_string, entries
+    # here we have a nuisance: we want the user to choose one entry
+    # by relative id (e.g. the third found), but we need to return
+    # the absolute id... so we just keep track of the real ids with an array
+    # we ask the user the index of the array
+
+    index = 0
+    found = Array.new
+    entries.each do |entry|
+      if entry["title"].downcase.include?(search_string.downcase)
+        print_entry found.size, entry
+        found << index
+      end
+      index += 1
+    end
+
+    if found.size == 0 then
+      printf "\nNo entry matches the search criteria."
+      return -1
+    end
+
+    if found.size > 1 then
+      printf "\nVarious matches. Select entry by ID (0..#{found.size-1}): "
+      id = STDIN.gets.chomp.to_i
+    else
+      id = 0
+    end
+
+    found[id]
+  end
+
+  #
+  # Print entry
+  #
+  def self.print_entry id, element
+    puts "\n---\nENTRY ID: #{id}"
+    # we need to duplicate, because deletion in place will remove
+    # passwords from entries (and, frankly, we need them)
+    new_el = element.dup
+    new_el.delete("password")
+    puts new_el.to_yaml
+  end
+  
+end

data/lib/pwss/cipher.rb

@@ -0,0 +1,40 @@
+require 'encryptor'
+ 
+#
+# Cipher does encryption and decryption of data
+# It reasons at the string level (both in input and in output)
+#
+module Cipher
+  def self.encrypt string, password
+    Encryptor.encrypt(:value => string, :key => password)
+  end
+
+  def self.decrypt string, password
+    Encryptor.decrypt(:value => string, :key => password)
+  end
+
+  # Ask for a password fom the command line
+  def self.ask_password prompt="Enter master password: "
+    printf prompt
+    system "stty -echo"
+    password = $stdin.gets.chomp
+    system "stty echo"
+    puts ""
+    password
+  end
+
+  # Ask for a password twice and make sure it is entered the same
+  def self.check_password prompt="master password: "
+    match = false
+    while ! match
+      password = ask_password "Enter #{prompt}"
+      repeat = ask_password "Repeat #{prompt}"
+      match = (password == repeat)
+
+      if match == false then
+        puts "Error! Password do not match.  Please enter them again."
+      end
+    end
+    password
+  end
+end

data/lib/pwss/entry.rb

@@ -0,0 +1,52 @@
+module Pwss
+  #
+  # Entry manages an entry in the password safe
+  # It is a wrapper to a Hash
+  #
+  class Entry
+    INPUT_F=0
+    DEFAULT=1
+    PROMPT=2
+
+    # the fields of an entry, together with the function to ask the, default value, and prompt
+    FIELDS = {
+      "title"       => ["gets.chomp", "'title'", "title: "], 
+      "username"    => ["gets.chomp", "''", "username: "],
+      "password"    => ["Cipher.check_password('password for entry: ')", "''", ""],
+      "added"       => ["", "Date.today.to_s", ""],
+      "url"         => ["gets.chomp", "''", "url: "],
+      "description" => ["get_lines",   "''", "description (terminate with '.'):\n"]
+    }
+
+    # the values (a Hash) of this issue
+    attr_reader :entry
+
+    def initialize
+      @entry = Hash.new
+    end
+
+    # interactively ask from command line all fields specified in FIELDS
+    def ask
+      FIELDS.keys.each do |key|
+        printf "#{FIELDS[key][PROMPT]}" if FIELDS[key][PROMPT] != ""
+        @entry[key] = (eval FIELDS[key][INPUT_F]) || (eval FIELDS[key][DEFAULT])
+      end
+    end
+    
+    # initialize all fields with the default values
+    # (and set title to the argument)
+    # def set_fields title
+    #   FIELDS.keys.each do |k|
+    #     @entry[k] = eval(FIELDS[k][DEFAULT])
+    #   end
+    #   @entry['title'] = title
+    # end
+
+    # read n-lines (terminated by a ".")
+    def get_lines
+      $/ = "\n.\n"  
+      STDIN.gets.chomp("\n.\n")
+    end
+
+  end
+end

data/lib/pwss/fileops.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+#
+# From file to string and back
+# There is no lower level than this
+#
+module FileOps
+  # load a file into a string
+  def self.load filename
+    file = File.open(filename, "rb")
+    file.read
+  end
+
+  # save a string to a file
+  def self.save filename, data
+    file = File.open(filename, "wb")
+    file.write data
+    file.close
+  end
+
+  # check if the extension is ".enc"
+  def self.encrypted? filename
+    File.extname(filename) == ".enc"
+  end
+
+  def self.backup filename
+    FileUtils::cp filename, filename + "~"
+  end
+  
+end
+

data/lib/pwss/version.rb

@@ -0,0 +1,3 @@
+module Pwss
+  VERSION = "0.0.2"
+end

data/pwss.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pwss/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pwss"
+  spec.version       = Pwss::VERSION
+  spec.authors       = ["Adolfo Villafiorita"]
+  spec.email         = ["adolfo.villafiorita@me.com"]
+  spec.summary       = %q{A password manager in the spirit of pwss}
+  spec.description   = %q{PWSS is a password safe, in the spirit of pws
+Distinguishing features:
+- all entries are stored in a single file
+- entries are "complex" records, with username, password, url, description
+- the safe file can be stored encrypted or not
+- decrypt and encrypt command allow to operate directly on the password file
+}
+  spec.homepage      = "http://www.github.com/avillafiorita/pwss"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency 'mercenary', '~> 0.3.3', '>= 0.3.3'
+  spec.add_runtime_dependency 'encryptor', '~> 1.3.0', '>= 1.3.0'     
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: pwss
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Adolfo Villafiorita
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mercenary
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: encryptor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: |
+  PWSS is a password safe, in the spirit of pws
+  Distinguishing features:
+  - all entries are stored in a single file
+  - entries are "complex" records, with username, password, url, description
+  - the safe file can be stored encrypted or not
+  - decrypt and encrypt command allow to operate directly on the password file
+email:
+- adolfo.villafiorita@me.com
+executables:
+- pwss
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.textile
+- Rakefile
+- bin/pwss
+- lib/pwss.rb
+- lib/pwss/cipher.rb
+- lib/pwss/entry.rb
+- lib/pwss/fileops.rb
+- lib/pwss/version.rb
+- pwss.gemspec
+homepage: http://www.github.com/avillafiorita/pwss
+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: A password manager in the spirit of pwss
+test_files: []