rubeepass 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8635dc28cb56a0bc98a6c2d8ac0f0029a1d16005
+  data.tar.gz: 83416771d1bf5a6ebd2d66cde4603b9de3d55cd5
+SHA512:
+  metadata.gz: ee4d0478d32fa683fbde3a7e80f9c42b48ce4e4248285e7ef7b094ee66c60918fd1c1563403fa7d59b6682a7a4670055853cbb8bae0fa7e66f453e5bce5d68a8
+  data.tar.gz: ee51c7575168d1727527690cb6d064f2d21fc2f6ff8ee877360744ec71590569dd14320ffb8467e6446e98878af97eb6bc2e8328da81a6e3e067b73311c7e5e1

data/bin/rpass

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+
+require "djinni"
+require "io/console"
+require "json"
+require "optparse"
+require "pathname"
+require "rubeepass"
+require "string"
+
+class RPassExit
+    GOOD = 0
+    INVALID_OPTION = 1
+    INVALID_ARGUMENT = 2
+    MISSING_ARGUMENT = 3
+    EXTRA_ARGUMENTS = 4
+    KDBX_NOT_FOUND = 5
+    KDBX_NOT_READABLE = 6
+    KEYFILE_NOT_FOUND = 7
+    KEYFILE_NOT_READABLE = 8
+    KDBX_NOT_OPENED = 9
+end
+
+def get_password
+    print "Enter password: "
+    passwd = STDIN.noecho(&:gets)
+    puts
+    return passwd.chomp
+end
+
+def parse(args)
+    options = Hash.new
+    options["export_file"] = nil
+    options["export_format"] = "xml"
+    options["password"] = nil
+    options["keyfile"] = nil
+    options["timeout"] = nil
+
+    parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [OPTIONS] [kdbx]"
+
+        opts.on(
+            "-e",
+            "--export=FILE",
+            "Export database to file"
+        ) do |file|
+            options["export_file"] = file
+        end
+
+        opts.on(
+            "-f",
+            "--format=FORMAT",
+            [ "gzip", "xml" ],
+            "Specify format to use when exporting (default: xml)"
+        ) do |format|
+            options["export_format"] = format
+        end
+
+        opts.on("-h", "--help", "Display this help message") do
+            puts opts
+            exit RPassExit::GOOD
+        end
+
+        opts.on(
+            "-k",
+            "--keyfile=KEYFILE",
+            "Use specified keyfile"
+        ) do |keyfile|
+            options["keyfile"] = Pathname.new(keyfile).expand_path
+        end
+
+        opts.on(
+            "-p",
+            "--password=PASSWORD",
+            "Use specified password (will prompt if not provided)"
+        ) do |password|
+            options["password"] = password
+        end
+
+        opts.on("-t", "--timeout=TIMEOUT", "Clipboard timeout") do |t|
+            options["timeout"] = t.to_i
+        end
+
+        opts.on(
+            "",
+            "FORMATS",
+            "\tgzip",
+            "\txml"
+        )
+    end
+
+    begin
+        parser.parse!
+    rescue OptionParser::InvalidOption => e
+        puts e.message
+        puts parser
+        exit RPassExit::INVALID_OPTION
+    rescue OptionParser::InvalidArgument => e
+        puts e.message
+        puts parser
+        exit RPassExit::INVALID_ARGUMENT
+    rescue OptionParser::MissingArgument => e
+        puts e.message
+        puts parser
+        exit RPassExit::MISSING_ARGUMENT
+    end
+
+    if (args.length > 1)
+        puts parser
+        exit RPassExit::EXTRA_ARGUMENTS
+    end
+
+    # Read config
+    rc = read_rpassrc
+
+    # Determine kdbx and keyfile
+    if (args.length == 1)
+        # Use specified kdbx (and keyfile if specified)
+        options["kdbx"] = Pathname.new(args[0]).expand_path
+    else
+        # Use kdbx from config if stored
+        if (rc["last_kdbx"] && !rc["last_kdbx"].empty?)
+            options["kdbx"] = Pathname.new(
+                rc["last_kdbx"]
+            ).expand_path
+        end
+
+        # Use keyfile from config if stored and not specified already
+        if (options["keyfile"].nil?)
+            if (rc["last_keyfile"] && !rc["last_keyfile"].empty?)
+                options["keyfile"] = Pathname.new(
+                    rc["last_keyfile"]
+                ).expand_path
+            end
+        end
+    end
+
+    # Determine timeout
+    if (options["timeout"].nil?)
+        if (rc["timeout"])
+            options["timeout"] = rc["timeout"]
+        else
+            options["timeout"] = 7
+        end
+    end
+
+    # Throw error if kdbx not specified or in config
+    if (options["kdbx"].nil?)
+        puts parser
+        exit RPassExit::MISSING_ARGUMENT
+    end
+
+    # Throw error if kdbx does not exist or is not readable
+    if (!options["kdbx"].exist?)
+        puts parser
+        exit RPassExit::KDBX_NOT_FOUND
+    elsif (!options["kdbx"].readable?)
+        puts parser
+        exit RPassExit::KDBX_NOT_READABLE
+    end
+
+    # Throw error if keyfile does not exist or is not readable
+    if (options["keyfile"])
+        if (!options["keyfile"].exist?)
+            puts parser
+            exit RPassExit::KEYFILE_NOT_FOUND
+        elsif (!options["keyfile"].readable?)
+            puts parser
+            exit RPassExit::KEYFILE_NOT_READABLE
+        end
+    end
+
+    # Store data in config
+    rc["last_kdbx"] = options["kdbx"]
+    rc["last_keyfile"] = options["keyfile"]
+    rc["timeout"] = options["timeout"]
+    write_rpassrc(rc)
+
+    return options
+end
+
+def read_rpassrc
+    default = Hash.new
+    default["last_kdbx"] = nil
+    default["last_keyfile"] = nil
+    default["timeout"] = 7
+
+    rc_file = Pathname.new("~/.rpassrc").expand_path
+    return default if (!rc_file.exist? && !rc_file.symlink?)
+    return JSON.parse(File.read(rc_file))
+end
+
+def write_rpassrc(rc)
+    rc_file = Pathname.new("~/.rpassrc").expand_path
+    File.open(rc_file, "w") do |f|
+        f.write(JSON.pretty_generate(rc))
+    end
+end
+
+options = parse(ARGV)
+
+kdbx = options["kdbx"]
+password = options["password"] if (options["password"])
+password = get_password if (options["password"].nil?)
+keyfile = options["keyfile"]
+
+keepass = nil
+begin
+    keepass = RubeePass.new(kdbx, password, keyfile).open
+rescue RubeePass::Error => e
+    puts e.message
+    exit RPassExit::KDBX_NOT_OPENED
+end
+exit RPassExit::KDBX_NOT_OPENED if (keepass.nil?)
+
+if (options["export_file"])
+    File.open(options["export_file"], "w") do |f|
+        case options["export_format"]
+        when "gzip"
+            f.write(keepass.gzip)
+        when "xml"
+            f.write(keepass.xml)
+        end
+    end
+    exit RPassExit::GOOD
+end
+
+djinni = Djinni.new
+djinni.load_wishes("#{File.dirname(__FILE__)}/../lib/builtins")
+djinni.prompt(
+    {
+        "keepass" => keepass,
+        "cwd" => keepass.db,
+        "clipboard_timeout" => options["timeout"]
+    },
+    "rpass:/> ".white
+)
+exit RPassExit::GOOD

