rmega 0.0.2

data/lib/rmega/node.rb

@@ -0,0 +1,128 @@
+module Rmega
+  class Node
+    attr_reader :data, :session
+
+    def initialize session, data
+      @session = session
+      @data = data
+    end
+
+    def self.initialize_by_public_url session, public_url
+      public_handle, key = public_url.split('!')[1, 2]
+      data = session.request a: 'g', g: 1, p: public_handle
+      node = new session, data
+      node.instance_variable_set '@public_url', public_url
+      node
+    end
+
+    def self.types
+      {file: 0, dir: 1, root: 2, inbox: 3, trash: 4}
+    end
+
+
+    # Member actions
+
+    def public_url
+      return @public_url if @public_url
+      return nil if type != :file
+      b64_dec_key = Utils.a32_to_base64 decrypted_file_key[0..7]
+      "https://mega.co.nz/#!#{public_handle}!#{b64_dec_key}"
+    end
+
+    def trash
+      trash_node_public_handle = session.storage.trash_node.public_handle
+      session.request a: 'm', n: handle, t: trash_node_public_handle
+    end
+
+
+    # Other methods
+
+    def public_handle
+      @public_handle ||= session.request(a: 'l', n: handle)
+    end
+
+    def handle
+      data['h']
+    end
+
+    def filesize
+      data['s']
+    end
+
+    def owner_key
+      data['k'].split(':').first
+    end
+
+    def name
+      return attributes['n'] if attributes
+    end
+
+    def file_key
+      data['k'].split(':').last
+    end
+
+    def decrypted_file_key
+      if data['k']
+        Crypto.decrypt_key session.master_key, Utils.base64_to_a32(file_key)
+      else
+        Utils.base64_to_a32 public_url.split('!').last
+      end
+    end
+
+    def can_decrypt_attributes?
+      !data['u'] or data['u'] == owner_key
+    end
+
+    def attributes
+      @attributes ||= begin
+        return nil unless can_decrypt_attributes?
+        Crypto.decrypt_attributes decrypted_file_key, (data['a'] || data['at'])
+      end
+    end
+
+    def type
+      founded_type = self.class.types.find { |k, v| data['t'] == v }
+      founded_type.first if founded_type
+    end
+
+    def delete
+      session.request a: 'd', n: handle
+    end
+
+    def storage_url
+      @storage_url ||= data['g'] || session.request(a: 'g', g: 1, n: handle)['g']
+    end
+
+    def chunks
+      Storage.chunks filesize
+    end
+
+    def download path
+      path = File.expand_path path
+      path = Dir.exists?(path) ? File.join(path, name) : path
+
+      Utils.show_progress :download, filesize
+
+      k = decrypted_file_key
+      k = [k[0] ^ k[4], k[1] ^ k[5], k[2] ^ k[6], k[3] ^ k[7]]
+      nonce = decrypted_file_key[4..5]
+
+      file = File.open path, 'wb'
+      connection = HTTPClient.new.get_async storage_url
+      message = connection.pop
+
+      chunks.each do |chunk_start, chunk_size|
+        buffer = message.content.read chunk_size
+        # TODO: should be (chunk_start/0x1000000000) >>> 0, (chunk_start/0x10) >>> 0
+        nonce = [nonce[0], nonce[1], (chunk_start/0x1000000000) >> 0, (chunk_start/0x10) >> 0]
+        decryption_result = Crypto::AesCtr.decrypt(k, nonce, buffer)
+        file.write(decryption_result[:data])
+        Utils.show_progress :download, filesize, chunk_size
+      end
+
+      nil
+    ensure
+      file.close if file
+    end
+  end
+end

data/lib/rmega/session.rb

@@ -0,0 +1,78 @@
+module Rmega
+  class Session
+    attr_accessor :email, :request_id, :sid, :master_key
+
+    def initialize email, password_str
+      self.email = email
+      self.request_id = random_request_id
+
+      login password_str
+    end
+
+    def debug message
+      Rmega.logger.debug message
+    end
+
+
+    # Delegate to Rmega.options
+
+    def options
+      Rmega.options
+    end
+
+    def api_request_timeout
+      options.api_request_timeout
+    end
+
+    def api_url
+      options.api_url
+    end
+
+
+    # Cache the Storage class
+
+    def storage
+      @storage ||= Storage.new self
+    end
+
+
+    # Login-related methods
+
+    def login password_str
+      uh = Crypto.stringhash Crypto.prepare_key_pw(password_str), email
+      resp = request a: 'us', user: email, uh: uh
+
+      # Decrypt the master key
+      encrypted_key = Crypto.prepare_key_pw password_str
+      self.master_key = Crypto.decrypt_key encrypted_key, Utils.base64_to_a32(resp['k'])
+
+      # Generate the session id
+      self.sid = Crypto.decrypt_sid master_key, resp['csid'], resp['privk']
+    end
+
+
+    # Api requests methods
+
+    def random_request_id
+      rand(1E7..1E9).to_i
+    end
+
+    def error_response? response
+      response = response.first if response.respond_to? :first
+      !!Integer(response) rescue false
+    end
+
+    def request body
+      self.request_id += 1
+      url = "#{api_url}?id=#{request_id}"
+      url << "&sid=#{sid}" if sid
+      debug "POST #{url}"
+      debug "#{body.inspect}"
+      response = HTTPClient.new.post url, [body].to_json, timeout: api_request_timeout
+      debug "#{response.code}\n#{response.body}"
+      resp = JSON.parse(response.body).first
+      raise "Error code received: #{resp}" if error_response?(resp)
+      resp
+    end
+  end
+end

