ssl: Ticket and session server recovery

As TLS-1.3 ticket usages is an optional feature the server handling
it will be started on demand and is local to to the TLS server
that it was configured for. Due to this restart to recover from
intermediate bugs via supervisor tree are unpractical and it
should instead be a temporary process under its simple_one_for_one
supervisor and restart handled on demand.

Note that if it would crash so restart is needed old ticket
are useless as the server state is lost.

It is similar for TLS-1.2 session servers

Author: IngelaAndin

lib/ssl/src/dtls_packet_demux.erl

@@ -117,7 +117,7 @@ getstat(PacketSocket, Opts) ->
 init([Owner, Port0, TransportInfo, EmOpts, DTLSOptions, Socket]) ->
     InternalActiveN = get_internal_active_n(),
     erlang:monitor(process, Owner),
-    {ok, SessionIdHandle} = session_id_tracker(Socket, DTLSOptions),
+    {ok, SessionIdHandle} = session_id_tracker(Socket),
     proc_lib:set_label({dtls_server_packet_demultiplexer, Port0}),
     {ok, #state{active_n = InternalActiveN,
                 port = Port0,
@@ -139,11 +139,11 @@ handle_call({accept, Accepter}, From, #state{active_n = N,
 					     listener = Socket} = State0) ->
     next_datagram(Socket, N),
     State = State0#state{first = false,
