ruby-keepassx 0.2.0beta11

data/lib/keepassx/entry.rb

@@ -0,0 +1,155 @@
+# 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:
+#   * 0000: Invalid or comment block, block is ignored
+#   * 0001: UUID, uniquely identifying an entry, FIELDSIZE must be 16
+#   * 0002: Group ID, identifying the group of the entry, FIELDSIZE = 4
+#           It can be any 32-bit value except 0 and 0xFFFFFFFF
+#   * 0003: Image ID, identifying the image/icon of the entry, FIELDSIZE = 4
+#   * 0004: Title of the entry, FIELDDATA is an UTF-8 encoded string
+#   * 0005: URL string, FIELDDATA is an UTF-8 encoded string
+#   * 0006: UserName string, FIELDDATA is an UTF-8 encoded string
+#   * 0007: Password string, FIELDDATA is an UTF-8 encoded string
+#   * 0008: Notes string, FIELDDATA is an UTF-8 encoded string
+#   * 0009: Creation time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 000A: Last modification time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 000B: Last access time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 000C: Expiration time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 000D: Binary description UTF-8 encoded string
+#   * 000E: Binary data
+#   * FFFF: Entry terminator, FIELDSIZE must be 0
+#   '''
+
+module Keepassx
+
+  class Entry
+
+    include Item
+
+    FIELD_CLASS   = Keepassx::EntryField
+    FIELD_MAPPING = {
+        :title       => :title,
+        :icon        => :imageid,
+        :lastmod     => :last_mod_time,
+        :lastaccess  => :last_acc_time,
+        :creation    => :creation_time,
+        :expire      => :expiration_time,
+        :password    => :password,
+        :username    => :username,
+        :uuid        => :uuid,
+        :url         => :url,
+        :binary_desc => :binary_desc,
+        :binary_data => :binary_data,
+        :comment     => :notes,
+    }
+
+
+    def self.extract_from_payload(header, groups, payload)
+      items = []
+      header.entry_number.times do
+        entry       = Entry.new(payload)
+        entry.group = groups.detect { |g| g.id.eql? entry.group_id }
+        items << entry
+      end
+      items
+    end
+
+
+    def self.fields
+      FIELD_MAPPING.keys
+    end
+
+
+    def initialize(payload)
+      super
+
+      if payload.is_a? StringIO
+        decode payload
+
+      elsif payload.is_a? Hash
+        fail "'title' is required" if payload[:title].nil?
+        fail "'group' is required" if payload[:group].nil?
+        self.group = payload[:group]
+
+        fields =  self.class.fields
+        data = payload.reject { |k, _| !fields.include? k }
+        data[:group_id] = group.id
+
+        @fields = []
+        default_fields.merge(data).each do |k, v|
+          fail "Unknown field: '#{k}'" unless self.respond_to? "#{k}=", true
+          @fields << self.send("#{k}=", v)
+        end
+
+      else
+        fail "Expecting StringIO or Hash, got #{payload.class}"
+      end
+    end
+
+
+    attr_reader :group
+
+
+    def group= v
+      if v.is_a? Keepassx::Group
+        self.group_id = v.id
+        @group        = v
+      else
+        fail "Expected Keepassx::Group, got #{v.class}"
+      end
+    end
+
+
+    def group_id
+      get :groupid
+    end
+
+
+    FIELD_MAPPING.each do |method, field|
+      define_method method do
+        get field
+      end
+
+      define_method "#{method}=" do |v|
+        set field, v
+      end
+    end
+
+
+    private
+
+    def default_fields
+      @default_fields ||= {
+          :uuid        => SecureRandom.uuid,
+          :group_id    => nil,
+          :icon        => 1,
+          :title       => nil,
+          :url         => nil,
+          :username    => nil,
+          :password    => nil,
+          :comment     => nil,
+          :creation    => Time.now,
+          :lastmod     => Time.now,
+          :lastaccess  => Time.now,
+          :expire      => Time.local(2999, 12, 28, 23, 59, 59),
+          :binary_desc => nil,
+          :binary_data => nil,
+          :terminator  => nil
+      }
+    end
+
+
+    # Keep this method private in order to avoid group/group_id divergence
+    def group_id= v
+      set :groupid, v
+    end
+
+  end
+end

data/lib/keepassx/entry_field.rb

@@ -0,0 +1,27 @@
+module Keepassx
+  class EntryField
+    include Field
+
+    FIELD_TYPES = [
+        [0x0, 'ignored', :null],
+        [0x1, 'uuid', :ascii],
+        [0x2, 'groupid', :int],
+        [0x3, 'imageid', :int],
+        [0x4, 'title', :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]
+    ]
+
+    attr_reader :name, :data_type, :type_code
+
+  end
+end

data/lib/keepassx/exceptions.rb

@@ -0,0 +1,4 @@
+module Keepassx
+  class HashError < StandardError; end
+  class MalformedDataError < StandardError; end
+end

data/lib/keepassx/field.rb

