def test_find_unencrypted_files__empty_dir(walk, expanduser, Inventory,
GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['restoredir'], saved_params['gpg_homedir'],
saved_params['gpg_binary']
]
register = {
'unenc_1': {
'unencrypted_file': 'unenc_1',
'encrypted_file': 'uuid-1',
'public_id': saved_params['public_id'],
'is_link': 0,
'target': ''
}
}
walk.return_value = []
de = DirEncryption(test_args)
files = de.find_unencrypted_files(register)
eq_(files, {})
def test_encrypt_regular_files(delete_file, encrypt, find_ufiles, Inventory,
GPGOps):
find_ufiles.return_value = {
'test_path_1': {
'is_new': False
},
'test_path_2': {
'is_new': False
},
'test_path_3': {
'is_new': True
}
}
de = DirEncryption(test_args)
de.encrypt_regular_files(Inventory().__enter__().read_register("all"),
Inventory().__enter__())
eq_(encrypt.call_count, 3)
eq_(delete_file.call_count, 2)
eq_(find_ufiles.call_count, 1)
eq_(encrypt.call_args_list[0][0][0], 'test_path_1')
eq_(encrypt.call_args_list[1][0][0], 'test_path_2')
eq_(encrypt.call_args_list[2][0][0], 'test_path_3')
def test_do_inv_maintenance(clean, Inventory, GPGOps):
de = DirEncryption(test_args)
de.do_inv_maintenance(Inventory().__enter__())
eq_(clean.call_count, 1)
eq_(Inventory().__enter__().update_last_timestamp.call_count, 1)
def test_find_unencrypted_files(stat, walk, expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
register = {
'unenc_1': {
'unencrypted_file': 'unenc_1',
'encrypted_file': 'uuid-1',
'public_id': saved_params['public_id']
}
}
walk.return_value = [
(saved_params['plaindir'], ['subdir_1'], ['unenc_1', 'unenc_2']),
(os.path.join(saved_params['plaindir'], 'subdir_1'), [], ['unenc_3'])
]
stat.return_value.st_mtime = 1400
de = DirEncryption(test_args)
files = de.find_unencrypted_files(register)
eq_(len(files), 2)
ok_('unenc_2' in files.keys())
ok_(os.path.join('subdir_1', 'unenc_3') in files.keys())
def test_encrypt_all(delete_file, encrypt, find, expanduser, Inventory,
GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
find.return_value = {
'test_path_1': {
'modified_time': 1234,
'is_new': False
},
'test_path_2': {
'modified_time': 1337,
'is_new': False
},
'test_path_3': {
'modified_time': 1414,
'is_new': True
}
}
de = DirEncryption(test_args)
de.encrypt_all()
eq_(encrypt.call_count, 3)
eq_(encrypt.call_args_list[0][0][0], 'test_path_1')
eq_(encrypt.call_args_list[1][0][0], 'test_path_2')
eq_(encrypt.call_args_list[2][0][0], 'test_path_3')
eq_(Inventory().__enter__().update_last_timestamp.call_count, 1)
eq_(delete_file.call_count, 2)
def test_decrypt_all(decrypt, expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
Inventory().__enter__().read_register.return_value = {
'unenc_file_1': {
'unencrypted_file': 'unenc_1',
'encrypted_file': 'uuid-1',
'public_id': saved_params['public_id']
},
'unenc_file_2': {
'unencrypted_file': 'unenc_2',
'encrypted_file': 'uuid-2',
'public_id': saved_params['public_id']
},
'unenc_file_3': {
'unencrypted_file': 'unenc_3',
'encrypted_file': 'uuid-3',
'public_id': 'some_other_id'
}
}
de = DirEncryption(test_args)
de.decrypt_all('trustno1')
eq_(de.decrypt.call_count, 2)
eq_(de.decrypt.call_args_list[0][0], ('uuid-1', 'unenc_1', 'trustno1'))
eq_(de.decrypt.call_args_list[1][0], ('uuid-2', 'unenc_2', 'trustno1'))
def test_clean_links(listdir, islink, expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['restoredir'], saved_params['gpg_homedir'],
saved_params['gpg_binary']
]
inv = MagicMock()
inv.read_register.return_value = {
'unenc_3': {
'unencrypted_file': 'unenc_3',
'encrypted_file': '',
'public_id': '',
'is_link': 1,
'target': 'link_3'
},
'unenc_4': {
'unencrypted_file': 'unenc_4',
'encrypted_file': '',
'public_id': '',
'is_link': 1,
'target': 'link_4'
}
}
islink.return_value = False
de = DirEncryption(test_args)
de.clean(inv)
eq_(inv.clean_record.call_count, 6)
def test_encrypt_all(maintenance, register_links, register_dirs,
encrypt_files):
de = DirEncryption(test_args)
de.encrypt_all()
eq_(maintenance.call_count, 1)
eq_(register_links.call_count, 1)
eq_(register_dirs.call_count, 1)
eq_(encrypt_files.call_count, 1)
def loop_through(self, clean=False, resync=False):
"""Go through all entries and take action based on user input.
This method can be called after check() has been executed,
otherwise it cannot properly report on the existence of
files.
"""
count_nok = 0
total_files = len(self.registered_files)
print('Plaindir: {}'.format(self.parameters['plaindir']))
print('Securedir: {}'.format(self.parameters['securedir']))
print('\nSTATUS PLAINFILE{}ENCFILE'.format(' '*27))
for filename, entry in self.registered_files.items():
unenc_exists = 'u'
enc_exists = 'e'
status = 'ok'
if not entry['unencrypted_file_check']:
unenc_exists = ''
if not entry['encrypted_file_check']:
enc_exists = ''
if clean and (not unenc_exists or not enc_exists):
if unenc_exists:
print("delete unenc")
FileOps.delete_file(self.parameters['plaindir'],
entry['unencrypted_file'])
if enc_exists:
print("delete enc")
FileOps.delete_file(self.parameters['securedir'],
entry['encrypted_file'])
self.clean_registry(entry['unencrypted_file'])
total_files -= 1
elif not unenc_exists and resync:
de = DirEncryption(None, self.database)
de.decrypt(entry['encrypted_file'],
entry['unencrypted_file'],
self.passphrase)
unenc_exists = 'u'
elif not unenc_exists or not enc_exists:
status = 'NOK'
count_nok += 1
print('%-3s %1s%1s %-35s %-30s' % (status, unenc_exists, enc_exists,
self.registered_files[filename]['unencrypted_file'],
self.registered_files[filename]['encrypted_file']))
print('\nTotal files in the register: {}'.format(total_files))
print('Check: {} ok, {} not ok'.format(total_files - count_nok, count_nok))
def test_encrypt_all__no_files(encrypt, find, expanduser, Inventory, GPGOps):
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
de = DirEncryption(test_args)
de.encrypt_all()
eq_(encrypt.call_count, 0)
eq_(Inventory().__enter__().update_last_timestamp.call_count, 1)
def test_encrypt(expanduser, GPGOps):
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
inventory = MagicMock()
de = DirEncryption(test_args)
de.encrypt('plainfile', 'securefile', inventory)
eq_(inventory.register.call_count, 1)
de.gpg.encrypt.assert_called_once_with(
os.path.join(saved_params['plaindir'], 'plainfile'),
os.path.join(saved_params['securedir'], 'securefile'))
def test_decrypt_all__no_files(decrypt, expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
Inventory().__enter__().read_register.return_value = {}
de = DirEncryption(test_args)
de.decrypt_all('trustno1')
eq_(de.decrypt.call_count, 0)
def test_decrypt(expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['gpg_homedir'], saved_params['gpg_binary']
]
de = DirEncryption(test_args)
de.decrypt('test_enc_file', 'test_plain_file', 'trustno1')
de.gpg.decrypt.assert_called_once_with(
os.path.join(saved_params['securedir'], 'test_enc_file'),
os.path.join(saved_params['plaindir'], 'test_plain_file'), 'trustno1')
def test_set_parameters__from_args(expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
args = MagicMock()
args.verbose = True
args.plaindir = 'runtime_plaindir'
args.securedir = 'runtime_securedir'
args.restoredir = 'runtime_restoredir'
args.public_id = 'runtime_public_id'
args.gpg_keyring = 'runtime_gpg_keyring'
args.gpg_homedir = 'runtime_gpg_homedir'
args.gpg_binary = 'runtime_gpg_binary'
expanduser.side_effect = [
args.plaindir, args.securedir, args.restoredir, args.gpg_homedir,
args.gpg_binary, args.plaindir, args.securedir, args.restoredir,
args.gpg_homedir, args.gpg_binary
]
de = DirEncryption(args)
eq_(de.verbose, True)
eq_(de.last_timestamp, saved_params['last_timestamp'])
eq_(de.plaindir, args.plaindir)
eq_(de.securedir, args.securedir)
eq_(de.restoredir, args.restoredir)
eq_(de.public_id, args.public_id)
eq_(de.gpg_keyring, args.gpg_keyring)
eq_(de.gpg_binary, args.gpg_binary)
def test_find_unregistered_links(readlink, islink, stat, walk, expanduser,
Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['restoredir'], saved_params['gpg_homedir'],
saved_params['gpg_binary']
]
register = {
'unenc_1': {
'unencrypted_file': 'unenc_1',
'encrypted_file': '',
'public_id': '',
'is_link': 1,
'target': 'target_1'
}
}
walk.return_value = [(saved_params['plaindir'], ['subdir_1'],
['unenc_1', 'unenc_2', 'unenc_3']),
(os.path.join(saved_params['plaindir'],
'subdir_1'), [], ['unenc_4'])]
stat.return_value.st_mtime = 1234567895
islink.return_value = True
readlink.return_value = 'my_target'
de = DirEncryption(test_args)
links = de.find_unregistered_links(register)
eq_(len(links), 6)
ok_('unenc_3' in links.keys())
ok_(os.path.join('subdir_1', 'unenc_4') in links.keys())
stat.reset_mock()
stat.return_value.st_mtime = 1234567885
links = de.find_unregistered_links(register)
eq_(len(links), 5)
islink.reset_mock()
islink.return_value = False
links = de.find_unregistered_links(register)
eq_(len(links), 0)
def test_register_symlinks(register, find_ulinks, Inventory, GPGOps):
find_ulinks.return_value = {
'test_link_1': {
'target': 'target_1',
'is_new': False
},
'test_link_2': {
'target': 'target_2',
'is_new': True
}
}
de = DirEncryption(test_args)
de.register_symlinks(Inventory().__enter__().read_register("links"),
Inventory().__enter__())
eq_(register.call_count, 2)
eq_(find_ulinks.call_count, 1)
eq_(Inventory().__enter__().clean_record.call_count, 1)
def test_register_empty_dirs(find_udirs, register, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
find_udirs.return_value = {
'test_dir_1': {
'is_new': False
},
'test_dir_2': {
'is_new': True
}
}
de = DirEncryption(test_args)
de.register_empty_dirs(Inventory().__enter__().read_register("dirs"),
Inventory().__enter__())
eq_(register.call_count, 2)
eq_(find_udirs.call_count, 1)
eq_(Inventory().__enter__().clean_record.call_count, 1)
def test_find_unregistered_empty_dirs(stat, walk, expanduser, Inventory,
GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['restoredir'], saved_params['gpg_homedir'],
saved_params['gpg_binary']
]
register = {
'subdir_1': {
'unencrypted_file': 'subdir_1',
'encrypted_file': '',
'public_id': '',
'is_link': 0,
'target': ''
}
}
walk.return_value = [(saved_params['plaindir'], ['subdir_1'],
['unenc_1', 'unenc_2', 'unenc_3']),
(os.path.join(saved_params['plaindir'],
'subdir_1'), [], [])]
stat.return_value.st_mtime = 1234567895
de = DirEncryption(test_args)
dirs = de.find_unregistered_empty_dirs(register)
eq_(len(dirs), 1)
ok_('subdir_1' in dirs.keys())
stat.reset_mock()
stat.return_value.st_mtime = 1234567885
dirs = de.find_unregistered_empty_dirs(register)
eq_(len(dirs), 0)
def test_set_parameters__from_param(expanduser, Inventory, GPGOps):
Inventory().__enter__().read_parameters.return_value = saved_params
expanduser.side_effect = [
saved_params['plaindir'], saved_params['securedir'],
saved_params['public_id'], saved_params['gpg_keyring'],
saved_params['gpg_binary']
]
de = DirEncryption(test_args)
eq_(de.verbose, False)
eq_(de.last_timestamp, saved_params['last_timestamp'])
eq_(de.plaindir, saved_params['plaindir'])
eq_(de.securedir, saved_params['securedir'])
eq_(de.public_id, saved_params['public_id'])
eq_(de.gpg_keyring, saved_params['gpg_keyring'])
eq_(de.gpg_binary, saved_params['gpg_binary'])
help='Print verbose messages during execution')
parser.add_argument('-p', '--plaindir', help='Unencrypted directory')
parser.add_argument('-s', '--securedir', help='Encrypted directory')
parser.add_argument('-i', '--public-id', help='GPG public id')
parser.add_argument('-P', '--passphrase',
help='Passphrase to decrypt files.')
parser.add_argument('-H', '--gpg-homedir', help='GPG home directory')
parser.add_argument('-k', '--gpg-keyring', help='GPG keyring file')
parser.add_argument('-b', '--gpg-binary', help='GPG binary file')
args = parser.parse_args()
if args.configure:
header()
c = RunConfig(database=database)
elif args.encrypt:
e = DirEncryption(args, database=database)
e.encrypt_all()
elif args.decrypt:
if args.passphrase:
passphrase = args.passphrase
else:
passphrase = getpass.getpass('Passphrase: ')
e = DirEncryption(args, database=database)
e.decrypt_all(passphrase)
else:
header()
print('Please specify encrypt (-e) or decrypt (-d) operation,')
print('or --configure to set up configuration.')