rmega 0.1.7 → 0.2.0

data/lib/rmega/nodes/expandable.rb

@@ -1,19 +1,23 @@
-require 'rmega/utils'
-require 'rmega/nodes/uploadable'
-require 'rmega/crypto/crypto'
-
 module Rmega
   module Nodes
     module Expandable
       include Uploadable
 
       def create_folder(name)
-        key = Crypto.random_key
-        encrypted_attributes = Utils.a32_to_base64 Crypto.encrypt_attributes(key[0..3], {n: name.strip})
-        encrypted_key = Utils.a32_to_base64 Crypto.encrypt_key(session.master_key, key)
-        n = [{h: 'xxxxxxxx', t: 1, a: encrypted_attributes, k: encrypted_key}]
-        data = session.request a: 'p', t: handle, n: n
-        Folder.new(session, data['f'][0])
+        node_key = NodeKey.random
+
+        # encrypt attributes
+        attributes_str = "MEGA"
+        attributes_str << {n: name.strip}.to_json
+        attributes_str << ("\x00" * (16 - (attributes_str.size % 16)))
+        encrypted_attributes = aes_cbc_encrypt(node_key.aes_key, attributes_str)
+
+        # Encrypt node key
+        encrypted_key = aes_ecb_encrypt(session.master_key, node_key.aes_key)
+
+        n = [{h: 'xxxxxxxx', t: 1, a: Utils.base64urlencode(encrypted_attributes), k: Utils.base64urlencode(encrypted_key)}]
+        data = session.request(a: 'p', t: handle, n: n)
+        return Folder.new(session, data['f'][0])
       end
 
       def upload_url(filesize)

data/lib/rmega/nodes/factory.rb

@@ -1,3 +1,9 @@
+require 'rmega/nodes/uploadable'
+require 'rmega/nodes/expandable'
+require 'rmega/nodes/downloadable'
+require 'rmega/nodes/deletable'
+require 'rmega/nodes/traversable'
+require 'rmega/nodes/node_key'
 require 'rmega/nodes/node'
 require 'rmega/nodes/file'
 require 'rmega/nodes/folder'
@@ -10,31 +16,38 @@ module Rmega
     module Factory
       extend self
 
+      URL_REGEXP = /mega\..+\/\#([A-Z0-9\_\-\!\=]+)/i
+
+      FOLDER_URL_REGEXP = /mega\..+\/\#\F([A-Z0-9\_\-\!\=]+)/i
+
+      def url?(string)
+        string.to_s =~ URL_REGEXP
+      end
+
       def build(session, data)
-        type_name = type(data['t'])
-        node_class = Nodes.const_get("#{type_name.to_s.capitalize}")
-        node_class.new(session, data)
+        type = Node::TYPES[data['t']].to_s
+        return Nodes.const_get(type.capitalize).new(session, data)
       end
 
-      # TODO: support other node types than File
-      def build_from_url(session, url)
+      def build_from_url(url, session = Session.new)
         public_handle, key = url.strip.split('!')[1, 2]
-        data = session.request(a: 'g', g: 1, p: public_handle)
 
-        Nodes::File.new(session, data).tap { |n| n.public_url = url }
-      end
+        raise "Invalid url or missing file key" unless key
 