data/lib/rmega/storage.rb

@@ -0,0 +1,146 @@
+module Rmega
+  class Storage
+
+    attr_reader :session
+
+    def initialize session
+      @session = session
+    end
+
+    def logger
+      Rmega.logger
+    end
+
+
+    # Quota-related methods
+
+    def used_space
+      quota['cstrg']
+    end
+
+    def total_space
+      quota['mstrg']
+    end
+
+    def quota
+      session.request a: 'uq', strg: 1
+    end
+
+
+    # Nodes finders
+
+    def nodes
+      nodes = session.request a: 'f', c: 1
+      nodes['f'].map { |node_data| Node.new(session, node_data) }
+    end
+
+    def nodes_by_type type
+      nodes.select { |n| n.type == type }
+    end
+
+    def nodes_by_name name_regexp
+      nodes.select do |node|
+        node.name and node.name =~ name_regexp
+      end
+    end
+
+    def trash_node
+      @trash ||= nodes_by_type(:trash).first
+    end
+
+    def root_node
+      @root_node ||= nodes_by_type(:root).first
+    end
+
+
+    # Handle node download
+
+    def self.chunks size
+      list = {}
+      p = 0
+      pp = 0
+      i = 1
+
+      while i <= 8 and p < size - (i * 0x20000)
+        list[p] = i * 0x20000
+        pp = p
+        p += list[p]
+        i += 1
+      end
+
+      while p < size
+        list[p] = 0x100000
+        pp = p
+        p += list[p]
+      end
+
+      if size - pp > 0
+        list[pp] = size - pp
+      end
+      list
+    end
+
+    def download public_url, path
+      Node.initialize_by_public_url(session, public_url).download path
+    end
+
+
+    # Handle file upload
+
+    def upload_url filesize
+      session.request(a: 'u', s: filesize)['p']
+    end
+
+    def upload_chunk url, start, chunk
+      response = HTTPClient.new.post "#{url}/#{start}", chunk, timeout: Rmega.options.upload_timeout
+      response.body
+    end
+
+    def upload local_path, parent_node = root_node
+      local_path = File.expand_path local_path
+      filesize = File.size local_path
+      upld_url = upload_url filesize
+
+      ul_key = Array.new(6).map { rand(0..0xFFFFFFFF) }
+      aes_key = ul_key[0..3]
+      nonce = ul_key[4..5]
+      local_file = File.open local_path, 'rb'
+      file_handle = nil
+      file_mac = [0, 0, 0, 0]
+
+      Utils.show_progress :upload, filesize
+
+      self.class.chunks(filesize).each do |chunk_start, chunk_size|
+        buffer = local_file.read chunk_size
+
+        # TODO: should be (chunk_start/0x1000000000) >>> 0, (chunk_start/0x10) >>> 0
+        nonce = [nonce[0], nonce[1], (chunk_start/0x1000000000) >> 0, (chunk_start/0x10) >> 0]
+
+        encrypted_buffer = Crypto::AesCtr.encrypt aes_key, nonce, buffer
+        chunk_mac = encrypted_buffer[:mac]
+
+        file_handle = upload_chunk upld_url, chunk_start, encrypted_buffer[: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]]
+        file_mac = Crypto::Aes.encrypt ul_key[0..3], file_mac
+        Utils.show_progress :upload, filesize, chunk_size
+      end
+
+      attribs = {n: File.basename(local_path)}
+      encrypt_attribs = Utils.a32_to_base64 Crypto.encrypt_attributes(ul_key[0..3], attribs)
+
+      meta_mac = [file_mac[0] ^ file_mac[1], file_mac[2] ^ file_mac[3]]
+
+      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]]
+
+      encrypted_key = Utils.a32_to_base64 Crypto.encrypt_key(session.master_key, key)
+      session.request a: 'p', t: parent_node.handle, n: [{h: file_handle, t: 0, a: encrypt_attribs, k: encrypted_key}]
+
+      nil
+    ensure
+      local_file.close if local_file
+    end
+  end
+end

data/lib/rmega/utils.rb

