trocla-ruby2 0.4.0

data/lib/trocla/store.rb

@@ -0,0 +1,80 @@
+# implements the default store behavior
+class Trocla::Store
+  attr_reader :store_config, :trocla
+  def initialize(config,trocla)
+    @store_config = config
+    @trocla = trocla
+  end
+
+  # closes the store
+  # when called do whatever "closes" your
+  # store, e.g. close database connections.
+  def close
+  end
+
+  # should return value for key & format
+  # returns nil if nothing or a nil value
+  # was found.
+  # If a key is expired it must return nil.
+  def get(key,format)
+    raise 'not implemented'
+  end
+
+  # sets value for key & format
+  # setting the plain format must invalidate
+  # all other formats as they should either
+  # be derived from plain or set directly.
+  # options is a hash containing further
+  # information for the store. e.g. expiration
+  # of a key. Keys can have an expiration /
+  # timeout by setting `expires` within
+  # the options hashs. Value of `expires`
+  # must be an integer indicating the
+  # amount of seconds a key can live with.
+  # This mechanism is expected to be
+  # be implemented by the backend.
+  def set(key,format,value,options={})
+    if format == 'plain'
+      set_plain(key,value,options)
+    else
+      set_format(key,format,value,options)
+    end
+  end
+
+  # deletes the value for format
+  # if format is nil everything is deleted
+  # returns value of format or hash of
+  # format => value # if everything is
+  # deleted.
+  def delete(key,format=nil)
+    format.nil? ? (delete_all(key)||{}) : delete_format(key,format)
+  end
+
+  private
+  # sets a new plain value
+  # *must* invalidate all
+  # other formats
+  def set_plain(key,value,options)
+    raise 'not implemented'
+  end
+
+  # sets a value of a format
+  def set_format(key,format,value,options)
+    raise 'not implemented'
+  end
+
+  # deletes all entries of this key
+  # and returns a hash with all
+  # formats and values
+  # or nil if nothing is found
+  def delete_all(key)
+    raise 'not implemented'
+  end
+
+  # deletes the value of the passed
+  # key & format and returns the
+  # value.
+  def delete_format(key,format)
+    raise 'not implemented'
+  end
+end

data/lib/trocla/stores.rb

@@ -0,0 +1,39 @@
+require 'trocla/store'
+# store management
+class Trocla::Stores
+  class << self
+    def [](store)
+      stores[store.to_s.downcase]
+    end
+
+    def all
+      @all ||= Dir[ path '*' ].collect do |store|
+        File.basename(store, '.rb').downcase
+      end
+    end
+
+    def available?(store)
+      all.include?(store.to_s.downcase)
+    end
+
+    private
+    def stores
+      @@stores ||= Hash.new do |hash, store|
+        store = store.to_s.downcase
+        if File.exists?(path(store))
+          require "trocla/stores/#{store}"
+          class_name = "Trocla::Stores::#{store.capitalize}"
+          hash[store] = (eval class_name)
+        else
+          raise "Store #{store} is not supported!"
+        end
+      end
+    end
+
+    def path(store)
+      File.expand_path(
+        File.join(File.dirname(__FILE__), 'stores', "#{store}.rb")
+      )
+    end
+  end
+end

data/lib/trocla/stores/memory.rb

@@ -0,0 +1,56 @@
+# a simple in memory store just as an example
+class Trocla::Stores::Memory < Trocla::Store
+  attr_reader :memory
+  def initialize(config,trocla)
+    super(config,trocla)
+    @memory = Hash.new({})
+  end
+
+  def get(key,format)
+    unless expired?(key)
+      memory[key][format]
+    else
+      delete_all(key)
+      nil
+    end
+  end
+  def set(key,format,value,options={})
+    super(key,format,value,options)
+    set_expires(key,options['expires'])
+  end
+
+  private
+  def set_plain(key,value,options)
+    memory[key] = { 'plain' => value }
+  end
+
+  def set_format(key,format,value,options)
+    memory[key].merge!({ format => value })
+  end
+
+  def delete_all(key)
+    memory.delete(key)
+  end
+  def delete_format(key,format)
+    old_val = (h = memory[key]).delete(format)
+    h.empty? ? memory.delete(key) : memory[key] = h
+    set_expires(key,nil)
+    old_val
+  end
+  private
+  def set_expires(key,expires)
+    expires = memory[key]['_expires'] if expires.nil?
+    if expires && expires > 0
+      memory[key]['_expires'] = expires
+      memory[key]['_expires_at'] = Time.now + expires
+    else
+      memory[key].delete('_expires')
+      memory[key].delete('_expires_at')
+    end
+  end
+  def expired?(key)
+    memory.key?(key) &&
+      (a = memory[key]['_expires_at']).is_a?(Time) && \
+      (a < Time.now)
+  end
+end

