sym 0.1.0 → 2.0.0

data/lib/sym/app/commands/show_version.rb

@@ -0,0 +1,14 @@
+require_relative 'command'
+module Sym
+  module App
+    module Commands
+      class ShowVersion < Command
+        required_options :version
+        try_after :show_help
+        def execute
+          "sym (version #{Sym::VERSION})"
+        end
+      end
+    end
+  end
+end

data/lib/sym/app/input/handler.rb

@@ -0,0 +1,41 @@
+require 'sym/errors'
+
+module Sym
+  module App
+    module Input
+      class Handler
+
+        def ask
+          retries ||= 0
+          prompt('Password: ', :green)
+        rescue ::OpenSSL::Cipher::CipherError
+          STDERR.puts 'Invalid password. Please try again.'
+          retry if (retries += 1) < 3
+          nil
+        end
+
+        def puts(*args)
+          STDERR.puts args
+        end
+
+        def prompt(message, color)
+          HighLine.new(STDIN, STDERR).ask(message.bold) { |q| q.echo = '•'.send(color) }
+        end
+
+        def new_password
+          password = prompt('New Password     :  ', :blue)
+
+          raise Sym::Errors::PasswordTooShort.new(
+            'Minimum length is 7 characters.') if password.length < 7
+
+          password_confirm = prompt('Confirm Password :  ', :blue)
+
+          raise Sym::Errors::PasswordsDontMatch.new(
+            'The passwords you entered do not match.') if password != password_confirm
+
+          password
+        end
+      end
+    end
+  end
+end

data/lib/sym/app/keychain.rb

@@ -0,0 +1,135 @@
+require 'sym'
+require 'sym/app'
+require 'sym/errors'
+
+
+module Sym
+  module App
+    #
+    # This class forms and shells several commands that wrap Mac OS-X +security+ command.
+    # They provide access to storing generic passwords in the KeyChain Access.
+    #
+    class KeyChain
+      class << self
+        attr_accessor :user, :kind, :sub_section
+
+        def configure
+          yield self
+        end
+
+        def validate!
+          raise ArgumentError.new(
+            'User is not defined. Either set $USER in environment, or directly on the class.') unless self.user
+        end
+      end
+
+      configure do
+        self.kind        = 'sym'
+        self.user        = ENV['USER']
+        self.sub_section = 'generic-password'
+      end
+
+      attr_accessor :key_name, :opts, :stderr_disabled
+
+      def initialize(key_name, opts = {})
+        self.key_name = key_name
+        self.opts     = opts
+        self.class.validate!
+      end
+
+      def add(password)
+        execute command(:add, "-U -w '#{password}' ")
+      end
+
+      def find
+        execute command(:find, ' -g -w ')
+      end
+
+      def delete
+        execute command(:delete)
+      end
+
+      def execute(command)
+        command += ' 2>/dev/null' if stderr_disabled
+        puts "> #{command.yellow.green}" if opts[:verbose]
+        output = `#{command}`
+        result = $?
+        raise Sym::Errors::KeyChainCommandError.new("Command error: #{result}, command: #{command}") unless result.success?
+        output.chomp
+      rescue Errno::ENOENT => e
+        raise Sym::Errors::KeyChainCommandError.new("Command error: #{e.message}, command: #{command}")
+      end
+
+      def stderr_off
+        self.stderr_disabled = true
+      end
+
+      def stderr_on
+        self.stderr_disabled = false
+      end
+
+      private
+
+      def command(action, extras = nil)
+        out = base_command(action)
+        out << extras if extras
+        out = out.join
+        # Do not actually ever run these commands on non MacOSX
+        out = "echo Run this –\"#{out}\", on #{Sym::App.this_os}?\nAre you sure?" unless Sym::App.is_osx?
+        out
+      end
+
+      def base_command(action)
+        [
+          "security #{action}-#{self.class.sub_section} ",
+          "-a '#{self.class.user}' ",
+          "-D '#{self.class.kind}' ",
+          "-s '#{self.key_name}' "
+        ]
+      end
+    end
+  end
+end
+
+
+#
+# Usage: add-generic-password [-a account] [-s service] [-w password] [options...] [-A|-T appPath] [keychain]
+#     -a  Specify account name (required)
+#     -c  Specify item creator (optional four-character code)
+#     -C  Specify item type (optional four-character code)
+#     -D  Specify kind (default is "application password")
+#     -G  Specify generic attribute (optional)
+#     -j  Specify comment string (optional)
+#     -l  Specify label (if omitted, service name is used as default label)
+#     -s  Specify service name (required)
+#     -p  Specify password to be added (legacy option, equivalent to -w)
+#     -w  Specify password to be added
+#     -A  Allow any application to access this item without warning (insecure, not recommended!)
+#     -T  Specify an application which may access this item (multiple -T options are allowed)
+#     -U  Update item if it already exists (if omitted, the item cannot already exist)
+#
+# Usage: find-generic-password [-a account] [-s service] [options...] [-g] [keychain...]
+#     -a  Match "account" string
+#     -c  Match "creator" (four-character code)
+#     -C  Match "type" (four-character code)
+#     -D  Match "kind" string
+#     -G  Match "value" string (generic attribute)
+#     -j  Match "comment" string
+#     -l  Match "label" string
+#     -s  Match "service" string
+#     -g  Display the password for the item found
+#     -w  Display only the password on stdout
+# If no keychains are specified to search, the default search list is used.
+#         Find a generic password item.
+#
+# Usage: delete-generic-password [-a account] [-s service] [options...] [keychain...]
+#     -a  Match "account" string
+#     -c  Match "creator" (four-character code)
+#     -C  Match "type" (four-character code)
+#     -D  Match "kind" string
+#     -G  Match "value" string (generic attribute)
+#     -j  Match "comment" string
+#     -l  Match "label" string
+#     -s  Match "service" string
+# If no keychains are specified to search, the default search list is used.
+#         Delete a generic password item.

