kbsecret 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9587292e2be80b4a53d26f4bdda06e2a94d1b7be
+  data.tar.gz: 5dd01f1c1819f0f17537487ff73e621e27193938
+SHA512:
+  metadata.gz: 4227a95d277ed064a5cd1b4dd3add4dedcabb97d041c66c5dffec753a87ab0de73684582a4d18e34bd33c192912d54dc173527516daa10a172dbd19d55e73574
+  data.tar.gz: b14e1d1524a71d70e85185c7c61c43a3791923c5698273b68398b6dcf1d072a682a3f7bfb695666d1cd25819812d740e5cf150c71142571d741dd5e426091845

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup-provider=redcarpet --markup=markdown - *.md LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 William Woodruff <william @ tuffbizz.com>
+
+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.md

@@ -0,0 +1,66 @@
+kbsecret
+========
+
+kbsecret is a combined library/utility that provides a secret management
+interface for [KBFS](https://keybase.io/docs/kbfs) and
+[Keybase](https://keybase.io/).
+
+### Benefits over current offerings
+
+* Easy password and environment sharing across multiple users.
+  - `kbsecret -s dev-team login github` prints the dev team's GitHub login.
+* No PGP/SSH key setup necessary - you only need a Keybase account.
+  - No more worrying about losing your key.
+* Transparent access - KBFS provides a VFS layer over all reads/writes.
+  - All records are stored encrypted on KBFS.
+
+### Installation
+
+kbsecret is available via RubyGems:
+
+```bash
+$ gem install kbsecret
+```
+
+For hacking:
+
+```bash
+$ git clone git@github.com:woodruffw/kbsecret.git && cd kbsecret
+$ RUBYLIB=./lib PATH=${PATH}:./bin ./bin/kbsecret help
+```
+
+### Usage
+
+```bash
+# create a new login record under the default session
+$ kbsecret new login gmail "foo@example.com" "barbazquux"
+
+# list all records under the default session
+$ kbsecret list
+gmail
+
+# show the requested login record
+$ kbsecret login gmail
+Label: gmail
+	Username: foo@example.com
+	Password: barbazquux
+
+# create a new session between 3 keybase users (foo, bar, and baz)
+$ kbsecret new-session -l dev-team -u foo,bar,baz
+
+# list available sessions
+$ kbsecret sessions
+default
+dev-team
+
+# add an environment record to the dev-team session
+$ kbsecret new environment API_KEY 0xBADBEEF -s dev-team
+
+# list all records under the dev-team session
+$ kbsecret list -s dev-team
+API_KEY
+
+# get all environment records in dev-team in an easy-to-source format
+$ kbsecret env -s dev-team --all
+export API_KEY='0xBADBEEF'
+```

data/bin/kbsecret

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+
+BUILTIN_CMDS = [
+  "help",
+  "version",
+].freeze
+
+EXT_PATHS = ENV["PATH"].split(File::PATH_SEPARATOR).map do |path|
+  Dir[File.join(path, "kbsecret-*")]
+end.flatten.freeze
+
+EXT_CMDS = EXT_PATHS.map do |c|
+  File.basename(c, File.extname(c)).sub!("kbsecret-", "")
+end.freeze
+
+ALIASES = Hash.new { |_, k| k }.update({
+  "--help" => "help",
+  "-h" => "help",
+  "l" => "login",
+  "pw" => "login",
+  "del" => "rm",
+  "create" => "new",
+}).freeze
+
+ALL_CMDS = (ALIASES.keys + BUILTIN_CMDS + EXT_CMDS).freeze
+
+def external?(cmd)
+  EXT_CMDS.include?(cmd)
+end
+
+def builtin?(cmd)
+  BUILTIN_CMDS.include?(cmd)
+end
+
+def alias?(cmd)
+  ALIASES.keys.include?(cmd)
+end
+
+def normalize(cmd)
+  ALIASES[cmd]
+end
+
+def expand(cmd)
+  return cmd if alias?(cmd) || builtin?(cmd)
+  "kbsecret-#{cmd}"
+end
+
+def help(*args)
+  command = normalize args.shift
+  if command.nil?
+    puts <<~EOS
+      Usage:
+        kbsecret <command> <args ...>
+
+      Available commands:
+        #{ALL_CMDS.join(", ")}
+
+      More more information about a particular command, try:
+        kbsecret help <command>
+    EOS
+  else
+    if builtin? command
+      send "#{command}_help"
+    else
+      system expand(command), "--help"
+    end
+  end
+end
+
+# lol
+def help_help
+  puts <<~EOS
+    Prints brief help for the given command.
+
+    Usage:
+      kbsecret help <command>
+
+    For a list of all commands, see:
+      kbsecret help
+  EOS
+end
+
+def version(*args)
+  puts <<~EOS
+    kbsecret version #{KBSecret::VERSION}.
+  EOS
+end
+
+def version_help
+  puts <<~EOS
+    Prints kbsecret's version.
+
+    Usage:
+      kbsecret version
+  EOS
+end
+
+command = normalize(ARGV.shift || "help")
+
+if builtin? command
+  send command, *ARGV
+elsif external? command
+  system expand(command), *ARGV
+else
+  STDERR.puts "Fatal: Unknown command: '#{command}'."
+end

data/bin/kbsecret-env

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    Retrieve environment records in a source-able format.
+
+    Usage:
+      kbsecret env [--session <name>] [--all] <label1 label2 ...>
+
+    Examples:
+      kbsecret env --all
+      kbsecret env staging beta
+  EOS
+
+  o.string "-s", "--session", "the session name", default: :default
+  o.bool "-a", "--all", "retrieve all environment records, not just listed ones"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+sess_name = opts[:session]
+
+unless KBSecret::Config.session? sess_name
+  abort "Fatal: Unknown session: '#{sess_name}'."
+end
+
+session = KBSecret::Session.new label: sess_name
+
+env_records = session.records.select { |r| r.type == "environment" }
+
+if opts.all?
+  selected_records = env_records
+else
+  selected_labels = opts.args.uniq
+
+  # instead of complaining about nonexistent records, just ignore them
+  selected_records = selected_labels.map do |l|
+    env_records.find { |r| r.label == l }
+  end.compact
+end
+
+env_records.each do |record|
+  puts record.to_export
+end

data/bin/kbsecret-list

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    List all secrets known to the specified session (or the default session).
+
+    Usage:
+      kbsecret list [--session <name>] [--show-all]
+  EOS
+
+  o.string "-s", "--session", "the session name", default: :default
+  o.bool "-a", "--show-all", "show everything in each secret (i.e. metadata)"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+sess_name = opts[:session]
+
+unless KBSecret::Config.session? sess_name
+  abort "Fatal: Unknown session: '#{sess_name}'."
+end
+
+session = KBSecret::Session.new label: sess_name
+
+session.records.each do |record|
+  line = "#{record.label}\n"
+  line << <<~EOS if opts.show_all?
+    \tType: #{record.type}
+    \tLast changed: #{Time.at(record.timestamp)}
+    \tRaw data: #{record.data}
+  EOS
+
+  puts line
+end
+

data/bin/kbsecret-login

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    Retrieve login records.
+
+    Usage:
+      kbsecret env [--session <name>] <label1 label2 ...>
+
+    Examples:
+      kbsecret login gmail
+      kbsecret login gmail netflix
+  EOS
+
+  o.bool "-a", "--all", "retrieve all login records, not just listed ones"
+  o.string "-s", "--session", "the session name", default: :default
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+sess_name = opts[:session]
+
+unless KBSecret::Config.session? sess_name
+  abort "Fatal: Unknown session: '#{sess_name}'."
+end
+
+session = KBSecret::Session.new label: sess_name
+
+login_records = session.records.select { |r| r.type == "login" }
+
+if opts.all?
+  selected_records = login_records
+else
+  selected_labels = opts.args.uniq
+
+  # instead of complaining about nonexistent records, just ignore them
+  selected_records = selected_labels.map do |l|
+    login_records.find { |r| r.label == l }
+  end.compact
+end
+
+selected_records.each do |record|
+  puts <<~EOS
+    Label: #{record.label}
+    \tUsername: #{record.username}
+    \tPassword: #{record.password}
+  EOS
+end

data/bin/kbsecret-new

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    Create a new secret record.
+
+    Usage:
+      kbsecret new [--session <name>] [--force] <type> <label> <args ...>
+
+    Examples:
+      kbsecret new login gmail "foo@bar.com" "mytopsecretpassword"
+      kbsecret new environment API_KEY "abcdef-0123456789"
+  EOS
+
+  o.string "-s", "--session", "the session name", default: :default
+  o.bool "-f", "--force", "force creation (ignore overwrites, etc.)"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+sess_name = opts[:session]
+
+unless KBSecret::Config.session? sess_name
+  abort "Fatal: Unknown session: '#{sess_name}'."
+end
+
+abort "Fatal: Not enough arguments." if opts.args.size < 2
+
+session = KBSecret::Session.new label: sess_name
+type, label = opts.args.shift 2
+
+if session.record?(label) && !opts.force?
+  abort "Fatal: Refusing to overwrite an existing record without --force."
+end
+
+unless KBSecret::Record.type?(type)
+  abort <<~EOS
+    Fatal: Unknown record type: '#{type}'.
+    Known types are: #{KBSecret::Record.record_types.join(", ")}.
+  EOS
+end
+
+begin
+  session.add_record(type, label, *opts.args)
+rescue => e
+  abort "Fatal: #{e.to_s}."
+end

data/bin/kbsecret-new-session

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require "keybase"
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    Create a new session.
+
+    Usage:
+      kbsecret new-session --label <label> --users <user1,...> --root <dir>
+
+    Example:
+      kbsecret new-session -l dev -u me,otherperson -r devsecrets
+  EOS
+
+  o.string "-l", "--label", "the session label", default: :default
+  o.array "-u", "--users", "the keybase users", default: [Keybase.current_user]
+  o.string "-r", "--root", "the secret root directory", default: "kbsecret"
+  o.bool "-f", "--force", "force creation (ignore overwrites, etc.)"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+session_label = opts[:label]
+
+if KBSecret::Config.session?(session_label) && !opts.force?
+  abort "Fatal: Refusing to overwrite an existing session without --force."
+end
+
+session_hash = {
+  users: opts[:users],
+  root: opts[:root],
+}
+
+KBSecret::Config.add_session(session_label, session_hash)

data/bin/kbsecret-rm

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+require "tty-prompt"
+
+$VERBOSE = nil # tty-prompt blasts us with irrelevant warnings on 2.4
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    Delete a record.
+
+    Usage:
+      kbsecret rm [--session <name>] <label>
+  EOS
+
+  o.string "-s", "--session", "the session name", default: :default
+  o.bool "-i", "--interactive", "ask for confirmation before deleting"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+sess_name = opts[:session]
+
+unless KBSecret::Config.session? sess_name
+  abort "Fatal: Unknown session: '#{sess_name}'."
+end
+
+session = KBSecret::Session.new label: sess_name
+
+label = opts.args.shift
+
+abort "Fatal: I need the label of a record to delete." unless label
+
+tty = TTY::Prompt.new
+confirm = true
+
+if opts.interactive?
+  confirm = tty.yes?("Delete '#{label}' from the #{session.label} session?")
+end
+
+session.delete_record(label) if confirm

data/bin/kbsecret-sessions

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require "kbsecret"
+require "slop"
+
+opts = Slop.parse suppress_errors: true do |o|
+  o.banner = <<~EOS
+    List all available sessions.
+    The sessions listed can be passed to other commands via the -s flag.
+
+    Usage:
+      kbsecret sessions [--show-all]
+  EOS
+
+  o.bool "-a", "--show-all", "show each session in depth (i.e. metadata)"
+
+  o.on "-h", "--help" do
+    puts o
+    exit
+  end
+end
+
+KBSecret::Config.session_names.each do |sess_name|
+  session_hash = KBSecret::Config.session(sess_name)
+  session = KBSecret::Session.new label: sess_name
+  line = "#{sess_name}\n"
+  line << <<~EOS if opts.show_all?
+    \tUsers: #{session_hash[:users].join(", ")}
+    \tSecrets root: #{session_hash[:root]} (#{session.directory})
+  EOS
+
+  puts line
+end

data/lib/kbsecret.rb

@@ -0,0 +1,13 @@
+require "keybase"
+
+require_relative "kbsecret/config"
+require_relative "kbsecret/exceptions"
+require_relative "kbsecret/record"
+require_relative "kbsecret/session"
+
+module KBSecret
+  VERSION = "0.0.1".freeze
+
+  raise Keybase::KeybaseNotRunningError unless Keybase.running?
+  raise Keybase::KBFSNotRunningError unless Dir.exist?(Config[:mount])
+end

data/lib/kbsecret/config.rb

@@ -0,0 +1,52 @@
+require "yaml"
+require "fileutils"
+
+module KBSecret
+  class Config
+    CONFIG_DIR = File.expand_path("~/.config/kbsecret").freeze
+
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.yml").freeze
+
+    DEFAULT_CONFIG = {
+      mount: "/keybase",
+
+      sessions: {
+        default: {
+          users: [Keybase.current_user],
+          root: "kbsecret",
+        }
+      }
+    }.freeze
+
+    def self.[](key)
+      @@config[key]
+    end
+
+    def self.session(sess)
+      @@config[:sessions][sess]
+    end
+
+    def self.session_names
+      @@config[:sessions].keys
+    end
+
+    def self.session?(sess)
+      session_names.include?(sess.to_sym)
+    end
+
+    def self.add_session(label, hsh)
+      @@config[:sessions][label.to_sym] = hsh
+      File.open(CONFIG_FILE, "w") { |io| io.write @@config.to_yaml }
+    end
+
+    if File.exist?(CONFIG_FILE)
+      user_config = YAML.load_file(CONFIG_FILE)
+    else
+      user_config = DEFAULT_CONFIG
+      FileUtils.mkdir_p CONFIG_DIR
+      File.open(CONFIG_FILE, "w") { |io| io.write DEFAULT_CONFIG.to_yaml }
+    end
+
+    @@config = DEFAULT_CONFIG.merge(user_config)
+  end
+end

data/lib/kbsecret/exceptions.rb

@@ -0,0 +1,10 @@
+module KBSecret
+  class KBSecretError < RuntimeError
+  end
+
+  class RecordCreationArityError < RuntimeError
+    def initialize(exp, act)
+      super "Needed #{exp} arguments for this record, got #{act}"
+    end
+  end
+end

data/lib/kbsecret/record.rb

@@ -0,0 +1,30 @@
+require "json"
+
+require_relative "record/abstract"
+require_relative "record/login"
+require_relative "record/environment"
+require_relative "record/unstructured"
+
+module KBSecret
+  module Record
+    def self.record_classes
+      klasses = constants.map(&Record.method(:const_get)).grep(Class)
+      klasses.delete(Record::Abstract)
+      klasses
+    end
+
+    def self.record_types
+      record_classes.map(&:type)
+    end
+
+    def self.type?(type)
+      record_types.include?(type)
+    end
+
+    def self.load_record!(session, path)
+      hsh = JSON.parse(File.read(path), symbolize_names: true)
+      klass = record_classes.find { |c| c.type == hsh[:type] }
+      klass.load!(session, hsh)
+    end
+  end
+end

data/lib/kbsecret/record/abstract.rb

@@ -0,0 +1,61 @@
+require "json"
+
+module KBSecret
+  module Record
+    # @abstract
+    class Abstract
+      attr_accessor :session
+      attr_reader :timestamp
+      attr_reader :label
+      attr_reader :type
+      attr_reader :data
+
+      def self.type
+        name.split("::").last.downcase
+      end
+
+      def self.load!(session, hsh)
+        instance = allocate
+        instance.session = session
+        instance.initialize_from_hash(hsh)
+
+        instance
+      end
+
+      def initialize(session, label)
+        @session = session
+        @timestamp = Time.now.to_i
+        @label = label
+        @type = self.class.type
+        @data = {}
+      end
+
+      def initialize_from_hash(hsh)
+        @timestamp = hsh[:timestamp]
+        @label = hsh[:label]
+        @type = hsh[:type]
+        @data = hsh[:data]
+      end
+
+      def path
+        File.join(session.directory, "#{label}.json")
+      end
+
+      def to_h
+        {
+          timestamp: timestamp,
+          label: label,
+          type: type,
+          data: data,
+        }
+      end
+
+      def sync!
+        # bump the timestamp every time we sync
+        @timestamp = Time.now.to_i
+
+        File.write(path, JSON.pretty_generate(to_h))
+      end
+    end
+  end
+end

data/lib/kbsecret/record/environment.rb

@@ -0,0 +1,42 @@
+module KBSecret
+  module Record
+    class Environment < Abstract
+      def initialize(session, label, variable, value)
+        super(session, label)
+
+        @data = {
+          environment: {
+            variable: variable,
+            value: value,
+          },
+        }
+      end
+
+      def variable
+        @data[:environment][:variable]
+      end
+
+      def variable=(var)
+        @data[:environment][:variable] = var
+        sync!
+      end
+
+      def value
+        @data[:environment][:value]
+      end
+
+      def value=(val)
+        @data[:environment][:value] = val
+        sync!
+      end
+
+      def to_assignment
+        "#{variable}='#{value}'"
+      end
+
+      def to_export
+        "export #{to_assignment}"
+      end
+    end
+  end
+end

data/lib/kbsecret/record/login.rb

@@ -0,0 +1,34 @@
+module KBSecret
+  module Record
+    class Login < Abstract
+      def initialize(session, label, user, pass)
+        super(session, label)
+
+        @data = {
+          login: {
+            username: user,
+            password: pass,
+          },
+        }
+      end
+
+      def username
+        @data[:login][:username]
+      end
+
+      def username=(user)
+        @data[:login][:username] = user
+        sync!
+      end
+
+      def password
+        @data[:login][:password]
+      end
+
+      def password=(pass)
+        @data[:login][:password] = pass
+        sync!
+      end
+    end
+  end
+end

data/lib/kbsecret/record/unstructured.rb

@@ -0,0 +1,22 @@
+module KBSecret
+  module Record
+    class Unstructured < Abstract
+      def initialize(session, label, text)
+        super(session, label)
+
+        @data = {
+          text: text
+        }
+      end
+
+      def text
+        @data[:text]
+      end
+
+      def text=(new_text)
+        @data[:text] = new_text
+        sync!
+      end
+    end
+  end
+end

data/lib/kbsecret/session.rb

@@ -0,0 +1,69 @@
+module KBSecret
+  class Session
+    attr_reader :label
+    attr_reader :config
+    attr_reader :directory
+    attr_reader :records
+
+    def initialize(label: :default)
+      @label = label
+      @config = Config.session(label.to_sym)
+
+      @directory = rel_path config[:root], mkdir: true
+      @records = load_records!
+    end
+
+    def record_labels
+      records.map(&:label)
+    end
+
+    def add_record(type, label, *args)
+      klass = Record.record_classes.find { |k| k.type == type }
+      arity = klass.instance_method(:initialize).arity - 2
+
+      unless arity == args.size
+        raise RecordCreationArityError.new(arity, args.size)
+      end
+
+      record = klass.new(self, label, *args)
+      records << record
+      record.sync!
+    end
+
+    def delete_record(rec_label)
+      record = records.find { |r| r.label == rec_label }
+      return unless record
+
+      File.delete(record.path)
+      records.delete(record)
+    end
+
+    def record?(label)
+      record_labels.include?(label)
+    end
+
+    private
+
+    def record_paths
+      Dir[File.join(directory, "*.json")]
+    end
+
+    def load_records!
+      record_paths.map do |path|
+        Record.load_record! self, path
+      end
+    end
+
+    def stringified_users
+      config[:users].join(",")
+    end
+
+    def rel_path(rel, mkdir: false)
+      path = File.join(Config[:mount], "private", stringified_users, rel)
+
+      FileUtils.mkdir_p path if mkdir
+
+      path
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: kbsecret
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Woodruff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: keybase-unofficial
+  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: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+description: Manages your passwords, environment, and more via KBFS.
+email: william@tuffbizz.com
+executables:
+- kbsecret
+- kbsecret-rm
+- kbsecret-login
+- kbsecret-new
+- kbsecret-env
+- kbsecret-new-session
+- kbsecret-list
+- kbsecret-sessions
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- bin/kbsecret
+- bin/kbsecret-env
+- bin/kbsecret-list
+- bin/kbsecret-login
+- bin/kbsecret-new
+- bin/kbsecret-new-session
+- bin/kbsecret-rm
+- bin/kbsecret-sessions
+- lib/kbsecret.rb
+- lib/kbsecret/config.rb
+- lib/kbsecret/exceptions.rb
+- lib/kbsecret/record.rb
+- lib/kbsecret/record/abstract.rb
+- lib/kbsecret/record/environment.rb
+- lib/kbsecret/record/login.rb
+- lib/kbsecret/record/unstructured.rb
+- lib/kbsecret/session.rb
+homepage: https://github.com/woodruffw/kbsecret
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: kbsecret - A KBFS (Keybase) backed secret manager.
+test_files: []