s7n 0.1.0

data/lib/s7n/gpass_file.rb

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+
+require "s7n/key"
+require "s7n/cipher"
+require "s7n/entry_collection"
+require "s7n/attribute"
+require "s7n/exception"
+require "gettext"
+
+module S7n
+  # GPass のファイルに関する処理を表現する。
+  class GPassFile
+    include GetText
+    
+    # GPass のファイルが格納されているデフォルトのパス。
+    DEFAULT_PATH = "~/.gpass/passwords.gps"
+
+    # Blowfish の初期化配列。
+    IV = [5, 23, 1, 123, 12, 3, 54, 94].pack("C8")
+
+    # GPass のファイルであることを示すマジック。
+    MAGIC_PATTERN = /\AGPassFile version (\d\.\d\.\d)/
+    
+    # GPass で扱う秘密情報の種類と属性。
+    ENTRY_ATTRIBUTE_TEMPLATES = { 
+      "entry" => [TextAttribute.new("name" => N_("name")),
+                  TextAttribute.new("name" => N_("description")),
+                  DateTimeAttribute.new("name" => N_("created_at")),
+                  DateTimeAttribute.new("name" => N_("updated_at")),
+                  BooleanAttribute.new("name" => N_("expiration")),
+                  DateTimeAttribute.new("name" => N_("expire_at"))],
+      "folder" => ["entry"],
+      "password" => ["entry",
+                     TextAttribute.new("name" => N_("username")),
+                     TextAttribute.new("name" => N_("password"),
+                                       "secret" => true)],
+      "general" => ["password",
+                    TextAttribute.new("name" => N_("hostname"))],
+      "shell" => ["general"],
+      "website" => ["password",
+                    TextAttribute.new("name" => N_("url"))],
+    }
+    
+    ENTRY_ATTRIBUTE_TEMPLATES.each do |name, template|
+      loop do
+        replaced = false
+        template.each_with_index do |attr, i|
+          if attr.is_a?(String)
+            template[i] = ENTRY_ATTRIBUTE_TEMPLATES[attr]
+            replaced = true
+          end
+        end
+        if replaced
+          template.flatten!
+        else
+          break
+        end
+      end
+    end
+    
+    def read(passphrase, path = DEFAULT_PATH)
+      res = EntryCollection.new
+      File.open(File.expand_path(path), "r") do |f|
+        f.flock(File::LOCK_EX)
+        s = decrypt(f, passphrase)
+        parse(s, res)
+      end
+      return res
+    end
+
+    private
+
+    def decrypt(io, passphrase)
+      key = Key.create_instance("SHA-1", passphrase)
+      cipher = Cipher.create_instance("BF-CBC", :key => key, :iv => IV)
+      return cipher.decrypt(io)
+    end
+
+    def parse(s, entry_collection)
+      if s.slice!(MAGIC_PATTERN).nil?
+        raise InvalidPassphrase
+      end
+      version = $1
+      # TODO: 1.1.0 より前のバージョンもサポートする。
+      if version != "1.1.0"
+        raise GPassFileError, _("not supported version: %s") % version
+      end
+      id_entry = {}
+      while !s.empty?
+        res = parse_gpass_entry(s)
+        id = res["id"]
+        entry = res["entry"]
+        if id_entry.key?(id)
+          raise GPassFileError, _("duplicated entry id: %s") % id
+        end
+        id_entry[id] = entry
+        parent = id_entry[res["parent_id"]]
+        if parent
+          entry.tags.push(*parent.tags)
+        end
+        if res["type"] == "folder"
+          entry.tags.push(entry.name)
+        else
+          entry_collection.add_entries(entry)
+        end
+      end
+    end
+
+    def parse_gpass_entry(s)
+      id = unpack_number(s)
+      parent_id = unpack_number(s)
+      type = unpack_string(s, unpack_number(s))
+      bytes = unpack_number(s)
+      if s.length < bytes
+        raise DataLengthError.new(s.length, bytes)
+      end
+      entry = Entry.new
+      unpack_attributes(entry, type, s.slice!(0, bytes))
+      return {
+        "id" => id,
+        "parent_id" => parent_id,
+        "type" => type,
+        "entry" => entry,
+      }
+    end
+
+    def unpack_attributes(entry, type, s)
+      template = ENTRY_ATTRIBUTE_TEMPLATES[type]
+      if !template
+        raise GPassFileError, _("invalid entry type: type=<%s>") % type
+      end
+      template.each do |a|
+        attr = a.dup
+        case attr
+        when NumericAttribute
+          attr.value = unpack_variable_number(s)
+        when BooleanAttribute
+          attr.value = unpack_boolean(s)
+        when DateTimeAttribute
+          attr.value = unpack_time(s)
+        when TextAttribute
+          attr.value = unpack_string(s, unpack_variable_number(s))
+        end
+        entry.add_attributes(attr)
+      end
+    end
+    
+    # s で指定したバイト列から 4 バイト取り出し、リトルエンディアンの数
+    # 値として unpack した結果を返す。
+    def unpack_number(s)
+      if s.length < 4
+        raise DataLengthError.new(s.length, 4)
+      end
+      return s.slice!(0, 4).unpack("V").first
+    end
+
+    # s で指定したバイト列から 8 ビット目が 0 のバイトを見つけるまで 1
+    # バイトずつ取り出し、4 バイトのリトルエンディアンの数値として
+    # unpack した結果を返す。
+    def unpack_variable_number(s)
+      n = 0
+      base = 1
+      i = 0
+      while (t = s.slice!(0)) && i <= 5
+        t = t.ord
+        if t & 0x80 == 0
+          n += base * t
+          break
+        else
+          n += base * (t & 0x7f)
+          base *= 0x80
+        end
+        i += 1
+      end
+      return [n].pack("V").unpack("I").first
+    end
+
+    # s で指定したバイト列から n で指定した長さを取り出し、それを文字列
+    # として返す。
+    def unpack_string(s, n)
+      if s.length < n
+        raise DataLengthError.new(s.length, n)
+      end
+      return s.slice!(0, n).force_encoding("utf-8")
+    end
+
+    # s で指定したバイト列から unpack_variable_number を使用して数値を
+    # 取り出す。それを time_t の値として扱い、DateTimeオブジェクトを返す。
+    def unpack_time(s)
+      return Time.at(unpack_variable_number(s)).to_datetime
+    end
+
+    # s で指定したバイト列から unpack_variable_number を使用して数値を
+    # 取り出す。それが 0 であれば false を、そうでなければ true を返す。
+    def unpack_boolean(s)
+      return unpack_variable_number(s) != 0
+    end
+
+    # GPass のファイルの処理中に発生したエラーを表現する例外クラス。
+    class GPassFileError < ApplicationError
+    end
+  end
+end

