Merge branch 'ingela/ssl/extensions-and-TLS-1.3-handshaking'

* ingela/ssl/extensions-and-TLS-1.3-handshaking:
  ssl: Correct extension decoding and dialyzer spec
  ssl: Generalize extensions handling

10 files changed, 639 insertions, 284 deletions

diff --git a/lib/ssl/src/dtls_connection.erl b/lib/ssl/src/dtls_connection.erl
index b05e4b7f24..8ed4505256 100644
--- a/lib/ssl/src/dtls_connection.erl
+++ b/lib/ssl/src/dtls_connection.erl
@@ -350,8 +350,8 @@ reinit_handshake_data(#state{protocol_buffers = Buffers} = State) ->
 		      dtls_handshake_later_fragments = []
 		     }}.
 
-select_sni_extension(#client_hello{extensions = HelloExtensions}) ->
-    HelloExtensions#hello_extensions.sni;
+select_sni_extension(#client_hello{extensions = #{sni := SNI}}) ->
+    SNI;
 select_sni_extension(_) ->
     undefined.
 
@@ -551,12 +551,12 @@ hello(internal, #client_hello{extensions = Extensions} = Hello, #state{ssl_optio
                                                                        start_or_recv_from = From} = State) ->
     {next_state, user_hello, State#state{start_or_recv_from = undefined,
                                              hello = Hello},
-     [{reply, From, {ok, ssl_connection:map_extensions(Extensions)}}]};
+     [{reply, From, {ok, Extensions}}]};
 hello(internal, #server_hello{extensions = Extensions} = Hello, #state{ssl_options = #ssl_options{handshake = hello},
                                                                        start_or_recv_from = From} = State) ->
     {next_state, user_hello, State#state{start_or_recv_from = undefined,
                                              hello = Hello},
-     [{reply, From, {ok, ssl_connection:map_extensions(Extensions)}}]};     
+     [{reply, From, {ok, Extensions}}]};     
 hello(internal, #client_hello{cookie = Cookie} = Hello, #state{role = server,
 							       transport_cb = Transport,
 							       socket = Socket,
diff --git a/lib/ssl/src/dtls_handshake.erl b/lib/ssl/src/dtls_handshake.erl
index 3f70eaec8a..c8daa11433 100644
--- a/lib/ssl/src/dtls_handshake.erl
+++ b/lib/ssl/src/dtls_handshake.erl
@@ -169,10 +169,7 @@ handle_client_hello(Version,
                                   cipher_suites = CipherSuites,
                                   compression_methods = Compressions,
                                   random = Random,
-                                  extensions =
-                                      #hello_extensions{elliptic_curves = Curves,
-                                                        signature_algs = ClientHashSigns} 
-                                  = HelloExt},
+                                  extensions = HelloExt},
 		    #ssl_options{versions = Versions,
 				 signature_algs = SupportedHashSigns,
                                  eccs = SupportedECCs,
@@ -181,6 +178,8 @@ handle_client_hello(Version,
                     Renegotiation) ->
     case dtls_record:is_acceptable_version(Version, Versions) of
 	true ->
+            Curves = maps:get(elliptic_curves, HelloExt, undefined),
+            ClientHashSigns = maps:get(signature_algs, HelloExt, undefined),
 	    TLSVersion = dtls_v1:corresponding_tls_version(Version),
 	    AvailableHashSigns = ssl_handshake:available_signature_algs(
 				   ClientHashSigns, SupportedHashSigns, Cert,TLSVersion),
@@ -335,7 +334,7 @@ decode_handshake(Version, <<?BYTE(Type), Bin/binary>>) ->
 
 decode_handshake(_, ?HELLO_REQUEST, <<>>) ->
     #hello_request{};
-decode_handshake(_Version, ?CLIENT_HELLO, <<?UINT24(_), ?UINT16(_),
+decode_handshake(Version, ?CLIENT_HELLO, <<?UINT24(_), ?UINT16(_),
 					    ?UINT24(_),  ?UINT24(_), 
 					    ?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 					    ?BYTE(SID_length), Session_ID:SID_length/binary,
@@ -343,8 +342,9 @@ decode_handshake(_Version, ?CLIENT_HELLO, <<?UINT24(_), ?UINT16(_),
 					    ?UINT16(Cs_length), CipherSuites:Cs_length/binary,
 					    ?BYTE(Cm_length), Comp_methods:Cm_length/binary,
 					    Extensions/binary>>) ->
-    
-    DecodedExtensions = ssl_handshake:decode_hello_extensions({client, Extensions}),
+    TLSVersion = dtls_v1:corresponding_tls_version(Version),
+    Exts = ssl_handshake:decode_vector(Extensions),
+    DecodedExtensions = ssl_handshake:decode_hello_extensions(Exts, TLSVersion, client),
 
     #client_hello{
        client_version = {Major,Minor},
diff --git a/lib/ssl/src/ssl_connection.erl b/lib/ssl/src/ssl_connection.erl
index 66e96f8da5..33d60ee0e6 100644
--- a/lib/ssl/src/ssl_connection.erl
+++ b/lib/ssl/src/ssl_connection.erl
@@ -60,7 +60,7 @@
 
 %% Help functions for tls|dtls_connection.erl
 -export([handle_session/7, ssl_config/3,
-	 prepare_connection/2, hibernate_after/3, map_extensions/1]).
+	 prepare_connection/2, hibernate_after/3]).
 
 %% General gen_statem state functions with extra callback argument 
 %% to determine if it is an SSL/TLS or DTLS gen_statem machine
@@ -1427,7 +1427,7 @@ security_info(#state{connection_states = ConnectionStates}) ->
 	ssl_record:current_connection_state(ConnectionStates, read),
     [{client_random, ClientRand}, {server_random, ServerRand}, {master_secret, MasterSecret}].
 
-do_server_hello(Type, #hello_extensions{next_protocol_negotiation = NextProtocols} =
+do_server_hello(Type, #{next_protocol_negotiation := NextProtocols} =
 		    ServerHelloExt,
 		#state{negotiated_version = Version,
 		       session = #session{session_id = SessId},
@@ -2351,22 +2351,6 @@ hibernate_after(connection = StateName,
 hibernate_after(StateName, State, Actions) ->
     {next_state, StateName, State, Actions}.
 
-map_extensions(#hello_extensions{renegotiation_info = RenegotiationInfo,
-                                 signature_algs = SigAlg,          
-                                 alpn = Alpn,
-                                 next_protocol_negotiation = Next, 
-                                 srp = SRP,
-                                 ec_point_formats = ECPointFmt,
-                                 elliptic_curves = ECCCurves,
-                                 sni = SNI}) ->
-    #{renegotiation_info => ssl_handshake:extension_value(RenegotiationInfo),
-      signature_algs =>  ssl_handshake:extension_value(SigAlg),
-      alpn =>  ssl_handshake:extension_value(Alpn),
-      srp  => ssl_handshake:extension_value(SRP),
-      next_protocol => ssl_handshake:extension_value(Next),
-      ec_point_formats  => ssl_handshake:extension_value(ECPointFmt),
-      elliptic_curves => ssl_handshake:extension_value(ECCCurves),
-      sni => ssl_handshake:extension_value(SNI)}.
 
 terminate_alert(normal) ->
     ?ALERT_REC(?WARNING, ?CLOSE_NOTIFY);
diff --git a/lib/ssl/src/ssl_handshake.erl b/lib/ssl/src/ssl_handshake.erl
index ced3c2675e..ba0b670091 100644
--- a/lib/ssl/src/ssl_handshake.erl
+++ b/lib/ssl/src/ssl_handshake.erl
@@ -57,10 +57,10 @@
 	]).
 
 %% Encode