-			 accepters = queue:in({Accepter, From}, Accepters)}, 		 
+			 accepters = queue:in({Accepter, From}, Accepters)},
     {noreply, State};
 
 handle_call({accept, Accepter}, From, #state{accepters = Accepters} = State0) ->
-    State = State0#state{accepters = queue:in({Accepter, From}, Accepters)}, 		 
+    State = State0#state{accepters = queue:in({Accepter, From}, Accepters)},
     {noreply, State};
 handle_call(sockname, _, #state{listener = Socket} = State) ->
     Reply = inet:sockname(Socket),
@@ -348,8 +348,16 @@ setup_new_connection(User, From, Client, Msg, #state{dtls_processes = Processes,
 						     dtls_options = DTLSOpts,
 						     port = Port,
 						     listener = Socket,
-                                                     session_id_tracker = Tracker,
+                                                     session_id_tracker = Tracker0,
 						     emulated_options = EmOpts} = State) ->
+    Tracker = case erlang:is_process_alive(Tracker0) of
+                  true ->
+                      Tracker0;
+                  false ->
+                      {ok, Tracker1} = session_id_tracker(Socket),
+                      Tracker1
+              end,
+
     ConnArgs = [server, "localhost", Port, {self(), {Client, Socket}},
 		{DTLSOpts,
                  emulated_opts_list(EmOpts, [mode, active], []),
@@ -360,11 +368,12 @@ setup_new_connection(User, From, Client, Msg, #state{dtls_processes = Processes,
 	    erlang:monitor(process, Pid),
 	    gen_server:reply(From, {ok, Pid}),
 	    Pid ! Msg,
-	    State#state{dtls_msq_queues = kv_insert(Client, {Pid, queue:new()}, MsgQueues),
+	    State#state{session_id_tracker = Tracker,
+                        dtls_msq_queues = kv_insert(Client, {Pid, queue:new()}, MsgQueues),
 			dtls_processes = kv_insert(Pid, Client, Processes)};
 	{error, Reason} ->
 	    gen_server:reply(From, {error, Reason}),
-	    State
+	    State#state{session_id_tracker = Tracker}
     end.
 
 kv_update(Key, Value, Store) ->
@@ -411,7 +420,7 @@ get_socket_opts(Socket, SocketOpts, Cb) ->
 do_set_emulated_opts([], Opts) ->
     Opts;
 do_set_emulated_opts([{mode, Value} | Rest], Opts) ->
-    do_set_emulated_opts(Rest,  Opts#socket_options{mode = Value}); 
+    do_set_emulated_opts(Rest,  Opts#socket_options{mode = Value});
 do_set_emulated_opts([{active, N0} | Rest], Opts=#socket_options{active = Active}) when is_integer(N0) ->
     N = tls_socket:update_active_n(N0, Active),
     do_set_emulated_opts(Rest,  Opts#socket_options{active = N});
@@ -421,14 +430,14 @@ do_set_emulated_opts([{active, Value} | Rest], Opts) ->
 emulated_opts_list(_,[], Acc) ->
     Acc;
 emulated_opts_list( Opts, [mode | Rest], Acc) ->
-    emulated_opts_list(Opts, Rest, [{mode, Opts#socket_options.mode} | Acc]); 
+    emulated_opts_list(Opts, Rest, [{mode, Opts#socket_options.mode} | Acc]);
 emulated_opts_list(Opts, [active | Rest], Acc) ->
     emulated_opts_list(Opts, Rest, [{active, Opts#socket_options.active} | Acc]).
 
 %% Regardless of the option reuse_sessions we need the session_id_tracker
 %% to generate session ids, but no sessions will be stored unless
 %% reuse_sessions = true.
-session_id_tracker(Listener,_) ->
+session_id_tracker(Listener) ->
     dtls_server_session_cache_sup:start_child(Listener).
 
 get_internal_active_n() ->

lib/ssl/src/ssl.erl

@@ -2504,9 +2504,11 @@ handshake(#sslsocket{connection_cb = tls_gen_connection,
   when is_list(SslOpts), is_list(Trackers), ?IS_TIMEOUT(Timeout) ->
     try
         Tracker = proplists:get_value(option_tracker, Trackers),
-	{ok, EmOpts, _} = tls_socket:get_all_opts(Tracker),
-	ssl_gen_statem:handshake(Socket, {SslOpts,
-					  tls_socket:emulated_socket_options(EmOpts, #socket_options{})}, Timeout)
+        {ok, EmOpts} = tls_socket:get_emulated_opts(Tracker),
+	ssl_gen_statem:handshake(Socket,
+                                 {SslOpts,
+                                  tls_socket:emulated_socket_options(EmOpts,
+                                                                     #socket_options{})}, Timeout)
     catch
 	Error = {error, _Reason} -> Error
     end;

lib/ssl/src/ssl_config.erl

@@ -126,7 +126,8 @@ get_ticket_store_size() ->
     application_int(server_session_ticket_store_size, 1000).
 
 get_max_early_data_size() ->
-    application_int(server_session_ticket_max_early_data, ?DEFAULT_MAX_EARLY_DATA_SIZE).
+    application_int(server_session_ticket_max_early_data,
+                    ?DEFAULT_MAX_EARLY_DATA_SIZE).
 
 get_internal_active_n() ->
     get_internal_active_n(false).

lib/ssl/src/ssl_record.erl

@@ -412,7 +412,7 @@ nonce_seed(_,_, CipherState) ->
 %%--------------------------------------------------------------------
 
 empty_connection_state(ConnectionEnd) ->
-    MaxEarlyDataSize = ssl_config:get_max_early_data_size(),
+    MaxEarlyDataSize = 0, %% TLS-1.3 only, this is not called by TLS-1.3
     empty_connection_state(ConnectionEnd, _Version = undefined, MaxEarlyDataSize).
 %%
 empty_connection_state(ConnectionEnd, Version, MaxEarlyDataSize) ->

lib/ssl/src/ssl_server_session_cache.erl

@@ -104,9 +104,7 @@ reuse_session(Pid, SessionId) ->
 %% Description: Makes a session available for reuse
 %%--------------------------------------------------------------------
 register_session(Pid, Session) ->
-    gen_server:cast(Pid, {register_session, Session}).
-
-
+        gen_server:cast(Pid, {register_session, Session}).
 %%%===================================================================
 %%% gen_server callbacks
 %%%===================================================================

lib/ssl/src/ssl_server_session_cache_sup.erl

@@ -51,13 +51,11 @@ start_child(Listener) ->
 %%%  Supervisor callback
 %%%=========================================================================
 init(_) ->
-    SupFlags = #{strategy  => simple_one_for_one, 
-                 intensity =>   3,
-                 period    => 3600
+    SupFlags = #{strategy  => simple_one_for_one
                 },
     ChildSpecs = [#{id       => undefined,
                     start    => {ssl_server_session_cache, start_link, []},
-                    restart  => transient, 
+                    restart  => temporary,
                     shutdown => 4000,
                     modules  => [ssl_server_session_cache],
                     type     => worker

lib/ssl/src/tls_dtls_gen_connection.erl

@@ -145,7 +145,10 @@ initial_state(Role, Sender, Tab, Host, Port, Socket, {SSLOptions, SocketOptions,
     %% Use highest supported version for client/server random nonce generation
     #{versions := [Version|_]} = SSLOptions,
     BeastMitigation = maps:get(beast_mitigation, SSLOptions, disabled),
-    ConnectionStates = tls_record:init_connection_states(Role, Version, BeastMitigation),
+    MaxEarlyData =
+        tls_gen_connection_1_3:init_max_early_data_size(Role),
+    ConnectionStates = tls_record:init_connection_states(Role, Version,
+                                                         BeastMitigation, MaxEarlyData),
     #{session_cb := SessionCacheCb} = ssl_config:pre_1_3_session_opts(Role),
     UserMonitor = erlang:monitor(process, User),
 

lib/ssl/src/tls_gen_connection_1_3.erl

@@ -51,6 +51,7 @@
          update_cipher_key/2,
          maybe_traffic_keylog_1_3/4,
          maybe_forget_hs_secrets/2,
+         init_max_early_data_size/1,
          do_maybe/0]).
 
 %%--------------------------------------------------------------------

lib/ssl/src/tls_record.erl

@@ -37,7 +37,6 @@
 
 %% Handling of incoming data
 -export([get_tls_records/5,
-         init_connection_states/3,
          init_connection_states/4]).
 
 %% Encoding TLS records
@@ -69,20 +68,10 @@
 %% Handling of incoming data
 %%====================================================================
 %%--------------------------------------------------------------------
--spec init_connection_states(Role, Version, BeastMitigation) ->
-          ssl_record:connection_states() when
-      Role :: client | server,
-      Version :: tls_version(),
-      BeastMitigation :: one_n_minus_one | zero_n | disabled.
-
 %%
 %% Description: Creates a connection_states record with appropriate
 %% values for the initial SSL connection setup.
 %%--------------------------------------------------------------------
-init_connection_states(Role, Version, BeastMitigation) ->
-    MaxEarlyDataSize = ssl_config:get_max_early_data_size(),
-    init_connection_states(Role, Version, BeastMitigation, MaxEarlyDataSize).
-%%
 -spec init_connection_states(Role, Version, BeastMitigation,
                              MaxEarlyDataSize) ->
           ssl_record:connection_states() when

lib/ssl/src/tls_server_connection_1_3.erl

@@ -665,16 +665,20 @@ maybe_send_session_ticket(State, 0) ->
     State;
 maybe_send_session_ticket(#state{connection_states = ConnectionStates,
                                  static_env = #static_env{trackers = Trackers,
-                                                          protocol_cb = Connection}
-                                } = State0, N) ->
+                                                          protocol_cb = Connection}}
+                          = State0, N) ->
     Tracker = proplists:get_value(session_tickets_tracker, Trackers),
     #{security_parameters := SecParamsR} =
         ssl_record:current_connection_state(ConnectionStates, read),
     #security_parameters{prf_algorithm = HKDF,
                          resumption_master_secret = RMS} = SecParamsR,
-    Ticket = new_session_ticket(Tracker, HKDF, RMS, State0),
-    {State, _} = Connection:send_handshake(Ticket, State0),
-    maybe_send_session_ticket(State, N - 1).
+    case new_session_ticket(Tracker, HKDF, RMS, State0) of
+        no_ticket -> %% Continuous restarts of ticket handler (unlikely scenario)
+            State0;
+        Ticket ->
+            {State, _} = Connection:send_handshake(Ticket, State0),
+            maybe_send_session_ticket(State, N - 1)
+    end.
 
 new_session_ticket(Tracker, HKDF, RMS,
                    #state{ssl_options = #{session_tickets := stateful_with_cert},