2022-06-17 12:48:55 +00:00
|
|
|
# Copyright 2023 The Matrix.org Foundation.
|
2014-08-12 14:10:52 +00:00
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
2016-07-26 15:46:53 +00:00
|
|
|
import logging
|
2023-05-16 08:52:37 +00:00
|
|
|
from typing import TYPE_CHECKING
|
2016-07-26 15:46:53 +00:00
|
|
|
|
|
|
|
import pymacaroons
|
2018-07-09 06:09:20 +00:00
|
|
|
|
2019-07-11 10:06:23 +00:00
|
|
|
from synapse.api.errors import (
|
|
|
|
AuthError,
|
|
|
|
Codes,
|
|
|
|
InvalidClientTokenError,
|
|
|
|
MissingClientTokenError,
|
|
|
|
)
|
2020-12-11 16:33:31 +00:00
|
|
|
from synapse.http.site import SynapseRequest
|
2022-06-17 12:48:55 +00:00
|
|
|
from synapse.logging.opentracing import active_span, force_tracing, start_active_span
|
2022-08-22 13:17:59 +00:00
|
|
|
from synapse.types import Requester, create_requester
|
2022-09-07 11:03:32 +00:00
|
|
|
from synapse.util.cancellation import cancellable
|
2014-08-12 14:10:52 +00:00
|
|
|
|
2022-06-17 12:48:55 +00:00
|
|
|
from . import GUEST_DEVICE_ID
|
|
|
|
from .base import BaseAuth
|
|
|
|
|
2021-04-23 16:02:16 +00:00
|
|
|
if TYPE_CHECKING:
|
|
|
|
from synapse.server import HomeServer
|
|
|
|
|
2014-08-12 14:10:52 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
2022-06-17 12:48:55 +00:00
|
|
|
class InternalAuth(BaseAuth):
|
2017-01-10 18:16:54 +00:00
|
|
|
"""
|
2021-07-01 18:25:37 +00:00
|
|
|
This class contains functions for authenticating users of our client-server API.
|
2017-01-10 18:16:54 +00:00
|
|
|
"""
|
2019-06-20 09:32:02 +00:00
|
|
|
|
2021-04-23 16:02:16 +00:00
|
|
|
def __init__(self, hs: "HomeServer"):
|
2022-06-17 12:48:55 +00:00
|
|
|
super().__init__(hs)
|
2017-01-10 18:16:54 +00:00
|
|
|
self.clock = hs.get_clock()
|
2021-07-16 16:11:53 +00:00
|
|
|
self._account_validity_handler = hs.get_account_validity_handler()
|
2022-06-14 13:12:08 +00:00
|
|
|
self._macaroon_generator = hs.get_macaroon_generator()
|
2017-06-29 13:50:18 +00:00
|
|
|
|
2021-05-14 09:51:08 +00:00
|
|
|
self._force_tracing_for_users = hs.config.tracing.force_tracing_for_users
|
2019-04-08 16:10:55 +00:00
|
|
|
|
2022-09-07 11:03:32 +00:00
|
|
|
@cancellable
|
2020-08-06 12:30:06 +00:00
|
|
|
async def get_user_by_req(
|
2020-05-14 15:32:49 +00:00
|
|
|
self,
|
2021-03-12 16:37:57 +00:00
|
|
|
request: SynapseRequest,
|
2020-05-14 15:32:49 +00:00
|
|
|
allow_guest: bool = False,
|
|
|
|
allow_expired: bool = False,
|
2023-08-10 09:10:55 +00:00
|
|
|
allow_locked: bool = False,
|
2021-04-23 16:02:16 +00:00
|
|
|
) -> Requester:
|
2014-08-12 14:10:52 +00:00
|
|
|
"""Get a registered user's ID.
|
|
|
|
|
|
|
|
Args:
|
2020-05-14 15:32:49 +00:00
|
|
|
request: An HTTP request with an access_token query parameter.
|
|
|
|
allow_guest: If False, will raise an AuthError if the user making the
|
|
|
|
request is a guest.
|
|
|
|
allow_expired: If True, allow the request through even if the account
|
|
|
|
is expired, or session token lifetime has ended. Note that
|
|
|
|
/login will deliver access tokens regardless of expiration.
|
|
|
|
|
2014-08-12 14:10:52 +00:00
|
|
|
Returns:
|
2020-08-06 12:30:06 +00:00
|
|
|
Resolves to the requester
|
2014-08-12 14:10:52 +00:00
|
|
|
Raises:
|
2019-07-11 10:06:23 +00:00
|
|
|
InvalidClientCredentialsError if no user by that token exists or the token
|
|
|
|
is invalid.
|
|
|
|
AuthError if access is denied for the user in the access token
|
2014-08-12 14:10:52 +00:00
|
|
|
"""
|
2021-12-21 11:10:36 +00:00
|
|
|
parent_span = active_span()
|
|
|
|
with start_active_span("get_user_by_req"):
|
|
|
|
requester = await self._wrapped_get_user_by_req(
|
2023-08-10 09:10:55 +00:00
|
|
|
request, allow_guest, allow_expired, allow_locked
|
2021-12-21 11:10:36 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if parent_span:
|
|
|
|
if requester.authenticated_entity in self._force_tracing_for_users:
|
|
|
|
# request tracing is enabled for this user, so we need to force it
|
|
|
|
# tracing on for the parent span (which will be the servlet span).
|
|
|
|
#
|
|
|
|
# It's too late for the get_user_by_req span to inherit the setting,
|
|
|
|
# so we also force it on for that.
|
|
|
|
force_tracing()
|
|
|
|
force_tracing(parent_span)
|
|
|
|
parent_span.set_tag(
|
|
|
|
"authenticated_entity", requester.authenticated_entity
|
|
|
|
)
|
|
|
|
parent_span.set_tag("user_id", requester.user.to_string())
|
|
|
|
if requester.device_id is not None:
|
|
|
|
parent_span.set_tag("device_id", requester.device_id)
|
|
|
|
if requester.app_service is not None:
|
|
|
|
parent_span.set_tag("appservice_id", requester.app_service.id)
|
|
|
|
return requester
|
|
|
|
|
2022-09-07 11:03:32 +00:00
|
|
|
@cancellable
|
2021-12-21 11:10:36 +00:00
|
|
|
async def _wrapped_get_user_by_req(
|
|
|
|
self,
|
|
|
|
request: SynapseRequest,
|
|
|
|
allow_guest: bool,
|
|
|
|
allow_expired: bool,
|
2023-08-10 09:10:55 +00:00
|
|
|
allow_locked: bool,
|
2021-12-21 11:10:36 +00:00
|
|
|
) -> Requester:
|
|
|
|
"""Helper for get_user_by_req
|
|
|
|
|
|
|
|
Once get_user_by_req has set up the opentracing span, this does the actual work.
|
|
|
|
"""
|
2014-08-12 14:10:52 +00:00
|
|
|
try:
|
2019-07-11 10:06:23 +00:00
|
|
|
access_token = self.get_access_token_from_request(request)
|
2018-12-04 11:44:41 +00:00
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
# First check if it could be a request from an appservice
|
2023-05-16 08:52:37 +00:00
|
|
|
requester = await self.get_appservice_user(request, access_token)
|
2022-08-22 13:17:59 +00:00
|
|
|
if not requester:
|
|
|
|
# If not, it should be from a regular user
|
|
|
|
requester = await self.get_user_by_access_token(
|
|
|
|
access_token, allow_expired=allow_expired
|
2021-12-15 10:40:52 +00:00
|
|
|
)
|
2020-10-29 15:58:44 +00:00
|
|
|
|
2023-08-10 09:10:55 +00:00
|
|
|
# Deny the request if the user account is locked.
|
|
|
|
if not allow_locked and await self.store.get_user_locked_status(
|
|
|
|
requester.user.to_string()
|
|
|
|
):
|
|
|
|
raise AuthError(
|
|
|
|
401,
|
|
|
|
"User account has been locked",
|
|
|
|
errcode=Codes.USER_LOCKED,
|
|
|
|
additional_fields={"soft_logout": True},
|
|
|
|
)
|
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
# Deny the request if the user account has expired.
|
|
|
|
# This check is only done for regular users, not appservice ones.
|
|
|
|
if not allow_expired:
|
|
|
|
if await self._account_validity_handler.is_user_expired(
|
|
|
|
requester.user.to_string()
|
|
|
|
):
|
|
|
|
# Raise the error if either an account validity module has determined
|
|
|
|
# the account has expired, or the legacy account validity
|
|
|
|
# implementation is enabled and determined the account has expired
|
|
|
|
raise AuthError(
|
|
|
|
403,
|
|
|
|
"User account has expired",
|
|
|
|
errcode=Codes.EXPIRED_ACCOUNT,
|
|
|
|
)
|
|
|
|
|
2023-11-23 12:35:37 +00:00
|
|
|
await self._record_request(request, requester)
|
2014-09-26 15:36:24 +00:00
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
if requester.is_guest and not allow_guest:
|
2015-11-04 17:29:07 +00:00
|
|
|
raise AuthError(
|
|
|
|
403,
|
|
|
|
"Guest access not allowed",
|
|
|
|
errcode=Codes.GUEST_ACCESS_FORBIDDEN,
|
|
|
|
)
|
|
|
|
|
2020-10-29 15:58:44 +00:00
|
|
|
request.requester = requester
|
|
|
|
return requester
|
2014-08-12 14:10:52 +00:00
|
|
|
except KeyError:
|
2019-07-11 10:06:23 +00:00
|
|
|
raise MissingClientTokenError()
|
2014-08-12 14:10:52 +00:00
|
|
|
|
2020-08-06 12:30:06 +00:00
|
|
|
async def get_user_by_access_token(
|
2020-05-14 15:32:49 +00:00
|
|
|
self,
|
|
|
|
token: str,
|
|
|
|
allow_expired: bool = False,
|
2022-08-22 13:17:59 +00:00
|
|
|
) -> Requester:
|
2016-12-06 15:31:37 +00:00
|
|
|
"""Validate access token and get user_id from it
|
2014-08-12 14:10:52 +00:00
|
|
|
|
|
|
|
Args:
|
2020-05-14 15:32:49 +00:00
|
|
|
token: The access token to get the user by
|
|
|
|
allow_expired: If False, raises an InvalidClientTokenError
|
|
|
|
if the token is expired
|
2020-10-29 15:58:44 +00:00
|
|
|
|
2014-08-12 14:10:52 +00:00
|
|
|
Raises:
|
2020-05-14 15:32:49 +00:00
|
|
|
InvalidClientTokenError if a user by that token exists, but the token is
|
|
|
|
expired
|
2019-07-11 10:06:23 +00:00
|
|
|
InvalidClientCredentialsError if no user by that token exists or the token
|
2020-05-14 15:32:49 +00:00
|
|
|
is invalid
|
2014-08-12 14:10:52 +00:00
|
|
|
"""
|
2019-01-10 12:41:13 +00:00
|
|
|
|
2022-06-14 13:12:08 +00:00
|
|
|
# First look in the database to see if the access token is present
|
|
|
|
# as an opaque token.
|
2022-08-22 13:17:59 +00:00
|
|
|
user_info = await self.store.get_user_by_access_token(token)
|
|
|
|
if user_info:
|
|
|
|
valid_until_ms = user_info.valid_until_ms
|
2022-06-14 13:12:08 +00:00
|
|
|
if (
|
|
|
|
not allow_expired
|
|
|
|
and valid_until_ms is not None
|
|
|
|
and valid_until_ms < self.clock.time_msec()
|
|
|
|
):
|
|
|
|
# there was a valid access token, but it has expired.
|
|
|
|
# soft-logout the user.
|
|
|
|
raise InvalidClientTokenError(
|
|
|
|
msg="Access token has expired", soft_logout=True
|
|
|
|
)
|
2019-07-12 16:26:02 +00:00
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
# Mark the token as used. This is used to invalidate old refresh
|
|
|
|
# tokens after some time.
|
|
|
|
await self.store.mark_access_token_as_used(user_info.token_id)
|
|
|
|
|
|
|
|
requester = create_requester(
|
|
|
|
user_id=user_info.user_id,
|
|
|
|
access_token_id=user_info.token_id,
|
|
|
|
is_guest=user_info.is_guest,
|
|
|
|
shadow_banned=user_info.shadow_banned,
|
|
|
|
device_id=user_info.device_id,
|
|
|
|
authenticated_entity=user_info.token_owner,
|
|
|
|
)
|
|
|
|
|
|
|
|
return requester
|
2015-08-26 12:22:23 +00:00
|
|
|
|
2022-05-05 12:39:59 +00:00
|
|
|
# If the token isn't found in the database, then it could still be a
|
2022-06-14 13:12:08 +00:00
|
|
|
# macaroon for a guest, so we check that here.
|
2015-08-26 12:22:23 +00:00
|
|
|
try:
|
2022-06-14 13:12:08 +00:00
|
|
|
user_id = self._macaroon_generator.verify_guest_token(token)
|
|
|
|
|
|
|
|
# Guest access tokens are not stored in the database (there can
|
|
|
|
# only be one access token per guest, anyway).
|
|
|
|
#
|
|
|
|
# In order to prevent guest access tokens being used as regular
|
|
|
|
# user access tokens (and hence getting around the invalidation
|
|
|
|
# process), we look up the user id and check that it is indeed
|
|
|
|
# a guest user.
|
|
|
|
#
|
|
|
|
# It would of course be much easier to store guest access
|
|
|
|
# tokens in the database as well, but that would break existing
|
|
|
|
# guest tokens.
|
|
|
|
stored_user = await self.store.get_user_by_id(user_id)
|
|
|
|
if not stored_user:
|
|
|
|
raise InvalidClientTokenError("Unknown user_id %s" % user_id)
|
2023-09-14 11:46:30 +00:00
|
|
|
if not stored_user.is_guest:
|
2022-06-14 13:12:08 +00:00
|
|
|
raise InvalidClientTokenError(
|
|
|
|
"Guest access token used for regular user"
|
2020-10-29 15:58:44 +00:00
|
|
|
)
|
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
return create_requester(
|
2022-06-14 13:12:08 +00:00
|
|
|
user_id=user_id,
|
|
|
|
is_guest=True,
|
|
|
|
# all guests get the same device id
|
|
|
|
device_id=GUEST_DEVICE_ID,
|
2022-08-22 13:17:59 +00:00
|
|
|
authenticated_entity=user_id,
|
2022-06-14 13:12:08 +00:00
|
|
|
)
|
2019-01-10 12:41:13 +00:00
|
|
|
except (
|
|
|
|
pymacaroons.exceptions.MacaroonException,
|
|
|
|
TypeError,
|
|
|
|
ValueError,
|
|
|
|
) as e:
|
2022-05-05 12:39:59 +00:00
|
|
|
logger.warning(
|
|
|
|
"Invalid access token in auth: %s %s.",
|
|
|
|
type(e),
|
|
|
|
e,
|
|
|
|
)
|
|
|
|
raise InvalidClientTokenError("Invalid access token passed.")
|
2015-08-26 12:22:23 +00:00
|
|
|
|
2022-08-22 13:17:59 +00:00
|
|
|
async def is_server_admin(self, requester: Requester) -> bool:
|
2017-09-19 15:08:14 +00:00
|
|
|
"""Check if the given user is a local server admin.
|
|
|
|
|
|
|
|
Args:
|
2022-08-22 13:17:59 +00:00
|
|
|
requester: The user making the request, according to the access token.
|
2017-09-19 15:08:14 +00:00
|
|
|
|
|
|
|
Returns:
|
2020-06-05 13:33:49 +00:00
|
|
|
True if the user is an admin
|
2017-09-19 15:08:14 +00:00
|
|
|
"""
|
2022-08-22 13:17:59 +00:00
|
|
|
return await self.store.is_server_admin(requester.user)
|