data/lib/trocla/stores/moneta.rb

@@ -0,0 +1,58 @@
+# the default moneta based store
+class Trocla::Stores::Moneta < Trocla::Store
+  attr_reader :moneta
+  def initialize(config,trocla)
+    super(config,trocla)
+    require 'moneta'
+    # load expire support by default
+    adapter_options = { :expires => true }.merge(
+                          store_config['adapter_options']||{})
+    @moneta = Moneta.new(store_config['adapter'],adapter_options)
+  end
+
+  def close
+    moneta.close
+  end
+
+  def get(key,format)
+    moneta.fetch(key, {})[format]
+  end
+
+  private
+  def set_plain(key,value,options)
+    h = { 'plain' => value }
+    mo = moneta_options(key,options)
+    if options['expires'] && options['expires'] > 0
+      h['_expires'] = options['expires']
+    else
+      # be sure that we disable the existing
+      # expires if nothing is set.
+      mo[:expires] = false
+    end
+    moneta.store(key,h,mo)
+  end
+
+  def set_format(key,format,value,options)
+    moneta.store(key,
+                 moneta.fetch(key,{}).merge({ format => value }),
+                 moneta_options(key,options))
+  end
+
+  def delete_all(key)
+    moneta.delete(key)
+  end
+  def delete_format(key,format)
+    old_val = (h = moneta.fetch(key,{})).delete(format)
+    h.empty? ? moneta.delete(key) : moneta.store(key,h,moneta_options(key,{}))
+    old_val
+  end
+  def moneta_options(key,options)
+    res = {}
+    if options.key?('expires')
+      res[:expires] = options['expires']
+    elsif e = moneta.fetch(key, {})['_expires']
+      res[:expires] = e
+    end
+    res
+  end
+end

data/lib/trocla/util.rb

