sym 0.1.0 → 2.0.0

data/Rakefile

@@ -1,5 +1,13 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = %w(lib/**/*.rb exe/*.rb - README.md MANAGING-KEYS.md LICENSE)
+  t.options.unshift('--title', '"Sym – Symmetric Key Encryption for Your Data"')
+  t.after = ->() { exec('open doc/index.html') }
+end
 
 RSpec::Core::RakeTask.new(:spec)
 

data/bin/sym.bash-completion

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+#
+# Sym command line completion
+#
+# © 2015-2016, Konstantin Gredeskoul,  https://github.com/kigster/sym
+# MIT LICENSE
+#
+
+_sym() {
+    local SYM_OPTS SYM_POINTS cur prev
+
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+    COMPREPLY=()
+
+    SYM_COMP_OPTIONS=$(sym --dictionary)
+    [[ $COMP_CWORD == 1 ]] && SYM_COMP_OPTIONS="${SYM_COMP_OPTIONS} ${SYM_COMMANDS}"
+    COMPREPLY=( $(compgen -W "${SYM_COMP_OPTIONS}" -- ${cur}) )
+    return 0
+}
+
+complete -F _sym sym
+

data/exe/keychain

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH << lib_path if File.exist?(lib_path) && !$LOAD_PATH.include?(lib_path)
+
+require 'sym'
+require 'sym/app'
+require 'sym/app/keychain'
+require 'colored2'
+
+def usage
+  puts 'Usage: ' + 'keychain'.bold.blue + ' item [ add <contents> | find | delete ]'.bold.green
+  exit 0
+end
+
+usage if ARGV.empty?
+
+key_name, action, data = ARGV
+
+unless %i(add find delete).include?(action.to_sym)
+  puts "Error: operation #{action.bold.red} is not recognized"
+  usage
+end
+
+if action.eql?('add') && data.nil?
+  puts "Error: please provide data to store with the #{'add'.bold.green} operation."
+  usage
+end
+
+begin
+puts data ? \
+  Sym::App::KeyChain.new(key_name).send(action.to_sym, data) :
+  Sym::App::KeyChain.new(key_name).send(action.to_sym)
+rescue StandardError => e
+  STDERR.puts "#{e.message.red}"
+end
+
+

data/exe/sym

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH << lib_path if File.exist?(lib_path) && !$LOAD_PATH.include?(lib_path)
+
+require 'sym'
+require 'sym/app'
+
+#ARGV.any?{ |a| a =~ /^-/ } ?
+begin
+ARGV.first =~ /^-/  ?
+  ::Sym::App::CLI.new(ARGV.dup).execute :
+  ::Sym::App::NLP::Translator.new(ARGV.dup).translate.and.execute
+rescue Interrupt => e
+  STDERR.flush
+  STDERR.puts "Interrupt, #{e.message}, exiting."
+  STDERR.flush
+end
+
+

data/lib/sym.rb

@@ -1,5 +1,113 @@
-require "sym/version"
+require 'colored2'
+require 'zlib'
+require 'coin'
+
+require_relative 'sym/configuration'
+
+Sym::Configuration.configure do |config|
+  config.password_cipher = 'AES-128-CBC'
+  config.data_cipher = 'AES-256-CBC'
+  config.private_key_cipher = config.data_cipher
+  config.compression_enabled = true
+  config.compression_level = Zlib::BEST_COMPRESSION
+end
+
+#
+# == Using Sym Library
+#
+# This library is a "wrapper" that allows you to take advantage of the
+# symmetric encryption functionality provided by the {OpenSSL} gem (and the
+# underlying C library). In order to use the library in your ruby classes, you
+# should _include_ the module {Sym}.
+#
+# The including class is decorated with four instance methods from the
+# module {Sym::Extensions::InstanceMethods} and two class methods from
+# {Sym::Extensions::ClassMethods} – for specifics, please refer there.
+#
+# The two main instance methods are +#encr+ and +#decr+, which as the name
+# implies, perform two-way symmetric encryption and decryption of any Ruby object
+# that can be +marshaled+.
+#
+# Two additional instance methods +#encr_password+ and +#decr_password+ turn on
+# password-based encryption, which actually uses a password to construct a 128-bit
+# long private key, and then uses that in the encryption of the data.
+# You could use them to encrypt data with a password instead of a randomly
+# generated private key.
+#
+# The library comes with a rich CLI interface, which is mostly encapsulated under the
+# +Sym::App+ namespace.
+#
+# The +sym+ executable that is the "app" in this case, and is a _user_ of the
+# API methods +#encr+ and +#decr+.
+#
+# Create a new key with +#create_private_key+ class method, which returns a new
+# key every time it's called, or with +#private_key+ class method, which either
+# assigns, or creates and caches the private key at a class level.
+#
+# == Example
+#
+#     require 'sym'
+#
+#     class TestClass
+#       include Sym
+#       # read the key from environmant variable and assign to this class.
+#       private_key ENV['PRIVATE_KEY']
+#
+#       def sensitive_value=(value)
+#         @sensitive_value = encr(value, self.class.private_key)
+#       end
+#
+#       def sensitive_value
+#         decr(@sensitive_value, self.class.private_key)
+#       end
+#     end
+#
+# == Private Key
+#
+# They private key can be generated by +TestClass.create_private_key+
+# which returns but does not store a new random 256-bit key.
+#
+# The key can be assigned and saved, or auto-generated and saved using the
+# +#private_key+ method on the class that includes the +Sym+ module.
+#
+# Each class including the +Sym+ module would get their own +#private_key#
+# class-instance variable accessor, and a possible value.
+#
+# For example:
+#
+#
+
+module Kernel
+  def require_dir(___dir)
+    @___dir ||= File.dirname(__FILE__)
+    # require files using a consistent order based on the dir/file name.
+    # this should be OS-neutral
+    Dir["#{@___dir}/#{___dir}/*.rb"].sort.each do |___file|
+      require(___file)
+    end
+  end
+end
+
+require_dir 'sym/extensions'
 
 module Sym
-  # Your code goes here...
+  def self.included(klass)
+    klass.instance_eval do
+      include ::Sym::Extensions::InstanceMethods
+      extend ::Sym::Extensions::ClassMethods
+      class << self
+        def private_key(value = nil)
+          if value
+            @private_key= value
+          elsif @private_key
+            @private_key
+          else
+            @private_key= self.create_private_key
+          end
+          @private_key
+        end
+      end
+    end
+  end
 end
+

data/lib/sym/app.rb

@@ -0,0 +1,56 @@
+require 'sym'
+require 'active_support/inflector'
+
+module Sym
+
+  # The {Sym::App} Module is responsible for handing user input and executing commands.
+  # Central class in this module is the {Sym::App::CLI} class. However, it is
+  # recommended that ruby integration with the {Sym::App} module functionality
+  # is done via the {Sym::Application} class.
+  #
+  # Methods in this module are responsible for reporting errors and
+  # maintaining the future exit code class-global variable.
+  #
+  # It also contains several helpers that enable some additional functionality
+  # on Mac OS-X (such as using KeyChain for storing encryption keys).
+  #
+  module App
+    class << self
+      attr_accessor :exit_code
+    end
+
+    self.exit_code = 0
+
+    def self.out
+      STDERR
+    end
+
+    def self.error(
+      config: {},
+      exception: nil,
+      type: nil,
+      details: nil,
+      reason: nil,
+      comments: nil)
+
+      self.out.puts([\
+                    "#{(type || exception.class.name).titleize}:".red.bold.underlined +
+                    (sprintf '  %s', details || exception.message).red.italic,
+                    (reason ? "\n#{reason.blue.bold.italic}" : nil),
+                    (comments ? "\n\n#{comments}" : nil)].compact.join("\n"))
+      self.out.puts "\n" + exception.backtrace.join("\n").bold.red if exception && config && config[:trace]
+      self.exit_code = 1
+    end
+
+    def self.is_osx?
+      Gem::Platform.local.os.eql?('darwin')
+    end
+    def self.this_os
+      Gem::Platform.local.os
+    end
+  end
+end
+
+require 'sym/app/short_name'
+require 'sym/version'
+require_dir 'sym/app'

data/lib/sym/app/args.rb

@@ -0,0 +1,42 @@
+module Sym
+  module App
+
+    class Args
+
+      OPTIONS_REQUIRE_KEY    = %i(encrypt decrypt edit)
+      OPTIONS_KEY_CREATED    = %i(generate)
+      OPTIONS_SPECIFY_KEY    = %i(private_key interactive keyfile keychain)
+      OPTIONS_SPECIFY_OUTPUT = %i(output quiet)
+
+      attr_accessor :opts, :selected_options
+
+      def initialize(opts)
+        self.opts             = opts
+        self.selected_options = opts.keys.reject { |k| !opts[k] }
+      end
+
+      def specify_key?
+        do?(OPTIONS_SPECIFY_KEY)
+      end
+
+      def require_key?
+        do?(OPTIONS_REQUIRE_KEY)
+      end
+
+      def generate_key?
+        do?(OPTIONS_KEY_CREATED)
+      end
+
+      def output_class
+        output_type = OPTIONS_SPECIFY_OUTPUT.find { |o| opts[o] } # includes nil
+        Sym::App::Output.outputs[output_type]
+      end
+
+      private
+      def do?(list)
+        !(list & selected_options).empty?
+      end
+
+    end
+  end
+end

data/lib/sym/app/cli.rb

@@ -0,0 +1,192 @@
+require 'slop'
+require 'sym'
+require 'colored2'
+require 'yaml'
+require 'forwardable'
+require 'openssl'
+require 'sym/application'
+require 'sym/errors'
+require 'sym/app/commands'
+require 'sym/app/keychain'
+require 'sym/app/private_key/handler'
+require 'sym/app/nlp/constants'
+require 'highline'
+
+require_relative 'output/file'
+require_relative 'output/file'
+require_relative 'output/stdout'
+
+module Sym
+  module App
+    # This is the main interface class for the CLI application.
+    # It is responsible for parsing user's input, providing help, examples,
+    # coordination of various sub-systems (such as PrivateKey detection), etc.
+    #
+    # Besides holding the majority of the application state, it contains
+    # two primary public methods: +#new+ and +#run+.
+    #
+    # The constructor is responsible for parsing the flags and determining
+    # the the application is about to do. It sets up input/output, but doesn't
+    # really execute any encryption or decryption. This happens in the +#run+
+    # method called immediately after +#new+.
+    #
+    # {{Shh::App::CLI}} module effectively performs the translation of
+    # the +opts+ object (of type {Slop::Result}) and interpretation of
+    # users intentions. It holds on to +opts+ for the duration of the program.
+    #
+    # == Responsibility Delegated
+    #
+    # The responsibility of determining the private key from various
+    # options provided is performed by the {Sym::App::PrivateKey::Handler}
+    # instance. See there for more details.
+    #
+    # Subsequently, +#run+ method handles the finding of the appropriate
+    # {Sym::App::Commands::Command} subclass to respond to user's request.
+    # Command registry, sorting, command dependencies, and finding them is
+    # done by the {Sym::App::Coommands} module.
+    #
+    # User input is handled by the {Sym::App::Input::Handler} instance, while
+    # the output is provided by the procs in the {Sym::App::Output} classes.
+    #
+    # Finally, the Mac OS-X -specific usage of the KeyChain, is encapsulated
+    # in a cross-platform way inside the {Sym::App::Keychain} module.
+
+    class CLI
+
+      extend Forwardable
+
+      def_delegators :@application, :command
+
+      attr_accessor :opts, :application, :outputs, :output_proc
+
+      def initialize(argv)
+        begin
+          argv_copy = argv.dup
+          dict      = false
+          if argv_copy.include?('--dictionary')
+            dict = true
+            argv_copy.delete('--dictionary')
+          end
+          self.opts = parse(argv_copy)
+          if dict
+            options = opts.parser.unused_options + opts.parser.used_options
+            puts options.map { |o| o.to_s.gsub(/.*(--[\w-]+).*/, '\1') }.sort.join(' ')
+            exit 0
+          end
+        rescue StandardError => e
+          error exception: e
+          return
+        end
+
+        configure_color(argv)
+
+        self.application = ::Sym::Application.new(opts)
+        select_output_stream
+      end
+
+      def execute
+        return Sym::App.exit_code if Sym::App.exit_code != 0
+
+        result = application.execute
+        if result.is_a?(Hash)
+          self.output_proc = ::Sym::App::Args.new({}).output_class
+          error(result)
+        else
+          self.output_proc.call(result)
+        end
+      end
+
+      private
+
+      def error(hash)
+        Sym::App.error(hash.merge(config: (opts ? opts.to_hash : {})))
+      end
+
+      def select_output_stream
+        output_klass = application.args.output_class
+
+        unless output_klass && output_klass.is_a?(Class)
+          raise "Can not determine output class from arguments #{opts.to_hash}"
+        end
+
+        self.output_proc = output_klass.new(self).output_proc
+      end
+
+      def configure_color(argv)
+        if opts[:no_color]
+          Colored2.disable! # reparse options without the colors to create new help msg
+          self.opts = parse(argv.dup)
+        end
+      end
+
+      def parse(arguments)
+        Slop.parse(arguments) do |o|
+          o.banner = "Sym (#{Sym::VERSION}) – encrypt/decrypt data with a private key\n".bold.white
+          o.separator 'Usage:'.yellow
+          o.separator '   # Generate a new key:'.dark
+          o.separator '   sym -g '.green.bold + '[ -c ] [ -p ] [ -x keychain ] [ -o keyfile | -q | ]  '.green
+          o.separator ''
+          o.separator '   # Encrypt/Decrypt '.dark
+          o.separator '   sym [ -d | -e ] '.green.bold + '[ -f <file> | -s <string> ] '.green
+          o.separator '        [ -k key | -K keyfile | -x keychain | -i ] '.green
+          o.separator '        [ -o <output file> ] '.green
+          o.separator ' '
+          o.separator '   # Edit an encrypted file in $EDITOR '.dark
+          o.separator '   sym -t -f <file> [ -b ]'.green.bold + '[ -k key | -K keyfile | -x keychain | -i ] '.green
+
+          o.separator ' '
+          o.separator 'Modes:'.yellow
+
+          o.bool '-e', '--encrypt', '           encrypt mode'
+          o.bool '-d', '--decrypt', '           decrypt mode'
+          o.bool '-t', '--edit',    '           decrypt, open an encr. file in an $EDITOR'
+
+          o.separator ' '
+          o.separator 'Create a private key:'.yellow
+
+          o.bool '-g', '--generate', '           generate a new private key'
+          o.bool '-p', '--password', '           encrypt the key with a password'
+          o.bool '-c', '--copy',     '           copy the new key to the clipboard'
+
+          if Sym::App.is_osx?
+            o.string '-x', '--keychain', '[key-name] '.blue + 'add to (or read from) the OS-X Keychain'
+          end
+
+          o.separator ' '
+          o.separator 'Password Caching:'.yellow
+
+          o.integer '-M', '--password-timeout', '[timeout]'.blue + '  when passwords expire (in seconds)'
+          o.bool '-P', '--no-password-cache', '           disables key password caching'
+
+          o.separator ' '
+          o.separator 'Provide a private key:'.yellow
+          o.bool '-i', '--interactive', '           Paste or type the key interactively'
+          o.string '-k', '--private-key', '[key]   '.blue + '   private key as a string'
+          o.string '-K', '--keyfile', '[key-file]'.blue + ' private key from a file'
+          o.separator ' '
+          o.separator 'Data:'.yellow
+          o.string '-s', '--string', '[string]'.blue + '   specify a string to encrypt/decrypt'
+          o.string '-f', '--file', '[file]  '.blue + '   filename to read from'
+          o.string '-o', '--output', '[file]  '.blue + '   filename to write to'
+          o.separator ' '
+          o.separator 'Flags:'.yellow
+          if Sym::App.is_osx?
+            o.string '--keychain-del', '[key-name] '.blue + 'delete keychain entry with that name'
+          end
+          o.bool '-b', '--backup', '           create a backup file in the edit mode'
+          o.bool '-v', '--verbose', '           show additional information'
+          o.bool '-T', '--trace', '           print a backtrace of any errors'
+          o.bool '-q', '--quiet', '           silence all output'
+          o.bool '-V', '--version', '           print library version'
+          o.bool '-N', '--no-color', '           disable color output'
+          o.separator ' '
+          o.separator 'Help & Examples:'.yellow
+          o.bool '-E', '--examples', '           show several examples'
+          o.bool '-L', '--language', '           natural language examples'
+          o.bool '-h', '--help', '           show help'
+
+        end
+      end
+    end
+  end
+end