megar 0.0.2 → 0.0.3

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.0.3 put and get ready                          9-Mar-2013
+===========================================================
+* basic file upload support added
+
 0.0.2 little more hearty release                 2-Mar-2013
 ===========================================================
 * basic file download support added

data/README.rdoc

@@ -12,9 +12,7 @@ Consider this totally alpha at this point, especially since the Mega API has yet
 
 * Currently tested with MRI 1.9.3
 * Requires OpenSSL 1.0.1+ (and properly linked with ruby)
-* MRI 1.9.2 and 2.x not yet tested
-* Rubinius and JRuby 1.9 modes not yet tested
-* No plans to support 1.8 Ruby branches
+* MRI 1.9.2 and 2.x, Rubinius and JRuby 1.9 modes not yet tested. No plans to support 1.8 Ruby modes.
 
 Mega API coverage is far from complete at this point (help appreciated!). Here's the run-down:
 
@@ -22,7 +20,11 @@ Supported API functions:
 * User/session management: Complete accounts
 * Login session challenge/response
 * Retrieve file and folder nodes
-* Request download URL (and download file contents)
+* Request download URL
+* Download files
+* Download file message authentication codes ({MAC}[http://en.wikipedia.org/wiki/Message_authentication_code])
+* Request upload URL
+* Upload files
 
 Currently unsupported API functions:
 * User/session management: Ephemeral accounts
@@ -35,7 +37,6 @@ Currently unsupported API functions:
 * Create/delete public handle
 * Create/modify/delete outgoing share
 * Key handling - Set or request share/node keys
-* Request upload URL
 * Add/update user
 * Get user
 * Retrieve user's public key
@@ -198,6 +199,35 @@ Once you have a file object (e.g. <tt>session.files.first</tt>):
   file = session.files.first
   file.body # returns the full decrypted body content
 
+=== How to upload a file
+
+Uploading a new file is performed using the <tt>create</tt> method of a folder of the files collection. For example:
+
+  # get a handle to the file you want to upload e.g.
+  file_handle = Pathname.new('../path/to/my_file.png')
+
+  # create the file in the root (Cloud Drive) folder:
+  session.root.create( body: file_handle )
+
+  # or this also implicitly creates the file in the root folder:
+  session.files.create( body: file_handle )
+
+  # or to create the file in a specific folder (e.g. 'My Images'):
+  session.folders.find_by_name('My Images').create( body: file_handle )
+
+The <tt>file_handle</tt> can actually be any suitable file name, Pathname or File object.
+
+If you want to change the name of the file as stored in Mega, you can also provide a <tt>name</tt> parameter:
+
+  session.files.create( name: 'with a new name.png', body: file_handle )
+
+Once a file has been uploaded successfully, it will also be available in the local files catalog:
+
+  session.files.create( body: file_handle, name: 'new_file.png' )
+  => true
+  session.files.find_by_name('new_file.png')
+  => returns new file catalog entry
+
 
 === CLI: How to use the command-line client
 
@@ -211,6 +241,9 @@ All operations require credentials to ba passed on the command line (email and p
     Connecting to mega as my@email.com..
     Connected!
 
+Note: If you just want to do a little hacking around, {megar_rt}[https://github.com/tardate/megar_rt]
+is an easy way to bootstrap an isolated environment and be up and running super fast.
+
 
 === CLI: How to get a file listing
 
@@ -228,13 +261,31 @@ Use the <tt>get</tt> command:
 
     $ megar --email=my@email.com --password=mypassword get L0xHwayA
     Connecting to mega as my@email.com..
-    Downloading L0xHwayA to mega.png...
+    Downloading L0xHwayA to mega.png..
 
 Note: this is very simple interface at the moment:
 * you can only identify the file by the ID (not name)
 * it downloads and saves using the same name as on the server
 * and it doesn't check if you are overwriting a local file
-* no file integrity testing yet
+
+
+=== CLI: How to upload a file
+
+Use the <tt>put</tt> command:
+
+    $ megar --email=my@email.com --password=mypassword put ../path/to/my_file.png
+    Connecting to mega as my@email.com..
+    Uploading my_file.png..
+
+This uploads a file into the root folder by default, and keeps the same file name.
+
+Standard command-line expansions work, so to upload multiple files, you can do this:
+
+    $ megar --email=my@email.com --password=mypassword put *.png
+    Connecting to mega as my@email.com..
+    Uploading my_file_1.png..
+    Uploading my_file_2.png..
+    (etc for all files matching *.png)
 
 
 === How to run tests

data/lib/megar/adapters.rb

@@ -1 +1,2 @@
-require 'megar/adapters/file_downloader'
+require 'megar/adapters/file_downloader'
+require 'megar/adapters/file_uploader'

data/lib/megar/adapters/file_downloader.rb

@@ -29,16 +29,18 @@ class Megar::FileDownloader
   def content
     return unless live_session?
     decoded_content = ''
+    calculated_mac = [0, 0, 0, 0]
+
+    decryptor = get_file_decrypter(decomposed_key,iv)
 
-    # TODO here: init mac calculation (perhaps should be an option to use of not)
-    decryptor = session.get_file_decrypter(file.decomposed_key,iv)
     get_chunks(download_size).each do |chunk_start, chunk_size|
       chunk = stream.readpartial(chunk_size)
       decoded_chunk = decryptor.update(chunk)
       decoded_content << decoded_chunk
-      # TODO here: calculate chunk mac
+      calculated_mac = accumulate_mac(decoded_chunk,calculated_mac,decomposed_key,chunk_mac_iv)
     end
-    # TODO here: perform integrity check against expected file mac
+
+    raise Megar::MacVerificationError.new unless ([calculated_mac[0] ^ calculated_mac[1], calculated_mac[2] ^ calculated_mac[3]] == mac)
 
     decoded_content
   end
@@ -62,13 +64,32 @@ class Megar::FileDownloader
   # Returns the decrypted download attributes
   def download_attributes
     if attributes = download_url_response['at']
-      decrypt_file_attributes(attributes,file.decomposed_key)
+      decrypt_file_attributes(attributes,decomposed_key)
     end
   end
 
   # Returns the initialisation vector
   def iv
-    @iv ||= file.key[4,2] + [0, 0]
+    @iv ||= key[4,2] + [0, 0]
+  end
+
+  def chunk_mac_iv
+    [iv[0], iv[1], iv[0], iv[1]]
+  end
+
+  # Returns the expected MAC for the file
+  def mac
+    key[6,2]
+  end
+
+  # Returns the file key (shortcut)
+  def key
+    file.key
+  end
+
+  # Returns the file key (shortcut)
+  def decomposed_key
+    file.decomposed_key
   end
 
   # Returns the initial value for AES counter
@@ -92,41 +113,4 @@ class Megar::FileDownloader
     !!(session && file)
   end
 
-  # Returns an array of chunk sizes given total file +size+
-  #
-  # Chunk boundaries are located at the following positions:
-  # 0 / 128K / 384K / 768K / 1280K / 1920K / 2688K / 3584K / 4608K / ... (every 1024 KB) / EOF
-  def get_chunks(size)
-    chunks = []
-    p = pp = 0
-    i = 1
-
-    while i <= 8 and p < size - i * 0x20000 do
-      chunk_size =  i * 0x20000
-      chunks << [p, chunk_size]
-      pp = p
-      p += chunk_size
-      i += 1
-    end
-
-    while p < size - 0x100000 do
-      chunk_size =  0x100000
-      chunks << [p, chunk_size]
-      pp = p
-      p += chunk_size
-    end
-
-    chunks << [p, size - p] if p < size
-
-    chunks
-  end
-
-  def calculate_chunk_mac(iv,chunk)
-    chunk_mac = [iv[0], iv[1], iv[0], iv[1]]
-    (1..chunk.length).take(16).each do |bit|
-      # NYI
-    end
-    chunk_mac
-  end
-
 end

data/lib/megar/adapters/file_uploader.rb

@@ -0,0 +1,148 @@
+require 'open-uri'
+require 'net/http'
+require 'pathname'
+
+# Encapsulates a file upload task. This is intended as a one-shot helper.
+#
+# NB: there seems to be an issue if you try to upload
+# multiple files of exactly the same size in the same session.
+#
+# Javascript reference implementation: function initupload3()
+#
+class Megar::FileUploader
+  include Megar::CryptoSupport
+
+  attr_reader :folder
+  attr_reader :session
+  attr_reader :body
+  attr_writer :name
+
+  def initialize(options={})
+    @folder = options[:folder]
+    @session = @folder && @folder.session
+    self.body = options[:body]
+    self.name = options[:name]
+  end
+
+  def body=(value)
+    @body = case value
+    when File
+      value
+    when Pathname
+      File.open(value,'rb')
+    when String
+      if value.size < 1024  # theoretically, a path name could be even longer but we'll assume
+        # see if its a file name
+        File.open(value,'rb')
+      end
+    when NilClass
+    else
+      raise Megar::UnsupportedFileHandleTypeError.new
+    end
+  end
+
+  # Returns the size of the file content
+  def upload_size
+    body.size
+  end
+
+  # Returns stream handle to the file body
+  def stream
+    body
+  end
+
+  # Returns the name of the file
+  def name
+    @name ||= Pathname.new(body.path).basename.to_s
+  end
+
+  # Command: perform upload
+  def post!
+    return unless live_session?
+    calculated_mac = [0, 0, 0, 0]
+    completion_file_handle = ''
+
+    encryptor = get_file_encrypter(upload_key,iv_str)
+
+    get_chunks(upload_size).each do |chunk_start, chunk_size|
+      chunk = stream.readpartial(chunk_size)
+      encrypted_chunk = encryptor.update(chunk)
+      calculated_mac = accumulate_mac(chunk,calculated_mac,mac_encryption_key,mac_iv,false)
+      completion_file_handle = post_chunk(encrypted_chunk,chunk_start)
+    end
+    stream.close
+    meta_mac = [calculated_mac[0] ^ calculated_mac[1], calculated_mac[2] ^ calculated_mac[3]]
+
+    upload_attributes_response = send_file_upload_attributes(meta_mac,completion_file_handle)
+    if upload_attributes_response.is_a?(Hash) && upload_attributes_response['f']
+      session.handle_files_response(upload_attributes_response,false)
+    else
+      raise Megar::FileUploadError.new
+    end
+  end
+
+  # upload chunk
+  def post_chunk(encrypted_chunk,chunk_start)
+    Net::HTTP.start(upload_uri.host, upload_uri.port) { |http|
+      path = "#{upload_uri.path}/#{chunk_start}"
+      response = http.post(path,encrypted_chunk)
+      response.body
+    }
+  end
+  protected :post_chunk
+
+  def send_file_upload_attributes(meta_mac,completion_file_handle)
+    session.send_file_upload_attributes(folder.id,name,upload_key,meta_mac,completion_file_handle)
+  end
+  protected :send_file_upload_attributes
+
+  # Returns an upload url for the file content
+  def upload_url
+    upload_url_response['p']
+  end
+
+  # Returns an upload url for the file content as a URI
+  def upload_uri
+    @upload_uri ||= URI.parse(upload_url)
+  end
+
+  def upload_key
+    @upload_key ||= 6.times.each_with_object([]) {|i,memo| memo << rand( 0xFFFFFFFF) }
+  end
+
+  # Returns the encryption key to use for calculating the MAC
+  def mac_encryption_key
+    upload_key[0,4]
+  end
+
+  # Returns the initialisation vector as array of 32bit integer to use for calculating the MAC
+  def mac_iv
+    [upload_key[4], upload_key[5], upload_key[4], upload_key[5]]
+  end
+
+  def iv
+    ((upload_key[4]<<32)+upload_key[5])<<64
+  end
+
+  def iv_str
+    hexstr_to_bstr( iv.to_s(16) )
+  end
+
+  # Returns and caches a file upload response
+  def upload_url_response
+    @upload_url_response ||= if live_session?
+      session.get_file_upload_url_response(upload_size)
+    else
+      {}
+    end
+  end
+
+  protected
+
+  # Returns true if live session/folder properly set
+  def live_session?
+    !!(session && folder)
+  end
+
+
+end

data/lib/megar/catalog/catalog_item.rb

@@ -42,10 +42,17 @@ module Megar::CatalogItem
   #   4: Special node: Trash Bin
   attr_accessor :type
 
+  # Returns the default parent folder (default is nil)
+  def default_parent_folder
+  end
+
   # Returns a handle to the enclosing folder (if any)
   def parent_folder
-    if session && parent_folder_id
+    return unless session
+    if parent_folder_id
       session.folders.find_by_id(parent_folder_id)
+    else
+      default_parent_folder
     end
   end
 

data/lib/megar/catalog/files.rb

@@ -2,4 +2,26 @@
 class Megar::Files
   include Megar::CatalogItem
 
+  # Command: creates a new file given +attributes+ which contains the following elements:
+  #   body: the file body. May be a Pathname, File, or filename (String)
+  #   name: the file name to assign (optional if already available from the body object)
+  #
+  # The file is stored in the parent folder (or root folder by defult)
+  def create(attributes)
+    if uploader = self.uploader(attributes)
+      uploader.post!
+    end
+  end
+
+  protected
+
+  # Returns the default parent folder (default is root)
+  def default_parent_folder
+    session && session.folders.root
+  end
+
+  def uploader(attributes)
+    Megar::FileUploader.new(attributes.merge(folder: parent_folder))
+  end
+
 end

data/lib/megar/catalog/folder.rb

@@ -29,4 +29,21 @@ class Megar::Folder
     session.files.find_all_by_parent_folder_id(id)
   end
 
+  # Command: creates a new file given +attributes+ which contains the following elements:
+  #   body: the file body. May be a Pathname, File, or filename (String)
+  #   name: the file name to assign (optional if already available from the body object)
+  #
+  # The file is stored in the parent folder (or root folder by defult)
+  def create(attributes)
+    if uploader = self.uploader(attributes)
+      uploader.post!
+    end
+  end
+
+  protected
+
+  def uploader(attributes)
+    Megar::FileUploader.new(attributes.merge(folder: self))
+  end
+
 end

data/lib/megar/crypto/support.rb

@@ -52,6 +52,16 @@ module Megar::CryptoSupport
     b
   end
 
+  # Javascript reference implementation: function encrypt_key(cipher,a)
+  #
+  def encrypt_key(a, key)
+    b=[]
+    (0..(a.length-1)).step(4) do |i|
+      b.concat aes_cbc_encrypt_a32(a[i,4], key)
+    end
+    b
+  end
+
   # Returns decrypted array of 32-bit integers representation of base64 +data+ decrypted using +key+
   def decrypt_base64_to_a32(data,key)
     decrypt_key(base64_to_a32(data), key)
@@ -75,12 +85,12 @@ module Megar::CryptoSupport
     # e.unpack('l>*')
   end
 
-  # Returns AES-128 decrypted given +key+ and +data+ (arrays of 32-bit signed integers)
+  # Returns AES-128 CBC decrypted given +key+ and +data+ (arrays of 32-bit signed integers)
   def aes_cbc_decrypt_a32(data, key)
     str_to_a32(aes_cbc_decrypt(a32_to_str(data), a32_to_str(key)))
   end
 
-  # Returns AES-128 decrypted given +key+ and +data+ (String)
+  # Returns AES-128 CBC decrypted given +key+ and +data+ (String)
   def aes_cbc_decrypt(data, key)
     aes = OpenSSL::Cipher::Cipher.new('AES-128-CBC')
     aes.decrypt
@@ -92,14 +102,36 @@ module Megar::CryptoSupport
     d
   end
 
+  # Returns AES-128 CBC decrypted given +key+ and +data+ (arrays of 32-bit signed integers)
+  def aes_cbc_encrypt_a32(data, key, signed=true)
+    str_to_a32(aes_cbc_encrypt(a32_to_str(data), a32_to_str(key)),signed)
+  end
+
+  # Returns AES-128 CBC encrypted given +key+ and +data+ (String)
+  def aes_cbc_encrypt(data, key)
+    aes = OpenSSL::Cipher::Cipher.new('AES-128-CBC')
+    aes.encrypt
+    aes.padding = 0
+    aes.key = key
+    aes.iv = "\0" * 16
+    d = aes.update(data)
+    d = aes.final if d.empty?
+    d
+  end
+
   # Returns an array of 32-bit signed integers representing the string +b+
   #
   # Javascript reference implementation: function str_to_a32(b)
   #
-  def str_to_a32(b)
+  def str_to_a32(b,signed=true)
     a = Array.new((b.length+3) >> 2,0)
     b.length.times { |i| a[i>>2] |= (b.getbyte(i) << (24-(i & 3)*8)) }
-    a.pack('l>*').unpack('l>*') # hack to force to signed 32-bit ... I don't think we really need to do this, but it makes comparison with
+    if signed
+      # hack to force to signed 32-bit ... I don't think we really need to do this, but it makes comparison with
+      a.pack('l>*').unpack('l>*')
+    else
+      a
+    end
   end
 
   # Returns a packed string given an array +a+ of 32-bit signed integers
@@ -395,6 +427,18 @@ module Megar::CryptoSupport
     JSON.parse( rstr.gsub("\x0",'').gsub(/^.*{/,'{'))
   end
 
+  # Returns encrypted file attributes given encrypted +attributes+ and decomposed file +key+
+  #
+  # Javascript reference implementation: function enc_attr(attr,key)
+  #
+  def encrypt_file_attributes(attributes, key)
+    rstr = 'MEGA' + attributes.to_json
+    if (mod = rstr.length % 16) > 0
+      rstr << "\x0" * (16 - mod)
+    end
+    aes_cbc_encrypt(rstr, a32_to_str(key))
+  end
+
   # Returns a decomposed file +key+
   #
   # Javascript reference implementation: function startdownload2(res,ctx)
@@ -408,7 +452,37 @@ module Megar::CryptoSupport
     ]
   end
 
-  # Returns AES CTR-mode decryption cipher
+
+  # Returns an array of chunk sizes given total file +size+
+  #
+  # Chunk boundaries are located at the following positions:
+  # 0 / 128K / 384K / 768K / 1280K / 1920K / 2688K / 3584K / 4608K / ... (every 1024 KB) / EOF
+  def get_chunks(size)
+    chunks = []
+    p = pp = 0
+    i = 1
+
+    while i <= 8 and p < size - i * 0x20000 do
+      chunk_size =  i * 0x20000
+      chunks << [p, chunk_size]
+      pp = p
+      p += chunk_size
+      i += 1
+    end
+
+    while p < size - 0x100000 do
+      chunk_size =  0x100000
+      chunks << [p, chunk_size]
+      pp = p
+      p += chunk_size
+    end
+
+    chunks << [p, size - p] if p < size
+
+    chunks
+  end
+
+  # Returns AES CTR-mode decryption cipher given +key+ and +iv+ as array of int
   #
   def get_file_decrypter(key,iv)
     aes = OpenSSL::Cipher::Cipher.new('AES-128-CTR')
@@ -419,4 +493,48 @@ module Megar::CryptoSupport
     aes
   end
 
+  # Returns AES CTR-mode encryption cipher given +key+ as array of int and +iv+ as binary string
+  #
+  def get_file_encrypter(key,iv)
+    aes = OpenSSL::Cipher::Cipher.new('AES-128-CTR')
+    aes.encrypt
+    aes.padding = 0
+    aes.key = a32_to_str(key)
+    aes.iv = iv
+    aes
+  end
+
+  # Returns the +chunk+ mac (array of unsigned int)
+  #
+  def calculate_chunk_mac(chunk,key,iv,signed=false)
+    chunk_mac = iv
+    (0..chunk.length-1).step(16).each do |i|
+      block = chunk[i,16]
+      if (mod = block.length % 16) > 0
+        block << "\x0" * (16 - mod)
+      end
+      block = str_to_a32(block,signed)
+      chunk_mac = [
+        chunk_mac[0] ^ block[0],
+        chunk_mac[1] ^ block[1],
+        chunk_mac[2] ^ block[2],
+        chunk_mac[3] ^ block[3]
+      ]
+      chunk_mac = aes_cbc_encrypt_a32(chunk_mac, key, signed)
+    end
+    chunk_mac
+  end
+
+  # Calculates the accummulated MAC given new +chunk+
+  def accumulate_mac(chunk,progressive_mac,key,iv,signed=true)
+    chunk_mac = calculate_chunk_mac(chunk,key,iv,signed)
+    combined_mac = [
+      progressive_mac[0] ^ chunk_mac[0],
+      progressive_mac[1] ^ chunk_mac[1],
+      progressive_mac[2] ^ chunk_mac[2],
+      progressive_mac[3] ^ chunk_mac[3]
+    ]
+    aes_cbc_encrypt_a32(combined_mac, key, signed)
+  end
+
 end

data/lib/megar/exception.rb

@@ -6,6 +6,15 @@ module Megar
   # Raised when crypto requirements are not met by the ruby platform we're running on
   class CryptoSupportRequirementsError < Error; end
 
+  # Raised when MAC fails verification test
+  class MacVerificationError < Error; end
+
+  # Raised when unsupported file type passed to create/update a file
+  class UnsupportedFileHandleTypeError < Error; end
+
+  # Raised on non-API related file upload errors
+  class FileUploadError < Error; end
+
   class MegaRequestError < Error
 
     # Initialise with +error_code+ returned from Mega

data/lib/megar/session.rb

@@ -98,6 +98,57 @@ class Megar::Session
     api_request({'a' => 'g', 'g' => 1, 'n' => node_id})
   end
 
+  # Command: requests file upload url from the API for the file of +size+
+  def get_file_upload_url_response(size)
+    ensure_connected!
+    api_request({'a' => 'u', 's' => size})
+  end
+
+  # Command: sends updated attributes following file upload to the API
+  def send_file_upload_attributes(folder_id,name,upload_key,meta_mac,completion_file_handle)
+    attribs = {'n' => name}
+    encrypt_attribs = base64urlencode(encrypt_file_attributes(attribs, upload_key[0,4]))
+
+    key = [upload_key[0] ^ upload_key[4], upload_key[1] ^ upload_key[5],
+           upload_key[2] ^ meta_mac[0], upload_key[3] ^ meta_mac[1],
+           upload_key[4], upload_key[5], meta_mac[0], meta_mac[1]]
+
+    encrypted_key = a32_to_base64(encrypt_key(key, master_key))
+    api_request({
+      'a' => 'p',
+      't' => folder_id,
+      'n' => [{
+        'h' => completion_file_handle,
+        't' => 0,
+        'a' => encrypt_attribs,
+        'k' => encrypted_key
+      }]
+    })
+  end
+
+  # Command: decrypt/decode the login +response_data+ received from Mega
+  #
+  def handle_files_response(response_data,reset=true)
+    reset_files! if reset
+    response_data['f'].each do |f|
+      item_attributes = {id: f['h'], payload: f.dup, type: f['t'] }
+      case f['t']
+      when 0 # File
+        item_attributes[:key] = k = decrypt_file_key(f)
+        item_attributes[:decomposed_key] = key = decompose_file_key(k)
+        item_attributes[:attributes] = decrypt_file_attributes(f['a'],key)
+        files.add(item_attributes)
+      when 1 # Folder
+        item_attributes[:key] = k = decrypt_file_key(f)
+        item_attributes[:attributes] = decrypt_file_attributes(f['a'],k)
+        folders.add(item_attributes)
+      when 2,3,4 # Root, Inbox, Trash Bin
+        folders.add(item_attributes)
+      end
+    end
+    true
+  end
+
   protected
 
   # Command: enforces guard condition requiring authenticated connection to proceed
@@ -147,27 +198,4 @@ class Megar::Session
     api_request({'a' => 'f', 'c' => 1})
   end
 
-  # Command: decrypt/decode the login +response_data+ received from Mega
-  #
-  def handle_files_response(response_data)
-    reset_files!
-    response_data['f'].each do |f|
-      item_attributes = {id: f['h'], payload: f.dup, type: f['t'] }
-      case f['t']
-      when 0 # File
-        item_attributes[:key] = k = decrypt_file_key(f)
-        item_attributes[:decomposed_key] = key = decompose_file_key(k)
-        item_attributes[:attributes] = decrypt_file_attributes(f['a'],key)
-        files.add(item_attributes)
-      when 1 # Folder
-        item_attributes[:key] = k = decrypt_file_key(f)
-        item_attributes[:attributes] = decrypt_file_attributes(f['a'],k)
-        folders.add(item_attributes)
-      when 2,3,4 # Root, Inbox, Trash Bin
-        folders.add(item_attributes)
-      end
-    end
-    true
-  end
-
 end

data/lib/megar/shell.rb

@@ -30,6 +30,8 @@ class Megar::Shell
         ls
       when /get/i
         get(args[1])
+      when /put/i
+        put(args.drop(1))
       else
         $stderr.puts "Connected!"
       end
@@ -63,10 +65,13 @@ Commands:
   (none)                 : will perform a basic connection test only
   ls                     : returns a full file listing
   get file_id            : downloads the file with id file_id
+  put file_name          : uploads the file called "file_name"
 
 Examples:
   megar --email=my@mail.com --password=MyPassword ls
   megar -e my@mail.com -p MyPassword ls
+  megar -e my@mail.com -p MyPassword get 74ZTXbyR
+  megar -e my@mail.com -p MyPassword put ../path/to/my_file.png
 
 EOS
     end
@@ -77,12 +82,14 @@ EOS
     self.class.usage
   end
 
+  # do file listing
   def ls
     session.files.each do |file|
       puts file
     end
   end
 
+  # download file with +file_id+
   def get(file_id)
     if file = session.files.find_by_id(file_id)
       $stderr.puts "Downloading #{file_id} to #{file.name}.."
@@ -94,6 +101,14 @@ EOS
     end
   end
 
+  # upload file(s) +filenames+
+  def put(filenames)
+    Array(filenames).each do |filename|
+      $stderr.puts "Uploading #{filename}.."
+      session.files.create(body: filename)
+    end
+  end
+
   def session
     @session ||= Megar::Session.new(email: email, password: password)
   end

data/lib/megar/version.rb

@@ -1,3 +1,3 @@
 module Megar
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/fixtures/crypto_expectations/sample_user.json

@@ -1,12 +1,12 @@
 {
   "email": "megartest@gmail.com",
   "email_mixed_case": "Megartest@gmail.com",
-  "password": "ToLlw2D748TqCVAmrc8laio1",
+  "password": "NEvfEM5xME7jAnr6YN9JZH8M",
   "autoconnect": false,
   "login_response_data": {
-    "csid": "CAA1bK6vGGR02BJCb8CfkaeI7F1kIUyvLSXZFXzlFIrsWIp0kw7GgCUZbqN_zE9z4_eV-g5Vl8GyC--TYwUZ1JigVwNPTWEncqk0qdUmmv1SpOcbOu-Z0Z5-GWnTK2oxSp8nKPBn0UGBvf98hQ3KD1uhjEFBrJbNdAgbHc8BGTaYvE0dHNtIE1Zz7bulDDg798Rjj1eGH5bC1vEZDQ_uI7l-wBRtXsCCdXAo6GZEyzr-dcpYInPL-Sy8ZY10RU67E-x_-v_sEUqyN69EHyENk97XzL0arGvXbnGNVH4OhdjynQ1csIlcmvbNQ5kAe9KjJTIT9NeVnmSAjao3AAbIfvRj",
+    "csid": "CABObd6kRiw5JF_4Fr7z2R_tleh8g3jlsiGl3fX48C3MFq57ni86x3cVOgtNgv48N5ZX_68g-MROc_5j6TP3g2FTBpOhMRf2E4swTAwBQxa0CF04dj6hfHKHIp5XyE1KPGN57GvecLzTV6FgtanY1v41Pm_1H6PE89XSejovQIGOOKwsmeUOlmfLYreMe58Il1aROqzr6E-eybD8BzozQgy8XMO80Gcc6eoja0VbbxehHPdCYS990tAWBYkG8up-rnQqwpln-UrmtZbXtv4WoNO5n3wI4s5abyQl7PbG_42xw9Uk2QYwvIrRSnt4rDB8m-iAihGS7Zp6QQO5RVpuWvU1",
     "privk": "4Iurk4vQ0BlLEEvEyaRUX8QnYzJFIedm0RVKe2pLh4wTzBBtgmafnszD_dP3Y40P-DSNLEGfWghL-0_BIW4XP8tfGNFkMg7mnYgQYC91ccz58BbhGEDf7-j97dstckf3OSSsT9D9H-cocXzyt1m231w9d7YLX23c3KAGz3vxdnl66F4jsFGO9AdIyb1KTEEt7NHkljtbz3WgWlk6W6wBawuEbJvLPHPx2L16i0iacbbkQi8ZF4pmddswMa9yWOSXwUribGDbdgx_jDGjBoKJUJI-7Aa-aOaRPEoVUTft2R2lNAVErvYwD_GIsIhQiCcJWul-KqPhI3vquvzUHd2rHHvKyTLyvXKyIDeVdBGXTaqFA2ni9xsjUNMOX14ftBZ4_fgDce0jvrZzYRs5IuOMt3K9gKMpBpUWtnlaBYbnYdL2zJuFlrM77PlcYab2uLLqlSe4hh-FxMAc_p_8tDAoU4dPgpgOpU3GRR8i7oszu_MKibzNpRBeAX1UtwKwQepjPnipu9aQlPy9OtgB-5KmGi34EcMKBPg8BN6vHRYg0Za_lk_TtTQ4WbkllAqR3Fla5-RBjzB7f3dWae4ES3VX4f-dI-UYrrKDQkqaS0R_xLaMPNG6_GQMDM7L5Fsa8I3hFjdgfs9rV4Xf_uIFrhUjm25EuT5JCdobNmwBi9VU5nCbk0LQJdrXDNYV3fmD-Y_p_KV8x_-opRnXUV03SCopOD6DhitsFtpv065QXcG1SNDu0mM-kgDh9E-QddtQQtXLLPuKFyX5o1ts08EqXTxHsZo5tIsevbExZoz9hxSRrr-V5swEDcJXoV78_k6sR3iniZ_m77JVo9QU572av2MvNhyu5YeTXyc0m6Me7cPGiO0",
-    "k": "x1EvGzxu16FpfYajxFSFWQ"
+    "k": "0sdW36PBOcqicUJ7814isw"
   },
   "master_key": [
     384287193,
@@ -14,8 +14,8 @@
     554881366,
     530403344
   ],
-  "expected_uh": "4h8kPReRUug",
-  "sid": "tRUhX2shZiPr8hl2KRGXJ3pBOEN6Q2Y5dFp3lh5A8mZnlSFgTcLOChMkLg",
+  "expected_uh": "FeGJgLm4ciM",
+  "sid": "gVes6vS8WZ2c-CB7HJRdXHpBOEN6Q2Y5dFp3CQbFwprvxr0nkhb_XTqQrA",
   "rsa_private_key_b64": "BACOQ7VCjwkiwYCKhqRRvPTMBaQ5Yx2_sszj6ILrxrTBOJ2bu-9LsOSvaGz0HpnM2lXpJg3h6QWJdlQBOhwvfeafHg7rcEaaDuUWONifv5ABpQgeoAij6cgARMvFiOdjarMvu954Eduup8PHcgfjsBSu76qpu3UqkZCpBpByAYU1oQQA1i5oxuA9i7qsXxhJRsBeceI7hZSnNYAQzsWfFD0kDW8GsJBuK-CST6oNNp0z7MQ5Qof6DZ8x9wt5ZJR43HFmD2VtTQUZLvIeemC4URuR74UWn25CETyzQdIhdNSEibaCRvi0sNwb-ikCZVxxo4-O7ZBQPw0egrQOJW06HlCQUykH_00EIoiBRcbJLS6W3nJ8KhddDf_4glZYPz6fBpqu1jIdIBGOGQf4Ttn_DmdAgkLxWF7AF6k59D45J9kxfANRJIBGSWUsI1bQBlrwFtois4O14uQkQ40Jh_d5BCrLPe599zrliGH1SsECx_xYGWcWY_GPsPa99d_St56BB9oUtDW3A1clEx2uVS8OWqRPgVimu6MXs_TEEnjWGRFofHpl_8qGeAoPbNkXsTMQb6uUK4NCYq3UzVfreByEnOqxuQcu2jlF4Ey0UH9w_KjkRyT8xu--kyZAbktYaw4EZmGUxZIlkZLk_OAGaW8KWPZhdGxjfi8K7WeZK2HtLe4At48DC_ED_20pNtkTCrB6-FQlMj6a4O2C1sE6pSdrIPofcK-HpaefOXqYKWpRM-Wnp_qHnuJgEtgodQ-pw74nXkOsVFZoJzVGCepZKoa2xhevAu3CfXMfR97LIski17PPwWV9n7yQ7onSKDmJP-q4mO7PG7LICE22WkgJkk_T1W4UkDTkCxZE_t64F6JOryg",
   "decomposed_rsa_private_key": [
     99901518447147034909201847419097315968297147437151469508360346463543063455874100243913856315732601845631262435262260706834732781343251117295631282035669718956849603873760427510697419513879951677293141811802298231979984193675329310799949319780256427743430868153430092107435691279045586737323088097814348379553,
@@ -109,6 +109,16 @@
         "k": "zA8CzCf9tZw:cnpz0cav9fLAJHK1TbL3MD5n9R7VvedDwbFRVp4qQh4",
         "s": 137080,
         "ts": 1361925899
+      },
+      {
+        "h": "LpJwSL5A",
+        "p": "ywJVFBKB",
+        "u": "zA8CzCf9tZw",
+        "t": 0,
+        "a": "lw4tddDm8mFFKt4EuPkPkBlbf5sG9Xf47c-Bif0lJ7jH9xiU1JbQcxqdRixtsOgN",
+        "k": "zA8CzCf9tZw:bLCHGilxhwBlxkZs8uptY87wZf_WNCR6RefwEgtbRmo",
+        "s": 8920445,
+        "ts": 1362235380
       }
     ],
     "ok": [
@@ -124,14 +134,17 @@
         "m": "megartest@gmail.com"
       }
     ],
-    "sn": "2q4ZpNDFGNA"
+    "sn": "rkC92G0-SNg"
+  },
+  "file_upload_url_response": {
+    "p": "http://gfs262n185.userstorage.mega.co.nz/ul/YKxC-sS4xNF8MgL4iddMm9PNukmzMODqpxWsV5CquftEe5YDUZaq2_QSuqt8ubYtt0_VYE-yLk2gN5uJIyDHhQ"
   },
   "sample_files": {
     "megar_test_sample_1.txt": {
       "file_download_url_response": {
         "s": 39,
         "at": "lv-LcMAl0dvpdxQFWNVZ7m9-mFT79mS0Mi_fH9InTqtBgcpe8kRVDGQ5Hj4BrXrc",
-        "g": "http://gfs262n164.userstorage.mega.co.nz/dl/mri5tfEwyd0zbAImLAPBzTeWY8_A6olaAjn4rztgo3cQZ_ovfobz7A5X4vhHxU6xDWX3Gcxkozxb0acSEOyC-wRl7gO3jZrJzqLT13812fUfghQvwQ"
+        "g": "http://gfs262n164.userstorage.mega.co.nz/dl/Hv0Huu5AKOP1CQKwZNxpr7JMVXST1oxYEWT08YF3WIAWIDX4-3-bKAGVDU13ESYqBmcMDQGDsohpihtrDwEIpz3W5yvdTIFAhhWR49qpZvi3yfkhGg"
       },
       "key": [
         2080156050,
@@ -156,13 +169,17 @@
         0,
         0
       ],
+      "mac": [
+        -1644788558,
+        -1184834090
+      ],
       "initial_counter_value": 60129435948344049243162590180076945408
     },
     "megar_test_sample_2.png": {
       "file_download_url_response": {
         "s": 137080,
         "at": "OFTM18eQGxUTcJP2BQWXBo23vnjqs4b9QzmNZtDqekz4GZESVNiYlqKtasZqdVHN",
-        "g": "http://gfs262n170.userstorage.mega.co.nz/dl/dpAQXYa5Q7qOQQKAWgqcNsmyPfr8As0DEJlX2LCKmTAvRVlvWpW6F3Hw-xV2Ou2ynF_bfjIcGG5ZO0vi3hf-6rFOx3jAu-FNNSKnvEA1irjUy4hT7g"
+        "g": "http://gfs262n170.userstorage.mega.co.nz/dl/ZWHZvT4lAtuWdwKYNzKGjqDfAvohHAi7AnKmQCCCWormdDhn-CLkuVb5Onah2GxtzcJ_vQFoI_EWAxIxGyBIXrsRLw60IJ6ZNjNWiDpcPG_6jTgP4A"
       },
       "key": [
         1029178532,
@@ -187,6 +204,10 @@
         0,
         0
       ],
+      "mac": [
+        870048465,
+        -473559286
+      ],
       "initial_counter_value": 111383565294958830569229712241211736064
     }
   }

data/spec/support/crypto_expectations_helper.rb

@@ -70,6 +70,7 @@ module CryptoExpectationsHelper
       e[:rsa_private_key_b64] = session.rsa_private_key_b64
       e[:decomposed_rsa_private_key] = session.decomposed_rsa_private_key
       e[:files_response_data] = session.send(:get_files_response)
+      e[:file_upload_url_response] = session.get_file_upload_url_response(39)
       session.send(:handle_files_response,e[:files_response_data])
       megar_test_sample_1 = session.files.find_by_name('megar_test_sample_1.txt')
       megar_test_sample_2 = session.files.find_by_name('megar_test_sample_2.png')
@@ -81,6 +82,7 @@ module CryptoExpectationsHelper
           decomposed_key: megar_test_sample_1.decomposed_key,
           size: downloader.download_size,
           iv: downloader.iv,
+          mac: downloader.mac,
           initial_counter_value: downloader.initial_counter_value
         }
         write_file_download_sample(megar_test_sample_1.name,downloader.raw_content)
@@ -92,6 +94,7 @@ module CryptoExpectationsHelper
           decomposed_key: megar_test_sample_2.decomposed_key,
           size: downloader.download_size,
           iv: downloader.iv,
+          mac: downloader.mac,
           initial_counter_value: downloader.initial_counter_value
         }
         write_file_download_sample(megar_test_sample_2.name,downloader.raw_content)

