s7 0.0.1

data/lib/s7/key.rb

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+require "openssl"
+
+module S7
+  # 暗号化用のキーを表現する。
+  class Key
+    @@key_classes = {}
+    
+    class << self
+      def create_instance(type, passphrase)
+        return @@key_classes[type].new(passphrase)
+      end
+
+      private
+      
+      def key_type(name)
+        if @@key_classes.nil?
+          @@key_classes = {}
+        end
+        @@key_classes[name] = self
+        self.const_set("KEY_TYPE", name)
+      end
+    end
+
+    attr_reader :key
+    attr_reader :length
+
+    def initialize(passphrase)
+      @key = OpenSSL::Digest.digest(hash_type, passphrase)
+      @length = @key.length
+    end
+
+    private
+
+    def hash_type
+      begin
+        return self.class.const_get("HASH_TYPE")
+      rescue NameError
+        return self.class.const_get("KEY_TYPE")
+      end
+    end
+  end
+
+  class Md5Key < Key
+    key_type "MD5"
+  end
+
+  class Sha1Key < Key
+    key_type "SHA-1"
+    HASH_TYPE = "SHA1"
+  end
+
+  begin
+    OpenSSL::Digest.const_get("SHA224")
+
+    class Sha224Key < Key
+      key_type "SHA-224"
+      HASH_TYPE = "SHA224"
+    end
+  rescue NameError
+  end
+
+  begin
+    OpenSSL::Digest.const_get("SHA256")
+    
+    class Sha256Key < Key
+      key_type "SHA-256"
+      HASH_TYPE = "SHA256"
+    end
+  rescue NameError
+  end
+  
+  begin
+    OpenSSL::Digest.const_get("SHA512")
+    
+    class Sha512Key < Key
+      key_type "SHA-512"
+      HASH_TYPE = "SHA512"
+    end
+  rescue NameError
+  end
+end

data/lib/s7/message_catalog.rb

@@ -0,0 +1,5 @@
+module S7
+  # 属性の名前を国際化するときに使用するメッセージカタログを表現する。
+  class MessageCatalog
+  end
+end

data/lib/s7/s7_file.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+require "fileutils"
+require "stringio"
+require "s7/utils"
+require "s7/cipher"
+
+module S7
+  # s7 オリジナルのファイル形式で機密情報の読み書きを表現する。
+  module S7File
+    # マジック。
+    MAGIC = "s7 file version 0\n"
+
+    # data で指定したバイト列を暗号化して書き込む。
+    def write(path, master_key, cipher_type, data)
+      cipher = Cipher.create_instance(cipher_type, :passphrase => master_key)
+      FileUtils.touch(path)
+      File.open(path, "r+b") do |f|
+        f.flock(File::LOCK_EX)
+        data = [MAGIC,
+                cipher_type + "\n",
+                cipher.encrypt(StringIO.new(data))].join
+        f.write(data)
+        f.truncate(f.pos)
+      end
+      FileUtils.chmod(0600, path)
+    end
+    module_function :write
+
+    # path で指定したファイルを読み込み、master_key で指定したマスター
+    # キーを使用して復号する。
+    def read(path, master_key)
+      File.open(path, "rb") do |f|
+        f.flock(File::LOCK_EX)
+        magic = f.gets
+        if magic != MAGIC
+          raise InvalidPassphrase
+        end
+        cipher_type = f.gets.chomp
+        cipher = Cipher.create_instance(cipher_type,
+                                        :passphrase => master_key)
+        return cipher.decrypt(f)
+      end
+    end
+    module_function :read
+  end
+end

