trustworthy 0.1.0 → 0.2.0

data/lib/trustworthy/settings.rb

@@ -1,63 +1,56 @@
 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'])
+    def self.open(filename)
+      store = YAML::Store.new(filename)
+      store.transaction do
+        yield Trustworthy::Settings.new(store)
+      end
     end
 
-    def initialize(keys = {}, secrets = {})
-      @keys = keys
-      @secrets = secrets
+    def initialize(store)
+      @store = store
     end
 
     def add_key(key, username, password)
       salt = SCrypt::Engine.generate_salt
 
-      crypto = _crypto_from_password(salt, password)
+      cipher = _cipher_from_password(salt, password)
+      nonce = Trustworthy::Cipher.generate_nonce
       plaintext = "#{key.x.to_s('F')},#{key.y.to_s('F')}"
-      ciphertext = crypto.encrypt(plaintext)
+      ciphertext = cipher.encrypt(nonce, '', plaintext)
 
-      @keys[username] = {
+      @store[username] = {
         'salt' => salt,
-        'ciphertext' => ciphertext,
-        'authentication' => crypto.sign(ciphertext)
+        'encrypted_point' => nonce + ciphertext,
       }
     end
 
-    def add_secret(environment, filename)
-      @secrets[environment] = filename
+    def empty?
+      @store.roots.empty?
+    end
+
+    def find_key(username)
+      @store[username]
     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)
+      key = find_key(username)
+      salt = key['salt']
+      ciphertext = key['encrypted_point']
+      ciphertext.force_encoding('BINARY') if ciphertext.respond_to?(:force_encoding)
+      nonce = ciphertext.slice(0, Trustworthy::Cipher.nonce_len)
+      ciphertext = ciphertext.slice(Trustworthy::Cipher.nonce_len..-1)
+
+      cipher = _cipher_from_password(salt, password)
+      plaintext = cipher.decrypt(nonce, '', 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)
+    def _cipher_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)
+      key = SCrypt::Engine.scrypt(password, salt, cost, 64)
+      Trustworthy::Cipher.new(key)
     end
   end
 end

data/lib/trustworthy/version.rb

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

data/lib/trustworthy.rb

@@ -1,13 +1,16 @@
+require 'aead'
 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'
+require 'yaml/store'
+
+module Trustworthy
+  CipherAlgorithm = 'AES-256-CBC-HMAC-SHA-256'
+  Cipher = AEAD::Cipher.new(CipherAlgorithm)
+end

data/spec/spec_helper.rb

@@ -1,18 +1,30 @@
-require 'fakefs/safe'
-
 require 'trustworthy'
+require 'trustworthy/cli'
+require 'construct'
+require 'highline/simulate'
 
 RSpec.configure do |config|
   config.order = 'random'
+  config.include Construct::Helpers
   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*')
+module TestValues
+  SettingsFile = 'trustworthy.yml'
+  InitializationVector = ['39164ec082fb8b7336d3c5500af99dcb'].pack('H*')
+  Plaintext = 'the chair is against the wall'
+  Ciphertext = ['39164ec082fb8b7336d3c5500af99dcb6f5eac5d817a65b8ac7c5ed80691db36904e1ce613a1057d807b37127d927a4b0a9a1b951ef576fc9a9edca0ef5b83e2bae850a8b3b79bfeddff892d1941d439'].pack('H*')
+  Salt = '400$8$1b$3e31f076a3226825'
+  MasterKey = Trustworthy::MasterKey.new(BigDecimal.new('1'), BigDecimal.new('5'))
+  EncryptedPoint = ['39164ec082fb8b7336d3c5500af99dcb17d2e60496ed553dfab4b05c568aa9260cb8e53930911c8e718bc97eb88def400e5cac1e4ee3d15060920c25d1346285'].pack('H*')
+  EncryptedFile = ['39164ec082fb8b7336d3c5500af99dcba37f59607382f87a2da14881a9e1eabd23965d46d7c1a651b0c930cd0ee756d9358d67edaaba02a22e902136a2a90953672c2937b0cbaac0167922918578a98c'].pack('H*')
+end
+
+def create_config(filename)
+  Trustworthy::Settings.open(filename) do |settings|
+    settings.add_key(TestValues::MasterKey.create_key, 'user1', 'password1')
+    settings.add_key(TestValues::MasterKey.create_key, 'user2', 'password2')
   end
 end