@@ -0,0 +1,205 @@
+module Keepassx
+
+  module Field
+
+    # FIELD_TERMINATOR = 0xFFFF # FIXME: Use it or remove it
+    TYPE_CODE_FIELD_SIZE = 2 # unsigned short integer
+    DATA_LENGTH_FIELD_SIZE = 4 # unsigned integer
+
+
+    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 = parse_type_code
+        fail "Failed to determine field name from '#{payload.inspect}'" if
+            @name.nil?
+        fail "Failed to determine field typefrom '#{payload.inspect}'" if
+            @data_type.nil?
+        # Not using setter because it should be raw data here
+        @data = payload.read(data_length) unless terminator?
+        set_export_import_methods
+
+      elsif payload.is_a? Hash
+        @name = payload[:name].to_s
+        type_set = self.class::FIELD_TYPES.detect do |_, name, _|
+          name.eql? @name.to_s
+        end
+        @type_code, _, @data_type = type_set
+
+        set_export_import_methods
+        self.data = payload[:data]
+      end
+
+    rescue NoMethodError => e
+      raise Keepassx::MalformedDataError.
+          new "Read error at #{payload.lineno}" if e.name.eql? :unpack
+      # fail
+    end
+
+
+    def encode
+      buffer = [@type_code, size].pack 'SI'
+      buffer << @data unless @data.nil? # Writing raw data
+      # [buffer].pack "a#{size}"
+      buffer
+    end
+
+
+    def terminator?
+      @name.eql? 'terminator'
+    end
+
+
+    # Return raw data length
+    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 data
+        self.send @export_method
+    end
+
+
+    def data= value
+        self.send @import_method, value
+    end
+
+
+    def raw
+      @data
+    end
+
+
+    private
+
+    def set_export_import_methods
+      @export_method = "#{@data_type}".to_sym
+      @import_method = "#{@data_type}=".to_sym
+    end
+
+
+    def parse_type_code
+      (_, name, data_type) = self.class::FIELD_TYPES.detect do |(code, *rest)|
+        code == @type_code
+      end
+      [name, data_type]
+    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
+
+
+    def null
+      nil
+    end
+
+
+    def shunt
+      @data
+    end
+
+
+    def string= value
+      @data = "#{value}\000"
+      # @data.force_encoding 'ASCII-8BIT' if @data.respond_to? :force_encoding
+    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
+      fail "Expected: Time, String or Fixnum, got: '#{value.class}'." unless
+          [Time, String, Fixnum].include? value.class
+
+      value = Time.parse value if value.is_a? String
+      value = Time.at value if value.is_a? Fixnum
+
+      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
+
+
+    def null= _
+      @data = nil
+    end
+
+
+    def shunt= value
+      @data = value
+    end
+
+  end
+end

data/lib/keepassx/group.rb

@@ -0,0 +1,138 @@
+# One group: [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:
+#   * 0000: Invalid or comment block, block is ignored
+#   * 0001: Group ID, FIELDSIZE must be 4 bytes
+#           It can be any 32-bit value except 0 and 0xFFFFFFFF
+#   * 0002: Group name, FIELDDATA is an UTF-8 encoded string
+#   * 0003: Creation time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 0004: Last modification time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 0005: Last access time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 0006: Expiration time, FIELDSIZE = 5, FIELDDATA = packed date/time
+#   * 0007: Image ID, FIELDSIZE must be 4 bytes
+#   * 0008: Level, FIELDSIZE = 2
+#   * 0009: Flags, 32-bit value, FIELDSIZE = 4
+#   * FFFF: Group entry terminator, FIELDSIZE must be 0
+module Keepassx
+
+  class Group
+
+    include Item
+
+    FIELD_CLASS   = Keepassx::GroupField
+    FIELD_MAPPING = {
+        :id         => :groupid,
+        :title      => :group_name,
+        :icon       => :imageid,
+        :lastmod    => :lastmod_time,
+        :lastaccess => :lastacc_time,
+        :creation   => :creation_time,
+        :expire     => :expire_time,
+        :level      => :level,
+        :flags      => :flags
+    }
+
+
+    def self.extract_from_payload(header, payload_io)
+      groups = []
+      header.group_number.times { groups << Group.new(payload_io) }
+      groups
+    end
+
+    # return
+    def self.fields
+      FIELD_MAPPING.keys
+    end
+
+
+    attr_reader :parent
+
+
+    def initialize payload
+      super
+
+      if payload.is_a? StringIO
+        decode payload
+
+      elsif payload.is_a? Hash
+        fail "'title' is required" if payload[:title].nil?
+        fail "'id' is required" if payload[:id].nil?
+
+        group_parent = payload.delete :parent
+        @fields      = []
+        default_fields.merge(payload).each do |k, v|
+          @fields << self.send("#{k.to_s}=", v)
+        end
+
+        self.parent = group_parent
+
+      else
+        fail "Expected StringIO or Hash, got #{payload.class}"
+      end
+    end
+
+
+    FIELD_MAPPING.each do |method, field|
+      define_method method do
+        get field
+      end
+
+      define_method "#{method}=" do |v|
+        set field, v
+      end
+    end
+
+
+    def parent= v
+      if v.is_a? Keepassx::Group
+        self.level = v.level + 1 # FIXME: If parent is nil, then set level to 0
+        @parent    = v
+
+      elsif v.nil?
+        self.level = 0 # Assume group located on top level if has no parent
+
+      else
+        fail "Expected Keepassx::Group, got #{v.class}"
+      end
+    end
+
+
+    def level
+      value = get :level
+      value.nil? ? 0 : value
+    end
+
+
+    private
+
+    def level= v
+      set :level, v
+    end
+
+
+    def default_fields
+      @default_field ||= {
+          :id         => :unknown,
+          :title      => :unknown,
+          :icon       => 1,
+          # Group's timestamps does not make sense to me,
+          # hence removing that from defaults
+          # :creation   => Time.now,
+          # :lastmod    => Time.now,
+          # :lastaccess => Time.now,
+          # :expire     => Time.local(2999, 12, 28, 23, 59, 59),
+          :level      => 0,
+          :flags      => 0,
+          :terminator => nil
+      }
+    end
+
+  end
+end