sym 2.3.0 → 2.4.3

data/lib/sym/application.rb

@@ -2,62 +2,80 @@ require 'colored2'
 require 'sym'
 require 'sym/app'
 require 'openssl'
+require 'json'
 
 module Sym
   class Application
 
     attr_accessor :opts,
-                  :opts_hash,
+                  :opts_original,
+                  :opts,
+                  :provided_options,
                   :args,
                   :action,
                   :key,
+                  :key_source,
                   :input_handler,
                   :key_handler,
                   :result,
                   :password_cache
 
     def initialize(opts)
-      self.opts      = opts
-      self.opts_hash = opts.respond_to?(:to_hash) ? opts.to_hash : opts
-      self.args      = ::Sym::App::Args.new(opts_hash)
+      self.opts_original = opts
+      self.opts          = opts.is_a?(Hash) ? opts : opts.to_hash
 
+      process_negated_option(opts[:negate]) if opts[:negate]
+      self.args = ::Sym::App::Args.new(self.provided_options)
+
+      initialize_action
+      initialize_data_source
       initialize_password_cache
       initialize_input_handler
-      initialize_key_handler
-      initialize_action
     end
 
-    def initialize_action
-      self.action = if opts[:encrypt] then
-                      :encr
-                    elsif opts[:decrypt]
-                      :decr
-                    end
+    def provided_options
+      provided_opts = self.opts.clone
+      provided_opts.delete_if { |k, v| !v }
+      provided_opts
+    end
+
+    def provided_safe_options
+      provided_options.map do |k, v|
+        k == :key && [44, 45].include?(v.size) ?
+          [k, '[reducted]'] :
+          [k, v]
+      end.to_h
+    end
+
+    def provided_flags
+      provided_flags = provided_options
+      provided_flags.delete_if { |k, v| ![false, true].include?(v) }
+      provided_flags.keys
+    end
+
+    def provided_value_options
+      provided = provided_safe_options
+      provided.delete_if { |k, v| [false, true].include?(v) }
+      provided
     end
 
     def execute!
-      if !args.generate_key? && (args.require_key? || args.specify_key?)
-        log :debug, 'operation requires a key...'
-        self.key = Sym::App::PrivateKey::Handler.new(opts, input_handler, password_cache).key
-        unless self.key
-          log :error, 'Unable to determine the key, which appears to be required'
-          raise Sym::Errors::NoPrivateKeyFound, 'Private key is required'
-        end
-      end
-      log :info, "detected command [#{command.class.name}]"
+      initialize_key_source
       unless command
-        raise Sym::Errors::InsufficientOptionsError, 'Can not determine what to do from the options ' + opts_hash.keys.reject { |k| !opts[k] }.to_s
+        raise Sym::Errors::InsufficientOptionsError,
+              " Can not determine what to do
+        from the options: \ n " +
+                " #{self.provided_options.inspect.green.bold}\n" +
+                "and flags #{self.provided_flags.to_s.green.bold}"
+      end
+      log :info, "command located is #{command.class.name.blue.bold}"
+      self.result = command.execute.tap do |result|
+        log :info, "result is  #{result.nil? ? 'nil' : result[0..10].to_s.blue.bold }..." if opts[:trace]
       end
-      self.result = command.execute
-    end
-
-    def log(*args)
-      Sym::App.log(*args, **opts)
     end
 
     def execute
       execute!
-
     rescue ::OpenSSL::Cipher::CipherError => e
       { reason:    'Invalid key provided',
         exception: e }
@@ -67,8 +85,8 @@ module Sym
         exception: e }
 
     rescue TypeError => e
