lastpass 1.0.1 → 1.1.0

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+Version 1.1.0
+-------------
+
+- Shared folder support
+
+
 Version 1.0.1
 -------------
 

data/README.md

@@ -8,6 +8,8 @@ LastPass Ruby API
 
 **This is unofficial LastPass API.**
 
+There's also [C#/.NET port](https://github.com/detunized/lastpass-sharp) available.
+
 This library implements fetching and parsing of LastPass data.  The library is
 still in the proof of concept stage and doesn't support all LastPass features
 yet.  Only account information (logins, passwords, urls, etc.) is available so
@@ -30,10 +32,17 @@ vault.accounts.each do |i|
 end
 ```
 
+
+A multifactor password (YubiKey, Google Authenticator) can optionally be appended to 
+the login credentials:
+
+```ruby
+vault = LastPass::Vault.open_remote "username", "password", "multifactor_password"
+```
+
 The blob received from LastPass could be safely stored locally (it's well
 encrypted) and reused later on.
 
-
 LostPass iOS App
 ----------------
 

data/TODO

@@ -0,0 +1,5 @@
+- Make tests more consistent. Currently there's a lot of different binary blobs stored in the tests.
+It would be good to generate the test data from some meaningful pieces. Like construct chunks from
+items, construct items themselves. Build the whole blob out of chunks. This way the tests would be
+more readable and easier to update in case of format changes. This also fixes the problem of
+exposing real world usernames, passwords and encryption keys.

data/example/example.rb

@@ -12,8 +12,25 @@ credentials = YAML.load_file File.join File.dirname(__FILE__), "credentials.yaml
 username = credentials["username"]
 password = credentials["password"]
 
-vault = LastPass::Vault.open_remote username, password
+begin
+    # First try without a multifactor password
+    vault = LastPass::Vault.open_remote username, password
+rescue LastPass::LastPassIncorrectGoogleAuthenticatorCodeError => e
+    # Get the code
+    puts "Enter Google Authenticator code:"
+    multifactor_password = gets.chomp
+
+    # And now retry with the code
+    vault = LastPass::Vault.open_remote username, password, multifactor_password
+rescue LastPass::LastPassIncorrectYubikeyPasswordError => e
+    # Get the password
+    puts "Enter Yubikey password:"
+    multifactor_password = gets.chomp
+
+    # And now retry with the Yubikey password
+    vault = LastPass::Vault.open_remote username, password, multifactor_password
+end
 
 vault.accounts.each_with_index do |i, index|
-    puts "#{index + 1}: #{i.id} #{i.name} #{i.username} #{i.password} #{i.url} #{i.group}}"
+    puts "#{index + 1}: #{i.id} #{i.name} #{i.username} #{i.password} #{i.url} #{i.group}"
 end

data/lastpass.gemspec

@@ -16,10 +16,10 @@ Gem::Specification.new do |s|
 
     s.required_ruby_version = ">= 1.9.3"
 
-    s.add_dependency "httparty", "~> 0.12.0"
+    s.add_dependency "httparty", "~> 0.13.0"
     s.add_dependency "pbkdf2-ruby", "~> 0.2.0"
 
-    s.add_development_dependency "rake", "~> 10.0.0"
+    s.add_development_dependency "rake", "~> 10.1.0"
     s.add_development_dependency "rspec", "~> 2.14.0"
     s.add_development_dependency "coveralls", "~> 0.7.0"
 

data/lib/lastpass/exceptions.rb

@@ -13,20 +13,26 @@ module LastPass
     class NetworkError < Error; end
 
     # Server responded with something we don't understand
-    class InvalidResponse < Error; end
+    class InvalidResponseError < Error; end
 
     # Server responded with XML we don't understand
-    class UnknownResponseSchema < Error; end
+    class UnknownResponseSchemaError < Error; end
 
     #
     # LastPass returned errors
     #
 
     # LastPass error: unknown username
-    class LastPassUnknownUsername < Error; end
+    class LastPassUnknownUsernameError < Error; end
 
     # LastPass error: invalid password
-    class LastPassInvalidPassword < Error; end
+    class LastPassInvalidPasswordError < Error; end
+
+    # LastPass error: missing or incorrect Google Authenticator code
+    class LastPassIncorrectGoogleAuthenticatorCodeError < Error; end
+
+    # LastPass error: missing or incorrect Yubikey password
+    class LastPassIncorrectYubikeyPasswordError < Error; end
 
     # LastPass error we don't know about
     class LastPassUnknownError < Error; end

data/lib/lastpass/fetcher.rb

@@ -3,13 +3,13 @@
 
 module LastPass
     class Fetcher
-        def self.login username, password
+        def self.login username, password, multifactor_password = nil
             key_iteration_count = request_iteration_count username
-            request_login username, password, key_iteration_count
+            request_login username, password, key_iteration_count, multifactor_password
         end
 
         def self.fetch session, web_client = HTTParty
-            response = web_client.get "https://lastpass.com/getaccts.php?mobile=1&b64=1&hash=0.0",
+            response = web_client.get "https://lastpass.com/getaccts.php?mobile=1&b64=1&hash=0.0&hasplugin=3.0.23&requestsrc=android",
                                       format: :plain,
                                       cookies: {"PHPSESSID" => URI.encode(session.id)}
 
@@ -27,30 +27,39 @@ module LastPass
             begin
                 count = Integer response.parsed_response
             rescue ArgumentError
-                raise InvalidResponse, "Key iteration count is invalid"
+                raise InvalidResponseError, "Key iteration count is invalid"
             end
 
-            raise InvalidResponse, "Key iteration count is not positive" unless count > 0
+            raise InvalidResponseError, "Key iteration count is not positive" unless count > 0
 
             count
         end
 
-        def self.request_login username, password, key_iteration_count, web_client = HTTParty
+        def self.request_login username,
+                               password,
+                               key_iteration_count,
+                               multifactor_password = nil,
+                               web_client = HTTParty
+
+            body = {
+                method: "mobile",
+                web: 1,
+                xml: 1,
+                username: username,
+                hash: make_hash(username, password, key_iteration_count),
+                iterations: key_iteration_count
+            }
+
+            body[:otp] = multifactor_password if multifactor_password
+
             response = web_client.post "https://lastpass.com/login.php",
                                        format: :xml,
-                                       body: {
-                                           method: "mobile",
-                                           web: 1,
-                                           xml: 1,
-                                           username: username,
-                                           hash: make_hash(username, password, key_iteration_count),
-                                           iterations: key_iteration_count
-                                       }
+                                       body: body
 
             raise NetworkError unless response.response.is_a? Net::HTTPOK
 
             parsed_response = response.parsed_response
-            raise InvalidResponse unless parsed_response.is_a? Hash
+            raise InvalidResponseError unless parsed_response.is_a? Hash
 
             create_session parsed_response, key_iteration_count or
                 raise login_error parsed_response
@@ -70,11 +79,14 @@ module LastPass
 
         def self.login_error parsed_response
             error = (parsed_response["response"] || {})["error"]
-            return UnknownResponseSchema unless error.is_a? Hash
+            return UnknownResponseSchemaError unless error.is_a? Hash
 
             exceptions = {
-                "unknownemail" => LastPassUnknownUsername,
-                "unknownpassword" => LastPassInvalidPassword,
+                "unknownemail" => LastPassUnknownUsernameError,
+                "unknownpassword" => LastPassInvalidPasswordError,
+                "googleauthrequired" => LastPassIncorrectGoogleAuthenticatorCodeError,
+                "googleauthfailed" => LastPassIncorrectGoogleAuthenticatorCodeError,
+                "yubikeyrestricted" => LastPassIncorrectYubikeyPasswordError,
             }
 
             cause = error["cause"]
@@ -83,7 +95,7 @@ module LastPass
             if cause
                 (exceptions[cause] || LastPassUnknownError).new message || cause
             else
-                InvalidResponse.new message
+                InvalidResponseError.new message
             end
         end
 

data/lib/lastpass/parser.rb

@@ -3,14 +3,16 @@
 
 module LastPass
     class Parser
+        # OpenSSL constant
+        RSA_PKCS1_OAEP_PADDING = 4
+
         # Splits the blob into chucks grouped by kind.
         def self.extract_chunks blob
-            chunks = Hash.new { |hash, key| hash[key] = [] }
+            chunks = []
 
             StringIO.open blob.bytes do |stream|
                 while !stream.eof?
-                    chunk = read_chunk stream
-                    chunks[chunk.id] << chunk
+                    chunks.push read_chunk stream
                 end
             end
 
@@ -18,8 +20,7 @@ module LastPass
         end
 
         # Parses an account chunk, decrypts and creates an Account object.
-        # TODO: See if this should be part of Account class.
-        def self.parse_account chunk, encryption_key
+        def self.parse_ACCT chunk, encryption_key
             StringIO.open chunk.payload do |io|
                 id = read_item io
                 name = decode_aes256_auto read_item(io), encryption_key
@@ -33,6 +34,56 @@ module LastPass
             end
         end
 
+        # Parse PRIK chunk which contains private RSA key
+        def self.parse_PRIK chunk, encryption_key
+            decrypted = decode_aes256 "cbc",
+                                      encryption_key[0, 16],
+                                      decode_hex(chunk.payload),
+                                      encryption_key
+
+            /^LastPassPrivateKey<(?<hex_key>.*)>LastPassPrivateKey$/ =~ decrypted
+            asn1_encoded_all = OpenSSL::ASN1.decode decode_hex hex_key
+            asn1_encoded_key = OpenSSL::ASN1.decode asn1_encoded_all.value[2].value
+
+            rsa_key = OpenSSL::PKey::RSA.new
+            rsa_key.n = asn1_encoded_key.value[1].value
+            rsa_key.e = asn1_encoded_key.value[2].value
+            rsa_key.d = asn1_encoded_key.value[3].value
+            rsa_key.p = asn1_encoded_key.value[4].value
+            rsa_key.q = asn1_encoded_key.value[5].value
+            rsa_key.dmp1 = asn1_encoded_key.value[6].value
+            rsa_key.dmq1 = asn1_encoded_key.value[7].value
+            rsa_key.iqmp = asn1_encoded_key.value[8].value
+
+            rsa_key
+        end
+
+        # TODO: Fake some data and make a test
+        def self.parse_SHAR chunk, encryption_key, rsa_key
+            StringIO.open chunk.payload do |io|
+                id = read_item io
+                encrypted_key = decode_hex read_item io
+                encrypted_name = read_item io
+                2.times { skip_item io }
+                key = read_item io
+
+                # Shared folder encryption key might come already in pre-decrypted form,
+                # where it's only AES encrypted with the regular encryption key.
+                # When the key is blank, then there's a RSA encrypted key, which has to
+                # be decrypted first before use.
+                key = if key.empty?
+                    decode_hex rsa_key.private_decrypt(encrypted_key, RSA_PKCS1_OAEP_PADDING)
+                else
+                    decode_hex decode_aes256_auto(key, encryption_key)
+                end
+
+                name = decode_aes256_auto encrypted_name, key
+
+                # TODO: Return an object, not a hash
+                {id: id, name: name, encryption_key: key}
+            end
+        end
+
         # Reads one chunk from a stream and creates a Chunk object with the data read.
         def self.read_chunk stream
             # LastPass blob chunk is made up of 4-byte ID,

data/lib/lastpass/vault.rb

@@ -6,8 +6,8 @@ module LastPass
         attr_reader :accounts
 
         # Fetches a blob from the server and creates a vault
-        def self.open_remote username, password
-            open Vault.fetch_blob(username, password), username, password
+        def self.open_remote username, password, multifactor_password = nil
+            open Vault.fetch_blob(username, password, multifactor_password), username, password
         end
 
         # Creates a vault from a locally stored blob
@@ -21,14 +21,29 @@ module LastPass
         end
 
         # Just fetches the blob, could be used to store it locally
-        def self.fetch_blob username, password
-            Fetcher.fetch Fetcher.login username, password
+        def self.fetch_blob username, password, multifactor_password = nil
+            Fetcher.fetch Fetcher.login username, password, multifactor_password
         end
 
         # This more of an internal method, use one of the static constructors instead
         def initialize blob, encryption_key
-            chunks = Parser.extract_chunks blob
-            @accounts = (chunks["ACCT"] || []).map { |i| Parser.parse_account i, encryption_key }
+            @accounts = []
+
+            key = encryption_key
+            rsa_private_key = nil
+
+            Parser.extract_chunks(blob).each do |i|
+                case i.id
+                when "ACCT"
+                    # TODO: Put shared folder name as group in the account
+                    @accounts.push Parser.parse_ACCT i, key
+                when "PRIK"
+                    rsa_private_key = Parser.parse_PRIK i, encryption_key
+                when "SHAR"
+                    # After SHAR chunk all the folliwing accounts are enrypted with a new key
+                    key = Parser.parse_SHAR(i, encryption_key, rsa_private_key)[:encryption_key]
+                end
+            end
         end
     end
 end

data/lib/lastpass/version.rb

@@ -2,5 +2,5 @@
 # Licensed under the terms of the MIT license. See LICENCE for details.
 
 module LastPass
-    VERSION = "1.0.1"
+    VERSION = "1.1.0"
 end

data/spec/fetcher_spec.rb

@@ -7,12 +7,28 @@ describe LastPass::Fetcher do
     let(:username) { "username" }
     let(:password) { "password" }
     let(:key_iteration_count) { 5000 }
+
+    let(:hash) { "7880a04588cfab954aa1a2da98fd9c0d2c6eba4c53e36a94510e6dbf30759256" }
     let(:session_id) { "53ru,Hb713QnEVM5zWZ16jMvxS0" }
     let(:session) { LastPass::Session.new session_id, key_iteration_count }
+
     let(:blob_response) { "TFBBVgAAAAMxMjJQUkVNAAAACjE0MTQ5" }
     let(:blob_bytes) { blob_response.decode64 }
     let(:blob) { LastPass::Blob.new blob_bytes, key_iteration_count }
 
+    let(:login_post_data) { {method: "mobile",
+                             web: 1,
+                             xml: 1,
+                             username: username,
+                             hash: hash,
+                             iterations: key_iteration_count} }
+
+    let(:google_authenticator_code) { "123456" }
+    let(:yubikey_password) { "emdbwzemyisymdnevznyqhqnklaqheaxszzvtnxjrmkb" }
+
+    let(:login_post_data_with_google_authenticator_code) { login_post_data.merge({otp: google_authenticator_code})}
+    let(:login_post_data_with_yubikey_password) { login_post_data.merge({otp: yubikey_password}) }
+
     describe ".request_iteration_count" do
         it "makes a POST request" do
             expect(web_client = double("web_client")).to receive(:post)
@@ -40,31 +56,48 @@ describe LastPass::Fetcher do
             expect {
                 LastPass::Fetcher.request_iteration_count username,
                                                           double("web_client", post: http_ok("not a number"))
-            }.to raise_error LastPass::InvalidResponse, "Key iteration count is invalid"
+            }.to raise_error LastPass::InvalidResponseError, "Key iteration count is invalid"
         end
 
         it "raises an exception on zero key iteration count" do
             expect {
                 LastPass::Fetcher.request_iteration_count username,
                                                           double("web_client", post: http_ok("0"))
-            }.to raise_error LastPass::InvalidResponse, "Key iteration count is not positive"
+            }.to raise_error LastPass::InvalidResponseError, "Key iteration count is not positive"
         end
 
         it "raises an exception on negative key iteration count" do
             expect {
                 LastPass::Fetcher.request_iteration_count username,
                                                           double("web_client", post: http_ok("-1"))
-            }.to raise_error LastPass::InvalidResponse, "Key iteration count is not positive"
+            }.to raise_error LastPass::InvalidResponseError, "Key iteration count is not positive"
         end
     end
 
     describe ".request_login" do
-        it "makes a POST request" do
-            expect(web_client = double("web_client")).to receive(:post)
-                .with("https://lastpass.com/login.php", format: :xml, body: anything)
+        def verify_post_request multifactor_password, post_data
+            web_client = double("web_client")
+            expect(web_client).to receive(:post)
+                .with("https://lastpass.com/login.php", format: :xml, body: post_data)
                 .and_return(http_ok("ok" => {"sessionid" => session_id}))
 
-            LastPass::Fetcher.request_login username, password, key_iteration_count, web_client
+            LastPass::Fetcher.request_login username,
+                                            password,
+                                            key_iteration_count,
+                                            multifactor_password,
+                                            web_client
+        end
+
+        it "makes a POST request" do
+            verify_post_request nil, login_post_data
+        end
+
+        it "makes a POST request with Google Authenticator code" do
+            verify_post_request google_authenticator_code, login_post_data_with_google_authenticator_code
+        end
+
+        it "makes a POST request with Yubikey password" do
+            verify_post_request yubikey_password, login_post_data_with_yubikey_password
         end
 
         it "returns a session" do
@@ -76,32 +109,52 @@ describe LastPass::Fetcher do
         end
 
         it "raises an exception when response is not a hash" do
-            expect { request_login_with_ok "not a hash" }.to raise_error LastPass::InvalidResponse
+            expect { request_login_with_ok "not a hash" }.to raise_error LastPass::InvalidResponseError
         end
 
         it "raises an exception on unknown response schema" do
-            expect { request_login_with_xml "<unknown />" }.to raise_error LastPass::UnknownResponseSchema
+            expect { request_login_with_xml "<unknown />" }.to raise_error LastPass::UnknownResponseSchemaError
         end
 
         it "raises an exception on unknown response schema" do
-            expect { request_login_with_xml "<response />" }.to raise_error LastPass::UnknownResponseSchema
+            expect { request_login_with_xml "<response />" }.to raise_error LastPass::UnknownResponseSchemaError
         end
 
         it "raises an exception on unknown response schema" do
             expect { request_login_with_xml "<response><error /></response>" }
-                .to raise_error LastPass::UnknownResponseSchema
+                .to raise_error LastPass::UnknownResponseSchemaError
         end
 
         it "raises an exception on unknown username" do
             message = "Unknown email address."
             expect { request_login_with_lastpass_error "unknownemail", message }
-                .to raise_error LastPass::LastPassUnknownUsername, message
+                .to raise_error LastPass::LastPassUnknownUsernameError, message
         end
 
         it "raises an exception on invalid password" do
             message = "Invalid password!"
             expect { request_login_with_lastpass_error "unknownpassword", message }
-                .to raise_error LastPass::LastPassInvalidPassword, message
+                .to raise_error LastPass::LastPassInvalidPasswordError, message
+        end
+
+        it "raises an exception on missing Google Authenticator code" do
+            message = "Google Authenticator authentication required! " +
+                      "Upgrade your browser extension so you can enter it."
+            expect { request_login_with_lastpass_error "googleauthrequired", message }
+                .to raise_error LastPass::LastPassIncorrectGoogleAuthenticatorCodeError, message
+        end
+
+        it "raises an exception on incorrect Google Authenticator code" do
+            message = "Google Authenticator authentication failed!"
+            expect { request_login_with_lastpass_error "googleauthfailed", message }
+                .to raise_error LastPass::LastPassIncorrectGoogleAuthenticatorCodeError, message
+        end
+
+        it "raises an exception on missing/incorrect Yubikey password" do
+            message = "Your account settings have restricted you from logging in " +
+                      "from mobile devices that do not support YubiKey authentication."
+            expect { request_login_with_lastpass_error "yubikeyrestricted", message }
+                .to raise_error LastPass::LastPassIncorrectYubikeyPasswordError, message
         end
 
         it "raises an exception on unknown LastPass error with a message" do
@@ -120,7 +173,7 @@ describe LastPass::Fetcher do
     describe ".fetch" do
         it "makes a GET request" do
             expect(web_client = double("web_client")).to receive(:get)
-                .with("https://lastpass.com/getaccts.php?mobile=1&b64=1&hash=0.0",
+                .with("https://lastpass.com/getaccts.php?mobile=1&b64=1&hash=0.0&hasplugin=3.0.23&requestsrc=android",
                       format: :plain,
                       cookies: {"PHPSESSID" => session_id})
                 .and_return(http_ok(blob_response))
@@ -223,6 +276,7 @@ describe LastPass::Fetcher do
         LastPass::Fetcher.request_login username,
                                         password,
                                         key_iteration_count,
+                                        nil,
                                         double("web_client", post: response)
     end
 end

data/spec/parser_spec.rb

@@ -9,38 +9,104 @@ describe LastPass::Parser do
     let(:blob) { LastPass::Blob.new TEST_BLOB, key_iteration_count }
     let(:padding) { "BEEFFACE"}
     let(:encryption_key) { "OfOUvVnQzB4v49sNh4+PdwIFb9Fr5+jVfWRTf+E2Ghg=".decode64 }
+    let(:encoded_rsa_key) { "98F3F5518AE7C03EBBF195A616361619033509FB1FFA0408E883B7C5E80381F8" +
+                            "C8A343925DDA78FB06A14324BEC77EAF63290D381F54763A2793FE25C3247FC0" +
+                            "29022687F453426DE96A9FB34CEB55C02764FB41E5E1619226FE47FA7EA40B41" +
+                            "0973132F7AB2DE2D7F08C181C7D56BBF92CD4D44BC7DEE4253DEC36C77D28E30" +
+                            "6F41B8BB26B0EDB97BADCEE912D3671C22339036FC064F5AF60D3545D47B8263" +
+                            "6BBA1896ECDCF5EBE99A1061EFB8FBBD6C3500EA06A28BB8863F413702D9C05B" +
+                            "9A54120F1BEFA0D98A48E82622A36DBD79772B5E4AD957045DC2B97311983592" +
+                            "A357037DDA172C284B4FEC7DF8962A11B42079D6F943C8F9C0FEDFEA0C43A362" +
+                            "B550E217715FD82D9F3BB168A006B0880B1F3660076158FE8CF6B706CF2FEAA1" +
+                            "A731D1F68B1BC20E7ADE15097D2CD84606B4B0756DFE25DAF110D62841F44265" +
+                            "73A676B904972B31AD7B02093C536341E1DA943F1AFF88DF2005BD04C6897FB6" +
+                            "F9E307DA1C2BD219AB39F911FF90C6B1EA658C72C67C1EADC36CD5202654B4E1" +
+                            "99A88F13DCE1148CC04F81485896627BB1DB5C73969520CC66652492383930E3" +
+                            "3AFD57BE171F4BA25016EC9C3662F5B054101E381565433E46CB9FD517B59AE8" +
+                            "A5CE7D11005282E551E9DCAA1996763E41B49677F906F122AAB76E852F35B31F" +
+                            "397B70949D5F6C8DAA244AF16E9D48E0801E5C6D3FCEAFD2C3E157968B3E796C" +
+                            "87E1F3FFF86B62FE5263D1A597E3906BF697C019F1F543D7BB1E11B08837B47F" +
+                            "4528E4B47EB77508CFC0581B2A005383D0A238EA5BDE2E2602E0D2408B139735" +
+                            "F4BAF8D6CF260BBC81833A85F14C5746AC6081B878486F5A4BD23B821F3F5F6B" +
+                            "DAC8A9B57E25E24EDB8D701F01AE142D63A8A7D0F1CC8FAFF5F0320551CEB29B" +
+                            "DB6907C57E38602927AD7240003FEB238AC5437FE4BAD11BB5038CA74D539523" +
+                            "A167B8EBB1210608EB7DA53B4155D05B87D21848E58905EFA550EA5A51E0A68D" +
+                            "5FF0F9E0CC0D5105DD98BE9E2C41362794A71A573CCA87B57147115B86FC8A6B" +
+                            "B1778CED1920787271C75D69C5D63CD798915BF8F9877808F841F9269B2EA809" +
+                            "0E11F6C89FDB537F341142CA29BAC761E1CF9D58FFB0C44A26E5EF7FA14142C8" +
+                            "A84BC9304A221D5F961DB41B5925B06823A12A6F8950E47325021A747A02A28F" +
+                            "DAE65997EBDF5D2BDBCA7C8D689AE186A9FE85A170B76EE92595C9E33639C993" +
+                            "07C377FA4DA975E191810E993CDC0A33EE494B0EE8A1B6A9408285012967C17A" +
+                            "8CB5EE8E7973CF9186A98000FE00F1CC76420089C6BDCE9E39D403C320DF1135" +
+                            "1597FF8B231689389CCE12844289FEFE468BFCAEE9A2CFB1A8DD066AEC974DA9" +
+                            "C8530C9A17593E25DC89934E056B178329C4BBF7113657677AB25EE66A1E1D92" +
+                            "F62154B2451B37727F05B3AC0F2501F7A95845C9BE210D411028C27A9AD4B0E8" +
+                            "31A6C46D26883A8AA2D1E2BD3E8E122A6FC21CECB7AE2B91C6FCFA793C5CAFF6" +
+                            "53C6670D914A29EAD81CD5C29FFB048C81CC80EDD693B4D8091B2D5DE88EA042" +
+                            "11AC551F406B713278BD14667E437C610953D6186C2986BA60361C2013395E8E" +
+                            "A9D14CD00EC5C61147BE03D8965B5376DF32E2C3740128398E0D47900C888FD0" +
+                            "D1F7D583808AFBC0712806E11462B37815C20692FB38E61CC0B1AAF66A854982" +
+                            "6A1F5FFFF2436B0B9F9EDFF4F5B59B362AA1D25A4E3C398EB18445483F8419BD" +
+                            "1511A5177E9C4B7034375A2D91B95153535E6CD5F023F4EED0E15B5415A3B7A7" +
+                            "7E390AA698DF00F4FD897B0454C00959AF0CB54B272DE63968815B971C44B273" +
+                            "6AC737FAE6A19F544907833F13C6F424D30E3B85054A4402EC94079C1473C20B" +
+                            "E4C1B33525486BB098EF960082DB4DF5FE9CAF71681B03CB2D4BE7382FF0C03F" +
+                            "18144DE554256591773DC3F381116955233FDA7223D71C402E558783F221E25A" +
+                            "94FECD350654A9CD8EE8C39E4B1CFBA0D5FD46891527F2D0FC9EA61584A76D59" +
+                            "99719811B2BAFC99769E6911733ED389A731C327CB5D7BB6D79CE030D3285586" +
+                            "C6681FC8C110EFE30CEE883FFEF5FB511B4421863E2A15F8CDCFA7B84B931121" +
+                            "5B23093DE3B5E7F4CFCCE60BE7857B7442B8FCC3E43C46C4BFA3E9ABD2F479F6" +
+                            "BD8D3F3D36C0FAC1F4D72FBE96C644AB56F73CAF956D5544B2EB9C589ED30FF3" +
+                            "0BB03D09DB455764EF4A33C24F93170A98A21455826390B13A8F338A820EC08D" +
+                            "6E9F562282C2F815BB57CE511AB6B0DE75EFA63F28C6D0B25298CDAAC76742D5" +
+                            "353B26B77C1533B4DFE2D95F3E89315C0D806A90FCDFDC31CE04A9E29937680D" +
+                            "32D8B503352388109C1F5F41E8496302E13A61917F70A9AA3C5ECDBD88163E3C" +
+                            "F0580C5EB1382BB66194AC0983BAA16B4D220756F4B7E3DDFFC5BF343FA7E31D" +
+                            "14FED4409AD0FE9BBE01AF79DA4852253CBF166FDCA90E894B5267A502F73347" +
+                            "06F8C767EC861324CC7734352D76DB007E25105E7994CF91D79532221316F4DE" +
+                            "56BAE4351D3E3C6549FBFEF13BBE2636071794AD9EC3787B4A71E5438B86C358" +
+                            "65ECF2EA5980318F82D8B113C0EC8FEE41C243E0A1A09F373A0CF546FA18E1EC" +
+                            "7DB4842A6B8B03D115654222B87DA6034EFDE2224DBD23AB104BF3723856C03D" +
+                            "B639BA073F2CC8E4AB05BAADDB5DEACC1874F4D6F86B95710019114DACBFE48F" +
+                            "EF2AE2DF27356B5C17948B26A41FD1A8F07E8068E176F995910C373886DB47D2" +
+                            "6C2FE5CD97AAF1829EBC1EEBA4D88343A322E810385138F51F0E5149183699C4" +
+                            "05E49ED13C2889A22742893A52567B0F7D4A3BC9F4DC6D29F713AA7FB4EF6B13" +
+                            "5F92F598404A80E7D6515CE234AFA68A4B562AF203162C60D578F0D00E302958" +
+                            "174E1A712FD449D257C6AA5F56E4DBD0363573931463BC910858AF1EC40C1F4A" +
+                            "7BE27DE8E170D4AACF6C34B0CDE15190FD81FA5676136A4D73E2AA4BBFBB8E7C" +
+                            "1178EF47362188D9288E822B10BBF2C8BE075A5BD1D3E1F08108BA8C4E6FB173" +
+                            "DCECB5771E9D8AE4CD776EA3409DF30FA2252D3C3769AF12177F4A1929DC8E74" +
+                            "D5AEAC94CF94EEBA0E9AC012C57B40A8BB57530C25846B841005767B9AABE436" +
+                            "D4590977FDDA519B9B284CF8B8922A0E8B659ECE3745A95800EE1B3DDD33E0FF" +
+                            "230C0528BC7A4CB80604411E59E08775A42C634E93BA9C77D015659AC912F436" +
+                            "94F774E94050E4B3BF84290368D5AFD7F043BDCA3BD0CC8C0E267069B6F1386A" +
+                            "E1D9C8B5512AAAA292FDA9CA07E27BAF983E1E25A11732797425F2BB396B302E" +
+                            "0782BA183D4BC1F682365774520EAC8A321C7A0BD08027021EA0063D471E0AD1" +
+                            "E1469AD803C311D3FBF50B5538265D4262B6716D90E89A8C906D08533D650000" +
+                            "6BF1B8ABAAFE1CA3AFDD1A19ACABE5B86A804D36AE27163CAF390FD266D5FFEF" +
+                            "FC7CE6FEF9458E4AF0C4108E32EFD11C19751B1D9883E803F7C2E1A5786F3385" +
+                            "1A7CA3772ECD7CB0E9782A7D30E0A9FD09EED361B774A277C618C995FD7F7634" +
+                            "E7DB3834690B58DDFF6B721157D0EC02" }
+    let(:rsa_key_encryption_key) { "v4uHomAR0tAXC3fA5Nfq7DjyJxuvYErMSCcZIWZKjpM=".decode64 }
 
     describe ".extract_chunks" do
         context "returned chunks" do
             let(:chunks) { LastPass::Parser.extract_chunks blob }
 
-            it { expect(chunks).to be_instance_of Hash }
+            it { expect(chunks).to be_instance_of Array }
 
-            it "all keys are strings" do
-                expect(chunks.keys).to match_array TEST_CHUNK_IDS
-            end
-
-            it "all values are arrays" do
-                expect(chunks.values.map(&:class).uniq).to eq [Array]
-            end
-
-            it "all arrays contain only chunks" do
-                expect(chunks.values.flat_map { |i| i.map &:class }.uniq).to eq [LastPass::Chunk]
-            end
-
-            it "all chunks grouped under correct IDs" do
-                expect(
-                    chunks.all? { |id, chunk_group| chunk_group.map(&:id).uniq == [id] }
-                ).to be_true
+            it "all values are instances of Chunk" do
+                expect(chunks.map(&:class).uniq).to eq [LastPass::Chunk]
             end
         end
     end
 
-    describe ".parse_account" do
+    describe ".parse_ACCT" do
         let(:accounts) {
             LastPass::Parser
-                .extract_chunks(blob)["ACCT"]
-                .map { |i| LastPass::Parser.parse_account i, TEST_ENCRYPTION_KEY }
+                .extract_chunks(blob)
+                .select { |i| i.id == "ACCT" }
+                .map { |i| LastPass::Parser.parse_ACCT i, TEST_ENCRYPTION_KEY }
         }
 
         it "parses accounts" do
@@ -48,9 +114,80 @@ describe LastPass::Parser do
         end
     end
 
+    describe ".parse_PRIK" do
+        let(:chunk) { LastPass::Chunk.new "PRIK", encoded_rsa_key }
+        let(:rsa_key) { LastPass::Parser.parse_PRIK chunk, rsa_key_encryption_key }
+
+        it "parses private key" do
+            expect(rsa_key).to be_instance_of OpenSSL::PKey::RSA
+            expect(rsa_key.n.to_s).to eq "26119467519435514320618523953258926539081857789201" +
+                                         "11592360794055150234493177840791445076164320959092" +
+                                         "33977645519805962686071307052774013402170389235283" +
+                                         "48398581900094955608774421569689169697285847986479" +
+                                         "82303230642077254435741682688235176460351551099267" +
+                                         "22581481667367599195203736002065084704013295528661" +
+                                         "76687143747593851140122182044652173598693510643390" +
+                                         "47711449981712845835960707676646864765530616733341" +
+                                         "58401920829305659156984748726238485655720031774127" +
+                                         "01900577710668575227691993026576480667273922300137" +
+                                         "80405264300989392980537603337301835174777026188388" +
+                                         "93147718435999645840214854231168704372464234421315" +
+                                         "01138217872658041"
+            expect(rsa_key.e.to_s).to eq "65537"
+            expect(rsa_key.d.to_s).to eq "20217010678828834626882766446083366137418639853408" +
+                                         "07494174069610076841252047428625473158347002598408" +
+                                         "18346644251082549844764624454370315666751565294997" +
+                                         "10533208173186395672159239558808345075823110774221" +
+                                         "61501075434955107584446470508660844962452555542861" +
+                                         "72030926355197158923586674949673551608716945271868" +
+                                         "18816984671497443384191412119383687600754285611808" +
+                                         "23265620694961977962255376280640334543711420731809" +
+                                         "16169692928898605559361322123131373948352054888316" +
+                                         "99068010065680008419210277574874665723796199239285" +
+                                         "78432149273871356528827780412288057677598714485872" +
+                                         "23380715275000339748138416696881866569449168516354" +
+                                         "08203050733598637"
+            expect(rsa_key.p.to_s).to eq "17745924258106322606344019888040076543466707208121" +
+                                         "93651272762195900747632457567234817364256394944312" +
+                                         "33791510564351470780224344194760390006214095043405" +
+                                         "42496712265086317539172843039592265661675784866722" +
+                                         "91261262550895476526939878375016658686669778355984" +
+                                         "43725100552628219407700007375820870959681331890216" +
+                                         "873285999"
+            expect(rsa_key.q.to_s).to eq "14718572636476888213359534581670909910031809536407" +
+                                         "40164297606657861988206326322941728093846078102409" +
+                                         "77115817405984843964689092056948880068086594283588" +
+                                         "67786990898525462713620707076259988063113810297786" +
+                                         "62342502396556461808879680749106840152602791951788" +
+                                         "07295572399572445909627940220804206538364578785262" +
+                                         "498615959"
+            expect(rsa_key.dmp1.to_s).to eq "11323089471614997519408698592522878386531994069" +
+                                            "33541387540978328974191124807026398192741826901" +
+                                            "86286081197790519393403018396347119829946883285" +
+                                            "08800265628051101161010033119239372833462468119" +
+                                            "90625594353955836736745514688525978377008530625" +
+                                            "69694172942783772849726563761756732407513441791" +
+                                            "680438851248236159711158591"
+            expect(rsa_key.dmq1.to_s).to eq "12614892732210916138126631634839174964470249502" +
+                                            "72370951196981338360130575847987543477227082933" +
+                                            "41184913630399067613236576233063778305668453307" +
+                                            "65828324726545238243590265660986543730618177968" +
+                                            "24851190055502445616363498122584261892788460430" +
+                                            "15963041982287770355559480659540210015737708509" +
+                                            "273864533597668007301940253"
+            expect(rsa_key.iqmp.to_s).to eq "12662716333617943892704787530332782239196594580" +
+                                            "72960727418453194230165281227127897455330083723" +
+                                            "88895713617946267318745745224382578970891647971" +
+                                            "94015463887039228876036602797561671319853126600" +
+                                            "52663805817336717151173320411542486382434841161" +
+                                            "62999647203566877832873138065626190040996517274" +
+                                            "418161068665712298519808863"
+        end
+    end
+
     describe ".read_chunk" do
         it "returns a chunk" do
-            with_hex "4142434400000004DEADBEEF" + padding do |io|
+            with_chunk_hex "ABCD", "DEADBEEF", padding do |io|
                 expect(LastPass::Parser.read_chunk io).to eq LastPass::Chunk.new("ABCD", "DEADBEEF".decode_hex)
                 expect(io.pos).to eq 12
             end
@@ -59,7 +196,7 @@ describe LastPass::Parser do
 
     describe ".read_item" do
         it "returns an item" do
-            with_hex "00000004DEADBEEF" + padding do |io|
+            with_item_hex "DEADBEEF", padding do |io|
                 expect(LastPass::Parser.read_item io).to eq "DEADBEEF".decode_hex
                 expect(io.pos).to eq 8
             end
@@ -68,14 +205,14 @@ describe LastPass::Parser do
 
     describe ".skip_item" do
         it "skips an empty item" do
-            with_hex "00000000" + padding do |io|
+            with_item_hex "", padding do |io|
                 LastPass::Parser.skip_item io
                 expect(io.pos).to eq 4
             end
         end
 
         it "skips a non-empty item" do
-            with_hex "00000004DEADBEEF" + padding do |io|
+            with_item_hex "DEADBEEF", padding do |io|
                 LastPass::Parser.skip_item io
                 expect(io.pos).to eq 8
             end
@@ -293,4 +430,44 @@ describe LastPass::Parser do
             yield io
         end
     end
+
+    #
+    # Chunks
+    #
+
+    def with_chunk id, payload, padding = "", &block
+        with_bytes make_chunk(id, payload, padding), &block
+    end
+
+    def with_chunk_hex id, payload, padding = "", &block
+        with_bytes make_chunk_hex(id, payload, padding), &block
+    end
+
+    def make_chunk id, payload, padding = ""
+        [id, payload.size, payload, padding].pack "a4Na*a*"
+    end
+
+    def make_chunk_hex id, payload, padding = ""
+        make_chunk id, payload.decode_hex, padding
+    end
+
+    #
+    # Items
+    #
+
+    def with_item payload, padding = "", &block
+        with_bytes make_item(payload, padding), &block
+    end
+
+    def with_item_hex payload, padding = "", &block
+        with_bytes make_item_hex(payload, padding), &block
+    end
+
+    def make_item payload, padding = ""
+        [payload.size, payload, padding].pack "Na*a*"
+    end
+
+    def make_item_hex payload, padding = ""
+        make_item payload.decode_hex, padding
+    end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lastpass
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-15 00:00:00.000000000 Z
+date: 2014-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: pbkdf2-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 10.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: 10.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,7 @@ files:
 - Makefile
 - README.md
 - Rakefile
+- TODO
 - example/credentials.yaml.example
 - example/example.rb
 - lastpass.gemspec