Skip to content

Commit 566d702

Browse files
authored
Merge commit from fork
1 parent 5779de1 commit 566d702

3 files changed

Lines changed: 135 additions & 21 deletions

File tree

‎lib/mint/http.ex‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,10 @@ defmodule Mint.HTTP do
226226
section](#module-logging) in the module documentation. Defaults to `false`.
227227
*Available since v1.5.0*.
228228
229+
* `:max_header_list_size` - (positive integer or `:infinity`) the maximum size, in
230+
**bytes**, of an HTTP/1 response header section or chunked trailer section. Defaults to
231+
256 KiB. This option is only used for HTTP/1 connections. *Available since 1.9.2*.
232+
229233
The following options are HTTP/1-specific and will force the connection
230234
to be an HTTP/1 connection.
231235

‎lib/mint/http1.ex‎

Lines changed: 98 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ defmodule Mint.HTTP1 do
3030
@opaque t() :: %__MODULE__{}
3131

3232
@user_agent "mint/" <> Mix.Project.config()[:version]
33+
@default_max_header_list_size 256 * 1024
3334

3435
@typedoc """
3536
An HTTP/1-specific error reason.
@@ -52,6 +53,10 @@ defmodule Mint.HTTP1 do
5253
5354
* `:invalid_header` - when headers can't be parsed correctly.
5455
56+
* `{:max_header_list_size_exceeded, size, max_size}` - when a response header section
57+
or chunked trailer section exceeds the configured size limit. `size` is the number of
58+
bytes received and `max_size` is the configured maximum.
59+
5560
* `{:invalid_header_name, name}` - when a header name is invalid.
5661
5762
* `{:invalid_header_value, name, value}` - when a header value is invalid. `name`
@@ -98,6 +103,7 @@ defmodule Mint.HTTP1 do
98103
:scheme_as_string,
99104
:case_sensitive_headers,
100105
:skip_target_validation,
106+
:max_header_list_size,
101107
requests: :queue.new(),
102108
state: :closed,
103109
buffer: "",
@@ -140,6 +146,10 @@ defmodule Mint.HTTP1 do
140146
for the status code if it is returned by the server in the status-line.
141147
This is only available for HTTP/1.1 connections. *Available since v1.8.0*.
142148
149+
* `:max_header_list_size` - (`t:pos_integer/0` or `:infinity`) the maximum number of
150+
bytes allowed in a response header section or chunked trailer section. This includes
151+
header names, values, and line delimiters. Defaults to 256 KiB. *Available since 1.9.2*.
152+
143153
"""
144154
@spec connect(Types.scheme(), Types.address(), :inet.port_number(), keyword()) ::
145155
{:ok, t()} | {:error, Types.error()}
@@ -195,6 +205,9 @@ defmodule Mint.HTTP1 do
195205
mode = Keyword.get(opts, :mode, :active)
196206
log? = Keyword.get(opts, :log, false)
197207

208+
max_header_list_size =
209+
Keyword.get(opts, :max_header_list_size, @default_max_header_list_size)
210+
198211
unless mode in [:active, :passive] do
199212
raise ArgumentError,
200213
"the :mode option must be either :active or :passive, got: #{inspect(mode)}"
@@ -205,6 +218,12 @@ defmodule Mint.HTTP1 do
205218
"the :log option must be a boolean, got: #{inspect(log?)}"
206219
end
207220

221+
unless max_header_list_size == :infinity or
222+
(is_integer(max_header_list_size) and max_header_list_size > 0) do
223+
raise ArgumentError,
224+
":max_header_list_size must be a positive integer or :infinity, got: #{inspect(max_header_list_size)}"
225+
end
226+
208227
with :ok <- Util.inet_opts(transport, socket),
209228
:ok <- if(mode == :active, do: transport.setopts(socket, active: :once), else: :ok) do
210229
conn = %__MODULE__{
@@ -218,6 +237,7 @@ defmodule Mint.HTTP1 do
218237
log: log?,
219238
case_sensitive_headers: Keyword.get(opts, :case_sensitive_headers, false),
220239
skip_target_validation: Keyword.get(opts, :skip_target_validation, false),
240+
max_header_list_size: max_header_list_size,
221241
optional_responses: validate_optional_response_values(opts)
222242
}
223243

@@ -728,21 +748,35 @@ defmodule Mint.HTTP1 do
728748
{:ok, {name, value}, rest} ->
729749
headers = [{name, value} | headers]
730750

731-
case store_header(request, name, value) do
732-
{:ok, request} -> decode_headers(conn, request, rest, responses, headers)
751+
with {:ok, request} <- add_header_bytes(conn, request, byte_size(data) - byte_size(rest)),
752+
{:ok, request} <- store_header(request, name, value) do
753+
decode_headers(conn, request, rest, responses, headers)
754+
else
733755
{:error, reason} -> {:error, conn, wrap_error(reason), responses}
734756
end
735757

736758
{:ok, :eof, rest} ->
737-
responses = [{:headers, request.ref, Enum.reverse(headers)} | responses]
738-
request = %{request | state: :body, headers_buffer: []}
739-
conn = %{conn | buffer: "", request: request}
740-
decode(:body, conn, rest, responses)
759+
case add_header_bytes(conn, request, byte_size(data) - byte_size(rest)) do
760+
{:ok, request} ->
761+
responses = [{:headers, request.ref, Enum.reverse(headers)} | responses]
762+
request = %{request | state: :body, headers_buffer: [], headers_size: 0}
763+
conn = %{conn | buffer: "", request: request}
764+
decode(:body, conn, rest, responses)
765+
766+
{:error, reason} ->
767+
{:error, conn, wrap_error(reason), responses}
768+
end
741769

742770
:more ->
743-
request = %{request | headers_buffer: headers}
744-
conn = %{conn | buffer: data, request: request}
745-
{:ok, conn, responses}
771+
case check_header_section_size(conn, request.headers_size + byte_size(data)) do
772+
:ok ->
773+
request = %{request | headers_buffer: headers}
774+
conn = %{conn | buffer: data, request: request}
775+
{:ok, conn, responses}
776+
777+
{:error, reason} ->
778+
{:error, conn, wrap_error(reason), responses}
779+
end
746780

747781
:error ->
748782
{:error, conn, wrap_error(:invalid_header), responses}
@@ -766,6 +800,7 @@ defmodule Mint.HTTP1 do
766800
version: nil,
767801
status: nil,
768802
headers_buffer: [],
803+
headers_size: 0,
769804
data_buffer: [],
770805
content_length: nil,
771806
connection: [],
@@ -885,24 +920,43 @@ defmodule Mint.HTTP1 do
885920
defp decode_trailer_headers(conn, data, responses, headers) do
886921
case Response.decode_header(data) do
887922
{:ok, {name, value}, rest} ->
888-
headers = [{name, value} | headers]
889-
decode_trailer_headers(conn, rest, responses, headers)
923+
case add_header_bytes(conn, conn.request, byte_size(data) - byte_size(rest)) do
924+
{:ok, request} ->
925+
conn = %{conn | request: request}
926+
headers = [{name, value} | headers]
927+
decode_trailer_headers(conn, rest, responses, headers)
928+
929+
{:error, reason} ->
930+
{:error, conn, wrap_error(reason), responses}
931+
end
890932

891933
{:ok, :eof, rest} ->
892-
headers = Headers.remove_unallowed_trailer(headers)
934+
case add_header_bytes(conn, conn.request, byte_size(data) - byte_size(rest)) do
935+
{:ok, _request} ->
936+
headers = Headers.remove_unallowed_trailer(headers)
893937

894-
responses = [
895-
{:done, conn.request.ref}
896-
| add_trailer_headers(headers, conn.request.ref, responses)
897-
]
938+
responses = [
939+
{:done, conn.request.ref}
940+
| add_trailer_headers(headers, conn.request.ref, responses)
941+
]
898942

899-
conn = request_done(conn)
900-
next_request(conn, rest, responses)
943+
conn = request_done(conn)
944+
next_request(conn, rest, responses)
945+
946+
{:error, reason} ->
947+
{:error, conn, wrap_error(reason), responses}
948+
end
901949

902950
:more ->
903-
request = %{conn.request | body: {:chunked, :trailer}, headers_buffer: headers}
904-
conn = %{conn | buffer: data, request: request}
905-
{:ok, conn, responses}
951+
case check_header_section_size(conn, conn.request.headers_size + byte_size(data)) do
952+
:ok ->
953+
request = %{conn.request | body: {:chunked, :trailer}, headers_buffer: headers}
954+
conn = %{conn | buffer: data, request: request}
955+
{:ok, conn, responses}
956+
957+
{:error, reason} ->
958+
{:error, conn, wrap_error(reason), responses}
959+
end
906960

907961
:error ->
908962
{:error, conn, wrap_error(:invalid_trailer_header), responses}
@@ -924,6 +978,23 @@ defmodule Mint.HTTP1 do
924978
defp add_trailer_headers(headers, request_ref, responses),
925979
do: [{:headers, request_ref, Enum.reverse(headers)} | responses]
926980

981+
defp add_header_bytes(conn, request, bytes) do
982+
size = request.headers_size + bytes
983+
984+
with :ok <- check_header_section_size(conn, size) do
985+
{:ok, %{request | headers_size: size}}
986+
end
987+
end
988+
989+
defp check_header_section_size(%{max_header_list_size: :infinity}, _size), do: :ok
990+
991+
defp check_header_section_size(%{max_header_list_size: max_size}, size)
992+
when size <= max_size,
993+
do: :ok
994+
995+
defp check_header_section_size(%{max_header_list_size: max_size}, size),
996+
do: {:error, {:max_header_list_size_exceeded, size, max_size}}
997+
927998
defp add_body(conn, data, responses) do
928999
conn = update_in(conn.request.data_buffer, &[&1 | data])
9291000
collapse_body_buffer(conn, responses)
@@ -1084,6 +1155,7 @@ defmodule Mint.HTTP1 do
10841155
version: nil,
10851156
status: nil,
10861157
headers_buffer: [],
1158+
headers_size: 0,
10871159
data_buffer: [],
10881160
content_length: nil,
10891161
connection: [],
@@ -1174,6 +1246,11 @@ defmodule Mint.HTTP1 do
11741246
"invalid header"
11751247
end
11761248

1249+
def format_error({:max_header_list_size_exceeded, size, max_size}) do
1250+
"the response header or trailer section (#{size} bytes) exceeds the maximum allowed size of " <>
1251+
"#{max_size} bytes"
1252+
end
1253+
11771254
def format_error({:invalid_request_target, target}) do
11781255
"invalid request target: #{inspect(target)}"
11791256
end

‎test/mint/http1/conn_test.exs‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,26 @@ defmodule Mint.HTTP1Test do
7373
assert {:headers, ^ref, [{"foo", "Bar"}, {"baz", "Boz"}]} = headers
7474
end
7575

76+
test "limits the size of a response header section", %{port: port} do
77+
assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, max_header_list_size: 10)
78+
{:ok, conn, _ref} = HTTP1.request(conn, "GET", "/", [], nil)
79+
80+
assert {:ok, conn, [_status]} = HTTP1.stream(conn, {:tcp, conn.socket, "HTTP/1.1 200 OK\r\n"})
81+
assert {:ok, conn, []} = HTTP1.stream(conn, {:tcp, conn.socket, "foo: bar\r\n"})
82+
83+
assert {:error, _conn, %HTTPError{reason: {:max_header_list_size_exceeded, 11, 10}}, []} =
84+
HTTP1.stream(conn, {:tcp, conn.socket, "x"})
85+
end
86+
87+
test "limits an incomplete response header section", %{port: port} do
88+
assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, max_header_list_size: 9)
89+
{:ok, conn, _ref} = HTTP1.request(conn, "GET", "/", [], nil)
90+
assert {:ok, conn, [_status]} = HTTP1.stream(conn, {:tcp, conn.socket, "HTTP/1.1 200 OK\r\n"})
91+
92+
assert {:error, _conn, %HTTPError{reason: {:max_header_list_size_exceeded, 10, 9}}, []} =
93+
HTTP1.stream(conn, {:tcp, conn.socket, "foo: bar\r\n"})
94+
end
95+
7696
test "status and headers", %{conn: conn} do
7797
{:ok, conn, ref} = HTTP1.request(conn, "GET", "/", [], nil)
7898

@@ -354,6 +374,19 @@ defmodule Mint.HTTP1Test do
354374
assert conn.buffer == "XXX"
355375
end
356376

377+
test "limits the size of a chunked trailer section", %{port: port} do
378+
assert {:ok, conn} = HTTP1.connect(:http, "localhost", port, max_header_list_size: 30)
379+
{:ok, conn, _ref} = HTTP1.request(conn, "GET", "/", [], nil)
380+
381+
response =
382+
"HTTP/1.1 200 OK\r\ntransfer-encoding: chunked\r\n\r\n" <>
383+
"1\r\nX\r\n0\r\nfoo: " <> String.duplicate("x", 25) <> "\r\n"
384+
385+
assert {:error, _conn, %HTTPError{reason: {:max_header_list_size_exceeded, 32, 30}},
386+
[{:data, _, "X"}, {:headers, _, _}, {:status, _, 200}]} =
387+
HTTP1.stream(conn, {:tcp, conn.socket, response})
388+
end
389+
357390
test "100 Continue informational response followed by final response", %{conn: conn} do
358391
{:ok, conn, ref} = HTTP1.request(conn, "POST", "/", [{"expect", "100-continue"}], "hello")
359392

0 commit comments

Comments
 (0)