voussoir/megapy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

fixed api resp issue #2, reformatted code pep 8 style

Browse source
This commit is contained in:
richard@richard.do 2013-02-09 18:29:58 +00:00
parent ff91521628
commit 2493a10b88
5 changed files with 66 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
# Compiled source #
###################
*.pyc
# Hidden files #
###################
.*

11
crypto.py
View file

@ -5,20 +5,25 @@ import struct
import binascii import binascii
import random import random
def aes_cbc_encrypt(data, key): def aes_cbc_encrypt(data, key):
aes_cipher = AES.new(key, AES.MODE_CBC, '\0' * 16) aes_cipher = AES.new(key, AES.MODE_CBC, '\0' * 16)
return aes_cipher.encrypt(data) return aes_cipher.encrypt(data)
def aes_cbc_decrypt(data, key): def aes_cbc_decrypt(data, key):
aes_cipher = AES.new(key, AES.MODE_CBC, '\0' * 16) aes_cipher = AES.new(key, AES.MODE_CBC, '\0' * 16)
return aes_cipher.decrypt(data) return aes_cipher.decrypt(data)
def aes_cbc_encrypt_a32(data, key): def aes_cbc_encrypt_a32(data, key):
return str_to_a32(aes_cbc_encrypt(a32_to_str(data), a32_to_str(key))) return str_to_a32(aes_cbc_encrypt(a32_to_str(data), a32_to_str(key)))
def aes_cbc_decrypt_a32(data, key): def aes_cbc_decrypt_a32(data, key):
return str_to_a32(aes_cbc_decrypt(a32_to_str(data), a32_to_str(key))) return str_to_a32(aes_cbc_decrypt(a32_to_str(data), a32_to_str(key)))
def stringhash(str, aeskey): def stringhash(str, aeskey):
s32 = str_to_a32(str) s32 = str_to_a32(str)
h32 = [0, 0, 0, 0] h32 = [0, 0, 0, 0]
@ -28,6 +33,7 @@ def stringhash(str, aeskey):
h32 = aes_cbc_encrypt_a32(h32, aeskey) h32 = aes_cbc_encrypt_a32(h32, aeskey)
return a32_to_base64((h32[0], h32[2])) return a32_to_base64((h32[0], h32[2]))
def prepare_key(arr): def prepare_key(arr):
pkey = [0x93C467E3, 0x7DB0C7A4, 0xD1BE3F81, 0x0152CB56] pkey = [0x93C467E3, 0x7DB0C7A4, 0xD1BE3F81, 0x0152CB56]
for r in range(0x10000): for r in range(0x10000):
@ -74,6 +80,7 @@ def str_to_a32(b):
b += '\0' * (4 - len(b) % 4) b += '\0' * (4 - len(b) % 4)
return struct.unpack('>%dI' % (len(b) / 4), b) return struct.unpack('>%dI' % (len(b) / 4), b)
def mpi_to_int(s): def mpi_to_int(s):
return int(binascii.hexlify(s[2:]), 16) return int(binascii.hexlify(s[2:]), 16)
@ -84,18 +91,22 @@ def base64_url_decode(data):
data = data.replace(search, replace) data = data.replace(search, replace)
return base64.b64decode(data) return base64.b64decode(data)
def base64_to_a32(s): def base64_to_a32(s):
return str_to_a32(base64_url_decode(s)) return str_to_a32(base64_url_decode(s))
def base64_url_encode(data): def base64_url_encode(data):
data = base64.b64encode(data) data = base64.b64encode(data)
for search, replace in (('+', '-'), ('/', '_'), ('=', '')): for search, replace in (('+', '-'), ('/', '_'), ('=', '')):
data = data.replace(search, replace) data = data.replace(search, replace)
return data return data
def a32_to_base64(a): def a32_to_base64(a):
return base64_url_encode(a32_to_str(a)) return base64_url_encode(a32_to_str(a))
def get_chunks(size): def get_chunks(size):
chunks = {} chunks = {}
p = pp = 0 p = pp = 0