data/spec/unit/adapters/file_downloader_spec.rb

@@ -5,26 +5,20 @@ describe Megar::FileDownloader do
   let(:instance) { model_class.new(attributes) }
   let(:attributes) { {} }
 
-  describe "#get_chunks (protected)" do
-    subject { instance.send(:get_chunks,size) }
-    {
-      122000   => [[0, 122000]],
-      332000   => [[0, 131072], [131072, 200928]],
-      500000   => [[0, 131072], [131072, 262144], [393216, 106784]],
-      800000   => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 13568]],
-      1800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 489280]],
-      2000000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 33920]],
-      2800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 47488]],
-      3800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 129984]],
-      4800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 1048576], [4718592, 81408]],
-      20800000 => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 1048576], [4718592, 1048576], [5767168, 1048576], [6815744, 1048576], [7864320, 1048576], [8912896, 1048576], [9961472, 1048576], [11010048, 1048576], [12058624, 1048576], [13107200, 1048576], [14155776, 1048576], [15204352, 1048576], [16252928, 1048576], [17301504, 1048576], [18350080, 1048576], [19398656, 1048576], [20447232, 352768]],
-    }.each do |size,chunks|
-      context "when size=#{size}" do
-        let(:size) { size }
-        let(:expected) { chunks }
-        it { should eql(chunks) }
+  describe "#mac" do
+    subject { instance.mac }
+    [
+      {
+        file_key: [1029178532, 1095006796,361733076,-1656803926,1405858242,1396716347,870048465,-473559286],
+        expected_mac: [870048465,-473559286]
+      }
+    ].each do |options|
+      context "when file key #{options[:file_key]}" do
+        before { instance.stub(:key).and_return(options[:file_key]) }
+        it { should eql(options[:expected_mac]) }
       end
     end