data/spec/trustworthy/cli/add_key_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Trustworthy::CLI::AddKey do
+  before(:each) do
+    $terminal.stub(:say)
+  end
+
+  around(:each) do |example|
+    within_construct do |construct|
+      construct.file(TestValues::SettingsFile)
+      create_config(TestValues::SettingsFile)
+      example.run
+    end
+  end
+
+  describe 'run' do
+    it 'should add a new user' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2',
+        'user3',
+        'password3',
+        'password3'
+      ) do
+        Trustworthy::CLI::AddKey.new.run([])
+      end
+
+      contents = File.read(TestValues::SettingsFile)
+      subkeys = YAML.load(contents)
+      subkeys.should have_key('user1')
+      subkeys.should have_key('user2')
+      subkeys.should have_key('user3')
+    end
+  end
+end

data/spec/trustworthy/cli/command_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Trustworthy::CLI::Command do
+  def test_command
+    return @klass if @klass
+    @klass = Class.new
+    @klass.send(:include, Trustworthy::CLI::Command)
+    @klass
+  end
+
+  before(:each) do
+    $terminal.stub(:say)
+  end
+
+  around(:each) do |example|
+    within_construct do |construct|
+      construct.file(TestValues::SettingsFile)
+      create_config(TestValues::SettingsFile)
+      example.run
+    end
+  end
+
+  describe 'unlock_master_key' do
+    it 'should require two distinct keys to unlock' do
+      command = test_command.new
+      command.should_receive(:error).with('Key user1 is already in use')
+
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user1',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::Settings.open(TestValues::SettingsFile) do |settings|
+          master_key = command.unlock_master_key(settings)
+          master_key.should == TestValues::MasterKey
+        end
+      end
+    end
+
+    it 'should required an existing user for the first key' do
+      command = test_command.new
+      command.should_receive(:error).with('Key missing does not exist')
+
+      HighLine::Simulate.with(
+        'missing',
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::Settings.open(TestValues::SettingsFile) do |settings|
+          master_key = command.unlock_master_key(settings)
+          master_key.should == TestValues::MasterKey
+        end
+      end
+    end
+
+    it 'should required an existing user for the second key' do
+      command = test_command.new
+      command.should_receive(:error).with('Key missing does not exist')
+
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'missing',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::Settings.open(TestValues::SettingsFile) do |settings|
+          master_key = command.unlock_master_key(settings)
+          master_key.should == TestValues::MasterKey
+        end
+      end
+    end
+
+    it 'should prompt for the correct password for the first key' do
+      command = test_command.new
+      command.should_receive(:error).with('Password incorrect for user1')
+
+      HighLine::Simulate.with(
+        'user1',
+        'bad_password',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::Settings.open(TestValues::SettingsFile) do |settings|
+          master_key = command.unlock_master_key(settings)
+          master_key.should == TestValues::MasterKey
+        end
+      end
+    end
+
+    it 'should prompt for the correct password for the second key' do
+      command = test_command.new
+      command.should_receive(:error).with('Password incorrect for user2')
+
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'bad_password',
+        'password2'
+      ) do
+        Trustworthy::Settings.open(TestValues::SettingsFile) do |settings|
+          master_key = command.unlock_master_key(settings)
+          master_key.should == TestValues::MasterKey
+        end
+      end
+    end
+  end
+end

data/spec/trustworthy/cli/decrypt_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Trustworthy::CLI::Decrypt do
+  before(:each) do
+    $terminal.stub(:say)
+  end
+
+  around(:each) do |example|
+    within_construct do |construct|
+      construct.file(TestValues::SettingsFile)
+      construct.file('input.txt', TestValues::EncryptedFile)
+      construct.file('output.txt')
+      create_config(TestValues::SettingsFile)
+      example.run
+    end
+  end
+
+  describe 'run' do
+    it 'should unlock the master key and decrypt the file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::CLI::Decrypt.new.run(['-i', 'input.txt', '-o', 'output.txt'])
+      end
+
+      File.open('output.txt', 'rb') do |file|
+        ciphertext = file.read
+        ciphertext.should == TestValues::Plaintext
+      end
+    end
+
+    it 'should require an input file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        decrypt = Trustworthy::CLI::Encrypt.new
+        decrypt.should_receive(:error).with('Must provide an input file')
+        decrypt.should_receive(:print_help)
+        decrypt.run([])
+      end
+    end
+
+    it 'should require an output file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        decrypt = Trustworthy::CLI::Encrypt.new
+        decrypt.should_receive(:error).with('Must provide an output file')
+        decrypt.should_receive(:print_help)
+        decrypt.run(['-i', 'input.txt'])
+      end
+    end
+  end
+end

data/spec/trustworthy/cli/encrypt_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Trustworthy::CLI::Encrypt do
+  before(:each) do
+    $terminal.stub(:say)
+    AEAD::Cipher::AES_256_CBC_HMAC_SHA_256.stub(:generate_nonce).and_return(TestValues::InitializationVector)
+  end
+
+  around(:each) do |example|
+    within_construct do |construct|
+      construct.file(TestValues::SettingsFile)
+      construct.file('input.txt', TestValues::Plaintext)
+      construct.file('output.txt')
+      create_config(TestValues::SettingsFile)
+      example.run
+    end
+  end
+
+  describe 'run' do
+    it 'should unlock the master key and encrypt the file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        Trustworthy::CLI::Encrypt.new.run(['-i', 'input.txt', '-o', 'output.txt'])
+      end
+
+      File.open('output.txt', 'rb') do |file|
+        ciphertext = file.read
+        ciphertext.should == TestValues::EncryptedFile
+      end
+    end
+
+    it 'should require an input file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        encrypt = Trustworthy::CLI::Encrypt.new
+        encrypt.should_receive(:error).with('Must provide an input file')
+        encrypt.should_receive(:print_help)
+        encrypt.run([])
+      end
+    end
+
+    it 'should require an output file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'user2',
+        'password2'
+      ) do
+        encrypt = Trustworthy::CLI::Encrypt.new
+        encrypt.should_receive(:error).with('Must provide an output file')
+        encrypt.should_receive(:print_help)
+        encrypt.run(['-i', 'input.txt'])
+      end
+    end
+  end
+end

