profile.py 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553
  1. # Copyright 2014-2016 OpenMarket Ltd
  2. #
  3. # Licensed under the Apache License, Version 2.0 (the "License");
  4. # you may not use this file except in compliance with the License.
  5. # You may obtain a copy of the License at
  6. #
  7. # http://www.apache.org/licenses/LICENSE-2.0
  8. #
  9. # Unless required by applicable law or agreed to in writing, software
  10. # distributed under the License is distributed on an "AS IS" BASIS,
  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. # See the License for the specific language governing permissions and
  13. # limitations under the License.
  14. import logging
  15. import random
  16. from typing import TYPE_CHECKING, Optional
  17. from synapse.api.errors import (
  18. AuthError,
  19. Codes,
  20. HttpResponseException,
  21. RequestSendFailed,
  22. StoreError,
  23. SynapseError,
  24. )
  25. from synapse.metrics.background_process_metrics import wrap_as_background_process
  26. from synapse.types import (
  27. JsonDict,
  28. Requester,
  29. UserID,
  30. create_requester,
  31. get_domain_from_id,
  32. )
  33. from synapse.util.caches.descriptors import cached
  34. from synapse.util.stringutils import parse_and_validate_mxc_uri
  35. if TYPE_CHECKING:
  36. from synapse.server import HomeServer
  37. logger = logging.getLogger(__name__)
  38. MAX_DISPLAYNAME_LEN = 256
  39. MAX_AVATAR_URL_LEN = 1000
  40. class ProfileHandler:
  41. """Handles fetching and updating user profile information.
  42. ProfileHandler can be instantiated directly on workers and will
  43. delegate to master when necessary.
  44. """
  45. PROFILE_UPDATE_MS = 60 * 1000
  46. PROFILE_UPDATE_EVERY_MS = 24 * 60 * 60 * 1000
  47. def __init__(self, hs: "HomeServer"):
  48. self.store = hs.get_datastores().main
  49. self.clock = hs.get_clock()
  50. self.hs = hs
  51. self.federation = hs.get_federation_client()
  52. hs.get_federation_registry().register_query_handler(
  53. "profile", self.on_profile_query
  54. )
  55. self.user_directory_handler = hs.get_user_directory_handler()
  56. self.request_ratelimiter = hs.get_request_ratelimiter()
  57. self.max_avatar_size = hs.config.server.max_avatar_size
  58. self.allowed_avatar_mimetypes = hs.config.server.allowed_avatar_mimetypes
  59. self.server_name = hs.config.server.server_name
  60. self._third_party_rules = hs.get_third_party_event_rules()
  61. if hs.config.worker.run_background_tasks:
  62. self.clock.looping_call(
  63. self._update_remote_profile_cache, self.PROFILE_UPDATE_MS
  64. )
  65. async def get_profile(self, user_id: str) -> JsonDict:
  66. target_user = UserID.from_string(user_id)
  67. if self.hs.is_mine(target_user):
  68. try:
  69. displayname = await self.store.get_profile_displayname(
  70. target_user.localpart
  71. )
  72. avatar_url = await self.store.get_profile_avatar_url(
  73. target_user.localpart
  74. )
  75. except StoreError as e:
  76. if e.code == 404:
  77. raise SynapseError(404, "Profile was not found", Codes.NOT_FOUND)
  78. raise
  79. return {"displayname": displayname, "avatar_url": avatar_url}
  80. else:
  81. try:
  82. result = await self.federation.make_query(
  83. destination=target_user.domain,
  84. query_type="profile",
  85. args={"user_id": user_id},
  86. ignore_backoff=True,
  87. )
  88. return result
  89. except RequestSendFailed as e:
  90. raise SynapseError(502, "Failed to fetch profile") from e
  91. except HttpResponseException as e:
  92. if e.code < 500 and e.code != 404:
  93. # Other codes are not allowed in c2s API
  94. logger.info(
  95. "Server replied with wrong response: %s %s", e.code, e.msg
  96. )
  97. raise SynapseError(502, "Failed to fetch profile")
  98. raise e.to_synapse_error()
  99. async def get_profile_from_cache(self, user_id: str) -> JsonDict:
  100. """Get the profile information from our local cache. If the user is
  101. ours then the profile information will always be correct. Otherwise,
  102. it may be out of date/missing.
  103. """
  104. target_user = UserID.from_string(user_id)
  105. if self.hs.is_mine(target_user):
  106. try:
  107. displayname = await self.store.get_profile_displayname(
  108. target_user.localpart
  109. )
  110. avatar_url = await self.store.get_profile_avatar_url(
  111. target_user.localpart
  112. )
  113. except StoreError as e:
  114. if e.code == 404:
  115. raise SynapseError(404, "Profile was not found", Codes.NOT_FOUND)
  116. raise
  117. return {"displayname": displayname, "avatar_url": avatar_url}
  118. else:
  119. profile = await self.store.get_from_remote_profile_cache(user_id)
  120. return profile or {}
  121. async def get_displayname(self, target_user: UserID) -> Optional[str]:
  122. if self.hs.is_mine(target_user):
  123. try:
  124. displayname = await self.store.get_profile_displayname(
  125. target_user.localpart
  126. )
  127. except StoreError as e:
  128. if e.code == 404:
  129. raise SynapseError(404, "Profile was not found", Codes.NOT_FOUND)
  130. raise
  131. return displayname
  132. else:
  133. try:
  134. result = await self.federation.make_query(
  135. destination=target_user.domain,
  136. query_type="profile",
  137. args={"user_id": target_user.to_string(), "field": "displayname"},
  138. ignore_backoff=True,
  139. )
  140. except RequestSendFailed as e:
  141. raise SynapseError(502, "Failed to fetch profile") from e
  142. except HttpResponseException as e:
  143. raise e.to_synapse_error()
  144. return result.get("displayname")
  145. async def set_displayname(
  146. self,
  147. target_user: UserID,
  148. requester: Requester,
  149. new_displayname: str,
  150. by_admin: bool = False,
  151. deactivation: bool = False,
  152. ) -> None:
  153. """Set the displayname of a user
  154. Args:
  155. target_user: the user whose displayname is to be changed.
  156. requester: The user attempting to make this change.
  157. new_displayname: The displayname to give this user.
  158. by_admin: Whether this change was made by an administrator.
  159. deactivation: Whether this change was made while deactivating the user.
  160. """
  161. if not self.hs.is_mine(target_user):
  162. raise SynapseError(400, "User is not hosted on this homeserver")
  163. if not by_admin and target_user != requester.user:
  164. raise AuthError(400, "Cannot set another user's displayname")
  165. if not by_admin and not self.hs.config.registration.enable_set_displayname:
  166. profile = await self.store.get_profileinfo(target_user.localpart)
  167. if profile.display_name:
  168. raise SynapseError(
  169. 400,
  170. "Changing display name is disabled on this server",
  171. Codes.FORBIDDEN,
  172. )
  173. if not isinstance(new_displayname, str):
  174. raise SynapseError(
  175. 400, "'displayname' must be a string", errcode=Codes.INVALID_PARAM
  176. )
  177. if len(new_displayname) > MAX_DISPLAYNAME_LEN:
  178. raise SynapseError(
  179. 400, "Displayname is too long (max %i)" % (MAX_DISPLAYNAME_LEN,)
  180. )
  181. displayname_to_set: Optional[str] = new_displayname
  182. if new_displayname == "":
  183. displayname_to_set = None
  184. # If the admin changes the display name of a user, the requesting user cannot send
  185. # the join event to update the displayname in the rooms.
  186. # This must be done by the target user himself.
  187. if by_admin:
  188. requester = create_requester(
  189. target_user,
  190. authenticated_entity=requester.authenticated_entity,
  191. )
  192. await self.store.set_profile_displayname(
  193. target_user.localpart, displayname_to_set
  194. )
  195. profile = await self.store.get_profileinfo(target_user.localpart)
  196. await self.user_directory_handler.handle_local_profile_change(
  197. target_user.to_string(), profile
  198. )
  199. await self._third_party_rules.on_profile_update(
  200. target_user.to_string(), profile, by_admin, deactivation
  201. )
  202. await self._update_join_states(requester, target_user)
  203. async def get_avatar_url(self, target_user: UserID) -> Optional[str]:
  204. if self.hs.is_mine(target_user):
  205. try:
  206. avatar_url = await self.store.get_profile_avatar_url(
  207. target_user.localpart
  208. )
  209. except StoreError as e:
  210. if e.code == 404:
  211. raise SynapseError(404, "Profile was not found", Codes.NOT_FOUND)
  212. raise
  213. return avatar_url
  214. else:
  215. try:
  216. result = await self.federation.make_query(
  217. destination=target_user.domain,
  218. query_type="profile",
  219. args={"user_id": target_user.to_string(), "field": "avatar_url"},
  220. ignore_backoff=True,
  221. )
  222. except RequestSendFailed as e:
  223. raise SynapseError(502, "Failed to fetch profile") from e
  224. except HttpResponseException as e:
  225. raise e.to_synapse_error()
  226. return result.get("avatar_url")
  227. async def set_avatar_url(
  228. self,
  229. target_user: UserID,
  230. requester: Requester,
  231. new_avatar_url: str,
  232. by_admin: bool = False,
  233. deactivation: bool = False,
  234. ) -> None:
  235. """Set a new avatar URL for a user.
  236. Args:
  237. target_user: the user whose avatar URL is to be changed.
  238. requester: The user attempting to make this change.
  239. new_avatar_url: The avatar URL to give this user.
  240. by_admin: Whether this change was made by an administrator.
  241. deactivation: Whether this change was made while deactivating the user.
  242. """
  243. if not self.hs.is_mine(target_user):
  244. raise SynapseError(400, "User is not hosted on this homeserver")
  245. if not by_admin and target_user != requester.user:
  246. raise AuthError(400, "Cannot set another user's avatar_url")
  247. if not by_admin and not self.hs.config.registration.enable_set_avatar_url:
  248. profile = await self.store.get_profileinfo(target_user.localpart)
  249. if profile.avatar_url:
  250. raise SynapseError(
  251. 400, "Changing avatar is disabled on this server", Codes.FORBIDDEN
  252. )
  253. if not isinstance(new_avatar_url, str):
  254. raise SynapseError(
  255. 400, "'avatar_url' must be a string", errcode=Codes.INVALID_PARAM
  256. )
  257. if len(new_avatar_url) > MAX_AVATAR_URL_LEN:
  258. raise SynapseError(
  259. 400, "Avatar URL is too long (max %i)" % (MAX_AVATAR_URL_LEN,)
  260. )
  261. if not await self.check_avatar_size_and_mime_type(new_avatar_url):
  262. raise SynapseError(403, "This avatar is not allowed", Codes.FORBIDDEN)
  263. avatar_url_to_set: Optional[str] = new_avatar_url
  264. if new_avatar_url == "":
  265. avatar_url_to_set = None
  266. # Same like set_displayname
  267. if by_admin:
  268. requester = create_requester(
  269. target_user, authenticated_entity=requester.authenticated_entity
  270. )
  271. await self.store.set_profile_avatar_url(
  272. target_user.localpart, avatar_url_to_set
  273. )
  274. profile = await self.store.get_profileinfo(target_user.localpart)
  275. await self.user_directory_handler.handle_local_profile_change(
  276. target_user.to_string(), profile
  277. )
  278. await self._third_party_rules.on_profile_update(
  279. target_user.to_string(), profile, by_admin, deactivation
  280. )
  281. await self._update_join_states(requester, target_user)
  282. @cached()
  283. async def check_avatar_size_and_mime_type(self, mxc: str) -> bool:
  284. """Check that the size and content type of the avatar at the given MXC URI are
  285. within the configured limits.
  286. If the given `mxc` is empty, no checks are performed. (Users are always able to
  287. unset their avatar.)
  288. Args:
  289. mxc: The MXC URI at which the avatar can be found.
  290. Returns:
  291. A boolean indicating whether the file can be allowed to be set as an avatar.
  292. """
  293. if mxc == "":
  294. return True
  295. if not self.max_avatar_size and not self.allowed_avatar_mimetypes:
  296. return True
  297. server_name, _, media_id = parse_and_validate_mxc_uri(mxc)
  298. if server_name == self.server_name:
  299. media_info = await self.store.get_local_media(media_id)
  300. else:
  301. media_info = await self.store.get_cached_remote_media(server_name, media_id)
  302. if media_info is None:
  303. # Both configuration options need to access the file's metadata, and
  304. # retrieving remote avatars just for this becomes a bit of a faff, especially
  305. # if e.g. the file is too big. It's also generally safe to assume most files
  306. # used as avatar are uploaded locally, or if the upload didn't happen as part
  307. # of a PUT request on /avatar_url that the file was at least previewed by the
  308. # user locally (and therefore downloaded to the remote media cache).
  309. logger.warning("Forbidding avatar change to %s: avatar not on server", mxc)
  310. return False
  311. if self.max_avatar_size:
  312. # Ensure avatar does not exceed max allowed avatar size
  313. if media_info["media_length"] > self.max_avatar_size:
  314. logger.warning(
  315. "Forbidding avatar change to %s: %d bytes is above the allowed size "
  316. "limit",
  317. mxc,
  318. media_info["media_length"],
  319. )
  320. return False
  321. if self.allowed_avatar_mimetypes:
  322. # Ensure the avatar's file type is allowed
  323. if (
  324. self.allowed_avatar_mimetypes
  325. and media_info["media_type"] not in self.allowed_avatar_mimetypes
  326. ):
  327. logger.warning(
  328. "Forbidding avatar change to %s: mimetype %s not allowed",
  329. mxc,
  330. media_info["media_type"],
  331. )
  332. return False
  333. return True
  334. async def on_profile_query(self, args: JsonDict) -> JsonDict:
  335. """Handles federation profile query requests."""
  336. if not self.hs.config.federation.allow_profile_lookup_over_federation:
  337. raise SynapseError(
  338. 403,
  339. "Profile lookup over federation is disabled on this homeserver",
  340. Codes.FORBIDDEN,
  341. )
  342. user = UserID.from_string(args["user_id"])
  343. if not self.hs.is_mine(user):
  344. raise SynapseError(400, "User is not hosted on this homeserver")
  345. just_field = args.get("field", None)
  346. response = {}
  347. try:
  348. if just_field is None or just_field == "displayname":
  349. response["displayname"] = await self.store.get_profile_displayname(
  350. user.localpart
  351. )
  352. if just_field is None or just_field == "avatar_url":
  353. response["avatar_url"] = await self.store.get_profile_avatar_url(
  354. user.localpart
  355. )
  356. except StoreError as e:
  357. if e.code == 404:
  358. raise SynapseError(404, "Profile was not found", Codes.NOT_FOUND)
  359. raise
  360. return response
  361. async def _update_join_states(
  362. self, requester: Requester, target_user: UserID
  363. ) -> None:
  364. if not self.hs.is_mine(target_user):
  365. return
  366. await self.request_ratelimiter.ratelimit(requester)
  367. # Do not actually update the room state for shadow-banned users.
  368. if requester.shadow_banned:
  369. # We randomly sleep a bit just to annoy the requester.
  370. await self.clock.sleep(random.randint(1, 10))
  371. return
  372. room_ids = await self.store.get_rooms_for_user(target_user.to_string())
  373. for room_id in room_ids:
  374. handler = self.hs.get_room_member_handler()
  375. try:
  376. # Assume the target_user isn't a guest,
  377. # because we don't let guests set profile or avatar data.
  378. await handler.update_membership(
  379. requester,
  380. target_user,
  381. room_id,
  382. "join", # We treat a profile update like a join.
  383. ratelimit=False, # Try to hide that these events aren't atomic.
  384. )
  385. except Exception as e:
  386. logger.warning(
  387. "Failed to update join event for room %s - %s", room_id, str(e)
  388. )
  389. async def check_profile_query_allowed(
  390. self, target_user: UserID, requester: Optional[UserID] = None
  391. ) -> None:
  392. """Checks whether a profile query is allowed. If the
  393. 'require_auth_for_profile_requests' config flag is set to True and a
  394. 'requester' is provided, the query is only allowed if the two users
  395. share a room.
  396. Args:
  397. target_user: The owner of the queried profile.
  398. requester: The user querying for the profile.
  399. Raises:
  400. SynapseError(403): The two users share no room, or ne user couldn't
  401. be found to be in any room the server is in, and therefore the query
  402. is denied.
  403. """
  404. # Implementation of MSC1301: don't allow looking up profiles if the
  405. # requester isn't in the same room as the target. We expect requester to
  406. # be None when this function is called outside of a profile query, e.g.
  407. # when building a membership event. In this case, we must allow the
  408. # lookup.
  409. if (
  410. not self.hs.config.server.limit_profile_requests_to_users_who_share_rooms
  411. or not requester
  412. ):
  413. return
  414. # Always allow the user to query their own profile.
  415. if target_user.to_string() == requester.to_string():
  416. return
  417. try:
  418. requester_rooms = await self.store.get_rooms_for_user(requester.to_string())
  419. target_user_rooms = await self.store.get_rooms_for_user(
  420. target_user.to_string()
  421. )
  422. # Check if the room lists have no elements in common.
  423. if requester_rooms.isdisjoint(target_user_rooms):
  424. raise SynapseError(403, "Profile isn't available", Codes.FORBIDDEN)
  425. except StoreError as e:
  426. if e.code == 404:
  427. # This likely means that one of the users doesn't exist,
  428. # so we act as if we couldn't find the profile.
  429. raise SynapseError(403, "Profile isn't available", Codes.FORBIDDEN)
  430. raise
  431. @wrap_as_background_process("Update remote profile")
  432. async def _update_remote_profile_cache(self) -> None:
  433. """Called periodically to check profiles of remote users we haven't
  434. checked in a while.
  435. """
  436. entries = await self.store.get_remote_profile_cache_entries_that_expire(
  437. last_checked=self.clock.time_msec() - self.PROFILE_UPDATE_EVERY_MS
  438. )
  439. for user_id, displayname, avatar_url in entries:
  440. is_subscribed = await self.store.is_subscribed_remote_profile_for_user(
  441. user_id
  442. )
  443. if not is_subscribed:
  444. await self.store.maybe_delete_remote_profile_cache(user_id)
  445. continue
  446. try:
  447. profile = await self.federation.make_query(
  448. destination=get_domain_from_id(user_id),
  449. query_type="profile",
  450. args={"user_id": user_id},
  451. ignore_backoff=True,
  452. )
  453. except Exception:
  454. logger.exception("Failed to get avatar_url")
  455. await self.store.update_remote_profile_cache(
  456. user_id, displayname, avatar_url
  457. )
  458. continue
  459. new_name = profile.get("displayname")
  460. if not isinstance(new_name, str):
  461. new_name = None
  462. new_avatar = profile.get("avatar_url")
  463. if not isinstance(new_avatar, str):
  464. new_avatar = None
  465. # We always hit update to update the last_check timestamp
  466. await self.store.update_remote_profile_cache(user_id, new_name, new_avatar)