sym 0.1.0 → 2.0.0

data/lib/sym/app/commands.rb

@@ -0,0 +1,56 @@
+require 'active_support/inflector'
+require 'tsort'
+require 'pp'
+module Sym
+  module App
+    module Commands
+
+      class DependencyResolver < Hash
+        include TSort
+        alias tsort_each_node each_key
+
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
+        end
+      end
+
+      @dependency = DependencyResolver.new
+      @commands = Set.new
+
+      class << self
+        attr_accessor :commands, :dependency
+
+        def register(command_class)
+          self.commands << command_class
+          self.dependency[command_class.short_name] ||= []
+        end
+
+        def order(command_class, after)
+          self.dependency[command_class.short_name].unshift(after) if after
+          self.dependency[command_class.short_name].flatten!
+        end
+
+        def dependencies
+          @dependencies ||= self.dependency.tsort
+          @dependencies
+        end
+
+        # Sort commands based on the #dependencies array, which itself is sorted
+        # based on command dependencies.
+        def sorted_commands
+          @sorted_commands ||= self.commands.to_a.sort_by{|klass| dependencies.index(klass.short_name) }
+          @sorted_commands
+        end
+
+        def find_command_class(opts)
+          self.sorted_commands.each do |command_class|
+            return command_class if command_class.options_satisfied_by?(opts)
+          end
+          nil
+        end
+      end
+    end
+  end
+end
+
+require_dir 'sym/app/commands'

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

