File 0128-ssl-Handle-SNI-earlier.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 0128-ssl-Handle-SNI-earlier.patch of Package erlang (Revision 57cf7c87cb80e2aaaf3f20327bf57529)

Currently displaying revision 57cf7c87cb80e2aaaf3f20327bf57529 , Show latest

From d9aa9efe91f252a1476f40c33c45c39a28cad821 Mon Sep 17 00:00:00 2001
From: Ingela Anderton Andin <ingela@erlang.org>
Date: Fri, 10 Dec 2021 08:08:28 +0100
Subject: [PATCH 2/2] ssl: Handle SNI earlier

The SNI (Server Name Indication) is a special hello extension
that needs to be processed first as it can change the servers
options available for the connection.

Closes #5341
---
 lib/ssl/src/dtls_connection.erl     |  4 +-
 lib/ssl/src/dtls_gen_connection.erl |  6 +--
 lib/ssl/src/dtls_handshake.erl      |  2 +-
 lib/ssl/src/ssl_gen_statem.erl      | 51 +++++++++++++++++++++-----
 lib/ssl/src/ssl_handshake.erl       | 27 +++++++++++---
 lib/ssl/src/ssl_internal.hrl        |  5 +++
 lib/ssl/src/tls_connection.erl      | 37 +++++++++----------
 lib/ssl/src/tls_connection_1_3.erl  |  2 +-
 lib/ssl/src/tls_gen_connection.erl  | 19 ++++++----
 lib/ssl/src/tls_handshake.erl       |  8 ++--
 lib/ssl/test/ssl_api_SUITE.erl      | 57 ++++++++++++++++++++++++++++-
 11 files changed, 164 insertions(+), 54 deletions(-)

diff --git a/lib/ssl/src/dtls_connection.erl b/lib/ssl/src/dtls_connection.erl
index 42d77bd840..4a45755346 100644
--- a/lib/ssl/src/dtls_connection.erl
+++ b/lib/ssl/src/dtls_connection.erl
@@ -559,7 +559,7 @@ connection(internal, new_connection, #state{ssl_options=SSLOptions,
                                             connection_states = OldCs} = State) ->
     case maps:get(previous_cs, OldCs, undefined) of
         undefined ->