data/lib/builtins/cd_wish.rb

@@ -0,0 +1,56 @@
+require "djinni"
+require "string"
+
+class CDWish < Djinni::Wish
+    def aliases
+        return [ "cd" ]
+    end
+
+    def description
+        return "Change to new group"
+    end
+
+    def execute(args, djinni_env = {})
+        keepass = djinni_env["keepass"]
+        cwd = djinni_env["cwd"]
+
+        args = keepass.absolute_path(args, cwd.path)
+        new_cwd = keepass.find_group(args)
+
+        if (new_cwd)
+            djinni_env["cwd"] = new_cwd
+            prompt = "rpass:#{new_cwd.name}> ".white
+            djinni_env["djinni_prompt"] = prompt
+        else
+            puts "Group \"#{args}\" doesn't exist!"
+        end
+    end
+
+    def tab_complete(input, djinni_env = {})
+        cwd = djinni_env["cwd"]
+        input, groups = cwd.fuzzy_find(input)
+        return input.gsub(%r{^#{cwd.path}/?}, "") if (groups.empty?)
+
+        path, dest = input.rsplit("/")
+
+        if (dest.empty?)
+            if (groups.length == 1)
+                input = "#{path}/#{groups.first}/"
+                return input.gsub(%r{^#{cwd.path}/?}, "")
+            end
+            puts
+            groups.each do |group|
+                puts "#{group}/"
+            end
+            return input.gsub(%r{^#{cwd.path}/?}, "")
+        end
+
+        input = "#{path}/#{groups.first}/"
+        return input.gsub(%r{^#{cwd.path}/?}, "")
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} [group]"
+        puts "\t#{description}."
+    end
+end

data/lib/builtins/clear_wish.rb

@@ -0,0 +1,24 @@
+require "djinni"
+
+class ClearWish < Djinni::Wish
+    def aliases
+        return [ "clear", "cls" ]
+    end
+
+    def description
+        return "Clear the screen"
+    end
+
+    def execute(args, djinni_env = {})
+        if (args.nil? || args.empty?)
+            system("clear")
+        else
+            usage
+        end
+    end
+
+    def usage
+        puts aliases.join(", ")
+        puts "\t#{description}."
+    end
+end

data/lib/builtins/copy_wish.rb

@@ -0,0 +1,134 @@
+require "djinni"
+require "string"
+
+class CopyWish < Djinni::Wish
+    def aliases
+        return [ "copy", "cp" ]
+    end
+
+    def description
+        return "Copy specified field to the clipboard"
+    end
+
+    def execute(args, djinni_env = {})
+        if (args.nil? || args.empty?)
+            puts usage
+            return
+        end
+
+        field, args = args.split(" ", 2)
+        if (!@fields.include?(field))
+            puts usage
+            return
+        end
+
+        keepass = djinni_env["keepass"]
+        cwd = djinni_env["cwd"]
+        args = cwd.path if (args.nil? || args.empty?)
+
+        args = keepass.absolute_path(args, cwd.path)
+        path, target = args.rsplit("/")
+        new_cwd = keepass.find_group(path)
+
+        if (new_cwd)
+            if (target.empty?)
+                usage
+            elsif (new_cwd.has_entry?(target))
+                target = new_cwd.entry_titles.select do |entry|
+                    target.downcase == entry.downcase
+                end.first
+
+                timeout = djinni_env["clipboard_timeout"]
+
+                case field
+                when "pass"
+                    new_cwd.entries[target].copy_password_to_clipboard
+                    keepass.send(
+                        "clear_clipboard_after_#{timeout}_seconds"
+                    )
+                when "url"
+                    new_cwd.entries[target].copy_url_to_clipboard
+                    keepass.send(
+                        "clear_clipboard_after_#{timeout}_seconds"
+                    )
+                when "user"
+                    new_cwd.entries[target].copy_username_to_clipboard
+                    keepass.send(
+                        "clear_clipboard_after_#{timeout}_seconds"
+                    )
+                end
+            else
+                puts "Entry \"#{args}\" doesn't exist!"
+            end
+        else
+            puts "Entry \"#{args}\" doesn't exist!"
+        end
+    end
+
+    def initialize
+        @fields = [ "pass", "url", "user" ]
+    end
+
+    def tab_complete(input, djinni_env = {})
+        if (input.nil? || input.empty?)
+            puts
+            puts @fields
+            return ""
+        end
+
+        field, input = input.split(" ", 2)
+
+        if (input.nil? || input.empty?)
+            @fields.each do |f|
+                break if (f == field)
+                if (f.start_with?(field))
+                    return "#{f} "
+                end
+            end
+        end
+
+        input = "" if (input.nil?)
+
+        cwd = djinni_env["cwd"]
+        input, groups, entries = cwd.fuzzy_find(input)
+        if (groups.empty? && entries.empty?)
+            return "#{field} #{input.gsub(%r{^#{cwd.path}/?}, "")}"
+        end
+
+        path, target = input.rsplit("/")
+
+        if (target.empty?)
+            if ((groups.length == 1) && entries.empty?)
+                input = "#{path}/#{groups.first}/"
+                return "#{field} #{input.gsub(%r{^#{cwd.path}/?}, "")}"
+            elsif (groups.empty? && (entries.length == 1))
+                input = "#{path}/#{entries.first}"
+                return "#{field} #{input.gsub(%r{^#{cwd.path}/?}, "")}"
+            end
+            puts
+            groups.each do |group|
+                puts "#{group}/"
+            end
+            puts entries
+            return "#{field} #{input.gsub(%r{^#{cwd.path}/?}, "")}"
+        end
+
+        if (!groups.empty?)
+            input = "#{path}/#{groups.first}/"
+        elsif (!entries.empty?)
+            input = "#{path}/#{entries.first}"
+        end
+
+        return "#{field} #{input.gsub(%r{^#{cwd.path}/?}, "")}"
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} <field> <entry>"
+        puts "\t#{description}."
+        puts
+        puts "FIELDS"
+        @fields.each do |field|
+            puts "\t#{field}"
+        end
+    end
+end

data/lib/builtins/ls_wish.rb

@@ -0,0 +1,60 @@
+require "djinni"
+require "string"
+
+class LSWish < Djinni::Wish
+    def aliases
+        return [ "ls", "dir" ]
+    end
+
+    def description
+        return "List groups and entries in current group"
+    end
+
+    def execute(args, djinni_env = {})
+        keepass = djinni_env["keepass"]
+        cwd = djinni_env["cwd"]
+        args = cwd.path if (args.nil? || args.empty?)
+
+        args = keepass.absolute_path(args, cwd.path)
+        new_cwd = keepass.find_group(args)
+
+        if (new_cwd)
+            new_cwd.group_names.each do |group|
+                puts "#{group}/"
+            end
+            new_cwd.entry_titles.each do |entry|
+                puts "#{entry}"
+            end
+        else
+            puts "Group \"#{args}\" doesn't exist!"
+        end
+    end
+
+    def tab_complete(input, djinni_env = {})
+        cwd = djinni_env["cwd"]
+        input, groups = cwd.fuzzy_find(input)
+        return input.gsub(%r{^#{cwd.path}/?}, "") if (groups.empty?)
+
+        path, dest = input.rsplit("/")
+
+        if (dest.empty?)
+            if (groups.length == 1)
+                input = "#{path}/#{groups.first}/"
+                return input.gsub(%r{^#{cwd.path}/?}, "")
+            end
+            puts
+            groups.each do |group|
+                puts "#{group}/"
+            end
+            return input.gsub(%r{^#{cwd.path}/?}, "")
+        end
+
+        input = "#{path}/#{groups.first}/"
+        return input.gsub(%r{^#{cwd.path}/?}, "")
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} [group]"
+        puts "\t#{description}."
+    end
+end

data/lib/builtins/pwd_wish.rb

@@ -0,0 +1,24 @@
+require "djinni"
+
+class PwdWish < Djinni::Wish
+    def aliases
+        return [ "pwd" ]
+    end
+
+    def description
+        return "Show path of current group"
+    end
+
+    def execute(args, djinni_env = {})
+        if (args.nil? || args.empty?)
+            puts djinni_env["cwd"].path
+        else
+            usage
+        end
+    end
+
+    def usage
+        puts aliases.join(", ")
+        puts "\t#{description}."
+    end
+end

data/lib/builtins/show_wish.rb

@@ -0,0 +1,79 @@
+require "djinni"
+require "string"
+
+class ShowWish < Djinni::Wish
+    def aliases
+        return [ "cat", "show" ]
+    end
+
+    def description
+        return "Show group contents"
+    end
+
+    def execute(args, djinni_env = {})
+        keepass = djinni_env["keepass"]
+        cwd = djinni_env["cwd"]
+        args = cwd.path if (args.nil? || args.empty?)
+
+        args = keepass.absolute_path(args, cwd.path)
+        path, target = args.rsplit("/")
+        new_cwd = keepass.find_group(path)
+
+        if (new_cwd)
+            if (target.empty?)
+                puts new_cwd
+            elsif (new_cwd.has_group?(target))
+                puts new_cwd.groups[target]
+            elsif (new_cwd.has_entry?(target))
+                new_cwd.entry_titles.select do |entry|
+                    target.downcase == entry.downcase
+                end.each do |entry|
+                    puts new_cwd.entries[entry]
+                end
+            else
+                puts "Group/entry \"#{args}\" doesn't exist!"
+            end
+        else
+            puts "Group/entry \"#{args}\" doesn't exist!"
+        end
+    end
+
+    def tab_complete(input, djinni_env = {})
+        cwd = djinni_env["cwd"]
+        input, groups, entries = cwd.fuzzy_find(input)
+        if (groups.empty? && entries.empty?)
+            return input.gsub(%r{^#{cwd.path}/?}, "")
+        end
+
+        path, target = input.rsplit("/")
+
+        if (target.empty?)
+            if ((groups.length == 1) && entries.empty?)
+                input = "#{path}/#{groups.first}/"
+                return input.gsub(%r{^#{cwd.path}/?}, "")
+            elsif (groups.empty? && (entries.length == 1))
+                input = "#{path}/#{entries.first}"
+                return input.gsub(%r{^#{cwd.path}/?}, "")
+            end
+            puts
+            groups.each do |group|
+                puts "#{group}/"
+            end
+            puts entries
+            return input.gsub(%r{^#{cwd.path}/?}, "")
+        end
+
+        if (!groups.empty?)
+            input = "#{path}/#{groups.first}/"
+        elsif (!entries.empty?)
+            input = "#{path}/#{entries.first}"
+        end
+
+        return input.gsub(%r{^#{cwd.path}/?}, "")
+    end
+
+    def usage
+        puts "#{aliases.join(", ")} [group]"
+        puts "\t#{description}."
+    end
+end

data/lib/rubeepass/entry.rb

@@ -0,0 +1,74 @@
+require "string"
+
+class RubeePass::Entry
+    include Comparable
+
+    attr_accessor :group
+    attr_accessor :keepass
+    attr_accessor :notes
+    attr_accessor :path
+    attr_accessor :title
+    attr_accessor :url
+    attr_accessor :username
+    attr_accessor :uuid
+
+    def ==(other)
+        return (self.uuid == other.uuid)
+    end
+
+    def <=>(other)
+        return (self.title.downcase <=> other.title.downcase)
+    end
+
+    def details(level = 0)
+        lvl = Array.new(level, "  ").join
+
+        return [
+            "#{lvl}Title    : #{@title}".green,
+            # "#{lvl}UUID     : #{@uuid}",
+            "#{lvl}Username : #{@username}",
+            # "#{lvl}Password : #{password}".red,
+            "#{lvl}Url      : #{@url}",
+            "#{lvl}Notes    : #{@notes}"
+        ].join("\n")
+    end
+
+    def initialize(params)
+        @group = params.fetch("Group", nil)
+        @keepass = params.fetch("Keepass", nil)
+        @password = params.fetch("Notes", "")
+        @password = params.fetch("Password", "")
+        @title = params.fetch("Title", "")
+        @url = params.fetch("URL", "")
+        @username = params.fetch("UserName", "")
+        @uuid = params.fetch("UUID", "")
+
+        @path = @title
+        @path = "#{@group.path}/#{@title}" if (@group)
+        @path.gsub!(%r{^//}, "/")
+    end
+
+    def method_missing(method_name, *args)
+        super if (@keepass.nil?)
+
+        case method_name.to_s.gsub(/^copy_(.+)_to_clipboard$/, "\\1")
+        when "password"
+            @keepass.copy_to_clipboard(password)
+        when "url"
+            @keepass.copy_to_clipboard(@url)
+        when "username"
+            @keepass.copy_to_clipboard(@username)
+        else
+            super
+        end
+    end
+
+    def password
+        return nil if (@keepass.nil?)
+        return @keepass.protected_decryptor.get_password(@password)
+    end
+
+    def to_s
+        return details
+    end
+end