rmega 0.1.7 → 0.2.0

data/lib/rmega/not_inspectable.rb

@@ -0,0 +1,10 @@
+module Rmega
+  module NotInspectable
+    def inspect(attributes = {})
+      memaddr = (__send__(:object_id) << 1).to_s(16)
+      string = "#<#{self.class.name}:#{memaddr}"
+      attributes.each { |k, v| string << " #{k}=#{v}" }
+      string << ">"
+    end
+  end
+end

data/lib/rmega/options.rb

@@ -1,12 +1,15 @@
-require 'ostruct'
-
 module Rmega
   def self.default_options
     {
-      upload_timeout:       120,
+      thread_pool_size:     4,
       max_retries:          10,
-      retry_interval:       1,
-      api_request_timeout:  20,
+      retry_interval:       3,
+      http_open_timeout:    180,
+      http_read_timeout:    180,
+      # http_proxy_address:   '127.0.0.1',
+      # http_proxy_port:      8080,
+      show_progress:        true,
+      file_integrity_check: true,
       api_url:              'https://eu.api.mega.co.nz/cs'
     }
   end
@@ -14,4 +17,18 @@ module Rmega
   def self.options
     @options ||= OpenStruct.new(default_options)
   end
+
+  module Options
+    extend ActiveSupport::Concern
+
+    def options
+      Rmega.options
+    end
+
+    module ClassMethods
+      def options
+        Rmega.options
+      end
+    end
+  end
 end

data/lib/rmega/pool.rb

@@ -1,29 +1,36 @@
-require 'thread'
-
 module Rmega
   class Pool
-    MAX = 4
+    include Options
 
-    def initialize(max = MAX)
-      Thread.abort_on_exception = true
+    def initialize
+      threads_raises_exceptions
 
       @mutex = Mutex.new
       @resource = ConditionVariable.new
-      @max = max || MAX
+      @max = options.thread_pool_size
 
       @running = []
       @queue = []
     end
 
+    def threads_raises_exceptions
+      Thread.abort_on_exception = true
+    end
+
     def defer(&block)
       synchronize { @queue << block }
       process_queue
     end
 
+    alias :process :defer
+
     def wait_done
+      return if done?
       synchronize { @resource.wait(@mutex) }
     end
 
+    alias :shutdown :wait_done
+
     private
 
     def synchronize(&block)
@@ -47,10 +54,14 @@ module Rmega
       synchronize { @resource.signal }
     end
 
+    def thread_terminated
+      synchronize { @running.reject! { |thread| thread == Thread.current } }
+    end
+
     def thread_proc(&block)
       Proc.new do
         block.call
-        @running.reject! { |thread| thread == Thread.current }
+        thread_terminated
         process_queue
         signal_done if done?
       end

data/lib/rmega/progress.rb

@@ -1,28 +1,61 @@
 module Rmega
   class Progress
+    include Options
 
-    def initialize(params)
-      @total = params[:total]
-      @caption = params[:caption]
+    def initialize(total, options = {})
+      @total = total
+      @caption = options[:caption]
       @bytes = 0
+      @real_bytes = 0
+      @mutex = Mutex.new
       @start_time = Time.now
 
       show
     end
 
+    def show?
+      options.show_progress
+    end
+
     def show
-      percentage = (100.0 * @bytes / @total).round(2)
+      return unless show?
 
-      message = "[#{@caption}] #{humanize(@bytes)} of #{humanize(@total)}"
+      message = @caption ? "[#{@caption}] " : ""
+      message << "#{humanize_bytes(@bytes)} of #{humanize_bytes(@total)}"
 
       if ended?
         message << ". Completed in #{elapsed_time} sec.\n"
       else
-        message << " (#{percentage}%)"
+        message << ", #{percentage}% @ #{humanize_bytes(speed, 1)}/s, #{options.thread_pool_size} threads"
+      end
+
+      print_r(message)
+    end
+
+    def stty_size_columns
+      return @stty_size_columns unless @stty_size_columns.nil?
+      @stty_size_columns ||= (`stty size`.split[1].to_i rescue false)
+    end
+
+    def columns
+      stty_size_columns || 80
+    end
+
+    def print_r(message)
+      if message.size + 10 > columns
+        puts message
+      else
+        blank_line = ' ' * (message.size + 10)
+        print "\r#{blank_line}\r#{message}"
       end
+    end
+
+    def percentage
+      (100.0 * @bytes / @total).round(2)
+    end
 
-      blank_line = ' ' * (message.size + 15)
-      print "\r#{blank_line}\r#{message}"
+    def speed
+      @real_bytes.to_f / (Time.now - @start_time).to_f
     end
 
     def elapsed_time
@@ -33,17 +66,24 @@ module Rmega
       @total == @bytes
     end
 
-    def increment(bytes)
-      @bytes += bytes
-      show
+    def increment(bytes, options = {})
+      @mutex.synchronize do
+        @bytes += bytes
+        @real_bytes += bytes unless options[:real] == false
+        show
+      end
+    end
+
+    def humanize_bytes(*args)
+      self.class.humanize_bytes(*args)
     end
 
