rapid-vaults 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d67262209d01142c67ff7d217f1cc967e6adeb4e
+  data.tar.gz: 3702f2c91fb43a52189ab806c7bd7fb6b74c6bf9
+SHA512:
+  metadata.gz: f11460cc7949a564f78d17488a63e0751058833d69715e5153ec3ee45f934dc1c0c22c9a2acd666f7f9d590573bf5157c9f5b6561d89a46c587e7d16501e708d
+  data.tar.gz: 11e1eb5da4c8c61a7012e8f966866b6d4e0eb88aadd96a75f8bb1b1c30bcf90012f8e9a722355fa20edaf4268ce4fc68f9b6c71cd94a370791205f0cf4276485

data/README.md

@@ -0,0 +1,94 @@
+# Rapid Vaults
+Currently in beta and can be used without expectation of support.
+
+[![Build Status](https://travis-ci.org/mschuchard/rapid-vaults.svg?branch=master)](https://travis-ci.org/mschuchard/rapid-vaults)
+
+- [Description](#description)
+- [Usage](#usage)
+  - [CLI](#cli)
+  - [API](#api)
+- [Contributing](#contributing)
+
+## Description
+
+Rapid Vaults is a gem that performs ad-hoc encryption and decryption of data behind multiple layers of protection via OpenSSL or GPG. It is lightweight and easy-to-use software to secure and retrieve your data with multiple layers of defense and verification.
+
+### Comparative Software
+
+Ansible-Vault is very similar to Rapid Vaults. Both are streamlined and easy to use ad-hoc encryption and decryption tools. The two primary differences are that Rapid Vaults has a Ruby API instead of a Python API and that Rapid Vaults offers additional verification and defense layers. The API can also be considered similar to the high level recipes provided by PyCA's Cryptography.
+
+### Non-Comparative Software
+
+Rapid Vaults is not similar to tools like RbNaCl or Hashicorp's Vault. RbNaCl offers advanced encryption techniques by providing bindings to libsodium. Rapid Vaults relies upon AES-256-GCM or GPG. Hashicorp's Vault is Enterprise level software with many powerful features and conveniences. Rapid Vaults is a lightweight and narrowly focused tool.
+
+## Usage
+
+### CLI
+
+```
+usage: rapid-vaults [options] file
+    -g, --generate                   Generate a key and nonce for encryption and decryption.
+    -e, --encrypt                    Encrypt a file using a key and nonce and generate a tag.
+    -d, --decrypt                    Decrypt a file using a key, nonce, and tag.
+    -k, --key key                    Key file to be used for encryption or decryption.
+    -n, --nonce nonce                Nonce file to be used for encryption or decryption.
+    -t, --tag tag                    Tag file to be used for decryption.
+    -p, --password password          (optional) Password to be used for encryption or decryption.
+```
+
+#### Generate Key and Nonce
+`rapid-vaults -g`
+
+#### Encrypt File with SSL
+
+`rapid-vaults -e -k cert.key -n nonce.txt -p secret unencrypted.txt`
+
+#### Decrypt a File with SSL
+
+`rapid-vaults -d -k cert.key -n nonce.txt -t tag.txt -p secret encrypted.txt`
+
+### API
+
+#### Generate Key and Nonce
+
+```ruby
+require 'rapid-vaults'
+
+options = {}
+options[:action] = :generate
+key, nonce = RapidVaults::API.main(options)
+```
+
+#### Encrypt with SSL
+
+```ruby
+require 'rapid-vaults'
+
+options = {}
+options[:action] = :encrypt
+options[:file] = '/path/to/data.txt'
+options[:key] = '/path/to/cert.key'
+options[:nonce] = '/path/to/nonce.txt'
+options[:pw] = File.read('/path/to/password.txt') # optional
+encrypted_contents, tag = RapidVaults::API.main(options)
+```
+
+#### Decrypt with SSL
+
+```ruby
+require 'rapid-vaults'
+
+options = {}
+options[:action] = :decrypt
+options[:file] = '/path/to/data.txt'
+options[:key] = '/path/to/cert.key'
+options[:nonce] = '/path/to/nonce.txt'
+options[:tag] = '/path/to/tag.txt'
+options[:pw] = File.read('/path/to/password.txt') # optional
+decrypted_contents = RapidVaults::API.main(options)
+```
+
+## Contributing
+Code should pass all spec tests. New features should involve new spec tests. Adherence to Rubocop and Reek is expected where not overly onerous or where the check is of dubious cost/benefit.
+
+A [Dockerfile](Dockerfile) is provided for easy rake testing. A [Vagrantfile](Vagrantfile) is provided for easy gem building, installation, and post-installation testing.

data/bin/rapid-vaults

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../lib/rapid-vaults/cli'
+
+exit RapidVaults::CLI.main(ARGV)

data/lib/rapid-vaults/api.rb

@@ -0,0 +1,20 @@
+require_relative '../rapid-vaults'
+
+# provides an application programming interface to interact with rapid vaults
+class RapidVaults::API
+  # lightweight api
+  def self.main(settings)
+    # parse settings in api and denote using api
+    RapidVaults.settings = parse(settings)
+
+    # run RapidVaults with specified file
+    RapidVaults.new.main
+  end
+
+  # parse api options
+  def self.parse(settings)
+    # establish settings for api
+    settings[:ui] = :api
+    settings
+  end
+end

data/lib/rapid-vaults/cli.rb

@@ -0,0 +1,47 @@
+require_relative '../rapid-vaults'
+
+# provides a command line interface to interact with rapid vaults
+class RapidVaults::CLI
+  # point of entry from executable
+  def self.main(args)
+    # parse args in cli and denote using cli
+    parse(args)
+    unless RapidVaults.settings[:action] == :generate
+      args.empty? ? (raise 'rapid-vaults: no file specified; try using --help') : RapidVaults.settings[:file] = args.first
+    end
+
+    # run RapidVaults with specified file
+    RapidVaults.new.main
+    0
+  end
+
+  # parse cli options
+  def self.parse(args)
+    require 'optparse'
+
+    # show help message if no args specified
+    args = %w[-h] if args.empty?
+
+    # specify cli being used
+    RapidVaults.settings[:ui] = :cli
+
+    opt_parser = OptionParser.new do |opts|
+      # usage
+      opts.banner = 'usage: rapid-vaults [options] file'
+
+      # generate, encrypt, or decrypt
+      opts.on('-g', '--generate', 'Generate a key and nonce for encryption and decryption.') { RapidVaults.settings[:action] = :generate }
+      opts.on('-e', '--encrypt', 'Encrypt a file using a key and nonce and generate a tag.') { RapidVaults.settings[:action] = :encrypt }
+      opts.on('-d', '--decrypt', 'Decrypt a file using a key, nonce, and tag.') { RapidVaults.settings[:action] = :decrypt }
+
+      # key, nonce, password, and tag
+      opts.on('-k', '--key key', String, 'Key file to be used for encryption or decryption.') { |arg| RapidVaults.settings[:key] = arg }
+      opts.on('-n', '--nonce nonce', String, 'Nonce file to be used for encryption or decryption.') { |arg| RapidVaults.settings[:nonce] = arg }
+      opts.on('-t', '--tag tag', String, 'Tag file to be used for decryption.') { |arg| RapidVaults.settings[:tag] = arg }
+      opts.on('-p', '--password password', String, '(optional) Password to be used for encryption or decryption.') { |arg| RapidVaults.settings[:pw] = arg }
+      opts.on('-f', '--file-password password.txt', String, '(optional) Text file containing a password to be used for encryption or decryption.') { |arg| RapidVaults.settings[:pw] = File.read(arg) }
+    end
+
+    opt_parser.parse!(args)
+  end
+end

data/lib/rapid-vaults/decrypt.rb

@@ -0,0 +1,27 @@
+require 'openssl'
+
+# decrypts strings using supplied decryption settings
+class Decrypt
+  # decrypts a string
+  def self.main(settings)
+    # check tag size
+    raise 'Tag is not 16 bytes.' unless settings[:tag].bytesize == 16
+
+    # setup the decryption parameters
+    decipher = OpenSSL::Cipher.new('aes-256-gcm').decrypt
+    decipher.key = settings[:key]
+    decipher.iv = settings[:nonce]
+    decipher.auth_tag = settings[:tag]
+    decipher.auth_data = settings.key?(:pw) ? settings[:pw] : ''
+
+    # output the decrypted file
+    if settings[:ui] == :cli
+      # output to file
+      File.write('decrypted.txt', decipher.update(settings[:file]) + decipher.final)
+      puts 'Your decrypted.txt has been written out to the current directory.'
+    elsif settings[:ui] == :api
+      # output to string
+      decipher.update(settings[:file]) + decipher.final
+    end
+  end
+end

data/lib/rapid-vaults/encrypt.rb

@@ -0,0 +1,24 @@
+require 'openssl'
+
+# encrypts strings using supplied encryption settings
+class Encrypt
+  # encrypts a string
+  def self.main(settings)
+    # setup the encryption parameters
+    cipher = OpenSSL::Cipher.new('aes-256-gcm').encrypt
+    cipher.key = settings[:key]
+    cipher.iv = settings[:nonce]
+    cipher.auth_data = settings.key?(:pw) ? settings[:pw] : ''
+
+    # output the encrypted file and associated tag
+    if settings[:ui] == :cli
+      # output to file
+      File.write('encrypted.txt', cipher.update(settings[:file]) + cipher.final)
+      File.write('tag.txt', cipher.auth_tag)
+      puts 'Your encrypted.txt and associated tag.txt for this encryption have been generated in your current directory.'
+    elsif settings[:ui] == :api
+      # output to array
+      [cipher.update(settings[:file]) + cipher.final, cipher.auth_tag]
+    end
+  end
+end

data/lib/rapid-vaults/generate.rb

@@ -0,0 +1,19 @@
+require 'openssl'
+require_relative '../rapid-vaults'
+
+# generates files necessary for encryption and decryption
+class Generate
+  # generates a key and nonce
+  def self.main(settings)
+    cipher = OpenSSL::Cipher.new('aes-256-gcm').encrypt
+    if settings[:ui] == :cli
+      # output to file
+      File.write('key.txt', cipher.random_key)
+      File.write('nonce.txt', cipher.random_iv)
+      puts 'Your key.txt and nonce.txt have been generated in your current directory.'
+    elsif settings[:ui] == :api
+      # output to string
+      [cipher.random_key, cipher.random_iv]
+    end
+  end
+end

data/lib/rapid-vaults.rb

@@ -0,0 +1,51 @@
+require_relative 'rapid-vaults/decrypt'
+require_relative 'rapid-vaults/encrypt'
+require_relative 'rapid-vaults/generate'
+
+# interfaces from cli/api, validates settings, and then distributes actions to appropriate classes
+class RapidVaults
+  # initialize settings hash
+  @settings = {}
+
+  # allow cli and api read/write access to settings with self since this is singleton
+  class << self
+    attr_accessor :settings
+  end
+
+  # main runner for software
+  def main
+    # short circuit if we are generating
+    return Generate.main(self.class.settings) if self.class.settings[:action] == :generate
+
+    # process settings
+    self.class.process
+
+    # execute desired action via dynamic call
+    # public_send("#{self.class.settings[:action].capitalize}.main".to_sym)
+    case self.class.settings[:action]
+    when :encrypt then Encrypt.main(self.class.settings)
+    when :decrypt then Decrypt.main(self.class.settings)
+    end
+  end
+
+  # method for processing the settings and inputs
+  def self.process
+    # check for problems with arguments
+    case @settings[:action]
+    when :encrypt
+      raise 'File, key, and nonce arguments are required for encryption.' unless @settings.key?(:file) && @settings.key?(:key) && @settings.key?(:nonce)
+    when :decrypt
+      raise 'File, key, nonce, and tag arguments are required for decryption.' unless @settings.key?(:file) && @settings.key?(:key) && @settings.key?(:nonce) && @settings.key?(:tag)
+    else
+      raise 'Action must be one of generate, encrypt, or decrypt.'
+    end
+
+    # check for problems with inputs and read in files
+    raise 'Password must be a string.' if @settings.key?(:pw) && !settings[:pw].is_a?(String)
+    File.file?(@settings[:file]) ? @settings[:file] = File.read(@settings[:file]) : (raise 'Input file is not an existing file.')
+    File.file?(@settings[:key]) ? @settings[:key] = File.read(@settings[:key]) : (raise 'Input key is not an existing file.')
+    File.file?(@settings[:nonce]) ? @settings[:nonce] = File.read(@settings[:nonce]) : (raise 'Input nonce is not an existing file.')
+    return unless @settings[:action] == :decrypt
+    File.file?(@settings[:tag]) ? @settings[:tag] = File.read(@settings[:tag]) : (raise 'Input tag is not an existing file.')
+  end
+end

data/spec/fixtures/file.yaml

@@ -0,0 +1 @@
+foo: bar

data/spec/rapid-vaults/api_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/api'
+
+describe RapidVaults::API do
+  context '.parse' do
+    it 'correctly parses the settings for encrypt' do
+      expect(RapidVaults::API.parse(action: :encrypt, file: 'file.txt', key: 'key.txt', nonce: 'nonce.txt', pw: 'secret')).to eq(ui: :api, action: :encrypt, file: 'file.txt', key: 'key.txt', nonce: 'nonce.txt', pw: 'secret')
+    end
+    it 'correctly parses the settings for decrypt' do
+      expect(RapidVaults::API.parse(action: :decrypt, file: 'file.txt', key: 'key.txt', nonce: 'nonce.txt', tag: 'tag.txt', pw: 'secret')).to eq(ui: :api, action: :decrypt, file: 'file.txt', key: 'key.txt', nonce: 'nonce.txt', tag: 'tag.txt', pw: 'secret')
+    end
+    it 'correctly parses the settings for decrypt' do
+      expect(RapidVaults::API.parse(action: :generate)).to eq(ui: :api, action: :generate)
+    end
+  end
+end

data/spec/rapid-vaults/cli_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/cli'
+
+describe RapidVaults::CLI do
+  context '.parse' do
+    it 'correctly parses the user arguments for encrypt' do
+      RapidVaults::CLI.parse(%w[-e -k key.txt -n nonce.txt -p secret file.txt])
+      expect(RapidVaults.instance_variable_get(:@settings)).to eq(ui: :cli, action: :encrypt, key: 'key.txt', nonce: 'nonce.txt', pw: 'secret')
+    end
+    it 'correctly parses the arguments for decrypt' do
+      RapidVaults::CLI.parse(%w[-d -k key.txt -n nonce.txt -t tag.txt -p secret file.txt])
+      expect(RapidVaults.instance_variable_get(:@settings)).to eq(ui: :cli, action: :decrypt, key: 'key.txt', nonce: 'nonce.txt', tag: 'tag.txt', pw: 'secret')
+    end
+    it 'correctly parses the arguments for generate' do
+      RapidVaults.instance_variable_set(:@settings, {})
+      RapidVaults::CLI.parse(%w[-g])
+      expect(RapidVaults.instance_variable_get(:@settings)).to eq(ui: :cli, action: :generate)
+    end
+  end
+end

data/spec/rapid-vaults/decrypt_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/encrypt'
+require_relative '../../lib/rapid-vaults/decrypt'
+
+describe Decrypt do
+  before(:all) do
+    Encrypt.main(ui: :cli, file: "foo: bar\n", key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M')
+  end
+
+  after(:all) do
+    %w[tag.txt encrypted.txt decrypted.txt].each { |file| File.delete(file) }
+  end
+
+  context '.decrypt' do
+    it 'outputs a decrypted file with the key, nonce, and tag from the cli' do
+      Decrypt.main(ui: :cli, file: File.read('encrypted.txt'), key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M', tag: File.read('tag.txt'))
+      expect(File.file?('decrypted.txt')).to be true
+      expect(File.read('decrypted.txt')).to eq("foo: bar\n")
+    end
+    it 'outputs decrypted content with the key, nonce, and tag from the api' do
+      decrypt = Decrypt.main(ui: :api, file: File.read('encrypted.txt'), key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M', tag: File.read('tag.txt'))
+      expect(decrypt).to be_a(String)
+      expect(decrypt).to eq("foo: bar\n")
+    end
+    it 'raises an error for an invalid tag size' do
+      expect { Decrypt.main(file: File.read('encrypted.txt'), key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M', tag: "�a����e�O_H|�\n") }.to raise_error('Tag is not 16 bytes.')
+    end
+  end
+end

data/spec/rapid-vaults/encrypt_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/encrypt'
+
+describe Encrypt do
+  after(:all) do
+    %w[tag.txt encrypted.txt].each { |file| File.delete(file) }
+  end
+
+  context '.encrypt' do
+    it 'outputs an encrypted file with the key and nonce from the cli' do
+      Encrypt.main(ui: :cli, file: "foo: bar\n", key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M')
+      expect(File.file?('tag.txt')).to be true
+      expect(File.file?('encrypted.txt')).to be true
+    end
+    it 'outputs an encrypted file with the key, nonce, and password from the cli' do
+      Encrypt.main(ui: :cli, file: "foo: bar\n", key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M', password: 'password')
+      expect(File.file?('tag.txt')).to be true
+      expect(File.file?('encrypted.txt')).to be true
+    end
+    it 'outputs an array of encrypted content and tag with the key and nonce from the api' do
+      encrypt = Encrypt.main(ui: :api, file: "foo: bar\n", key: '���b+����R�v�Í%("����=8o/���', nonce: 'Ëá!í^Uë^EÜ<83>oã^M')
+      expect(encrypt).to be_a(Array)
+      expect(encrypt[0]).to be_a(String)
+      expect(encrypt[1]).to be_a(String)
+      expect(encrypt.length).to eq(2)
+    end
+  end
+end

data/spec/rapid-vaults/generate_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/generate'
+
+describe RapidVaults do
+  after(:all) do
+    %w[key.txt nonce.txt].each { |file| File.delete(file) }
+  end
+
+  context '.generate' do
+    it 'generates the key and nonce files from the cli' do
+      Generate.main(ui: :cli)
+      expect(File.file?('key.txt')).to be true
+      expect(File.file?('nonce.txt')).to be true
+      expect(File.read('key.txt')).to be_a(String)
+      expect(File.read('nonce.txt')).to be_a(String)
+    end
+    it 'outputs an array with the key and nonce from the api' do
+      generate = Generate.main(ui: :api)
+      expect(generate).to be_a(Array)
+      expect(generate[0]).to be_a(String)
+      expect(generate[1]).to be_a(String)
+      expect(generate.length).to eq(2)
+    end
+  end
+end

data/spec/rapid-vaults_spec.rb

@@ -0,0 +1,32 @@
+require_relative 'spec_helper'
+require_relative '../lib/rapid-vaults'
+
+describe RapidVaults do
+  #  let(:rapidvaults) { RapidVaults.new('fixtures/foo.yml', 'fixtures/key.txt', 'fixtures/nonce.txt', 'fixtures/tag.txt') }
+
+  context '.process' do
+    it 'raises an error for a non-string password' do
+      RapidVaults.instance_variable_set(:@settings, action: :encrypt, file: 'a', key: 'b', nonce: 'c', pw: 1)
+      expect { RapidVaults.process }.to raise_error('Password must be a string.')
+    end
+    it 'raises an error for a missing argument to encrypt' do
+      RapidVaults.instance_variable_set(:@settings, action: :encrypt, file: 'a', key: 'b')
+      expect { RapidVaults.process }.to raise_error('File, key, and nonce arguments are required for encryption.')
+    end
+    it 'raises an error for a missing argument to decrypt' do
+      RapidVaults.instance_variable_set(:@settings, action: :decrypt, file: 'a', key: 'b', nonce: 'c')
+      expect { RapidVaults.process }.to raise_error('File, key, nonce, and tag arguments are required for decryption.')
+    end
+    it 'raises an error for a missing action' do
+      RapidVaults.instance_variable_set(:@settings, file: 'a', key: 'b', nonce: 'c', tag: 'd')
+      expect { RapidVaults.process }.to raise_error('Action must be one of generate, encrypt, or decrypt.')
+    end
+    it 'raises an error for a nonexistent input file' do
+      RapidVaults.instance_variable_set(:@settings, action: :encrypt, file: 'a', key: 'b', nonce: 'c', tag: 'd')
+      expect { RapidVaults.process }.to raise_error('Input file is not an existing file.')
+    end
+    it 'reads in all input files correctly for decryption' do
+      #
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rspec'
+
+# for path to fixtures
+module Variables
+  extend RSpec::SharedContext
+
+  let(:fixtures_dir) { File.dirname(__FILE__) + '/fixtures/' }
+end
+
+RSpec.configure do |config|
+  config.include Variables
+  config.color = true
+end

data/spec/system/system_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rapid-vaults/cli'
+require_relative '../../lib/rapid-vaults/api'
+
+describe RapidVaults do
+  after(:all) do
+    %w[key.txt nonce.txt tag.txt encrypted.txt decrypted.txt].each { |file| File.delete(file) }
+  end
+
+  context 'executed as a system from the CLI with settings and a file to be processed' do
+    it 'generates key and nonce, encrypts a file, and then decrypts a file in order' do
+      # generate and utilize files inside suitable directory
+      Dir.chdir(fixtures_dir)
+
+      # generate key and nonce
+      RapidVaults::CLI.main(%w[-g])
+      expect(File.file?('key.txt')).to be true
+      expect(File.file?('nonce.txt')).to be true
+
+      # generate encrypted file
+      RapidVaults::CLI.main(%w[-e -k key.txt -n nonce.txt -p password file.yaml])
+      expect(File.file?('tag.txt')).to be true
+      expect(File.file?('encrypted.txt')).to be true
+
+      # generate decrypted file
+      RapidVaults::CLI.main(%w[-d -k key.txt -n nonce.txt -t tag.txt -p password encrypted.txt])
+      expect(File.file?('decrypted.txt')).to be true
+      expect(File.read('decrypted.txt')).to eq("foo: bar\n")
+    end
+  end
+
+  context 'executed as a system from the API with settings and a file to be processed' do
+    it 'generates key and nonce, encrypts a file, and then decrypts a file in order' do
+      # generate and utilize files inside suitable directory
+      Dir.chdir(fixtures_dir)
+
+      # generate key and nonce
+      RapidVaults::API.main(action: :generate)
+      expect(File.file?('key.txt')).to be true
+      expect(File.file?('nonce.txt')).to be true
+
+      # generate encrypted file
+      encrypt, tag = RapidVaults::API.main(action: :encrypt, file: 'file.yaml', key: 'key.txt', nonce: 'nonce.txt', password: 'password')
+      expect(encrypt).to be_a(String)
+      expect(tag).to be_a(String)
+
+      # generate decrypted file
+      File.write('encrypted.txt', encrypt)
+      File.write('tag.txt', tag)
+      decrypt = RapidVaults::API.main(action: :decrypt, file: 'encrypted.txt', key: 'key.txt', nonce: 'nonce.txt', tag: 'tag.txt', password: 'password')
+      expect(decrypt).to eq("foo: bar\n")
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rapid-vaults
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matt Schuchard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
+description: Ad-hoc encrypt and decrypt data behind multiple layers of protection
+  via OpenSSL or GPG.
+email: 
+executables:
+- rapid-vaults
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/rapid-vaults
+- lib/rapid-vaults.rb
+- lib/rapid-vaults/api.rb
+- lib/rapid-vaults/cli.rb
+- lib/rapid-vaults/decrypt.rb
+- lib/rapid-vaults/encrypt.rb
+- lib/rapid-vaults/generate.rb
+- spec/fixtures/file.yaml
+- spec/rapid-vaults/api_spec.rb
+- spec/rapid-vaults/cli_spec.rb
+- spec/rapid-vaults/decrypt_spec.rb
+- spec/rapid-vaults/encrypt_spec.rb
+- spec/rapid-vaults/generate_spec.rb
+- spec/rapid-vaults_spec.rb
+- spec/spec_helper.rb
+- spec/system/system_spec.rb
+homepage: https://www.github.com/mschuchard/rapid-vaults
+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.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Ad-hoc encrypt and decrypt data.
+test_files:
+- spec/fixtures/file.yaml
+- spec/rapid-vaults/api_spec.rb
+- spec/rapid-vaults/cli_spec.rb
+- spec/rapid-vaults/decrypt_spec.rb
+- spec/rapid-vaults/encrypt_spec.rb
+- spec/rapid-vaults/generate_spec.rb
+- spec/rapid-vaults_spec.rb
+- spec/spec_helper.rb
+- spec/system/system_spec.rb