reedb 0.10.rc1 → 0.11

data/lib/reedb/debouncer.rb

@@ -0,0 +1,129 @@
+# ====================================================
+# Copyright 2015 Lonely Robot (see @author)
+# @author: Katharina Sabel | www.lonelyrobot.io
+#
+# Distributed under the GNU Lesser GPL Version 3
+# (See accompanying LICENSE file or get a copy at
+# 	https://www.gnu.org/licenses/lgpl.html)
+# ====================================================
+
+'' '
+This file contains the debounce handler for the daemon.
+That means that it is handed vault information and woken up every time there is an action
+on a specified vault which makes it "debounce" back to the start of the counter.
+' ''
+
+require_relative 'constants'
+
+DRES = 0xEEE
+VREM = 0xFFF
+VINS = 0x000
+
+module Reedb
+	class Debouncer
+
+		attr_accessor :running
+
+		#
+		# @param core [Object] the owning container instance to
+		#               register the debounce close of a vault
+		# @return self
+		#
+		def initialize(core)
+			@reedb = core
+			@running = true
+
+			# Vault management
+			@delta_vaults = {}
+			@vaults = {}
+			@token_set = {}
+			@timeout = Reedb::KEY_CACHE_TIME
+		end
+
+		def set_custom_timeout(time)
+			@timeout = time
+		end
+
+		# The main loop to run in a thread
+		def main
+			last = Time.new
+			while @running
+				# Update the delta time
+				tmp = Time.new; r_delta = tmp - last
+
+				# Work through the delta_vaults file to check what info needs to change
+				@delta_vaults.each do |uuid, data|
+
+					# Make sure that the vault set is current
+					if data == VINS
+						@vaults[uuid] = @timeout
+					elsif data == VREM
+						@vaults.delete(uuid)
+					elsif data == DRES
+						@vaults[uuid] = @timeout
+					end
+				end
+
+				# Then reset it for the next delta
+				@delta_vaults = {}
+
+				# Now actually iterate through the vaults and subtract delta time
+				@vaults.each do |uuid, data|
+
+					# Subtract real delta time from timeset
+					@vaults[uuid] = data - r_delta
+
+					# Then check if that vault needs to be closed
+					if @vaults[uuid] <= 0
+						Reedb::Vault::close_vault(uuid, @token_set[uuid])
+					end
+				end
+				
+				last = tmp # Update last time and then sleep
+				sleep(Reedb::DEBOUNCE_DELTA)
+			end
+			# puts 'I can feel my mind going, Dave'
+		end
+
+		# Updates the vault instances every time the vault set changes. Only changes values
+		# for vaults that change and attempts to leave old vaults unchanged.
+		#
+		# @param [String] uuid of a vault for identification
+		# @param [String] token as a Base64 encoded string
+		#
+		# @return Boolean to indicate whether there was already a token for this vault
+		#
+		def add_vault(uuid, token)
+			if @vaults.include?(uuid)
+
+				# Marks the vault to debounce because it was just interacted with but already in scope
+				@delta_vaults[uuid] = DRES
+				return false
+			else
+				@delta_vaults[uuid] = VINS
+				@token_set[uuid] = token
+				return true
+			end
+		end
+
+		def remove_vault(uuid)
+			@delta_vaults[uuid] = VREM
+			@token_set.delete(uuid)
+		end
+
+		# This is called every time an action is performed on a vault.
+		def debounce_vault(vault_id)
+			@delta_vaults[vault_id] = DRES
+		end
+
+		# Some utility and helper functions to plug into the Reedb main interface
+		def knows_vault(uuid)
+			return @vaults.include?(uuid)
+		end
+
+		def get_token(uuid)
+			return @token_set[uuid]
+		end
+
+	end
+end

data/lib/reedb/errors/daemon_errors.rb

@@ -12,15 +12,18 @@
 class DaemonError < StandardError
 end
 
+# These are scoping errors
 class VaultAlreadyScopedError < DaemonError
 end
 
 class VaultNotScopedError < DaemonError
 end
 
+# Not knowing a vault
 class VaultNotAvailableError < DaemonError
 end
 
+# Token errors
 class UnknownTokenError < DaemonError
 end
 
@@ -28,7 +31,4 @@ class UnautherisedTokenError < DaemonError
 end
 
 class MissingTokenError < DaemonError
-end
-
-class FunctionNotImplementedError < DaemonError
-end
+end

data/lib/reedb/errors/exit_errors.rb

