def initialize(self):
super(logging_UserCrash, self).initialize()
# If the device has a GUI, return the device to the sign-in screen, as
# some tests will fail inside a user session.
if upstart.has_service('ui'):
cros_ui.restart()
def run_once(self):
expected_owner = '*****@*****.**'
other_user = '******'
self.__start_session_for(expected_owner)
self.__start_session_for(other_user)
self._listener.wait_for_signals(desc='Initial policy push complete.')
# Ensure that the first user got to be the owner.
retrieved_policy = policy.get_policy(self._session_manager)
if retrieved_policy is None: raise error.TestFail('Policy not found')
policy.compare_policy_response(self.srcdir,
retrieved_policy,
owner=expected_owner)
# bounce the session manager and wait for it to come back up before
# reconnecting.
cros_ui.restart()
self._session_manager = session_manager.connect(self._bus_loop)
# Destroy the owner's cryptohome and start sessions again in a
# different order
self.__start_session_for(other_user)
self.__start_session_for(expected_owner)
self._listener.wait_for_signals(
desc='Re-taking of ownership complete.')
# Ensure that the first user still gets to be the owner.
retrieved_policy = policy.get_policy(self._session_manager)
if retrieved_policy is None: raise error.TestFail('Policy not found')
policy.compare_policy_response(self.srcdir,
retrieved_policy,
owner=expected_owner)
def initialize(self):
user_crash_test.UserCrashTest.initialize(self)
# If the device has a GUI, return the device to the sign-in screen, as
# some tests will fail inside a user session.
if upstart.has_service('ui'):
cros_ui.restart()
def run_once(self):
# Mount the vault, connect to session_manager and start the session.
self._cryptohome_proxy.mount(ownership.TESTUSER,
ownership.TESTPASS,
create=True)
sm = session_manager.connect(self._bus_loop)
sm.StartSession(ownership.TESTUSER, '')
# No policy stored yet.
retrieved_policy = sm.RetrievePolicyEx(
session_manager.make_user_policy_descriptor(ownership.TESTUSER),
byte_arrays=True)
if retrieved_policy:
raise error.TestError('session_manager already has user policy!')
# And no user key exists.
key_file = ownership.get_user_policy_key_filename(ownership.TESTUSER)
if os.path.exists(key_file):
raise error.TestFail('%s exists before storing user policy!' %
key_file)
# Now store a policy. This is building a device policy protobuf, but
# that's fine as far as the session_manager is concerned; it's the
# outer PolicyFetchResponse that contains the public_key.
public_key = ownership.known_pubkey()
private_key = ownership.known_privkey()
policy_data = policy.build_policy_data()
policy_response = policy.generate_policy(private_key, public_key,
policy_data)
try:
sm.StorePolicyEx(
session_manager.make_user_policy_descriptor(
ownership.TESTUSER), dbus.ByteArray(policy_response))
except dbus.exceptions.DBusException as e:
raise error.TestFail('Failed to store user policy', e)
# The policy key should have been created now.
self._verify_key_file(key_file)
# Restart the ui; the key should be deleted.
self._cryptohome_proxy.unmount(ownership.TESTUSER)
cros_ui.restart()
if os.path.exists(key_file):
raise error.TestFail('%s exists after restarting ui!' % key_file)
# Starting a new session will restore the key that was previously
# stored. Reconnect to the session_manager, since the restart killed it.
self._cryptohome_proxy.mount(ownership.TESTUSER,
ownership.TESTPASS,
create=True)
sm = session_manager.connect(self._bus_loop)
sm.StartSession(ownership.TESTUSER, '')
self._verify_key_file(key_file)
class platform_SessionManagerBlockDevmodeSetting(test.test):
"""Verifies that session_manager updates the block_devmode flag to be in
sync with the corresponding device setting."""
version = 1
def initialize(self):
super(platform_SessionManagerBlockDevmodeSetting, self).initialize()
ownership.restart_ui_to_clear_ownership_files()
self._bus_loop = DBusGMainLoop(set_as_default=True)
def run_once(self):
try:
if utils.system_output('crossystem mainfw_type') == 'nonchrome':
raise error.TestNAError(
'State key generation only works on Chrome OS hardware')
except error.CmdError, e:
raise error.TestError('Failed to run crossystem: %s' % e)
# Make sure that the flag sticks when there is no owner.
set_block_devmode(True)
cros_ui.restart()
cros_ui.stop()
if not get_block_devmode():
raise error.TestFail("Flag got reset for non-owned device.")
# Test whether the flag gets reset when taking ownership.
listener = session_manager.OwnershipSignalListener(gobject.MainLoop())
listener.listen_for_new_key_and_policy()
with chrome.Chrome() as cr:
listener.wait_for_signals(desc='Ownership files written to disk.')
if get_block_devmode():
raise error.TestFail(
"Flag not clear after ownership got established.")
# Put a new owner key and policy blob in place, the latter of which
# specifies block_devmode=true.
cros_ui.stop(allow_fail=True)
shutil.copyfile(os.path.join(self.bindir, 'owner.key'),
constants.OWNER_KEY_FILE)
shutil.copyfile(
os.path.join(self.bindir, 'policy_block_devmode_enabled'),
constants.SIGNED_POLICY_FILE)
cros_ui.start()
if not get_block_devmode():
raise error.TestFail(
"Flag not set after starting with policy enabled.")
# Send a new policy blob to session_manager that disables block_devmode.
listener.listen_for_new_policy()
with open(os.path.join(self.bindir,
'policy_block_devmode_disabled')) as f:
session_manager_proxy = session_manager.connect(self._bus_loop)
session_manager_proxy.StorePolicyEx(
session_manager.make_device_policy_descriptor(), f.read())
listener.wait_for_signals(desc='Policy updated.')
if get_block_devmode():
raise error.TestFail(
"Flag set after updating policy to clear flag.")
def cleanup(self):
if self._tempdir: self._tempdir.clean()
cros_ui.restart()
self._cryptohome_proxy.remove(ownership.TESTUSER)
super(login_OwnershipRetaken, self).cleanup()
def initialize(self):
super(login_RetrieveActiveSessions, self).initialize()
cros_ui.restart()
def initialize(self):
super(login_SameSessionTwice, self).initialize()
cros_ui.restart()
def cleanup(self):
cros_ui.restart()
self._cryptohome_proxy.remove(ownership.TESTUSER)
super(login_UserPolicyKeys, self).cleanup()
