rubeepass 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 369d21017f882fa9c9f7255640b6d498a0990a00
-  data.tar.gz: a48d53c24ce87d35611e13af2ced5e9bd1585ca4
+  metadata.gz: 198fd42f6442a724c48c2e9fed48dde20d381ce6
+  data.tar.gz: 632b3d39273d942925b56139da529b35a08ec2f4
 SHA512:
-  metadata.gz: de43b254efde377d3efcc245715125edc28bfcf18b697823be773bf303a189142024f1f8428bab73828c8595fde3b31c53dc161a3d6136c1ba79689f08396e0f
-  data.tar.gz: bc39deec9c478d2df9570b0158385669f6587fbf484e42788332dc8e26ca82a1a7cd6870c6fae294466bf15ed508c25f9dc21f2a92833a96836918cd84410122
+  metadata.gz: 1f1dc4135f2c8d9de6cc409ea99c44f0b2c4d78a2001c63ca2047639c7613bb9e458939604d1e3af6b2bab151b4a2fba329f799dde7c3a344ae1aa1f408791eb
+  data.tar.gz: 510391ec34652bfea7b32895d3d3b82c8727d9077c12cac06bd09875fe257e505fcb216870290ded1f3d083210cbc9f0a77e3045ed59c0bc374030016b11c08d

data/lib/rubeepass/entry.rb

@@ -1,3 +1,4 @@
+require "rexml/document"
 require "string"
 
 class RubeePass::Entry
@@ -43,15 +44,90 @@ class RubeePass::Entry
         return ret.join("\n")
     end
 
-    def initialize(params)
-        @group = params.fetch("Group", nil)
-        @keepass = params.fetch("Keepass", nil)
-        @notes = params.fetch("Notes", "")
-        @password = params.fetch("Password", "")
-        @title = params.fetch("Title", "")
-        @url = params.fetch("URL", "")
-        @username = params.fetch("UserName", "")
-        @uuid = params.fetch("UUID", "")
+    def self.from_xml(keepass, parent, xml)
+        notes = ""
+        password = ""
+        title = ""
+        url = ""
+        username = ""
+
+        uuid = xml.elements["UUID"].text
+        uuid = "" if (uuid.nil?)
+
+        xml.elements.each("String") do |elem|
+            case elem.elements["Key"].text
+            when "Notes"
+                notes = elem.elements["Value"].text
+                notes = "" if (notes.nil?)
+            when "Password"
+                value = elem.elements["Value"]
+                if (value.attributes["Protected"] == "True")
+                    password = handle_protected(keepass, value.text)
+                else
+                    password = value.text
+                    password = "" if (password.nil?)
+                end
+            when "Title"
+                title = elem.elements["Value"].text
+                title = "" if (title.nil?)
+            when "URL"
+                url = elem.elements["Value"].text
+                url = "" if (url.nil?)
+            when "UserName"
+                username = elem.elements["Value"].text
+                username = "" if (username.nil?)
+            end
+        end
+
+        # Handle protected data from history
+        xml.elements.each("History/Entry/String/Value") do |value|
+            if (value.attributes["Protected"] == "True")
+                handle_protected(keepass, value.text)
+            end
+        end
+
+        return RubeePass::Entry.new(
+            parent,
+            keepass,
+            notes,
+            password,
+            title,
+            url,
+            username,
+            uuid
+        )
+    end
+
+    def self.handle_protected(keepass, base64)
+        data = nil
+        begin
+            data = base64.unpack("m*")[0].fix
+        rescue ArgumentError => e
+            raise Error::InvalidProtectedDataError.new
+        end
+        raise Error::InvalidProtectedDataError.new if (data.nil?)
+
+        return keepass.protected_decryptor.add_to_stream(data)
+    end
+
+    def initialize(
+        group,
+        keepass,
+        notes,
+        password,
+        title,
+        url,
+        username,
+        uuid
+    )
+        @group = group
+        @keepass = keepass
+        @notes = notes
+        @password = password
+        @title = title
+        @url = url
+        @username = username
+        @uuid = uuid
 
         @path = @title
         @path = "#{@group.path}/#{@title}" if (@group)