-            #{beast_mitigation := BeastMitigation} = SSLOptions,
+            BeastMitigation = maps:get(beast_mitigation, SSLOptions, disabled),
             ConnectionStates0 = dtls_record:init_connection_states(server, BeastMitigation),
             ConnectionStates = ConnectionStates0#{previous_cs => OldCs},
             {next_state, hello, State#state{handshake_env = HsEnv#handshake_env{renegotiation = {false, first}},
@@ -627,7 +627,7 @@ format_status(Type, Data) ->
 initial_state(Role, Host, Port, Socket,
               {#{client_renegotiation := ClientRenegotiation} = SSLOptions, SocketOptions, Trackers}, User,
 	      {CbModule, DataTag, CloseTag, ErrorTag, PassiveTag}) ->
-    #{beast_mitigation := BeastMitigation} = SSLOptions,
+    BeastMitigation = maps:get(beast_mitigation, SSLOptions, disabled),
     ConnectionStates = dtls_record:init_connection_states(Role, BeastMitigation),
     #{session_cb := SessionCacheCb} = ssl_config:pre_1_3_session_opts(Role),
     InternalActiveN = ssl_config:get_internal_active_n(),
diff --git a/lib/ssl/src/dtls_gen_connection.erl b/lib/ssl/src/dtls_gen_connection.erl
index 56426aca7a..1a16007010 100644
--- a/lib/ssl/src/dtls_gen_connection.erl
+++ b/lib/ssl/src/dtls_gen_connection.erl
@@ -66,7 +66,7 @@
 %% Alert and close handling
 -export([send_alert/2,
          send_alert_in_connection/2,
-         close/5,
+         close/4,
          protocol_name/0]).
 
 
@@ -464,10 +464,10 @@ send_alert_in_connection(Alert, State) ->
     _ = send_alert(Alert, State),
     ok.
 
-close(downgrade, _,_,_,_) ->
+close(downgrade, _,_,_) ->
     ok;
 %% Other
-close(_, Socket, Transport, _,_) ->
+close(_, Socket, Transport, _) ->
     dtls_socket:close(Transport,Socket).
 
 protocol_name() ->
diff --git a/lib/ssl/src/dtls_handshake.erl b/lib/ssl/src/dtls_handshake.erl
index bc2051a18b..2d0f37e0fe 100644
--- a/lib/ssl/src/dtls_handshake.erl
+++ b/lib/ssl/src/dtls_handshake.erl
@@ -187,7 +187,7 @@ handle_client_hello(Version,
 	    TLSVersion = dtls_v1:corresponding_tls_version(Version),
 	    AvailableHashSigns = ssl_handshake:available_signature_algs(
 				   ClientHashSigns, SupportedHashSigns, OwnCert,TLSVersion),
-	    ECCCurve = ssl_handshake:select_curve(Curves, SupportedECCs, ECCOrder),
+	    ECCCurve = ssl_handshake:select_curve(Curves, SupportedECCs, TLSVersion, ECCOrder),
 	    {Type, #session{cipher_suite = CipherSuite} = Session1}
 		= ssl_handshake:select_session(SugesstedId, CipherSuites, 
                                                AvailableHashSigns, Compressions,
diff --git a/lib/ssl/src/ssl_gen_statem.erl b/lib/ssl/src/ssl_gen_statem.erl
index ddd529d032..292e490e8d 100644
--- a/lib/ssl/src/ssl_gen_statem.erl
+++ b/lib/ssl/src/ssl_gen_statem.erl
@@ -1101,7 +1101,7 @@ terminate({shutdown, transport_closed} = Reason,
                                                       socket = Socket,
                                                       transport_cb = Transport}} = State) ->
     handle_trusted_certs_db(State),
-    Connection:close(Reason, Socket, Transport, undefined, undefined);
+    Connection:close(Reason, Socket, Transport, undefined);
 terminate({shutdown, own_alert}, _StateName, #state{
 						static_env = #static_env{protocol_cb = Connection,
                                                                          socket = Socket,
@@ -1109,28 +1109,28 @@ terminate({shutdown, own_alert}, _StateName, #state{
     handle_trusted_certs_db(State),
     case application:get_env(ssl, alert_timeout) of
 	{ok, Timeout} when is_integer(Timeout) ->
-	    Connection:close({timeout, Timeout}, Socket, Transport, undefined, undefined);
+	    Connection:close({timeout, Timeout}, Socket, Transport, undefined);
 	_ ->
-	    Connection:close({timeout, ?DEFAULT_TIMEOUT}, Socket, Transport, undefined, undefined)
+	    Connection:close({timeout, ?DEFAULT_TIMEOUT}, Socket, Transport, undefined)
     end;
 terminate(Reason, connection, #state{static_env = #static_env{
                                                      protocol_cb = Connection,
                                                      transport_cb = Transport,
                                                      socket = Socket},
-                                     connection_states = ConnectionStates,
-                                     ssl_options = #{padding_check := Check}
+                                     connection_states = ConnectionStates
                                     } = State) ->
+
     handle_trusted_certs_db(State),
     Alert = terminate_alert(Reason),
     %% Send the termination ALERT if possible
     catch (ok = Connection:send_alert_in_connection(Alert, State)),
-    Connection:close({timeout, ?DEFAULT_TIMEOUT}, Socket, Transport, ConnectionStates, Check);
+    Connection:close({timeout, ?DEFAULT_TIMEOUT}, Socket, Transport, ConnectionStates);
 terminate(Reason, _StateName, #state{static_env = #static_env{transport_cb = Transport,
                                                               protocol_cb = Connection,
                                                               socket = Socket}
 				    } = State) ->
     handle_trusted_certs_db(State),
-    Connection:close(Reason, Socket, Transport, undefined, undefined).
+    Connection:close(Reason, Socket, Transport, undefined).
 
 %%====================================================================
 %% Log handling
@@ -1272,7 +1272,7 @@ handle_sni_hostname(Hostname,
 
 update_ssl_options_from_sni(#{sni_fun := SNIFun,
                               sni_hosts := SNIHosts} = OrigSSLOptions, SNIHostname) ->
-    SSLOption =
+    SSLOptions =
 	case SNIFun of
 	    undefined ->
 		proplists:get_value(SNIHostname,
@@ -1280,11 +1280,42 @@ update_ssl_options_from_sni(#{sni_fun := SNIFun,
 	    SNIFun ->
 		SNIFun(SNIHostname)
 	end,
-    case SSLOption of
+    case SSLOptions of
         undefined ->
             undefined;
         _ ->
-            ssl:handle_options(SSLOption, server, OrigSSLOptions)
+            VersionsOpt = proplists:get_value(versions, SSLOptions, []),
+            FallBackOptions = filter_for_versions(VersionsOpt, OrigSSLOptions),
+            ssl:handle_options(SSLOptions, server, FallBackOptions)
+    end.
+
+filter_for_versions([], OrigSSLOptions) ->
+    OrigSSLOptions;
+filter_for_versions(['tlsv1.3'], OrigSSLOptions) ->
+    Opts = ?'PRE_TLS-1_3_ONLY_OPTIONS' ++ ?'TLS-1_0_ONLY_OPTIONS',
+    maps:without(Opts, OrigSSLOptions);
+filter_for_versions(['tlsv1.3', 'tlsv1.2'| Rest], OrigSSLOptions) ->
+    maybe_exclude_tlsv1(Rest, OrigSSLOptions);
+filter_for_versions(['tlsv1.2'], OrigSSLOptions) ->
+    Opts = ?'TLS-1_3_ONLY_OPTIONS' ++ ?'TLS-1_0_ONLY_OPTIONS',
+    maps:without(Opts, OrigSSLOptions);
+filter_for_versions(['tlsv1.2' | Rest], OrigSSLOptions) ->
+    Opts = ?'TLS-1_3_ONLY_OPTIONS',
+    maybe_exclude_tlsv1(Rest, maps:without(Opts, OrigSSLOptions));
+filter_for_versions(['tlsv1.1'], OrigSSLOptions) ->
+    Opts = ?'TLS-1_3_ONLY_OPTIONS' ++ ?'FROM_TLS-1_2_ONLY_OPTIONS'++ ?'TLS-1_0_ONLY_OPTIONS',
+    maps:without(Opts, OrigSSLOptions);
+filter_for_versions(['tlsv1.1'| Rest], OrigSSLOptions) ->
+    Opts = ?'TLS-1_3_ONLY_OPTIONS' ++ ?'FROM_TLS-1_2_ONLY_OPTIONS',
+    maybe_exclude_tlsv1(Rest, maps:without(Opts, OrigSSLOptions)).
+
+maybe_exclude_tlsv1(Versions, Options) ->
+    case lists:member('tlsv1', Versions) of
+        false ->
+            Opts = ?'TLS-1_0_ONLY_OPTIONS',
+            maps:without(Opts, Options);
+        true ->
+            Options
     end.
 
 set_sni_guided_cert_selection(#state{handshake_env = HsEnv0} = State, Bool) ->
diff --git a/lib/ssl/src/ssl_handshake.erl b/lib/ssl/src/ssl_handshake.erl
index 2b0df83576..6ee0aa8f7b 100644
--- a/lib/ssl/src/ssl_handshake.erl
+++ b/lib/ssl/src/ssl_handshake.erl
@@ -74,7 +74,7 @@
 %% Extensions handling
 -export([client_hello_extensions/8,
 	 handle_client_hello_extensions/10, %% Returns server hello extensions
-	 handle_server_hello_extensions/10, select_curve/2, select_curve/3,
+	 handle_server_hello_extensions/10, select_curve/3, select_curve/4,
          select_hashsign/4, select_hashsign/5,
 	 select_hashsign_algs/3, empty_extensions/2, add_server_share/3,
 	 add_alpn/2, add_selected_version/1, decode_alpn/1, max_frag_enum/1
@@ -1492,11 +1492,12 @@ handle_server_hello_extensions(RecordCB, Random, CipherSuite, Compression,
             end
     end.
 
-select_curve(Client, Server) ->
-    select_curve(Client, Server, false).
+select_curve(Client, Server, Version) ->
+    select_curve(Client, Server, Version, false).
 
 select_curve(#elliptic_curves{elliptic_curve_list = ClientCurves},
 	     #elliptic_curves{elliptic_curve_list = ServerCurves},
+             _,
 	     ServerOrder) ->
     case ServerOrder of
         false ->
@@ -1504,10 +1505,26 @@ select_curve(#elliptic_curves{elliptic_curve_list = ClientCurves},
         true ->
             select_shared_curve(ServerCurves, ClientCurves)
     end;
-select_curve(undefined, _, _) ->
+select_curve(undefined, _, {_,Minor}, _) ->
     %% Client did not send ECC extension use default curve if 
     %% ECC cipher is negotiated
-    {namedCurve, ?secp256r1}.
+    case tls_v1:ecc_curves(Minor, [secp256r1]) of
+        [] ->
+            %% Curve not supported by cryptolib ECC algorithms can not be negotiated
+            no_curve;
+        [CurveOid] ->
+            {namedCurve, CurveOid}
+    end;
+select_curve({supported_groups, Groups}, Server,{_, Minor} = Version, HonorServerOrder) ->
+    %% TLS-1.3 hello but lesser version choosen
+    TLSCommonCurves = [secp256r1,secp384r1,secp521r1],
+    Curves = [tls_v1:enum_to_oid(tls_v1:group_to_enum(Name)) || Name <- Groups, lists:member(Name, TLSCommonCurves)],
+    case tls_v1:ecc_curves(Minor, Curves) of
+        [] ->
+            select_curve(undefined, Server, Version, HonorServerOrder);
+        [_|_] = ClientCurves ->
+            select_curve(#elliptic_curves{elliptic_curve_list = ClientCurves}, Server, Version, HonorServerOrder)
+    end.
 
 %%--------------------------------------------------------------------
 -spec select_hashsign(#hash_sign_algos{} | undefined,  undefined | binary(), 
diff --git a/lib/ssl/src/ssl_internal.hrl b/lib/ssl/src/ssl_internal.hrl
index f4575a01a6..0c1a74de0d 100644
--- a/lib/ssl/src/ssl_internal.hrl
+++ b/lib/ssl/src/ssl_internal.hrl
@@ -216,6 +216,11 @@
           versions                   => {[], [protocol]}
          }).
 
+-define('TLS-1_3_ONLY_OPTIONS', [anti_replay, cookie, early_data, key_update_at, middlebox_comp_mode, session_tickets, supported_groups, use_ticket]).
+-define('FROM_TLS-1_2_ONLY_OPTIONS', [signature_algs, signature_algs_cert]).
+-define('PRE_TLS-1_3_ONLY_OPTIONS', [client_renegotiation, secure_renegotiate]).
+-define('TLS-1_0_ONLY_OPTIONS', [padding_check, beast_mitigation]).
+
 -record(socket_options,
 	{
 	  mode   = list, 
diff --git a/lib/ssl/src/tls_connection.erl b/lib/ssl/src/tls_connection.erl
index 42db225c81..69cefc727d 100644
--- a/lib/ssl/src/tls_connection.erl
+++ b/lib/ssl/src/tls_connection.erl
@@ -222,20 +222,20 @@ hello(internal, #server_hello{extensions = Extensions} = Hello,
      State#state{start_or_recv_from = undefined,
                  handshake_env = HsEnv#handshake_env{
                                    hello = Hello}}, [{reply, From, {ok, Extensions}}]};
-hello(internal, #client_hello{client_version = ClientVersion} = Hello, #state{ssl_options = SslOpts0,
-                                                                              connection_env = CEnv} = State0) ->
-    case choose_tls_fsm(SslOpts0, Hello) of
-        tls_1_3_fsm ->
-            %% Continue in TLS 1.3 'start' state
-            {next_state, start, State0, [{change_callback_module, tls_connection_1_3}, {next_event, internal, Hello}]};
-        tls_1_0_to_1_2_fsm ->
-            try handle_client_hello(Hello, State0) of
-                {ServerHelloExt, Type, State} ->
-                    {next_state, hello, State, [{next_event, internal, {common_client_hello, Type, ServerHelloExt}}]}
-            catch throw:#alert{} = Alert ->
-                    State = State0#state{connection_env = CEnv#connection_env{negotiated_version = ClientVersion}},
-                    ssl_gen_statem:handle_own_alert(Alert, hello, State)
-            end
+hello(internal, #client_hello{client_version = ClientVersion} = Hello, #state{connection_env = CEnv} = State0) ->
+    try
+        #state{ssl_options = SslOpts} = State1 = tls_dtls_connection:handle_sni_extension(State0, Hello),
+        case choose_tls_fsm(SslOpts, Hello) of
+            tls_1_3_fsm ->
+                %% Continue in TLS 1.3 'start' state
+                {next_state, start, State1, [{change_callback_module, tls_connection_1_3}, {next_event, internal, Hello}]};
+            tls_1_0_to_1_2_fsm ->
+                {ServerHelloExt, Type, State} = handle_client_hello(Hello, State1),
+                {next_state, hello, State, [{next_event, internal, {common_client_hello, Type, ServerHelloExt}}]}
+        end
+    catch  throw:#alert{} = Alert ->
+            AlertState = State0#state{connection_env = CEnv#connection_env{negotiated_version = ClientVersion}},
+            ssl_gen_statem:handle_own_alert(Alert, hello, AlertState)
     end;
 hello(internal, #server_hello{} = Hello,
       #state{connection_states = ConnectionStates0,
@@ -434,7 +434,7 @@ terminate({shutdown, {sender_died, Reason}}, _StateName,
                                           transport_cb = Transport}} 
           = State) ->
     ssl_gen_statem:handle_trusted_certs_db(State),
-    tls_gen_connection:close(Reason, Socket, Transport, undefined, undefined);
+    tls_gen_connection:close(Reason, Socket, Transport, undefined);
 terminate(Reason, StateName, State) ->
     ssl_gen_statem:terminate(Reason, StateName, State).
 
@@ -449,11 +449,11 @@ code_change(_OldVsn, StateName, State, _) ->
 %%--------------------------------------------------------------------
 initial_state(Role, Sender, Host, Port, Socket, {SSLOptions, SocketOptions, Trackers}, User,
 	      {CbModule, DataTag, CloseTag, ErrorTag, PassiveTag}) ->
-    #{beast_mitigation := BeastMitigation,
-      erl_dist := IsErlDist,
+    #{erl_dist := IsErlDist,
       %% Use highest supported version for client/server random nonce generation
       versions := [Version|_],
       client_renegotiation := ClientRenegotiation} = SSLOptions,
+    BeastMitigation = maps:get(beast_mitigation, SSLOptions, disabled),
     ConnectionStates = tls_record:init_connection_states(Role,
                                                          Version,
                                                          BeastMitigation),
@@ -495,8 +495,7 @@ initial_state(Role, Sender, Host, Port, Socket, {SSLOptions, SocketOptions, Trac
                             }
       }.
 
-handle_client_hello(#client_hello{client_version = ClientVersion} = Hello, State0) ->
-    State = tls_dtls_connection:handle_sni_extension(State0, Hello),
+handle_client_hello(#client_hello{client_version = ClientVersion} = Hello, State) ->
     #state{connection_states = ConnectionStates0,
            static_env = #static_env{trackers = Trackers},
            handshake_env = #handshake_env{
diff --git a/lib/ssl/src/tls_connection_1_3.erl b/lib/ssl/src/tls_connection_1_3.erl
index 23d7f3a753..19c9a05a2f 100644
--- a/lib/ssl/src/tls_connection_1_3.erl
+++ b/lib/ssl/src/tls_connection_1_3.erl
@@ -202,7 +202,7 @@ terminate({shutdown, {sender_died, Reason}}, _StateName,
                                           transport_cb = Transport}}
           = State) ->
     ssl_gen_statem:handle_trusted_certs_db(State),
-    tls_gen_connection:close(Reason, Socket, Transport, undefined, undefined);
+    tls_gen_connection:close(Reason, Socket, Transport, undefined);
 terminate(Reason, StateName, State) ->
     ssl_gen_statem:terminate(Reason, StateName, State).
 
diff --git a/lib/ssl/src/tls_gen_connection.erl b/lib/ssl/src/tls_gen_connection.erl
index 1d2bc122ef..f1aca8ca22 100644
--- a/lib/ssl/src/tls_gen_connection.erl
+++ b/lib/ssl/src/tls_gen_connection.erl
@@ -67,7 +67,7 @@
 -export([send_alert/2,
          send_alert_in_connection/2,
          send_sync_alert/2,
-         close/5,
+         close/4,
          protocol_name/0]).
 
 -define(DIST_CNTRL_SPAWN_OPTS, [{priority, max}]).
@@ -480,16 +480,16 @@ send_sync_alert(
     end.
 
 %% User closes or recursive call!
-close({close, Timeout}, Socket, Transport = gen_tcp, _,_) ->
+close({close, Timeout}, Socket, Transport = gen_tcp, _) ->
     tls_socket:setopts(Transport, Socket, [{active, false}]),
     Transport:shutdown(Socket, write),
     _ = Transport:recv(Socket, 0, Timeout),
     ok;
 %% Peer closed socket
-close({shutdown, transport_closed}, Socket, Transport = gen_tcp, ConnectionStates, Check) ->
-    close({close, 0}, Socket, Transport, ConnectionStates, Check);
+close({shutdown, transport_closed}, Socket, Transport = gen_tcp, ConnectionStates) ->
+    close({close, 0}, Socket, Transport, ConnectionStates);
 %% We generate fatal alert
-close({shutdown, own_alert}, Socket, Transport = gen_tcp, ConnectionStates, Check) ->
+close({shutdown, own_alert}, Socket, Transport = gen_tcp, ConnectionStates) ->
     %% Standard trick to try to make sure all
     %% data sent to the tcp port is really delivered to the
     %% peer application before tcp port is closed so that the peer will
@@ -498,9 +498,9 @@ close({shutdown, own_alert}, Socket, Transport = gen_tcp, ConnectionStates, Chec
     %% e.g. we do not want to hang if something goes wrong
     %% with the network but we want to maximise the odds that
     %% peer application gets all data sent on the tcp connection.
-    close({close, ?DEFAULT_TIMEOUT}, Socket, Transport, ConnectionStates, Check);
+    close({close, ?DEFAULT_TIMEOUT}, Socket, Transport, ConnectionStates);
 %% Other
-close(_, Socket, Transport, _,_) -> 
+close(_, Socket, Transport, _) ->
     tls_socket:close(Transport, Socket).
 protocol_name() ->
     "TLS".
@@ -581,7 +581,10 @@ next_record(_, #state{handshake_env =
 next_record(_, #state{protocol_buffers =
                           #protocol_buffers{tls_cipher_texts = [_|_] = CipherTexts},
                       connection_states = ConnectionStates,
-                      ssl_options = #{padding_check := Check}} = State) ->
+                      ssl_options = SslOpts} = State) ->
+    %% Do not match this option as it is relevant for TLS-1.0 only
+    %% and will not be present otherwise that is we regard it to always be true
+    Check = maps:get(padding_check, SslOpts, true),
     next_record(State, CipherTexts, ConnectionStates, Check);
 next_record(connection, #state{protocol_buffers = #protocol_buffers{tls_cipher_texts = []},
                                protocol_specific = #{active_n_toggle := true}
diff --git a/lib/ssl/src/tls_handshake.erl b/lib/ssl/src/tls_handshake.erl
index 2c2315c15f..a6375d28e3 100644
--- a/lib/ssl/src/tls_handshake.erl
+++ b/lib/ssl/src/tls_handshake.erl
@@ -322,20 +322,20 @@ handle_client_hello(Version,
                                   random = Random,
                                   extensions = HelloExt},
 		    #{versions := Versions,
-                      signature_algs := SupportedHashSigns,
                       eccs := SupportedECCs,
                       honor_ecc_order := ECCOrder} = SslOpts,
 		    {SessIdTracker, Session0, ConnectionStates0, OwnCerts, _},
                     Renegotiation) ->
-    OwnCert = ssl_handshake:select_own_cert(OwnCerts),
     case tls_record:is_acceptable_version(Version, Versions) of
 	true ->
+            OwnCert = ssl_handshake:select_own_cert(OwnCerts),
+            SupportedHashSigns = maps:get(signature_algs, SslOpts, undefined),
             Curves = maps:get(elliptic_curves, HelloExt, undefined),
             ClientHashSigns = maps:get(signature_algs, HelloExt, undefined),
             ClientSignatureSchemes = maps:get(signature_algs_cert, HelloExt, undefined),
 	    AvailableHashSigns = ssl_handshake:available_signature_algs(
 				   ClientHashSigns, SupportedHashSigns, OwnCert, Version),
-	    ECCCurve = ssl_handshake:select_curve(Curves, SupportedECCs, ECCOrder),
+	    ECCCurve = ssl_handshake:select_curve(Curves, SupportedECCs, Version, ECCOrder),
 	    {Type, #session{cipher_suite = CipherSuite} = Session1}
 		= ssl_handshake:select_session(SugesstedId, CipherSuites,
                                                AvailableHashSigns, Compressions,
@@ -346,7 +346,7 @@ handle_client_hello(Version,
                     throw(?ALERT_REC(?FATAL, ?INSUFFICIENT_SECURITY, no_suitable_ciphers));
 		_ ->
 		    #{key_exchange := KeyExAlg} = ssl_cipher_format:suite_bin_to_map(CipherSuite),
-		    case ssl_handshake:select_hashsign({ClientHashSigns, ClientSignatureSchemes},
+                    case ssl_handshake:select_hashsign({ClientHashSigns, ClientSignatureSchemes},
                                                        OwnCert, KeyExAlg,
                                                        SupportedHashSigns,
                                                        Version) of
diff --git a/lib/ssl/test/ssl_api_SUITE.erl b/lib/ssl/test/ssl_api_SUITE.erl
index 08b1da51af..fc1a5ac7d0 100644
--- a/lib/ssl/test/ssl_api_SUITE.erl
+++ b/lib/ssl/test/ssl_api_SUITE.erl
@@ -58,6 +58,8 @@
          keylog_connection_info/1,
          versions/0,
          versions/1,
+         versions_option_based_on_sni/0,
+         versions_option_based_on_sni/1,
          active_n/0,
          active_n/1,
          dh_params/0,
@@ -200,6 +202,7 @@
          ssl_getstat/1,
 	 log/2,
          get_connection_information/3,
+         protocol_version_check/2,
          %%TODO Keep?
          run_error_server/1,
          run_error_server_close/1,
@@ -249,7 +252,8 @@ groups() ->
 since_1_2() ->
     [
      conf_signature_algs,
-     no_common_signature_algs
+     no_common_signature_algs,
+     versions_option_based_on_sni
     ].
 
 pre_1_3() ->
@@ -988,6 +992,44 @@ versions(Config) when is_list(Config) ->
     [_|_] = Versions = ssl:versions(),
     ct:log("~p~n", [Versions]).
 
+%%--------------------------------------------------------------------
+
+versions_option_based_on_sni() ->
+    [{doc,"Test that SNI versions option is selected over defalt versions"}].
+
+versions_option_based_on_sni(Config) when is_list(Config) ->
+    ClientOpts = ssl_test_lib:ssl_options(client_rsa_opts, Config),
+    ServerOpts = ssl_test_lib:ssl_options(server_rsa_opts, Config),
+    TestVersion = ssl_test_lib:protocol_version(Config),
+    {Version, Versions} = test_versions_for_option_based_on_sni(TestVersion),
+    {ClientNode, ServerNode, Hostname} = ssl_test_lib:run_where(Config),
+
+    SNI = net_adm:localhost(),
+    Fun = fun(ServerName) ->
+              case ServerName of
+                  SNI ->
+                      [{versions, [Version]} | ServerOpts];
+                  _ ->
+                      ServerOpts
+              end
+          end,
+
+    Server = ssl_test_lib:start_server([{node, ServerNode}, {port, 0},
+					{from, self()},
+					{mfa, {?MODULE, protocol_version_check, [Version]}},
+					{options, [{sni_fun, Fun},
+                                                   {versions, Versions} | ServerOpts]}]),
+    Port = ssl_test_lib:inet_port(Server),
+    Client = ssl_test_lib:start_client([{node, ClientNode}, {port, Port},
+					{host, Hostname},
+					{from, self()},
+					{mfa, {ssl_test_lib, no_result, []}},
+					{options, [{server_name_indication, SNI}, {versions, Versions} | ClientOpts]}]),
+
+    ssl_test_lib:check_result(Server, ok),
+    ssl_test_lib:close(Server),
+    ssl_test_lib:close(Client).
+
 %%--------------------------------------------------------------------
 %% Test case adapted from gen_tcp_misc_SUITE.
 active_n() ->
@@ -3046,6 +3088,19 @@ ssl_getstat(Socket) ->
             ok
     end.
 
+test_versions_for_option_based_on_sni('tlsv1.3') ->
+    {'tlsv1.2', ['tlsv1.3', 'tlsv1.2']};
+test_versions_for_option_based_on_sni('tlsv1.2') ->
+    {'tlsv1.1', ['tlsv1.2', 'tlsv1.1']}.
+
+protocol_version_check(Socket, Version) ->
+    case ssl:connection_information(Socket, [protocol]) of
+        {ok, [{protocol, Version}]} ->
+            ok;
+        Other ->
+            ct:fail({expected, Version, got, Other})
+    end.
+
 log(#{msg:={report,_Report}},#{config:=Pid}) ->
     Pid ! warning_generated;
 log(_,_) ->
-- 
2.31.1

Places

File 0128-ssl-Handle-SNI-earlier.patch of Package erlang (Revision 57cf7c87cb80e2aaaf3f20327bf57529)

Places