+
   end
 
   crypto_expectations['sample_files'].keys.each do |sample_file_name|
@@ -78,6 +72,12 @@ describe Megar::FileDownloader do
         it { should eql(expected) }
       end
 
+      describe "#mac" do
+        let(:expected) { file_expectation['mac'] }
+        subject { instance.mac }
+        it { should eql(expected) }
+      end
+
       describe "#initial_counter_value" do
         let(:expected) { file_expectation['initial_counter_value'] }
         subject { instance.initial_counter_value }

data/spec/unit/adapters/file_uploader_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Megar::FileUploader do
+  let(:model_class) { Megar::FileUploader }
+  let(:instance) { model_class.new(attributes) }
+  let(:attributes) { {} }
+
+  subject { instance }
+
+  describe "#upload_key" do
+    subject { instance.upload_key }
+    it { should be_a(Array) }
+    its(:size) { should eql(6) }
+  end
+
+  describe "keys" do
+    subject { instance }
+    [
+      {
+        upload_key:      [3230625094, 2656764682, 1008836587, 1082599785, 1919494632, 3993726968],
+        expected_iv:     152078032723025278718811426614033776640,
+        expected_mac_iv: [1919494632, 3993726968,1919494632, 3993726968],
+        expected_mac_encryption_key: [3230625094, 2656764682, 1008836587, 1082599785]
+      }
+    ].each do |options|
+      context "when upload_key #{options[:upload_key]}" do
+        before       { instance.stub(:upload_key).and_return(options[:upload_key]) }
+        its(:iv)     { should eql(options[:expected_iv]) }
+        its(:mac_iv) { should eql(options[:expected_mac_iv]) }
+        its(:mac_encryption_key) { should eql(options[:expected_mac_encryption_key]) }
+      end
+    end
+  end
+
+  context "with sample file" do
+    let(:file_name) { 'megar_test_sample_1.txt' }
+    let(:file_expectation) { crypto_expectations['sample_files'][file_name] }
+    let(:attributes) { { body: file_handle } }
+
+    context "when given a File" do
+      let(:file_handle) { File.open(crypto_sample_file_path(file_name),'rb') }
+      it { file_handle.should be_a(File) }
+      its(:upload_size) { should eql(file_expectation['size']) }
+      its(:name) { should eql(file_name) }
+
+      context "when override the filename" do
+        let(:new_name) { 'a new name.txt' }
+        let(:attributes) { { body: file_handle, name: new_name } }
+        its(:name) { should eql(new_name) }
+      end
+    end
+
+    context "when given a Pathname" do
+      let(:file_handle) { crypto_sample_file_path(file_name) }
+      it { file_handle.should be_a(Pathname) }
+      describe "#upload_size" do
+        subject { instance.upload_size }
+        it { should eql(file_expectation['size']) }
+      end
+    end
+
+    context "when given a file path as a string" do
+      let(:file_handle) { crypto_sample_file_path(file_name).to_s }
+      it { file_handle.should be_a(String) }
+      describe "#upload_size" do
+        subject { instance.upload_size }
+        it { should eql(file_expectation['size']) }
+      end
+    end
+
+    context "when given a path string to a non-existent file" do
+      let(:file_handle) { crypto_sample_file_path(file_name).to_s + '.bogative' }
+      it "should raise an error" do
+        expect { instance }.to raise_error(Errno::ENOENT)
+      end
+    end
+
+    describe "#post!" do
+      let(:file_handle) { crypto_sample_file_path(file_name) }
+      let(:session) { connected_session_with_mocked_api_responses }
+      let(:uploader) { Megar::FileUploader.new(attributes.merge(folder: session.folders.root)) }
+      let(:do_post) { uploader.post! }
+      let(:upload_attributes_response) { {"f"=>[session.files.find_by_name(file_name).payload]} }
+      let(:completion_file_handle) { "h4Zgt7cRyMUlzl6WguZALImGOr2Yyr31cTXd" }
+
+      it "should upload in a single chunk" do
+        uploader.should_receive(:post_chunk).and_return(completion_file_handle)
+        uploader.should_receive(:send_file_upload_attributes).and_return(upload_attributes_response)
+        do_post
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/catalog/files_spec.rb