data/lib/sym/app/nlp.rb

@@ -0,0 +1,18 @@
+require_relative 'cli'
+require_relative 'nlp/constants'
+require_relative 'nlp/usage'
+require_relative 'nlp/translator'
+module Sym
+  module App
+    #     sym generate key to the clipboard and keychain
+    #     sym encrypt file 'hello' using $key [to output.enc]
+    #     sym edit 'passwords.enc' using $key
+    #     sym decrypt /etc/secrets encrypted with $key save to ./secrets
+    #     sym encrypt file $input with keychain $item
+    module NLP
+      class Base
+        extend Usage
+      end
+    end
+  end
+end

data/lib/sym/app/nlp/constants.rb

@@ -0,0 +1,32 @@
+module Sym
+  module App
+    module NLP
+      module Constants
+        STRIPPED = %i(and a the it item to key with about for of new make store in print)
+
+        DICTIONARY = {
+          # option (Slop)
+          #               list of english words that map to it
+          :copy        => [:clipboard],
+          :decrypt     => [:unlock],
+          :edit        => [:open],
+          :encrypt     => [:lock],
+          :backup      => [],
+          :keychain    => [],
+          :file        => [:read],
+          :generate    => [:create],
+          :interactive => [:ask, :enter, :type],
+          :keyfile     => [:from],
+          :output      => [:save, :write],
+          :private_key => [:using, :private],
+          :string      => [:value],
+          :quiet       => [:silently, :quietly, :silent, :sym],
+          :password    => [:secure, :secured, :protected]
+        }
+
+      end
+
+    end
+  end
+end
+

data/lib/sym/app/nlp/translator.rb

@@ -0,0 +1,61 @@
+require_relative 'constants'
+module Sym
+  module App
+    module NLP
+      class Translator
+
+        attr_accessor :argv, :translated_argv, :opts
+
+        def initialize(argv)
+          self.argv            = argv
+          self.opts            = CLI.new(%w(-E)).opts.to_hash
+          self.translated_argv = []
+        end
+
+        def dict
+          ::Sym::App::NLP::Constants::DICTIONARY
+        end
+
+        def stripped
+          ::Sym::App::NLP::Constants::STRIPPED
+        end
+
+        def translate
+          self.translated_argv = argv.map do |value|
+            nlp_argument = value.to_sym
+            arg = nil
+            arg ||= dict.keys.find do |key|
+              dict[key].include?(nlp_argument) || key == nlp_argument
+            end
+            arg ||= nlp_argument
+
+            if stripped.include?(arg)
+              # nada
+            elsif opts.to_hash.key?(arg)
+              '--' + "#{arg.to_s.gsub(/_/, '-')}"
+            else
+              arg.to_s
+            end
+          end.compact
+
+          counts = {}
+          translated_argv.each{ |arg| counts.key?(arg) ? counts[arg] += 1 : counts[arg] = 1 }
+          translated_argv.delete_if{ |arg| counts[arg] > 1 }
+          self
+        end
+
+        def and
+          translate if translated_argv.empty?
+          if self.translated_argv.include?('--verbose')
+            STDERR.puts 'Original arguments: '.dark + "#{argv.join(' ').green}"
+            STDERR.puts '   Translated argv: '.dark + "#{translated_argv.join(' ').blue}"
+          end
+          ::Sym::App::CLI.new(self.translated_argv)
+        end
+
+        alias_method :application, :and
+
+      end
+    end
+  end
+end

