No OneTemporary
Actions

Authored By

Unknown

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/media_proxy/media_proxy_controller.ex b/lib/pleroma/web/media_proxy/media_proxy_controller.ex
	index b3a92d75a..84e07132a 100644
	--- a/lib/pleroma/web/media_proxy/media_proxy_controller.ex
	+++ b/lib/pleroma/web/media_proxy/media_proxy_controller.ex
	@@ -1,205 +1,205 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.MediaProxyController do
	use Pleroma.Web, :controller

	alias Pleroma.Config
	alias Pleroma.Helpers.MediaHelper
	alias Pleroma.Helpers.UriHelper
	alias Pleroma.ReverseProxy
	alias Pleroma.Web.MediaProxy
	alias Plug.Conn

	def remote(conn, %{"sig" => sig64, "url" => url64}) do
	with {_, true} <- {:enabled, MediaProxy.enabled?()},
	{:ok, url} <- MediaProxy.decode_url(sig64, url64),
	{_, false} <- {:in_banned_urls, MediaProxy.in_banned_urls(url)},
	:ok <- MediaProxy.verify_request_path_and_url(conn, url) do
	ReverseProxy.call(conn, url, media_proxy_opts())
	else
	{:enabled, false} ->
	send_resp(conn, 404, Conn.Status.reason_phrase(404))

	{:in_banned_urls, true} ->
	send_resp(conn, 404, Conn.Status.reason_phrase(404))

	{:error, :invalid_signature} ->
	send_resp(conn, 403, Conn.Status.reason_phrase(403))

	{:wrong_filename, filename} ->
	redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
	end
	end

	def preview(%Conn{} = conn, %{"sig" => sig64, "url" => url64}) do
	with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
	{:ok, url} <- MediaProxy.decode_url(sig64, url64),
	:ok <- MediaProxy.verify_request_path_and_url(conn, url) do
	handle_preview(conn, url)
	else
	{:enabled, false} ->
	send_resp(conn, 404, Conn.Status.reason_phrase(404))

	{:error, :invalid_signature} ->
	send_resp(conn, 403, Conn.Status.reason_phrase(403))

	{:wrong_filename, filename} ->
	redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
	end
	end

	defp handle_preview(conn, url) do
	media_proxy_url = MediaProxy.url(url)

	with {:ok, %{status: status} = head_response} when status in 200..299 <-
	- Pleroma.HTTP.request("head", media_proxy_url, [], [], name: MyFinch) do
	+ Pleroma.HTTP.request("HEAD", media_proxy_url, [], [], name: MyFinch) do
	content_type = Tesla.get_header(head_response, "content-type")
	content_length = Tesla.get_header(head_response, "content-length")
	content_length = content_length && String.to_integer(content_length)
	static = conn.params["static"] in ["true", true]

	cond do
	static and content_type == "image/gif" ->
	handle_jpeg_preview(conn, media_proxy_url)

	static ->
	drop_static_param_and_redirect(conn)

	content_type == "image/gif" ->
	redirect(conn, external: media_proxy_url)

	min_content_length_for_preview() > 0 and content_length > 0 and
	content_length < min_content_length_for_preview() ->
	redirect(conn, external: media_proxy_url)

	true ->
	handle_preview(content_type, conn, media_proxy_url)
	end
	else
	# If HEAD failed, redirecting to media proxy URI doesn't make much sense; returning an error
	{_, %{status: status}} ->
	send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")

	{:error, :recv_response_timeout} ->
	send_resp(conn, :failed_dependency, "HEAD request timeout.")

	_ ->
	send_resp(conn, :failed_dependency, "Can't fetch HTTP headers.")
	end
	end

	defp handle_preview("image/png" <> _ = _content_type, conn, media_proxy_url) do
	handle_png_preview(conn, media_proxy_url)
	end

	defp handle_preview("image/" <> _ = _content_type, conn, media_proxy_url) do
	handle_jpeg_preview(conn, media_proxy_url)
	end

	defp handle_preview("video/" <> _ = _content_type, conn, media_proxy_url) do
	handle_video_preview(conn, media_proxy_url)
	end

	defp handle_preview(_unsupported_content_type, conn, media_proxy_url) do
	fallback_on_preview_error(conn, media_proxy_url)
	end

	defp handle_png_preview(conn, media_proxy_url) do
	quality = Config.get!([:media_preview_proxy, :image_quality])
	{thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()

	with {:ok, thumbnail_binary} <-
	MediaHelper.image_resize(
	media_proxy_url,
	%{
	max_width: thumbnail_max_width,
	max_height: thumbnail_max_height,
	quality: quality,
	format: "png"
	}
	) do
	conn
	\|> put_preview_response_headers(["image/png", "preview.png"])
	\|> send_resp(200, thumbnail_binary)
	else
	_ ->
	fallback_on_preview_error(conn, media_proxy_url)
	end
	end

	defp handle_jpeg_preview(conn, media_proxy_url) do
	quality = Config.get!([:media_preview_proxy, :image_quality])
	{thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()

	with {:ok, thumbnail_binary} <-
	MediaHelper.image_resize(
	media_proxy_url,
	%{max_width: thumbnail_max_width, max_height: thumbnail_max_height, quality: quality}
	) do
	conn
	\|> put_preview_response_headers()
	\|> send_resp(200, thumbnail_binary)
	else
	_ ->
	fallback_on_preview_error(conn, media_proxy_url)
	end
	end

	defp handle_video_preview(conn, media_proxy_url) do
	with {:ok, thumbnail_binary} <-
	MediaHelper.video_framegrab(media_proxy_url) do
	conn
	\|> put_preview_response_headers()
	\|> send_resp(200, thumbnail_binary)
	else
	_ ->
	fallback_on_preview_error(conn, media_proxy_url)
	end
	end

	defp drop_static_param_and_redirect(conn) do
	uri_without_static_param =
	conn
	\|> current_url()
	\|> UriHelper.modify_uri_params(%{}, ["static"])

	redirect(conn, external: uri_without_static_param)
	end

	defp fallback_on_preview_error(conn, media_proxy_url) do
	redirect(conn, external: media_proxy_url)
	end

	defp put_preview_response_headers(
	conn,
	[content_type, filename] = _content_info \\ ["image/jpeg", "preview.jpg"]
	) do
	conn
	\|> put_resp_header("content-type", content_type)
	\|> put_resp_header("content-disposition", "inline; filename=\"#{filename}\"")
	\|> put_resp_header("cache-control", ReverseProxy.default_cache_control_header())
	end

	defp thumbnail_max_dimensions do
	config = media_preview_proxy_config()

	thumbnail_max_width = Keyword.fetch!(config, :thumbnail_max_width)
	thumbnail_max_height = Keyword.fetch!(config, :thumbnail_max_height)

	{thumbnail_max_width, thumbnail_max_height}
	end

	defp min_content_length_for_preview do
	Keyword.get(media_preview_proxy_config(), :min_content_length, 0)
	end

	defp media_preview_proxy_config do
	Config.get!([:media_preview_proxy])
	end

	defp media_proxy_opts do
	Config.get([:media_proxy, :proxy_opts], [])
	end
	end
	diff --git a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	index 1f2e54194..e4b66c109 100644
	--- a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	+++ b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	@@ -1,336 +1,336 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest do
	use Pleroma.Web.ConnCase

	import Mock

	alias Pleroma.Web.MediaProxy
	alias Plug.Conn

	describe "Media Proxy" do
	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	[url: MediaProxy.encode_url("https://google.fn/test.png")]
	end

	test "it returns 404 when disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "it performs ReverseProxy.call with valid signature", %{conn: conn, url: url} do
	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: :success} = get(conn, url)
	end
	end

	test "it returns 404 when url is in banned_urls cache", %{conn: conn, url: url} do
	MediaProxy.put_in_banned_urls("https://google.fn/test.png")

	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: 404, resp_body: "Not Found"} = get(conn, url)
	end
	end
	end

	describe "Media Preview Proxy" do
	def assert_dependencies_installed do
	missing_dependencies = Pleroma.Helpers.MediaHelper.missing_dependencies()

	assert missing_dependencies == [],
	"Error: missing dependencies (please refer to `docs/installation`): #{inspect(missing_dependencies)}"
	end

	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	original_url = "https://google.fn/test.png"

	[
	url: MediaProxy.encode_preview_url(original_url),
	media_proxy_url: MediaProxy.encode_url(original_url)
	]
	end

	test "returns 404 when media proxy is disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "returns 404 when disabled", %{conn: conn} do
	clear_config([:media_preview_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "responds with 424 Failed Dependency if HEAD request to media proxy fails", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	response = get(conn, url)
	assert response.status == 424
	assert response.resp_body == "Can't fetch HTTP headers (HTTP 500)."
	end

	test "redirects to media proxy URI on unsupported content type", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "application/pdf"}]}
	end)

	response = get(conn, url)
	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static=true` and GIF image preview requested, responds with JPEG image", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	# Setting a high :min_content_length to ensure this scenario is not affected by its logic
	clear_config([:media_preview_proxy, :min_content_length], 1_000_000_000)

	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "1001718"}]
	}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.gif")}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "with GIF image preview requested and no `static` param, redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/gif"}]}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static` param and non-GIF image preview requested, " <>
	"redirects to media preview proxy URI without `static` param",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "with :min_content_length setting not matched by Content-Length header, " <>
	"redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	clear_config([:media_preview_proxy, :min_content_length], 100_000)

	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "5000"}]
	}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "thumbnails PNG images into PNG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/png"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.png")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/png"]
	assert response.resp_body != ""
	end

	test "thumbnails JPEG images into JPEG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.jpg")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "redirects to media proxy URI in case of thumbnailing error", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	- %{method: "head", url: ^media_proxy_url} ->
	+ %{method: "HEAD", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "<html><body>error</body></html>"}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 10:12 AM (3 m, 39 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1804426
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions