trustworthy 0.1.0

data/README.md

@@ -0,0 +1,35 @@
+## Trustworthy [![Build Status](https://secure.travis-ci.org/jtdowney/trustworthy.png?branch=master)](http://travis-ci.org/jtdowney/trustworthy)
+
+Implements a special case (k = 2) of [Adi Shamir's](http://en.wikipedia.org/wiki/Adi_Shamir) [secret sharing algorithm](http://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing). This allows secret files to be encrypted on disk but loaded into a process on start if two of the keys are available.
+
+### Uses
+
+#### Generate a new master key
+
+    trustworthy init -c trustworthy.yml
+
+This will create a new master key and ask for two users to be added who can decrypt the master key. The information about users and secrets is stored in trustworthy.yml.
+
+#### Add an additional user to the master key
+
+    trustworthy add-user -c trustworthy.yml
+
+The master key will be loaded so that a new user can be added to trustworthy.yml.
+
+#### Add a secret
+
+    trustworthy add-secret -c trustworthy.yml -e ENCRYPTION_KEY -i encryption.key -o encryption.key.tw
+
+Secrets are the main purpose behind trustworthy. This will encrypt the file using the master key and will load it into the given environment variable when executed.
+
+#### Run a program under trustworthy
+
+    trustworthy exec -c trustworthy.yml rails console
+
+The master key will be loaded so all secrets can be decrypted and stored in the environment. After that the given program will be spawned and inherit the environment.
+
+### Reference
+
+RSA Labs - [http://www.rsa.com/rsalabs/node.asp?id=2259](http://www.rsa.com/rsalabs/node.asp?id=2259)
+ssss - [http://point-at-infinity.org/ssss/](http://point-at-infinity.org/ssss/)
+Secret sharing on Wikipedia - [http://en.wikipedia.org/wiki/Secret_sharing](http://en.wikipedia.org/wiki/Secret_sharing)

data/bin/trustworthy

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'commander/import'
+require 'trustworthy'
+
+program :version, Trustworthy::VERSION
+program :description, 'Trustworthy secret sharing'
+
+command 'init' do |c|
+  c.syntax = 'trustworthy init [options]'
+  c.summary = 'Create a new master key'
+  c.description = 'Used to generate a setup a new master key for trustworthy'
+  c.example 'create a new master key named foo', 'trustworthy init -c foo.yml'
+  c.option '-k', '--keys NUMBER', Integer, 'Initial number of keys to create (must be 2 or more, defaults to 2)'
+  c.option '-c', '--config FILE', String, 'Configuration file'
+  c.action do |args, options|
+    options.default :keys => 2
+
+    raise Commander::Runner::InvalidCommandError.new('Must provide a config file') unless options.config
+    raise Commander::Runner::InvalidCommandError.new('Cannot generate fewer than two sub-keys') if options.keys < 2
+
+    say "Creating a new master key with #{options.keys} sub-keys."
+
+    master_key = Trustworthy::MasterKey.create
+    settings = Trustworthy::Settings.new
+
+    options.keys.times do
+      add_user_key(settings, master_key)
+    end
+
+    settings.write(options.config)
+    say "Created #{options.config}"
+  end
+end
+
+command 'add-user' do |c|
+  c.syntax = 'trustworthy add-user [options]'
+  c.summary = 'Add a new user sub-key'
+  c.description = 'Load the master key and create a new user sub-key for it.'
+  c.example 'add a new user the master key', 'trustworthy add-key -c foo.yml'
+  c.option '-k', '--keys NUMBER', Integer, 'Number of keys to create'
+  c.option '-c', '--config FILE', String, 'Configuration file'
+  c.action do |args, options|
+    options.default :keys => 1
+
+    raise Commander::Runner::InvalidCommandError.new('Must provide a config file') unless options.config
+    raise Commander::Runner::InvalidCommandError.new('Cannot generate fewer than one key') if options.keys < 1
+
+    settings = Trustworthy::Settings.load(options.config)
+    master_key = load_master_key(settings)
+
+    options.keys.times do
+      add_user_key(settings, master_key)
+    end
+
+    settings.write(options.config)
+    say "Updated #{options.config} with #{options.keys} new key(s)"
+  end
+end
+
+command 'add-secret' do |c|
+  c.syntax = 'trustworthy add-secret [options]'
+  c.summary = 'Add a new secret'
+  c.description = 'Loads the master key and uses it to encrypt a new secret.'
+  c.example 'add a new secret with master key', 'trustworthy add-secret -c foo.yml -e ENCRYPTION_KEY -i encryption.key -o encryption.key.tw'
+  c.option '-e', '--environment ENVIRONMENT', 'Environment variable to store secret in when running exec'
+  c.option '-i', '--input FILE', 'File to be encrypted'
+  c.option '-o', '--output FILE', 'Encrypted output file'
+  c.option '-c', '--config FILE', String, 'Configuration file'
+  c.action do |args, options|
+    raise Commander::Runner::InvalidCommandError.new('Must provide a config file') unless options.config
+    raise Commander::Runner::InvalidCommandError.new('Must provide an environment variable') unless options.environment
+    raise Commander::Runner::InvalidCommandError.new('Must provide an input file') unless options.input
+    raise Commander::Runner::InvalidCommandError.new('Must provide an output file') unless options.output
+
+    settings = Trustworthy::Settings.load(options.config)
+    master_key = load_master_key(settings)
+
+    plaintext = File.read(options.input)
+    ciphertext = master_key.encrypt(plaintext)
+
+    File.open(options.output, 'w') do |file|
+      file.write(ciphertext)
+    end
+
+    settings.add_secret(options.environment, options.output)
+    settings.write(options.config)
+    say "Updated #{options.config} with the #{options.environment} secret"
+  end
+end
+
+command 'exec' do |c|
+  c.syntax = 'trustworthy exec -c [config file] program'
+  c.summary = 'Load secrets and run program'
+  c.description = 'Loads and decrypted all secrets with the master key and stores them in the environment before forking program'
+  c.example 'run rails console', 'trustworthy -c foo.yml rails console'
+  c.option '-c', '--config FILE', String, 'Configuration file'
+  c.action do |args, options|
+    raise Commander::Runner::InvalidCommandError.new('Must provide a config file') unless options.config
+
+    settings = Trustworthy::Settings.load(options.config)
+    master_key = load_master_key(settings)
+
+    environment = {}
+    settings.secrets.each do |key, encrypted_file|
+      ciphertext = File.read(encrypted_file)
+      environment[key] = master_key.decrypt(ciphertext)
+    end
+
+    pid = POSIX::Spawn.spawn(environment, *args)
+    Process.waitpid(pid)
+  end
+end
+
+def load_master_key(settings)
+  keys = []
+  2.times do
+    username = ask('Username: ')
+    password = password('Password: ', '')
+    keys << settings.unlock_key(username, password)
+    say "Unlocked key for #{username}."
+  end
+
+  Trustworthy::MasterKey.create_from_keys(*keys)
+end
+
+def add_user_key(settings, master_key)
+  key = master_key.create_key
+  username = ask('Username: ').to_s
+
+  password = nil
+  loop do
+    password = password('Password: ', '')
+    password_confirm = password('Password (again): ', '')
+    if password == password_confirm
+      break
+    else
+      say_error 'Password mismatch'
+    end
+  end
+
+  settings.add_key(key, username, password)
+  say "User #{username} added."
+end

data/lib/trustworthy/crypto.rb

@@ -0,0 +1,50 @@
+module Trustworthy
+  class Crypto
+    def initialize(encryption_key, authentication_key)
+      @encryption_key = encryption_key
+      @authentication_key = authentication_key
+      @digest = OpenSSL::Digest.new('SHA256')
+      @cipher = OpenSSL::Cipher.new('AES-256-CBC')
+    end
+
+    def decrypt(ciphertext)
+      ciphertext.force_encoding('BINARY') if ciphertext.respond_to?(:force_encoding)
+      iv = ciphertext.slice(0..15)
+      ciphertext = ciphertext.slice(16..-1)
+      @cipher.decrypt
+      @cipher.key = @encryption_key
+      @cipher.iv = iv
+      @cipher.update(ciphertext) + @cipher.final
+    end
+
+    def encrypt(plaintext)
+      iv = Trustworthy::Random.bytes(16)
+      @cipher.encrypt
+      @cipher.key = @encryption_key
+      @cipher.iv = iv
+      ciphertext = @cipher.update(plaintext) + @cipher.final
+      iv + ciphertext
+    end
+
+    def sign(data)
+      OpenSSL::HMAC.digest(@digest, @authentication_key, data)
+    end
+
+    def valid_signature?(given_signature, data)
+      computed_signature = sign(data)
+      _secure_compare(given_signature, computed_signature)
+    end
+
+    def _secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      bytes = a.unpack("C#{a.bytesize}")
+
+      result = 0
+      b.each_byte do |byte|
+        result |= byte ^ bytes.shift
+      end
+      result == 0
+    end
+  end
+end

data/lib/trustworthy/key.rb

@@ -0,0 +1,16 @@
+module Trustworthy
+  class Key
+    attr_reader :x, :y
+
+    def self.create(slope, intercept)
+      x = Random.number
+      y = slope * x + intercept
+      new(x, y)
+    end
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+  end
+end

data/lib/trustworthy/master_key.rb

@@ -0,0 +1,48 @@
+module Trustworthy
+  class MasterKey
+    def self.create
+      slope = Trustworthy::Random.number
+      intercept = Trustworthy::Random.number
+      new(slope, intercept)
+    end
+
+    def self.create_from_keys(key1, key2)
+      slope = (key2.y - key1.y) / (key2.x - key1.x)
+      intercept = key1.y - (slope * key1.x)
+      new(slope, intercept)
+    end
+
+    def initialize(slope, intercept)
+      @slope = slope
+      @intercept = intercept
+    end
+
+    def create_key
+      Trustworthy::Key.create(@slope, @intercept)
+    end
+
+    def encrypt(plaintext)
+      ciphertext = _crypto.encrypt(plaintext)
+      signature = _crypto.sign(ciphertext)
+      signature + ciphertext
+    end
+
+    def decrypt(ciphertext)
+      ciphertext.force_encoding('BINARY') if ciphertext.respond_to?(:force_encoding)
+      signature = ciphertext.slice(0..31)
+      ciphertext = ciphertext.slice(32..-1)
+      raise 'invalid signature' unless _crypto.valid_signature?(signature, ciphertext)
+      _crypto.decrypt(ciphertext)
+    end
+
+    def _crypto
+      return @crypto if @crypto
+
+      secret = @intercept.to_s('F')
+      hkdf = HKDF.new(secret)
+      encryption_key = hkdf.next_bytes(32)
+      authentication_key = hkdf.next_bytes(32)
+      @crypto = Trustworthy::Crypto.new(encryption_key, authentication_key)
+    end
+  end
+end

data/lib/trustworthy/random.rb

@@ -0,0 +1,21 @@
+module Trustworthy
+  module Random
+    def self.number(size = 32)
+      raw_bytes = bytes(size)
+      number = raw_bytes.unpack('H*').first.hex
+      BigDecimal.new(number.to_s)
+    end
+
+    def self.bytes(size = 32)
+      flags = File::RDONLY
+      flags |= File::NOCTTY if defined? File::NOCTTY
+      File.open(_source, flags) do |file|
+        file.read(size)
+      end
+    end
+
+    def self._source
+      '/dev/random'
+    end
+  end
+end

data/lib/trustworthy/settings.rb

@@ -0,0 +1,63 @@
+module Trustworthy
+  class Settings
+    attr_reader :keys, :secrets
+
+    def self.load(filename)
+      data = File.read(filename)
+      yaml = YAML.load(data)
+      new(yaml['keys'], yaml['secrets'])
+    end
+
+    def initialize(keys = {}, secrets = {})
+      @keys = keys
+      @secrets = secrets
+    end
+
+    def add_key(key, username, password)
+      salt = SCrypt::Engine.generate_salt
+
+      crypto = _crypto_from_password(salt, password)
+      plaintext = "#{key.x.to_s('F')},#{key.y.to_s('F')}"
+      ciphertext = crypto.encrypt(plaintext)
+
+      @keys[username] = {
+        'salt' => salt,
+        'ciphertext' => ciphertext,
+        'authentication' => crypto.sign(ciphertext)
+      }
+    end
+
+    def add_secret(environment, filename)
+      @secrets[environment] = filename
+    end
+
+    def unlock_key(username, password)
+      key_data = keys[username]
+      ciphertext = key_data['ciphertext']
+      signature = key_data['authentication']
+      salt = key_data['salt']
+      crypto = _crypto_from_password(salt, password)
+      raise 'invalid signature' unless crypto.valid_signature?(signature, ciphertext)
+      plaintext = crypto.decrypt(ciphertext)
+      x, y = plaintext.split(',').map { |n| BigDecimal.new(n) }
+      Trustworthy::Key.new(x, y)
+    end
+
+    def write(filename)
+      File.open(filename, 'w') do |file|
+        data = YAML.dump('keys' => @keys, 'secrets' => @secrets)
+        file.write(data)
+      end
+    end
+
+    def _crypto_from_password(salt, password)
+      cost, salt = salt.rpartition('$')
+      raw_key = SCrypt::Engine.scrypt(password, salt, cost, 64)
+
+      encryption_key = raw_key.slice(0, 32)
+      authentication_key = raw_key.slice(32, 32)
+
+      Trustworthy::Crypto.new(encryption_key, authentication_key)
+    end
+  end
+end

data/lib/trustworthy/version.rb

@@ -0,0 +1,3 @@
+module Trustworthy
+  VERSION = '0.1.0'
+end

data/lib/trustworthy.rb

@@ -0,0 +1,13 @@
+require 'bigdecimal'
+require 'hkdf'
+require 'openssl'
+require 'posix/spawn'
+require 'scrypt'
+require 'securerandom'
+require 'trustworthy/crypto'
+require 'trustworthy/key'
+require 'trustworthy/master_key'
+require 'trustworthy/random'
+require 'trustworthy/settings'
+require 'trustworthy/version'
+require 'yaml'

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'fakefs/safe'
+
+require 'trustworthy'
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.before(:each) do
+    Trustworthy::Random.stub(:_source).and_return('/dev/urandom')
+  end
+end
+
+module Trustworthy
+  module TestValues
+    EncryptionKey = ['7fc6880ba7a75148e6b14a6ebca73b9861954835fd17237cbedb71a6ad3fefc4'].pack('H*')
+    AuthenticationKey = ['12e7489dc1b2e6da1213cac0df946615a7088eeccdd6b2d4bf330e9560fabd52'].pack('H*')
+    InitializationVector = ['39164ec082fb8b7336d3c5500af99dcb'].pack('H*')
+  end
+end

data/spec/trustworthy/crypto_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Trustworthy::Crypto do
+  before(:each) do
+    @crypto = Trustworthy::Crypto.new(Trustworthy::TestValues::EncryptionKey, Trustworthy::TestValues::AuthenticationKey)
+  end
+
+  describe 'sign' do
+    it 'should sign the input using the authentication key' do
+      signature = @crypto.sign('foobar')
+      signature.should == ['f9e948d9259d35e729b14e370a7456ec4b22d2a0a1d5daa1accbeb54f414865e'].pack('H*')
+    end
+  end
+
+  describe 'valid_signature?' do
+    it 'should return true when the signature matches the data' do
+      given_signature = ['f9e948d9259d35e729b14e370a7456ec4b22d2a0a1d5daa1accbeb54f414865e'].pack('H*')
+      @crypto.should be_valid_signature(given_signature, 'foobar')
+    end
+
+    it 'should return false when the signature matches the data' do
+      given_signature = ['4d15a6427d6b56e07b819ff0a147dd8ff77b1b5fafd33f9071b0359755edde42'].pack('H*')
+      @crypto.should_not be_valid_signature(given_signature, 'foobar')
+    end
+  end
+
+  describe 'encrypt' do
+    it 'should encrypt the input using the encryption key' do
+      Trustworthy::Random.stub(:bytes).and_return(Trustworthy::TestValues::InitializationVector)
+      ciphertext = @crypto.encrypt('foobar')
+      ciphertext.should == ['39164ec082fb8b7336d3c5500af99dcbf3af2b0abd6f2ac79f1a76cb4e092a7c'].pack('H*')
+    end
+  end
+
+  describe 'decrypt' do
+    it 'should decrypt the input using the encryption key' do
+      ciphertext = ['39164ec082fb8b7336d3c5500af99dcbf3af2b0abd6f2ac79f1a76cb4e092a7c'].pack('H*')
+      plaintext = @crypto.decrypt(ciphertext)
+      plaintext.should == 'foobar'
+    end
+  end
+end

data/spec/trustworthy/key_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Trustworthy::Key do
+  describe 'self.create' do
+    it 'should create a key along the slope and intercept' do
+      Trustworthy::Random.stub(:number).and_return(BigDecimal.new('10'))
+      key = Trustworthy::Key.create(6, 24)
+      key.y.should == 84
+    end
+  end
+end

data/spec/trustworthy/master_key_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Trustworthy::MasterKey do
+  it 'should encrypt and decrypt a master_key' do
+    master_key = Trustworthy::MasterKey.create
+    key1 = master_key.create_key
+    key2 = master_key.create_key
+
+    ciphertext = master_key.encrypt('foobar')
+
+    new_master_key = Trustworthy::MasterKey.create_from_keys(key1, key2)
+    plaintext = new_master_key.decrypt(ciphertext)
+    plaintext.should == 'foobar'
+  end
+
+  it 'should function with any 2 of n keys' do
+    master_key1 = Trustworthy::MasterKey.create
+    key1 = master_key1.create_key
+    key2 = master_key1.create_key
+
+    ciphertext = master_key1.encrypt('foobar')
+
+    master_key2 = Trustworthy::MasterKey.create_from_keys(key1, key2)
+    key3 = master_key2.create_key
+
+    master_key3 = Trustworthy::MasterKey.create_from_keys(key1, key3)
+    plaintext = master_key3.decrypt(ciphertext)
+    plaintext.should == 'foobar'
+  end
+
+  describe 'self.create' do
+    it 'should generate a random slope and intercept' do
+      Trustworthy::Random.stub(:number).and_return(BigDecimal.new('10'))
+      master_key = Trustworthy::MasterKey.create
+      key = master_key.create_key
+      key.x.should == 10
+      key.y.should == 110
+    end
+  end
+
+  describe 'self.create_from_keys' do
+    it 'should calculate the slope and intercept given two keys' do
+      Trustworthy::Random.stub(:number).and_return(BigDecimal.new('10'))
+
+      key1 = Trustworthy::Key.new(BigDecimal.new('2'), BigDecimal.new('30'))
+      key2 = Trustworthy::Key.new(BigDecimal.new('5'), BigDecimal.new('60'))
+
+      master_key = Trustworthy::MasterKey.create_from_keys(key1, key2)
+      new_key = master_key.create_key
+      new_key.x.should == 10
+      new_key.y.should == 110
+    end
+  end
+
+  describe 'create_key' do
+    it 'should define a new key' do
+      master_key = Trustworthy::MasterKey.new(BigDecimal.new('6'), BigDecimal.new('24'))
+      key = master_key.create_key
+      key.x.should_not == 0
+      key.y.should_not == 0
+    end
+  end
+
+  describe 'encrypt' do
+    it 'should encrypt and sign the data using the intercept' do
+      Trustworthy::Random.stub(:bytes).and_return(Trustworthy::TestValues::InitializationVector)
+      master_key = Trustworthy::MasterKey.new(BigDecimal.new('6'), BigDecimal.new('24'))
+      ciphertext = master_key.encrypt('foobar')
+      ciphertext.should == ['0438a89ef9e5792849ef611bff0e7b405a84ac515461489499679ca77ade6a6a39164ec082fb8b7336d3c5500af99dcbde056af859baa7e72c4c2661651e88d5'].pack('H*')
+    end
+  end
+
+  describe 'decrypt' do
+    it 'should decrypt and verify the data using the intercept' do
+      master_key = Trustworthy::MasterKey.new(BigDecimal.new('6'), BigDecimal.new('24'))
+      ciphertext = ['0438a89ef9e5792849ef611bff0e7b405a84ac515461489499679ca77ade6a6a39164ec082fb8b7336d3c5500af99dcbde056af859baa7e72c4c2661651e88d5'].pack('H*')
+      plaintext = master_key.decrypt(ciphertext)
+      plaintext.should == 'foobar'
+    end
+
+    it 'should raise an invalid signature error if signatures do not match' do
+      master_key = Trustworthy::MasterKey.new(BigDecimal.new('6'), BigDecimal.new('24'))
+      ciphertext = ['00000000000000000000000000000000000000005461489499679ca77ade6a6a39164ec082fb8b7336d3c5500af99dcbde056af859baa7e72c4c2661651e88d5'].pack('H*')
+      expect { master_key.decrypt(ciphertext) }.to raise_error('invalid signature')
+    end
+  end
+end

data/spec/trustworthy/random_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Trustworthy::Random do
+  describe 'self.number' do
+    it 'should return a random number' do
+      random = Trustworthy::Random.number
+      random.should_not == Trustworthy::Random.number
+    end
+
+    it 'should return a number up to a given byte size' do
+      random = Trustworthy::Random.number(2)
+      random.should <= 2 ** 16
+    end
+  end
+
+  describe 'self.bytes' do
+    it 'should return a string of the given length' do
+      bytes = Trustworthy::Random.bytes(16)
+      bytes.size.should == 16
+    end
+
+    it 'should return a random string' do
+      bytes1 = Trustworthy::Random.bytes(16)
+      bytes2 = Trustworthy::Random.bytes(16)
+      bytes1.should_not == bytes2
+    end
+  end
+end

data/spec/trustworthy/settings_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Trustworthy::Settings do
+  before(:each) do
+    SCrypt::Engine.stub(:generate_salt).and_return('400$8$1b$3e31f076a3226825')
+    Trustworthy::Random.stub(:bytes).and_return(Trustworthy::TestValues::InitializationVector)
+
+    key = Trustworthy::Key.new(BigDecimal.new('2'), BigDecimal.new('3'))
+    @settings = Trustworthy::Settings.new
+  end
+
+  describe 'add_key' do
+    it 'encrypts and signs the key with the password' do
+      key = Trustworthy::Key.new(BigDecimal.new('2'), BigDecimal.new('3'))
+      settings = Trustworthy::Settings.new
+      settings.add_key(key, 'user', 'password1')
+      settings.keys['user']['salt'].should == '400$8$1b$3e31f076a3226825'
+      settings.keys['user']['authentication'].should == ['20c274efc68a460568853cc4be586183012769a312549d1aa57e29a36ec1503d'].pack('H*')
+      settings.keys['user']['ciphertext'].should == ['39164ec082fb8b7336d3c5500af99dcb17d2e60496ed553dfab4b05c568aa926'].pack('H*')
+    end
+  end
+
+  describe 'add_secret' do
+    it 'adds a secret file name with an environment' do
+      settings = Trustworthy::Settings.new
+      settings.add_secret('foo', 'foo.enc')
+      settings.secrets['foo'].should == 'foo.enc'
+    end
+  end
+
+  describe 'unlock_key' do
+    it 'verifies and decrypts the key with the password' do
+      key = Trustworthy::Key.new(BigDecimal.new('2'), BigDecimal.new('3'))
+      settings = Trustworthy::Settings.new
+      settings.add_key(key, 'user', 'password1')
+      unlocked_key = settings.unlock_key('user', 'password1')
+      unlocked_key.x.should == BigDecimal.new('2')
+      unlocked_key.y.should == BigDecimal.new('3')
+    end
+  end
+
+
+  describe 'write' do
+    it 'writes key information to the given file' do
+      key = Trustworthy::Key.new(BigDecimal.new('2'), BigDecimal.new('3'))
+      settings = Trustworthy::Settings.new
+      settings.add_key(key, 'user', 'password1')
+      FakeFS do
+        settings.write('settings.yml')
+
+        data = File.read('settings.yml')
+        yaml = YAML.load(data)
+        yaml['keys']['user']['salt'].should == '400$8$1b$3e31f076a3226825'
+        yaml['keys']['user']['authentication'].should == ['20c274efc68a460568853cc4be586183012769a312549d1aa57e29a36ec1503d'].pack('H*')
+        yaml['keys']['user']['ciphertext'].should == ['39164ec082fb8b7336d3c5500af99dcb17d2e60496ed553dfab4b05c568aa926'].pack('H*')
+      end
+    end
+  end
+
+  describe 'self.load' do
+    it 'loads the key information from the given file' do
+      FakeFS do
+        File.open('settings.yml', 'w') do |file|
+          file.write(<<-EOF)
+keys:
+  user:
+    salt: 400$8$1b$3e31f076a3226825
+    ciphertext: !binary |-
+      ORZOwIL7i3M208VQCvmdyxfS5gSW7VU9+rSwXFaKqSY=
+    authentication: !binary |-
+      IMJ078aKRgVohTzEvlhhgwEnaaMSVJ0apX4po27BUD0=
+EOF
+        end
+
+        settings = Trustworthy::Settings.load('settings.yml')
+        settings.keys['user']['salt'].should == '400$8$1b$3e31f076a3226825'
+        settings.keys['user']['authentication'].should == ['20c274efc68a460568853cc4be586183012769a312549d1aa57e29a36ec1503d'].pack('H*')
+        settings.keys['user']['ciphertext'].should == ['39164ec082fb8b7336d3c5500af99dcb17d2e60496ed553dfab4b05c568aa926'].pack('H*')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: trustworthy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- John Downey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: hkdf
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+- !ruby/object:Gem::Dependency
+  name: scrypt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Implements a special case (k = 2) of Adi Shamir's secret sharing algorithm.
+  This allows secret files to be encrypted on disk but loaded into a process on start
+  if two keys are available.
+email:
+- jdowney@gmail.com
+executables:
+- trustworthy
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/trustworthy/crypto.rb
+- lib/trustworthy/key.rb
+- lib/trustworthy/master_key.rb
+- lib/trustworthy/random.rb
+- lib/trustworthy/settings.rb
+- lib/trustworthy/version.rb
+- lib/trustworthy.rb
+- spec/spec_helper.rb
+- spec/trustworthy/crypto_spec.rb
+- spec/trustworthy/key_spec.rb
+- spec/trustworthy/master_key_spec.rb
+- spec/trustworthy/random_spec.rb
+- spec/trustworthy/settings_spec.rb
+- bin/trustworthy
+- README.md
+homepage: http://github.com/jtdowney/trustworthy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Launch processes while keeping secrets encrypted on disk
+test_files:
+- spec/spec_helper.rb
+- spec/trustworthy/crypto_spec.rb
+- spec/trustworthy/key_spec.rb
+- spec/trustworthy/master_key_spec.rb
+- spec/trustworthy/random_spec.rb
+- spec/trustworthy/settings_spec.rb