data/lib/s7/s7cli.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+
+require "optparse"
+require "readline"
+require "gettext"
+require "fileutils"
+require "s7/s7cli/option"
+require "s7/s7cli/command"
+command_pattern =
+  File.expand_path("s7cli/*_command.rb", File.dirname(__FILE__))
+Dir.glob(command_pattern).each do |path|
+  require path.gsub(/\.rb\z/, "")
+end
+
+# s7 のコマンドラインインタフェースを表現する。
+module S7
+  class S7Cli
+    include GetText
+
+    # 最初に実行するメソッド。
+    def self.run(argv)
+      obj = S7Cli.new
+      obj.parse_command_line_argument(argv)
+      obj.run
+    end
+
+    # prompt に指定した文字列を表示後、Readline ライブラリを利用してユー
+    # ザからの入力を得る。
+    def self.input_string(prompt = "", add_history = true)
+      input = Readline.readline(prompt, add_history)
+      input.force_encoding("utf-8") if input
+      return input
+    end
+
+    # prompt に指定した文字列を表示後、エコーバックせずにユーザからの入
+    # 力を得る。パスフレーズの入力を想定。
+    def self.input_string_without_echo(prompt = "")
+      print(prompt) if prompt.length > 0
+      STDOUT.flush
+      Utils.execute("stty -echo")
+      begin
+        input = STDIN.gets
+      ensure
+        Utils.execute("stty echo")
+        puts("")
+      end
+      if input
+        input.chomp!
+        input.force_encoding("utf-8")
+      end
+      return input
+    end
+
+    # prompt に指定した文字列を表示後、ユーザからの入力を得る。
+    # それがyes、y、true、t、okのいずれかであれば true を返し、
+    # そうでなければ false を返す。大小文字は区別しない。
+    # ^D などにより何も入力しない場合、defualt で指定した真偽値を返す。
+    def self.input_boolean(prompt = "", default = false)
+      if input = Readline.readline(prompt, false)
+        input.strip!
+        if input.empty?
+          return default
+        end
+        input.force_encoding("utf-8")
+        if /\Ay|yes|t|true|ok\z/i =~ input
+          return true
+        else
+          return false
+        end
+      else
+        return default
+      end
+    end
+
+    # World クラスのインスタンス。
+    attr_accessor :world
+
+    def initialize
+      @world = World.new
+    end
+
+    # コマンドラインオプションを解析する。
+    def parse_command_line_argument(argv)
+      option_parser = OptionParser.new { |opts|
+        opts.banner = _("usage: s7cli [options]")
+        opts.separator("")
+        opts.separator(_("options:"))
+        opts.on("-d", "--base-dir=DIR",
+                _("Specify the base directory. Default is '%s'.") % world.base_dir) do |dir|
+          world.base_dir = dir
+        end
+        opts.on("-v", "--version", _("Show version.")) do
+          puts(_("s7cli, version %s") % S7::VERSION)
+          exit(0)
+        end
+        opts.on("-h", "--help",
+                _("Show help and exit.")) do
+          puts(opts)
+          exit(0)
+        end
+      }
+      option_parser.parse(argv)
+    end
+  
+    # メインの処理を行う。
+    def run
+      if File.exist?(world.base_dir)
+        if !File.directory?(world.base_dir)
+          Utils::shred_string(master_key)
+          raise InvalidPath.new(world.base_dir)
+        end
+        world.start_logging
+        begin
+          master_key =
+            S7Cli.input_string_without_echo(_("Enter the master key for s7: "))
+          if master_key.nil?
+            exit(1)
+          end
+          world.load(S7File.read(world.secrets_path, master_key))
+          world.master_key = master_key
+        rescue InvalidPassphrase => e
+          puts(e.message)
+          retry
+        end
+      else
+        master_key =
+          S7Cli.input_string_without_echo(_("Enter the master key for s7: "))
+        if master_key.nil?
+          exit(1)
+        end
+        confirmation =
+          S7Cli.input_string_without_echo(_("Comfirm the master key for s7: "))
+        if master_key != confirmation
+          Utils::shred_string(master_key)
+          Utils::shred_string(confirmation) if !confirmation.nil?
+          raise InvalidPassphrase
+        end
+        world.master_key = master_key
+        FileUtils.mkdir_p(world.base_dir)
+        FileUtils.chmod(0700, world.base_dir)
+        world.start_logging
+        world.logger.info(_("created base directory: %s") % world.base_dir)
+        world.save(true)
+      end
+      world.lock
+      begin
+        path = File.join(world.base_dir, "s7cli")
+        if File.file?(path)
+          begin
+            hash = YAML.load(S7File.read(path, world.master_key))
+            hash["history"].each_line do |line|
+              Readline::HISTORY.push(line.chomp)
+            end
+          rescue
+            puts(_("could not read: %s") % path)
+            raise
+          end
+        end
+        loop do
+          begin
+            prompt = "%ss7> " % (world.changed ? "*" : "")
+            input = S7Cli.input_string(prompt, true)
+            if !input
+              puts("")
+              break
+            end
+            name, argv = *Command.split_name_and_argv(input)
+            if !name
+              next
+            end
+            command = Command.create_instance(name, world)
+            if command
+              if !command.run(argv)
+                break
+              end
+            else
+              raise ApplicationError, _("Unknown command: %s") % name
+            end
+          rescue Interrupt
+            puts("")
+            retry
+          rescue ApplicationError
+            puts($!)
+          rescue => e
+            puts(e.message)
+            puts("----- back trace -----")
+            e.backtrace.each do |line|
+              puts("  #{line}")
+            end
+          end
+        end
+      ensure
+        begin
+          world.save
+          begin
+            path = File.join(world.base_dir, "s7cli")
+            # TODO: history の上限を設ける。
+            hash = {
+              "history" => Readline::HISTORY.to_a.join("\n"),
+            }
+            S7File.write(path, world.master_key,
+                         world.configuration.cipher_type, hash.to_yaml)
+          rescue
+            puts(_("could not write: %s") % path)
+            puts($!)
+          end
+        ensure
+          world.unlock
+        end
+      end
+    end
+  end
+end

