keepassx 0.1.0 → 1.0.0

data/lib/keepassx/database/dumper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Keepassx
+  class Database
+    module Dumper
+
+      # Dump Array representation of database.
+      #
+      # @return [Array]
+      def to_a(opts = {})
+        result = []
+        find_groups(level: 0).each { |group| result << build_branch(group, opts) }
+        result
+      end
+
+
+      # Dump YAML representation of database.
+      #
+      # @return [String]
+      def to_yaml(opts = {})
+        YAML.dump to_a(opts)
+      end
+
+
+      # Save database to file storage
+      #
+      # @param password [String] Password the database will be encoded with.
+      # @return [Fixnum]
+      def save(opts = {})
+        path     = opts.delete(:path) { nil }
+        password = opts.delete(:password) { nil }
+
+        new_path     = path || @path
+        new_password = password || @password
+
+        raise ArgumentError, 'File path is not set' if new_path.nil?
+        raise ArgumentError, 'Password is not set' if new_password.nil?
+
+        File.open(new_path, 'wb') do |file|
+          file.write dump(new_password)
+        end
+      end
+
+
+      private
+
+
+        # Get raw encoded database.
+        #
+        # @param password [String] Password the database will be encoded with.
+        # @param key_file [String] Path to key file.
+        # @return [String]
+        def dump(password)
+          final_key = header.final_key(password)
+          initialize_payload
+          header.content_hash = checksum
+          @encrypted_payload  = encrypt_payload(@payload, final_key)
+          data = header.encode << @encrypted_payload.to_s
+          data
+        end
+
+
+        # Organize descendants in proper structure for given group.
+        # @param [Keepassx::Group] group Root group, branch is build for.
+        def build_branch(group, opts = {})
+          group_hash = group.to_hash(opts)
+
+          group_entries = find_entries(group: group)
+          descendant_groups = find_groups(parent: group)
+
+          unless group_entries.nil?
+            group_hash['entries'] = []
+            group_entries.each { |e| group_hash['entries'] << e.to_hash(opts) }
+          end
+
+          unless descendant_groups.nil?
+            group_hash['groups'] = []
+            # Recursively build branch for descendant groups
+            descendant_groups.each { |g| group_hash['groups'] << build_branch(g, opts) }
+          end
+
+          group_hash
+        end
+
+    end
+  end
+end