@@ -0,0 +1,12 @@
+module Reedb
+
+	# Exit codes to be used throughout the API
+	EXIT_STILL_LOCKED = 0x10
+	EXIT_OS_PARSE = 0x11
+
+	# Severe panic codes
+	EXIT_PANIC_INTERUPT = 0x31
+	EXIT_MISSING_USER_CODE = 0x32
+	EXIT_CORRUPT_FS = 0x33
+	EXIT_HTTP_MALFUNCT = 0x34
+end

data/lib/reedb/errors/reedb_errors.rb

@@ -0,0 +1,21 @@
+# ====================================================
+# Copyright 2015 Random Robot Softworks (see @author)
+# @author: Katharina Sabel | www.lonelyrobot.io
+#
+# Distributed under the GNU Lesser GPL Version 3
+# (See accompanying LICENSE file or get a copy at
+# 	https://www.gnu.org/licenses/lgpl.html)
+# ====================================================
+
+# Some errors code that are too generic to go into either of the categories.
+# They just apply to EVERYTHING!
+
+class ReedbError < StandardError
+end
+
+# General Error
+class FunctionNotImplementedError < ReedbError
+end
+
+class UnknownOSError < ReedbError
+end

data/lib/reedb/errors/vault_errors.rb

@@ -19,21 +19,23 @@ end
 class VaultWritePermissionsError < VaultError
 end
 
+# I/O error or fucked?
 class VaultMissingConfigurationError < VaultError
 end
 
-class VaultLoggerError < VaultError
+class FileNotFoundError < VaultError
 end
 
-# This has been depreciated.
-class BadCacheError < VaultError
+class FileBusyError < VaultError
 end
 
-class FileNotFoundError < VaultError
+class MalformedSearchError < VaultError
 end
 
-class FileBusyError < VaultError
+# This one is VERY hypothetical
+class VaultLoggerError < VaultError
 end
 
-class MalformedSearchError < VaultError
+# This has been depreciated.
+class BadCacheError < VaultError
 end

data/lib/reedb/reevault.rb

@@ -54,9 +54,9 @@ module Reedb
 		# Constructor for a vault with name, path and encryption enum.
 		# Valid encryption parameters are :aes, :twofish, :multi and :auto_fill
 		#
-		def initialize(name, path, encprytion)
+		def initialize(name, path, encprytion, header_override = nil)
 			@already_logging = false
-			
+
 			# Header maps
 			@headers = {}
 			@hgroups = {}
@@ -66,13 +66,16 @@ module Reedb
 			@locks = []
 
 			# Defines the default (and boring vanilla) header set
-			@header_set = {
-				'urls'=>'list',
-				'tags'=>'list'
-			}
+			# TODO: Get the header set via config and init that instead!
+			@header_set = header_override ? header_override : { 'urls' => 'list', 'tags' => 'list' }
 
+			# Make the path available as an object variable
 			construct_path("#{name}", "#{path}")
-			init_encryption(encprytion) # => Throws exceptions!
+
+			# Init ecnryption module. So @crypt must not be nil after this
+			init_encryption(encprytion)
+
+			# Setup the secure config to false by default. Change this?
 			self.secure_config(false)
 			return self
 		end
@@ -114,7 +117,9 @@ module Reedb
 		# a write cycle. Which would cause horrible crashes on other applications
 		# and errors on the file system if things are moved around inside
 		#
-		def locked?() return @locked end
+		def locked?;
+			@locked
+		end
 
 		def create(password = :failed)
 			# If keygen was used to set a user password then fetch it
@@ -123,7 +128,7 @@ module Reedb
 			return nil unless encryption?(password)
 
 			# puts "This is the password: #{password}"
-			
+
 			# => Encryption now active and key available under @crypt.key
 			@conf_path = "#{@path}/config"
 
@@ -131,22 +136,17 @@ module Reedb
 
 			if self.includes?('config')
 				raise VaultExistsAtLocationError.new, "Vault already exists at location #{@path}. Aborting operation..."
-				
+
 				# => This rules out lots of code to be run
 				needs_creation = false
 			else
-				if Reedb::archos == :linux || Reedb::archos == :osx
-					FileUtils::mkdir_p(File.expand_path("#{@path}/data")) # => Data dir
-					FileUtils::mkdir(File.expand_path("#{@path}/shasums")) # => Checksum dir
-					FileUtils::mkdir(File.expand_path("#{@path}/logs")) # => Logs dir
+				FileUtils::mkdir_p(File.expand_path("#{@path}/data")) # => Data dir
+				FileUtils::mkdir(File.expand_path("#{@path}/shasums")) # => Checksum dir
+				FileUtils::mkdir(File.expand_path("#{@path}/logs")) # => Logs dir
 
