rmega 0.1.7 → 0.2.0

data/lib/rmega/crypto/aes_ctr.rb

@@ -1,94 +1,25 @@
-require 'rmega/utils'
-require 'rmega/crypto/aes'
-
 module Rmega
   module Crypto
     module AesCtr
-      extend self
-
-      def decrypt(key, nonce, data)
-        raise "invalid nonce" if nonce.size != 4 or !nonce.respond_to?(:pack)
-        raise "invalid key" if key.size != 4 or !key.respond_to?(:pack)
-
-        nonce = nonce.dup
-
-        mac = [nonce[0], nonce[1], nonce[0], nonce[1]]
-        enc = nil
-        a32 = Utils.str_to_a32 data
-        len = a32.size - 3
-        last_i = 0
-
-        (0..len).step(4) do |i|
-          enc = Aes.encrypt key, nonce
-          4.times do |m|
-            a32[i+m] = (a32[i+m] || 0) ^ (enc[m] || 0)
-            mac[m] = (mac[m] || 0) ^ (a32[i+m] || 0)
-          end
-          mac = Aes.encrypt key, mac
-          nonce[3] += 1
-          nonce[2] += 1 if nonce[3] == 0
-          last_i = i + 4
-        end
-
-        if last_i < a32.size
-          v = [0, 0, 0, 0]
-          (last_i..a32.size - 1).step(1) { |m| v[m-last_i] = a32[m] || 0 }
-
-          enc = Aes.encrypt key, nonce
-          4.times { |m| v[m] = v[m] ^ enc[m] }
-
-          j = data.size & 15
-          m = Utils.str_to_a32 Array.new(j+1).join(255.chr)+Array.new(17-j).join(0.chr)
-
-          4.times { |x| mac[x] = mac[x] ^ (v[x] & m[x]) }
-
-          mac = Aes.encrypt key, mac
-
-          (last_i..a32.size - 1).step(1) { |j| a32[j] = v[j - last_i] || 0 }
-        end
-
-        decrypted_data = Utils.a32_to_str(a32, data.size)
-
-        {data: decrypted_data, mac: mac}
+      def aes_ctr_cipher
+        OpenSSL::Cipher::AES.new(128, :CTR)
       end
 
-      def encrypt(key, nonce, data)
-        raise "invalid nonce" if nonce.size != 4 or !nonce.respond_to?(:pack)
-        raise "invalid key" if key.size != 4 or !key.respond_to?(:pack)
-
-        ctr = nonce.dup
-        mac = [ctr[0], ctr[1], ctr[0], ctr[1]]
-        ab32 = Utils.str_to_a32 data
-        len = ab32.size - 3
-        enc = nil
-        last_i = 0
-
-        (0..len).step(4) do |i|
-          4.times { |x| mac[x] = mac[x] ^ (ab32[i+x] || 0) }
-          mac = Aes.encrypt key, mac
-          enc = Aes.encrypt key, ctr
-          4.times { |x|  ab32[i+x] = (ab32[i+x] || 0) ^ (enc[x] || 0) }
-          ctr[3] += 1
-          ctr[2] += 1 if ctr[3].zero?
-          last_i = i + 4
-        end
-
-        i = last_i
-
-        if i < ab32.size
-          v = [0, 0, 0, 0]
-          (i..ab32.size - 1).step(1) { |j| v[j - i] = ab32[j] || 0 }
-          4.times { |x| mac[x] = mac[x] ^ v[x] }
-          mac = Aes.encrypt key, mac
-          enc = Aes.encrypt key, ctr
-          4.times { |x| v[x] = v[x] ^ enc[x] }
-          (i..ab32.size - 1).step(1) { |j| ab32[j] = v[j - i] || 0 }
-        end
-
-        decrypted_data = Utils.a32_to_str ab32, data.size
-        {data: decrypted_data, mac: mac}
+      def aes_ctr_decrypt(key, data, iv)
+        cipher = aes_ctr_cipher
+        cipher.decrypt
+        cipher.iv = iv
+        cipher.key = key
+        return cipher.update(data) + cipher.final
       end
 
