Git of dcc - anni/blob - lib/pleroma/web/media_proxy/media_proxy_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MediaProxy.MediaProxyController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Config
   9   alias Pleroma.Helpers.MediaHelper
  10   alias Pleroma.Helpers.UriHelper
  11   alias Pleroma.ReverseProxy
  12   alias Pleroma.Web.MediaProxy
  13   alias Plug.Conn
  14
  15   plug(:sandbox)
  16
  17   def remote(conn, %{"sig" => sig64, "url" => url64}) do
  18     with {_, true} <- {:enabled, MediaProxy.enabled?()},
  19          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  20          {_, false} <- {:in_banned_urls, MediaProxy.in_banned_urls(url)},
  21          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  22       ReverseProxy.call(conn, url, media_proxy_opts())
  23     else
  24       {:enabled, false} ->
  25         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  26
  27       {:in_banned_urls, true} ->
  28         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  29
  30       {:error, :invalid_signature} ->
  31         send_resp(conn, 403, Conn.Status.reason_phrase(403))
  32
  33       {:wrong_filename, filename} ->
  34         redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
  35     end
  36   end
  37
  38   def preview(%Conn{} = conn, %{"sig" => sig64, "url" => url64}) do
  39     with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
  40          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  41          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  42       handle_preview(conn, url)
  43     else
  44       {:enabled, false} ->
  45         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  46
  47       {:error, :invalid_signature} ->
  48         send_resp(conn, 403, Conn.Status.reason_phrase(403))
  49
  50       {:wrong_filename, filename} ->
  51         redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
  52     end
  53   end
  54
  55   defp handle_preview(conn, url) do
  56     media_proxy_url = MediaProxy.url(url)
  57
  58     with {:ok, %{status: status} = head_response} when status in 200..299 <-
  59            Pleroma.HTTP.request("HEAD", media_proxy_url, [], [], pool: :media) do
  60       content_type = Tesla.get_header(head_response, "content-type")
  61       content_length = Tesla.get_header(head_response, "content-length")
  62       content_length = content_length && String.to_integer(content_length)
  63       static = conn.params["static"] in ["true", true]
  64
  65       cond do
  66         static and content_type == "image/gif" ->
  67           handle_jpeg_preview(conn, media_proxy_url)
  68
  69         static ->
  70           drop_static_param_and_redirect(conn)
  71
  72         content_type == "image/gif" ->
  73           redirect(conn, external: media_proxy_url)
  74
  75         min_content_length_for_preview() > 0 and content_length > 0 and
  76             content_length < min_content_length_for_preview() ->
  77           redirect(conn, external: media_proxy_url)
  78
  79         true ->
  80           handle_preview(content_type, conn, media_proxy_url)
  81       end
  82     else
  83       # If HEAD failed, redirecting to media proxy URI doesn't make much sense; returning an error
  84       {_, %{status: status}} ->
  85         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")
  86
  87       {:error, :recv_response_timeout} ->
  88         send_resp(conn, :failed_dependency, "HEAD request timeout.")
  89
  90       _ ->
  91         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers.")
  92     end
  93   end
  94
  95   defp handle_preview("image/png" <> _ = _content_type, conn, media_proxy_url) do
  96     handle_png_preview(conn, media_proxy_url)
  97   end
  98
  99   defp handle_preview("image/" <> _ = _content_type, conn, media_proxy_url) do
 100     handle_jpeg_preview(conn, media_proxy_url)
 101   end
 102
 103   defp handle_preview("video/" <> _ = _content_type, conn, media_proxy_url) do
 104     handle_video_preview(conn, media_proxy_url)
 105   end
 106
 107   defp handle_preview(_unsupported_content_type, conn, media_proxy_url) do
 108     fallback_on_preview_error(conn, media_proxy_url)
 109   end
 110
 111   defp handle_png_preview(conn, media_proxy_url) do
 112     quality = Config.get!([:media_preview_proxy, :image_quality])
 113     {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()
 114
 115     with {:ok, thumbnail_binary} <-
 116            MediaHelper.image_resize(
 117              media_proxy_url,
 118              %{
 119                max_width: thumbnail_max_width,
 120                max_height: thumbnail_max_height,
 121                quality: quality,
 122                format: "png"
 123              }
 124            ) do
 125       conn
 126       |> put_preview_response_headers(["image/png", "preview.png"])
 127       |> send_resp(200, thumbnail_binary)
 128     else
 129       _ ->
 130         fallback_on_preview_error(conn, media_proxy_url)
 131     end
 132   end
 133
 134   defp handle_jpeg_preview(conn, media_proxy_url) do
 135     quality = Config.get!([:media_preview_proxy, :image_quality])
 136     {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()
 137
 138     with {:ok, thumbnail_binary} <-
 139            MediaHelper.image_resize(
 140              media_proxy_url,
 141              %{max_width: thumbnail_max_width, max_height: thumbnail_max_height, quality: quality}
 142            ) do
 143       conn
 144       |> put_preview_response_headers()
 145       |> send_resp(200, thumbnail_binary)
 146     else
 147       _ ->
 148         fallback_on_preview_error(conn, media_proxy_url)
 149     end
 150   end
 151
 152   defp handle_video_preview(conn, media_proxy_url) do
 153     with {:ok, thumbnail_binary} <-
 154            MediaHelper.video_framegrab(media_proxy_url) do
 155       conn
 156       |> put_preview_response_headers()
 157       |> send_resp(200, thumbnail_binary)
 158     else
 159       _ ->
 160         fallback_on_preview_error(conn, media_proxy_url)
 161     end
 162   end
 163
 164   defp drop_static_param_and_redirect(conn) do
 165     uri_without_static_param =
 166       conn
 167       |> current_url()
 168       |> UriHelper.modify_uri_params(%{}, ["static"])
 169
 170     redirect(conn, external: uri_without_static_param)
 171   end
 172
 173   defp fallback_on_preview_error(conn, media_proxy_url) do
 174     redirect(conn, external: media_proxy_url)
 175   end
 176
 177   defp put_preview_response_headers(
 178          conn,
 179          [content_type, filename] = _content_info \\ ["image/jpeg", "preview.jpg"]
 180        ) do
 181     conn
 182     |> put_resp_header("content-type", content_type)
 183     |> put_resp_header("content-disposition", "inline; filename=\"#{filename}\"")
 184     |> put_resp_header("cache-control", ReverseProxy.default_cache_control_header())
 185   end
 186
 187   defp thumbnail_max_dimensions do
 188     config = media_preview_proxy_config()
 189
 190     thumbnail_max_width = Keyword.fetch!(config, :thumbnail_max_width)
 191     thumbnail_max_height = Keyword.fetch!(config, :thumbnail_max_height)
 192
 193     {thumbnail_max_width, thumbnail_max_height}
 194   end
 195
 196   defp min_content_length_for_preview do
 197     Keyword.get(media_preview_proxy_config(), :min_content_length, 0)
 198   end
 199
 200   defp media_preview_proxy_config do
 201     Config.get!([:media_preview_proxy])
 202   end
 203
 204   defp media_proxy_opts do
 205     Config.get([:media_proxy, :proxy_opts], [])
 206   end
 207
 208   defp sandbox(conn, _params) do
 209     conn
 210     |> merge_resp_headers([{"content-security-policy", "sandbox;"}])
 211   end
 212 end