-      if e.message =~ /marshal/
-        { reason: 'Corrupt source data or invalid/corrupt key provided',
+      if e.message =~ /marshal/m
+        { reason:    'Corrupt source data or invalid/corrupt key provided',
           exception: e }
       else
         { exception: e }
@@ -84,10 +102,17 @@ module Sym
       @command
     end
 
+    def log(*args)
+      Sym::App.log(*args, **opts)
+    end
+
     def editor
       editors_to_try.find { |editor| File.exist?(editor) }
     end
 
+
+    private
+
     def editors_to_try
       [
         ENV['EDITOR'],
@@ -108,17 +133,74 @@ module Sym
     end
 
     def initialize_key_handler
-      self.key_handler = ::Sym::App::PrivateKey::Handler.new(self.opts, input_handler, password_cache)
+      self.key_handler = ::Sym::App::PrivateKey::Handler.new(opts, input_handler, password_cache)
     end
 
     def initialize_password_cache
       args            = {}
-      args[:timeout]  = opts[:cache_for].to_i if opts[:cache_for]
-      args[:enabled]  = opts[:cache_password]
+      args[:timeout]  = (opts[:cache_timeout] || ENV['SYM_CACHE_TTL'] || Sym::Configuration.config.password_cache_timeout).to_i
+      args[:enabled]  = opts[:cache_passwords]
       args[:verbose]  = opts[:verbose]
       args[:provider] = opts[:cache_provider] if opts[:cache_provider]
 
       self.password_cache = Sym::App::Password::Cache.instance.configure(args)
     end
+
+    def process_negated_option(file)
+      opts.delete(:negate)
+      opts[:file] = file
+      extension   = Sym.config.encrypted_file_extension
+      if file.end_with?('.enc')
+        opts[:decrypt] = true
+        opts[:output]  = file.gsub(/\.#{extension}/, '')
+        opts.delete(:output) if opts[:output] == ''
+      else
+        opts[:encrypt] = true
+        opts[:output]  = "#{file}.#{extension}"
+      end
+    end
+
+    def initialize_action
+      self.action = if opts[:encrypt] then
+                      :encr
+                    elsif opts[:decrypt]
+                      :decr
+                    end
+    end
+
+    # If we are encrypting or decrypting, and no data has been provided, check if we
+    # should read from STDIN
+    def initialize_data_source
+      if self.action && opts[:string].nil? && opts[:file].nil? && !(STDIN.tty?)
+        opts[:file] = '-'
+      end
+    end
+
+    # If no key is provided with command line options, check the default
+    # key location (which can be changed via Configuration class).
+    # In any case, attempt to initialize the key one way or another.
+    def initialize_key_source
+      detect_key_source
+
+      if args.require_key? && !self.key
+        log :error, 'Unable to determine the key, which appears to be required with current args'
+        raise Sym::Errors::NoPrivateKeyFound, 'Private key is required when ' + provided_flags.join(', ') << 'ing.'
+      end
+      log :debug, "initialize_key_source: detected key ends with [...#{(key ? key[-5..-1] : 'nil').bold.magenta}]"
+      log :debug, "opts: #{self.provided_value_options.to_s.green.bold}"
+      log :debug, "flags: #{self.provided_flags.to_s.green.bold}"
+    end
+
+    def detect_key_source
+      initialize_key_handler
+      self.key = self.key_handler.key
+      if self.key
+        self.key_source = key_handler.key_source
+        if key_source =~ /^default_file/
+          opts[:key] = self.key
+        end
+        log :info, "key was detected from source #{key_source.to_s.bold.green}"
+      end
+    end
   end
 end

data/lib/sym/configuration.rb

@@ -39,5 +39,6 @@ module Sym
     attr_accessor :compression_enabled, :compression_level
     attr_accessor :password_cache_default_provider, :password_cache_timeout
     attr_accessor :password_cache_arguments
+    attr_accessor :default_key_file, :encrypted_file_extension
   end
 end

data/lib/sym/constants.rb

@@ -0,0 +1,24 @@
+require 'logger'
+module Sym
+  module Constants
+    module Completion
+      FILE = '.sym.completion'.freeze
+      PATH = "#{ENV['HOME']}/#{FILE}".freeze
+      Config = {
+        file:   File.expand_path('../../../bin/sym.completion', __FILE__),
+        script: "[[ -f '#{PATH}' ]] && source '#{PATH}'",
+      }.freeze
+
+    end
+
+    module Log
+      NIL = Logger.new(nil).freeze # empty logger
+      LOG = Logger.new(STDERR).freeze
+    end
+
+    ENV_ARGS_VARIABLE_NAME = 'SYM_ARGS'.freeze
+    SYM_KEY_FILE = "#{ENV['HOME']}/.sym.key"
+  end
+end
+
+

data/lib/sym/data/decoder.rb

@@ -1,6 +1,7 @@
-require_relative '../errors'
+require 'sym/errors'
 require 'base64'
 require 'zlib'
+
 module Sym
   module Data
     class Decoder

data/lib/sym/data/wrapper_struct.rb

@@ -1,4 +1,4 @@
-require_relative '../errors'
+require 'sym/errors'
 module Sym
   module Data
     class WrapperStruct < Struct.new(

data/lib/sym/extensions/stdlib.rb

@@ -21,3 +21,4 @@ class Object
     end
   end
 end
+

data/lib/sym/version.rb

@@ -1,5 +1,5 @@
 module Sym
-  VERSION = '2.3.0'
+  VERSION = '2.4.3'
   DESCRIPTION = <<-eof
     Sym is a command line utility and a Ruby API that makes it trivial to encrypt and decrypt 
     sensitive data. Unlike many other existing encryption tools, sym focuses on usability and 

data/sym.gemspec

@@ -48,4 +48,4 @@ EOF
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'rspec-its'
   spec.add_development_dependency 'yard'
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sym
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.3
 platform: ruby
 authors:
 - Konstantin Gredeskoul
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-25 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colored2
@@ -274,15 +274,16 @@ files:
 - lib/sym/app/private_key/decryptor.rb
 - lib/sym/app/private_key/detector.rb
 - lib/sym/app/private_key/handler.rb
+- lib/sym/app/private_key/key_source_check.rb
 - lib/sym/app/short_name.rb
 - lib/sym/application.rb
 - lib/sym/cipher_handler.rb
 - lib/sym/configuration.rb
+- lib/sym/constants.rb
 - lib/sym/data.rb
 - lib/sym/data/decoder.rb
 - lib/sym/data/encoder.rb
 - lib/sym/data/wrapper_struct.rb
-- lib/sym/encrypted_file.rb
 - lib/sym/errors.rb
 - lib/sym/extensions/class_methods.rb
 - lib/sym/extensions/instance_methods.rb
@@ -315,7 +316,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Super easy to use encryption library & a CLI with a strong aes-256-cbc cipher

data/lib/sym/encrypted_file.rb

@@ -1,34 +0,0 @@
-require 'sym'
-require 'sym/application'
-require 'sym/app/args'
-
-module Sym
-  # This class provides a convenience wrapper for opening and reading
-  # encrypted files as they were regular files, and then possibly writing
-  # changes to them later.
-
-  class EncryptedFile
-
-    include Sym
-
-    attr_reader :application, :file, :key_id, :key_type, :app_args
-
-    def initialize(file:, key_id:, key_type:)
-      @file        = file
-      @key_id      = key_id
-      @key_type    = key_type.to_sym
-      @app_args    = { file: file, key_type => key_id, decrypt: true }
-      @application = Sym::Application.new(self.app_args)
-    end
-
-    def read
-      @content = application.execute! unless @content
-      @content
-    end
-
-    def write
-      Sym::Application.new(file: file, key_type => key_id, encrypt: true, output: file).execute
-    end
-  end
-end
-