def encrypt_message(self, message):
file = open(self.key_file_name, 'rb')
key = file.read()
f = fn(key)
encrypted = f.encrypt(message.encode())
print(encrypted)
return encrypted
def decrypt_message(self, encrypted_message):
file = open(self.key_file_name, 'rb')
key = file.read()
f = fn(key)
decrypted = f.decrypt(encrypted_message)
file.close()
return decrypted
def reviewAndroidAutoConfig():
no_of_config = 0
os.system('cls')
count = 0
print(
"\n -------------------------------Auto Backup Solution-----------------------------"
)
print(
"\n ---------------------------Android Auto Backup Solution-------------------------"
)
print(
"\n -------------------------Review Android Auto Configration-----------------------\n"
)
if os.path.isfile(
"C://ProgramData//Ultra Backup//UserAccount.iUB") == True:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'rb') as fileBackup:
data = fileBackup.read()
fileBackup.close()
decrData = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).
decrypt(data))
for eachData in decrData:
if eachData.find("AndroidAutoConfig") != -1:
no_of_config += 1
if no_of_config == 0:
print(
" --Sorry you dont have any Android Auto Configration Saved."
)
print(
" --Goto Android Auto Backup/New Auto Configration to create one."
)
input(" --Press enter to continue.")
return
else:
for eachfind in decrData:
if eachfind.find("AndroidAutoConfig") != -1:
print(" [" + str(count) + "]." + eachfind)
count += 1
print(" FTP Details: ")
print(" --Host Address: " +
decrData[eachfind]['adress'])
print(" --Port: " +
str(decrData[eachfind]['port']))
print(" --Username: "******" --Password: "******" Backup Directory: " +
decrData[eachfind]['backupDir'])
print(" Folder to Backup: ")
for folder in decrData[eachfind]['folderBackup']:
print(" --" +
decrData[eachfind]['folderBackup'][folder])
print(" Activation Status: " +
decrData[eachfind]['activation'] + "\n")
input(" --Press Enter to continue: ")
return
def reviewPCAutoConfig():
no_of_config = 0
os.system('cls')
count = 0
print(
"\n ------------------------------Auto Backup Solution------------------------------"
)
print(
"\n ----------------------------PC Auto Backup Solution-----------------------------"
)
print(
"\n --------------------------Review PC Auto Configration---------------------------\n"
)
if os.path.isfile(
"C://ProgramData//Ultra Backup//UserAccount.iUB") == True:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'rb') as fileBackup:
data = fileBackup.read()
fileBackup.close()
decrData = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).
decrypt(data))
for eachData in decrData:
if eachData.find("PCAutoConfig") != -1:
no_of_config += 1
if no_of_config == 0:
print(" --Sorry you dont have any PC Auto Configration Saved.")
print(
" --Goto PC Auto Backup/New Auto Configration to create one."
)
input(" --Press enter to continue.")
return
else:
for eachfind in decrData:
if eachfind.find("PCAutoConfig") != -1:
print(" [" + str(count) + "]." + eachfind)
count += 1
print(" Folder to Backup: ")
for folder in decrData[eachfind]['folder']:
print(" --" +
decrData[eachfind]['folder'][folder])
print(" Folder where to backup: " +
decrData[eachfind]['location'])
print(" UBMap directory: " +
decrData[eachfind]['ubmap'])
print(" Working Directory: " +
decrData[eachfind]['workingDir'])
print(" Type of Backup: " +
decrData[eachfind]['simCry'])
print(" Activation Status: " +
decrData[eachfind]['activation'] + "\n")
input(" --Press Enter to continue: ")
return
def pack_msg(self, str):
msg = dict()
#Create and save encryption key
key = fn.generate_key()
encrypter = fn(key)
msg['key'] = key.decode()
msg['body'] = encrypter.encrypt(str.encode()).decode()
if self.cp:
print("[Checkpoint 09] Encrypt: Generated Key: ", msg['key'],
" Cyper Text: ", msg['body'])
msg['checksum'] = hashlib.md5(str.encode()).hexdigest()
if self.cp: print("[Checkpoint 10] MD5 Checksum: ", msg['checksum'])
return json.dumps(msg)
def userMenu():
data = {}
if os.path.isfile(
"C://ProgramData//Ultra Backup//UserAccount.iUB") == False:
if os.path.isdir("C://ProgramData//Ultra Backup") == False:
os.makedirs("C://ProgramData//Ultra Backup")
print(" --It seems that you are new to Ultra Backup")
print(" --Create a new User ID\n")
userID = input(" --Enter your Name: ")
print("\n --Now onwards you will be called: " + userID)
data["User"] = userID
writeEncry = fn(
"CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).encrypt(
json.dumps(data).encode())
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'wb') as file:
file.write(writeEncry)
file.close()
print("\n --Now you will be directed to main menu")
def unpack_msg(self, str):
if self.cp: print("[Checkpoint 04] Received Data: ", str)
e_msg = json.loads(str)
d_msg = dict()
e_msg['key'] = e_msg['key'].encode()
e_msg['body'] = e_msg['body'].encode()
decrypter = fn(e_msg['key'])
d_msg['body'] = decrypter.decrypt(e_msg['body']).decode()
d_msg['checksum'] = e_msg['checksum'] == hashlib.md5(
d_msg['body'].encode()).hexdigest()
if self.cp:
print("[Checkpoint 05] Decrypt: Key: ", e_msg['key'],
" Plain text: ", d_msg['body'])
return d_msg
with open("C://ProgramData//Ultra Backup//TurnAutoOff.UBon",
'w') as offAutoBackup: #to turn of the autobackup programme.
offAutoBackup.write("Off Auto Backup")
offAutoBackup.close()
if os.path.isdir("C://temp") == False:
try:
os.makedirs("C://temp")
except:
num = 0
if os.path.isfile("C://ProgramData//Ultra Backup//UserAccount.iUB") == False:
li.userMenu()
input(" --Press enter to continue")
os.system('cls')
with open("C://ProgramData//Ultra Backup//UserAccount.iUB", 'rb') as file2:
data = file2.read()
file2.close()
USER = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).decrypt(
data))['User']
os.startfile("ubAutoRedar.exe")
mainMenu()
else:
if os.path.isdir("C://ProgramData//Ultra Backup") == False:
os.makedirs("C://ProgramData//Ultra Backup")
with open("C://ProgramData//Ultra Backup//UserAccount.iUB", 'rb') as file2:
data = file2.read()
file2.close()
USER = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).decrypt(
data))['User']
mainMenu()
def zipEncryptFiles(fil_dict, dir_loc, nu_ub_files, where_to_B, working_dir):
limit_zip = 300*1024*1024
size_to = 200*1024*1024
symbol_list = "~!`@#$%^&()_-+={[}];',"
zip_name = {}
key = {}
error = 0
error_report = {}
if len(fil_dict)!=0:
for files in fil_dict:
os.chdir(dir_loc)
error_report[files] = {}
rand_range = random.randrange(8, 24)
rand_name = ''.join(random.choices(string.ascii_letters + string.digits + symbol_list, k=rand_range))
fi_name = rand_name + ".zip"
try:
rar_file = zf.ZipFile(working_dir + fi_name, 'w')
try:
rar_file.write(fil_dict[files], compress_type=zf.ZIP_DEFLATED)
except:
error_report[files]["er_write_zip"] = fil_dict[files]
error = 1
rar_file.close()
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
rar_file.close()
except:
error_report[files]["er_create_zip"] = working_dir + fi_name
error = 1
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
key[files] = (fn.generate_key()).decode()
enc_key = fn(key[files].encode())
os.chdir(working_dir)
if os.stat(fi_name).st_size>=limit_zip:
zip_name[files] = {}
num_split = os.stat(fi_name).st_size//size_to + 1
try:
with open (fi_name, 'rb') as split:
for volume in range(1, num_split + 1, 1):
rand_range = random.randrange(8, 24)
rand_name = ''.join(random.choices(string.ascii_letters + string.digits + symbol_list, k=rand_range))
split_name = where_to_B + "//" + rand_name + "."
zip_name[files][volume] = rand_name
encr_spl_file = enc_key.encrypt(split.read(size_to))
try:
with open (split_name + "sUB", 'wb') as writ_spl:
try:
writ_spl.write(encr_spl_file)
writ_spl.close()
nu_ub_files = nu_ub_files + 1
except:
error = 1
error_report[files]["er_write_sUB"] = split_name + "sUB"
writ_spl.close()
split.close()
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
except:
error = 1
error_report[files]["er_create_sUB"] = split_name + "sUB"
split.close()
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
split.close()
except:
error_report[files]["er_open_zip"] = working_dir + fi_name
error = 1
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
os.remove(fi_name)
print(".", end='', flush=True)
else:
zip_name[files] = fi_name[:-4]
try:
with open (fi_name, 'rb') as no_split:
no_split_name = where_to_B + "//" + fi_name[:-4] + "."
encr_spl_file = enc_key.encrypt(no_split.read())
try:
with open (no_split_name + "eUB", 'wb') as writ_spl:
try:
writ_spl.write(encr_spl_file)
writ_spl.close()
nu_ub_files = nu_ub_files + 1
except:
error_report[files]["er_write_eUB"] = no_split_name + "eUB"
error = 1
writ_spl.close()
no_split.close()
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
except:
error_report[files]["er_create_eUB"] = no_split_name + "eUB"
error = 1
no_split.close()
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
no_split.close()
except:
error_report[files]["er_open_zip"] = working_dir + fi_name
error = 1
errorSave(working_dir, error_report, dir_loc)
return zip_name, key, nu_ub_files
os.remove(fi_name)
print(".", end='', flush=True)
return zip_name, key, nu_ub_files
def step4(ftpAdress, port, username, password, selectedFolder, backup_dir):
errorReport = {}
os.system('cls')
print(
"\n ------------------------------------Project Ultra backup---------------------------------\n"
)
print(
" --------------------------------Android Auto Backup Configure----------------------------\n"
)
print(" STEP: 4 FINAL STAGE\n")
print(
" --Finally the process is complete, the following configration will be saved: \n"
)
print(" >> FTP Server Adress: " + str(ftpAdress))
print(" >> FTP Port: " + str(port))
print(" >> User Name: " + str(username))
print(" >> Password: "******" >> Backup folder in PC: " + str(backup_dir))
print(" >> Selected folder to backup: ")
for each in selectedFolder:
print(" --" + selectedFolder[each])
yesOrNo = input("\n Do you want to save the settings[y/n]: ")
if yesOrNo == 'y':
print(
"\n --Name you configration.(exclude these charactor: \\, /, :, *, >, <, |"
)
nameSettings = input(" Enter a name: ")
print(
"\n --Activating the configure will start the backup process from this time onwards"
)
doTurnOn = input(
" Do you want to Activate the Auto Backup, you just configured[y/n]: "
)
if os.path.isfile(backup_dir + "//" + "UB_" + str(nameSettings) +
".aab") == False:
try:
with open(
backup_dir + "//" + "UB_" + str(nameSettings) + ".aab",
'w') as aabFile:
aabFile.write(
"This is a ULTRA BACKUP Android Auto Backup File")
aabFile.close()
except Exception as e:
print(" --Sorry the Location to backup is Read Only.")
print(" --Select a different folder, exiting.")
errorReport["er_create_aab"] = backup_dir + "//" + "UB_" + str(
nameSettings) + ".aab"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, whereTo)
return
try:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'rb') as file2:
data = file2.read()
file2.close()
except Exception as e:
errorReport[
"er_read_UBi"] = "C://ProgramData//Ultra Backup//UserAccount.iUB"
errorReport["Exception: "] = str(e)
errorSave('C://temp', errorReport, 'read UBi')
return
decryData = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).
decrypt(data))
decryData["AndroidAutoConfig-" + str(nameSettings)] = {}
decryData["AndroidAutoConfig-" +
str(nameSettings)]['adress'] = ftpAdress
decryData["AndroidAutoConfig-" + str(nameSettings)]['port'] = port
decryData["AndroidAutoConfig-" +
str(nameSettings)]['username'] = username
decryData["AndroidAutoConfig-" +
str(nameSettings)]['password'] = password
decryData["AndroidAutoConfig-" +
str(nameSettings)]['backupDir'] = backup_dir
decryData["AndroidAutoConfig-" +
str(nameSettings)]['folderBackup'] = selectedFolder
decryData["AndroidAutoConfig-" +
str(nameSettings)]['activation'] = doTurnOn
writeEncry = fn(
"CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).encrypt(
json.dumps(decryData).encode())
try:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'wb') as file3:
file3.write(writeEncry)
file3.close()
print(" --Configration Saved Successfully")
except Exception as e:
errorReport[
"er_save_config"] = "C://ProgramData//Ultra Backup//UserAccount.iUB"
errorReport["Exception: "] = str(e)
errorSave('C://temp', errorReport, 'save')
return
return
else:
print('All you configration, is discarded...')
return
def pcAutoActivateDeactivte():
no_of_config = 0
count = 0
loop = 'notexit'
xcount = 0
os.system('cls')
print(
"\n -------------------------------Auto Backup Solution-----------------------------"
)
print(
"\n -----------------------------PC Auto Backup Solution----------------------------"
)
print(
"\n -------------------------Activate Deactivate Configration-----------------------\n"
)
if os.path.isfile(
"C://ProgramData//Ultra Backup//UserAccount.iUB") == True:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'rb') as fileBackup:
data = fileBackup.read()
fileBackup.close()
decrData = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).
decrypt(data))
for eachData in decrData:
if eachData.find("PCAutoConfig") != -1:
no_of_config += 1
if no_of_config == 0:
print(" --Sorry you dont have any PC Auto Configration Saved.")
print(
" --Goto PC Auto Backup/New Auto Configration to create one."
)
input(" --Press enter to continue.")
return
else:
while loop != 'exit':
os.system('cls')
print(
"\n -------------------------------Auto Backup Solution-----------------------------"
)
print(
"\n -----------------------------PC Auto Backup Solution----------------------------"
)
print(
"\n -------------------------Activate Deactivate Configration-----------------------\n"
)
print(" --The follwing Configration was found: \n")
count = 0
for eachfind in decrData:
if eachfind.find("PCAutoConfig") != -1:
print(" [" + str(count) + "]." + eachfind)
count += 1
print(" Folder to Backup: ")
for folder in decrData[eachfind]['folder']:
print(" --" +
decrData[eachfind]['folder'][folder])
print(" Folder where to backup: " +
decrData[eachfind]['location'])
print(" UBMap directory: " +
decrData[eachfind]['ubmap'])
print(" Working Directory: " +
decrData[eachfind]['workingDir'])
print(" Type of Backup: " +
decrData[eachfind]['simCry'])
print(" Activation Status: " +
decrData[eachfind]['activation'] + "\n")
print(
"\n --Select the setting you want to Activate/Deactivate, enter the number corresponding."
)
print(" --if you want to quit type 'exit'.")
x = input("\n --Select: ")
if x == 'exit':
loop = 'exit'
print(" --Settings saved successfully.")
input(" --Press enter to continue.")
writeEncry = fn(
"CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode(
)).encrypt(json.dumps(decrData).encode())
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'wb') as writefile:
writefile.write(writeEncry)
writefile.close()
elif x.isdigit() == True:
xcount = 0
for change in decrData:
if change.find("PCAutoConfig") != -1:
xcount += 1
if xcount == int(x) + 1:
print("\n --You selected: " + change +
" with activation status: " +
decrData[change]['activation'])
if decrData[change]['activation'] == 'y':
doYou = input(
" --Do you wish to deactivate the settings[y/n]: "
)
if doYou == 'y':
print(
" --Settings changed, Deactivated"
)
decrData[change]['activation'] = 'n'
else:
print(
" --No change made, Setting remains activated"
)
elif decrData[change]['activation'] == 'n':
doYouN = input(
" --Do you wish to activate the settings[y/n]: "
)
if doYouN == 'y':
print(
" --Settings changed, Activated")
decrData[change]['activation'] = 'y'
else:
print(
" --No change made, Settings remains deactivated"
)
else:
print(" --Enter a valid option.")
input(" --Press enter to continue.")
else:
print(" --Enter a valid option.")
input(" --Press enter to continue: ")
else:
print(
"It seems that you are new to this software, please Open Ultra Backup and config"
)
def extractUBMap():
errorReport = {}
backupData = {}
print(" --This tool help you to extract a UBMap and file contained within it.")
print(" --You only have to select the location of the UBMap, and type the location")
print(" .. of backup folder and location to restore the data.")
ubdir = input("\n --Enter the location of the UBMap location: ")
ubfileSelected = viewUB(ubdir)
if ubfileSelected.find("\\")!=-1:
ubfileSelected = ubfileSelected.replace("\\", "//")
backupFile = input("\n --Enter the backup folder location: ")
if os.path.isdir(backupFile)==False:
print(" --Invalid folder")
input(" --Press enter to continue: ")
return
if backupFile.find("\\")!=-1:
backupFile = backupFile.replace("\\", "//")
restoreLocation = input(" --Enter the restore location: ")
if os.path.isdir(restoreLocation)==False:
print(" --Invalid folder")
input(" --Press enter to continue: ")
return
if restoreLocation.find("\\")!=-1:
restoreLocation = restoreLocation.replace("\\", "//")
workingDir = input(" --Enter the working Directory: ")
if os.path.isdir(workingDir)==False:
print(" --Invalid folder")
input(" --Press enter to continue: ")
return
if workingDir.find("\\")!=-1:
workingDir = workingDir.replace("\\", "//")
with open(ubfileSelected, 'r') as ourfile:
dataUbamp = json.load(ourfile)
ourfile.close()
for folder, subfolder, files in os.walk(backupFile):
for eachFile in files:
backupData[eachFile] = folder.replace("\\", "//")
for eachFolder in dataUbamp:
if os.path.isdir(restoreLocation + "//" + eachFolder)==False:
os.makedirs(restoreLocation + "//" + eachFolder)
for eachfiles in dataUbamp[eachFolder]["fi_s"]:
if type(dataUbamp[eachFolder]["z_n"][eachfiles])==type({}):
randName = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
for eachZip in dataUbamp[eachFolder]["z_n"][eachfiles]:
if dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB" in backupData:
try:
with open(workingDir + "//" + randName + ".zip", 'ab') as subZip:
with open(backupData[dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB"] + "//" + dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB", 'rb') as subFile:
subExcData = subFile.read()
subFile.close()
subDecKey = dataUbamp[eachFolder]["k"][eachfiles].encode()
subDecKey = fn(subDecKey)
subDecryptData = subDecKey.decrypt(subExcData)
subZip.write(subDecryptData)
subZip.close()
except Exception as e:
errorReport["er_create/write/decrypt: "] = workingDir + "//" + randName + ".zip" + " or " + backupData[dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB"] + "//" + dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
else:
print(" --Some file are missing..the restore, will not be proper.")
print(" --File missing: " + dataUbamp[eachFolder]["z_n"][eachfiles][eachZip] + ".sUB")
print(" --Restore not possible: " + dataUbamp[eachFolder]["fi_s"][eachfiles])
try:
openZipSub = zf.ZipFile(workingDir + "//" + randName + ".zip")
openZipSub.extractall(restoreLocation + "//" + eachFolder + "//")
openZipSub.close()
except Exception as e:
errorReport["er_unzipping: "] = workingDir + "//" + randName + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
try:
os.remove(workingDir + "//" + randName + ".zip")
except Exception as e:
errorReport["er_removing_:"] = workingDir + "//" + randName + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
print(".", end='', flush=True)
elif type(dataUbamp[eachFolder]["z_n"][eachfiles])==type('str'):
if dataUbamp[eachFolder]["z_n"][eachfiles] + ".eUB" in backupData:
with open(backupData[dataUbamp[eachFolder]["z_n"][eachfiles] + ".eUB"] + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".eUB", 'rb') as encrFile:
encrData = encrFile.read()
encrFile.close()
deckey = dataUbamp[eachFolder]["k"][eachfiles].encode()
deckey = fn(deckey)
decData = deckey.decrypt(encrData)
try:
with open(workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip", 'wb') as zipfile:
zipfile.write(decData)
zipfile.close()
except Exception as e:
errorReport["er_create/write_zip"] = workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
try:
openZipFile = zf.ZipFile(workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip")
openZipFile.extractall(restoreLocation + "//" + eachFolder + "//")
openZipFile.close()
except Exception as e:
errorReport["er_unzipping: "] = workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
try:
os.remove(workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip")
except Exception as e:
errorReport["er_removing_zip"] = workingDir + "//" + dataUbamp[eachFolder]["z_n"][eachfiles] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, workingDir)
print(".", end='', flush=True)
else:
print(" --File missing: " + dataUbamp[eachFolder]["z_n"][eachfiles] + ".eUB" + " cannot backup file: " + dataUbamp[eachFolder]["fi_s"][eachfiles])
print(" --Select another backup location if any.")
print(" --Restore Completed: Files saved at: " + restoreLocation)
return
def srFileExtract(sr_file, restore_directory, backup_directory, working_directory):
errorReport = {}
if os.path.isfile(sr_file)==False:
print(" Error, no such .srUB file found")
return
if os.path.isdir(restore_directory)==False:
print(" Error, Restore directory Not found")
return
if os.path.isdir(backup_directory)==False:
print(" Error, Backup Directory not found")
return
if os.path.isdir(working_directory)==False:
try:
os.makedirs(working_directory)
except Exception as e:
errorReport["er_making_dir"] = working_directory
errorReport["Exception: "] = str(e)
print("Choose a different Working directory.")
return
try:
with open(sr_file, 'r') as srFIle:
srData = json.load(srFIle)
srFIle.close()
except Exception as e:
print(" srUB file cannot be opened")
print(" Error: " + e)
errorReport["Exception: "] = str(e)
errorReport["er_opening_srUBfile: "] = sr_file
errorSave("C://temp", errorReport, sr_file)
return
for count in srData:
if type(srData[count]["UB file name"])==type([]):
randName = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
for eachSub in srData[count]["UB file name"]:
for folder, subfolder, files in os.walk(backup_directory):
for sUb in files:
if os.path.basename(sUB)==srData[count]["UB file name"][eachSub] + ".sUB":
try:
with open(folder + "//" + sUB, 'rb') as sfile:
sdata = sfile.read()
sfile.close()
except Exception as e:
print(" Error, sUB file cannot be opened")
print(" Moving to next file.")
errorReport["er_open_sub: "] = folder + "//" + sUB
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, folder)
key = srData[count]["Key used to Encrypt"].encode()
key = fn(key)
try:
sdecodeData = key.decrypt(sdata)
except Exception as e:
errorReport["er_decrypt"] = folder + "//" + sUB + " data"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, folder)
try:
with open(working_directory + "//" + randName + ".zip", 'ab') as szipfile:
szipfile.write(sdecodeData)
szipfile.close()
except Exception as e:
errorReport["er_create/write_zip"] = working_directory + "//" + randName + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, working_directory)
if os.path.isdir(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"])==False:
try:
os.makedirs(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"])
except Exception as e:
errorReport["er_create_directory: "] = restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"]
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, restore_directory)
try:
szipExtr = zf.ZipFile(working_directory + "//" + randName + ".zip")
szipExtr.extractall(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"] + "//")
szipExtr.close()
except Exception as e:
errorReport["er_unzipping: "] = working_directory + "//" + randName + ".zip"
errorReport["Exception:"] = str(e)
errorSave("C://temp", errorReport, working_directory)
try:
os.remove(working_directory + "//" + randName + ".zip")
except Exception as e:
errorReport["er_remove_zip"] = working_directory + "//" + randName + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, working_directory)
print(".", end='', flush=True)
elif type(srData[count]["UB file name"])==type("str"):
for folder, subfolder, files in os.walk(backup_directory):
for fil in files:
if os.path.basename(fil)==srData[count]["UB file name"] + ".eUB":
with open(folder + "//" + fil, 'rb') as efile:
edata = efile.read()
efile.close()
key = srData[count]["Key used to Encrypt"].encode()
key = fn(key)
try:
decodeData = key.decrypt(edata)
except Exception as e:
errorReport["er_decrypt"] = folder + "//" + fil + " data"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, folder)
try:
with open(working_directory + "//" + srData[count]["UB file name"] + ".zip", 'wb') as ezip:
ezip.write(decodeData)
ezip.close
except Exception as e:
errorReport["er_create/write_zip"] = working_directory + "//" + srData[count]["UB file name"] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, working_directory)
if os.path.isdir(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"])==False:
try:
os.makedirs(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"])
except Exception as e:
errorReport["er_make_directory: "] = restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"]
errorReport["Exception: "] =str(e)
errorSave("C://temp", errorReport. restore_directory)
try:
ezipExtr = zf.ZipFile(working_directory + "//" + srData[count]["UB file name"] + ".zip")
ezipExtr.extractall(restore_directory + "//" + srData[count]["UBmap"] + "//" + srData[count]["File in Directory"] + "//")
ezipExtr.close()
except Exception as e:
errorReport["er_unzipping: "] = working_directory + "//" + srData[count]["UB file name"] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, working_directory)
try:
os.remove(working_directory + "//" + srData[count]["UB file name"] + ".zip")
except Exception as e:
errorReport["er_removing_file: "] = working_directory + "//" + srData[count]["UB file name"] + ".zip"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, working_directory)
print(".", end='', flush=True)
return
def step4(backupFolder, whereTo, ubmap, workingDir, simCry):
errorReport = {}
decryData = {}
os.system('cls')
print(
"\n ------------------------------------Project Ultra backup---------------------------------\n"
)
print(
" ------------------------------------PC Auto Backup Configure-----------------------------\n"
)
print(" STEP: 4 FINISH\n")
print(" --You entered the following configration: \n")
print(" --Selected folder to Backup: \n")
for each in backupFolder:
print(" [" + str(each) + "]." + backupFolder[each])
print("\n")
print(" --Location where to Backup: " + whereTo + "\n")
print(" --UBMap Folder: " + ubmap)
print(" --Working Directory: " + workingDir)
print(" --Type of Backup: " + simCry)
doYou = input(" --Do you want to save the settings[y/n]: ")
if doYou == 'y':
print(
"\n --Name you configration.(exclude these charactor: \\, /, :, *, >, <, |"
)
name = input(" --Name: ")
doActivate = input("\n --Do you wish to activate the Backup[y/n]: ")
if os.path.isfile(whereTo + "//" + "UB_" + str(name) +
"autoFile.pab") == False:
try:
with open(whereTo + "//" + "UB_" + str(name) + ".pab",
'w') as pab: #Not this file for Auto Backup
pab.write("This is a ULTRA BACKUP PC Auto Backup File")
pab.close()
except Exception as e:
print(" --Sorry the Location to backup is Read Only.")
print(" --Select a different folder, exiting.")
errorReport["er_create_pab"] = whereTo + "//" + "UB_" + str(
name) + ".pab"
errorReport["Exception: "] = str(e)
errorSave("C://temp", errorReport, whereTo)
return 'exit'
print("\n --You will see a new file: " + whereTo + "//" + "UB_" +
str(name) + "autoFile.pab" + " in the")
print(
" ..location to backup, do not worry this is a system file for the Ultra backup"
)
print(
" ..do not delete this file, as it may result in stop working of Auto Backup\n"
)
if os.path.isfile(
"C://ProgramData//Ultra Backup//UserAccount.iUB") == True:
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'rb') as filess:
readData = filess.read()
filess.close()
decryData = json.loads(
fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).
decrypt(readData))
decryData["PCAutoConfig-" + name] = {}
decryData["PCAutoConfig-" + name]['folder'] = backupFolder
decryData["PCAutoConfig-" + name]['location'] = whereTo
decryData["PCAutoConfig-" + name]['activation'] = doActivate
decryData["PCAutoConfig-" + name]['ubmap'] = ubmap
decryData["PCAutoConfig-" + name]['workingDir'] = workingDir
decryData["PCAutoConfig-" + name]['simCry'] = simCry
writeEncry = fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".
encode()).encrypt(json.dumps(decryData).encode())
with open("C://ProgramData//Ultra Backup//UserAccount.iUB",
'wb') as writeFile:
writeFile.write(writeEncry)
writeFile.close()
print(" --Configration saved successfully")
return 'success'
else:
print(" --Enter a valid option, user terminated")
return 'exit'
def restore(restoreDirectory, backupDirectory, toRecover, workingDirectory, backupScan):
global error
errorReport = {}
if os.path.isdir(restoreDirectory)==False:
try:
os.makedirs(restoreDirectory)
except Exception as e:
error += 1
errorReport["er_create_restoredir"] = restoreDirectory
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Please select another directory."
errorSave(workingDirectory, errorReport, restoreDirectory)
return
for eachUBFile in backupScan[".UBmap"]:
try:
with open(backupScan[".UBmap"][eachUBFile], 'r') as ubfile:
try:
ubstore = json.load(ubfile)
ubfile.close()
except Exception as e:
ubfile.close()
error += 1
errorReport["er_load_ubmap"] = backupScan[".UBmap"][eachUBFile]
errorReport["Error: "] = str(e)
errorSave(workingDirectory, errorReport, ubmapDirectory)
except Exception as e:
error += 1
errorReport["er_open_UBmap"] = backupScan[".UBmap"][eachUBFile]
errorReport["Error: "] = str(e)
errorReport["Effect: "] = "Some files cannot be backed up due to, not accessible .UBmap or try again"
errorSave(workingDirectory, errorReport, ubmapDirectory)
scanUBFiles = scanDate(backupScan["UB_date"][eachUBFile])
for eachData in ubstore:
if os.path.isdir(restoreDirectory + eachData)==False:
try:
os.makedirs(restoreDirectory + eachData)
except Exception as e:
error += 1
errorReport["er_create_dir"] = restoreDirectory + eachData
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Please select another directory."
errorSave(workingDirectory, errorReport, restoreDirectory)
return
for withinData in ubstore[eachData]["z_n"]:
if type(ubstore[eachData]["z_n"][withinData])==type({}):
badFile = 0
randName = ''.join(random.choices(string.ascii_letters + string.digits, k=8))
for eachSplit in ubstore[eachData]["z_n"][withinData]:
if ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB" in scanUBFiles:
try:
with open(workingDirectory + randName + ".zip", 'ab') as sUBZipFile:
try:
with open(scanUBFiles[ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"] + "//" + ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB", 'rb') as sUBFile:
try:
sUBData = sUBFile.read()
sUBFile.close()
except Exception as e:
sUBFile.close()
error += 1
errorReport["er_read_.sUB"] = scanUBFiles[ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"] + "//" + ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to next file to restore."
errorSave(workingDirectory, errorReport, backupDirectory)
decryptKey = (ubstore[eachData]["k"][withinData]).encode()
decryptKey = fn(decryptKey)
try:
decryptFile = decryptKey.decrypt(sUBData)
except Exception as e:
error += 1
errorReport["er_decrypt_file"] = scanUBFiles[ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"] + "//" + ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"
errorReport["Error: "] = str(e)
errorReport["Planof action: "] = "Looks that the key is not suitable, or the UBmap file is altered...."
errorSave(workingDirectory, errorReport, backupDirectory)
try:
sUBZipFile.write(decryptFile)
sUBZipFile.close()
except Exception as e:
sUBZipFile.close()
error += 1
errorReport["er_writing_zip"] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to next file."
errorSave(workingDirectory, errorReport, workingDirectory)
except Exception as e:
sUBZipFile.close()
error += 1
errorReport["er_open_.sUB"] = scanUBFiles[ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"] + "//" + ubstore[eachData]["z_n"][withinData][eachSplit] + ".sUB"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to next file"
errorSave(workingDirectory, errorReport, backupDirectory)
except Exception as e:
error += 1
errorReport["er_open/create_zip"] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Continue with the next files....."
errorSave(workingDirectory, errorReport, workingDirectory)
else:
badFile = 1
print("Some files are missing from the backup directory.")
print("Restore of: " + str(ubstore[eachData]["fi_s"][withinData]) + " is currently not possible...")
print("Missing file: " + str(ubstore[eachData]["z_n"][withinData][eachSplit]) + ".sUB")
try:
os.remove(workingDirectory + randName + ".zip")
except Exception as e:
error += 1
errorReport["er_remove_zip"] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorSave(workingDirectory, errorReport, workingDirectory)
print(".", end='', flush=True)
if badFile!=1:
try:
openZip = zf.ZipFile(workingDirectory + randName + ".zip")
try:
openZip.extractall(restoreDirectory + eachData + "//")
openZip.close()
except Exception as e:
openZip.close()
error += 1
errorReport["er_extracting_files: "] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Move to next file" + " Cause amy be due to corrupted zip."
errorSave(workingDirectory, errorReport, workingDirectory)
except Exception as e:
error += 1
errorReport["er_open_zip"] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to he next file"
errorSave(workingDirectory, errorReport, workingDirectory)
try:
os.remove(workingDirectory + randName + ".zip")
except Exception as e:
error += 1
errorReport["er_remove_zip"] = workingDirectory + randName + ".zip"
errorReport["Error: "] = str(e)
errorSave(workingDirectory, errorReport, workingDirectory)
print(".", end='', flush=True)
else:
if ubstore[eachData]["z_n"][withinData] + ".eUB" in scanUBFiles:
try:
with open(scanUBFiles[ubstore[eachData]["z_n"][withinData] + ".eUB"] + "//" + ubstore[eachData]["z_n"][withinData] + ".eUB", 'rb') as eUBFile:
try:
eUBData = eUBFile.read()
eUBFile.close()
except Exception as e:
eUBFile.close()
error += 1
errorReport["er_read_.eUB"] = scanUBFiles[ubstore[eachData]["z_n"][withinData] + ".eUB"] + "//" + ubstore[eachData]["z_n"][withinData] + ".eUB"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to next file"
errorSave(workingDirectory, errorReport, workingDirectory)
except Exception as e:
error += 1
errorReport["er_open_.eUB"] = scanUBFiles[ubstore[eachData]["z_n"][withinData] + ".eUB"] + "//" + ubstore[eachData]["z_n"][withinData] + ".eUB"
errorReport["Error: "] = str(e)
errorReport["Plan of action: "] = "Moving to next file"
errorSave(workingDirectory, errorReport, workingDirectory)
decryptKey = (ubstore[eachData]["k"][withinData]).encode()
decryptKey = fn(decryptKey)
try:
decryptFile = decryptKey.decrypt(eUBData)
except Exception as e:
error += 1
errorReport["er_decrypt_file"] = scanUBFiles[ubstore[eachData]["z_n"][withinData] + ".eUB"] + "//" + ubstore[eachData]["z_n"][withinData] + ".eUB"
errorReport["Error: "] = str(e)
errorReport["Planof action: "] = "Looks that the key is not suitable, or the UBmap file is altered...."
errorSave(workingDirectory, errorReport, backupDirectory)
try:
with open(workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip", 'wb') as zipFile:
try:
zipFile.write(decryptFile)
zipFile.close()
except Exception as e:
zipFile.close()
error += 1
errorReport["er_writing_zip"] = workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip"
errorReport["Error: "] = str(e)
errorReport["Paln of action: "] = "Moving to next files."
errorSave(workingDirectory, errorReport, workingDirectory)
except Exception as e:
error += 1
errorReport["er_create_zip"] = workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip"
errorReport["Error: "] = str(e)
errorReport["Paln of action: "] = "Moving to next files."
errorSave(workingDirectory, errorReport, workingDirectory)
try:
openZip = zf.ZipFile(workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip")
openZip.extractall(restoreDirectory + eachData + "//")
openZip.close()
except Exception as e:
error += 1
errorReport["er_open_zip"] = workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip"
errorReport["Error: "] =str(e)
errorReport["Plan of action: "] = "Not able to open zip due to corruption. Skipping the file."
errorSave(workingDirectory, errorReport, workingDirectory)
try:
os.remove(workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip")
except Exception as e:
error += 1
errorReport["er_remove_zip"] = workingDirectory + ubstore[eachData]["z_n"][withinData] + ".zip"
errorReport["Error: "] = str(e)
errorSave(workingDirectory, errorReport, workingDirectory)
print(".", end='', flush=True)
else:
print("Some files are missing form the backup directory.")
print("Restore of the file: " + ubstore[eachData]["fi_s"][withinData] + " is not possible")
print("Missing file: " + ubstore[eachData]["z_n"][withinData] + ".eUB")
dataDecry = {}
androidInfo = {}
backupfile = {}
pcInfo = {}
errorReport = {}
while on==False:
time.sleep(sleepAuto)
if os.path.isfile("C://ProgramData//Ultra Backup//TurnAutoOff.UBon")==False or os.path.isfile("C://ProgramData//Ultra Backup//backUPThis.bu")==False or os.path.isfile("C://ProgramData//Ultra Backup//backUPThisPC.bu")==False:
backupfile = {}
backupfilePC = {}
if readFile=='new':
readFile = 'old'
with open("C://ProgramData//Ultra Backup//UserAccount.iUB", 'rb') as fileUBi:
data = fileUBi.read()
fileUBi.close()
dataDecry = json.loads(fn("CB9rESpkfeU_IPqgOQlR2MKjVIq3jWg3orr-H4XZRwE=".encode()).decrypt(data))
for each in dataDecry:
if each.find("AndroidAutoConfig")!=-1:
androidInfo[each] = dataDecry[each]
if each.find("PCAutoConfig")!=-1:
pcInfo[each] = dataDecry[each]
for eachConnection in androidInfo:
if androidInfo[eachConnection]['activation']=='y':
if connectFTP(androidInfo[eachConnection]['adress'], androidInfo[eachConnection]['port'], androidInfo[eachConnection]['username'], androidInfo[eachConnection]['password'])==True:
if os.path.isfile(androidInfo[eachConnection]['backupDir'] + "//" + "UB_" + eachConnection[18:] + ".aab")==True:
backupfile[eachConnection] = androidInfo[eachConnection]
if len(backupfile)!=0:
with open("C://ProgramData//Ultra Backup//backUPThis.bu", 'w') as backupthis:
json.dump(backupfile, backupthis)
backupthis.close()
on = True