data/lib/sym/app/nlp/usage.rb

@@ -0,0 +1,72 @@
+require 'pp'
+module Sym
+  module App
+    #     sym generate key to the clipboard and keychain
+    #     sym encrypt file 'hello' using $key [to output.enc]
+    #     sym edit 'passwords.enc' using $key
+    #     sym decrypt /etc/secrets encrypted with $key save to ./secrets
+    #     sym encrypt file $input with keychain $item
+    module NLP
+      module Usage
+
+        def usage
+          out = ''
+          out << %Q`
+#{header('Natural Language Processing')}
+
+#{'When '.dark.normal}#{'sym'.bold.blue} #{'is invoked, and the first argument does not begin with a dash,
+then the the NLP (natural language processing) Translator is invoked.
+The Translator is based on a very simple algorithm:
+
+ * ignore any of the words tagged STRIPPED. These are the ambiguous words,
+   or words with duplicate meaning.
+
+ * map the remaining arguments to regular double-dashed options using the DICTIONARY
+
+ * words that are a direct match for a --option are automatically double-dashed
+
+ * remaining words are left as is (these would be file names, key names, etc).
+
+ * finally, the resulting "new" command line is parsed with regular options.
+
+ * When arguments include "verbose", NLP system will print "before" and "after"
+   of the arguments, so that any issues can be debugged and corrected.
+
+'.dark.normal}
+
+#{header('Currently ignored words:')}
+    #{Constants::STRIPPED.join(', ').red.italic}
+
+#{header('Regular Word Mapping')}
+#{Constants::DICTIONARY.pretty_inspect.split(/\n/).map do |line|
+            line.gsub(
+              /[\:\}\,\[\]]/, ''
+            ).gsub(
+              /[ {](\w+)=>([^\n]*)/, '\2|\1'
+            )
+          end.map { |line| convert_dictionary(*line.split('|')) }.join}
+
+#{header('Examples')}
+`
+          out
+        end
+
+        def convert_dictionary(left = '', right = '')
+          [
+            sprintf('%35.35s', left.gsub(/ /, ' ')).italic.yellow,
+            '   ───────➤   '.dark,
+            sprintf('--%-20.20s', right).blue,
+
+            "\n"
+          ].join
+        end
+
+        private
+        def header(title)
+          title.upcase.bold.underlined
+        end
+
+      end
+    end
+  end
+end

data/lib/sym/app/output.rb

@@ -0,0 +1,15 @@
+require 'sym/app/output/base'
+require 'sym/app/output/file'
+require 'sym/app/output/stdout'
+require 'sym/app/output/noop'
+
+module Sym
+  module App
+    module Output
+      def self.outputs
+        Sym::App::Output::Base.options_to_outputs
+      end
+    end
+  end
+end
+

data/lib/sym/app/output/base.rb

@@ -0,0 +1,61 @@
+require 'sym/app/short_name'
+module Sym
+  module App
+    module Output
+      class Base
+
+        attr_accessor :cli
+
+        def initialize(cli)
+          self.cli = cli
+        end
+
+        def opts
+          cli.opts
+        end
+
+        @outputs = []
+        class << self
+          attr_accessor :outputs
+
+          def append(output_klass)
+            outputs << output_klass if outputs.is_a?(Array)
+            raise "Cannot append #{output_class} after #outputs has been converted to a Hash" \
+              unless outputs.is_a?(Array)
+          end
+
+          def map_outputs!
+            klasses      = self.outputs
+            self.outputs = Hash.new
+            klasses.each { |k| self.outputs[k.required_option] = k }
+            outputs
+          end
+
+          def options_to_outputs
+            map_outputs! if outputs.is_a?(Array)
+            outputs
+          end
+        end
+
+        def self.inherited(klass)
+          klass.instance_eval do
+            class << self
+              attr_writer :required_option
+            end
+
+            klass.required_option = nil
+
+            class << self
+              def required_option(_option = nil)
+                self.required_option = _option if _option
+                @required_option
+              end
+            end
+          end
+          klass.extend(Sym::App::ShortName)
+          Sym::App::Output::Base.append klass
+        end
+      end
+    end
+  end
+end