data/lib/s7/s7cli/attribute_command.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+require "s7/s7cli/command"
+require "open3"
+
+module S7
+  class S7Cli
+    # 機密情報の属性のうち、指定したものの値をクリップボードにコピーするコ
+    # マンドを表現する。
+    class AttributeCopyCommand < Command
+      command("copy",
+              ["attribute:copy",
+               "c"],
+              _("Copy the attribute value to the clipboard."),
+              _("usage: copy [ID] [ATTRIBUTE NAME] [OPTIONS]"))
+      
+      def initialize(*args)
+        super
+        @config["copy_command"] = "/usr/bin/pbcopy"
+        @config["inclement_rate"] = true
+        @options.push(IntOption.new("i", "id", "ID", _("Entry ID.")),
+                      StringOption.new("n", "name", _("Attribute name.")),
+                      BoolOption.new("inclement_rate",
+                                     _("Inclement the entry's rate after copied.")),
+                      StringOption.new("copy_command", _("Copy command.")))
+      end
+
+      # コマンドを実行する。
+      def run(argv)
+        option_parser.parse!(argv)
+        if argv.length > 0
+          config["id"] = argv.shift.to_i
+        end
+        if argv.length > 0
+          config["name"] = argv.shift
+        end
+        if config["id"].nil? || config["name"].nil?
+          puts(_("Too few arguments."))
+          help
+          return true
+        end
+        puts(_("Copy the attribute value to the clipboard."))
+        entry = world.entry_collection.find(config["id"])
+        if entry.nil?
+          raise NoSuchEntry.new("id" => config["id"])
+        end
+        attr = entry.get_attribute(config["name"])
+        if attr.nil?
+          raise NoSuchAttribute.new("id" => config["id"],
+                                    "name" => config["name"])
+        end
+        copy_command = @config["copy_command"]
+        res, status = Open3.capture2(copy_command,
+                                     stdin_data: attr.value.to_s,
+                                     binmode: true)
+        if status != 0
+          raise CommandFailed.new(copy_command, status)
+        end
+        if config["inclement_rate"]
+          # TODO: undo スタックに操作を追加する。
+          entry.rate += 1
+          puts(_("Changed rate to %d.") % entry.rate)
+          world.changed = true
+        end
+        return true
+      end
+    end
+  end
+end

