@@ -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
0 commit comments