async def validate_otp(self, request, context):
try:
success_status = self.service.verify_otp(request.user_id,
request.pre_access_token,
request.otp_code)
if not success_status:
raise Exception(Message.AUTH_USER_NOT_FOUND)
user_info = self.user_service.get_user_by_id(request.user_id)
introspect_token = KeyCloakUtils.introspect_token(
token['access_token'])
require_action = ""
client_key_obj = SignalService().peer_get_client_key(
request.user_id)
client_key_peer = auth_messages.PeerGetClientKeyResponse(
clientId=request.user_id,
workspace_domain=get_owner_workspace_domain(),
registrationId=client_key_obj.registration_id,
deviceId=client_key_obj.device_id,
identityKeyPublic=client_key_obj.identity_key_public,
preKeyId=client_key_obj.prekey_id,
preKey=client_key_obj.prekey,
signedPreKeyId=client_key_obj.signed_prekey_id,
signedPreKey=client_key_obj.signed_prekey,
signedPreKeySignature=client_key_obj.signed_prekey_signature,
identityKeyEncrypted=client_key_obj.identity_key_encrypted)
token = self.service.token(user_info.email,
user_info.password_verifier)
self.user_service.update_last_login(user_id=request.user_id)
return auth_messages.AuthRes(
workspace_domain=get_owner_workspace_domain(),
workspace_name=get_system_config()['server_name'],
access_token=token["access_token"],
expires_in=token['expires_in'],
refresh_expires_in=token['refresh_expires_in'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
session_state=token['session_state'],
scope=token['scope'],
require_action=require_action,
salt=user_info.salt,
client_key_peer=client_key_peer,
iv_parameter=user_info.iv_parameter)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(Message.GET_MFA_STATE_FALED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
async def register_srp(self, request, context):
# check exist user
try:
email = request.email
display_name = request.display_name
password_verifier = request.password_verifier
salt = request.salt
iv_parameter = request.iv_parameter
exists_user = self.service.get_user_by_email(email)
if exists_user:
raise Exception(Message.REGISTER_USER_ALREADY_EXISTS)
# register new user
new_user_id = self.service.register_srp_user(
email, password_verifier, display_name)
if new_user_id:
# create new user in database
UserService().create_new_user_srp(new_user_id, email,
password_verifier, salt,
iv_parameter, display_name,
'account')
else:
self.service.delete_user(new_user_id)
raise Exception(Message.REGISTER_USER_FAILED)
try:
SignalService().peer_register_client_key(
new_user_id, request.client_key_peer)
except Exception:
self.service.delete_user(new_user_id)
UserService().delete_user(new_user_id)
raise Exception(Message.REGISTER_USER_FAILED)
return auth_messages.RegisterSRPRes()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(Message.REGISTER_USER_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
async def change_password(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(
header_data['access_token'])
user_name = introspect_token['preferred_username']
client_session_key_proof = request.client_session_key_proof
user_info = self.service.get_user_by_auth_source(
user_name, "account")
if not user_info:
raise Exception(Message.AUTH_USER_NOT_FOUND)
password_verifier = bytes.fromhex(user_info.password_verifier)
salt = bytes.fromhex(user_info.salt)
client_session_key_proof_bytes = bytes.fromhex(
client_session_key_proof)
srv = srp.Verifier(username=user_name,
bytes_s=salt,
bytes_v=password_verifier,
bytes_A=bytes.fromhex(request.client_public),
bytes_b=bytes.fromhex(
user_info.srp_server_private))
srv.verify_session(client_session_key_proof_bytes)
authenticated = srv.authenticated()
if not authenticated:
raise Exception(Message.AUTHENTICATION_FAILED)
self.service.change_password(
request, user_info.password_verifier, request.hash_password,
introspect_token['sub']) # update for keycloak
try:
old_identity_key_encrypted = SignalService(
).client_update_identity_key(introspect_token["sub"],
request.identity_key_encrypted)
except Exception as e:
logger.error(e)
self.service.change_password(request, request.hash_password,
user_info.password_verifier,
introspect_token['sub'])
raise Exception(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
try:
salt, iv_parameter = self.service.update_hash_pass(
introspect_token["sub"], request.hash_password,
request.salt, request.iv_parameter)
except Exception as e:
logger.error(e)
self.service.change_password(request, request.hash_password,
request.password_verifier,
introspect_token['sub'])
SignalService().client_update_identity_key(
introspect_token["sub"], old_identity_key_encrypted)
raise Exception(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
user_sessions = KeyCloakUtils.get_sessions(
user_id=introspect_token["sub"])
for user_session in user_sessions:
if user_session['id'] != introspect_token['session_state']:
KeyCloakUtils.remove_session(session_id=user_session['id'])
return user_messages.BaseResponse()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(Message.CHANGE_PASSWORD_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
def __init__(self, *kwargs):
self.service = SignalService()
class SignalController(BaseController):
def __init__(self, *kwargs):
self.service = SignalService()
@request_logged
@auth_required
async def PeerRegisterClientKey(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(header_data['access_token'])
user_id = introspect_token['sub']
self.service.peer_register_client_key(user_id, request)
return signal_pb2.BaseResponse()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
@auth_required
async def ClientUpdatePeerKey(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(header_data['access_token'])
user_id = introspect_token['sub']
if user_id == request.client_id:
self.service.client_update_peer_key(user_id, request)
return signal_pb2.BaseResponse()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
async def WorkspacePeerGetClientKey(self, request, context):
try:
client_id = request.clientId
client_workspace_domain = request.workspace_domain
owner_workspace_domain = get_owner_workspace_domain()
if client_workspace_domain and client_workspace_domain == owner_workspace_domain:
obj_resp = self.service.peer_get_client_key(client_id)
if obj_resp is not None:
response = signal_pb2.PeerGetClientKeyResponse(
clientId=client_id,
registrationId=obj_resp.registration_id,
deviceId=obj_resp.device_id,
identityKeyPublic=obj_resp.identity_key_public,
preKeyId=obj_resp.prekey_id,
preKey=obj_resp.prekey,
signedPreKeyId=obj_resp.signed_prekey_id,
signedPreKey=obj_resp.signed_prekey,
signedPreKeySignature=obj_resp.signed_prekey_signature
)
return response
raise Exception(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
@auth_required
async def PeerGetClientKey(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(header_data.get('access_token', ''))
user_id = introspect_token.get('sub', None)
client_id = request.clientId
client_workspace_domain = request.workspace_domain
owner_workspace_domain = get_owner_workspace_domain()
if client_workspace_domain and client_workspace_domain != owner_workspace_domain:
# get key from other server
obj_resp = ClientSignal(client_workspace_domain).workspace_get_user_signal_key(client_id, client_workspace_domain)
return obj_resp
else:
obj_resp = self.service.peer_get_client_key(client_id)
if obj_resp is not None:
response = signal_pb2.PeerGetClientKeyResponse(
clientId=client_id,
registrationId=obj_resp.registration_id,
deviceId=obj_resp.device_id,
identityKeyPublic=obj_resp.identity_key_public,
preKeyId=obj_resp.prekey_id,
preKey=obj_resp.prekey,
signedPreKeyId=obj_resp.signed_prekey_id,
signedPreKey=obj_resp.signed_prekey,
signedPreKeySignature=obj_resp.signed_prekey_signature
)
if user_id == client_id:
response.identityKeyEncrypted = obj_resp.identity_key_encrypted
return response
raise Exception(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
@auth_required
async def GroupRegisterClientKey(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(header_data['access_token'])
user_id = introspect_token['sub']
self.service.group_register_client_key(user_id, request)
return signal_pb2.BaseResponse()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.REGISTER_CLIENT_GROUP_KEY_FAILED)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
@auth_required
async def GroupUpdateClientKey(self, request, context):
try:
header_data = dict(context.invocation_metadata())
introspect_token = KeyCloakUtils.introspect_token(header_data['access_token'])
user_id = introspect_token['sub']
self.service.group_bulk_update_client_key(user_id, request.listGroupClientKey)
return signal_pb2.BaseResponse()
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [Message.get_error_object(Message.REGISTER_CLIENT_GROUP_KEY_FAILED)]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
@request_logged
async def GroupGetClientKey(self, request, context):
try:
group_id = request.groupId
client_id = request.clientId
# get group first
group = GroupService().get_group_obj(group_id)
owner_workspace_domain = get_owner_workspace_domain()
if group.owner_workspace_domain and group.owner_workspace_domain != owner_workspace_domain:
owner_workspace_group_id = group.owner_group_id
obj_resp = self.service.group_by_owner_get_client_key(owner_workspace_group_id, client_id)
if obj_resp is not None:
response = signal_pb2.GroupGetClientKeyResponse(
groupId=obj_resp.group_id,
clientKey=signal_pb2.GroupClientKeyObject(
clientId=obj_resp.client_id,
deviceId=obj_resp.device_id,
clientKeyDistribution=obj_resp.client_key
)
)
return response
else:
obj_resp = ClientSignal(group.owner_workspace_domain).group_get_client_key(group.owner_group_id, client_id)
return obj_resp
else:
obj_resp = self.service.group_get_client_key(group_id, client_id)
if obj_resp is not None:
if obj_resp.client_workspace_domain and obj_resp.client_workspace_domain != owner_workspace_domain:
obj_resp = ClientSignal(obj_resp.client_workspace_domain).workspace_group_get_client_key(obj_resp.client_workspace_group_id, obj_resp.client_id)
return obj_resp
else:
response = signal_pb2.GroupGetClientKeyResponse(
groupId=obj_resp.group_id,
clientKey=signal_pb2.GroupClientKeyObject(
clientId=obj_resp.client_id,
deviceId=obj_resp.device_id,
clientKeyDistribution=obj_resp.client_key
)
)
return response
raise Exception(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)
except Exception as e:
errors = [Message.get_error_object(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.NOT_FOUND)
@request_logged
async def WorkspaceGroupGetClientKey(self, request, context):
try:
group_id = request.groupId
client_id = request.clientId
obj_resp = self.service.group_get_client_key(group_id, client_id)
if obj_resp is not None:
response = signal_pb2.GroupGetClientKeyResponse(
groupId=obj_resp.group_id,
clientKey=signal_pb2.GroupClientKeyObject(
clientId=obj_resp.client_id,
deviceId=obj_resp.device_id,
clientKeyDistribution=obj_resp.client_key
)
)
return response
raise Exception(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)
except Exception as e:
errors = [Message.get_error_object(Message.CLIENT_SIGNAL_KEY_NOT_FOUND)]
context.set_details(json.dumps(
errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.NOT_FOUND)
@request_logged
#not use for now
async def GroupGetAllClientKey(self, request, context):
group_id = request.groupId
lst_client = self.service.group_get_all_client_key(group_id)
lst_client_key = []
for client in lst_client:
client_key = signal_pb2.GroupClientKeyObject(
clientId=client.client_id,
deviceId=client.device_id,
clientKeyDistribution=client.client_key
)
lst_client_key.append(client_key)
response = signal_pb2.GroupGetAllClientKeyResponse(
groupId=group_id,
lstClientKey=lst_client_key
)
return response
async def verify_pincode(self, request, context):
try:
exists_user = self.service.get_user_by_email(request.user_name)
user_info = self.user_service.get_user_by_id(exists_user["id"])
if not user_info:
raise Exception(Message.AUTH_USER_NOT_FOUND)
password_verifier = bytes.fromhex(user_info.password_verifier)
salt = bytes.fromhex(user_info.salt)
client_session_key_proof = request.client_session_key_proof
client_session_key_proof_bytes = bytes.fromhex(
client_session_key_proof)
srv = srp.Verifier(username=request.user_name,
bytes_s=salt,
bytes_v=password_verifier,
bytes_A=bytes.fromhex(request.client_public),
bytes_b=bytes.fromhex(
user_info.srp_server_private))
srv.verify_session(client_session_key_proof_bytes)
authenticated = srv.authenticated()
if not authenticated:
raise Exception(Message.AUTHENTICATION_FAILED)
token = self.service.token(request.user_name,
user_info.password_verifier)
introspect_token = KeyCloakUtils.introspect_token(
token['access_token'])
if not token:
raise Exception(Message.VERIFY_PINCODE_FAILED)
client_key_obj = SignalService().peer_get_client_key(
introspect_token['sub'])
client_key_peer = auth_messages.PeerGetClientKeyResponse(
clientId=introspect_token['sub'],
workspace_domain=get_owner_workspace_domain(),
registrationId=client_key_obj.registration_id,
deviceId=client_key_obj.device_id,
identityKeyPublic=client_key_obj.identity_key_public,
preKeyId=client_key_obj.prekey_id,
preKey=client_key_obj.prekey,
signedPreKeyId=client_key_obj.signed_prekey_id,
signedPreKey=client_key_obj.signed_prekey,
signedPreKeySignature=client_key_obj.signed_prekey_signature,
identityKeyEncrypted=client_key_obj.identity_key_encrypted)
self.user_service.update_last_login(
user_id=introspect_token['sub'])
return auth_messages.AuthRes(
workspace_domain=get_owner_workspace_domain(),
workspace_name=get_system_config()['server_name'],
access_token=token["access_token"],
expires_in=token['expires_in'],
refresh_expires_in=token['refresh_expires_in'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
session_state=token['session_state'],
scope=token['scope'],
salt=user_info.salt,
client_key_peer=client_key_peer,
iv_parameter=user_info.iv_parameter)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(Message.VERIFY_PINCODE_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
async def reset_pincode(self, request, context):
try:
success_status = self.service.verify_hash_pre_access_token(
request.user_name, request.reset_pincode_token,
"verify_pincode")
exists_user = self.service.get_user_by_email(request.user_name)
if not exists_user:
raise Exception(Message.USER_NOT_FOUND)
if not success_status:
raise Exception(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
self.user_service.change_password(request, None,
request.hash_pincode,
exists_user["id"])
old_client_key_peer = SignalService().peer_get_client_key(
exists_user["id"])
SignalService().client_update_peer_key(exists_user["id"],
request.client_key_peer)
try:
salt, iv_parameter = UserService().update_hash_pin(
exists_user["id"], request.hash_pincode, request.salt,
request.iv_parameter)
except Exception as e:
logger.error(e)
SignalService().client_update_peer_key(exists_user["id"],
old_client_key_peer)
raise Message.get_error_object(
Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
client_key_obj = request.client_key_peer
client_key_peer = auth_messages.PeerGetClientKeyResponse(
clientId=exists_user["id"],
workspace_domain=get_owner_workspace_domain(),
registrationId=client_key_obj.registrationId,
deviceId=client_key_obj.deviceId,
identityKeyPublic=client_key_obj.identityKeyPublic,
preKeyId=client_key_obj.preKeyId,
preKey=client_key_obj.preKey,
signedPreKeyId=client_key_obj.signedPreKeyId,
signedPreKey=client_key_obj.signedPreKey,
signedPreKeySignature=client_key_obj.signedPreKeySignature,
identityKeyEncrypted=client_key_obj.identityKeyEncrypted)
# logout all device before get new token for user after updated new key
user_sessions = KeyCloakUtils.get_sessions(
user_id=exists_user["id"])
for user_session in user_sessions:
KeyCloakUtils.remove_session(session_id=user_session['id'])
token = self.service.token(request.user_name, request.hash_pincode)
introspect_token = KeyCloakUtils.introspect_token(
token['access_token'])
return auth_messages.AuthRes(
workspace_domain=get_owner_workspace_domain(),
workspace_name=get_system_config()['server_name'],
access_token=token["access_token"],
expires_in=token['expires_in'],
refresh_expires_in=token['refresh_expires_in'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
session_state=token['session_state'],
scope=token['scope'],
salt=salt,
client_key_peer=client_key_peer,
iv_parameter=iv_parameter)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(
Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
async def register_pincode(self, request, context):
try:
exists_user = self.service.get_user_by_email(request.user_name)
if not exists_user:
raise Exception(Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
user_info = self.user_service.get_user_by_id(exists_user["id"])
if user_info.password_verifier is not None:
raise Exception(Message.REGISTER_USER_ALREADY_EXISTS)
salt = request.salt
self.user_service.change_password(request, None,
request.hash_pincode,
exists_user['id'])
# using hash_pincode as password for social user
try:
SignalService().peer_register_client_key(
exists_user['id'], request.client_key_peer)
except Exception as e:
logger.error(e)
try:
UserService().update_hash_pin(exists_user['id'],
request.hash_pincode,
request.salt,
request.iv_parameter)
except Exception as e:
logger.error(e)
## TODO: revert change_password
SignalService().delete_client_peer_key(exists_user['id'])
raise Message.get_error_object(
Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
require_action = ""
client_key_obj = request.client_key_peer
client_key_peer = auth_messages.PeerGetClientKeyResponse(
clientId=exists_user['id'],
workspace_domain=get_owner_workspace_domain(),
registrationId=client_key_obj.registrationId,
deviceId=client_key_obj.deviceId,
identityKeyPublic=client_key_obj.identityKeyPublic,
preKeyId=client_key_obj.preKeyId,
preKey=client_key_obj.preKey,
signedPreKeyId=client_key_obj.signedPreKeyId,
signedPreKey=client_key_obj.signedPreKey,
signedPreKeySignature=client_key_obj.signedPreKeySignature,
identityKeyEncrypted=client_key_obj.identityKeyEncrypted)
token = self.service.token(request.user_name, request.hash_pincode)
introspect_token = KeyCloakUtils.introspect_token(
token['access_token'])
self.user_service.update_last_login(
user_id=introspect_token['sub'])
return auth_messages.AuthRes(
workspace_domain=get_owner_workspace_domain(),
workspace_name=get_system_config()['server_name'],
access_token=token["access_token"],
expires_in=token['expires_in'],
refresh_expires_in=token['refresh_expires_in'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
session_state=token['session_state'],
scope=token['scope'],
salt=request.salt,
client_key_peer=client_key_peer,
iv_parameter=request.iv_parameter)
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(
Message.REGISTER_CLIENT_SIGNAL_KEY_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)
async def forgot_password_update(self, request, context):
try:
logger.info("from email {}".format(request.email))
user_info = self.user_service.get_user_by_auth_source(
request.email, "account")
old_user_id = user_info.id
self.service.verify_hash_pre_access_token(old_user_id,
request.pre_access_token,
"forgot_password")
new_user_id = self.service.forgot_user(request.email,
request.password_verifier,
user_info.display_name)
try:
await GroupService().forgot_peer_groups_for_client(user_info)
except Exception as e:
logger.error("cannot send notify to other group")
logger.error(e)
SignalService().delete_client_peer_key(old_user_id)
if new_user_id:
# create new user in database
UserService().forgot_user(user_info, new_user_id,
request.password_verifier,
request.salt, request.iv_parameter)
else:
self.service.delete_user(new_user_id)
raise Exception(Message.REGISTER_USER_FAILED)
try:
SignalService().peer_register_client_key(
new_user_id, request.client_key_peer)
except Exception:
self.service.delete_user(new_user_id)
UserService().delete_user(new_user_id)
raise Exception(Message.REGISTER_USER_FAILED)
token = self.service.token(request.email,
request.password_verifier)
if token:
client_key_obj = request.client_key_peer
client_key_peer = auth_messages.PeerGetClientKeyResponse(
clientId=new_user_id,
workspace_domain=get_owner_workspace_domain(),
registrationId=client_key_obj.registrationId,
deviceId=client_key_obj.deviceId,
identityKeyPublic=client_key_obj.identityKeyPublic,
preKeyId=client_key_obj.preKeyId,
preKey=client_key_obj.preKey,
signedPreKeyId=client_key_obj.signedPreKeyId,
signedPreKey=client_key_obj.signedPreKey,
signedPreKeySignature=client_key_obj.signedPreKeySignature,
identityKeyEncrypted=client_key_obj.identityKeyEncrypted)
self.user_service.update_last_login(user_id=new_user_id)
auth_message = auth_messages.AuthRes(
workspace_domain=get_owner_workspace_domain(),
workspace_name=get_system_config()['server_name'],
access_token=token['access_token'],
expires_in=token['expires_in'],
refresh_expires_in=token['refresh_expires_in'],
refresh_token=token['refresh_token'],
token_type=token['token_type'],
session_state=token['session_state'],
scope=token['scope'],
salt=request.salt,
client_key_peer=client_key_peer,
iv_parameter=request.iv_parameter)
else:
raise Exception(Message.AUTH_USER_NOT_FOUND)
return auth_message
except Exception as e:
logger.error(e)
if not e.args or e.args[0] not in Message.msg_dict:
errors = [
Message.get_error_object(Message.CHANGE_PASSWORD_FAILED)
]
else:
errors = [Message.get_error_object(e.args[0])]
context.set_details(
json.dumps(errors, default=lambda x: x.__dict__))
context.set_code(grpc.StatusCode.INTERNAL)