+      def aes_ctr_encrypt(key, data, iv)
+        cipher = aes_ctr_cipher
+        cipher.encrypt
+        cipher.iv = iv
+        cipher.key = key
+        return cipher.update(data) + cipher.final
+      end
     end
   end
 end

data/lib/rmega/crypto/aes_ecb.rb

@@ -0,0 +1,25 @@
+module Rmega
+  module Crypto
+    module AesEcb
+      def aes_ecb_cipher
+        OpenSSL::Cipher::AES.new(128, :ECB)
+      end
+
+      def aes_ecb_encrypt(key, data)
+        cipher = aes_ecb_cipher
+        cipher.encrypt
+        cipher.padding = 0
+        cipher.key = key
+        return cipher.update(data) + cipher.final
+      end
+
+      def aes_ecb_decrypt(key, data)
+        cipher = aes_ecb_cipher
+        cipher.decrypt
+        cipher.padding = 0
+        cipher.key = key
+        return cipher.update(data) + cipher.final
+      end
+    end
+  end
+end

data/lib/rmega/crypto/rsa.rb

@@ -1,20 +1,29 @@
-require 'execjs'
-
 module Rmega
   module Crypto
     module Rsa
-      extend self
-
-      def script_path
-        File.join File.dirname(__FILE__), 'rsa_mega.js'
-      end
-
-      def context
-        @context ||= ExecJS.compile File.read(script_path)
+      def powm(b, p, m)
+        if p == 1
+          b % m
+        elsif (p & 0x1) == 0
+          t = powm(b, p >> 1, m)
+          (t * t) % m
+        else
+          (b * powm(b, p-1, m)) % m
+        end
       end
 
-      def decrypt(t, privk)
-        context.call "RSAdecrypt", t, privk[2], privk[0], privk[1], privk[3]
+      def rsa_decrypt(m, pqdu)
+        p, q, d, u = pqdu
+        if p && q && u
+          m1 = powm(m, d % (p - 1), p)
+          m2 = powm(m, d % (q - 1), q)
+          h = m2 - m1
+          h = h + q if h < 0
+          h = h * u % q
+          h * p + m1
+        else
+          pow_m(m, d, p * q)
+        end
       end
     end
   end

data/lib/rmega/errors.rb

@@ -1,55 +1,7 @@
 module Rmega
-  module Errors
-
-    # Check out the error codes list at https://mega.co.nz/#doc (section 11)
-    CODES = {
-      -1  => 'An internal error has occurred. Please submit a bug report, detailing the exact circumstances in which this error occurred.',
-      -2  => 'You have passed invalid arguments to this command.',
-      -3  => 'A temporary congestion or server malfunction prevented your request from being processed. No data was altered. Retry. Retries must be spaced with exponential backoff.',
-      -4  => 'You have exceeded your command weight per time quota. Please wait a few seconds, then try again (this should never happen in sane real-life applications).',
-      -5  => 'The upload failed. Please restart it from scratch.',
-      -6  => 'Too many concurrent IP addresses are accessing this upload target URL.',
-      -7  => 'The upload file packet is out of range or not starting and ending on a chunk boundary.',
-      -8  => 'The upload target URL you are trying to access has expired. Please request a fresh one.',
-      -9  => 'Object (typically, node or user) not found',
-      -10 => 'Circular linkage attempted',
-      -11 => 'Access violation (e.g., trying to write to a read-only share)',
-      -12 => 'Trying to create an object that already exists',
-      -13 => 'Trying to access an incomplete resource',
-      -14 => 'A decryption operation failed (never returned by the API)',
-      -15 => 'Invalid or expired user session, please relogin',
-      -16 => 'User blocked',
-      -17 => 'Request over quota',
-      -18 => 'Resource temporarily not available, please try again later',
-      -19 => 'Too many connections on this resource',
-      -20 => 'Write failed',
-      -21 => 'Read failed',
-      -22 => 'Invalid application key; request not processed',
-    }.freeze
-
-    class ServerError < StandardError
-      attr_reader :code, :message
-      attr_accessor :temporary
-
-      def initialize(value, opts = {})
-        if msg = Errors::CODES[value.to_i]
-          @code = value.to_i
-          @message = msg || "Error code #{@code}"
-        else
-          @message = value
-        end
-
-        self.temporary = opts[:temporary] || false
-
-        super(@message)
-      end
-
-      def temporary?
-        self.temporary || [-3, -18, -6].include?(@code)
-      end
-    end
+  class ServerError < StandardError
   end
 
