def get_encrypted_configs(options, name_stop=None):
"""
@type options: optparse.Values, instance
@param name_stop: stop looking if this name is matched
@type name_stop:bool
"""
hidden_configs = get_hidden_configs(options)
encrypted_configs = []
for config in hidden_configs:
config_file_path = os.path.join(options.basedir, config[0])
config_file_path = os.path.join(config_file_path, config[1])
cryptoboxname = unpickle_object(config_file_path)
secret = password_derivation(options.password, cryptoboxname["salt"])
cryptoboxname, secret = msgpack_decrypt_pyobject(secret, obj_string=cryptoboxname["encrypted_name"])
encrypted_configs.append({"cryptoboxname": cryptoboxname, "secret": secret, "config_file_path": config_file_path})
if name_stop == cryptoboxname:
return encrypted_configs
return encrypted_configs
def get_encrypted_configs(options, name_stop=None):
"""
@type options: optparse.Values, instance
@param name_stop: stop looking if this name is matched
@type name_stop:bool
"""
hidden_configs = get_hidden_configs(options)
encrypted_configs = []
for config in hidden_configs:
config_file_path = os.path.join(options.basedir, config[0])
config_file_path = os.path.join(config_file_path, config[1])
cryptoboxname = unpickle_object(config_file_path)
secret = password_derivation(options.password, cryptoboxname["salt"])
cryptoboxname, secret = msgpack_decrypt_pyobject(
secret, obj_string=cryptoboxname["encrypted_name"])
encrypted_configs.append({
"cryptoboxname": cryptoboxname,
"secret": secret,
"config_file_path": config_file_path
})
if name_stop == cryptoboxname:
return encrypted_configs
return encrypted_configs
def get_unique_content(memory, options, all_unique_nodes, local_paths):
"""
@type memory: Memory
@type options: istance
@type all_unique_nodes: dict
@type local_paths: tuple
"""
if len(local_paths) == 0:
return memory
unique_nodes_hashes = [fhash for fhash in all_unique_nodes if not have_blob(options, fhash)]
unique_nodes = [all_unique_nodes[fhash] for fhash in all_unique_nodes if fhash in unique_nodes_hashes]
downloaded_files_cnt = 0
unique_nodes = [node for node in unique_nodes if not os.path.exists(os.path.join(options.dir, node["doc"]["m_path_p64s"].lstrip(os.path.sep)))]
unique_nodes = sorted(unique_nodes, key=lambda k: k["doc"]["m_size_p64s"])
for node in unique_nodes:
update_progress(downloaded_files_cnt, len(unique_nodes), "downloading " + str(node["doc"]["m_name"]))
content_path, content_hash = download_blob(memory, options, node)
update_item_progress(100)
output_json({"item_progress": 0})
memory, file_nodes_left = write_blobs_to_filepaths(memory, options, local_paths, None, content_hash, content_path)
downloaded_files_cnt += 1
update_progress(downloaded_files_cnt, len(unique_nodes), "downloading done")
for lp in local_paths:
memory = add_local_path_history(memory, os.path.join(options.dir, lp["doc"]["m_path_p64s"].lstrip(os.sep)))
source_path = None
file_path = os.path.join(options.dir, lp["doc"]["m_path_p64s"].lstrip(os.path.sep))
if not os.path.exists(file_path):
for lph in all_unique_nodes:
if lph == lp["content_hash_latest_timestamp"][0]:
source_path = os.path.join(options.dir, all_unique_nodes[lph]["doc"]["m_path_p64s"].lstrip(os.path.sep))
break
datapath = data = None
if source_path:
if not os.path.exists(source_path):
fhash = lp["content_hash_latest_timestamp"][0]
source_path = os.path.join(get_blob_dir(options), fhash[:2])
source_path = os.path.join(source_path, fhash[2:])
memory = add_path_history(file_path, memory)
secret = password_derivation(options.password, base64.decodestring(memory.get("salt_b64")))
dec_file = decrypt_file(source_path, secret)
datapath = dec_file.name
if not datapath:
st_ctime, st_atime, st_mtime, st_mode, st_uid, st_gid, st_size, datapath = read_file(source_path, True)
else:
st_ctime, st_atime, st_mtime, st_mode, st_uid, st_gid, st_size, datapath_dummy = read_file(source_path)
st_mtime = int(lp["content_hash_latest_timestamp"][1])
write_file(file_path, data, datapath, st_mtime, st_mtime, st_mode, st_uid, st_gid)
local_paths_not_written = [fp for fp in local_paths if not os.path.exists(os.path.join(options.dir, fp["doc"]["m_path_p64s"].lstrip(os.path.sep)))]
if len(local_paths_not_written) > 0:
local_index = get_localindex(memory)
local_path_hashes = {}
for ldir in local_index["dirnames"]:
for f in local_index["dirnames"][ldir]["filenames"]:
if "hash" in f:
local_path_hashes[f["hash"]] = os.path.join(local_index["dirnames"][ldir]["dirname"], f["name"])
for lfnw in local_paths_not_written:
w = False
for lfh in local_path_hashes:
if not w:
if strcmp(lfnw["content_hash_latest_timestamp"][0], lfh):
w = True
open(os.path.join(options.dir, lfnw["doc"]["m_path_p64s"].lstrip(os.path.sep)), "w").write(open(local_path_hashes[lfh]).read())
return memory
def index_and_encrypt(memory, options):
"""
index_and_encrypt
@type memory: Memory
@type options: optparse.Values, instance
@rtype salt, secret, memory, localindex: str, str, Memory, dict
"""
localindex = make_local_index(options)
datadir = get_data_dir(options)
if quick_lock_check(options):
output_json({
"message":
"cryptobox is locked, nothing can be added now first decrypt (-d)"
})
return None, None, memory, localindex
salt = None
if memory.has("salt_b64"):
salt = base64.decodestring(memory.get("salt_b64"))
if not salt:
salt = Random.new().read(32)
memory.set("salt_b64", base64.encodestring(salt))
output_json({"msg": "preparing encrypt"})
secret = password_derivation(options.password, salt)
ensure_directory(datadir)
new_blobs = {}
file_cnt = 0
new_objects = 0
hash_set_on_disk = set()
processed_files = 0
numfiles = 0
for dirhash in localindex["dirnames"]:
numfiles += len(localindex["dirnames"][dirhash]["filenames"])
for dirhash in localindex["dirnames"]:
for fname in localindex["dirnames"][dirhash]["filenames"]:
file_cnt += 1
file_dir = localindex["dirnames"][dirhash]["dirname"]
file_path = os.path.join(file_dir, fname["name"])
if os.path.exists(file_path):
update_progress(processed_files, numfiles,
"indexing " + os.path.basename(file_path))
filedata, localindex = make_cryptogit_hash(
file_path, datadir, localindex)
fname["hash"] = filedata["filehash"]
hash_set_on_disk.add(filedata["filehash"])
if not filedata["blob_exists"]:
new_blobs[filedata["filehash"]] = filedata
new_objects += 1
if len(new_blobs) > 1500:
encrypt_new_blobs(secret, new_blobs)
new_blobs = {}
if len(new_blobs) > 0:
if len(new_blobs) > 0:
encrypt_new_blobs(secret, new_blobs)
cleanup_tempfiles()
memory = store_localindex(memory, localindex)
if options.remove:
ld = os.listdir(options.dir)
ld.remove(".cryptobox")
processed_files = 0
numfiles = len(ld)
for fname in ld:
fpath = os.path.join(options.dir, fname)
processed_files += 1
update_progress(processed_files, numfiles,
"delete " + os.path.basename(fpath))
if os.path.isdir(fpath):
if os.path.exists(fpath):
shutil.rmtree(fpath, True)
else:
if os.path.exists(fpath):
os.remove(fpath)
obsolute_blob_store_entries = set()
blob_dirs = os.path.join(datadir, "blobs")
ensure_directory(blob_dirs)
for blob_dir in os.listdir(blob_dirs):
blob_store = os.path.join(blob_dirs, blob_dir.lstrip(os.path.sep))
if os.path.isdir(blob_store):
for blob_file in os.listdir(blob_store):
found = False
for fhash in hash_set_on_disk:
if fhash in (blob_dir + blob_file):
found = True
if not found:
obsolute_blob_store_entries.add(blob_dir + blob_file)
for f_hash in obsolute_blob_store_entries:
blob_dir = os.path.join(blob_dirs, f_hash[:2])
blob_path = os.path.join(blob_dir, f_hash[2:])
os.remove(blob_path)
if os.path.isdir(blob_dir):
blob_entries = [
f for f in os.listdir(blob_dir) if not f.startswith('.')
]
if len(blob_entries) == 0:
shutil.rmtree(blob_dir, True)
cleanup_tempfiles()
return salt, secret, memory, localindex
def index_and_encrypt(memory, options):
"""
index_and_encrypt
@type memory: Memory
@type options: optparse.Values, instance
@rtype salt, secret, memory, localindex: str, str, Memory, dict
"""
localindex = make_local_index(options)
datadir = get_data_dir(options)
if quick_lock_check(options):
output_json({"message": "cryptobox is locked, nothing can be added now first decrypt (-d)"})
return None, None, memory, localindex
salt = None
if memory.has("salt_b64"):
salt = base64.decodestring(memory.get("salt_b64"))
if not salt:
salt = Random.new().read(32)
memory.set("salt_b64", base64.encodestring(salt))
output_json({"msg": "preparing encrypt"})
secret = password_derivation(options.password, salt)
ensure_directory(datadir)
new_blobs = {}
file_cnt = 0
new_objects = 0
hash_set_on_disk = set()
processed_files = 0
numfiles = 0
for dirhash in localindex["dirnames"]:
numfiles += len(localindex["dirnames"][dirhash]["filenames"])
for dirhash in localindex["dirnames"]:
for fname in localindex["dirnames"][dirhash]["filenames"]:
file_cnt += 1
file_dir = localindex["dirnames"][dirhash]["dirname"]
file_path = os.path.join(file_dir, fname["name"])
if os.path.exists(file_path):
update_progress(processed_files, numfiles, "indexing " + os.path.basename(file_path))
filedata, localindex = make_cryptogit_hash(file_path, datadir, localindex)
fname["hash"] = filedata["filehash"]
hash_set_on_disk.add(filedata["filehash"])
if not filedata["blob_exists"]:
new_blobs[filedata["filehash"]] = filedata
new_objects += 1
if len(new_blobs) > 1500:
encrypt_new_blobs(secret, new_blobs)
new_blobs = {}
if len(new_blobs) > 0:
if len(new_blobs) > 0:
encrypt_new_blobs(secret, new_blobs)
cleanup_tempfiles()
memory = store_localindex(memory, localindex)
if options.remove:
ld = os.listdir(options.dir)
ld.remove(".cryptobox")
processed_files = 0
numfiles = len(ld)
for fname in ld:
fpath = os.path.join(options.dir, fname)
processed_files += 1
update_progress(processed_files, numfiles, "delete " + os.path.basename(fpath))
if os.path.isdir(fpath):
if os.path.exists(fpath):
shutil.rmtree(fpath, True)
else:
if os.path.exists(fpath):
os.remove(fpath)
obsolute_blob_store_entries = set()
blob_dirs = os.path.join(datadir, "blobs")
ensure_directory(blob_dirs)
for blob_dir in os.listdir(blob_dirs):
blob_store = os.path.join(blob_dirs, blob_dir.lstrip(os.path.sep))
if os.path.isdir(blob_store):
for blob_file in os.listdir(blob_store):
found = False
for fhash in hash_set_on_disk:
if fhash in (blob_dir + blob_file):
found = True
if not found:
obsolute_blob_store_entries.add(blob_dir + blob_file)
for f_hash in obsolute_blob_store_entries:
blob_dir = os.path.join(blob_dirs, f_hash[:2])
blob_path = os.path.join(blob_dir, f_hash[2:])
os.remove(blob_path)
if os.path.isdir(blob_dir):
blob_entries = [f for f in os.listdir(blob_dir) if not f.startswith('.')]
if len(blob_entries) == 0:
shutil.rmtree(blob_dir, True)
cleanup_tempfiles()
return salt, secret, memory, localindex
def cryptobox_command(options):
"""
@param options: dictionary with options
@type options: namedtuple, Values
@return: succes indicator
@rtype: bool
"""
Events = Events()
try:
if options.acommand:
if options.acommand == "open_folder":
if options.dir:
p = os.path.join(options.dir, options.cryptobox)
open_folder(p)
output_json({"log": "open " + p})
else:
message_json("no folder given(-f)")
elif options.acommand == "hash":
if not options.input:
message_json("need input (-i)")
path = options.input
output_json({"hash": make_hash_path(path)})
return
elif options.acommand == "check_new_release":
if not options.server:
message_json("server mising")
if not options.compiled:
message_json("compiled mising")
log_json("options.compiled: " + options.compiled)
current_hash = make_hash_path(options.compiled)
hash_url = urlparse.urljoin(options.server, "/st/data/cba_main.hash.json")
log_json("hash_url: " + hash_url)
result = urllib2.urlopen(hash_url).read()
result_json = json.loads(result)
new_release = not (current_hash == result_json["hash"])
output_json(
{"new_release": new_release, "current_hash": current_hash, "hash_server": result_json["hash"]}
)
return
elif options.acommand == "download_new_release":
if not options.server:
message_json("server mising")
output_json({"msg": "Downloading Cryptobox.dmg"})
download_url = urlparse.urljoin(options.server, "/st/data/Cryptobox.dmg")
tempfile_cb = download_server(
None, options, download_url, output_name_item_percentage="global_progress"
)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
root = Tkinter.Tk()
root.withdraw()
file_path = tkFileDialog.asksaveasfilename(
parent=None, message="Cryptobox", initialfile="Cryptobox.dmg"
)
if file_path:
if os.path.exists(os.path.dirname(file_path)):
if os.path.exists(tempfile_cb):
os.rename(tempfile_cb, file_path)
cleanup_tempfiles()
return
elif options.acommand == "delete_blobs":
if not options.dir:
message_json("dir mising")
return
if not options.cryptobox:
message_json("cryptobox mising")
return
blobpath = os.path.join(options.dir, options.cryptobox)
blobpath = os.path.join(blobpath, ".cryptobox")
blobpath = os.path.join(blobpath, "blobs")
if os.path.exists(blobpath):
shutil.rmtree(blobpath, True)
message_json("encrypted cache emptied")
return
elif options.acommand == "open_website":
if not options.username:
message_json("username mising")
return
if not options.password:
message_json("password missing")
return
if not options.cryptobox:
message_json("cryptobox missing")
return
m = Memory()
m = authorize_user(m, options, force=True)
if not m.has_get("authorized"):
message_json("Username or password is not correct")
else:
encoded_token = b64_encode_safe("session_token:" + m.get("session_token"))
private_key = b64_encode_safe(m.get("private_key"))
webbrowser.open_new_tab(
options.server
+ options.cryptobox
+ "/autologin/"
+ options.username
+ "/"
+ encoded_token
+ "/"
+ private_key
)
else:
print "cba_main.py:267", "unknown command"
return
if options.motivation:
qlist = msgpack.load(open("quotes.list"))
q = qlist[random.randint(0, len(qlist)) - 1]
output_json({"motivation": q[0] + "\n\n- " + q[1]})
return
# noinspection PyUnusedLocal
single_instance = singleton.SingleInstance()
if options.decrypt:
if options.remove:
print "cba_main.py:281", "option remove (-r) cannot be used together with decrypt (dataloss)"
return False
if options.sync:
print "cba_main.py:285", "option sync (-s) cannot be used together with decrypt (hashmismatch)"
return False
if options.check:
print "cba_main.py:289", "option check (-o) cannot be used together with decrypt (hashmismatch)"
return False
if not options.password:
print "cba_main.py:293", "No password given (-p or --password)"
return False
if options.username or options.cryptobox:
if not options.username:
print "cba_main.py:298", "No username given (-u or --username)"
return False
if not options.cryptobox:
print "cba_main.py:302", "No cryptobox given (-b or --cryptobox)"
return False
if isinstance(options, dict):
options = Dict2Obj(options)
if options.version:
return "0.1"
if not options.numdownloadthreads:
options.numdownloadthreads = 2
else:
options.numdownloadthreads = int(options.numdownloadthreads)
options.numdownloadthreads = 8
if not options.dir:
print "cba_main.py:319", "Need DIR -f or --dir to continue"
return False
if not options.cryptobox:
print "cba_main.py:323", "No cryptobox given -b or --cryptobox"
return False
options.basedir = options.dir
ensure_directory(options.basedir)
options.dir = os.path.join(options.dir, options.cryptobox)
if not options.decrypt:
if quick_lock_check(options):
output_json({"locked": True})
return False
if not options.encrypt:
restore_hidden_config(options)
ensure_directory(options.dir)
datadir = get_data_dir(options)
if options.clear == "1":
if os.path.exists(datadir):
shutil.rmtree(datadir)
output_json({"info_message": "cryptobox cache removed: " + str(datadir)})
else:
output_json({"info_message": "cryptobox cache already removed: " + str(datadir)})
return
ensure_directory(datadir)
if not datadir:
print "cba_main.py:351", "datadir is None"
memory = Memory()
memory.load(datadir)
memory.replace("cryptobox_folder", options.dir)
if not os.path.exists(options.basedir):
print "cba_main.py:357", "DIR [", options.dir, "] does not exist"
return False
if options.sync:
if not options.username:
print "cba_main.py:362", "No username given (-u or --username)"
return False
if not options.password:
print "cba_main.py:366", "No password given (-p or --password)"
return False
if options.logout:
result, memory = on_server(memory, options, "logoutserver", {}, memory.get("session"))
return result[0]
elif options.treeseq:
memory = authorize_user(memory, options)
tree_seq = get_tree_sequence(memory, options)
if tree_seq:
output_json({"tree_seq": tree_seq})
return True
elif options.password and options.username and options.cryptobox and (options.sync or options.check):
memory = authorize_user(memory, options, force=True)
if not memory.get("connection"):
return
if not memory.get("authorized"):
message_json("Username or password is not correct")
output_json({"instruction": "lock_buttons_password_wrong"})
return
if memory.get("authorized"):
if options.check:
if quick_lock_check(options):
return False
ensure_directory(options.dir)
Events.event("check get_server_index")
serverindex, memory = get_server_index(memory, options)
Events.event("check make_local_index")
localindex = make_local_index(options)
Events.event("check get_sync_changes")
memory, options, file_del_server, file_downloads, file_uploads, dir_del_server, dir_make_local, dir_make_server, dir_del_local, file_del_local, server_path_nodes, unique_content, rename_server, rename_dirs, rename_local_dirs = get_sync_changes(
memory, options, localindex, serverindex
)
all_synced = all_item_zero_len(
[
file_del_server,
file_downloads,
file_uploads,
dir_del_server,
dir_make_local,
dir_make_server,
dir_del_local,
file_del_local,
rename_server,
rename_dirs,
]
)
outputdict = {
"file_del_server": file_del_server,
"file_downloads": file_downloads,
"file_uploads": file_uploads,
"dir_del_server": dir_del_server,
"dir_make_local": dir_make_local,
"dir_make_server": dir_make_server,
"dir_del_local": dir_del_local,
"file_del_local": file_del_local,
"all_synced": all_synced,
"rename_file_server": rename_server,
"rename_folder_server": rename_dirs,
"rename_local_dirs": rename_local_dirs,
}
output_json(outputdict)
elif options.sync:
if options.encrypt:
message_json("sync and encrypt called together")
return False
if quick_lock_check(options):
message_json("cryptobox is locked, nothing can be added now first decrypt (-d)")
return False
ensure_directory(options.dir)
Events.event("check sync_server")
localindex, memory = sync_server(memory, options)
# Events.report_measurements()
salt = secret = None
if options.encrypt:
salt, secret, memory, localindex = index_and_encrypt(memory, options)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
if options.decrypt:
if not options.clear == "1":
if not secret:
if memory.has("salt_b64"):
salt = base64.decodestring(memory.get("salt_b64"))
if not salt:
raise Exception("decrypt, no salt")
secret = password_derivation(options.password, salt)
memory = decrypt_and_build_filetree(memory, options, secret)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
reset_cryptobox_local(options)
memory.save(datadir)
if options.remove and salt and secret:
hide_config(options, salt, secret)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
finally:
pass
return True
def cryptobox_command(options):
"""
@param options: dictionary with options
@type options: namedtuple, Values
@return: succes indicator
@rtype: bool
"""
Events = Events()
try:
if options.acommand:
if options.acommand == "open_folder":
if options.dir:
p = os.path.join(options.dir, options.cryptobox)
open_folder(p)
output_json({"log": "open " + p})
else:
message_json("no folder given(-f)")
elif options.acommand == "hash":
if not options.input:
message_json("need input (-i)")
path = options.input
output_json({"hash": make_hash_path(path)})
return
elif options.acommand == "check_new_release":
if not options.server:
message_json("server mising")
if not options.compiled:
message_json("compiled mising")
log_json("options.compiled: " + options.compiled)
current_hash = make_hash_path(options.compiled)
hash_url = urlparse.urljoin(options.server,
"/st/data/cba_main.hash.json")
log_json("hash_url: " + hash_url)
result = urllib2.urlopen(hash_url).read()
result_json = json.loads(result)
new_release = not (current_hash == result_json["hash"])
output_json({
"new_release": new_release,
"current_hash": current_hash,
"hash_server": result_json["hash"]
})
return
elif options.acommand == "download_new_release":
if not options.server:
message_json("server mising")
output_json({"msg": "Downloading Cryptobox.dmg"})
download_url = urlparse.urljoin(options.server,
"/st/data/Cryptobox.dmg")
tempfile_cb = download_server(
None,
options,
download_url,
output_name_item_percentage="global_progress")
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
root = Tkinter.Tk()
root.withdraw()
file_path = tkFileDialog.asksaveasfilename(
parent=None,
message="Cryptobox",
initialfile='Cryptobox.dmg')
if file_path:
if os.path.exists(os.path.dirname(file_path)):
if os.path.exists(tempfile_cb):
os.rename(tempfile_cb, file_path)
cleanup_tempfiles()
return
elif options.acommand == "delete_blobs":
if not options.dir:
message_json("dir mising")
return
if not options.cryptobox:
message_json("cryptobox mising")
return
blobpath = os.path.join(options.dir, options.cryptobox)
blobpath = os.path.join(blobpath, ".cryptobox")
blobpath = os.path.join(blobpath, "blobs")
if os.path.exists(blobpath):
shutil.rmtree(blobpath, True)
message_json("encrypted cache emptied")
return
elif options.acommand == "open_website":
if not options.username:
message_json("username mising")
return
if not options.password:
message_json("password missing")
return
if not options.cryptobox:
message_json("cryptobox missing")
return
m = Memory()
m = authorize_user(m, options, force=True)
if not m.has_get("authorized"):
message_json("Username or password is not correct")
else:
encoded_token = b64_encode_safe("session_token:" +
m.get("session_token"))
private_key = b64_encode_safe(m.get("private_key"))
webbrowser.open_new_tab(options.server +
options.cryptobox + "/autologin/" +
options.username + "/" +
encoded_token + "/" + private_key)
else:
print "cba_main.py:267", "unknown command"
return
if options.motivation:
qlist = msgpack.load(open("quotes.list"))
q = qlist[random.randint(0, len(qlist)) - 1]
output_json({"motivation": q[0] + "\n\n- " + q[1]})
return
#noinspection PyUnusedLocal
single_instance = singleton.SingleInstance()
if options.decrypt:
if options.remove:
print "cba_main.py:281", "option remove (-r) cannot be used together with decrypt (dataloss)"
return False
if options.sync:
print "cba_main.py:285", "option sync (-s) cannot be used together with decrypt (hashmismatch)"
return False
if options.check:
print "cba_main.py:289", "option check (-o) cannot be used together with decrypt (hashmismatch)"
return False
if not options.password:
print "cba_main.py:293", "No password given (-p or --password)"
return False
if options.username or options.cryptobox:
if not options.username:
print "cba_main.py:298", "No username given (-u or --username)"
return False
if not options.cryptobox:
print "cba_main.py:302", "No cryptobox given (-b or --cryptobox)"
return False
if isinstance(options, dict):
options = Dict2Obj(options)
if options.version:
return "0.1"
if not options.numdownloadthreads:
options.numdownloadthreads = 2
else:
options.numdownloadthreads = int(options.numdownloadthreads)
options.numdownloadthreads = 8
if not options.dir:
print "cba_main.py:319", "Need DIR -f or --dir to continue"
return False
if not options.cryptobox:
print "cba_main.py:323", "No cryptobox given -b or --cryptobox"
return False
options.basedir = options.dir
ensure_directory(options.basedir)
options.dir = os.path.join(options.dir, options.cryptobox)
if not options.decrypt:
if quick_lock_check(options):
output_json({"locked": True})
return False
if not options.encrypt:
restore_hidden_config(options)
ensure_directory(options.dir)
datadir = get_data_dir(options)
if options.clear == "1":
if os.path.exists(datadir):
shutil.rmtree(datadir)
output_json({
"info_message":
"cryptobox cache removed: " + str(datadir)
})
else:
output_json({
"info_message":
"cryptobox cache already removed: " + str(datadir)
})
return
ensure_directory(datadir)
if not datadir:
print "cba_main.py:351", "datadir is None"
memory = Memory()
memory.load(datadir)
memory.replace("cryptobox_folder", options.dir)
if not os.path.exists(options.basedir):
print "cba_main.py:357", "DIR [", options.dir, "] does not exist"
return False
if options.sync:
if not options.username:
print "cba_main.py:362", "No username given (-u or --username)"
return False
if not options.password:
print "cba_main.py:366", "No password given (-p or --password)"
return False
if options.logout:
result, memory = on_server(memory, options, "logoutserver", {},
memory.get("session"))
return result[0]
elif options.treeseq:
memory = authorize_user(memory, options)
tree_seq = get_tree_sequence(memory, options)
if tree_seq:
output_json({"tree_seq": tree_seq})
return True
elif options.password and options.username and options.cryptobox and (
options.sync or options.check):
memory = authorize_user(memory, options, force=True)
if not memory.get("connection"):
return
if not memory.get("authorized"):
message_json("Username or password is not correct")
output_json({"instruction": "lock_buttons_password_wrong"})
return
if memory.get("authorized"):
if options.check:
if quick_lock_check(options):
return False
ensure_directory(options.dir)
Events.event("check get_server_index")
serverindex, memory = get_server_index(memory, options)
Events.event("check make_local_index")
localindex = make_local_index(options)
Events.event("check get_sync_changes")
memory, options, file_del_server, file_downloads, file_uploads, dir_del_server, dir_make_local, dir_make_server, dir_del_local, file_del_local, server_path_nodes, unique_content, rename_server, rename_dirs, rename_local_dirs = get_sync_changes(
memory, options, localindex, serverindex)
all_synced = all_item_zero_len([
file_del_server, file_downloads, file_uploads,
dir_del_server, dir_make_local, dir_make_server,
dir_del_local, file_del_local, rename_server,
rename_dirs
])
outputdict = {
"file_del_server": file_del_server,
"file_downloads": file_downloads,
"file_uploads": file_uploads,
"dir_del_server": dir_del_server,
"dir_make_local": dir_make_local,
"dir_make_server": dir_make_server,
"dir_del_local": dir_del_local,
"file_del_local": file_del_local,
"all_synced": all_synced,
"rename_file_server": rename_server,
"rename_folder_server": rename_dirs,
"rename_local_dirs": rename_local_dirs
}
output_json(outputdict)
elif options.sync:
if options.encrypt:
message_json("sync and encrypt called together")
return False
if quick_lock_check(options):
message_json(
"cryptobox is locked, nothing can be added now first decrypt (-d)"
)
return False
ensure_directory(options.dir)
Events.event("check sync_server")
localindex, memory = sync_server(memory, options)
#Events.report_measurements()
salt = secret = None
if options.encrypt:
salt, secret, memory, localindex = index_and_encrypt(
memory, options)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
if options.decrypt:
if not options.clear == "1":
if not secret:
if memory.has("salt_b64"):
salt = base64.decodestring(memory.get("salt_b64"))
if not salt:
raise Exception("decrypt, no salt")
secret = password_derivation(options.password, salt)
memory = decrypt_and_build_filetree(memory, options, secret)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
reset_cryptobox_local(options)
memory.save(datadir)
if options.remove and salt and secret:
hide_config(options, salt, secret)
output_json({"msg": ""})
output_json({"item_progress": 0})
output_json({"global_progress": 0})
finally:
pass
return True
