def setUpClass(cls):
cls.params = KeeperParams()
read_config_file(cls.params)
cls.params.user = cls.params.config['enterprise']['user']
cls.params.password = cls.params.config['enterprise']['password']
api.login(cls.params)
TestEnterpriseCommands.wipe_out_data()
def test_login_auth_expired(self):
params = get_user_params()
call_no = 0
def return_auth_expired(context, rq):
nonlocal call_no
call_no += 1
rs = TestLogin.process_login_command(context, rq)
if call_no == 1:
rs['result'] = 'fail'
rs['result_code'] = 'auth_expired'
rs['message'] = 'Auth expired'
elif call_no == 2:
pass
else:
raise Exception()
return rs
self.v2_execute_mock.side_effect = return_auth_expired
with mock.patch(
'keepercommander.api.change_master_password') as m_passwd:
def password_changed(params):
params.password = vault_env.password
return True
m_passwd.side_effect = password_changed
with self.assertLogs():
login(params)
m_passwd.assert_called()
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def _import(params, format, filename):
api.login(params)
if format == 'json':
def read_json():
with open(filename, mode="rt", encoding="utf8") as f:
return json.load(f)
records_to_add = [api.prepare_record(params, parse_record_json(json)) for json in read_json()]
else:
def read_lines():
with open(filename, mode="rt", encoding="utf8") as f:
return f.readlines()
records_to_add = [api.prepare_record(params, parse_line(line)) for line in read_lines()]
if (len(records_to_add) == 0):
print('No records to import')
return
request = api.make_request(params, 'record_update')
print('importing {0} records to Keeper'.format(len(records_to_add)))
request['add_records'] = records_to_add
response_json = api.communicate(params, request)
success = [info for info in response_json['add_records'] if info['status'] == 'success']
if len(success) > 0:
print("{0} records imported successfully".format(len(success)))
failures = [info for info in response_json['add_records'] if info['status'] != 'success']
if len(failures) > 0:
print("{0} records failed to import".format(len(failures)))
def _import(params, format, filename):
api.login(params)
if format == 'json':
def read_json():
with open(filename, 'rt') as f:
return json.load(f)
records_to_add = [api.prepare_record(params, parse_json(json)) for json in read_json()]
else:
def read_lines():
with open(filename, 'rt') as f:
return f.readlines()
records_to_add = [api.prepare_record(params, parse_line(line)) for line in read_lines()]
if (len(records_to_add) == 0):
print('No records to import')
return
request = api.make_request(params, 'record_update')
print('importing {0} records to Keeper'.format(len(records_to_add)))
request['add_records'] = records_to_add
response_json = api.communicate(params, request)
success = [info for info in response_json['add_records'] if info['status'] == 'success']
if len(success) > 0:
print("{0} records imported successfully".format(len(success)))
failures = [info for info in response_json['add_records'] if info['status'] != 'success']
if len(failures) > 0:
print("{0} records failed to import".format(len(failures)))
def login_to_keeper_with_config(filename): # type: (str) -> KeeperParams
# Load connection parameters from file
my_params = get_params_from_config(filename)
my_params.password = '' # Keeper account password. Can be omitted if account is setup for session resumption
# Login to Keeper
api.login(my_params)
api.sync_down(my_params)
return my_params
def test_login_success_2fa_device_token(self):
TestLogin.has2fa = True
params = get_user_params()
params.mfa_token = vault_env.device_token
params.mfa_type = 'device_token'
login(params)
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def test_ignore_invite(self):
TestLogin.enterpriseInvite = True
params = get_user_params()
self.input_mock.side_effect = ['ignore', self.ctrl_c]
login(params)
self.assertEqual(self.input_mock.call_count, 1)
self.assertEqual(self.print_mock.call_count, 1)
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def test_login_success_2fa_one_time(self):
TestLogin.has2fa = True
self.getpass_mock.side_effect = [vault_env.one_time_token, self.ctrl_c]
self.store_config_mock.side_effect = None
params = get_user_params()
login(params)
self.store_config_mock.assert_called_once_with(params.config_filename,
'w')
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def test_accept_invite(self):
TestLogin.enterpriseInvite = True
params = get_user_params()
self.input_mock.side_effect = [
'accept', TestLogin.enterpriseInviteCode, self.ctrl_c
]
self.comm_mock.side_effect = TestLogin.process_invite
login(params)
self.assertEqual(self.comm_mock.call_count, 1)
self.assertEqual(self.input_mock.call_count, 2)
self.assertEqual(self.print_mock.call_count, 1)
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def login(email,
password=None,
keeper_server='https://keepersecurity.com/api/v2/',
config_file='myconfig.json'):
if os.path.exists(config_file):
params = get_params_from_config(config_file)
else:
params = KeeperParams()
params.config_filename = config_file
params.user = email
params.password = password if password else ''
params.server = keeper_server
params.config['server'] = params.server
api.login(params)
api.sync_down(params)
return params
def setUpClass(cls):
cls.params1 = KeeperParams()
config_filename = os.path.join(os.path.dirname(__file__),
'cross-enterprise.json')
with open(config_filename, 'r') as f:
config = json.load(f)
cls.params1.server = config['server']
device_id = base64.urlsafe_b64decode(config['device_id'] + '==')
cls.params1.rest_context.device_id = device_id
cls.params1.user = config['user']
cls.params1.password = config['password']
cls.params1.config = config
api.login(cls.params1)
cls.params2 = KeeperParams()
cls.params2.server = cls.params1.server
cls.params2.rest_context.device_id = cls.params1.rest_context.device_id
cls.params2.user = config['enterprise2']['user']
cls.params2.password = config['enterprise2']['password']
api.login(cls.params2)
def test_account_transfer_expired(self):
params = get_user_params()
call_no = 0
def return_auth_expired(context, rq):
nonlocal call_no
call_no += 1
rs = TestLogin.process_login_command(context, rq)
if call_no == 1:
rs['result'] = 'fail'
rs['result_code'] = 'auth_expired_transfer'
rs['message'] = 'Auth Transfer expired'
rs['settings'] = {
'share_account_to': [{
'role_id':
123456789,
'public_key':
vault_env.encoded_public_key
}]
}
elif call_no == 2:
pass
else:
raise Exception()
return rs
self.v2_execute_mock.side_effect = return_auth_expired
with mock.patch('keepercommander.api.accept_account_transfer_consent'
) as m_transfer:
m_transfer.return_value = True
with self.assertLogs():
login(params)
m_transfer.assert_called()
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def setUpClass(cls):
cls.params1 = KeeperParams()
config_filename = os.path.join(os.path.dirname(__file__),
'cross-enterprise.json')
with open(config_filename, 'r') as f:
config = json.load(f)
cls.params1.server = config['server']
cls.params1.user = config['user']
cls.params1.password = config['password']
cls.params1.device_private_key = config['private_key']
cls.params1.device_token = config['device_token']
cls.params1.clone_code = config['clone_code']
cls.params1.config = config
api.login(cls.params1)
cls.params2 = KeeperParams()
cls.params2.server = cls.params1.server
cls.params2.device_private_key = cls.params1.device_private_key
cls.params2.device_token = cls.params1.device_token
cls.params2.clone_code = cls.params1.clone_code
cls.params2.user = config['enterprise2']['user']
cls.params2.password = config['enterprise2']['password']
api.login(cls.params2)
user = os.environ['user']
except KeyError:
user = input("User:"******"Exitting because of over repeat limit {repeat}")
break
rec = api.get_record(params, uid)
if rec.login_url == sn_url:
rec.login_url = '' # set string empty
api.update_record(params, rec)
logger.info(f"sn_url is erased at {uid} : {rec.title}")
# Configure logging
slh = ScriptLogHandler()
slh.setLevel(logging.WARNING)
logging.root.addHandler(slh)
# Create parameters
my_params = KeeperParams()
my_params.user = '' # Keeper account name. 'config.json' file, 'user' property
my_params.password = '' # Keeper account password.
my_params.device_token = '' # Device Token. 'config.json' file, 'device_token' property
my_params.device_private_key = '' # Device Key. 'config.json' file, 'private_key' property
# Login to Keeper
api.login(my_params)
# Load the Enterprise configuration state
api.query_enterprise(my_params)
# Create team/user mapping
if 'users' in my_params.enterprise and 'team_users' in my_params.enterprise:
# params.enterprise['users'] is a list of all users in enterprise
# params.enterprise['team_users'] is a list of team <-> user pairs
# map user ID to active user email.
user_lookup = {
u['enterprise_user_id']: u['username']
for u in my_params.enterprise['users'] if u['status'] == 'active'
}
def setUpClass(cls):
cls.params = KeeperParams()
read_config_file(cls.params, 'enterprise.json')
api.login(cls.params)
TestEnterpriseCommands.wipe_out_data()
def setUpClass(cls):
cls.params = KeeperParams()
read_config_file(cls.params)
api.login(cls.params)
TestConnectedCommands.wipe_out_data()
def test_login_success(self):
params = get_user_params()
login(params)
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def test_login_invalid_user(self):
params = get_user_params()
params.user = '******'
with self.assertRaises(AuthenticationError):
login(params)
def test_login_failed(self):
params = get_user_params()
params.password = '******'
with self.assertRaises(AuthenticationError):
login(params)
def test_login_success_2fa_cancel(self):
TestLogin.has2fa = True
params = get_user_params()
login(params)
self.assertFalse(params.session_token)
def test_refresh_session_token(self):
params = get_connected_params()
login(params)
self.assertEqual(params.session_token, vault_env.session_token)
self.assertEqual(params.data_key, vault_env.data_key)
def test_login_success_params(self):
TestLogin.dataKeyAsEncParam = True
params = get_user_params()
login(params)
self.assertEqual(params.data_key, vault_env.data_key)
self.assertEqual(params.session_token, vault_env.session_token)