@@ -0,0 +1,71 @@
+require 'securerandom'
+class Trocla
+  class Util
+    class << self
+      def random_str(length=12, charset='default')
+        _charsets = charsets[charset] || charsets['default']
+        (1..length).collect{|a| _charsets[SecureRandom.random_number(_charsets.size)] }.join.to_s
+      end
+
+      def salt(length=8)
+        alphanumeric_size = alphanumeric.size
+        (1..length).collect{|a| alphanumeric[SecureRandom.random_number(alphanumeric_size)] }.join.to_s
+      end
+
+      private
+
+      def charsets
+        @charsets ||= begin
+          h = {
+            'default'      => chars,
+            'alphanumeric' => alphanumeric,
+            'shellsafe'    => shellsafe,
+            'windowssafe'  => windowssafe,
+            'numeric'      => numeric,
+            'hexadecimal'  => hexadecimal,
+            'consolesafe'  => consolesafe,
+            'typesafe'     => typesafe,
+          }
+          h.each { |k, v| h[k] = v.uniq }
+        end
+      end
+
+      def chars
+        @chars ||= shellsafe + special_chars
+      end
+      def shellsafe
+        @shellsafe ||= alphanumeric + shellsafe_chars
+      end
+      def windowssafe
+        @windowssafe ||= alphanumeric + windowssafe_chars
+      end
+      def consolesafe
+        @consolesafe ||= alphanumeric + consolesafe_chars
+      end
+      def hexadecimal
+        @hexadecimal ||= numeric + ('a'..'f').to_a
+      end
+      def alphanumeric
+        @alphanumeric ||= ('a'..'z').to_a + ('A'..'Z').to_a + numeric
+      end
+      def numeric
+        @numeric ||= ('0'..'9').to_a
+      end
+      def typesafe
+        @typesafe ||= ('a'..'x').to_a - ['i'] - ['l'] + ('A'..'X').to_a - ['I'] - ['L'] + ('1'..'9').to_a
+      end
+      def special_chars
+        @special_chars ||= "*()&![]{}-".split(//)
+      end
+      def shellsafe_chars
+        @shellsafe_chars ||= "+%/@=?_.,:".split(//)
+      end
+      def windowssafe_chars
+        @windowssafe_chars ||= "+%/@=?_.,".split(//)
+      end
+      def consolesafe_chars
+        @consolesafe_chars ||= '+.-,_'.split(//)
+      end
+    end
+  end
+end

data/lib/trocla/version.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+class Trocla
+  class VERSION
+    version = {}
+    File.read(File.join(File.dirname(__FILE__), '../', 'VERSION')).each_line do |line|
+      type, value = line.chomp.split(":")
+      next if type =~ /^\s+$/ || value =~ /^\s+$/
+      version[type] = value
+    end
+    
+    MAJOR = version['major']
+    MINOR = version['minor']
+    PATCH = version['patch']
+    BUILD = version['build']
+    
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+    
+    def self.version
+      STRING
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,290 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rspec/pending_for'
+require 'yaml'
+require 'trocla'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.shared_examples "encryption_basics" do
+  describe 'storing' do
+    it "random passwords" do
+      expect(@trocla.password('random1', 'plain').length).to eql(16)
+    end
+
+    it "long random passwords" do
+      expect(@trocla.set_password('random1_long','plain',4096.times.collect{|s| 'x' }.join('')).length).to eql(4096)
+    end
+  end
+
+  describe 'retrieve' do
+    it "random passwords" do
+      stored = @trocla.password('random1', 'plain')
+      retrieved = @trocla.password('random1', 'plain')
+      retrieved_again = @trocla.password('random1', 'plain')
+      expect(retrieved).to eql(stored)
+      expect(retrieved_again).to eql(stored)
+      expect(retrieved_again).to eql(retrieved)
+    end
+
+    it "encrypted passwords" do
+      @trocla.set_password('some_pass', 'plain', 'super secret')
+      expect(@trocla.get_password('some_pass', 'plain')).to eql('super secret')
+    end
+
+  end
+  describe 'deleting' do
+    it "plain" do
+      @trocla.set_password('some_pass', 'plain', 'super secret')
+      expect(@trocla.delete_password('some_pass', 'plain')).to eql('super secret')
+    end
+    it "delete formats" do
+      plain = @trocla.password('some_mysqlpass', 'plain')
+      mysql = @trocla.password('some_mysqlpass', 'mysql')
+      expect(@trocla.delete_password('some_mysqlpass', 'mysql')).to eql(mysql)
+      expect(@trocla.delete_password('some_mysqlpass', 'plain')).to eql(plain)
+      expect(@trocla.get_password('some_mysqlpass','plain')).to be_nil
+      expect(@trocla.get_password('some_mysqlpass','mysql')).to be_nil
+    end
+
+    it "all passwords" do
+      plain = @trocla.password('some_mysqlpass', 'plain')
+      mysql = @trocla.password('some_mysqlpass', 'mysql')
+      deleted = @trocla.delete_password('some_mysqlpass')
+      expect(deleted).to be_a_kind_of(Hash)
+      expect(deleted['plain']).to eql(plain)
+      expect(deleted['mysql']).to eql(mysql)
+    end
+  end
+end
+RSpec.shared_examples "verify_encryption" do
+  it "does not store plaintext passwords" do
+    @trocla.set_password('noplain', 'plain', 'plaintext_password')
+    expect(File.readlines(trocla_yaml_file).grep(/plaintext_password/)).to be_empty
+  end
+
+  it "makes sure identical passwords do not match when stored" do
+    @trocla.set_password('one_key', 'plain', 'super secret')
+    @trocla.set_password('another_key', 'plain', 'super secret')
+    yaml = YAML.load_file(trocla_yaml_file)
+    expect(yaml['one_key']['plain']).not_to eq(yaml['another_key']['plain'])
+  end
+end
+
+RSpec.shared_examples 'store_validation' do |store|
+  describe '.get' do
+    it { expect(store.get('some_key','plain')).to be_nil }
+  end
+  describe '.set' do
+    it 'stores nil values' do
+      store.set('some_nil_value','plain',nil)
+      expect(store.get('some_nil_value','plain')).to be_nil
+    end
+    it 'stores plain format' do
+      store.set('some_value','plain','value')
+      expect(store.get('some_value','plain')).to eql('value')
+    end
+    it 'stores other formats' do
+      store.set('some_value','foo','bla')
+      expect(store.get('some_value','foo')).to eql('bla')
+    end
+    it 'resets other formats on setting plain' do
+      store.set('some_value','foo','bla')
+      store.set('some_value','plain','value')
+      expect(store.get('some_value','plain')).to eql('value')
+      expect(store.get('some_value','foo')).to be_nil
+    end
+  end
+  describe '.delete' do
+    it { expect(store.delete('something','foo')).to be_nil }
+    it { expect(store.delete('something')).to be_empty }
+    it 'deletes the value of a format' do
+      store.set('some_value','foo','bla')
+      expect(store.delete('some_value','foo')).to eql('bla')
+      expect(store.get('some_value','foo')).to be_nil
+    end
+    it 'deletes only the value of a format' do
+      store.set('some_value','plain','value')
+      store.set('some_value','foo','bla')
+      expect(store.delete('some_value','plain')).to eql('value')
+      expect(store.get('some_value','plain')).to be_nil
+      expect(store.get('some_value','foo')).to eql('bla')
+    end
+    it 'deletes all values without a format' do
+      store.set('some_value','plain','value')
+      store.set('some_value','foo','bla')
+      hash = store.delete('some_value')
+      expect(hash).to be_a_kind_of(Hash)
+      expect(hash['plain']).to eql('value')
+      expect(hash['foo']).to eql('bla')
+      expect(store.get('some_value','plain')).to be_nil
+      expect(store.get('some_value','foo')).to be_nil
+    end
+  end
+  describe 'expiration' do
+    it 'will not return an expired key' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'increases expiration when setting anything for that key' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 1
+      store.set('some_expiring_value','bla','bla_to_be_expired',{ 'expires' => 3 })
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'keeps expiration when setting another value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      store.set('some_expiring_value','foo','to_be_expired_foo')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+      expect(store.get('some_expiring_value','foo')).to be_nil
+    end
+    it 'setting plain clears everything including expiration' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      sleep 1
+      store.set('some_expiring_value','plain','to_be_expired2')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+    end
+    it 'extends expiration when setting another value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 4 })
+      sleep 2
+      store.set('some_expiring_value','foo','to_be_expired_foo')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'extends expiration when deleting a format' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 4 })
+      store.set('some_expiring_value','foo','to_be_expired2')
+      sleep 2
+      expect(store.delete('some_expiring_value','foo')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'keeps expiration although we\'re fetching a value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 3 })
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'readding a value with an expiration makes it expiring in the future' do
+      store.set('some_expiring_value','plain','to_be_expired')
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'setting an expires of false removes expiration' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => false })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+    end
+    it 'setting an expires of 0 removes expiration' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 0 })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+    end
+    it 'setting an expires of false removes expiration even if it\'s for a different format' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','foo','to_be_expired_foo',{ 'expires' => false })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      expect(store.get('some_expiring_value','foo')).to eql('to_be_expired_foo')
+    end
+    it 'setting an expires of 0 removes expiration even if it\'s for a different format' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','foo','to_be_expired_foo',{ 'expires' => 0 })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      expect(store.get('some_expiring_value','foo')).to eql('to_be_expired_foo')
+    end
+  end
+end
+
+def default_config
+  @default_config ||= YAML.load(File.read(File.expand_path(base_dir+'/lib/trocla/default_config.yaml')))
+end
+
+def test_config
+  @config ||= default_config.merge({
+    'store' => :memory,
+  })
+end
+
+def test_config_persistent
+  @config ||= default_config.merge({
+    'store_options' => {
+      'adapter'         => :YAML,
+      'adapter_options' => {
+        :file => trocla_yaml_file
+      },
+    },
+  })
+end
+
+def ssl_test_config
+  @ssl_config ||= test_config_persistent.merge({
+    'encryption' => :ssl,
+    'encryption_options' => {
+      :private_key => data_dir('trocla.key'),
+      :public_key  => data_dir('trocla.pub'),
+    },
+  })
+end
+
+def base_dir
+  File.dirname(__FILE__)+'/../'
+end
+
+def data_dir(file = nil)
+  File.expand_path(File.join(base_dir, 'spec/data', file))
+end
+
+def trocla_yaml_file
+  data_dir('trocla_store.yaml')
+end
+
+def generate_ssl_keys
+  require 'openssl'
+  rsa_key = OpenSSL::PKey::RSA.new(4096)
+  File.open(data_dir('trocla.key'), 'w') { |f| f.write(rsa_key.to_pem) }
+  File.open(data_dir('trocla.pub'), 'w') { |f| f.write(rsa_key.public_key.to_pem) }
+end
+
+def remove_ssl_keys
+  File.unlink(data_dir('trocla.key'))
+  File.unlink(data_dir('trocla.pub'))
+end
+
+def remove_yaml_store
+  File.unlink(trocla_yaml_file)
+end
+class Trocla::Formats::Sleep < Trocla::Formats::Base
+  def format(plain_password,options={})
+    sleep options['sleep'] ||= 0
+    (options['sleep'] + 1 ).times.collect{ plain_password }.join(' ')
+  end
+end