-  # Backward compatibility
-  RequestError = Errors::ServerError
+  class TemporaryServerError < StandardError
+  end
 end

data/lib/rmega/loggable.rb

@@ -1,6 +1,3 @@
-require 'logger'
-require 'active_support/concern'
-
 module Rmega
   def self.logger
     @logger ||= begin

data/lib/rmega/net.rb

@@ -0,0 +1,56 @@
+module Rmega
+  module Net
+    include Loggable
+    include Options
+
+    def survive(retries = options.max_retries, &block)
+      yield
+    rescue ServerError
+      raise
+    rescue Exception => error
+      retries -= 1
+      raise(error) if retries < 0
+      logger.debug("[#{error.class}] #{error.message}. #{retries} attempt(s) left.")
+      sleep(options.retry_interval)
+      retry
+    end
+
+    def http_get_content(url)
+      uri = URI(url)
+      req = ::Net::HTTP::Get.new(uri.request_uri)
+      return send_http_request(uri, req).body
+    end
+
+    def http_post(url, data)
+      uri = URI(url)
+      req = ::Net::HTTP::Post.new(uri.request_uri)
+      req.body = data
+      logger.debug("REQ POST #{url} #{cut_string(data)}")
+      response = send_http_request(uri, req)
+      logger.debug("REP #{response.code} #{cut_string(response.body)}")
+      return response
+    end
+
+    private
+
+    def send_http_request(uri, req)
+      http = ::Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.scheme == 'https'
+      apply_http_options(http)
+      return http.request(req)
+    end
+
+    def apply_http_options(http)
+      http.proxy_from_env = false if options.http_proxy_address
+
+      options.marshal_dump.each do |name, value|
+        setter_method = name.to_s.split('http_')[1]
+        http.__send__("#{setter_method}=", value) if setter_method and value
+      end
+    end
+
+    def cut_string(string, max = 50)
+      string.size <= max ? string : string[0..max-1]+"..."
+    end
+  end
+end

data/lib/rmega/nodes/deletable.rb

@@ -1,6 +1,3 @@
-require 'rmega/utils'
-require 'rmega/crypto/crypto'
-
 module Rmega
   module Nodes
     module Deletable

data/lib/rmega/nodes/downloadable.rb

@@ -1,17 +1,45 @@
-require 'rmega/pool'
-require 'rmega/utils'
-
 module Rmega
   module Nodes
     module Downloadable
+      include Net
+      include Options
 
       # Creates the local file allocating filesize-n bytes (of /dev/zero) for it.
       # Opens the local file to start writing from the beginning of it.
       def allocate(path)
-        `dd if=/dev/zero of="#{path}" bs=1 count=0 seek=#{filesize} > /dev/null 2>&1`
-        raise "Unable to create file #{path}" if ::File.size(path) != filesize
+        unless allocated?(path)
+          `dd if=/dev/zero of="#{path}" bs=1 count=0 seek=#{filesize} > /dev/null 2>&1`
+          raise "Unable to allocate space for file #{path}" if ::File.size(path) != filesize
+        end
+
+        @file = ::File.open(path, 'r+b')
+        @file.rewind
+      end
+
+      def file_io_synchronize(&block)
+        @file_io_mutex ||= Mutex.new
+        @file_io_mutex.synchronize(&block)
+      end
+
+      def allocated?(path)
+        ::File.exists?(path) and ::File.size(path) == filesize
+      end
+
+      # Writes a buffer in the local file, starting from the start-n byte.
+      def write_chunk(start, buffer)
+        file_io_synchronize do
+          @file.seek(start)
+          @file.write(buffer)
+        end
+      end
 