data/spec/trustworthy/cli/init_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Trustworthy::CLI::Init do
+  before(:each) do
+    $terminal.stub(:say)
+  end
+
+  around(:each) do |example|
+    within_construct do |construct|
+      construct.file(TestValues::SettingsFile)
+      example.run
+    end
+  end
+
+  describe 'run' do
+    it 'should not allow any previous keys to exist' do
+      create_config(TestValues::SettingsFile)
+      $terminal.should_receive(:say).with(/Config trustworthy\.yml already exists/)
+      Trustworthy::CLI::Init.new.run([])
+    end
+
+    it 'should write a settings file' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'password1',
+        'user2',
+        'password2',
+        'password2'
+      ) do
+        Trustworthy::CLI::Init.new.run([])
+      end
+
+      contents = File.read(TestValues::SettingsFile)
+      subkeys = YAML.load(contents)
+      subkeys.should have_key('user1')
+      subkeys.should have_key('user2')
+    end
+
+    it 'should confirm passwords' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'password2',
+        'password1',
+        'password1',
+        'user2',
+        'password2',
+        'password2'
+      ) do
+        Trustworthy::CLI::Init.new.run([])
+      end
+
+      contents = File.read(TestValues::SettingsFile)
+      subkeys = YAML.load(contents)
+      subkeys.should have_key('user1')
+      subkeys.should have_key('user2')
+    end
+
+    it 'should write to a specified file' do
+      filename = 'test.yml'
+      within_construct do |construct|
+        construct.file(filename)
+        HighLine::Simulate.with(
+          'user1',
+          'password1',
+          'password1',
+          'user2',
+          'password2',
+          'password2'
+        ) do
+          Trustworthy::CLI::Init.new.run(['-c', filename])
+        end
+
+        contents = File.read(filename)
+        subkeys = YAML.load(contents)
+        subkeys.should have_key('user1')
+        subkeys.should have_key('user2')
+      end
+    end
+
+    it 'should generate the specified number of keys' do
+      HighLine::Simulate.with(
+        'user1',
+        'password1',
+        'password1',
+        'user2',
+        'password2',
+        'password2',
+        'user3',
+        'password3',
+        'password3'
+      ) do
+        Trustworthy::CLI::Init.new.run(['-k', '3'])
+      end
+
+      contents = File.read(TestValues::SettingsFile)
+      subkeys = YAML.load(contents)
+      subkeys.should have_key('user1')
+      subkeys.should have_key('user2')
+      subkeys.should have_key('user3')
+    end
+
+    it 'should require two subkeys minimum' do
+      init = Trustworthy::CLI::Init.new
+      init.should_receive(:error).with('Must generate at least two keys')
+      init.should_receive(:print_help)
+      init.run(['-k', '1'])
+    end
+  end
+end