@@ -23,4 +23,16 @@ describe Megar::Files do
     end
   end
 
+  describe "#create" do
+    let(:attributes) { { name: 'a name', body: 'file_handle'} }
+    subject { instance.create(attributes) }
+    it "should create a valid uploader and post!" do
+      instance.stub(:parent_folder).and_return('parent_folder')
+      uploader = mock()
+      uploader.should_receive(:post!)
+      Megar::FileUploader.should_receive(:new).with(attributes.merge(folder: 'parent_folder')).and_return(uploader)
+      subject
+    end
+  end
+
 end

data/spec/unit/catalog/folder_spec.rb

@@ -44,6 +44,16 @@ describe Megar::Folder do
         its(:id) { should eql('dir3') }
         its(:parent_folder) { should eql(folder) }
       end
+      describe "#create" do
+        let(:attributes) { { name: 'a name', body: 'file_handle'} }
+        subject { folder.create(attributes) }
+        it "should create a valid uploader and post!" do
+          uploader = mock()
+          uploader.should_receive(:post!)
+          Megar::FileUploader.should_receive(:new).with(attributes.merge(folder: folder)).and_return(uploader)
+          subject
+        end
+      end
     end
 
     context "when child folders not present" do

data/spec/unit/crypto/support_spec.rb

@@ -18,6 +18,7 @@ describe Megar::CryptoSupport do
     subject { harness.str_to_a32(string) }
     # expectation generation in Javascript:
     #   str_to_a32(base64urldecode('zL-S9BspoEopTUm3z3O8CA'))