-        ::File.open(path, 'r+b').tap { |f| f.rewind }
+      def read_chunk(start, size)
+        file_io_synchronize do
+          @file.seek(start)
+          data = @file.read(size)
+          @file.seek(start)
+          return (data == "\x0"*size) ? nil : data
+        end
       end
 
       # Downloads a part of the remote file, starting from the start-n byte
@@ -19,52 +47,67 @@ module Rmega
       def download_chunk(start, size)
         stop = start + size - 1
         url = "#{storage_url}/#{start}-#{stop}"
-        HTTPClient.new.get_content(url)
+
+        survive do
+          data = http_get_content(url)
+          raise("Unexpected data length") if data.size != size
+          return data
+        end
       end
 
-      # Writes a buffer in the local file, starting from the start-n byte.
-      def write_chunk(file, start, buffer)
-        file.seek(start)
-        file.write(buffer)
+      def decrypt_chunk(start, data)
+        iv = @node_key.ctr_nonce + [start/0x1000000000, start/0x10].pack('l>*')
+        return aes_ctr_decrypt(@node_key.aes_key, data, iv)
       end
 
-      def decrypt_chunk(start, encrypted_buffer)
-        k = decrypted_file_key
-        nonce = [k[4], k[5], (start/0x1000000000) >> 0, (start/0x10) >> 0]
-        decrypt_key = [k[0] ^ k[4], k[1] ^ k[5], k[2] ^ k[6], k[3] ^ k[7]]
-        Crypto::AesCtr.decrypt(decrypt_key, nonce, encrypted_buffer)[:data]
+      def calculate_chunck_mac(data)
+        mac_iv = @node_key.ctr_nonce * 2
+        return aes_cbc_mac(@node_key.aes_key, data, mac_iv)
       end
 
       def download(path)
         path = ::File.expand_path(path)
         path = Dir.exists?(path) ? ::File.join(path, name) : path
 
-        logger.info "Download #{name} (#{filesize} bytes) => #{path}"
-
+        progress = Progress.new(filesize, caption: 'Download')
         pool = Pool.new
-        write_mutex = Mutex.new
-        file = allocate(path)
 
-        progress = Progress.new(total: filesize, caption: 'Download')
+        @resumed_download = allocated?(path)
+        allocate(path)
+        @node_key = NodeKey.load(decrypted_file_key)
 
-        Utils.chunks(filesize).each do |start, size|
-          pool.defer do
-            encrypted_buffer = download_chunk(start, size)
+        chunk_macs = {}
 
-            write_mutex.synchronize do
-              clean_buffer = decrypt_chunk(start, encrypted_buffer)
+        each_chunk do |start, size|
+          pool.process do
+            data = @resumed_download ? read_chunk(start, size) : nil
+
+            if data
+              chunk_macs[start] = calculate_chunck_mac(data) if options.file_integrity_check
+              progress.increment(size, real: false)
+            else
+              data = decrypt_chunk(start, download_chunk(start, size))
+              chunk_macs[start] = calculate_chunck_mac(data) if options.file_integrity_check
+              write_chunk(start, data)
               progress.increment(size)
-              write_chunk(file, start, clean_buffer)
             end
           end
         end
 
         # waits for the last running threads to finish
-        pool.wait_done
+        pool.shutdown
+
+        if options.file_integrity_check
+          file_mac = aes_cbc_mac(@node_key.aes_key, chunk_macs.sort.map(&:last).join, "\x0"*16)
+
+          if Utils.compact_to_8_bytes(file_mac) != @node_key.meta_mac
+            raise("Checksum failed. File corrupted?")
+          end
+        end
 
-        file.flush
+        return nil
       ensure
-        file.close rescue nil
+        @file.close rescue nil
       end
     end
   end