-    def humanize(bytes, round = 2)
+    def self.humanize_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]}"
+      return "#{value.round(round)} #{units[e]}"
     end
   end
 end

data/lib/rmega/session.rb

@@ -1,82 +1,155 @@
-require 'rmega/storage'
-require 'rmega/errors'
-require 'rmega/crypto/crypto'
-require 'rmega/utils'
-
 module Rmega
-  def self.login(email, password)
-    Session.new(email, password).storage
-  end
-
   class Session
+    include NotInspectable
     include Loggable
+    include Net
+    include Options
+    include Crypto
+    extend Crypto
 
-    attr_reader :email, :request_id, :sid, :master_key, :shared_keys, :rsa_privk
+    attr_reader :request_id, :sid, :shared_keys, :rsa_privk
+    attr_accessor :master_key
 
-    def initialize(email, password)
-      @email = email
+    def initialize
       @request_id = random_request_id
       @shared_keys = {}
+    end
 
-      login(password)
+    def storage
+      @storage ||= Storage.new(self)
     end
 
-    def options
-      Rmega.options
+    def decrypt_rsa_private_key(encrypted_privk)
+      privk = aes_ecb_decrypt(@master_key, Utils.base64urldecode(encrypted_privk))
+
+      # Decompose private key
+      decomposed_key = []
+
+      4.times do
+        len = ((privk[0].ord * 256 + privk[1].ord + 7) >> 3) + 2
+        privk_part = privk[0, len]
+        decomposed_key << Utils.string_to_bignum(privk[0..len-1][2..-1])
+        privk = privk[len..-1]
+      end
+
+      return decomposed_key
     end
 
-    delegate :api_url, :api_request_timeout, to: :options
-    delegate :max_retries, :retry_interval, to: :options
+    def hash_password(password)
+      self.class.hash_password(password)
+    end
 
-    def storage
-      @storage ||= Storage.new(self)
+    def self.hash_password(password)
+      pwd = password.dup.force_encoding('BINARY')
+      pkey = "\x93\xc4\x67\xe3\x7d\xb0\xc7\xa4\xd1\xbe\x3f\x81\x1\x52\xcb\x56".force_encoding('BINARY')
+      null_byte = "\x0".force_encoding('BINARY').freeze
+      blank = (null_byte*16).force_encoding('BINARY').freeze
+      keys = {}
+
+      65536.times do
+        (0..pwd.size-1).step(16) do |j|
+
+          keys[j] ||= begin
+            key = blank.dup
+            16.times { |i| key[i] = pwd[i+j] || null_byte if i+j < pwd.size }
+            key
+          end
+
+          pkey = aes_ecb_encrypt(keys[j], pkey)
+        end
+      end
+
+      return pkey
+    end
+
+    def decrypt_session_id(csid)
+      csid = Utils.base64_mpi_to_bn(csid)
+      csid = rsa_decrypt(csid, @rsa_privk)
+      csid = csid.to_s(16)
+      csid = '0' + csid if csid.length % 2 > 0
+      csid = Utils.hexstr_to_bstr(csid)[0,43]
+      csid = Utils.base64urlencode(csid)
+      return csid
+    end
+
+    def user_hash(aes_key, email)
+      s_bytes = email.bytes.to_a
+      hash = Array.new(16, 0)
+      s_bytes.size.times { |n| hash[n & 15] = hash[n & 15] ^ s_bytes[n] }
+      hash = hash.pack('c*')
+      16384.times { hash = aes_ecb_encrypt(aes_key, hash) }
+      hash = hash[0..4-1] + hash[8..12-1]
+      return Utils.base64urlencode(hash)
     end
 
-    def login(password)
-      uh = Crypto.stringhash Crypto.prepare_key_pw(password), email.downcase
-      resp = request(a: 'us', user: email, uh: uh)
+    # If the user_hash is found on the server it returns:
+    # * The user master_key (128 bit for AES) encrypted with the password_hash
+    # * The RSA private key ecrypted with the master_key
+    # * A brand new session_id encrypted with the RSA private key
+    def login(email, password)
+      # Derive an hash from the user password
+      password_hash = hash_password(password)
+      u_hash = user_hash(password_hash, email.strip.downcase)
 
-      # Decrypts the master key
-      encrypted_key = Crypto.prepare_key_pw(password)
-      @master_key = Crypto.decrypt_key(encrypted_key, Utils.base64_to_a32(resp['k']))
+      resp = request(a: 'us', user: email.strip, uh: u_hash)
+
+      @master_key = aes_cbc_decrypt(password_hash, Utils.base64urldecode(resp['k']))
+      @rsa_privk = decrypt_rsa_private_key(resp['privk'])
+      @sid = decrypt_session_id(resp['csid'])
+      @shared_keys = {}
 