@@ -0,0 +1,197 @@
+module Rmega
+  module Utils
+    extend self
+
+    def show_progress direction, total, increment = 0
+      return unless Rmega.options.show_progress
+      @progressbar_progress = 0 if increment.zero?
+      @progressbar_progress += increment
+      format = "#{direction.to_s.capitalize} in progress #{Utils.format_bytes(@progressbar_progress)} of #{Utils.format_bytes(total)} | %P% | %e        "
+      @progressbar ||= ProgressBar.create format: format, total: total
+      @progressbar.reset if increment.zero?
+      @progressbar.format format
+      @progressbar.progress += increment
+    end
+
+    def format_bytes bytes, round = 2
+      units = ['bytes', 'kb', 'MB', 'GB', 'TB', 'PB']
+      e = (bytes == 0 ? 0 : Math.log(bytes)) / Math.log(1024)
+      value = bytes.to_f / (1024 ** e.floor)
+      "#{value.round(round)}#{units[e]}"
+    end
+
+    def str_to_a32 string
+      pad_to = string.bytesize + ((string.bytesize) % 4)
+      string = string.ljust pad_to, "\x00"
+      string.unpack 'l>*'
+    end
+
+    def a32_to_str a32, len=nil
+      if len
+        b = []
+        len.times do |i|
+          # TODO: should be ((a32[i>>2] >>> (24-(i & 3)*8)) & 255)
+          b << (((a32[i>>2] || 0) >> (24-(i & 3)*8)) & 255)
+        end
+        b.pack 'C*'
+      else
+        a32.pack 'l>*'
+      end
+    end
+
+    def b64a
+      @b64a ||= ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ["-", "_", "="]
+    end
+
+    def a32_to_base64 a32
+      base64urlencode a32_to_str(a32)
+    end
+
+    def base64_to_a32 base64
+      str_to_a32 base64urldecode(base64)
+    end
+
+    def base64urlencode string
+      i = 0
+      tmp_arr = []
+
+      while i < string.size + 1
+        o1 = string[i].ord rescue 0
+        i += 1
+        o2 = string[i].ord rescue 0
+        i += 1
+        o3 = string[i].ord rescue 0
+        i += 1
+
+        bits = o1 << 16 | o2 << 8 | o3
+
+        h1 = bits >> 18 & 0x3f
+        h2 = bits >> 12 & 0x3f
+        h3 = bits >> 6 & 0x3f
+        h4 = bits & 0x3f
+
+        tmp_arr.push b64a[h1] + b64a[h2] + b64a[h3] + b64a[h4]
+      end
+
+      enc = tmp_arr.join ''
+      r = string.size % 3
+      (r != 0) ? enc[0..r - 4] : enc
+    end
+
+    def base64urldecode data
+      data += '=='[((2-data.length*3)&3)..-1]
+
+      i = 0
+      ac = 0
+      dec = ""
+      tmp_arr = []
+
+      return data unless data
+
+      while i < data.size
+        h1 = b64a.index(data[i]) || -1
+        i += 1
+        h2 = b64a.index(data[i]) || -1
+        i += 1
+        h3 = b64a.index(data[i]) || -1
+        i += 1
+        h4 = b64a.index(data[i]) || -1
+        i += 1
+
+        bits = (h1 << 18) | (h2 << 12) | (h3 << 6) | h4
+
+        o1 = bits >> 16 & 0xff
+        o2 = bits >> 8 & 0xff
+        o3 = bits & 0xff
+
+        if h3 == 64
+          tmp_arr[ac] = o1.chr
+        elsif h4 == 64
+          tmp_arr[ac] = o1.chr + o2.chr
+        else
+          tmp_arr[ac] = o1.chr + o2.chr + o3.chr
+        end
+
+        ac += 1
+      end
+
+      tmp_arr.join ''
+    end
+
+    def mpi2b s
+      bn = 1
+      r = [0]
+      rn = 0
+      sb = 256
+      sn = s.size
+      bm = 268435455
+      c = nil
+
+      return 0 if sn < 2
+
+      len = (sn - 2) * 8
+      bits = s[0].ord * 256 + s[1].ord
+
+      return 0 if bits > len or bits < len - 8
+
+      len.times do |n|
+        sb = sb << 1
+
+        if sb > 255
+          sb = 1
+          c = s[sn -= 1].ord
+        end
+
+        if bn > bm
+          bn = 1
+          r[rn += 1] = 0
+        end
+
+        if (c & sb) and (c & sb != 0)
+          r[rn] = r[rn] ? (r[rn] | bn) : bn
+        end
+
+        bn = bn << 1
+      end
+      r
+    end
+
+    def b2s b
+      bs = 28
+      bm = 268435455
+      bn = 1; bc = 0; r = [0]; rb = 1; rn = 0
+      bits = b.length * bs
+      rr = ''
+
+      bits.times do |n|
+        if (b[bc] & bn) and (b[bc] & bn) != 0
+          r[rn] = r[rn] ? (r[rn] | rb) : rb
+        end
+
+        rb = rb << 1
+
+        if rb > 255
+          rb = 1
+          r[rn += 1] = 0
+        end
+
+        bn = bn << 1
+
+        if bn > bm
+          bn = 1
+          bc += 1
+        end
+      end
+
+      while rn >= 0 && r[rn] == 0
+        rn -= 1
+      end
+
+      (rn + 1).times do |n|
+        rr = r[n].chr + rr
+      end
+
+      rr
+    end
+  end
+end