2
errors.py
View file

@ -1,10 +1,10 @@
class ValidationError(Exception): class ValidationError(Exception):
""" """
Error in validation stage Error in validation stage
""" """
pass pass
class RequestError(Exception): class RequestError(Exception):
""" """
Error in API request Error in API request

48
mega.py
View file

@ -10,12 +10,12 @@ import requests
import errors import errors
from crypto import * from crypto import *
class Mega(object):
class Mega(object):
def __init__(self): def __init__(self):
self.schema = 'https' self.schema = 'https'
self.domain = 'mega.co.nz' self.domain = 'mega.co.nz'
self.timeout = 160 #max time (secs) to wait for response from api requests self.timeout = 160 #max time (secs) to wait for resp from api requests
self.sid = None self.sid = None
self.sequence_num = random.randint(0, 0xFFFFFFFF) self.sequence_num = random.randint(0, 0xFFFFFFFF)
self.request_id = make_id(10) self.request_id = make_id(10)
@ -46,7 +46,8 @@ class Mega(object):
self.sid = resp['tsid'] self.sid = resp['tsid']
elif 'csid' in resp: elif 'csid' in resp:
encrypted_rsa_private_key = base64_to_a32(resp['privk']) encrypted_rsa_private_key = base64_to_a32(resp['privk'])
rsa_private_key = decrypt_key(encrypted_rsa_private_key, self.master_key) rsa_private_key = decrypt_key(encrypted_rsa_private_key,
self.master_key)
private_key = a32_to_str(rsa_private_key) private_key = a32_to_str(rsa_private_key)
self.rsa_private_key = [0, 0, 0, 0] self.rsa_private_key = [0, 0, 0, 0]
@ -73,8 +74,11 @@ class Mega(object):
if self.sid: if self.sid:
params.update({'sid': self.sid}) params.update({'sid': self.sid})
req = requests.post( req = requests.post(
'{0}://g.api.{1}/cs'.format(self.schema,self.domain), params=params, data=json.dumps([data]), timeout=self.timeout) '{0}://g.api.{1}/cs'.format(self.schema, self.domain),
json_resp = req.json() params=params,
data=json.dumps([data]),
timeout=self.timeout)
json_resp = json.loads(req.text)
#if numeric error code response #if numeric error code response
if isinstance(json_resp, int): if isinstance(json_resp, int):
@ -107,7 +111,8 @@ class Mega(object):
public_handle, public_handle,
decrypted_key) decrypted_key)
else: else:
raise ValueError('Upload() response required as input, use get_link() for regular file input') raise ValueError('''Upload() response required as input,
use get_link() for regular file input''')
def get_link(self, file): def get_link(self, file):
''' '''
@ -199,7 +204,8 @@ class Mega(object):
if i['h'] is not u'': if i['h'] is not u'':
node_id = i['h'] node_id = i['h']
return self.api_request({'a': 'm', 'n': node_id, 't': target_node_id, 'i': self.request_id}) return self.api_request({'a': 'm', 'n': node_id, 't': target_node_id,
'i': self.request_id})
def get_node_by_type(self, type): def get_node_by_type(self, type):
''' '''
@ -234,7 +240,9 @@ class Mega(object):
attribs = decrypt_attr(attribs, k) attribs = decrypt_attr(attribs, k)
file_name = attribs['n'] file_name = attribs['n']
print "downloading {0} (size: {1}), url = {2}".format(attribs['n'], file_size, file_url) print "downloading {0} (size: {1}), url = {2}".format(attribs['n'],
file_size,
file_url)
input_file = requests.get(file_url, stream=True).raw input_file = requests.get(file_url, stream=True).raw
output_file = open(file_name, 'wb') output_file = open(file_name, 'wb')
@ -305,18 +313,21 @@ class Mega(object):
if len(block) % 16: if len(block) % 16:
block += '\0' * (16 - len(block) % 16) block += '\0' * (16 - len(block) % 16)
block = str_to_a32(block) block = str_to_a32(block)
chunk_mac = [chunk_mac[0] ^ block[0], chunk_mac[1] ^ block[1], chunk_mac[2] ^ block[2], chunk_mac = [chunk_mac[0] ^ block[0], chunk_mac[1] ^ block[1],
chunk_mac[2] ^ block[2],
chunk_mac[3] ^ block[3]] chunk_mac[3] ^ block[3]]
chunk_mac = aes_cbc_encrypt_a32(chunk_mac, ul_key[:4]) chunk_mac = aes_cbc_encrypt_a32(chunk_mac, ul_key[:4])
#our files mac #our files mac
file_mac = [file_mac[0] ^ chunk_mac[0], file_mac[1] ^ chunk_mac[1], file_mac[2] ^ chunk_mac[2], 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[3] ^ chunk_mac[3]]
file_mac = aes_cbc_encrypt_a32(file_mac, ul_key[:4]) file_mac = aes_cbc_encrypt_a32(file_mac, ul_key[:4])
#encrypt file and upload #encrypt file and upload
chunk = aes.encrypt(chunk) chunk = aes.encrypt(chunk)
output_file = requests.post(ul_url + "/" + str(chunk_start), data=chunk, timeout=self.timeout) output_file = requests.post(ul_url + "/" + str(chunk_start),
data=chunk, timeout=self.timeout)
completion_file_handle = output_file.text completion_file_handle = output_file.text
#determine meta mac #determine meta mac
@ -324,14 +335,16 @@ class Mega(object):
attribs = {'n': os.path.basename(filename)} attribs = {'n': os.path.basename(filename)}
encrypt_attribs = base64_url_encode(encrypt_attr(attribs, ul_key[:4])) encrypt_attribs = base64_url_encode(encrypt_attr(attribs, ul_key[:4]))
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], 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]] ul_key[4], ul_key[5], meta_mac[0], meta_mac[1]]
encrypted_key = a32_to_base64(encrypt_key(key, self.master_key)) encrypted_key = a32_to_base64(encrypt_key(key, self.master_key))
#update attributes #update attributes
data = self.api_request({'a': 'p', 't': dest, 'n': [ data = self.api_request({'a': 'p', 't': dest, 'n': [{
{'h': completion_file_handle, 't': 0, 'a': encrypt_attribs, 'k': encrypted_key}]} 'h': completion_file_handle,
) 't': 0,
'a': encrypt_attribs,
'k': encrypted_key}]})
#close input file and return API msg #close input file and return API msg
input_file.close() input_file.close()
return data return data
@ -344,7 +357,8 @@ class Mega(object):
key = file['k'][file['k'].index(':') + 1:] key = file['k'][file['k'].index(':') + 1:]
key = decrypt_key(base64_to_a32(key), self.master_key) key = decrypt_key(base64_to_a32(key), self.master_key)
if file['t'] == 0: if file['t'] == 0:
k = (key[0] ^ key[4], key[1] ^ key[5], key[2] ^ key[6], key[3] ^ key[7]) k = (key[0] ^ key[4], key[1] ^ key[5], key[2] ^ key[6],
key[3] ^ key[7])
file['iv'] = key[4:6] + (0, 0) file['iv'] = key[4:6] + (0, 0)
file['meta_mac'] = key[6:8] file['meta_mac'] = key[6:8]
else: else:

2
tests/test.py
View file

@ -1,5 +1,6 @@
from mega import Mega from mega import Mega
def test(): def test():
#user details #user details
email = 'your@email.com' email = 'your@email.com'
@ -45,5 +46,6 @@ def test():
#m.download(file) #m.download(file)
#m.download_url('https://mega.co.nz/#!6hBW0R4a!By7-Vjj5xal8K5w_IXH3PlGNyZ1VvIrjZkOmHGq1X00') #m.download_url('https://mega.co.nz/#!6hBW0R4a!By7-Vjj5xal8K5w_IXH3PlGNyZ1VvIrjZkOmHGq1X00')
if __name__ == '__main__': if __name__ == '__main__':
test() test()