-      def mega_url?(url)
-        !!(url.to_s =~ /^https:\/\/mega\.co\.nz\/#!.*$/i)
-      end
+        node = if url =~ FOLDER_URL_REGEXP
+          nodes_data = session.request({a: 'f', c: 1, r: 1}, {n: public_handle})
+          session.master_key = Utils.base64urldecode(key)
+          session.storage.nodes = nodes_data['f'].map { |data| Nodes::Factory.build(session, data) }
+          session.storage.nodes[0]
+        else
+          data = session.request(a: 'g', g: 1, p: public_handle)
+          Nodes::File.new(session, data)
+        end
 
-      def type(number)
-        founded_type = types.find { |k, v| number == v }
-        founded_type.first if founded_type
-      end
+        node.instance_variable_set('@public_handle', public_handle)
+        node.instance_variable_set('@public_url', url)
 
-      def types
-        {file: 0, folder: 1, root: 2, inbox: 3, trash: 4}
+        return node
       end
     end
   end

data/lib/rmega/nodes/file.rb

@@ -1,7 +1,3 @@
-require 'rmega/nodes/node'
-require 'rmega/nodes/deletable'
-require 'rmega/nodes/downloadable'
-
 module Rmega
   module Nodes
     class File < Node

data/lib/rmega/nodes/folder.rb

@@ -1,10 +1,3 @@
-require 'rmega/crypto/crypto'
-require 'rmega/utils'
-require 'rmega/nodes/node'
-require 'rmega/nodes/expandable'
-require 'rmega/nodes/traversable'
-require 'rmega/nodes/deletable'
-
 module Rmega
   module Nodes
     class Folder < Node
@@ -13,14 +6,11 @@ module Rmega
       include Deletable
 
       def download(path)
+        path = ::File.join(path, self.name)
+        FileUtils.mkdir_p(path)
+
         children.each do |node|
-          if node.type == :file
-            node.download path
-          elsif node.type == :folder
-            subfolder = ::File.expand_path ::File.join(path, node.name)
-            Dir.mkdir(subfolder) unless Dir.exists?(subfolder)
-            node.download subfolder
-          end
+          node.download(path)
         end
 
         nil

data/lib/rmega/nodes/inbox.rb

@@ -1,5 +1,3 @@
-require 'rmega/nodes/node'
-
 module Rmega
   module Nodes
     class Inbox < Node

data/lib/rmega/nodes/node.rb

@@ -1,17 +1,16 @@
-require 'rmega/loggable'
-require 'rmega/utils'
-require 'rmega/crypto/crypto'
-require 'rmega/nodes/traversable'
-
 module Rmega
   module Nodes
     class Node
+      include NotInspectable
       include Loggable
       include Traversable
+      include Crypto
 
       attr_reader :data, :session
 
-      delegate :storage, :request, :shared_keys, :rsa_privk, :to => :session
+      delegate :request, :shared_keys, :rsa_privk, :master_key, :storage, :to => :session
+
+      TYPES = {0 => :file, 1 => :folder, 2 => :root, 3 => :inbox, 4 => :trash}
 
       def initialize(session, data)
         @session = session
@@ -19,14 +18,7 @@ module Rmega
       end
 
       def public_url
-        @public_url ||= begin
-          b64_dec_key = Utils.a32_to_base64(decrypted_file_key[0..7])
-          "https://mega.co.nz/#!#{public_handle}!#{b64_dec_key}"
-        end
-      end
-
-      def public_url=(url)
-        @public_url = url
+        @public_url ||= "https://mega.co.nz/#!#{public_handle}!#{Utils.base64urlencode(decrypted_file_key)}"
       end
 
       def public_handle
@@ -51,13 +43,14 @@ module Rmega
         pairs = data['k'].split('/')
         pairs.inject({}) do |hash, pair|
           h, k = pair.split(':')
-          hash[h] = k
+          hash[h] = Utils.base64urldecode(k)
           hash
         end
       end
 
       def file_key
-        file_keys.values.first
+        k = file_keys.values.first
+        return k ? k : nil
       end
 
       def shared_root?
@@ -73,37 +66,67 @@ module Rmega
         return unless sk
 
         shared_key = if sk.size > 22
-          sk = Rmega::Utils.mpi2b(Rmega::Utils.base64urldecode(sk))
-          dec_sk = Rmega::Crypto::Rsa.decrypt(sk, rsa_privk)
-          Utils.str_to_a32(Rmega::Utils.b2s(dec_sk)[0..15])
+          # Decrypt sk
+          sk = Utils.base64_mpi_to_bn(sk)
+          sk = rsa_decrypt(sk, rsa_privk)
+          sk = sk.to_s(16)
+          sk = '0' + sk if sk.size % 2 > 0
+          Utils.hexstr_to_bstr(sk)[0..15]
         else
-          Crypto.decrypt_key session.master_key, Utils.base64_to_a32(data['sk'])
+          aes_ecb_decrypt(master_key, Utils.base64urldecode(sk))
         end
 
         shared_keys[handle] = shared_key
         [handle, shared_key]
       end
 
+      def self.each_chunk(size, &block)
+        start, p = 0, 0
+
+        return if size <= 0
+
+        loop do
+          offset = p < 8 ? (131072 * (p += 1)) : 1048576
+          next_start = offset + start
+
+          if next_start >= size
+            yield(start, size - start)
+            break
+          else
+            yield(start, offset)
+            start = next_start
+          end
+        end
+      end
+
+      def each_chunk(&block)
+        self.class.each_chunk(filesize, &block)
+      end
+
       def decrypted_file_key
         h, shared_key = *process_shared_key
 
         if shared_key
-          Crypto.decrypt_key(shared_key, Utils.base64_to_a32(file_keys[h]))
+          aes_ecb_decrypt(shared_key, file_keys[h])
         elsif file_key
-          Crypto.decrypt_key(session.master_key, Utils.base64_to_a32(file_key))
+          aes_ecb_decrypt(master_key, file_key)
         else
-          Utils.base64_to_a32(public_url.split('!').last)
+          Utils.base64urldecode(public_url.split('!').last)
         end
       end
 
       def attributes
         encrypted = data['a'] || data['at']
         return if !encrypted or encrypted.empty?
-        Crypto.decrypt_attributes(decrypted_file_key, encrypted)
+        node_key = NodeKey.load(decrypted_file_key)
+        encrypted = Utils.base64urldecode(encrypted)
+        encrypted.strip! if encrypted.size % 16 != 0 # Fix possible errors
+        json = aes_cbc_decrypt(node_key.aes_key, encrypted)
+        JSON.parse json.gsub(/^MEGA/, '').rstrip
       end
 
       def type
-        Factory.type(data['t'])
+        TYPES[data['t']]
       end
     end
   end

data/lib/rmega/nodes/node_key.rb

@@ -0,0 +1,44 @@
+module Rmega
+  module Nodes
+
+    # The key associated to a node. It can be 128 or 256 bits long,
+    # when is 256 bits long is composed by:
+    # * A 128 bit AES-128 key
+    # * The upper 64 bit of the counter start value (the lower 64 bit
+    #   are starting at 0 and incrementing by 1 for each AES block of 16
+    #   bytes)
+    # * A 64 bit meta-MAC of all chunk MACs
+    class NodeKey
+      attr_reader :aes_key, :ctr_nonce, :meta_mac
+      attr_accessor :meta_mac
+
+      def initialize(string)
+        @aes_key   = string[0..15]
+        @ctr_nonce = string[16..23]
+        @meta_mac  = string[24..31]
+      end
+
+      def generate
+        self.class.compact("#{@aes_key}#{@ctr_nonce}#{@meta_mac}") + @ctr_nonce + @meta_mac
+      end
+
+      # note: folder key is 16 bytes long while file key is 32
+      def self.load(string)
+        new("#{compact(string)}#{string[16..-1]}")
+      end
+
+      def self.compact(string)
+        if string.size > 16
+          bytes = string.bytes.to_a
+          return 16.times.inject([]) { |ary, i| ary[i] = bytes[i] ^ bytes[i+16]; ary }.map(&:chr).join
+        else
+          return string
+        end
+      end
+
+      def self.random
+        new(OpenSSL::Random.random_bytes(16 + 8 + 0))
+      end
+    end
+  end
+end

data/lib/rmega/nodes/root.rb

@@ -1,7 +1,3 @@
-require 'rmega/nodes/node'
-require 'rmega/nodes/expandable'
-require 'rmega/nodes/traversable'
-
 module Rmega
   module Nodes
     class Root < Node

data/lib/rmega/nodes/trash.rb

@@ -1,6 +1,3 @@
-require 'rmega/nodes/node'
-require 'rmega/nodes/traversable'
-
 module Rmega
   module Nodes
     class Trash < Node

data/lib/rmega/nodes/uploadable.rb

@@ -1,16 +1,18 @@
-require 'rmega/utils'
-require 'rmega/pool'
-require 'rmega/progress'
-
 module Rmega
   module Nodes
     module Uploadable
+      include Net
+
       def upload_chunk(base_url, start, buffer)
         size = buffer.length
         stop = start + size - 1
         url = "#{base_url}/#{start}-#{stop}"
 
-        HTTPClient.new.post(url, buffer).body
+        survive do
+          response = http_post(url, buffer)
+          raise("Upload failed") if response.code.to_i != 200
+          return response.body
+        end
       end
 
       def read_chunk(file, start, size)
@@ -18,65 +20,72 @@ module Rmega
         file.read(size)
       end
 
-      def encrypt_chunck(rnd_key, file_mac, start, clean_buffer)
-        nonce = [rnd_key[4], rnd_key[5], (start/0x1000000000) >> 0, (start/0x10) >> 0]
-
-        encrypted = Crypto::AesCtr.encrypt(rnd_key[0..3], nonce, clean_buffer)
-        chunk_mac, data = encrypted[:mac], encrypted[:data]
-
-        file_mac = [file_mac[0] ^ chunk_mac[0], file_mac[1] ^ chunk_mac[1],
-                    file_mac[2] ^ chunk_mac[2], file_mac[3] ^ chunk_mac[3]]
+      def encrypt_chunck(start, clean_buffer, aes_key, nonce)
+        iv = nonce + [start/0x1000000000, start/0x10].pack('l>*')
+        enc_data = aes_ctr_encrypt(aes_key, clean_buffer, iv)
 
-        file_mac = Crypto::Aes.encrypt(rnd_key[0..3], file_mac)
+        # calculate mac
+        mac_iv = nonce * 2
+        mac = aes_cbc_mac(aes_key, clean_buffer, mac_iv)
 
-        data
+        return [enc_data, mac]
       end
 
       def upload(path)
         path = ::File.expand_path(path)
         filesize = ::File.size(path)
+
+        raise "Empty file - #{path}" if filesize == 0
+
         file = ::File.open(path, 'rb')
 
-        ul_key = Crypto.random_key
-        file_mac = [0, 0, 0, 0]
+        rnd_node_key = NodeKey.random
         file_handle = nil
         base_url = upload_url(filesize)
 
         pool = Pool.new
         read_mutex = Mutex.new
 
-        progress = Progress.new(total: filesize, caption: 'Upload')
+        progress = Progress.new(filesize, caption: 'Upload')
+
+        chunk_macs = {}
 
-        Utils.chunks(filesize).each do |start, size|
-          pool.defer do
-            encrypted_buffer = nil
+        self.class.each_chunk(filesize) do |start, size|
+          pool.process do
+            clean_buffer = nil
 
             read_mutex.synchronize do
               clean_buffer = read_chunk(file, start, size)
-              encrypted_buffer = encrypt_chunck(ul_key, file_mac, start, clean_buffer)
             end
 
+            encrypted_buffer, chunk_mac = *encrypt_chunck(start, clean_buffer, rnd_node_key.aes_key, rnd_node_key.ctr_nonce)
             file_handle = upload_chunk(base_url, start, encrypted_buffer)
+            chunk_macs[start] = chunk_mac
+
             progress.increment(size)
           end
         end
 
-        pool.wait_done
-
-        attribs = {n: ::File.basename(path)}
-        encrypt_attribs = Utils.a32_to_base64(Crypto.encrypt_attributes(ul_key[0..3], attribs))
+        pool.shutdown
 
-        meta_mac = [file_mac[0] ^ file_mac[1], file_mac[2] ^ file_mac[3]]
+        # encrypt attributes
+        attributes_str = "MEGA"
+        attributes_str << {n: ::File.basename(path)}.to_json
+        attributes_str << ("\x00" * (16 - (attributes_str.size % 16)))
+        encrypted_attributes = aes_cbc_encrypt(rnd_node_key.aes_key, attributes_str)
 
-        key = [ul_key[0] ^ ul_key[4], ul_key[1] ^ ul_key[5], ul_key[2] ^ meta_mac[0],
-               ul_key[3] ^ meta_mac[1], ul_key[4], ul_key[5], meta_mac[0], meta_mac[1]]
+        # Calculate meta_mac
+        file_mac = aes_cbc_mac(rnd_node_key.aes_key, chunk_macs.sort.map(&:last).join, "\x0"*16)
+        rnd_node_key.meta_mac = Utils.compact_to_8_bytes(file_mac)
+        encrypted_key = aes_ecb_encrypt(session.master_key, rnd_node_key.generate)
 
-        encrypted_key = Utils.a32_to_base64 Crypto.encrypt_key(session.master_key, key)
-        request(a: 'p', t: handle, n: [{h: file_handle, t: 0, a: encrypt_attribs, k: encrypted_key}])
+        resp = request(a: 'p', t: handle, n: [
+          {h: file_handle, t: 0, a: Utils.base64urlencode(encrypted_attributes), k: Utils.base64urlencode(encrypted_key)}
+        ])
 
-        attribs[:n]
+        return Nodes::Factory.build(session, resp['f'][0])
       ensure
-        file.close
+        file.close if file
       end
     end
   end