data/lib/s7n/key.rb

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+require "openssl"
+
+module S7n
+  # 暗号化用のキーを表現する。
+  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/s7n/message_catalog.rb

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

data/lib/s7n/s7n_file.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+require "fileutils"
+require "stringio"
+require "s7n/utils"
+require "s7n/cipher"
+
+module S7n
+  # s7 オリジナルのファイル形式で機密情報の読み書きを表現する。
+  module S7nFile
+    # マジック。
+    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/s7n/s7ncli.rb

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+
+require "optparse"
+require "readline"
+require "gettext"
+require "fileutils"
+require "s7n/s7ncli/option"
+require "s7n/s7ncli/command"
+command_pattern =
+  File.expand_path("s7ncli/*_command.rb", File.dirname(__FILE__))
+Dir.glob(command_pattern).each do |path|
+  require path.gsub(/\.rb\z/, "")
+end
+
+# s7n のコマンドラインインタフェースを表現する。
+module S7n
+  class S7nCli
+    include GetText
+
+    # 最初に実行するメソッド。
+    def self.run(argv)
+      obj = S7nCli.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: s7ncli [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("--debug",
+                _("Turn on debug mode. Default is '%s'.") % world.debug) do
+          world.debug = true
+        end
+        opts.on("-v", "--version", _("Show version.")) do
+          puts(_("s7ncli, version %s") % S7n::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.lock
+        world.start_logging
+        begin
+          master_key =
+            S7nCli.input_string_without_echo(_("Enter the master key for s7n: "))
+          if master_key.nil?
+            exit(1)
+          end
+          world.load(S7nFile.read(world.secrets_path, master_key))
+          world.master_key = master_key
+        rescue InvalidPassphrase => e
+          puts(e.message)
+          retry
+        end
+      else
+        master_key =
+          S7nCli.input_string_without_echo(_("Enter the master key for s7n: "))
+        if master_key.nil?
+          exit(1)
+        end
+        confirmation =
+          S7nCli.input_string_without_echo(_("Comfirm the master key for s7n: "))
+        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)
+        world.lock
+      end
+      begin
+        path = File.join(world.base_dir, "s7ncli")
+        if File.file?(path)
+          begin
+            hash = YAML.load(S7nFile.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 = "%ss7n> " % (world.changed ? "*" : "")
+            input = S7nCli.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 => e
+            puts(e.message)
+            if world.debug
+              puts(_("----- back trace -----"))
+              e.backtrace.each do |line|
+                puts("  #{line}")
+              end
+            end
+          end
+        end
+      ensure
+        begin
+          world.save
+          begin
+            path = File.join(world.base_dir, "s7ncli")
+            # TODO: history の上限を設ける。
+            hash = {
+              "history" => Readline::HISTORY.to_a.join("\n"),
+            }
+            S7nFile.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
+    rescue ApplicationError => e
+      puts(e.message)
+      if world.debug
+        puts(GetText._("----- back trace -----"))
+        e.backtrace.each do |line|
+          puts("  #{line}")
+        end
+      end
+    end
+  end
+end