data/spec/trustworthy/master_key_spec.rb

@@ -6,11 +6,11 @@ describe Trustworthy::MasterKey do
     key1 = master_key.create_key
     key2 = master_key.create_key
 
-    ciphertext = master_key.encrypt('foobar')
+    ciphertext = master_key.encrypt(TestValues::Plaintext)
 
     new_master_key = Trustworthy::MasterKey.create_from_keys(key1, key2)
     plaintext = new_master_key.decrypt(ciphertext)
-    plaintext.should == 'foobar'
+    plaintext.should == TestValues::Plaintext
   end
 
   it 'should function with any 2 of n keys' do
@@ -18,14 +18,14 @@ describe Trustworthy::MasterKey do
     key1 = master_key1.create_key
     key2 = master_key1.create_key
 
-    ciphertext = master_key1.encrypt('foobar')
+    ciphertext = master_key1.encrypt(TestValues::Plaintext)
 
     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'
+    plaintext.should == TestValues::Plaintext
   end
 
   describe 'self.create' do
@@ -63,25 +63,25 @@ describe Trustworthy::MasterKey do
 
   describe 'encrypt' do
     it 'should encrypt and sign the data using the intercept' do
-      Trustworthy::Random.stub(:bytes).and_return(Trustworthy::TestValues::InitializationVector)
+      AEAD::Cipher::AES_256_CBC_HMAC_SHA_256.stub(:generate_nonce).and_return(TestValues::InitializationVector)
       master_key = Trustworthy::MasterKey.new(BigDecimal.new('6'), BigDecimal.new('24'))
-      ciphertext = master_key.encrypt('foobar')
-      ciphertext.should == ['0438a89ef9e5792849ef611bff0e7b405a84ac515461489499679ca77ade6a6a39164ec082fb8b7336d3c5500af99dcbde056af859baa7e72c4c2661651e88d5'].pack('H*')
+      ciphertext = master_key.encrypt(TestValues::Plaintext)
+      ciphertext.should == TestValues::Ciphertext
     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'
+      plaintext = master_key.decrypt(TestValues::Ciphertext)
+      plaintext.should == TestValues::Plaintext
     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')
+      ciphertext = TestValues::Ciphertext.next
+      expect { master_key.decrypt(ciphertext) }.to raise_error(ArgumentError, 'ciphertext failed authentication step')
     end
   end
 end
+