+    #   str_to_a32(base64urldecode('YmxlLi4AAAAAAAAAAAAAAA'))
     [
       { given: "\xCC\xBF\x92\xF4\e)\xA0J)MI\xB7\xCFs\xBC\b", expect: [-859860236,455712842,692930999,-814498808] },
       { given: 'a', expect: [1627389952] },
@@ -28,6 +29,15 @@ describe Megar::CryptoSupport do
         it { should eql(test_case[:expect]) }
       end
     end
+    [
+      { given: 'zL-S9BspoEopTUm3z3O8CA', expect: [-859860236,455712842,692930999,-814498808] },
+      { given: 'YmxlLi4AAAAAAAAAAAAAAA', expect: [1651270958, 771751936, 0, 0] }
+    ].each do |test_case|
+      context "given #{test_case[:given]}" do
+        let(:string) { harness.base64urldecode(test_case[:given]) }
+        it { should eql(test_case[:expect]) }
+      end
+    end
   end
 
   describe "#a32_to_str" do
@@ -500,4 +510,71 @@ describe Megar::CryptoSupport do
     end
   end
 
+  describe "#get_chunks" do
+    subject { harness.get_chunks(size) }
+    {
+      122000   => [[0, 122000]],
+      332000   => [[0, 131072], [131072, 200928]],
+      500000   => [[0, 131072], [131072, 262144], [393216, 106784]],
+      800000   => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 13568]],
+      1800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 489280]],
+      2000000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 33920]],
+      2800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 47488]],
+      3800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 129984]],
+      4800000  => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 1048576], [4718592, 81408]],
+      20800000 => [[0, 131072], [131072, 262144], [393216, 393216], [786432, 524288], [1310720, 655360], [1966080, 786432], [2752512, 917504], [3670016, 1048576], [4718592, 1048576], [5767168, 1048576], [6815744, 1048576], [7864320, 1048576], [8912896, 1048576], [9961472, 1048576], [11010048, 1048576], [12058624, 1048576], [13107200, 1048576], [14155776, 1048576], [15204352, 1048576], [16252928, 1048576], [17301504, 1048576], [18350080, 1048576], [19398656, 1048576], [20447232, 352768]],
+    }.each do |size,chunks|
+      context "when size=#{size}" do
+        let(:size) { size }
+        let(:expected) { chunks }
+        it { should eql(chunks) }
+      end
+    end
+  end
+
+  describe "#calculate_chunk_mac" do
+    subject { harness.calculate_chunk_mac(chunk,decomposed_key,iv) }
+    [
+      {
+        chunk_b64:      'Re_JkMdeElC-EdjpC0Aoxw9k6mymXoJq5Deqgx9a2Vpj8sX6l34B',
+        decomposed_key: [1455434630,1271130048,979342435,1808341711],
+        chunk_mac_iv:   [758940180,1555777008,758940180,1555777008],
+        expected_mac:   [2029949810, 584234195, 3282227752, 2170965113]
+      },{
+        chunk_b64:      'SnVzdCBhYm91dCB0aGUgc2ltcGxlc3QgZmlsZSBwb3NzaWJsZS4uSnVzdCBhYm91dCB0aGUgc2ltcGxlc3QgZmlsZSBwb3NzaWJsZS4uSnVzdCBhYm91dCB0aGUgc2ltcGxlc3QgZmlsZSBwb3NzaWJsZS4u',
+        decomposed_key: [2016295139, 2872496308, 1974113602, 40814121],
+        chunk_mac_iv:   [3326582948, 288270468, 3326582948, 288270468],
+        expected_mac:   [4085249905, 2687924527, 2252792538, 707619224]
+      }
+    ].each do |options|
+      context "when chunk_b64 = #{options[:chunk_b64]}" do
+        let(:chunk)          { harness.base64urldecode(options[:chunk_b64]) }
+        let(:decomposed_key) { options[:decomposed_key] }
+        let(:iv)             { options[:chunk_mac_iv] }
+        it { should eql(options[:expected_mac]) }
+      end
+    end
+  end
+
+  describe "#accumulate_mac" do
+    subject { harness.accumulate_mac(chunk,progressive_mac,key,iv) }
+    [
+      {
+        chunk_b64:       'Re_JkMdeElC-EdjpC0Aoxw9k6mymXoJq5Deqgx9a2Vpj8sX6l34B',
+        key:             [1455434630, 1271130048, 979342435, 1808341711],
+        progressive_mac: [1649900877, 3786760977, 26559147, 602156686],
+        chunk_mac_iv:    [758940180, 1555777008, 758940180, 1555777008],
+        expected_mac:    [-259790568, 215606833, 1883564717, -1389129415]
+      }
+    ].each do |options|
+      context "when chunk_b64 = #{options[:chunk_b64]}" do
+        let(:chunk)           { harness.base64urldecode(options[:chunk_b64]) }
+        let(:key)             { options[:key] }
+        let(:progressive_mac) { options[:progressive_mac] }
+        let(:iv)              { options[:chunk_mac_iv] }
+        it { should eql(options[:expected_mac]) }
+      end
+    end
+  end
+
 end