@@ -95,7 +171,9 @@ class RubeePass::Entry
     def password
         return nil if (@keepass.nil?)
         begin
-            return @keepass.protected_decryptor.get_password(@password)
+            return @keepass.protected_decryptor.get_password(
+                @password
+            )
         rescue
             return @password
         end

data/lib/rubeepass/error/invalid_xml_error.rb

@@ -0,0 +1,7 @@
+require "rubeepass/error"
+
+class RubeePass::Error::InvalidXMLError < RubeePass::Error
+    def initialize
+        super("Invalid xml schema!")
+    end
+end

data/lib/rubeepass/error.rb

@@ -8,5 +8,6 @@ require "rubeepass/error/invalid_password_error"
 require "rubeepass/error/invalid_protected_data_error"
 require "rubeepass/error/invalid_protected_stream_key_error"
 require "rubeepass/error/invalid_version_error"
+require "rubeepass/error/invalid_xml_error"
 require "rubeepass/error/not_aes_error"
 require "rubeepass/error/not_salsa20_error"

data/lib/rubeepass/group.rb

@@ -1,3 +1,4 @@
+require "rexml/document"
 require "string"
 
 class RubeePass::Group
@@ -23,8 +24,8 @@ class RubeePass::Group
         out = Array.new
         lvl = Array.new(level, "  ").join
 
-        group_details = [ "#{@name}".blue ]
-        group_details[0] = "#{@path}".blue if (level == 0)
+        group_details = [ "#{@path}".blue ] if (level == 0)
+        group_details = [ "#{@name}".blue ] if (level != 0)
 
         group_details.each do |line|
             out.push("#{lvl}#{line}")
@@ -63,6 +64,52 @@ class RubeePass::Group
         return cwd
     end
 
+    def self.from_xml(keepass, parent, xml)
+        name = xml.elements["Name"].text if (parent)
+        name = "" if (name.nil?)
+        name = "/" if (parent.nil?)
+
+        notes = xml.elements["Notes"].text if (parent)
+        notes = "" if (notes.nil?)
+        notes = "" if (parent.nil?)
+
+        uuid = xml.elements["UUID"].text if (parent)
+        uuid = "" if (uuid.nil?)
+        uuid = "" if (parent.nil?)
+
+        group = RubeePass::Group.new(
+            parent,
+            keepass,
+            name,
+            notes,
+            uuid
+        )
+
+        if (xml.elements["Entry"])
+            xml.elements.each("Entry") do |entry_xml|
+                entry = RubeePass::Entry.from_xml(
+                    keepass,
+                    group,
+                    entry_xml
+                )
+                group.entries[entry.title] = entry
+            end
+        end
+
+        if (xml.elements["Group"])
+            xml.elements.each("Group") do |group_xml|
+                child = RubeePass::Group.from_xml(
+                    keepass,
+                    group,
+                    group_xml
+                )
+                group.groups[child.name] = child
+            end
+        end
+
+        return group
+    end
+
     def fuzzy_find(input)
         return [ [], [], [] ] if (@keepass.nil?)
 
@@ -114,13 +161,14 @@ class RubeePass::Group
         return false
     end
 
-    def initialize(params)
+    def initialize(group, keepass, name, notes, uuid)
         @entries = Hash.new
-        @group = params.fetch("Group", nil)
+        @group = group
         @groups = Hash.new
-        @keepass = params.fetch("Keepass", nil)
-        @name = params.fetch("Name", "")
-        @uuid = params.fetch("UUID", "")
+        @keepass = keepass
+        @name = name
+        @notes = notes
+        @uuid = uuid
 
         @path = @name
         @path = "#{@group.path}/#{@name}" if (@group)

data/lib/rubeepass.rb

@@ -2,6 +2,7 @@ require "cgi"
 require "digest"
 require "openssl"
 require "os"
+require "rexml/document"
 require "scoobydoo"
 require "shellwords"
 require "uri"
@@ -169,19 +170,6 @@ class RubeePass
         return @db.fuzzy_find(input)
     end
 