data/lib/s7/s7cli/command.rb

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+
+require "gettext"
+
+module S7
+  class S7Cli
+    # コマンドを表現する。
+    class Command
+      include GetText
+
+      # オプションの配列。
+      attr_reader :options
+
+      # 設定。
+      attr_reader :config
+
+      # World オブジェクト。
+      attr_reader :world
+
+      @@command_classes = {}
+      
+      class << self
+        # s で指定した文字列をコマンド名とオプションに分割する。
+        def split_name_and_argv(s)
+          s = s.strip
+          name = s.slice!(/\A\w+/)
+          argv = s.split
+          return name, argv
+        end
+        
+        def create_instance(name, world)
+          klass = @@command_classes[name]
+          if klass
+            return klass.new(world)
+          else
+            return nil
+          end
+        end
+        
+        private
+      
+        def command(name, aliases, description, usage)
+          @@command_classes[name] = self
+          self.const_set("NAME", name)
+          aliases.each do |s|
+            @@command_classes[s] = self
+          end
+          self.const_set("ALIASES", aliases)
+          self.const_set("DESCRIPTION", description)
+          self.const_set("USAGE", usage)
+        end
+      end
+
+      def initialize(world)
+        @world = world
+        @config = {}
+        @options = []
+      end
+
+      # コマンド名を取得する。
+      def name
+        return self.class.const_get("NAME")
+      end
+
+      # 別名の配列を取得する。
+      def aliases
+        return self.class.const_get("ALIASES")
+      end
+
+      # 概要を取得する。
+      def description
+        return self.class.const_get("DESCRIPTION")
+      end
+
+      # 使用例を取得する。
+      def usage
+        return self.class.const_get("USAGE")
+      end
+
+      # コマンドラインオプションを解析するための OptionParser オブジェ
+      # クトを取得する。
+      def option_parser
+        return OptionParser.new { |opts|
+          opts.banner = [
+                         "#{name} (#{aliases.join(",")}): #{description}",
+                         usage,
+                        ].join("\n")
+          if options && options.length > 0
+            opts.separator("")
+            opts.separator("Valid options:")
+            for option in options
+              option.define(opts, config)
+            end
+          end
+        }
+      end
+
+      # 使用方法を示す文字列を返す。
+      def help
+        puts(option_parser)
+      end
+
+      private
+
+      # キャンセルした旨を出力し、true を返す。
+      # Command オブジェクトの run メソッドで return canceled という使
+      # い方を想定している。
+      def canceled
+        puts("\n" + Canceled::MESSAGE)
+        return true
+      end
+    end
+
+    # プログラムを終了するコマンドを表現する。
+    class HelpCommand < Command
+      command("help",
+              ["usage", "h"],
+              _("Describe the commands."),
+              _("usage: help [COMMAND]"))
+      
+      def run(argv)
+        if argv.length > 0
+          command_name = argv.shift
+          command = Command.create_instance(command_name, world)
+          if command
+            command.help
+          else
+            puts(_("Unknown command: %s") % command_name)
+          end
+        else
+          puts(_("Available commands:"))
+          command_classes = @@command_classes.values.uniq.sort_by { |klass|
+            klass.const_get("NAME")
+          }
+          command_classes.each do |klass|
+            s = "  #{klass.const_get("NAME")}"
+            aliases = klass.const_get("ALIASES")
+            if aliases.length > 0
+              s << " (#{aliases.join(", ")})"
+            end
+            puts(s)
+          end
+        end
+        return true
+      end
+    end
+
+    # 現在の状態を保存するコマンドを表現する。
+    class SaveCommand < Command
+      command("save", [], _("Save."), _("usage: save"))
+
+      def initialize(*args)
+        super
+        @options.push(BoolOption.new("f", "force", _("Force.")))
+      end
+
+      def run(argv)
+        option_parser.parse!(argv)
+        world.save(config["force"])
+        puts(_("Saved."))
+        return true
+      end
+    end
+
+    # スクリーンロックし、マスターキーを入力するまでは操作できないよう
+    # にするコマンドを表現する。
+    class LockCommand < Command
+      command("lock", [], _("Lock screen after saved."), _("usage: lock"))
+
+      def run(argv)
+        system("clear")
+        puts(_("Locked screen."))
+        world.save
+        prompt = _("Enter the master key for s7: ")
+        begin
+          input = S7Cli.input_string_without_echo(prompt)
+          if input != world.master_key
+            raise InvalidPassphrase
+          end
+          puts(_("Unlocked."))
+          return true
+        rescue Interrupt
+        rescue ApplicationError => e
+          puts($!.message + _("Try again."))
+          retry
+        rescue Exception => e
+          puts(e.message)
+          puts("----- back trace -----")
+          e.backtrace.each do |line|
+            puts("  #{line}")
+          end
+        end
+        puts(_("Quit."))
+        return false
+      end
+    end
+    
+    # プログラムを終了するコマンドを表現する。
+    class QuitCommand < Command
+      command("quit",
+              ["exit", "q"],
+              _("Quit."),
+              _("usage: quit"))
+
+      def run(argv)
+        return false
+      end
+    end
+  end
+end