keepassx 0.1.0 → 1.0.0

data/lib/keepassx/field/base.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Keepassx
+  module Field
+    class Base
+
+      FIELD_TERMINATOR       = 0xFFFF
+      TYPE_CODE_FIELD_SIZE   = 2 # unsigned short integer
+      DATA_LENGTH_FIELD_SIZE = 4 # unsigned integer
+
+      attr_reader :name, :data_type, :type_code
+
+
+      def initialize(payload)
+        if payload.is_a?(StringIO)
+          @type_code, data_length = payload.read(TYPE_CODE_FIELD_SIZE + DATA_LENGTH_FIELD_SIZE).unpack('SI')
+          _, @name, @data_type = self.class.fields_description.find { |type_code, _, _| type_code == @type_code }
+
+          # Not using setter because it should be raw data here
+          @data = payload.read(data_length)
+
+          # Set export_import_methods *after* setting data
+          set_export_import_methods(@data_type)
+
+        elsif payload.is_a?(Hash)
+          @name = payload[:name].to_s
+          @type_code, _, @data_type = self.class.fields_description.find { |_, name, _| name == @name }
+
+          # Set export_import_methods *before* setting data
+          set_export_import_methods(@data_type)
+
+          # Using setter because we need to convert data here
+          self.data = payload[:data]
+        end
+      end
+
+
+      def data
+        send(@export_method)
+      end
+
+
+      def data=(value)
+        send(@import_method, value)
+      end
+
+
+      def terminator?
+        name == 'terminator'
+      end
+
+
+      def length
+        TYPE_CODE_FIELD_SIZE + DATA_LENGTH_FIELD_SIZE + size
+      end
+
+
+      def size
+        case data_type
+        when :null
+          0
+        when :int
+          4
+        when :date
+          5
+        when :uuid
+          16
+        else
+          (@data.nil? && 0) || @data.length
+        end
+      end
+
+
+      def encode
+        buffer = [type_code, size].pack 'SI'
+        buffer << @data unless @data.nil?
+        buffer
+      end
+
+
+      private
+
+
+        # rubocop:disable Style/UnneededInterpolation
+        def set_export_import_methods(type)
+          @export_method = "#{type}".to_sym
+          @import_method = "#{type}=".to_sym
+        end
+        # rubocop:enable Style/UnneededInterpolation
+
+
+        ### EXPORT METHODS
+
+        def null
+          nil
+        end
+
+
+        def shunt
+          @data
+        end
+
+
+        def string
+          @data.chomp("\000")
+        end
+
+
+        def int
+          @data.unpack('I')[0]
+        end
+
+
+        def short
+          @data.unpack('S')[0]
+        end
+
+
+        def ascii
+          # TODO: Add spec
+          @data.unpack('H*')[0]
+        end
+
+
+        def date
+          buffer = @data.unpack('C5')
+          year   = (buffer[0] << 6) | (buffer[1] >> 2)
+          month  = ((buffer[1] & 0b11) << 2) | (buffer[2] >> 6)
+          day    = ((buffer[2] & 0b111111) >> 1)
+          hour   = ((buffer[2] & 0b1) << 4) | (buffer[3] >> 4)
+          min    = ((buffer[3] & 0b1111) << 2) | (buffer[4] >> 6)
+          sec    = ((buffer[4] & 0b111111))
+
+          Time.local(year, month, day, hour, min, sec)
+        end
+
+
+        ### IMPORT METHODS
+
+        # rubocop:disable Naming/UncommunicativeMethodParamName
+        def null=(_)
+          @data = nil
+        end
+        # rubocop:enable Naming/UncommunicativeMethodParamName
+
+
+        def shunt=(value)
+          @data = value
+        end
+
+
+        def string=(value)
+          @data = "#{value}\000"
+        end
+
+
+        def int=(value)
+          @data = [value].pack('I')
+        end
+
+
+        def short=(value)
+          @data = [value].pack('S')
+        end
+
+
+        def ascii=(value)
+          @data = [value].pack('H*')
+        end
+
+
+        def date=(value)
+          raise ArgumentError, "Expected: Time, String or Integer, got: '#{value.class}'." unless [Time, String, Integer].include?(value.class)
+
+          value = Time.parse(value) if value.is_a?(String)
+          value = Time.at(value) if value.is_a?(Integer)
+
+          sec, min, hour, day, month, year = value.to_a
+
+          @data = [
+            0x0000FFFF & ((year >> 6) & 0x0000003F),
+            0x0000FFFF & (((year & 0x0000003f) << 2) | ((month >> 2) & 0x00000003)),
+            0x0000FFFF & (((month & 0x00000003) << 6) | ((day & 0x0000001F) << 1) | ((hour >> 4) & 0x00000001)),
+            0x0000FFFF & (((hour & 0x0000000F) << 4) | ((min >> 2) & 0x0000000F)),
+            0x0000FFFF & (((min & 0x00000003) << 6) | (sec & 0x0000003F)),
+          ].pack('<C5')
+        end
+
+    end
+  end
+end