+				# On *nix devices change permissions.
+				if Reedb::archos == :linux || Reedb::archos == :osx || Reedb::archos == :vars
 					FileUtils::chmod_R(0744, "#{@path}")
-
-				# This is used for windows because windows fucking sucks!
-				else
-					FileUtils::mkdir_p(File.expand_path("#{@path}/data")) # => Data dir
-					FileUtils::mkdir(File.expand_path("#{@path}/shasums")) # => Checksum dir
-					FileUtils::mkdir(File.expand_path("#{@path}/logs")) # => Logs dir
 				end
 			end
 
@@ -167,15 +167,20 @@ module Reedb
 				@config['updating_machine'] = "#{Socket.gethostname}"
 				@config['creation_user'] = "#{Etc.getlogin}"
 				@config['updating_user'] = "#{Etc.getlogin}"
-				@config['header_set'] = "#{@header_set}"
+
+				# Convert the header set to JSON, then write it into the config
+				hset = JSON.dump(@header_set)
+				@config['header_set'] = "#{hset}"
+
+				# Add the Reedb version this vault was created with for upgradability
 				@config['creation_version'] = "#{Reedb::VERSION}"
 				save_config
-				
+
 				# Now writing encrypted key to file with ASCII armour
-				update_secure_info("cey", @encrypted_key)
+				update_secure_info('cey', @encrypted_key)
 				# remove_instance_variable(:@encrypted_key)
 			end
-			self.load("#{password}")
+			self.load(password)
 		end
 
 		def load(password)
@@ -192,10 +197,9 @@ module Reedb
 				@config = YAML.load_file("#{@path}/config")
 			end
 
-			
 
 			return nil unless unlock_vault("#{password}")
-			VaultLogger.write("Finished loading vault", 'debug')
+			VaultLogger.write('Finished loading vault', 'debug')
 			cache_headers
 
 			return self
@@ -207,10 +211,10 @@ module Reedb
 		def read_file(name, history = false)
 
 			# Loads the file data into a local variable if it exists
-			file_data = load_file_data(name) 
+			file_data = load_file_data(name)
 			if file_data == nil
 				raise FileNotFoundError.new("#{name} could not be read: File not found!")
-				return VAULT_FILE_NOT_FOUND_ERROR # If the exception isn't handled correctly
+				# return VAULT_FILE_NOT_FOUND_ERROR # If the exception isn't handled correctly
 			else
 				# This code is executed if the file was found (thus data is in file_data)
 				compiled = {}
@@ -218,14 +222,14 @@ module Reedb
 
 				# Removes the latest version from the header because it is insignificant.
 				file_data['header'].each do |key, value|
-					compiled['header']["#{key}"] = value unless key == "latest"
+					compiled['header']["#{key}"] = value unless key == 'latest'
 				end
 
 				if history
 					compiled['body'] = file_data['body']
 				else
 					body_list = []
-					file_data['body'].each do |key, value|
+					file_data['body'].each do |key, _|
 						body_list << key
 					end
 
@@ -233,14 +237,16 @@ module Reedb
 
 					# Now sort the list of body versions
 					body_list.heapsort!
+
+					# Then compile the data together into one data hash
 					body_list.each do |version|
 						file_data['body']["#{version}"].each do |key, value|
 							compiled['body']["#{key}"] = value
 						end
 					end
 				end
-				
-				# Then return that value
+
+				# Then return that hash. Huzza!
 				return compiled
 			end
 		end
@@ -249,9 +255,12 @@ module Reedb
 		# This function is also used to delete fields from header space.
 		#
 		def update(name, data)
-			cache_headers # Cache headers first to be sure
 
-			(raise FileBusyError.new, "File #{name} busy" ; return) if @locks.include?(name)
+			# Cache headers first to be sure we're up to date
+			cache_headers
+
+			# Raises exception and [returns] in case exception isn't properly being handled
+			(raise FileBusyError.new, "File #{name} busy"; return) if @locks.include?(name)
 			@locks << name
 
 			if @headers.key?(name)
@@ -278,11 +287,10 @@ module Reedb
 			@locks.delete(name)
 		end
 
-		def remove_file name
+		def remove_file(name)
 			path_to_file = load_file_hash(name)
 			if path_to_file
 				FileUtils.rm(path_to_file)
-				puts "Successfullly removed file #{name}"
 				VaultLogger.write("Removed file #{name} from vault.", 'debug')
 			else
 				raise FileNotFoundError.new("#{name} could not be removed: File not found!")
@@ -311,9 +319,10 @@ module Reedb
 					slice = target.split('=')
 					query["#{slice[0]}"] = slice[1..-1]
 				end