--export([encode_handshake/2, encode_hello_extensions/1,
+-export([encode_handshake/2, encode_hello_extensions/1, encode_extensions/1, encode_extensions/2,
 	 encode_client_protocol_negotiation/2, encode_protocols_advertised_on_server/1]).
 %% Decode
--export([decode_handshake/3, decode_hello_extensions/1,
+-export([decode_handshake/3, decode_vector/1, decode_hello_extensions/3, decode_extensions/1,
 	 decode_server_key/3, decode_client_key/3,
 	 decode_suites/2
 	]).
@@ -93,7 +93,7 @@ hello_request() ->
 
 %%--------------------------------------------------------------------
 -spec server_hello(#session{}, ssl_record:ssl_version(), ssl_record:connection_states(),
-		   #hello_extensions{}) -> #server_hello{}.
+		   Extension::map()) -> #server_hello{}.
 %%
 %% Description: Creates a server hello message.
 %%--------------------------------------------------------------------
@@ -532,7 +532,7 @@ encode_handshake(#server_hello{server_version = {Major, Minor},
 			       session_id = Session_ID,
 			       cipher_suite = CipherSuite,
 			       compression_method = Comp_method,
-			       extensions = #hello_extensions{} = Extensions}, _Version) ->
+			       extensions = Extensions}, _Version) ->
 			SID_length = byte_size(Session_ID),
     ExtensionsBin = encode_hello_extensions(Extensions),
     {?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
@@ -582,93 +582,94 @@ encode_handshake(#certificate_verify{signature = BinSig, hashsign_algorithm = Ha
 encode_handshake(#finished{verify_data = VerifyData}, _Version) ->
     {?FINISHED, VerifyData}.
 
-encode_hello_extensions(#hello_extensions{} = Extensions) ->
-    encode_hello_extensions(hello_extensions_list(Extensions), <<>>).
-encode_hello_extensions([], <<>>) ->
+encode_hello_extensions(Extensions) ->
+    encode_extensions(hello_extensions_list(Extensions), <<>>).
+
+encode_extensions(Exts) ->
+    encode_extensions(Exts, <<>>).
+    
+encode_extensions([], <<>>) ->
     <<>>;
-encode_hello_extensions([], Acc) ->
+encode_extensions([], Acc) ->
     Size = byte_size(Acc),
     <<?UINT16(Size), Acc/binary>>;
-
-encode_hello_extensions([#alpn{extension_data = ExtensionData} | Rest], Acc) ->
-	Len = byte_size(ExtensionData),
+encode_extensions([#alpn{extension_data = ExtensionData} | Rest], Acc) ->
+    Len = byte_size(ExtensionData),
     ExtLen = Len + 2,
-	encode_hello_extensions(Rest, <<?UINT16(?ALPN_EXT), ?UINT16(ExtLen), ?UINT16(Len),
-					ExtensionData/binary, Acc/binary>>);
-encode_hello_extensions([#next_protocol_negotiation{extension_data = ExtensionData} | Rest], Acc) ->
+    encode_extensions(Rest, <<?UINT16(?ALPN_EXT), ?UINT16(ExtLen), ?UINT16(Len),
+                              ExtensionData/binary, Acc/binary>>);
+encode_extensions([#next_protocol_negotiation{extension_data = ExtensionData} | Rest], Acc) ->
     Len = byte_size(ExtensionData),
-    encode_hello_extensions(Rest, <<?UINT16(?NEXTPROTONEG_EXT), ?UINT16(Len),
+    encode_extensions(Rest, <<?UINT16(?NEXTPROTONEG_EXT), ?UINT16(Len),
 				    ExtensionData/binary, Acc/binary>>);
-encode_hello_extensions([#renegotiation_info{renegotiated_connection = undefined} | Rest], Acc) ->
-    encode_hello_extensions(Rest, Acc);
-encode_hello_extensions([#renegotiation_info{renegotiated_connection = ?byte(0) = Info} | Rest], Acc) ->
+encode_extensions([#renegotiation_info{renegotiated_connection = undefined} | Rest], Acc) ->
+    encode_extensions(Rest, Acc);
+encode_extensions([#renegotiation_info{renegotiated_connection = ?byte(0) = Info} | Rest], Acc) ->
     Len = byte_size(Info),
-    encode_hello_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info/binary, Acc/binary>>);
+    encode_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info/binary, Acc/binary>>);
 
-encode_hello_extensions([#renegotiation_info{renegotiated_connection = Info} | Rest], Acc) ->
+encode_extensions([#renegotiation_info{renegotiated_connection = Info} | Rest], Acc) ->
     InfoLen = byte_size(Info),
     Len = InfoLen +1,
-    encode_hello_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), ?BYTE(InfoLen),
+    encode_extensions(Rest, <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), ?BYTE(InfoLen),
 				    Info/binary, Acc/binary>>);
-encode_hello_extensions([#elliptic_curves{elliptic_curve_list = EllipticCurves} | Rest], Acc) ->
+encode_extensions([#elliptic_curves{elliptic_curve_list = EllipticCurves} | Rest], Acc) ->
 
     EllipticCurveList = << <<(tls_v1:oid_to_enum(X)):16>> || X <- EllipticCurves>>,
     ListLen = byte_size(EllipticCurveList),
     Len = ListLen + 2,
-    encode_hello_extensions(Rest, <<?UINT16(?ELLIPTIC_CURVES_EXT),
+    encode_extensions(Rest, <<?UINT16(?ELLIPTIC_CURVES_EXT),
 				 ?UINT16(Len), ?UINT16(ListLen), EllipticCurveList/binary, Acc/binary>>);
-encode_hello_extensions([#ec_point_formats{ec_point_format_list = ECPointFormats} | Rest], Acc) ->
+encode_extensions([#ec_point_formats{ec_point_format_list = ECPointFormats} | Rest], Acc) ->
     ECPointFormatList = list_to_binary(ECPointFormats),
     ListLen = byte_size(ECPointFormatList),
     Len = ListLen + 1,
-    encode_hello_extensions(Rest, <<?UINT16(?EC_POINT_FORMATS_EXT),
+    encode_extensions(Rest, <<?UINT16(?EC_POINT_FORMATS_EXT),
 				 ?UINT16(Len), ?BYTE(ListLen), ECPointFormatList/binary, Acc/binary>>);
-encode_hello_extensions([#srp{username = UserName} | Rest], Acc) ->
+encode_extensions([#srp{username = UserName} | Rest], Acc) ->
     SRPLen = byte_size(UserName),
     Len = SRPLen + 2,
-    encode_hello_extensions(Rest, <<?UINT16(?SRP_EXT), ?UINT16(Len), ?BYTE(SRPLen),
+    encode_extensions(Rest, <<?UINT16(?SRP_EXT), ?UINT16(Len), ?BYTE(SRPLen),
 				    UserName/binary, Acc/binary>>);
-encode_hello_extensions([#hash_sign_algos{hash_sign_algos = HashSignAlgos} | Rest], Acc) ->
+encode_extensions([#hash_sign_algos{hash_sign_algos = HashSignAlgos} | Rest], Acc) ->
     SignAlgoList = << <<(ssl_cipher:hash_algorithm(Hash)):8, (ssl_cipher:sign_algorithm(Sign)):8>> ||
 		       {Hash, Sign} <- HashSignAlgos >>,
     ListLen = byte_size(SignAlgoList),
     Len = ListLen + 2,
-    encode_hello_extensions(Rest, <<?UINT16(?SIGNATURE_ALGORITHMS_EXT),
+    encode_extensions(Rest, <<?UINT16(?SIGNATURE_ALGORITHMS_EXT),
 				 ?UINT16(Len), ?UINT16(ListLen), SignAlgoList/binary, Acc/binary>>);
-encode_hello_extensions([#signature_scheme_list{
+encode_extensions([#signature_scheme_list{
                             signature_scheme_list = SignatureSchemes} | Rest], Acc) ->
     SignSchemeList = << <<(ssl_cipher:signature_scheme(SignatureScheme)):16 >> ||
 		       SignatureScheme <- SignatureSchemes >>,
     ListLen = byte_size(SignSchemeList),
     Len = ListLen + 2,
-    encode_hello_extensions(Rest, <<?UINT16(?SIGNATURE_ALGORITHMS_CERT_EXT),
+    encode_extensions(Rest, <<?UINT16(?SIGNATURE_ALGORITHMS_CERT_EXT),
 				 ?UINT16(Len), ?UINT16(ListLen), SignSchemeList/binary, Acc/binary>>);
-encode_hello_extensions([#sni{hostname = Hostname} | Rest], Acc) ->
+encode_extensions([#sni{hostname = Hostname} | Rest], Acc) ->
     HostLen = length(Hostname),
     HostnameBin = list_to_binary(Hostname),
     % Hostname type (1 byte) + Hostname length (2 bytes) + Hostname (HostLen bytes)
     ServerNameLength = 1 + 2 + HostLen,
     % ServerNameListSize (2 bytes) + ServerNameLength
     ExtLength = 2 + ServerNameLength,
-    encode_hello_extensions(Rest, <<?UINT16(?SNI_EXT), ?UINT16(ExtLength),
-				    ?UINT16(ServerNameLength),
-				    ?BYTE(?SNI_NAMETYPE_HOST_NAME),
-				    ?UINT16(HostLen), HostnameBin/binary,
-				    Acc/binary>>);
-encode_hello_extensions([#client_hello_versions{versions = Versions0} | Rest], Acc) ->
+    encode_extensions(Rest, <<?UINT16(?SNI_EXT), ?UINT16(ExtLength),
+                              ?UINT16(ServerNameLength),
+                              ?BYTE(?SNI_NAMETYPE_HOST_NAME),
+                              ?UINT16(HostLen), HostnameBin/binary,
+                              Acc/binary>>);
+encode_extensions([#client_hello_versions{versions = Versions0} | Rest], Acc) ->
     Versions = encode_versions(Versions0),
     VerLen = byte_size(Versions),
     Len = VerLen + 2,
-    encode_hello_extensions(Rest, <<?UINT16(?SUPPORTED_VERSIONS_EXT),
+    encode_extensions(Rest, <<?UINT16(?SUPPORTED_VERSIONS_EXT),
                                     ?UINT16(Len), ?UINT16(VerLen), Versions/binary, Acc/binary>>);
-encode_hello_extensions([#server_hello_selected_version{selected_version = Version0} | Rest], Acc) ->
-    Version = encode_versions(Version0),
+encode_extensions([#server_hello_selected_version{selected_version = Version0} | Rest], Acc) ->
+    Version = encode_versions([Version0]),
     Len = byte_size(Version), %% 2
-    encode_hello_extensions(Rest, <<?UINT16(?SUPPORTED_VERSIONS_EXT),
+    encode_extensions(Rest, <<?UINT16(?SUPPORTED_VERSIONS_EXT),
                                     ?UINT16(Len), Version/binary, Acc/binary>>).
 
-
-
 encode_client_protocol_negotiation(undefined, _) ->
     undefined;
 encode_client_protocol_negotiation(_, false) ->
@@ -693,7 +694,7 @@ decode_handshake(_, ?NEXT_PROTOCOL, <<?BYTE(SelectedProtocolLength),
 				      ?BYTE(PaddingLength), _Padding:PaddingLength/binary>>) ->
     #next_protocol{selected_protocol = SelectedProtocol};
 
-decode_handshake(_Version, ?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
+decode_handshake(Version, ?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 					    ?BYTE(SID_length), Session_ID:SID_length/binary,
 					    Cipher_suite:2/binary, ?BYTE(Comp_method)>>) ->
     #server_hello{
@@ -702,14 +703,14 @@ decode_handshake(_Version, ?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:3
        session_id = Session_ID,
        cipher_suite = Cipher_suite,
        compression_method = Comp_method,
-       extensions = #hello_extensions{}};
+       extensions = empty_hello_extensions(Version, server)};
 
-decode_handshake(_Version, ?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
+decode_handshake(Version, ?SERVER_HELLO, <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
 		       ?BYTE(SID_length), Session_ID:SID_length/binary,
 		       Cipher_suite:2/binary, ?BYTE(Comp_method),
 		       ?UINT16(ExtLen), Extensions:ExtLen/binary>>) ->
 
-    HelloExtensions = decode_hello_extensions(Extensions),
+    HelloExtensions = decode_hello_extensions(Extensions, Version, server),
 
     #server_hello{
        server_version = {Major,Minor},
@@ -752,17 +753,34 @@ decode_handshake(_Version, ?FINISHED, VerifyData) ->
 decode_handshake(_, Message, _) ->
     throw(?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE, {unknown_or_malformed_handshake, Message})).
 
+
 %%--------------------------------------------------------------------
--spec decode_hello_extensions({client, binary()} | binary()) -> #hello_extensions{}.
+-spec decode_vector(binary()) -> binary().
+%%
+%% Description: Remove length tag from TLS Vector type. Needed
+%% for client hello when extensions in older versions may be empty.
+%% 
+%%--------------------------------------------------------------------
+decode_vector(<<>>) ->
+    <<>>;
+decode_vector(<<?UINT16(Len), Vector:Len/binary>>) ->
+    Vector.
+
+%%--------------------------------------------------------------------
+-spec decode_hello_extensions(binary(), ssl_record:ssl_version(), client | server) -> map().
+%%
+%% Description: Decodes TLS hello extensions
+%%--------------------------------------------------------------------
+decode_hello_extensions(Extensions, Version, Role) ->
+    decode_extensions(Extensions, empty_hello_extensions(Version, Role)).
+
+%%--------------------------------------------------------------------
+-spec decode_extensions(binary()) -> map().
 %%
 %% Description: Decodes TLS hello extensions
 %%--------------------------------------------------------------------
-decode_hello_extensions({client, <<>>}) ->
-    #hello_extensions{};
-decode_hello_extensions({client, <<?UINT16(ExtLen), Extensions:ExtLen/binary>>}) ->
-    decode_hello_extensions(Extensions);
-decode_hello_extensions(Extensions) ->
-    dec_hello_extensions(Extensions, #hello_extensions{}).
+decode_extensions(Extensions) ->
+    decode_extensions(Extensions, empty_extensions()).
 
 %%--------------------------------------------------------------------
 -spec decode_server_key(binary(), ssl_cipher_format:key_algo(), ssl_record:ssl_version()) ->
@@ -979,57 +997,52 @@ client_hello_extensions(Version, CipherSuites,
 	end,
     SRP = srp_user(SslOpts),
 
-    HelloExtensions =
-        #hello_extensions{
-           renegotiation_info = renegotiation_info(tls_record, client,
-                                                   ConnectionStates, Renegotiation),
-           srp = SRP,
-           signature_algs = available_signature_algs(SupportedHashSigns, Version),
-           ec_point_formats = EcPointFormats,
-           elliptic_curves = EllipticCurves,
-           alpn = encode_alpn(SslOpts#ssl_options.alpn_advertised_protocols, Renegotiation),
-           next_protocol_negotiation =
-               encode_client_protocol_negotiation(SslOpts#ssl_options.next_protocol_selector,
-                                                  Renegotiation),
-           sni = sni(SslOpts#ssl_options.server_name_indication)},
+    HelloExtensions = #{renegotiation_info => renegotiation_info(tls_record, client,
+                                                                 ConnectionStates, Renegotiation),
+                        srp => SRP,
+                        signature_algs => available_signature_algs(SupportedHashSigns, Version),
+                        ec_point_formats => EcPointFormats,
+                        elliptic_curves => EllipticCurves,
+                        alpn => encode_alpn(SslOpts#ssl_options.alpn_advertised_protocols, Renegotiation),
+                        next_protocol_negotiation =>
+                            encode_client_protocol_negotiation(SslOpts#ssl_options.next_protocol_selector,
+                                                               Renegotiation),
+                        sni => sni(SslOpts#ssl_options.server_name_indication)
+                       },
 
     %% Add "supported_versions" extension if TLS 1.3
     case Version of
         {3,4} ->
-            HelloExtensions#hello_extensions{
-              client_hello_versions = #client_hello_versions{
-                                         versions = Versions},
-              signature_algs_cert = #signature_scheme_list{
-                                       signature_scheme_list = SignatureSchemes}};
+            HelloExtensions#{client_hello_versions => 
+                                 #client_hello_versions{versions = Versions},
+                             signature_algs_cert => 
+                                 #signature_scheme_list{signature_scheme_list = SignatureSchemes}};
         _Else ->
             HelloExtensions
     end.
 
 handle_client_hello_extensions(RecordCB, Random, ClientCipherSuites,
-			       #hello_extensions{renegotiation_info = Info,
-						 srp = SRP,
-						 ec_point_formats = ECCFormat,
-						 alpn = ALPN,
-						 next_protocol_negotiation = NextProtocolNegotiation}, Version,
+                               Exts, Version,
 			       #ssl_options{secure_renegotiate = SecureRenegotation,
                                             alpn_preferred_protocols = ALPNPreferredProtocols} = Opts,
 			       #session{cipher_suite = NegotiatedCipherSuite,
 					compression_method = Compression} = Session0,
 			       ConnectionStates0, Renegotiation) ->
-    Session = handle_srp_extension(SRP, Session0),
-    ConnectionStates = handle_renegotiation_extension(server, RecordCB, Version, Info,
+    Session = handle_srp_extension(maps:get(srp, Exts, undefined), Session0),
+    ConnectionStates = handle_renegotiation_extension(server, RecordCB, Version, maps:get(renegotiation_info, Exts, undefined),
 						      Random, NegotiatedCipherSuite, 
 						      ClientCipherSuites, Compression,
 						      ConnectionStates0, Renegotiation, SecureRenegotation),
 
-    ServerHelloExtensions =  #hello_extensions{
-				renegotiation_info = renegotiation_info(RecordCB, server,
-									ConnectionStates, Renegotiation),
-				ec_point_formats = server_ecc_extension(Version, ECCFormat)
-			       },
-
+    Empty = empty_hello_extensions(Version, client),
+    ServerHelloExtensions = Empty#{renegotiation_info => renegotiation_info(RecordCB, server,
+                                                                            ConnectionStates, Renegotiation),
+                                   ec_point_formats => server_ecc_extension(Version, maps:get(ec_point_formats, Exts, undefined))
+                                  },
+    
     %% If we receive an ALPN extension and have ALPN configured for this connection,
     %% we handle it. Otherwise we check for the NPN extension.
+    ALPN = maps:get(alpn, Exts, undefined),
     if
         ALPN =/= undefined, ALPNPreferredProtocols =/= undefined ->
 			case handle_alpn_extension(ALPNPreferredProtocols, decode_alpn(ALPN)) of
@@ -1037,35 +1050,36 @@ handle_client_hello_extensions(RecordCB, Random, ClientCipherSuites,
                     Alert;
                 Protocol ->
                     {Session, ConnectionStates, Protocol,
-                        ServerHelloExtensions#hello_extensions{alpn=encode_alpn([Protocol], Renegotiation)}}
+                        ServerHelloExtensions#{alpn => encode_alpn([Protocol], Renegotiation)}}
             end;
         true ->
+            NextProtocolNegotiation = maps:get(next_protocol_negotiation, Exts, undefined),
             ProtocolsToAdvertise = handle_next_protocol_extension(NextProtocolNegotiation, Renegotiation, Opts),
             {Session, ConnectionStates, undefined,
-				ServerHelloExtensions#hello_extensions{next_protocol_negotiation=
-                	encode_protocols_advertised_on_server(ProtocolsToAdvertise)}}
+             ServerHelloExtensions#{next_protocol_negotiation =>
+                                        encode_protocols_advertised_on_server(ProtocolsToAdvertise)}}
     end.
 
 handle_server_hello_extensions(RecordCB, Random, CipherSuite, Compression,
-			       #hello_extensions{renegotiation_info = Info,
-                                                 alpn = ALPN,
-						 next_protocol_negotiation = NextProtocolNegotiation}, Version,
+                               Exts, Version,
 			       #ssl_options{secure_renegotiate = SecureRenegotation,
 					    next_protocol_selector = NextProtoSelector},
 			       ConnectionStates0, Renegotiation) ->
-    ConnectionStates = handle_renegotiation_extension(client, RecordCB, Version, Info, Random, 
+    ConnectionStates = handle_renegotiation_extension(client, RecordCB, Version,  maps:get(renegotiation_info, Exts, undefined), Random, 
 						      CipherSuite, undefined,
 						      Compression, ConnectionStates0,
 						      Renegotiation, SecureRenegotation),
 
     %% If we receive an ALPN extension then this is the protocol selected,
     %% otherwise handle the NPN extension.
+    ALPN = maps:get(alpn, Exts, undefined),
     case decode_alpn(ALPN) of
         %% ServerHello contains exactly one protocol: the one selected.
         %% We also ignore the ALPN extension during renegotiation (see encode_alpn/2).
         [Protocol] when not Renegotiation ->
             {ConnectionStates, alpn, Protocol};
         undefined ->
+            NextProtocolNegotiation = maps:get(next_protocol_negotiation, Exts, undefined),
             case handle_next_protocol(NextProtocolNegotiation, NextProtoSelector, Renegotiation) of
                 #alert{} = Alert ->
                     Alert;
@@ -1823,21 +1837,8 @@ encode_versions([{M,N}|T], Acc) ->
     encode_versions(T, <<?BYTE(M),?BYTE(N),Acc/binary>>).
 
 
-hello_extensions_list(#hello_extensions{renegotiation_info = RenegotiationInfo,
-					srp = SRP,
-					signature_algs = HashSigns,
-                                        signature_algs_cert = SignatureSchemes,
-					ec_point_formats = EcPointFormats,
-					elliptic_curves = EllipticCurves,
-                                        alpn = ALPN,
-					next_protocol_negotiation = NextProtocolNegotiation,
-					sni = Sni,
-                                        client_hello_versions = Versions,
-                                        server_hello_selected_version = Version}) ->
-    [Ext || Ext <- [RenegotiationInfo, SRP, HashSigns, SignatureSchemes,
-		    EcPointFormats, EllipticCurves, ALPN,
-                    NextProtocolNegotiation, Sni,
-                    Versions, Version], Ext =/= undefined].
+hello_extensions_list(HelloExtensions) ->
+    [Ext || {_, Ext} <- maps:to_list(HelloExtensions), Ext =/= undefined].
 
 %%-------------Decode handshakes---------------------------------
 dec_server_key(<<?UINT16(PLen), P:PLen/binary,
@@ -1977,16 +1978,16 @@ dec_server_key_signature(Params, <<?UINT16(Len), Signature:Len/binary>>, _) ->
 dec_server_key_signature(_, _, _) ->
     throw(?ALERT_REC(?FATAL, ?HANDSHAKE_FAILURE, failed_to_decrypt_server_key_sign)).
 
-dec_hello_extensions(<<>>, Acc) ->
+decode_extensions(<<>>, Acc) ->
     Acc;
-dec_hello_extensions(<<?UINT16(?ALPN_EXT), ?UINT16(ExtLen), ?UINT16(Len), ExtensionData:Len/binary, Rest/binary>>, Acc)
+decode_extensions(<<?UINT16(?ALPN_EXT), ?UINT16(ExtLen), ?UINT16(Len), ExtensionData:Len/binary, Rest/binary>>, Acc)
         when Len + 2 =:= ExtLen ->
     ALPN = #alpn{extension_data = ExtensionData},
-    dec_hello_extensions(Rest, Acc#hello_extensions{alpn = ALPN});
-dec_hello_extensions(<<?UINT16(?NEXTPROTONEG_EXT), ?UINT16(Len), ExtensionData:Len/binary, Rest/binary>>, Acc) ->
+    decode_extensions(Rest, Acc#{alpn => ALPN});
+decode_extensions(<<?UINT16(?NEXTPROTONEG_EXT), ?UINT16(Len), ExtensionData:Len/binary, Rest/binary>>, Acc) ->
     NextP = #next_protocol_negotiation{extension_data = ExtensionData},
-    dec_hello_extensions(Rest, Acc#hello_extensions{next_protocol_negotiation = NextP});
-dec_hello_extensions(<<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info:Len/binary, Rest/binary>>, Acc) ->
+    decode_extensions(Rest, Acc#{next_protocol_negotiation => NextP});
+decode_extensions(<<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info:Len/binary, Rest/binary>>, Acc) ->
     RenegotiateInfo = case Len of
 			  1 ->  % Initial handshake
 			      Info; % should be <<0>> will be matched in handle_renegotiation_info
@@ -1995,34 +1996,34 @@ dec_hello_extensions(<<?UINT16(?RENEGOTIATION_EXT), ?UINT16(Len), Info:Len/binar
 			      <<?BYTE(VerifyLen), VerifyInfo/binary>> = Info,
 			      VerifyInfo
 		      end,
-    dec_hello_extensions(Rest, Acc#hello_extensions{renegotiation_info =
-							#renegotiation_info{renegotiated_connection =
-										RenegotiateInfo}});
+    decode_extensions(Rest, Acc#{renegotiation_info =>
+                                     #renegotiation_info{renegotiated_connection =
+                                                             RenegotiateInfo}});
 
-dec_hello_extensions(<<?UINT16(?SRP_EXT), ?UINT16(Len), ?BYTE(SRPLen), SRP:SRPLen/binary, Rest/binary>>, Acc)
+decode_extensions(<<?UINT16(?SRP_EXT), ?UINT16(Len), ?BYTE(SRPLen), SRP:SRPLen/binary, Rest/binary>>, Acc)
   when Len == SRPLen + 2 ->
-    dec_hello_extensions(Rest,  Acc#hello_extensions{srp = #srp{username = SRP}});
+    decode_extensions(Rest,  Acc#{srp => #srp{username = SRP}});
 
-dec_hello_extensions(<<?UINT16(?SIGNATURE_ALGORITHMS_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?SIGNATURE_ALGORITHMS_EXT), ?UINT16(Len),
 		       ExtData:Len/binary, Rest/binary>>, Acc) ->
     SignAlgoListLen = Len - 2,
     <<?UINT16(SignAlgoListLen), SignAlgoList/binary>> = ExtData,
     HashSignAlgos = [{ssl_cipher:hash_algorithm(Hash), ssl_cipher:sign_algorithm(Sign)} ||
 			<<?BYTE(Hash), ?BYTE(Sign)>> <= SignAlgoList],
-    dec_hello_extensions(Rest, Acc#hello_extensions{signature_algs =
-						    #hash_sign_algos{hash_sign_algos = HashSignAlgos}});
+    decode_extensions(Rest, Acc#{signature_algs =>
+                                     #hash_sign_algos{hash_sign_algos = HashSignAlgos}});
 
-dec_hello_extensions(<<?UINT16(?SIGNATURE_ALGORITHMS_CERT_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?SIGNATURE_ALGORITHMS_CERT_EXT), ?UINT16(Len),
 		       ExtData:Len/binary, Rest/binary>>, Acc) ->
     SignSchemeListLen = Len - 2,
     <<?UINT16(SignSchemeListLen), SignSchemeList/binary>> = ExtData,
     SignSchemes = [ssl_cipher:signature_scheme(SignScheme) ||
 			<<?UINT16(SignScheme)>> <= SignSchemeList],
-    dec_hello_extensions(Rest, Acc#hello_extensions{signature_algs_cert =
-                                                        #signature_scheme_list{
-                                                           signature_scheme_list = SignSchemes}});
+    decode_extensions(Rest, Acc#{signature_algs_cert =>
+                                     #signature_scheme_list{
+                                        signature_scheme_list = SignSchemes}});
 
-dec_hello_extensions(<<?UINT16(?ELLIPTIC_CURVES_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?ELLIPTIC_CURVES_EXT), ?UINT16(Len),
 		       ExtData:Len/binary, Rest/binary>>, Acc) ->
     <<?UINT16(_), EllipticCurveList/binary>> = ExtData,
     %% Ignore unknown curves
@@ -2035,44 +2036,42 @@ dec_hello_extensions(<<?UINT16(?ELLIPTIC_CURVES_EXT), ?UINT16(Len),
 		   end
 	   end,
     EllipticCurves = lists:filtermap(Pick, [ECC || <<ECC:16>> <= EllipticCurveList]),
-    dec_hello_extensions(Rest, Acc#hello_extensions{elliptic_curves =
-							#elliptic_curves{elliptic_curve_list =
-									     EllipticCurves}});
-dec_hello_extensions(<<?UINT16(?EC_POINT_FORMATS_EXT), ?UINT16(Len),
+    decode_extensions(Rest, Acc#{elliptic_curves =>
+                                     #elliptic_curves{elliptic_curve_list =
+                                                          EllipticCurves}});
+decode_extensions(<<?UINT16(?EC_POINT_FORMATS_EXT), ?UINT16(Len),
 		       ExtData:Len/binary, Rest/binary>>, Acc) ->
     <<?BYTE(_), ECPointFormatList/binary>> = ExtData,
     ECPointFormats = binary_to_list(ECPointFormatList),
-    dec_hello_extensions(Rest, Acc#hello_extensions{ec_point_formats =
-							#ec_point_formats{ec_point_format_list =
-									      ECPointFormats}});
+    decode_extensions(Rest, Acc#{ec_point_formats =>
+                                     #ec_point_formats{ec_point_format_list =
+                                                           ECPointFormats}});
 
-dec_hello_extensions(<<?UINT16(?SNI_EXT), ?UINT16(Len), Rest/binary>>, Acc) when Len == 0 ->
-    dec_hello_extensions(Rest, Acc#hello_extensions{sni = #sni{hostname = ""}}); %% Server may send an empy SNI
+decode_extensions(<<?UINT16(?SNI_EXT), ?UINT16(Len), Rest/binary>>, Acc) when Len == 0 ->
+    decode_extensions(Rest, Acc#{sni => #sni{hostname = ""}}); %% Server may send an empy SNI
 
-dec_hello_extensions(<<?UINT16(?SNI_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?SNI_EXT), ?UINT16(Len),
                 ExtData:Len/binary, Rest/binary>>, Acc) ->
     <<?UINT16(_), NameList/binary>> = ExtData,
-    dec_hello_extensions(Rest, Acc#hello_extensions{sni = dec_sni(NameList)});
+    decode_extensions(Rest, Acc#{sni => dec_sni(NameList)});
 
-dec_hello_extensions(<<?UINT16(?SUPPORTED_VERSIONS_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?SUPPORTED_VERSIONS_EXT), ?UINT16(Len),
                        ExtData:Len/binary, Rest/binary>>, Acc) when Len > 2 ->
     <<?UINT16(_),Versions/binary>> = ExtData,
-    dec_hello_extensions(Rest, Acc#hello_extensions{
-                                 client_hello_versions =
+    decode_extensions(Rest, Acc#{client_hello_versions =>
                                      #client_hello_versions{versions = decode_versions(Versions)}});
 
-dec_hello_extensions(<<?UINT16(?SUPPORTED_VERSIONS_EXT), ?UINT16(Len),
+decode_extensions(<<?UINT16(?SUPPORTED_VERSIONS_EXT), ?UINT16(Len),
                        ?UINT16(Version), Rest/binary>>, Acc) when Len =:= 2, Version =:= 16#0304 ->
-    dec_hello_extensions(Rest, Acc#hello_extensions{
-                                 server_hello_selected_version =
-                                     #server_hello_selected_version{selected_version = [{3,4}]}});
+    decode_extensions(Rest, Acc#{server_hello_selected_version =>
+                                     #server_hello_selected_version{selected_version = {3,4}}});
 
 %% Ignore data following the ClientHello (i.e.,
 %% extensions) if not understood.
-dec_hello_extensions(<<?UINT16(_), ?UINT16(Len), _Unknown:Len/binary, Rest/binary>>, Acc) ->
-    dec_hello_extensions(Rest, Acc);
+decode_extensions(<<?UINT16(_), ?UINT16(Len), _Unknown:Len/binary, Rest/binary>>, Acc) ->
+    decode_extensions(Rest, Acc);
 %% This theoretically should not happen if the protocol is followed, but if it does it is ignored.
-dec_hello_extensions(_, Acc) ->
+decode_extensions(_, Acc) ->
     Acc.
 
 dec_hashsign(<<?BYTE(HashAlgo), ?BYTE(SignAlgo)>>) ->
@@ -2576,4 +2575,39 @@ cert_curve(Cert, ECCCurve0, CipherSuite) ->
             {ECCCurve0, CipherSuite}
     end.
 
-   
+empty_hello_extensions({3, 4}, server) ->
+    #{server_hello_selected_version => undefined,
+      key_share => undefined,
+      pre_shared_key => undefined,
+      sni => undefined
+     };
+empty_hello_extensions({3, 4}, client) -> 
+    #{client_hello_versions => undefined,
+      signature_algs => undefined,
+      signature_algs_cert => undefined,
+      sni => undefined,
+      alpn => undefined,
+      key_share => undefined,
+      pre_shared_key => undefined
+     };
+empty_hello_extensions({3, 3}, client) -> 
+    Ext = empty_hello_extensions({3,2}, client),
+    Ext#{client_hello_versions => undefined,
+         signature_algs => undefined,
+         signature_algs_cert => undefined};
+empty_hello_extensions(_, client) ->
+    #{renegotiation_info => undefined,
+      alpn => undefined,
+      next_protocol_negotiation => undefined,
+      srp => undefined,
+      ec_point_formats => undefined,
+      elliptic_curves => undefined,
+      sni => undefined};
+empty_hello_extensions(_, server) ->
+    #{renegotiation_info => undefined,
+      alpn => undefined,
+      next_protocol_negotiation => undefined,
+      ec_point_formats => undefined,
+      sni => undefined}.
+empty_extensions() ->
+     #{}.
diff --git a/lib/ssl/src/tls_connection.erl b/lib/ssl/src/tls_connection.erl
index 94a4fa511d..f85e00ea50 100644
--- a/lib/ssl/src/tls_connection.erl
+++ b/lib/ssl/src/tls_connection.erl
@@ -341,8 +341,8 @@ reinit_handshake_data(State) ->
        tls_handshake_history = ssl_handshake:init_handshake_history()
      }.
 
-select_sni_extension(#client_hello{extensions = HelloExtensions}) ->
-    HelloExtensions#hello_extensions.sni;
+select_sni_extension(#client_hello{extensions = #{sni := SNI}}) ->
+    SNI;
 select_sni_extension(_) ->
     undefined.
 
@@ -517,13 +517,13 @@ hello(internal, #client_hello{extensions = Extensions} = Hello,
              start_or_recv_from = From} = State) ->
     {next_state, user_hello, State#state{start_or_recv_from = undefined,
                                               hello = Hello},
-     [{reply, From, {ok, ssl_connection:map_extensions(Extensions)}}]};
+     [{reply, From, {ok, Extensions}}]};
 hello(internal, #server_hello{extensions = Extensions} = Hello, 
       #state{ssl_options = #ssl_options{handshake = hello},
              start_or_recv_from = From} = State) ->
     {next_state, user_hello, State#state{start_or_recv_from = undefined,
                                          hello = Hello},
-     [{reply, From, {ok, ssl_connection:map_extensions(Extensions)}}]};     
+     [{reply, From, {ok, Extensions}}]};     
 hello(internal, #client_hello{client_version = ClientVersion} = Hello,
       #state{connection_states = ConnectionStates0,
 	     port = Port, session = #session{own_certificate = Cert} = Session0,
diff --git a/lib/ssl/src/tls_handshake.erl b/lib/ssl/src/tls_handshake.erl
index 82ed2e8d14..050b4be870 100644
--- a/lib/ssl/src/tls_handshake.erl
+++ b/lib/ssl/src/tls_handshake.erl
@@ -100,7 +100,7 @@ client_hello(Host, Port, ConnectionStates,
 		    ssl_record:connection_states(), alpn | npn, binary() | undefined}|
 		   {tls_record:tls_version(), {resumed | new, #session{}}, 
 		    ssl_record:connection_states(), binary() | undefined, 
-		    #hello_extensions{}, {ssl_cipher_format:hash(), ssl_cipher_format:sign_algo()} | 
+                    HelloExt::map(), {ssl_cipher_format:hash(), ssl_cipher_format:sign_algo()} | 
                     undefined} | #alert{}.
 %%
 %% Description: Handles a received hello message
@@ -145,10 +145,9 @@ hello(#server_hello{server_version = {Major, Minor},
 %% - If "supported_version" is present (ServerHello):
 %%   - Abort handshake with an "illegal_parameter" alert
 hello(#server_hello{server_version = Version,
-                    extensions = #hello_extensions{
-                                    server_hello_selected_version =
-                                        #server_hello_selected_version{selected_version = Version}
-                                   }},
+                    extensions = #{server_hello_selected_version :=
+                                       #server_hello_selected_version{selected_version = Version}}
+                   },
       #ssl_options{versions = SupportedVersions},
       _ConnectionStates0, _Renegotiation) ->
     case tls_record:is_higher({3,4}, Version) of
@@ -196,10 +195,9 @@ hello(#server_hello{server_version = Version, random = Random,
 %%      e.g. Server 1.0,1.2 Client 1.1 -> ServerHello 1.0
 hello(#client_hello{client_version = _ClientVersion,
 		    cipher_suites = CipherSuites,
-                    extensions = #hello_extensions{
-                                    client_hello_versions =
-                                        #client_hello_versions{versions = ClientVersions}
-                                   }} = Hello,
+                    extensions = #{client_hello_versions :=
+                                       #client_hello_versions{versions = ClientVersions}
+                                  }} = Hello,
       #ssl_options{versions = Versions} = SslOpts,
       Info, Renegotiation) ->
     try
@@ -267,10 +265,7 @@ handle_client_hello(Version,
                                   cipher_suites = CipherSuites,
                                   compression_methods = Compressions,
                                   random = Random,
-                                  extensions = 
-                                      #hello_extensions{elliptic_curves = Curves,
-                                                        signature_algs = ClientHashSigns} 
-                                  = HelloExt},
+                                  extensions = HelloExt},
 		    #ssl_options{versions = Versions,
 				 signature_algs = SupportedHashSigns,
 				 eccs = SupportedECCs,
@@ -279,6 +274,8 @@ handle_client_hello(Version,
                     Renegotiation) ->
     case tls_record:is_acceptable_version(Version, Versions) of
 	true ->
+            Curves = maps:get(elliptic_curves, HelloExt, undefined),
+            ClientHashSigns = maps:get(signature_algs, HelloExt, undefined),
 	    AvailableHashSigns = ssl_handshake:available_signature_algs(
 				   ClientHashSigns, SupportedHashSigns, Cert, Version),
 	    ECCCurve = ssl_handshake:select_curve(Curves, SupportedECCs, ECCOrder),
@@ -407,13 +404,14 @@ get_tls_handshake_aux(_Version, Data, _, Acc) ->
 
 decode_handshake({3, N}, ?HELLO_REQUEST, <<>>) when N < 4 ->
     #hello_request{};
-decode_handshake(_Version, ?CLIENT_HELLO, 
+decode_handshake(Version, ?CLIENT_HELLO, 
                  <<?BYTE(Major), ?BYTE(Minor), Random:32/binary,
                    ?BYTE(SID_length), Session_ID:SID_length/binary,
                    ?UINT16(Cs_length), CipherSuites:Cs_length/binary,
                    ?BYTE(Cm_length), Comp_methods:Cm_length/binary,
                    Extensions/binary>>) ->
-    DecodedExtensions = ssl_handshake:decode_hello_extensions({client, Extensions}),
+    Exts = ssl_handshake:decode_vector(Extensions),
+    DecodedExtensions = ssl_handshake:decode_hello_extensions(Exts, Version, client),
     #client_hello{
        client_version = {Major,Minor},
        random = Random,
@@ -426,5 +424,3 @@ decode_handshake({3, 4}, Tag, Msg) ->
     tls_handshake_1_3:decode_handshake(Tag, Msg);
 decode_handshake(Version, Tag, Msg) ->
     ssl_handshake:decode_handshake(Version, Tag, Msg).
-
-
diff --git a/lib/ssl/src/tls_handshake_1_3.erl b/lib/ssl/src/tls_handshake_1_3.erl
index 2957e3a5b4..199054b43b 100644
--- a/lib/ssl/src/tls_handshake_1_3.erl
+++ b/lib/ssl/src/tls_handshake_1_3.erl
@@ -89,7 +89,7 @@ decode_handshake(?CERTIFICATE, <<?BYTE(CSize), Context:CSize/binary,
        certificate_request_context = Context,
        entries = CertList
       };
-decode_handshake(?ENCRYPTED_EXTENSIONS, EncExts) ->
+decode_handshake(?ENCRYPTED_EXTENSIONS, <<?UINT16(Size), EncExts:Size/binary>>) ->
     #encrypted_extensions{
        extensions = decode_extensions(EncExts)
       };
@@ -127,23 +127,27 @@ encode_cert_entries([], Acc) ->
     iolist_to_binary(lists:reverse(Acc));
 encode_cert_entries([#certificate_entry{data = Data,
                                         extensions = Exts} | Rest], Acc) ->
+    DSize = byte_size(Data),
     BinExts = encode_extensions(Exts),
-    Size = byte_size(Data),
+    ExtSize = byte_size(BinExts),
     encode_cert_entries(Rest, 
-                        [<<?UINT24(Size), Data/binary, BinExts/binary>> | Acc]).
+                        [<<?UINT24(DSize), Data/binary, ?UINT16(ExtSize), BinExts/binary>> | Acc]).
 
 decode_cert_entries(Entries) ->
     decode_cert_entries(Entries, []).
 
 decode_cert_entries(<<>>, Acc) ->
     lists:reverse(Acc);
-decode_cert_entries(<<?UINT24(DSize), Data:DSize/binary, ?UINT24(Esize), BinExts:Esize/binary,
+decode_cert_entries(<<?UINT24(DSize), Data:DSize/binary, ?UINT16(Esize), BinExts:Esize/binary,
                       Rest/binary>>, Acc) ->
     Exts = decode_extensions(BinExts),
     decode_cert_entries(Rest, [#certificate_entry{data = Data,
                                                   extensions = Exts} | Acc]).
 
 encode_extensions(Exts)->
-    ssl_handshake:encode_hello_extensions(Exts).
+    ssl_handshake:encode_extensions(extensions_list(Exts)).
 decode_extensions(Exts) ->
-    ssl_handshake:decode_hello_extensions(Exts).
+    ssl_handshake:decode_extensions(Exts).
+
+extensions_list(HelloExtensions) ->
+    [Ext || {_, Ext} <- maps:to_list(HelloExtensions)].
diff --git a/lib/ssl/test/property_test/ssl_eqc_handshake.erl b/lib/ssl/test/property_test/ssl_eqc_handshake.erl
index 88046f7386..99c6554f15 100644
--- a/lib/ssl/test/property_test/ssl_eqc_handshake.erl
+++ b/lib/ssl/test/property_test/ssl_eqc_handshake.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2004-2015. All Rights Reserved.
+%% Copyright Ericsson AB 2018-2018. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -51,6 +51,7 @@
 -endif.
 -endif.
 
+-include_lib("kernel/include/inet.hrl").
 -include_lib("ssl/src/tls_handshake_1_3.hrl").
 -include_lib("ssl/src/tls_handshake.hrl").
 -include_lib("ssl/src/ssl_handshake.hrl").
@@ -83,79 +84,261 @@ prop_tls_hs_encode_decode() ->
             end
 	   ).
 
+%%--------------------------------------------------------------------
+%% Message Generators  --------------------------------------------------
+%%--------------------------------------------------------------------
+
 tls_version() ->
-    oneof([?'TLS_v1.2', ?'TLS_v1.1', ?'TLS_v1', ?'SSL_v3']). 
+    oneof([?'TLS_v1.3', ?'TLS_v1.2', ?'TLS_v1.1', ?'TLS_v1', ?'SSL_v3']). 
 
 tls_msg(?'TLS_v1.3'= Version) ->
     oneof([client_hello(Version),
-           %%server_hello(Version)
+           server_hello(Version),
            %%new_session_ticket()
            #end_of_early_data{},
-           %%encrypted_extensions()
-           %%certificate_1_3(),
-           %%certificate_request()
+           encrypted_extensions(),
+           certificate_1_3(),
+           %%certificate_request_1_3,
            %%certificate_verify()
-           %%finished()
+           finished(),
            key_update()
-           %%message_hash()
           ]);
 tls_msg(Version) ->
     oneof([#hello_request{},
            client_hello(Version),
-           %%server_hello(Version)
-           %%certificate(),
+           server_hello(Version),
+           certificate(),
            %%server_key_exchange()
-           %%certificate_request()
-           #server_hello_done{}
+           certificate_request(Version),
+           #server_hello_done{},
            %%certificate_verify()
            %%client_key_exchange()
-           %%finished()
+           finished()
           ]).
 
 client_hello(?'TLS_v1.3' = Version) ->
     #client_hello{session_id = session_id(),
 		  client_version = ?'TLS_v1.2',
-		  cipher_suites = ssl_cipher:suites(Version), 
+		  cipher_suites = cipher_suites(Version),
 		  compression_methods = compressions(Version),
 		  random = client_random(Version),
-		  extensions = client_extensions(Version)    
+		  extensions = client_hello_extensions(Version)    
                  };
 client_hello(Version) ->
     #client_hello{session_id = session_id(),
 		  client_version = Version,
-		  cipher_suites = ssl_cipher:suites(Version), 
+                  cipher_suites = cipher_suites(Version),
 		  compression_methods = compressions(Version),
 		  random = client_random(Version),
-		  extensions = client_extensions(Version)    
+		  extensions = client_hello_extensions(Version)    
                  }.
+
+server_hello(?'TLS_v1.3' = Version) ->
+    #server_hello{server_version = ?'TLS_v1.2',
+		  session_id = session_id(),
+                  random = server_random(Version),
+                  cipher_suite = cipher_suite(Version),
+		  compression_method = compression(Version),
+		  extensions = server_hello_extensions(Version)    
+                 };
+server_hello(Version) ->
+    #server_hello{server_version = Version,
+		  session_id = session_id(),
+                  random = server_random(Version),
+                  cipher_suite = cipher_suite(Version),
+		  compression_method = compression(Version),
+		  extensions = server_hello_extensions(Version)    
+                 }.
+
+encrypted_extensions() ->
+    ?LET(Exts, extensions(?'TLS_v1.3'),
+         #encrypted_extensions{extensions = Exts}).
+        
+certificate() ->
+    #certificate{
+       asn1_certificates = certificate_chain()
+      }.
+
+certificate_1_3() ->
+     ?LET(Certs, certificate_chain(),
+          #certificate_1_3{
+             certificate_request_context = certificate_request_context(),
+             entries = certificate_entries(Certs, [])  
+            }).
+
+key_update() ->
+    #key_update{request_update = request_update()}.
+
+finished() ->
+    ?LET(Size, digest_size(),
+         #finished{verify_data = crypto:strong_rand_bytes(Size)}).
+
+%%--------------------------------------------------------------------
+%% Messge Data Generators  -------------------------------------------
+%%--------------------------------------------------------------------
+
+
+cipher_suite(Version) ->
+    oneof(cipher_suites(Version)).
+
+cipher_suites(Version) ->
+    ssl_cipher:suites(Version).
+
 session_id() ->
     crypto:strong_rand_bytes(?NUM_OF_SESSION_ID_BYTES).
  
+compression(Version) ->
+     oneof(compressions(Version)).
+
 compressions(_) -> 
     ssl_record:compressions().
+
 client_random(_) ->
     crypto:strong_rand_bytes(32).
-       
-client_extensions(?'TLS_v1.3' = Version) ->
-    #hello_extensions{
-       client_hello_versions =
-           #client_hello_versions{
-              versions = supported_versions(Version)
-             },
-       signature_algs_cert =
-           #signature_scheme_list{
-              signature_scheme_list = signature_scheme_list()
-             }
-      };
-client_extensions(Version) ->
-    #hello_extensions{
-       client_hello_versions =
-           #client_hello_versions{
-              versions = supported_versions(Version)
-             }
-      }.
+
+server_random(_) ->
+    crypto:strong_rand_bytes(32).
+
+
+client_hello_extensions(?'TLS_v1.3' = Version) ->
+    ?LET({Versions, Ext}, {supported_versions(Version), c_hello_extensions(Version)},
+         maps:merge(Ext, #{client_hello_versions => client_hello_versions(Versions)})
+        );
+client_hello_extensions(?'TLS_v1.2' = Version) ->
+    ?LET({Versions, Exts}, {supported_versions(Version),  c_hello_extensions(Version)}, 
+         maps:merge(Exts, #{client_hello_versions => client_hello_versions(Versions)})
+        );
+client_hello_extensions(Version) ->
+    ?LET(Exts,
+         c_hello_extensions(Version),
+         maps:merge(empty_hello_extensions(Version, client), Exts)).
+
+server_hello_extensions(?'TLS_v1.3' = Version) ->
+    ?LET(Exts,       
+         s_hello_extensions(Version),
+         maps:merge(Exts, #{server_hello_selected_version => server_hello_selected_version(Version)}));
+server_hello_extensions(Version) ->
+    ?LET(Exts,    
+         s_hello_extensions(Version),
+         Exts).
+
+c_hello_extensions(?'TLS_v1.3'= Version) ->
+    ?LET({KeyShare, PreShare}, {key_share_client_hello(),
+                                pre_shared_keyextension()},
+         maps:merge(empty_hello_extensions(Version, client),
+                    #{key_share => KeyShare,
+                      pre_shared_key => PreShare
+                     })
+        );
+c_hello_extensions(Version) ->
+    ?LET(Exts, extensions(Version),
+         maps:merge(empty_hello_extensions(Version, client),
+                    Exts)).
+
+s_hello_extensions(?'TLS_v1.3'= Version) ->
+    ?LET({KeyShare, PreShare}, {key_share_server_hello(),
+                                pre_shared_keyextension()},
+         maps:merge(empty_hello_extensions(Version, server),
+                    #{key_share => KeyShare,
+                      pre_shared_key => PreShare
+                     })
+        );
+s_hello_extensions(Version) ->
+    ?LET(Exts, extensions(Version),
+         maps:merge(empty_hello_extensions(Version, server),
+                    Exts)).
+
+key_share_client_hello() ->
+     oneof([undefined]).
+    %%oneof([#key_share_client_hello{}, undefined]).
+
+key_share_server_hello() ->
+     oneof([undefined]).
+    %%oneof([#key_share_server_hello{}, undefined]).
+
+pre_shared_keyextension() ->
+     oneof([undefined]).
+     %%oneof([#pre_shared_keyextension{},undefined]).
+
+extensions(?'TLS_v1.3') ->
+    ?LET({Ext_1_3, Exts}, {extensions_1_3(), extensions(?'TLS_v1.2')}, maps:merge(Ext_1_3, Exts));
+extensions(?'SSL_v3') ->
+    #{};
+extensions(Version) ->
+    ?LET({SNI, ECPoitF, ECCurves, ALPN, NextP, SRP}, 
+         {oneof([sni(), undefined]),
+          oneof([ec_poit_formats(), undefined]),
+          oneof([elliptic_curves(Version), undefined]), 
+          oneof([alpn(),  undefined]), 
+          oneof([next_protocol_negotiation(), undefined]),
+          oneof([srp(), undefined])},  
+         maps:filter(fun(_, undefined) -> 
+                             false;
+                        (_,_) -> 
+                             true 
+                     end, 
+                     #{sni => SNI,
+                       ec_point_formats => ECPoitF,
+                       elliptic_curves => ECCurves,
+                       alpn => ALPN,
+                       next_protocol_negotiation => NextP,
+                       srp => SRP})).  
+
+extensions_1_3() ->
+    %% ?LET(Entry, key_share_entry(), 
+    %%          maps:filter(fun(_, undefined) -> 
+    %%                              false;
+    %%                         (_,_) -> 
+    %%                              true 
+    %%                      end, #{key_share_entry => Entry})).
+    ?LET({HashSign, SigAlgCert}, {oneof([hash_sign_algos(?'TLS_v1.2')]),  oneof([signature_scheme_list()])},  
+         #{signature_algs => HashSign,
+           signature_algs_cert => SigAlgCert}).      
+
+empty_hello_extensions({3, 4}, server) ->
+    #{server_hello_selected_version => undefined,
+      key_share => undefined,
+      pre_shared_key => undefined,
+      sni => undefined
+     };
+empty_hello_extensions({3, 4}, client) -> 
+    #{client_hello_versions => undefined,
+      signature_algs => undefined,
+      signature_algs_cert => undefined,
+      sni => undefined,
+      alpn => undefined,
+      key_share => undefined,
+      pre_shared_key => undefined      
+     };
+empty_hello_extensions({3, 3}, client) -> 
+    Ext = empty_hello_extensions({3,2}, client),
+    Ext#{client_hello_versions => undefined,
+         signature_algs => undefined,
+         signature_algs_cert => undefined};
+empty_hello_extensions(_, client) ->
+    #{renegotiation_info => undefined,
+      alpn => undefined,
+      next_protocol_negotiation => undefined,
+      srp => undefined,
+      ec_point_formats => undefined,
+      elliptic_curves => undefined,
+      sni => undefined};
+empty_hello_extensions(_, server) ->
+    #{renegotiation_info => undefined,
+      alpn => undefined,
+      next_protocol_negotiation => undefined,
+      ec_point_formats => undefined,
+      sni => undefined}.
+
+signature_algs_cert() ->
+    ?LET(Algs, signature_scheme_list(),
+         Algs).
 
 signature_scheme_list() ->
+    ?LET(List,  sig_scheme_list(), 
+         #signature_scheme_list{signature_scheme_list = List}).
+
+sig_scheme_list() ->
     oneof([[rsa_pkcs1_sha256],
            [rsa_pkcs1_sha256, ecdsa_sha1],
            [rsa_pkcs1_sha256,
@@ -185,8 +368,167 @@ supported_versions(_) ->
            [{3,3},{3,2},{3,1},{3,0}]
           ]).
 
-key_update() ->
-    #key_update{request_update = request_update()}.
-
 request_update() ->
      oneof([?UPDATE_NOT_REQUESTED, ?UPDATE_REQUESTED]).
+
+certificate_chain()->
+    Conf = cert_conf(),
+    ?LET(Chain, 
+         choose_certificate_chain(Conf),
+         Chain).
+
+choose_certificate_chain(#{server_config := ServerConf,
+                           client_config := ClientConf}) -> 
+    oneof([certificate_chain(ServerConf), certificate_chain(ClientConf)]).
+
+certificate_request_context() ->
+    <<>>.
+certificate_entries([], Acc) ->
+    lists:reverse(Acc);
+certificate_entries([Cert | Rest], Acc) ->
+    certificate_entries(Rest, [certificate_entry(Cert) | Acc]).
+
+certificate_entry(Cert) ->
+    #certificate_entry{data = Cert,
+                       extensions = certificate_entry_extensions()
+                      }.
+certificate_entry_extensions() ->
+    #{}.
+
+certificate_chain(Conf) ->  
+    CAs = proplists:get_value(cacerts, Conf),
+    Cert = proplists:get_value(cert, Conf),
+    %% Middle argument are of correct type but will not be used
+    {ok, _, Chain} = ssl_certificate:certificate_chain(Cert, ets:new(foo, []), make_ref(), CAs), 
+    Chain.
+
+cert_conf()->
+    Hostname = net_adm:localhost(),
+    {ok, #hostent{h_addr_list = [_IP |_]}} = inet:gethostbyname(net_adm:localhost()),
+    public_key:pkix_test_data(#{server_chain => 
+                                    #{root => [{key, ssl_test_lib:hardcode_rsa_key(1)}],
+                                      intermediates => [[{key, ssl_test_lib:hardcode_rsa_key(2)}]],
+                                      peer => [{extensions, [#'Extension'{extnID = 
+                                                                              ?'id-ce-subjectAltName',
+                                                                          extnValue = [{dNSName, Hostname}],
+                                                                          critical = false}]},
+                                               {key, ssl_test_lib:hardcode_rsa_key(3)}
+                                              ]},
+                                client_chain => 
+                                    #{root => [{key, ssl_test_lib:hardcode_rsa_key(4)}],
+                                      intermediates => [[{key, ssl_test_lib:hardcode_rsa_key(5)}]],
+                                      peer => [{key, ssl_test_lib:hardcode_rsa_key(6)}]}}).
+
+certificate_request(Version) ->
+    #certificate_request{certificate_types = certificate_types(Version),
+			 hashsign_algorithms = hashsign_algorithms(Version),
+			 certificate_authorities = certificate_authorities()}.
+
+certificate_types(?'TLS_v1.3') ->
+    iolist_to_binary([<<?BYTE(?ECDSA_SIGN)>>, <<?BYTE(?RSA_SIGN)>>]);
+certificate_types(?'TLS_v1.2') ->
+    iolist_to_binary([<<?BYTE(?ECDSA_SIGN)>>, <<?BYTE(?RSA_SIGN)>>, <<?BYTE(?DSS_SIGN)>>]);
+certificate_types(_) ->
+    iolist_to_binary([<<?BYTE(?ECDSA_SIGN)>>, <<?BYTE(?RSA_SIGN)>>, <<?BYTE(?DSS_SIGN)>>]).
+
+hashsign_algorithms({_, N} = Version) when N >= 3 ->                                 
+    #hash_sign_algos{hash_sign_algos = hash_alg_list(Version)};
+hashsign_algorithms(_) -> 
+    undefined.
+
+hash_alg_list(Version) ->
+    ?LET(NumOf, choose(0,15),
+	 ?LET(List, [hash_alg(Version) || _ <- lists:seq(1,NumOf)],
+	      lists:usort(List)
+             )).
+    
+hash_alg(Version) ->
+   ?LET(Alg, sign_algorithm(Version),
+         {hash_algorithm(Version, Alg), Alg}
+       ).
+
+hash_algorithm(?'TLS_v1.3', _) ->
+    oneof([sha, sha224, sha256, sha384, sha512]);
+hash_algorithm(?'TLS_v1.2', rsa) ->
+    oneof([sha, sha224, sha256, sha384, sha512]);
+hash_algorithm(_, rsa) ->
+    oneof([md5, sha, sha224, sha256, sha384, sha512]);
+hash_algorithm(_, ecdsa) ->
+    oneof([sha, sha224, sha256, sha384, sha512]);
+hash_algorithm(_, dsa) ->
+    sha.
+
+sign_algorithm(?'TLS_v1.3') ->
+    oneof([rsa, ecdsa]);
+sign_algorithm(_) ->
+    oneof([rsa, dsa, ecdsa]).
+
+certificate_authorities() ->
+    #{server_config := ServerConf} = cert_conf(), 
+    Authorities = proplists:get_value(cacerts, ServerConf),
+    Enc = fun(#'OTPCertificate'{tbsCertificate=TBSCert}) ->
+		  OTPSubj = TBSCert#'OTPTBSCertificate'.subject,
+		  DNEncodedBin = public_key:pkix_encode('Name', OTPSubj, otp),
+		  DNEncodedLen = byte_size(DNEncodedBin),
+		  <<?UINT16(DNEncodedLen), DNEncodedBin/binary>>
+	  end,
+    list_to_binary([Enc(public_key:pkix_decode_cert(DERCert, otp)) || DERCert <- Authorities]).
+
+digest_size()->
+   oneof([160,224,256,384,512]).
+
+key_share_entry() ->
+    undefined.
+    %%#key_share_entry{}.
+
+client_hello_versions(Versions) ->
+    #client_hello_versions{versions = Versions}. 
+
+server_hello_selected_version(Version) ->
+    #server_hello_selected_version{selected_version = Version}.
+
+sni() ->
+    #sni{hostname = net_adm:localhost()}.
+
+ec_poit_formats() ->
+    #ec_point_formats{ec_point_format_list = ec_point_format_list()}.
+ 
+ec_point_format_list() ->
+    [?ECPOINT_UNCOMPRESSED].
+
+elliptic_curves({_, Minor}) ->
+    Curves = tls_v1:ecc_curves(Minor),
+    #elliptic_curves{elliptic_curve_list = Curves}.
+
+hash_sign_algos(Version) ->
+    #hash_sign_algos{hash_sign_algos = hash_alg_list(Version)}.
+
+alpn() ->
+    ?LET(ExtD,  alpn_protocols(), #alpn{extension_data = ExtD}).
+
+alpn_protocols() ->
+    oneof([<<"spdy/2">>, <<"spdy/3">>, <<"http/2">>, <<"http/1.0">>, <<"http/1.1">>]).
+    
+next_protocol_negotiation() ->
+   %% Predecessor to APLN
+    ?LET(ExtD,  alpn_protocols(), #next_protocol_negotiation{extension_data = ExtD}).
+
+srp() ->
+   ?LET(Name, gen_name(),  #srp{username = list_to_binary(Name)}).
+
+renegotiation_info() ->
+    #renegotiation_info{renegotiated_connection = 0}.
+
+gen_name() -> 
+    ?LET(Size, choose(0,10), gen_string(Size)).
+
+gen_char() -> 
+    choose($a,$z).
+
+gen_string(N) ->
+    gen_string(N, []).
+
+gen_string(0, Acc) ->
+    Acc;
+gen_string(N, Acc) ->
+    ?LET(Char, gen_char(), gen_string(N-1, [Char | Acc])).
diff --git a/lib/ssl/test/ssl_handshake_SUITE.erl b/lib/ssl/test/ssl_handshake_SUITE.erl
index b8b9989d30..ef1f6be286 100644
--- a/lib/ssl/test/ssl_handshake_SUITE.erl
+++ b/lib/ssl/test/ssl_handshake_SUITE.erl
@@ -104,15 +104,13 @@ decode_hello_handshake(_Config) ->
 							 #ssl_options{}),
 
     {Hello, _Data} = hd(Records),
-    #renegotiation_info{renegotiated_connection = <<0>>}
-	= (Hello#server_hello.extensions)#hello_extensions.renegotiation_info.
-
+    Extensions = Hello#server_hello.extensions,
+    #{renegotiation_info := #renegotiation_info{renegotiated_connection = <<0>>}} = Extensions.
 
 decode_single_hello_extension_correctly(_Config) -> 
     Renegotiation = <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(1), 0>>,
-    Extensions = ssl_handshake:decode_hello_extensions(Renegotiation),
-    #renegotiation_info{renegotiated_connection = <<0>>}
-	= Extensions#hello_extensions.renegotiation_info.
+    Extensions = ssl_handshake:decode_extensions(Renegotiation),
+    #{renegotiation_info := #renegotiation_info{renegotiated_connection = <<0>>}} = Extensions.
 
 decode_supported_elliptic_curves_hello_extension_correctly(_Config) ->
     % List of supported and unsupported curves (RFC4492:S5.1.1)
@@ -123,37 +121,34 @@ decode_supported_elliptic_curves_hello_extension_correctly(_Config) ->
     Len = ListLen + 2,
     Extension = <<?UINT16(?ELLIPTIC_CURVES_EXT), ?UINT16(Len), ?UINT16(ListLen), EllipticCurveList/binary>>,
     % after decoding we should see only valid curves
-    #hello_extensions{elliptic_curves = DecodedCurves} = ssl_handshake:decode_hello_extensions(Extension),
-    #elliptic_curves{elliptic_curve_list = [?sect233k1, ?sect193r2]} = DecodedCurves.
+    Extensions = ssl_handshake:decode_hello_extensions(Extension, {3,2}, client),
+    #{elliptic_curves := #elliptic_curves{elliptic_curve_list = [?sect233k1, ?sect193r2]}} = Extensions. 
 
 decode_unknown_hello_extension_correctly(_Config) ->
     FourByteUnknown = <<16#CA,16#FE, ?UINT16(4), 3, 0, 1, 2>>,
     Renegotiation = <<?UINT16(?RENEGOTIATION_EXT), ?UINT16(1), 0>>,
-    Extensions = ssl_handshake:decode_hello_extensions(<<FourByteUnknown/binary, Renegotiation/binary>>),
-     #renegotiation_info{renegotiated_connection = <<0>>}
-	= Extensions#hello_extensions.renegotiation_info.
+    Extensions = ssl_handshake:decode_hello_extensions(<<FourByteUnknown/binary, Renegotiation/binary>>, {3,2}, client),
+    #{renegotiation_info := #renegotiation_info{renegotiated_connection = <<0>>}} = Extensions.
+
 
 encode_single_hello_sni_extension_correctly(_Config) ->
-    Exts = #hello_extensions{sni = #sni{hostname = "test.com"}},
     SNI = <<16#00, 16#00, 16#00, 16#0d, 16#00, 16#0b, 16#00, 16#00, 16#08,
 	    $t,    $e,    $s,    $t,    $.,    $c,    $o,    $m>>,
     ExtSize = byte_size(SNI),
     HelloExt = <<ExtSize:16/unsigned-big-integer, SNI/binary>>,
-    Encoded = ssl_handshake:encode_hello_extensions(Exts),
+    Encoded = ssl_handshake:encode_extensions([#sni{hostname = "test.com"}]),
     HelloExt = Encoded.
 
 decode_single_hello_sni_extension_correctly(_Config) ->
-    Exts = #hello_extensions{sni = #sni{hostname = "test.com"}},
     SNI = <<16#00, 16#00, 16#00, 16#0d, 16#00, 16#0b, 16#00, 16#00, 16#08,
 	    $t,    $e,    $s,    $t,    $.,    $c,    $o,    $m>>,
-    Decoded = ssl_handshake:decode_hello_extensions(SNI),
-    Exts = Decoded.
+    Decoded = ssl_handshake:decode_hello_extensions(SNI, {3,3}, client),
+    #{sni := #sni{hostname = "test.com"}} = Decoded.
 
 decode_empty_server_sni_correctly(_Config) ->
-    Exts = #hello_extensions{sni = #sni{hostname = ""}},
     SNI = <<?UINT16(?SNI_EXT),?UINT16(0)>>,
-    Decoded = ssl_handshake:decode_hello_extensions(SNI),
-    Exts = Decoded.
+    Decoded = ssl_handshake:decode_hello_extensions(SNI, {3,3}, server),
+    #{sni := #sni{hostname = ""}} = Decoded.
 
 
 select_proper_tls_1_2_rsa_default_hashsign(_Config) ->
diff --git a/lib/ssl/test/ssl_npn_hello_SUITE.erl b/lib/ssl/test/ssl_npn_hello_SUITE.erl
index 35af666e9e..46734ba180 100644
--- a/lib/ssl/test/ssl_npn_hello_SUITE.erl
+++ b/lib/ssl/test/ssl_npn_hello_SUITE.erl
@@ -71,44 +71,46 @@ encode_and_decode_client_hello_test(Config) ->
     Version = ssl_test_lib:protocol_version(Config),
     {[{DecodedHandshakeMessage, _Raw}], _} =
 	tls_handshake:get_tls_handshake(Version, list_to_binary(HandShakeData), <<>>, #ssl_options{}),
-    NextProtocolNegotiation = (DecodedHandshakeMessage#client_hello.extensions)#hello_extensions.next_protocol_negotiation,
-    NextProtocolNegotiation = undefined.
+    Extensions = DecodedHandshakeMessage#client_hello.extensions,
+    #{next_protocol_negotiation := undefined} = Extensions.
 %%--------------------------------------------------------------------
 encode_and_decode_npn_client_hello_test(Config) ->
     HandShakeData = create_client_handshake(#next_protocol_negotiation{extension_data = <<>>}),
     Version = ssl_test_lib:protocol_version(Config),
     {[{DecodedHandshakeMessage, _Raw}], _} =
 	tls_handshake:get_tls_handshake(Version, list_to_binary(HandShakeData), <<>>,  #ssl_options{}),
-    NextProtocolNegotiation = (DecodedHandshakeMessage#client_hello.extensions)#hello_extensions.next_protocol_negotiation,
-    NextProtocolNegotiation = #next_protocol_negotiation{extension_data = <<>>}.
+    Extensions = DecodedHandshakeMessage#client_hello.extensions,
+    #{next_protocol_negotiation := #next_protocol_negotiation{extension_data = <<>>}} = Extensions.
 %%--------------------------------------------------------------------
 encode_and_decode_server_hello_test(Config) ->
     HandShakeData = create_server_handshake(undefined),
     Version = ssl_test_lib:protocol_version(Config),
     {[{DecodedHandshakeMessage, _Raw}], _} =
 	tls_handshake:get_tls_handshake(Version, list_to_binary(HandShakeData), <<>>, #ssl_options{}),
-    NextProtocolNegotiation = (DecodedHandshakeMessage#server_hello.extensions)#hello_extensions.next_protocol_negotiation,
-    NextProtocolNegotiation = undefined.
+    Extensions = DecodedHandshakeMessage#server_hello.extensions,
+    #{next_protocol_negotiation := undefined} = Extensions.
+
 %%--------------------------------------------------------------------
 encode_and_decode_npn_server_hello_test(Config) ->
     HandShakeData = create_server_handshake(#next_protocol_negotiation{extension_data = <<6, "spdy/2">>}),
     Version = ssl_test_lib:protocol_version(Config),
     {[{DecodedHandshakeMessage, _Raw}], _} =
 	tls_handshake:get_tls_handshake(Version, list_to_binary(HandShakeData), <<>>,  #ssl_options{}),
-    NextProtocolNegotiation = (DecodedHandshakeMessage#server_hello.extensions)#hello_extensions.next_protocol_negotiation,
-    ct:log("~p ~n", [NextProtocolNegotiation]),
-    NextProtocolNegotiation = #next_protocol_negotiation{extension_data = <<6, "spdy/2">>}.
+    Extensions = DecodedHandshakeMessage#server_hello.extensions, 
+    ct:log("~p ~n", [Extensions]),
+    #{next_protocol_negotiation := #next_protocol_negotiation{extension_data = <<6, "spdy/2">>}} = Extensions.
 
 %%--------------------------------------------------------------------
 create_server_hello_with_no_advertised_protocols_test(_Config) ->
-    Hello = ssl_handshake:server_hello(<<>>, {3, 0}, create_connection_states(), #hello_extensions{}),
-    undefined = (Hello#server_hello.extensions)#hello_extensions.next_protocol_negotiation.
+    Hello = ssl_handshake:server_hello(<<>>, {3, 0}, create_connection_states(), #{}),
+    Extensions = Hello#server_hello.extensions,
+    #{} = Extensions.
 %%--------------------------------------------------------------------
 create_server_hello_with_advertised_protocols_test(_Config) ->
     Hello = ssl_handshake:server_hello(<<>>, {3, 0}, create_connection_states(),
-				       #hello_extensions{next_protocol_negotiation = [<<"spdy/1">>, <<"http/1.0">>, <<"http/1.1">>]}),
-    [<<"spdy/1">>, <<"http/1.0">>, <<"http/1.1">>] =
-	(Hello#server_hello.extensions)#hello_extensions.next_protocol_negotiation.
+				       #{next_protocol_negotiation => [<<"spdy/1">>, <<"http/1.0">>, <<"http/1.1">>]}),
+    Extensions = Hello#server_hello.extensions,
+    #{next_protocol_negotiation := [<<"spdy/1">>, <<"http/1.0">>, <<"http/1.1">>]} = Extensions.
 %%--------------------------------------------------------------------
 %% Internal functions ------------------------------------------------
 %%--------------------------------------------------------------------
@@ -120,9 +122,8 @@ create_client_handshake(Npn) ->
 				      session_id = <<>>,
 				      cipher_suites = [?TLS_DHE_DSS_WITH_DES_CBC_SHA],
 				      compression_methods = "",
-				      extensions = #hello_extensions{
-						      next_protocol_negotiation = Npn,
-						      renegotiation_info = #renegotiation_info{}}
+				      extensions = #{next_protocol_negotiation => Npn,
+						      renegotiation_info => #renegotiation_info{}}
 				     }, Vsn).
 
 create_server_handshake(Npn) ->
@@ -133,9 +134,8 @@ create_server_handshake(Npn) ->
 				      session_id = <<>>,
 				      cipher_suite = ?TLS_DHE_DSS_WITH_DES_CBC_SHA,
 				      compression_method = 1,
-				      extensions = #hello_extensions{
-						      next_protocol_negotiation = Npn,
-						      renegotiation_info = #renegotiation_info{}}
+				      extensions = #{next_protocol_negotiation => Npn,
+                                                     renegotiation_info => #renegotiation_info{}}
 				     }, Vsn).
 
 create_connection_states() ->
@@ -146,5 +146,5 @@ create_connection_states() ->
 						 }
 		       },
       current_read => #{secure_renegotiation => false
-       }
+                       }
      }.