data/lib/keepassx/field/entry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Keepassx
+  module Field
+    class Entry < Base
+
+      # rubocop:disable Metrics/MethodLength
+      def self.fields_description
+        @fields_description ||= [
+          [0x0, 'ignored',         :null],
+          [0x1, 'id',              :ascii],
+          [0x2, 'group_id',        :int],
+          [0x3, 'icon',            :int],
+          [0x4, 'name',            :string],
+          [0x5, 'url',             :string],
+          [0x6, 'username',        :string],
+          [0x7, 'password',        :string],
+          [0x8, 'notes',           :string],
+          [0x9, 'creation_time',   :date],
+          [0xa, 'last_mod_time',   :date],
+          [0xb, 'last_acc_time',   :date],
+          [0xc, 'expiration_time', :date],
+          [0xd, 'binary_desc',     :string],
+          [0xe, 'binary_data',     :shunt],
+          [0xFFFF, 'terminator',   :null],
+        ]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+    end
+  end
+end

data/lib/keepassx/field/group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Keepassx
+  module Field
+    class Group < Base
+
+      # rubocop:disable Metrics/MethodLength
+      def self.fields_description
+        @fields_description ||= [
+          [0x0, 'ignored',         :null],
+          [0x1, 'id',              :int],
+          [0x2, 'name',            :string],
+          [0x3, 'creation_time',   :date],
+          [0x4, 'last_mod_time',   :date],
+          [0x5, 'last_acc_time',   :date],
+          [0x6, 'expiration_time', :date],
+          [0x7, 'icon',            :int],
+          [0x8, 'level',           :short],
+          [0x9, 'flags',           :int],
+          [0xFFFF, 'terminator',   :null],
+        ]
+      end
+      # rubocop:enable Metrics/MethodLength
+
+    end
+  end
+end

data/lib/keepassx/fieldable.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Keepassx
+  class Fieldable
+
+    attr_reader :fields
+
+    def initialize(payload)
+      @fields = []
+
+      if payload.is_a?(StringIO)
+        @fields = decode_payload(payload)
+      elsif payload.is_a?(Hash)
+        yield
+      else
+        raise ArgumentError, "Expected StringIO or Hash, got #{payload.class}"
+      end
+    end
+
+
+    class << self
+
+      attr_reader :field_descriptor
+
+      def set_field_descriptor(klass)
+        @field_descriptor = klass
+        create_fieldable_methods(klass.fields_description)
+      end
+
+
+      def create_fieldable_methods(methods)
+        methods.each do |_, method, _|
+          define_method method do
+            get method
+          end
+
+          define_method "#{method}=" do |v|
+            set method, v
+          end
+        end
+      end
+
+
+      # Return the list of fields' names
+      def fields
+        @fields ||= field_descriptor.fields_description.map { |_, name, _| name }
+      end
+
+    end
+
+
+    def length
+      fields.map(&:length).reduce(&:+)
+    end
+
+
+    def to_hash(opts = {})
+      skip_date = opts.fetch(:skip_date, false)
+
+      result = {}
+      fields.each do |field|
+        next if excluded_field?(field.name)
+        next if date_field?(field.name) && skip_date
+
+        result[field.name] = field.data
+      end
+      result
+    end
+
+
+    def encode
+      buffer = +''
+      fields.each do |field|
+        buffer << field.encode
+      end
+      buffer
+    end
+
+
+    def inspect
+      output = []
+      default_fields.each_key do |field_name|
+        if field_name == :password
+          output << 'password=[FILTERED]'
+        else
+          output << "#{field_name}=#{send(field_name)}" unless field_name == :terminator
+        end
+      end
+      "<#{self.class} #{output.join(', ')}>"
+    end
+
+
+    private
+
+
+      def decode_payload(payload)
+        fields = []
+
+        loop do
+          field = self.class.field_descriptor.new(payload)
+          fields << field
+          break if field.terminator?
+        end
+
+        fields
+      end
+
+
+      def build_payload(payload)
+        fields = []
+        default_fields.merge(payload).each do |k, v|
+          fields << self.class.field_descriptor.new(name: k, data: v)
+        end
+        fields
+      end
+
+
+      def valid_integer?(field)
+        field.is_a?(Integer)
+      end
+
+
+      def valid_string?(field)
+        field.is_a?(String) && !field.empty?
+      end
+
+
+      def get(name)
+        field = @fields.find { |f| f.name == name.to_s }
+        field&.data
+      end
+
+
+      def set(name, value)
+        field = @fields.find { |f| f.name == name.to_s }
+        if field.nil?
+          field = self.class.field_descriptor.new(name: name, data: value)
+          @fields << field
+        else
+          field.data = value
+        end
+        field
+      end
+
+
+      def excluded_field?(field)
+        exclusion_list.include?(field)
+      end
+
+
+      def exclusion_list
+        %w[terminator]
+      end
+
+
+      def date_field?(field)
+        %w[creation_time last_mod_time last_acc_time expiration_time].include?(field)
+      end
+
+  end
+end