-				# puts query
+
+					# Rescue the query in case it was bad
 			rescue
-				raise MalformedSearchError.new, "Malformed search data"
+				raise MalformedSearchError.new, 'Malformed search data'
 			end
 
 			log_query = {}
@@ -322,7 +331,7 @@ module Reedb
 			query.each do |cat, data|
 				data.each do |val|
 					log_query["#{cat}"] = @hgroups["#{cat}"]["#{val}"] if @hgroups["#{cat}"].include?(val)
-					log_query["#{cat}"].each { |c| candidates << c unless candidates.include?(c)  }
+					log_query["#{cat}"].each { |c| candidates << c unless candidates.include?(c) }
 				end
 			end
 			return_buffer = candidates
@@ -337,16 +346,17 @@ module Reedb
 
 		# Dump headers and files from memory in times of
 		# inactivity for security reasons
-		def unload
+		def unload(time)
 			remove_instance_variable(:@headers)
 			@headers = {}
 
-			VaultLogger.write("It has been $TIME since the last interaction. Unloading vault contents for security reasons.", 'debug')
+			VaultLogger.write("It has been #{time*60} minutes since the last interaction. Unloading vault contents for security reasons.", 'debug')
 		end
 
 		def close
-			VaultLogger.write("Scheduled closing of the vault.", 'debug')
-			@crypt.stop_encryption if @crypt.init
+			VaultLogger.write('Force closing the vault. Check parent logs for details', 'debug')
+			# puts "Crypto module is: #{@crypt}"
+			@crypt.stop_encryption if @crypt && @crypt.init
 
 			# Removing class variables for cleanup
 			remove_instance_variable(:@crypt)
@@ -354,7 +364,7 @@ module Reedb
 		end
 
 		# Quickly returns if a file exists in the vault or it's children.
-		def includes? file
+		def includes?(file)
 			return File.exists?("#{@path}/#{file}")
 		end
 
@@ -369,24 +379,25 @@ module Reedb
 		def cache_headers
 			@headers = {}
 
-			VaultLogger.write("Starting a cache cycle.", 'debug')
+			VaultLogger.write('Starting a cache cycle.', 'debug')
 
 			Dir.glob("#{@path}/data/*.ree") do |file|
 				f = File.open(file, 'r')
 				encrypted = Base64.decode64(f.read)
 				decrypted = @crypt.decrypt(encrypted)
 
-				data = JSON.parse(decrypted)
-				df = DataFile.new(nil, self, data)
+				raw = JSON.parse(decrypted)
+				df = DataFile.new(nil, self, raw)
 
 				tmp_head = df.cache(:header)
 				tmp_name = df.name
 
 				# Blank the df variable just in case.
-				df = 0x111111111111111
-				
-				@headers[tmp_name] = tmp_head 
-				
+				df = 0xEFFFFFFFFFFFFFFF
+				# remove_instance_variable(df)
+
+				@headers[tmp_name] = tmp_head
+
 				# Now work with the header set to determine sub-groups
 				tmp_head.each do |category, data|
 
@@ -450,10 +461,10 @@ module Reedb
 			if @secure_config
 				update_secure_info('config', @config)
 				par_path = "#{@path}/pom"
-				msg = "Why are you reading this?"
-				File.open("#{par_path}", "wb").write(Base64.encode64("#{msg}"))
+				msg = 'Polarbears are left handed. Spread the word!'
+				File.open("#{par_path}", 'wb').write(Base64.encode64("#{msg}"))
 			else
-				File.open("#{@conf_path}", "wb+"){ |f| YAML.dump(@config, f) }
+				File.open("#{@conf_path}", 'wb+') { |f| YAML.dump(@config, f) }
 			end
 		end
 
@@ -461,24 +472,26 @@ module Reedb
 		# additional slashes from the end.
 		#
 		def construct_path(name, path)
-			(@name = name ; @path = "")
-			path.end_with?("/") ? @path = "#{path}#{name}.reevault" : @path = "#{path}/#{name}.reevault"
+			(@name = name; @path = '')
+			path.end_with?('/') ? @path = "#{path}#{name}.reevault" : @path = "#{path}/#{name}.reevault"
 		end
 
 		def update_secure_info(name, data = nil)
 			path = "#{@path}/#{name}"
-			File.open(path, "wb").write(Base64.encode64("#{data}"))
+			File.write(path, Base64.encode64(data))
+			# File.open(path, 'wb+').write(Base64.encode64(data))
 		end
 
-		def read_secure_info name
+		def read_secure_info(name)
 			path = "#{@path}/#{name}"