-    def handle_protected(base64)
-        data = nil
-        begin
-            data = base64.unpack("m*")[0].fix
-        rescue ArgumentError => e
-            raise Error::InvalidProtectedDataError.new
-        end
-        raise Error::InvalidProtectedDataError.new if (data.nil?)
-
-        return @protected_decryptor.add_to_stream(data)
-    end
-    private :handle_protected
-
     def initialize(kdbx, password, keyfile = nil)
         @kdbx = kdbx
         @keyfile = keyfile
@@ -316,104 +304,14 @@ class RubeePass
     end
     private :parse_gzip
 
-    # Horrible attempt at parsing xml. Someday I might use a library.
     def parse_xml
-        curr = Group.new({"Keepass" => self, "Name" => "/"})
-        entry_params = Hash.new
-        group_params = Hash.new
-        ignore = true
-        inside_value = false
-        status = nil
-
-        @xml.gsub("<", "\n<").each_line do |line|
-            line.strip!
-
-            case line
-            when "<History>"
-                ignore = true
-                next
-            when "</History>"
-                ignore = false
-                next
-            when "<Root>"
-                ignore = false
-                next
-            when "</Root>"
-                break
-            when "</Value>"
-                status = nil
-                inside_value = false
-                next
-            when ""
-                next if (!inside_value)
-            end
-
-            line = CGI::unescapeHTML(line)
-            line = URI::unescape(line)
-            if (!line.valid_encoding?)
-                line = line.encode(
-                    "UTF-16be",
-                    :invalid=>:replace,
-                    :replace=>"?"
-                ).encode('UTF-8')
-            end
-
-            # Handle values with newlines
-            if (inside_value && !ignore)
-                entry_params[status] += "\n#{line}"
-                next
-            end
-
-            # Always handle protected data
-            case line
-            when %r{^<Value Protected="True">.+}
-                line.gsub!(%r{^<Value Protected="True">}, "")
-                if (ignore)
-                    handle_protected(line)
-                else
-                    entry_params[status] = handle_protected(line)
-                end
-                next
-            else
-                next if (ignore)
-            end
-
-            case line
-            when "<Entry>"
-                entry_params = { "Keepass" => self, "Group" => curr }
-            when "</Entry>"
-                entry = Entry.new(entry_params)
-                curr.entries[entry.title] = entry
-            when "<Group>"
-                group_params = { "Keepass" => self, "Group" => curr }
-            when "</Group>"
-                curr = curr.group
-                break if (curr.nil?)
-            when %r{^<Key>.+}
-                status = line.gsub(%r{^<Key>}, "")
-            when %r{^<Name>.+}
-                line.gsub!(%r{^<Name>}, "")
-                group_params["Name"] = line
-
-                group = Group.new(group_params)
-                curr.groups[group.name] = group
-                curr = group
-            when %r{^<UUID>.+}
-                uuid = line.gsub(%r{^<UUID>}, "")
-                if (group_params["UUID"].nil?)
-                    group_params["UUID"] = uuid
-                else
-                    entry_params["UUID"] = uuid
-                end
-            when %r{^<Value>.*}
-                line.gsub!(%r{^<Value>}, "")
-                line = "" if (line.nil?)
-                entry_params[status] = line
-                inside_value = true
-            end
+        doc = REXML::Document.new(@xml)
+        if (doc.elements["KeePassFile/Root"].nil?)
+            raise Error::InvalidXMLError.new
         end
 
-        @db = curr
+        root = doc.elements["KeePassFile/Root"]
+        @db = Group.from_xml(self, nil, root)
     end
     private :parse_xml
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubeepass
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Miles Whittaker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -148,6 +148,7 @@ files:
 - lib/rubeepass/error/invalid_protected_data_error.rb
 - lib/rubeepass/error/invalid_protected_stream_key_error.rb
 - lib/rubeepass/error/invalid_version_error.rb
+- lib/rubeepass/error/invalid_xml_error.rb
 - lib/rubeepass/error/not_aes_error.rb
 - lib/rubeepass/error/not_salsa20_error.rb
 - lib/rubeepass/group.rb