@@ -0,0 +1,77 @@
+require 'sym'
+require 'sym/app'
+
+require 'active_support/inflector'
+
+module Sym
+  module App
+    module Commands
+      class Command
+
+        def self.inherited(klass)
+          klass.instance_eval do
+            class << self
+              attr_accessor :required, :incompatible
+
+              include Sym::App::ShortName
+
+              def try_after(*dependencies)
+                Sym::App::Commands.order(self, dependencies)
+              end
+
+              def required_options(*args)
+                self.required ||= Set.new
+                required.merge(args) if args
+                required
+              end
+
+              def incompatible_options(*args)
+                self.incompatible ||= Set.new
+                incompatible.merge(args) if args
+                incompatible
+              end
+
+              def options_satisfied_by?(opts_hash)
+                proc = required_options.find { |option| option.is_a?(Proc) }
+                return true if proc && proc.call(opts_hash)
+                return false if incompatible_options.any? { |option| opts_hash[option] }
+                required_options.to_a.delete_if { |o| o.is_a?(Proc) }.all? { |o|
+                  o.is_a?(Array) ? o.any? { |opt| opts_hash[opt] } : opts_hash[o]
+                }
+              end
+            end
+
+            # Register this command with the global list.
+            Sym::App::Commands.register klass
+          end
+        end
+
+        attr_accessor :application
+
+        def initialize(application)
+          self.application = application
+        end
+
+        def opts
+          application.opts
+        end
+        def opts_hash
+          application.opts_hash
+        end
+
+        def key
+          @key ||= application.key
+        end
+
+        def execute
+          raise Sym::Errors::AbstractMethodCalled.new(:run)
+        end
+
+        def to_s
+          "#{self.class.short_name.to_s.bold.yellow}, with options: #{application.args.argv.join(' ').gsub(/--/, '').bold.green}"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative 'command'
+require 'sym/app/keychain'
+module Sym
+  module App
+    module Commands
+      class DeleteKeychainItem < Command
+
+        required_options :keychain_del
+        try_after :generate_key, :open_editor, :encrypt_decrypt
+
+        def execute
+          Sym::App::KeyChain.new(opts[:keychain_del]).delete
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative 'command'
+module Sym
+  module App
+    module Commands
+      class EncryptDecrypt < Command
+        include Sym
+
+        required_options [ :private_key, :keyfile, :keychain, :interactive ],
+                         [ :encrypt, :decrypt ],
+                         [ :file, :string ]
+
+        try_after :generate_key
+
+        def execute
+          send(application.action, content, application.key)
+        end
+
+        private
+
+        def content
+          @content ||= (opts[:string] || (opts[:file].eql?('-') ? STDIN.read : File.read(opts[:file])))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require_relative 'command'
+require 'sym/app/keychain'
+module Sym
+  module App
+    module Commands
+      class GenerateKey < Command
+        include Sym
+
+        required_options :generate
+
+        def execute
+          retries         ||= 0
+          new_private_key = self.class.create_private_key
+          new_private_key = encr_password(new_private_key,
+                                          application.input_handler.new_password) if opts[:password]
+
+          clipboard_copy(new_private_key) if opts[:copy]
+
+          Sym::App::KeyChain.new(opts[:keychain], opts).
+            add(new_private_key) if opts[:keychain] && Sym::App.is_osx?
+
+          new_private_key
+        rescue Sym::Errors::PasswordsDontMatch, Sym::Errors::PasswordTooShort => e
+          STDERR.puts e.message.bold
+          retry if (retries += 1) < 3
+        end
+
+        private
+
+        def clipboard_copy(key)
+          require 'clipboard'
+          Clipboard.copy(key)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'digest'
+require 'fileutils'
+require 'tempfile'
+require 'sym'
+require 'sym/errors'
+require_relative 'command'
+module Sym
+  module App
+    module Commands
+      class OpenEditor < Command
+        include Sym
+
+        required_options [ :private_key, :keyfile, :keychain, :interactive ],
+                           :edit,
+                           :file
+
+        try_after :generate_key, :encrypt_decrypt
+
+        attr_accessor :tempfile
+
+        def execute
+          begin
+            self.tempfile = ::Tempfile.new(::Base64.urlsafe_encode64(opts[:file]))
+            decrypt_content(self.tempfile)
+
+            result = process launch_editor
+          ensure
+            self.tempfile.close if tempfile
+            self.tempfile.unlink rescue nil
+          end
+          result
+        end
+
+        def launch_editor
+          system("#{application.editor} #{tempfile.path}")
+        end
+
+        private
+
+        def decrypt_content(file)
+          file.open
+          file.write(content)
+          file.flush
+        end
+
+        def content
+          @content ||= decr(File.read(opts[:file]), key)
+        end
+
+        def timestamp
+          @timestamp ||= Time.now.to_a.select { |d| d.is_a?(Fixnum) }.map { |d| '%02d' % d }[0..-3].reverse.join
+        end
+
+        def process(code)
+          if code == true
+            content_edited = File.read(tempfile.path)
+            md5            = ::Base64.encode64(Digest::MD5.new.digest(content))
+            md5_edited     = ::Base64.encode64(Digest::MD5.new.digest(content_edited))
+            return 'No changes have been made.' if md5 == md5_edited
+
+            FileUtils.cp opts[:file], "#{opts[:file]}.#{timestamp}" if opts[:backup]
+
+            diff = compute_diff
+
+            File.open(opts[:file], 'w') { |f| f.write(encr(content_edited, key)) }
+
+            out = ''
+            if opts[:verbose]
+              out << "Saved encrypted/compressed content to #{opts[:file].bold.blue}" +
+                      " (#{File.size(opts[:file]) / 1024}Kb), unencrypted size #{content.length / 1024}Kb."
+              out << (opts[:backup] ? ",\nbacked up the last version to #{backup_file.bold.blue}." : '.')
+            end
+            out << "\n\nDiff:\n#{diff}"
+            out
+          else
+            raise Sym::Errors::EditorExitedAbnormally.new("#{application.editor} exited with #{$<}")
+          end
+        end
+
+        # Computes the diff between two unencrypted versions
+        def compute_diff
+          original_content_file = Tempfile.new(rand(1024).to_s)
+          original_content_file.open
+          original_content_file.write(content)
+          original_content_file.flush
+          diff = `diff #{original_content_file.path} #{tempfile.path}`
+          diff.gsub!(/> (.*\n)/m, '\1'.green)
+          diff.gsub!(/< (.*\n)/m, '\1'.red)
+        ensure
+          original_content_file.close
+          original_content_file.unlink
+          diff
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require_relative 'command'
+require 'sym/app/keychain'
+module Sym
+  module App
+    module Commands
+      class PrintKey < Command
+        required_options [ :keychain, :keyfile ]
+
+        def execute
+          self.key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'colored2'
+require_relative 'command'
+module Sym
+  module App
+    module Commands
+      class ShowExamples < Command
+        required_options :examples
+        try_after :show_help
+
+        def execute
+          output = []
+
+          output << example(comment: 'generate a new private key into an environment variable:',
+                            command: 'export KEY=$(sym -g)',
+                            echo:    'echo $KEY',
+                            result:  '75ngenJpB6zL47/8Wo7Ne6JN1pnOsqNEcIqblItpfg4='.green)
+
+          output << example(comment: 'generate a new password-protected key, copy to the clipboard & save to a file',
+                            command: 'sym -gpc -o ~/.key',
+                            echo:    'New Password     : ' + '••••••••••'.green,
+                            result:  'Confirm Password : ' + '••••••••••'.green)
+
+          output << example(comment: 'encrypt a plain text string with a key, and save the output to a file',
+                            command: 'sym -e -s ' + '"secret string"'.bold.yellow + ' -k $KEY -o file.enc',
+                            echo:    'cat file.enc',
+                            result:  'Y09MNDUyczU1S0UvelgrLzV0RTYxZz09CkBDMEw4Q0R0TmpnTm9md1QwNUNy%T013PT0K'.green)
+
+          output << example(comment: 'decrypt a previously encrypted string:',
+                            command: 'sym -d -s $(cat file.enc) -k $KEY',
+                            result:  'secret string'.green)
+
+          output << example(comment: 'encrypt sym.yml and save it to sym.enc:',
+                            command: 'sym -e -f sym.yml -o sym.enc -k $KEY')
+
+          output << example(comment: 'decrypt an encrypted file and print it to STDOUT:',
+                            command: 'sym -df sym.enc -k $KEY')
+
+          output << example(comment: 'edit an encrypted file in $EDITOR, ask for key, create a backup',
+                            command: 'sym -tibf ecrets.enc',
+                            result:  '
+Private Key: ••••••••••••••••••••••••••••••••••••••••••••
+Saved encrypted content to sym.enc.
+
+Diff:
+3c3
+'.white.dark + '# (c) 2015 Konstantin Gredeskoul.  All rights reserved.'.red.bold  + '
+---' + '
+# (c) 2016 Konstantin Gredeskoul.  All rights reserved.'.green.bold)
+
+
+          if Sym::App.is_osx?
+          output << example(comment: 'generate a new password-encrypted key, save it to your Keychain:',
+                            command: 'sym -gpx mykey -o ~/.key')
+
+          output << example(comment: 'use the new key to encrypt a file:',
+                            command: 'sym -x mykey -e -f password.txt -o passwords.enc')
+
+          output << example(comment: 'use the new key to inline-edit the encrypted file:',
+                            command: 'sym -x mykey -t -f sym.yml')
+          end
+
+          output.flatten.compact.join("\n")
+        end
+
+        def example(comment: nil, command: nil, echo: nil, result: nil)
+          out = []
+          out << "# #{comment}".white.dark.italic if comment
+          out << "#{command}" if command
+          out << "#{echo}" if echo
+          out << "#{result}" if result
+          out << '—'*80
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require_relative 'command'
+module Sym
+  module App
+    module Commands
+      class ShowHelp < Command
+
+        required_options :help, ->(opts) { opts.to_hash.keys.all? { |k| !opts[k] } }
+        try_after :generate_key, :open_editor, :encrypt_decrypt
+
+        def execute
+          opts.to_s(prefix: ' ' * 2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'colored2'
+require_relative 'command'
+require_relative '../nlp'
+module Sym
+  module App
+    module Commands
+      class ShowLanguageExamples < Command
+        required_options :language
+        try_after :show_help
+
+
+
+        def execute
+          output = []
+
+          output << Sym::App::NLP::Base.usage
+
+          output << example(comment: 'generate a new private key and copy to the clipboard but do not print to terminal',
+                            command: 'sym create new key to clipboard quietly'
+          )
+
+          output << example(comment: 'generate and save to a file a password-protected key, silently',
+                            command: 'sym create a secure key and save it to "my.key"',
+          )
+
+          output << example(comment: 'encrypt a plain text string with a key, and save the output to a file',
+                            command: 'sym encrypt string "secret string" using $(cat my.key) save to file.enc')
+
+          output << example(comment: 'decrypt a previously encrypted string:',
+                            command: 'sym decrypt string $ENC using $(cat my.key)')
+
+          output << example(comment: 'encrypt "file.txt" with key from my.key and save it to file.enc',
+                            command: 'sym encrypt file file.txt with key from my.key and save it to file.enc')
+
+          output << example(comment: 'decrypt an encrypted file and print it to STDOUT:',
+                            command: 'sym decrypt file file.enc with key from "my.key"')
+
+          output << example(comment: 'edit an encrypted file in $EDITOR, ask for key, and create a backup upon save',
+                            command: 'sym edit file file.enc ask for a key and make a backup',
+          )
+
+          if Sym::App.is_osx?
+            output << example(comment: 'generate a new password-encrypted key, save it to your Keychain:',
+                              command: 'sym create a new protected key store in keychain "my-keychain-key"')
+
+            output << example(comment: 'print the key stored in the keychain item "my-keychain-key"',
+                              command: 'sym print keychain "my-keychain-key"')
+
+            output << example(comment: 'use the new key to encrypt a file:',
+                              command: 'sym encrypt with keychain "my-keychain-key" file "password.txt" and write to "passwords.enc"')
+
+          end
+
+          output.flatten.compact.join("\n")
+        end
+
+        def example(comment: nil, command: nil, echo: nil, result: nil)
+          @dict   ||= ::Sym::App::NLP::Constants::DICTIONARY.to_a.flatten!
+          _command = command.split(' ').map do |w|
+            _w = w.to_sym
+            if w == 'sym'
+              w.italic.yellow
+            elsif ::Sym::App::NLP::Constants::STRIPPED.include?(_w)
+              w.italic.red
+            elsif @dict.include?(_w)
+              w.blue
+            else
+              w
+            end
+          end.join(' ') if command
+          out     = []
+          out << "# #{comment}".white.dark.italic if comment
+          out << "#{_command}" if command
+          out << "#{echo}" if echo
+          out << "#{result}" if result
+          out << (' '*80).dark
+        end
+      end
+    end
+  end
+end