-			return Base64.decode64(File.open(path, "r").read())
+			return Base64.decode64(File.read(path))
+			# return Base64.decode64(File.open(path, 'r').read())
 		end
 
-		def init_logger bool
+		def init_logger(bool)
 			begin
 				unless logger?(bool)
-					raise VaultLoggerError.new, "Logger failed to be initialised" 
+					raise VaultLoggerError.new, 'Logger failed to be initialised'
 				end
 			rescue VaultError => e
 				puts e.message
@@ -489,18 +502,16 @@ module Reedb
 			(return false) if @already_logging && bool
 
 			VaultLogger.setup("#{@path}")
-			(@already_logging = true ; return true)
+			(@already_logging = true; return true)
 		end
 
-		def password? password
-			raise MissingUserPasswordError.new, "Encryption error: Missing user password!" if password == nil
-
-			raise InsecureUserPasswordError.new, "Encryption error: Password too short! See: https://xkcd.com/936/" if password.length < Reedb::passlength
-
+		def password?(password)
+			raise MissingUserPasswordError.new, 'Encryption error: Missing user password!' if password == nil
+			raise InsecureUserPasswordError.new, 'Encryption error: Password too short! See: https://xkcd.com/936/' if password.length < Reedb::passlength
 			return true
 		end
 
-		def encryption? password
+		def encryption?(password)
 			begin
 				@encrypted_key = @crypt.start_encryption(password)
 			rescue EncryptionError => e
@@ -513,13 +524,14 @@ module Reedb
 		# Unlocks the vault by decrypting the key and loading it into memory
 		# Enables the cryptographic module to decrypt and encrypt files.
 		#
-		def unlock_vault pw
+		def unlock_vault(pw)
 			begin
 				@encrypted_key = read_secure_info('cey') unless @encrypted_key
 				@crypt.start_encryption(pw, @encrypted_key)
 				remove_instance_variable(:@encrypted_key) if @encrypted_key
-			rescue #TODO: Check exception type here.
-				raise WrongUserPasswordError.new, "Incorrect user passphrase. Could not unlock!"
+			rescue Exception => e
+				puts e.class # TODO: This finds out the class of the exception next time it is encountered c:
+				raise WrongUserPasswordError.new, 'Incorrect user passphrase. Could not unlock!'
 			end
 
 			# Return values for the rest of the file.
@@ -542,6 +554,6 @@ module Reedb
 				raise MissingEncryptionTypeError.new, "Encryption failed: Missing type. Aborting..."
 			end
 		end
-	
+
 	end # class close
 end # module close

data/lib/reedb/security/encryption.rb

@@ -42,11 +42,7 @@ module Reedb
 		# Used to hash file-names in vaults
 		#
 		def self.tiger_hash(string)
-			if Reedb::verbose?
-				DaemonLogger.write("[FIX ME]: t_hash is a broken function!", "warn")
-			end
-			return self.sha512_hash("#{string}")
-			# Digest::Tiger.hexdigest("#{string}")
+			return Digest::Tiger.hexdigest("#{string}")
 		end
 
 		# => Returns 64 byte sha hash.

data/lib/reedb/security/tokens.rb

@@ -0,0 +1,21 @@
+# ====================================================
+# Copyright 2015 Lonely Robot (see @author)
+# @author: Katharina Sabel | www.2rsoftworks.de
+#
+# Distributed under the GNU Lesser GPL Version 3
+# (See accompanying LICENSE file or get a copy at
+# 	https://www.gnu.org/licenses/lgpl.html)
+# ====================================================
+
+module Reedb
+
+	# Class that can generate tokens for any occasion that are
+	# cryptographically more secure.
+	#
+	class TokenFactory
+		
+		def initialize params
+			# Constructor stub
+		end
+	end
+end

data/lib/reedb/utils/logger.rb

@@ -36,17 +36,17 @@ module Reedb
 		# 'warn':: Logs a warning. Should be event that won't impact stability.
 		# 'error':: Logs an error. Should be recoverable event.
 		# 'fatal':: Logs a fatal crash. Should make the Reepass daemon crash!
-		def self.write(message, level = "")
-			if level == "warn"
+		def self.write(message, level = '')
+			if level == 'warn'
 				@@logger.warn(message)
 
-			elsif level == "debug"
+			elsif level == 'debug'
 				@@logger.debug(message)
 
-			elsif level == "error"
+			elsif level == 'error'
 				@@logger.error(message)
 
-			elsif level == "fatal"
+			elsif level == 'fatal'
 				@@logger.fatal(message)
 				
 			else