data/lib/keepassx/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # One group: [FIELDTYPE(FT)][FIELDSIZE(FS)][FIELDDATA(FD)]
 #            [FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)][FT+FS+(FD)]...
 #
@@ -20,37 +22,108 @@
 #   * 0008: Level, FIELDSIZE = 2
 #   * 0009: Flags, 32-bit value, FIELDSIZE = 4
 #   * FFFF: Group entry terminator, FIELDSIZE must be 0
+
 module Keepassx
-  class Group
-    def self.extract_from_payload(header, payload_io)
-      groups = []
-      header.ngroups.times do
-        group = Group.new(payload_io)
-        groups << group
+  class Group < Fieldable
+
+    set_field_descriptor Keepassx::Field::Group
+
+    attr_accessor :entries
+    attr_reader   :parent
+
+    def initialize(payload)
+      @parent  = nil
+      @entries = []
+
+      super do
+        # Do some validation
+        raise ArgumentError, "'id' is required (type: integer)" unless valid_integer?(payload[:id])
+        raise ArgumentError, "'name' is required (type: string)" unless valid_string?(payload[:name])
+
+        # First set @parent and @level.
+        # Remove key from payload to not interfere with KeePassX fields format
+        self.parent = payload.delete(:parent)
+
+        # Build list of fields
+        @fields = build_payload(payload)
       end
-      groups
     end
 
-    def initialize(payload_io)
-      fields = []
-      begin
-        field = GroupField.new(payload_io)
-        fields << field
-      end while not field.terminator?
 
-      @fields = fields
+    class << self
+
+      def extract_from_payload(header, payload)
+        groups = []
+        header.groups_count.times { groups << Group.new(payload) }
+        groups
+      end
+
     end
 
-    def length
-      @fields.map(&:length).reduce(&:+)
+
+    def parent=(value)
+      raise ArgumentError, "Expected Keepassx::Group or nil, got #{value.class}" unless valid_parent?(value)
+
+      if value.is_a?(Keepassx::Group)
+        self.level = value.level + 1
+        @parent    = value
+
+      elsif value.nil?
+        # Assume, group is located at the top level, in case it has no parent
+        self.level = 0
+        @parent    = nil
+      end
     end
 
-    def group_id
-      @fields.detect { |field| field.name == 'groupid' }.data
+
+    # Redefine #level method to return 0 instead of nil
+    def level
+      value = get :level
+      value.nil? ? 0 : value
     end
 
-    def name
-      @fields.detect { |field| field.name == 'group_name' }.data.chomp("\000")
+
+    def ==(other)
+      return false if other.nil?
+
+      parent == other.parent  &&
+        name   == other.name  &&
+        id     == other.id    &&
+        level  == other.level &&
+        icon   == other.icon
     end
+
+
+    private
+
+
+      # Redefine #level= to make it private :
+      # Setting group level only is a non-sense as it depends
+      # on parent group.
+      def level=(value)
+        set :level, value
+      end
+
+
+      def default_fields
+        @default_fields ||= {
+          id:              :unknown,
+          name:            :unknown,
+          creation_time:   Time.now,
+          last_mod_time:   Time.now,
+          last_acc_time:   Time.now,
+          expiration_time: Time.local(2999, 12, 28, 23, 59, 59),
+          icon:            1,
+          level:           0,
+          flags:           0,
+          terminator:      nil,
+        }
+      end
+
+
+      def valid_parent?(object)
+        object.is_a?(Keepassx::Group) || object.nil?
+      end
+
   end
 end