-      # Generates the session id
-      @rsa_privk = Crypto.decrypt_rsa_privk(@master_key, resp['privk'])
-      @sid = Crypto.decrypt_sid(@rsa_privk, resp['csid'])
+      return self
     end
 
-    def random_request_id
-      rand(1E7..1E9).to_i
+    def ephemeral_login(user_handle, password)
+      resp = request(a: 'us', user: user_handle)
+
+      password_hash = hash_password(password)
+
+      @master_key = aes_cbc_decrypt(password_hash, Utils.base64urldecode(resp['k']))
+      @sid = resp['tsid']
+      @rsa_privk = nil
+      @shared_keys = {}
+
+      return self
     end
 
-    def request_url
-      "#{api_url}?id=#{@request_id}".tap do |url|
-        url << "&sid=#{@sid}" if @sid
-      end
+    def self.ephemeral
+      master_key = OpenSSL::Random.random_bytes(16)
+      password = OpenSSL::Random.random_bytes(16)
+      password_hash = hash_password(password)
+      challenge = OpenSSL::Random.random_bytes(16)
+
+      session = new
+
+      user_handle = session.request(a: 'up', k: Utils.base64urlencode(aes_ecb_encrypt(password_hash, master_key)),
+        ts: Utils.base64urlencode(challenge + aes_ecb_encrypt(master_key, challenge)))
+
+      return session.ephemeral_login(user_handle, password)
     end
 
-    def request(content, retries = max_retries)
-      @request_id += 1
-      logger.debug "POST #{request_url} #{content.inspect}"
+    def random_request_id
+      rand(1E7..1E9).to_i
+    end
 
-      response = HTTPClient.new.post(request_url, [content].to_json, timeout: api_request_timeout)
-      code, body = response.code.to_i, response.body
+    def request_url(params = {})
+      params = params.merge(sid: @sid) if @sid
+      params = params.to_a.map { |a| a.join("=") }.join("&")
+      params = "&#{params}" unless params.empty?
 
-      logger.debug("#{code} #{body}")
+      return "#{options.api_url}?id=#{@request_id}#{params}"
+    end
 
-      if code == 500 && body.to_s.empty?
-        raise Errors::ServerError.new("Server too busy", temporary: true)
-      else
-        json = JSON.parse(body).first
-        raise Errors::ServerError.new(json) if json.to_s =~ /\A\-\d+\z/
-        json
+    def request(body, query_params = {})
+      survive do
+        @request_id += 1
+        api_response = APIResponse.new(http_post(request_url(query_params), [body].to_json))
+        if api_response.ok?
+          return(api_response.as_json)
+        else
+          raise(api_response.as_error)
+        end
       end
-    rescue SocketError, Errors::ServerError => error
-      raise(error) if retries < 0
-      raise(error) if error.respond_to?(:temporary?) && !error.temporary?
-      retries -= 1
-      sleep(retry_interval)
-      retry
     end
   end
 end

data/lib/rmega/storage.rb

@@ -1,8 +1,8 @@
-require 'rmega/nodes/factory'
-
 module Rmega
   class Storage
+    include NotInspectable
     include Loggable
+    include Crypto
 
     attr_reader :session
 
@@ -20,14 +20,34 @@ module Rmega
       quota['mstrg']
     end
 
+    def stats
+      stats_hash = {files: 0, size: 0}
+
+      nodes.each do |n|
+        next unless n.type == :file
+        stats_hash[:files] += 1
+        stats_hash[:size] += n.filesize
+      end
+
+      return stats_hash
+    end
+
     def quota
       session.request(a: 'uq', strg: 1)
     end
 
+    def nodes=(list)
+      @nodes = list
+    end
+
     def nodes
+      return @nodes if @nodes
+
       results = session.request(a: 'f', c: 1)
 
-      store_shared_keys(results['ok'] || [])
+      (results['ok'] || []).each do |hash|
+        shared_keys[hash['h']] ||= aes_ecb_decrypt(master_key, Utils.base64urldecode(hash['k']))
+      end
 
       (results['f'] || []).map do |node_data|
         node = Nodes::Factory.build(session, node_data)
@@ -36,12 +56,8 @@ module Rmega
       end
     end
 
-    def folders
-      list = nodes
-      root_handle = list.find { |node| node.type == :root }.handle
-      list.select do |node|
-        node.shared_root? || (node.type == :folder && node.parent_handle == root_handle)
-      end
+    def shared
+      nodes.select { |node| node.shared_root? }
     end
 
     def trash
@@ -51,17 +67,5 @@ module Rmega
     def root
       @root ||= nodes.find { |n| n.type == :root }
     end
-
-    def download(public_url, path)
-      Nodes::Factory.build_from_url(session, public_url).download(path)
-    end
-
-    private
-
-    def store_shared_keys(list)
-      list.each do |hash|
-        shared_keys[hash['h']] = Crypto.decrypt_key(master_key, Utils.base64_to_a32(hash['k']))
-      end
-    end
   end
 end