data/lib/keepassx/database/finder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Keepassx
+  class Database
+    module Finder
+
+      # Get the first matching entry.
+      #
+      # @return [Keepassx::Entry]
+      def find_entry(opts = {}, &block)
+        entries = find_entries(opts, &block)
+        filter_list(entries)
+      end
+
+
+      # Get the first matching group.
+      #
+      # @return [Keepassx::Group]
+      def find_group(opts = {}, &block)
+        groups = find_groups(opts, &block)
+        filter_list(groups)
+      end
+
+
+      # Get all matching groups.
+      #
+      # @param opts [Hash]
+      # @return [Array<Keepassx::Group>]
+      def find_groups(opts = {}, &block)
+        find :group, opts, &block
+      end
+
+
+      # Get all matching entries.
+      #
+      # @return [Array<Keepassx::Entry>]
+      def find_entries(opts = {}, &block)
+        find :entry, opts, &block
+      end
+
+
+      def search(pattern)
+        backup = groups.find { |g| g.name == 'Backup' }
+        backup_group_id = backup&.id
+        entries.select { |e| e.group_id != backup_group_id && e.name =~ /#{pattern}/i }
+      end
+
+
+      private
+
+
+        # Search for items, using AND statement for the search conditions
+        #
+        # @param item_type [Symbol] Can be :entry or :group.
+        # @param opts [Hash] Search options.
+        # @return [Keepassx::Group, Keepassx::Entry]
+        def find(item_type, opts = {})
+          item_list = item_type == :entry ? @entries : @groups
+          items     = opts.empty? ? item_list : deep_search(item_list, opts)
+
+          return items unless block_given?
+
+          items.each do |i|
+            yield i
+          end
+        end
+
+
+        # rubocop:disable Metrics/MethodLength
+        def deep_search(item_list, opts = {})
+          opts = { name: opts.to_s } if opts.is_a?(String) || opts.is_a?(Symbol)
+
+          match_number = opts.length
+
+          items = []
+          opts.each do |k, v|
+            items += Array(item_list.select { |e| e.send(k) == v })
+          end
+
+          buffer = Hash.new 0
+          items.each do |e|
+            buffer[e] += 1
+          end
+
+          # Select only items which matches all conditions
+          items = []
+          buffer.each do |k, v|
+            items << k if v == match_number
+          end
+
+          items
+        end
+        # rubocop:enable Metrics/MethodLength
+
+
+        def filter_list(list)
+          list.empty? ? nil : list.first
+        end
+
+    end
+  end
+end

data/lib/keepassx/database/loader.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Keepassx
+  class Database
+    module Loader
+
+      attr_reader :header
+      attr_reader :groups
+      attr_reader :entries
+
+      # rubocop:disable Metrics/MethodLength
+      def initialize(opts)
+        @password = nil
+        @groups   = []
+        @entries  = []
+        raw_db    = ''
+
+        if opts.is_a?(File)
+          @path  = opts.path
+          raw_db = read_file(opts)
+          load_database(raw_db)
+
+        elsif opts.is_a?(String)
+          @path  = opts
+          raw_db = read_file(opts) if File.exist?(opts)
+          load_database(raw_db)
+
+        elsif opts.is_a?(Array)
+          @path = nil
+          load_database(raw_db)
+          opts.each { |item| parse_data(item) }
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+
+      # Unlock database.
+      #
+      # @param password [String] Database password.
+      # @return [Boolean] Whether or not password validation successfull.
+      # rubocop:disable Metrics/MethodLength
+      def unlock(password, keyfile = nil)
+        return true unless locked?
+
+        # Store password as we'll need it to dump/save database
+        @password = password
+        keyfile_data = keyfile ? read_file(keyfile) : nil
+
+        # Uncrypt database
+        final_key  = header.final_key(password, keyfile_data)
+        @payload   = decrypt_payload(@encrypted_payload, final_key)
+        payload_io = StringIO.new(@payload)
+
+        # Load it
+        groups   = Group.extract_from_payload(header, payload_io)
+        @groups  = initialize_groups(groups)
+        @entries = Entry.extract_from_payload(header, payload_io)
+
+        # Make groups <-> entries association
+        @entries.each do |entry|
+          group = @groups.detect { |g| g.id == entry.group_id }
+          group.entries << entry
+          entry.group = group
+        end
+
+        @locked = false
+
+        true
+      rescue OpenSSL::Cipher::CipherError
+        false
+      end
+      # rubocop:enable Metrics/MethodLength
+
+
+      # Get actual payload checksum.
+      #
+      # @return [String]
+      def checksum
+        Digest::SHA256.digest(payload)
+      end
+
+
+      def payload
+        @payload ||= initialize_payload
+      end
+
+
+      # Get Entries and Groups total number.
+      #
+      # @return [Fixnum]
+      def length
+        length = 0
+        [@groups, @entries].each do |items|
+          items.each do |item|
+            length += item.length
+          end
+        end
+        length
+      end
+
+
+      private
+
+
+        def read_file(file)
+          read_method = File.respond_to?(:binread) && :binread || :read
+          File.send(read_method, file)
+        end
+
+
+        def load_database(db)
+          if db.empty?
+            @header            = Header.new
+            @encrypted_payload = ''
+            @locked            = false
+          else
+            @header            = Header.new(db[0..124])
+            @encrypted_payload = db[124..-1]
+            @locked            = true
+          end
+
+          @locked
+        end
+
+
+        # See spec/fixtures/test_data_array.yaml for data example
+        # rubocop:disable Metrics/MethodLength
+        def parse_data(opts)
+          groups  = opts[:groups]  || []
+          entries = opts[:entries] || []
+          parent  = opts[:parent]
+
+          # Remove groups and entries from options, so new group could be
+          # initialized from incoming Hash
+          fields          = Keepassx::Group.fields
+          group_opts      = opts.select { |k, _| fields.include?(k.to_s) }
+          group           = add_group group_opts
+          group.parent    = parent
+
+          entries.each do |e|
+            add_entry e.merge(group: group)
+          end
+
+          # Recursively proceed each child group
+          groups.each do |g|
+            parse_data g.merge(parent: group)
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+
+        def decrypt_payload(payload, final_key)
+          AESCrypt.decrypt(payload, final_key, header.encryption_iv, 'AES-256-CBC')
+        end
+
+
+        def encrypt_payload(payload, final_key)
+          AESCrypt.encrypt(payload, final_key, header.encryption_iv, 'AES-256-CBC')
+        end
+
+
+        # Set parents for groups
+        #
+        #  @param list [Array] Array of groups.
+        #  @return [Array] Updated array of groups.
+        # rubocop:disable Metrics/MethodLength
+        def initialize_groups(list)
+          list.each_with_index do |group, index|
+            previous_group = index == 0 ? nil : list[index - 1]
+
+            # If group is first entry or has level equal 0,
+            # it gets parent set to nil
+            if previous_group.nil? || group.level == 0
+              group.parent = nil
+
+            # If group has same level than the previous group,
+            # then is has the same parent
+            elsif group.level == previous_group.level
+              group.parent = previous_group.parent
+
+            # If group has level greater than parent's level by one,
+            # it gets parent set to the first previous group with level less
+            # than group's level by one
+            elsif group.level == previous_group.level + 1
+              group.parent = previous_group
+
+            # If group has level less than or equal the level of the previous
+            # group and its level is no less than zero, then need to backward
+            # search for the first group which level is less than group's
+            # level by 1 and set it as a parent of the group
+            elsif group.level > 0 && group.level <= previous_group.level
+              group.parent = (index - 2).downto 0 do |i|
+                parent_candidate = list[i]
+                break parent_candidate if parent_candidate.level + 1 == group.level
+              end
+
+            # Invalid level
+            else
+              raise "Unexpected level '#{group.level}' for group '#{group.name}'"
+            end
+          end
+
+          list
+        end
+        # rubocop:enable Metrics/MethodLength
+
+
+        def initialize_payload
+          result = +''
+          @groups.each { |group| result << group.encode }
+          @entries.each { |entry| result << entry.encode }
+          result
+        end
+
+    end
+  end
+end

data/lib/keepassx/entry.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # One entry: [FIELDTYPE(FT)][FIELDSIZE(FS)][FIELDDATA(FD)]
 #            [FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)]...
-
+#
 # [ 2 bytes] FIELDTYPE
 # [ 4 bytes] FIELDSIZE, size of FIELDDATA in bytes
 # [ n bytes] FIELDDATA, n = FIELDSIZE
-
+#
 # Notes:
 # - Strings are stored in UTF-8 encoded form and are null-terminated.
 # - FIELDTYPE can be one of the following identifiers:
@@ -25,57 +27,87 @@
 #   * 000D: Binary description UTF-8 encoded string
 #   * 000E: Binary data
 #   * FFFF: Entry terminator, FIELDSIZE must be 0
-#   '''
 
 module Keepassx
-  class Entry
-    def self.extract_from_payload(header, payload_io)
-      groups = []
-      header.nentries.times do
-        group = Entry.new(payload_io)
-        groups << group
+  class Entry < Fieldable
+
+    set_field_descriptor Keepassx::Field::Entry
+
+    attr_reader :group
+
+    def initialize(payload)
+      super do
+        # Do some validation
+        raise ArgumentError, "'name' is required (type: string)" unless valid_string?(payload[:name])
+        raise ArgumentError, "'group_id' is required (type: integer)" unless payload[:group] || valid_integer?(payload[:group_id])
+
+        # First set @group and @group_id.
+        # Remove key from payload to not interfere with KeePassX fields format
+        self.group = payload.delete(:group)
+
+        # Add group_id key to respect KeePassX fields format
+        payload[:group_id] = group.id
+
+        # Build list of fields
+        @fields = build_payload(payload)
       end
-      groups
     end
 
-    attr_reader :fields
 
-    def initialize(payload_io)
-      fields = []
-      begin
-        field = EntryField.new(payload_io)
-        fields << field
-      end while not field.terminator?
+    class << self
 
-      @fields = fields
-    end
+      def extract_from_payload(header, payload)
+        entries = []
+        header.entries_count.times { entries << Entry.new(payload) }
+        entries
+      end
 
-    def length
-      @fields.map(&:length).reduce(&:+)
     end
 
-    def notes
-      @fields.detect { |field| field.name == 'notes' }.data.chomp("\000")
-    end
 
-    def password
-      @fields.detect { |field| field.name == 'password' }.data.chomp("\000")
-    end
+    def group=(value)
+      raise ArgumentError, "Expected Keepassx::Group, got #{value.class}" unless value.is_a?(Keepassx::Group)
 
-    def title
-      @fields.detect { |field| field.name == 'title' }.data.chomp("\000")
+      self.group_id = value.id
+      @group        = value
     end
 
-    def username
-      @fields.detect { |field| field.name == 'username' }.data.chomp("\000")
-    end
 
-    def group_id
-      @fields.detect { |field| field.name == 'groupid' }.data
-    end
+    private
+
+
+      # rubocop:disable Metrics/MethodLength
+      def default_fields
+        @default_fields ||= {
+          id:              SecureRandom.uuid.gsub('-', ''),
+          group_id:        nil,
+          icon:            1,
+          name:            nil,
+          url:             nil,
+          username:        nil,
+          password:        nil,
+          notes:           nil,
+          creation_time:   Time.now,
+          last_mod_time:   Time.now,
+          last_acc_time:   Time.now,
+          expiration_time: Time.local(2999, 12, 28, 23, 59, 59),
+          binary_desc:     nil,
+          binary_data:     nil,
+          terminator:      nil,
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+
+      # Keep this method private in order to avoid group/group_id divergence
+      def group_id=(value)
+        set :group_id, value
+      end
+
+
+      def exclusion_list
+        super.concat(%w[binary_desc binary_data])
+      end
 
-    def inspect
-      "Entry<title=#{title.inspect}, username=[FILTERED], password=[FILTERED], notes=#{notes.inspect}>"
-    end
   end
 end