data/spec/unit/exception_spec.rb

@@ -2,19 +2,18 @@ require 'spec_helper'
 
 describe "Megar Exceptions" do
 
-  describe "Megar::Error" do
-    let(:exception_class) { Megar::Error }
-    subject { raise exception_class.new("test") }
-    it "should raise correctly" do
-      expect { subject }.to raise_error(exception_class)
-    end
-  end
-
-  describe "Megar::CryptoSupportRequirementsError" do
-    let(:exception_class) { Megar::CryptoSupportRequirementsError }
-    subject { raise exception_class.new("test") }
-    it "should raise correctly" do
-      expect { subject }.to raise_error(exception_class)
+  [
+    Megar::Error,
+    Megar::CryptoSupportRequirementsError,
+    Megar::MacVerificationError,
+    Megar::UnsupportedFileHandleTypeError,
+    Megar::FileUploadError
+  ].each do |exception_class|
+    describe exception_class do
+      subject { raise exception_class.new("test") }
+      it "should raise correctly" do
+        expect { subject }.to raise_error(exception_class)
+      end
     end
   end
 

data/spec/unit/shell_spec.rb

@@ -43,4 +43,16 @@ describe Megar::Shell do
     end
   end
 
+  describe "#put" do
+    let(:options) { ['-e=email','-p=pwd'] }
+    let(:argv) { ['put', 'file_name'] }
+    it "should invoke put" do
+      mock_session = mock()
+      mock_session.stub(:connected?).and_return(true)
+      shell.stub(:session).and_return(mock_session)
+      shell.should_receive(:put).with(argv.drop(1))
+      shell.run
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: megar
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+date: 2013-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: getoptions
@@ -172,6 +172,7 @@ files:
 - lib/megar.rb
 - lib/megar/adapters.rb
 - lib/megar/adapters/file_downloader.rb
+- lib/megar/adapters/file_uploader.rb
 - lib/megar/catalog.rb
 - lib/megar/catalog/catalog_item.rb
 - lib/megar/catalog/file.rb
@@ -195,6 +196,7 @@ files:
 - spec/support/crypto_expectations_helper.rb
 - spec/support/mocks_helper.rb
 - spec/unit/adapters/file_downloader_spec.rb
+- spec/unit/adapters/file_uploader_spec.rb
 - spec/unit/catalog/file_spec.rb
 - spec/unit/catalog/files_spec.rb
 - spec/unit/catalog/folder_spec.rb
@@ -239,6 +241,7 @@ test_files:
 - spec/support/crypto_expectations_helper.rb
 - spec/support/mocks_helper.rb
 - spec/unit/adapters/file_downloader_spec.rb
+- spec/unit/adapters/file_uploader_spec.rb
 - spec/unit/catalog/file_spec.rb
 - spec/unit/catalog/files_spec.rb
 - spec/unit/catalog/folder_spec.rb